static void blist_create_cb(PurpleBuddyList *purple_blist, void *data) {
purple_debug_info(WINPREFS_PLUGIN_ID, "buddy list created\n");
blist = PIDGIN_BLIST(purple_blist)->window;
if(purple_prefs_get_bool(PREF_DBLIST_DOCKABLE)) {
blist_set_dockable(TRUE);
if(purple_prefs_get_bool(PREF_DBLIST_DOCKED)) {
blist_ab->undocked_height = purple_prefs_get_int(PREF_DBLIST_HEIGHT);
if(!(gdk_window_get_state(gtk_widget_get_window(blist))
& GDK_WINDOW_STATE_WITHDRAWN)) {
gtk_appbar_dock(blist_ab,
purple_prefs_get_int(PREF_DBLIST_SIDE));
if(purple_prefs_get_int(PREF_BLIST_ON_TOP)
== BLIST_TOP_DOCKED)
blist_set_ontop(TRUE);
} else {
g_idle_add(listen_for_blist_visible_cb, NULL);
}
}
}
if(purple_prefs_get_int(PREF_BLIST_ON_TOP) == BLIST_TOP_ALWAYS)
blist_set_ontop(TRUE);
}
static void
init_plugin(PurplePlugin *plugin)
{
purple_prefs_add_none("/plugins/gtk");
purple_prefs_add_none("/plugins/gtk/win32");
purple_prefs_add_none("/plugins/gtk/win32/winprefs");
purple_prefs_add_bool(PREF_DBLIST_DOCKABLE, FALSE);
purple_prefs_add_bool(PREF_DBLIST_DOCKED, FALSE);
purple_prefs_add_int(PREF_DBLIST_HEIGHT, 0);
purple_prefs_add_int(PREF_DBLIST_SIDE, 0);
/* Convert old preferences */
if(purple_prefs_exists(PREF_DBLIST_ON_TOP)) {
gint blist_top = BLIST_TOP_NEVER;
if(purple_prefs_get_bool(PREF_BLIST_ON_TOP))
blist_top = BLIST_TOP_ALWAYS;
else if(purple_prefs_get_bool(PREF_DBLIST_ON_TOP))
blist_top = BLIST_TOP_DOCKED;
purple_prefs_remove(PREF_BLIST_ON_TOP);
purple_prefs_remove(PREF_DBLIST_ON_TOP);
purple_prefs_add_int(PREF_BLIST_ON_TOP, blist_top);
} else
purple_prefs_add_int(PREF_BLIST_ON_TOP, BLIST_TOP_NEVER);
purple_prefs_remove(PREF_CHAT_BLINK);
}
static void
notify_new_message_cb (PurpleAccount *account,
const gchar *sender,
const gchar *message,
int flags,
gpointer data)
{
PurpleConversation *conv;
if (!purple_prefs_get_bool ("/plugins/gtk/libnotify/newmsg"))
return;
conv = purple_find_conversation_with_account (PURPLE_CONV_TYPE_IM, sender, account);
#ifndef DEBUG /* in debug mode, always show notifications */
if (conv && purple_conversation_has_focus (conv)) {
purple_debug_info (PLUGIN_ID, "Conversation has focus 0x%lx\n", (unsigned long)conv);
return;
}
#endif
if (conv && purple_prefs_get_bool ("/plugins/gtk/libnotify/newconvonly")) {
purple_debug_info (PLUGIN_ID, "Conversation is not new 0x%lx\n", (unsigned long)conv);
return;
}
if (!should_notify_unavailable (account))
return;
notify_msg_sent (account, conv, sender, message);
}
static void
notify_buddy_signoff_cb (PurpleBuddy *buddy,
gpointer data)
{
gchar *tr_name, *title;
gboolean blocked;
g_return_if_fail (buddy);
if (!purple_prefs_get_bool ("/plugins/gtk/libnotify/signoff"))
return;
if (g_list_find (just_signed_on_accounts, buddy->account))
return;
blocked = purple_prefs_get_bool ("/plugins/gtk/libnotify/blocked");
if (!purple_privacy_check (buddy->account, buddy->name) && blocked)
return;
if (!should_notify_unavailable (purple_buddy_get_account (buddy)))
return;
tr_name = truncate_escape_string (best_name (buddy), 25);
title = g_strdup_printf (_("%s signed off"), tr_name);
notify (title, NULL, buddy, NULL);
g_free (tr_name);
g_free (title);
}
static void set_conv_window_trans(PidginWindow *oldwin, PidginWindow *newwin) {
GtkWidget *win = newwin->window;
/* check prefs to see if we want trans */
if (purple_prefs_get_bool(OPT_WINTRANS_IM_ENABLED)) {
set_wintrans(win, purple_prefs_get_int(OPT_WINTRANS_IM_ALPHA),
TRUE, purple_prefs_get_bool(OPT_WINTRANS_IM_ONTOP));
if (purple_prefs_get_bool(OPT_WINTRANS_IM_SLIDER)) {
add_slider(win);
}
}
/* If we're moving from one window to another,
* add the focus listeners to the new window if not already there */
if (oldwin != NULL && oldwin != newwin) {
if (pidgin_conv_window_get_gtkconv_count(newwin) == 0) {
g_signal_connect(G_OBJECT(win), "focus_in_event",
G_CALLBACK(focus_conv_win_cb), win);
g_signal_connect(G_OBJECT(win), "focus_out_event",
G_CALLBACK(focus_conv_win_cb), win);
}
/* If we've moved the last conversation, cleanup the window */
if (pidgin_conv_window_get_gtkconv_count(oldwin) == 1)
cleanup_conv_window(oldwin);
}
}
void
purple_prefs_init(void)
{
void *handle = purple_prefs_get_handle();
prefs_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
purple_prefs_connect_callback(handle, "/", prefs_save_cb, NULL);
purple_prefs_add_none("/purple");
purple_prefs_add_none("/plugins");
purple_prefs_add_none("/plugins/core");
purple_prefs_add_none("/plugins/lopl");
purple_prefs_add_none("/plugins/prpl");
/* Away */
purple_prefs_add_none("/purple/away");
purple_prefs_add_string("/purple/away/idle_reporting", "system");
purple_prefs_add_bool("/purple/away/away_when_idle", TRUE);
purple_prefs_add_int("/purple/away/mins_before_away", 5);
/* Away -> Auto-Reply */
if (!purple_prefs_exists("/purple/away/auto_response/enabled") ||
!purple_prefs_exists("/purple/away/auto_response/idle_only"))
{
purple_prefs_add_string("/purple/away/auto_reply", "awayidle");
}
else
{
if (!purple_prefs_get_bool("/purple/away/auto_response/enabled"))
{
purple_prefs_add_string("/purple/away/auto_reply", "never");
}
else
{
if (purple_prefs_get_bool("/purple/away/auto_response/idle_only"))
{
purple_prefs_add_string("/purple/away/auto_reply", "awayidle");
}
else
{
purple_prefs_add_string("/purple/away/auto_reply", "away");
}
}
}
/* Buddies */
purple_prefs_add_none("/purple/buddies");
/* Contact Priority Settings */
purple_prefs_add_none("/purple/contact");
purple_prefs_add_bool("/purple/contact/last_match", FALSE);
purple_prefs_remove("/purple/contact/offline_score");
purple_prefs_remove("/purple/contact/away_score");
purple_prefs_remove("/purple/contact/idle_score");
purple_prefs_load();
purple_prefs_update_old();
}
static void set_blist_trans(GtkWidget *w, const char *pref) {
gboolean enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w));
purple_prefs_set_bool(pref, enabled);
if (blist) {
set_wintrans(blist, purple_prefs_get_int(OPT_WINTRANS_BL_ALPHA),
purple_prefs_get_bool(OPT_WINTRANS_BL_ENABLED),
purple_prefs_get_bool(OPT_WINTRANS_IM_ONTOP));
}
}
static GtkWidget *
purplerc_make_fonts_vbox(void)
{
GtkWidget *vbox = NULL, *hbox = NULL, *check = NULL, *widget = NULL;
GtkSizeGroup *labelsg = NULL;
gsize i;
vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
labelsg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
gtk_container_set_border_width(GTK_CONTAINER(vbox), PIDGIN_HIG_BORDER);
hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
check = pidgin_prefs_checkbox(_("GTK+ Interface Font"),
"/plugins/gtk/purplerc/set/gtk-font-name",
hbox);
gtk_size_group_add_widget(labelsg, check);
widget = pidgin_pixbuf_button_from_stock("", GTK_STOCK_SELECT_FONT,
PIDGIN_BUTTON_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
gtk_widget_set_sensitive(widget,
purple_prefs_get_bool("/plugins/gtk/purplerc/set/gtk-font-name"));
g_signal_connect(G_OBJECT(check), "toggled",
G_CALLBACK(pidgin_toggle_sensitive), widget);
g_signal_connect(G_OBJECT(widget), "clicked",
G_CALLBACK(purplerc_set_font), GINT_TO_POINTER(-1));
for (i = 0; i < G_N_ELEMENTS(font_prefs); i++) {
hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
check = pidgin_prefs_checkbox(_(font_names[i]),
font_prefs_set[i], hbox);
gtk_size_group_add_widget(labelsg, check);
font_widgets[i] = pidgin_pixbuf_button_from_stock("",
GTK_STOCK_SELECT_FONT, PIDGIN_BUTTON_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(hbox), font_widgets[i], FALSE,
FALSE, 0);
gtk_widget_set_sensitive(font_widgets[i],
purple_prefs_get_bool(font_prefs_set[i]));
g_signal_connect(G_OBJECT(check), "toggled",
G_CALLBACK(pidgin_toggle_sensitive),
font_widgets[i]);
g_signal_connect(G_OBJECT(font_widgets[i]), "clicked",
G_CALLBACK(purplerc_set_font),
GINT_TO_POINTER(i));
}
g_object_unref(labelsg);
return vbox;
}
static void
conv_menu_cb(PurpleConversation *conv, GList **list)
{
PurpleConversationType type = purple_conversation_get_type(conv);
gboolean enabled = ((type == PURPLE_CONV_TYPE_IM && purple_prefs_get_bool(PREF_IMS)) ||
(type == PURPLE_CONV_TYPE_CHAT && purple_prefs_get_bool(PREF_CHATS)));
PurpleMenuAction *action = purple_menu_action_new(_("Jump to markerline"),
enabled ? PURPLE_CALLBACK(jump_to_markerline) : NULL, NULL, NULL);
*list = g_list_append(*list, action);
}
static void change_alpha(GtkWidget *w, gpointer data) {
int alpha = gtk_range_get_value(GTK_RANGE(w));
purple_prefs_set_int(OPT_WINTRANS_IM_ALPHA, alpha);
/* If we're in no-transparency on focus mode,
* don't take effect immediately */
if (!purple_prefs_get_bool(OPT_WINTRANS_IM_ONFOCUS))
set_wintrans(GTK_WIDGET(data), alpha, TRUE,
purple_prefs_get_bool(OPT_WINTRANS_IM_ONTOP));
}
static int
attach_signals(PurpleConversation *conv)
{
PidginConversation *gtkconv = NULL;
PidginWindow *gtkwin = NULL;
GSList *imhtml_ids = NULL, *entry_ids = NULL;
guint id;
gtkconv = PIDGIN_CONVERSATION(conv);
if (!gtkconv) {
purple_debug_misc("notify", "Failed to find gtkconv\n");
return 0;
}
gtkwin = gtkconv->win;
if (purple_prefs_get_bool("/plugins/gtk/X11/notify/notify_focus")) {
/* TODO should really find a way to make this work no matter
* where the focus is inside the conv window, without having
* to bind to focus-in-event on the g(d|t)kwindow */
/* try setting the signal on the focus-in-event for
* gtkwin->notebook->container? */
id = g_signal_connect(G_OBJECT(gtkconv->entry), "focus-in-event",
G_CALLBACK(unnotify_cb), conv);
entry_ids = g_slist_append(entry_ids, GUINT_TO_POINTER(id));
id = g_signal_connect(G_OBJECT(gtkconv->imhtml), "focus-in-event",
G_CALLBACK(unnotify_cb), conv);
imhtml_ids = g_slist_append(imhtml_ids, GUINT_TO_POINTER(id));
}
if (purple_prefs_get_bool("/plugins/gtk/X11/notify/notify_click")) {
/* TODO similarly should really find a way to allow for
* clicking in other places of the window */
id = g_signal_connect(G_OBJECT(gtkconv->entry), "button-press-event",
G_CALLBACK(unnotify_cb), conv);
entry_ids = g_slist_append(entry_ids, GUINT_TO_POINTER(id));
id = g_signal_connect(G_OBJECT(gtkconv->imhtml), "button-press-event",
G_CALLBACK(unnotify_cb), conv);
imhtml_ids = g_slist_append(imhtml_ids, GUINT_TO_POINTER(id));
}
if (purple_prefs_get_bool("/plugins/gtk/X11/notify/notify_type")) {
id = g_signal_connect(G_OBJECT(gtkconv->entry), "key-press-event",
G_CALLBACK(unnotify_cb), conv);
entry_ids = g_slist_append(entry_ids, GUINT_TO_POINTER(id));
}
purple_conversation_set_data(conv, "notify-imhtml-signals", imhtml_ids);
purple_conversation_set_data(conv, "notify-entry-signals", entry_ids);
return 0;
}
static void
history_prefs_check(PurplePlugin *plugin)
{
if (!purple_prefs_get_bool("/purple/logging/log_ims") &&
!purple_prefs_get_bool("/purple/logging/log_chats"))
{
purple_notify_warning(plugin, NULL, _("History Plugin Requires Logging"),
_("Logging can be enabled from Tools -> Preferences -> Logging.\n\n"
"Enabling logs for instant messages and/or chats will activate "
"history for the same conversation type(s)."), NULL);
}
}
static void
history_prefs_check(PurplePlugin *plugin)
{
if (!purple_prefs_get_bool("/purple/logging/log_ims") &&
!purple_prefs_get_bool("/purple/logging/log_chats"))
{
PurpleRequestFields *fields = purple_request_fields_new();
PurpleRequestFieldGroup *group;
PurpleRequestField *field;
struct {
const char *pref;
const char *label;
} prefs[] = {
{"/purple/logging/log_ims", N_("Log IMs")},
{"/purple/logging/log_chats", N_("Log chats")},
{NULL, NULL}
};
int iter;
GList *list = purple_log_logger_get_options();
const char *system = purple_prefs_get_string("/purple/logging/format");
group = purple_request_field_group_new(_("Logging"));
field = purple_request_field_list_new("/purple/logging/format", _("Log format"));
while (list) {
const char *label = _(list->data);
list = g_list_delete_link(list, list);
purple_request_field_list_add_icon(field, label, NULL, list->data);
if (system && strcmp(system, list->data) == 0)
purple_request_field_list_add_selected(field, label);
list = g_list_delete_link(list, list);
}
purple_request_field_group_add_field(group, field);
for (iter = 0; prefs[iter].pref; iter++) {
field = purple_request_field_bool_new(prefs[iter].pref, _(prefs[iter].label),
purple_prefs_get_bool(prefs[iter].pref));
purple_request_field_group_add_field(group, field);
}
purple_request_fields_add_group(fields, group);
purple_request_fields(plugin, NULL, _("History Plugin Requires Logging"),
_("Logging can be enabled from Tools -> Preferences -> Logging.\n\n"
"Enabling logs for instant messages and/or chats will activate "
"history for the same conversation type(s)."),
fields,
_("OK"), G_CALLBACK(finch_request_save_in_prefs),
_("Cancel"), NULL,
NULL, NULL, NULL, plugin);
}
}
void BuddyList::UpdateCachedPreference(const char *name)
{
if (!strcmp(name, CONF_PREFIX "/blist/show_empty_groups"))
show_empty_groups = purple_prefs_get_bool(name);
else if (!strcmp(name, CONF_PREFIX "/blist/show_offline_buddies"))
show_offline_buddies = purple_prefs_get_bool(name);
else if (!strcmp(name, CONF_PREFIX "/blist/colorization_mode")) {
const char *value = purple_prefs_get_string(name);
if (!strcmp(value, "status"))
colorization_mode = COLOR_BY_STATUS;
else
colorization_mode = COLOR_NONE;
}
}
static void
load_pref_window(const char * profile)
{
gint i;
finch_sound_set_active_profile(profile);
gnt_combo_box_set_selected(GNT_COMBO_BOX(pref_dialog->method), (gchar *)purple_prefs_get_string(make_pref("/method")));
gnt_entry_set_text(GNT_ENTRY(pref_dialog->command), purple_prefs_get_path(make_pref("/command")));
gnt_check_box_set_checked(GNT_CHECK_BOX(pref_dialog->conv_focus), purple_prefs_get_bool(make_pref("/conv_focus")));
gnt_combo_box_set_selected(GNT_COMBO_BOX(pref_dialog->while_status), GINT_TO_POINTER(purple_prefs_get_int("/purple" "/sound/while_status")));
gnt_slider_set_value(GNT_SLIDER(pref_dialog->volume), CLAMP(purple_prefs_get_int(make_pref("/volume")), 0, 100));
for (i = 0; i < PURPLE_NUM_SOUNDS; i++) {
FinchSoundEvent * event = &sounds[i];
gchar *boolpref;
gchar *filepref, *basename = NULL;
const char * profile = finch_sound_get_active_profile();
filepref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/file/%s", profile, event->pref);
g_free(event->file);
event->file = g_strdup(purple_prefs_get_path(filepref));
g_free(filepref);
if (event->label == NULL) {
continue;
}
boolpref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/enabled/%s", profile, event->pref);
gnt_tree_change_text(GNT_TREE(pref_dialog->events), GINT_TO_POINTER(i), 0, event->label);
gnt_tree_change_text(GNT_TREE(pref_dialog->events), GINT_TO_POINTER(i), 1,
event->file[0] ? (basename = g_path_get_basename(event->file)) : _("(default)"));
g_free(basename);
gnt_tree_set_choice(GNT_TREE(pref_dialog->events), GINT_TO_POINTER(i), purple_prefs_get_bool(boolpref));
g_free(boolpref);
}
gnt_tree_set_selected(GNT_TREE(pref_dialog->profiles), (gchar *)finch_sound_get_active_profile());
gnt_widget_draw(pref_dialog->window);
}
static void
im_recv_im(PurpleAccount *account, char *who, char *what,
PurpleConversation * conv, PurpleMessageFlags flags)
{
int wasPlaying = 0;
if(system("dbus-send --print-reply --dest=net.kevinmehall.Pithos /net/kevinmehall/Pithos net.kevinmehall.Pithos.IsPlaying")){
wasPlaying = 1;
system("dbus-send --print-reply --dest=net.kevinmehall.Pithos /net/kevinmehall/Pithos net.kevinmehall.Pithos.PlayPause");
}
char *stripped;
const char *alias = get_best_name(account, who);
silent_joins = NULL;
GString *buffer= g_string_new("");
/* msg_utf8=purple_utf8_try_convert(what) */
stripped = (char *)purple_markup_strip_html(/*msg_utf8?msg_utf8:*/what);
if(purple_prefs_get_bool("/plugins/gtk/festival/speaker/replace_url"))
stripped = unlinkify_text(stripped);
if (strlen(stripped) <= purple_prefs_get_int("/plugins/gtk/festival/speaker/maxlength")) {
if(purple_prefs_get_bool("/plugins/gtk/festival/speaker/prepend_who") &&
strcmp(alias, prev_alias))
g_string_printf(buffer,"%s %s %s", alias, _("says"), stripped);
else
g_string_printf(buffer,"%s", stripped);
strcpy(prev_alias, alias);
speak(buffer);
} else {
g_string_printf(buffer, "message overflow");
speak(buffer);
}
g_free(stripped);
/* if (msg_utf8) g_free(msg_utf8); */
g_string_free(buffer,TRUE);
if(wasPlaying==1 && !system("dbus-send --print-reply --dest=net.kevinmehall.Pithos /net/kevinmehall/Pithos net.kevinmehall.Pithos.IsPlaying")){
sleep(5);
system("dbus-send --print-reply --dest=net.kevinmehall.Pithos /net/kevinmehall/Pithos net.kevinmehall.Pithos.PlayPause");
}
}
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;
}
}
static void
conv_updated_cb(PurpleConversation *conv, PurpleConvUpdateType type) {
PidginConversation *pconv = PIDGIN_CONVERSATION(conv);
PidginWindow *win = pidgin_conv_get_window(pconv);
if (type == PURPLE_CONV_UPDATE_UNSEEN && !pidgin_conv_is_hidden(pconv)
&& pconv->unseen_state == PIDGIN_UNSEEN_NONE
&& pidgin_conv_window_get_gtkconv_count(win) == 1) {
GtkWidget *window = win->window;
gboolean has_focus;
g_object_get(G_OBJECT(window), "has-toplevel-focus", &has_focus, NULL);
if (!has_focus || !purple_prefs_get_bool(OPT_WINTRANS_IM_ONFOCUS))
set_conv_window_trans(NULL, win);
if (g_signal_handler_find(G_OBJECT(window), G_SIGNAL_MATCH_FUNC,
0, 0, NULL, G_CALLBACK(focus_conv_win_cb), NULL) == 0) {
g_signal_connect(G_OBJECT(window), "focus_in_event",
G_CALLBACK(focus_conv_win_cb), window);
g_signal_connect(G_OBJECT(window), "focus_out_event",
G_CALLBACK(focus_conv_win_cb), window);
}
}
}
/**************************************************************************************************
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;
}
void
otrg_prefs_global_load(gboolean *enabledp, gboolean *automaticp,
gboolean *onlyprivatep, gboolean *avoidloggingp)
{
if (purple_prefs_exists("/OTR/enabled")) {
*enabledp = purple_prefs_get_bool("/OTR/enabled");
*automaticp = purple_prefs_get_bool("/OTR/automatic");
*onlyprivatep = purple_prefs_get_bool("/OTR/onlyprivate");
*avoidloggingp = purple_prefs_get_bool("/OTR/avoidloggingotr");
} else {
*enabledp = TRUE;
*automaticp = TRUE;
*onlyprivatep = FALSE;
*avoidloggingp = TRUE;
}
}
/* When buddy list window is focused,
* if we're only transparent when unfocused, deal with transparency */
static gboolean focus_blist_win_cb(GtkWidget *w, GdkEventFocus *e, gpointer d) {
if (purple_prefs_get_bool(OPT_WINTRANS_BL_ENABLED)
&& purple_prefs_get_bool(OPT_WINTRANS_BL_ONFOCUS)) {
GtkWidget *window = (GtkWidget *) d;
if (e->in) { /* Focused */
set_wintrans(window, 0, FALSE,
purple_prefs_get_bool(OPT_WINTRANS_BL_ONTOP));
} else {
set_wintrans(window,
purple_prefs_get_int(OPT_WINTRANS_BL_ALPHA),
TRUE,
purple_prefs_get_bool(OPT_WINTRANS_BL_ONTOP));
}
}
return FALSE;
}
static void
received_im_msg(PurpleAccount *account, const char *sender, const char *msg,
PurpleIMConversation *im, PurpleMessageFlags flags, gpointer null)
{
if (purple_prefs_get_bool(PREFS_EVENT_IM_MSG))
notify(PURPLE_CONVERSATION(im), _("%s sent you a message"), sender);
}
static gboolean should_hide_notice(PurpleConversation *conv, const char *name,
GHashTable *users)
{
PurpleConvChat *chat;
int threshold;
struct joinpart_key key;
time_t *last_said;
g_return_val_if_fail(conv != NULL, FALSE);
g_return_val_if_fail(purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT, FALSE);
/* If the room is small, don't bother. */
chat = PURPLE_CONV_CHAT(conv);
threshold = purple_prefs_get_int(THRESHOLD_PREF);
if (g_list_length(purple_conv_chat_get_users(chat)) < threshold)
return FALSE;
if (!purple_prefs_get_bool(HIDE_BUDDIES_PREF) &&
purple_find_buddy(purple_conversation_get_account(conv), name))
return FALSE;
/* Only show the notice if the user has spoken recently. */
key.conv = conv;
key.user = (gchar *)name;
last_said = g_hash_table_lookup(users, &key);
if (last_said != NULL)
{
int delay = purple_prefs_get_int(DELAY_PREF);
if (delay > 0 && (*last_said + (delay * 60)) >= time(NULL))
return FALSE;
}
return TRUE;
}
static void
conv_switched(PurpleConversation *conv)
{
#if 0
PidginWindow *purplewin = purple_conversation_get_window(new_conv);
#endif
/*
* If the conversation was switched, then make sure we re-notify
* because Purple will have overwritten our custom window title.
*/
notify(conv, FALSE);
#if 0
printf("conv_switched - %p - %p\n", old_conv, new_conv);
printf("count - %d\n", count_messages(purplewin));
if (purple_prefs_get_bool("/plugins/gtk/X11/notify/notify_switch"))
unnotify(new_conv, FALSE);
else {
/* if we don't have notification on the window then we don't want to
* re-notify it */
if (count_messages(purplewin))
notify_win(purplewin);
}
#endif
}
static void
finch_sound_play_event(PurpleSoundEventID event)
{
char *enable_pref;
char *file_pref;
if ((event == PURPLE_SOUND_BUDDY_ARRIVE) && mute_login_sounds)
return;
if (event >= PURPLE_NUM_SOUNDS ||
event >= G_N_ELEMENTS(sounds)) {
purple_debug_error("sound", "got request for unknown sound: %d\n", event);
return;
}
enable_pref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/enabled/%s",
finch_sound_get_active_profile(),
sounds[event].pref);
file_pref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/file/%s", finch_sound_get_active_profile(), sounds[event].pref);
/* check NULL for sounds that don't have an option, ie buddy pounce */
if (purple_prefs_get_bool(enable_pref)) {
char *filename = g_strdup(purple_prefs_get_path(file_pref));
if (!filename || !strlen(filename)) {
g_free(filename);
/* XXX Consider creating a constant for "sounds/purple" to be shared with Pidgin */
filename = g_build_filename(DATADIR, "sounds", "purple", sounds[event].def, NULL);
}
purple_sound_play_file(filename, NULL);
g_free(filename);
}
g_free(enable_pref);
g_free(file_pref);
}
static void
test_cb(GntWidget *button, gpointer null)
{
PurpleSoundEventID id = GPOINTER_TO_INT(gnt_tree_get_selection_data(GNT_TREE(pref_dialog->events)));
FinchSoundEvent * event = &sounds[id];
char *enabled, *file, *tmpfile, *volpref;
gboolean temp_value;
int volume;
enabled = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/enabled/%s",
finch_sound_get_active_profile(), event->pref);
file = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/file/%s",
finch_sound_get_active_profile(), event->pref);
volpref = g_strdup(make_pref("/volume"));
temp_value = purple_prefs_get_bool(enabled);
tmpfile = g_strdup(purple_prefs_get_path(file));
volume = purple_prefs_get_int(volpref);
purple_prefs_set_path(file, event->file);
if (!temp_value) purple_prefs_set_bool(enabled, TRUE);
purple_prefs_set_int(volpref, gnt_slider_get_value(GNT_SLIDER(pref_dialog->volume)));
purple_sound_play_event(id, NULL);
if (!temp_value) purple_prefs_set_bool(enabled, FALSE);
purple_prefs_set_path(file, tmpfile);
purple_prefs_set_int(volpref, volume);
g_free(enabled);
g_free(file);
g_free(tmpfile);
g_free(volpref);
}
/* someone wants to add you to his buddy list */
static void server_buddy_add_request(PurpleConnection *gc, gchar *from, gchar *to,
guint8 *data, gint data_len)
{
guint32 uid;
gchar *msg, *reason;
g_return_if_fail(from != NULL && to != NULL);
uid = strtoul(from, NULL, 10);
g_return_if_fail(uid != 0);
if (purple_prefs_get_bool("/plugins/prpl/qq/auto_get_authorize_info")) {
qq_request_buddy_info(gc, uid, 0, QQ_BUDDY_INFO_DISPLAY);
}
if (data_len <= 0) {
reason = g_strdup( _("No reason given") );
} else {
msg = g_strndup((gchar *)data, data_len);
reason = qq_to_utf8(msg, QQ_CHARSET_DEFAULT);
if (reason == NULL) reason = g_strdup( _("Unknown reason") );
g_free(msg);
}
buddy_add_input(gc, uid, reason);
g_free(reason);
}
static void
blist_created_cb(PurpleBuddyList *purple_blist, gpointer data) {
if (blist) {
if (purple_prefs_get_bool(OPT_WINTRANS_BL_ENABLED)) {
set_wintrans(blist,
purple_prefs_get_int(OPT_WINTRANS_BL_ALPHA),
TRUE,
purple_prefs_get_bool(OPT_WINTRANS_BL_ONTOP));
}
g_signal_connect(G_OBJECT(blist), "focus_in_event",
G_CALLBACK(focus_blist_win_cb), blist);
g_signal_connect(G_OBJECT(blist), "focus_out_event",
G_CALLBACK(focus_blist_win_cb), blist);
}
}
/** Eventually ask for a custom capture name when sending :
- as file
- to a remote FTP server
*/
void
screenshot_maybe_rename (PurplePlugin * plugin, gchar ** basename) {
g_assert (plugin != NULL && plugin->extra != NULL);
if (purple_prefs_get_bool (PREF_ASK_FILENAME) &&
(PLUGIN (send_as) == SEND_AS_FILE
#ifdef ENABLE_UPLOAD
|| PLUGIN (send_as) == SEND_AS_FTP_LINK)
#else
)
#endif
) {
GtkWidget *dlgbox_rename = NULL;
gint result = 0;
dlgbox_rename = capture_rename (plugin, *basename);
result = gtk_dialog_run (GTK_DIALOG (dlgbox_rename));
if (result == GTK_RESPONSE_OK) {
GtkWidget *entry = NULL;
entry = g_object_get_data (G_OBJECT (dlgbox_rename), "entry");
g_free (*basename);
*basename = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
}
gtk_widget_destroy (dlgbox_rename);
}
}
static void buddy_add_input(PurpleConnection *gc, guint32 uid, gchar *reason)
{
PurpleAccount *account = purple_connection_get_account(gc);
qq_buddy_req *add_req;
gchar *who;
g_return_if_fail(uid != 0 && reason != NULL);
purple_debug_info("QQ", "Buddy %u request adding, msg: %s\n", uid, reason);
add_req = g_new0(qq_buddy_req, 1);
add_req->gc = gc;
add_req->uid = uid;
if (purple_prefs_get_bool("/plugins/prpl/qq/auto_get_authorize_info")) {
qq_request_buddy_info(gc, add_req->uid, 0, QQ_BUDDY_INFO_DISPLAY);
}
who = uid_to_purple_name(add_req->uid);
purple_account_request_authorization(account,
who, NULL,
NULL, reason,
purple_find_buddy(account, who) != NULL,
buddy_add_authorize_cb,
buddy_add_deny_cb,
add_req);
g_free(who);
}
