Mercurial > audlegacy-plugins
comparison src/skins/ui_skinned_window.c @ 2572:d0daee216c8d
stub (really incomplete) for skin engine plugin
author | Tomasz Mon <desowin@gmail.com> |
---|---|
date | Sun, 18 May 2008 14:20:51 +0200 |
parents | |
children | 8da9705862e5 |
comparison
equal
deleted
inserted
replaced
2571:3a59f3d578f1 | 2572:d0daee216c8d |
---|---|
1 /* | |
2 * Audacious: A cross-platform multimedia player | |
3 * Copyright (c) 2007 William Pitcock <nenolod -at- sacredspiral.co.uk> | |
4 * | |
5 * This program is free software; you can redistribute it and/or modify | |
6 * it under the terms of the GNU General Public License as published by | |
7 * the Free Software Foundation; under version 3 of the License. | |
8 * | |
9 * This program is distributed in the hope that it will be useful, | |
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 * GNU General Public License for more details. | |
13 * | |
14 * You should have received a copy of the GNU General Public License | |
15 * along with this program. If not, see <http://www.gnu.org/licenses>. | |
16 * | |
17 * The Audacious team does not consider modular code linking to | |
18 * Audacious or using our public API to be a derived work. | |
19 */ | |
20 | |
21 #include "platform/smartinclude.h" | |
22 #include "ui_skin.h" | |
23 | |
24 #include <gtk/gtkmain.h> | |
25 #include <glib-object.h> | |
26 #include <glib/gmacros.h> | |
27 #include <gtk/gtkmarshal.h> | |
28 #include <gtk/gtkwindow.h> | |
29 #include <string.h> | |
30 | |
31 #include <audacious/plugin.h> | |
32 #include "ui_dock.h" | |
33 #include "ui_skinned_window.h" | |
34 | |
35 static void ui_skinned_window_class_init(SkinnedWindowClass *klass); | |
36 static void ui_skinned_window_init(GtkWidget *widget); | |
37 static GtkWindowClass *parent = NULL; | |
38 | |
39 GType | |
40 ui_skinned_window_get_type(void) | |
41 { | |
42 static GType window_type = 0; | |
43 | |
44 if (!window_type) | |
45 { | |
46 static const GTypeInfo window_info = | |
47 { | |
48 sizeof (SkinnedWindowClass), | |
49 NULL, /* base_init */ | |
50 NULL, /* base_finalize */ | |
51 (GClassInitFunc) ui_skinned_window_class_init, | |
52 NULL, /* class_finalize */ | |
53 NULL, /* class_data */ | |
54 sizeof (SkinnedWindow), | |
55 0, /* n_preallocs */ | |
56 (GInstanceInitFunc) ui_skinned_window_init | |
57 }; | |
58 | |
59 window_type = | |
60 g_type_register_static (GTK_TYPE_WINDOW, "SkinnedWindow2", | |
61 &window_info, 0); | |
62 } | |
63 | |
64 return window_type; | |
65 } | |
66 | |
67 static void | |
68 ui_skinned_window_map(GtkWidget *widget) | |
69 { | |
70 (* GTK_WIDGET_CLASS (parent)->map) (widget); | |
71 | |
72 SkinnedWindow *window = SKINNED_WINDOW(widget); | |
73 if (window->type == WINDOW_MAIN) | |
74 gtk_widget_shape_combine_mask(widget, skin_get_mask(aud_active_skin, SKIN_MASK_MAIN + aud_cfg->player_shaded), 0, 0); | |
75 else if (window->type == WINDOW_EQ) | |
76 gtk_widget_shape_combine_mask(widget, skin_get_mask(aud_active_skin, SKIN_MASK_EQ + aud_cfg->equalizer_shaded), 0, 0); | |
77 | |
78 gtk_window_set_keep_above(GTK_WINDOW(widget), aud_cfg->always_on_top); | |
79 } | |
80 | |
81 static gboolean | |
82 ui_skinned_window_motion_notify_event(GtkWidget *widget, | |
83 GdkEventMotion *event) | |
84 { | |
85 if (dock_is_moving(GTK_WINDOW(widget))) | |
86 dock_move_motion(GTK_WINDOW(widget), event); | |
87 | |
88 return FALSE; | |
89 } | |
90 | |
91 static gboolean ui_skinned_window_focus_in(GtkWidget *widget, GdkEventFocus *focus) { | |
92 gboolean val = GTK_WIDGET_CLASS (parent)->focus_in_event (widget, focus); | |
93 gtk_widget_queue_draw(widget); | |
94 return val; | |
95 } | |
96 | |
97 static gboolean ui_skinned_window_focus_out(GtkWidget *widget, GdkEventFocus *focus) { | |
98 gboolean val = GTK_WIDGET_CLASS (parent)->focus_out_event (widget, focus); | |
99 gtk_widget_queue_draw(widget); | |
100 return val; | |
101 } | |
102 | |
103 static gboolean ui_skinned_window_expose(GtkWidget *widget, GdkEventExpose *event) { | |
104 SkinnedWindow *window = SKINNED_WINDOW(widget); | |
105 | |
106 GdkPixbuf *obj = NULL; | |
107 | |
108 gint width = 0, height = 0; | |
109 switch (window->type) { | |
110 case WINDOW_MAIN: | |
111 width = aud_active_skin->properties.mainwin_width; | |
112 height = aud_active_skin->properties.mainwin_height; | |
113 break; | |
114 case WINDOW_EQ: | |
115 width = 275 * (aud_cfg->scaled ? aud_cfg->scale_factor : 1); | |
116 height = 116 * (aud_cfg->scaled ? aud_cfg->scale_factor : 1) ; | |
117 break; | |
118 case WINDOW_PLAYLIST: | |
119 #if 0 | |
120 width = playlistwin_get_width(); | |
121 height = aud_cfg->playlist_height; | |
122 #endif | |
123 break; | |
124 default: | |
125 return FALSE; | |
126 } | |
127 obj = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, width, height); | |
128 | |
129 gboolean focus = gtk_window_has_toplevel_focus(GTK_WINDOW(widget)); | |
130 | |
131 switch (window->type) { | |
132 case WINDOW_MAIN: | |
133 skin_draw_pixbuf(widget, aud_active_skin, obj,SKIN_MAIN, 0, 0, 0, 0, width, height); | |
134 skin_draw_mainwin_titlebar(aud_active_skin, obj, aud_cfg->player_shaded, focus || !aud_cfg->dim_titlebar); | |
135 break; | |
136 case WINDOW_EQ: | |
137 skin_draw_pixbuf(widget, aud_active_skin, obj, SKIN_EQMAIN, 0, 0, 0, 0, width, height); | |
138 if (focus || !aud_cfg->dim_titlebar) { | |
139 if (!aud_cfg->equalizer_shaded) | |
140 skin_draw_pixbuf(widget, aud_active_skin, obj, SKIN_EQMAIN, 0, 134, 0, 0, width, 14); | |
141 else | |
142 skin_draw_pixbuf(widget, aud_active_skin, obj, SKIN_EQ_EX, 0, 0, 0, 0, width, 14); | |
143 } else { | |
144 if (!aud_cfg->equalizer_shaded) | |
145 skin_draw_pixbuf(widget, aud_active_skin, obj, SKIN_EQMAIN, 0, 149, 0, 0, width, 14); | |
146 else | |
147 skin_draw_pixbuf(widget, aud_active_skin, obj, SKIN_EQ_EX, 0, 15, 0, 0, width, 14); | |
148 } | |
149 break; | |
150 case WINDOW_PLAYLIST: | |
151 focus |= !aud_cfg->dim_titlebar; | |
152 if (aud_cfg->playlist_shaded) { | |
153 skin_draw_playlistwin_shaded(aud_active_skin, obj, width, focus); | |
154 } else { | |
155 skin_draw_playlistwin_frame(aud_active_skin, obj, width, aud_cfg->playlist_height, focus); | |
156 } | |
157 break; | |
158 } | |
159 | |
160 ui_skinned_widget_draw(GTK_WIDGET(window), obj, width, height, | |
161 window->type != WINDOW_PLAYLIST && aud_cfg->scaled); | |
162 | |
163 g_object_unref(obj); | |
164 | |
165 return FALSE; | |
166 } | |
167 | |
168 static void | |
169 ui_skinned_window_class_init(SkinnedWindowClass *klass) | |
170 { | |
171 GtkWidgetClass *widget_class; | |
172 | |
173 widget_class = (GtkWidgetClass*) klass; | |
174 | |
175 parent = gtk_type_class(gtk_window_get_type()); | |
176 | |
177 widget_class->motion_notify_event = ui_skinned_window_motion_notify_event; | |
178 widget_class->expose_event = ui_skinned_window_expose; | |
179 widget_class->focus_in_event = ui_skinned_window_focus_in; | |
180 widget_class->focus_out_event = ui_skinned_window_focus_out; | |
181 widget_class->map = ui_skinned_window_map; | |
182 } | |
183 | |
184 void | |
185 ui_skinned_window_hide(SkinnedWindow *window) | |
186 { | |
187 g_return_if_fail(SKINNED_CHECK_WINDOW(window)); | |
188 | |
189 gtk_window_get_position(GTK_WINDOW(window), &window->x, &window->y); | |
190 gtk_widget_hide(GTK_WIDGET(window)); | |
191 } | |
192 | |
193 void | |
194 ui_skinned_window_show(SkinnedWindow *window) | |
195 { | |
196 g_return_if_fail(SKINNED_CHECK_WINDOW(window)); | |
197 | |
198 gtk_window_move(GTK_WINDOW(window), window->x, window->y); | |
199 gtk_widget_show_all(GTK_WIDGET(window)); | |
200 } | |
201 | |
202 static void | |
203 ui_skinned_window_init(GtkWidget *widget) | |
204 { | |
205 SkinnedWindow *window; | |
206 window = SKINNED_WINDOW(widget); | |
207 window->x = -1; | |
208 window->y = -1; | |
209 } | |
210 | |
211 GtkWidget * | |
212 ui_skinned_window_new(const gchar *wmclass_name) | |
213 { | |
214 GtkWidget *widget = g_object_new(ui_skinned_window_get_type(), NULL); | |
215 GtkWindow *window = GTK_WINDOW(widget); | |
216 | |
217 window->type = SKINNED_WINDOW_TYPE; | |
218 | |
219 if (wmclass_name) | |
220 gtk_window_set_wmclass(GTK_WINDOW(widget), wmclass_name, "Audacious"); | |
221 | |
222 gtk_widget_add_events(GTK_WIDGET(widget), | |
223 GDK_FOCUS_CHANGE_MASK | GDK_BUTTON_MOTION_MASK | | |
224 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | | |
225 GDK_SCROLL_MASK | GDK_KEY_PRESS_MASK | | |
226 GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK); | |
227 gtk_widget_realize(GTK_WIDGET(widget)); | |
228 | |
229 set_dock_window_list(dock_window_set_decorated(get_dock_window_list(), | |
230 GTK_WINDOW(widget), | |
231 aud_cfg->show_wm_decorations)); | |
232 gtk_widget_set_app_paintable(GTK_WIDGET(widget), TRUE); | |
233 gdk_window_set_back_pixmap(widget->window, NULL, FALSE); | |
234 gtk_widget_shape_combine_mask(widget, NULL, 0, 0); | |
235 | |
236 if (!strcmp(wmclass_name, "player")) | |
237 SKINNED_WINDOW(widget)->type = WINDOW_MAIN; | |
238 if (!strcmp(wmclass_name, "equalizer")) | |
239 SKINNED_WINDOW(widget)->type = WINDOW_EQ; | |
240 if (!strcmp(wmclass_name, "playlist")) | |
241 SKINNED_WINDOW(widget)->type = WINDOW_PLAYLIST; | |
242 | |
243 /* GtkFixed hasn't got its GdkWindow, this means that it can be used to | |
244 display widgets while the logo below will be displayed anyway; | |
245 however fixed positions are not that great, cause the button sizes may (will) | |
246 vary depending on the gtk style used, so it's not possible to center | |
247 them unless a fixed width and heigth is forced (and this may bring to cutted | |
248 text if someone, i.e., uses a big font for gtk widgets); | |
249 other types of container most likely have their GdkWindow, this simply | |
250 means that the logo must be drawn on the container widget, instead of the | |
251 window; otherwise, it won't be displayed correctly */ | |
252 SKINNED_WINDOW(widget)->fixed = gtk_fixed_new(); | |
253 gtk_container_add(GTK_CONTAINER(widget), GTK_WIDGET(SKINNED_WINDOW(widget)->fixed)); | |
254 return widget; | |
255 } | |
256 | |
257 void ui_skinned_window_draw_all(GtkWidget *widget) { | |
258 #if 0 | |
259 if (SKINNED_WINDOW(widget)->type == WINDOW_MAIN) | |
260 mainwin_refresh_hints(); | |
261 #endif | |
262 gtk_widget_queue_draw(widget); | |
263 GList *iter; | |
264 for (iter = GTK_FIXED (SKINNED_WINDOW(widget)->fixed)->children; iter; iter = g_list_next (iter)) { | |
265 GtkFixedChild *child_data = (GtkFixedChild *) iter->data; | |
266 GtkWidget *child = child_data->widget; | |
267 gtk_widget_queue_draw(child); | |
268 } | |
269 } |