PurpleCmdRet flist_global_kick_ban_unban_cmd(PurpleConversation *convo, const gchar *cmd, gchar **args, gchar **error, void *data) {
PurpleConnection *pc = purple_conversation_get_gc(convo);
FListAccount *fla = pc->proto_data;
const gchar *character, *code;
JsonObject *json;
FListFlags flags;
flags = flist_get_flags(fla, NULL, fla->proper_character);
if(!(flags & (FLIST_FLAG_ADMIN | FLIST_FLAG_GLOBAL_OP))) {
*error = g_strdup(_("You must be a global operator to globally kick, ban, or unban."));
return PURPLE_CMD_STATUS_FAILED;
}
if(!purple_utf8_strcasecmp(cmd, "gkick")) code = FLIST_GLOBAL_KICK;
if(!purple_utf8_strcasecmp(cmd, "ipban")) code = FLIST_GLOBAL_IP_BAN;
if(!purple_utf8_strcasecmp(cmd, "accountban")) code = FLIST_GLOBAL_ACCOUNT_BAN;
if(!purple_utf8_strcasecmp(cmd, "gunban")) code = FLIST_GLOBAL_UNBAN;
if(!code) return PURPLE_CMD_STATUS_NOT_FOUND;
character = args[0];
json = json_object_new();
json_object_set_string_member(json, "character", character);
flist_request(pc, code, json);
json_object_unref(json);
return PURPLE_CMD_STATUS_OK;
}
PurpleCmdRet flist_create_kill_channel_cmd(PurpleConversation *convo, const gchar *cmd, gchar **args, gchar **error, void *data) {
PurpleConnection *pc = purple_conversation_get_gc(convo);
FListAccount *fla = pc->proto_data;
const gchar *channel, *code;
JsonObject *json;
FListFlags flags;
flags = flist_get_flags(fla, NULL, fla->proper_character);
if(!(flags & (FLIST_FLAG_ADMIN | FLIST_FLAG_GLOBAL_OP))) {
*error = g_strdup(_("You must be a global operator to create or delete public channels."));
return PURPLE_CMD_STATUS_FAILED;
}
if(!purple_utf8_strcasecmp(cmd, "createchannel")) code = FLIST_PUBLIC_CHANNEL_CREATE;
if(!purple_utf8_strcasecmp(cmd, "killchannel")) code = FLIST_PUBLIC_CHANNEL_DELETE;
if(!code) return PURPLE_CMD_STATUS_NOT_FOUND;
channel = args[0];
json = json_object_new();
json_object_set_string_member(json, "channel", channel);
flist_request(pc, code, json);
json_object_unref(json);
return PURPLE_CMD_STATUS_OK;
}
PurpleCmdRet flist_admin_op_deop_cmd(PurpleConversation *convo, const gchar *cmd, gchar **args, gchar **error, void *data) {
PurpleConnection *pc = purple_conversation_get_gc(convo);
FListAccount *fla = pc->proto_data;
const gchar *character, *code;
JsonObject *json;
FListFlags flags;
flags = flist_get_flags(fla, NULL, fla->proper_character);
if(!(flags & FLIST_FLAG_ADMIN)) {
*error = g_strdup(_("You must be an administrator to add or remove global operators."));
return PURPLE_CMD_STATUS_FAILED;
}
if(!purple_utf8_strcasecmp(cmd, "op")) code = FLIST_CHANNEL_BAN;
if(!purple_utf8_strcasecmp(cmd, "deop")) code = FLIST_CHANNEL_UNBAN;
if(!code) return PURPLE_CMD_STATUS_NOT_FOUND;
character = args[0];
json = json_object_new();
json_object_set_string_member(json, "character", character);
flist_request(pc, code, json);
json_object_unref(json);
return PURPLE_CMD_STATUS_OK;
}
bool PurpleIMChat::addContactCbk(void * dataIn)
{
Mutex::ScopedLock lock(PurpleIMChat::_mutex);
PurpleIMChatCallbackData* cbData = (PurpleIMChatCallbackData*) dataIn;
PurpleIMChat* imChat = cbData->getPurpleIMChat();
IMChatSession* chatSession = cbData->getIMChatSession();
PurpleAccount* gAccount = getPurpleAccount( imChat->getIMAccount() );
// const char * contactId = (const char *)((misc_t *)data)->data_ptr2;
mConvInfo_t *mConv = FindChatStructById(chatSession->getId());
int BuddyNbr = chatSession->getIMContactSet().size();
PurpleConversation *gConv = NULL;
if (mConv)
gConv = mConv->purple_conv_session; //VOXOX - JRT - 2009.07.09
else
LOG_FATAL("ConvInfo not created !!!");
if (purple_conversation_get_type(gConv) == PURPLE_CONV_TYPE_IM)
{
GList *mlist = NULL;
IMContactSet& chatContact = const_cast<IMContactSet&>(chatSession->getIMContactSet());
IMContactSet::const_iterator it = chatContact.begin();
const std::string & firstContactId = it->getContactId();
PurpleConnection *gGC;
gConv = mConv->purple_conv_session; //VOXOX - JRT - 2009.07.09
gGC = purple_conversation_get_gc(gConv);
mlist = g_list_append(mlist, const_cast<char*>(cbData->getContactId().c_str()) );
mlist = g_list_append(mlist, (char *) firstContactId.c_str());
createPurpleChat(gGC, chatSession->getId(), mlist, *imChat, gAccount); //VOXOX - JRT - 2009.07.10
}
else if (purple_conversation_get_type(gConv) == PURPLE_CONV_TYPE_CHAT)
{
serv_chat_invite(purple_conversation_get_gc(gConv), purple_conv_chat_get_id(PURPLE_CONV_CHAT(gConv)), NULL, cbData->getContactId().c_str() );
}
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
/*------------------------------------------------------------------------
* This gets called when a new chat conversation is opened by the user
*
* @param conv The conversation object
* @param session The MXit session object
*/
static void mxit_cb_chat_created( PurpleConversation* conv, struct MXitSession* session )
{
PurpleConnection* gc;
struct contact* contact;
PurpleBuddy* buddy;
const char* who;
char* tmp;
gc = purple_conversation_get_gc( conv );
if ( session->con != gc ) {
/* not our conversation */
return;
}
else if ( purple_conversation_get_type( conv ) != PURPLE_CONV_TYPE_IM ) {
/* wrong type of conversation */
return;
}
/* get the contact name */
who = purple_conversation_get_name( conv );
if ( !who )
return;
purple_debug_info( MXIT_PLUGIN_ID, "Conversation started with '%s'\n", who );
/* find the buddy object */
buddy = purple_find_buddy( session->acc, who );
if ( !buddy )
return;
contact = purple_buddy_get_protocol_data( buddy );
if ( !contact )
return;
/* we ignore all conversations with which we have chatted with in this session */
if ( find_active_chat( session->active_chats, who ) )
return;
/* determine if this buddy is a MXit service */
switch ( contact->type ) {
case MXIT_TYPE_BOT :
case MXIT_TYPE_CHATROOM :
case MXIT_TYPE_GALLERY :
case MXIT_TYPE_INFO :
tmp = g_strdup_printf("<font color=\"#999999\">%s</font>\n", _( "Loading menu..." ));
serv_got_im( session->con, who, tmp, PURPLE_MESSAGE_NOTIFY, time( NULL ) );
g_free( tmp );
mxit_send_message( session, who, " ", FALSE, FALSE );
default :
break;
}
}
void PurpleChatMngr::ChatJoinedCbk(PurpleConversation *conv)
{
mConvInfo_t *mConv = (mConvInfo_t *) conv->ui_data;
if (mConv->pending_invites)
{
for (GList *l = mConv->pending_invites; l != NULL; l = l->next)
{
serv_chat_invite(purple_conversation_get_gc(conv),
purple_conv_chat_get_id(PURPLE_CONV_CHAT(conv)),
"Join my conference...", (char *)l->data);
}
}
}
/**
* A function to send a chat or im message to the specific conversation
* without emitting "sending-im" or "sending-chat" signal, which would
* cause an infinite loop for this plugin.
*
* taken from conversation.c with signal emission removed.
*/
static void
splitter_common_send(PurpleConversation *conv, const char *message,
PurpleMessageFlags msgflags)
{
PurpleConversationType type;
PurpleAccount *account;
PurpleConnection *gc;
char *sent = NULL;
if (strlen(message) == 0)
return;
account = purple_conversation_get_account(conv);
#if PURPLE_VERSION_CHECK(3,0,0)
gc = purple_conversation_get_connection(conv);
#else
gc = purple_conversation_get_gc(conv);
#endif
g_return_if_fail(account != NULL);
g_return_if_fail(gc != NULL);
type = purple_conversation_get_type(conv);
if ((purple_conversation_get_features(conv) & PURPLE_CONNECTION_HTML) &&
!(msgflags & PURPLE_MESSAGE_RAW))
{
sent = purple_markup_linkify(message);
}
else
sent = g_strdup(message);
msgflags |= PURPLE_MESSAGE_SEND;
splitter_injected_message = TRUE;
if (type == PURPLE_CONV_TYPE_IM) {
if (sent != NULL && sent[0] != '\0')
purple_conv_im_send_with_flags(PURPLE_CONV_IM(conv), sent, msgflags);
}
else {
if (sent != NULL && sent[0] != '\0')
purple_conv_chat_send_with_flags(PURPLE_CONV_CHAT(conv), sent, msgflags);
}
splitter_injected_message = FALSE;
g_free(sent);
}
/*static void
toggle_nickchange_pref(const char *name, PurplePrefType type, gconstpointer val, gpointer data)
{
}*/
static void nickchange_chat_rename_user
(PurpleConversation *conv, const char *old_user, const char *new_user, const char *new_alias)
{
if (!should_hide_notice(conv, old_user, userstable)) {
PurpleConvChat *chat = PURPLE_CONV_CHAT(conv);
char tmp[2048];
if (purple_strequal(chat->nick, purple_normalize(conv->account, old_user))) {
// Its me!
char *escaped = g_markup_escape_text(new_user, -1);
g_snprintf(tmp, sizeof(tmp),
_("You are now known as %s"), escaped);
g_free(escaped);
} else {
const char *old_alias = old_user;
const char *new_alias = new_user;
char *escaped;
char *escaped2;
PurpleConnection *gc = purple_conversation_get_gc(conv);
PurplePluginProtocolInfo *prpl_info;
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc));
if (prpl_info && !(prpl_info->options & OPT_PROTO_UNIQUE_CHATNAME)) {
PurpleBuddy *buddy;
if ((buddy = purple_find_buddy(gc->account, old_user)) != NULL)
old_alias = purple_buddy_get_contact_alias(buddy);
if ((buddy = purple_find_buddy(gc->account, new_user)) != NULL)
new_alias = purple_buddy_get_contact_alias(buddy);
}
escaped = g_markup_escape_text(old_alias, -1);
escaped2 = g_markup_escape_text(new_alias, -1);
g_snprintf(tmp, sizeof(tmp),
_("%s is now known as %s"), escaped, escaped2);
g_free(escaped);
g_free(escaped2);
}
purple_conversation_write(conv, NULL, tmp,
PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LINKIFY,
time(NULL));
}
if (orig_chat_rename_user)
return orig_chat_rename_user(conv, old_user, new_user, new_alias);
}
bool PurpleIMChat::changeTypingStateCbk(void * dataIn)
{
Mutex::ScopedLock lock(PurpleIMChat::_mutex);
PurpleIMChatCallbackData* cbData = (PurpleIMChatCallbackData*) dataIn;
IMChatSession* chatSession = cbData->getIMChatSession();
IMChat::TypingState state = cbData->getTypingState();
PurpleTypingState gState = PURPLE_NOT_TYPING;
mConvInfo_t *mConv = FindChatStructById(chatSession->getId());
PurpleConversation *gConv = NULL;
if (mConv)
{
// if ((gConv = (PurpleConversation *)mConv->purple_conv_session)) //VOXOX - JRT - 2009.07.09 This is poor coding technique!
gConv = mConv->purple_conv_session;
if ( gConv )
{
switch (state)
{
case IMChat::TypingStateTyping:
gState = PURPLE_TYPING;
break;
case IMChat::TypingStateStopTyping:
//gState = PURPLE_TYPED;
gState = PURPLE_NOT_TYPING;
break;
default:
gState = PURPLE_NOT_TYPING;
break;
}
serv_send_typing(purple_conversation_get_gc(gConv), purple_conversation_get_name(gConv), gState);
}
}
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
PurpleCmdRet flist_timeout_cmd(PurpleConversation *convo, const gchar *cmd, gchar **args, gchar **error, void *data) {
PurpleConnection *pc = purple_conversation_get_gc(convo);
FListAccount *fla = pc->proto_data;
gchar **split; guint count;
const gchar *character, *time, *reason;
gulong time_parsed; gchar *endptr;
JsonObject *json;
FListFlags flags;
flags = flist_get_flags(fla, NULL, fla->proper_character);
if(!(flags & (FLIST_FLAG_ADMIN | FLIST_FLAG_GLOBAL_OP))) {
*error = g_strdup(_("You must be a global operator to timeban."));
return PURPLE_CMD_STATUS_FAILED;
}
split = g_strsplit(args[0], ",", 3);
count = g_strv_length(split);
if(count < 3) {
g_strfreev(split);
*error = g_strdup(_("You must enter a character, a time, and a reason."));
return PURPLE_CMD_STATUS_WRONG_ARGS;
}
character = split[0];
time = g_strchug(split[1]);
reason = g_strchug(split[2]);
time_parsed = strtoul(time, &endptr, 10);
if(time_parsed == 0 || endptr != time + strlen(time)) {
g_strfreev(split);
*error = g_strdup(_("You must enter a valid length of time."));
return PURPLE_CMD_STATUS_WRONG_ARGS;
}
json = json_object_new();
json_object_set_string_member(json, "character", character);
json_object_set_string_member(json, "reason", reason);
json_object_set_int_member(json, "time", time_parsed);
flist_request(pc, FLIST_GLOBAL_TIMEOUT, json);
json_object_unref(json);
g_strfreev(split);
return PURPLE_CMD_STATUS_OK;
}
static PurpleCmdRet irc_parse_purple_cmd(PurpleConversation *conv, const gchar *cmd,
gchar **args, gchar **error, void *data)
{
PurpleConnection *gc;
struct irc_conn *irc;
struct _irc_user_cmd *cmdent;
gc = purple_conversation_get_gc(conv);
if (!gc)
return PURPLE_CMD_RET_FAILED;
irc = gc->proto_data;
if ((cmdent = g_hash_table_lookup(irc->cmds, cmd)) == NULL)
return PURPLE_CMD_RET_FAILED;
(cmdent->cb)(irc, cmd, purple_conversation_get_name(conv), (const char **)args);
return PURPLE_CMD_RET_OK;
}
PurpleCmdRet flist_reward_cmd(PurpleConversation *convo, const gchar *cmd, gchar **args, gchar **error, void *data) {
PurpleConnection *pc = purple_conversation_get_gc(convo);
FListAccount *fla = pc->proto_data;
const gchar *character;
JsonObject *json;
FListFlags flags;
flags = flist_get_flags(fla, NULL, fla->proper_character);
if(!(flags & (FLIST_FLAG_ADMIN | FLIST_FLAG_GLOBAL_OP))) {
*error = g_strdup(_("You must be a global operator to reward a user."));
return PURPLE_CMD_STATUS_FAILED;
}
character = args[0];
json = json_object_new();
json_object_set_string_member(json, "character", character);
flist_request(pc, FLIST_REWARD, json);
json_object_unref(json);
return PURPLE_CMD_STATUS_OK;
}
PurpleCmdRet flist_broadcast_cmd(PurpleConversation *convo, const gchar *cmd, gchar **args, gchar **error, void *data) {
PurpleConnection *pc = purple_conversation_get_gc(convo);
FListAccount *fla = pc->proto_data;
const gchar *message;
JsonObject *json;
FListFlags flags;
flags = flist_get_flags(fla, NULL, fla->proper_character);
if(!(flags & (FLIST_FLAG_ADMIN))) {
*error = g_strdup(_("You must be an administrator to send a global broadcast."));
return PURPLE_CMD_STATUS_FAILED;
}
message = args[0];
json = json_object_new();
json_object_set_string_member(json, "message", message);
flist_request(pc, FLIST_BROADCAST, json);
json_object_unref(json);
return PURPLE_CMD_STATUS_OK;
}
static gboolean
catch_hotkeys_cb (PidginWindow * win, GdkEventKey * event) {
if (event->is_modifier == FALSE) {
gint all_modifiers = 0;
PurpleConversation *conv = NULL;
if (event->state & GDK_SHIFT_MASK)
all_modifiers |= GDK_SHIFT_MASK;
if (event->state & GDK_CONTROL_MASK)
all_modifiers |= GDK_CONTROL_MASK;
if (event->state & GDK_MOD1_MASK)
all_modifiers |= GDK_MOD1_MASK;
conv = pidgin_conv_window_get_active_conversation (win);
if (gdk_keyval_to_lower (event->keyval) ==
(guint) purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_FILE)
&&
all_modifiers ==
purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_FILE_MDFS))
{
PurpleConnection *gc = NULL;
PurplePluginProtocolInfo *prpl_info = NULL;
gc = purple_conversation_get_gc (conv);
if ((gc != NULL) &&
((purple_conversation_get_type (conv) !=
PURPLE_CONV_TYPE_CHAT)
|| !purple_conv_chat_has_left (PURPLE_CONV_CHAT (conv)))) {
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO (gc->prpl);
if (purple_conversation_get_type (conv) ==
PURPLE_CONV_TYPE_IM
&& prpl_info->send_file != NULL
&& (!prpl_info->can_receive_file
|| prpl_info->can_receive_file (gc,
purple_conversation_get_name
(conv)))) {
PurplePlugin *plugin =
purple_plugins_find_with_id (PLUGIN_ID);
if (PLUGIN (locked))
return FALSE; /* Just return, don't fail. */
else {
PLUGIN (locked) = TRUE;
PLUGIN (send_as) = SEND_AS_FILE;
REMEMBER_ACCOUNT (PIDGIN_CONVERSATION (conv));
freeze_desktop (plugin, FALSE);
}
}
}
}
#ifdef ENABLE_UPLOAD
else if (gdk_keyval_to_lower (event->keyval) ==
(guint) purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_FTP)
&&
all_modifiers ==
purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_FTP_MDFS)
)
send_as_ftp_link(win, NULL);
//on_screenshot_insert_as_ftp_link_fromwin_activate_cb (win);
else if (gdk_keyval_to_lower (event->keyval) ==
(guint) purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_HTTP)
&&
all_modifiers ==
purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_HTTP_MDFS)
)
send_as_link(win, NULL);
//on_screenshot_insert_as_link_fromwin_activate_cb (win);
#endif
else if (gdk_keyval_to_lower (event->keyval) == (guint)
purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_IMAGE)
&&
all_modifiers ==
purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_IMAGE_MDFS)
) {
// if (!(purple_conversation_get_features (conv) &
// PURPLE_CONNECTION_NO_IMAGES))
// on_screenshot_insert_as_image_fromwin_activate_cb (win);
}
else {
/* nothing match ! */
}
return TRUE;
}
return FALSE; /* let the signal be handled by other callbacks */
}
static void send_request_confirmed(MMConversation *mmconv)
{
PurpleConnection *connection = purple_conversation_get_gc(mmconv->conv);
const char *convName = purple_conversation_get_name(mmconv->conv);
serv_send_im(connection, convName, MUSICMESSAGING_CONFIRM_MSG, PURPLE_MESSAGE_SEND);
}
void PurpleChatMngr::ChatLeftCbk(PurpleConversation *conv)
{
serv_chat_leave(purple_conversation_get_gc(conv), purple_conv_chat_get_id(PURPLE_CONV_CHAT(conv)) );
}
