libpurple/purpleaccountoption.c

   1 /* purple
   2  *
   3  * Purple is the legal property of its developers, whose names are too numerous
   4  * to list here.  Please refer to the COPYRIGHT file distributed with this
   5  * source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  20  */
  21 #include "internal.h"
  22
  23 #include "purpleaccountoption.h"
  24 #include "prefs.h"
  25 #include "util.h"
  26 #include "glibcompat.h"
  27
  28 /*
  29  * An option for an account.
  30  *
  31  * This is set by protocols, and appears in the account settings
  32  * dialogs.
  33  */
  34 struct _PurpleAccountOption
  35 {
  36         PurplePrefType type;    /* The type of value.                     */
  37
  38         gchar *text;            /* The text that will appear to the user. */
  39         gchar *pref_name;       /* The name of the associated preference. */
  40
  41         union
  42         {
  43                 gboolean boolean;   /* The default boolean value.             */
  44                 gint integer;       /* The default integer value.             */
  45                 gchar *string;      /* The default string value.              */
  46                 GList *list;        /* The default list value.                */
  47
  48         } default_value;
  49
  50         union
  51         {
  52                 struct
  53                 {
  54                         gboolean masked; /* Whether the value entered should
  55                                           *   be obscured from view (for
  56                                           *   passwords and similar options)
  57                                           */
  58                         GSList *hints;    /* List of hinted values */
  59                 } string;
  60         } params;
  61 };
  62
  63 G_DEFINE_BOXED_TYPE(
  64         PurpleAccountOption,
  65         purple_account_option,
  66         purple_account_option_copy,
  67         purple_account_option_destroy
  68 );
  69
  70 PurpleAccountOption *
  71 purple_account_option_new(PurplePrefType type, const char *text,
  72                                                 const char *pref_name)
  73 {
  74         PurpleAccountOption *option;
  75
  76         g_return_val_if_fail(type      != PURPLE_PREF_NONE, NULL);
  77         g_return_val_if_fail(text      != NULL,           NULL);
  78         g_return_val_if_fail(pref_name != NULL,           NULL);
  79
  80         option = g_new0(PurpleAccountOption, 1);
  81
  82         option->type      = type;
  83         option->text      = g_strdup(text);
  84         option->pref_name = g_strdup(pref_name);
  85
  86         return option;
  87 }
  88
  89 PurpleAccountOption *
  90 purple_account_option_copy(PurpleAccountOption *option) {
  91         PurpleAccountOption *opt = NULL;
  92
  93         g_return_val_if_fail(option, NULL);
  94
  95         opt = g_new0(PurpleAccountOption, 1);
  96         *opt = *option;
  97
  98         opt->text = g_strdup(option->text);
  99         opt->pref_name = g_strdup(option->pref_name);
 100
 101         if(opt->type == PURPLE_PREF_STRING) {
 102                 opt->default_value.string = g_strdup(option->default_value.string);
 103                 opt->params.string.hints = g_slist_copy(option->params.string.hints);
 104         }
 105
 106         return opt;
 107 }
 108
 109 PurpleAccountOption *
 110 purple_account_option_bool_new(const char *text, const char *pref_name,
 111                                                          gboolean default_value)
 112 {
 113         PurpleAccountOption *option;
 114
 115         option = purple_account_option_new(PURPLE_PREF_BOOLEAN, text, pref_name);
 116
 117         if (option == NULL)
 118                 return NULL;
 119
 120         option->default_value.boolean = default_value;
 121
 122         return option;
 123 }
 124
 125 PurpleAccountOption *
 126 purple_account_option_int_new(const char *text, const char *pref_name,
 127                                                         int default_value)
 128 {
 129         PurpleAccountOption *option;
 130
 131         option = purple_account_option_new(PURPLE_PREF_INT, text, pref_name);
 132
 133         if (option == NULL)
 134                 return NULL;
 135
 136         option->default_value.integer = default_value;
 137
 138         return option;
 139 }
 140
 141 PurpleAccountOption *
 142 purple_account_option_string_new(const char *text, const char *pref_name,
 143                                                            const char *default_value)
 144 {
 145         PurpleAccountOption *option;
 146
 147         option = purple_account_option_new(PURPLE_PREF_STRING, text, pref_name);
 148
 149         if (option == NULL)
 150                 return NULL;
 151
 152         option->default_value.string = g_strdup(default_value);
 153
 154         return option;
 155 }
 156
 157 PurpleAccountOption *
 158 purple_account_option_list_new(const char *text, const char *pref_name,
 159                                                          GList *list)
 160 {
 161         PurpleAccountOption *option;
 162
 163         option = purple_account_option_new(PURPLE_PREF_STRING_LIST, text, pref_name);
 164
 165         if (option == NULL)
 166                 return NULL;
 167
 168         option->default_value.list = list;
 169
 170         return option;
 171 }
 172
 173 static void
 174 purple_account_option_list_free(gpointer data, gpointer user_data)
 175 {
 176         PurpleKeyValuePair *kvp = data;
 177
 178         g_free(kvp->value);
 179         g_free(kvp->key);
 180         g_free(kvp);
 181 }
 182
 183 void
 184 purple_account_option_destroy(PurpleAccountOption *option)
 185 {
 186         g_return_if_fail(option != NULL);
 187
 188         g_free(option->text);
 189         g_free(option->pref_name);
 190
 191         if (option->type == PURPLE_PREF_STRING)
 192         {
 193                 g_free(option->default_value.string);
 194                 g_slist_free_full(option->params.string.hints, &g_free);
 195         }
 196         else if (option->type == PURPLE_PREF_STRING_LIST)
 197         {
 198                 g_list_free_full(option->default_value.list,
 199                                  (GDestroyNotify)purple_account_option_list_free);
 200         }
 201
 202         g_free(option);
 203 }
 204
 205 void
 206 purple_account_option_set_default_bool(PurpleAccountOption *option,
 207                                                                          gboolean value)
 208 {
 209         g_return_if_fail(option != NULL);
 210         g_return_if_fail(option->type == PURPLE_PREF_BOOLEAN);
 211
 212         option->default_value.boolean = value;
 213 }
 214
 215 void
 216 purple_account_option_set_default_int(PurpleAccountOption *option, int value)
 217 {
 218         g_return_if_fail(option != NULL);
 219         g_return_if_fail(option->type == PURPLE_PREF_INT);
 220
 221         option->default_value.integer = value;
 222 }
 223
 224 void
 225 purple_account_option_set_default_string(PurpleAccountOption *option,
 226                                                                            const char *value)
 227 {
 228         g_return_if_fail(option != NULL);
 229         g_return_if_fail(option->type == PURPLE_PREF_STRING);
 230
 231         g_free(option->default_value.string);
 232         option->default_value.string = g_strdup(value);
 233 }
 234
 235 void
 236 purple_account_option_string_set_masked(PurpleAccountOption *option, gboolean masked)
 237 {
 238         g_return_if_fail(option != NULL);
 239         g_return_if_fail(option->type == PURPLE_PREF_STRING);
 240
 241         option->params.string.masked = masked;
 242 }
 243
 244 void
 245 purple_account_option_string_set_hints(PurpleAccountOption *option, GSList *hints)
 246 {
 247         g_return_if_fail(option != NULL);
 248         g_return_if_fail(option->type == PURPLE_PREF_STRING);
 249
 250         g_slist_free_full(option->params.string.hints, &g_free);
 251         option->params.string.hints = hints;
 252 }
 253
 254 void
 255 purple_account_option_set_list(PurpleAccountOption *option, GList *values)
 256 {
 257         g_return_if_fail(option != NULL);
 258         g_return_if_fail(option->type == PURPLE_PREF_STRING_LIST);
 259
 260         g_list_free_full(option->default_value.list,
 261                          (GDestroyNotify)purple_account_option_list_free);
 262
 263         option->default_value.list = values;
 264 }
 265
 266 void
 267 purple_account_option_add_list_item(PurpleAccountOption *option,
 268                                                                   const char *key, const char *value)
 269 {
 270         PurpleKeyValuePair *kvp;
 271
 272         g_return_if_fail(option != NULL);
 273         g_return_if_fail(key    != NULL);
 274         g_return_if_fail(value  != NULL);
 275         g_return_if_fail(option->type == PURPLE_PREF_STRING_LIST);
 276
 277         kvp = g_new0(PurpleKeyValuePair, 1);
 278         kvp->key = g_strdup(key);
 279         kvp->value = g_strdup(value);
 280
 281         option->default_value.list = g_list_append(option->default_value.list,
 282                                                                                            kvp);
 283 }
 284
 285 PurplePrefType
 286 purple_account_option_get_pref_type(const PurpleAccountOption *option)
 287 {
 288         g_return_val_if_fail(option != NULL, PURPLE_PREF_NONE);
 289
 290         return option->type;
 291 }
 292
 293 const char *
 294 purple_account_option_get_text(const PurpleAccountOption *option)
 295 {
 296         g_return_val_if_fail(option != NULL, NULL);
 297
 298         return option->text;
 299 }
 300
 301 const char *
 302 purple_account_option_get_setting(const PurpleAccountOption *option)
 303 {
 304         g_return_val_if_fail(option != NULL, NULL);
 305
 306         return option->pref_name;
 307 }
 308
 309 gboolean
 310 purple_account_option_get_default_bool(const PurpleAccountOption *option)
 311 {
 312         g_return_val_if_fail(option != NULL, FALSE);
 313         g_return_val_if_fail(option->type == PURPLE_PREF_BOOLEAN, FALSE);
 314
 315         return option->default_value.boolean;
 316 }
 317
 318 int
 319 purple_account_option_get_default_int(const PurpleAccountOption *option)
 320 {
 321         g_return_val_if_fail(option != NULL, -1);
 322         g_return_val_if_fail(option->type == PURPLE_PREF_INT, -1);
 323
 324         return option->default_value.integer;
 325 }
 326
 327 const char *
 328 purple_account_option_get_default_string(const PurpleAccountOption *option)
 329 {
 330         g_return_val_if_fail(option != NULL, NULL);
 331         g_return_val_if_fail(option->type == PURPLE_PREF_STRING, NULL);
 332
 333         return option->default_value.string;
 334 }
 335
 336 const char *
 337 purple_account_option_get_default_list_value(const PurpleAccountOption *option)
 338 {
 339         PurpleKeyValuePair *kvp;
 340
 341         g_return_val_if_fail(option != NULL, NULL);
 342         g_return_val_if_fail(option->type == PURPLE_PREF_STRING_LIST, NULL);
 343
 344         if (option->default_value.list == NULL)
 345                 return NULL;
 346
 347         kvp = option->default_value.list->data;
 348
 349         return (kvp ? kvp->value : NULL);
 350 }
 351
 352 gboolean
 353 purple_account_option_string_get_masked(const PurpleAccountOption *option)
 354 {
 355         g_return_val_if_fail(option != NULL, FALSE);
 356         g_return_val_if_fail(option->type == PURPLE_PREF_STRING, FALSE);
 357
 358         return option->params.string.masked;
 359 }
 360
 361 const GSList *
 362 purple_account_option_string_get_hints(const PurpleAccountOption *option)
 363 {
 364         g_return_val_if_fail(option != NULL, NULL);
 365         g_return_val_if_fail(option->type == PURPLE_PREF_STRING, NULL);
 366
 367         return option->params.string.hints;
 368 }
 369
 370 GList *
 371 purple_account_option_get_list(const PurpleAccountOption *option)
 372 {
 373         g_return_val_if_fail(option != NULL, NULL);
 374         g_return_val_if_fail(option->type == PURPLE_PREF_STRING_LIST, NULL);
 375
 376         return option->default_value.list;
 377 }