libpurple/accountopt.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 "accountopt.h"
  24 #include "util.h"
  25 #include "glibcompat.h"
  26
  27 /*
  28  * An option for an account.
  29  *
  30  * This is set by protocols, and appears in the account settings
  31  * dialogs.
  32  */
  33 struct _PurpleAccountOption
  34 {
  35         PurplePrefType type;      /* The type of value.                     */
  36
  37         char *text;             /* The text that will appear to the user. */
  38         char *pref_name;        /* The name of the associated preference. */
  39
  40         union
  41         {
  42                 gboolean boolean;   /* The default boolean value.             */
  43                 int integer;        /* The default integer value.             */
  44                 char *string;       /* The default string value.              */
  45                 GList *list;        /* The default list value.                */
  46
  47         } default_value;
  48
  49         union
  50         {
  51                 struct
  52                 {
  53                         gboolean masked; /* Whether the value entered should
  54                                           *   be obscured from view (for
  55                                           *   passwords and similar options)
  56                                           */
  57                         GSList *hints;    /* List of hinted values */
  58                 } string;
  59         } params;
  60 };
  61
  62 /*
  63  * A username split.
  64  *
  65  * This is used by some protocols to separate the fields of the username
  66  * into more human-readable components.
  67  */
  68 struct _PurpleAccountUserSplit
  69 {
  70         char *text;             /* The text that will appear to the user. */
  71         char *default_value;    /* The default value.                     */
  72         char  field_sep;        /* The field separator.                   */
  73         gboolean reverse;       /* TRUE if the separator should be found
  74                                                            starting a the end of the string, FALSE
  75                                                            otherwise                                 */
  76         gboolean constant;
  77 };
  78
  79
  80 PurpleAccountOption *
  81 purple_account_option_new(PurplePrefType type, const char *text,
  82                                                 const char *pref_name)
  83 {
  84         PurpleAccountOption *option;
  85
  86         g_return_val_if_fail(type      != PURPLE_PREF_NONE, NULL);
  87         g_return_val_if_fail(text      != NULL,           NULL);
  88         g_return_val_if_fail(pref_name != NULL,           NULL);
  89
  90         option = g_new0(PurpleAccountOption, 1);
  91
  92         option->type      = type;
  93         option->text      = g_strdup(text);
  94         option->pref_name = g_strdup(pref_name);
  95
  96         return option;
  97 }
  98
  99 PurpleAccountOption *
 100 purple_account_option_bool_new(const char *text, const char *pref_name,
 101                                                          gboolean default_value)
 102 {
 103         PurpleAccountOption *option;
 104
 105         option = purple_account_option_new(PURPLE_PREF_BOOLEAN, text, pref_name);
 106
 107         if (option == NULL)
 108                 return NULL;
 109
 110         option->default_value.boolean = default_value;
 111
 112         return option;
 113 }
 114
 115 PurpleAccountOption *
 116 purple_account_option_int_new(const char *text, const char *pref_name,
 117                                                         int default_value)
 118 {
 119         PurpleAccountOption *option;
 120
 121         option = purple_account_option_new(PURPLE_PREF_INT, text, pref_name);
 122
 123         if (option == NULL)
 124                 return NULL;
 125
 126         option->default_value.integer = default_value;
 127
 128         return option;
 129 }
 130
 131 PurpleAccountOption *
 132 purple_account_option_string_new(const char *text, const char *pref_name,
 133                                                            const char *default_value)
 134 {
 135         PurpleAccountOption *option;
 136
 137         option = purple_account_option_new(PURPLE_PREF_STRING, text, pref_name);
 138
 139         if (option == NULL)
 140                 return NULL;
 141
 142         option->default_value.string = g_strdup(default_value);
 143
 144         return option;
 145 }
 146
 147 PurpleAccountOption *
 148 purple_account_option_list_new(const char *text, const char *pref_name,
 149                                                          GList *list)
 150 {
 151         PurpleAccountOption *option;
 152
 153         option = purple_account_option_new(PURPLE_PREF_STRING_LIST, text, pref_name);
 154
 155         if (option == NULL)
 156                 return NULL;
 157
 158         option->default_value.list = list;
 159
 160         return option;
 161 }
 162
 163 static void
 164 purple_account_option_list_free(gpointer data, gpointer user_data)
 165 {
 166         PurpleKeyValuePair *kvp = data;
 167
 168         g_free(kvp->value);
 169         g_free(kvp->key);
 170         g_free(kvp);
 171 }
 172
 173 void
 174 purple_account_option_destroy(PurpleAccountOption *option)
 175 {
 176         g_return_if_fail(option != NULL);
 177
 178         g_free(option->text);
 179         g_free(option->pref_name);
 180
 181         if (option->type == PURPLE_PREF_STRING)
 182         {
 183                 g_free(option->default_value.string);
 184                 g_slist_free_full(option->params.string.hints, &g_free);
 185         }
 186         else if (option->type == PURPLE_PREF_STRING_LIST)
 187         {
 188                 g_list_free_full(option->default_value.list,
 189                                  (GDestroyNotify)purple_account_option_list_free);
 190         }
 191
 192         g_free(option);
 193 }
 194
 195 void
 196 purple_account_option_set_default_bool(PurpleAccountOption *option,
 197                                                                          gboolean value)
 198 {
 199         g_return_if_fail(option != NULL);
 200         g_return_if_fail(option->type == PURPLE_PREF_BOOLEAN);
 201
 202         option->default_value.boolean = value;
 203 }
 204
 205 void
 206 purple_account_option_set_default_int(PurpleAccountOption *option, int value)
 207 {
 208         g_return_if_fail(option != NULL);
 209         g_return_if_fail(option->type == PURPLE_PREF_INT);
 210
 211         option->default_value.integer = value;
 212 }
 213
 214 void
 215 purple_account_option_set_default_string(PurpleAccountOption *option,
 216                                                                            const char *value)
 217 {
 218         g_return_if_fail(option != NULL);
 219         g_return_if_fail(option->type == PURPLE_PREF_STRING);
 220
 221         g_free(option->default_value.string);
 222         option->default_value.string = g_strdup(value);
 223 }
 224
 225 void
 226 purple_account_option_string_set_masked(PurpleAccountOption *option, gboolean masked)
 227 {
 228         g_return_if_fail(option != NULL);
 229         g_return_if_fail(option->type == PURPLE_PREF_STRING);
 230
 231         option->params.string.masked = masked;
 232 }
 233
 234 void
 235 purple_account_option_string_set_hints(PurpleAccountOption *option, GSList *hints)
 236 {
 237         g_return_if_fail(option != NULL);
 238         g_return_if_fail(option->type == PURPLE_PREF_STRING);
 239
 240         g_slist_free_full(option->params.string.hints, &g_free);
 241         option->params.string.hints = hints;
 242 }
 243
 244 void
 245 purple_account_option_set_list(PurpleAccountOption *option, GList *values)
 246 {
 247         g_return_if_fail(option != NULL);
 248         g_return_if_fail(option->type == PURPLE_PREF_STRING_LIST);
 249
 250         g_list_free_full(option->default_value.list,
 251                          (GDestroyNotify)purple_account_option_list_free);
 252
 253         option->default_value.list = values;
 254 }
 255
 256 void
 257 purple_account_option_add_list_item(PurpleAccountOption *option,
 258                                                                   const char *key, const char *value)
 259 {
 260         PurpleKeyValuePair *kvp;
 261
 262         g_return_if_fail(option != NULL);
 263         g_return_if_fail(key    != NULL);
 264         g_return_if_fail(value  != NULL);
 265         g_return_if_fail(option->type == PURPLE_PREF_STRING_LIST);
 266
 267         kvp = g_new0(PurpleKeyValuePair, 1);
 268         kvp->key = g_strdup(key);
 269         kvp->value = g_strdup(value);
 270
 271         option->default_value.list = g_list_append(option->default_value.list,
 272                                                                                            kvp);
 273 }
 274
 275 PurplePrefType
 276 purple_account_option_get_pref_type(const PurpleAccountOption *option)
 277 {
 278         g_return_val_if_fail(option != NULL, PURPLE_PREF_NONE);
 279
 280         return option->type;
 281 }
 282
 283 const char *
 284 purple_account_option_get_text(const PurpleAccountOption *option)
 285 {
 286         g_return_val_if_fail(option != NULL, NULL);
 287
 288         return option->text;
 289 }
 290
 291 const char *
 292 purple_account_option_get_setting(const PurpleAccountOption *option)
 293 {
 294         g_return_val_if_fail(option != NULL, NULL);
 295
 296         return option->pref_name;
 297 }
 298
 299 gboolean
 300 purple_account_option_get_default_bool(const PurpleAccountOption *option)
 301 {
 302         g_return_val_if_fail(option != NULL, FALSE);
 303         g_return_val_if_fail(option->type == PURPLE_PREF_BOOLEAN, FALSE);
 304
 305         return option->default_value.boolean;
 306 }
 307
 308 int
 309 purple_account_option_get_default_int(const PurpleAccountOption *option)
 310 {
 311         g_return_val_if_fail(option != NULL, -1);
 312         g_return_val_if_fail(option->type == PURPLE_PREF_INT, -1);
 313
 314         return option->default_value.integer;
 315 }
 316
 317 const char *
 318 purple_account_option_get_default_string(const PurpleAccountOption *option)
 319 {
 320         g_return_val_if_fail(option != NULL, NULL);
 321         g_return_val_if_fail(option->type == PURPLE_PREF_STRING, NULL);
 322
 323         return option->default_value.string;
 324 }
 325
 326 const char *
 327 purple_account_option_get_default_list_value(const PurpleAccountOption *option)
 328 {
 329         PurpleKeyValuePair *kvp;
 330
 331         g_return_val_if_fail(option != NULL, NULL);
 332         g_return_val_if_fail(option->type == PURPLE_PREF_STRING_LIST, NULL);
 333
 334         if (option->default_value.list == NULL)
 335                 return NULL;
 336
 337         kvp = option->default_value.list->data;
 338
 339         return (kvp ? kvp->value : NULL);
 340 }
 341
 342 gboolean
 343 purple_account_option_string_get_masked(const PurpleAccountOption *option)
 344 {
 345         g_return_val_if_fail(option != NULL, FALSE);
 346         g_return_val_if_fail(option->type == PURPLE_PREF_STRING, FALSE);
 347
 348         return option->params.string.masked;
 349 }
 350
 351 const GSList *
 352 purple_account_option_string_get_hints(const PurpleAccountOption *option)
 353 {
 354         g_return_val_if_fail(option != NULL, FALSE);
 355         g_return_val_if_fail(option->type == PURPLE_PREF_STRING, FALSE);
 356
 357         return option->params.string.hints;
 358 }
 359
 360 GList *
 361 purple_account_option_get_list(const PurpleAccountOption *option)
 362 {
 363         g_return_val_if_fail(option != NULL, NULL);
 364         g_return_val_if_fail(option->type == PURPLE_PREF_STRING_LIST, NULL);
 365
 366         return option->default_value.list;
 367 }
 368
 369 /**************************************************************************
 370  * Account User Split API
 371  **************************************************************************/
 372 PurpleAccountUserSplit *
 373 purple_account_user_split_new(const char *text, const char *default_value,
 374                                                         char sep)
 375 {
 376         PurpleAccountUserSplit *split;
 377
 378         g_return_val_if_fail(text != NULL, NULL);
 379         g_return_val_if_fail(sep != 0, NULL);
 380
 381         split = g_new0(PurpleAccountUserSplit, 1);
 382
 383         split->text = g_strdup(text);
 384         split->field_sep = sep;
 385         split->default_value = g_strdup(default_value);
 386         split->reverse = TRUE;
 387
 388         return split;
 389 }
 390
 391 void
 392 purple_account_user_split_destroy(PurpleAccountUserSplit *split)
 393 {
 394         g_return_if_fail(split != NULL);
 395
 396         g_free(split->text);
 397         g_free(split->default_value);
 398         g_free(split);
 399 }
 400
 401 const char *
 402 purple_account_user_split_get_text(const PurpleAccountUserSplit *split)
 403 {
 404         g_return_val_if_fail(split != NULL, NULL);
 405
 406         return split->text;
 407 }
 408
 409 const char *
 410 purple_account_user_split_get_default_value(const PurpleAccountUserSplit *split)
 411 {
 412         g_return_val_if_fail(split != NULL, NULL);
 413
 414         return split->default_value;
 415 }
 416
 417 char
 418 purple_account_user_split_get_separator(const PurpleAccountUserSplit *split)
 419 {
 420         g_return_val_if_fail(split != NULL, 0);
 421
 422         return split->field_sep;
 423 }
 424
 425 gboolean
 426 purple_account_user_split_get_reverse(const PurpleAccountUserSplit *split)
 427 {
 428         g_return_val_if_fail(split != NULL, FALSE);
 429
 430         return split->reverse;
 431 }
 432
 433 void
 434 purple_account_user_split_set_reverse(PurpleAccountUserSplit *split, gboolean reverse)
 435 {
 436         g_return_if_fail(split != NULL);
 437
 438         split->reverse = reverse;
 439 }
 440
 441 gboolean
 442 purple_account_user_split_is_constant(const PurpleAccountUserSplit *split)
 443 {
 444         g_return_val_if_fail(split != NULL, FALSE);
 445
 446         return split->constant;
 447 }
 448
 449 void
 450 purple_account_user_split_set_constant(PurpleAccountUserSplit *split,
 451         gboolean constant)
 452 {
 453         g_return_if_fail(split != NULL);
 454
 455         split->constant = constant;
 456 }