finch/gntprefs.c

   1 /*
   2  * finch
   3  *
   4  * Finch is the legal property of its developers, whose names are too numerous
   5  * to list here.  Please refer to the COPYRIGHT file distributed with this
   6  * source distribution.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  21  */
  22
  23 #include "finch.h"
  24 #include <internal.h>
  25
  26 #include <prefs.h>
  27 #include <savedstatuses.h>
  28
  29 #include "gntprefs.h"
  30 #include "gntrequest.h"
  31
  32 #include "gnt.h"
  33 #include "gntwidget.h"
  34
  35 #include <string.h>
  36
  37 static struct {
  38         GList *freestrings;  /* strings to be freed when the pref-window is closed */
  39         gboolean showing;
  40         GntWidget *window;
  41         GntWidget *keyring_window;
  42 } pref_request;
  43
  44 void finch_prefs_init()
  45 {
  46         purple_prefs_add_none("/finch");
  47
  48         purple_prefs_add_none("/finch/plugins");
  49         purple_prefs_add_path_list("/finch/plugins/loaded", NULL);
  50         purple_prefs_add_path_list("/finch/plugins/seen", NULL);
  51
  52         purple_prefs_add_none("/finch/conversations");
  53         purple_prefs_add_bool("/finch/conversations/timestamps", TRUE);
  54         purple_prefs_add_bool("/finch/conversations/notify_typing", FALSE);
  55
  56         purple_prefs_add_none("/finch/filelocations");
  57         purple_prefs_add_path("/finch/filelocations/last_save_folder", "");
  58         purple_prefs_add_path("/finch/filelocations/last_save_folder", "");
  59 }
  60
  61 void finch_prefs_update_old()
  62 {
  63 }
  64
  65 typedef struct
  66 {
  67         PurplePrefType type;
  68         const char *pref;
  69         const char *label;
  70         GList *(*lv)(void);   /* If the value is to be selected from a number of choices */
  71 } Prefs;
  72
  73 static GList *
  74 get_log_options(void)
  75 {
  76         return purple_log_logger_get_options();
  77 }
  78
  79 static GList *
  80 get_idle_options(void)
  81 {
  82         GList *list = NULL;
  83         list = g_list_append(list, (char *)_("Based on keyboard use"));
  84         list = g_list_append(list, "system");
  85         list = g_list_append(list, (char*)_("From last sent message"));
  86         list = g_list_append(list, "purple");
  87         list = g_list_append(list, (char*)_("Never"));
  88         list = g_list_append(list, "never");
  89         return list;
  90 }
  91
  92 static GList *
  93 get_status_titles(void)
  94 {
  95         GList *list = NULL;
  96         GList *iter;
  97         for (iter = purple_savedstatuses_get_all(); iter; iter = iter->next) {
  98                 char *str;
  99                 if (purple_savedstatus_is_transient(iter->data))
 100                         continue;
 101                 str = g_strdup_printf("%ld", purple_savedstatus_get_creation_time(iter->data));
 102                 list = g_list_append(list, (char*)purple_savedstatus_get_title(iter->data));
 103                 list = g_list_append(list, str);
 104                 pref_request.freestrings = g_list_prepend(pref_request.freestrings, str);
 105         }
 106         return list;
 107 }
 108
 109 static PurpleRequestField *
 110 get_pref_field(Prefs *prefs)
 111 {
 112         PurpleRequestField *field = NULL;
 113
 114         if (prefs->lv == NULL)
 115         {
 116                 switch (prefs->type)
 117                 {
 118                         case PURPLE_PREF_BOOLEAN:
 119                                 field = purple_request_field_bool_new(prefs->pref, _(prefs->label),
 120                                                 purple_prefs_get_bool(prefs->pref));
 121                                 break;
 122                         case PURPLE_PREF_INT:
 123                                 field = purple_request_field_int_new(prefs->pref, _(prefs->label),
 124                                                 purple_prefs_get_int(prefs->pref), INT_MIN, INT_MAX);
 125                                 break;
 126                         case PURPLE_PREF_STRING:
 127                                 field = purple_request_field_string_new(prefs->pref, _(prefs->label),
 128                                                 purple_prefs_get_string(prefs->pref), FALSE);
 129                                 break;
 130                         default:
 131                                 break;
 132                 }
 133         }
 134         else
 135         {
 136                 GList *list = prefs->lv(), *iter;
 137                 if (list)
 138                         field = purple_request_field_list_new(prefs->pref, _(prefs->label));
 139                 for (iter = list; iter; iter = iter->next)
 140                 {
 141                         gboolean select = FALSE;
 142                         const char *data = iter->data;
 143                         int idata;
 144                         iter = iter->next;
 145                         switch (prefs->type)
 146                         {
 147                                 case PURPLE_PREF_BOOLEAN:
 148                                         if (sscanf(iter->data, "%d", &idata) != 1)
 149                                                 idata = FALSE;
 150                                         if (purple_prefs_get_bool(prefs->pref) == idata)
 151                                                 select = TRUE;
 152                                         break;
 153                                 case PURPLE_PREF_INT:
 154                                         if (sscanf(iter->data, "%d", &idata) != 1)
 155                                                 idata = 0;
 156                                         if (purple_prefs_get_int(prefs->pref) == idata)
 157                                                 select = TRUE;
 158                                         break;
 159                                 case PURPLE_PREF_STRING:
 160                                         if (purple_strequal(purple_prefs_get_string(prefs->pref), iter->data))
 161                                                 select = TRUE;
 162                                         break;
 163                                 default:
 164                                         break;
 165                         }
 166                         purple_request_field_list_add_icon(field, data, NULL, iter->data);
 167                         if (select)
 168                                 purple_request_field_list_add_selected(field, data);
 169                 }
 170                 g_list_free(list);
 171         }
 172         return field;
 173 }
 174
 175 static Prefs blist[] =
 176 {
 177         {PURPLE_PREF_BOOLEAN, "/finch/blist/idletime", N_("Show Idle Time"), NULL},
 178         {PURPLE_PREF_BOOLEAN, "/finch/blist/showoffline", N_("Show Offline Buddies"), NULL},
 179         {PURPLE_PREF_NONE, NULL, NULL, NULL}
 180 };
 181
 182 static Prefs convs[] =
 183 {
 184         {PURPLE_PREF_BOOLEAN, "/finch/conversations/timestamps", N_("Show Timestamps"), NULL},
 185         {PURPLE_PREF_BOOLEAN, "/finch/conversations/notify_typing", N_("Notify buddies when you are typing"), NULL},
 186         {PURPLE_PREF_NONE, NULL, NULL, NULL}
 187 };
 188
 189 static Prefs logging[] =
 190 {
 191         {PURPLE_PREF_STRING, "/purple/logging/format", N_("Log format"), get_log_options},
 192         {PURPLE_PREF_BOOLEAN, "/purple/logging/log_ims", N_("Log IMs"), NULL},
 193         {PURPLE_PREF_BOOLEAN, "/purple/logging/log_chats", N_("Log chats"), NULL},
 194         {PURPLE_PREF_BOOLEAN, "/purple/logging/log_system", N_("Log status change events"), NULL},
 195         {PURPLE_PREF_NONE, NULL, NULL, NULL},
 196 };
 197
 198 static Prefs keyring[] =
 199 {
 200         {PURPLE_PREF_STRING, "/purple/keyring/active", N_("Active keyring"), purple_keyring_get_options},
 201         {PURPLE_PREF_NONE, NULL, NULL, NULL}
 202 };
 203
 204 static Prefs idle[] =
 205 {
 206         {PURPLE_PREF_STRING, "/purple/away/idle_reporting", N_("Report Idle time"), get_idle_options},
 207         {PURPLE_PREF_BOOLEAN, "/purple/away/away_when_idle", N_("Change status when idle"), NULL},
 208         {PURPLE_PREF_INT, "/purple/away/mins_before_away", N_("Minutes before changing status"), NULL},
 209         {PURPLE_PREF_INT, "/purple/savedstatus/idleaway", N_("Change status to"), get_status_titles},
 210         {PURPLE_PREF_NONE, NULL, NULL, NULL},
 211 };
 212
 213 static void
 214 free_strings(void)
 215 {
 216         g_list_free_full(pref_request.freestrings, g_free);
 217         pref_request.freestrings = NULL;
 218         pref_request.showing = FALSE;
 219 }
 220
 221 static void
 222 save_cb(void *data, PurpleRequestFields *allfields)
 223 {
 224         finch_request_save_in_prefs(data, allfields);
 225         free_strings();
 226 }
 227
 228 static void
 229 add_pref_group(PurpleRequestFields *fields, const char *title, Prefs *prefs)
 230 {
 231         PurpleRequestField *field;
 232         PurpleRequestFieldGroup *group;
 233         int i;
 234
 235         group = purple_request_field_group_new(title);
 236         purple_request_fields_add_group(fields, group);
 237         for (i = 0; prefs[i].pref; i++)
 238         {
 239                 field = get_pref_field(prefs + i);
 240                 if (field)
 241                         purple_request_field_group_add_field(group, field);
 242         }
 243 }
 244
 245 void finch_prefs_show_all()
 246 {
 247         PurpleRequestFields *fields;
 248
 249         if (pref_request.showing) {
 250                 gnt_window_present(pref_request.window);
 251                 return;
 252         }
 253
 254         if (pref_request.keyring_window != NULL)
 255                 purple_request_close(PURPLE_REQUEST_FIELDS,
 256                         pref_request.keyring_window);
 257
 258         fields = purple_request_fields_new();
 259
 260         add_pref_group(fields, _("Buddy List"), blist);
 261         add_pref_group(fields, _("Conversations"), convs);
 262         add_pref_group(fields, _("Keyring"), keyring);
 263         add_pref_group(fields, _("Logging"), logging);
 264         add_pref_group(fields, _("Idle"), idle);
 265
 266         pref_request.showing = TRUE;
 267         pref_request.window = purple_request_fields(NULL, _("Preferences"), NULL, NULL, fields,
 268                         _("Save"), G_CALLBACK(save_cb), _("Cancel"), free_strings,
 269                         NULL, NULL);
 270 }
 271
 272 static void
 273 finch_prefs_keyring_save(void *data, PurpleRequestFields *fields)
 274 {
 275         pref_request.keyring_window = NULL;
 276
 277         purple_keyring_apply_settings(NULL, fields);
 278 }
 279
 280 static void
 281 finch_prefs_keyring_cancel(void)
 282 {
 283         pref_request.keyring_window = NULL;
 284 }
 285
 286 void finch_prefs_show_keyring(void)
 287 {
 288         PurpleRequestFields *fields;
 289
 290         if (pref_request.keyring_window != NULL) {
 291                 gnt_window_present(pref_request.keyring_window);
 292                 return;
 293         }
 294
 295         fields = purple_keyring_read_settings();
 296         if (fields == NULL) {
 297                 purple_notify_info(NULL, _("Keyring settings"),
 298                         _("Selected keyring doesn't allow any configuration"),
 299                         NULL, NULL);
 300                 return;
 301         }
 302
 303         pref_request.keyring_window = purple_request_fields(NULL,
 304                 _("Keyring settings"), NULL, NULL, fields,
 305                 _("Save"), G_CALLBACK(finch_prefs_keyring_save),
 306                 _("Cancel"), G_CALLBACK(finch_prefs_keyring_cancel),
 307                 NULL, NULL);
 308 }