src/plugins/libravatar/libravatar_prefs.c

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