pidgin/pidgin
Clone
Summary
Browse
Changes
Graph
Use Meson summary() function.
2021-07-27, Elliott Sales de Andrade
cb640ea0f315
Use Meson summary() function.
Now that we require at least 0.52, we can use Meson's builtin summary printing to display the results of configuration.
Testing Done:
Configured with defaults, and with pixmaps disabled to trigger the warning: https://asciinema.org/a/mV2oxOoVCJNdmrPwgqqUJ3mkU?t=17
Reviewed at https://reviews.imfreedom.org/r/848/
/*
* Pidgin - Transparency plugin
*
* Copyright (C) 1998-2002, Rob Flynn <rob@marko.net>
* Copyright (C) 2002-2003, Herman Bloggs <hermanator12002@yahoo.com>
* Copyright (C) 2005, Daniel Atallah <daniel_atallah@yahoo.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02111-1301, USA.
*
*/
#include
<glib.h>
#include
<glib/gi18n-lib.h>
#include
<purple.h>
#include
<gplugin.h>
#include
<gplugin-native.h>
#include
<pidgin.h>
/*
* MACROS & DEFINES
*/
/* The plugin name is left unchanged from its WinAPI days in order to keep it
* loading for users who were using it. */
#define WINTRANS_PLUGIN_ID "gtk-win-trans"
/*
* DATA STRUCTS
*/
typedef
struct
{
GtkWidget
*
win
;
GtkWidget
*
slider
;
}
slider_win
;
/*
* LOCALS
*/
static
const
char
*
OPT_WINTRANS_IM_ENABLED
=
"/plugins/gtk/transparency/im_enabled"
;
static
const
char
*
OPT_WINTRANS_IM_ALPHA
=
"/plugins/gtk/transparency/im_alpha"
;
static
const
char
*
OPT_WINTRANS_IM_SLIDER
=
"/plugins/gtk/transparency/im_slider"
;
static
const
char
*
OPT_WINTRANS_IM_ONFOCUS
=
"/plugins/gtk/transparency/im_solid_onfocus"
;
static
const
char
*
OPT_WINTRANS_IM_ONTOP
=
"/plugins/gtk/transparency/im_always_on_top"
;
static
const
char
*
OPT_WINTRANS_BL_ENABLED
=
"/plugins/gtk/transparency/bl_enabled"
;
static
const
char
*
OPT_WINTRANS_BL_ALPHA
=
"/plugins/gtk/transparency/bl_alpha"
;
static
const
char
*
OPT_WINTRANS_BL_ONFOCUS
=
"/plugins/gtk/transparency/bl_solid_onfocus"
;
static
const
char
*
OPT_WINTRANS_BL_ONTOP
=
"/plugins/gtk/transparency/bl_always_on_top"
;
static
GSList
*
window_list
=
NULL
;
/*
* CODE
*/
static
GtkWidget
*
get_buddy_list_window
(
void
)
{
PurpleBuddyList
*
purple_blist
=
NULL
;
purple_blist
=
purple_blist_get_default
();
if
(
PIDGIN_IS_BUDDY_LIST
(
purple_blist
))
{
PidginBuddyList
*
pidgin_blist
=
PIDGIN_BUDDY_LIST
(
purple_blist
);
return
pidgin_blist
->
window
;
}
return
NULL
;
}
/* Set window transparency level */
static
void
set_wintrans
(
GtkWidget
*
window
,
int
alpha
,
gboolean
enabled
,
gboolean
always_on_top
)
{
GdkWindow
*
gdk_window
=
gtk_widget_get_window
(
window
);
if
(
enabled
)
{
gdk_window_set_opacity
(
gdk_window
,
alpha
/
255.0
);
gdk_window_set_keep_above
(
gdk_window
,
always_on_top
);
}
else
{
gdk_window_set_opacity
(
gdk_window
,
1
);
gdk_window_set_keep_above
(
gdk_window
,
0
);
}
}
/* When a conv window is focused, if we're only transparent when unfocused,
* deal with transparency */
static
gboolean
focus_conv_win_cb
(
GtkWidget
*
w
,
GdkEventFocus
*
e
,
gpointer
d
)
{
if
(
purple_prefs_get_bool
(
OPT_WINTRANS_IM_ENABLED
)
&&
purple_prefs_get_bool
(
OPT_WINTRANS_IM_ONFOCUS
))
{
GtkWidget
*
window
=
(
GtkWidget
*
)
d
;
if
(
e
->
in
)
{
/* Focused */
set_wintrans
(
window
,
0
,
FALSE
,
purple_prefs_get_bool
(
OPT_WINTRANS_IM_ONTOP
));
}
else
{
set_wintrans
(
window
,
purple_prefs_get_int
(
OPT_WINTRANS_IM_ALPHA
),
TRUE
,
purple_prefs_get_bool
(
OPT_WINTRANS_IM_ONTOP
));
}
}
return
FALSE
;
}
/* 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
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
GtkWidget
*
wintrans_slider
(
GtkWidget
*
win
)
{
GtkWidget
*
hbox
;
GtkWidget
*
label
,
*
slider
;
GtkWidget
*
frame
;
int
imalpha
=
purple_prefs_get_int
(
OPT_WINTRANS_IM_ALPHA
);
frame
=
gtk_frame_new
(
NULL
);
gtk_frame_set_shadow_type
(
GTK_FRAME
(
frame
),
GTK_SHADOW_NONE
);
gtk_widget_show
(
frame
);
hbox
=
gtk_box_new
(
GTK_ORIENTATION_HORIZONTAL
,
5
);
gtk_container_add
(
GTK_CONTAINER
(
frame
),
hbox
);
label
=
gtk_label_new
(
_
(
"Opacity:"
));
gtk_box_pack_start
(
GTK_BOX
(
hbox
),
label
,
FALSE
,
FALSE
,
5
);
gtk_widget_show
(
hbox
);
slider
=
gtk_scale_new_with_range
(
GTK_ORIENTATION_HORIZONTAL
,
50
,
255
,
1
);
gtk_range_set_value
(
GTK_RANGE
(
slider
),
imalpha
);
/* On slider val change, update window's transparency level */
g_signal_connect
(
G_OBJECT
(
slider
),
"value-changed"
,
G_CALLBACK
(
change_alpha
),
win
);
gtk_box_pack_start
(
GTK_BOX
(
hbox
),
slider
,
FALSE
,
TRUE
,
5
);
/* Set the initial transparency level */
set_wintrans
(
win
,
imalpha
,
TRUE
,
purple_prefs_get_bool
(
OPT_WINTRANS_IM_ONTOP
));
gtk_widget_show_all
(
hbox
);
return
frame
;
}
static
slider_win
*
find_slidwin
(
GtkWidget
*
win
)
{
GSList
*
tmp
=
window_list
;
while
(
tmp
)
{
if
(((
slider_win
*
)
(
tmp
->
data
))
->
win
==
win
)
return
(
slider_win
*
)
tmp
->
data
;
tmp
=
tmp
->
next
;
}
return
NULL
;
}
/* Clean up transparency stuff for the conv window */
static
void
cleanup_conv_window
(
PidginConvWindow
*
win
)
{
GtkWidget
*
window
=
win
->
window
;
slider_win
*
slidwin
=
NULL
;
/* Remove window from the window list */
purple_debug_info
(
WINTRANS_PLUGIN_ID
,
"Conv window destroyed... removing from list
\n
"
);
if
((
slidwin
=
find_slidwin
(
window
)))
{
window_list
=
g_slist_remove
(
window_list
,
slidwin
);
g_free
(
slidwin
);
}
/* Remove the focus cbs */
g_signal_handlers_disconnect_by_func
(
G_OBJECT
(
window
),
G_CALLBACK
(
focus_conv_win_cb
),
window
);
}
static
void
conversation_delete_cb
(
PurpleConversation
*
conv
)
{
PidginConvWindow
*
win
=
pidgin_conv_get_window
(
PIDGIN_CONVERSATION
(
conv
));
/* If it is the last conversation in the window, cleanup */
if
(
win
!=
NULL
&&
pidgin_conv_window_get_gtkconv_count
(
win
)
==
1
)
cleanup_conv_window
(
win
);
}
static
void
set_blist_trans
(
GtkWidget
*
w
,
const
char
*
pref
)
{
GtkWidget
*
window
=
get_buddy_list_window
();
gboolean
enabled
=
gtk_toggle_button_get_active
(
GTK_TOGGLE_BUTTON
(
w
));
purple_prefs_set_bool
(
pref
,
enabled
);
if
(
window
!=
NULL
)
{
set_wintrans
(
window
,
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
void
add_slider
(
GtkWidget
*
win
)
{
GList
*
wl
,
*
wl1
;
GtkWidget
*
vbox
=
NULL
;
/* Look up this window to see if it already has a slider */
if
(
!
find_slidwin
(
win
))
{
GtkWidget
*
slider_box
=
NULL
;
slider_win
*
slidwin
=
NULL
;
/* Get top vbox */
for
(
wl1
=
wl
=
gtk_container_get_children
(
GTK_CONTAINER
(
win
));
wl
!=
NULL
;
wl
=
wl
->
next
)
{
if
(
GTK_IS_BOX
(
G_OBJECT
(
wl
->
data
)))
vbox
=
GTK_WIDGET
(
wl
->
data
);
else
{
purple_debug_error
(
WINTRANS_PLUGIN_ID
,
"no vbox found
\n
"
);
return
;
}
}
g_list_free
(
wl1
);
slider_box
=
wintrans_slider
(
win
);
gtk_box_pack_start
(
GTK_BOX
(
vbox
),
slider_box
,
FALSE
,
FALSE
,
0
);
/* Add window to list, to track that it has a slider */
slidwin
=
g_new0
(
slider_win
,
1
);
slidwin
->
win
=
win
;
slidwin
->
slider
=
slider_box
;
window_list
=
g_slist_append
(
window_list
,
slidwin
);
}
}
static
void
remove_sliders
()
{
if
(
window_list
)
{
GSList
*
tmp
=
window_list
;
while
(
tmp
)
{
slider_win
*
slidwin
=
(
slider_win
*
)
tmp
->
data
;
if
(
slidwin
!=
NULL
&&
GTK_IS_WINDOW
(
slidwin
->
win
))
{
gtk_widget_destroy
(
slidwin
->
slider
);
}
g_free
(
slidwin
);
tmp
=
tmp
->
next
;
}
g_slist_free
(
window_list
);
window_list
=
NULL
;
}
}
/* Remove all transparency related aspects from conversation windows */
static
void
remove_convs_wintrans
(
gboolean
remove_signal
)
{
GList
*
wins
;
for
(
wins
=
pidgin_conv_windows_get_list
();
wins
;
wins
=
wins
->
next
)
{
PidginConvWindow
*
win
=
wins
->
data
;
GtkWidget
*
window
=
win
->
window
;
if
(
purple_prefs_get_bool
(
OPT_WINTRANS_IM_ENABLED
))
set_wintrans
(
window
,
0
,
FALSE
,
FALSE
);
/* Remove the focus cbs */
if
(
remove_signal
)
g_signal_handlers_disconnect_by_func
(
G_OBJECT
(
window
),
G_CALLBACK
(
focus_conv_win_cb
),
window
);
}
remove_sliders
();
}
static
void
set_conv_window_trans
(
PidginConvWindow
*
oldwin
,
PidginConvWindow
*
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
);
}
}
static
void
update_convs_wintrans
(
GtkWidget
*
toggle_btn
,
const
char
*
pref
)
{
purple_prefs_set_bool
(
pref
,
gtk_toggle_button_get_active
(
GTK_TOGGLE_BUTTON
(
toggle_btn
)));
if
(
purple_prefs_get_bool
(
OPT_WINTRANS_IM_ENABLED
))
{
GList
*
wins
;
for
(
wins
=
pidgin_conv_windows_get_list
();
wins
;
wins
=
wins
->
next
)
{
PidginConvWindow
*
win
=
wins
->
data
;
set_conv_window_trans
(
NULL
,
win
);
}
if
(
!
purple_prefs_get_bool
(
OPT_WINTRANS_IM_SLIDER
))
remove_sliders
();
}
else
remove_convs_wintrans
(
FALSE
);
}
static
void
conv_updated_cb
(
PurpleConversation
*
conv
,
PurpleConversationUpdateType
type
)
{
PidginConversation
*
pconv
=
PIDGIN_CONVERSATION
(
conv
);
PidginConvWindow
*
win
=
pidgin_conv_get_window
(
pconv
);
if
(
type
==
PURPLE_CONVERSATION_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
);
}
}
}
static
void
new_conversation_cb
(
PurpleConversation
*
conv
)
{
PidginConvWindow
*
win
=
pidgin_conv_get_window
(
PIDGIN_CONVERSATION
(
conv
));
/* If it is the first conversation in the window,
* add the sliders, and set transparency */
if
(
!
pidgin_conv_is_hidden
(
PIDGIN_CONVERSATION
(
conv
))
&&
pidgin_conv_window_get_gtkconv_count
(
win
)
==
1
)
{
GtkWidget
*
window
=
win
->
window
;
set_conv_window_trans
(
NULL
,
win
);
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
);
}
}
static
void
blist_created_cb
(
PurpleBuddyList
*
purple_blist
,
gpointer
data
)
{
GtkWidget
*
window
=
get_buddy_list_window
();
if
(
window
!=
NULL
)
{
if
(
purple_prefs_get_bool
(
OPT_WINTRANS_BL_ENABLED
))
{
set_wintrans
(
window
,
purple_prefs_get_int
(
OPT_WINTRANS_BL_ALPHA
),
TRUE
,
purple_prefs_get_bool
(
OPT_WINTRANS_BL_ONTOP
));
}
g_signal_connect
(
G_OBJECT
(
window
),
"focus_in_event"
,
G_CALLBACK
(
focus_blist_win_cb
),
window
);
g_signal_connect
(
G_OBJECT
(
window
),
"focus_out_event"
,
G_CALLBACK
(
focus_blist_win_cb
),
window
);
}
}
static
void
alpha_change
(
GtkWidget
*
w
,
gpointer
data
)
{
GList
*
wins
;
int
imalpha
=
gtk_range_get_value
(
GTK_RANGE
(
w
));
for
(
wins
=
pidgin_conv_windows_get_list
();
wins
;
wins
=
wins
->
next
)
{
PidginConvWindow
*
win
=
wins
->
data
;
set_wintrans
(
win
->
window
,
imalpha
,
TRUE
,
purple_prefs_get_bool
(
OPT_WINTRANS_IM_ONTOP
));
}
}
static
void
alpha_pref_set_int
(
GtkWidget
*
w
,
GdkEventFocus
*
e
,
const
char
*
pref
)
{
int
alpha
=
gtk_range_get_value
(
GTK_RANGE
(
w
));
purple_prefs_set_int
(
pref
,
alpha
);
}
static
void
bl_alpha_change
(
GtkWidget
*
w
,
gpointer
data
)
{
GtkWidget
*
window
=
get_buddy_list_window
();
if
(
window
!=
NULL
)
{
change_alpha
(
w
,
window
);
}
}
static
void
update_existing_convs
()
{
GList
*
wins
;
for
(
wins
=
pidgin_conv_windows_get_list
();
wins
;
wins
=
wins
->
next
)
{
PidginConvWindow
*
win
=
wins
->
data
;
GtkWidget
*
window
=
win
->
window
;
set_conv_window_trans
(
NULL
,
win
);
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
);
}
}
static
GtkWidget
*
get_config_frame
(
PurplePlugin
*
plugin
)
{
GtkWidget
*
ret
;
GtkWidget
*
imtransbox
,
*
bltransbox
;
GtkWidget
*
hbox
;
GtkWidget
*
label
,
*
slider
;
GtkWidget
*
button
;
GtkWidget
*
trans_box
;
ret
=
gtk_box_new
(
GTK_ORIENTATION_VERTICAL
,
18
);
gtk_container_set_border_width
(
GTK_CONTAINER
(
ret
),
12
);
/* IM Convo trans options */
imtransbox
=
pidgin_make_frame
(
ret
,
_
(
"IM Conversation Windows"
));
button
=
pidgin_prefs_checkbox
(
_
(
"_IM window transparency"
),
OPT_WINTRANS_IM_ENABLED
,
imtransbox
);
g_signal_connect
(
G_OBJECT
(
button
),
"clicked"
,
G_CALLBACK
(
update_convs_wintrans
),
(
gpointer
)
OPT_WINTRANS_IM_ENABLED
);
trans_box
=
gtk_box_new
(
GTK_ORIENTATION_VERTICAL
,
18
);
gtk_widget_show
(
trans_box
);
g_object_bind_property
(
button
,
"active"
,
trans_box
,
"sensitive"
,
G_BINDING_SYNC_CREATE
);
button
=
pidgin_prefs_checkbox
(
_
(
"_Show slider bar in IM window"
),
OPT_WINTRANS_IM_SLIDER
,
trans_box
);
g_signal_connect
(
G_OBJECT
(
button
),
"clicked"
,
G_CALLBACK
(
update_convs_wintrans
),
(
gpointer
)
OPT_WINTRANS_IM_SLIDER
);
button
=
pidgin_prefs_checkbox
(
_
(
"Remove IM window transparency on focus"
),
OPT_WINTRANS_IM_ONFOCUS
,
trans_box
);
button
=
pidgin_prefs_checkbox
(
_
(
"Always on top"
),
OPT_WINTRANS_IM_ONTOP
,
trans_box
);
g_signal_connect
(
G_OBJECT
(
button
),
"clicked"
,
G_CALLBACK
(
update_convs_wintrans
),
(
gpointer
)
OPT_WINTRANS_IM_ONTOP
);
gtk_box_pack_start
(
GTK_BOX
(
imtransbox
),
trans_box
,
FALSE
,
FALSE
,
5
);
/* IM transparency slider */
hbox
=
gtk_box_new
(
GTK_ORIENTATION_HORIZONTAL
,
5
);
label
=
gtk_label_new
(
_
(
"Opacity:"
));
gtk_box_pack_start
(
GTK_BOX
(
hbox
),
label
,
FALSE
,
FALSE
,
5
);
slider
=
gtk_scale_new_with_range
(
GTK_ORIENTATION_HORIZONTAL
,
50
,
255
,
1
);
gtk_range_set_value
(
GTK_RANGE
(
slider
),
purple_prefs_get_int
(
OPT_WINTRANS_IM_ALPHA
));
g_signal_connect
(
G_OBJECT
(
slider
),
"value-changed"
,
G_CALLBACK
(
alpha_change
),
NULL
);
g_signal_connect
(
G_OBJECT
(
slider
),
"focus-out-event"
,
G_CALLBACK
(
alpha_pref_set_int
),
(
gpointer
)
OPT_WINTRANS_IM_ALPHA
);
gtk_box_pack_start
(
GTK_BOX
(
hbox
),
slider
,
FALSE
,
TRUE
,
5
);
gtk_widget_show_all
(
hbox
);
gtk_box_pack_start
(
GTK_BOX
(
trans_box
),
hbox
,
FALSE
,
FALSE
,
5
);
/* Buddy List trans options */
bltransbox
=
pidgin_make_frame
(
ret
,
_
(
"Buddy List Window"
));
button
=
pidgin_prefs_checkbox
(
_
(
"_Buddy List window transparency"
),
OPT_WINTRANS_BL_ENABLED
,
bltransbox
);
g_signal_connect
(
G_OBJECT
(
button
),
"clicked"
,
G_CALLBACK
(
set_blist_trans
),
(
gpointer
)
OPT_WINTRANS_BL_ENABLED
);
trans_box
=
gtk_box_new
(
GTK_ORIENTATION_VERTICAL
,
18
);
gtk_widget_show
(
trans_box
);
g_object_bind_property
(
button
,
"active"
,
trans_box
,
"sensitive"
,
G_BINDING_SYNC_CREATE
);
button
=
pidgin_prefs_checkbox
(
_
(
"Remove Buddy List window transparency on focus"
),
OPT_WINTRANS_BL_ONFOCUS
,
trans_box
);
button
=
pidgin_prefs_checkbox
(
_
(
"Always on top"
),
OPT_WINTRANS_BL_ONTOP
,
trans_box
);
g_signal_connect
(
G_OBJECT
(
button
),
"clicked"
,
G_CALLBACK
(
set_blist_trans
),
(
gpointer
)
OPT_WINTRANS_BL_ONTOP
);
gtk_box_pack_start
(
GTK_BOX
(
bltransbox
),
trans_box
,
FALSE
,
FALSE
,
5
);
/* IM transparency slider */
hbox
=
gtk_box_new
(
GTK_ORIENTATION_HORIZONTAL
,
5
);
label
=
gtk_label_new
(
_
(
"Opacity:"
));
gtk_box_pack_start
(
GTK_BOX
(
hbox
),
label
,
FALSE
,
FALSE
,
5
);
slider
=
gtk_scale_new_with_range
(
GTK_ORIENTATION_HORIZONTAL
,
50
,
255
,
1
);
gtk_range_set_value
(
GTK_RANGE
(
slider
),
purple_prefs_get_int
(
OPT_WINTRANS_BL_ALPHA
));
g_signal_connect
(
G_OBJECT
(
slider
),
"value-changed"
,
G_CALLBACK
(
bl_alpha_change
),
NULL
);
g_signal_connect
(
G_OBJECT
(
slider
),
"focus-out-event"
,
G_CALLBACK
(
alpha_pref_set_int
),
(
gpointer
)
OPT_WINTRANS_BL_ALPHA
);
gtk_box_pack_start
(
GTK_BOX
(
hbox
),
slider
,
FALSE
,
TRUE
,
5
);
gtk_widget_show_all
(
hbox
);
gtk_box_pack_start
(
GTK_BOX
(
trans_box
),
hbox
,
FALSE
,
FALSE
,
5
);
gtk_widget_show_all
(
ret
);
return
ret
;
}
static
GPluginPluginInfo
*
transparency_query
(
GError
**
error
)
{
const
gchar
*
const
authors
[]
=
{
"Pidgin Developers <devel@pidgin.im>"
,
NULL
};
return
pidgin_plugin_info_new
(
"id"
,
WINTRANS_PLUGIN_ID
,
"name"
,
N_
(
"Transparency"
),
"version"
,
DISPLAY_VERSION
,
"category"
,
N_
(
"User interface"
),
"summary"
,
N_
(
"Variable Transparency for the buddy list and conversations."
),
"description"
,
N_
(
"This plugin enables variable alpha transparency on conversation windows and the buddy list."
),
"authors"
,
authors
,
"website"
,
PURPLE_WEBSITE
,
"abi-version"
,
PURPLE_ABI_VERSION
,
"gtk-config-frame-cb"
,
get_config_frame
,
NULL
);
}
static
gboolean
transparency_load
(
GPluginPlugin
*
plugin
,
GError
**
error
)
{
GtkWidget
*
window
=
NULL
;
gpointer
conv_handle
=
NULL
;
purple_prefs_add_none
(
"/plugins/gtk"
);
purple_prefs_add_none
(
"/plugins/gtk/transparency"
);
purple_prefs_add_bool
(
OPT_WINTRANS_IM_ENABLED
,
FALSE
);
purple_prefs_add_int
(
OPT_WINTRANS_IM_ALPHA
,
255
);
purple_prefs_add_bool
(
OPT_WINTRANS_IM_SLIDER
,
FALSE
);
purple_prefs_add_bool
(
OPT_WINTRANS_IM_ONFOCUS
,
FALSE
);
purple_prefs_add_bool
(
OPT_WINTRANS_IM_ONTOP
,
FALSE
);
purple_prefs_add_bool
(
OPT_WINTRANS_BL_ENABLED
,
FALSE
);
purple_prefs_add_int
(
OPT_WINTRANS_BL_ALPHA
,
255
);
purple_prefs_add_bool
(
OPT_WINTRANS_BL_ONFOCUS
,
FALSE
);
purple_prefs_add_bool
(
OPT_WINTRANS_BL_ONTOP
,
FALSE
);
purple_prefs_rename
(
"/plugins/gtk/win32/wintrans"
,
"/plugins/gtk/transparency"
);
conv_handle
=
purple_conversations_get_handle
();
purple_signal_connect
(
conv_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
(
conv_handle
,
"deleting-conversation"
,
plugin
,
PURPLE_CALLBACK
(
conversation_delete_cb
),
NULL
);
purple_signal_connect
(
conv_handle
,
"conversation-dragging"
,
plugin
,
PURPLE_CALLBACK
(
set_conv_window_trans
),
NULL
);
purple_signal_connect
(
conv_handle
,
"conversation-updated"
,
plugin
,
PURPLE_CALLBACK
(
conv_updated_cb
),
NULL
);
update_existing_convs
();
window
=
get_buddy_list_window
();
if
(
window
!=
NULL
)
{
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
transparency_unload
(
GPluginPlugin
*
plugin
,
GError
**
error
)
{
GtkWidget
*
window
=
NULL
;
purple_debug_info
(
WINTRANS_PLUGIN_ID
,
"Unloading transparency plugin
\n
"
);
remove_convs_wintrans
(
TRUE
);
window
=
get_buddy_list_window
();
if
(
window
!=
NULL
)
{
if
(
purple_prefs_get_bool
(
OPT_WINTRANS_BL_ENABLED
))
set_wintrans
(
window
,
0
,
FALSE
,
FALSE
);
/* Remove the focus cbs */
g_signal_handlers_disconnect_by_func
(
G_OBJECT
(
window
),
G_CALLBACK
(
focus_blist_win_cb
),
window
);
}
return
TRUE
;
}
GPLUGIN_NATIVE_PLUGIN_DECLARE
(
transparency
)