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