/**************************************************************************************************
Load plugin
**************************************************************************************************/
static gboolean
plugin_load(PurplePlugin *plugin)
{
PidginBuddyList *gtkblist = pidgin_blist_get_default_gtk_blist();
GList *convs = purple_get_conversations();
if (purple_prefs_get_bool("/plugins/core/hidemenu/default_state")) {
hmb_is_menu_visible = FALSE;
} else {
hmb_is_menu_visible = TRUE;
}
// set callback for 'blist created' signal
purple_signal_connect(pidgin_blist_get_handle(), "gtkblist-created", plugin,
PURPLE_CALLBACK(hmb_blist_created_cb), NULL);
// set callback for 'conversation displayed' signal
purple_signal_connect(pidgin_conversations_get_handle(), "conversation-displayed", plugin,
PURPLE_CALLBACK(hmb_conversation_displayed_cb), NULL);
// hide blist menubar
hmb_toggle_menubar(gtkblist, NULL);
// hide conversations menubar
while (convs) {
PurpleConversation *conv = (PurpleConversation *)convs->data;
if (PIDGIN_IS_PIDGIN_CONVERSATION(conv)) {
hmb_toggle_menubar(NULL, PIDGIN_CONVERSATION(conv));
}
convs = convs->next;
}
return TRUE;
}
static gboolean
plugin_load(PurplePlugin *plugin) {
void *conv_list_handle;
PURPLE_DBUS_RETURN_FALSE_IF_DISABLED(plugin);
/* First, we have to register our four exported functions with the
main purple dbus loop. Without this statement, the purple dbus
code wouldn't know about our functions. */
PURPLE_DBUS_REGISTER_BINDINGS(plugin);
/* Keep the plugin for reference (needed for notify's) */
plugin_pointer = plugin;
/* Add the button to all the current conversations */
purple_conversation_foreach (init_conversation);
/* Listen for any new conversations */
conv_list_handle = purple_conversations_get_handle();
purple_signal_connect(conv_list_handle, "conversation-created",
plugin, PURPLE_CALLBACK(init_conversation), NULL);
/* Listen for conversations that are ending */
purple_signal_connect(conv_list_handle, "deleting-conversation",
plugin, PURPLE_CALLBACK(conv_destroyed), NULL);
/* Listen for sending/receiving messages to replace tags */
purple_signal_connect(conv_list_handle, "sending-im-msg",
plugin, PURPLE_CALLBACK(intercept_sent), NULL);
purple_signal_connect(conv_list_handle, "receiving-im-msg",
plugin, PURPLE_CALLBACK(intercept_received), NULL);
return TRUE;
}
static gboolean
plugin_load(PurplePlugin *plugin, GError **error)
{
purple_prefs_add_none("/plugins");
purple_prefs_add_none("/plugins/gnt");
purple_prefs_add_none("/plugins/gnt/gntgf");
purple_prefs_add_none(PREFS_EVENT);
purple_prefs_add_bool(PREFS_EVENT_SIGNONF, TRUE);
purple_prefs_add_bool(PREFS_EVENT_IM_MSG, TRUE);
purple_prefs_add_bool(PREFS_EVENT_CHAT_MSG, TRUE);
purple_prefs_add_bool(PREFS_EVENT_CHAT_NICK, TRUE);
purple_prefs_add_bool(PREFS_BEEP, TRUE);
#ifdef HAVE_X11
purple_prefs_add_bool(PREFS_URGENT, FALSE);
#endif
purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", plugin,
PURPLE_CALLBACK(buddy_signed_on), NULL);
purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", plugin,
PURPLE_CALLBACK(buddy_signed_off), NULL);
purple_signal_connect(purple_conversations_get_handle(), "received-im-msg", plugin,
PURPLE_CALLBACK(received_im_msg), NULL);
purple_signal_connect(purple_conversations_get_handle(), "received-chat-msg", plugin,
PURPLE_CALLBACK(received_chat_msg), NULL);
memset(&gpsy, 0, sizeof(gpsy));
memset(&gpsw, 0, sizeof(gpsw));
return TRUE;
}
static gboolean
plugin_load(PurplePlugin *plugin, GError **error)
{
PurpleNotifyUiOps *ops = purple_notify_get_ui_ops();
purple_prefs_add_none(PREFS_BASE);
purple_prefs_add_int(PREF_LENGTH, 30);
purple_prefs_add_string(PREF_URL, "http://tinyurl.com/api-create.php?url=");
g_object_set_data(G_OBJECT(plugin), "notify-uri", ops->notify_uri);
ops->notify_uri = tinyurl_notify_uri;
tinyurl_cache = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, g_free);
purple_signal_connect(purple_conversations_get_handle(),
"wrote-im-msg",
plugin, PURPLE_CALLBACK(wrote_msg), NULL);
purple_signal_connect(purple_conversations_get_handle(),
"wrote-chat-msg",
plugin, PURPLE_CALLBACK(wrote_msg), NULL);
purple_signal_connect(purple_conversations_get_handle(),
"writing-im-msg",
plugin, PURPLE_CALLBACK(writing_msg), NULL);
purple_signal_connect(purple_conversations_get_handle(),
"writing-chat-msg",
plugin, PURPLE_CALLBACK(writing_msg), NULL);
purple_signal_connect(purple_conversations_get_handle(),
"deleting-conversation",
plugin, PURPLE_CALLBACK(free_conv_urls), NULL);
return TRUE;
}
void
finch_pounces_init(void)
{
purple_pounces_register_handler(FINCH_UI, pounce_cb, new_pounce,
free_pounce);
purple_prefs_add_none("/finch/pounces");
purple_prefs_add_none("/finch/pounces/default_actions");
purple_prefs_add_bool("/finch/pounces/default_actions/open-window",
FALSE);
purple_prefs_add_bool("/finch/pounces/default_actions/popup-notify",
TRUE);
purple_prefs_add_bool("/finch/pounces/default_actions/send-message",
FALSE);
purple_prefs_add_bool("/finch/pounces/default_actions/execute-command",
FALSE);
purple_prefs_add_bool("/finch/pounces/default_actions/play-beep",
FALSE);
purple_prefs_add_none("/finch/pounces/dialog");
purple_signal_connect(purple_connections_get_handle(), "signed-on",
finch_pounces_get_handle(),
PURPLE_CALLBACK(signed_on_off_cb), NULL);
purple_signal_connect(purple_connections_get_handle(), "signed-off",
finch_pounces_get_handle(),
PURPLE_CALLBACK(signed_on_off_cb), NULL);
}
static gboolean plugin_load(PurplePlugin *plugin)
{
void *conv_handle;
GHashTable *users;
guint id;
gpointer *data;
users = g_hash_table_new_full((GHashFunc)joinpart_key_hash,
(GEqualFunc)joinpart_key_equal,
(GDestroyNotify)joinpart_key_destroy,
g_free);
conv_handle = purple_conversations_get_handle();
purple_signal_connect(conv_handle, "chat-buddy-joining", plugin,
PURPLE_CALLBACK(chat_buddy_joining_cb), users);
purple_signal_connect(conv_handle, "chat-buddy-leaving", plugin,
PURPLE_CALLBACK(chat_buddy_leaving_cb), users);
purple_signal_connect(conv_handle, "received-chat-msg", plugin,
PURPLE_CALLBACK(received_chat_msg_cb), users);
/* Cleanup every 5 minutes */
id = purple_timeout_add_seconds(60 * 5, (GSourceFunc)clean_users_hash, users);
data = g_new(gpointer, 2);
data[0] = users;
data[1] = GUINT_TO_POINTER(id);
plugin->extra = data;
return TRUE;
}
static gboolean
indicator_load(PurplePlugin *plugin) {
indicator_docklet_init(plugin, &ui_ops);
AppIndicator *indicator =
app_indicator_new_with_path("pidgin", PIDGIN_STOCK_TRAY_AVAILABLE,
APP_INDICATOR_CATEGORY_APPLICATION_STATUS,
DATADIR G_DIR_SEPARATOR_S "pixmaps" G_DIR_SEPARATOR_S "pidgin" G_DIR_SEPARATOR_S "tray");
sIndicator = indicator;
app_indicator_set_status(indicator, APP_INDICATOR_STATUS_ACTIVE);
indicator_update_icon(purple_savedstatus_get_type(purple_savedstatus_get_current()),
FALSE, FALSE);
void *plugins_handle = purple_plugins_get_handle();
purple_signal_connect(plugins_handle, "plugin-load", plugin->handle,
PURPLE_CALLBACK(indicator_build_menu), indicator);
purple_signal_connect(plugins_handle, "plugin-unload", plugin->handle,
PURPLE_CALLBACK(indicator_build_menu), indicator);
indicator_build_menu(NULL, indicator);
plugin->extra = indicator;
pidgin_blist_visibility_manager_add();
return TRUE;
}
static gboolean plugin_load(PurplePlugin *plugin)
{
PurpleBuddyList *buddy_list;
void *conv_handle;
if (cc_init_gtk_gl())
return FALSE;
cc_init(&cc_info);
buddy_list = purple_get_blist();
if (buddy_list) {
purple_signal_connect(PIDGIN_BLIST
(buddy_list),
"drawing-menu", plugin,
PURPLE_CALLBACK(cc_buddy_menu), NULL);
conv_handle = purple_conversations_get_handle();
purple_signal_connect(conv_handle, "received-im-msg", plugin,
PURPLE_CALLBACK(receive_im_cb), &cc_info);
purple_signal_connect(conv_handle, "displaying-im-msg", plugin,
PURPLE_CALLBACK(display_im_cb), &cc_info);
} else {
purple_signal_connect
(purple_connections_get_handle(), "signed-on",
plugin, PURPLE_CALLBACK(cc_signed_on), plugin);
}
Debug("CrazyChat plugin loaded.\n");
return TRUE;
}
/*
* EXPORTED FUNCTIONS
*/
static gboolean plugin_load(PurplePlugin *plugin) {
purple_signal_connect(purple_conversations_get_handle(),
"conversation-created", plugin,
PURPLE_CALLBACK(new_conversation_cb), NULL);
/* Set callback to remove window from the list, if the window is destroyed */
purple_signal_connect(purple_conversations_get_handle(),
"deleting-conversation", plugin,
PURPLE_CALLBACK(conversation_delete_cb), NULL);
purple_signal_connect(pidgin_conversations_get_handle(),
"conversation-dragging", plugin,
PURPLE_CALLBACK(set_conv_window_trans), NULL);
purple_signal_connect(purple_conversations_get_handle(),
"conversation-updated", plugin,
PURPLE_CALLBACK(conv_updated_cb), NULL);
update_existing_convs();
if (blist)
blist_created_cb(NULL, NULL);
else
purple_signal_connect(pidgin_blist_get_handle(),
"gtkblist-created", plugin,
PURPLE_CALLBACK(blist_created_cb), NULL);
return TRUE;
}
static gboolean
plugin_load (PurplePlugin * plugin)
{
printf("Foobar");
purple_debug_info("core-hoh-hubbub-pidgin", "Fork debug\n");
/*
purple_notify_message (plugin, PURPLE_NOTIFY_MSG_INFO, "Hello World!",
"Welcome to the Hubbub-Pidgin plugin ! Make sure the OTR plugin is loaded after me.", NULL, NULL,
NULL);
*/
purple_signal_connect(
purple_conversations_get_handle(),
"receiving-im-msg",
plugin,
PURPLE_CALLBACK(receiving_im_msg_cb),
NULL);
purple_signal_connect(
purple_conversations_get_handle(),
"writing-im-msg",
plugin,
PURPLE_CALLBACK(writing_im_msg_cb),
NULL);
helloworld_plugin = plugin; /* assign this here so we have a valid handle later */
//hubbub_engine_status = system("/home/okso/Documents/Thesis/Hubbub/venv3/bin/python3 -m hubbub fork");
purple_debug_info("core-hoh-hubbub-pidgin",
"Fork finished launching Python.\n");
return TRUE;
}
static void connect_to_signals(void) {
static int handle;
purple_signal_connect(purple_connections_get_handle(), "signed-on", &handle,
PURPLE_CALLBACK(signed_on), NULL);
purple_signal_connect(purple_connections_get_handle(), "signed-off", &handle,
PURPLE_CALLBACK(signed_off), NULL);
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
PurplePlugin *prpl = NULL;
PurpleAccountOption *option;
void *gc_handle = NULL;
#if !PURPLE_VERSION_CHECK(2,4,0)
gchar *notice_help = NULL;
#endif
prpl = purple_find_prpl("prpl-irc");
/* if we didn't find the prpl, bail */
if (!prpl)
return FALSE;
#if !PURPLE_VERSION_CHECK(2,4,0)
/* specify our help string and register our command */
notice_help = _("notice target message: Send a notice to the specified target.");
notice_cmd_id = purple_cmd_register("notice", "ws", PURPLE_CMD_P_PLUGIN,
PURPLE_CMD_FLAG_IM | PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PRPL_ONLY,
"prpl-irc", notice_cmd_cb, notice_help, NULL);
#endif
/* we need this handle for the signed-on signal */
gc_handle = purple_connections_get_handle();
/* list signals in alphabetical order for consistency */
purple_signal_connect(prpl, "irc-sending-text", plugin,
G_CALLBACK(irc_sending_text), NULL);
purple_signal_connect(prpl, "irc-receiving-text", plugin,
G_CALLBACK(irc_receiving_text), NULL);
purple_signal_connect(gc_handle, "signed-on", plugin,
G_CALLBACK(signed_on_cb), NULL);
irc_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
/* Alphabetize the option label strings */
option = purple_account_option_string_new(_("Auto-Join Channels"), "autojoin", "");
irc_info->protocol_options = g_list_append(irc_info->protocol_options, option);
option = purple_account_option_string_new(_("CTCP Version reply"), "ctcp-message", "Purple IRC");
irc_info->protocol_options = g_list_append(irc_info->protocol_options, option);
option = purple_account_option_string_new(_("Default Quit Message"), "quit-message", "Leaving.");
irc_info->protocol_options = g_list_append(irc_info->protocol_options, option);
option = purple_account_option_string_new(_("Default Part Message"), "part-message", "Leaving.");
irc_info->protocol_options = g_list_append(irc_info->protocol_options, option);
option = purple_account_option_string_new(_("Set User Modes On Connect"), "setumodes", "i");
irc_info->protocol_options = g_list_append(irc_info->protocol_options, option);
option = purple_account_option_string_new(_("Unset User Modes On Connect"), "unsetumodes", "");
irc_info->protocol_options = g_list_append(irc_info->protocol_options, option);
return TRUE;
}
static void
connect_to_signals_for_demonstration_purposes_only(void)
{
static int handle;
purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", &handle,
PURPLE_CALLBACK(buddy_presence), NULL);
purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", &handle,
PURPLE_CALLBACK(buddy_presence), 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 connect_to_signals(void) {
static int handle;
purple_signal_connect(purple_connections_get_handle(), "signed-on", &handle,
PURPLE_CALLBACK(signed_on), NULL);
purple_signal_connect(purple_conversations_get_handle(), "received-im-msg", &handle,
PURPLE_CALLBACK(received_im_msg), NULL);
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
purple_signal_connect(pidgin_conversations_get_handle(), "conversation-timestamp",
plugin, PURPLE_CALLBACK(conversation_timestamp_cb), NULL);
purple_signal_connect(purple_log_get_handle(), "log-timestamp",
plugin, PURPLE_CALLBACK(log_timestamp_cb), NULL);
return TRUE;
}
void
purple_idle_init()
{
purple_signal_connect(purple_connections_get_handle(), "signing-on",
purple_idle_get_handle(),
PURPLE_CALLBACK(signing_on_cb), NULL);
purple_signal_connect(purple_connections_get_handle(), "signing-off",
purple_idle_get_handle(),
PURPLE_CALLBACK(signing_off_cb), NULL);
}
static gboolean
plugin_load(PurplePlugin *plugin, GError **error)
{
void *accounts_handle = pidgin_accounts_get_handle();
void *blist_handle = pidgin_blist_get_handle();
void *conv_handle = pidgin_conversations_get_handle();
/* Accounts subsystem signals */
purple_signal_connect(accounts_handle, "account-modified",
plugin, PURPLE_CALLBACK(account_modified_cb), NULL);
/* Buddy List subsystem signals */
purple_signal_connect(blist_handle, "gtkblist-created",
plugin, PURPLE_CALLBACK(blist_created_cb), NULL);
purple_signal_connect(blist_handle, "drawing-tooltip",
plugin, PURPLE_CALLBACK(blist_drawing_tooltip_cb), NULL);
/* Conversations subsystem signals */
purple_signal_connect(conv_handle, "conversation-dragging",
plugin, PURPLE_CALLBACK(conversation_dragging_cb), NULL);
purple_signal_connect(conv_handle, "displaying-im-msg",
plugin, PURPLE_CALLBACK(displaying_im_msg_cb), NULL);
purple_signal_connect(conv_handle, "displayed-im-msg",
plugin, PURPLE_CALLBACK(displayed_im_msg_cb), NULL);
purple_signal_connect(conv_handle, "displaying-chat-msg",
plugin, PURPLE_CALLBACK(displaying_chat_msg_cb), NULL);
purple_signal_connect(conv_handle, "displayed-chat-msg",
plugin, PURPLE_CALLBACK(displayed_chat_msg_cb), NULL);
purple_signal_connect(conv_handle, "conversation-switched",
plugin, PURPLE_CALLBACK(conversation_switched_cb), NULL);
return TRUE;
}
void twitter_conv_icon_account_load(PurpleAccount * account)
{
PurpleConnection *gc = purple_account_get_connection(account);
TwitterConnectionData *twitter = gc->proto_data;
twitter->icons = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify) twitter_conv_icon_free);
purple_signal_connect(pidgin_conversations_get_handle(), "displaying-chat-msg", twitter->icons, PURPLE_CALLBACK(twitter_conv_icon_displaying_chat_cb), account);
purple_signal_connect(pidgin_conversations_get_handle(), "displayed-chat-msg", twitter->icons, PURPLE_CALLBACK(twitter_conv_icon_displayed_chat_cb), account);
purple_signal_connect(purple_conversations_get_handle(), "conversation-created", twitter->icons, PURPLE_CALLBACK(twitter_conv_icon_conversation_created_cb), account);
purple_signal_connect(purple_conversations_get_handle(), "deleting-conversation", twitter->icons, PURPLE_CALLBACK(twitter_conv_icon_deleting_conversation_cb), account);
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
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);
return TRUE;
}
void
purple_pounces_init(void)
{
void *handle = purple_pounces_get_handle();
void *blist_handle = purple_blist_get_handle();
void *conv_handle = purple_conversations_get_handle();
pounce_handlers = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, free_pounce_handler);
purple_signal_connect(blist_handle, "buddy-idle-changed",
handle, PURPLE_CALLBACK(buddy_idle_changed_cb), NULL);
purple_signal_connect(blist_handle, "buddy-status-changed",
handle, PURPLE_CALLBACK(buddy_status_changed_cb), NULL);
purple_signal_connect(blist_handle, "buddy-signed-on",
handle, PURPLE_CALLBACK(buddy_state_cb),
GINT_TO_POINTER(PURPLE_POUNCE_SIGNON));
purple_signal_connect(blist_handle, "buddy-signed-off",
handle, PURPLE_CALLBACK(buddy_state_cb),
GINT_TO_POINTER(PURPLE_POUNCE_SIGNOFF));
purple_signal_connect(conv_handle, "buddy-typing",
handle, PURPLE_CALLBACK(buddy_typing_cb), NULL);
purple_signal_connect(conv_handle, "buddy-typed",
handle, PURPLE_CALLBACK(buddy_typing_cb), NULL);
purple_signal_connect(conv_handle, "buddy-typing-stopped",
handle, PURPLE_CALLBACK(buddy_typing_cb), NULL);
purple_signal_connect(conv_handle, "received-im-msg",
handle, PURPLE_CALLBACK(received_message_cb), NULL);
purple_pounces_load();
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
void *blist_handle = purple_blist_get_handle();
purple_signal_connect(blist_handle, "buddy-status-changed", plugin,
PURPLE_CALLBACK(buddy_status_changed_cb), NULL);
purple_signal_connect(blist_handle, "buddy-idle-changed", plugin,
PURPLE_CALLBACK(buddy_idle_changed_cb), NULL);
purple_signal_connect(blist_handle, "buddy-signed-on", plugin,
PURPLE_CALLBACK(buddy_signon_cb), NULL);
purple_signal_connect(blist_handle, "buddy-signed-off", plugin,
PURPLE_CALLBACK(buddy_signoff_cb), NULL);
return TRUE;
}
static void add_plugin_functionality(PurplePlugin *plugin) {
if(_signals_connected)
return;
purple_debug_info("cap", "Adding plugin functionality.\n");
/* Connect all the signals */
purple_signal_connect(purple_conversations_get_handle(), "sent-im-msg", plugin,
PURPLE_CALLBACK(sent_im_msg), NULL);
purple_signal_connect(purple_conversations_get_handle(), "received-im-msg", plugin,
PURPLE_CALLBACK(received_im_msg), NULL);
purple_signal_connect(purple_blist_get_handle(), "buddy-status-changed", plugin,
PURPLE_CALLBACK(buddy_status_changed), NULL);
purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", plugin,
PURPLE_CALLBACK(buddy_signed_on), NULL);
purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", plugin,
PURPLE_CALLBACK(buddy_signed_off), NULL);
purple_signal_connect(pidgin_blist_get_handle(), "drawing-tooltip", plugin,
PURPLE_CALLBACK(drawing_tooltip), NULL);
purple_signal_connect(purple_connections_get_handle(), "signed-on", plugin,
PURPLE_CALLBACK(signed_on), NULL);
purple_signal_connect(purple_connections_get_handle(), "signed-off", plugin,
PURPLE_CALLBACK(signed_off), NULL);
_signals_connected = TRUE;
}
/* Create the privkeys UI, and pack it into the vbox */
static void make_privkeys_ui(GtkWidget *vbox)
{
GtkWidget *fbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *frame;
frame = gtk_frame_new(_("My private keys"));
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
fbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(fbox), 10);
gtk_container_add(GTK_CONTAINER(frame), fbox);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(fbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Key for account:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
ui_layout.accountmenu = pidgin_account_option_menu_new(NULL, 1,
G_CALLBACK(account_menu_changed_cb), NULL, NULL);
gtk_box_pack_start(GTK_BOX(hbox), ui_layout.accountmenu, TRUE, TRUE, 0);
/* Make sure we notice if the menu changes because an account has
* been added or removed */
purple_signal_connect(purple_accounts_get_handle(), "account-added",
ui_layout.accountmenu,
PURPLE_CALLBACK(account_menu_added_removed_cb), NULL);
purple_signal_connect(purple_accounts_get_handle(), "account-removed",
ui_layout.accountmenu,
PURPLE_CALLBACK(account_menu_added_removed_cb), NULL);
ui_layout.fprint_label = gtk_label_new("");
gtk_label_set_selectable(GTK_LABEL(ui_layout.fprint_label), 1);
gtk_box_pack_start(GTK_BOX(fbox), ui_layout.fprint_label,
FALSE, FALSE, 0);
ui_layout.generate_button = gtk_button_new();
gtk_signal_connect(GTK_OBJECT(ui_layout.generate_button), "clicked",
GTK_SIGNAL_FUNC(generate), NULL);
label = gtk_label_new(_("Generate"));
gtk_container_add(GTK_CONTAINER(ui_layout.generate_button), label);
otrg_gtk_ui_update_fingerprint();
gtk_box_pack_start(GTK_BOX(fbox), ui_layout.generate_button,
FALSE, FALSE, 0);
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
// purple_debug(PURPLE_DEBUG_INFO, "simple", "simple plugin loaded.\n");
void *conv_handle = purple_conversations_get_handle();
purple_signal_connect(conv_handle, "conversation-created",
plugin, PURPLE_CALLBACK(nouvelle_convers), NULL);
/*purple_signal_connect(conv_handle, "receiving-chat-msg",
plugin, PURPLE_CALLBACK(message_recu), NULL);*/
purple_signal_connect(conv_handle, "receiving-im-msg",
plugin, PURPLE_CALLBACK(message_recu2), NULL);
purple_cmd_register("jeu", "w", PURPLE_CMD_P_PLUGIN, PURPLE_CMD_FLAG_IM|PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS, NULL, PURPLE_CMD_FUNC(commande), "jeu nom_du_jeu",NULL);
return TRUE;
}
static gboolean plugin_load(PurplePlugin *plugin)
{
ea_plugin = plugin;
void *conv_handle = purple_conversations_get_handle();
// connect callbacks
purple_signal_connect(conv_handle, "received-im-msg", plugin,
PURPLE_CALLBACK(on_new_im_message), NULL);
purple_signal_connect(conv_handle, "received-chat-msg", plugin,
PURPLE_CALLBACK(on_new_chat_message), NULL);
return TRUE;
}
static gboolean plugin_load(PurplePlugin *plugin)
{
purple_signal_connect(purple_connections_get_handle(), "signed-on",
plugin, PURPLE_CALLBACK(online), NULL);
purple_signal_connect(purple_connections_get_handle(), "signing-off",
plugin, PURPLE_CALLBACK(signoff), NULL);
purple_signal_connect(purple_accounts_get_handle(), "account-status-changed",
plugin, PURPLE_CALLBACK(status_changed), NULL);
under_recursion = TRUE;
return TRUE;
}
static void waprpl_login(PurpleAccount * acct)
{
PurpleConnection *gc = purple_account_get_connection(acct);
purple_debug_info(WHATSAPP_ID, "logging in %s\n", purple_account_get_username(acct));
purple_connection_update_progress(gc, "Connecting", 0, 4);
whatsapp_connection *wconn = g_new0(whatsapp_connection, 1);
wconn->fd = -1;
wconn->sslfd = -1;
wconn->account = acct;
wconn->rh = 0;
wconn->wh = 0;
wconn->timer = 0;
wconn->connected = 0;
wconn->conv_id = 1;
wconn->gsc = 0;
wconn->sslrh = 0;
wconn->sslwh = 0;
const char *username = purple_account_get_username(acct);
const char *password = purple_account_get_password(acct);
const char *nickname = purple_account_get_string(acct, "nick", "");
wconn->waAPI = waAPI_create(username, password, nickname);
purple_connection_set_protocol_data(gc, wconn);
const char *hostname = purple_account_get_string(acct, "server", "");
int port = purple_account_get_int(acct, "port", WHATSAPP_DEFAULT_PORT);
char hn[256];
if (strlen(hostname) == 0) {
sprintf(hn, "e%d.whatsapp.net", rand() % 9 + 1);
hostname = hn;
}
if (purple_proxy_connect(gc, acct, hostname, port, waprpl_connect_cb, gc) == NULL) {
purple_connection_error_reason(gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, "Unable to connect");
}
static int sig_con = 0;
if (!sig_con) {
sig_con = 1;
purple_signal_connect(purple_blist_get_handle(), "blist-node-removed", _whatsapp_protocol, PURPLE_CALLBACK(waprpl_blist_node_removed), NULL);
purple_signal_connect(purple_blist_get_handle(), "blist-node-added", _whatsapp_protocol, PURPLE_CALLBACK(waprpl_blist_node_added), NULL);
}
}
static gboolean plugin_load(PurplePlugin * plugin) {
asprintf(&hook_script, "%s/%s", purple_user_dir(), AUTORESPOND);
void *conv_handle = purple_conversations_get_handle();
purple_signal_connect(conv_handle, "received-im-msg", plugin,
PURPLE_CALLBACK(received_im_msg_cb), NULL);
return TRUE;
}
void
purple_upnp_init()
{
purple_signal_connect(purple_network_get_handle(), "network-configuration-changed",
purple_upnp_get_handle(), PURPLE_CALLBACK(purple_upnp_network_config_changed_cb),
NULL);
}
