Mercurial > pidgin3 / file comparison

comparison: plugins/win32/transparency/win2ktrans.c

plugins/win32/transparency/win2ktrans.c

changeset 14253
b63ebf84c42b
parent 14252
d10dda2777a9
child 14254
77edc7a6191a
equal deleted inserted replaced
14252:d10dda2777a9 14253:b63ebf84c42b
1 /*
2 * gaim - Transparency plugin
3 *
4 * copyright (c) 1998-2002, rob flynn <rob@marko.net>
5 * copyright (c) 2002-2003, Herman Bloggs <hermanator12002@yahoo.com>
6 * copyright (c) 2005, Daniel Atallah <daniel_atallah@yahoo.com>
7 *
8 * this program is free software; you can redistribute it and/or modify
9 * it under the terms of the gnu general public license as published by
10 * the free software foundation; either version 2 of the license, or
11 * (at your option) any later version.
12 *
13 * this program is distributed in the hope that it will be useful,
14 * but without any warranty; without even the implied warranty of
15 * merchantability or fitness for a particular purpose. see the
16 * gnu general public license for more details.
17 *
18 * you should have received a copy of the gnu general public license
19 * along with this program; if not, write to the free software
20 * foundation, inc., 59 temple place, suite 330, boston, ma 02111-1307 usa
21 *
22 */
23 #ifndef _WIN32_WINNT
24 #define _WIN32_WINNT 0x0500
25 #endif
26 #include <gdk/gdkwin32.h>
27 #include "internal.h"
28
29 #include "core.h"
30 #include "prefs.h"
31 #include "debug.h"
32
33 #include "gtkconv.h"
34 #include "gtkplugin.h"
35 #include "gtkprefs.h"
36 #include "gtkblist.h"
37 #include "gtkutils.h"
38 #include "signals.h"
39 #include "version.h"
40
41 /*
42 * MACROS & DEFINES
43 */
44 #define WINTRANS_PLUGIN_ID "gtk-win-trans"
45
46 #define blist (gaim_get_blist() \
47 ? (GAIM_GTK_BLIST(gaim_get_blist()) \
48 ? ((GAIM_GTK_BLIST(gaim_get_blist()))->window) \
49 : NULL) \
50 : NULL)
51
52 /*
53 * DATA STRUCTS
54 */
55 typedef struct {
56 GtkWidget *win;
57 GtkWidget *slider;
58 } slider_win;
59
60 /*
61 * LOCALS
62 */
63 static const char *OPT_WINTRANS_IM_ENABLED= "/plugins/gtk/win32/wintrans/im_enabled";
64 static const char *OPT_WINTRANS_IM_ALPHA = "/plugins/gtk/win32/wintrans/im_alpha";
65 static const char *OPT_WINTRANS_IM_SLIDER = "/plugins/gtk/win32/wintrans/im_slider";
66 static const char *OPT_WINTRANS_IM_ONFOCUS= "/plugins/gtk/win32/wintrans/im_solid_onfocus";
67 static const char *OPT_WINTRANS_IM_ONTOP = "/plugins/gtk/win32/wintrans/im_always_on_top";
68 static const char *OPT_WINTRANS_BL_ENABLED= "/plugins/gtk/win32/wintrans/bl_enabled";
69 static const char *OPT_WINTRANS_BL_ALPHA = "/plugins/gtk/win32/wintrans/bl_alpha";
70 static const char *OPT_WINTRANS_BL_ONFOCUS= "/plugins/gtk/win32/wintrans/bl_solid_onfocus";
71 static const char *OPT_WINTRANS_BL_ONTOP = "/plugins/gtk/win32/wintrans/bl_always_on_top";
72 static GSList *window_list = NULL;
73
74 static BOOL (*MySetLayeredWindowAttributes)(HWND hwnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags) = NULL;
75
76 /*
77 * CODE
78 */
79 static GtkWidget *wgaim_button(const char *text, const char *pref, GtkWidget *page) {
80 GtkWidget *button;
81 button = gtk_check_button_new_with_mnemonic(text);
82 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),
83 gaim_prefs_get_bool(pref));
84 gtk_box_pack_start(GTK_BOX(page), button, FALSE, FALSE, 0);
85 gtk_widget_show(button);
86 return button;
87 }
88
89 /* Set window transparency level */
90 static void set_wintrans(GtkWidget *window, int alpha, gboolean enabled,
91 gboolean always_on_top) {
92 if (MySetLayeredWindowAttributes) {
93 HWND hWnd = GDK_WINDOW_HWND(window->window);
94 LONG style = GetWindowLong(hWnd, GWL_EXSTYLE);
95 if (enabled) {
96 style |= WS_EX_LAYERED;
97 } else {
98 style &= ~WS_EX_LAYERED;
99 }
100 SetWindowLong(hWnd, GWL_EXSTYLE, style);
101
102
103 if (enabled) {
104 SetWindowPos(hWnd,
105 always_on_top ? HWND_TOPMOST : HWND_NOTOPMOST,
106 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
107 MySetLayeredWindowAttributes(hWnd, 0, alpha, LWA_ALPHA);
108 } else {
109 /* Ask the window and its children to repaint */
110 SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
111 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
112
113 RedrawWindow(hWnd, NULL, NULL,
114 RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
115 }
116 }
117 }
118
119 /* When a conv window is focused, if we're only transparent when unfocused,
120 * deal with transparency */
121 static gboolean focus_conv_win_cb(GtkWidget *w, GdkEventFocus *e, gpointer d) {
122 if (gaim_prefs_get_bool(OPT_WINTRANS_IM_ENABLED)
123 && gaim_prefs_get_bool(OPT_WINTRANS_IM_ONFOCUS)) {
124 GtkWidget *window = (GtkWidget *) d;
125 if (e->in) { /* Focused */
126 set_wintrans(window, 0, FALSE,
127 gaim_prefs_get_bool(OPT_WINTRANS_IM_ONTOP));
128 } else {
129 set_wintrans(window,
130 gaim_prefs_get_int(OPT_WINTRANS_IM_ALPHA),
131 TRUE,
132 gaim_prefs_get_bool(OPT_WINTRANS_IM_ONTOP));
133 }
134 }
135 return FALSE;
136 }
137
138 /* When buddy list window is focused,
139 * if we're only transparent when unfocused, deal with transparency */
140 static gboolean focus_blist_win_cb(GtkWidget *w, GdkEventFocus *e, gpointer d) {
141 if (gaim_prefs_get_bool(OPT_WINTRANS_BL_ENABLED)
142 && gaim_prefs_get_bool(OPT_WINTRANS_BL_ONFOCUS)) {
143 GtkWidget *window = (GtkWidget *) d;
144 if (e->in) { /* Focused */
145 set_wintrans(window, 0, FALSE,
146 gaim_prefs_get_bool(OPT_WINTRANS_BL_ONTOP));
147 } else {
148 set_wintrans(window,
149 gaim_prefs_get_int(OPT_WINTRANS_BL_ALPHA),
150 TRUE,
151 gaim_prefs_get_bool(OPT_WINTRANS_BL_ONTOP));
152 }
153 }
154 return FALSE;
155 }
156
157 static void change_alpha(GtkWidget *w, gpointer data) {
158 int alpha = gtk_range_get_value(GTK_RANGE(w));
159 gaim_prefs_set_int(OPT_WINTRANS_IM_ALPHA, alpha);
160
161 /* If we're in no-transparency on focus mode,
162 * don't take effect immediately */
163 if (!gaim_prefs_get_bool(OPT_WINTRANS_IM_ONFOCUS))
164 set_wintrans(GTK_WIDGET(data), alpha, TRUE,
165 gaim_prefs_get_bool(OPT_WINTRANS_IM_ONTOP));
166 }
167
168
169 static GtkWidget *wintrans_slider(GtkWidget *win) {
170 GtkWidget *hbox;
171 GtkWidget *label, *slider;
172 GtkWidget *frame;
173
174 int imalpha = gaim_prefs_get_int(OPT_WINTRANS_IM_ALPHA);
175
176 frame = gtk_frame_new(NULL);
177 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
178 gtk_widget_show(frame);
179
180 hbox = gtk_hbox_new(FALSE, 5);
181 gtk_container_add(GTK_CONTAINER(frame), hbox);
182
183 label = gtk_label_new(_("Opacity:"));
184 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
185 gtk_widget_show(hbox);
186
187 slider = gtk_hscale_new_with_range(50, 255, 1);
188 gtk_range_set_value(GTK_RANGE(slider), imalpha);
189 gtk_widget_set_usize(GTK_WIDGET(slider), 200, -1);
190
191 /* On slider val change, update window's transparency level */
192 g_signal_connect(GTK_OBJECT(slider), "value-changed",
193 GTK_SIGNAL_FUNC(change_alpha), win);
194
195 gtk_box_pack_start(GTK_BOX(hbox), slider, FALSE, TRUE, 5);
196
197 /* Set the initial transparency level */
198 set_wintrans(win, imalpha, TRUE,
199 gaim_prefs_get_bool(OPT_WINTRANS_IM_ONTOP));
200
201 gtk_widget_show_all(hbox);
202
203 return frame;
204 }
205
206 static slider_win* find_slidwin(GtkWidget *win) {
207 GSList *tmp = window_list;
208
209 while (tmp) {
210 if (((slider_win*) (tmp->data))->win == win)
211 return (slider_win*) tmp->data;
212 tmp = tmp->next;
213 }
214 return NULL;
215 }
216
217 /* Clean up transparency stuff for the conv window */
218 static void cleanup_conv_window(GaimGtkWindow *win) {
219 GtkWidget *window = win->window;
220 slider_win *slidwin = NULL;
221
222 /* Remove window from the window list */
223 gaim_debug_info(WINTRANS_PLUGIN_ID,
224 "Conv window destroyed... removing from list\n");
225
226 if ((slidwin = find_slidwin(window))) {
227 window_list = g_slist_remove(window_list, slidwin);
228 g_free(slidwin);
229 }
230
231 /* Remove the focus cbs */
232 g_signal_handlers_disconnect_by_func(G_OBJECT(window),
233 G_CALLBACK(focus_conv_win_cb), window);
234 }
235
236 static void gaim_conversation_delete(GaimConversation *conv) {
237 GaimGtkWindow *win = gaim_gtkconv_get_window(GAIM_GTK_CONVERSATION(conv));
238 /* If it is the last conversation in the window, cleanup */
239 if (gaim_gtk_conv_window_get_gtkconv_count(win) == 1)
240 cleanup_conv_window(win);
241 }
242
243 static void set_blist_trans(GtkWidget *w, const char *pref) {
244 gboolean enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w));
245 gaim_prefs_set_bool(pref, enabled);
246 if (blist) {
247 set_wintrans(blist, gaim_prefs_get_int(OPT_WINTRANS_BL_ALPHA),
248 gaim_prefs_get_bool(OPT_WINTRANS_BL_ENABLED),
249 gaim_prefs_get_bool(OPT_WINTRANS_IM_ONTOP));
250 }
251 }
252
253 static void add_slider(GtkWidget *win) {
254 GList *wl, *wl1;
255 GtkWidget *vbox = NULL;
256
257 /* Look up this window to see if it already has a slider */
258 if (!find_slidwin(win)) {
259 GtkWidget *slider_box = NULL;
260 slider_win *slidwin = NULL;
261 GtkRequisition slidereq;
262 gint width, height;
263
264 /* Get top vbox */
265 for (wl1 = wl = gtk_container_get_children(
266 GTK_CONTAINER(win));
267 wl != NULL;
268 wl = wl->next) {
269 if (GTK_IS_VBOX(GTK_OBJECT(wl->data)))
270 vbox = GTK_WIDGET(wl->data);
271 else {
272 gaim_debug_error(WINTRANS_PLUGIN_ID,
273 "no vbox found\n");
274 return;
275 }
276 }
277 g_list_free(wl1);
278
279 slider_box = wintrans_slider(win);
280 /* Figure out how tall the slider wants to be */
281 gtk_widget_size_request(slider_box, &slidereq);
282 gtk_window_get_size(GTK_WINDOW(win), &width, &height);
283 gtk_box_pack_start(GTK_BOX(vbox),
284 slider_box, FALSE, FALSE, 0);
285 /* Make window taller so we don't slowly collapse its message area */
286 gtk_window_resize(GTK_WINDOW(win), width,
287 (height + slidereq.height));
288 /* Add window to list, to track that it has a slider */
289 slidwin = g_new0(slider_win, 1);
290 slidwin->win = win;
291 slidwin->slider = slider_box;
292 window_list = g_slist_append(window_list, slidwin);
293 }
294 }
295
296 static void remove_sliders() {
297 if (window_list) {
298 GSList *tmp = window_list;
299 while (tmp) {
300 slider_win *slidwin = (slider_win*) tmp->data;
301 if (slidwin != NULL &&
302 GTK_IS_WINDOW(slidwin->win)) {
303 GtkRequisition slidereq;
304 gint width, height;
305 /* Figure out how tall the slider was */
306 gtk_widget_size_request(
307 slidwin->slider, &slidereq);
308 gtk_window_get_size(
309 GTK_WINDOW(slidwin->win),
310 &width, &height);
311
312 gtk_widget_destroy(slidwin->slider);
313
314 gtk_window_resize(
315 GTK_WINDOW(slidwin->win),
316 width, (height - slidereq.height));
317 }
318 g_free(slidwin);
319 tmp = tmp->next;
320 }
321 g_slist_free(window_list);
322 window_list = NULL;
323 }
324 }
325
326 /* Remove all transparency related aspects from conversation windows */
327 static void remove_convs_wintrans(gboolean remove_signal) {
328 GList *wins;
329
330 for (wins = gaim_gtk_conv_windows_get_list(); wins; wins = wins->next) {
331 GaimGtkWindow *win = wins->data;
332 GtkWidget *window = win->window;
333
334 if (gaim_prefs_get_bool(OPT_WINTRANS_IM_ENABLED))
335 set_wintrans(window, 0, FALSE, FALSE);
336
337 /* Remove the focus cbs */
338 if (remove_signal)
339 g_signal_handlers_disconnect_by_func(G_OBJECT(window),
340 G_CALLBACK(focus_conv_win_cb), window);
341 }
342
343 remove_sliders();
344 }
345
346 static void set_conv_window_trans(GaimGtkWindow *oldwin, GaimGtkWindow *newwin) {
347 GtkWidget *win = newwin->window;
348
349 /* check prefs to see if we want trans */
350 if (gaim_prefs_get_bool(OPT_WINTRANS_IM_ENABLED)) {
351 set_wintrans(win, gaim_prefs_get_int(OPT_WINTRANS_IM_ALPHA),
352 TRUE, gaim_prefs_get_bool(OPT_WINTRANS_IM_ONTOP));
353
354 if (gaim_prefs_get_bool(OPT_WINTRANS_IM_SLIDER)) {
355 add_slider(win);
356 }
357 }
358
359 /* If we're moving from one window to another,
360 * add the focus listeners to the new window if not already there */
361 if (oldwin != NULL && oldwin != newwin) {
362 if (gaim_gtk_conv_window_get_gtkconv_count(newwin) == 0) {
363 g_signal_connect(G_OBJECT(win), "focus_in_event",
364 G_CALLBACK(focus_conv_win_cb), win);
365 g_signal_connect(G_OBJECT(win), "focus_out_event",
366 G_CALLBACK(focus_conv_win_cb), win);
367 }
368
369 /* If we've moved the last conversation, cleanup the window */
370 if (gaim_gtk_conv_window_get_gtkconv_count(oldwin) == 1)
371 cleanup_conv_window(oldwin);
372 }
373 }
374
375 static void update_convs_wintrans(GtkWidget *toggle_btn, const char *pref) {
376 gaim_prefs_set_bool(pref, gtk_toggle_button_get_active(
377 GTK_TOGGLE_BUTTON(toggle_btn)));
378
379 if (gaim_prefs_get_bool(OPT_WINTRANS_IM_ENABLED)) {
380 GList *wins;
381
382 for (wins = gaim_gtk_conv_windows_get_list(); wins; wins = wins->next) {
383 GaimGtkWindow *win = wins->data;
384 set_conv_window_trans(NULL, win);
385 }
386
387 if (!gaim_prefs_get_bool(OPT_WINTRANS_IM_SLIDER))
388 remove_sliders();
389 }
390 else
391 remove_convs_wintrans(FALSE);
392 }
393
394 static void gaim_new_conversation(GaimConversation *conv) {
395 GaimGtkWindow *win = gaim_gtkconv_get_window(GAIM_GTK_CONVERSATION(conv));
396
397 /* If it is the first conversation in the window,
398 * add the sliders, and set transparency */
399 if (gaim_gtk_conv_window_get_gtkconv_count(win) == 1) {
400 GtkWidget *window = win->window;
401
402 set_conv_window_trans(NULL, win);
403
404 g_signal_connect(G_OBJECT(window), "focus_in_event",
405 G_CALLBACK(focus_conv_win_cb), window);
406 g_signal_connect(G_OBJECT(window), "focus_out_event",
407 G_CALLBACK(focus_conv_win_cb), window);
408 }
409 }
410
411 static void blist_created_cb(GaimBuddyList *gaim_blist, gpointer data) {
412 if (blist) {
413 if (gaim_prefs_get_bool(OPT_WINTRANS_BL_ENABLED)) {
414 set_wintrans(blist,
415 gaim_prefs_get_int(OPT_WINTRANS_BL_ALPHA),
416 TRUE,
417 gaim_prefs_get_bool(OPT_WINTRANS_BL_ONTOP));
418 }
419
420 g_signal_connect(G_OBJECT(blist), "focus_in_event",
421 G_CALLBACK(focus_blist_win_cb), blist);
422 g_signal_connect(G_OBJECT(blist), "focus_out_event",
423 G_CALLBACK(focus_blist_win_cb), blist);
424 }
425 }
426
427 static void alpha_change(GtkWidget *w, gpointer data) {
428 GList *wins;
429 int imalpha = gtk_range_get_value(GTK_RANGE(w));
430
431 for (wins = gaim_gtk_conv_windows_get_list(); wins; wins = wins->next) {
432 GaimGtkWindow *win = wins->data;
433 set_wintrans(win->window, imalpha, TRUE,
434 gaim_prefs_get_bool(OPT_WINTRANS_IM_ONTOP));
435 }
436 }
437
438 static void alpha_pref_set_int (GtkWidget *w, GdkEventFocus *e, const char *pref)
439 {
440 int alpha = gtk_range_get_value(GTK_RANGE(w));
441 gaim_prefs_set_int(pref, alpha);
442 }
443
444 static void bl_alpha_change(GtkWidget *w, gpointer data) {
445 if (blist)
446 change_alpha(w, blist);
447 }
448
449 static void update_existing_convs() {
450 GList *wins;
451
452 for (wins = gaim_gtk_conv_windows_get_list(); wins; wins = wins->next) {
453 GaimGtkWindow *win = wins->data;
454 GtkWidget *window = win->window;
455
456 set_conv_window_trans(NULL, win);
457
458 g_signal_connect(G_OBJECT(window), "focus_in_event",
459 G_CALLBACK(focus_conv_win_cb), window);
460 g_signal_connect(G_OBJECT(window), "focus_out_event",
461 G_CALLBACK(focus_conv_win_cb), window);
462 }
463 }
464
465 /*
466 * EXPORTED FUNCTIONS
467 */
468 static gboolean plugin_load(GaimPlugin *plugin) {
469 MySetLayeredWindowAttributes = (void*) wgaim_find_and_loadproc(
470 "user32.dll", "SetLayeredWindowAttributes");
471
472 if (!MySetLayeredWindowAttributes) {
473 gaim_debug_error(WINTRANS_PLUGIN_ID,
474 "SetLayeredWindowAttributes API not found (Required W2K+)\n");
475 return FALSE;
476 }
477
478 gaim_signal_connect(gaim_conversations_get_handle(),
479 "conversation-created", plugin,
480 GAIM_CALLBACK(gaim_new_conversation), NULL);
481
482 /* Set callback to remove window from the list, if the window is destroyed */
483 gaim_signal_connect(gaim_conversations_get_handle(),
484 "deleting-conversation", plugin,
485 GAIM_CALLBACK(gaim_conversation_delete), NULL);
486
487 gaim_signal_connect(gaim_gtk_conversations_get_handle(),
488 "conversation-dragging", plugin,
489 GAIM_CALLBACK(set_conv_window_trans), NULL);
490
491 update_existing_convs();
492
493 if (blist)
494 blist_created_cb(NULL, NULL);
495 else
496 gaim_signal_connect(gaim_gtk_blist_get_handle(),
497 "gtkblist-created", plugin,
498 GAIM_CALLBACK(blist_created_cb), NULL);
499
500
501 return TRUE;
502 }
503
504 static gboolean plugin_unload(GaimPlugin *plugin) {
505 gaim_debug_info(WINTRANS_PLUGIN_ID, "Unloading win2ktrans plugin\n");
506
507 remove_convs_wintrans(TRUE);
508
509 if (blist) {
510 if (gaim_prefs_get_bool(OPT_WINTRANS_BL_ENABLED))
511 set_wintrans(blist, 0, FALSE, FALSE);
512
513 /* Remove the focus cbs */
514 g_signal_handlers_disconnect_by_func(G_OBJECT(blist),
515 G_CALLBACK(focus_blist_win_cb), blist);
516 }
517
518 return TRUE;
519 }
520
521 static GtkWidget *get_config_frame(GaimPlugin *plugin) {
522 GtkWidget *ret;
523 GtkWidget *imtransbox, *bltransbox;
524 GtkWidget *hbox;
525 GtkWidget *label, *slider;
526 GtkWidget *button;
527 GtkWidget *trans_box;
528
529 ret = gtk_vbox_new(FALSE, 18);
530 gtk_container_set_border_width(GTK_CONTAINER (ret), 12);
531
532 /* IM Convo trans options */
533 imtransbox = gaim_gtk_make_frame(ret, _("IM Conversation Windows"));
534 button = wgaim_button(_("_IM window transparency"),
535 OPT_WINTRANS_IM_ENABLED, imtransbox);
536 g_signal_connect(GTK_OBJECT(button), "clicked",
537 GTK_SIGNAL_FUNC(update_convs_wintrans),
538 (gpointer) OPT_WINTRANS_IM_ENABLED);
539
540 trans_box = gtk_vbox_new(FALSE, 18);
541 if (!gaim_prefs_get_bool(OPT_WINTRANS_IM_ENABLED))
542 gtk_widget_set_sensitive(GTK_WIDGET(trans_box), FALSE);
543 gtk_widget_show(trans_box);
544
545 g_signal_connect(GTK_OBJECT(button), "clicked",
546 GTK_SIGNAL_FUNC(gaim_gtk_toggle_sensitive), trans_box);
547
548 button = wgaim_button(_("_Show slider bar in IM window"),
549 OPT_WINTRANS_IM_SLIDER, trans_box);
550 g_signal_connect(GTK_OBJECT(button), "clicked",
551 GTK_SIGNAL_FUNC(update_convs_wintrans),
552 (gpointer) OPT_WINTRANS_IM_SLIDER);
553
554 button = gaim_gtk_prefs_checkbox(
555 _("Remove IM window transparency on focus"),
556 OPT_WINTRANS_IM_ONFOCUS, trans_box);
557
558 button = wgaim_button(_("Always on top"), OPT_WINTRANS_IM_ONTOP,
559 trans_box);
560 g_signal_connect(GTK_OBJECT(button), "clicked",
561 GTK_SIGNAL_FUNC(update_convs_wintrans),
562 (gpointer) OPT_WINTRANS_IM_ONTOP);
563
564 gtk_box_pack_start(GTK_BOX(imtransbox), trans_box, FALSE, FALSE, 5);
565
566 /* IM transparency slider */
567 hbox = gtk_hbox_new(FALSE, 5);
568
569 label = gtk_label_new(_("Opacity:"));
570 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
571
572 slider = gtk_hscale_new_with_range(50, 255, 1);
573 gtk_range_set_value(GTK_RANGE(slider),
574 gaim_prefs_get_int(OPT_WINTRANS_IM_ALPHA));
575 gtk_widget_set_usize(GTK_WIDGET(slider), 200, -1);
576
577 g_signal_connect(GTK_OBJECT(slider), "value-changed",
578 GTK_SIGNAL_FUNC(alpha_change), NULL);
579 g_signal_connect(GTK_OBJECT(slider), "focus-out-event",
580 GTK_SIGNAL_FUNC(alpha_pref_set_int),
581 (gpointer) OPT_WINTRANS_IM_ALPHA);
582
583 gtk_box_pack_start(GTK_BOX(hbox), slider, FALSE, TRUE, 5);
584
585 gtk_widget_show_all(hbox);
586
587 gtk_box_pack_start(GTK_BOX(trans_box), hbox, FALSE, FALSE, 5);
588
589 /* Buddy List trans options */
590 bltransbox = gaim_gtk_make_frame (ret, _("Buddy List Window"));
591 button = wgaim_button(_("_Buddy List window transparency"),
592 OPT_WINTRANS_BL_ENABLED, bltransbox);
593 g_signal_connect(GTK_OBJECT(button), "clicked",
594 GTK_SIGNAL_FUNC(set_blist_trans),
595 (gpointer) OPT_WINTRANS_BL_ENABLED);
596
597 trans_box = gtk_vbox_new(FALSE, 18);
598 if (!gaim_prefs_get_bool(OPT_WINTRANS_BL_ENABLED))
599 gtk_widget_set_sensitive(GTK_WIDGET(trans_box), FALSE);
600 gtk_widget_show(trans_box);
601 g_signal_connect(GTK_OBJECT(button), "clicked",
602 GTK_SIGNAL_FUNC(gaim_gtk_toggle_sensitive), trans_box);
603 button = gaim_gtk_prefs_checkbox(
604 _("Remove Buddy List window transparency on focus"),
605 OPT_WINTRANS_BL_ONFOCUS, trans_box);
606 button = wgaim_button(_("Always on top"), OPT_WINTRANS_BL_ONTOP,
607 trans_box);
608 g_signal_connect(GTK_OBJECT(button), "clicked",
609 GTK_SIGNAL_FUNC(set_blist_trans),
610 (gpointer) OPT_WINTRANS_BL_ONTOP);
611 gtk_box_pack_start(GTK_BOX(bltransbox), trans_box, FALSE, FALSE, 5);
612
613 /* IM transparency slider */
614 hbox = gtk_hbox_new(FALSE, 5);
615
616 label = gtk_label_new(_("Opacity:"));
617 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
618
619 slider = gtk_hscale_new_with_range(50, 255, 1);
620 gtk_range_set_value(GTK_RANGE(slider),
621 gaim_prefs_get_int(OPT_WINTRANS_BL_ALPHA));
622
623 gtk_widget_set_usize(GTK_WIDGET(slider), 200, -1);
624
625 g_signal_connect(GTK_OBJECT(slider), "value-changed",
626 GTK_SIGNAL_FUNC(bl_alpha_change), NULL);
627 g_signal_connect(GTK_OBJECT(slider), "focus-out-event",
628 GTK_SIGNAL_FUNC(alpha_pref_set_int),
629 (gpointer) OPT_WINTRANS_BL_ALPHA);
630
631 gtk_box_pack_start(GTK_BOX(hbox), slider, FALSE, TRUE, 5);
632
633 gtk_widget_show_all(hbox);
634
635 gtk_box_pack_start(GTK_BOX(trans_box), hbox, FALSE, FALSE, 5);
636
637 gtk_widget_show_all(ret);
638 return ret;
639 }
640
641 static GaimGtkPluginUiInfo ui_info =
642 {
643 get_config_frame,
644 0 /* page_num (Reserved) */
645 };
646
647 static GaimPluginInfo info =
648 {
649 GAIM_PLUGIN_MAGIC,
650 GAIM_MAJOR_VERSION,
651 GAIM_MINOR_VERSION,
652 GAIM_PLUGIN_STANDARD, /**< type */
653 GAIM_GTK_PLUGIN_TYPE, /**< ui_requirement */
654 0, /**< flags */
655 NULL, /**< dependencies */
656 GAIM_PRIORITY_DEFAULT, /**< priority */
657 WINTRANS_PLUGIN_ID, /**< id */
658 N_("Transparency"), /**< name */
659 VERSION, /**< version */
660 /** summary */
661 N_("Variable Transparency for the buddy list and conversations."),
662 /** description */
663 N_("This plugin enables variable alpha transparency on conversation windows and the buddy list.\n\n"
664 "* Note: This plugin requires Win2000 or greater."),
665 "Herman Bloggs <hermanator12002@yahoo.com>", /**< author */
666 GAIM_WEBSITE, /**< homepage */
667 plugin_load, /**< load */
668 plugin_unload, /**< unload */
669 NULL, /**< destroy */
670 &ui_info, /**< ui_info */
671 NULL, /**< extra_info */
672 NULL, /**< prefs_info */
673 NULL /**< actions */
674 };
675
676 static void
677 init_plugin(GaimPlugin *plugin)
678 {
679 gaim_prefs_add_none("/plugins/gtk/win32");
680 gaim_prefs_add_none("/plugins/gtk/win32/wintrans");
681 gaim_prefs_add_bool(OPT_WINTRANS_IM_ENABLED, FALSE);
682 gaim_prefs_add_int(OPT_WINTRANS_IM_ALPHA, 255);
683 gaim_prefs_add_bool(OPT_WINTRANS_IM_SLIDER, FALSE);
684 gaim_prefs_add_bool(OPT_WINTRANS_IM_ONFOCUS, FALSE);
685 gaim_prefs_add_bool(OPT_WINTRANS_IM_ONTOP, FALSE);
686 gaim_prefs_add_bool(OPT_WINTRANS_BL_ENABLED, FALSE);
687 gaim_prefs_add_int(OPT_WINTRANS_BL_ALPHA, 255);
688 gaim_prefs_add_bool(OPT_WINTRANS_BL_ONFOCUS, FALSE);
689 gaim_prefs_add_bool(OPT_WINTRANS_BL_ONTOP, FALSE);
690 }
691
692 GAIM_INIT_PLUGIN(wintrans, init_plugin, info)

Mercurial Repository: pidgin3

mercurial