int yahoo_c_send(PurpleConnection *gc, int id, const char *what, PurpleMessageFlags flags)
{
PurpleConversation *c;
int ret;
YahooData *yd;
yd = (YahooData *) gc->proto_data;
if (!yd)
return -1;
c = purple_find_chat(gc, id);
if (!c)
return -1;
if (id != YAHOO_CHAT_ID) {
ret = yahoo_conf_send(gc, purple_connection_get_display_name(gc),
purple_conversation_get_name(c), purple_conv_chat_get_users(PURPLE_CONV_CHAT(c)), what);
} else {
ret = yahoo_chat_send(gc, purple_connection_get_display_name(gc),
purple_conversation_get_name(c), what, flags);
if (!ret)
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(c)),
purple_connection_get_display_name(gc), flags, what, time(NULL));
}
return ret;
}
int yahoo_c_send(PurpleConnection *gc, int id, PurpleMessage *msg)
{
PurpleChatConversation *c;
int ret;
YahooData *yd;
const gchar *what = purple_message_get_contents(msg);
PurpleMessageFlags flags = purple_message_get_flags(msg);
yd = purple_connection_get_protocol_data(gc);
if (!yd)
return -1;
c = purple_conversations_find_chat(gc, id);
if (!c)
return -1;
if (id != YAHOO_CHAT_ID) {
GList *users;
users = purple_chat_conversation_get_users(c);
ret = yahoo_conf_send(gc,
purple_connection_get_display_name(gc),
purple_conversation_get_name(PURPLE_CONVERSATION(c)),
users, what);
g_list_free(users);
} else {
ret = yahoo_chat_send(gc, purple_connection_get_display_name(gc),
purple_conversation_get_name(PURPLE_CONVERSATION(c)), what, flags);
if (!ret)
purple_serv_got_chat_in(gc, purple_chat_conversation_get_id(c),
purple_connection_get_display_name(gc), flags, what, time(NULL));
}
return ret;
}
void yahoo_c_leave(PurpleConnection *gc, int id)
{
YahooData *yd = purple_connection_get_protocol_data(gc);
PurpleChatConversation *c;
if (!yd)
return;
c = purple_conversations_find_chat(gc, id);
if (!c)
return;
if (id != YAHOO_CHAT_ID) {
GList *users;
users = purple_chat_conversation_get_users(c);
yahoo_conf_leave(yd,
purple_conversation_get_name(PURPLE_CONVERSATION(c)),
purple_connection_get_display_name(gc), users);
g_list_free(users);
yd->confs = g_slist_remove(yd->confs, c);
} else {
yahoo_chat_leave(gc, purple_conversation_get_name(PURPLE_CONVERSATION(c)),
purple_connection_get_display_name(gc), TRUE);
}
purple_serv_got_chat_left(gc, id);
}
static void irc_chat_invite(PurpleConnection *gc, int id, const char *message, const char *name)
{
struct irc_conn *irc = gc->proto_data;
PurpleConversation *convo = purple_find_chat(gc, id);
const char *args[2];
if (!convo) {
purple_debug(PURPLE_DEBUG_ERROR, "irc", "Got chat invite request for bogus chat\n");
return;
}
args[0] = name;
args[1] = purple_conversation_get_name(convo);
irc_cmd_invite(irc, "invite", purple_conversation_get_name(convo), args);
}
static void irc_chat_leave (PurpleConnection *gc, int id)
{
struct irc_conn *irc = gc->proto_data;
PurpleConversation *convo = purple_find_chat(gc, id);
const char *args[2];
if (!convo)
return;
args[0] = purple_conversation_get_name(convo);
args[1] = NULL;
irc_cmd_part(irc, "part", purple_conversation_get_name(convo), args);
serv_got_chat_left(gc, id);
}
static void nullprpl_chat_invite(PurpleConnection *gc, int id,
const char *message, const char *who) {
const char *username = purple_account_get_username(purple_connection_get_account(gc));
PurpleChatConversation *chat = purple_conversations_find_chat(gc, id);
const char *room = purple_conversation_get_name(PURPLE_CONVERSATION(chat));
PurpleAccount *to_acct = purple_accounts_find(who, NULLPRPL_ID);
purple_debug_info("nullprpl", "%s is inviting %s to join chat room %s\n",
username, who, room);
if (to_acct) {
PurpleChatConversation *to_conv = purple_conversations_find_chat(purple_account_get_connection(to_acct), id);
if (to_conv) {
char *tmp = g_strdup_printf("%s is already in chat room %s.", who, room);
purple_debug_info("nullprpl",
"%s is already in chat room %s; "
"ignoring invitation from %s\n",
who, room, username);
purple_notify_info(gc, _("Chat invitation"), _("Chat invitation"), tmp,
purple_request_cpar_from_conversation(PURPLE_CONVERSATION(to_conv)));
g_free(tmp);
} else {
GHashTable *components;
components = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_free);
g_hash_table_replace(components, "room", g_strdup(room));
g_hash_table_replace(components, "invited_by", g_strdup(username));
purple_serv_got_chat_invite(purple_account_get_connection(to_acct), room, username, message, components);
}
}
}
GList *
otrg_conversation_get_contexts(PurpleConversation *conv)
{
PurpleAccount *account;
const gchar *accountname, *protocol;
gchar *username;
ConnContext *it = NULL;
GList *contexts = NULL;
g_return_val_if_fail(conv != NULL, NULL);
g_return_val_if_fail(PURPLE_IS_IM_CONVERSATION(conv), NULL);
account = purple_conversation_get_account(conv);
accountname = purple_account_get_username(account);
protocol = purple_account_get_protocol_id(account);
username = g_strdup(purple_normalize(account,
purple_conversation_get_name(conv)));
for (it = otrg_plugin_userstate->context_root; it; it = it->next) {
if (g_strcmp0(it->accountname, accountname) != 0)
continue;
if (g_strcmp0(it->protocol, protocol) != 0)
continue;
if (g_strcmp0(it->username, username) != 0)
continue;
contexts = g_list_append(contexts, it);
}
g_free(username);
return contexts;
}
void
_purple_conversations_update_cache(PurpleConversation *conv, const char *name,
PurpleAccount *account)
{
PurpleAccount *old_account;
struct _purple_hconv *hc;
g_return_if_fail(conv != NULL);
g_return_if_fail(account != NULL || name != NULL);
old_account = purple_conversation_get_account(conv);
hc = g_new(struct _purple_hconv, 1);
hc->im = PURPLE_IS_IM_CONVERSATION(conv);
hc->account = old_account;
hc->name = (gchar *)purple_normalize(old_account,
purple_conversation_get_name(conv));
g_hash_table_remove(conversation_cache, hc);
if (account)
hc->account = account;
if (name)
hc->name = g_strdup(purple_normalize(hc->account, name));
g_hash_table_insert(conversation_cache, hc, conv);
}
static void pidginwhiteboard_button_start_press(GtkButton *button, gpointer data)
{
PurpleConversation *conv = data;
PurpleAccount *account = purple_conversation_get_account(conv);
PurpleConnection *gc = purple_account_get_connection(account);
char *to = (char*)(purple_conversation_get_name(conv));
/* Only handle this if local client requested Doodle session (else local
* client would have sent one)
*/
PurpleWhiteboard *wb = purple_whiteboard_get(account, to);
/* Write a local message to this conversation showing that a request for a
* Doodle session has been made
*/
/* XXXX because otherwise gettext will see this string, even though it's
* in an #if 0 block. Remove the XXXX if you want to use this code.
* But, it really shouldn't be a Yahoo-specific string. ;) */
purple_conv_im_write(PURPLE_CONV_IM(conv), "", XXXX_("Sent Doodle request."),
PURPLE_MESSAGE_NICK | PURPLE_MESSAGE_RECV, time(NULL));
yahoo_doodle_command_send_request(gc, to);
yahoo_doodle_command_send_ready(gc, to);
/* Insert this 'session' in the list. At this point, it's only a requested
* session.
*/
wb = purple_whiteboard_create(account, to, DOODLE_STATE_REQUESTING);
}
void yahoo_process_chat_exit(PurpleConnection *gc, struct yahoo_packet *pkt)
{
char *who = NULL;
char *room = NULL;
GSList *l;
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
if (pair->key == 104) {
g_free(room);
room = yahoo_string_decode(gc, pair->value, TRUE);
}
if (pair->key == 109)
who = pair->value;
}
if (who && room) {
PurpleConversation *c = purple_find_chat(gc, YAHOO_CHAT_ID);
if (c && !purple_utf8_strcasecmp(purple_conversation_get_name(c), room))
purple_conv_chat_remove_user(PURPLE_CONV_CHAT(c), who, NULL);
}
g_free(room);
}
void
purple_conversations_add(PurpleConversation *conv)
{
PurpleAccount *account;
struct _purple_hconv *hc;
g_return_if_fail(conv != NULL);
if (g_list_find(conversations, conv) != NULL)
return;
conversations = g_list_prepend(conversations, conv);
if (PURPLE_IS_IM_CONVERSATION(conv))
ims = g_list_prepend(ims, conv);
else
chats = g_list_prepend(chats, conv);
account = purple_conversation_get_account(conv);
hc = g_new(struct _purple_hconv, 1);
hc->name = g_strdup(purple_normalize(account,
purple_conversation_get_name(conv)));
hc->account = account;
hc->im = PURPLE_IS_IM_CONVERSATION(conv);
g_hash_table_insert(conversation_cache, hc, conv);
}
static void
irc_receiving_text(PurpleConnection *gc, const char **incoming, gpointer null)
{
char **splits, *str;
PurpleAccount *account = NULL;
if (!incoming || !*incoming || !**incoming) /* oh the fun .. I can do this all day! */
return;
splits = g_strsplit(*incoming, " ", -1);
/* if there's not at least 5 elements in the string array, this isn't a kick; ignore */
if(g_strv_length(splits) < 5)
return;
account = purple_connection_get_account(gc);
str = g_ascii_strdown(splits[1], -1);
if (strcmp(str, "kick") == 0 && splits[2] && splits[3]) {
char *name = splits[2];
GList *chats = purple_get_chats();
while (chats) {
PurpleConversation *conv = chats->data;
chats = chats->next;
if (purple_conversation_get_account(conv) == account
&& strcmp(purple_conversation_get_name(conv), name) == 0) {
purple_timeout_add(100, show_them, conv);
break;
}
}
}
g_free(str);
g_strfreev(splits);
}
static void
displayed_chat_msg_cb(PurpleConversation *conv, PurpleMessage *msg, gpointer data)
{
purple_debug_misc("gtk-signals test", "displayed-chat-msg (%s, %s)\n",
purple_conversation_get_name(conv),
purple_message_get_contents(msg));
}
/* Exported functions */
DBUS_EXPORT void
music_messaging_change_request(const int session, const char *command,
const char *parameters)
{
MMConversation *mmconv = (MMConversation *)g_list_nth_data(conversations, session);
if (mmconv->started)
{
if (mmconv->originator)
{
const char *name = purple_conversation_get_name(mmconv->conv);
send_change_request (session, name, command, parameters);
} else
{
GString *to_send = g_string_new("");
g_string_append_printf(to_send, "##MM## request %s %s##MM##", command, parameters);
purple_conversation_send(mmconv->conv, to_send->str);
purple_debug_misc("musicmessaging", "Sent request: %s\n", to_send->str);
}
}
}
static void send_request_confirmed(MMConversation *mmconv)
{
PurpleConnection *connection = purple_conversation_get_connection(mmconv->conv);
const char *convName = purple_conversation_get_name(mmconv->conv);
purple_serv_send_im(connection, purple_message_new_outgoing(
convName, MUSICMESSAGING_CONFIRM_MSG, 0));
}
static void
conversation_created_cb (PurpleConversation *conv, gpointer data)
{
gchar *str;
const gchar *tmp_user, *friendly_name;
MsnSession *session = data;
struct pn_contact *contact;
tmp_user = purple_conversation_get_name (conv);
contact = pn_contactlist_find_contact (session->contactlist, tmp_user);
if (contact)
friendly_name = pn_contact_get_friendly_name (contact);
else
friendly_name = tmp_user;
if (!friendly_name)
friendly_name = tmp_user;
if (contact && !(contact->list_op & (1 << MSN_LIST_RL)))
{
str = g_strdup_printf (_("You are not in %s's contact list."), friendly_name);
purple_conversation_write (conv, NULL, str, PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NOTIFY, time (NULL));
g_free (str);
}
}
void PurpleChatMngr::UpdateBuddyTyping(PurpleConversation *conv, PurpleTypingState state)
{
IMChat::TypingState mState;
mConvInfo_t *mConv = (mConvInfo_t *)conv->ui_data;
PurpleIMChat *mIMChat = FindIMChatByPurpleConv(conv);
if (!mIMChat)
return;
switch (state)
{
case PURPLE_TYPING:
mState = IMChat::TypingStateTyping;
break;
case PURPLE_TYPED:
mState = IMChat::TypingStateStopTyping;
break;
default:
mState = IMChat::TypingStateNotTyping;
break;
}
// Get contact id. If it's a jabber contact, remove its ressource.
const char* name = purple_conversation_get_name(conv);
PurpleAccount* gAccount = purple_conversation_get_account(conv);
const char* gPrclId = purple_account_get_protocol_id(gAccount);
std::string contactId = cleanContactId(name, PurpleIMPrcl::GetEnumIMProtocol(gPrclId));
// mIMChat->typingStateChangedEvent(*mIMChat, *((IMChatSession *)(mConv->conv_session)), contactId, mState);
mIMChat->typingStateChangedEvent(*mIMChat, *(mConv->conv_session), contactId, mState); //VOXOX - JRT - 2009.07.09
}
void yahoo_process_chat_exit(PurpleConnection *gc, struct yahoo_packet *pkt)
{
char *who = NULL;
char *room = NULL;
GSList *l;
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
if (pair->key == 104) {
g_free(room);
room = yahoo_string_decode(gc, pair->value, TRUE);
} else if (pair->key == 109) {
if (g_utf8_validate(pair->value, -1, NULL)) {
who = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_chat_exit "
"got non-UTF-8 string for key %d\n", pair->key);
}
}
}
if (who && room) {
PurpleChatConversation *c = purple_conversations_find_chat(gc, YAHOO_CHAT_ID);
if (c && !purple_utf8_strcasecmp(purple_conversation_get_name(
PURPLE_CONVERSATION(c)), room))
purple_chat_conversation_remove_user(c, who, NULL);
}
g_free(room);
}
void yahoo_c_invite(PurpleConnection *gc, int id, const char *msg, const char *name)
{
PurpleConversation *c;
c = purple_find_chat(gc, id);
if (!c || !c->name)
return;
if (id != YAHOO_CHAT_ID) {
yahoo_conf_invite(gc, c, purple_connection_get_display_name(gc), name,
purple_conversation_get_name(c), msg);
} else {
yahoo_chat_invite(gc, purple_connection_get_display_name(gc), name,
purple_conversation_get_name(c), msg);
}
}
static void
qt_write_conv(PurpleConversation *conv, const char *who, const char *alias,
const char *message, PurpleMessageFlags flags, time_t mtime)
{
printf("(%s) %s %s: %s\n", purple_conversation_get_name(conv),
purple_utf8_strftime("(%H:%M:%S)", localtime(&mtime)),
who, message);
}
static VALUE conversation_get_name(VALUE self)
{
PurpleConversation *conversation;
Data_Get_Struct(self, PurpleConversation, conversation);
const char* name = purple_conversation_get_name(conversation);
return rb_str_new2(name);
}
static void received_im_msg(PurpleAccount *account, char *sender, char *message,
PurpleConversation *conv, PurpleMessageFlags flags) {
if (conv==NULL) {
conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, sender);
}
printf("(%s) %s (%s): %s\n", purple_utf8_strftime("%H:%M:%S", NULL), sender, purple_conversation_get_name(conv), message);
}
static gboolean
displaying_chat_msg_cb(PurpleConversation *conv, PurpleMessage *pmsg, gpointer data)
{
purple_debug_misc("gtk-signals test", "displaying-chat-msg (%s, %s)\n",
purple_conversation_get_name(conv),
purple_message_get_contents(pmsg));
return FALSE;
}
int PurpleLine::chat_send(int id, const char *message, PurpleMessageFlags flags) {
PurpleConversation *conv = purple_find_chat(conn, id);
if (!conv) {
purple_debug_warning("line", "Tried to send to a nonexistent chat.\n");
return 0;
}
return send_message(purple_conversation_get_name(conv), message);
}
string ImConversation::get_name() const
{
string ret;
const char *p = NULL;
if (m_purple_conv && (p = purple_conversation_get_name(m_purple_conv))) {
ret = p;
}
return ret;
}
static void nullprpl_chat_leave(PurpleConnection *gc, int id) {
PurpleChatConversation *chat = purple_conversations_find_chat(gc, id);
purple_debug_info("nullprpl", "%s is leaving chat room %s\n",
purple_account_get_username(purple_connection_get_account(gc)),
purple_conversation_get_name(PURPLE_CONVERSATION(chat)));
/* tell everyone that we left */
foreach_gc_in_chat(left_chat_room, gc, id, NULL);
}
static void
received_chat_msg(PurpleAccount *account, const char *sender, const char *msg,
PurpleChatConversation *chat, PurpleMessageFlags flags, gpointer null)
{
const char *nick;
PurpleConversation *conv = PURPLE_CONVERSATION(chat);
nick = purple_chat_conversation_get_nick(chat);
if (g_utf8_collate(sender, nick) == 0)
return;
if (purple_prefs_get_bool(PREFS_EVENT_CHAT_NICK) &&
(purple_utf8_has_word(msg, nick)))
notify(conv, _("%s said your nick in %s"), sender, purple_conversation_get_name(conv));
else if (purple_prefs_get_bool(PREFS_EVENT_CHAT_MSG))
notify(conv, _("%s sent a message in %s"), sender, purple_conversation_get_name(conv));
}
static void nullprpl_get_cb_info(PurpleConnection *gc, int id, const char *who) {
PurpleChatConversation *chat = purple_conversations_find_chat(gc, id);
purple_debug_info("nullprpl",
"retrieving %s's info for %s in chat room %s\n", who,
purple_account_get_username(purple_connection_get_account(gc)),
purple_conversation_get_name(PURPLE_CONVERSATION(chat)));
nullprpl_get_info(gc, who);
}
static void call_chat_func(gpointer data, gpointer userdata) {
PurpleConnection *to = (PurpleConnection *)data;
ChatFuncData *cfdata = (ChatFuncData *)userdata;
int id = purple_chat_conversation_get_id(cfdata->from_chat);
PurpleChatConversation *chat = purple_conversations_find_chat(to, id);
if (chat)
cfdata->fn(cfdata->from_chat, chat, id,
purple_conversation_get_name(PURPLE_CONVERSATION(chat)), cfdata->userdata);
}
PurpleBuddy *
otrg_purple_conversation_get_buddy(PurpleConversation *conv)
{
if (!PURPLE_IS_IM_CONVERSATION(conv))
return NULL;
return purple_blist_find_buddy(
purple_conversation_get_account(conv),
purple_conversation_get_name(conv));
}
