libpurple/accountopt.c

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