Mercurial > pidgin3 / file comparison

comparison: libpurple/protocols/silc/ops.c

libpurple/protocols/silc/ops.c

changeset 40997
997ab408c113
parent 40889
00c77e22fb64
child 41349
15aeaa1e84ec
equal deleted inserted replaced
40996:ea1c2cf86b55 40997:997ab408c113
93 const char *type; 93 const char *type;
94 const unsigned char *data; 94 const unsigned char *data;
95 SilcUInt32 data_len; 95 SilcUInt32 data_len;
96 PurpleMessageFlags cflags = 0; 96 PurpleMessageFlags cflags = 0;
97 PurpleConversation *chat = NULL; 97 PurpleConversation *chat = NULL;
98 PurpleConversationManager *manager = NULL;
98 SilcBool ret = FALSE; 99 SilcBool ret = FALSE;
99 100
100 if (!mime) 101 if (!mime)
101 return FALSE; 102 return FALSE;
102 103
178 data_len); 179 data_len);
179 ret = TRUE; 180 ret = TRUE;
180 goto out; 181 goto out;
181 } 182 }
182 183
184 manager = purple_conversation_manager_get_default();
185
183 /* Image */ 186 /* Image */
184 if (g_str_has_prefix(type, "image/")) { 187 if (g_str_has_prefix(type, "image/")) {
185 char tmp[32]; 188 char tmp[32];
186 PurpleImage *img; 189 PurpleImage *img;
187 guint img_id; 190 guint img_id;
192 SilcPurplePrvgrp prv; 195 SilcPurplePrvgrp prv;
193 196
194 for (l = sg->grps; l; l = l->next) 197 for (l = sg->grps; l; l = l->next)
195 if (((SilcPurplePrvgrp)l->data)->key == key) { 198 if (((SilcPurplePrvgrp)l->data)->key == key) {
196 prv = l->data; 199 prv = l->data;
197 chat = purple_conversations_find_chat_with_account( 200 chat = purple_conversation_manager_find_chat(manager,
198 prv->channel, sg->account); 201 sg->account,
202 prv->channel);
199 break; 203 break;
200 } 204 }
201 } 205 }
202 if (channel && !chat) 206 if (channel && !chat) {
203 chat = purple_conversations_find_chat_with_account( 207 chat = purple_conversation_manager_find_chat(manager, sg->account,
204 channel->channel_name, sg->account); 208 channel->channel_name);
205 if (channel && !chat) 209 }
210
211 if (channel && !chat) {
206 goto out; 212 goto out;
213 }
207 214
208 img = purple_image_new_from_data(data, data_len); 215 img = purple_image_new_from_data(data, data_len);
209 if (!img) 216 if (!img)
210 goto out; 217 goto out;
211 img_id = purple_image_store_add_temporary(img); 218 img_id = purple_image_store_add_temporary(img);
266 SilcUInt32 message_len) 273 SilcUInt32 message_len)
267 { 274 {
268 PurpleConnection *gc = client->application; 275 PurpleConnection *gc = client->application;
269 SilcPurple sg = purple_connection_get_protocol_data(gc); 276 SilcPurple sg = purple_connection_get_protocol_data(gc);
270 PurpleConversation *chat = NULL; 277 PurpleConversation *chat = NULL;
278 PurpleConversationManager *manager = NULL;
271 char *msg, *tmp; 279 char *msg, *tmp;
272 280
273 if (!message) 281 if (!message)
274 return; 282 return;
283
284 manager = purple_conversation_manager_get_default();
275 285
276 if (key) { 286 if (key) {
277 GList *l; 287 GList *l;
278 SilcPurplePrvgrp prv; 288 SilcPurplePrvgrp prv;
279 289
280 for (l = sg->grps; l; l = l->next) 290 for (l = sg->grps; l; l = l->next)
281 if (((SilcPurplePrvgrp)l->data)->key == key) { 291 if (((SilcPurplePrvgrp)l->data)->key == key) {
282 prv = l->data; 292 prv = l->data;
283 chat = purple_conversations_find_chat_with_account( 293 chat = purple_conversation_manager_find_chat(manager, sg->account,
284 prv->channel, sg->account); 294 prv->channel);
285 break; 295 break;
286 } 296 }
287 } 297 }
288 if (!chat) 298 if (!chat) {
289 chat = purple_conversations_find_chat_with_account( 299 chat = purple_conversation_manager_find_chat(manager, sg->account,
290 channel->channel_name, sg->account); 300 channel->channel_name);
291 if (!chat) 301 }
302
303 if (!chat) {
292 return; 304 return;
305 }
293 306
294 if (flags & SILC_MESSAGE_FLAG_SIGNED && 307 if (flags & SILC_MESSAGE_FLAG_SIGNED &&
295 purple_account_get_bool(sg->account, "sign-verify", FALSE)) { 308 purple_account_get_bool(sg->account, "sign-verify", FALSE)) {
296 /* XXX */ 309 /* XXX */
297 } 310 }
363 SilcUInt32 message_len) 376 SilcUInt32 message_len)
364 { 377 {
365 PurpleConnection *gc = client->application; 378 PurpleConnection *gc = client->application;
366 SilcPurple sg = purple_connection_get_protocol_data(gc); 379 SilcPurple sg = purple_connection_get_protocol_data(gc);
367 PurpleConversation *convo; 380 PurpleConversation *convo;
381 PurpleConversationManager *manager = NULL;
368 char *msg, *tmp; 382 char *msg, *tmp;
369 383
370 if (!message) 384 if (!message) {
371 return; 385 return;
372 386 }
387
388 manager = purple_conversation_manager_get_default();
373 /* XXX - Should this be PURPLE_CONV_TYPE_IM? */ 389 /* XXX - Should this be PURPLE_CONV_TYPE_IM? */
374 convo = purple_conversations_find_with_account( 390 convo = purple_conversation_manager_find(manager, sg->account,
375 sender->nickname, sg->account); 391 sender->nickname);
376 392
377 if (flags & SILC_MESSAGE_FLAG_SIGNED && 393 if (flags & SILC_MESSAGE_FLAG_SIGNED &&
378 purple_account_get_bool(sg->account, "sign-verify", FALSE)) { 394 purple_account_get_bool(sg->account, "sign-verify", FALSE)) {
379 /* XXX */ 395 /* XXX */
380 } 396 }
443 silc_notify(SilcClient client, SilcClientConnection conn, 459 silc_notify(SilcClient client, SilcClientConnection conn,
444 SilcNotifyType type, ...) 460 SilcNotifyType type, ...)
445 { 461 {
446 va_list va; 462 va_list va;
447 PurpleConnection *gc = client->application; 463 PurpleConnection *gc = client->application;
464 PurpleConversationManager *manager;
448 SilcPurple sg = purple_connection_get_protocol_data(gc); 465 SilcPurple sg = purple_connection_get_protocol_data(gc);
449 PurpleAccount *account = purple_connection_get_account(gc); 466 PurpleAccount *account = purple_connection_get_account(gc);
450 PurpleConversation *chat; 467 PurpleConversation *chat;
451 SilcClientEntry client_entry, client_entry2; 468 SilcClientEntry client_entry, client_entry2;
452 SilcChannelEntry channel; 469 SilcChannelEntry channel;
462 SilcDList list; 479 SilcDList list;
463 480
464 va_start(va, type); 481 va_start(va, type);
465 memset(buf, 0, sizeof(buf)); 482 memset(buf, 0, sizeof(buf));
466 483
484 manager = purple_conversation_manager_get_default();
485
467 switch (type) { 486 switch (type) {
468 487
469 case SILC_NOTIFY_TYPE_NONE: 488 case SILC_NOTIFY_TYPE_NONE:
470 break; 489 break;
471 490
488 507
489 /* If we joined channel, do nothing */ 508 /* If we joined channel, do nothing */
490 if (client_entry == conn->local_entry) 509 if (client_entry == conn->local_entry)
491 break; 510 break;
492 511
493 chat = purple_conversations_find_chat_with_account( 512 chat = purple_conversation_manager_find_chat(manager, sg->account,
494 channel->channel_name, sg->account); 513 channel->channel_name);
495 if (!chat) 514 if (!chat) {
496 break; 515 break;
516 }
497 517
498 /* Join user to channel */ 518 /* Join user to channel */
499 g_snprintf(buf, sizeof(buf), "%s@%s", 519 g_snprintf(buf, sizeof(buf), "%s@%s",
500 client_entry->username, client_entry->hostname); 520 client_entry->username, client_entry->hostname);
501 purple_chat_conversation_add_user(PURPLE_CHAT_CONVERSATION(chat), 521 purple_chat_conversation_add_user(PURPLE_CHAT_CONVERSATION(chat),
505 525
506 case SILC_NOTIFY_TYPE_LEAVE: 526 case SILC_NOTIFY_TYPE_LEAVE:
507 client_entry = va_arg(va, SilcClientEntry); 527 client_entry = va_arg(va, SilcClientEntry);
508 channel = va_arg(va, SilcChannelEntry); 528 channel = va_arg(va, SilcChannelEntry);
509 529
510 chat = purple_conversations_find_chat_with_account( 530 chat = purple_conversation_manager_find_chat(manager, sg->account,
511 channel->channel_name, sg->account); 531 channel->channel_name);
512 if (!chat) 532 if (!chat) {
513 break; 533 break;
534 }
514 535
515 /* Remove user from channel */ 536 /* Remove user from channel */
516 purple_chat_conversation_remove_user(PURPLE_CHAT_CONVERSATION(chat), 537 purple_chat_conversation_remove_user(PURPLE_CHAT_CONVERSATION(chat),
517 client_entry->nickname, NULL); 538 client_entry->nickname, NULL);
518 539
523 tmp = va_arg(va, char *); 544 tmp = va_arg(va, char *);
524 545
525 /* Remove from all channels */ 546 /* Remove from all channels */
526 silc_hash_table_list(client_entry->channels, &htl); 547 silc_hash_table_list(client_entry->channels, &htl);
527 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) { 548 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
528 chat = purple_conversations_find_chat_with_account( 549 chat = purple_conversation_manager_find_chat(manager, sg->account,
529 chu->channel->channel_name, sg->account); 550 chu->channel->channel_name);
530 if (!chat) 551 if (!chat) {
531 continue; 552 continue;
553 }
532 purple_chat_conversation_remove_user(PURPLE_CHAT_CONVERSATION(chat), 554 purple_chat_conversation_remove_user(PURPLE_CHAT_CONVERSATION(chat),
533 client_entry->nickname, 555 client_entry->nickname,
534 tmp); 556 tmp);
535 } 557 }
536 silc_hash_table_list_reset(&htl); 558 silc_hash_table_list_reset(&htl);
543 idtype = va_arg(va, int); 565 idtype = va_arg(va, int);
544 entry = va_arg(va, void *); 566 entry = va_arg(va, void *);
545 tmp = va_arg(va, char *); 567 tmp = va_arg(va, char *);
546 channel = va_arg(va, SilcChannelEntry); 568 channel = va_arg(va, SilcChannelEntry);
547 569
548 chat = purple_conversations_find_chat_with_account( 570 chat = purple_conversation_manager_find_chat(manager, sg->account,
549 channel->channel_name, sg->account); 571 channel->channel_name);
550 if (!chat) 572 if (!chat) {
551 break; 573 break;
552 574 }
553 if (!tmp) 575
576 if (!tmp) {
554 break; 577 break;
578 }
555 579
556 esc = g_markup_escape_text(tmp, -1); 580 esc = g_markup_escape_text(tmp, -1);
557 tmp2 = purple_markup_linkify(esc); 581 tmp2 = purple_markup_linkify(esc);
558 g_free(esc); 582 g_free(esc);
559 583
602 break; 626 break;
603 627
604 /* Change nick on all channels */ 628 /* Change nick on all channels */
605 silc_hash_table_list(client_entry->channels, &htl); 629 silc_hash_table_list(client_entry->channels, &htl);
606 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) { 630 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
607 chat = purple_conversations_find_chat_with_account( 631 chat = purple_conversation_manager_find_chat(manager, sg->account,
608 chu->channel->channel_name, sg->account); 632 chu->channel->channel_name);
609 if (!chat) 633 if (!chat) {
610 continue; 634 continue;
611 if (purple_chat_conversation_has_user(PURPLE_CHAT_CONVERSATION(chat), client_entry->nickname)) 635 }
636 if (purple_chat_conversation_has_user(PURPLE_CHAT_CONVERSATION(chat), client_entry->nickname)) {
612 purple_chat_conversation_rename_user(PURPLE_CHAT_CONVERSATION(chat), 637 purple_chat_conversation_rename_user(PURPLE_CHAT_CONVERSATION(chat),
613 tmp, name); 638 tmp, name);
639 }
614 } 640 }
615 silc_hash_table_list_reset(&htl); 641 silc_hash_table_list_reset(&htl);
616 642
617 break; 643 break;
618 644
625 (void)va_arg(va, char *); 651 (void)va_arg(va, char *);
626 (void)va_arg(va, SilcPublicKey); 652 (void)va_arg(va, SilcPublicKey);
627 (void)va_arg(va, SilcDList); 653 (void)va_arg(va, SilcDList);
628 channel = va_arg(va, SilcChannelEntry); 654 channel = va_arg(va, SilcChannelEntry);
629 655
630 chat = purple_conversations_find_chat_with_account( 656 chat = purple_conversation_manager_find_chat(manager, sg->account,
631 channel->channel_name, sg->account); 657 channel->channel_name);
632 if (!chat) 658 if (!chat) {
633 break; 659 break;
634 660 }
635 if (idtype == SILC_ID_CLIENT) 661
662 if (idtype == SILC_ID_CLIENT) {
636 name = ((SilcClientEntry)entry)->nickname; 663 name = ((SilcClientEntry)entry)->nickname;
637 else if (idtype == SILC_ID_SERVER) 664 } else if (idtype == SILC_ID_SERVER) {
638 name = ((SilcServerEntry)entry)->server_name; 665 name = ((SilcServerEntry)entry)->server_name;
639 else 666 } else {
640 name = ((SilcChannelEntry)entry)->channel_name; 667 name = ((SilcChannelEntry)entry)->channel_name;
641 if (!name) 668 }
669
670 if (!name) {
642 break; 671 break;
672 }
643 673
644 if (mode) { 674 if (mode) {
645 silcpurple_get_chmode_string(mode, buf2, sizeof(buf2)); 675 silcpurple_get_chmode_string(mode, buf2, sizeof(buf2));
646 g_snprintf(buf, sizeof(buf), 676 g_snprintf(buf, sizeof(buf),
647 _("<I>%s</I> set channel <I>%s</I> modes to: %s"), name, 677 _("<I>%s</I> set channel <I>%s</I> modes to: %s"), name,
661 entry = va_arg(va, void *); 691 entry = va_arg(va, void *);
662 mode = va_arg(va, SilcUInt32); 692 mode = va_arg(va, SilcUInt32);
663 client_entry2 = va_arg(va, SilcClientEntry); 693 client_entry2 = va_arg(va, SilcClientEntry);
664 channel = va_arg(va, SilcChannelEntry); 694 channel = va_arg(va, SilcChannelEntry);
665 695
666 chat = purple_conversations_find_chat_with_account( 696 chat = purple_conversation_manager_find_chat(manager, sg->account,
667 channel->channel_name, sg->account); 697 channel->channel_name);
668 if (!chat) 698 if (!chat) {
669 break; 699 break;
670 700 }
671 if (idtype == SILC_ID_CLIENT) 701
702 if (idtype == SILC_ID_CLIENT) {
672 name = ((SilcClientEntry)entry)->nickname; 703 name = ((SilcClientEntry)entry)->nickname;
673 else if (idtype == SILC_ID_SERVER) 704 } else if (idtype == SILC_ID_SERVER) {
674 name = ((SilcServerEntry)entry)->server_name; 705 name = ((SilcServerEntry)entry)->server_name;
675 else 706 } else {
676 name = ((SilcChannelEntry)entry)->channel_name; 707 name = ((SilcChannelEntry)entry)->channel_name;
677 if (!name) 708 }
709
710 if (!name) {
678 break; 711 break;
712 }
679 713
680 if (mode) { 714 if (mode) {
681 silcpurple_get_chumode_string(mode, buf2, sizeof(buf2)); 715 silcpurple_get_chumode_string(mode, buf2, sizeof(buf2));
682 g_snprintf(buf, sizeof(buf), 716 g_snprintf(buf, sizeof(buf),
683 _("<I>%s</I> set <I>%s's</I> modes to: %s"), name, 717 _("<I>%s</I> set <I>%s's</I> modes to: %s"), name,
707 client_entry = va_arg(va, SilcClientEntry); 741 client_entry = va_arg(va, SilcClientEntry);
708 tmp = va_arg(va, char *); 742 tmp = va_arg(va, char *);
709 client_entry2 = va_arg(va, SilcClientEntry); 743 client_entry2 = va_arg(va, SilcClientEntry);
710 channel = va_arg(va, SilcChannelEntry); 744 channel = va_arg(va, SilcChannelEntry);
711 745
712 chat = purple_conversations_find_chat_with_account( 746 chat = purple_conversation_manager_find_chat(manager, sg->account,
713 channel->channel_name, sg->account); 747 channel->channel_name);
714 if (!chat) 748 if (!chat) {
715 break; 749 break;
750 }
716 751
717 if (client_entry == conn->local_entry) { 752 if (client_entry == conn->local_entry) {
718 /* Remove us from channel */ 753 /* Remove us from channel */
719 g_snprintf(buf, sizeof(buf), 754 g_snprintf(buf, sizeof(buf),
720 _("You have been kicked off <I>%s</I> by <I>%s</I> (%s)"), 755 _("You have been kicked off <I>%s</I> by <I>%s</I> (%s)"),
758 } 793 }
759 794
760 /* Remove us from all channels */ 795 /* Remove us from all channels */
761 silc_hash_table_list(client_entry->channels, &htl); 796 silc_hash_table_list(client_entry->channels, &htl);
762 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) { 797 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
763 chat = purple_conversations_find_chat_with_account( 798 chat = purple_conversation_manager_find_chat(manager, sg->account,
764 chu->channel->channel_name, sg->account); 799 chu->channel->channel_name);
765 if (!chat) 800 if (!chat) {
766 continue; 801 continue;
802 }
767 purple_conversation_write_system_message(chat, buf, 0); 803 purple_conversation_write_system_message(chat, buf, 0);
768 purple_serv_got_chat_left(gc, purple_chat_conversation_get_id(PURPLE_CHAT_CONVERSATION(chat))); 804 purple_serv_got_chat_left(gc, purple_chat_conversation_get_id(PURPLE_CHAT_CONVERSATION(chat)));
769 } 805 }
770 silc_hash_table_list_reset(&htl); 806 silc_hash_table_list_reset(&htl);
771 807
788 } 824 }
789 825
790 /* Remove user from all channels */ 826 /* Remove user from all channels */
791 silc_hash_table_list(client_entry->channels, &htl); 827 silc_hash_table_list(client_entry->channels, &htl);
792 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) { 828 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
793 chat = purple_conversations_find_chat_with_account( 829 chat = purple_conversation_manager_find_chat(manager, sg->account,
794 chu->channel->channel_name, sg->account); 830 chu->channel->channel_name);
795 if (!chat) 831 if (!chat) {
796 continue; 832 continue;
833 }
797 purple_chat_conversation_remove_user(PURPLE_CHAT_CONVERSATION(chat), 834 purple_chat_conversation_remove_user(PURPLE_CHAT_CONVERSATION(chat),
798 client_entry->nickname, tmp); 835 client_entry->nickname, tmp);
799 } 836 }
800 silc_hash_table_list_reset(&htl); 837 silc_hash_table_list_reset(&htl);
801 } 838 }
812 silc_dlist_start(list); 849 silc_dlist_start(list);
813 while ((client_entry = silc_dlist_get(list))) { 850 while ((client_entry = silc_dlist_get(list))) {
814 /* Remove from all channels */ 851 /* Remove from all channels */
815 silc_hash_table_list(client_entry->channels, &htl); 852 silc_hash_table_list(client_entry->channels, &htl);
816 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) { 853 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
817 chat = purple_conversations_find_chat_with_account( 854 chat = purple_conversation_manager_find_chat(manager, sg->account,
818 chu->channel->channel_name, sg->account); 855 chu->channel->channel_name);
819 if (!chat) 856 if (!chat) {
820 continue; 857 continue;
858 }
821 purple_chat_conversation_remove_user(PURPLE_CHAT_CONVERSATION(chat), 859 purple_chat_conversation_remove_user(PURPLE_CHAT_CONVERSATION(chat),
822 client_entry->nickname, 860 client_entry->nickname,
823 _("Server signoff")); 861 _("Server signoff"));
824 } 862 }
825 silc_hash_table_list_reset(&htl); 863 silc_hash_table_list_reset(&htl);
988 SilcStatus error, va_list ap) 1026 SilcStatus error, va_list ap)
989 { 1027 {
990 PurpleConnection *gc = client->application; 1028 PurpleConnection *gc = client->application;
991 SilcPurple sg = purple_connection_get_protocol_data(gc); 1029 SilcPurple sg = purple_connection_get_protocol_data(gc);
992 PurpleConversation *chat; 1030 PurpleConversation *chat;
1031 PurpleConversationManager *manager;
1032
1033 manager = purple_conversation_manager_get_default();
993 1034
994 switch (command) { 1035 switch (command) {
995 case SILC_COMMAND_JOIN: 1036 case SILC_COMMAND_JOIN:
996 { 1037 {
997 SilcChannelEntry channel; 1038 SilcChannelEntry channel;
1014 topic = va_arg(ap, char *); 1055 topic = va_arg(ap, char *);
1015 1056
1016 /* Add channel to Purple */ 1057 /* Add channel to Purple */
1017 channel->context = SILC_32_TO_PTR(++sg->channel_ids); 1058 channel->context = SILC_32_TO_PTR(++sg->channel_ids);
1018 purple_serv_got_joined_chat(gc, sg->channel_ids, channel->channel_name); 1059 purple_serv_got_joined_chat(gc, sg->channel_ids, channel->channel_name);
1019 chat = purple_conversations_find_chat_with_account( 1060 chat = purple_conversation_manager_find_chat(manager, sg->account,
1020 channel->channel_name, sg->account); 1061 channel->channel_name);
1021 if (!chat) 1062 if (!chat) {
1022 return; 1063 return;
1064 }
1023 1065
1024 /* Add all users to channel */ 1066 /* Add all users to channel */
1025 while (silc_hash_table_get(user_list, NULL, (void *)&chu)) { 1067 while (silc_hash_table_get(user_list, NULL, (void *)&chu)) {
1026 PurpleChatUserFlags f = PURPLE_CHAT_USER_NONE; 1068 PurpleChatUserFlags f = PURPLE_CHAT_USER_NONE;
1027 chu->context = SILC_32_TO_PTR(sg->channel_ids); 1069 chu->context = SILC_32_TO_PTR(sg->channel_ids);
1308 return; 1350 return;
1309 } 1351 }
1310 1352
1311 channel = va_arg(ap, SilcChannelEntry); 1353 channel = va_arg(ap, SilcChannelEntry);
1312 1354
1313 chat = purple_conversations_find_chat_with_account( 1355 chat = purple_conversation_manager_find_chat(manager, sg->account,
1314 channel->channel_name, sg->account); 1356 channel->channel_name);
1315 if (!chat) { 1357 if (!chat) {
1316 purple_debug_error("silc", "Got a topic for %s, which doesn't exist\n", 1358 purple_debug_error("silc", "Got a topic for %s, which doesn't exist\n",
1317 channel->channel_name); 1359 channel->channel_name);
1318 break; 1360 break;
1319 } 1361 }
1344 newnick = va_arg(ap, char *); 1386 newnick = va_arg(ap, char *);
1345 1387
1346 /* Change nick on all channels */ 1388 /* Change nick on all channels */
1347 silc_hash_table_list(local_entry->channels, &htl); 1389 silc_hash_table_list(local_entry->channels, &htl);
1348 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) { 1390 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
1349 chat = purple_conversations_find_chat_with_account( 1391 chat = purple_conversation_manager_find_chat(manager, sg->account,
1350 chu->channel->channel_name, sg->account); 1392 chu->channel->channel_name);
1351 if (!chat) 1393 if (!chat) {
1352 continue; 1394 continue;
1395 }
1353 oldnick = purple_chat_conversation_get_nick(PURPLE_CHAT_CONVERSATION(chat)); 1396 oldnick = purple_chat_conversation_get_nick(PURPLE_CHAT_CONVERSATION(chat));
1354 if (!purple_strequal(oldnick, 1397 if (!purple_strequal(oldnick,
1355 purple_normalize(purple_conversation_get_account(chat), 1398 purple_normalize(purple_conversation_get_account(chat),
1356 newnick))) { 1399 newnick)))
1400 {
1357 1401
1358 purple_chat_conversation_rename_user(PURPLE_CHAT_CONVERSATION(chat), 1402 purple_chat_conversation_rename_user(PURPLE_CHAT_CONVERSATION(chat),
1359 oldnick, newnick); 1403 oldnick, newnick);
1360 purple_chat_conversation_set_nick(PURPLE_CHAT_CONVERSATION(chat), newnick); 1404 purple_chat_conversation_set_nick(PURPLE_CHAT_CONVERSATION(chat), newnick);
1361 } 1405 }

Mercurial Repository: pidgin3

mercurial