pidgin/pidgin
Clone
Summary
Browse
Changes
Graph
Remove the deprecated keyring API.
2021-04-21, Gary Kramlich
32c1f097d4e8
Remove the deprecated keyring API.
I've disable the building of the internal keyring for now but left it so it
can be referenced when it is ported to the CredentialProvider API.
Testing Done:
Ran Pidgin and verified the preferences window worked.
Bugs closed: PIDGIN-17486
Reviewed at https://reviews.imfreedom.org/r/624/
/*
* 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
"internal.h"
#include
<purple.h>
#include
"gtkconv.h"
#include
"gtkplugin.h"
#include
"gtkprefs.h"
#include
"gtkblist.h"
#include
"gtkutils.h"
#include
"signals.h"
#include
"version.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"
#define blist (purple_get_blist() \
? (PIDGIN_BLIST(purple_get_blist()) \
? ((PIDGIN_BLIST(purple_get_blist()))->window) \
: NULL) \
: NULL)
/*
* 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
*/
/* Set window transparency level */
static
void
set_wintrans
(
GtkWidget
*
window
,
int
alpha
,
gboolean
enabled
,
gboolean
always_on_top
)
{
if
(
enabled
)
{
gdk_window_set_opacity
(
window
->
window
,
alpha
/
255.0
);
gdk_window_set_keep_above
(
window
->
window
,
always_on_top
);
}
else
{
gdk_window_set_opacity
(
window
->
window
,
1
);
gdk_window_set_keep_above
(
window
->
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_hbox_new
(
FALSE
,
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_hscale_new_with_range
(
50
,
255
,
1
);
gtk_range_set_value
(
GTK_RANGE
(
slider
),
imalpha
);
gtk_widget_set_usize
(
GTK_WIDGET
(
slider
),
200
,
-1
);
/* On slider val change, update window's transparency level */
g_signal_connect
(
GTK_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
(
PidginWindow
*
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
)
{
PidginWindow
*
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
)
{
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
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
;
GtkRequisition
slidereq
;
gint
width
,
height
;
/* Get top vbox */
for
(
wl1
=
wl
=
gtk_container_get_children
(
GTK_CONTAINER
(
win
));
wl
!=
NULL
;
wl
=
wl
->
next
)
{
if
(
GTK_IS_VBOX
(
GTK_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
);
/* Figure out how tall the slider wants to be */
gtk_widget_size_request
(
slider_box
,
&
slidereq
);
gtk_window_get_size
(
GTK_WINDOW
(
win
),
&
width
,
&
height
);
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
)
{
PidginWindow
*
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
(
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
);
}
}
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
)
{
PidginWindow
*
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
,
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
);
}
}
}
static
void
new_conversation_cb
(
PurpleConversation
*
conv
)
{
PidginWindow
*
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
)
{
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
);
}
}
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
)
{
PidginWindow
*
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
)
{
if
(
blist
)
change_alpha
(
w
,
blist
);
}
static
void
update_existing_convs
()
{
GList
*
wins
;
for
(
wins
=
pidgin_conv_windows_get_list
();
wins
;
wins
=
wins
->
next
)
{
PidginWindow
*
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
);
}
}
/*
* 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_unload
(
PurplePlugin
*
plugin
)
{
purple_debug_info
(
WINTRANS_PLUGIN_ID
,
"Unloading transparency plugin
\n
"
);
remove_convs_wintrans
(
TRUE
);
if
(
blist
)
{
if
(
purple_prefs_get_bool
(
OPT_WINTRANS_BL_ENABLED
))
set_wintrans
(
blist
,
0
,
FALSE
,
FALSE
);
/* Remove the focus cbs */
g_signal_handlers_disconnect_by_func
(
G_OBJECT
(
blist
),
G_CALLBACK
(
focus_blist_win_cb
),
blist
);
}
return
TRUE
;
}
static
GtkWidget
*
get_config_frame
(
PurplePlugin
*
plugin
)
{
GtkWidget
*
ret
;
GtkWidget
*
imtransbox
,
*
bltransbox
;
GtkWidget
*
hbox
;
GtkWidget
*
label
,
*
slider
;
GtkWidget
*
button
;
GtkWidget
*
trans_box
;
ret
=
gtk_vbox_new
(
FALSE
,
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
(
GTK_OBJECT
(
button
),
"clicked"
,
G_CALLBACK
(
update_convs_wintrans
),
(
gpointer
)
OPT_WINTRANS_IM_ENABLED
);
trans_box
=
gtk_vbox_new
(
FALSE
,
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
(
GTK_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
(
GTK_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_hbox_new
(
FALSE
,
5
);
label
=
gtk_label_new
(
_
(
"Opacity:"
));
gtk_box_pack_start
(
GTK_BOX
(
hbox
),
label
,
FALSE
,
FALSE
,
5
);
slider
=
gtk_hscale_new_with_range
(
50
,
255
,
1
);
gtk_range_set_value
(
GTK_RANGE
(
slider
),
purple_prefs_get_int
(
OPT_WINTRANS_IM_ALPHA
));
gtk_widget_set_usize
(
GTK_WIDGET
(
slider
),
200
,
-1
);
g_signal_connect
(
GTK_OBJECT
(
slider
),
"value-changed"
,
G_CALLBACK
(
alpha_change
),
NULL
);
g_signal_connect
(
GTK_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
(
GTK_OBJECT
(
button
),
"clicked"
,
G_CALLBACK
(
set_blist_trans
),
(
gpointer
)
OPT_WINTRANS_BL_ENABLED
);
trans_box
=
gtk_vbox_new
(
FALSE
,
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
(
GTK_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_hbox_new
(
FALSE
,
5
);
label
=
gtk_label_new
(
_
(
"Opacity:"
));
gtk_box_pack_start
(
GTK_BOX
(
hbox
),
label
,
FALSE
,
FALSE
,
5
);
slider
=
gtk_hscale_new_with_range
(
50
,
255
,
1
);
gtk_range_set_value
(
GTK_RANGE
(
slider
),
purple_prefs_get_int
(
OPT_WINTRANS_BL_ALPHA
));
gtk_widget_set_usize
(
GTK_WIDGET
(
slider
),
200
,
-1
);
g_signal_connect
(
GTK_OBJECT
(
slider
),
"value-changed"
,
G_CALLBACK
(
bl_alpha_change
),
NULL
);
g_signal_connect
(
GTK_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
PidginPluginUiInfo
ui_info
=
{
get_config_frame
,
0
,
/* page_num (Reserved) */
/* padding */
NULL
,
NULL
,
NULL
,
NULL
};
static
PurplePluginInfo
info
=
{
PURPLE_PLUGIN_MAGIC
,
PURPLE_MAJOR_VERSION
,
PURPLE_MINOR_VERSION
,
PURPLE_PLUGIN_STANDARD
,
/**< type */
PIDGIN_PLUGIN_TYPE
,
/**< ui_requirement */
0
,
/**< flags */
NULL
,
/**< dependencies */
PURPLE_PRIORITY_DEFAULT
,
/**< priority */
WINTRANS_PLUGIN_ID
,
/**< id */
N_
(
"Transparency"
),
/**< name */
DISPLAY_VERSION
,
/**< version */
/** 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."
),
"Herman Bloggs <hermanator12002@yahoo.com>"
,
/**< author */
PURPLE_WEBSITE
,
/**< homepage */
plugin_load
,
/**< load */
plugin_unload
,
/**< unload */
NULL
,
/**< destroy */
&
ui_info
,
/**< ui_info */
NULL
,
/**< extra_info */
NULL
,
/**< prefs_info */
NULL
,
/**< actions */
/* padding */
NULL
,
NULL
,
NULL
,
NULL
};
static
void
init_plugin
(
PurplePlugin
*
plugin
)
{
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"
);
}
PURPLE_INIT_PLUGIN
(
wintrans
,
init_plugin
,
info
)