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                 if (option->default_value.list != NULL)
 189                 {
 190                         g_list_foreach(option->default_value.list, purple_account_option_list_free, NULL);
 191                         g_list_free(option->default_value.list);
 192                 }
 193         }
 194
 195         g_free(option);
 196 }
 197
 198 void
 199 purple_account_option_set_default_bool(PurpleAccountOption *option,
 200                                                                          gboolean value)
 201 {
 202         g_return_if_fail(option != NULL);
 203         g_return_if_fail(option->type == PURPLE_PREF_BOOLEAN);
 204
 205         option->default_value.boolean = value;
 206 }
 207
 208 void
 209 purple_account_option_set_default_int(PurpleAccountOption *option, int value)
 210 {
 211         g_return_if_fail(option != NULL);
 212         g_return_if_fail(option->type == PURPLE_PREF_INT);
 213
 214         option->default_value.integer = value;
 215 }
 216
 217 void
 218 purple_account_option_set_default_string(PurpleAccountOption *option,
 219                                                                            const char *value)
 220 {
 221         g_return_if_fail(option != NULL);
 222         g_return_if_fail(option->type == PURPLE_PREF_STRING);
 223
 224         g_free(option->default_value.string);
 225         option->default_value.string = g_strdup(value);
 226 }
 227
 228 void
 229 purple_account_option_string_set_masked(PurpleAccountOption *option, gboolean masked)
 230 {
 231         g_return_if_fail(option != NULL);
 232         g_return_if_fail(option->type == PURPLE_PREF_STRING);
 233
 234         option->params.string.masked = masked;
 235 }
 236
 237 void
 238 purple_account_option_string_set_hints(PurpleAccountOption *option, GSList *hints)
 239 {
 240         g_return_if_fail(option != NULL);
 241         g_return_if_fail(option->type == PURPLE_PREF_STRING);
 242
 243         g_slist_free_full(option->params.string.hints, &g_free);
 244         option->params.string.hints = hints;
 245 }
 246
 247 void
 248 purple_account_option_set_list(PurpleAccountOption *option, GList *values)
 249 {
 250         g_return_if_fail(option != NULL);
 251         g_return_if_fail(option->type == PURPLE_PREF_STRING_LIST);
 252
 253         if (option->default_value.list != NULL)
 254         {
 255                 g_list_foreach(option->default_value.list, purple_account_option_list_free, NULL);
 256                 g_list_free(option->default_value.list);
 257         }
 258
 259         option->default_value.list = values;
 260 }
 261
 262 void
 263 purple_account_option_add_list_item(PurpleAccountOption *option,
 264                                                                   const char *key, const char *value)
 265 {
 266         PurpleKeyValuePair *kvp;
 267
 268         g_return_if_fail(option != NULL);
 269         g_return_if_fail(key    != NULL);
 270         g_return_if_fail(value  != NULL);
 271         g_return_if_fail(option->type == PURPLE_PREF_STRING_LIST);
 272
 273         kvp = g_new0(PurpleKeyValuePair, 1);
 274         kvp->key = g_strdup(key);
 275         kvp->value = g_strdup(value);
 276
 277         option->default_value.list = g_list_append(option->default_value.list,
 278                                                                                            kvp);
 279 }
 280
 281 PurplePrefType
 282 purple_account_option_get_pref_type(const PurpleAccountOption *option)
 283 {
 284         g_return_val_if_fail(option != NULL, PURPLE_PREF_NONE);
 285
 286         return option->type;
 287 }
 288
 289 const char *
 290 purple_account_option_get_text(const PurpleAccountOption *option)
 291 {
 292         g_return_val_if_fail(option != NULL, NULL);
 293
 294         return option->text;
 295 }
 296
 297 const char *
 298 purple_account_option_get_setting(const PurpleAccountOption *option)
 299 {
 300         g_return_val_if_fail(option != NULL, NULL);
 301
 302         return option->pref_name;
 303 }
 304
 305 gboolean
 306 purple_account_option_get_default_bool(const PurpleAccountOption *option)
 307 {
 308         g_return_val_if_fail(option != NULL, FALSE);
 309         g_return_val_if_fail(option->type == PURPLE_PREF_BOOLEAN, FALSE);
 310
 311         return option->default_value.boolean;
 312 }
 313
 314 int
 315 purple_account_option_get_default_int(const PurpleAccountOption *option)
 316 {
 317         g_return_val_if_fail(option != NULL, -1);
 318         g_return_val_if_fail(option->type == PURPLE_PREF_INT, -1);
 319
 320         return option->default_value.integer;
 321 }
 322
 323 const char *
 324 purple_account_option_get_default_string(const PurpleAccountOption *option)
 325 {
 326         g_return_val_if_fail(option != NULL, NULL);
 327         g_return_val_if_fail(option->type == PURPLE_PREF_STRING, NULL);
 328
 329         return option->default_value.string;
 330 }
 331
 332 const char *
 333 purple_account_option_get_default_list_value(const PurpleAccountOption *option)
 334 {
 335         PurpleKeyValuePair *kvp;
 336
 337         g_return_val_if_fail(option != NULL, NULL);
 338         g_return_val_if_fail(option->type == PURPLE_PREF_STRING_LIST, NULL);
 339
 340         if (option->default_value.list == NULL)
 341                 return NULL;
 342
 343         kvp = option->default_value.list->data;
 344
 345         return (kvp ? kvp->value : NULL);
 346 }
 347
 348 gboolean
 349 purple_account_option_string_get_masked(const PurpleAccountOption *option)
 350 {
 351         g_return_val_if_fail(option != NULL, FALSE);
 352         g_return_val_if_fail(option->type == PURPLE_PREF_STRING, FALSE);
 353
 354         return option->params.string.masked;
 355 }
 356
 357 const GSList *
 358 purple_account_option_string_get_hints(const PurpleAccountOption *option)
 359 {
 360         g_return_val_if_fail(option != NULL, FALSE);
 361         g_return_val_if_fail(option->type == PURPLE_PREF_STRING, FALSE);
 362
 363         return option->params.string.hints;
 364 }
 365
 366 GList *
 367 purple_account_option_get_list(const PurpleAccountOption *option)
 368 {
 369         g_return_val_if_fail(option != NULL, NULL);
 370         g_return_val_if_fail(option->type == PURPLE_PREF_STRING_LIST, NULL);
 371
 372         return option->default_value.list;
 373 }
 374
 375 /**************************************************************************
 376  * Account User Split API
 377  **************************************************************************/
 378 PurpleAccountUserSplit *
 379 purple_account_user_split_new(const char *text, const char *default_value,
 380                                                         char sep)
 381 {
 382         PurpleAccountUserSplit *split;
 383
 384         g_return_val_if_fail(text != NULL, NULL);
 385         g_return_val_if_fail(sep != 0, NULL);
 386
 387         split = g_new0(PurpleAccountUserSplit, 1);
 388
 389         split->text = g_strdup(text);
 390         split->field_sep = sep;
 391         split->default_value = g_strdup(default_value);
 392         split->reverse = TRUE;
 393
 394         return split;
 395 }
 396
 397 void
 398 purple_account_user_split_destroy(PurpleAccountUserSplit *split)
 399 {
 400         g_return_if_fail(split != NULL);
 401
 402         g_free(split->text);
 403         g_free(split->default_value);
 404         g_free(split);
 405 }
 406
 407 const char *
 408 purple_account_user_split_get_text(const PurpleAccountUserSplit *split)
 409 {
 410         g_return_val_if_fail(split != NULL, NULL);
 411
 412         return split->text;
 413 }
 414
 415 const char *
 416 purple_account_user_split_get_default_value(const PurpleAccountUserSplit *split)
 417 {
 418         g_return_val_if_fail(split != NULL, NULL);
 419
 420         return split->default_value;
 421 }
 422
 423 char
 424 purple_account_user_split_get_separator(const PurpleAccountUserSplit *split)
 425 {
 426         g_return_val_if_fail(split != NULL, 0);
 427
 428         return split->field_sep;
 429 }
 430
 431 gboolean
 432 purple_account_user_split_get_reverse(const PurpleAccountUserSplit *split)
 433 {
 434         g_return_val_if_fail(split != NULL, FALSE);
 435
 436         return split->reverse;
 437 }
 438
 439 void
 440 purple_account_user_split_set_reverse(PurpleAccountUserSplit *split, gboolean reverse)
 441 {
 442         g_return_if_fail(split != NULL);
 443
 444         split->reverse = reverse;
 445 }
 446
 447 gboolean
 448 purple_account_user_split_is_constant(const PurpleAccountUserSplit *split)
 449 {
 450         g_return_val_if_fail(split != NULL, FALSE);
 451
 452         return split->constant;
 453 }
 454
 455 void
 456 purple_account_user_split_set_constant(PurpleAccountUserSplit *split,
 457         gboolean constant)
 458 {
 459         g_return_if_fail(split != NULL);
 460
 461         split->constant = constant;
 462 }