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 *
purple_account_option_new(PurplePrefType type,const char * text,const char * pref_name)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 *
purple_account_option_bool_new(const char * text,const char * pref_name,gboolean default_value)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 *
purple_account_option_int_new(const char * text,const char * pref_name,int default_value)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 *
purple_account_option_string_new(const char * text,const char * pref_name,const char * default_value)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 *
purple_account_option_list_new(const char * text,const char * pref_name,GList * list)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
purple_account_option_list_free(gpointer data,gpointer user_data)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
purple_account_option_destroy(PurpleAccountOption * option)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
purple_account_option_set_default_bool(PurpleAccountOption * option,gboolean value)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
purple_account_option_set_default_int(PurpleAccountOption * option,int value)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
purple_account_option_set_default_string(PurpleAccountOption * option,const char * value)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
purple_account_option_set_masked(PurpleAccountOption * option,gboolean masked)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
purple_account_option_set_list(PurpleAccountOption * option,GList * values)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
purple_account_option_add_list_item(PurpleAccountOption * option,const char * key,const char * value)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
purple_account_option_get_type(const PurpleAccountOption * option)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 *
purple_account_option_get_text(const PurpleAccountOption * option)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 *
purple_account_option_get_setting(const PurpleAccountOption * option)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
purple_account_option_get_default_bool(const PurpleAccountOption * option)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
purple_account_option_get_default_int(const PurpleAccountOption * option)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 *
purple_account_option_get_default_string(const PurpleAccountOption * option)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 *
purple_account_option_get_default_list_value(const PurpleAccountOption * option)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
purple_account_option_get_masked(const PurpleAccountOption * option)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 *
purple_account_option_get_list(const PurpleAccountOption * option)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 *
purple_account_user_split_new(const char * text,const char * default_value,char sep)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
purple_account_user_split_destroy(PurpleAccountUserSplit * split)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 *
purple_account_user_split_get_text(const PurpleAccountUserSplit * split)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 *
purple_account_user_split_get_default_value(const PurpleAccountUserSplit * split)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
purple_account_user_split_get_separator(const PurpleAccountUserSplit * split)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
purple_account_user_split_get_reverse(const PurpleAccountUserSplit * split)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
purple_account_user_split_set_reverse(PurpleAccountUserSplit * split,gboolean reverse)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 }
378