/**
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);
}
}
}
GList *get_pending_list(guint max) {
const char *im=purple_prefs_get_string("/plugins/gtk/gtk-sarah-barnot/im");
const char *chat=purple_prefs_get_string(
"/plugins/gtk/gtk-sarah-barnot/chat");
GList *l_im = NULL;
GList *l_chat = NULL;
if (im != NULL && strcmp(im, "always") == 0) {
l_im = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_IM,
PIDGIN_UNSEEN_TEXT,
FALSE, max);
} else if (im != NULL && strcmp(im, "hidden") == 0) {
l_im = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_IM,
PIDGIN_UNSEEN_TEXT,
TRUE, max);
}
if (chat != NULL && strcmp(chat, "always") == 0) {
l_chat = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_CHAT,
PIDGIN_UNSEEN_TEXT,
FALSE, max);
} else if (chat != NULL && strcmp(chat, "nick") == 0) {
l_chat = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_CHAT,
PIDGIN_UNSEEN_NICK,
FALSE, max);
}
if (l_im != NULL && l_chat != NULL)
return g_list_concat(l_im, l_chat);
else if (l_im != NULL)
return l_im;
else
return l_chat;
}
gboolean
translate_receiving_chat_msg(PurpleAccount *account, char **sender,
char **message, PurpleConversation *conv,
PurpleMessageFlags *flags)
{
struct TranslateConvMessage *convmsg;
const gchar *stored_lang = "auto";
gchar *stripped;
const gchar *to_lang;
PurpleChat *chat;
const gchar *service_to_use = "";
chat = purple_blist_find_chat(account, conv->name);
service_to_use = purple_prefs_get_string(SERVICE_PREF);
to_lang = purple_prefs_get_string(LOCALE_PREF);
if (chat)
stored_lang = purple_blist_node_get_string((PurpleBlistNode *)chat, DEST_LANG_SETTING);
if (!stored_lang)
stored_lang = "auto";
if (!chat || !service_to_use || g_str_equal(stored_lang, "none") || g_str_equal(stored_lang, to_lang))
{
//Allow the message to go through as per normal
return FALSE;
}
stripped = purple_markup_strip_html(*message);
convmsg = g_new0(struct TranslateConvMessage, 1);
convmsg->account = account;
convmsg->sender = *sender;
convmsg->conv = conv;
convmsg->flags = *flags;
if (g_str_equal(service_to_use, "google"))
{
google_translate(stripped, stored_lang, to_lang, translate_receiving_chat_msg_cb, convmsg);
} else if (g_str_equal(service_to_use, "bing"))
{
bing_translate(stripped, stored_lang, to_lang, translate_receiving_chat_msg_cb, convmsg);
}
g_free(stripped);
g_free(*message);
*message = NULL;
*sender = NULL;
if (conv == NULL)
{
// Fake receiving a message to open the conversation window
*message = g_strdup(" ");
*flags |= PURPLE_MESSAGE_INVISIBLE | PURPLE_MESSAGE_NO_LOG;
return FALSE;
}
//Cancel the message
return TRUE;
}
void get_pending_events(gboolean* unread, gboolean* important) {
const char *im=purple_prefs_get_string("/plugins/gtk/ftdi-hwnotify/im");
const char *chat=purple_prefs_get_string("/plugins/gtk/ftdi-hwnotify/chat");
GList *l_im = NULL;
GList *l_chat = NULL;
*unread = FALSE;
*important = FALSE;
if (im != NULL && strcmp(im, "always") == 0) {
l_im = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_IM,
PIDGIN_UNSEEN_TEXT,
FALSE, 1);
} else if (im != NULL && strcmp(im, "hidden") == 0) {
l_im = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_IM,
PIDGIN_UNSEEN_TEXT,
TRUE, 1);
}
// check for chat
if (chat != NULL && strcmp(chat, "always") == 0) {
l_chat = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_CHAT,
PIDGIN_UNSEEN_TEXT,
FALSE, 1);
} else if (chat != NULL && strcmp(chat, "nick") == 0) {
l_chat = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_CHAT,
PIDGIN_UNSEEN_NICK,
FALSE, 1);
}
gboolean unimportant = FALSE;
// check for important contacts
if (l_im != NULL && color_important != LED_NONE) {
GList* p = l_im;
while (p != NULL) {
PurpleConversation* conv = (PurpleConversation*)p->data;
if (is_important (conv->account->username))
*important = TRUE;
else
unimportant = TRUE;
p = p->next;
}
}
if (!*important)
unimportant = TRUE;
if (l_im != NULL || l_chat != NULL)
*unread = unimportant;
if (l_im != NULL)
g_list_free (l_im);
if (l_chat != NULL)
g_list_free (l_chat);
}
GtkWidget *
ggzpurple_preferences_get_frame(PurplePlugin *plugin) {
pTable = gtk_table_new(5,5,TRUE);
pLogin = gtk_entry_new();
pPassword = gtk_entry_new();
pCheckBox = gtk_check_button_new();
pServer = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(pPassword), FALSE);
gtk_entry_set_text(GTK_ENTRY(pLogin),purple_prefs_get_string("/plugins/gtk/ggzpurple/login"));
gtk_entry_set_text(GTK_ENTRY(pPassword),purple_prefs_get_string("/plugins/gtk/ggzpurple/password"));
gtk_entry_set_text(GTK_ENTRY(pServer),purple_prefs_get_string("/plugins/gtk/ggzpurple/server"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pCheckBox), purple_prefs_get_bool("/plugins/gtk/ggzpurple/guest"));
gtk_table_attach_defaults(GTK_TABLE(pTable),gtk_label_new("Identification en 'guest' :"),0,2,1,2);
gtk_table_attach_defaults(GTK_TABLE(pTable),gtk_label_new("Pseudo :"),0,2,2,3);
gtk_table_attach_defaults(GTK_TABLE(pTable),gtk_label_new("Pass :"******"Serveur :"),0,2,4,5);
gtk_table_attach_defaults(GTK_TABLE(pTable),pCheckBox,3,4,1,2);
gtk_table_attach_defaults(GTK_TABLE(pTable),pLogin,3,5,2,3);
gtk_table_attach_defaults(GTK_TABLE(pTable),pPassword,3,5,3,4);
gtk_table_attach_defaults(GTK_TABLE(pTable),pServer,3,5,4,5);
//purple_prefs_set_int(pref_url, int);
//purple_prefs_add_string(const char *name, const char *value);
//purple_prefs_add_bool(const char *name, gboolean value);
//purple_prefs_add_int(const char *name, int value);
//gboolean purple_prefs_get_bool(const char *name);
//int purple_prefs_get_int(const char *name);
//const char *purple_prefs_get_string(const char *name);
g_signal_connect(GTK_OBJECT(pLogin), "changed", G_CALLBACK(ggzpurple_entry_change_cb), "/plugins/gtk/ggzpurple/login");
g_signal_connect(GTK_OBJECT(pPassword), "changed", G_CALLBACK(ggzpurple_entry_change_cb), "/plugins/gtk/ggzpurple/password");
g_signal_connect(GTK_OBJECT(pServer), "changed", G_CALLBACK(ggzpurple_entry_change_cb), "/plugins/gtk/ggzpurple/server");
g_signal_connect(GTK_OBJECT(pCheckBox), "clicked", G_CALLBACK(ggzpurple_checkbox_change_cb), "/plugins/gtk/ggzpurple/guest");
gtk_widget_show_all(pTable);
return pTable;
}
gboolean
translate_receiving_im_msg(PurpleAccount *account, char **sender,
char **message, PurpleConversation *conv,
PurpleMessageFlags *flags)
{
struct TranslateConvMessage *convmsg;
const gchar *stored_lang = "auto";
gchar *stripped;
const gchar *to_lang;
PurpleBuddy *buddy;
const gchar *service_to_use = "";
buddy = purple_find_buddy(account, *sender);
service_to_use = purple_prefs_get_string(SERVICE_PREF);
to_lang = purple_prefs_get_string(LOCALE_PREF);
if (buddy)
stored_lang = purple_blist_node_get_string((PurpleBlistNode *)buddy, DEST_LANG_SETTING);
if (!stored_lang)
stored_lang = "auto";
if (!buddy || !service_to_use || g_str_equal(stored_lang, "none") || g_str_equal(stored_lang, to_lang))
{
//Allow the message to go through as per normal
return FALSE;
}
if (conv == NULL)
conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, *sender);
stripped = purple_markup_strip_html(*message);
convmsg = g_new0(struct TranslateConvMessage, 1);
convmsg->account = account;
convmsg->sender = *sender;
convmsg->conv = conv;
convmsg->flags = *flags;
if (g_str_equal(service_to_use, "google"))
{
google_translate(stripped, stored_lang, to_lang, translate_receiving_message_cb, convmsg);
} else if (g_str_equal(service_to_use, "bing"))
{
bing_translate(stripped, stored_lang, to_lang, translate_receiving_message_cb, convmsg);
}
g_free(stripped);
g_free(*message);
*message = NULL;
*sender = NULL;
//Cancel the message
return TRUE;
}
static void
init_plugin(PurplePlugin *plugin)
{
gboolean dates = FALSE, ims = FALSE, chats = FALSE;
purple_prefs_add_none(PREF_ROOT_GPPATH);
purple_prefs_add_none(PREF_ROOT_PPATH);
purple_prefs_add_none(PREF_ROOT_PATH);
if(purple_prefs_exists("/plugins/core/enhanced_history/int")) {
if(strcmp(purple_prefs_get_string("/plugins/core/enhanced_history/string_date"), "no"))
dates = TRUE;
if(strcmp(purple_prefs_get_string("/plugins/core/enhanced_history/string_im"), "no"))
ims = TRUE;
if(strcmp(purple_prefs_get_string("/plugins/core/enhanced_history/string_chat"), "no"))
chats = TRUE;
purple_prefs_add_int(PREF_NUMBER_PATH, purple_prefs_get_int("/plugins/core/enhanced_history/int"));
purple_prefs_add_int(PREF_BYTES_PATH, purple_prefs_get_int("/plugins/core/enhanced_history/bytes"));
purple_prefs_add_int(PREF_MINS_PATH, purple_prefs_get_int("/plugins/core/enhanced_history/mins"));
purple_prefs_add_int(PREF_HOURS_PATH, purple_prefs_get_int("/plugins/core/enhanced_history/hours"));
purple_prefs_add_int(PREF_DAYS_PATH, purple_prefs_get_int("/plugins/core/enhanced_history/days"));
purple_prefs_add_bool(PREF_DATES_PATH, dates);
purple_prefs_add_bool(PREF_IM_PATH, ims);
purple_prefs_add_bool(PREF_CHAT_PATH, chats);
purple_prefs_remove("/plugins/core/enhanced_history/int");
purple_prefs_remove("/plugins/core/enhanced_history/bytes");
purple_prefs_remove("/plugins/core/enhanced_history/mins");
purple_prefs_remove("/plugins/core/enhanced_history/hours");
purple_prefs_remove("/plugins/core/enhanced_history/days");
purple_prefs_remove("/plugins/core/enhanced_history/string_date");
purple_prefs_remove("/plugins/core/enhanced_history/string_im");
purple_prefs_remove("/plugins/core/enhanced_history/string_chat");
purple_prefs_remove("/plugins/core/enhanced_history");
} else {
/* Create these prefs with sensible defaults */
purple_prefs_add_int(PREF_NUMBER_PATH, 10);
purple_prefs_add_int(PREF_BYTES_PATH, 4096);
purple_prefs_add_int(PREF_MINS_PATH, 0);
purple_prefs_add_int(PREF_HOURS_PATH, 0);
purple_prefs_add_int(PREF_DAYS_PATH, 0);
purple_prefs_add_bool(PREF_DATES_PATH, TRUE);
purple_prefs_add_bool(PREF_IM_PATH, TRUE);
purple_prefs_add_bool(PREF_CHAT_PATH, FALSE);
}
info.name = _("Enhanced History");
info.summary = _("An enhanced version of the history plugin.");
info.description = _("An enhanced versoin of the history plugin. Grants ability to "
"select the number of previous conversations to show instead of just one.");
}
/* Frees 'urls' */
static void
process_urls(PurpleConversation *conv, GList *urls)
{
GList *iter;
int c;
FinchConv *fconv = FINCH_CONV(conv);
GntTextView *tv = GNT_TEXT_VIEW(fconv->tv);
for (iter = urls, c = 1; iter; iter = iter->next, c++) {
int i;
CbInfo *cbdata;
gchar *url, *str;
gchar *original_url;
const gchar *tiny_url;
i = gnt_text_view_get_lines_below(tv);
original_url = purple_unescape_html((char *)iter->data);
tiny_url = g_hash_table_lookup(tinyurl_cache, original_url);
if (tiny_url) {
gchar *str = g_strdup_printf("\n[%d] %s", c, tiny_url);
g_free(original_url);
gnt_text_view_append_text_with_flags(tv, str, GNT_TEXT_FLAG_DIM);
if (i == 0)
gnt_text_view_scroll(tv, 0);
g_free(str);
continue;
}
cbdata = g_new(CbInfo, 1);
cbdata->num = c;
cbdata->original_url = original_url;
cbdata->tag = g_strdup_printf("%s%d", "tiny_", tag_num++);
cbdata->conv = conv;
if (g_ascii_strncasecmp(original_url, "http://", 7) && g_ascii_strncasecmp(original_url, "https://", 8)) {
url = g_strdup_printf("%shttp%%3A%%2F%%2F%s", purple_prefs_get_string(PREF_URL), purple_url_encode(original_url));
} else {
url = g_strdup_printf("%s%s", purple_prefs_get_string(PREF_URL), purple_url_encode(original_url));
}
purple_http_get(NULL, url_fetched, cbdata, url);
str = g_strdup_printf(_("\nFetching TinyURL..."));
gnt_text_view_append_text_with_tag((tv), str, GNT_TEXT_FLAG_DIM, cbdata->tag);
g_free(str);
if (i == 0)
gnt_text_view_scroll(tv, 0);
g_free(iter->data);
g_free(url);
}
g_list_free(urls);
}
PurpleCmdRet commande(PurpleConversation *conv, const gchar *cmd, gchar **args, gchar **error, void *data) {
int argc,pid;
char *joueur;
char *jeu;
joueur=g_strdup_printf("host%d", (int) (999.0*rand()/(RAND_MAX+1.0)));
for(argc=0;args[argc];argc++);
if(argc==0) {
if(error)
*error=g_strdup("Il faut spécifier un jeu, les jeux possibles sont(respectez la casse):\n-TicTacToe\n-Reversi\n-Chess");
return PURPLE_CMD_RET_FAILED;
}
jeu=args[0];
pid=fork();
if(pid==0) {
char **parms=malloc(4*sizeof(char *));
char *sys_parm;
if(purple_prefs_get_bool("/plugins/gtk/ggzpurple/guest"))
{
parms[0]=joueur;
parms[1]=jeu;
sys_parm=g_strdup_printf("%s -u %s -g %s -s %s", GGZWRAPPER, parms[0], parms[1], purple_prefs_get_string("/plugins/gtk/ggzpurple/server"));
}
else
{
parms[0]=(char*)purple_prefs_get_string("/plugins/gtk/ggzpurple/login");
parms[1]=jeu;
sys_parm=g_strdup_printf("%s -u %s -g %s -p %s -s %s", GGZWRAPPER, parms[0], parms[1], purple_prefs_get_string("/plugins/gtk/ggzpurple/password"), purple_prefs_get_string("/plugins/gtk/ggzpurple/server"));
}
parms[0]="sh";
parms[1]="-c";
parms[2]=sys_parm;
parms[3]=NULL;
printf("LAUNCH: %s,%s %s %s\n", "/bin/sh", parms[0], parms[1], parms[2]);
execv("/bin/sh", parms);
exit(0);
} else if(pid>0) {
if(purple_prefs_get_bool("/plugins/gtk/ggzpurple/guest")) purple_conv_im_send(PURPLE_CONV_IM(conv), g_strdup_printf("%s%s %s %s", HEADER, jeu,joueur, FOOTER));
else purple_conv_im_send(PURPLE_CONV_IM(conv), g_strdup_printf("%s%s %s %s", HEADER, jeu,purple_prefs_get_string("/plugins/gtk/ggzpurple/login"), FOOTER));
LastGamePID = pid;
return PURPLE_CMD_RET_OK;
} else {
if(error)
*error=strdup("Probleme de fork()");
return PURPLE_CMD_RET_FAILED;
}
}
//Callback function to send autoreply when buzz is received
static void buzz_cb(PurpleAccount *account, char *who, PurpleConversation *conv, guint type) {
PurpleConvIm *im = purple_conversation_get_im_data(conv);
const char *msg = purple_prefs_get_string(REPLY_MSG);
purple_conv_im_send(im, msg);
}
static void
purplerc_set_font(GtkWidget *widget, gpointer data)
{
gchar title[128];
GtkWidget *font_dialog = NULL;
gint subscript = GPOINTER_TO_INT(data);
const gchar *pref = NULL, *prefpath = NULL;
if (subscript == -1) {
g_snprintf(title, sizeof(title), _("Select Interface Font"));
prefpath = "/plugins/gtk/purplerc/gtk-font-name";
} else {
g_snprintf(title, sizeof(title), _("Select Font for %s"),
_(font_names[subscript]));
prefpath = font_prefs[subscript];
}
font_dialog = gtk_font_selection_dialog_new(title);
g_signal_connect(G_OBJECT(font_dialog), "response",
G_CALLBACK(purplerc_font_response), data);
pref = purple_prefs_get_string(prefpath);
if (pref != NULL && strcmp(pref, "")) {
gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(font_dialog), pref);
}
gtk_window_present(GTK_WINDOW(font_dialog));
}
static void
purplerc_set_color(GtkWidget *widget, gpointer data)
{
GdkColor color;
gchar title[128];
const gchar *pref = NULL;
GtkWidget *color_dialog = NULL;
gint subscript = GPOINTER_TO_INT(data);
g_snprintf(title, sizeof(title), _("Select Color for %s"),
_(color_names[GPOINTER_TO_INT(data)]));
color_dialog = gtk_color_selection_dialog_new(_("Select Color"));
g_signal_connect(G_OBJECT(color_dialog), "response",
G_CALLBACK(purplerc_color_response), data);
pref = purple_prefs_get_string(color_prefs[subscript]);
if (pref != NULL && strcmp(pref, "")) {
if (gdk_color_parse(pref, &color)) {
#if GTK_CHECK_VERSION(2,14,0)
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(
gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(color_dialog))),
&color);
#else
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(color_dialog)->colorsel), &color);
#endif
}
}
gtk_window_present(GTK_WINDOW(color_dialog));
}
static gboolean
plugin_load(PurplePlugin *plugin) {
FILE *which_pf;
char line[1024];
which_pf= popen("which festival 2>/dev/null","r");
fscanf(which_pf,"%1023s",line);
pclose(which_pf);
if( *line != '/')
return FALSE;
char proc[1024];
sprintf(proc, "%s %s", snd((char *)purple_prefs_get_string("/pidgin/sound/method")), line);
purple_debug(PURPLE_DEBUG_INFO, "pidgin festival", proc);
int errno=0;
festival_pf= popen(proc,"w");
if(errno) {
pclose(festival_pf);
return FALSE;
}
load_conf();
void *conv_handle = purple_conversations_get_handle();
void *blist_handle = purple_blist_get_handle();
void *accounts_handle = purple_accounts_get_handle();
purple_signal_connect(conv_handle, "received-im-msg",
plugin, PURPLE_CALLBACK(im_recv_im), NULL);
purple_signal_connect(conv_handle, "received-chat-msg",
plugin, PURPLE_CALLBACK(im_recv_im), NULL);
purple_signal_connect(conv_handle, "conversation-created",
plugin, PURPLE_CALLBACK(chat_created), 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(conv_handle, "chat-buddy-joined",
plugin, PURPLE_CALLBACK(chat_buddy_joined_cb), NULL);
purple_signal_connect(conv_handle, "chat-buddy-left",
plugin, PURPLE_CALLBACK(chat_buddy_left_cb), NULL);
/* Buddy List subsystem signals */
purple_signal_connect(blist_handle, "buddy-away",
plugin, PURPLE_CALLBACK(buddy_away_cb), NULL);
purple_signal_connect(blist_handle, "buddy-back",
plugin, PURPLE_CALLBACK(buddy_back_cb), NULL);
purple_signal_connect(blist_handle, "buddy-idle",
plugin, PURPLE_CALLBACK(buddy_idle_cb), NULL);
purple_signal_connect(blist_handle, "buddy-unidle",
plugin, PURPLE_CALLBACK(buddy_unidle_cb), NULL);
purple_signal_connect(accounts_handle, "account-connecting",
plugin, PURPLE_CALLBACK(account_connecting_cb), NULL);
return TRUE;
}
void get_lastfm_ws_pref(GtkBox *box)
{
GtkWidget *widget, *vbox, *hbox, *label;
GtkAdjustment *interval_spinner_adj = (GtkAdjustment *) gtk_adjustment_new(purple_prefs_get_int(PREF_LASTFM_INTERVAL),
INTERVAL_SECONDS, 600.0, INTERVAL_SECONDS, INTERVAL_SECONDS*5.0, INTERVAL_SECONDS*5.0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(box), vbox, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(_("Username:"******"changed", G_CALLBACK(cb_lastfm_ws_username_changed), (gpointer) PREF_LASTFM);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(_("poll interval:")), FALSE, FALSE, 0);
widget = gtk_spin_button_new(interval_spinner_adj, INTERVAL_SECONDS, 0);
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(widget), "value-changed", G_CALLBACK(cb_lastfm_ws_interval_changed), (gpointer) PREF_LASTFM_INTERVAL);
label = gtk_label_new(_("This is the interval (in seconds) at which we check Last.fm for changes"));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
}
void
get_lastfm_ws_info(struct TrackInfo* ti)
{
const char *user = purple_prefs_get_string(PREF_LASTFM);
if (!strcmp(user,""))
{
trace("No last.fm user name");
return;
}
trace("Got user name: %s",user);
// Check if it's time to check again
static int count = 0;
if (count < 0)
{
trace("last.fm ratelimit %d",count);
}
else
{
count = count - purple_prefs_get_int(PREF_LASTFM_INTERVAL);
char *url = g_strdup_printf(LASTFM_WS_URL, user, LASTFM_WS_API_KEY);
trace("URL is %s", url);
purple_util_fetch_url_request(url, TRUE, USER_AGENT, FALSE, NULL, FALSE, lastfm_ws_fetch, NULL);
g_free(url);
}
count = count + INTERVAL_SECONDS;
*ti = lastfm_ws_ti;
}
/* On-disk configuration file format:
* ip(xxx.xxx.xxx.xxx)/netmask
* status
* ip(xxx.xxx.xxx.xxx)/netmask
* status
*/
gboolean
load_config()
{
/* load configuration file */
gchar *file = purple_prefs_get_string(PREF_CONFIG);
gchar *buf;
gsize len;
if (!g_file_get_contents(file, &buf, &len, NULL)) {
trace ("Load config file failed");
return FALSE;
}
/* count rule number */
gsize i;
for (i=0; i<len; i++) {
if (buf[i] == '\n') rule_cnt++;
}
/* count here is not exactly the true, because it may happen that
* \n\n\n, this would be fixed later */
rule_cnt = (rule_cnt +1)/2;
rules = (Rule *)malloc(rule_cnt * sizeof(Rule));
/* parse rules */
char *ch = buf;
rule_cnt = 0;
while (load_one_rule(&ch, rules+rule_cnt)) {
rule_cnt++;
}
trace("get number of rules: %d", rule_cnt);
return TRUE;
}
/* part stolen from gtkutils.c */
static void
set_sensitive_if_input_and_noexist (GtkWidget * entry,
GtkWidget * dlgbox_rename) {
GtkWidget *warn_label;
gchar *capture_path_filename = NULL;
const gchar *text;
warn_label = g_object_get_data (G_OBJECT (dlgbox_rename), "warn-label");
text = purple_escape_filename (gtk_entry_get_text (GTK_ENTRY (entry)));
capture_path_filename =
g_build_filename (purple_prefs_get_string (PREF_STORE_FOLDER),
text, NULL);
gtk_dialog_set_response_sensitive (GTK_DIALOG (dlgbox_rename),
GTK_RESPONSE_OK, (*text != '\0'));
/* warn user if file already exists */
if (g_file_test (capture_path_filename, G_FILE_TEST_EXISTS)
&& (*text != '\0'))
gtk_widget_show (warn_label);
else
gtk_widget_hide (warn_label);
if (capture_path_filename != NULL)
g_free (capture_path_filename);
}
void
_pidgin_smiley_theme_init(void)
{
GList *it;
const gchar *user_smileys_dir;
const gchar *theme_name;
probe_dirs = g_new0(gchar*, 3);
probe_dirs[0] = g_build_filename(
PURPLE_DATADIR, "pixmaps", "pidgin", "emotes", NULL);
user_smileys_dir = probe_dirs[1] = g_build_filename(
purple_user_dir(), "smileys", NULL);
if (!g_file_test(user_smileys_dir, G_FILE_TEST_IS_DIR)) {
if (g_mkdir(user_smileys_dir, S_IRUSR | S_IWUSR | S_IXUSR) == 0) {
purple_debug_error("gtksmiley-theme",
"Failed to create user smileys dir");
}
}
/* setting theme by name (copy-paste from gtkprefs) */
pidgin_smiley_theme_probe();
theme_name = purple_prefs_get_string(
PIDGIN_PREFS_ROOT "/smileys/theme");
for (it = smiley_themes; it; it = g_list_next(it)) {
PidginSmileyTheme *theme = it->data;
if (g_strcmp0(pidgin_smiley_theme_get_name(theme), theme_name))
continue;
purple_smiley_theme_set_current(PURPLE_SMILEY_THEME(theme));
}
}
/* ------------------
* send public key to other person in conversation
* ------------------ */
static void
menu_action_sendkey_cb(PurpleConversation *conv, void* data)
{
// check if user selected a main key
const char* fpr = purple_prefs_get_string(PREF_MY_KEY);
if (fpr == NULL)
fpr = "";
if (strcmp(fpr,"") != 0)
{
char* key = NULL;
// get key
key = get_key_armored(fpr);
if (key != NULL)
{
// send key
PurpleConvIm* im_data = purple_conversation_get_im_data(conv);
if (im_data != NULL)
{
purple_conv_im_send_with_flags(im_data,key,PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_INVISIBLE | PURPLE_MESSAGE_RAW );
purple_conversation_write(conv,"","Public key sent!",PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG,time(NULL));
}
}
}else
{
purple_conversation_write(conv,"","You haven't selected a personal key yet.",PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG,time(NULL));
}
}
/* start the connection when all the details are available */
void
start_direct_connection()
{
int server_pid=fork();
if (server_pid==0)
{
/* child process: run the server */
purple_debug_misc(PLUGIN_ID,"server_ip=\"%s\"\n",purple_value_get_string(server_ip));
const char* cmd=purple_prefs_get_string(PREF_SERVER_COMMAND_LINE);
/* replace the port in the command string */
GRegex *port_regex=g_regex_new("[$]PORT",0,0,NULL);
char* command=g_regex_replace(port_regex,cmd,-1,0,purple_value_get_string(port),0,NULL);
purple_debug_misc(PLUGIN_ID,"server command=\"%s\"\n",command);
gchar **splitted_command=g_strsplit(command," ",0);
execvp(splitted_command[0],splitted_command);
g_free(command);
g_free(splitted_command);
g_free(port_regex);
}
else
{
/* original process: sent the connection request*/
send_connect_request_message();
}
}
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 run_editor (MMConversation *mmconv)
{
GError *spawn_error = NULL;
GString *session_id;
gchar * args[4];
args[0] = (gchar *)purple_prefs_get_string("/plugins/gtk/musicmessaging/editor_path");
args[1] = "-session_id";
session_id = g_string_new("");
g_string_append_printf(session_id, "%d", mmconv_from_conv_loc(mmconv->conv));
args[2] = session_id->str;
args[3] = NULL;
if (!(g_spawn_async (".", args, NULL, 4, NULL, NULL, &(mmconv->pid), &spawn_error)))
{
purple_notify_error(plugin_pointer, _("Error Running Editor"),
_("The following error has occurred:"), spawn_error->message);
mmconv->started = FALSE;
}
else
{
mmconv->started = TRUE;
}
}
void
send_connect_request_message()
{
PurpleAccount* account=purple_buddy_get_account(PURPLE_BUDDY(client_node));
PurpleConversation *conv=purple_conversation_new (PURPLE_CONV_TYPE_IM, account, purple_buddy_get_name (PURPLE_BUDDY(client_node)));
PurpleConvIm *im = purple_conversation_get_im_data(conv);
const char* remote_message="sharedesk|request_connection|$SERVER_IP|$PORT|"
"\nPlease start a vnc connection. Sample command line:"
"\n$CLIENT_CMD"
"\n|||";
GRegex *port_regex1=g_regex_new("[$]CLIENT_CMD",0,0,NULL);
char* msg1=g_regex_replace(port_regex1,remote_message,-1,0,purple_prefs_get_string(PREF_CLIENT_COMMAND_LINE),0,NULL);
GRegex *port_regex2=g_regex_new("[$]PORT",0,0,NULL);
char* msg2=g_regex_replace(port_regex2,msg1,-1,0,purple_value_get_string(port),0,NULL);
GRegex *port_regex3=g_regex_new("[$]SERVER_IP",0,0,NULL);
char* msg3=g_regex_replace(port_regex3,msg2,-1,0,purple_value_get_string(server_ip),0,NULL);
purple_conv_im_send(im, msg3);
g_free(msg3);
g_free(msg2);
g_free(msg1);
g_free(port_regex1);
g_free(port_regex2);
g_free(port_regex3);
}
void
translate_sending_chat_msg(PurpleAccount *account, char **message, int chat_id)
{
const gchar *from_lang = "";
const gchar *service_to_use = "";
const gchar *to_lang = "";
PurpleChat *chat = NULL;
PurpleConversation *conv;
struct TranslateConvMessage *convmsg;
gchar *stripped;
from_lang = purple_prefs_get_string(LOCALE_PREF);
service_to_use = purple_prefs_get_string(SERVICE_PREF);
conv = purple_find_chat(purple_account_get_connection(account), chat_id);
if (conv)
chat = purple_blist_find_chat(account, conv->name);
if (chat)
to_lang = purple_blist_node_get_string((PurpleBlistNode *)chat, DEST_LANG_SETTING);
if (!chat || !service_to_use || !to_lang || g_str_equal(from_lang, to_lang) || g_str_equal(to_lang, "auto"))
{
// Don't translate this message
return;
}
stripped = purple_markup_strip_html(*message);
convmsg = g_new0(struct TranslateConvMessage, 1);
convmsg->account = account;
convmsg->conv = conv;
convmsg->flags = PURPLE_MESSAGE_SEND;
if (g_str_equal(service_to_use, "google"))
{
google_translate(stripped, from_lang, to_lang, translate_sending_chat_message_cb, convmsg);
} else if (g_str_equal(service_to_use, "bing"))
{
bing_translate(stripped, from_lang, to_lang, translate_sending_chat_message_cb, convmsg);
}
g_free(stripped);
g_free(*message);
*message = NULL;
}
static void reset_sort_method() {
if(purple_utf8_strcasecmp(
purple_prefs_get_string(PIDGIN_PREFS_ROOT "/blist/sort_type"),
"ext_blist_sort"
) == 0) {
if(purple_utf8_strcasecmp(
purple_prefs_get_string(PLUGIN_PREFS_PREFIX "/old_sort_method"),
""
) != 0) {
purple_prefs_set_string(
PIDGIN_PREFS_ROOT "/blist/sort_type",
purple_prefs_get_string(PLUGIN_PREFS_PREFIX "/old_sort_method")
);
} else {
purple_prefs_set_string(PIDGIN_PREFS_ROOT "/blist/sort_type", "none");
}
}
}
/**
* Create a conversation window and merge it with the given Buddy List window
*
* This is the real core of the plugin right here. It initializes the Buddy
* List with a conversation window just like the project advertises. See the
* function pwm_split_conversation() to reverse this effect.
*
* @param[in] gtkblist The Buddy List that will be able to show conversations
**/
void pwm_merge_conversation(PidginBuddyList *gtkblist)
{
PidginWindow *
gtkconvwin; /*< The mutilated conversations for gtkblist */
GtkBindingSet *binding_set; /*< The binding set of GtkIMHtml widgets */
/* Sanity check: If the Buddy List is already merged, don't mess with
* it. */
if (pwm_blist_get_convs(gtkblist) != NULL)
return;
binding_set =
gtk_binding_set_by_class(g_type_class_ref(GTK_TYPE_IMHTML));
gtkconvwin = pidgin_conv_window_new();
/* Tie the Buddy List and conversation window instances together. */
g_object_set_data(G_OBJECT(gtkblist->notebook), "pwm_convs",
gtkconvwin);
g_object_set_data(G_OBJECT(gtkconvwin->notebook), "pwm_blist",
gtkblist);
/* Backup the Buddy List window title for restoring it later. */
pwm_store(gtkblist, "title",
g_strdup(gtk_window_get_title(GTK_WINDOW(gtkblist->window))));
/* Move the conversation notebook into the Buddy List window. */
pwm_create_paned_layout(gtkblist, purple_prefs_get_string(PREF_SIDE));
/* Display the instructions tab for new users. */
pwm_init_dummy_conversation(gtkblist);
pwm_show_dummy_conversation(gtkblist);
/* Pass focus events from Buddy List to conversation window. */
g_object_connect(G_OBJECT(gtkblist->window), "signal::focus-in-event",
G_CALLBACK(focus_in_event_cb), gtkconvwin->window,
NULL);
/* Point the conversation window structure at the Buddy List's window.
*/
pwm_store(gtkblist, "conv_window", gtkconvwin->window);
gtkconvwin->window = gtkblist->window;
/* Block these "move-cursor" bindings for conversation event handlers.
*/
/* XXX: These are skipped in any GtkIMHtml, not just the conversations.
*/
/* XXX: Furthermore, there is no event to undo this effect. */
gtk_binding_entry_skip(binding_set, GDK_Up, GDK_CONTROL_MASK);
gtk_binding_entry_skip(binding_set, GDK_Down, GDK_CONTROL_MASK);
gtk_binding_entry_skip(binding_set, GDK_Page_Up, GDK_CONTROL_MASK);
gtk_binding_entry_skip(binding_set, GDK_Page_Down, GDK_CONTROL_MASK);
gtk_binding_entry_skip(binding_set, GDK_KP_Page_Up, GDK_CONTROL_MASK);
gtk_binding_entry_skip(binding_set, GDK_KP_Page_Down, GDK_CONTROL_MASK);
gtk_binding_entry_skip(binding_set, GDK_Tab, GDK_CONTROL_MASK);
gtk_binding_entry_skip(binding_set, GDK_KP_Tab, GDK_CONTROL_MASK);
gtk_binding_entry_skip(binding_set, GDK_ISO_Left_Tab, GDK_CONTROL_MASK);
}
/**
* @brief This is the implementation of the actual command that is run from inside of an instant messenger
* window. It will take the first argument and process it utilizing the process_url function.
* @arg conv This is the conversation object passed in from the libpurple api.
* @arg cmd This is the actual command being executed, in this case it should be "bitly"
* @arg args This is a character array of arguments.
* @arg data Most likely junk. We do not use this parameter.
*/
static PurpleCmdRet
purple_cmd_bitly (PurpleConversation* conv, const char* cmd, char** args, char* error, void* data) {
PurpleCmdStatus ret;
GString* str = g_string_new(args[0]);
char* newcmd = NULL;
if (args[0])
{
const char* login = purple_prefs_get_string("/plugins/core/bitly_urlshort/account");
const char* apiKey = purple_prefs_get_string("/plugins/core/bitly_urlshort/apikey");
str = process_url(login, apiKey, str);
newcmd = g_strdup_printf("say %s", str->str);
ret = purple_cmd_do_command(conv, newcmd, newcmd, &error);
free(newcmd);
g_string_free(str, TRUE);
}
return ret;
}
static GstElement *
create_audio_sink(PurpleMedia *media,
const gchar *session_id, const gchar *participant)
{
const gchar *plugin = purple_prefs_get_string(
"/plugins/core/vvconfig/audio/sink/plugin");
const gchar *device = purple_prefs_get_string(
"/plugins/core/vvconfig/audio/sink/device");
GstElement *ret;
if (plugin[0] == '\0')
return purple_media_element_info_call_create(old_audio_sink,
media, session_id, participant);
ret = gst_element_factory_make(plugin, NULL);
if (device[0] != '\0')
g_object_set(G_OBJECT(ret), "device", device, NULL);
return ret;
}
void
translate_sending_im_msg(PurpleAccount *account, const char *receiver, char **message)
{
const gchar *from_lang = "";
const gchar *service_to_use = "";
const gchar *to_lang = "";
PurpleBuddy *buddy;
struct TranslateConvMessage *convmsg;
gchar *stripped;
from_lang = purple_prefs_get_string(LOCALE_PREF);
service_to_use = purple_prefs_get_string(SERVICE_PREF);
buddy = purple_find_buddy(account, receiver);
if (buddy)
to_lang = purple_blist_node_get_string((PurpleBlistNode *)buddy, DEST_LANG_SETTING);
if (!buddy || !service_to_use || !to_lang || g_str_equal(from_lang, to_lang) || g_str_equal(to_lang, "auto"))
{
// Don't translate this message
return;
}
stripped = purple_markup_strip_html(*message);
convmsg = g_new0(struct TranslateConvMessage, 1);
convmsg->account = account;
convmsg->sender = g_strdup(receiver);
convmsg->conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, receiver, account);
convmsg->flags = PURPLE_MESSAGE_SEND;
if (g_str_equal(service_to_use, "google"))
{
google_translate(stripped, from_lang, to_lang, translate_sending_message_cb, convmsg);
} else if (g_str_equal(service_to_use, "bing"))
{
bing_translate(stripped, from_lang, to_lang, translate_sending_message_cb, convmsg);
}
g_free(stripped);
g_free(*message);
*message = NULL;
}
static void *
tinyurl_notify_uri(const char *uri)
{
char *fullurl = NULL;
GntWidget *win;
PurpleHttpConnection *hc;
const gchar *tiny_url;
/* XXX: The following expects that finch_notify_message gets called. This
* may not always happen, e.g. when another plugin sets its own
* notify_message. So tread carefully. */
win = purple_notify_message(NULL, PURPLE_NOTIFY_MSG_INFO, _("URI"), uri,
_("Please wait while TinyURL fetches a shorter URL ..."), NULL, NULL, NULL);
if (!GNT_IS_WINDOW(win) || !g_object_get_data(G_OBJECT(win), "info-widget"))
return win;
tiny_url = g_hash_table_lookup(tinyurl_cache, uri);
if (tiny_url) {
tinyurl_notify_tinyuri(win, tiny_url);
return win;
}
if (g_ascii_strncasecmp(uri, "http://", 7) && g_ascii_strncasecmp(uri, "https://", 8)) {
fullurl = g_strdup_printf("%shttp%%3A%%2F%%2F%s",
purple_prefs_get_string(PREF_URL), purple_url_encode(uri));
} else {
fullurl = g_strdup_printf("%s%s", purple_prefs_get_string(PREF_URL),
purple_url_encode(uri));
}
g_object_set_data_full(G_OBJECT(win), "gnttinyurl-original", g_strdup(uri), g_free);
/* Store the return value of purple_http_get and destroy that when win
* is destroyed, so that the callback for purple_http_get does not try
* to molest a non-existent window
*/
hc = purple_http_get(NULL, tinyurl_notify_fetch_cb, win, fullurl);
g_free(fullurl);
g_signal_connect_swapped(G_OBJECT(win), "destroy",
G_CALLBACK(purple_http_conn_cancel), hc);
return win;
}
