Mercurial > pidgin
annotate src/blist.c @ 6179:16e384bb7fbf
[gaim-migrate @ 6664]
Core/UI split the core initialization and shutdown. I think I got all the
bugs worked out. It's looking nice and stable here, but if it causes CVS to
go to hell for everyone.. er, try to fix it or let me know :) I don't have
this in patch form.
committer: Tailor Script <tailor@pidgin.im>
author | Christian Hammond <chipx86@chipx86.com> |
---|---|
date | Thu, 17 Jul 2003 10:35:43 +0000 |
parents | de49cfd8fd59 |
children | 9083f92e0d58 |
rev | line source |
---|---|
5228 | 1 /* |
2 * gaim | |
3 * | |
4 * Copyright (C) 2003, Sean Egan <sean.egan@binghamton.edu> | |
5 * Copyright (C) 1998-1999, Mark Spencer <markster@marko.net> | |
6 * | |
7 * This program is free software; you can redistribute it and/or modify | |
8 * it under the terms of the GNU General Public License as published by | |
9 * the Free Software Foundation; either version 2 of the License, or | |
10 * (at your option) any later version. | |
11 * | |
12 * This program is distributed in the hope that it will be useful, | |
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 * GNU General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU General Public License | |
18 * along with this program; if not, write to the Free Software | |
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
20 * | |
21 */ | |
5872
059d95c67cda
[gaim-migrate @ 6304]
Christian Hammond <chipx86@chipx86.com>
parents:
5855
diff
changeset
|
22 #include "internal.h" |
5228 | 23 #include "blist.h" |
5872
059d95c67cda
[gaim-migrate @ 6304]
Christian Hammond <chipx86@chipx86.com>
parents:
5855
diff
changeset
|
24 #include "conversation.h" |
059d95c67cda
[gaim-migrate @ 6304]
Christian Hammond <chipx86@chipx86.com>
parents:
5855
diff
changeset
|
25 #include "debug.h" |
6034 | 26 #include "multi.h" |
5436
ad445074d239
[gaim-migrate @ 5818]
Christian Hammond <chipx86@chipx86.com>
parents:
5435
diff
changeset
|
27 #include "notify.h" |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
28 #include "prefs.h" |
5872
059d95c67cda
[gaim-migrate @ 6304]
Christian Hammond <chipx86@chipx86.com>
parents:
5855
diff
changeset
|
29 #include "privacy.h" |
059d95c67cda
[gaim-migrate @ 6304]
Christian Hammond <chipx86@chipx86.com>
parents:
5855
diff
changeset
|
30 #include "prpl.h" |
059d95c67cda
[gaim-migrate @ 6304]
Christian Hammond <chipx86@chipx86.com>
parents:
5855
diff
changeset
|
31 #include "server.h" |
059d95c67cda
[gaim-migrate @ 6304]
Christian Hammond <chipx86@chipx86.com>
parents:
5855
diff
changeset
|
32 #include "util.h" |
5228 | 33 |
34 #define PATHSIZE 1024 | |
35 | |
36 struct gaim_buddy_list *gaimbuddylist = NULL; | |
37 static struct gaim_blist_ui_ops *blist_ui_ops = NULL; | |
38 | |
39 /***************************************************************************** | |
40 * Private Utility functions * | |
41 *****************************************************************************/ | |
42 static GaimBlistNode *gaim_blist_get_last_sibling(GaimBlistNode *node) | |
43 { | |
44 GaimBlistNode *n = node; | |
45 if (!n) | |
46 return NULL; | |
47 while (n->next) | |
48 n = n->next; | |
49 return n; | |
50 } | |
51 static GaimBlistNode *gaim_blist_get_last_child(GaimBlistNode *node) | |
52 { | |
53 if (!node) | |
54 return NULL; | |
55 return gaim_blist_get_last_sibling(node->child); | |
56 } | |
57 | |
5247 | 58 struct _gaim_hbuddy { |
59 char *name; | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
60 GaimAccount *account; |
5758 | 61 GaimBlistNode *group; |
5247 | 62 }; |
63 | |
64 static guint _gaim_blist_hbuddy_hash (struct _gaim_hbuddy *hb) | |
65 { | |
66 return g_str_hash(hb->name); | |
67 } | |
68 | |
69 static guint _gaim_blist_hbuddy_equal (struct _gaim_hbuddy *hb1, struct _gaim_hbuddy *hb2) | |
70 { | |
5758 | 71 return ((!strcmp(hb1->name, hb2->name)) && hb1->account == hb2->account && hb1->group == hb2->group); |
5247 | 72 } |
73 | |
6006 | 74 static void blist_pref_cb(const char *name, GaimPrefType typ, gpointer value, gpointer data) |
75 { | |
6012 | 76 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; |
77 GaimBlistNode *group, *buddy; | |
78 | |
79 if (!ops) | |
80 return; | |
81 | |
82 for(group = gaimbuddylist->root; group; group = group->next) { | |
83 if(!GAIM_BLIST_NODE_IS_GROUP(group)) | |
84 continue; | |
85 for(buddy = group->child; buddy; buddy = buddy->next) { | |
86 if(!GAIM_BLIST_NODE_IS_BUDDY(buddy)) | |
87 continue; | |
88 ops->update(gaimbuddylist, buddy); | |
89 } | |
90 } | |
6006 | 91 } |
92 | |
5228 | 93 /***************************************************************************** |
94 * Public API functions * | |
95 *****************************************************************************/ | |
96 | |
97 struct gaim_buddy_list *gaim_blist_new() | |
98 { | |
99 struct gaim_buddy_list *gbl = g_new0(struct gaim_buddy_list, 1); | |
100 | |
101 gbl->ui_ops = gaim_get_blist_ui_ops(); | |
102 | |
5247 | 103 gbl->buddies = g_hash_table_new ((GHashFunc)_gaim_blist_hbuddy_hash, |
104 (GEqualFunc)_gaim_blist_hbuddy_equal); | |
105 | |
5228 | 106 if (gbl->ui_ops != NULL && gbl->ui_ops->new_list != NULL) |
107 gbl->ui_ops->new_list(gbl); | |
108 | |
6006 | 109 gaim_prefs_connect_callback("/core/buddies/use_server_alias", blist_pref_cb, NULL); |
110 | |
5228 | 111 return gbl; |
112 } | |
113 | |
114 void | |
115 gaim_set_blist(struct gaim_buddy_list *list) | |
116 { | |
117 gaimbuddylist = list; | |
118 } | |
119 | |
120 struct gaim_buddy_list * | |
121 gaim_get_blist(void) | |
122 { | |
123 return gaimbuddylist; | |
124 } | |
125 | |
126 void gaim_blist_show () | |
127 { | |
128 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
129 if (ops) | |
130 ops->show(gaimbuddylist); | |
131 } | |
132 | |
133 void gaim_blist_destroy() | |
134 { | |
135 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
136 if (ops) | |
137 ops->destroy(gaimbuddylist); | |
138 } | |
139 | |
140 void gaim_blist_set_visible (gboolean show) | |
141 { | |
142 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
143 if (ops) | |
144 ops->set_visible(gaimbuddylist, show); | |
145 } | |
146 | |
147 void gaim_blist_update_buddy_status (struct buddy *buddy, int status) | |
148 { | |
5266
b3a03b86b09b
[gaim-migrate @ 5638]
Christian Hammond <chipx86@chipx86.com>
parents:
5259
diff
changeset
|
149 struct gaim_blist_ui_ops *ops; |
b3a03b86b09b
[gaim-migrate @ 5638]
Christian Hammond <chipx86@chipx86.com>
parents:
5259
diff
changeset
|
150 |
b3a03b86b09b
[gaim-migrate @ 5638]
Christian Hammond <chipx86@chipx86.com>
parents:
5259
diff
changeset
|
151 if (buddy->uc == status) |
b3a03b86b09b
[gaim-migrate @ 5638]
Christian Hammond <chipx86@chipx86.com>
parents:
5259
diff
changeset
|
152 return; |
b3a03b86b09b
[gaim-migrate @ 5638]
Christian Hammond <chipx86@chipx86.com>
parents:
5259
diff
changeset
|
153 |
b3a03b86b09b
[gaim-migrate @ 5638]
Christian Hammond <chipx86@chipx86.com>
parents:
5259
diff
changeset
|
154 ops = gaimbuddylist->ui_ops; |
5228 | 155 |
5305 | 156 if((status & UC_UNAVAILABLE) != (buddy->uc & UC_UNAVAILABLE)) { |
157 if(status & UC_UNAVAILABLE) | |
158 gaim_event_broadcast(event_buddy_away, buddy->account->gc, buddy->name); | |
159 else | |
160 gaim_event_broadcast(event_buddy_back, buddy->account->gc, buddy->name); | |
161 } | |
5228 | 162 |
5305 | 163 buddy->uc = status; |
5228 | 164 if (ops) |
165 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
166 } | |
167 | |
168 static gboolean presence_update_timeout_cb(struct buddy *buddy) { | |
169 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
170 | |
171 if(buddy->present == GAIM_BUDDY_SIGNING_ON) { | |
172 buddy->present = GAIM_BUDDY_ONLINE; | |
173 } else if(buddy->present == GAIM_BUDDY_SIGNING_OFF) { | |
174 buddy->present = GAIM_BUDDY_OFFLINE; | |
175 } | |
176 | |
177 buddy->timer = 0; | |
178 | |
179 if (ops) | |
180 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
181 | |
182 return FALSE; | |
183 } | |
184 | |
185 void gaim_blist_update_buddy_presence(struct buddy *buddy, int presence) { | |
186 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
187 gboolean do_timer = FALSE; | |
188 | |
189 if (!GAIM_BUDDY_IS_ONLINE(buddy) && presence) { | |
190 buddy->present = GAIM_BUDDY_SIGNING_ON; | |
191 gaim_event_broadcast(event_buddy_signon, buddy->account->gc, buddy->name); | |
192 do_timer = TRUE; | |
5277 | 193 ((struct group *)((GaimBlistNode *)buddy)->parent)->online++; |
5228 | 194 } else if(GAIM_BUDDY_IS_ONLINE(buddy) && !presence) { |
195 buddy->present = GAIM_BUDDY_SIGNING_OFF; | |
196 gaim_event_broadcast(event_buddy_signoff, buddy->account->gc, buddy->name); | |
197 do_timer = TRUE; | |
5394 | 198 ((struct group *)((GaimBlistNode *)buddy)->parent)->online--; |
5228 | 199 } |
200 | |
201 if(do_timer) { | |
202 if(buddy->timer > 0) | |
203 g_source_remove(buddy->timer); | |
204 buddy->timer = g_timeout_add(10000, (GSourceFunc)presence_update_timeout_cb, buddy); | |
205 } | |
206 | |
207 if (ops) | |
208 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
209 } | |
210 | |
211 | |
212 void gaim_blist_update_buddy_idle (struct buddy *buddy, int idle) | |
213 { | |
214 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
215 buddy->idle = idle; | |
216 if (ops) | |
217 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
218 } | |
219 void gaim_blist_update_buddy_evil (struct buddy *buddy, int warning) | |
220 { | |
221 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
222 buddy->evil = warning; | |
223 if (ops) | |
224 ops->update(gaimbuddylist,(GaimBlistNode*)buddy); | |
225 } | |
226 void gaim_blist_update_buddy_icon(struct buddy *buddy) { | |
227 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
228 if(ops) | |
229 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
230 } | |
231 void gaim_blist_rename_buddy (struct buddy *buddy, const char *name) | |
232 { | |
233 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
5634 | 234 g_free(buddy->name); |
5228 | 235 buddy->name = g_strdup(name); |
236 if (ops) | |
237 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
238 } | |
5234 | 239 |
240 void gaim_blist_alias_chat(struct chat *chat, const char *alias) | |
241 { | |
242 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
243 | |
5237 | 244 g_free(chat->alias); |
5234 | 245 |
5237 | 246 if(alias && strlen(alias)) |
247 chat->alias = g_strdup(alias); | |
248 else | |
249 chat->alias = NULL; | |
250 | |
5234 | 251 if(ops) |
252 ops->update(gaimbuddylist, (GaimBlistNode*)chat); | |
253 } | |
254 | |
5228 | 255 void gaim_blist_alias_buddy (struct buddy *buddy, const char *alias) |
256 { | |
257 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
5676
dae79aefac8d
[gaim-migrate @ 6094]
Christian Hammond <chipx86@chipx86.com>
parents:
5634
diff
changeset
|
258 GaimConversation *conv; |
5228 | 259 |
260 g_free(buddy->alias); | |
261 | |
262 if(alias && strlen(alias)) | |
263 buddy->alias = g_strdup(alias); | |
264 else | |
265 buddy->alias = NULL; | |
266 | |
267 if (ops) | |
268 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
269 | |
270 conv = gaim_find_conversation_with_account(buddy->name, buddy->account); | |
271 | |
272 if (conv) | |
273 gaim_conversation_autoset_title(conv); | |
274 } | |
275 | |
6058 | 276 void gaim_blist_server_alias_buddy (struct buddy *buddy, const char *alias) |
277 { | |
278 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
279 GaimConversation *conv; | |
280 | |
281 g_free(buddy->server_alias); | |
282 | |
283 if(alias && strlen(alias) && g_utf8_validate(alias, -1, NULL)) | |
284 buddy->server_alias = g_strdup(alias); | |
285 else | |
286 buddy->server_alias = NULL; | |
287 | |
288 if (ops) | |
289 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
290 | |
291 conv = gaim_find_conversation_with_account(buddy->name, buddy->account); | |
292 | |
293 if (conv) | |
294 gaim_conversation_autoset_title(conv); | |
295 } | |
296 | |
5228 | 297 void gaim_blist_rename_group(struct group *group, const char *name) |
298 { | |
299 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
5346 | 300 struct group *dest_group; |
301 GaimBlistNode *prev, *child, *next; | |
302 GSList *accts; | |
303 | |
304 if(!name || !strlen(name) || !strcmp(name, group->name)) { | |
305 /* nothing to do here */ | |
306 return; | |
307 } else if((dest_group = gaim_find_group(name))) { | |
308 /* here we're merging two groups */ | |
309 prev = gaim_blist_get_last_child((GaimBlistNode*)dest_group); | |
310 child = ((GaimBlistNode*)group)->child; | |
311 | |
312 while(child) | |
313 { | |
314 next = child->next; | |
315 if(GAIM_BLIST_NODE_IS_BUDDY(child)) { | |
316 gaim_blist_add_buddy((struct buddy *)child, dest_group, prev); | |
317 prev = child; | |
318 } else if(GAIM_BLIST_NODE_IS_CHAT(child)) { | |
319 gaim_blist_add_chat((struct chat *)child, dest_group, prev); | |
320 prev = child; | |
321 } else { | |
322 gaim_debug(GAIM_DEBUG_ERROR, "blist", | |
323 "Unknown child type in group %s\n", group->name); | |
324 } | |
325 child = next; | |
326 } | |
327 for (accts = gaim_group_get_accounts(group); accts; accts = g_slist_remove(accts, accts->data)) { | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
328 GaimAccount *account = accts->data; |
5346 | 329 serv_rename_group(account->gc, group, name); |
330 } | |
331 gaim_blist_remove_group(group); | |
332 } else { | |
333 /* a simple rename */ | |
334 for (accts = gaim_group_get_accounts(group); accts; accts = g_slist_remove(accts, accts->data)) { | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
335 GaimAccount *account = accts->data; |
5346 | 336 serv_rename_group(account->gc, group, name); |
337 } | |
338 g_free(group->name); | |
339 group->name = g_strdup(name); | |
340 if (ops) | |
341 ops->update(gaimbuddylist, (GaimBlistNode*)group); | |
342 } | |
5228 | 343 } |
5234 | 344 |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
345 struct chat *gaim_chat_new(GaimAccount *account, const char *alias, GHashTable *components) |
5234 | 346 { |
347 struct chat *chat; | |
348 struct gaim_blist_ui_ops *ops; | |
349 | |
5237 | 350 if(!components) |
5234 | 351 return NULL; |
352 | |
353 chat = g_new0(struct chat, 1); | |
354 chat->account = account; | |
5237 | 355 if(alias && strlen(alias)) |
356 chat->alias = g_strdup(alias); | |
5234 | 357 chat->components = components; |
5906 | 358 chat->settings = g_hash_table_new_full(g_str_hash, g_str_equal, |
359 g_free, g_free); | |
5234 | 360 |
361 ((GaimBlistNode*)chat)->type = GAIM_BLIST_CHAT_NODE; | |
362 | |
363 ops = gaim_get_blist_ui_ops(); | |
364 | |
365 if (ops != NULL && ops->new_node != NULL) | |
366 ops->new_node((GaimBlistNode *)chat); | |
367 | |
368 return chat; | |
369 } | |
370 | |
6036 | 371 char *gaim_chat_get_display_name(struct chat *chat) |
6034 | 372 { |
373 char *name; | |
374 | |
375 if(chat->alias){ | |
376 name = g_strdup(chat->alias); | |
377 } | |
378 else{ | |
379 GList *parts; | |
380 GaimPlugin *prpl; | |
381 GaimPluginProtocolInfo *prpl_info; | |
382 struct proto_chat_entry *pce; | |
383 | |
384 prpl = gaim_find_prpl(gaim_account_get_protocol(chat->account)); | |
385 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(prpl); | |
386 | |
387 parts = prpl_info->chat_info(chat->account->gc); | |
388 | |
389 pce = parts->data; | |
390 name = g_markup_escape_text(g_hash_table_lookup(chat->components, | |
391 pce->identifier), -1); | |
392 g_list_free(parts); | |
393 } | |
394 | |
395 return name; | |
396 } | |
397 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
398 struct buddy *gaim_buddy_new(GaimAccount *account, const char *screenname, const char *alias) |
5228 | 399 { |
400 struct buddy *b; | |
401 struct gaim_blist_ui_ops *ops; | |
402 | |
403 b = g_new0(struct buddy, 1); | |
404 b->account = account; | |
405 b->name = g_strdup(screenname); | |
406 b->alias = g_strdup(alias); | |
407 b->settings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); | |
408 ((GaimBlistNode*)b)->type = GAIM_BLIST_BUDDY_NODE; | |
409 | |
410 ops = gaim_get_blist_ui_ops(); | |
411 | |
412 if (ops != NULL && ops->new_node != NULL) | |
413 ops->new_node((GaimBlistNode *)b); | |
414 | |
415 return b; | |
416 } | |
5634 | 417 |
5234 | 418 void gaim_blist_add_chat(struct chat *chat, struct group *group, GaimBlistNode *node) |
419 { | |
420 GaimBlistNode *n = node, *cnode = (GaimBlistNode*)chat; | |
421 struct group *g = group; | |
422 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
423 gboolean save = FALSE; | |
424 | |
425 if (!n) { | |
426 if (!g) { | |
427 g = gaim_group_new(_("Chats")); | |
5634 | 428 gaim_blist_add_group(g, |
429 gaim_blist_get_last_sibling(gaimbuddylist->root)); | |
5234 | 430 } |
431 } else { | |
432 g = (struct group*)n->parent; | |
433 } | |
434 | |
435 /* if we're moving to overtop of ourselves, do nothing */ | |
436 if(cnode == n) | |
437 return; | |
438 | |
439 if (cnode->parent) { | |
440 /* This chat was already in the list and is | |
441 * being moved. | |
442 */ | |
5277 | 443 ((struct group *)cnode->parent)->totalsize--; |
5855 | 444 if (gaim_account_is_connected(chat->account)) { |
5287 | 445 ((struct group *)cnode->parent)->online--; |
5277 | 446 ((struct group *)cnode->parent)->currentsize--; |
5287 | 447 } |
5234 | 448 if(cnode->next) |
449 cnode->next->prev = cnode->prev; | |
450 if(cnode->prev) | |
451 cnode->prev->next = cnode->next; | |
452 if(cnode->parent->child == cnode) | |
453 cnode->parent->child = cnode->next; | |
454 | |
455 ops->remove(gaimbuddylist, cnode); | |
456 | |
457 save = TRUE; | |
458 } | |
459 | |
460 if (n) { | |
461 if(n->next) | |
462 n->next->prev = cnode; | |
463 cnode->next = n->next; | |
464 cnode->prev = n; | |
465 cnode->parent = n->parent; | |
466 n->next = cnode; | |
5277 | 467 ((struct group *)n->parent)->totalsize++; |
5855 | 468 if (gaim_account_is_connected(chat->account)) { |
5287 | 469 ((struct group *)n->parent)->online++; |
5277 | 470 ((struct group *)n->parent)->currentsize++; |
5287 | 471 } |
5234 | 472 } else { |
5634 | 473 if(((GaimBlistNode*)g)->child) |
474 ((GaimBlistNode*)g)->child->prev = cnode; | |
475 cnode->next = ((GaimBlistNode*)g)->child; | |
476 cnode->prev = NULL; | |
5234 | 477 ((GaimBlistNode*)g)->child = cnode; |
478 cnode->parent = (GaimBlistNode*)g; | |
5277 | 479 g->totalsize++; |
5855 | 480 if (gaim_account_is_connected(chat->account)) { |
5287 | 481 g->online++; |
5277 | 482 g->currentsize++; |
5287 | 483 } |
5234 | 484 } |
485 | |
486 if (ops) | |
487 ops->update(gaimbuddylist, (GaimBlistNode*)cnode); | |
488 if (save) | |
489 gaim_blist_save(); | |
490 } | |
491 | |
5228 | 492 void gaim_blist_add_buddy (struct buddy *buddy, struct group *group, GaimBlistNode *node) |
493 { | |
494 GaimBlistNode *n = node, *bnode = (GaimBlistNode*)buddy; | |
495 struct group *g = group; | |
496 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
5247 | 497 struct _gaim_hbuddy *hb; |
5228 | 498 gboolean save = FALSE; |
499 | |
500 if (!n) { | |
501 if (!g) { | |
502 g = gaim_group_new(_("Buddies")); | |
5634 | 503 gaim_blist_add_group(g, |
504 gaim_blist_get_last_sibling(gaimbuddylist->root)); | |
5228 | 505 } |
506 } else { | |
507 g = (struct group*)n->parent; | |
508 } | |
509 | |
510 /* if we're moving to overtop of ourselves, do nothing */ | |
511 if(bnode == n) | |
512 return; | |
513 | |
514 if (bnode->parent) { | |
515 /* This buddy was already in the list and is | |
516 * being moved. | |
517 */ | |
5394 | 518 ((struct group *)bnode->parent)->totalsize--; |
5855 | 519 if (gaim_account_is_connected(buddy->account)) |
5277 | 520 ((struct group *)bnode->parent)->currentsize--; |
5394 | 521 if (GAIM_BUDDY_IS_ONLINE(buddy)) |
5313 | 522 ((struct group *)bnode->parent)->online--; |
5277 | 523 |
5228 | 524 if(bnode->next) |
525 bnode->next->prev = bnode->prev; | |
526 if(bnode->prev) | |
527 bnode->prev->next = bnode->next; | |
528 if(bnode->parent->child == bnode) | |
529 bnode->parent->child = bnode->next; | |
530 | |
531 ops->remove(gaimbuddylist, bnode); | |
532 | |
5277 | 533 if (bnode->parent != ((GaimBlistNode*)g)) { |
5228 | 534 serv_move_buddy(buddy, (struct group*)bnode->parent, g); |
5277 | 535 } |
5228 | 536 save = TRUE; |
537 } | |
538 | |
539 if (n) { | |
540 if(n->next) | |
541 n->next->prev = (GaimBlistNode*)buddy; | |
542 ((GaimBlistNode*)buddy)->next = n->next; | |
543 ((GaimBlistNode*)buddy)->prev = n; | |
544 ((GaimBlistNode*)buddy)->parent = n->parent; | |
545 n->next = (GaimBlistNode*)buddy; | |
5277 | 546 ((struct group *)n->parent)->totalsize++; |
5855 | 547 if (gaim_account_is_connected(buddy->account)) |
5277 | 548 ((struct group *)n->parent)->currentsize++; |
5394 | 549 if (GAIM_BUDDY_IS_ONLINE(buddy)) |
5313 | 550 ((struct group *)n->parent)->online++; |
5228 | 551 } else { |
5634 | 552 if(((GaimBlistNode*)g)->child) |
553 ((GaimBlistNode*)g)->child->prev = (GaimBlistNode*)buddy; | |
554 ((GaimBlistNode*)buddy)->prev = NULL; | |
555 ((GaimBlistNode*)buddy)->next = ((GaimBlistNode*)g)->child; | |
5228 | 556 ((GaimBlistNode*)g)->child = (GaimBlistNode*)buddy; |
557 ((GaimBlistNode*)buddy)->parent = (GaimBlistNode*)g; | |
5277 | 558 g->totalsize++; |
5855 | 559 if (gaim_account_is_connected(buddy->account)) |
5277 | 560 g->currentsize++; |
5394 | 561 if (GAIM_BUDDY_IS_ONLINE(buddy)) |
5313 | 562 g->online++; |
5228 | 563 } |
564 | |
5247 | 565 hb = g_malloc(sizeof(struct _gaim_hbuddy)); |
566 hb->name = g_strdup(normalize(buddy->name)); | |
567 hb->account = buddy->account; | |
5758 | 568 hb->group = ((GaimBlistNode*)buddy)->parent; |
5247 | 569 |
570 if (g_hash_table_lookup(gaimbuddylist->buddies, (gpointer)hb)) { | |
571 /* This guy already exists */ | |
572 g_free(hb->name); | |
573 g_free(hb); | |
574 } else { | |
575 g_hash_table_insert(gaimbuddylist->buddies, (gpointer)hb, (gpointer)buddy); | |
576 } | |
577 | |
5228 | 578 if (ops) |
579 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
580 if (save) | |
581 gaim_blist_save(); | |
582 } | |
583 | |
584 struct group *gaim_group_new(const char *name) | |
585 { | |
586 struct group *g = gaim_find_group(name); | |
587 | |
588 if (!g) { | |
589 struct gaim_blist_ui_ops *ops; | |
590 g= g_new0(struct group, 1); | |
591 g->name = g_strdup(name); | |
5277 | 592 g->totalsize = 0; |
593 g->currentsize = 0; | |
594 g->online = 0; | |
5228 | 595 g->settings = g_hash_table_new_full(g_str_hash, g_str_equal, |
596 g_free, g_free); | |
597 ((GaimBlistNode*)g)->type = GAIM_BLIST_GROUP_NODE; | |
598 | |
599 ops = gaim_get_blist_ui_ops(); | |
600 | |
601 if (ops != NULL && ops->new_node != NULL) | |
602 ops->new_node((GaimBlistNode *)g); | |
603 | |
604 } | |
605 return g; | |
606 } | |
607 | |
608 void gaim_blist_add_group (struct group *group, GaimBlistNode *node) | |
609 { | |
610 struct gaim_blist_ui_ops *ops; | |
611 GaimBlistNode *gnode = (GaimBlistNode*)group; | |
612 gboolean save = FALSE; | |
613 | |
614 if (!gaimbuddylist) | |
615 gaimbuddylist = gaim_blist_new(); | |
616 ops = gaimbuddylist->ui_ops; | |
617 | |
618 if (!gaimbuddylist->root) { | |
619 gaimbuddylist->root = gnode; | |
620 return; | |
621 } | |
622 | |
623 /* if we're moving to overtop of ourselves, do nothing */ | |
624 if(gnode == node) | |
625 return; | |
626 | |
627 if (gaim_find_group(group->name)) { | |
628 /* This is just being moved */ | |
629 | |
630 ops->remove(gaimbuddylist, (GaimBlistNode*)group); | |
631 | |
632 if(gnode == gaimbuddylist->root) | |
633 gaimbuddylist->root = gnode->next; | |
634 if(gnode->prev) | |
635 gnode->prev->next = gnode->next; | |
636 if(gnode->next) | |
637 gnode->next->prev = gnode->prev; | |
638 | |
639 save = TRUE; | |
640 } | |
641 | |
5634 | 642 if (node) { |
643 gnode->next = node->next; | |
644 gnode->prev = node; | |
645 if(node->next) | |
646 node->next->prev = gnode; | |
647 node->next = gnode; | |
648 } else { | |
649 gaimbuddylist->root->prev = gnode; | |
650 gnode->next = gaimbuddylist->root; | |
651 gnode->prev = NULL; | |
652 gaimbuddylist->root = gnode; | |
653 } | |
654 | |
5228 | 655 |
656 if (ops) { | |
657 ops->update(gaimbuddylist, gnode); | |
658 for(node = gnode->child; node; node = node->next) | |
659 ops->update(gaimbuddylist, node); | |
660 } | |
661 if (save) | |
662 gaim_blist_save(); | |
663 } | |
664 | |
665 void gaim_blist_remove_buddy (struct buddy *buddy) | |
666 { | |
667 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
668 | |
669 GaimBlistNode *gnode, *node = (GaimBlistNode*)buddy; | |
670 struct group *group; | |
5247 | 671 struct _gaim_hbuddy hb, *key; |
672 struct buddy *val; | |
5228 | 673 |
674 gnode = node->parent; | |
675 group = (struct group *)gnode; | |
676 | |
677 if(gnode->child == node) | |
678 gnode->child = node->next; | |
679 if (node->prev) | |
680 node->prev->next = node->next; | |
681 if (node->next) | |
682 node->next->prev = node->prev; | |
5394 | 683 group->totalsize--; |
5855 | 684 if (gaim_account_is_connected(buddy->account)) |
5277 | 685 group->currentsize--; |
5394 | 686 if (GAIM_BUDDY_IS_ONLINE(buddy)) |
687 group->online--; | |
5228 | 688 |
5247 | 689 hb.name = normalize(buddy->name); |
690 hb.account = buddy->account; | |
5758 | 691 hb.group = ((GaimBlistNode*)buddy)->parent; |
5247 | 692 if (g_hash_table_lookup_extended(gaimbuddylist->buddies, &hb, (gpointer *)&key, (gpointer *)&val)) { |
693 g_hash_table_remove(gaimbuddylist->buddies, &hb); | |
694 g_free(key->name); | |
695 g_free(key); | |
696 } | |
697 | |
5292 | 698 if(buddy->timer > 0) |
699 g_source_remove(buddy->timer); | |
700 | |
5228 | 701 ops->remove(gaimbuddylist, node); |
702 g_hash_table_destroy(buddy->settings); | |
703 g_free(buddy->name); | |
704 g_free(buddy->alias); | |
705 g_free(buddy); | |
706 } | |
707 | |
5234 | 708 void gaim_blist_remove_chat (struct chat *chat) |
709 { | |
710 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
711 | |
712 GaimBlistNode *gnode, *node = (GaimBlistNode*)chat; | |
713 struct group *group; | |
714 | |
715 gnode = node->parent; | |
716 group = (struct group *)gnode; | |
717 | |
718 if(gnode->child == node) | |
719 gnode->child = node->next; | |
720 if (node->prev) | |
721 node->prev->next = node->next; | |
722 if (node->next) | |
723 node->next->prev = node->prev; | |
5277 | 724 group->totalsize--; |
5855 | 725 if (gaim_account_is_connected(chat->account)) { |
5277 | 726 group->currentsize--; |
5394 | 727 group->online--; |
728 } | |
5234 | 729 |
730 ops->remove(gaimbuddylist, node); | |
731 g_hash_table_destroy(chat->components); | |
732 g_free(chat->alias); | |
733 g_free(chat); | |
734 } | |
735 | |
5228 | 736 void gaim_blist_remove_group (struct group *group) |
737 { | |
738 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
739 GaimBlistNode *node = (GaimBlistNode*)group; | |
740 | |
741 if(node->child) { | |
742 char *buf; | |
743 int count = 0; | |
744 GaimBlistNode *child = node->child; | |
745 | |
746 while(child) { | |
747 count++; | |
748 child = child->next; | |
749 } | |
750 | |
751 buf = g_strdup_printf(_("%d buddies from group %s were not " | |
752 "removed because their accounts were not logged in. These " | |
5541
aee0ee458974
[gaim-migrate @ 5941]
Christian Hammond <chipx86@chipx86.com>
parents:
5436
diff
changeset
|
753 "buddies and the group were not removed.\n"), |
5228 | 754 count, group->name); |
5436
ad445074d239
[gaim-migrate @ 5818]
Christian Hammond <chipx86@chipx86.com>
parents:
5435
diff
changeset
|
755 |
5541
aee0ee458974
[gaim-migrate @ 5941]
Christian Hammond <chipx86@chipx86.com>
parents:
5436
diff
changeset
|
756 gaim_notify_error(NULL, NULL, _("Group not removed"), buf); |
5228 | 757 g_free(buf); |
758 return; | |
759 } | |
760 | |
761 if(gaimbuddylist->root == node) | |
762 gaimbuddylist->root = node->next; | |
763 if (node->prev) | |
764 node->prev->next = node->next; | |
765 if (node->next) | |
766 node->next->prev = node->prev; | |
767 | |
768 ops->remove(gaimbuddylist, node); | |
769 g_free(group->name); | |
770 g_free(group); | |
771 } | |
772 | |
773 char *gaim_get_buddy_alias_only(struct buddy *b) { | |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
774 if(!b) |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
775 return NULL; |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
776 |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
777 if(b->alias && b->alias[0]) { |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
778 return b->alias; |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
779 } |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
780 else if (b->server_alias != NULL && |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
781 gaim_prefs_get_bool("/core/buddies/use_server_alias")) { |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
782 |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
783 return b->server_alias; |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
784 } |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
785 |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
786 return NULL; |
5228 | 787 } |
788 | |
789 char * gaim_get_buddy_alias (struct buddy *buddy) | |
790 { | |
791 char *ret = gaim_get_buddy_alias_only(buddy); | |
792 | |
6036 | 793 if(!ret) |
794 return buddy ? buddy->name : _("Unknown"); | |
795 | |
796 return ret; | |
5228 | 797 } |
798 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
799 struct buddy *gaim_find_buddy(GaimAccount *account, const char *name) |
5228 | 800 { |
5758 | 801 static struct buddy *buddy = NULL; |
5247 | 802 struct _gaim_hbuddy hb; |
5758 | 803 GaimBlistNode *group; |
804 const char *n = NULL; | |
5228 | 805 |
806 if (!gaimbuddylist) | |
807 return NULL; | |
5758 | 808 |
5985
60d9cbfb6bf8
[gaim-migrate @ 6433]
Christian Hammond <chipx86@chipx86.com>
parents:
5947
diff
changeset
|
809 if (!name && !buddy) |
60d9cbfb6bf8
[gaim-migrate @ 6433]
Christian Hammond <chipx86@chipx86.com>
parents:
5947
diff
changeset
|
810 return NULL; |
5228 | 811 |
5758 | 812 if (name) { |
813 group = gaimbuddylist->root; | |
814 n = name; | |
815 } else { | |
816 group = ((GaimBlistNode*)buddy)->parent->next; | |
817 n = buddy->name; | |
818 } | |
5247 | 819 |
5758 | 820 while (group) { |
821 hb.name = normalize(n); | |
822 hb.account = account; | |
823 hb.group = group; | |
5776 | 824 if ((buddy = g_hash_table_lookup(gaimbuddylist->buddies, &hb)) != NULL) |
5758 | 825 return buddy; |
826 group = ((GaimBlistNode*)group)->next; | |
827 } | |
828 return NULL; | |
5228 | 829 } |
830 | |
831 struct group *gaim_find_group(const char *name) | |
832 { | |
833 GaimBlistNode *node; | |
834 if (!gaimbuddylist) | |
835 return NULL; | |
836 node = gaimbuddylist->root; | |
837 while(node) { | |
838 if (!strcmp(((struct group*)node)->name, name)) | |
839 return (struct group*)node; | |
840 node = node->next; | |
841 } | |
842 return NULL; | |
843 } | |
844 struct group *gaim_find_buddys_group(struct buddy *buddy) | |
845 { | |
846 if (!buddy) | |
847 return NULL; | |
848 return (struct group*)(((GaimBlistNode*)buddy)->parent); | |
849 } | |
850 | |
851 GSList *gaim_group_get_accounts(struct group *g) | |
852 { | |
853 GSList *l = NULL; | |
854 GaimBlistNode *child = ((GaimBlistNode *)g)->child; | |
855 | |
856 while (child) { | |
857 if (!g_slist_find(l, ((struct buddy*)child)->account)) | |
858 l = g_slist_append(l, ((struct buddy*)child)->account); | |
859 child = child->next; | |
860 } | |
861 return l; | |
862 } | |
863 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
864 void gaim_blist_add_account(GaimAccount *account) |
5234 | 865 { |
866 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
867 GaimBlistNode *group, *buddy; | |
868 | |
869 if(!gaimbuddylist) | |
870 return; | |
871 | |
872 for(group = gaimbuddylist->root; group; group = group->next) { | |
873 if(!GAIM_BLIST_NODE_IS_GROUP(group)) | |
874 continue; | |
875 for(buddy = group->child; buddy; buddy = buddy->next) { | |
876 if(GAIM_BLIST_NODE_IS_BUDDY(buddy)) { | |
877 if (account == ((struct buddy*)buddy)->account) { | |
5277 | 878 ((struct group *)group)->currentsize++; |
5234 | 879 if(ops) |
880 ops->update(gaimbuddylist, buddy); | |
881 } | |
882 } else if(GAIM_BLIST_NODE_IS_CHAT(buddy)) { | |
883 if (account == ((struct chat*)buddy)->account) { | |
5287 | 884 ((struct group *)group)->online++; |
5277 | 885 ((struct group *)group)->currentsize++; |
5234 | 886 if(ops) |
887 ops->update(gaimbuddylist, buddy); | |
888 } | |
889 } | |
890 } | |
891 } | |
892 } | |
893 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
894 void gaim_blist_remove_account(GaimAccount *account) |
5228 | 895 { |
896 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
5234 | 897 GaimBlistNode *group, *buddy; |
898 | |
5228 | 899 if (!gaimbuddylist) |
900 return; | |
5234 | 901 |
902 for(group = gaimbuddylist->root; group; group = group->next) { | |
903 if(!GAIM_BLIST_NODE_IS_GROUP(group)) | |
904 continue; | |
905 for(buddy = group->child; buddy; buddy = buddy->next) { | |
906 if(GAIM_BLIST_NODE_IS_BUDDY(buddy)) { | |
907 if (account == ((struct buddy*)buddy)->account) { | |
5394 | 908 if (GAIM_BUDDY_IS_ONLINE((struct buddy*)buddy)) |
5277 | 909 ((struct group *)group)->online--; |
5234 | 910 ((struct buddy*)buddy)->present = GAIM_BUDDY_OFFLINE; |
5394 | 911 ((struct group *)group)->currentsize--; |
5234 | 912 if(ops) |
913 ops->remove(gaimbuddylist, buddy); | |
914 } | |
915 } else if(GAIM_BLIST_NODE_IS_CHAT(buddy)) { | |
916 if (account == ((struct chat*)buddy)->account) { | |
5277 | 917 ((struct group *)group)->online--; |
918 ((struct group *)group)->currentsize--; | |
5234 | 919 if(ops) |
920 ops->remove(gaimbuddylist, buddy); | |
921 } | |
5228 | 922 } |
923 } | |
924 } | |
925 } | |
926 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
927 void parse_toc_buddy_list(GaimAccount *account, char *config) |
5228 | 928 { |
929 char *c; | |
930 char current[256]; | |
931 GList *bud = NULL; | |
932 | |
933 | |
934 if (config != NULL) { | |
935 | |
936 /* skip "CONFIG:" (if it exists) */ | |
937 c = strncmp(config + 6 /* sizeof(struct sflap_hdr) */ , "CONFIG:", strlen("CONFIG:")) ? | |
938 strtok(config, "\n") : | |
939 strtok(config + 6 /* sizeof(struct sflap_hdr) */ + strlen("CONFIG:"), "\n"); | |
940 do { | |
941 if (c == NULL) | |
942 break; | |
943 if (*c == 'g') { | |
944 char *utf8 = NULL; | |
945 utf8 = gaim_try_conv_to_utf8(c + 2); | |
946 if (utf8 == NULL) { | |
947 g_strlcpy(current, _("Invalid Groupname"), sizeof(current)); | |
948 } else { | |
949 g_strlcpy(current, utf8, sizeof(current)); | |
950 g_free(utf8); | |
951 } | |
952 if (!gaim_find_group(current)) { | |
953 struct group *g = gaim_group_new(current); | |
5634 | 954 gaim_blist_add_group(g, |
955 gaim_blist_get_last_sibling(gaimbuddylist->root)); | |
5228 | 956 } |
957 } else if (*c == 'b') { /*&& !gaim_find_buddy(user, c + 2)) {*/ | |
958 char nm[80], sw[388], *a, *utf8 = NULL; | |
959 | |
960 if ((a = strchr(c + 2, ':')) != NULL) { | |
961 *a++ = '\0'; /* nul the : */ | |
962 } | |
963 | |
964 g_strlcpy(nm, c + 2, sizeof(nm)); | |
965 if (a) { | |
966 utf8 = gaim_try_conv_to_utf8(a); | |
967 if (utf8 == NULL) { | |
968 gaim_debug(GAIM_DEBUG_ERROR, "toc blist", | |
969 "Failed to convert alias for " | |
970 "'%s' to UTF-8\n", nm); | |
971 } | |
972 } | |
973 if (utf8 == NULL) { | |
974 sw[0] = '\0'; | |
975 } else { | |
976 /* This can leave a partial sequence at the end, | |
977 * but who cares? */ | |
978 g_strlcpy(sw, utf8, sizeof(sw)); | |
979 g_free(utf8); | |
980 } | |
981 | |
982 if (!gaim_find_buddy(account, nm)) { | |
983 struct buddy *b = gaim_buddy_new(account, nm, sw); | |
984 struct group *g = gaim_find_group(current); | |
5634 | 985 gaim_blist_add_buddy(b, g, |
986 gaim_blist_get_last_child((GaimBlistNode*)g)); | |
5228 | 987 bud = g_list_append(bud, g_strdup(nm)); |
988 } | |
989 } else if (*c == 'p') { | |
990 gaim_privacy_permit_add(account, c + 2); | |
991 } else if (*c == 'd') { | |
992 gaim_privacy_deny_add(account, c + 2); | |
993 } else if (!strncmp("toc", c, 3)) { | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
994 sscanf(c + strlen(c) - 1, "%d", &account->perm_deny); |
5228 | 995 gaim_debug(GAIM_DEBUG_MISC, "toc blist", |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
996 "permdeny: %d\n", account->perm_deny); |
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
997 if (account->perm_deny == 0) |
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
998 account->perm_deny = 1; |
5228 | 999 } else if (*c == 'm') { |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1000 sscanf(c + 2, "%d", &account->perm_deny); |
5228 | 1001 gaim_debug(GAIM_DEBUG_MISC, "toc blist", |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1002 "permdeny: %d\n", account->perm_deny); |
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1003 if (account->perm_deny == 0) |
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1004 account->perm_deny = 1; |
5228 | 1005 } |
1006 } while ((c = strtok(NULL, "\n"))); | |
1007 | |
1008 if(account->gc) { | |
1009 if(bud) { | |
1010 GList *node = bud; | |
1011 serv_add_buddies(account->gc, bud); | |
1012 while(node) { | |
1013 g_free(node->data); | |
1014 node = node->next; | |
1015 } | |
1016 } | |
1017 serv_set_permit_deny(account->gc); | |
1018 } | |
1019 g_list_free(bud); | |
1020 } | |
1021 } | |
1022 | |
1023 #if 0 | |
1024 /* translate an AIM 3 buddylist (*.lst) to a Gaim buddylist */ | |
1025 static GString *translate_lst(FILE *src_fp) | |
1026 { | |
1027 char line[BUF_LEN], *line2; | |
1028 char *name; | |
1029 int i; | |
1030 | |
1031 GString *dest = g_string_new("m 1\n"); | |
1032 | |
1033 while (fgets(line, BUF_LEN, src_fp)) { | |
1034 line2 = g_strchug(line); | |
1035 if (strstr(line2, "group") == line2) { | |
1036 name = strpbrk(line2, " \t\n\r\f") + 1; | |
1037 dest = g_string_append(dest, "g "); | |
1038 for (i = 0; i < strcspn(name, "\n\r"); i++) | |
1039 if (name[i] != '\"') | |
1040 dest = g_string_append_c(dest, name[i]); | |
1041 dest = g_string_append_c(dest, '\n'); | |
1042 } | |
1043 if (strstr(line2, "buddy") == line2) { | |
1044 name = strpbrk(line2, " \t\n\r\f") + 1; | |
1045 dest = g_string_append(dest, "b "); | |
1046 for (i = 0; i < strcspn(name, "\n\r"); i++) | |
1047 if (name[i] != '\"') | |
1048 dest = g_string_append_c(dest, name[i]); | |
1049 dest = g_string_append_c(dest, '\n'); | |
1050 } | |
1051 } | |
1052 | |
1053 return dest; | |
1054 } | |
1055 | |
1056 | |
1057 /* translate an AIM 4 buddylist (*.blt) to Gaim format */ | |
1058 static GString *translate_blt(FILE *src_fp) | |
1059 { | |
1060 int i; | |
1061 char line[BUF_LEN]; | |
1062 char *buddy; | |
1063 | |
1064 GString *dest = g_string_new("m 1\n"); | |
1065 | |
1066 while (strstr(fgets(line, BUF_LEN, src_fp), "Buddy") == NULL); | |
1067 while (strstr(fgets(line, BUF_LEN, src_fp), "list") == NULL); | |
1068 | |
1069 while (1) { | |
1070 fgets(line, BUF_LEN, src_fp); g_strchomp(line); | |
1071 if (strchr(line, '}') != NULL) | |
1072 break; | |
1073 | |
1074 if (strchr(line, '{') != NULL) { | |
1075 /* Syntax starting with "<group> {" */ | |
1076 | |
1077 dest = g_string_append(dest, "g "); | |
1078 buddy = g_strchug(strtok(line, "{")); | |
1079 for (i = 0; i < strlen(buddy); i++) | |
1080 if (buddy[i] != '\"') | |
1081 dest = g_string_append_c(dest, buddy[i]); | |
1082 dest = g_string_append_c(dest, '\n'); | |
1083 while (strchr(fgets(line, BUF_LEN, src_fp), '}') == NULL) { | |
1084 gboolean pounce = FALSE; | |
1085 char *e; | |
1086 g_strchomp(line); | |
1087 buddy = g_strchug(line); | |
1088 gaim_debug(GAIM_DEBUG_MISC, "AIM 4 blt import", | |
1089 "buddy: \"%s\"\n", buddy); | |
1090 dest = g_string_append(dest, "b "); | |
1091 if (strchr(buddy, '{') != NULL) { | |
1092 /* buddy pounce, etc */ | |
1093 char *pos = strchr(buddy, '{') - 1; | |
1094 *pos = 0; | |
1095 pounce = TRUE; | |
1096 } | |
1097 if ((e = strchr(buddy, '\"')) != NULL) { | |
1098 *e = '\0'; | |
1099 buddy++; | |
1100 } | |
1101 dest = g_string_append(dest, buddy); | |
1102 dest = g_string_append_c(dest, '\n'); | |
1103 if (pounce) | |
1104 do | |
1105 fgets(line, BUF_LEN, src_fp); | |
1106 while (!strchr(line, '}')); | |
1107 } | |
1108 } else { | |
1109 | |
1110 /* Syntax "group buddy buddy ..." */ | |
1111 buddy = g_strchug(strtok(line, " \n")); | |
1112 dest = g_string_append(dest, "g "); | |
1113 if (strchr(buddy, '\"') != NULL) { | |
1114 dest = g_string_append(dest, &buddy[1]); | |
1115 dest = g_string_append_c(dest, ' '); | |
1116 buddy = g_strchug(strtok(NULL, " \n")); | |
1117 while (strchr(buddy, '\"') == NULL) { | |
1118 dest = g_string_append(dest, buddy); | |
1119 dest = g_string_append_c(dest, ' '); | |
1120 buddy = g_strchug(strtok(NULL, " \n")); | |
1121 } | |
1122 buddy[strlen(buddy) - 1] = '\0'; | |
1123 dest = g_string_append(dest, buddy); | |
1124 } else { | |
1125 dest = g_string_append(dest, buddy); | |
1126 } | |
1127 dest = g_string_append_c(dest, '\n'); | |
1128 while ((buddy = g_strchug(strtok(NULL, " \n"))) != NULL) { | |
1129 dest = g_string_append(dest, "b "); | |
1130 if (strchr(buddy, '\"') != NULL) { | |
1131 dest = g_string_append(dest, &buddy[1]); | |
1132 dest = g_string_append_c(dest, ' '); | |
1133 buddy = g_strchug(strtok(NULL, " \n")); | |
1134 while (strchr(buddy, '\"') == NULL) { | |
1135 dest = g_string_append(dest, buddy); | |
1136 dest = g_string_append_c(dest, ' '); | |
1137 buddy = g_strchug(strtok(NULL, " \n")); | |
1138 } | |
1139 buddy[strlen(buddy) - 1] = '\0'; | |
1140 dest = g_string_append(dest, buddy); | |
1141 } else { | |
1142 dest = g_string_append(dest, buddy); | |
1143 } | |
1144 dest = g_string_append_c(dest, '\n'); | |
1145 } | |
1146 } | |
1147 } | |
1148 | |
1149 return dest; | |
1150 } | |
1151 | |
1152 static GString *translate_gnomeicu(FILE *src_fp) | |
1153 { | |
1154 char line[BUF_LEN]; | |
1155 GString *dest = g_string_new("m 1\ng Buddies\n"); | |
1156 | |
1157 while (strstr(fgets(line, BUF_LEN, src_fp), "NewContacts") == NULL); | |
1158 | |
1159 while (fgets(line, BUF_LEN, src_fp)) { | |
1160 char *eq; | |
1161 g_strchomp(line); | |
1162 if (line[0] == '\n' || line[0] == '[') | |
1163 break; | |
1164 eq = strchr(line, '='); | |
1165 if (!eq) | |
1166 break; | |
1167 *eq = ':'; | |
1168 eq = strchr(eq, ','); | |
1169 if (eq) | |
1170 *eq = '\0'; | |
1171 dest = g_string_append(dest, "b "); | |
1172 dest = g_string_append(dest, line); | |
1173 dest = g_string_append_c(dest, '\n'); | |
1174 } | |
1175 | |
1176 return dest; | |
1177 } | |
1178 #endif | |
1179 | |
1180 static gchar *get_screenname_filename(const char *name) | |
1181 { | |
1182 gchar **split; | |
1183 gchar *good; | |
1184 gchar *ret; | |
1185 | |
1186 split = g_strsplit(name, G_DIR_SEPARATOR_S, -1); | |
1187 good = g_strjoinv(NULL, split); | |
1188 g_strfreev(split); | |
1189 | |
1190 ret = g_utf8_strup(good, -1); | |
1191 | |
1192 g_free(good); | |
1193 | |
1194 return ret; | |
1195 } | |
1196 | |
1197 static gboolean gaim_blist_read(const char *filename); | |
1198 | |
1199 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1200 static void do_import(GaimAccount *account, const char *filename) |
5228 | 1201 { |
1202 GString *buf = NULL; | |
1203 char first[64]; | |
1204 char path[PATHSIZE]; | |
1205 int len; | |
1206 FILE *f; | |
1207 struct stat st; | |
1208 | |
1209 if (filename) { | |
1210 g_snprintf(path, sizeof(path), "%s", filename); | |
1211 } else { | |
1212 char *g_screenname = get_screenname_filename(account->username); | |
5943
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1213 const char *username; |
5228 | 1214 char *file = gaim_user_dir(); |
5943
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1215 GaimProtocol prpl_num; |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1216 int protocol; |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1217 |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1218 prpl_num = gaim_account_get_protocol(account); |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1219 |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1220 protocol = prpl_num; |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1221 |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1222 if (prpl_num == GAIM_PROTO_OSCAR) { |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1223 if ((username = gaim_account_get_username(account)) != NULL) { |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1224 protocol = (isalpha(*username) |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1225 ? GAIM_PROTO_TOC : GAIM_PROTO_ICQ); |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1226 } |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1227 } |
5228 | 1228 |
1229 if (file != (char *)NULL) { | |
5435 | 1230 snprintf(path, PATHSIZE, "%s" G_DIR_SEPARATOR_S "%s.%d.blist", file, g_screenname, protocol); |
5228 | 1231 g_free(g_screenname); |
1232 } else { | |
1233 g_free(g_screenname); | |
1234 return; | |
1235 } | |
1236 } | |
1237 | |
1238 if (stat(path, &st)) { | |
1239 gaim_debug(GAIM_DEBUG_ERROR, "blist import", "Unable to stat %s.\n", | |
1240 path); | |
1241 return; | |
1242 } | |
1243 | |
1244 if (!(f = fopen(path, "r"))) { | |
1245 gaim_debug(GAIM_DEBUG_ERROR, "blist import", "Unable to open %s.\n", | |
1246 path); | |
1247 return; | |
1248 } | |
1249 | |
1250 fgets(first, 64, f); | |
1251 | |
1252 if ((first[0] == '\n') || (first[0] == '\r' && first[1] == '\n')) | |
1253 fgets(first, 64, f); | |
1254 | |
1255 #if 0 | |
1256 if (!g_strncasecmp(first, "<xml", strlen("<xml"))) { | |
1257 /* new gaim XML buddy list */ | |
1258 gaim_blist_read(path); | |
1259 | |
1260 /* We really don't need to bother doing stuf like translating AIM 3 buddy lists anymore */ | |
1261 | |
1262 } else if (!g_strncasecmp(first, "Config {", strlen("Config {"))) { | |
1263 /* AIM 4 buddy list */ | |
1264 gaim_debug(GAIM_DEBUG_MISC, "blist import", "aim 4\n"); | |
1265 rewind(f); | |
1266 buf = translate_blt(f); | |
1267 } else if (strstr(first, "group") != NULL) { | |
1268 /* AIM 3 buddy list */ | |
1269 gaim_debug(GAIM_DEBUG_MISC, "blist import", "aim 3\n"); | |
1270 rewind(f); | |
1271 buf = translate_lst(f); | |
1272 } else if (!g_strncasecmp(first, "[User]", strlen("[User]"))) { | |
1273 /* GnomeICU (hopefully) */ | |
1274 gaim_debug(GAIM_DEBUG_MISC, "blist import", "gnomeicu\n"); | |
1275 rewind(f); | |
1276 buf = translate_gnomeicu(f); | |
1277 | |
1278 } else | |
1279 #endif | |
1280 if (first[0] == 'm') { | |
1281 /* Gaim buddy list - no translation */ | |
1282 char buf2[BUF_LONG * 2]; | |
1283 buf = g_string_new(""); | |
1284 rewind(f); | |
1285 while (1) { | |
1286 len = fread(buf2, 1, BUF_LONG * 2 - 1, f); | |
1287 if (len <= 0) | |
1288 break; | |
1289 buf2[len] = '\0'; | |
1290 buf = g_string_append(buf, buf2); | |
1291 if (len != BUF_LONG * 2 - 1) | |
1292 break; | |
1293 } | |
1294 } | |
1295 | |
1296 fclose(f); | |
1297 | |
1298 if (buf) { | |
1299 buf = g_string_prepend(buf, "toc_set_config {"); | |
1300 buf = g_string_append(buf, "}\n"); | |
1301 parse_toc_buddy_list(account, buf->str); | |
1302 g_string_free(buf, TRUE); | |
1303 } | |
1304 } | |
1305 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1306 gboolean gaim_group_on_account(struct group *g, GaimAccount *account) { |
5228 | 1307 GaimBlistNode *bnode; |
1308 for(bnode = g->node.child; bnode; bnode = bnode->next) { | |
1309 struct buddy *b = (struct buddy *)bnode; | |
1310 if(!GAIM_BLIST_NODE_IS_BUDDY(bnode)) | |
1311 continue; | |
5855 | 1312 if((!account && gaim_account_is_connected(b->account)) |
1313 || b->account == account) | |
5228 | 1314 return TRUE; |
1315 } | |
1316 return FALSE; | |
1317 } | |
1318 | |
1319 static gboolean blist_safe_to_write = FALSE; | |
1320 | |
1321 static char *blist_parser_group_name = NULL; | |
1322 static char *blist_parser_person_name = NULL; | |
1323 static char *blist_parser_account_name = NULL; | |
1324 static int blist_parser_account_protocol = 0; | |
5234 | 1325 static char *blist_parser_chat_alias = NULL; |
1326 static char *blist_parser_component_name = NULL; | |
1327 static char *blist_parser_component_value = NULL; | |
5228 | 1328 static char *blist_parser_buddy_name = NULL; |
1329 static char *blist_parser_buddy_alias = NULL; | |
1330 static char *blist_parser_setting_name = NULL; | |
1331 static char *blist_parser_setting_value = NULL; | |
1332 static GHashTable *blist_parser_buddy_settings = NULL; | |
5906 | 1333 static GHashTable *blist_parser_chat_settings = NULL; |
5228 | 1334 static GHashTable *blist_parser_group_settings = NULL; |
5234 | 1335 static GHashTable *blist_parser_chat_components = NULL; |
5228 | 1336 static int blist_parser_privacy_mode = 0; |
1337 static GList *tag_stack = NULL; | |
1338 enum { | |
1339 BLIST_TAG_GAIM, | |
1340 BLIST_TAG_BLIST, | |
1341 BLIST_TAG_GROUP, | |
5234 | 1342 BLIST_TAG_CHAT, |
1343 BLIST_TAG_COMPONENT, | |
5228 | 1344 BLIST_TAG_PERSON, |
1345 BLIST_TAG_BUDDY, | |
1346 BLIST_TAG_NAME, | |
1347 BLIST_TAG_ALIAS, | |
1348 BLIST_TAG_SETTING, | |
1349 BLIST_TAG_PRIVACY, | |
1350 BLIST_TAG_ACCOUNT, | |
1351 BLIST_TAG_PERMIT, | |
1352 BLIST_TAG_BLOCK, | |
1353 BLIST_TAG_IGNORE | |
1354 }; | |
1355 static gboolean blist_parser_error_occurred = FALSE; | |
1356 | |
1357 static void blist_start_element_handler (GMarkupParseContext *context, | |
1358 const gchar *element_name, | |
1359 const gchar **attribute_names, | |
1360 const gchar **attribute_values, | |
1361 gpointer user_data, | |
1362 GError **error) { | |
1363 int i; | |
1364 | |
1365 if(!strcmp(element_name, "gaim")) { | |
1366 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_GAIM)); | |
1367 } else if(!strcmp(element_name, "blist")) { | |
1368 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_BLIST)); | |
1369 } else if(!strcmp(element_name, "group")) { | |
1370 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_GROUP)); | |
1371 for(i=0; attribute_names[i]; i++) { | |
1372 if(!strcmp(attribute_names[i], "name")) { | |
1373 g_free(blist_parser_group_name); | |
1374 blist_parser_group_name = g_strdup(attribute_values[i]); | |
1375 } | |
1376 } | |
1377 if(blist_parser_group_name) { | |
1378 struct group *g = gaim_group_new(blist_parser_group_name); | |
5634 | 1379 gaim_blist_add_group(g, |
1380 gaim_blist_get_last_sibling(gaimbuddylist->root)); | |
5228 | 1381 } |
5234 | 1382 } else if(!strcmp(element_name, "chat")) { |
1383 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_CHAT)); | |
1384 for(i=0; attribute_names[i]; i++) { | |
1385 if(!strcmp(attribute_names[i], "account")) { | |
1386 g_free(blist_parser_account_name); | |
1387 blist_parser_account_name = g_strdup(attribute_values[i]); | |
1388 } else if(!strcmp(attribute_names[i], "protocol")) { | |
1389 blist_parser_account_protocol = atoi(attribute_values[i]); | |
1390 } | |
1391 } | |
5228 | 1392 } else if(!strcmp(element_name, "person")) { |
1393 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_PERSON)); | |
1394 for(i=0; attribute_names[i]; i++) { | |
1395 if(!strcmp(attribute_names[i], "name")) { | |
1396 g_free(blist_parser_person_name); | |
1397 blist_parser_person_name = g_strdup(attribute_values[i]); | |
1398 } | |
1399 } | |
1400 } else if(!strcmp(element_name, "buddy")) { | |
1401 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_BUDDY)); | |
1402 for(i=0; attribute_names[i]; i++) { | |
1403 if(!strcmp(attribute_names[i], "account")) { | |
1404 g_free(blist_parser_account_name); | |
1405 blist_parser_account_name = g_strdup(attribute_values[i]); | |
1406 } else if(!strcmp(attribute_names[i], "protocol")) { | |
1407 blist_parser_account_protocol = atoi(attribute_values[i]); | |
1408 } | |
1409 } | |
1410 } else if(!strcmp(element_name, "name")) { | |
1411 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_NAME)); | |
1412 } else if(!strcmp(element_name, "alias")) { | |
1413 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_ALIAS)); | |
1414 } else if(!strcmp(element_name, "setting")) { | |
1415 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_SETTING)); | |
1416 for(i=0; attribute_names[i]; i++) { | |
1417 if(!strcmp(attribute_names[i], "name")) { | |
1418 g_free(blist_parser_setting_name); | |
1419 blist_parser_setting_name = g_strdup(attribute_values[i]); | |
1420 } | |
1421 } | |
5234 | 1422 } else if(!strcmp(element_name, "component")) { |
1423 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_COMPONENT)); | |
1424 for(i=0; attribute_names[i]; i++) { | |
1425 if(!strcmp(attribute_names[i], "name")) { | |
1426 g_free(blist_parser_component_name); | |
1427 blist_parser_component_name = g_strdup(attribute_values[i]); | |
1428 } | |
1429 } | |
1430 | |
5228 | 1431 } else if(!strcmp(element_name, "privacy")) { |
1432 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_PRIVACY)); | |
1433 } else if(!strcmp(element_name, "account")) { | |
1434 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_ACCOUNT)); | |
1435 for(i=0; attribute_names[i]; i++) { | |
1436 if(!strcmp(attribute_names[i], "protocol")) | |
1437 blist_parser_account_protocol = atoi(attribute_values[i]); | |
1438 else if(!strcmp(attribute_names[i], "mode")) | |
1439 blist_parser_privacy_mode = atoi(attribute_values[i]); | |
1440 else if(!strcmp(attribute_names[i], "name")) { | |
1441 g_free(blist_parser_account_name); | |
1442 blist_parser_account_name = g_strdup(attribute_values[i]); | |
1443 } | |
1444 } | |
1445 } else if(!strcmp(element_name, "permit")) { | |
1446 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_PERMIT)); | |
1447 } else if(!strcmp(element_name, "block")) { | |
1448 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_BLOCK)); | |
1449 } else if(!strcmp(element_name, "ignore")) { | |
1450 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_IGNORE)); | |
1451 } | |
1452 } | |
1453 | |
1454 static void blist_end_element_handler(GMarkupParseContext *context, | |
1455 const gchar *element_name, gpointer user_data, GError **error) { | |
1456 if(!strcmp(element_name, "gaim")) { | |
1457 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1458 } else if(!strcmp(element_name, "blist")) { | |
1459 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1460 } else if(!strcmp(element_name, "group")) { | |
1461 if(blist_parser_group_settings) { | |
1462 struct group *g = gaim_find_group(blist_parser_group_name); | |
1463 g_hash_table_destroy(g->settings); | |
1464 g->settings = blist_parser_group_settings; | |
1465 } | |
1466 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1467 blist_parser_group_settings = NULL; | |
5234 | 1468 } else if(!strcmp(element_name, "chat")) { |
5874
964e4f94fc56
[gaim-migrate @ 6306]
Christian Hammond <chipx86@chipx86.com>
parents:
5872
diff
changeset
|
1469 GaimAccount *account = gaim_accounts_find(blist_parser_account_name, |
5234 | 1470 blist_parser_account_protocol); |
5237 | 1471 if(account) { |
5234 | 1472 struct chat *chat = gaim_chat_new(account, blist_parser_chat_alias, blist_parser_chat_components); |
1473 struct group *g = gaim_find_group(blist_parser_group_name); | |
5634 | 1474 gaim_blist_add_chat(chat,g, |
1475 gaim_blist_get_last_child((GaimBlistNode*)g)); | |
5906 | 1476 if(blist_parser_chat_settings) { |
1477 g_hash_table_destroy(chat->settings); | |
1478 chat->settings = blist_parser_chat_settings; | |
1479 } | |
5234 | 1480 } |
1481 g_free(blist_parser_chat_alias); | |
1482 blist_parser_chat_alias = NULL; | |
1483 g_free(blist_parser_account_name); | |
1484 blist_parser_account_name = NULL; | |
1485 blist_parser_chat_components = NULL; | |
5906 | 1486 blist_parser_chat_settings = NULL; |
5234 | 1487 tag_stack = g_list_delete_link(tag_stack, tag_stack); |
5228 | 1488 } else if(!strcmp(element_name, "person")) { |
1489 g_free(blist_parser_person_name); | |
1490 blist_parser_person_name = NULL; | |
1491 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1492 } else if(!strcmp(element_name, "buddy")) { | |
5874
964e4f94fc56
[gaim-migrate @ 6306]
Christian Hammond <chipx86@chipx86.com>
parents:
5872
diff
changeset
|
1493 GaimAccount *account = gaim_accounts_find(blist_parser_account_name, |
5228 | 1494 blist_parser_account_protocol); |
1495 if(account) { | |
1496 struct buddy *b = gaim_buddy_new(account, blist_parser_buddy_name, blist_parser_buddy_alias); | |
1497 struct group *g = gaim_find_group(blist_parser_group_name); | |
5634 | 1498 gaim_blist_add_buddy(b,g, |
1499 gaim_blist_get_last_child((GaimBlistNode*)g)); | |
5228 | 1500 if(blist_parser_buddy_settings) { |
1501 g_hash_table_destroy(b->settings); | |
1502 b->settings = blist_parser_buddy_settings; | |
1503 } | |
1504 } | |
1505 g_free(blist_parser_buddy_name); | |
1506 blist_parser_buddy_name = NULL; | |
1507 g_free(blist_parser_buddy_alias); | |
1508 blist_parser_buddy_alias = NULL; | |
1509 g_free(blist_parser_account_name); | |
1510 blist_parser_account_name = NULL; | |
1511 blist_parser_buddy_settings = NULL; | |
1512 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1513 } else if(!strcmp(element_name, "name")) { | |
1514 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1515 } else if(!strcmp(element_name, "alias")) { | |
1516 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
5234 | 1517 } else if(!strcmp(element_name, "component")) { |
1518 if(!blist_parser_chat_components) | |
1519 blist_parser_chat_components = g_hash_table_new_full(g_str_hash, | |
1520 g_str_equal, g_free, g_free); | |
1521 if(blist_parser_component_name && blist_parser_component_value) { | |
1522 g_hash_table_replace(blist_parser_chat_components, | |
1523 g_strdup(blist_parser_component_name), | |
1524 g_strdup(blist_parser_component_value)); | |
1525 } | |
1526 g_free(blist_parser_component_name); | |
1527 g_free(blist_parser_component_value); | |
1528 blist_parser_component_name = NULL; | |
1529 blist_parser_component_value = NULL; | |
1530 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
5228 | 1531 } else if(!strcmp(element_name, "setting")) { |
1532 if(GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_BUDDY) { | |
1533 if(!blist_parser_buddy_settings) | |
1534 blist_parser_buddy_settings = g_hash_table_new_full(g_str_hash, | |
1535 g_str_equal, g_free, g_free); | |
1536 if(blist_parser_setting_name && blist_parser_setting_value) { | |
1537 g_hash_table_replace(blist_parser_buddy_settings, | |
1538 g_strdup(blist_parser_setting_name), | |
1539 g_strdup(blist_parser_setting_value)); | |
1540 } | |
5906 | 1541 } else if(GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_CHAT) { |
1542 if(!blist_parser_chat_settings) | |
1543 blist_parser_chat_settings = g_hash_table_new_full(g_str_hash, | |
1544 g_str_equal, g_free, g_free); | |
1545 if(blist_parser_setting_name && blist_parser_setting_value) { | |
1546 g_hash_table_replace(blist_parser_buddy_settings, | |
1547 g_strdup(blist_parser_setting_name), | |
1548 g_strdup(blist_parser_setting_value)); | |
1549 } | |
5228 | 1550 } else if(GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_GROUP) { |
1551 if(!blist_parser_group_settings) | |
1552 blist_parser_group_settings = g_hash_table_new_full(g_str_hash, | |
1553 g_str_equal, g_free, g_free); | |
1554 if(blist_parser_setting_name && blist_parser_setting_value) { | |
1555 g_hash_table_replace(blist_parser_group_settings, | |
1556 g_strdup(blist_parser_setting_name), | |
1557 g_strdup(blist_parser_setting_value)); | |
1558 } | |
1559 } | |
1560 g_free(blist_parser_setting_name); | |
1561 g_free(blist_parser_setting_value); | |
1562 blist_parser_setting_name = NULL; | |
1563 blist_parser_setting_value = NULL; | |
1564 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1565 } else if(!strcmp(element_name, "privacy")) { | |
1566 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1567 } else if(!strcmp(element_name, "account")) { | |
5874
964e4f94fc56
[gaim-migrate @ 6306]
Christian Hammond <chipx86@chipx86.com>
parents:
5872
diff
changeset
|
1568 GaimAccount *account = gaim_accounts_find(blist_parser_account_name, |
5228 | 1569 blist_parser_account_protocol); |
1570 if(account) { | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1571 account->perm_deny = blist_parser_privacy_mode; |
5228 | 1572 } |
1573 g_free(blist_parser_account_name); | |
1574 blist_parser_account_name = NULL; | |
1575 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1576 } else if(!strcmp(element_name, "permit")) { | |
5874
964e4f94fc56
[gaim-migrate @ 6306]
Christian Hammond <chipx86@chipx86.com>
parents:
5872
diff
changeset
|
1577 GaimAccount *account = gaim_accounts_find(blist_parser_account_name, |
5228 | 1578 blist_parser_account_protocol); |
1579 if(account) { | |
1580 gaim_privacy_permit_add(account, blist_parser_buddy_name); | |
1581 } | |
1582 g_free(blist_parser_buddy_name); | |
1583 blist_parser_buddy_name = NULL; | |
1584 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1585 } else if(!strcmp(element_name, "block")) { | |
5874
964e4f94fc56
[gaim-migrate @ 6306]
Christian Hammond <chipx86@chipx86.com>
parents:
5872
diff
changeset
|
1586 GaimAccount *account = gaim_accounts_find(blist_parser_account_name, |
5228 | 1587 blist_parser_account_protocol); |
1588 if(account) { | |
1589 gaim_privacy_deny_add(account, blist_parser_buddy_name); | |
1590 } | |
1591 g_free(blist_parser_buddy_name); | |
1592 blist_parser_buddy_name = NULL; | |
1593 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1594 } else if(!strcmp(element_name, "ignore")) { | |
1595 /* we'll apparently do something with this later */ | |
1596 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1597 } | |
1598 } | |
1599 | |
1600 static void blist_text_handler(GMarkupParseContext *context, const gchar *text, | |
1601 gsize text_len, gpointer user_data, GError **error) { | |
1602 switch(GPOINTER_TO_INT(tag_stack->data)) { | |
1603 case BLIST_TAG_NAME: | |
1604 blist_parser_buddy_name = g_strndup(text, text_len); | |
1605 break; | |
1606 case BLIST_TAG_ALIAS: | |
5234 | 1607 if(tag_stack->next && |
1608 GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_BUDDY) | |
1609 blist_parser_buddy_alias = g_strndup(text, text_len); | |
1610 else if(tag_stack->next && | |
1611 GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_CHAT) | |
1612 blist_parser_chat_alias = g_strndup(text, text_len); | |
5228 | 1613 break; |
1614 case BLIST_TAG_PERMIT: | |
1615 case BLIST_TAG_BLOCK: | |
1616 case BLIST_TAG_IGNORE: | |
1617 blist_parser_buddy_name = g_strndup(text, text_len); | |
1618 break; | |
5234 | 1619 case BLIST_TAG_COMPONENT: |
1620 blist_parser_component_value = g_strndup(text, text_len); | |
1621 break; | |
5228 | 1622 case BLIST_TAG_SETTING: |
1623 blist_parser_setting_value = g_strndup(text, text_len); | |
1624 break; | |
1625 default: | |
1626 break; | |
1627 } | |
1628 } | |
1629 | |
1630 static void blist_error_handler(GMarkupParseContext *context, GError *error, | |
1631 gpointer user_data) { | |
1632 blist_parser_error_occurred = TRUE; | |
1633 gaim_debug(GAIM_DEBUG_ERROR, "blist import", | |
1634 "Error parsing blist.xml: %s\n", error->message); | |
1635 } | |
1636 | |
1637 static GMarkupParser blist_parser = { | |
1638 blist_start_element_handler, | |
1639 blist_end_element_handler, | |
1640 blist_text_handler, | |
1641 NULL, | |
1642 blist_error_handler | |
1643 }; | |
1644 | |
1645 static gboolean gaim_blist_read(const char *filename) { | |
1646 gchar *contents = NULL; | |
1647 gsize length; | |
1648 GMarkupParseContext *context; | |
1649 GError *error = NULL; | |
1650 | |
1651 gaim_debug(GAIM_DEBUG_INFO, "blist import", | |
1652 "Reading %s\n", filename); | |
1653 if(!g_file_get_contents(filename, &contents, &length, &error)) { | |
1654 gaim_debug(GAIM_DEBUG_ERROR, "blist import", | |
1655 "Error reading blist: %s\n", error->message); | |
1656 g_error_free(error); | |
1657 return FALSE; | |
1658 } | |
1659 | |
1660 context = g_markup_parse_context_new(&blist_parser, 0, NULL, NULL); | |
1661 | |
1662 if(!g_markup_parse_context_parse(context, contents, length, NULL)) { | |
1663 g_markup_parse_context_free(context); | |
1664 g_free(contents); | |
1665 return FALSE; | |
1666 } | |
1667 | |
1668 if(!g_markup_parse_context_end_parse(context, NULL)) { | |
1669 gaim_debug(GAIM_DEBUG_ERROR, "blist import", | |
1670 "Error parsing %s\n", filename); | |
1671 g_markup_parse_context_free(context); | |
1672 g_free(contents); | |
1673 return FALSE; | |
1674 } | |
1675 | |
1676 g_markup_parse_context_free(context); | |
1677 g_free(contents); | |
1678 | |
1679 if(blist_parser_error_occurred) | |
1680 return FALSE; | |
1681 | |
1682 gaim_debug(GAIM_DEBUG_INFO, "blist import", "Finished reading %s\n", | |
1683 filename); | |
1684 | |
1685 return TRUE; | |
1686 } | |
1687 | |
1688 void gaim_blist_load() { | |
5580
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
1689 GList *accts; |
5228 | 1690 char *user_dir = gaim_user_dir(); |
1691 char *filename; | |
1692 char *msg; | |
1693 | |
1694 blist_safe_to_write = TRUE; | |
1695 | |
1696 if(!user_dir) | |
1697 return; | |
1698 | |
1699 filename = g_build_filename(user_dir, "blist.xml", NULL); | |
1700 | |
1701 if(g_file_test(filename, G_FILE_TEST_EXISTS)) { | |
1702 if(!gaim_blist_read(filename)) { | |
1703 msg = g_strdup_printf(_("An error was encountered parsing your " | |
1704 "buddy list. It has not been loaded.")); | |
5436
ad445074d239
[gaim-migrate @ 5818]
Christian Hammond <chipx86@chipx86.com>
parents:
5435
diff
changeset
|
1705 gaim_notify_error(NULL, NULL, _("Buddy List Error"), msg); |
5228 | 1706 g_free(msg); |
1707 } | |
5580
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
1708 } else if(g_list_length(gaim_accounts_get_all())) { |
5947
ac4dd1d0ee39
[gaim-migrate @ 6388]
Christian Hammond <chipx86@chipx86.com>
parents:
5943
diff
changeset
|
1709 GMainContext *ctx; |
ac4dd1d0ee39
[gaim-migrate @ 6388]
Christian Hammond <chipx86@chipx86.com>
parents:
5943
diff
changeset
|
1710 |
5228 | 1711 /* rob wants to inform the user that their buddy lists are |
1712 * being converted */ | |
1713 msg = g_strdup_printf(_("Gaim is converting your old buddy lists " | |
1714 "to a new format, which will now be located at %s"), | |
1715 filename); | |
5436
ad445074d239
[gaim-migrate @ 5818]
Christian Hammond <chipx86@chipx86.com>
parents:
5435
diff
changeset
|
1716 gaim_notify_info(NULL, NULL, _("Converting Buddy List"), msg); |
5228 | 1717 g_free(msg); |
1718 | |
1719 /* now, let gtk actually display the dialog before we start anything */ | |
5947
ac4dd1d0ee39
[gaim-migrate @ 6388]
Christian Hammond <chipx86@chipx86.com>
parents:
5943
diff
changeset
|
1720 ctx = g_main_context_default(); |
ac4dd1d0ee39
[gaim-migrate @ 6388]
Christian Hammond <chipx86@chipx86.com>
parents:
5943
diff
changeset
|
1721 |
ac4dd1d0ee39
[gaim-migrate @ 6388]
Christian Hammond <chipx86@chipx86.com>
parents:
5943
diff
changeset
|
1722 while(g_main_context_pending(ctx)) |
ac4dd1d0ee39
[gaim-migrate @ 6388]
Christian Hammond <chipx86@chipx86.com>
parents:
5943
diff
changeset
|
1723 g_main_context_iteration(ctx, FALSE); |
5228 | 1724 |
1725 /* read in the old lists, then save to the new format */ | |
5580
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
1726 for(accts = gaim_accounts_get_all(); accts; accts = accts->next) { |
5228 | 1727 do_import(accts->data, NULL); |
1728 } | |
1729 gaim_blist_save(); | |
1730 } | |
1731 | |
1732 g_free(filename); | |
1733 } | |
1734 | |
1735 static void blist_print_group_settings(gpointer key, gpointer data, | |
1736 gpointer user_data) { | |
1737 char *key_val; | |
1738 char *data_val; | |
1739 FILE *file = user_data; | |
1740 | |
1741 if(!key || !data) | |
1742 return; | |
1743 | |
1744 key_val = g_markup_escape_text(key, -1); | |
1745 data_val = g_markup_escape_text(data, -1); | |
1746 | |
1747 fprintf(file, "\t\t\t<setting name=\"%s\">%s</setting>\n", key_val, | |
1748 data_val); | |
1749 g_free(key_val); | |
1750 g_free(data_val); | |
1751 } | |
1752 | |
1753 static void blist_print_buddy_settings(gpointer key, gpointer data, | |
1754 gpointer user_data) { | |
1755 char *key_val; | |
1756 char *data_val; | |
1757 FILE *file = user_data; | |
1758 | |
1759 if(!key || !data) | |
1760 return; | |
1761 | |
1762 key_val = g_markup_escape_text(key, -1); | |
1763 data_val = g_markup_escape_text(data, -1); | |
1764 | |
1765 fprintf(file, "\t\t\t\t\t<setting name=\"%s\">%s</setting>\n", key_val, | |
1766 data_val); | |
1767 g_free(key_val); | |
1768 g_free(data_val); | |
1769 } | |
1770 | |
5234 | 1771 static void blist_print_chat_components(gpointer key, gpointer data, |
1772 gpointer user_data) { | |
1773 char *key_val; | |
1774 char *data_val; | |
1775 FILE *file = user_data; | |
1776 | |
1777 if(!key || !data) | |
1778 return; | |
1779 | |
1780 key_val = g_markup_escape_text(key, -1); | |
1781 data_val = g_markup_escape_text(data, -1); | |
1782 | |
1783 fprintf(file, "\t\t\t\t<component name=\"%s\">%s</component>\n", key_val, | |
1784 data_val); | |
1785 g_free(key_val); | |
1786 g_free(data_val); | |
1787 } | |
1788 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1789 static void gaim_blist_write(FILE *file, GaimAccount *exp_acct) { |
5580
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
1790 GList *accounts; |
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
1791 GSList *buds; |
5228 | 1792 GaimBlistNode *gnode,*bnode; |
1793 struct group *group; | |
1794 struct buddy *bud; | |
1795 fprintf(file, "<?xml version='1.0' encoding='UTF-8' ?>\n"); | |
1796 fprintf(file, "<gaim version=\"1\">\n"); | |
1797 fprintf(file, "\t<blist>\n"); | |
1798 | |
1799 for(gnode = gaimbuddylist->root; gnode; gnode = gnode->next) { | |
1800 if(!GAIM_BLIST_NODE_IS_GROUP(gnode)) | |
1801 continue; | |
1802 group = (struct group *)gnode; | |
1803 if(!exp_acct || gaim_group_on_account(group, exp_acct)) { | |
1804 char *group_name = g_markup_escape_text(group->name, -1); | |
1805 fprintf(file, "\t\t<group name=\"%s\">\n", group_name); | |
1806 g_hash_table_foreach(group->settings, blist_print_group_settings, file); | |
1807 for(bnode = gnode->child; bnode; bnode = bnode->next) { | |
5234 | 1808 if(GAIM_BLIST_NODE_IS_BUDDY(bnode)) { |
1809 bud = (struct buddy *)bnode; | |
1810 if(!exp_acct || bud->account == exp_acct) { | |
1811 char *bud_name = g_markup_escape_text(bud->name, -1); | |
1812 char *bud_alias = NULL; | |
1813 char *acct_name = g_markup_escape_text(bud->account->username, -1); | |
1814 if(bud->alias) | |
1815 bud_alias= g_markup_escape_text(bud->alias, -1); | |
1816 fprintf(file, "\t\t\t<person name=\"%s\">\n", | |
1817 bud_alias ? bud_alias : bud_name); | |
1818 fprintf(file, "\t\t\t\t<buddy protocol=\"%d\" " | |
5943
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1819 "account=\"%s\">\n", |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1820 gaim_account_get_protocol(bud->account), |
5234 | 1821 acct_name); |
1822 fprintf(file, "\t\t\t\t\t<name>%s</name>\n", bud_name); | |
1823 if(bud_alias) { | |
1824 fprintf(file, "\t\t\t\t\t<alias>%s</alias>\n", | |
1825 bud_alias); | |
1826 } | |
1827 g_hash_table_foreach(bud->settings, | |
1828 blist_print_buddy_settings, file); | |
1829 fprintf(file, "\t\t\t\t</buddy>\n"); | |
1830 fprintf(file, "\t\t\t</person>\n"); | |
1831 g_free(bud_name); | |
1832 g_free(bud_alias); | |
1833 g_free(acct_name); | |
5228 | 1834 } |
5234 | 1835 } else if(GAIM_BLIST_NODE_IS_CHAT(bnode)) { |
1836 struct chat *chat = (struct chat *)bnode; | |
1837 if(!exp_acct || chat->account == exp_acct) { | |
1838 char *acct_name = g_markup_escape_text(chat->account->username, -1); | |
5943
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1839 fprintf(file, "\t\t\t<chat protocol=\"%d\" account=\"%s\">\n", |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1840 gaim_account_get_protocol(chat->account), |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1841 acct_name); |
5237 | 1842 if(chat->alias) { |
1843 char *chat_alias = g_markup_escape_text(chat->alias, -1); | |
1844 fprintf(file, "\t\t\t\t<alias>%s</alias>\n", chat_alias); | |
1845 g_free(chat_alias); | |
1846 } | |
5234 | 1847 g_hash_table_foreach(chat->components, |
1848 blist_print_chat_components, file); | |
5906 | 1849 /* works for chats too, I don't feel like renaming */ |
1850 g_hash_table_foreach(chat->settings, | |
1851 blist_print_buddy_settings, file); | |
5234 | 1852 fprintf(file, "\t\t\t</chat>\n"); |
5237 | 1853 g_free(acct_name); |
5234 | 1854 } |
5228 | 1855 } |
1856 } | |
1857 fprintf(file, "\t\t</group>\n"); | |
1858 g_free(group_name); | |
1859 } | |
1860 } | |
1861 | |
1862 fprintf(file, "\t</blist>\n"); | |
1863 fprintf(file, "\t<privacy>\n"); | |
1864 | |
5580
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
1865 for(accounts = gaim_accounts_get_all(); |
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
1866 accounts != NULL; |
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
1867 accounts = accounts->next) { |
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
1868 |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1869 GaimAccount *account = accounts->data; |
5228 | 1870 char *acct_name = g_markup_escape_text(account->username, -1); |
1871 if(!exp_acct || account == exp_acct) { | |
1872 fprintf(file, "\t\t<account protocol=\"%d\" name=\"%s\" " | |
5943
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1873 "mode=\"%d\">\n", gaim_account_get_protocol(account), |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1874 acct_name, account->perm_deny); |
5228 | 1875 for(buds = account->permit; buds; buds = buds->next) { |
1876 char *bud_name = g_markup_escape_text(buds->data, -1); | |
1877 fprintf(file, "\t\t\t<permit>%s</permit>\n", bud_name); | |
1878 g_free(bud_name); | |
1879 } | |
1880 for(buds = account->deny; buds; buds = buds->next) { | |
1881 char *bud_name = g_markup_escape_text(buds->data, -1); | |
1882 fprintf(file, "\t\t\t<block>%s</block>\n", bud_name); | |
1883 g_free(bud_name); | |
1884 } | |
1885 fprintf(file, "\t\t</account>\n"); | |
1886 } | |
1887 g_free(acct_name); | |
1888 } | |
1889 | |
1890 fprintf(file, "\t</privacy>\n"); | |
1891 fprintf(file, "</gaim>\n"); | |
1892 } | |
1893 | |
1894 void gaim_blist_save() { | |
1895 FILE *file; | |
1896 char *user_dir = gaim_user_dir(); | |
1897 char *filename; | |
1898 char *filename_real; | |
1899 | |
1900 if(!user_dir) | |
1901 return; | |
1902 if(!blist_safe_to_write) { | |
1903 gaim_debug(GAIM_DEBUG_WARNING, "blist save", | |
1904 "AHH!! Tried to write the blist before we read it!\n"); | |
1905 return; | |
1906 } | |
1907 | |
1908 file = fopen(user_dir, "r"); | |
1909 if(!file) | |
1910 mkdir(user_dir, S_IRUSR | S_IWUSR | S_IXUSR); | |
1911 else | |
1912 fclose(file); | |
1913 | |
1914 filename = g_build_filename(user_dir, "blist.xml.save", NULL); | |
1915 | |
1916 if((file = fopen(filename, "w"))) { | |
1917 gaim_blist_write(file, NULL); | |
1918 fclose(file); | |
1919 chmod(filename, S_IRUSR | S_IWUSR); | |
1920 } else { | |
1921 gaim_debug(GAIM_DEBUG_ERROR, "blist save", "Unable to write %s\n", | |
1922 filename); | |
1923 } | |
1924 | |
1925 filename_real = g_build_filename(user_dir, "blist.xml", NULL); | |
1926 | |
1927 if(rename(filename, filename_real) < 0) | |
1928 gaim_debug(GAIM_DEBUG_ERROR, "blist save", | |
1929 "Error renaming %s to %s\n", filename, filename_real); | |
1930 | |
1931 | |
1932 g_free(filename); | |
1933 g_free(filename_real); | |
1934 } | |
1935 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1936 gboolean gaim_privacy_permit_add(GaimAccount *account, const char *who) { |
5228 | 1937 GSList *d = account->permit; |
1938 char *n = g_strdup(normalize(who)); | |
1939 while(d) { | |
1940 if(!gaim_utf8_strcasecmp(n, normalize(d->data))) | |
1941 break; | |
1942 d = d->next; | |
1943 } | |
1944 g_free(n); | |
1945 if(!d) { | |
1946 account->permit = g_slist_append(account->permit, g_strdup(who)); | |
1947 return TRUE; | |
1948 } | |
1949 | |
1950 return FALSE; | |
1951 } | |
1952 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1953 gboolean gaim_privacy_permit_remove(GaimAccount *account, const char *who) { |
5228 | 1954 GSList *d = account->permit; |
1955 char *n = g_strdup(normalize(who)); | |
1956 while(d) { | |
1957 if(!gaim_utf8_strcasecmp(n, normalize(d->data))) | |
1958 break; | |
1959 d = d->next; | |
1960 } | |
1961 g_free(n); | |
1962 if(d) { | |
1963 account->permit = g_slist_remove(account->permit, d->data); | |
1964 g_free(d->data); | |
1965 return TRUE; | |
1966 } | |
1967 return FALSE; | |
1968 } | |
1969 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1970 gboolean gaim_privacy_deny_add(GaimAccount *account, const char *who) { |
5228 | 1971 GSList *d = account->deny; |
1972 char *n = g_strdup(normalize(who)); | |
1973 while(d) { | |
1974 if(!gaim_utf8_strcasecmp(n, normalize(d->data))) | |
1975 break; | |
1976 d = d->next; | |
1977 } | |
1978 g_free(n); | |
1979 if(!d) { | |
1980 account->deny = g_slist_append(account->deny, g_strdup(who)); | |
1981 return TRUE; | |
1982 } | |
1983 | |
1984 return FALSE; | |
1985 } | |
1986 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1987 gboolean gaim_privacy_deny_remove(GaimAccount *account, const char *who) { |
5228 | 1988 GSList *d = account->deny; |
1989 char *n = g_strdup(normalize(who)); | |
1990 while(d) { | |
1991 if(!gaim_utf8_strcasecmp(n, normalize(d->data))) | |
1992 break; | |
1993 d = d->next; | |
1994 } | |
1995 g_free(n); | |
1996 if(d) { | |
1997 account->deny = g_slist_remove(account->deny, d->data); | |
1998 g_free(d->data); | |
1999 return TRUE; | |
2000 } | |
2001 return FALSE; | |
2002 } | |
2003 | |
2004 void gaim_group_set_setting(struct group *g, const char *key, | |
2005 const char *value) { | |
2006 if(!g) | |
2007 return; | |
2008 g_hash_table_replace(g->settings, g_strdup(key), g_strdup(value)); | |
2009 } | |
2010 | |
2011 char *gaim_group_get_setting(struct group *g, const char *key) { | |
2012 if(!g) | |
2013 return NULL; | |
2014 return g_strdup(g_hash_table_lookup(g->settings, key)); | |
2015 } | |
2016 | |
5906 | 2017 void gaim_chat_set_setting(struct chat *c, const char *key, |
2018 const char *value) | |
2019 { | |
2020 if(!c) | |
2021 return; | |
2022 g_hash_table_replace(c->settings, g_strdup(key), g_strdup(value)); | |
2023 } | |
2024 | |
2025 char *gaim_chat_get_setting(struct chat *c, const char *key) | |
2026 { | |
2027 if(!c) | |
2028 return NULL; | |
2029 return g_strdup(g_hash_table_lookup(c->settings, key)); | |
2030 } | |
2031 | |
5228 | 2032 void gaim_buddy_set_setting(struct buddy *b, const char *key, |
2033 const char *value) { | |
2034 if(!b) | |
2035 return; | |
2036 g_hash_table_replace(b->settings, g_strdup(key), g_strdup(value)); | |
2037 } | |
2038 | |
2039 char *gaim_buddy_get_setting(struct buddy *b, const char *key) { | |
2040 if(!b) | |
2041 return NULL; | |
2042 return g_strdup(g_hash_table_lookup(b->settings, key)); | |
2043 } | |
2044 | |
2045 void gaim_set_blist_ui_ops(struct gaim_blist_ui_ops *ops) | |
2046 { | |
2047 blist_ui_ops = ops; | |
2048 } | |
2049 | |
2050 struct gaim_blist_ui_ops * | |
2051 gaim_get_blist_ui_ops(void) | |
2052 { | |
2053 return blist_ui_ops; | |
2054 } | |
2055 | |
2056 int gaim_blist_get_group_size(struct group *group, gboolean offline) { | |
2057 if(!group) | |
2058 return 0; | |
2059 | |
5277 | 2060 return offline ? group->totalsize : group->currentsize; |
5228 | 2061 } |
2062 | |
2063 int gaim_blist_get_group_online_count(struct group *group) { | |
2064 if(!group) | |
2065 return 0; | |
2066 | |
5277 | 2067 return group->online; |
5228 | 2068 } |
2069 | |
2070 |