void IMInvoker::setupPurpleSignals() {
int handle;
// connection signals
purple_signal_connect(purple_connections_get_handle(), "signed-on", &handle, PURPLE_CALLBACK(signedOnCB), NULL);
// conversation signals
purple_signal_connect(purple_conversations_get_handle(), "conversation-created", &handle, PURPLE_CALLBACK(conversationCreatedCB), NULL);
purple_signal_connect(purple_conversations_get_handle(), "chat-joined", &handle, PURPLE_CALLBACK(chatJoinedCB), NULL);
purple_signal_connect(purple_conversations_get_handle(), "chat-join-failed", &handle, PURPLE_CALLBACK(chatJoinFailedCB), NULL);
purple_signal_connect(purple_conversations_get_handle(), "buddy-typing", &handle, PURPLE_CALLBACK(buddyTypingCB), NULL);
purple_signal_connect(purple_conversations_get_handle(), "buddy-typed", &handle, PURPLE_CALLBACK(buddyTypedCB), NULL);
purple_signal_connect(purple_conversations_get_handle(), "buddy-typing-stopped", &handle, PURPLE_CALLBACK(buddyTypingStoppedCB), NULL);
// buddy signals
purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", &handle, PURPLE_CALLBACK(buddyEventCB), GINT_TO_POINTER(PURPLE_BUDDY_SIGNON));
purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", &handle, PURPLE_CALLBACK(buddyEventCB), GINT_TO_POINTER(PURPLE_BUDDY_SIGNOFF));
purple_signal_connect(purple_blist_get_handle(), "buddy-got-login-time", &handle, PURPLE_CALLBACK(buddyEventCB), GINT_TO_POINTER(PURPLE_BUDDY_SIGNON_TIME));
purple_signal_connect(purple_blist_get_handle(), "buddy-idle-changed", &handle, PURPLE_CALLBACK(buddyIdleChangedCB), NULL);
purple_signal_connect(purple_blist_get_handle(), "buddy-status-changed", &handle, PURPLE_CALLBACK(buddyStatusChangedCB), NULL);
purple_signal_connect(purple_blist_get_handle(), "buddy-icon-changed", &handle, PURPLE_CALLBACK(buddyEventCB), GINT_TO_POINTER(PURPLE_BUDDY_ICON));
purple_signal_connect(purple_blist_get_handle(), "buddy-added", &handle, PURPLE_CALLBACK(buddyAddedCB), NULL);
purple_signal_connect(purple_blist_get_handle(), "buddy-removed", &handle, PURPLE_CALLBACK(buddyRemovedCB), NULL);
purple_signal_connect(purple_blist_get_handle(), "blist-node-aliased", &handle, PURPLE_CALLBACK(blistNodeAliasedCB), NULL);
purple_signal_connect(purple_blist_get_handle(), "buddy-caps-changed", &handle, PURPLE_CALLBACK(buddyCapsChangedCB), NULL);
// xfer signals
purple_signal_connect(purple_xfers_get_handle(), "file-recv-request", &handle, PURPLE_CALLBACK(fileRecvRequestCB), NULL);
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
purple_signal_connect(purple_xfers_get_handle(), "file-recv-request", plugin,
PURPLE_CALLBACK(file_recv_request_cb), plugin);
purple_signal_connect(purple_blist_get_handle(), "blist-node-extended-menu", plugin,
PURPLE_CALLBACK(context_menu), plugin);
return TRUE;
}
static void
purple_xfer_set_status(PurpleXfer *xfer, PurpleXferStatusType status)
{
g_return_if_fail(xfer != NULL);
if (purple_debug_is_verbose())
purple_debug_info("xfer", "Changing status of xfer %p from %s to %s\n",
xfer, purple_xfer_status_type_to_string(xfer->status),
purple_xfer_status_type_to_string(status));
if (xfer->status == status)
return;
xfer->status = status;
if(xfer->type == PURPLE_XFER_SEND) {
switch(status) {
case PURPLE_XFER_STATUS_ACCEPTED:
purple_signal_emit(purple_xfers_get_handle(), "file-send-accept", xfer);
break;
case PURPLE_XFER_STATUS_STARTED:
purple_signal_emit(purple_xfers_get_handle(), "file-send-start", xfer);
break;
case PURPLE_XFER_STATUS_DONE:
purple_signal_emit(purple_xfers_get_handle(), "file-send-complete", xfer);
break;
case PURPLE_XFER_STATUS_CANCEL_LOCAL:
case PURPLE_XFER_STATUS_CANCEL_REMOTE:
purple_signal_emit(purple_xfers_get_handle(), "file-send-cancel", xfer);
break;
default:
break;
}
} else if(xfer->type == PURPLE_XFER_RECEIVE) {
switch(status) {
case PURPLE_XFER_STATUS_ACCEPTED:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-accept", xfer);
break;
case PURPLE_XFER_STATUS_STARTED:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-start", xfer);
break;
case PURPLE_XFER_STATUS_DONE:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-complete", xfer);
break;
case PURPLE_XFER_STATUS_CANCEL_LOCAL:
case PURPLE_XFER_STATUS_CANCEL_REMOTE:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-cancel", xfer);
break;
default:
break;
}
}
}
void
purple_xfers_uninit(void)
{
void *handle = purple_xfers_get_handle();
purple_signals_disconnect_by_handle(handle);
purple_signals_unregister_by_instance(handle);
g_hash_table_destroy(xfers_data);
xfers_data = NULL;
}
void set_file_send_complete(PurplePlugin *plugin, PyObject *func)
{
static PyObject *file_send_complete_cb = 0;
Py_XINCREF(func);
Py_XDECREF(file_send_complete_cb);
file_send_complete_cb = func;
purple_signal_connect(purple_xfers_get_handle(), "file-send-complete",
plugin, PURPLE_CALLBACK(xfers_python_cb), file_send_complete_cb);
}
void set_file_recv_cancel(PurplePlugin *plugin, PyObject *func)
{
static PyObject *file_recv_cancel_cb = 0;
Py_XINCREF(func);
Py_XDECREF(file_recv_cancel_cb);
file_recv_cancel_cb = func;
purple_signal_connect(purple_xfers_get_handle(), "file-recv-cancel",
plugin, PURPLE_CALLBACK(xfers_python_cb), file_recv_cancel_cb);
}
static void
purple_xfer_set_status(PurpleXfer *xfer, PurpleXferStatusType status)
{
g_return_if_fail(xfer != NULL);
if (xfer->status == status)
return;
xfer->status = status;
if(xfer->type == PURPLE_XFER_SEND) {
switch(status) {
case PURPLE_XFER_STATUS_ACCEPTED:
purple_signal_emit(purple_xfers_get_handle(), "file-send-accept", xfer);
break;
case PURPLE_XFER_STATUS_STARTED:
purple_signal_emit(purple_xfers_get_handle(), "file-send-start", xfer);
break;
case PURPLE_XFER_STATUS_DONE:
purple_signal_emit(purple_xfers_get_handle(), "file-send-complete", xfer);
break;
case PURPLE_XFER_STATUS_CANCEL_LOCAL:
case PURPLE_XFER_STATUS_CANCEL_REMOTE:
purple_signal_emit(purple_xfers_get_handle(), "file-send-cancel", xfer);
break;
default:
break;
}
} else if(xfer->type == PURPLE_XFER_RECEIVE) {
switch(status) {
case PURPLE_XFER_STATUS_ACCEPTED:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-accept", xfer);
break;
case PURPLE_XFER_STATUS_STARTED:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-start", xfer);
break;
case PURPLE_XFER_STATUS_DONE:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-complete", xfer);
break;
case PURPLE_XFER_STATUS_CANCEL_LOCAL:
case PURPLE_XFER_STATUS_CANCEL_REMOTE:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-cancel", xfer);
break;
default:
break;
}
}
}
void
purple_xfers_init(void) {
void *handle = purple_xfers_get_handle();
xfers_data = g_hash_table_new_full(g_direct_hash, g_direct_equal,
NULL, purple_xfer_priv_data_destroy);
/* register signals */
purple_signal_register(handle, "file-recv-accept",
purple_marshal_VOID__POINTER, NULL, 1,
purple_value_new(PURPLE_TYPE_SUBTYPE,
PURPLE_SUBTYPE_XFER));
purple_signal_register(handle, "file-send-accept",
purple_marshal_VOID__POINTER, NULL, 1,
purple_value_new(PURPLE_TYPE_SUBTYPE,
PURPLE_SUBTYPE_XFER));
purple_signal_register(handle, "file-recv-start",
purple_marshal_VOID__POINTER, NULL, 1,
purple_value_new(PURPLE_TYPE_SUBTYPE,
PURPLE_SUBTYPE_XFER));
purple_signal_register(handle, "file-send-start",
purple_marshal_VOID__POINTER, NULL, 1,
purple_value_new(PURPLE_TYPE_SUBTYPE,
PURPLE_SUBTYPE_XFER));
purple_signal_register(handle, "file-send-cancel",
purple_marshal_VOID__POINTER, NULL, 1,
purple_value_new(PURPLE_TYPE_SUBTYPE,
PURPLE_SUBTYPE_XFER));
purple_signal_register(handle, "file-recv-cancel",
purple_marshal_VOID__POINTER, NULL, 1,
purple_value_new(PURPLE_TYPE_SUBTYPE,
PURPLE_SUBTYPE_XFER));
purple_signal_register(handle, "file-send-complete",
purple_marshal_VOID__POINTER, NULL, 1,
purple_value_new(PURPLE_TYPE_SUBTYPE,
PURPLE_SUBTYPE_XFER));
purple_signal_register(handle, "file-recv-complete",
purple_marshal_VOID__POINTER, NULL, 1,
purple_value_new(PURPLE_TYPE_SUBTYPE,
PURPLE_SUBTYPE_XFER));
purple_signal_register(handle, "file-recv-request",
purple_marshal_VOID__POINTER, NULL, 1,
purple_value_new(PURPLE_TYPE_SUBTYPE,
PURPLE_SUBTYPE_XFER));
}
void
purple_xfer_request(PurpleXfer *xfer)
{
g_return_if_fail(xfer != NULL);
g_return_if_fail(xfer->ops.init != NULL);
purple_xfer_ref(xfer);
if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE)
{
purple_signal_emit(purple_xfers_get_handle(), "file-recv-request", xfer);
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL)
{
/* The file-transfer was cancelled by a plugin */
purple_xfer_cancel_local(xfer);
}
else if (purple_xfer_get_filename(xfer) ||
purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_ACCEPTED)
{
gchar* message = NULL;
PurpleBuddy *buddy = purple_find_buddy(xfer->account, xfer->who);
message = g_strdup_printf(_("%s is offering to send file %s"),
buddy ? purple_buddy_get_alias(buddy) : xfer->who, purple_xfer_get_filename(xfer));
purple_xfer_conversation_write_with_thumbnail(xfer, message);
g_free(message);
/* Ask for a filename to save to if it's not already given by a plugin */
if (xfer->local_filename == NULL)
purple_xfer_ask_recv(xfer);
}
else
{
purple_xfer_ask_accept(xfer);
}
}
else
{
purple_xfer_choose_file(xfer);
}
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
/* migrate the old pref (we should only care if the plugin is actually *used*) */
/*
* TODO: We should eventually call purple_prefs_remove(PREFS_STRANGER_OLD)
* to clean up after ourselves, but we don't want to do it yet
* so that we don't break users who share a .purple directory
* between old libpurple clients and new libpurple clients.
* --Mark Doliner, 2011-01-03
*/
if (!purple_prefs_exists(PREF_STRANGER)) {
if (purple_prefs_get_bool(PREF_STRANGER_OLD))
purple_prefs_add_int(PREF_STRANGER, FT_REJECT);
else
purple_prefs_set_int(PREF_STRANGER, FT_ASK);
}
purple_signal_connect(purple_xfers_get_handle(), "file-recv-request", plugin,
PURPLE_CALLBACK(file_recv_request_cb), plugin);
purple_signal_connect(purple_blist_get_handle(), "blist-node-extended-menu", plugin,
PURPLE_CALLBACK(context_menu), plugin);
return TRUE;
}
static void
file_recv_request_cb(PurpleXfer *xfer, gpointer handle)
{
PurpleAccount *account;
PurpleBlistNode *node;
const char *pref;
char *filename;
char *dirname;
int accept_setting;
account = xfer->account;
node = PURPLE_BLIST_NODE(purple_find_buddy(account, xfer->who));
/* If person is on buddy list, use the buddy setting; otherwise, use the
stranger setting. */
if (node) {
node = purple_blist_node_get_parent(node);
g_return_if_fail(PURPLE_BLIST_NODE_IS_CONTACT(node));
accept_setting = purple_blist_node_get_int(node, "autoaccept");
} else {
accept_setting = purple_prefs_get_int(PREF_STRANGER);
}
switch (accept_setting)
{
case FT_ASK:
break;
case FT_ACCEPT:
pref = purple_prefs_get_string(PREF_PATH);
if (ensure_path_exists(pref))
{
int count = 1;
const char *escape;
gchar **name_and_ext;
const gchar *name;
gchar *ext;
if (purple_prefs_get_bool(PREF_NEWDIR))
dirname = g_build_filename(pref, purple_normalize(account, xfer->who), NULL);
else
dirname = g_build_filename(pref, NULL);
if (!ensure_path_exists(dirname))
{
g_free(dirname);
break;
}
/* Escape filename (if escaping is turned on) */
if (purple_prefs_get_bool(PREF_ESCAPE)) {
escape = purple_escape_filename(xfer->filename);
} else {
escape = xfer->filename;
}
filename = g_build_filename(dirname, escape, NULL);
/* Split at the first dot, to avoid uniquifying "foo.tar.gz" to "foo.tar-2.gz" */
name_and_ext = g_strsplit(escape, ".", 2);
name = name_and_ext[0];
g_return_if_fail(name != NULL);
if (name_and_ext[1] != NULL) {
/* g_strsplit does not include the separator in each chunk. */
ext = g_strdup_printf(".%s", name_and_ext[1]);
} else {
ext = g_strdup("");
}
/* Make sure the file doesn't exist. Do we want some better checking than this? */
/* FIXME: There is a race here: if the newly uniquified file name gets created between
* this g_file_test and the transfer starting, the file created in the meantime
* will be clobbered. But it's not at all straightforward to fix.
*/
while (g_file_test(filename, G_FILE_TEST_EXISTS)) {
char *file = g_strdup_printf("%s-%d%s", name, count++, ext);
g_free(filename);
filename = g_build_filename(dirname, file, NULL);
g_free(file);
}
purple_xfer_request_accepted(xfer, filename);
g_strfreev(name_and_ext);
g_free(ext);
g_free(dirname);
g_free(filename);
}
purple_signal_connect(purple_xfers_get_handle(), "file-recv-complete", handle,
PURPLE_CALLBACK(auto_accept_complete_cb), xfer);
break;
case FT_REJECT:
xfer->status = PURPLE_XFER_STATUS_CANCEL_LOCAL;
break;
}
}
/**************************************************************************
* Plugin stuff
**************************************************************************/
static gboolean
plugin_load(PurplePlugin *plugin)
{
void *core_handle = purple_get_core();
void *acc_handle = purple_accounts_get_handle();
void *blist_handle = purple_blist_get_handle();
void *conn_handle = purple_connections_get_handle();
void *conv_handle = purple_conversations_get_handle();
void *ft_handle = purple_xfers_get_handle();
void *notify_handle = purple_notify_get_handle();
//gntp_register(NULL);
connected = 0;
registered = 0;
connect_to_dll();
_getcwd(DefaultIcon, _MAX_PATH);
strcat(DefaultIcon, "/pixmaps/pidgin/growl_icon.png");
if(!registered)
{
if(growl_register)
{
growl_register(SERVER_IP, PLUGIN_NAME, (const char **const)notifications, 12, 0, DefaultIcon);
registered = 1;
}
}
/* Account subsystem signals */
purple_signal_connect(acc_handle, "account-status-changed",
plugin, PURPLE_CALLBACK(account_status_changed_cb), NULL);
/* Buddy List subsystem signals */
purple_signal_connect(blist_handle, "buddy-status-changed",
plugin, PURPLE_CALLBACK(buddy_status_changed_cb), NULL);
purple_signal_connect(blist_handle, "buddy-signed-on",
plugin, PURPLE_CALLBACK(buddy_signed_on_cb), NULL);
purple_signal_connect(blist_handle, "buddy-signed-off",
plugin, PURPLE_CALLBACK(buddy_signed_off_cb), NULL);
purple_signal_connect(blist_handle, "buddy-icon-changed",
plugin, PURPLE_CALLBACK(buddy_icon_changed_cb), NULL);
/* Connection subsystem signals */
purple_signal_connect(conn_handle, "signed-on",
plugin, PURPLE_CALLBACK(signed_on_cb), NULL);
purple_signal_connect(conn_handle, "signed-off",
plugin, PURPLE_CALLBACK(signed_off_cb), NULL);
purple_signal_connect(conn_handle, "connection-error",
plugin, PURPLE_CALLBACK(connection_error_cb), NULL);
/* Conversations subsystem signals */
purple_signal_connect(conv_handle, "wrote-im-msg",
plugin, PURPLE_CALLBACK(wrote_im_msg_cb), NULL);
purple_signal_connect(conv_handle, "sent-im-msg",
plugin, PURPLE_CALLBACK(sent_im_msg_cb), NULL);
purple_signal_connect(conv_handle, "received-im-msg",
plugin, PURPLE_CALLBACK(received_im_msg_cb), NULL);
purple_signal_connect(conv_handle, "wrote-chat-msg",
plugin, PURPLE_CALLBACK(wrote_chat_msg_cb), NULL);
purple_signal_connect(conv_handle, "sent-chat-msg",
plugin, PURPLE_CALLBACK(sent_chat_msg_cb), NULL);
purple_signal_connect(conv_handle, "received-chat-msg",
plugin, PURPLE_CALLBACK(received_chat_msg_cb), NULL);
purple_signal_connect(conv_handle, "conversation-created",
plugin, PURPLE_CALLBACK(conversation_created_cb), NULL);
purple_signal_connect(conv_handle, "chat-buddy-joined",
plugin, PURPLE_CALLBACK(chat_buddy_joined_cb), NULL);
purple_signal_connect(conv_handle, "chat-buddy-flags",
plugin, PURPLE_CALLBACK(chat_buddy_flags_cb), NULL);
purple_signal_connect(conv_handle, "chat-buddy-left",
plugin, PURPLE_CALLBACK(chat_buddy_left_cb), NULL);
purple_signal_connect(conv_handle, "chat-invited-user",
plugin, PURPLE_CALLBACK(chat_invited_user_cb), NULL);
purple_signal_connect(conv_handle, "chat-invited",
plugin, PURPLE_CALLBACK(chat_invited_cb), NULL);
purple_signal_connect(conv_handle, "chat-joined",
plugin, PURPLE_CALLBACK(chat_joined_cb), NULL);
purple_signal_connect(conv_handle, "chat-left",
plugin, PURPLE_CALLBACK(chat_left_cb), NULL);
purple_signal_connect(conv_handle, "chat-topic-changed",
plugin, PURPLE_CALLBACK(chat_topic_changed_cb), NULL);
/* Core signals */
purple_signal_connect(core_handle, "quitting",
plugin, PURPLE_CALLBACK(quitting_cb), NULL);
/* File transfer signals */
purple_signal_connect(ft_handle, "file-recv-accept",
plugin, PURPLE_CALLBACK(ft_recv_accept_cb), NULL);
purple_signal_connect(ft_handle, "file-recv-start",
plugin, PURPLE_CALLBACK(ft_recv_start_cb), NULL);
purple_signal_connect(ft_handle, "file-recv-cancel",
plugin, PURPLE_CALLBACK(ft_recv_cancel_cb), NULL);
purple_signal_connect(ft_handle, "file-recv-complete",
plugin, PURPLE_CALLBACK(ft_recv_complete_cb), NULL);
purple_signal_connect(ft_handle, "file-send-accept",
plugin, PURPLE_CALLBACK(ft_send_accept_cb), NULL);
purple_signal_connect(ft_handle, "file-send-start",
plugin, PURPLE_CALLBACK(ft_send_start_cb), NULL);
purple_signal_connect(ft_handle, "file-send-cancel",
plugin, PURPLE_CALLBACK(ft_send_cancel_cb), NULL);
purple_signal_connect(ft_handle, "file-send-complete",
plugin, PURPLE_CALLBACK(ft_send_complete_cb), NULL);
/* Notify signals */
purple_signal_connect(notify_handle, "displaying-email-notification",
plugin, PURPLE_CALLBACK(notify_email_cb), NULL);
purple_signal_connect(notify_handle, "displaying-emails-notification",
plugin, PURPLE_CALLBACK(notify_emails_cb), NULL);
return TRUE;
}
