src/plugins/libravatar/libravatar_prefs.c

   1 /*
   2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2014 Hiroyuki Yamamoto and the Claws Mail Team
   4  * Copyright (C) 2014 Ricardo Mones
   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 3 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, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #include "claws-features.h"
  23 #endif
  24
  25 #include <glib.h>
  26 #include <glib/gi18n.h>
  27
  28 #include "libravatar.h"
  29
  30 #include <gtk/gtk.h>
  31 #include <gtk/filesel.h>
  32
  33 #include "defs.h"
  34 #include "libravatar_prefs.h"
  35 #include "prefs_common.h"
  36 #include "prefs_gtk.h"
  37
  38 #define PREFS_BLOCK_NAME "Libravatar"
  39 #define NUM_DEF_BUTTONS 7
  40 /* cache interval goes from 1 hour to 30 days */
  41 #define INTERVAL_MIN_H 1.0
  42 #define INTERVAL_MAX_H 720.0
  43
  44 LibravatarPrefs libravatarprefs;
  45 GHashTable *libravatarmisses;
  46
  47 struct LibravatarPrefsPage
  48 {
  49         PrefsPage page;
  50
  51         GtkWidget *cache_interval_spin;
  52         GtkWidget *cache_icons_check;
  53         GtkWidget *defm_radio[NUM_DEF_BUTTONS];
  54         GtkWidget *defm_url_text;
  55         GtkWidget *allow_redirects_check;
  56 };
  57
  58 struct LibravatarPrefsPage libravatarprefs_page;
  59
  60 static PrefParam param[] = {
  61         { "base_url", "http://cdn.libravatar.org/avatar",
  62           &libravatarprefs.base_url,
  63           P_STRING, NULL, NULL, NULL },
  64         { "cache_interval", "24",
  65           &libravatarprefs.cache_interval,
  66           P_INT, NULL, NULL, NULL },
  67         { "cache_icons", "TRUE",
  68           &libravatarprefs.cache_icons,
  69           P_BOOL, NULL, NULL, NULL },
  70         { "default_mode", "0",
  71           &libravatarprefs.default_mode,
  72           P_INT, NULL, NULL, NULL },
  73         { "default_mode_url", "",
  74           &libravatarprefs.default_mode_url,
  75           P_STRING, NULL, NULL, NULL },
  76         { "allow_redirects", "TRUE",
  77           &libravatarprefs.allow_redirects,
  78           P_BOOL, NULL, NULL, NULL },
  79         {NULL, NULL, NULL, P_OTHER, NULL, NULL, NULL}
  80 };
  81
  82 static GtkWidget *create_checkbox(gchar *label, gchar *hint)
  83 {
  84         GtkWidget *cb = gtk_check_button_new_with_mnemonic(label);
  85         CLAWS_SET_TIP(cb, hint);
  86         gtk_widget_show(cb);
  87
  88         return cb;
  89 }
  90
  91 static void cache_icons_check_toggled_cb(GtkToggleButton *button, gpointer data)
  92 {
  93         gtk_widget_set_sensitive(libravatarprefs_page.cache_interval_spin,
  94                                  gtk_toggle_button_get_active(button));
  95 }
  96
  97 static GtkWidget *p_create_frame_cache(struct LibravatarPrefsPage *page)
  98 {
  99         GtkWidget *vbox, *checkbox, *lbl, *lbla, *spinner, *hbox;
 100         GtkAdjustment *adj;
 101
 102         vbox =  gtk_vbox_new(FALSE, 6);
 103
 104         checkbox = create_checkbox(_("_Use cached icons"),
 105                                    _("Keep icons on disk for reusing instead "
 106                                      "of making another network request"));
 107         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox),
 108                                      libravatarprefs.cache_icons);
 109         g_signal_connect(checkbox, "toggled",
 110                          G_CALLBACK(cache_icons_check_toggled_cb), NULL);
 111         page->cache_icons_check = checkbox;
 112
 113         lbl = gtk_label_new(_("Cache refresh interval"));
 114         gtk_widget_show(lbl);
 115         lbla = gtk_label_new(_("hours"));
 116         gtk_widget_show(lbla);
 117         adj = (GtkAdjustment *) gtk_adjustment_new(
 118                                         libravatarprefs.cache_interval,
 119                                         INTERVAL_MIN_H, INTERVAL_MAX_H, 1.0,
 120                                         0.0, 0.0);
 121         spinner = gtk_spin_button_new(adj, 1.0, 0);
 122         gtk_widget_show(spinner);
 123         gtk_widget_set_sensitive(spinner, libravatarprefs.cache_icons);
 124         hbox = gtk_hbox_new(FALSE, 6);
 125         gtk_box_pack_start(GTK_BOX(hbox), lbl, FALSE, FALSE, 0);
 126         gtk_box_pack_start(GTK_BOX(hbox), spinner, FALSE, FALSE, 0);
 127         gtk_box_pack_start(GTK_BOX(hbox), lbla, FALSE, FALSE, 0);
 128         page->cache_interval_spin = spinner;
 129
 130         gtk_box_pack_start(GTK_BOX(vbox), checkbox, FALSE, FALSE, 0);
 131         gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 132
 133         return vbox;
 134 }
 135
 136 static void default_mode_radio_button_cb(GtkToggleButton *button, gpointer data)
 137 {
 138         guint mode;
 139         gboolean is_url;
 140
 141         if (gtk_toggle_button_get_active(button) != TRUE)
 142                 return;
 143
 144         mode = *((guint *)data);
 145         is_url = (mode == DEF_MODE_URL)? TRUE: FALSE;
 146
 147         gtk_widget_set_sensitive(libravatarprefs_page.defm_url_text, is_url);
 148         if (is_url) /* custom URL requires following redirects */
 149                 gtk_toggle_button_set_active(
 150                         GTK_TOGGLE_BUTTON(libravatarprefs_page.allow_redirects_check),
 151                         TRUE);
 152
 153         if (mode == DEF_MODE_NONE) {
 154                 prefs_common.enable_avatars = AVATARS_ENABLE_BOTH;
 155         } else {
 156                 /* don't waste time with headers that won't be displayed */
 157                 prefs_common.enable_avatars = AVATARS_DISABLE;
 158                 /* empty missing cache when switching to generated */
 159                 g_hash_table_remove_all(libravatarmisses);
 160         }
 161 }
 162
 163 static const guint radio_value[] = {
 164         DEF_MODE_NONE,
 165         DEF_MODE_MM,
 166         DEF_MODE_IDENTICON,
 167         DEF_MODE_MONSTERID,
 168         DEF_MODE_WAVATAR,
 169         DEF_MODE_RETRO,
 170         DEF_MODE_URL
 171 };
 172
 173 static GtkWidget *p_create_frame_missing(struct LibravatarPrefsPage *page)
 174 {
 175         GtkWidget *vbox, *radio[NUM_DEF_BUTTONS], *hbox, *label, *entry;
 176         gboolean enable = FALSE;
 177         int i, e = 0;
 178
 179         gchar *radio_label[] = {
 180                 _("None"),
 181                 _("Mystery man"),
 182                 _("Identicon"),
 183                 _("MonsterID"),
 184                 _("Wavatar"),
 185                 _("Retro"),
 186                 _("Custom URL")
 187         };
 188         gchar *radio_hint[] = {
 189                 _("A blank image"),
 190                 _("The unobtrusive low-contrast greyish silhouette"),
 191                 _("A generated geometric pattern"),
 192                 _("A generated full-body monster"),
 193                 _("A generated almost unique face"),
 194                 _("A generated 8-bit arcade-style pixelated image"),
 195                 _("Redirect to a user provided URL")
 196         };
 197
 198         vbox =  gtk_vbox_new(FALSE, 6);
 199
 200         for (i = 0; i < NUM_DEF_BUTTONS; ++i) {
 201                 enable = (libravatarprefs.default_mode == radio_value[i])? TRUE: FALSE;
 202                 e += enable? 1: 0;
 203                 radio[i] = gtk_radio_button_new_with_label_from_widget(
 204                                 (i > 0)? GTK_RADIO_BUTTON(radio[i - 1]): NULL, radio_label[i]);
 205                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio[i]), enable);
 206                 gtk_box_pack_start(GTK_BOX(vbox), radio[i], FALSE, FALSE, 0);
 207                 g_signal_connect(radio[i], "toggled",
 208                                  G_CALLBACK(default_mode_radio_button_cb),
 209                                  (gpointer) &(radio_value[i]));
 210                 CLAWS_SET_TIP(radio[i], radio_hint[i]);
 211                 gtk_widget_show(radio[i]);
 212                 page->defm_radio[i] = radio[i];
 213         }
 214         if (e == 0) { /* unknown value, go default */
 215                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio[0]), TRUE);
 216                 libravatarprefs.default_mode = DEF_MODE_NONE;
 217         }
 218         /* don't waste time with headers that won't be displayed */
 219         prefs_common.enable_avatars = (libravatarprefs.default_mode == DEF_MODE_NONE)
 220                                                 ? AVATARS_ENABLE_BOTH: AVATARS_DISABLE;
 221
 222         label = gtk_label_new(_("URL:"));
 223         gtk_widget_show(label);
 224         entry = gtk_entry_new_with_max_length(MAX_URL_LENGTH);
 225         gtk_widget_show(entry);
 226         gtk_entry_set_text(GTK_ENTRY(entry), libravatarprefs.default_mode_url);
 227
 228         hbox = gtk_hbox_new(FALSE, 6);
 229         gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 230         gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
 231         gtk_widget_set_sensitive(entry,
 232                 (libravatarprefs.default_mode == DEF_MODE_URL)? TRUE: FALSE);
 233         page->defm_url_text = entry;
 234
 235         gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 236
 237         return vbox;
 238 }
 239
 240 static GtkWidget *p_create_frame_network(struct LibravatarPrefsPage *page)
 241 {
 242         GtkWidget *vbox, *checkbox;
 243
 244         vbox =  gtk_vbox_new(FALSE, 6);
 245
 246         checkbox = create_checkbox(_("_Allow redirects to other sites"),
 247                                    _("Follow redirect responses received from "
 248                                      "libravatar server to other avatar "
 249                                      "services like gravatar.com"));
 250         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox),
 251                                      libravatarprefs.allow_redirects);
 252         page->allow_redirects_check = checkbox;
 253
 254         gtk_box_pack_start(GTK_BOX(vbox), checkbox, FALSE, FALSE, 0);
 255
 256         return vbox;
 257 }
 258
 259 /*
 260   ┌─Icon cache───────────────────────────────────────────┐
 261   │ [✔] Use cached icons                                 │
 262   │ Cache refresh interval [ 24 |⬘] hours                │
 263   └──────────────────────────────────────────────────────┘
 264   ┌─Default missing icon mode────────────────────────────┐
 265   │ (•) None                                             │
 266   │ ( ) Mystery man                                      │
 267   │ ( ) Identicon                                        │
 268   │ ( ) MonsterID                                        │
 269   │ ( ) Wavatar                                          │
 270   │ ( ) Retro                                            │
 271   │ ( ) Custom URL                                       │
 272   │     URL: [_________________________________________] │
 273   └──────────────────────────────────────────────────────┘
 274   ┌─Network──────────────────────────────────────────────┐
 275   │ [✔] Allow redirects                                  │
 276   └──────────────────────────────────────────────────────┘
 277  */
 278 static void libravatar_prefs_create_widget_func(PrefsPage * _page,
 279                                                 GtkWindow * window,
 280                                                 gpointer data)
 281 {
 282         struct LibravatarPrefsPage *page = (struct LibravatarPrefsPage *) _page;
 283         GtkWidget *vbox, *vbox1, *vbox2, *vbox3, *frame;
 284
 285         vbox1 = p_create_frame_cache(page);
 286         vbox2 = p_create_frame_missing(page);
 287         vbox3 = p_create_frame_network(page);
 288
 289         vbox = gtk_vbox_new(FALSE, 6);
 290         gtk_container_set_border_width(GTK_CONTAINER(vbox), VBOX_BORDER);
 291
 292         PACK_FRAME (vbox, frame, _("Icon cache"));
 293         gtk_container_set_border_width(GTK_CONTAINER(vbox1), 6);
 294         gtk_container_add(GTK_CONTAINER(frame), vbox1);
 295
 296         PACK_FRAME (vbox, frame, _("Default missing icon mode"));
 297         gtk_container_set_border_width(GTK_CONTAINER(vbox2), 6);
 298         gtk_container_add(GTK_CONTAINER(frame), vbox2);
 299
 300         PACK_FRAME (vbox, frame, _("Network"));
 301         gtk_container_set_border_width(GTK_CONTAINER(vbox3), 6);
 302         gtk_container_add(GTK_CONTAINER(frame), vbox3);
 303
 304         gtk_widget_show_all(vbox);
 305         page->page.widget = vbox;
 306 }
 307
 308 static void libravatar_prefs_destroy_widget_func(PrefsPage *_page)
 309 {
 310         /* nothing */
 311 }
 312
 313 static void libravatar_save_config(void)
 314 {
 315         PrefFile *pfile;
 316         gchar *rcpath;
 317
 318         debug_print("Saving Libravatar Page\n");
 319
 320         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
 321         pfile = prefs_write_open(rcpath);
 322         g_free(rcpath);
 323         if (!pfile || (prefs_set_block_label(pfile, PREFS_BLOCK_NAME) < 0))
 324                 return;
 325
 326         if (prefs_write_param(param, pfile->fp) < 0) {
 327                 g_warning("Failed to write Libravatar configuration to file\n");
 328                 prefs_file_close_revert(pfile);
 329                 return;
 330         }
 331         if (fprintf(pfile->fp, "\n") < 0) {
 332                 FILE_OP_ERROR(rcpath, "fprintf");
 333                 prefs_file_close_revert(pfile);
 334         } else
 335                 prefs_file_close(pfile);
 336 }
 337
 338 static void libravatar_prefs_save_func(PrefsPage * _page)
 339 {
 340         struct LibravatarPrefsPage *page = (struct LibravatarPrefsPage *) _page;
 341         int i;
 342
 343         /* cache */
 344         libravatarprefs.cache_icons = gtk_toggle_button_get_active(
 345                 GTK_TOGGLE_BUTTON(page->cache_icons_check));
 346         /* cache interval */
 347         libravatarprefs.cache_interval = gtk_spin_button_get_value_as_int(
 348                 GTK_SPIN_BUTTON(page->cache_interval_spin));
 349         /* default mode */
 350         for (i = 0; i < NUM_DEF_BUTTONS; ++i) {
 351                 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->defm_radio[i]))) {
 352                         libravatarprefs.default_mode = radio_value[i];
 353                         break;
 354                 }
 355         }
 356         /* custom url */
 357         if (libravatarprefs.default_mode_url != NULL) {
 358                 g_free(libravatarprefs.default_mode_url);
 359         }
 360         libravatarprefs.default_mode_url = gtk_editable_get_chars(
 361                 GTK_EDITABLE(page->defm_url_text), 0, -1);
 362         /* redirects */
 363         libravatarprefs.allow_redirects = gtk_toggle_button_get_active(
 364                 GTK_TOGGLE_BUTTON(page->allow_redirects_check));
 365
 366         libravatar_save_config();
 367 }
 368
 369 void libravatar_prefs_init(void)
 370 {
 371         static gchar *path[3];
 372         gchar *rcpath;
 373
 374         path[0] = _("Plugins");
 375         path[1] = _("Libravatar");
 376         path[2] = NULL;
 377
 378         prefs_set_default(param);
 379         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
 380         prefs_read_config(param, PREFS_BLOCK_NAME, rcpath, NULL);
 381         g_free(rcpath);
 382
 383         libravatarprefs_page.page.path = path;
 384         libravatarprefs_page.page.create_widget = libravatar_prefs_create_widget_func;
 385         libravatarprefs_page.page.destroy_widget = libravatar_prefs_destroy_widget_func;
 386         libravatarprefs_page.page.save_page = libravatar_prefs_save_func;
 387
 388         prefs_gtk_register_page((PrefsPage *) &libravatarprefs_page);
 389 }
 390
 391 void libravatar_prefs_done(void)
 392 {
 393         prefs_gtk_unregister_page((PrefsPage *) &libravatarprefs_page);
 394 }
 395