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