static gboolean
check_for_buddynote(gpointer data)
{
PurplePlugin *buddynote = NULL;
PurplePlugin *plugin = (PurplePlugin *)data;
buddynote = purple_plugins_find_with_id("core-plugin_pack-buddynote");
if (buddynote == NULL) {
buddynote = purple_plugins_find_with_basename("buddynote");
}
if (buddynote != NULL) {
PurplePluginInfo *bninfo = buddynote->info;
bninfo->flags = PURPLE_PLUGIN_FLAG_INVISIBLE;
/* If non-gtk buddy note plugin is loaded, but we are not, then load
* ourselves, otherwise people upgrading from pre-gtkbuddynote days
* will not have 'Buddy Notes' showing as loaded in the plugins list.
* We also trigger a save on the list of plugins because it's not been
* loaded through the UI. */
if (purple_plugin_is_loaded(buddynote) &&
!purple_plugin_is_loaded(plugin)) {
purple_plugin_load(plugin);
pidgin_plugins_save();
}
} else {
info.flags = PURPLE_PLUGIN_FLAG_INVISIBLE;
}
return FALSE;
}
/**
The user wants to insert a sreenshot.
*/
static void
on_screenshot_insert_menuitem_activate_cb (GtkWidget * screenshot_insert_menuitem,
PidginConversation *gtkconv) {
PurplePlugin *plugin = purple_plugins_find_with_id (PLUGIN_ID);
if (!strcmp (purple_prefs_get_string (PREF_SEND_TYPE), "img-ftp-http")) {
PurpleConversation *conv = gtkconv->active_conv;
/* Direct IM of image is allowed by current protocol */
if (!(purple_conversation_get_features (conv) & PURPLE_CONNECTION_NO_IMAGES)) {
send_as_image (NULL, gtkconv);
} else if (strcmp(purple_prefs_get_string (PREF_FTP_REMOTE_URL), "") &&
strcmp(purple_prefs_get_string (PREF_FTP_USERNAME), "") &&
strcmp(purple_prefs_get_string (PREF_FTP_PASSWORD), "")) {
send_as_ftp_link (NULL, gtkconv);
} else if (strcmp (purple_prefs_get_string (PREF_UPLOAD_TO), HOST_DISABLED)) {
send_as_link (NULL, gtkconv);
} else {
purple_notify_error (plugin, PLUGIN_NAME, PLUGIN_ERROR,
PLUGIN_CONFIGURE_ERROR);
plugin_stop (plugin);
}
}
}
static void
send_as_link (PidginWindow * win,
PidginConversation * _gtkconv) {
PurplePlugin *plugin;
plugin = purple_plugins_find_with_id (PLUGIN_ID);
if (PLUGIN (locked))
return; /* Just return, don't fail. */
else {
PidginConversation *gtkconv;
PLUGIN (locked) = TRUE;
PLUGIN (send_as) = SEND_AS_HTTP_LINK;
if (win != NULL)
gtkconv =
PIDGIN_CONVERSATION
(pidgin_conv_window_get_active_conversation (win));
else
gtkconv = _gtkconv;
if (!strcmp (purple_prefs_get_string (PREF_UPLOAD_TO), HOST_DISABLED)) {
purple_notify_error (plugin, PLUGIN_NAME, PLUGIN_ERROR,
PLUGIN_HOST_DISABLED_ERROR);
plugin_stop (plugin);
return;
}
REMEMBER_ACCOUNT (gtkconv);
PLUGIN (conv_features) = gtkconv->active_conv->features;
freeze_desktop (plugin, FALSE);
}
}
static void
send_as_image (PidginWindow * win,
PidginConversation * _gtkconv) {
PurplePlugin *plugin = purple_plugins_find_with_id (PLUGIN_ID);
if (PLUGIN (locked))
return; /* Just return, don't fail. */
else {
PidginConversation *gtkconv;
PLUGIN (locked) = TRUE;
PLUGIN (send_as) = SEND_AS_IMAGE;
if (win != NULL)
gtkconv =
PIDGIN_CONVERSATION
(pidgin_conv_window_get_active_conversation (win));
else
gtkconv = _gtkconv;
REMEMBER_ACCOUNT (gtkconv);
PLUGIN (conv_features) = gtkconv->active_conv->features;
freeze_desktop (plugin, FALSE);
}
}
struct groupchat *purple_chat_with(struct im_connection *ic, char *who)
{
/* No, "of course" this won't work this way. Or in fact, it almost
does, but it only lets you send msgs to it, you won't receive
any. Instead, we have to click the virtual menu item.
PurpleAccount *pa = ic->proto_data;
PurpleConversation *pc;
PurpleConvChat *pcc;
struct groupchat *gc;
gc = imcb_chat_new( ic, "BitlBee-libpurple groupchat" );
gc->data = pc = purple_conversation_new( PURPLE_CONV_TYPE_CHAT, pa, "BitlBee-libpurple groupchat" );
pc->ui_data = gc;
pcc = PURPLE_CONV_CHAT( pc );
purple_conv_chat_add_user( pcc, ic->acc->user, "", 0, TRUE );
purple_conv_chat_invite_user( pcc, who, "Please join my chat", FALSE );
//purple_conv_chat_add_user( pcc, who, "", 0, TRUE );
*/
/* There went my nice afternoon. :-( */
struct purple_data *pd = ic->proto_data;
PurplePlugin *prpl = purple_plugins_find_with_id(pd->account->protocol_id);
PurplePluginProtocolInfo *pi = prpl->info->extra_info;
PurpleBuddy *pb = purple_find_buddy(pd->account, who);
PurpleMenuAction *mi;
GList *menu;
void (*callback)(PurpleBlistNode *, gpointer); /* FFFFFFFFFFFFFUUUUUUUUUUUUUU */
if (!pb || !pi || !pi->blist_node_menu) {
return NULL;
}
menu = pi->blist_node_menu(&pb->node);
while (menu) {
mi = menu->data;
if (purple_menu_cmp(mi->label, "initiate chat") ||
purple_menu_cmp(mi->label, "initiate conference")) {
break;
}
menu = menu->next;
}
if (menu == NULL) {
return NULL;
}
/* Call the f****r. */
callback = (void *) mi->callback;
callback(&pb->node, mi->data);
return NULL;
}
static gboolean
plugin_unload(PurplePlugin *plugin)
{
PurplePlugin *buddynote = NULL;
buddynote = purple_plugins_find_with_id("core-plugin_pack-buddynote");
purple_plugin_unload(buddynote);
return TRUE;
}
struct groupchat *purple_chat_join(struct im_connection *ic, const char *room, const char *nick, const char *password,
set_t **sets)
{
struct purple_data *pd = ic->proto_data;
PurplePlugin *prpl = purple_plugins_find_with_id(pd->account->protocol_id);
PurplePluginProtocolInfo *pi = prpl->info->extra_info;
GHashTable *chat_hash;
PurpleConversation *conv;
GList *info, *l;
if (!pi->chat_info || !pi->chat_info_defaults ||
!(info = pi->chat_info(purple_account_get_connection(pd->account)))) {
imcb_error(ic, "Joining chatrooms not supported by this protocol");
return NULL;
}
if ((conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT,
room, pd->account))) {
purple_conversation_destroy(conv);
}
chat_hash = pi->chat_info_defaults(
purple_account_get_connection(pd->account), room
);
for (l = info; l; l = l->next) {
struct proto_chat_entry *pce = l->data;
if (strcmp(pce->identifier, "handle") == 0) {
g_hash_table_replace(chat_hash, "handle", g_strdup(nick));
} else if (strcmp(pce->identifier, "password") == 0) {
g_hash_table_replace(chat_hash, "password", g_strdup(password));
} else if (strcmp(pce->identifier, "passwd") == 0) {
g_hash_table_replace(chat_hash, "passwd", g_strdup(password));
}
g_free(pce);
}
g_list_free(info);
serv_join_chat(purple_account_get_connection(pd->account), chat_hash);
g_hash_table_destroy(chat_hash);
return imcb_chat_new(ic, room);
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
PurplePlugin *server_plugin;
gboolean ok;
int result;
server_plugin = purple_plugins_find_with_id("core-ipc-test-server");
if (server_plugin == NULL)
{
purple_debug_error("ipc-test-client",
"Unable to locate plugin core-ipc-test-server, "
"needed for IPC.\n");
return TRUE;
}
result = (int)purple_plugin_ipc_call(server_plugin, "add", &ok, 36, 6);
if (!ok)
{
purple_debug_error("ipc-test-client",
"Unable to call IPC function 'add' in "
"core-ipc-test-server plugin.");
return TRUE;
}
purple_debug_info("ipc-test-client", "36 + 6 = %d\n", result);
result = (int)purple_plugin_ipc_call(server_plugin, "sub", &ok, 50, 8);
if (!ok)
{
purple_debug_error("ipc-test-client",
"Unable to call IPC function 'sub' in "
"core-ipc-test-server plugin.");
return TRUE;
}
purple_debug_info("ipc-test-client", "50 - 8 = %d\n", result);
return TRUE;
}
AccountWindow::ProtocolOption::ProtocolOption(PurpleAccount *account_,
AccountWindow &account_window_)
: account_window(&account_window_), account(account_)
{
g_assert(account);
setText(_("Protocol"));
for (GList *i = purple_plugins_get_protocols(); i; i = i->next)
addOptionPtr(purple_plugin_get_name(
reinterpret_cast<PurplePlugin*>(i->data)), i->data);
const char *proto_id = purple_account_get_protocol_id(account);
PurplePlugin *plugin = purple_plugins_find_with_id(proto_id);
setSelectedByDataPtr(plugin);
signal_selection_changed.connect(sigc::mem_fun(this,
&ProtocolOption::onProtocolChanged));
}
/* store screenshot contents in buf */
static size_t
read_callback (void *buf, size_t size, size_t nmemb, void *stream) {
PurplePlugin *plugin;
GIOChannel *io_chan;
GError *error = NULL;
size_t ret;
plugin = purple_plugins_find_with_id (PLUGIN_ID);
io_chan = (GIOChannel *) stream;
g_io_channel_read_chars (io_chan, buf, size * nmemb, &ret, &error);
if (error != NULL) {
g_propagate_error (&PLUGIN (error), error);
return CURL_READFUNC_ABORT;
}
PLUGIN (read_size) += ret; /* progress bar */
return ret;
}
/* ------------------
* called on module load
* ------------------ */
static gboolean plugin_load(PurplePlugin *plugin)
{
// check if hashtable already created
if (list_fingerprints == NULL)
list_fingerprints = g_hash_table_new(g_str_hash,g_str_equal);
// register presence receiver handler
void *jabber_handle = purple_plugins_find_with_id("prpl-jabber");
void *conv_handle = purple_conversations_get_handle();
if (conv_handle != NULL)
{
purple_signal_connect(conv_handle, "conversation-created", plugin, PURPLE_CALLBACK(conversation_created_cb), NULL);
purple_signal_connect(conv_handle, "receiving-im-msg", plugin, PURPLE_CALLBACK(receiving_im_msg_cb), NULL);
purple_signal_connect(conv_handle, "conversation-extended-menu", plugin, PURPLE_CALLBACK(conversation_extended_menu_cb), NULL);
purple_signal_connect(conv_handle, "sending-im-msg", plugin, PURPLE_CALLBACK(sending_im_msg_cb), NULL);
}else
return FALSE;
if (jabber_handle)
{
purple_signal_connect(jabber_handle, "jabber-receiving-message", plugin,PURPLE_CALLBACK(jabber_message_received), NULL);
purple_signal_connect(jabber_handle, "jabber-receiving-presence", plugin,PURPLE_CALLBACK(jabber_presence_received), NULL);
purple_signal_connect(jabber_handle, "jabber-sending-xmlnode", plugin, PURPLE_CALLBACK(jabber_send_signal_cb), NULL);
}else
return FALSE;
/*
Initialize everything needed; get the passphrase for encrypting and decrypting messages.
Attach to all windows the chat windows.
*/
/* attach_to_all_windows();
purple_signal_connect(pidgin_conversations_get_handle(), "conversation-displayed", plugin, PURPLE_CALLBACK(conv_created), NULL);
purple_signal_connect(purple_conversations_get_handle(), "conversation-extended-menu", plugin, PURPLE_CALLBACK(conv_menu_cb), NULL);*/
// initialize gpgme lib on module load
init_gpgme();
return TRUE;
}
static void purple_sync_settings( account_t *acc, PurpleAccount *pa )
{
PurplePlugin *prpl = purple_plugins_find_with_id( pa->protocol_id );
PurplePluginProtocolInfo *pi = prpl->info->extra_info;
GList *i;
for( i = pi->protocol_options; i; i = i->next )
{
PurpleAccountOption *o = i->data;
const char *name;
set_t *s;
name = purple_account_option_get_setting( o );
s = set_find( &acc->set, name );
if( s->value == NULL )
continue;
switch( purple_account_option_get_type( o ) )
{
case PURPLE_PREF_STRING:
case PURPLE_PREF_STRING_LIST:
purple_account_set_string( pa, name, set_getstr( &acc->set, name ) );
break;
case PURPLE_PREF_INT:
purple_account_set_int( pa, name, set_getint( &acc->set, name ) );
break;
case PURPLE_PREF_BOOLEAN:
purple_account_set_bool( pa, name, set_getbool( &acc->set, name ) );
break;
default:
break;
}
}
if( pi->options & OPT_PROTO_MAIL_CHECK )
purple_account_set_check_mail( pa, set_getbool( &acc->set, "mail_notifications" ) );
}
static gboolean
load_ui_plugin(gpointer data)
{
char *ui_plugin_id;
PurplePlugin *ui_plugin;
ui_plugin_id = g_strconcat(purple_core_get_ui(), "-", PLUGIN_STATIC_NAME, NULL);
ui_plugin = purple_plugins_find_with_id(ui_plugin_id);
if (ui_plugin != NULL)
{
if (!purple_plugin_load(ui_plugin))
{
purple_notify_error(ui_plugin, NULL, _("Failed to load the Buddy Timezone UI."),
ui_plugin->error ? ui_plugin->error : "");
}
}
g_free(ui_plugin_id);
return FALSE;
}
IRCProtocol::IRCProtocol() {
// m_transportFeatures.push_back("jabber:iq:register");
m_transportFeatures.push_back("http://jabber.org/protocol/disco#info");
m_transportFeatures.push_back("http://jabber.org/protocol/caps");
m_transportFeatures.push_back("http://jabber.org/protocol/commands");
m_transportFeatures.push_back("http://jabber.org/protocol/muc");
m_buddyFeatures.push_back("http://jabber.org/protocol/disco#info");
m_buddyFeatures.push_back("http://jabber.org/protocol/caps");
m_buddyFeatures.push_back("http://jabber.org/protocol/commands");
adhocCommand command = { "IRC Nickserv password configuration", false, createConfigHandler };
GlooxAdhocHandler::instance()->registerAdhocCommandHandler("transport_irc_config", command);
m_irchelper = purple_plugins_find_with_id(IRCHELPER_ID);
if (m_irchelper) {
if (!purple_plugin_load(m_irchelper))
m_irchelper = NULL;
}
std::cout << "IRCHELPER " << m_irchelper << "\n";
}
/**
* Handle hiding and showing stuff based on what type of conv this is...
*/
static void
on_conversation_menu_show_cb (PidginWindow * win) {
PurpleConversation *conv;
GtkWidget *conversation_menu, *img_menuitem, *screenshot_menuitem;
#ifdef ENABLE_UPLOAD
GtkWidget *link_menuitem, *ftp_link_menuitem;
#endif
PurplePlugin *plugin = purple_plugins_find_with_id (PLUGIN_ID);
conv = pidgin_conv_window_get_active_conversation (win);
conversation_menu =
gtk_item_factory_get_widget (win->menu.item_factory,
N_("/Conversation"));
#ifdef ENABLE_UPLOAD
link_menuitem =
g_object_get_data (G_OBJECT (conversation_menu), "link_menuitem");
ftp_link_menuitem =
g_object_get_data (G_OBJECT (conversation_menu), "ftp_link_menuitem");
on_screenshot_insert_as_link_show_cb (link_menuitem,
PIDGIN_CONVERSATION (conv));
on_screenshot_insert_as_ftp_link_show_cb (ftp_link_menuitem,
PIDGIN_CONVERSATION (conv));
#endif
img_menuitem =
g_object_get_data (G_OBJECT (conversation_menu), "img_menuitem");
// on_screenshot_insert_as_image_show_cb (img_menuitem,
// PIDGIN_CONVERSATION (conv));
screenshot_menuitem =
g_object_get_data (G_OBJECT (conversation_menu),
"screenshot_menuitem");
gtk_widget_set_sensitive (screenshot_menuitem, !PLUGIN (locked));
}
static gboolean
ssl_init(void)
{
PurplePlugin *plugin;
PurpleSslOps *ops;
if (_ssl_initialized)
return FALSE;
plugin = purple_plugins_find_with_id("core-ssl");
if (plugin != NULL && !purple_plugin_is_loaded(plugin))
purple_plugin_load(plugin);
ops = purple_ssl_get_ops();
if ((ops == NULL) || (ops->init == NULL) || (ops->uninit == NULL) ||
(ops->connectfunc == NULL) || (ops->close == NULL) ||
(ops->read == NULL) || (ops->write == NULL))
{
return FALSE;
}
return (_ssl_initialized = ops->init());
}
static void purple_init( account_t *acc )
{
PurplePlugin *prpl = purple_plugins_find_with_id( (char*) acc->prpl->data );
PurplePluginProtocolInfo *pi = prpl->info->extra_info;
PurpleAccount *pa;
GList *i, *st;
set_t *s;
char help_title[64];
GString *help;
static gboolean dir_fixed = FALSE;
/* Layer violation coming up: Making an exception for libpurple here.
Dig in the IRC state a bit to get a username. Ideally we should
check if s/he identified but this info doesn't seem *that* important.
It's just that fecking libpurple can't *not* store this shit.
Remember that libpurple is not really meant to be used on public
servers anyway! */
if( !dir_fixed )
{
irc_t *irc = acc->bee->ui_data;
char *dir;
dir = g_strdup_printf( "%s/purple/%s", global.conf->configdir, irc->user->nick );
purple_util_set_user_dir( dir );
g_free( dir );
purple_blist_load();
purple_prefs_load();
dir_fixed = TRUE;
}
help = g_string_new( "" );
g_string_printf( help, "BitlBee libpurple module %s (%s).\n\nSupported settings:",
(char*) acc->prpl->name, prpl->info->name );
if( pi->user_splits )
{
GList *l;
g_string_append_printf( help, "\n* username: Username" );
for( l = pi->user_splits; l; l = l->next )
g_string_append_printf( help, "%c%s",
purple_account_user_split_get_separator( l->data ),
purple_account_user_split_get_text( l->data ) );
}
/* Convert all protocol_options into per-account setting variables. */
for( i = pi->protocol_options; i; i = i->next )
{
PurpleAccountOption *o = i->data;
const char *name;
char *def = NULL;
set_eval eval = NULL;
void *eval_data = NULL;
GList *io = NULL;
GSList *opts = NULL;
name = purple_account_option_get_setting( o );
switch( purple_account_option_get_type( o ) )
{
case PURPLE_PREF_STRING:
def = g_strdup( purple_account_option_get_default_string( o ) );
g_string_append_printf( help, "\n* %s (%s), %s, default: %s",
name, purple_account_option_get_text( o ),
"string", def );
break;
case PURPLE_PREF_INT:
def = g_strdup_printf( "%d", purple_account_option_get_default_int( o ) );
eval = set_eval_int;
g_string_append_printf( help, "\n* %s (%s), %s, default: %s",
name, purple_account_option_get_text( o ),
"integer", def );
break;
case PURPLE_PREF_BOOLEAN:
if( purple_account_option_get_default_bool( o ) )
def = g_strdup( "true" );
else
def = g_strdup( "false" );
eval = set_eval_bool;
g_string_append_printf( help, "\n* %s (%s), %s, default: %s",
name, purple_account_option_get_text( o ),
"boolean", def );
break;
case PURPLE_PREF_STRING_LIST:
def = g_strdup( purple_account_option_get_default_list_value( o ) );
g_string_append_printf( help, "\n* %s (%s), %s, default: %s",
name, purple_account_option_get_text( o ),
"list", def );
g_string_append( help, "\n Possible values: " );
for( io = purple_account_option_get_list( o ); io; io = io->next )
{
PurpleKeyValuePair *kv = io->data;
opts = g_slist_append( opts, kv->value );
/* TODO: kv->value is not a char*, WTF? */
if( strcmp( kv->value, kv->key ) != 0 )
g_string_append_printf( help, "%s (%s), ", (char*) kv->value, kv->key );
else
g_string_append_printf( help, "%s, ", (char*) kv->value );
}
g_string_truncate( help, help->len - 2 );
eval = set_eval_list;
eval_data = opts;
break;
default:
/** No way to talk to the user right now, invent one when
this becomes important.
irc_rootmsg( acc->irc, "Setting with unknown type: %s (%d) Expect stuff to break..\n",
name, purple_account_option_get_type( o ) );
*/
g_string_append_printf( help, "\n* [%s] UNSUPPORTED (type %d)",
name, purple_account_option_get_type( o ) );
name = NULL;
}
if( name != NULL )
{
s = set_add( &acc->set, name, def, eval, acc );
s->flags |= ACC_SET_OFFLINE_ONLY;
s->eval_data = eval_data;
g_free( def );
}
}
g_snprintf( help_title, sizeof( help_title ), "purple %s", (char*) acc->prpl->name );
help_add_mem( &global.help, help_title, help->str );
g_string_free( help, TRUE );
s = set_add( &acc->set, "display_name", NULL, set_eval_display_name, acc );
s->flags |= ACC_SET_ONLINE_ONLY;
if( pi->options & OPT_PROTO_MAIL_CHECK )
{
s = set_add( &acc->set, "mail_notifications", "false", set_eval_bool, acc );
s->flags |= ACC_SET_OFFLINE_ONLY;
}
if( strcmp( prpl->info->name, "Gadu-Gadu" ) == 0 )
s = set_add( &acc->set, "gg_sync_contacts", "true", set_eval_bool, acc );
/* Go through all away states to figure out if away/status messages
are possible. */
pa = purple_account_new( acc->user, (char*) acc->prpl->data );
for( st = purple_account_get_status_types( pa ); st; st = st->next )
{
PurpleStatusPrimitive prim = purple_status_type_get_primitive( st->data );
if( prim == PURPLE_STATUS_AVAILABLE )
{
if( purple_status_type_get_attr( st->data, "message" ) )
acc->flags |= ACC_FLAG_STATUS_MESSAGE;
}
else if( prim != PURPLE_STATUS_OFFLINE )
{
if( purple_status_type_get_attr( st->data, "message" ) )
acc->flags |= ACC_FLAG_AWAY_MESSAGE;
}
}
purple_accounts_remove( pa );
}
gboolean
purple_plugin_load(PurplePlugin *plugin)
{
#ifdef PURPLE_PLUGINS
GList *dep_list = NULL;
GList *l;
g_return_val_if_fail(plugin != NULL, FALSE);
if (purple_plugin_is_loaded(plugin))
return TRUE;
if (purple_plugin_is_unloadable(plugin))
return FALSE;
g_return_val_if_fail(plugin->error == NULL, FALSE);
/*
* Go through the list of the plugin's dependencies.
*
* First pass: Make sure all the plugins needed are probed.
*/
for (l = plugin->info->dependencies; l != NULL; l = l->next)
{
const char *dep_name = (const char *)l->data;
PurplePlugin *dep_plugin;
dep_plugin = purple_plugins_find_with_id(dep_name);
if (dep_plugin == NULL)
{
char *tmp;
tmp = g_strdup_printf(_("The required plugin %s was not found. "
"Please install this plugin and try again."),
dep_name);
purple_notify_error(NULL, NULL,
_("Unable to load the plugin"), tmp, NULL);
g_free(tmp);
g_list_free(dep_list);
return FALSE;
}
dep_list = g_list_append(dep_list, dep_plugin);
}
/* Second pass: load all the required plugins. */
for (l = dep_list; l != NULL; l = l->next)
{
PurplePlugin *dep_plugin = (PurplePlugin *)l->data;
if (!purple_plugin_is_loaded(dep_plugin))
{
if (!purple_plugin_load(dep_plugin))
{
char *tmp;
tmp = g_strdup_printf(_("The required plugin %s was unable to load."),
plugin->info->name);
purple_notify_error(NULL, NULL,
_("Unable to load your plugin."), tmp, NULL);
g_free(tmp);
g_list_free(dep_list);
return FALSE;
}
}
}
/* Third pass: note that other plugins are dependencies of this plugin.
* This is done separately in case we had to bail out earlier. */
for (l = dep_list; l != NULL; l = l->next)
{
PurplePlugin *dep_plugin = (PurplePlugin *)l->data;
dep_plugin->dependent_plugins = g_list_prepend(dep_plugin->dependent_plugins, (gpointer)plugin->info->id);
}
g_list_free(dep_list);
if (plugin->native_plugin)
{
if (plugin->info->load != NULL && !plugin->info->load(plugin))
return FALSE;
}
else {
PurplePlugin *loader;
PurplePluginLoaderInfo *loader_info;
loader = find_loader_for_plugin(plugin);
if (loader == NULL)
return FALSE;
loader_info = PURPLE_PLUGIN_LOADER_INFO(loader);
if (loader_info->load != NULL)
{
if (!loader_info->load(plugin))
return FALSE;
}
}
loaded_plugins = g_list_insert_sorted(loaded_plugins, plugin, compare_plugins);
plugin->loaded = TRUE;
purple_signal_emit(purple_plugins_get_handle(), "plugin-load", plugin);
return TRUE;
#else
return TRUE;
#endif /* !PURPLE_PLUGINS */
}
gboolean
purple_plugin_unload(PurplePlugin *plugin)
{
#ifdef PURPLE_PLUGINS
GList *l;
GList *ll;
g_return_val_if_fail(plugin != NULL, FALSE);
g_return_val_if_fail(purple_plugin_is_loaded(plugin), FALSE);
purple_debug_info("plugins", "Unloading plugin %s\n", plugin->info->name);
/* Unload all plugins that depend on this plugin. */
for (l = plugin->dependent_plugins; l != NULL; l = ll) {
const char * dep_name = (const char *)l->data;
PurplePlugin *dep_plugin;
/* Store a pointer to the next element in the list.
* This is because we'll be modifying this list in the loop. */
ll = l->next;
dep_plugin = purple_plugins_find_with_id(dep_name);
if (dep_plugin != NULL && purple_plugin_is_loaded(dep_plugin))
{
if (!purple_plugin_unload(dep_plugin))
{
g_free(plugin->error);
plugin->error = g_strdup_printf(_("%s requires %s, but it failed to unload."),
_(plugin->info->name),
_(dep_plugin->info->name));
return FALSE;
}
else
{
#if 0
/* This isn't necessary. This has already been done when unloading dep_plugin. */
plugin->dependent_plugins = g_list_delete_link(plugin->dependent_plugins, l);
#endif
}
}
}
/* Remove this plugin from each dependency's dependent_plugins list. */
for (l = plugin->info->dependencies; l != NULL; l = l->next)
{
const char *dep_name = (const char *)l->data;
PurplePlugin *dependency;
dependency = purple_plugins_find_with_id(dep_name);
if (dependency != NULL)
dependency->dependent_plugins = g_list_remove(dependency->dependent_plugins, plugin->info->id);
else
purple_debug_error("plugins", "Unable to remove from dependency list for %s\n", dep_name);
}
if (plugin->native_plugin) {
if (plugin->info->unload && !plugin->info->unload(plugin))
return FALSE;
if (plugin->info->type == PURPLE_PLUGIN_PROTOCOL) {
PurplePluginProtocolInfo *prpl_info;
GList *l;
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);
for (l = prpl_info->user_splits; l != NULL; l = l->next)
purple_account_user_split_destroy(l->data);
for (l = prpl_info->protocol_options; l != NULL; l = l->next)
purple_account_option_destroy(l->data);
if (prpl_info->user_splits != NULL) {
g_list_free(prpl_info->user_splits);
prpl_info->user_splits = NULL;
}
if (prpl_info->protocol_options != NULL) {
g_list_free(prpl_info->protocol_options);
prpl_info->protocol_options = NULL;
}
}
} else {
PurplePlugin *loader;
PurplePluginLoaderInfo *loader_info;
loader = find_loader_for_plugin(plugin);
if (loader == NULL)
return FALSE;
loader_info = PURPLE_PLUGIN_LOADER_INFO(loader);
if (loader_info->unload && !loader_info->unload(plugin))
return FALSE;
}
/* cancel any pending dialogs the plugin has */
purple_request_close_with_handle(plugin);
purple_notify_close_with_handle(plugin);
purple_signals_disconnect_by_handle(plugin);
purple_plugin_ipc_unregister_all(plugin);
loaded_plugins = g_list_remove(loaded_plugins, plugin);
if ((plugin->info != NULL) && PURPLE_IS_PROTOCOL_PLUGIN(plugin))
protocol_plugins = g_list_remove(protocol_plugins, plugin);
plugins_to_disable = g_list_remove(plugins_to_disable, plugin);
plugin->loaded = FALSE;
/* We wouldn't be anywhere near here if the plugin wasn't loaded, so
* if plugin->error is set at all, it had to be from a previous
* unload failure. It's obviously okay now.
*/
g_free(plugin->error);
plugin->error = NULL;
purple_signal_emit(purple_plugins_get_handle(), "plugin-unload", plugin);
purple_prefs_disconnect_by_handle(plugin);
return TRUE;
#else
return TRUE;
#endif /* PURPLE_PLUGINS */
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
if ( ( ! notify_is_initted() ) && ( ! notify_init("libpurple") ) )
{
purple_debug_error(PACKAGE_NAME, "libnotify not running!\n");
return FALSE;
}
notify_plus_adapt_to_server_capabilities();
gpointer handle;
handle = purple_plugins_find_with_id(purple_events_get_plugin_id());
g_return_val_if_fail(handle != NULL, FALSE);
purple_signal_connect(
handle, "user_presence-online", plugin,
(PurpleCallback)_purple_notify_plus_signed_on, plugin
);
purple_signal_connect(
handle, "user_presence-offline", plugin,
(PurpleCallback)_purple_notify_plus_signed_off, plugin
);
purple_signal_connect(
handle, "user_presence-away", plugin,
(PurpleCallback)_purple_notify_plus_away, plugin
);
purple_signal_connect(
handle, "user_presence-back", plugin,
(PurpleCallback)_purple_notify_plus_back, plugin
);
purple_signal_connect(
handle, "user_presence-idle", plugin,
(PurpleCallback)_purple_notify_plus_idle, plugin
);
purple_signal_connect(
handle, "user_presence-idle-back", plugin,
(PurpleCallback)_purple_notify_plus_idle_back, plugin
);
purple_signal_connect(
handle, "user_presence-message", plugin,
(PurpleCallback)_purple_notify_plus_status, plugin
);
purple_signal_connect(
handle, "user_im-received", plugin,
(PurpleCallback)_purple_notify_plus_im_message, plugin
);
purple_signal_connect(
handle, "user_im-highlight", plugin,
(PurpleCallback)_purple_notify_plus_im_highlight, plugin
);
purple_signal_connect(
handle, "user_chat-received", plugin,
(PurpleCallback)_purple_notify_plus_chat_message, plugin
);
purple_signal_connect(
handle, "user_chat-highlight", plugin,
(PurpleCallback)_purple_notify_plus_chat_highlight, plugin
);
purple_signal_connect(
handle, "user_email-arrived", plugin,
(PurpleCallback)_purple_notify_plus_email, plugin
);
return TRUE;
}
void
remove_pidgin_menuitems (PurpleConversation * conv) {
if (PIDGIN_IS_PIDGIN_CONVERSATION (conv)) {
PurplePlugin *plugin;
GtkWidget *screenshot_insert_menuitem;
GtkWidget *screenshot_menuitem, *conversation_menu;
GtkWidget *insert_menu;
PidginWindow *win;
PidginConversation *gtkconv;
gtkconv = PIDGIN_CONVERSATION (conv);
plugin = purple_plugins_find_with_id (PLUGIN_ID);
win = pidgin_conv_get_window (gtkconv);
if (win != NULL) {
if ((conversation_menu =
gtk_item_factory_get_widget (win->menu.item_factory,
N_("/Conversation"))) != NULL) {
/* remove signal */
gulong handler = g_signal_handler_find (conversation_menu,
G_SIGNAL_MATCH_FUNC,
0,
0,
NULL,
G_CALLBACK
(on_conversation_menu_show_cb),
NULL);
if (handler)
g_signal_handler_disconnect (conversation_menu, handler);
if ((screenshot_menuitem =
g_object_get_data (G_OBJECT (conversation_menu),
"screenshot_menuitem")) != NULL) {
gtk_widget_destroy (screenshot_menuitem);
g_object_steal_data (G_OBJECT (conversation_menu),
"screenshot_menuitem");
g_object_steal_data (G_OBJECT (conversation_menu),
"img_menuitem");
#ifdef ENABLE_UPLOAD
g_object_steal_data (G_OBJECT (conversation_menu),
"link_menuitem");
g_object_steal_data (G_OBJECT (conversation_menu),
"ftp_link_menuitem");
#endif
}
}
}
/* remove signal */
if ((insert_menu =
g_object_get_data (G_OBJECT (gtkconv->toolbar),
"insert_menu")) != NULL) {
gulong handler = g_signal_handler_find (insert_menu,
G_SIGNAL_MATCH_FUNC,
0,
0,
NULL,
G_CALLBACK
(on_insert_menu_show_cb),
NULL);
if (handler)
g_signal_handler_disconnect (insert_menu, handler);
}
screenshot_insert_menuitem =
g_object_get_data (G_OBJECT (gtkconv->toolbar),
"screenshot_insert_menuitem");
if (screenshot_insert_menuitem != NULL) {
gtk_widget_destroy (screenshot_insert_menuitem);
g_object_steal_data (G_OBJECT (gtkconv->toolbar),
"screenshot_insert_menuitem");
}
}
}
void
create_plugin_menuitems (PurpleConversation * conv) {
if (PIDGIN_IS_PIDGIN_CONVERSATION (conv)) {
PidginConversation *gtkconv;
PurplePlugin *plugin;
PidginWindow *win;
GtkWidget *conversation_menu, *screenshot_menuitem;
GtkWidget *screenshot_insert_menuitem;
gtkconv = PIDGIN_CONVERSATION (conv);
plugin = purple_plugins_find_with_id (PLUGIN_ID);
win = pidgin_conv_get_window (gtkconv);
conversation_menu =
gtk_item_factory_get_widget (win->menu.item_factory,
N_("/Conversation"));
screenshot_insert_menuitem =
g_object_get_data (G_OBJECT (gtkconv->toolbar),
"screenshot_insert_menuitem");
screenshot_menuitem =
g_object_get_data (G_OBJECT (conversation_menu),
"screenshot_menuitem");
/* Intercept hotkeys defined in pref window */
g_signal_connect_swapped (G_OBJECT
(pidgin_conv_get_window (gtkconv)->window),
"key_release_event",
G_CALLBACK (catch_hotkeys_cb), win);
/* Add us to the conv "Insert" menu */
if (screenshot_insert_menuitem == NULL) {
GtkWidget *insert_menu;//, *submenu;
if ((insert_menu =
g_object_get_data (G_OBJECT (gtkconv->toolbar),
"insert_menu")) != NULL) {
/* add us to the "insert" list */
screenshot_insert_menuitem =
gtk_menu_item_new_with_mnemonic
(SCREENSHOT_INSERT_MENUITEM_LABEL);
//submenu = create_plugin_submenu (gtkconv, FALSE);
g_signal_connect_swapped (G_OBJECT (insert_menu), "show",
G_CALLBACK (on_insert_menu_show_cb),
screenshot_insert_menuitem);
g_signal_connect (G_OBJECT (screenshot_insert_menuitem), "activate",
G_CALLBACK (on_screenshot_insert_menuitem_activate_cb),
gtkconv);
/*
gtk_menu_item_set_submenu (GTK_MENU_ITEM
(screenshot_insert_menuitem),
submenu);
*/
gtk_menu_shell_insert (GTK_MENU_SHELL (insert_menu), screenshot_insert_menuitem, 1); /* 0 = Image */
/* register new widget */
g_object_set_data (G_OBJECT (gtkconv->toolbar),
"screenshot_insert_menuitem",
screenshot_insert_menuitem);
}
}
/* Add us to the conv "Conversation" menu. */
if (screenshot_menuitem == NULL) {
GList *children = NULL, *head_chld = NULL; /* don't g_list_free() it */
guint i = 0;
//GtkWidget *submenu = create_plugin_submenu (gtkconv, TRUE);
screenshot_menuitem =
gtk_menu_item_new_with_mnemonic (SCREENSHOT_MENUITEM_LABEL);
/*gtk_menu_item_set_submenu (GTK_MENU_ITEM
(screenshot_menuitem), submenu); */
/*gtk_widget_show_all (submenu);*/
children =
gtk_container_get_children (GTK_CONTAINER
(conversation_menu));
head_chld = children; /* keep first element addr */
/* pack our menuitem at correct place */
while (children != NULL && children->data !=
(gpointer) win->menu.insert_image) {
children = g_list_next (children);
i++;
}
g_list_free (head_chld);
gtk_menu_shell_insert (GTK_MENU_SHELL (conversation_menu),
screenshot_menuitem, i + 1);
gtk_widget_show (screenshot_menuitem);
g_object_set_data (G_OBJECT (conversation_menu),
"screenshot_menuitem", screenshot_menuitem);
}
}
}
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 gboolean
plugin_unload(PurplePlugin *plugin)
{
gpointer handle;
handle = purple_plugins_find_with_id(purple_events_get_plugin_id());
g_return_val_if_fail(handle != NULL, FALSE);
purple_signal_disconnect(
handle, "user_presence-online", plugin,
(PurpleCallback)_purple_notify_plus_signed_on
);
purple_signal_disconnect(
handle, "user_presence-offline", plugin,
(PurpleCallback)_purple_notify_plus_signed_off
);
purple_signal_disconnect(
handle, "user_presence-away", plugin,
(PurpleCallback)_purple_notify_plus_away
);
purple_signal_disconnect(
handle, "user_presence-back", plugin,
(PurpleCallback)_purple_notify_plus_back
);
purple_signal_disconnect(
handle, "user_presence-idle", plugin,
(PurpleCallback)_purple_notify_plus_idle
);
purple_signal_disconnect(
handle, "user_presence-idle-back", plugin,
(PurpleCallback)_purple_notify_plus_idle_back
);
purple_signal_disconnect(
handle, "user_presence-message", plugin,
(PurpleCallback)_purple_notify_plus_status
);
purple_signal_disconnect(
handle, "user_im-received", plugin,
(PurpleCallback)_purple_notify_plus_im_message
);
purple_signal_disconnect(
handle, "user_im-highlight", plugin,
(PurpleCallback)_purple_notify_plus_im_highlight
);
purple_signal_disconnect(
handle, "user_chat-received", plugin,
(PurpleCallback)_purple_notify_plus_chat_message
);
purple_signal_disconnect(
handle, "user_chat-highlight", plugin,
(PurpleCallback)_purple_notify_plus_chat_highlight
);
purple_signal_disconnect(
handle, "user_email-arrived", plugin,
(PurpleCallback)_purple_notify_plus_email
);
notify_uninit();
return TRUE;
}
/**
If the plugin is locked, don't activate the menuitem.
This tipically happens when we're sending the capture to a remote server.
*/
static void
on_insert_menu_show_cb (GtkWidget * screenshot_insert_menuitem) {
PurplePlugin *plugin = purple_plugins_find_with_id (PLUGIN_ID);
gtk_widget_set_sensitive (screenshot_insert_menuitem, !PLUGIN (locked));
}
