Mercurial > pidgin.yaz
annotate src/prefs.c @ 6546:e34907332e46
[gaim-migrate @ 7068]
I added translators to help->about. Bueno?
I also changed a few .po files minorly, and converting one or 3 to utf-8
from iso-8859-somethingotherthanone.
committer: Tailor Script <tailor@pidgin.im>
author | Mark Doliner <mark@kingant.net> |
---|---|
date | Thu, 21 Aug 2003 03:43:03 +0000 |
parents | 4bc050b1af34 |
children | 8c1b5dd87fbf |
rev | line source |
---|---|
1 | 1 /* |
2 * gaim | |
3 * | |
5440 | 4 * Copyright (C) 2003, Nathan Walp <faceprint@faceprint.com> |
1 | 5 * |
6 * This program is free software; you can redistribute it and/or modify | |
7 * it under the terms of the GNU General Public License as published by | |
8 * the Free Software Foundation; either version 2 of the License, or | |
9 * (at your option) any later version. | |
10 * | |
11 * This program is distributed in the hope that it will be useful, | |
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 * GNU General Public License for more details. | |
15 * | |
16 * You should have received a copy of the GNU General Public License | |
17 * along with this program; if not, write to the Free Software | |
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
19 * | |
20 */ | |
21 | |
349
b402a23f35df
[gaim-migrate @ 359]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
340
diff
changeset
|
22 #ifdef HAVE_CONFIG_H |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2074
diff
changeset
|
23 #include <config.h> |
349
b402a23f35df
[gaim-migrate @ 359]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
340
diff
changeset
|
24 #endif |
5440 | 25 |
1 | 26 #include <string.h> |
27 #include <stdio.h> | |
28 #include <stdlib.h> | |
5440 | 29 #include <sys/stat.h> |
30 #include <sys/types.h> | |
31 #include <glib.h> | |
6216 | 32 #include "internal.h" |
5440 | 33 #include "prefs.h" |
34 #include "debug.h" | |
35 #include "util.h" | |
3366 | 36 |
4026
a997156437b6
[gaim-migrate @ 4230]
Herman Bloggs <hermanator12002@yahoo.com>
parents:
4010
diff
changeset
|
37 #ifdef _WIN32 |
a997156437b6
[gaim-migrate @ 4230]
Herman Bloggs <hermanator12002@yahoo.com>
parents:
4010
diff
changeset
|
38 #include "win32dep.h" |
a997156437b6
[gaim-migrate @ 4230]
Herman Bloggs <hermanator12002@yahoo.com>
parents:
4010
diff
changeset
|
39 #endif |
a997156437b6
[gaim-migrate @ 4230]
Herman Bloggs <hermanator12002@yahoo.com>
parents:
4010
diff
changeset
|
40 |
5440 | 41 struct pref_cb { |
42 GaimPrefCallback func; | |
43 gpointer data; | |
44 guint id; | |
45 }; | |
46 | |
47 struct gaim_pref { | |
48 GaimPrefType type; | |
49 char *name; | |
50 union { | |
51 gpointer generic; | |
52 gboolean boolean; | |
53 int integer; | |
54 char *string; | |
5561 | 55 GList *stringlist; |
5440 | 56 } value; |
57 GSList *callbacks; | |
58 struct gaim_pref *parent; | |
59 struct gaim_pref *sibling; | |
60 struct gaim_pref *first_child; | |
61 }; | |
3366 | 62 |
5440 | 63 static GHashTable *prefs_hash = NULL; |
64 | |
65 static struct gaim_pref prefs = { GAIM_PREF_NONE, NULL, {NULL}, NULL, | |
66 NULL, NULL, NULL }; | |
67 | |
5534 | 68 static guint prefs_save_timer = 0; |
69 static gboolean prefs_is_loaded = FALSE; | |
70 | |
71 | |
72 static gboolean prefs_save_callback(gpointer who_cares) { | |
73 gaim_prefs_sync(); | |
74 prefs_save_timer = 0; | |
75 return FALSE; | |
76 } | |
77 | |
78 static void schedule_prefs_save() { | |
79 if(!prefs_save_timer) | |
80 prefs_save_timer = g_timeout_add(5000, prefs_save_callback, NULL); | |
81 } | |
82 | |
83 static void prefs_save_cb(const char *name, GaimPrefType type, gpointer val, | |
84 gpointer user_data) { | |
85 | |
86 if(!prefs_is_loaded) | |
87 return; | |
88 | |
89 gaim_debug(GAIM_DEBUG_MISC, "prefs", "%s changed, scheduling save.\n", name); | |
90 | |
91 schedule_prefs_save(); | |
92 } | |
93 | |
5440 | 94 void gaim_prefs_init() { |
95 prefs_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); | |
96 | |
5534 | 97 gaim_prefs_connect_callback("/", prefs_save_cb, NULL); |
98 | |
5529
e7747cae9710
[gaim-migrate @ 5929]
Christian Hammond <chipx86@chipx86.com>
parents:
5458
diff
changeset
|
99 gaim_prefs_add_none("/core"); |
5550
b18c2a37cc96
[gaim-migrate @ 5951]
Christian Hammond <chipx86@chipx86.com>
parents:
5547
diff
changeset
|
100 gaim_prefs_add_none("/plugins"); |
b18c2a37cc96
[gaim-migrate @ 5951]
Christian Hammond <chipx86@chipx86.com>
parents:
5547
diff
changeset
|
101 gaim_prefs_add_none("/plugins/core"); |
b18c2a37cc96
[gaim-migrate @ 5951]
Christian Hammond <chipx86@chipx86.com>
parents:
5547
diff
changeset
|
102 gaim_prefs_add_none("/plugins/lopl"); |
b18c2a37cc96
[gaim-migrate @ 5951]
Christian Hammond <chipx86@chipx86.com>
parents:
5547
diff
changeset
|
103 gaim_prefs_add_none("/plugins/prpl"); |
5529
e7747cae9710
[gaim-migrate @ 5929]
Christian Hammond <chipx86@chipx86.com>
parents:
5458
diff
changeset
|
104 |
5440 | 105 /* XXX: this is where you would want to put prefs declarations */ |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
106 |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
107 /* Away */ |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
108 gaim_prefs_add_none("/core/away"); |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
109 gaim_prefs_add_bool("/core/away/away_when_idle", TRUE); |
5550
b18c2a37cc96
[gaim-migrate @ 5951]
Christian Hammond <chipx86@chipx86.com>
parents:
5547
diff
changeset
|
110 gaim_prefs_add_int("/core/away/mins_before_away", 1); |
6216 | 111 /* XXX: internationalized string in prefs...evil */ |
112 gaim_prefs_add_string("/core/away/default_message", | |
113 _("Slightly less boring default")); | |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
114 |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
115 /* Away -> Auto Response */ |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
116 gaim_prefs_add_none("/core/away/auto_response"); |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
117 gaim_prefs_add_bool("/core/away/auto_response/enabled", TRUE); |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
118 gaim_prefs_add_bool("/core/away/auto_response/in_active_conv", TRUE); |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
119 gaim_prefs_add_bool("/core/away/auto_response/idle_only", FALSE); |
5550
b18c2a37cc96
[gaim-migrate @ 5951]
Christian Hammond <chipx86@chipx86.com>
parents:
5547
diff
changeset
|
120 gaim_prefs_add_int("/core/away/auto_response/sec_before_resend", 60); |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
121 |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
122 /* Buddies */ |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
123 gaim_prefs_add_none("/core/buddies"); |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
124 gaim_prefs_add_bool("/core/buddies/use_server_alias", TRUE); |
5440 | 125 } |
3366 | 126 |
5787
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
127 static char * |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
128 get_path_dirname(const char *name) |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
129 { |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
130 char *c, *str; |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
131 |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
132 str = g_strdup(name); |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
133 |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
134 if ((c = strrchr(str, '/')) != NULL) { |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
135 *c = '\0'; |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
136 |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
137 if (*str == '\0') { |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
138 g_free(str); |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
139 |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
140 str = g_strdup("/"); |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
141 } |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
142 } |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
143 else { |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
144 g_free(str); |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
145 |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
146 str = g_strdup("."); |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
147 } |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
148 |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
149 return str; |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
150 } |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
151 |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
152 static char * |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
153 get_path_basename(const char *name) |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
154 { |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
155 const char *c; |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
156 |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
157 if ((c = strrchr(name, '/')) != NULL) |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
158 return g_strdup(c + 1); |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
159 |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
160 return g_strdup(name); |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
161 } |
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
162 |
5440 | 163 static char *pref_full_name(struct gaim_pref *pref) { |
164 GString *name; | |
165 struct gaim_pref *parent; | |
166 if(!pref) | |
167 return NULL; | |
168 | |
169 if(pref == &prefs) | |
170 return g_strdup("/"); | |
171 | |
172 name = g_string_new(pref->name); | |
173 parent = pref->parent; | |
3366 | 174 |
5440 | 175 for(parent = pref->parent; parent && parent->name; parent = parent->parent) { |
176 name = g_string_prepend_c(name, '/'); | |
177 name = g_string_prepend(name, parent->name); | |
178 } | |
179 g_string_free(name, FALSE); | |
180 return name->str; | |
181 } | |
182 | |
183 static struct gaim_pref *find_pref(const char *name) | |
184 { | |
185 if(!name || name[0] != '/') { | |
186 return NULL; | |
187 } else if(name[1] == '\0') { | |
188 return &prefs; | |
189 } else { | |
190 return g_hash_table_lookup(prefs_hash, name); | |
191 } | |
192 } | |
193 | |
194 static struct gaim_pref *find_pref_parent(const char *name) | |
195 { | |
5787
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
196 char *parent_name = get_path_dirname(name); |
5440 | 197 struct gaim_pref *ret = &prefs; |
198 | |
199 if(strcmp(parent_name, "/")) { | |
200 ret = find_pref(parent_name); | |
201 } | |
1026 | 202 |
5440 | 203 g_free(parent_name); |
204 return ret; | |
205 } | |
206 | |
207 static void free_pref_value(struct gaim_pref *pref) { | |
208 switch(pref->type) { | |
209 case GAIM_PREF_BOOLEAN: | |
210 pref->value.boolean = FALSE; | |
211 case GAIM_PREF_INT: | |
212 pref->value.integer = 0; | |
213 break; | |
214 case GAIM_PREF_STRING: | |
215 g_free(pref->value.string); | |
216 pref->value.string = NULL; | |
217 break; | |
5561 | 218 case GAIM_PREF_STRING_LIST: |
219 { | |
220 GList *tmp; | |
221 for(tmp = pref->value.stringlist; tmp; tmp = tmp->next) | |
222 g_free(tmp->data); | |
223 | |
224 g_list_free(pref->value.stringlist); | |
225 } break; | |
5440 | 226 case GAIM_PREF_NONE: |
227 break; | |
228 } | |
229 } | |
230 | |
231 static struct gaim_pref *add_pref(GaimPrefType type, const char *name) { | |
232 struct gaim_pref *parent; | |
233 struct gaim_pref *me; | |
234 struct gaim_pref *sibling; | |
5458
156e65ca910f
[gaim-migrate @ 5846]
Christian Hammond <chipx86@chipx86.com>
parents:
5451
diff
changeset
|
235 char *my_name; |
5440 | 236 |
237 parent = find_pref_parent(name); | |
238 | |
239 if(!parent) | |
240 return NULL; | |
1525
ba8e6e211af5
[gaim-migrate @ 1535]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1455
diff
changeset
|
241 |
5787
2adc29c88a45
[gaim-migrate @ 6212]
Christian Hammond <chipx86@chipx86.com>
parents:
5684
diff
changeset
|
242 my_name = get_path_basename(name); |
5458
156e65ca910f
[gaim-migrate @ 5846]
Christian Hammond <chipx86@chipx86.com>
parents:
5451
diff
changeset
|
243 |
5440 | 244 for(sibling = parent->first_child; sibling; sibling = sibling->sibling) { |
245 if(!strcmp(sibling->name, my_name)) { | |
246 g_free(my_name); | |
247 return NULL; | |
248 } | |
249 } | |
250 | |
251 me = g_new0(struct gaim_pref, 1); | |
252 me->type = type; | |
253 me->name = my_name; | |
254 | |
255 me->parent = parent; | |
256 if(parent->first_child) { | |
257 /* blatant abuse of a for loop */ | |
258 for(sibling = parent->first_child; sibling->sibling; | |
259 sibling = sibling->sibling); | |
260 sibling->sibling = me; | |
261 } else { | |
262 parent->first_child = me; | |
263 } | |
264 | |
265 g_hash_table_insert(prefs_hash, g_strdup(name), (gpointer)me); | |
266 | |
267 return me; | |
268 } | |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
269 |
5440 | 270 void gaim_prefs_add_none(const char *name) { |
271 add_pref(GAIM_PREF_NONE, name); | |
272 } | |
273 | |
274 void gaim_prefs_add_bool(const char *name, gboolean value) { | |
275 struct gaim_pref *pref = add_pref(GAIM_PREF_BOOLEAN, name); | |
276 | |
277 if(!pref) | |
278 return; | |
279 | |
280 pref->value.boolean = value; | |
281 } | |
3630 | 282 |
5440 | 283 void gaim_prefs_add_int(const char *name, int value) { |
284 struct gaim_pref *pref = add_pref(GAIM_PREF_INT, name); | |
285 | |
286 if(!pref) | |
287 return; | |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
288 |
5440 | 289 pref->value.integer = value; |
290 } | |
291 | |
292 void gaim_prefs_add_string(const char *name, const char *value) { | |
293 struct gaim_pref *pref = add_pref(GAIM_PREF_STRING, name); | |
294 | |
295 if(!pref) | |
296 return; | |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
297 |
5440 | 298 pref->value.string = g_strdup(value); |
299 } | |
300 | |
5561 | 301 void gaim_prefs_add_string_list(const char *name, GList *value) { |
302 struct gaim_pref *pref = add_pref(GAIM_PREF_STRING_LIST, name); | |
303 GList *tmp; | |
304 | |
305 if(!pref) | |
306 return; | |
307 | |
308 for(tmp = value; tmp; tmp = tmp->next) | |
309 pref->value.stringlist = g_list_append(pref->value.stringlist, | |
310 g_strdup(tmp->data)); | |
311 } | |
312 | |
5440 | 313 void remove_pref(struct gaim_pref *pref) { |
314 char *name; | |
315 | |
316 if(!pref || pref == &prefs) | |
317 return; | |
318 | |
319 if(pref->parent->first_child == pref) { | |
320 pref->parent->first_child = pref->sibling; | |
321 } else { | |
322 struct gaim_pref *sib = pref->parent->first_child; | |
323 while(sib->sibling != pref) | |
324 sib = sib->sibling; | |
325 sib->sibling = pref->sibling; | |
326 } | |
327 | |
328 name = pref_full_name(pref); | |
329 | |
330 g_hash_table_remove(prefs_hash, name); | |
331 g_free(name); | |
332 | |
333 free_pref_value(pref); | |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
334 |
5440 | 335 g_slist_free(pref->callbacks); |
336 g_free(pref->name); | |
337 g_free(pref); | |
338 } | |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
339 |
5440 | 340 void gaim_prefs_remove(const char *name) { |
341 struct gaim_pref *pref = find_pref(name); | |
342 struct gaim_pref *child, *child2; | |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
343 |
5440 | 344 if(!pref) |
345 return; | |
346 child = pref->first_child; | |
347 while(child) { | |
348 child2 = child; | |
349 child = child->sibling; | |
350 remove_pref(child2); | |
351 } | |
352 | |
353 remove_pref(pref); | |
354 } | |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
355 |
5440 | 356 void gaim_prefs_destroy() { |
357 gaim_prefs_remove("/"); | |
358 } | |
359 | |
360 static void do_callbacks(const char* name, struct gaim_pref *pref) { | |
361 GSList *cbs; | |
362 struct gaim_pref *cb_pref; | |
363 for(cb_pref = pref; cb_pref; cb_pref = cb_pref->parent) { | |
364 for(cbs = cb_pref->callbacks; cbs; cbs = cbs->next) { | |
365 struct pref_cb *cb = cbs->data; | |
366 cb->func(name, pref->type, pref->value.generic, cb->data); | |
4215 | 367 } |
368 } | |
1525
ba8e6e211af5
[gaim-migrate @ 1535]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1455
diff
changeset
|
369 } |
ba8e6e211af5
[gaim-migrate @ 1535]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1455
diff
changeset
|
370 |
5684 | 371 void gaim_prefs_trigger_callback(const char *name) { |
372 struct gaim_pref *pref = find_pref(name); | |
373 | |
5814 | 374 if(!pref) { |
375 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
376 "gaim_prefs_trigger_callback: Unknown pref %s\n", name); | |
377 return; | |
378 } | |
379 | |
5684 | 380 do_callbacks(name, pref); |
381 } | |
382 | |
5440 | 383 void gaim_prefs_set_generic(const char *name, gpointer value) { |
384 struct gaim_pref *pref = find_pref(name); | |
3366 | 385 |
5814 | 386 if(!pref) { |
387 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
388 "gaim_prefs_set_generic: Unknown pref %s\n", name); | |
389 return; | |
390 } | |
3500 | 391 |
5440 | 392 pref->value.generic = value; |
393 do_callbacks(name, pref); | |
3366 | 394 } |
395 | |
5440 | 396 void gaim_prefs_set_bool(const char *name, gboolean value) { |
397 struct gaim_pref *pref = find_pref(name); | |
4288 | 398 |
5533 | 399 if(pref) { |
5814 | 400 if(pref->type != GAIM_PREF_BOOLEAN) { |
401 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
402 "gaim_prefs_set_bool: %s not a boolean pref\n", name); | |
403 return; | |
404 } | |
4325 | 405 |
5533 | 406 if(pref->value.boolean != value) { |
407 pref->value.boolean = value; | |
408 do_callbacks(name, pref); | |
409 } | |
410 } else { | |
411 gaim_prefs_add_bool(name, value); | |
4288 | 412 } |
4324 | 413 } |
4325 | 414 |
5440 | 415 void gaim_prefs_set_int(const char *name, int value) { |
416 struct gaim_pref *pref = find_pref(name); | |
4325 | 417 |
5533 | 418 if(pref) { |
5814 | 419 if(pref->type != GAIM_PREF_INT) { |
420 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
421 "gaim_prefs_set_int: %s not an integer pref\n", name); | |
422 return; | |
423 } | |
4325 | 424 |
5533 | 425 if(pref->value.integer != value) { |
426 pref->value.integer = value; | |
427 do_callbacks(name, pref); | |
428 } | |
429 } else { | |
430 gaim_prefs_add_int(name, value); | |
5440 | 431 } |
4326 | 432 } |
433 | |
5451 | 434 void gaim_prefs_set_string(const char *name, const char *value) { |
5440 | 435 struct gaim_pref *pref = find_pref(name); |
4325 | 436 |
5533 | 437 if(pref) { |
5814 | 438 if(pref->type != GAIM_PREF_STRING) { |
439 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
440 "gaim_prefs_set_string: %s not a string pref\n", name); | |
441 return; | |
442 } | |
4325 | 443 |
6295 | 444 if((value && !pref->value.string) || |
445 (!value && pref->value.string) || | |
446 strcmp(pref->value.string, value)) { | |
5533 | 447 g_free(pref->value.string); |
448 pref->value.string = g_strdup(value); | |
449 do_callbacks(name, pref); | |
450 } | |
451 } else { | |
452 gaim_prefs_add_string(name, value); | |
4325 | 453 } |
454 } | |
455 | |
5561 | 456 void gaim_prefs_set_string_list(const char *name, GList *value) { |
457 struct gaim_pref *pref = find_pref(name); | |
458 if(pref) { | |
459 GList *tmp; | |
5814 | 460 |
461 if(pref->type != GAIM_PREF_STRING_LIST) { | |
462 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
463 "gaim_prefs_set_string_list: %s not a string list pref\n", | |
464 name); | |
465 return; | |
466 } | |
467 | |
5561 | 468 for(tmp = pref->value.stringlist; tmp; tmp = tmp->next) |
469 g_free(tmp->data); | |
470 | |
471 g_list_free(pref->value.stringlist); | |
472 pref->value.stringlist = NULL; | |
473 | |
474 for(tmp = value; tmp; tmp = tmp->next) | |
475 pref->value.stringlist = g_list_append(pref->value.stringlist, | |
476 g_strdup(tmp->data)); | |
477 | |
5986
96e0ac28d933
[gaim-migrate @ 6434]
Christian Hammond <chipx86@chipx86.com>
parents:
5949
diff
changeset
|
478 do_callbacks(name, pref); |
96e0ac28d933
[gaim-migrate @ 6434]
Christian Hammond <chipx86@chipx86.com>
parents:
5949
diff
changeset
|
479 |
5561 | 480 } else { |
481 gaim_prefs_add_string_list(name, value); | |
482 } | |
483 } | |
484 | |
5440 | 485 gpointer gaim_prefs_get_generic(const char *name) { |
486 struct gaim_pref *pref = find_pref(name); | |
4325 | 487 |
5814 | 488 if(!pref) { |
489 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
490 "gaim_prefs_get_generic: Unknown pref %s\n", name); | |
491 return NULL; | |
492 } | |
4288 | 493 |
5440 | 494 return pref->value.generic; |
4288 | 495 } |
496 | |
6538 | 497 GaimPrefType gaim_prefs_get_type(const char *name) { |
498 struct gaim_pref *pref = find_pref(name); | |
499 | |
500 if (pref == NULL) | |
501 return GAIM_PREF_NONE; | |
502 | |
503 return (pref->type); | |
504 } | |
505 | |
5440 | 506 gboolean gaim_prefs_get_bool(const char *name) { |
507 struct gaim_pref *pref = find_pref(name); | |
3427 | 508 |
5814 | 509 if(!pref) { |
510 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
511 "gaim_prefs_get_bool: Unknown pref %s\n", name); | |
512 return FALSE; | |
513 } else if(pref->type != GAIM_PREF_BOOLEAN) { | |
514 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
515 "gaim_prefs_get_bool: %s not a boolean pref\n", name); | |
516 return FALSE; | |
517 } | |
3472 | 518 |
5440 | 519 return pref->value.boolean; |
3366 | 520 } |
521 | |
5440 | 522 int gaim_prefs_get_int(const char *name) { |
523 struct gaim_pref *pref = find_pref(name); | |
3500 | 524 |
5814 | 525 if(!pref) { |
526 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
527 "gaim_prefs_get_int: Unknown pref %s\n", name); | |
528 return 0; | |
529 } else if(pref->type != GAIM_PREF_INT) { | |
530 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
531 "gaim_prefs_get_int: %s not an integer pref\n", name); | |
532 return 0; | |
533 } | |
3366 | 534 |
5440 | 535 return pref->value.integer; |
3366 | 536 } |
537 | |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
538 const char *gaim_prefs_get_string(const char *name) { |
5440 | 539 struct gaim_pref *pref = find_pref(name); |
3366 | 540 |
5814 | 541 if(!pref) { |
542 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
543 "gaim_prefs_get_string: Unknown pref %s\n", name); | |
544 return NULL; | |
545 } else if(pref->type != GAIM_PREF_STRING) { | |
546 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
547 "gaim_prefs_get_string: %s not a string pref\n", name); | |
548 return NULL; | |
549 } | |
4469
d76095396a0e
[gaim-migrate @ 4744]
Christian Hammond <chipx86@chipx86.com>
parents:
4461
diff
changeset
|
550 |
5440 | 551 return pref->value.string; |
4469
d76095396a0e
[gaim-migrate @ 4744]
Christian Hammond <chipx86@chipx86.com>
parents:
4461
diff
changeset
|
552 } |
d76095396a0e
[gaim-migrate @ 4744]
Christian Hammond <chipx86@chipx86.com>
parents:
4461
diff
changeset
|
553 |
5561 | 554 GList *gaim_prefs_get_string_list(const char *name) { |
555 struct gaim_pref *pref = find_pref(name); | |
556 GList *ret = NULL, *tmp; | |
557 | |
5814 | 558 if(!pref) { |
559 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
560 "gaim_prefs_get_string_list: Unknown pref %s\n", name); | |
561 return NULL; | |
562 } else if(pref->type != GAIM_PREF_STRING_LIST) { | |
563 gaim_debug(GAIM_DEBUG_ERROR, "prefs", | |
564 "gaim_prefs_get_string_list: %s not a string list pref\n", name); | |
565 return NULL; | |
566 } | |
5561 | 567 |
568 for(tmp = pref->value.stringlist; tmp; tmp = tmp->next) | |
569 ret = g_list_append(ret, g_strdup(tmp->data)); | |
570 | |
571 return ret; | |
572 } | |
573 | |
5440 | 574 guint gaim_prefs_connect_callback(const char *name, GaimPrefCallback func, gpointer data) |
575 { | |
576 struct gaim_pref *pref = find_pref(name); | |
577 struct pref_cb *cb; | |
578 static guint cb_id = 0; | |
3366 | 579 |
5440 | 580 if(!pref) |
581 return 0; | |
3366 | 582 |
5440 | 583 cb = g_new0(struct pref_cb, 1); |
1881
a02584b98823
[gaim-migrate @ 1891]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1840
diff
changeset
|
584 |
5440 | 585 cb->func = func; |
586 cb->data = data; | |
587 cb->id = ++cb_id; | |
4991 | 588 |
5440 | 589 pref->callbacks = g_slist_append(pref->callbacks, cb); |
3366 | 590 |
5440 | 591 return cb->id; |
3366 | 592 } |
593 | |
5440 | 594 gboolean disco_callback_helper(struct gaim_pref *pref, guint callback_id) { |
595 GSList *cbs; | |
596 struct gaim_pref *child; | |
2254 | 597 |
5440 | 598 if(!pref) |
599 return FALSE; | |
1881
a02584b98823
[gaim-migrate @ 1891]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1840
diff
changeset
|
600 |
5440 | 601 for(cbs = pref->callbacks; cbs; cbs = cbs->next) { |
602 struct pref_cb *cb = cbs->data; | |
603 if(cb->id == callback_id) { | |
604 pref->callbacks = g_slist_remove(pref->callbacks, cb); | |
605 g_free(cb); | |
606 return TRUE; | |
4428 | 607 } |
608 } | |
609 | |
5440 | 610 for(child = pref->first_child; child; child = child->sibling) { |
611 if(disco_callback_helper(child, callback_id)) | |
612 return TRUE; | |
4428 | 613 } |
4451
ce5b64fac95d
[gaim-migrate @ 4726]
Herman Bloggs <hermanator12002@yahoo.com>
parents:
4449
diff
changeset
|
614 |
5440 | 615 return FALSE; |
1757
3dfe4aefd366
[gaim-migrate @ 1767]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1755
diff
changeset
|
616 } |
3dfe4aefd366
[gaim-migrate @ 1767]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1755
diff
changeset
|
617 |
5440 | 618 void gaim_prefs_disconnect_callback(guint callback_id) { |
619 disco_callback_helper(&prefs, callback_id); | |
2262
9c8f353331e7
[gaim-migrate @ 2272]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2254
diff
changeset
|
620 } |
9c8f353331e7
[gaim-migrate @ 2272]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2254
diff
changeset
|
621 |
5440 | 622 static void gaim_prefs_write(FILE *f, struct gaim_pref *pref, int depth) { |
623 struct gaim_pref *tmp; | |
624 char *esc; | |
625 int i; | |
3500 | 626 |
5440 | 627 if(!pref) { |
628 pref = &prefs; | |
3551 | 629 |
5440 | 630 fprintf(f, "<?xml version='1.0' encoding='UTF-8' ?>\n"); |
631 fprintf(f, "<pref name='/'"); | |
632 } else { | |
633 for(i=0; i<depth; i++) | |
634 fprintf(f, "\t"); | |
635 esc = g_markup_escape_text(pref->name, -1); | |
636 fprintf(f, "<pref name='%s'", esc); | |
637 g_free(esc); | |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
638 } |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
639 |
5440 | 640 switch(pref->type) { |
641 case GAIM_PREF_NONE: | |
642 break; | |
643 case GAIM_PREF_BOOLEAN: | |
644 fprintf(f, " type='bool' value='%d'", pref->value.boolean); | |
645 break; | |
646 case GAIM_PREF_INT: | |
647 fprintf(f, " type='int' value='%d'", pref->value.integer); | |
648 break; | |
649 case GAIM_PREF_STRING: | |
650 esc = g_markup_escape_text(pref->value.string, -1); | |
651 fprintf(f, " type='string' value='%s'", esc); | |
652 g_free(esc); | |
653 break; | |
5561 | 654 case GAIM_PREF_STRING_LIST: |
655 fprintf(f, " type='stringlist'"); | |
656 break; | |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
657 } |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
658 |
5561 | 659 if(pref->first_child || pref->type == GAIM_PREF_STRING_LIST) { |
5440 | 660 fprintf(f, ">\n"); |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
661 |
5440 | 662 for(tmp = pref->first_child; tmp; tmp = tmp->sibling) |
663 gaim_prefs_write(f, tmp, depth+1); | |
5561 | 664 |
665 if(pref->type == GAIM_PREF_STRING_LIST) { | |
666 GList *tmp2; | |
667 for(tmp2 = pref->value.stringlist; tmp2; tmp2 = tmp2->next) { | |
668 for(i=0; i<depth+1; i++) | |
669 fprintf(f, "\t"); | |
670 esc = g_markup_escape_text(tmp2->data, -1); | |
671 fprintf(f, "<item value='%s' />\n", esc); | |
672 g_free(esc); | |
673 } | |
674 } | |
675 | |
5440 | 676 for(i=0; i<depth; i++) |
677 fprintf(f, "\t"); | |
678 fprintf(f, "</pref>\n"); | |
679 } else { | |
680 fprintf(f, " />\n"); | |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
681 } |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
682 } |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5105
diff
changeset
|
683 |
5440 | 684 void gaim_prefs_sync() { |
685 FILE *file; | |
686 const char *user_dir = gaim_user_dir(); | |
687 char *filename; | |
688 char *filename_real; | |
3551 | 689 |
5534 | 690 if(!prefs_is_loaded) { |
691 gaim_debug(GAIM_DEBUG_WARNING, "prefs", "prefs saved before loading! scheduling save.\n"); | |
692 schedule_prefs_save(); /* schedule a save for after we read in */ | |
693 return; | |
694 } | |
695 | |
5440 | 696 if(!user_dir) |
697 return; | |
3551 | 698 |
5534 | 699 gaim_debug(GAIM_DEBUG_INFO, "prefs", "writing prefs out to disk.\n"); |
700 | |
5440 | 701 file = fopen(user_dir, "r"); |
702 if(!file) | |
703 mkdir(user_dir, S_IRUSR | S_IWUSR | S_IXUSR); | |
704 else | |
705 fclose(file); | |
3551 | 706 |
5440 | 707 filename = g_build_filename(user_dir, "prefs.xml.save", NULL); |
3551 | 708 |
5440 | 709 if((file = fopen(filename, "w"))) { |
710 gaim_prefs_write(file, NULL, 0); | |
711 fclose(file); | |
712 chmod(filename, S_IRUSR | S_IWUSR); | |
713 } else { | |
714 gaim_debug(GAIM_DEBUG_ERROR, "prefs", "Unable to write %s\n", | |
715 filename); | |
716 } | |
3551 | 717 |
5440 | 718 filename_real = g_build_filename(user_dir, "prefs.xml", NULL); |
719 if(rename(filename, filename_real) < 0) | |
720 gaim_debug(GAIM_DEBUG_ERROR, "prefs", "Error renaming %s to %s\n", | |
721 filename, filename_real); | |
3551 | 722 |
5440 | 723 g_free(filename); |
724 g_free(filename_real); | |
3551 | 725 } |
726 | |
5440 | 727 static GList *prefs_stack = NULL; |
873
789df4b47508
[gaim-migrate @ 883]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
864
diff
changeset
|
728 |
5440 | 729 static void prefs_start_element_handler (GMarkupParseContext *context, |
730 const gchar *element_name, | |
731 const gchar **attribute_names, | |
732 const gchar **attribute_values, | |
733 gpointer user_data, | |
734 GError **error) { | |
735 GaimPrefType pref_type = GAIM_PREF_NONE; | |
736 int i; | |
737 const char *pref_name = NULL, *pref_value = NULL; | |
738 GString *pref_name_full; | |
739 GList *tmp; | |
3366 | 740 |
5561 | 741 if(strcmp(element_name, "pref") && strcmp(element_name, "item")) |
5440 | 742 return; |
3500 | 743 |
5440 | 744 for(i = 0; attribute_names[i]; i++) { |
745 if(!strcmp(attribute_names[i], "name")) { | |
746 pref_name = attribute_values[i]; | |
747 } else if(!strcmp(attribute_names[i], "type")) { | |
748 if(!strcmp(attribute_values[i], "bool")) | |
749 pref_type = GAIM_PREF_BOOLEAN; | |
750 else if(!strcmp(attribute_values[i], "int")) | |
751 pref_type = GAIM_PREF_INT; | |
752 else if(!strcmp(attribute_values[i], "string")) | |
753 pref_type = GAIM_PREF_STRING; | |
5561 | 754 else if(!strcmp(attribute_values[i], "stringlist")) |
755 pref_type = GAIM_PREF_STRING_LIST; | |
5440 | 756 else |
757 return; | |
758 } else if(!strcmp(attribute_names[i], "value")) { | |
759 pref_value = attribute_values[i]; | |
760 } | |
761 } | |
873
789df4b47508
[gaim-migrate @ 883]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
864
diff
changeset
|
762 |
5561 | 763 if(!strcmp(element_name, "item")) { |
5838 | 764 struct gaim_pref *pref; |
765 | |
766 pref_name_full = g_string_new(""); | |
767 | |
768 for(tmp = prefs_stack; tmp; tmp = tmp->next) { | |
769 pref_name_full = g_string_prepend(pref_name_full, tmp->data); | |
770 pref_name_full = g_string_prepend_c(pref_name_full, '/'); | |
771 } | |
772 | |
773 pref = find_pref(pref_name_full->str); | |
774 | |
5561 | 775 if(pref) { |
776 pref->value.stringlist = g_list_append(pref->value.stringlist, | |
777 g_strdup(pref_value)); | |
778 } | |
5838 | 779 } else { |
780 if(!pref_name || !strcmp(pref_name, "/")) | |
781 return; | |
652
4d3285caa191
[gaim-migrate @ 662]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
619
diff
changeset
|
782 |
5838 | 783 pref_name_full = g_string_new(pref_name); |
652
4d3285caa191
[gaim-migrate @ 662]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
619
diff
changeset
|
784 |
5838 | 785 for(tmp = prefs_stack; tmp; tmp = tmp->next) { |
786 pref_name_full = g_string_prepend_c(pref_name_full, '/'); | |
787 pref_name_full = g_string_prepend(pref_name_full, tmp->data); | |
788 } | |
789 | |
5440 | 790 pref_name_full = g_string_prepend_c(pref_name_full, '/'); |
1253
8342d3aab1f1
[gaim-migrate @ 1263]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1250
diff
changeset
|
791 |
5838 | 792 switch(pref_type) { |
793 case GAIM_PREF_NONE: | |
794 break; | |
795 case GAIM_PREF_BOOLEAN: | |
796 gaim_prefs_set_bool(pref_name_full->str, atoi(pref_value)); | |
797 break; | |
798 case GAIM_PREF_INT: | |
799 gaim_prefs_set_int(pref_name_full->str, atoi(pref_value)); | |
800 break; | |
801 case GAIM_PREF_STRING: | |
802 gaim_prefs_set_string(pref_name_full->str, pref_value); | |
803 break; | |
804 case GAIM_PREF_STRING_LIST: | |
805 gaim_prefs_set_string_list(pref_name_full->str, NULL); | |
806 break; | |
807 } | |
808 prefs_stack = g_list_prepend(prefs_stack, g_strdup(pref_name)); | |
809 g_string_free(pref_name_full, TRUE); | |
5440 | 810 } |
1170 | 811 } |
812 | |
5440 | 813 static void prefs_end_element_handler(GMarkupParseContext *context, |
814 const gchar *element_name, gpointer user_data, GError **error) { | |
5940 | 815 if(prefs_stack && !strcmp(element_name, "pref")) { |
816 g_free(prefs_stack->data); | |
5440 | 817 prefs_stack = g_list_delete_link(prefs_stack, prefs_stack); |
818 } | |
1170 | 819 } |
820 | |
5440 | 821 static GMarkupParser prefs_parser = { |
822 prefs_start_element_handler, | |
823 prefs_end_element_handler, | |
824 NULL, | |
825 NULL, | |
826 NULL | |
827 }; | |
1170 | 828 |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
829 gboolean gaim_prefs_load() { |
5440 | 830 gchar *filename = g_build_filename(gaim_user_dir(), "prefs.xml", NULL); |
831 gchar *contents = NULL; | |
832 gsize length; | |
833 GMarkupParseContext *context; | |
834 GError *error = NULL; | |
5314
1f901484599d
[gaim-migrate @ 5686]
Christian Hammond <chipx86@chipx86.com>
parents:
5297
diff
changeset
|
835 |
5534 | 836 |
837 if(!filename) { | |
838 prefs_is_loaded = TRUE; | |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
839 return FALSE; |
5534 | 840 } |
5440 | 841 |
842 gaim_debug(GAIM_DEBUG_INFO, "prefs", "Reading %s\n", filename); | |
5314
1f901484599d
[gaim-migrate @ 5686]
Christian Hammond <chipx86@chipx86.com>
parents:
5297
diff
changeset
|
843 |
5440 | 844 if(!g_file_get_contents(filename, &contents, &length, &error)) { |
845 gaim_debug(GAIM_DEBUG_ERROR, "prefs", "Error reading prefs: %s\n", | |
846 error->message); | |
847 g_error_free(error); | |
6040 | 848 g_free(filename); |
5534 | 849 prefs_is_loaded = TRUE; |
6040 | 850 |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
851 return FALSE; |
1170 | 852 } |
853 | |
5440 | 854 context = g_markup_parse_context_new(&prefs_parser, 0, NULL, NULL); |
855 | |
856 if(!g_markup_parse_context_parse(context, contents, length, NULL)) { | |
857 g_markup_parse_context_free(context); | |
858 g_free(contents); | |
6040 | 859 g_free(filename); |
5534 | 860 prefs_is_loaded = TRUE; |
6040 | 861 |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
862 return FALSE; |
5440 | 863 } |
864 | |
865 if(!g_markup_parse_context_end_parse(context, NULL)) { | |
866 gaim_debug(GAIM_DEBUG_ERROR, "prefs", "Error parsing %s\n", filename); | |
867 g_markup_parse_context_free(context); | |
868 g_free(contents); | |
6040 | 869 g_free(filename); |
5534 | 870 prefs_is_loaded = TRUE; |
6040 | 871 |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
872 return FALSE; |
5440 | 873 } |
874 | |
6040 | 875 gaim_debug(GAIM_DEBUG_INFO, "prefs", "Finished reading %s\n", filename); |
5440 | 876 g_markup_parse_context_free(context); |
877 g_free(contents); | |
878 g_free(filename); | |
5534 | 879 prefs_is_loaded = TRUE; |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
880 |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5539
diff
changeset
|
881 return TRUE; |
1006
0a4d0ed65e17
[gaim-migrate @ 1016]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1002
diff
changeset
|
882 } |
0a4d0ed65e17
[gaim-migrate @ 1016]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1002
diff
changeset
|
883 |