Mercurial > pidgin
annotate src/prefs.c @ 6629:bdc448cf4cb6
[gaim-migrate @ 7153]
Tim Ringenbach (marv_sf) writes:
" This patch makes sending colors in yahoo work. It also
makes a few changing to receiving them, and addresses
most of the problems with that patch (which I think
were all related to the fact it didn't do outgoing colors).
It now handles bold, italic, underline, font face, font
size, and font color in both directions. It disables
the background color button if the prpl is yahoo (in a
generic way), and farthermore strips out any <body>
tags that the user might try to type anyway (the yahoo
server purposely mangles them).
It also adds a line to g_strescape some debug messages
because I got tired them of changing the color of my
terminal.
I think I got all the bugs out. If you run with -d or
open the debug window, it will show you what both
conversion function returned, which should help track
down any problems."
committer: Tailor Script <tailor@pidgin.im>
| author | Luke Schierer <lschiere@pidgin.im> |
|---|---|
| date | Tue, 26 Aug 2003 01:34:51 +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 |