Mercurial > pidgin.yaz
annotate src/prefs.c @ 14067:f3ed5f4efcae
[gaim-migrate @ 16688]
Fix for CID 110 (which also will fix some asserts that happen when you edit your Jabber User Info for the first time)
Fix for CID 251 (Null check after deref)
Fixes for CID 252, 253. (UNUSED_VALUE)
I also changed the jabber_buddy_find() call in jabber_vcard_parse not to create the JabberBuddy if it doesn't exist - there should be a specific jabber buddy attached to the JabberBuddyInfo and if isn't present any more, we shouldn't create a new one.
committer: Tailor Script <tailor@pidgin.im>
author | Daniel Atallah <daniel.atallah@gmail.com> |
---|---|
date | Thu, 10 Aug 2006 21:08:00 +0000 |
parents | 8bda65b88e49 |
children | 11394a70de37 |
rev | line source |
---|---|
1 | 1 /* |
2 * gaim | |
3 * | |
8046 | 4 * Gaim is the legal property of its developers, whose names are too numerous |
5 * to list here. Please refer to the COPYRIGHT file distributed with this | |
6 * source distribution. | |
1 | 7 * |
8 * This program is free software; you can redistribute it and/or modify | |
9 * it under the terms of the GNU General Public License as published by | |
10 * the Free Software Foundation; either version 2 of the License, or | |
11 * (at your option) any later version. | |
12 * | |
13 * This program is distributed in the hope that it will be useful, | |
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 * GNU General Public License for more details. | |
17 * | |
18 * You should have received a copy of the GNU General Public License | |
19 * along with this program; if not, write to the Free Software | |
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
21 * | |
22 */ | |
23 | |
349
b402a23f35df
[gaim-migrate @ 359]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
340
diff
changeset
|
24 #ifdef HAVE_CONFIG_H |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2074
diff
changeset
|
25 #include <config.h> |
349
b402a23f35df
[gaim-migrate @ 359]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
340
diff
changeset
|
26 #endif |
5440 | 27 |
1 | 28 #include <string.h> |
29 #include <stdio.h> | |
30 #include <stdlib.h> | |
5440 | 31 #include <sys/stat.h> |
32 #include <sys/types.h> | |
33 #include <glib.h> | |
6216 | 34 #include "internal.h" |
5440 | 35 #include "prefs.h" |
36 #include "debug.h" | |
37 #include "util.h" | |
3366 | 38 |
4026
a997156437b6
[gaim-migrate @ 4230]
Herman Bloggs <hermanator12002@yahoo.com>
parents:
4010
diff
changeset
|
39 #ifdef _WIN32 |
a997156437b6
[gaim-migrate @ 4230]
Herman Bloggs <hermanator12002@yahoo.com>
parents:
4010
diff
changeset
|
40 #include "win32dep.h" |
a997156437b6
[gaim-migrate @ 4230]
Herman Bloggs <hermanator12002@yahoo.com>
parents:
4010
diff
changeset
|
41 #endif |
a997156437b6
[gaim-migrate @ 4230]
Herman Bloggs <hermanator12002@yahoo.com>
parents:
4010
diff
changeset
|
42 |
5440 | 43 struct pref_cb { |
44 GaimPrefCallback func; | |
45 gpointer data; | |
46 guint id; | |
10087 | 47 void *handle; |
5440 | 48 }; |
49 | |
10443 | 50 /* TODO: This should use GaimValues? */ |
5440 | 51 struct gaim_pref { |
52 GaimPrefType type; | |
53 char *name; | |
54 union { | |
55 gpointer generic; | |
56 gboolean boolean; | |
57 int integer; | |
58 char *string; | |
5561 | 59 GList *stringlist; |
5440 | 60 } value; |
61 GSList *callbacks; | |
62 struct gaim_pref *parent; | |
63 struct gaim_pref *sibling; | |
64 struct gaim_pref *first_child; | |
65 }; | |
3366 | 66 |
5440 | 67 |
10443 | 68 static struct gaim_pref prefs = { |
69 GAIM_PREF_NONE, | |
70 NULL, | |
71 { NULL }, | |
72 NULL, | |
73 NULL, | |
74 NULL, | |
75 NULL | |
76 }; | |
5440 | 77 |
10443 | 78 static GHashTable *prefs_hash = NULL; |
79 static guint save_timer = 0; | |
80 static gboolean prefs_loaded = FALSE; | |
5534 | 81 |
82 | |
10443 | 83 /********************************************************************* |
84 * Private utility functions * | |
85 *********************************************************************/ | |
8235 | 86 |
10443 | 87 static struct |
88 gaim_pref *find_pref(const char *name) | |
5787
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
89 { |
10443 | 90 if (!name || name[0] != '/') |
5440 | 91 return NULL; |
10443 | 92 else if (name[1] == '\0') |
5440 | 93 return &prefs; |
10443 | 94 else |
5440 | 95 return g_hash_table_lookup(prefs_hash, name); |
96 } | |
97 | |
10443 | 98 |
99 /********************************************************************* | |
100 * Writing to disk * | |
101 *********************************************************************/ | |
102 | |
103 /* | |
104 * This function recursively creates the xmlnode tree from the prefs | |
105 * tree structure. Yay recursion! | |
106 */ | |
10850 | 107 static void |
10443 | 108 pref_to_xmlnode(xmlnode *parent, struct gaim_pref *pref) |
109 { | |
110 xmlnode *node, *childnode; | |
111 struct gaim_pref *child; | |
112 char buf[20]; | |
113 GList *cur; | |
5561 | 114 |
10443 | 115 /* Create a new node */ |
116 node = xmlnode_new_child(parent, "pref"); | |
117 xmlnode_set_attrib(node, "name", pref->name); | |
5440 | 118 |
10443 | 119 /* Set the type of this node (if type == GAIM_PREF_NONE then do nothing) */ |
120 if (pref->type == GAIM_PREF_INT) { | |
121 xmlnode_set_attrib(node, "type", "int"); | |
122 snprintf(buf, sizeof(buf), "%d", pref->value.integer); | |
123 xmlnode_set_attrib(node, "value", buf); | |
124 } | |
125 else if (pref->type == GAIM_PREF_STRING) { | |
126 xmlnode_set_attrib(node, "type", "string"); | |
127 xmlnode_set_attrib(node, "value", pref->value.string); | |
128 } | |
129 else if (pref->type == GAIM_PREF_STRING_LIST) { | |
130 xmlnode_set_attrib(node, "type", "stringlist"); | |
131 for (cur = pref->value.stringlist; cur != NULL; cur = cur->next) | |
132 { | |
133 childnode = xmlnode_new_child(node, "item"); | |
134 xmlnode_set_attrib(childnode, "value", cur->data); | |
5440 | 135 } |
136 } | |
10443 | 137 else if (pref->type == GAIM_PREF_BOOLEAN) { |
138 xmlnode_set_attrib(node, "type", "bool"); | |
139 snprintf(buf, sizeof(buf), "%d", pref->value.boolean); | |
140 xmlnode_set_attrib(node, "value", buf); | |
5440 | 141 } |
142 | |
10443 | 143 /* All My Children */ |
144 for (child = pref->first_child; child != NULL; child = child->sibling) | |
145 pref_to_xmlnode(node, child); | |
5440 | 146 } |
147 | |
10443 | 148 static xmlnode * |
149 prefs_to_xmlnode(void) | |
150 { | |
151 xmlnode *node; | |
152 struct gaim_pref *pref, *child; | |
5440 | 153 |
10443 | 154 pref = &prefs; |
5440 | 155 |
10443 | 156 /* Create the root preference node */ |
157 node = xmlnode_new("pref"); | |
158 xmlnode_set_attrib(node, "version", "1"); | |
159 xmlnode_set_attrib(node, "name", "/"); | |
5561 | 160 |
10443 | 161 /* All My Children */ |
162 for (child = pref->first_child; child != NULL; child = child->sibling) | |
163 pref_to_xmlnode(node, child); | |
5561 | 164 |
10443 | 165 return node; |
5561 | 166 } |
167 | |
10443 | 168 static void |
169 sync_prefs(void) | |
170 { | |
171 xmlnode *node; | |
172 char *data; | |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
173 |
10443 | 174 if (!prefs_loaded) |
175 { | |
176 /* | |
177 * TODO: Call schedule_prefs_save()? Ideally we wouldn't need to. | |
178 * (prefs.xml should be loaded when gaim_prefs_init is called) | |
179 */ | |
180 gaim_debug_error("prefs", "Attempted to save prefs before " | |
181 "they were read!\n"); | |
5814 | 182 return; |
183 } | |
3500 | 184 |
10443 | 185 node = prefs_to_xmlnode(); |
186 data = xmlnode_to_formatted_str(node, NULL); | |
187 gaim_util_write_data_to_file("prefs.xml", data, -1); | |
188 g_free(data); | |
189 xmlnode_free(node); | |
4326 | 190 } |
191 | |
10443 | 192 static gboolean |
193 save_cb(gpointer data) | |
194 { | |
195 sync_prefs(); | |
196 save_timer = 0; | |
9594 | 197 return FALSE; |
4288 | 198 } |
199 | |
10443 | 200 static void |
201 schedule_prefs_save(void) | |
5440 | 202 { |
10443 | 203 if (save_timer == 0) |
204 save_timer = gaim_timeout_add(5000, save_cb, NULL); | |
3366 | 205 } |
206 | |
2254 | 207 |
10443 | 208 /********************************************************************* |
209 * Reading from disk * | |
210 *********************************************************************/ | |
3551 | 211 |
5440 | 212 static GList *prefs_stack = NULL; |
873
789df4b47508
[gaim-migrate @ 883]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
864
diff
changeset
|
213 |
10443 | 214 static void |
215 prefs_start_element_handler (GMarkupParseContext *context, | |
5440 | 216 const gchar *element_name, |
217 const gchar **attribute_names, | |
218 const gchar **attribute_values, | |
219 gpointer user_data, | |
10443 | 220 GError **error) |
221 { | |
5440 | 222 GaimPrefType pref_type = GAIM_PREF_NONE; |
223 int i; | |
224 const char *pref_name = NULL, *pref_value = NULL; | |
225 GString *pref_name_full; | |
226 GList *tmp; | |
3366 | 227 |
5561 | 228 if(strcmp(element_name, "pref") && strcmp(element_name, "item")) |
5440 | 229 return; |
3500 | 230 |
5440 | 231 for(i = 0; attribute_names[i]; i++) { |
232 if(!strcmp(attribute_names[i], "name")) { | |
233 pref_name = attribute_values[i]; | |
234 } else if(!strcmp(attribute_names[i], "type")) { | |
235 if(!strcmp(attribute_values[i], "bool")) | |
236 pref_type = GAIM_PREF_BOOLEAN; | |
237 else if(!strcmp(attribute_values[i], "int")) | |
238 pref_type = GAIM_PREF_INT; | |
239 else if(!strcmp(attribute_values[i], "string")) | |
240 pref_type = GAIM_PREF_STRING; | |
5561 | 241 else if(!strcmp(attribute_values[i], "stringlist")) |
242 pref_type = GAIM_PREF_STRING_LIST; | |
5440 | 243 else |
244 return; | |
245 } else if(!strcmp(attribute_names[i], "value")) { | |
246 pref_value = attribute_values[i]; | |
247 } | |
248 } | |
873
789df4b47508
[gaim-migrate @ 883]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
864
diff
changeset
|
249 |
5561 | 250 if(!strcmp(element_name, "item")) { |
5838 | 251 struct gaim_pref *pref; |
252 | |
253 pref_name_full = g_string_new(""); | |
254 | |
255 for(tmp = prefs_stack; tmp; tmp = tmp->next) { | |
256 pref_name_full = g_string_prepend(pref_name_full, tmp->data); | |
257 pref_name_full = g_string_prepend_c(pref_name_full, '/'); | |
258 } | |
259 | |
260 pref = find_pref(pref_name_full->str); | |
261 | |
5561 | 262 if(pref) { |
263 pref->value.stringlist = g_list_append(pref->value.stringlist, | |
264 g_strdup(pref_value)); | |
265 } | |
5838 | 266 } else { |
267 if(!pref_name || !strcmp(pref_name, "/")) | |
268 return; | |
652
4d3285caa191
[gaim-migrate @ 662]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
619
diff
changeset
|
269 |
5838 | 270 pref_name_full = g_string_new(pref_name); |
652
4d3285caa191
[gaim-migrate @ 662]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
619
diff
changeset
|
271 |
5838 | 272 for(tmp = prefs_stack; tmp; tmp = tmp->next) { |
273 pref_name_full = g_string_prepend_c(pref_name_full, '/'); | |
274 pref_name_full = g_string_prepend(pref_name_full, tmp->data); | |
275 } | |
276 | |
5440 | 277 pref_name_full = g_string_prepend_c(pref_name_full, '/'); |
1253
8342d3aab1f1
[gaim-migrate @ 1263]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1250
diff
changeset
|
278 |
5838 | 279 switch(pref_type) { |
280 case GAIM_PREF_NONE: | |
7785 | 281 gaim_prefs_add_none(pref_name_full->str); |
5838 | 282 break; |
283 case GAIM_PREF_BOOLEAN: | |
284 gaim_prefs_set_bool(pref_name_full->str, atoi(pref_value)); | |
285 break; | |
286 case GAIM_PREF_INT: | |
287 gaim_prefs_set_int(pref_name_full->str, atoi(pref_value)); | |
288 break; | |
289 case GAIM_PREF_STRING: | |
290 gaim_prefs_set_string(pref_name_full->str, pref_value); | |
291 break; | |
292 case GAIM_PREF_STRING_LIST: | |
293 gaim_prefs_set_string_list(pref_name_full->str, NULL); | |
294 break; | |
295 } | |
296 prefs_stack = g_list_prepend(prefs_stack, g_strdup(pref_name)); | |
297 g_string_free(pref_name_full, TRUE); | |
5440 | 298 } |
1170 | 299 } |
300 | |
10443 | 301 static void |
302 prefs_end_element_handler(GMarkupParseContext *context, | |
303 const gchar *element_name, | |
304 gpointer user_data, GError **error) | |
305 { | |
5940 | 306 if(prefs_stack && !strcmp(element_name, "pref")) { |
307 g_free(prefs_stack->data); | |
5440 | 308 prefs_stack = g_list_delete_link(prefs_stack, prefs_stack); |
309 } | |
1170 | 310 } |
311 | |
5440 | 312 static GMarkupParser prefs_parser = { |
313 prefs_start_element_handler, | |
314 prefs_end_element_handler, | |
315 NULL, | |
316 NULL, | |
317 NULL | |
318 }; | |
1170 | 319 |
10443 | 320 gboolean |
321 gaim_prefs_load() | |
322 { | |
5440 | 323 gchar *filename = g_build_filename(gaim_user_dir(), "prefs.xml", NULL); |
324 gchar *contents = NULL; | |
325 gsize length; | |
326 GMarkupParseContext *context; | |
327 GError *error = NULL; | |
5314
1f901484599d
[gaim-migrate @ 5686]
Christian Hammond <chipx86@chipx86.com>
parents:
5297
diff
changeset
|
328 |
7561
cdfdbabd3266
[gaim-migrate @ 8175]
Christian Hammond <chipx86@chipx86.com>
parents:
7555
diff
changeset
|
329 if (!filename) { |
10443 | 330 prefs_loaded = TRUE; |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
331 return FALSE; |
5534 | 332 } |
5440 | 333 |
10443 | 334 gaim_debug_info("prefs", "Reading %s\n", filename); |
5314
1f901484599d
[gaim-migrate @ 5686]
Christian Hammond <chipx86@chipx86.com>
parents:
5297
diff
changeset
|
335 |
5440 | 336 if(!g_file_get_contents(filename, &contents, &length, &error)) { |
8671
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
337 #ifndef _WIN32 |
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
338 g_free(filename); |
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
339 g_error_free(error); |
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
340 |
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
341 error = NULL; |
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
342 |
8702 | 343 filename = g_build_filename(SYSCONFDIR, "gaim", "prefs.xml", NULL); |
8671
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
344 |
10443 | 345 gaim_debug_info("prefs", "Reading %s\n", filename); |
8671
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
346 |
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
347 if (!g_file_get_contents(filename, &contents, &length, &error)) { |
10443 | 348 gaim_debug_error("prefs", "Error reading prefs: %s\n", |
8671
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
349 error->message); |
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
350 g_error_free(error); |
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
351 g_free(filename); |
10443 | 352 prefs_loaded = TRUE; |
8671
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
353 |
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
354 return FALSE; |
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
355 } |
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
356 #else /* _WIN32 */ |
10443 | 357 gaim_debug_error("prefs", "Error reading prefs: %s\n", |
5440 | 358 error->message); |
359 g_error_free(error); | |
6040 | 360 g_free(filename); |
10443 | 361 prefs_loaded = TRUE; |
6040 | 362 |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
363 return FALSE; |
8671
d99d2572d1a9
[gaim-migrate @ 9423]
Christian Hammond <chipx86@chipx86.com>
parents:
8549
diff
changeset
|
364 #endif /* _WIN32 */ |
1170 | 365 } |
366 | |
5440 | 367 context = g_markup_parse_context_new(&prefs_parser, 0, NULL, NULL); |
368 | |
369 if(!g_markup_parse_context_parse(context, contents, length, NULL)) { | |
370 g_markup_parse_context_free(context); | |
371 g_free(contents); | |
6040 | 372 g_free(filename); |
10443 | 373 prefs_loaded = TRUE; |
6040 | 374 |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
375 return FALSE; |
5440 | 376 } |
377 | |
378 if(!g_markup_parse_context_end_parse(context, NULL)) { | |
10443 | 379 gaim_debug_error("prefs", "Error parsing %s\n", filename); |
5440 | 380 g_markup_parse_context_free(context); |
381 g_free(contents); | |
6040 | 382 g_free(filename); |
10443 | 383 prefs_loaded = TRUE; |
6040 | 384 |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
385 return FALSE; |
5440 | 386 } |
387 | |
10443 | 388 gaim_debug_info("prefs", "Finished reading %s\n", filename); |
5440 | 389 g_markup_parse_context_free(context); |
390 g_free(contents); | |
391 g_free(filename); | |
10443 | 392 prefs_loaded = TRUE; |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
393 |
13053
d50c330e8089
[gaim-migrate @ 15414]
Richard Laager <rlaager@wiktel.com>
parents:
13040
diff
changeset
|
394 /* I introduced a bug in 2.0.0beta2. This fixes the broken |
d50c330e8089
[gaim-migrate @ 15414]
Richard Laager <rlaager@wiktel.com>
parents:
13040
diff
changeset
|
395 * scores on upgrade. This can be removed sometime shortly |
d50c330e8089
[gaim-migrate @ 15414]
Richard Laager <rlaager@wiktel.com>
parents:
13040
diff
changeset
|
396 * after 2.0.0 final is released. -- rlaager */ |
d50c330e8089
[gaim-migrate @ 15414]
Richard Laager <rlaager@wiktel.com>
parents:
13040
diff
changeset
|
397 if (gaim_prefs_get_int("/core/status/scores/offline") == -500 && |
d50c330e8089
[gaim-migrate @ 15414]
Richard Laager <rlaager@wiktel.com>
parents:
13040
diff
changeset
|
398 gaim_prefs_get_int("/core/status/scores/available") == 100 && |
d50c330e8089
[gaim-migrate @ 15414]
Richard Laager <rlaager@wiktel.com>
parents:
13040
diff
changeset
|
399 gaim_prefs_get_int("/core/status/scores/invisible") == -50 && |
d50c330e8089
[gaim-migrate @ 15414]
Richard Laager <rlaager@wiktel.com>
parents:
13040
diff
changeset
|
400 gaim_prefs_get_int("/core/status/scores/away") == -100 && |
d50c330e8089
[gaim-migrate @ 15414]
Richard Laager <rlaager@wiktel.com>
parents:
13040
diff
changeset
|
401 gaim_prefs_get_int("/core/status/scores/extended_away") == -200 && |
d50c330e8089
[gaim-migrate @ 15414]
Richard Laager <rlaager@wiktel.com>
parents:
13040
diff
changeset
|
402 gaim_prefs_get_int("/core/status/scores/idle") == -400) |
d50c330e8089
[gaim-migrate @ 15414]
Richard Laager <rlaager@wiktel.com>
parents:
13040
diff
changeset
|
403 { |
d50c330e8089
[gaim-migrate @ 15414]
Richard Laager <rlaager@wiktel.com>
parents:
13040
diff
changeset
|
404 gaim_prefs_set_int("/core/status/scores/idle", -10); |
d50c330e8089
[gaim-migrate @ 15414]
Richard Laager <rlaager@wiktel.com>
parents:
13040
diff
changeset
|
405 } |
d50c330e8089
[gaim-migrate @ 15414]
Richard Laager <rlaager@wiktel.com>
parents:
13040
diff
changeset
|
406 |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
407 return TRUE; |
1006
0a4d0ed65e17
[gaim-migrate @ 1016]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1002
diff
changeset
|
408 } |
0a4d0ed65e17
[gaim-migrate @ 1016]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1002
diff
changeset
|
409 |
10443 | 410 |
411 | |
412 static void | |
12822
cecc9706c11f
[gaim-migrate @ 15170]
Richard Laager <rlaager@wiktel.com>
parents:
12762
diff
changeset
|
413 prefs_save_cb(const char *name, GaimPrefType type, gconstpointer val, |
10443 | 414 gpointer user_data) |
415 { | |
416 | |
417 if(!prefs_loaded) | |
418 return; | |
419 | |
420 gaim_debug_misc("prefs", "%s changed, scheduling save.\n", name); | |
421 | |
422 schedule_prefs_save(); | |
423 } | |
424 | |
425 static char * | |
426 get_path_dirname(const char *name) | |
427 { | |
428 char *c, *str; | |
429 | |
430 str = g_strdup(name); | |
431 | |
432 if ((c = strrchr(str, '/')) != NULL) { | |
433 *c = '\0'; | |
434 | |
435 if (*str == '\0') { | |
436 g_free(str); | |
437 | |
438 str = g_strdup("/"); | |
439 } | |
440 } | |
441 else { | |
442 g_free(str); | |
443 | |
444 str = g_strdup("."); | |
445 } | |
446 | |
447 return str; | |
448 } | |
449 | |
450 static char * | |
451 get_path_basename(const char *name) | |
452 { | |
453 const char *c; | |
454 | |
455 if ((c = strrchr(name, '/')) != NULL) | |
456 return g_strdup(c + 1); | |
457 | |
458 return g_strdup(name); | |
459 } | |
460 | |
461 static char * | |
462 pref_full_name(struct gaim_pref *pref) | |
463 { | |
464 GString *name; | |
465 struct gaim_pref *parent; | |
466 | |
467 if(!pref) | |
468 return NULL; | |
469 | |
470 if(pref == &prefs) | |
471 return g_strdup("/"); | |
472 | |
473 name = g_string_new(pref->name); | |
474 parent = pref->parent; | |
475 | |
476 for(parent = pref->parent; parent && parent->name; parent = parent->parent) { | |
477 name = g_string_prepend_c(name, '/'); | |
478 name = g_string_prepend(name, parent->name); | |
479 } | |
12759
019d0e4d8d65
[gaim-migrate @ 15106]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
12615
diff
changeset
|
480 name = g_string_prepend_c(name, '/'); |
14035 | 481 return g_string_free(name, FALSE); |
10443 | 482 } |
483 | |
484 static struct gaim_pref * | |
485 find_pref_parent(const char *name) | |
486 { | |
487 char *parent_name = get_path_dirname(name); | |
488 struct gaim_pref *ret = &prefs; | |
489 | |
490 if(strcmp(parent_name, "/")) { | |
491 ret = find_pref(parent_name); | |
492 } | |
493 | |
494 g_free(parent_name); | |
495 return ret; | |
496 } | |
497 | |
498 static void | |
499 free_pref_value(struct gaim_pref *pref) | |
500 { | |
501 switch(pref->type) { | |
502 case GAIM_PREF_BOOLEAN: | |
503 pref->value.boolean = FALSE; | |
504 break; | |
505 case GAIM_PREF_INT: | |
506 pref->value.integer = 0; | |
507 break; | |
508 case GAIM_PREF_STRING: | |
509 g_free(pref->value.string); | |
510 pref->value.string = NULL; | |
511 break; | |
512 case GAIM_PREF_STRING_LIST: | |
513 { | |
14035 | 514 g_list_foreach(pref->value.stringlist, (GFunc)g_free, NULL); |
10443 | 515 g_list_free(pref->value.stringlist); |
516 } break; | |
517 case GAIM_PREF_NONE: | |
518 break; | |
519 } | |
520 } | |
521 | |
522 static struct gaim_pref * | |
523 add_pref(GaimPrefType type, const char *name) | |
524 { | |
525 struct gaim_pref *parent; | |
526 struct gaim_pref *me; | |
527 struct gaim_pref *sibling; | |
528 char *my_name; | |
529 | |
530 parent = find_pref_parent(name); | |
531 | |
532 if(!parent) | |
533 return NULL; | |
534 | |
535 my_name = get_path_basename(name); | |
536 | |
537 for(sibling = parent->first_child; sibling; sibling = sibling->sibling) { | |
538 if(!strcmp(sibling->name, my_name)) { | |
539 g_free(my_name); | |
540 return NULL; | |
541 } | |
542 } | |
543 | |
544 me = g_new0(struct gaim_pref, 1); | |
545 me->type = type; | |
546 me->name = my_name; | |
547 | |
548 me->parent = parent; | |
549 if(parent->first_child) { | |
550 /* blatant abuse of a for loop */ | |
551 for(sibling = parent->first_child; sibling->sibling; | |
552 sibling = sibling->sibling); | |
553 sibling->sibling = me; | |
554 } else { | |
555 parent->first_child = me; | |
556 } | |
557 | |
558 g_hash_table_insert(prefs_hash, g_strdup(name), (gpointer)me); | |
559 | |
560 return me; | |
561 } | |
562 | |
563 void | |
564 gaim_prefs_add_none(const char *name) | |
565 { | |
566 add_pref(GAIM_PREF_NONE, name); | |
567 } | |
568 | |
569 void | |
570 gaim_prefs_add_bool(const char *name, gboolean value) | |
571 { | |
572 struct gaim_pref *pref = add_pref(GAIM_PREF_BOOLEAN, name); | |
573 | |
574 if(!pref) | |
575 return; | |
576 | |
577 pref->value.boolean = value; | |
578 } | |
579 | |
580 void | |
581 gaim_prefs_add_int(const char *name, int value) | |
582 { | |
583 struct gaim_pref *pref = add_pref(GAIM_PREF_INT, name); | |
584 | |
585 if(!pref) | |
586 return; | |
587 | |
588 pref->value.integer = value; | |
589 } | |
590 | |
591 void | |
592 gaim_prefs_add_string(const char *name, const char *value) | |
593 { | |
594 struct gaim_pref *pref = add_pref(GAIM_PREF_STRING, name); | |
595 | |
596 if(!pref) | |
597 return; | |
598 | |
599 pref->value.string = g_strdup(value); | |
600 } | |
601 | |
602 void | |
603 gaim_prefs_add_string_list(const char *name, GList *value) | |
604 { | |
605 struct gaim_pref *pref = add_pref(GAIM_PREF_STRING_LIST, name); | |
606 GList *tmp; | |
607 | |
608 if(!pref) | |
609 return; | |
610 | |
611 for(tmp = value; tmp; tmp = tmp->next) | |
612 pref->value.stringlist = g_list_append(pref->value.stringlist, | |
613 g_strdup(tmp->data)); | |
614 } | |
615 | |
10871 | 616 static void |
10443 | 617 remove_pref(struct gaim_pref *pref) |
618 { | |
619 char *name; | |
620 | |
621 if(!pref || pref == &prefs) | |
622 return; | |
623 | |
624 while(pref->first_child) | |
625 remove_pref(pref->first_child); | |
626 | |
627 if(pref->parent->first_child == pref) { | |
628 pref->parent->first_child = pref->sibling; | |
629 } else { | |
630 struct gaim_pref *sib = pref->parent->first_child; | |
12599 | 631 while(sib && sib->sibling != pref) |
10443 | 632 sib = sib->sibling; |
12599 | 633 if(sib) |
634 sib->sibling = pref->sibling; | |
10443 | 635 } |
636 | |
637 name = pref_full_name(pref); | |
638 | |
12762
40584fbf8c6e
[gaim-migrate @ 15109]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
12759
diff
changeset
|
639 gaim_debug_info("prefs", "removing pref %s\n", name); |
10443 | 640 |
641 g_hash_table_remove(prefs_hash, name); | |
642 g_free(name); | |
643 | |
644 free_pref_value(pref); | |
645 | |
646 g_slist_free(pref->callbacks); | |
647 g_free(pref->name); | |
648 g_free(pref); | |
649 } | |
650 | |
651 void | |
652 gaim_prefs_remove(const char *name) | |
653 { | |
654 struct gaim_pref *pref = find_pref(name); | |
655 | |
656 if(!pref) | |
657 return; | |
658 | |
659 remove_pref(pref); | |
660 } | |
661 | |
662 void | |
663 gaim_prefs_destroy() | |
664 { | |
665 gaim_prefs_remove("/"); | |
666 } | |
667 | |
668 static void | |
669 do_callbacks(const char* name, struct gaim_pref *pref) | |
670 { | |
671 GSList *cbs; | |
672 struct gaim_pref *cb_pref; | |
673 for(cb_pref = pref; cb_pref; cb_pref = cb_pref->parent) { | |
674 for(cbs = cb_pref->callbacks; cbs; cbs = cbs->next) { | |
675 struct pref_cb *cb = cbs->data; | |
676 cb->func(name, pref->type, pref->value.generic, cb->data); | |
677 } | |
678 } | |
679 } | |
680 | |
681 void | |
682 gaim_prefs_trigger_callback(const char *name) | |
683 { | |
684 struct gaim_pref *pref = find_pref(name); | |
685 | |
686 if(!pref) { | |
687 gaim_debug_error("prefs", | |
688 "gaim_prefs_trigger_callback: Unknown pref %s\n", name); | |
689 return; | |
690 } | |
691 | |
692 do_callbacks(name, pref); | |
693 } | |
694 | |
695 void | |
696 gaim_prefs_set_generic(const char *name, gpointer value) | |
697 { | |
698 struct gaim_pref *pref = find_pref(name); | |
699 | |
700 if(!pref) { | |
701 gaim_debug_error("prefs", | |
702 "gaim_prefs_set_generic: Unknown pref %s\n", name); | |
703 return; | |
704 } | |
705 | |
706 pref->value.generic = value; | |
707 do_callbacks(name, pref); | |
708 } | |
709 | |
710 void | |
711 gaim_prefs_set_bool(const char *name, gboolean value) | |
712 { | |
713 struct gaim_pref *pref = find_pref(name); | |
714 | |
715 if(pref) { | |
716 if(pref->type != GAIM_PREF_BOOLEAN) { | |
717 gaim_debug_error("prefs", | |
718 "gaim_prefs_set_bool: %s not a boolean pref\n", name); | |
719 return; | |
720 } | |
721 | |
722 if(pref->value.boolean != value) { | |
723 pref->value.boolean = value; | |
724 do_callbacks(name, pref); | |
725 } | |
726 } else { | |
727 gaim_prefs_add_bool(name, value); | |
728 } | |
729 } | |
730 | |
731 void | |
732 gaim_prefs_set_int(const char *name, int value) | |
733 { | |
734 struct gaim_pref *pref = find_pref(name); | |
735 | |
736 if(pref) { | |
737 if(pref->type != GAIM_PREF_INT) { | |
738 gaim_debug_error("prefs", | |
739 "gaim_prefs_set_int: %s not an integer pref\n", name); | |
740 return; | |
741 } | |
742 | |
743 if(pref->value.integer != value) { | |
744 pref->value.integer = value; | |
745 do_callbacks(name, pref); | |
746 } | |
747 } else { | |
748 gaim_prefs_add_int(name, value); | |
749 } | |
750 } | |
751 | |
752 void | |
753 gaim_prefs_set_string(const char *name, const char *value) | |
754 { | |
755 struct gaim_pref *pref = find_pref(name); | |
756 | |
757 if(pref) { | |
758 if(pref->type != GAIM_PREF_STRING) { | |
759 gaim_debug_error("prefs", | |
760 "gaim_prefs_set_string: %s not a string pref\n", name); | |
761 return; | |
762 } | |
763 | |
764 if((value && !pref->value.string) || | |
765 (!value && pref->value.string) || | |
13638 | 766 (value && pref->value.string && |
767 strcmp(pref->value.string, value))) { | |
10443 | 768 g_free(pref->value.string); |
769 pref->value.string = g_strdup(value); | |
770 do_callbacks(name, pref); | |
771 } | |
772 } else { | |
773 gaim_prefs_add_string(name, value); | |
774 } | |
775 } | |
776 | |
777 void | |
778 gaim_prefs_set_string_list(const char *name, GList *value) | |
779 { | |
780 struct gaim_pref *pref = find_pref(name); | |
781 if(pref) { | |
782 GList *tmp; | |
783 | |
784 if(pref->type != GAIM_PREF_STRING_LIST) { | |
785 gaim_debug_error("prefs", | |
786 "gaim_prefs_set_string_list: %s not a string list pref\n", | |
787 name); | |
788 return; | |
789 } | |
790 | |
14035 | 791 g_list_foreach(pref->value.stringlist, (GFunc)g_free, NULL); |
10443 | 792 g_list_free(pref->value.stringlist); |
793 pref->value.stringlist = NULL; | |
794 | |
795 for(tmp = value; tmp; tmp = tmp->next) | |
14035 | 796 pref->value.stringlist = g_list_prepend(pref->value.stringlist, |
10443 | 797 g_strdup(tmp->data)); |
14035 | 798 pref->value.stringlist = g_list_reverse(pref->value.stringlist); |
10443 | 799 |
800 do_callbacks(name, pref); | |
801 | |
802 } else { | |
803 gaim_prefs_add_string_list(name, value); | |
804 } | |
805 } | |
806 | |
807 gboolean | |
808 gaim_prefs_exists(const char *name) | |
809 { | |
810 struct gaim_pref *pref = find_pref(name); | |
811 | |
812 if (pref != NULL) | |
813 return TRUE; | |
814 | |
815 return FALSE; | |
816 } | |
817 | |
818 GaimPrefType | |
819 gaim_prefs_get_type(const char *name) | |
820 { | |
821 struct gaim_pref *pref = find_pref(name); | |
822 | |
823 if (pref == NULL) | |
824 return GAIM_PREF_NONE; | |
825 | |
826 return (pref->type); | |
827 } | |
828 | |
829 gboolean | |
830 gaim_prefs_get_bool(const char *name) | |
831 { | |
832 struct gaim_pref *pref = find_pref(name); | |
833 | |
834 if(!pref) { | |
835 gaim_debug_error("prefs", | |
836 "gaim_prefs_get_bool: Unknown pref %s\n", name); | |
837 return FALSE; | |
838 } else if(pref->type != GAIM_PREF_BOOLEAN) { | |
839 gaim_debug_error("prefs", | |
840 "gaim_prefs_get_bool: %s not a boolean pref\n", name); | |
841 return FALSE; | |
842 } | |
843 | |
844 return pref->value.boolean; | |
845 } | |
846 | |
847 int | |
848 gaim_prefs_get_int(const char *name) | |
849 { | |
850 struct gaim_pref *pref = find_pref(name); | |
851 | |
852 if(!pref) { | |
853 gaim_debug_error("prefs", | |
854 "gaim_prefs_get_int: Unknown pref %s\n", name); | |
855 return 0; | |
856 } else if(pref->type != GAIM_PREF_INT) { | |
857 gaim_debug_error("prefs", | |
858 "gaim_prefs_get_int: %s not an integer pref\n", name); | |
859 return 0; | |
860 } | |
861 | |
862 return pref->value.integer; | |
863 } | |
864 | |
865 const char * | |
866 gaim_prefs_get_string(const char *name) | |
867 { | |
868 struct gaim_pref *pref = find_pref(name); | |
869 | |
870 if(!pref) { | |
871 gaim_debug_error("prefs", | |
872 "gaim_prefs_get_string: Unknown pref %s\n", name); | |
873 return NULL; | |
874 } else if(pref->type != GAIM_PREF_STRING) { | |
875 gaim_debug_error("prefs", | |
876 "gaim_prefs_get_string: %s not a string pref\n", name); | |
877 return NULL; | |
878 } | |
879 | |
880 return pref->value.string; | |
881 } | |
882 | |
883 GList * | |
884 gaim_prefs_get_string_list(const char *name) | |
885 { | |
886 struct gaim_pref *pref = find_pref(name); | |
887 GList *ret = NULL, *tmp; | |
888 | |
889 if(!pref) { | |
890 gaim_debug_error("prefs", | |
891 "gaim_prefs_get_string_list: Unknown pref %s\n", name); | |
892 return NULL; | |
893 } else if(pref->type != GAIM_PREF_STRING_LIST) { | |
894 gaim_debug_error("prefs", | |
895 "gaim_prefs_get_string_list: %s not a string list pref\n", name); | |
896 return NULL; | |
897 } | |
898 | |
899 for(tmp = pref->value.stringlist; tmp; tmp = tmp->next) | |
14035 | 900 ret = g_list_prepend(ret, g_strdup(tmp->data)); |
901 ret = g_list_reverse(ret); | |
10443 | 902 |
903 return ret; | |
904 } | |
905 | |
906 void | |
907 gaim_prefs_rename(const char *oldname, const char *newname) | |
908 { | |
909 struct gaim_pref *oldpref, *newpref; | |
910 | |
911 oldpref = find_pref(oldname); | |
912 | |
913 /* it's already been renamed, call off the dogs */ | |
914 if(!oldpref) | |
915 return; | |
916 | |
13710
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
917 if (oldpref->first_child != NULL) /* can't rename parents */ |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
918 { |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
919 gaim_debug_error("prefs", "Unable to rename %s to %s: can't rename parents\n", oldname, newname); |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
920 return; |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
921 } |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
922 |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
923 |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
924 newpref = find_pref(newname); |
10443 | 925 |
13710
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
926 if (newpref == NULL) |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
927 { |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
928 gaim_debug_error("prefs", "Unable to rename %s to %s: new pref not created\n", oldname, newname); |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
929 return; |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
930 } |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
931 |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
932 if (oldpref->type != newpref->type) |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
933 { |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
934 gaim_debug_error("prefs", "Unable to rename %s to %s: differing types\n", oldname, newname); |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
935 return; |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
936 } |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
937 |
848c9685ecc7
[gaim-migrate @ 16114]
Richard Laager <rlaager@wiktel.com>
parents:
13709
diff
changeset
|
938 gaim_debug_info("prefs", "Renaming %s to %s\n", oldname, newname); |
10443 | 939 |
940 switch(oldpref->type) { | |
941 case GAIM_PREF_NONE: | |
942 break; | |
943 case GAIM_PREF_BOOLEAN: | |
944 gaim_prefs_set_bool(newname, oldpref->value.boolean); | |
945 break; | |
946 case GAIM_PREF_INT: | |
947 gaim_prefs_set_int(newname, oldpref->value.integer); | |
948 break; | |
949 case GAIM_PREF_STRING: | |
950 gaim_prefs_set_string(newname, oldpref->value.string); | |
951 break; | |
952 case GAIM_PREF_STRING_LIST: | |
953 gaim_prefs_set_string_list(newname, oldpref->value.stringlist); | |
954 break; | |
955 } | |
956 | |
957 remove_pref(oldpref); | |
958 } | |
959 | |
960 void | |
961 gaim_prefs_rename_boolean_toggle(const char *oldname, const char *newname) | |
962 { | |
963 struct gaim_pref *oldpref, *newpref; | |
964 | |
965 oldpref = find_pref(oldname); | |
966 | |
967 /* it's already been renamed, call off the cats */ | |
968 if(!oldpref) | |
969 return; | |
970 | |
13709
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
971 if (oldpref->type != GAIM_PREF_BOOLEAN) |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
972 { |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
973 gaim_debug_error("prefs", "Unable to rename %s to %s: old pref not a boolean\n", oldname, newname); |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
974 return; |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
975 } |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
976 |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
977 if (oldpref->first_child != NULL) /* can't rename parents */ |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
978 { |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
979 gaim_debug_error("prefs", "Unable to rename %s to %s: can't rename parents\n", oldname, newname); |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
980 return; |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
981 } |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
982 |
11736 | 983 |
13709
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
984 newpref = find_pref(newname); |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
985 |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
986 if (newpref == NULL) |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
987 { |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
988 gaim_debug_error("prefs", "Unable to rename %s to %s: new pref not created\n", oldname, newname); |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
989 return; |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
990 } |
10443 | 991 |
13709
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
992 if (oldpref->type != newpref->type) |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
993 { |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
994 gaim_debug_error("prefs", "Unable to rename %s to %s: differing types\n", oldname, newname); |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
995 return; |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
996 } |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
997 |
ff25f6d2b484
[gaim-migrate @ 16113]
Richard Laager <rlaager@wiktel.com>
parents:
13638
diff
changeset
|
998 gaim_debug_info("prefs", "Renaming and toggling %s to %s\n", oldname, newname); |
10443 | 999 gaim_prefs_set_bool(newname, !(oldpref->value.boolean)); |
1000 | |
1001 remove_pref(oldpref); | |
1002 } | |
1003 | |
1004 guint | |
1005 gaim_prefs_connect_callback(void *handle, const char *name, GaimPrefCallback func, gpointer data) | |
1006 { | |
1007 struct gaim_pref *pref; | |
1008 struct pref_cb *cb; | |
1009 static guint cb_id = 0; | |
1010 | |
1011 pref = find_pref(name); | |
1012 if (pref == NULL) | |
1013 return 0; | |
1014 | |
1015 cb = g_new0(struct pref_cb, 1); | |
1016 | |
1017 cb->func = func; | |
1018 cb->data = data; | |
1019 cb->id = ++cb_id; | |
1020 cb->handle = handle; | |
1021 | |
1022 pref->callbacks = g_slist_append(pref->callbacks, cb); | |
1023 | |
1024 return cb->id; | |
1025 } | |
1026 | |
1027 static gboolean | |
1028 disco_callback_helper(struct gaim_pref *pref, guint callback_id) | |
1029 { | |
1030 GSList *cbs; | |
1031 struct gaim_pref *child; | |
1032 | |
1033 if(!pref) | |
1034 return FALSE; | |
1035 | |
1036 for(cbs = pref->callbacks; cbs; cbs = cbs->next) { | |
1037 struct pref_cb *cb = cbs->data; | |
1038 if(cb->id == callback_id) { | |
11719
109ee3bfeac5
[gaim-migrate @ 14010]
Richard Laager <rlaager@wiktel.com>
parents:
11698
diff
changeset
|
1039 pref->callbacks = g_slist_delete_link(pref->callbacks, cbs); |
10443 | 1040 g_free(cb); |
1041 return TRUE; | |
1042 } | |
1043 } | |
1044 | |
1045 for(child = pref->first_child; child; child = child->sibling) { | |
1046 if(disco_callback_helper(child, callback_id)) | |
1047 return TRUE; | |
1048 } | |
1049 | |
1050 return FALSE; | |
1051 } | |
1052 | |
1053 void | |
1054 gaim_prefs_disconnect_callback(guint callback_id) | |
1055 { | |
1056 disco_callback_helper(&prefs, callback_id); | |
1057 } | |
1058 | |
1059 static void | |
1060 disco_callback_helper_handle(struct gaim_pref *pref, void *handle) | |
1061 { | |
1062 GSList *cbs; | |
1063 struct gaim_pref *child; | |
1064 | |
1065 if(!pref) | |
1066 return; | |
1067 | |
1068 cbs = pref->callbacks; | |
1069 while (cbs != NULL) { | |
1070 struct pref_cb *cb = cbs->data; | |
1071 if(cb->handle == handle) { | |
11719
109ee3bfeac5
[gaim-migrate @ 14010]
Richard Laager <rlaager@wiktel.com>
parents:
11698
diff
changeset
|
1072 pref->callbacks = g_slist_delete_link(pref->callbacks, cbs); |
10443 | 1073 g_free(cb); |
1074 cbs = pref->callbacks; | |
1075 } else | |
1076 cbs = cbs->next; | |
1077 } | |
1078 | |
1079 for(child = pref->first_child; child; child = child->sibling) | |
1080 disco_callback_helper_handle(child, handle); | |
1081 } | |
1082 | |
1083 void | |
1084 gaim_prefs_disconnect_by_handle(void *handle) | |
1085 { | |
1086 g_return_if_fail(handle != NULL); | |
1087 | |
1088 disco_callback_helper_handle(&prefs, handle); | |
1089 } | |
1090 | |
1091 void | |
1092 gaim_prefs_update_old() | |
1093 { | |
8900 | 1094 /* Remove some no-longer-used prefs */ |
9594 | 1095 gaim_prefs_remove("/core/away/auto_response/enabled"); |
1096 gaim_prefs_remove("/core/away/auto_response/idle_only"); | |
8948 | 1097 gaim_prefs_remove("/core/away/auto_response/in_active_conv"); |
1098 gaim_prefs_remove("/core/away/auto_response/sec_before_resend"); | |
9594 | 1099 gaim_prefs_remove("/core/away/auto_response"); |
11654 | 1100 gaim_prefs_remove("/core/away/default_message"); |
10353 | 1101 gaim_prefs_remove("/core/buddies/use_server_alias"); |
8942 | 1102 gaim_prefs_remove("/core/conversations/away_back_on_send"); |
8900 | 1103 gaim_prefs_remove("/core/conversations/send_urls_as_links"); |
8942 | 1104 gaim_prefs_remove("/core/conversations/im/show_login"); |
8998 | 1105 gaim_prefs_remove("/core/conversations/chat/show_join"); |
1106 gaim_prefs_remove("/core/conversations/chat/show_leave"); | |
9251 | 1107 gaim_prefs_remove("/core/conversations/combine_chat_im"); |
10389 | 1108 gaim_prefs_remove("/core/conversations/use_alias_for_title"); |
11698 | 1109 gaim_prefs_remove("/core/logging/log_signon_signoff"); |
1110 gaim_prefs_remove("/core/logging/log_idle_state"); | |
1111 gaim_prefs_remove("/core/logging/log_away_state"); | |
1112 gaim_prefs_remove("/core/logging/log_own_states"); | |
13040
b705e30efe61
[gaim-migrate @ 15399]
Richard Laager <rlaager@wiktel.com>
parents:
12822
diff
changeset
|
1113 gaim_prefs_remove("/core/status/scores/hidden"); |
11959 | 1114 gaim_prefs_remove("/plugins/core/autorecon/hide_connected_error"); |
1115 gaim_prefs_remove("/plugins/core/autorecon/hide_connecting_error"); | |
1116 gaim_prefs_remove("/plugins/core/autorecon/hide_reconnecting_dialog"); | |
1117 gaim_prefs_remove("/plugins/core/autorecon/restore_state"); | |
1118 gaim_prefs_remove("/plugins/core/autorecon"); | |
8900 | 1119 } |
10443 | 1120 |
1121 void * | |
1122 gaim_prefs_get_handle(void) | |
1123 { | |
1124 static int handle; | |
1125 | |
1126 return &handle; | |
1127 } | |
1128 | |
1129 void | |
1130 gaim_prefs_init(void) | |
1131 { | |
1132 void *handle = gaim_prefs_get_handle(); | |
1133 | |
1134 prefs_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); | |
1135 | |
1136 gaim_prefs_connect_callback(handle, "/", prefs_save_cb, NULL); | |
1137 | |
1138 gaim_prefs_add_none("/core"); | |
1139 gaim_prefs_add_none("/plugins"); | |
1140 gaim_prefs_add_none("/plugins/core"); | |
1141 gaim_prefs_add_none("/plugins/lopl"); | |
1142 gaim_prefs_add_none("/plugins/prpl"); | |
1143 | |
1144 /* Away */ | |
1145 gaim_prefs_add_none("/core/away"); | |
12573 | 1146 gaim_prefs_add_string("/core/away/idle_reporting", "system"); |
10443 | 1147 gaim_prefs_add_bool("/core/away/away_when_idle", TRUE); |
1148 gaim_prefs_add_int("/core/away/mins_before_away", 5); | |
1149 | |
1150 /* Away -> Auto-Reply */ | |
1151 if (!gaim_prefs_exists("/core/away/auto_response/enabled") || | |
12615
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1152 !gaim_prefs_exists("/core/away/auto_response/idle_only")) |
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1153 { |
10443 | 1154 gaim_prefs_add_string("/core/away/auto_reply", "awayidle"); |
12615
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1155 } |
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1156 else |
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1157 { |
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1158 if (!gaim_prefs_get_bool("/core/away/auto_response/enabled")) |
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1159 { |
10443 | 1160 gaim_prefs_add_string("/core/away/auto_reply", "never"); |
12615
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1161 } |
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1162 else |
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1163 { |
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1164 if (gaim_prefs_get_bool("/core/away/auto_response/idle_only")) |
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1165 { |
10443 | 1166 gaim_prefs_add_string("/core/away/auto_reply", "awayidle"); |
12615
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1167 } |
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1168 else |
e3ca84a8b551
[gaim-migrate @ 14951]
Richard Laager <rlaager@wiktel.com>
parents:
12599
diff
changeset
|
1169 { |
10443 | 1170 gaim_prefs_add_string("/core/away/auto_reply", "away"); |
1171 } | |
1172 } | |
1173 } | |
1174 | |
1175 /* Buddies */ | |
1176 gaim_prefs_add_none("/core/buddies"); | |
1177 | |
1178 /* Contact Priority Settings */ | |
1179 gaim_prefs_add_none("/core/contact"); | |
1180 gaim_prefs_add_bool("/core/contact/last_match", FALSE); | |
12164
281ab2ecc08c
[gaim-migrate @ 14465]
Richard Laager <rlaager@wiktel.com>
parents:
11959
diff
changeset
|
1181 gaim_prefs_remove("/core/contact/offline_score"); |
281ab2ecc08c
[gaim-migrate @ 14465]
Richard Laager <rlaager@wiktel.com>
parents:
11959
diff
changeset
|
1182 gaim_prefs_remove("/core/contact/away_score"); |
281ab2ecc08c
[gaim-migrate @ 14465]
Richard Laager <rlaager@wiktel.com>
parents:
11959
diff
changeset
|
1183 gaim_prefs_remove("/core/contact/idle_score"); |
10443 | 1184 } |
1185 | |
1186 void | |
1187 gaim_prefs_uninit() | |
1188 { | |
1189 if (save_timer != 0) | |
1190 { | |
1191 gaim_timeout_remove(save_timer); | |
1192 save_timer = 0; | |
1193 sync_prefs(); | |
1194 } | |
1195 | |
1196 gaim_prefs_disconnect_by_handle(gaim_prefs_get_handle()); | |
1197 } |