Mercurial > pidgin
annotate src/blist.c @ 6821:636b5215552e
[gaim-migrate @ 7365]
Adding blogger whatchamacallit
committer: Tailor Script <tailor@pidgin.im>
author | Herman Bloggs <hermanator12002@yahoo.com> |
---|---|
date | Fri, 12 Sep 2003 23:32:10 +0000 |
parents | ff477c28df7b |
children | f76e26a0e6a9 |
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" |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
32 #include "signals.h" |
5872
059d95c67cda
[gaim-migrate @ 6304]
Christian Hammond <chipx86@chipx86.com>
parents:
5855
diff
changeset
|
33 #include "util.h" |
5228 | 34 |
35 #define PATHSIZE 1024 | |
36 | |
37 struct gaim_buddy_list *gaimbuddylist = NULL; | |
38 static struct gaim_blist_ui_ops *blist_ui_ops = NULL; | |
39 | |
40 /***************************************************************************** | |
41 * Private Utility functions * | |
42 *****************************************************************************/ | |
43 static GaimBlistNode *gaim_blist_get_last_sibling(GaimBlistNode *node) | |
44 { | |
45 GaimBlistNode *n = node; | |
46 if (!n) | |
47 return NULL; | |
48 while (n->next) | |
49 n = n->next; | |
50 return n; | |
51 } | |
6695 | 52 |
5228 | 53 static GaimBlistNode *gaim_blist_get_last_child(GaimBlistNode *node) |
54 { | |
55 if (!node) | |
56 return NULL; | |
57 return gaim_blist_get_last_sibling(node->child); | |
58 } | |
59 | |
5247 | 60 struct _gaim_hbuddy { |
61 char *name; | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
62 GaimAccount *account; |
5758 | 63 GaimBlistNode *group; |
5247 | 64 }; |
65 | |
66 static guint _gaim_blist_hbuddy_hash (struct _gaim_hbuddy *hb) | |
67 { | |
68 return g_str_hash(hb->name); | |
69 } | |
70 | |
71 static guint _gaim_blist_hbuddy_equal (struct _gaim_hbuddy *hb1, struct _gaim_hbuddy *hb2) | |
72 { | |
5758 | 73 return ((!strcmp(hb1->name, hb2->name)) && hb1->account == hb2->account && hb1->group == hb2->group); |
5247 | 74 } |
75 | |
6742 | 76 static void _gaim_blist_hbuddy_free_key(struct _gaim_hbuddy *hb) |
77 { | |
78 g_free(hb->name); | |
79 g_free(hb); | |
80 } | |
81 | |
6006 | 82 static void blist_pref_cb(const char *name, GaimPrefType typ, gpointer value, gpointer data) |
83 { | |
6012 | 84 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; |
6695 | 85 GaimBlistNode *gnode, *cnode, *bnode; |
6012 | 86 |
87 if (!ops) | |
88 return; | |
89 | |
6695 | 90 for(gnode = gaimbuddylist->root; gnode; gnode = gnode->next) { |
91 if(!GAIM_BLIST_NODE_IS_GROUP(gnode)) | |
6012 | 92 continue; |
6695 | 93 for(cnode = gnode->child; cnode; cnode = cnode->next) { |
94 if(GAIM_BLIST_NODE_IS_CONTACT(cnode)) { | |
95 for(bnode = cnode->child; bnode; bnode = bnode->next) { | |
96 if(!GAIM_BLIST_NODE_IS_BUDDY(bnode)) | |
97 continue; | |
98 ops->update(gaimbuddylist, bnode); | |
99 } | |
100 } else if(GAIM_BLIST_NODE_IS_CHAT(cnode)) { | |
101 ops->update(gaimbuddylist, cnode); | |
102 } | |
6012 | 103 } |
104 } | |
6006 | 105 } |
106 | |
5228 | 107 /***************************************************************************** |
108 * Public API functions * | |
109 *****************************************************************************/ | |
110 | |
111 struct gaim_buddy_list *gaim_blist_new() | |
112 { | |
113 struct gaim_buddy_list *gbl = g_new0(struct gaim_buddy_list, 1); | |
114 | |
115 gbl->ui_ops = gaim_get_blist_ui_ops(); | |
116 | |
6742 | 117 gbl->buddies = g_hash_table_new_full((GHashFunc)_gaim_blist_hbuddy_hash, |
118 (GEqualFunc)_gaim_blist_hbuddy_equal, | |
119 (GDestroyNotify)_gaim_blist_hbuddy_free_key, NULL); | |
5247 | 120 |
5228 | 121 if (gbl->ui_ops != NULL && gbl->ui_ops->new_list != NULL) |
122 gbl->ui_ops->new_list(gbl); | |
123 | |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
124 gaim_prefs_connect_callback("/core/buddies/use_server_alias", |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
125 blist_pref_cb, NULL); |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
126 |
6006 | 127 |
5228 | 128 return gbl; |
129 } | |
130 | |
131 void | |
132 gaim_set_blist(struct gaim_buddy_list *list) | |
133 { | |
134 gaimbuddylist = list; | |
135 } | |
136 | |
137 struct gaim_buddy_list * | |
138 gaim_get_blist(void) | |
139 { | |
140 return gaimbuddylist; | |
141 } | |
142 | |
6695 | 143 void gaim_blist_show () |
5228 | 144 { |
145 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
146 if (ops) | |
147 ops->show(gaimbuddylist); | |
148 } | |
149 | |
150 void gaim_blist_destroy() | |
151 { | |
152 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
153 if (ops) | |
154 ops->destroy(gaimbuddylist); | |
155 } | |
156 | |
157 void gaim_blist_set_visible (gboolean show) | |
158 { | |
159 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
160 if (ops) | |
161 ops->set_visible(gaimbuddylist, show); | |
162 } | |
163 | |
6695 | 164 void gaim_blist_update_buddy_status (GaimBuddy *buddy, int status) |
5228 | 165 { |
5266
b3a03b86b09b
[gaim-migrate @ 5638]
Christian Hammond <chipx86@chipx86.com>
parents:
5259
diff
changeset
|
166 struct gaim_blist_ui_ops *ops; |
b3a03b86b09b
[gaim-migrate @ 5638]
Christian Hammond <chipx86@chipx86.com>
parents:
5259
diff
changeset
|
167 |
b3a03b86b09b
[gaim-migrate @ 5638]
Christian Hammond <chipx86@chipx86.com>
parents:
5259
diff
changeset
|
168 if (buddy->uc == status) |
b3a03b86b09b
[gaim-migrate @ 5638]
Christian Hammond <chipx86@chipx86.com>
parents:
5259
diff
changeset
|
169 return; |
b3a03b86b09b
[gaim-migrate @ 5638]
Christian Hammond <chipx86@chipx86.com>
parents:
5259
diff
changeset
|
170 |
b3a03b86b09b
[gaim-migrate @ 5638]
Christian Hammond <chipx86@chipx86.com>
parents:
5259
diff
changeset
|
171 ops = gaimbuddylist->ui_ops; |
5228 | 172 |
5305 | 173 if((status & UC_UNAVAILABLE) != (buddy->uc & UC_UNAVAILABLE)) { |
174 if(status & UC_UNAVAILABLE) | |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
175 gaim_signal_emit(gaim_blist_get_handle(), "buddy-away", buddy); |
5305 | 176 else |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
177 gaim_signal_emit(gaim_blist_get_handle(), "buddy-back", buddy); |
5305 | 178 } |
5228 | 179 |
5305 | 180 buddy->uc = status; |
5228 | 181 if (ops) |
182 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
183 } | |
184 | |
6695 | 185 static gboolean presence_update_timeout_cb(GaimBuddy *buddy) { |
5228 | 186 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; |
6640
314111e7b601
[gaim-migrate @ 7165]
Christian Hammond <chipx86@chipx86.com>
parents:
6564
diff
changeset
|
187 GaimConversation *conv; |
314111e7b601
[gaim-migrate @ 7165]
Christian Hammond <chipx86@chipx86.com>
parents:
6564
diff
changeset
|
188 |
314111e7b601
[gaim-migrate @ 7165]
Christian Hammond <chipx86@chipx86.com>
parents:
6564
diff
changeset
|
189 conv = gaim_find_conversation_with_account(buddy->name, buddy->account); |
5228 | 190 |
191 if(buddy->present == GAIM_BUDDY_SIGNING_ON) { | |
192 buddy->present = GAIM_BUDDY_ONLINE; | |
193 } else if(buddy->present == GAIM_BUDDY_SIGNING_OFF) { | |
194 buddy->present = GAIM_BUDDY_OFFLINE; | |
195 } | |
196 | |
197 buddy->timer = 0; | |
198 | |
199 if (ops) | |
200 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
201 | |
6392
e9974608b319
[gaim-migrate @ 6897]
Christian Hammond <chipx86@chipx86.com>
parents:
6378
diff
changeset
|
202 if (conv) { |
e9974608b319
[gaim-migrate @ 6897]
Christian Hammond <chipx86@chipx86.com>
parents:
6378
diff
changeset
|
203 if (buddy->present == GAIM_BUDDY_ONLINE) |
e9974608b319
[gaim-migrate @ 6897]
Christian Hammond <chipx86@chipx86.com>
parents:
6378
diff
changeset
|
204 gaim_conversation_update(conv, GAIM_CONV_ACCOUNT_ONLINE); |
e9974608b319
[gaim-migrate @ 6897]
Christian Hammond <chipx86@chipx86.com>
parents:
6378
diff
changeset
|
205 else if (buddy->present == GAIM_BUDDY_OFFLINE) |
e9974608b319
[gaim-migrate @ 6897]
Christian Hammond <chipx86@chipx86.com>
parents:
6378
diff
changeset
|
206 gaim_conversation_update(conv, GAIM_CONV_ACCOUNT_OFFLINE); |
e9974608b319
[gaim-migrate @ 6897]
Christian Hammond <chipx86@chipx86.com>
parents:
6378
diff
changeset
|
207 } |
e9974608b319
[gaim-migrate @ 6897]
Christian Hammond <chipx86@chipx86.com>
parents:
6378
diff
changeset
|
208 |
5228 | 209 return FALSE; |
210 } | |
211 | |
6695 | 212 void gaim_blist_update_buddy_presence(GaimBuddy *buddy, int presence) { |
5228 | 213 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; |
214 gboolean do_timer = FALSE; | |
215 | |
216 if (!GAIM_BUDDY_IS_ONLINE(buddy) && presence) { | |
217 buddy->present = GAIM_BUDDY_SIGNING_ON; | |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
218 gaim_signal_emit(gaim_blist_get_handle(), "buddy-signed-on", buddy); |
5228 | 219 do_timer = TRUE; |
6695 | 220 ((GaimContact*)((GaimBlistNode*)buddy)->parent)->online++; |
221 if(((GaimContact*)((GaimBlistNode*)buddy)->parent)->online == 1) | |
222 ((GaimGroup *)((GaimBlistNode *)buddy)->parent->parent)->online++; | |
5228 | 223 } else if(GAIM_BUDDY_IS_ONLINE(buddy) && !presence) { |
224 buddy->present = GAIM_BUDDY_SIGNING_OFF; | |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
225 gaim_signal_emit(gaim_blist_get_handle(), "buddy-signed-off", buddy); |
5228 | 226 do_timer = TRUE; |
6695 | 227 ((GaimContact*)((GaimBlistNode*)buddy)->parent)->online--; |
228 if(((GaimContact*)((GaimBlistNode*)buddy)->parent)->online == 0) | |
229 ((GaimGroup *)((GaimBlistNode *)buddy)->parent->parent)->online--; | |
5228 | 230 } |
231 | |
232 if(do_timer) { | |
233 if(buddy->timer > 0) | |
234 g_source_remove(buddy->timer); | |
235 buddy->timer = g_timeout_add(10000, (GSourceFunc)presence_update_timeout_cb, buddy); | |
236 } | |
237 | |
238 if (ops) | |
239 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
240 } | |
241 | |
242 | |
6695 | 243 void gaim_blist_update_buddy_idle (GaimBuddy *buddy, int idle) |
5228 | 244 { |
245 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
246 buddy->idle = idle; | |
247 if (ops) | |
248 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
249 } | |
6695 | 250 |
251 void gaim_blist_update_buddy_evil (GaimBuddy *buddy, int warning) | |
5228 | 252 { |
253 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
254 buddy->evil = warning; | |
255 if (ops) | |
256 ops->update(gaimbuddylist,(GaimBlistNode*)buddy); | |
257 } | |
6695 | 258 |
259 void gaim_blist_update_buddy_icon(GaimBuddy *buddy) { | |
5228 | 260 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; |
261 if(ops) | |
262 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
263 } | |
6695 | 264 |
265 void gaim_blist_rename_buddy (GaimBuddy *buddy, const char *name) | |
5228 | 266 { |
267 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
5634 | 268 g_free(buddy->name); |
5228 | 269 buddy->name = g_strdup(name); |
270 if (ops) | |
271 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
272 } | |
5234 | 273 |
6695 | 274 void gaim_blist_alias_chat(GaimBlistChat *chat, const char *alias) |
5234 | 275 { |
276 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
277 | |
5237 | 278 g_free(chat->alias); |
5234 | 279 |
5237 | 280 if(alias && strlen(alias)) |
281 chat->alias = g_strdup(alias); | |
282 else | |
283 chat->alias = NULL; | |
284 | |
5234 | 285 if(ops) |
286 ops->update(gaimbuddylist, (GaimBlistNode*)chat); | |
287 } | |
288 | |
6695 | 289 void gaim_blist_alias_buddy (GaimBuddy *buddy, const char *alias) |
5228 | 290 { |
291 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
5676
dae79aefac8d
[gaim-migrate @ 6094]
Christian Hammond <chipx86@chipx86.com>
parents:
5634
diff
changeset
|
292 GaimConversation *conv; |
5228 | 293 |
294 g_free(buddy->alias); | |
295 | |
296 if(alias && strlen(alias)) | |
297 buddy->alias = g_strdup(alias); | |
298 else | |
299 buddy->alias = NULL; | |
300 | |
301 if (ops) | |
302 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
303 | |
304 conv = gaim_find_conversation_with_account(buddy->name, buddy->account); | |
305 | |
306 if (conv) | |
307 gaim_conversation_autoset_title(conv); | |
308 } | |
309 | |
6695 | 310 void gaim_blist_server_alias_buddy (GaimBuddy *buddy, const char *alias) |
6058 | 311 { |
312 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
313 GaimConversation *conv; | |
314 | |
315 g_free(buddy->server_alias); | |
316 | |
317 if(alias && strlen(alias) && g_utf8_validate(alias, -1, NULL)) | |
318 buddy->server_alias = g_strdup(alias); | |
319 else | |
320 buddy->server_alias = NULL; | |
321 | |
322 if (ops) | |
323 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
324 | |
325 conv = gaim_find_conversation_with_account(buddy->name, buddy->account); | |
326 | |
327 if (conv) | |
328 gaim_conversation_autoset_title(conv); | |
329 } | |
330 | |
6695 | 331 void gaim_blist_rename_group(GaimGroup *group, const char *name) |
5228 | 332 { |
333 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
6695 | 334 GaimGroup *dest_group; |
5346 | 335 GaimBlistNode *prev, *child, *next; |
336 GSList *accts; | |
337 | |
338 if(!name || !strlen(name) || !strcmp(name, group->name)) { | |
339 /* nothing to do here */ | |
340 return; | |
341 } else if((dest_group = gaim_find_group(name))) { | |
342 /* here we're merging two groups */ | |
343 prev = gaim_blist_get_last_child((GaimBlistNode*)dest_group); | |
344 child = ((GaimBlistNode*)group)->child; | |
345 | |
346 while(child) | |
347 { | |
348 next = child->next; | |
6695 | 349 if(GAIM_BLIST_NODE_IS_CONTACT(child)) { |
350 GaimBlistNode *bnode; | |
351 gaim_blist_add_contact((GaimContact *)child, dest_group, prev); | |
352 for(bnode = child->child; bnode; bnode = bnode->next) | |
353 gaim_blist_add_buddy((GaimBuddy*)bnode, (GaimContact*)child, | |
354 NULL, bnode->prev); | |
5346 | 355 prev = child; |
356 } else if(GAIM_BLIST_NODE_IS_CHAT(child)) { | |
6695 | 357 gaim_blist_add_chat((GaimBlistChat *)child, dest_group, prev); |
5346 | 358 prev = child; |
359 } else { | |
360 gaim_debug(GAIM_DEBUG_ERROR, "blist", | |
361 "Unknown child type in group %s\n", group->name); | |
362 } | |
363 child = next; | |
364 } | |
365 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
|
366 GaimAccount *account = accts->data; |
5346 | 367 serv_rename_group(account->gc, group, name); |
368 } | |
369 gaim_blist_remove_group(group); | |
370 } else { | |
371 /* a simple rename */ | |
372 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
|
373 GaimAccount *account = accts->data; |
5346 | 374 serv_rename_group(account->gc, group, name); |
375 } | |
376 g_free(group->name); | |
377 group->name = g_strdup(name); | |
378 if (ops) | |
379 ops->update(gaimbuddylist, (GaimBlistNode*)group); | |
380 } | |
5228 | 381 } |
5234 | 382 |
6695 | 383 GaimBlistChat *gaim_blist_chat_new(GaimAccount *account, const char *alias, GHashTable *components) |
5234 | 384 { |
6695 | 385 GaimBlistChat *chat; |
5234 | 386 struct gaim_blist_ui_ops *ops; |
387 | |
5237 | 388 if(!components) |
5234 | 389 return NULL; |
390 | |
6695 | 391 chat = g_new0(GaimBlistChat, 1); |
5234 | 392 chat->account = account; |
5237 | 393 if(alias && strlen(alias)) |
394 chat->alias = g_strdup(alias); | |
5234 | 395 chat->components = components; |
5906 | 396 chat->settings = g_hash_table_new_full(g_str_hash, g_str_equal, |
397 g_free, g_free); | |
5234 | 398 |
399 ((GaimBlistNode*)chat)->type = GAIM_BLIST_CHAT_NODE; | |
400 | |
401 ops = gaim_get_blist_ui_ops(); | |
402 | |
403 if (ops != NULL && ops->new_node != NULL) | |
404 ops->new_node((GaimBlistNode *)chat); | |
405 | |
406 return chat; | |
407 } | |
408 | |
6695 | 409 char *gaim_blist_chat_get_display_name(GaimBlistChat *chat) |
6034 | 410 { |
411 char *name; | |
412 | |
413 if(chat->alias){ | |
414 name = g_strdup(chat->alias); | |
415 } | |
416 else{ | |
417 GList *parts; | |
418 GaimPlugin *prpl; | |
419 GaimPluginProtocolInfo *prpl_info; | |
420 struct proto_chat_entry *pce; | |
421 | |
422 prpl = gaim_find_prpl(gaim_account_get_protocol(chat->account)); | |
423 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(prpl); | |
424 | |
425 parts = prpl_info->chat_info(chat->account->gc); | |
426 | |
427 pce = parts->data; | |
428 name = g_markup_escape_text(g_hash_table_lookup(chat->components, | |
429 pce->identifier), -1); | |
430 g_list_free(parts); | |
431 } | |
432 | |
433 return name; | |
434 } | |
435 | |
6695 | 436 GaimBuddy *gaim_buddy_new(GaimAccount *account, const char *screenname, const char *alias) |
5228 | 437 { |
6695 | 438 GaimBuddy *b; |
5228 | 439 struct gaim_blist_ui_ops *ops; |
440 | |
6695 | 441 b = g_new0(GaimBuddy, 1); |
5228 | 442 b->account = account; |
443 b->name = g_strdup(screenname); | |
444 b->alias = g_strdup(alias); | |
445 b->settings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); | |
446 ((GaimBlistNode*)b)->type = GAIM_BLIST_BUDDY_NODE; | |
447 | |
448 ops = gaim_get_blist_ui_ops(); | |
449 | |
450 if (ops != NULL && ops->new_node != NULL) | |
451 ops->new_node((GaimBlistNode *)b); | |
452 | |
453 return b; | |
454 } | |
5634 | 455 |
6695 | 456 void gaim_blist_add_chat(GaimBlistChat *chat, GaimGroup *group, GaimBlistNode *node) |
5234 | 457 { |
458 GaimBlistNode *n = node, *cnode = (GaimBlistNode*)chat; | |
6695 | 459 GaimGroup *g = group; |
5234 | 460 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; |
461 gboolean save = FALSE; | |
462 | |
6774 | 463 |
464 g_return_if_fail(chat != NULL); | |
465 g_return_if_fail(GAIM_BLIST_NODE_IS_CHAT((GaimBlistNode*)chat)); | |
466 | |
5234 | 467 if (!n) { |
468 if (!g) { | |
469 g = gaim_group_new(_("Chats")); | |
5634 | 470 gaim_blist_add_group(g, |
471 gaim_blist_get_last_sibling(gaimbuddylist->root)); | |
5234 | 472 } |
473 } else { | |
6695 | 474 g = (GaimGroup*)n->parent; |
5234 | 475 } |
476 | |
477 /* if we're moving to overtop of ourselves, do nothing */ | |
478 if(cnode == n) | |
479 return; | |
480 | |
481 if (cnode->parent) { | |
482 /* This chat was already in the list and is | |
483 * being moved. | |
484 */ | |
6695 | 485 ((GaimGroup *)cnode->parent)->totalsize--; |
5855 | 486 if (gaim_account_is_connected(chat->account)) { |
6695 | 487 ((GaimGroup *)cnode->parent)->online--; |
488 ((GaimGroup *)cnode->parent)->currentsize--; | |
5287 | 489 } |
5234 | 490 if(cnode->next) |
491 cnode->next->prev = cnode->prev; | |
492 if(cnode->prev) | |
493 cnode->prev->next = cnode->next; | |
494 if(cnode->parent->child == cnode) | |
495 cnode->parent->child = cnode->next; | |
496 | |
497 ops->remove(gaimbuddylist, cnode); | |
498 | |
499 save = TRUE; | |
500 } | |
501 | |
502 if (n) { | |
503 if(n->next) | |
504 n->next->prev = cnode; | |
505 cnode->next = n->next; | |
506 cnode->prev = n; | |
507 cnode->parent = n->parent; | |
508 n->next = cnode; | |
6695 | 509 ((GaimGroup *)n->parent)->totalsize++; |
5855 | 510 if (gaim_account_is_connected(chat->account)) { |
6695 | 511 ((GaimGroup *)n->parent)->online++; |
512 ((GaimGroup *)n->parent)->currentsize++; | |
5287 | 513 } |
5234 | 514 } else { |
5634 | 515 if(((GaimBlistNode*)g)->child) |
516 ((GaimBlistNode*)g)->child->prev = cnode; | |
517 cnode->next = ((GaimBlistNode*)g)->child; | |
518 cnode->prev = NULL; | |
5234 | 519 ((GaimBlistNode*)g)->child = cnode; |
520 cnode->parent = (GaimBlistNode*)g; | |
5277 | 521 g->totalsize++; |
5855 | 522 if (gaim_account_is_connected(chat->account)) { |
5287 | 523 g->online++; |
5277 | 524 g->currentsize++; |
5287 | 525 } |
5234 | 526 } |
527 | |
528 if (ops) | |
529 ops->update(gaimbuddylist, (GaimBlistNode*)cnode); | |
530 if (save) | |
531 gaim_blist_save(); | |
532 } | |
533 | |
6695 | 534 void gaim_blist_add_buddy (GaimBuddy *buddy, GaimContact *contact, GaimGroup *group, GaimBlistNode *node) |
5228 | 535 { |
6695 | 536 GaimBlistNode *cnode, *bnode; |
537 GaimGroup *g; | |
538 GaimContact *c; | |
5228 | 539 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; |
6695 | 540 gboolean save = FALSE; |
5247 | 541 struct _gaim_hbuddy *hb; |
6695 | 542 |
543 g_return_if_fail(buddy != NULL); | |
6774 | 544 g_return_if_fail(GAIM_BLIST_NODE_IS_BUDDY((GaimBlistNode*)buddy)); |
6695 | 545 |
546 bnode = (GaimBlistNode *)buddy; | |
5228 | 547 |
6695 | 548 /* if we're moving to overtop of ourselves, do nothing */ |
549 if(bnode == node || (!node && bnode->parent && | |
550 contact && bnode->parent == (GaimBlistNode*)contact | |
551 && bnode == bnode->parent->child)) | |
552 return; | |
553 | |
554 if(node && GAIM_BLIST_NODE_IS_BUDDY(node)) { | |
555 c = (GaimContact*)node->parent; | |
556 g = (GaimGroup*)node->parent->parent; | |
557 } else if(contact) { | |
558 c = contact; | |
559 g = (GaimGroup*)((GaimBlistNode*)c)->parent; | |
560 } else { | |
561 if(group) { | |
562 g = group; | |
563 } else { | |
5228 | 564 g = gaim_group_new(_("Buddies")); |
5634 | 565 gaim_blist_add_group(g, |
566 gaim_blist_get_last_sibling(gaimbuddylist->root)); | |
5228 | 567 } |
6695 | 568 c = gaim_contact_new(); |
569 gaim_blist_add_contact(c, g, | |
570 gaim_blist_get_last_child((GaimBlistNode*)g)); | |
5228 | 571 } |
572 | |
6695 | 573 cnode = (GaimBlistNode *)c; |
5228 | 574 |
6695 | 575 if(bnode->parent) { |
576 if(GAIM_BUDDY_IS_ONLINE(buddy)) { | |
577 ((GaimContact*)bnode->parent)->online--; | |
578 if(((GaimContact*)bnode->parent)->online == 0) | |
579 ((GaimGroup*)bnode->parent->parent)->online--; | |
580 } | |
581 if(gaim_account_is_connected(buddy->account)) { | |
582 ((GaimContact*)bnode->parent)->currentsize--; | |
583 if(((GaimContact*)bnode->parent)->currentsize == 0) | |
584 ((GaimGroup*)bnode->parent->parent)->currentsize--; | |
585 } | |
586 ((GaimContact*)bnode->parent)->totalsize--; | |
587 /* the group totalsize will be taken care of by remove_contact below */ | |
588 | |
589 if(bnode->parent->parent != (GaimBlistNode*)g) | |
590 serv_move_buddy(buddy, (GaimGroup *)bnode->parent->parent, g); | |
5277 | 591 |
5228 | 592 if(bnode->next) |
593 bnode->next->prev = bnode->prev; | |
594 if(bnode->prev) | |
595 bnode->prev->next = bnode->next; | |
6794 | 596 if(bnode->parent->child == bnode) |
5228 | 597 bnode->parent->child = bnode->next; |
598 | |
599 ops->remove(gaimbuddylist, bnode); | |
600 | |
601 save = TRUE; | |
6742 | 602 |
603 if(bnode->parent->parent != (GaimBlistNode*)g) { | |
604 hb = g_new(struct _gaim_hbuddy, 1); | |
605 hb->name = normalize(buddy->name); | |
606 hb->account = buddy->account; | |
607 hb->group = bnode->parent->parent; | |
6775 | 608 g_hash_table_remove(gaimbuddylist->buddies, hb); |
6742 | 609 g_free(hb); |
610 } | |
6794 | 611 |
612 if(!bnode->parent->child) | |
613 gaim_blist_remove_contact((GaimContact*)bnode->parent); | |
614 | |
5228 | 615 } |
616 | |
6695 | 617 if(node && GAIM_BLIST_NODE_IS_BUDDY(node)) { |
618 if(node->next) | |
619 node->next->prev = bnode; | |
620 bnode->next = node->next; | |
621 bnode->prev = node; | |
622 bnode->parent = node->parent; | |
623 node->next = bnode; | |
5228 | 624 } else { |
6695 | 625 if(cnode->child) |
626 cnode->child->prev = bnode; | |
627 bnode->prev = NULL; | |
628 bnode->next = cnode->child; | |
629 cnode->child = bnode; | |
630 bnode->parent = cnode; | |
5228 | 631 } |
632 | |
6695 | 633 if(GAIM_BUDDY_IS_ONLINE(buddy)) { |
634 ((GaimContact*)bnode->parent)->online++; | |
635 if(((GaimContact*)bnode->parent)->online == 1) | |
636 ((GaimGroup*)bnode->parent->parent)->online++; | |
637 } | |
638 if(gaim_account_is_connected(buddy->account)) { | |
639 ((GaimContact*)bnode->parent)->currentsize++; | |
640 if(((GaimContact*)bnode->parent)->currentsize == 1) | |
641 ((GaimGroup*)bnode->parent->parent)->currentsize++; | |
642 } | |
643 ((GaimContact*)bnode->parent)->totalsize++; | |
644 | |
645 | |
6742 | 646 hb = g_new(struct _gaim_hbuddy, 1); |
5247 | 647 hb->name = g_strdup(normalize(buddy->name)); |
648 hb->account = buddy->account; | |
6695 | 649 hb->group = ((GaimBlistNode*)buddy)->parent->parent; |
5247 | 650 |
6742 | 651 g_hash_table_replace(gaimbuddylist->buddies, hb, buddy); |
5247 | 652 |
5228 | 653 if (ops) |
654 ops->update(gaimbuddylist, (GaimBlistNode*)buddy); | |
655 if (save) | |
656 gaim_blist_save(); | |
657 } | |
658 | |
6695 | 659 GaimContact *gaim_contact_new() |
5228 | 660 { |
6695 | 661 struct gaim_blist_ui_ops *ops; |
662 GaimContact *c = g_new0(GaimContact, 1); | |
663 ((GaimBlistNode*)c)->type = GAIM_BLIST_CONTACT_NODE; | |
664 | |
665 c->totalsize = c->currentsize = c->online = 0; | |
666 | |
667 ops = gaim_get_blist_ui_ops(); | |
668 if (ops != NULL && ops->new_node != NULL) | |
669 ops->new_node((GaimBlistNode *)c); | |
670 | |
671 return c; | |
672 } | |
673 | |
6755 | 674 void gaim_contact_set_alias(GaimContact* contact, const char *alias) |
675 { | |
676 g_return_if_fail(contact != NULL); | |
677 | |
678 if(contact->alias) | |
679 g_free(contact->alias); | |
680 | |
681 contact->alias = g_strdup(alias); | |
682 } | |
683 | |
684 const char *gaim_contact_get_alias(GaimContact* contact) | |
685 { | |
686 return contact ? contact->alias : NULL; | |
687 } | |
688 | |
6695 | 689 GaimGroup *gaim_group_new(const char *name) |
690 { | |
691 GaimGroup *g = gaim_find_group(name); | |
5228 | 692 |
693 if (!g) { | |
694 struct gaim_blist_ui_ops *ops; | |
6695 | 695 g= g_new0(GaimGroup, 1); |
5228 | 696 g->name = g_strdup(name); |
5277 | 697 g->totalsize = 0; |
698 g->currentsize = 0; | |
699 g->online = 0; | |
5228 | 700 g->settings = g_hash_table_new_full(g_str_hash, g_str_equal, |
701 g_free, g_free); | |
702 ((GaimBlistNode*)g)->type = GAIM_BLIST_GROUP_NODE; | |
703 | |
704 ops = gaim_get_blist_ui_ops(); | |
705 | |
706 if (ops != NULL && ops->new_node != NULL) | |
707 ops->new_node((GaimBlistNode *)g); | |
708 | |
709 } | |
710 return g; | |
711 } | |
712 | |
6695 | 713 void gaim_blist_add_contact(GaimContact *contact, GaimGroup *group, GaimBlistNode *node) |
714 { | |
715 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
716 GaimGroup *g; | |
6742 | 717 GaimBlistNode *gnode, *cnode, *bnode; |
6695 | 718 gboolean save = FALSE; |
719 | |
6774 | 720 g_return_if_fail(contact != NULL); |
721 g_return_if_fail(GAIM_BLIST_NODE_IS_CONTACT((GaimBlistNode*)contact)); | |
6695 | 722 |
723 if(node && (GAIM_BLIST_NODE_IS_CONTACT(node) || | |
724 GAIM_BLIST_NODE_IS_CHAT(node))) | |
725 g = (GaimGroup*)node->parent; | |
726 else if(group) | |
727 g = group; | |
728 else { | |
729 g = gaim_group_new(_("Buddies")); | |
730 gaim_blist_add_group(g, | |
731 gaim_blist_get_last_sibling(gaimbuddylist->root)); | |
732 } | |
733 | |
734 gnode = (GaimBlistNode*)g; | |
735 cnode = (GaimBlistNode*)contact; | |
736 | |
737 if(cnode->parent) { | |
6731 | 738 if(cnode->parent->child == cnode) |
739 cnode->parent->child = cnode->next; | |
6695 | 740 if(cnode->prev) |
741 cnode->prev->next = cnode->next; | |
742 if(cnode->next) | |
743 cnode->next->prev = cnode->prev; | |
744 | |
745 | |
746 if(contact->online > 0) | |
747 ((GaimGroup*)cnode->parent)->online--; | |
748 if(contact->currentsize > 0) | |
749 ((GaimGroup*)cnode->parent)->currentsize--; | |
750 ((GaimGroup*)cnode->parent)->totalsize--; | |
751 | |
6731 | 752 ops->remove(gaimbuddylist, cnode); |
753 | |
6695 | 754 save = TRUE; |
6742 | 755 |
756 if(cnode->parent != gnode) { | |
757 for(bnode = cnode->child; bnode; bnode = bnode->next) { | |
758 GaimBuddy *b = (GaimBuddy*)bnode; | |
759 | |
760 struct _gaim_hbuddy *hb = g_new(struct _gaim_hbuddy, 1); | |
761 hb->name = g_strdup(normalize(b->name)); | |
762 hb->account = b->account; | |
763 hb->group = cnode->parent; | |
764 | |
6776 | 765 g_hash_table_remove(gaimbuddylist->buddies, hb); |
6742 | 766 |
767 hb->group = gnode; | |
768 g_hash_table_replace(gaimbuddylist->buddies, hb, b); | |
769 | |
770 if(b->account->gc) | |
771 serv_move_buddy(b, (GaimGroup*)cnode->parent, g); | |
772 } | |
773 } | |
6695 | 774 } |
775 | |
6775 | 776 |
6695 | 777 if(node && (GAIM_BLIST_NODE_IS_CONTACT(node) || |
778 GAIM_BLIST_NODE_IS_CHAT(node))) { | |
779 if(node->next) | |
780 node->next->prev = cnode; | |
781 cnode->next = node->next; | |
782 cnode->prev = node; | |
783 cnode->parent = node->parent; | |
784 node->next = cnode; | |
785 } else { | |
786 if(gnode->child) | |
787 gnode->child->prev = cnode; | |
788 cnode->prev = NULL; | |
789 cnode->next = gnode->child; | |
790 gnode->child = cnode; | |
791 cnode->parent = gnode; | |
792 } | |
793 | |
794 if(contact->online > 0) | |
795 g->online++; | |
796 if(contact->currentsize > 0) | |
797 g->currentsize++; | |
798 g->totalsize++; | |
799 | |
800 if(ops && cnode->child) | |
801 ops->update(gaimbuddylist, cnode); | |
6775 | 802 |
803 for(bnode = cnode->child; bnode; bnode = bnode->next) | |
804 ops->update(gaimbuddylist, bnode); | |
805 | |
6695 | 806 if (save) |
807 gaim_blist_save(); | |
808 } | |
809 | |
810 void gaim_blist_add_group (GaimGroup *group, GaimBlistNode *node) | |
5228 | 811 { |
812 struct gaim_blist_ui_ops *ops; | |
813 GaimBlistNode *gnode = (GaimBlistNode*)group; | |
814 gboolean save = FALSE; | |
815 | |
6774 | 816 g_return_if_fail(group != NULL); |
817 g_return_if_fail(GAIM_BLIST_NODE_IS_GROUP((GaimBlistNode*)group)); | |
818 | |
5228 | 819 if (!gaimbuddylist) |
820 gaimbuddylist = gaim_blist_new(); | |
821 ops = gaimbuddylist->ui_ops; | |
822 | |
823 if (!gaimbuddylist->root) { | |
824 gaimbuddylist->root = gnode; | |
825 return; | |
826 } | |
827 | |
828 /* if we're moving to overtop of ourselves, do nothing */ | |
829 if(gnode == node) | |
830 return; | |
831 | |
832 if (gaim_find_group(group->name)) { | |
833 /* This is just being moved */ | |
834 | |
835 ops->remove(gaimbuddylist, (GaimBlistNode*)group); | |
836 | |
837 if(gnode == gaimbuddylist->root) | |
838 gaimbuddylist->root = gnode->next; | |
839 if(gnode->prev) | |
840 gnode->prev->next = gnode->next; | |
841 if(gnode->next) | |
842 gnode->next->prev = gnode->prev; | |
843 | |
844 save = TRUE; | |
845 } | |
846 | |
6695 | 847 if (node && GAIM_BLIST_NODE_IS_GROUP(node)) { |
5634 | 848 gnode->next = node->next; |
849 gnode->prev = node; | |
850 if(node->next) | |
851 node->next->prev = gnode; | |
852 node->next = gnode; | |
853 } else { | |
6807 | 854 if(gaimbuddylist->root) |
855 gaimbuddylist->root->prev = gnode; | |
5634 | 856 gnode->next = gaimbuddylist->root; |
857 gnode->prev = NULL; | |
858 gaimbuddylist->root = gnode; | |
859 } | |
860 | |
5228 | 861 |
862 if (ops) { | |
863 ops->update(gaimbuddylist, gnode); | |
864 for(node = gnode->child; node; node = node->next) | |
865 ops->update(gaimbuddylist, node); | |
866 } | |
867 if (save) | |
868 gaim_blist_save(); | |
869 } | |
870 | |
6695 | 871 void gaim_blist_remove_contact(GaimContact* contact) |
5228 | 872 { |
873 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
874 | |
6695 | 875 GaimBlistNode *gnode, *cnode = (GaimBlistNode*)contact; |
876 | |
877 gnode = cnode->parent; | |
878 | |
879 if(cnode->child) { | |
880 while(cnode->child) { | |
881 gaim_blist_remove_buddy((GaimBuddy*)cnode->child); | |
882 } | |
883 } else { | |
884 if(ops) | |
885 ops->remove(gaimbuddylist, cnode); | |
886 | |
887 if(gnode->child == cnode) | |
888 gnode->child = cnode->next; | |
889 if(cnode->prev) | |
890 cnode->prev->next = cnode->next; | |
891 if(cnode->next) | |
892 cnode->next->prev = cnode->prev; | |
893 | |
894 g_free(contact); | |
895 } | |
896 } | |
897 | |
6742 | 898 void gaim_blist_remove_buddy (GaimBuddy *buddy) |
6695 | 899 { |
900 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
901 | |
902 GaimBlistNode *cnode, *node = (GaimBlistNode*)buddy; | |
903 GaimGroup *group; | |
6742 | 904 struct _gaim_hbuddy hb; |
5228 | 905 |
6695 | 906 cnode = node->parent; |
907 group = (GaimGroup *)cnode->parent; | |
5228 | 908 |
6695 | 909 if(GAIM_BUDDY_IS_ONLINE(buddy)) { |
910 ((GaimContact*)cnode)->online--; | |
911 if(((GaimContact*)cnode)->online == 0) | |
912 group->online--; | |
913 } | |
914 if(gaim_account_is_connected(buddy->account)) { | |
915 ((GaimContact*)cnode)->currentsize--; | |
916 if(((GaimContact*)cnode)->currentsize == 0) | |
917 group->currentsize--; | |
918 } | |
919 ((GaimContact*)cnode)->totalsize--; | |
920 | |
5228 | 921 if (node->prev) |
922 node->prev->next = node->next; | |
923 if (node->next) | |
924 node->next->prev = node->prev; | |
6695 | 925 if(cnode->child == node) { |
926 cnode->child = node->next; | |
927 } | |
5228 | 928 |
6755 | 929 |
5247 | 930 hb.name = normalize(buddy->name); |
931 hb.account = buddy->account; | |
6695 | 932 hb.group = ((GaimBlistNode*)buddy)->parent->parent; |
6742 | 933 g_hash_table_remove(gaimbuddylist->buddies, &hb); |
5247 | 934 |
5292 | 935 if(buddy->timer > 0) |
936 g_source_remove(buddy->timer); | |
937 | |
5228 | 938 ops->remove(gaimbuddylist, node); |
939 g_hash_table_destroy(buddy->settings); | |
940 g_free(buddy->name); | |
941 g_free(buddy->alias); | |
942 g_free(buddy); | |
6755 | 943 |
944 if(!cnode->child) | |
945 gaim_blist_remove_contact((GaimContact*)cnode); | |
5228 | 946 } |
947 | |
6695 | 948 void gaim_blist_remove_chat (GaimBlistChat *chat) |
5234 | 949 { |
950 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
951 | |
952 GaimBlistNode *gnode, *node = (GaimBlistNode*)chat; | |
6695 | 953 GaimGroup *group; |
5234 | 954 |
955 gnode = node->parent; | |
6695 | 956 group = (GaimGroup *)gnode; |
5234 | 957 |
958 if(gnode->child == node) | |
959 gnode->child = node->next; | |
960 if (node->prev) | |
961 node->prev->next = node->next; | |
962 if (node->next) | |
963 node->next->prev = node->prev; | |
5277 | 964 group->totalsize--; |
5855 | 965 if (gaim_account_is_connected(chat->account)) { |
5277 | 966 group->currentsize--; |
5394 | 967 group->online--; |
968 } | |
5234 | 969 |
970 ops->remove(gaimbuddylist, node); | |
971 g_hash_table_destroy(chat->components); | |
972 g_free(chat->alias); | |
973 g_free(chat); | |
974 } | |
975 | |
6695 | 976 void gaim_blist_remove_group (GaimGroup *group) |
5228 | 977 { |
978 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
979 GaimBlistNode *node = (GaimBlistNode*)group; | |
980 | |
981 if(node->child) { | |
982 char *buf; | |
983 int count = 0; | |
984 GaimBlistNode *child = node->child; | |
985 | |
986 while(child) { | |
987 count++; | |
988 child = child->next; | |
989 } | |
990 | |
6308 | 991 buf = g_strdup_printf(ngettext("%d buddy from group %s was not removed " |
992 "because its account was not logged in." | |
993 " This buddy and the group were not " | |
994 "removed.\n", | |
995 "%d buddies from group %s were not " | |
996 "removed because their accounts were " | |
6336 | 997 "not logged in. These buddies and " |
998 "the group were not removed.\n", count), | |
6308 | 999 count, group->name); |
5541
aee0ee458974
[gaim-migrate @ 5941]
Christian Hammond <chipx86@chipx86.com>
parents:
5436
diff
changeset
|
1000 gaim_notify_error(NULL, NULL, _("Group not removed"), buf); |
5228 | 1001 g_free(buf); |
1002 return; | |
1003 } | |
1004 | |
1005 if(gaimbuddylist->root == node) | |
1006 gaimbuddylist->root = node->next; | |
1007 if (node->prev) | |
1008 node->prev->next = node->next; | |
1009 if (node->next) | |
1010 node->next->prev = node->prev; | |
1011 | |
1012 ops->remove(gaimbuddylist, node); | |
1013 g_free(group->name); | |
1014 g_free(group); | |
1015 } | |
1016 | |
6695 | 1017 GaimBuddy *gaim_contact_get_priority_buddy(GaimContact *contact) { |
1018 GaimBuddy *top = NULL; | |
1019 GaimBlistNode *bnode; | |
1020 | |
1021 for(bnode = ((GaimBlistNode*)contact)->child; bnode; bnode = bnode->next) { | |
1022 GaimBuddy *buddy; | |
1023 if(!GAIM_BLIST_NODE_IS_BUDDY(bnode)) | |
1024 continue; | |
1025 buddy = (GaimBuddy*)bnode; | |
1026 if(!top) { | |
1027 top = buddy; | |
1028 } else if(GAIM_BUDDY_IS_ONLINE(buddy)) { | |
1029 if(!GAIM_BUDDY_IS_ONLINE(top)) { | |
1030 top = buddy; | |
1031 } else if(!(buddy->uc & UC_UNAVAILABLE) && !buddy->idle && | |
1032 (top->uc & UC_UNAVAILABLE || top->idle)) { | |
1033 top = buddy; | |
1034 } else if(!buddy->idle && top->idle) { | |
1035 top = buddy; | |
1036 } else if(top->uc & UC_UNAVAILABLE && top->idle && | |
1037 (!(buddy->uc & UC_UNAVAILABLE) || !buddy->idle)) { | |
1038 top = buddy; | |
1039 } | |
1040 } | |
1041 } | |
1042 | |
1043 return top; | |
1044 } | |
1045 | |
1046 const char *gaim_get_buddy_alias_only(GaimBuddy *b) { | |
5545
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
1047 if(!b) |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
1048 return NULL; |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
1049 |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
1050 if(b->alias && b->alias[0]) { |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
1051 return b->alias; |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
1052 } |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
1053 else if (b->server_alias != NULL && |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
1054 gaim_prefs_get_bool("/core/buddies/use_server_alias")) { |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
1055 |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
1056 return b->server_alias; |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
1057 } |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
1058 |
7a64114641c3
[gaim-migrate @ 5946]
Christian Hammond <chipx86@chipx86.com>
parents:
5541
diff
changeset
|
1059 return NULL; |
5228 | 1060 } |
1061 | |
6695 | 1062 const char * gaim_get_buddy_alias (GaimBuddy *buddy) |
5228 | 1063 { |
6755 | 1064 GaimContact *contact; |
1065 const char *ret; | |
1066 | |
1067 if(!buddy) | |
1068 return _("Unknown"); | |
5228 | 1069 |
6755 | 1070 contact = (GaimContact*)((GaimBlistNode*)buddy)->parent; |
6036 | 1071 |
6755 | 1072 if(contact && contact->alias) |
1073 return contact->alias; | |
1074 | |
1075 ret= gaim_get_buddy_alias_only(buddy); | |
1076 | |
1077 return ret ? ret : buddy->name; | |
5228 | 1078 } |
1079 | |
6744 | 1080 const char *gaim_blist_chat_get_name(GaimBlistChat *chat) |
1081 { | |
1082 if(chat->alias && *chat->alias) { | |
1083 return chat->alias; | |
1084 } else { | |
1085 struct proto_chat_entry *pce; | |
1086 GList *parts, *tmp; | |
1087 char *ret; | |
1088 | |
1089 parts = GAIM_PLUGIN_PROTOCOL_INFO(chat->account->gc->prpl)->chat_info(chat->account->gc); | |
1090 pce = parts->data; | |
1091 ret = g_hash_table_lookup(chat->components, pce->identifier); | |
1092 for(tmp = parts; tmp; tmp = tmp->next) | |
1093 g_free(tmp->data); | |
1094 g_list_free(parts); | |
1095 | |
1096 return ret; | |
1097 } | |
1098 } | |
1099 | |
6695 | 1100 GaimBuddy *gaim_find_buddy(GaimAccount *account, const char *name) |
5228 | 1101 { |
6695 | 1102 GaimBuddy *buddy; |
5247 | 1103 struct _gaim_hbuddy hb; |
5758 | 1104 GaimBlistNode *group; |
5228 | 1105 |
1106 if (!gaimbuddylist) | |
1107 return NULL; | |
6245 | 1108 |
1109 if (!name) | |
5985
60d9cbfb6bf8
[gaim-migrate @ 6433]
Christian Hammond <chipx86@chipx86.com>
parents:
5947
diff
changeset
|
1110 return NULL; |
5228 | 1111 |
6245 | 1112 hb.name = normalize(name); |
1113 hb.account = account; | |
5247 | 1114 |
6245 | 1115 for(group = gaimbuddylist->root; group; group = group->next) { |
5758 | 1116 hb.group = group; |
5776 | 1117 if ((buddy = g_hash_table_lookup(gaimbuddylist->buddies, &hb)) != NULL) |
5758 | 1118 return buddy; |
1119 } | |
6245 | 1120 |
5758 | 1121 return NULL; |
5228 | 1122 } |
1123 | |
6245 | 1124 GSList *gaim_find_buddies(GaimAccount *account, const char *name) |
1125 { | |
1126 struct buddy *buddy; | |
1127 struct _gaim_hbuddy hb; | |
1128 GaimBlistNode *group; | |
1129 GSList *ret = NULL; | |
1130 | |
1131 if (!gaimbuddylist) | |
1132 return NULL; | |
1133 | |
1134 if (!name) | |
1135 return NULL; | |
1136 | |
1137 hb.name = normalize(name); | |
1138 hb.account = account; | |
1139 | |
1140 for(group = gaimbuddylist->root; group; group = group->next) { | |
1141 hb.group = group; | |
1142 if ((buddy = g_hash_table_lookup(gaimbuddylist->buddies, &hb)) != NULL) | |
1143 ret = g_slist_append(ret, buddy); | |
1144 } | |
1145 | |
1146 return ret; | |
1147 } | |
1148 | |
6695 | 1149 GaimGroup *gaim_find_group(const char *name) |
5228 | 1150 { |
1151 GaimBlistNode *node; | |
1152 if (!gaimbuddylist) | |
1153 return NULL; | |
1154 node = gaimbuddylist->root; | |
1155 while(node) { | |
6695 | 1156 if (!strcmp(((GaimGroup *)node)->name, name)) |
1157 return (GaimGroup *)node; | |
5228 | 1158 node = node->next; |
1159 } | |
1160 return NULL; | |
1161 } | |
6456
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1162 |
6695 | 1163 GaimBlistChat * |
6456
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1164 gaim_blist_find_chat(GaimAccount *account, const char *name) |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1165 { |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1166 char *chat_name; |
6695 | 1167 GaimBlistChat *chat; |
6456
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1168 GaimPlugin *prpl; |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1169 GaimPluginProtocolInfo *prpl_info = NULL; |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1170 struct proto_chat_entry *pce; |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1171 GaimBlistNode *node, *group; |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1172 GList *parts; |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1173 |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1174 g_return_val_if_fail(gaim_get_blist() != NULL, NULL); |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1175 g_return_val_if_fail(name != NULL, NULL); |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1176 |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1177 for (group = gaimbuddylist->root; group != NULL; group = group->next) { |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1178 for (node = group->child; node != NULL; node = node->next) { |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1179 if (GAIM_BLIST_NODE_IS_CHAT(node)) { |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1180 |
6695 | 1181 chat = (GaimBlistChat*)node; |
6456
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1182 |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1183 prpl = gaim_find_prpl(gaim_account_get_protocol(chat->account)); |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1184 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(prpl); |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1185 |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1186 parts = prpl_info->chat_info( |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1187 gaim_account_get_connection(chat->account)); |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1188 |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1189 pce = parts->data; |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1190 chat_name = g_hash_table_lookup(chat->components, |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1191 pce->identifier); |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1192 |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1193 if (chat->account == account && |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1194 name != NULL && !strcmp(chat_name, name)) { |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1195 |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1196 return chat; |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1197 } |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1198 } |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1199 } |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1200 } |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1201 |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1202 return NULL; |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1203 } |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1204 |
6695 | 1205 GaimGroup * |
1206 gaim_blist_chat_get_group(GaimBlistChat *chat) | |
6456
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1207 { |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1208 g_return_val_if_fail(chat != NULL, NULL); |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1209 |
6695 | 1210 return (GaimGroup *)(((GaimBlistNode *)chat)->parent); |
6456
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1211 } |
ccfdf9f2cdd1
[gaim-migrate @ 6965]
Christian Hammond <chipx86@chipx86.com>
parents:
6450
diff
changeset
|
1212 |
6695 | 1213 GaimGroup *gaim_find_buddys_group(GaimBuddy *buddy) |
5228 | 1214 { |
1215 if (!buddy) | |
1216 return NULL; | |
6706
854a435d2cc3
[gaim-migrate @ 7232]
Christian Hammond <chipx86@chipx86.com>
parents:
6695
diff
changeset
|
1217 |
854a435d2cc3
[gaim-migrate @ 7232]
Christian Hammond <chipx86@chipx86.com>
parents:
6695
diff
changeset
|
1218 if (((GaimBlistNode *)buddy)->parent == NULL) |
854a435d2cc3
[gaim-migrate @ 7232]
Christian Hammond <chipx86@chipx86.com>
parents:
6695
diff
changeset
|
1219 return NULL; |
854a435d2cc3
[gaim-migrate @ 7232]
Christian Hammond <chipx86@chipx86.com>
parents:
6695
diff
changeset
|
1220 |
6695 | 1221 return (GaimGroup *)(((GaimBlistNode*)buddy)->parent->parent); |
5228 | 1222 } |
1223 | |
6695 | 1224 GSList *gaim_group_get_accounts(GaimGroup *g) |
5228 | 1225 { |
1226 GSList *l = NULL; | |
6695 | 1227 GaimBlistNode *gnode, *cnode, *bnode; |
1228 | |
1229 gnode = (GaimBlistNode *)g; | |
5228 | 1230 |
6695 | 1231 for(cnode = gnode->child; cnode; cnode = cnode->next) { |
1232 if (GAIM_BLIST_NODE_IS_CHAT(cnode)) { | |
1233 if(!g_slist_find(l, ((GaimBlistChat *)cnode)->account)) | |
1234 l = g_slist_append(l, ((GaimBlistChat *)cnode)->account); | |
1235 } else if(GAIM_BLIST_NODE_IS_CONTACT(cnode)) { | |
1236 for(bnode = cnode->child; bnode; bnode = bnode->next) { | |
1237 if(GAIM_BLIST_NODE_IS_BUDDY(bnode)) { | |
1238 if(!g_slist_find(l, ((GaimBuddy *)bnode)->account)) | |
1239 l = g_slist_append(l, ((GaimBuddy *)bnode)->account); | |
1240 } | |
1241 } | |
1242 } | |
5228 | 1243 } |
6695 | 1244 |
5228 | 1245 return l; |
1246 } | |
1247 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1248 void gaim_blist_add_account(GaimAccount *account) |
5234 | 1249 { |
1250 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
6695 | 1251 GaimBlistNode *gnode, *cnode, *bnode; |
5234 | 1252 |
1253 if(!gaimbuddylist) | |
1254 return; | |
1255 | |
6695 | 1256 if(!ops) |
1257 return; | |
1258 | |
1259 for(gnode = gaimbuddylist->root; gnode; gnode = gnode->next) { | |
1260 if(!GAIM_BLIST_NODE_IS_GROUP(gnode)) | |
5234 | 1261 continue; |
6695 | 1262 for(cnode = gnode->child; cnode; cnode = cnode->next) { |
1263 if(GAIM_BLIST_NODE_IS_CONTACT(cnode)) { | |
1264 for(bnode = cnode->child; bnode; bnode = bnode->next) { | |
1265 if(GAIM_BLIST_NODE_IS_BUDDY(bnode) && | |
1266 ((GaimBuddy*)bnode)->account == account) { | |
1267 ((GaimContact*)cnode)->currentsize++; | |
1268 if(((GaimContact*)cnode)->currentsize == 1) | |
1269 ((GaimGroup*)gnode)->currentsize++; | |
1270 if(GAIM_BUDDY_IS_ONLINE((GaimBuddy*)bnode)) { | |
1271 ((GaimContact*)cnode)->online++; | |
1272 if(((GaimContact*)cnode)->online == 1) | |
1273 ((GaimGroup*)gnode)->online++; | |
1274 } | |
1275 ops->update(gaimbuddylist, bnode); | |
1276 } | |
1277 } | |
1278 ops->update(gaimbuddylist, cnode); | |
1279 } else if(GAIM_BLIST_NODE_IS_CHAT(cnode) && | |
1280 ((GaimBlistChat*)cnode)->account == account) { | |
1281 ((GaimGroup *)gnode)->online++; | |
1282 ((GaimGroup *)gnode)->currentsize++; | |
1283 ops->update(gaimbuddylist, cnode); | |
5234 | 1284 } |
1285 } | |
6695 | 1286 ops->update(gaimbuddylist, gnode); |
5234 | 1287 } |
1288 } | |
1289 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1290 void gaim_blist_remove_account(GaimAccount *account) |
5228 | 1291 { |
1292 struct gaim_blist_ui_ops *ops = gaimbuddylist->ui_ops; | |
6695 | 1293 GaimBlistNode *gnode, *cnode, *bnode; |
5234 | 1294 |
5228 | 1295 if (!gaimbuddylist) |
1296 return; | |
5234 | 1297 |
6695 | 1298 for(gnode = gaimbuddylist->root; gnode; gnode = gnode->next) { |
1299 if(!GAIM_BLIST_NODE_IS_GROUP(gnode)) | |
5234 | 1300 continue; |
6695 | 1301 for(cnode = gnode->child; cnode; cnode = cnode->next) { |
1302 if(GAIM_BLIST_NODE_IS_CONTACT(cnode)) { | |
1303 for(bnode = cnode->child; bnode; bnode = bnode->next) { | |
1304 if(!GAIM_BLIST_NODE_IS_BUDDY(bnode)) | |
1305 continue; | |
1306 if(account == ((GaimBuddy *)bnode)->account) { | |
1307 if(((GaimBuddy*)bnode)->present == GAIM_BUDDY_ONLINE || | |
1308 ((GaimBuddy*)bnode)->present == GAIM_BUDDY_SIGNING_ON) { | |
1309 ((GaimContact*)cnode)->online--; | |
1310 if(((GaimContact*)cnode)->online == 0) | |
1311 ((GaimGroup*)gnode)->online--; | |
1312 } | |
1313 ((GaimContact*)cnode)->currentsize--; | |
1314 if(((GaimContact*)cnode)->currentsize == 0) | |
1315 ((GaimGroup*)gnode)->currentsize--; | |
1316 | |
1317 ((GaimBuddy*)bnode)->present = GAIM_BUDDY_OFFLINE; | |
1318 | |
6803 | 1319 ((GaimBuddy*)bnode)->uc = 0; |
1320 ((GaimBuddy*)bnode)->idle = 0; | |
1321 ((GaimBuddy*)bnode)->evil = 0; | |
1322 | |
6695 | 1323 if(ops) |
1324 ops->remove(gaimbuddylist, bnode); | |
1325 } | |
5234 | 1326 } |
6695 | 1327 } else if(GAIM_BLIST_NODE_IS_CHAT(cnode) && |
1328 ((GaimBlistChat*)cnode)->account == account) { | |
1329 ((GaimGroup*)gnode)->currentsize--; | |
1330 ((GaimGroup*)gnode)->online--; | |
1331 if(ops) | |
1332 ops->remove(gaimbuddylist, cnode); | |
5228 | 1333 } |
1334 } | |
1335 } | |
1336 } | |
1337 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1338 void parse_toc_buddy_list(GaimAccount *account, char *config) |
5228 | 1339 { |
1340 char *c; | |
1341 char current[256]; | |
1342 GList *bud = NULL; | |
1343 | |
1344 | |
1345 if (config != NULL) { | |
1346 | |
1347 /* skip "CONFIG:" (if it exists) */ | |
1348 c = strncmp(config + 6 /* sizeof(struct sflap_hdr) */ , "CONFIG:", strlen("CONFIG:")) ? | |
1349 strtok(config, "\n") : | |
1350 strtok(config + 6 /* sizeof(struct sflap_hdr) */ + strlen("CONFIG:"), "\n"); | |
1351 do { | |
1352 if (c == NULL) | |
1353 break; | |
1354 if (*c == 'g') { | |
1355 char *utf8 = NULL; | |
1356 utf8 = gaim_try_conv_to_utf8(c + 2); | |
1357 if (utf8 == NULL) { | |
1358 g_strlcpy(current, _("Invalid Groupname"), sizeof(current)); | |
1359 } else { | |
1360 g_strlcpy(current, utf8, sizeof(current)); | |
1361 g_free(utf8); | |
1362 } | |
1363 if (!gaim_find_group(current)) { | |
6695 | 1364 GaimGroup *g = gaim_group_new(current); |
5634 | 1365 gaim_blist_add_group(g, |
1366 gaim_blist_get_last_sibling(gaimbuddylist->root)); | |
5228 | 1367 } |
1368 } else if (*c == 'b') { /*&& !gaim_find_buddy(user, c + 2)) {*/ | |
1369 char nm[80], sw[388], *a, *utf8 = NULL; | |
1370 | |
1371 if ((a = strchr(c + 2, ':')) != NULL) { | |
1372 *a++ = '\0'; /* nul the : */ | |
1373 } | |
1374 | |
1375 g_strlcpy(nm, c + 2, sizeof(nm)); | |
1376 if (a) { | |
1377 utf8 = gaim_try_conv_to_utf8(a); | |
1378 if (utf8 == NULL) { | |
1379 gaim_debug(GAIM_DEBUG_ERROR, "toc blist", | |
1380 "Failed to convert alias for " | |
1381 "'%s' to UTF-8\n", nm); | |
1382 } | |
1383 } | |
1384 if (utf8 == NULL) { | |
1385 sw[0] = '\0'; | |
1386 } else { | |
1387 /* This can leave a partial sequence at the end, | |
1388 * but who cares? */ | |
1389 g_strlcpy(sw, utf8, sizeof(sw)); | |
1390 g_free(utf8); | |
1391 } | |
1392 | |
1393 if (!gaim_find_buddy(account, nm)) { | |
6695 | 1394 GaimBuddy *b = gaim_buddy_new(account, nm, sw); |
1395 GaimGroup *g = gaim_find_group(current); | |
1396 gaim_blist_add_buddy(b, NULL, g, | |
5634 | 1397 gaim_blist_get_last_child((GaimBlistNode*)g)); |
5228 | 1398 bud = g_list_append(bud, g_strdup(nm)); |
1399 } | |
1400 } else if (*c == 'p') { | |
6378
01289157fc37
[gaim-migrate @ 6883]
Christian Hammond <chipx86@chipx86.com>
parents:
6371
diff
changeset
|
1401 gaim_privacy_permit_add(account, c + 2, TRUE); |
5228 | 1402 } else if (*c == 'd') { |
6378
01289157fc37
[gaim-migrate @ 6883]
Christian Hammond <chipx86@chipx86.com>
parents:
6371
diff
changeset
|
1403 gaim_privacy_deny_add(account, c + 2, TRUE); |
5228 | 1404 } else if (!strncmp("toc", c, 3)) { |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1405 sscanf(c + strlen(c) - 1, "%d", &account->perm_deny); |
5228 | 1406 gaim_debug(GAIM_DEBUG_MISC, "toc blist", |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1407 "permdeny: %d\n", account->perm_deny); |
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1408 if (account->perm_deny == 0) |
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1409 account->perm_deny = 1; |
5228 | 1410 } else if (*c == 'm') { |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1411 sscanf(c + 2, "%d", &account->perm_deny); |
5228 | 1412 gaim_debug(GAIM_DEBUG_MISC, "toc blist", |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1413 "permdeny: %d\n", account->perm_deny); |
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1414 if (account->perm_deny == 0) |
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1415 account->perm_deny = 1; |
5228 | 1416 } |
1417 } while ((c = strtok(NULL, "\n"))); | |
1418 | |
1419 if(account->gc) { | |
1420 if(bud) { | |
1421 GList *node = bud; | |
1422 serv_add_buddies(account->gc, bud); | |
1423 while(node) { | |
1424 g_free(node->data); | |
1425 node = node->next; | |
1426 } | |
1427 } | |
1428 serv_set_permit_deny(account->gc); | |
1429 } | |
1430 g_list_free(bud); | |
1431 } | |
1432 } | |
1433 | |
1434 #if 0 | |
1435 /* translate an AIM 3 buddylist (*.lst) to a Gaim buddylist */ | |
1436 static GString *translate_lst(FILE *src_fp) | |
1437 { | |
1438 char line[BUF_LEN], *line2; | |
1439 char *name; | |
1440 int i; | |
1441 | |
1442 GString *dest = g_string_new("m 1\n"); | |
1443 | |
1444 while (fgets(line, BUF_LEN, src_fp)) { | |
1445 line2 = g_strchug(line); | |
1446 if (strstr(line2, "group") == line2) { | |
1447 name = strpbrk(line2, " \t\n\r\f") + 1; | |
1448 dest = g_string_append(dest, "g "); | |
1449 for (i = 0; i < strcspn(name, "\n\r"); i++) | |
1450 if (name[i] != '\"') | |
1451 dest = g_string_append_c(dest, name[i]); | |
1452 dest = g_string_append_c(dest, '\n'); | |
1453 } | |
1454 if (strstr(line2, "buddy") == line2) { | |
1455 name = strpbrk(line2, " \t\n\r\f") + 1; | |
1456 dest = g_string_append(dest, "b "); | |
1457 for (i = 0; i < strcspn(name, "\n\r"); i++) | |
1458 if (name[i] != '\"') | |
1459 dest = g_string_append_c(dest, name[i]); | |
1460 dest = g_string_append_c(dest, '\n'); | |
1461 } | |
1462 } | |
1463 | |
1464 return dest; | |
1465 } | |
1466 | |
1467 | |
1468 /* translate an AIM 4 buddylist (*.blt) to Gaim format */ | |
1469 static GString *translate_blt(FILE *src_fp) | |
1470 { | |
1471 int i; | |
1472 char line[BUF_LEN]; | |
1473 char *buddy; | |
1474 | |
1475 GString *dest = g_string_new("m 1\n"); | |
1476 | |
1477 while (strstr(fgets(line, BUF_LEN, src_fp), "Buddy") == NULL); | |
1478 while (strstr(fgets(line, BUF_LEN, src_fp), "list") == NULL); | |
1479 | |
1480 while (1) { | |
1481 fgets(line, BUF_LEN, src_fp); g_strchomp(line); | |
1482 if (strchr(line, '}') != NULL) | |
1483 break; | |
1484 | |
1485 if (strchr(line, '{') != NULL) { | |
1486 /* Syntax starting with "<group> {" */ | |
1487 | |
1488 dest = g_string_append(dest, "g "); | |
1489 buddy = g_strchug(strtok(line, "{")); | |
1490 for (i = 0; i < strlen(buddy); i++) | |
1491 if (buddy[i] != '\"') | |
1492 dest = g_string_append_c(dest, buddy[i]); | |
1493 dest = g_string_append_c(dest, '\n'); | |
1494 while (strchr(fgets(line, BUF_LEN, src_fp), '}') == NULL) { | |
1495 gboolean pounce = FALSE; | |
1496 char *e; | |
1497 g_strchomp(line); | |
1498 buddy = g_strchug(line); | |
1499 gaim_debug(GAIM_DEBUG_MISC, "AIM 4 blt import", | |
1500 "buddy: \"%s\"\n", buddy); | |
1501 dest = g_string_append(dest, "b "); | |
1502 if (strchr(buddy, '{') != NULL) { | |
1503 /* buddy pounce, etc */ | |
1504 char *pos = strchr(buddy, '{') - 1; | |
1505 *pos = 0; | |
1506 pounce = TRUE; | |
1507 } | |
1508 if ((e = strchr(buddy, '\"')) != NULL) { | |
1509 *e = '\0'; | |
1510 buddy++; | |
1511 } | |
1512 dest = g_string_append(dest, buddy); | |
1513 dest = g_string_append_c(dest, '\n'); | |
1514 if (pounce) | |
1515 do | |
1516 fgets(line, BUF_LEN, src_fp); | |
1517 while (!strchr(line, '}')); | |
1518 } | |
1519 } else { | |
1520 | |
1521 /* Syntax "group buddy buddy ..." */ | |
1522 buddy = g_strchug(strtok(line, " \n")); | |
1523 dest = g_string_append(dest, "g "); | |
1524 if (strchr(buddy, '\"') != NULL) { | |
1525 dest = g_string_append(dest, &buddy[1]); | |
1526 dest = g_string_append_c(dest, ' '); | |
1527 buddy = g_strchug(strtok(NULL, " \n")); | |
1528 while (strchr(buddy, '\"') == NULL) { | |
1529 dest = g_string_append(dest, buddy); | |
1530 dest = g_string_append_c(dest, ' '); | |
1531 buddy = g_strchug(strtok(NULL, " \n")); | |
1532 } | |
1533 buddy[strlen(buddy) - 1] = '\0'; | |
1534 dest = g_string_append(dest, buddy); | |
1535 } else { | |
1536 dest = g_string_append(dest, buddy); | |
1537 } | |
1538 dest = g_string_append_c(dest, '\n'); | |
1539 while ((buddy = g_strchug(strtok(NULL, " \n"))) != NULL) { | |
1540 dest = g_string_append(dest, "b "); | |
1541 if (strchr(buddy, '\"') != NULL) { | |
1542 dest = g_string_append(dest, &buddy[1]); | |
1543 dest = g_string_append_c(dest, ' '); | |
1544 buddy = g_strchug(strtok(NULL, " \n")); | |
1545 while (strchr(buddy, '\"') == NULL) { | |
1546 dest = g_string_append(dest, buddy); | |
1547 dest = g_string_append_c(dest, ' '); | |
1548 buddy = g_strchug(strtok(NULL, " \n")); | |
1549 } | |
1550 buddy[strlen(buddy) - 1] = '\0'; | |
1551 dest = g_string_append(dest, buddy); | |
1552 } else { | |
1553 dest = g_string_append(dest, buddy); | |
1554 } | |
1555 dest = g_string_append_c(dest, '\n'); | |
1556 } | |
1557 } | |
1558 } | |
1559 | |
1560 return dest; | |
1561 } | |
1562 | |
1563 static GString *translate_gnomeicu(FILE *src_fp) | |
1564 { | |
1565 char line[BUF_LEN]; | |
1566 GString *dest = g_string_new("m 1\ng Buddies\n"); | |
1567 | |
1568 while (strstr(fgets(line, BUF_LEN, src_fp), "NewContacts") == NULL); | |
1569 | |
1570 while (fgets(line, BUF_LEN, src_fp)) { | |
1571 char *eq; | |
1572 g_strchomp(line); | |
1573 if (line[0] == '\n' || line[0] == '[') | |
1574 break; | |
1575 eq = strchr(line, '='); | |
1576 if (!eq) | |
1577 break; | |
1578 *eq = ':'; | |
1579 eq = strchr(eq, ','); | |
1580 if (eq) | |
1581 *eq = '\0'; | |
1582 dest = g_string_append(dest, "b "); | |
1583 dest = g_string_append(dest, line); | |
1584 dest = g_string_append_c(dest, '\n'); | |
1585 } | |
1586 | |
1587 return dest; | |
1588 } | |
1589 #endif | |
1590 | |
1591 static gchar *get_screenname_filename(const char *name) | |
1592 { | |
1593 gchar **split; | |
1594 gchar *good; | |
1595 gchar *ret; | |
1596 | |
1597 split = g_strsplit(name, G_DIR_SEPARATOR_S, -1); | |
1598 good = g_strjoinv(NULL, split); | |
1599 g_strfreev(split); | |
1600 | |
1601 ret = g_utf8_strup(good, -1); | |
1602 | |
1603 g_free(good); | |
1604 | |
1605 return ret; | |
1606 } | |
1607 | |
1608 static gboolean gaim_blist_read(const char *filename); | |
1609 | |
1610 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
1611 static void do_import(GaimAccount *account, const char *filename) |
5228 | 1612 { |
1613 GString *buf = NULL; | |
1614 char first[64]; | |
1615 char path[PATHSIZE]; | |
1616 int len; | |
1617 FILE *f; | |
1618 struct stat st; | |
1619 | |
1620 if (filename) { | |
1621 g_snprintf(path, sizeof(path), "%s", filename); | |
1622 } else { | |
1623 char *g_screenname = get_screenname_filename(account->username); | |
5943
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1624 const char *username; |
5228 | 1625 char *file = gaim_user_dir(); |
5943
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1626 GaimProtocol prpl_num; |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1627 int protocol; |
6695 | 1628 |
5943
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1629 prpl_num = gaim_account_get_protocol(account); |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1630 |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1631 protocol = prpl_num; |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1632 |
6450
e7b87c8e8c0a
[gaim-migrate @ 6959]
Christian Hammond <chipx86@chipx86.com>
parents:
6392
diff
changeset
|
1633 /* TODO Somehow move this checking into prpls */ |
5943
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1634 if (prpl_num == GAIM_PROTO_OSCAR) { |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1635 if ((username = gaim_account_get_username(account)) != NULL) { |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1636 protocol = (isalpha(*username) |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1637 ? GAIM_PROTO_TOC : GAIM_PROTO_ICQ); |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1638 } |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
1639 } |
5228 | 1640 |
1641 if (file != (char *)NULL) { | |
5435 | 1642 snprintf(path, PATHSIZE, "%s" G_DIR_SEPARATOR_S "%s.%d.blist", file, g_screenname, protocol); |
5228 | 1643 g_free(g_screenname); |
1644 } else { | |
1645 g_free(g_screenname); | |
1646 return; | |
1647 } | |
1648 } | |
1649 | |
1650 if (stat(path, &st)) { | |
1651 gaim_debug(GAIM_DEBUG_ERROR, "blist import", "Unable to stat %s.\n", | |
1652 path); | |
1653 return; | |
1654 } | |
1655 | |
1656 if (!(f = fopen(path, "r"))) { | |
1657 gaim_debug(GAIM_DEBUG_ERROR, "blist import", "Unable to open %s.\n", | |
1658 path); | |
1659 return; | |
1660 } | |
1661 | |
1662 fgets(first, 64, f); | |
1663 | |
1664 if ((first[0] == '\n') || (first[0] == '\r' && first[1] == '\n')) | |
1665 fgets(first, 64, f); | |
1666 | |
1667 #if 0 | |
1668 if (!g_strncasecmp(first, "<xml", strlen("<xml"))) { | |
1669 /* new gaim XML buddy list */ | |
1670 gaim_blist_read(path); | |
1671 | |
1672 /* We really don't need to bother doing stuf like translating AIM 3 buddy lists anymore */ | |
1673 | |
1674 } else if (!g_strncasecmp(first, "Config {", strlen("Config {"))) { | |
1675 /* AIM 4 buddy list */ | |
1676 gaim_debug(GAIM_DEBUG_MISC, "blist import", "aim 4\n"); | |
1677 rewind(f); | |
1678 buf = translate_blt(f); | |
1679 } else if (strstr(first, "group") != NULL) { | |
1680 /* AIM 3 buddy list */ | |
1681 gaim_debug(GAIM_DEBUG_MISC, "blist import", "aim 3\n"); | |
1682 rewind(f); | |
1683 buf = translate_lst(f); | |
1684 } else if (!g_strncasecmp(first, "[User]", strlen("[User]"))) { | |
1685 /* GnomeICU (hopefully) */ | |
1686 gaim_debug(GAIM_DEBUG_MISC, "blist import", "gnomeicu\n"); | |
1687 rewind(f); | |
1688 buf = translate_gnomeicu(f); | |
1689 | |
1690 } else | |
1691 #endif | |
1692 if (first[0] == 'm') { | |
1693 /* Gaim buddy list - no translation */ | |
1694 char buf2[BUF_LONG * 2]; | |
1695 buf = g_string_new(""); | |
1696 rewind(f); | |
1697 while (1) { | |
1698 len = fread(buf2, 1, BUF_LONG * 2 - 1, f); | |
1699 if (len <= 0) | |
1700 break; | |
1701 buf2[len] = '\0'; | |
1702 buf = g_string_append(buf, buf2); | |
1703 if (len != BUF_LONG * 2 - 1) | |
1704 break; | |
1705 } | |
1706 } | |
1707 | |
1708 fclose(f); | |
1709 | |
1710 if (buf) { | |
1711 buf = g_string_prepend(buf, "toc_set_config {"); | |
1712 buf = g_string_append(buf, "}\n"); | |
1713 parse_toc_buddy_list(account, buf->str); | |
1714 g_string_free(buf, TRUE); | |
1715 } | |
1716 } | |
1717 | |
6695 | 1718 gboolean gaim_group_on_account(GaimGroup *g, GaimAccount *account) { |
1719 GaimBlistNode *cnode, *bnode; | |
1720 for(cnode = ((GaimBlistNode *)g)->child; cnode; cnode = cnode->next) { | |
1721 if(GAIM_BLIST_NODE_IS_CONTACT(cnode)) { | |
1722 for(bnode = cnode->child; bnode; bnode = bnode->next) { | |
1723 if(GAIM_BLIST_NODE_IS_BUDDY(bnode)) { | |
1724 GaimBuddy *buddy = (GaimBuddy *)bnode; | |
1725 if((!account && gaim_account_is_connected(buddy->account)) | |
1726 || buddy->account == account) | |
1727 return TRUE; | |
1728 } | |
1729 } | |
1730 } else if(GAIM_BLIST_NODE_IS_CHAT(cnode)) { | |
1731 GaimBlistChat *chat = (GaimBlistChat *)cnode; | |
1732 if((!account && gaim_account_is_connected(chat->account)) | |
1733 || chat->account == account) | |
1734 return TRUE; | |
1735 } | |
5228 | 1736 } |
1737 return FALSE; | |
1738 } | |
1739 | |
1740 static gboolean blist_safe_to_write = FALSE; | |
1741 | |
6695 | 1742 GaimGroup *blist_parser_group = NULL; |
1743 GaimContact *blist_parser_contact = NULL; | |
5228 | 1744 static char *blist_parser_account_name = NULL; |
1745 static int blist_parser_account_protocol = 0; | |
5234 | 1746 static char *blist_parser_chat_alias = NULL; |
1747 static char *blist_parser_component_name = NULL; | |
1748 static char *blist_parser_component_value = NULL; | |
5228 | 1749 static char *blist_parser_buddy_name = NULL; |
1750 static char *blist_parser_buddy_alias = NULL; | |
1751 static char *blist_parser_setting_name = NULL; | |
1752 static char *blist_parser_setting_value = NULL; | |
1753 static GHashTable *blist_parser_buddy_settings = NULL; | |
5906 | 1754 static GHashTable *blist_parser_chat_settings = NULL; |
5228 | 1755 static GHashTable *blist_parser_group_settings = NULL; |
5234 | 1756 static GHashTable *blist_parser_chat_components = NULL; |
5228 | 1757 static int blist_parser_privacy_mode = 0; |
1758 static GList *tag_stack = NULL; | |
1759 enum { | |
1760 BLIST_TAG_GAIM, | |
1761 BLIST_TAG_BLIST, | |
1762 BLIST_TAG_GROUP, | |
5234 | 1763 BLIST_TAG_CHAT, |
1764 BLIST_TAG_COMPONENT, | |
6695 | 1765 BLIST_TAG_CONTACT, |
5228 | 1766 BLIST_TAG_BUDDY, |
1767 BLIST_TAG_NAME, | |
1768 BLIST_TAG_ALIAS, | |
1769 BLIST_TAG_SETTING, | |
1770 BLIST_TAG_PRIVACY, | |
1771 BLIST_TAG_ACCOUNT, | |
1772 BLIST_TAG_PERMIT, | |
1773 BLIST_TAG_BLOCK, | |
1774 BLIST_TAG_IGNORE | |
1775 }; | |
1776 static gboolean blist_parser_error_occurred = FALSE; | |
1777 | |
1778 static void blist_start_element_handler (GMarkupParseContext *context, | |
1779 const gchar *element_name, | |
1780 const gchar **attribute_names, | |
1781 const gchar **attribute_values, | |
1782 gpointer user_data, | |
1783 GError **error) { | |
1784 int i; | |
1785 | |
1786 if(!strcmp(element_name, "gaim")) { | |
1787 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_GAIM)); | |
1788 } else if(!strcmp(element_name, "blist")) { | |
1789 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_BLIST)); | |
1790 } else if(!strcmp(element_name, "group")) { | |
6803 | 1791 const char *name = NULL; |
5228 | 1792 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_GROUP)); |
1793 for(i=0; attribute_names[i]; i++) { | |
1794 if(!strcmp(attribute_names[i], "name")) { | |
6778 | 1795 name = attribute_values[i]; |
5228 | 1796 } |
1797 } | |
6778 | 1798 if(name) { |
1799 blist_parser_group = gaim_group_new(name); | |
6695 | 1800 gaim_blist_add_group(blist_parser_group, |
5634 | 1801 gaim_blist_get_last_sibling(gaimbuddylist->root)); |
5228 | 1802 } |
6695 | 1803 } else if(!strcmp(element_name, "contact")) { |
6755 | 1804 char *alias = NULL; |
6695 | 1805 tag_stack = g_list_prepend(tag_stack, |
1806 GINT_TO_POINTER(BLIST_TAG_CONTACT)); | |
1807 | |
6755 | 1808 for(i=0; attribute_names[i]; i++) { |
1809 if(!strcmp(attribute_names[i], "alias")) { | |
1810 g_free(alias); | |
1811 alias = g_strdup(attribute_values[i]); | |
1812 } | |
1813 } | |
1814 | |
6695 | 1815 blist_parser_contact = gaim_contact_new(); |
1816 gaim_blist_add_contact(blist_parser_contact, blist_parser_group, | |
1817 gaim_blist_get_last_sibling(((GaimBlistNode*)blist_parser_group)->child)); | |
6755 | 1818 |
1819 if(alias) { | |
1820 gaim_contact_set_alias(blist_parser_contact, alias); | |
1821 g_free(alias); | |
1822 } | |
5234 | 1823 } else if(!strcmp(element_name, "chat")) { |
1824 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_CHAT)); | |
1825 for(i=0; attribute_names[i]; i++) { | |
1826 if(!strcmp(attribute_names[i], "account")) { | |
1827 g_free(blist_parser_account_name); | |
1828 blist_parser_account_name = g_strdup(attribute_values[i]); | |
1829 } else if(!strcmp(attribute_names[i], "protocol")) { | |
1830 blist_parser_account_protocol = atoi(attribute_values[i]); | |
1831 } | |
1832 } | |
5228 | 1833 } else if(!strcmp(element_name, "buddy")) { |
1834 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_BUDDY)); | |
1835 for(i=0; attribute_names[i]; i++) { | |
1836 if(!strcmp(attribute_names[i], "account")) { | |
1837 g_free(blist_parser_account_name); | |
1838 blist_parser_account_name = g_strdup(attribute_values[i]); | |
1839 } else if(!strcmp(attribute_names[i], "protocol")) { | |
1840 blist_parser_account_protocol = atoi(attribute_values[i]); | |
1841 } | |
1842 } | |
1843 } else if(!strcmp(element_name, "name")) { | |
1844 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_NAME)); | |
1845 } else if(!strcmp(element_name, "alias")) { | |
1846 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_ALIAS)); | |
1847 } else if(!strcmp(element_name, "setting")) { | |
1848 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_SETTING)); | |
1849 for(i=0; attribute_names[i]; i++) { | |
1850 if(!strcmp(attribute_names[i], "name")) { | |
1851 g_free(blist_parser_setting_name); | |
1852 blist_parser_setting_name = g_strdup(attribute_values[i]); | |
1853 } | |
1854 } | |
5234 | 1855 } else if(!strcmp(element_name, "component")) { |
1856 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_COMPONENT)); | |
1857 for(i=0; attribute_names[i]; i++) { | |
1858 if(!strcmp(attribute_names[i], "name")) { | |
1859 g_free(blist_parser_component_name); | |
1860 blist_parser_component_name = g_strdup(attribute_values[i]); | |
1861 } | |
1862 } | |
1863 | |
5228 | 1864 } else if(!strcmp(element_name, "privacy")) { |
1865 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_PRIVACY)); | |
1866 } else if(!strcmp(element_name, "account")) { | |
1867 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_ACCOUNT)); | |
1868 for(i=0; attribute_names[i]; i++) { | |
1869 if(!strcmp(attribute_names[i], "protocol")) | |
1870 blist_parser_account_protocol = atoi(attribute_values[i]); | |
1871 else if(!strcmp(attribute_names[i], "mode")) | |
1872 blist_parser_privacy_mode = atoi(attribute_values[i]); | |
1873 else if(!strcmp(attribute_names[i], "name")) { | |
1874 g_free(blist_parser_account_name); | |
1875 blist_parser_account_name = g_strdup(attribute_values[i]); | |
1876 } | |
1877 } | |
1878 } else if(!strcmp(element_name, "permit")) { | |
1879 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_PERMIT)); | |
1880 } else if(!strcmp(element_name, "block")) { | |
1881 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_BLOCK)); | |
1882 } else if(!strcmp(element_name, "ignore")) { | |
1883 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_IGNORE)); | |
1884 } | |
1885 } | |
1886 | |
1887 static void blist_end_element_handler(GMarkupParseContext *context, | |
1888 const gchar *element_name, gpointer user_data, GError **error) { | |
1889 if(!strcmp(element_name, "gaim")) { | |
1890 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1891 } else if(!strcmp(element_name, "blist")) { | |
1892 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1893 } else if(!strcmp(element_name, "group")) { | |
1894 if(blist_parser_group_settings) { | |
6778 | 1895 g_hash_table_destroy(blist_parser_group->settings); |
1896 blist_parser_group->settings = blist_parser_group_settings; | |
5228 | 1897 } |
1898 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1899 blist_parser_group_settings = NULL; | |
6695 | 1900 blist_parser_group = NULL; |
5234 | 1901 } else if(!strcmp(element_name, "chat")) { |
5874
964e4f94fc56
[gaim-migrate @ 6306]
Christian Hammond <chipx86@chipx86.com>
parents:
5872
diff
changeset
|
1902 GaimAccount *account = gaim_accounts_find(blist_parser_account_name, |
5234 | 1903 blist_parser_account_protocol); |
5237 | 1904 if(account) { |
6695 | 1905 GaimBlistChat *chat = gaim_blist_chat_new(account, |
1906 blist_parser_chat_alias, blist_parser_chat_components); | |
6778 | 1907 gaim_blist_add_chat(chat,blist_parser_group, |
1908 gaim_blist_get_last_child((GaimBlistNode*)blist_parser_group)); | |
5906 | 1909 if(blist_parser_chat_settings) { |
1910 g_hash_table_destroy(chat->settings); | |
1911 chat->settings = blist_parser_chat_settings; | |
1912 } | |
5234 | 1913 } |
1914 g_free(blist_parser_chat_alias); | |
1915 blist_parser_chat_alias = NULL; | |
1916 g_free(blist_parser_account_name); | |
1917 blist_parser_account_name = NULL; | |
1918 blist_parser_chat_components = NULL; | |
5906 | 1919 blist_parser_chat_settings = NULL; |
5234 | 1920 tag_stack = g_list_delete_link(tag_stack, tag_stack); |
6695 | 1921 } else if(!strcmp(element_name, "contact")) { |
1922 if(blist_parser_contact && !blist_parser_contact->node.child) | |
1923 gaim_blist_remove_contact(blist_parser_contact); | |
1924 blist_parser_contact = NULL; | |
5228 | 1925 tag_stack = g_list_delete_link(tag_stack, tag_stack); |
1926 } else if(!strcmp(element_name, "buddy")) { | |
5874
964e4f94fc56
[gaim-migrate @ 6306]
Christian Hammond <chipx86@chipx86.com>
parents:
5872
diff
changeset
|
1927 GaimAccount *account = gaim_accounts_find(blist_parser_account_name, |
5228 | 1928 blist_parser_account_protocol); |
1929 if(account) { | |
6695 | 1930 GaimBuddy *b = gaim_buddy_new(account, blist_parser_buddy_name, blist_parser_buddy_alias); |
1931 gaim_blist_add_buddy(b,blist_parser_contact, blist_parser_group, | |
1932 gaim_blist_get_last_child((GaimBlistNode*)blist_parser_contact)); | |
5228 | 1933 if(blist_parser_buddy_settings) { |
1934 g_hash_table_destroy(b->settings); | |
1935 b->settings = blist_parser_buddy_settings; | |
1936 } | |
1937 } | |
1938 g_free(blist_parser_buddy_name); | |
1939 blist_parser_buddy_name = NULL; | |
1940 g_free(blist_parser_buddy_alias); | |
1941 blist_parser_buddy_alias = NULL; | |
1942 g_free(blist_parser_account_name); | |
1943 blist_parser_account_name = NULL; | |
1944 blist_parser_buddy_settings = NULL; | |
1945 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1946 } else if(!strcmp(element_name, "name")) { | |
1947 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1948 } else if(!strcmp(element_name, "alias")) { | |
1949 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
5234 | 1950 } else if(!strcmp(element_name, "component")) { |
1951 if(!blist_parser_chat_components) | |
1952 blist_parser_chat_components = g_hash_table_new_full(g_str_hash, | |
1953 g_str_equal, g_free, g_free); | |
1954 if(blist_parser_component_name && blist_parser_component_value) { | |
1955 g_hash_table_replace(blist_parser_chat_components, | |
1956 g_strdup(blist_parser_component_name), | |
1957 g_strdup(blist_parser_component_value)); | |
1958 } | |
1959 g_free(blist_parser_component_name); | |
1960 g_free(blist_parser_component_value); | |
1961 blist_parser_component_name = NULL; | |
1962 blist_parser_component_value = NULL; | |
1963 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
5228 | 1964 } else if(!strcmp(element_name, "setting")) { |
1965 if(GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_BUDDY) { | |
1966 if(!blist_parser_buddy_settings) | |
1967 blist_parser_buddy_settings = g_hash_table_new_full(g_str_hash, | |
1968 g_str_equal, g_free, g_free); | |
1969 if(blist_parser_setting_name && blist_parser_setting_value) { | |
1970 g_hash_table_replace(blist_parser_buddy_settings, | |
1971 g_strdup(blist_parser_setting_name), | |
1972 g_strdup(blist_parser_setting_value)); | |
1973 } | |
5906 | 1974 } else if(GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_CHAT) { |
1975 if(!blist_parser_chat_settings) | |
1976 blist_parser_chat_settings = g_hash_table_new_full(g_str_hash, | |
1977 g_str_equal, g_free, g_free); | |
1978 if(blist_parser_setting_name && blist_parser_setting_value) { | |
6307 | 1979 g_hash_table_replace(blist_parser_chat_settings, |
5906 | 1980 g_strdup(blist_parser_setting_name), |
1981 g_strdup(blist_parser_setting_value)); | |
1982 } | |
5228 | 1983 } else if(GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_GROUP) { |
1984 if(!blist_parser_group_settings) | |
1985 blist_parser_group_settings = g_hash_table_new_full(g_str_hash, | |
1986 g_str_equal, g_free, g_free); | |
1987 if(blist_parser_setting_name && blist_parser_setting_value) { | |
1988 g_hash_table_replace(blist_parser_group_settings, | |
1989 g_strdup(blist_parser_setting_name), | |
1990 g_strdup(blist_parser_setting_value)); | |
1991 } | |
1992 } | |
1993 g_free(blist_parser_setting_name); | |
1994 g_free(blist_parser_setting_value); | |
1995 blist_parser_setting_name = NULL; | |
1996 blist_parser_setting_value = NULL; | |
1997 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
1998 } else if(!strcmp(element_name, "privacy")) { | |
1999 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
2000 } else if(!strcmp(element_name, "account")) { | |
5874
964e4f94fc56
[gaim-migrate @ 6306]
Christian Hammond <chipx86@chipx86.com>
parents:
5872
diff
changeset
|
2001 GaimAccount *account = gaim_accounts_find(blist_parser_account_name, |
5228 | 2002 blist_parser_account_protocol); |
2003 if(account) { | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
2004 account->perm_deny = blist_parser_privacy_mode; |
5228 | 2005 } |
2006 g_free(blist_parser_account_name); | |
2007 blist_parser_account_name = NULL; | |
2008 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
2009 } else if(!strcmp(element_name, "permit")) { | |
5874
964e4f94fc56
[gaim-migrate @ 6306]
Christian Hammond <chipx86@chipx86.com>
parents:
5872
diff
changeset
|
2010 GaimAccount *account = gaim_accounts_find(blist_parser_account_name, |
5228 | 2011 blist_parser_account_protocol); |
2012 if(account) { | |
6378
01289157fc37
[gaim-migrate @ 6883]
Christian Hammond <chipx86@chipx86.com>
parents:
6371
diff
changeset
|
2013 gaim_privacy_permit_add(account, blist_parser_buddy_name, TRUE); |
5228 | 2014 } |
2015 g_free(blist_parser_buddy_name); | |
2016 blist_parser_buddy_name = NULL; | |
2017 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
2018 } else if(!strcmp(element_name, "block")) { | |
5874
964e4f94fc56
[gaim-migrate @ 6306]
Christian Hammond <chipx86@chipx86.com>
parents:
5872
diff
changeset
|
2019 GaimAccount *account = gaim_accounts_find(blist_parser_account_name, |
5228 | 2020 blist_parser_account_protocol); |
2021 if(account) { | |
6378
01289157fc37
[gaim-migrate @ 6883]
Christian Hammond <chipx86@chipx86.com>
parents:
6371
diff
changeset
|
2022 gaim_privacy_deny_add(account, blist_parser_buddy_name, TRUE); |
5228 | 2023 } |
2024 g_free(blist_parser_buddy_name); | |
2025 blist_parser_buddy_name = NULL; | |
2026 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
2027 } else if(!strcmp(element_name, "ignore")) { | |
2028 /* we'll apparently do something with this later */ | |
2029 tag_stack = g_list_delete_link(tag_stack, tag_stack); | |
2030 } | |
2031 } | |
2032 | |
2033 static void blist_text_handler(GMarkupParseContext *context, const gchar *text, | |
2034 gsize text_len, gpointer user_data, GError **error) { | |
2035 switch(GPOINTER_TO_INT(tag_stack->data)) { | |
2036 case BLIST_TAG_NAME: | |
2037 blist_parser_buddy_name = g_strndup(text, text_len); | |
2038 break; | |
2039 case BLIST_TAG_ALIAS: | |
5234 | 2040 if(tag_stack->next && |
2041 GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_BUDDY) | |
2042 blist_parser_buddy_alias = g_strndup(text, text_len); | |
2043 else if(tag_stack->next && | |
2044 GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_CHAT) | |
2045 blist_parser_chat_alias = g_strndup(text, text_len); | |
5228 | 2046 break; |
2047 case BLIST_TAG_PERMIT: | |
2048 case BLIST_TAG_BLOCK: | |
2049 case BLIST_TAG_IGNORE: | |
2050 blist_parser_buddy_name = g_strndup(text, text_len); | |
2051 break; | |
5234 | 2052 case BLIST_TAG_COMPONENT: |
2053 blist_parser_component_value = g_strndup(text, text_len); | |
2054 break; | |
5228 | 2055 case BLIST_TAG_SETTING: |
2056 blist_parser_setting_value = g_strndup(text, text_len); | |
2057 break; | |
2058 default: | |
2059 break; | |
2060 } | |
2061 } | |
2062 | |
2063 static void blist_error_handler(GMarkupParseContext *context, GError *error, | |
2064 gpointer user_data) { | |
2065 blist_parser_error_occurred = TRUE; | |
2066 gaim_debug(GAIM_DEBUG_ERROR, "blist import", | |
2067 "Error parsing blist.xml: %s\n", error->message); | |
2068 } | |
2069 | |
2070 static GMarkupParser blist_parser = { | |
2071 blist_start_element_handler, | |
2072 blist_end_element_handler, | |
2073 blist_text_handler, | |
2074 NULL, | |
2075 blist_error_handler | |
2076 }; | |
2077 | |
2078 static gboolean gaim_blist_read(const char *filename) { | |
2079 gchar *contents = NULL; | |
2080 gsize length; | |
2081 GMarkupParseContext *context; | |
2082 GError *error = NULL; | |
2083 | |
2084 gaim_debug(GAIM_DEBUG_INFO, "blist import", | |
2085 "Reading %s\n", filename); | |
2086 if(!g_file_get_contents(filename, &contents, &length, &error)) { | |
2087 gaim_debug(GAIM_DEBUG_ERROR, "blist import", | |
2088 "Error reading blist: %s\n", error->message); | |
2089 g_error_free(error); | |
2090 return FALSE; | |
2091 } | |
2092 | |
2093 context = g_markup_parse_context_new(&blist_parser, 0, NULL, NULL); | |
2094 | |
2095 if(!g_markup_parse_context_parse(context, contents, length, NULL)) { | |
2096 g_markup_parse_context_free(context); | |
2097 g_free(contents); | |
2098 return FALSE; | |
2099 } | |
2100 | |
2101 if(!g_markup_parse_context_end_parse(context, NULL)) { | |
2102 gaim_debug(GAIM_DEBUG_ERROR, "blist import", | |
2103 "Error parsing %s\n", filename); | |
2104 g_markup_parse_context_free(context); | |
2105 g_free(contents); | |
2106 return FALSE; | |
2107 } | |
2108 | |
2109 g_markup_parse_context_free(context); | |
2110 g_free(contents); | |
2111 | |
2112 if(blist_parser_error_occurred) | |
2113 return FALSE; | |
2114 | |
2115 gaim_debug(GAIM_DEBUG_INFO, "blist import", "Finished reading %s\n", | |
2116 filename); | |
2117 | |
2118 return TRUE; | |
2119 } | |
2120 | |
2121 void gaim_blist_load() { | |
5580
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
2122 GList *accts; |
5228 | 2123 char *user_dir = gaim_user_dir(); |
2124 char *filename; | |
2125 char *msg; | |
2126 | |
2127 blist_safe_to_write = TRUE; | |
2128 | |
2129 if(!user_dir) | |
2130 return; | |
2131 | |
2132 filename = g_build_filename(user_dir, "blist.xml", NULL); | |
2133 | |
2134 if(g_file_test(filename, G_FILE_TEST_EXISTS)) { | |
2135 if(!gaim_blist_read(filename)) { | |
2136 msg = g_strdup_printf(_("An error was encountered parsing your " | |
2137 "buddy list. It has not been loaded.")); | |
5436
ad445074d239
[gaim-migrate @ 5818]
Christian Hammond <chipx86@chipx86.com>
parents:
5435
diff
changeset
|
2138 gaim_notify_error(NULL, NULL, _("Buddy List Error"), msg); |
5228 | 2139 g_free(msg); |
2140 } | |
5580
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
2141 } else if(g_list_length(gaim_accounts_get_all())) { |
5228 | 2142 /* 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
|
2143 for(accts = gaim_accounts_get_all(); accts; accts = accts->next) { |
5228 | 2144 do_import(accts->data, NULL); |
2145 } | |
2146 gaim_blist_save(); | |
2147 } | |
2148 | |
2149 g_free(filename); | |
2150 } | |
2151 | |
2152 static void blist_print_group_settings(gpointer key, gpointer data, | |
2153 gpointer user_data) { | |
2154 char *key_val; | |
2155 char *data_val; | |
2156 FILE *file = user_data; | |
2157 | |
2158 if(!key || !data) | |
2159 return; | |
2160 | |
2161 key_val = g_markup_escape_text(key, -1); | |
2162 data_val = g_markup_escape_text(data, -1); | |
2163 | |
2164 fprintf(file, "\t\t\t<setting name=\"%s\">%s</setting>\n", key_val, | |
2165 data_val); | |
2166 g_free(key_val); | |
2167 g_free(data_val); | |
2168 } | |
2169 | |
2170 static void blist_print_buddy_settings(gpointer key, gpointer data, | |
2171 gpointer user_data) { | |
2172 char *key_val; | |
2173 char *data_val; | |
2174 FILE *file = user_data; | |
2175 | |
2176 if(!key || !data) | |
2177 return; | |
2178 | |
2179 key_val = g_markup_escape_text(key, -1); | |
2180 data_val = g_markup_escape_text(data, -1); | |
2181 | |
2182 fprintf(file, "\t\t\t\t\t<setting name=\"%s\">%s</setting>\n", key_val, | |
2183 data_val); | |
2184 g_free(key_val); | |
2185 g_free(data_val); | |
2186 } | |
2187 | |
6695 | 2188 static void blist_print_cnode_settings(gpointer key, gpointer data, |
2189 gpointer user_data) { | |
2190 char *key_val; | |
2191 char *data_val; | |
2192 FILE *file = user_data; | |
2193 | |
2194 if(!key || !data) | |
2195 return; | |
2196 | |
2197 key_val = g_markup_escape_text(key, -1); | |
2198 data_val = g_markup_escape_text(data, -1); | |
2199 | |
2200 fprintf(file, "\t\t\t\t<setting name=\"%s\">%s</setting>\n", key_val, | |
2201 data_val); | |
2202 g_free(key_val); | |
2203 g_free(data_val); | |
2204 } | |
2205 | |
5234 | 2206 static void blist_print_chat_components(gpointer key, gpointer data, |
2207 gpointer user_data) { | |
2208 char *key_val; | |
2209 char *data_val; | |
2210 FILE *file = user_data; | |
2211 | |
2212 if(!key || !data) | |
2213 return; | |
2214 | |
2215 key_val = g_markup_escape_text(key, -1); | |
2216 data_val = g_markup_escape_text(data, -1); | |
2217 | |
2218 fprintf(file, "\t\t\t\t<component name=\"%s\">%s</component>\n", key_val, | |
2219 data_val); | |
2220 g_free(key_val); | |
2221 g_free(data_val); | |
2222 } | |
2223 | |
6695 | 2224 static void print_buddy(FILE *file, GaimBuddy *buddy) { |
2225 char *bud_name = g_markup_escape_text(buddy->name, -1); | |
2226 char *bud_alias = NULL; | |
2227 char *acct_name = g_markup_escape_text(buddy->account->username, -1); | |
2228 if(buddy->alias) | |
2229 bud_alias= g_markup_escape_text(buddy->alias, -1); | |
2230 fprintf(file, "\t\t\t\t<buddy protocol=\"%d\" " | |
2231 "account=\"%s\">\n", | |
2232 gaim_account_get_protocol(buddy->account), | |
2233 acct_name); | |
2234 fprintf(file, "\t\t\t\t\t<name>%s</name>\n", bud_name); | |
2235 if(bud_alias) { | |
2236 fprintf(file, "\t\t\t\t\t<alias>%s</alias>\n", bud_alias); | |
2237 } | |
2238 g_hash_table_foreach(buddy->settings, blist_print_buddy_settings, file); | |
2239 fprintf(file, "\t\t\t\t</buddy>\n"); | |
2240 g_free(bud_name); | |
2241 g_free(bud_alias); | |
2242 g_free(acct_name); | |
2243 } | |
2244 | |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
2245 static void gaim_blist_write(FILE *file, GaimAccount *exp_acct) { |
5580
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
2246 GList *accounts; |
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
2247 GSList *buds; |
6695 | 2248 GaimBlistNode *gnode, *cnode, *bnode; |
5228 | 2249 fprintf(file, "<?xml version='1.0' encoding='UTF-8' ?>\n"); |
2250 fprintf(file, "<gaim version=\"1\">\n"); | |
2251 fprintf(file, "\t<blist>\n"); | |
2252 | |
2253 for(gnode = gaimbuddylist->root; gnode; gnode = gnode->next) { | |
6695 | 2254 GaimGroup *group; |
2255 | |
5228 | 2256 if(!GAIM_BLIST_NODE_IS_GROUP(gnode)) |
2257 continue; | |
6695 | 2258 |
2259 group = (GaimGroup *)gnode; | |
5228 | 2260 if(!exp_acct || gaim_group_on_account(group, exp_acct)) { |
2261 char *group_name = g_markup_escape_text(group->name, -1); | |
2262 fprintf(file, "\t\t<group name=\"%s\">\n", group_name); | |
2263 g_hash_table_foreach(group->settings, blist_print_group_settings, file); | |
6695 | 2264 for(cnode = gnode->child; cnode; cnode = cnode->next) { |
2265 if(GAIM_BLIST_NODE_IS_CONTACT(cnode)) { | |
6755 | 2266 GaimContact *contact = (GaimContact*)cnode; |
2267 fprintf(file, "\t\t\t<contact"); | |
2268 if(contact->alias) { | |
2269 char *alias = g_markup_escape_text(contact->alias, -1); | |
2270 fprintf(file, " alias=\"%s\"", alias); | |
2271 g_free(alias); | |
2272 } | |
2273 fprintf(file, ">\n"); | |
6695 | 2274 |
2275 for(bnode = cnode->child; bnode; bnode = bnode->next) { | |
2276 if(GAIM_BLIST_NODE_IS_BUDDY(bnode)) { | |
2277 GaimBuddy *buddy = (GaimBuddy *)bnode; | |
2278 if(!exp_acct || buddy->account == exp_acct) { | |
2279 print_buddy(file, buddy); | |
2280 } | |
5234 | 2281 } |
5228 | 2282 } |
6695 | 2283 |
2284 fprintf(file, "\t\t\t</contact>\n"); | |
2285 } else if(GAIM_BLIST_NODE_IS_CHAT(cnode)) { | |
2286 GaimBlistChat *chat = (GaimBlistChat *)cnode; | |
5234 | 2287 if(!exp_acct || chat->account == exp_acct) { |
2288 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
|
2289 fprintf(file, "\t\t\t<chat protocol=\"%d\" account=\"%s\">\n", |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
2290 gaim_account_get_protocol(chat->account), |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
2291 acct_name); |
5237 | 2292 if(chat->alias) { |
2293 char *chat_alias = g_markup_escape_text(chat->alias, -1); | |
2294 fprintf(file, "\t\t\t\t<alias>%s</alias>\n", chat_alias); | |
2295 g_free(chat_alias); | |
2296 } | |
5234 | 2297 g_hash_table_foreach(chat->components, |
2298 blist_print_chat_components, file); | |
5906 | 2299 g_hash_table_foreach(chat->settings, |
6695 | 2300 blist_print_cnode_settings, file); |
5234 | 2301 fprintf(file, "\t\t\t</chat>\n"); |
5237 | 2302 g_free(acct_name); |
5234 | 2303 } |
5228 | 2304 } |
2305 } | |
2306 fprintf(file, "\t\t</group>\n"); | |
2307 g_free(group_name); | |
2308 } | |
2309 } | |
2310 | |
2311 fprintf(file, "\t</blist>\n"); | |
2312 fprintf(file, "\t<privacy>\n"); | |
2313 | |
5580
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
2314 for(accounts = gaim_accounts_get_all(); |
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
2315 accounts != NULL; |
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
2316 accounts = accounts->next) { |
86456ec3ca25
[gaim-migrate @ 5984]
Christian Hammond <chipx86@chipx86.com>
parents:
5563
diff
changeset
|
2317 |
5563
9eb5b13fd412
[gaim-migrate @ 5965]
Christian Hammond <chipx86@chipx86.com>
parents:
5545
diff
changeset
|
2318 GaimAccount *account = accounts->data; |
5228 | 2319 char *acct_name = g_markup_escape_text(account->username, -1); |
2320 if(!exp_acct || account == exp_acct) { | |
2321 fprintf(file, "\t\t<account protocol=\"%d\" name=\"%s\" " | |
5943
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
2322 "mode=\"%d\">\n", gaim_account_get_protocol(account), |
a4f2aba0848d
[gaim-migrate @ 6384]
Christian Hammond <chipx86@chipx86.com>
parents:
5906
diff
changeset
|
2323 acct_name, account->perm_deny); |
5228 | 2324 for(buds = account->permit; buds; buds = buds->next) { |
2325 char *bud_name = g_markup_escape_text(buds->data, -1); | |
2326 fprintf(file, "\t\t\t<permit>%s</permit>\n", bud_name); | |
2327 g_free(bud_name); | |
2328 } | |
2329 for(buds = account->deny; buds; buds = buds->next) { | |
2330 char *bud_name = g_markup_escape_text(buds->data, -1); | |
2331 fprintf(file, "\t\t\t<block>%s</block>\n", bud_name); | |
2332 g_free(bud_name); | |
2333 } | |
2334 fprintf(file, "\t\t</account>\n"); | |
2335 } | |
2336 g_free(acct_name); | |
2337 } | |
2338 | |
2339 fprintf(file, "\t</privacy>\n"); | |
2340 fprintf(file, "</gaim>\n"); | |
2341 } | |
2342 | |
2343 void gaim_blist_save() { | |
2344 FILE *file; | |
2345 char *user_dir = gaim_user_dir(); | |
2346 char *filename; | |
2347 char *filename_real; | |
2348 | |
2349 if(!user_dir) | |
2350 return; | |
2351 if(!blist_safe_to_write) { | |
2352 gaim_debug(GAIM_DEBUG_WARNING, "blist save", | |
2353 "AHH!! Tried to write the blist before we read it!\n"); | |
2354 return; | |
2355 } | |
2356 | |
2357 file = fopen(user_dir, "r"); | |
2358 if(!file) | |
2359 mkdir(user_dir, S_IRUSR | S_IWUSR | S_IXUSR); | |
2360 else | |
2361 fclose(file); | |
2362 | |
2363 filename = g_build_filename(user_dir, "blist.xml.save", NULL); | |
2364 | |
2365 if((file = fopen(filename, "w"))) { | |
2366 gaim_blist_write(file, NULL); | |
2367 fclose(file); | |
2368 chmod(filename, S_IRUSR | S_IWUSR); | |
2369 } else { | |
2370 gaim_debug(GAIM_DEBUG_ERROR, "blist save", "Unable to write %s\n", | |
2371 filename); | |
2372 } | |
2373 | |
2374 filename_real = g_build_filename(user_dir, "blist.xml", NULL); | |
2375 | |
2376 if(rename(filename, filename_real) < 0) | |
2377 gaim_debug(GAIM_DEBUG_ERROR, "blist save", | |
2378 "Error renaming %s to %s\n", filename, filename_real); | |
2379 | |
2380 | |
2381 g_free(filename); | |
2382 g_free(filename_real); | |
2383 } | |
2384 | |
6695 | 2385 void gaim_group_set_setting(GaimGroup *g, const char *key, |
5228 | 2386 const char *value) { |
2387 if(!g) | |
2388 return; | |
2389 g_hash_table_replace(g->settings, g_strdup(key), g_strdup(value)); | |
2390 } | |
2391 | |
6695 | 2392 char *gaim_group_get_setting(GaimGroup *g, const char *key) { |
5228 | 2393 if(!g) |
2394 return NULL; | |
2395 return g_strdup(g_hash_table_lookup(g->settings, key)); | |
2396 } | |
2397 | |
6695 | 2398 void gaim_blist_chat_set_setting(GaimBlistChat *c, const char *key, |
5906 | 2399 const char *value) |
2400 { | |
2401 if(!c) | |
2402 return; | |
2403 g_hash_table_replace(c->settings, g_strdup(key), g_strdup(value)); | |
2404 } | |
2405 | |
6695 | 2406 char *gaim_blist_chat_get_setting(GaimBlistChat *c, const char *key) |
5906 | 2407 { |
2408 if(!c) | |
2409 return NULL; | |
2410 return g_strdup(g_hash_table_lookup(c->settings, key)); | |
2411 } | |
2412 | |
6695 | 2413 void gaim_buddy_set_setting(GaimBuddy *b, const char *key, |
5228 | 2414 const char *value) { |
2415 if(!b) | |
2416 return; | |
2417 g_hash_table_replace(b->settings, g_strdup(key), g_strdup(value)); | |
2418 } | |
2419 | |
6695 | 2420 char *gaim_buddy_get_setting(GaimBuddy *b, const char *key) { |
5228 | 2421 if(!b) |
2422 return NULL; | |
2423 return g_strdup(g_hash_table_lookup(b->settings, key)); | |
2424 } | |
2425 | |
2426 void gaim_set_blist_ui_ops(struct gaim_blist_ui_ops *ops) | |
2427 { | |
2428 blist_ui_ops = ops; | |
2429 } | |
2430 | |
2431 struct gaim_blist_ui_ops * | |
2432 gaim_get_blist_ui_ops(void) | |
2433 { | |
2434 return blist_ui_ops; | |
2435 } | |
2436 | |
6695 | 2437 int gaim_blist_get_group_size(GaimGroup *group, gboolean offline) { |
5228 | 2438 if(!group) |
2439 return 0; | |
2440 | |
5277 | 2441 return offline ? group->totalsize : group->currentsize; |
5228 | 2442 } |
2443 | |
6695 | 2444 int gaim_blist_get_group_online_count(GaimGroup *group) { |
5228 | 2445 if(!group) |
2446 return 0; | |
2447 | |
5277 | 2448 return group->online; |
5228 | 2449 } |
2450 | |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2451 void * |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2452 gaim_blist_get_handle(void) |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2453 { |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2454 static int handle; |
5228 | 2455 |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2456 return &handle; |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2457 } |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2458 |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2459 void |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2460 gaim_blist_init(void) |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2461 { |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2462 void *handle = gaim_blist_get_handle(); |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2463 |
6564
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2464 gaim_signal_register(handle, "buddy-away", |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2465 gaim_marshal_VOID__POINTER, NULL, 1, |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2466 gaim_value_new(GAIM_TYPE_SUBTYPE, |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2467 GAIM_SUBTYPE_BLIST_BUDDY)); |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2468 |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2469 gaim_signal_register(handle, "buddy-back", |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2470 gaim_marshal_VOID__POINTER, NULL, 1, |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2471 gaim_value_new(GAIM_TYPE_SUBTYPE, |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2472 GAIM_SUBTYPE_BLIST_BUDDY)); |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2473 |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2474 gaim_signal_register(handle, "buddy-idle", |
6564
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2475 gaim_marshal_VOID__POINTER, NULL, 1, |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2476 gaim_value_new(GAIM_TYPE_SUBTYPE, |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2477 GAIM_SUBTYPE_BLIST_BUDDY)); |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2478 gaim_signal_register(handle, "buddy-unidle", |
6564
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2479 gaim_marshal_VOID__POINTER, NULL, 1, |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2480 gaim_value_new(GAIM_TYPE_SUBTYPE, |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2481 GAIM_SUBTYPE_BLIST_BUDDY)); |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2482 |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2483 gaim_signal_register(handle, "buddy-signed-on", |
6564
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2484 gaim_marshal_VOID__POINTER, NULL, 1, |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2485 gaim_value_new(GAIM_TYPE_SUBTYPE, |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2486 GAIM_SUBTYPE_BLIST_BUDDY)); |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2487 |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2488 gaim_signal_register(handle, "buddy-signed-off", |
6564
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2489 gaim_marshal_VOID__POINTER, NULL, 1, |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2490 gaim_value_new(GAIM_TYPE_SUBTYPE, |
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2491 GAIM_SUBTYPE_BLIST_BUDDY)); |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2492 |
6564
800ef4a51096
[gaim-migrate @ 7086]
Christian Hammond <chipx86@chipx86.com>
parents:
6506
diff
changeset
|
2493 gaim_signal_register(handle, "update-idle", gaim_marshal_VOID, NULL, 0); |
6485
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2494 } |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2495 |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2496 void |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2497 gaim_blist_uninit(void) |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2498 { |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2499 gaim_signals_unregister_by_instance(gaim_blist_get_handle()); |
70d5122bc3ff
[gaim-migrate @ 6999]
Christian Hammond <chipx86@chipx86.com>
parents:
6473
diff
changeset
|
2500 } |