Mercurial > audlegacy
comparison src/audacious/ui_skinned_menurow.c @ 3071:5ae86bc2233d
oops, forgot to include new files
author | Tomasz Mon <desowin@gmail.com> |
---|---|
date | Fri, 13 Jul 2007 21:49:14 +0200 |
parents | |
children | 4b076ad636e6 |
comparison
equal
deleted
inserted
replaced
3070:be5375dd588f | 3071:5ae86bc2233d |
---|---|
1 /* | |
2 * Audacious - a cross-platform multimedia player | |
3 * Copyright (c) 2007 Audacious development team. | |
4 * | |
5 * Based on: | |
6 * BMP - Cross-platform multimedia player | |
7 * Copyright (C) 2003-2004 BMP development team. | |
8 * XMMS: | |
9 * Copyright (C) 1998-2003 XMMS development team. | |
10 * | |
11 * This program is free software; you can redistribute it and/or modify | |
12 * it under the terms of the GNU General Public License as published by | |
13 * the Free Software Foundation; under version 2 of the License. | |
14 * | |
15 * This program is distributed in the hope that it will be useful, | |
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 * GNU General Public License for more details. | |
19 * | |
20 * You should have received a copy of the GNU General Public License | |
21 * along with this program; if not, write to the Free Software | |
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. | |
23 */ | |
24 | |
25 #include "widgets/widgetcore.h" | |
26 #include "ui_skinned_menurow.h" | |
27 #include "main.h" | |
28 #include "util.h" | |
29 #include <gtk/gtkmain.h> | |
30 #include <gtk/gtkmarshal.h> | |
31 #include <gtk/gtkimage.h> | |
32 | |
33 #define UI_TYPE_SKINNED_MENUROW (ui_skinned_menurow_get_type()) | |
34 | |
35 enum { | |
36 DOUBLED, | |
37 CHANGE, | |
38 RELEASE, | |
39 LAST_SIGNAL | |
40 }; | |
41 | |
42 static void ui_skinned_menurow_class_init (UiSkinnedMenurowClass *klass); | |
43 static void ui_skinned_menurow_init (UiSkinnedMenurow *menurow); | |
44 static void ui_skinned_menurow_destroy (GtkObject *object); | |
45 static void ui_skinned_menurow_realize (GtkWidget *widget); | |
46 static void ui_skinned_menurow_size_request (GtkWidget *widget, GtkRequisition *requisition); | |
47 static void ui_skinned_menurow_size_allocate (GtkWidget *widget, GtkAllocation *allocation); | |
48 static gboolean ui_skinned_menurow_expose (GtkWidget *widget, GdkEventExpose *event); | |
49 static MenuRowItem menurow_find_selected (UiSkinnedMenurow * mr, gint x, gint y); | |
50 static gboolean ui_skinned_menurow_button_press (GtkWidget *widget, GdkEventButton *event); | |
51 static gboolean ui_skinned_menurow_button_release (GtkWidget *widget, GdkEventButton *event); | |
52 static gboolean ui_skinned_menurow_motion_notify (GtkWidget *widget, GdkEventMotion *event); | |
53 static void ui_skinned_menurow_toggle_doublesize (UiSkinnedMenurow *menurow); | |
54 | |
55 static GtkWidgetClass *parent_class = NULL; | |
56 static guint menurow_signals[LAST_SIGNAL] = { 0 }; | |
57 | |
58 GType ui_skinned_menurow_get_type() { | |
59 static GType menurow_type = 0; | |
60 if (!menurow_type) { | |
61 static const GTypeInfo menurow_info = { | |
62 sizeof (UiSkinnedMenurowClass), | |
63 NULL, | |
64 NULL, | |
65 (GClassInitFunc) ui_skinned_menurow_class_init, | |
66 NULL, | |
67 NULL, | |
68 sizeof (UiSkinnedMenurow), | |
69 0, | |
70 (GInstanceInitFunc) ui_skinned_menurow_init, | |
71 }; | |
72 menurow_type = g_type_register_static (GTK_TYPE_WIDGET, "UiSkinnedMenurow", &menurow_info, 0); | |
73 } | |
74 | |
75 return menurow_type; | |
76 } | |
77 | |
78 static void ui_skinned_menurow_class_init(UiSkinnedMenurowClass *klass) { | |
79 GObjectClass *gobject_class; | |
80 GtkObjectClass *object_class; | |
81 GtkWidgetClass *widget_class; | |
82 | |
83 gobject_class = G_OBJECT_CLASS(klass); | |
84 object_class = (GtkObjectClass*) klass; | |
85 widget_class = (GtkWidgetClass*) klass; | |
86 parent_class = gtk_type_class (gtk_widget_get_type ()); | |
87 | |
88 object_class->destroy = ui_skinned_menurow_destroy; | |
89 | |
90 widget_class->realize = ui_skinned_menurow_realize; | |
91 widget_class->expose_event = ui_skinned_menurow_expose; | |
92 widget_class->size_request = ui_skinned_menurow_size_request; | |
93 widget_class->size_allocate = ui_skinned_menurow_size_allocate; | |
94 widget_class->button_press_event = ui_skinned_menurow_button_press; | |
95 widget_class->button_release_event = ui_skinned_menurow_button_release; | |
96 widget_class->motion_notify_event = ui_skinned_menurow_motion_notify; | |
97 | |
98 klass->doubled = ui_skinned_menurow_toggle_doublesize; | |
99 klass->change = NULL; | |
100 klass->release = NULL; | |
101 | |
102 menurow_signals[DOUBLED] = | |
103 g_signal_new ("toggle-double-size", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, | |
104 G_STRUCT_OFFSET (UiSkinnedMenurowClass, doubled), NULL, NULL, | |
105 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); | |
106 | |
107 | |
108 menurow_signals[CHANGE] = | |
109 g_signal_new ("change", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, | |
110 G_STRUCT_OFFSET (UiSkinnedMenurowClass, change), NULL, NULL, | |
111 gtk_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); | |
112 | |
113 menurow_signals[RELEASE] = | |
114 g_signal_new ("release", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, | |
115 G_STRUCT_OFFSET (UiSkinnedMenurowClass, release), NULL, NULL, | |
116 gtk_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); | |
117 | |
118 } | |
119 | |
120 static void ui_skinned_menurow_init(UiSkinnedMenurow *menurow) { | |
121 menurow->doublesize_selected = cfg.doublesize; | |
122 menurow->always_selected = cfg.always_on_top; | |
123 } | |
124 | |
125 GtkWidget* ui_skinned_menurow_new(GtkWidget *fixed, gint x, gint y, gint nx, gint ny, gint sx, gint sy, SkinPixmapId si) { | |
126 UiSkinnedMenurow *menurow = g_object_new (ui_skinned_menurow_get_type (), NULL); | |
127 | |
128 menurow->x = x; | |
129 menurow->y = y; | |
130 menurow->width = 8; | |
131 menurow->height = 43; | |
132 menurow->nx = nx; | |
133 menurow->ny = ny; | |
134 menurow->sx = sx; | |
135 menurow->sy = sy; | |
136 menurow->selected = MENUROW_NONE; | |
137 | |
138 menurow->skin_index = si; | |
139 | |
140 menurow->fixed = fixed; | |
141 menurow->double_size = FALSE; | |
142 | |
143 gtk_fixed_put(GTK_FIXED(menurow->fixed), GTK_WIDGET(menurow), menurow->x, menurow->y); | |
144 | |
145 return GTK_WIDGET(menurow); | |
146 } | |
147 | |
148 static void ui_skinned_menurow_destroy(GtkObject *object) { | |
149 UiSkinnedMenurow *menurow; | |
150 | |
151 g_return_if_fail (object != NULL); | |
152 g_return_if_fail (UI_SKINNED_IS_MENUROW (object)); | |
153 | |
154 menurow = UI_SKINNED_MENUROW (object); | |
155 | |
156 if (GTK_OBJECT_CLASS (parent_class)->destroy) | |
157 (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); | |
158 } | |
159 | |
160 static void ui_skinned_menurow_realize(GtkWidget *widget) { | |
161 UiSkinnedMenurow *menurow; | |
162 GdkWindowAttr attributes; | |
163 gint attributes_mask; | |
164 | |
165 g_return_if_fail (widget != NULL); | |
166 g_return_if_fail (UI_SKINNED_IS_MENUROW(widget)); | |
167 | |
168 GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED); | |
169 menurow = UI_SKINNED_MENUROW(widget); | |
170 | |
171 attributes.x = widget->allocation.x; | |
172 attributes.y = widget->allocation.y; | |
173 attributes.width = widget->allocation.width; | |
174 attributes.height = widget->allocation.height; | |
175 attributes.wclass = GDK_INPUT_OUTPUT; | |
176 attributes.window_type = GDK_WINDOW_CHILD; | |
177 attributes.event_mask = gtk_widget_get_events(widget); | |
178 attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | | |
179 GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK; | |
180 attributes.visual = gtk_widget_get_visual(widget); | |
181 attributes.colormap = gtk_widget_get_colormap(widget); | |
182 | |
183 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; | |
184 widget->window = gdk_window_new(widget->parent->window, &attributes, attributes_mask); | |
185 | |
186 widget->style = gtk_style_attach(widget->style, widget->window); | |
187 | |
188 gdk_window_set_user_data(widget->window, widget); | |
189 } | |
190 | |
191 static void ui_skinned_menurow_size_request(GtkWidget *widget, GtkRequisition *requisition) { | |
192 UiSkinnedMenurow *menurow = UI_SKINNED_MENUROW(widget); | |
193 | |
194 requisition->width = menurow->width*(1+menurow->double_size); | |
195 requisition->height = menurow->height*(1+menurow->double_size); | |
196 } | |
197 | |
198 static void ui_skinned_menurow_size_allocate(GtkWidget *widget, GtkAllocation *allocation) { | |
199 UiSkinnedMenurow *menurow = UI_SKINNED_MENUROW (widget); | |
200 | |
201 widget->allocation = *allocation; | |
202 widget->allocation.x *= (1+menurow->double_size); | |
203 widget->allocation.y *= (1+menurow->double_size); | |
204 if (GTK_WIDGET_REALIZED (widget)) | |
205 gdk_window_move_resize(widget->window, widget->allocation.x, widget->allocation.y, allocation->width, allocation->height); | |
206 | |
207 menurow->x = widget->allocation.x/(menurow->double_size ? 2 : 1); | |
208 menurow->y = widget->allocation.y/(menurow->double_size ? 2 : 1); | |
209 } | |
210 | |
211 static gboolean ui_skinned_menurow_expose(GtkWidget *widget, GdkEventExpose *event) { | |
212 g_return_val_if_fail (widget != NULL, FALSE); | |
213 g_return_val_if_fail (UI_SKINNED_IS_MENUROW (widget), FALSE); | |
214 g_return_val_if_fail (event != NULL, FALSE); | |
215 | |
216 UiSkinnedMenurow *menurow = UI_SKINNED_MENUROW (widget); | |
217 | |
218 GdkPixmap *obj = NULL; | |
219 GdkGC *gc; | |
220 | |
221 obj = gdk_pixmap_new(NULL, menurow->width, menurow->height, gdk_rgb_get_visual()->depth); | |
222 gc = gdk_gc_new(obj); | |
223 | |
224 if (menurow->selected == MENUROW_NONE) { | |
225 if (cfg.always_show_cb || menurow->pushed) | |
226 skin_draw_pixmap(bmp_active_skin, obj, gc, menurow->skin_index, | |
227 menurow->nx, menurow->ny, 0, 0, 8, 43); | |
228 else | |
229 skin_draw_pixmap(bmp_active_skin, obj, gc, menurow->skin_index, | |
230 menurow->nx + 8, menurow->ny, 0, 0, 8, 43); | |
231 } | |
232 else { | |
233 skin_draw_pixmap(bmp_active_skin, obj, gc, menurow->skin_index, | |
234 menurow->sx + ((menurow->selected - 1) * 8), | |
235 menurow->sy, 0, 0, 8, 43); | |
236 } | |
237 if (cfg.always_show_cb || menurow->pushed) { | |
238 if (menurow->always_selected) | |
239 skin_draw_pixmap(bmp_active_skin, obj, gc, menurow->skin_index, | |
240 menurow->sx + 8, menurow->sy + 10, 0, 10, 8, 8); | |
241 if (menurow->doublesize_selected) | |
242 skin_draw_pixmap(bmp_active_skin, obj, gc, menurow->skin_index, | |
243 menurow->sx + 24, menurow->sy + 26, 0, 26, 8, 8); | |
244 } | |
245 | |
246 GdkPixmap *image; | |
247 image = gdk_pixmap_new(NULL, menurow->width*(1+menurow->double_size), | |
248 menurow->height*(1+menurow->double_size), | |
249 gdk_rgb_get_visual()->depth); | |
250 | |
251 if (menurow->double_size) { | |
252 GdkImage *img, *img2x; | |
253 img = gdk_drawable_get_image(obj, 0, 0, menurow->width, menurow->height); | |
254 img2x = create_dblsize_image(img); | |
255 gdk_draw_image (image, gc, img2x, 0, 0, 0, 0, menurow->width*2, menurow->height*2); | |
256 g_object_unref(img2x); | |
257 g_object_unref(img); | |
258 } else | |
259 gdk_draw_drawable (image, gc, obj, 0, 0, 0, 0, menurow->width, menurow->height); | |
260 | |
261 | |
262 g_object_unref(obj); | |
263 | |
264 gdk_draw_drawable (widget->window, gc, image, 0, 0, 0, 0, | |
265 menurow->width*(1+menurow->double_size), menurow->height*(1+menurow->double_size)); | |
266 g_object_unref(gc); | |
267 g_object_unref(image); | |
268 | |
269 return FALSE; | |
270 } | |
271 | |
272 static MenuRowItem menurow_find_selected(UiSkinnedMenurow * mr, gint x, gint y) { | |
273 MenuRowItem ret = MENUROW_NONE; | |
274 | |
275 x = x/(mr->double_size ? 2 : 1); | |
276 y = y/(mr->double_size ? 2 : 1); | |
277 if (x > 0 && x < 8) { | |
278 if (y >= 0 && y <= 10) | |
279 ret = MENUROW_OPTIONS; | |
280 if (y >= 10 && y <= 17) | |
281 ret = MENUROW_ALWAYS; | |
282 if (y >= 18 && y <= 25) | |
283 ret = MENUROW_FILEINFOBOX; | |
284 if (y >= 26 && y <= 33) | |
285 ret = MENUROW_DOUBLESIZE; | |
286 if (y >= 34 && y <= 42) | |
287 ret = MENUROW_VISUALIZATION; | |
288 } | |
289 return ret; | |
290 } | |
291 | |
292 static gboolean ui_skinned_menurow_button_press(GtkWidget *widget, GdkEventButton *event) { | |
293 g_return_val_if_fail (widget != NULL, FALSE); | |
294 g_return_val_if_fail (UI_SKINNED_IS_MENUROW (widget), FALSE); | |
295 g_return_val_if_fail (event != NULL, FALSE); | |
296 | |
297 UiSkinnedMenurow *menurow = UI_SKINNED_MENUROW (widget); | |
298 | |
299 if (event->type == GDK_BUTTON_PRESS) { | |
300 if (event->button == 1) { | |
301 | |
302 menurow->pushed = TRUE; | |
303 menurow->selected = menurow_find_selected(menurow, event->x, event->y); | |
304 | |
305 gtk_widget_queue_draw(widget); | |
306 g_signal_emit_by_name(widget, "change", menurow->selected); | |
307 } | |
308 } | |
309 | |
310 return TRUE; | |
311 } | |
312 | |
313 static gboolean ui_skinned_menurow_button_release(GtkWidget *widget, GdkEventButton *event) { | |
314 UiSkinnedMenurow *menurow = UI_SKINNED_MENUROW(widget); | |
315 if (menurow->pushed) { | |
316 menurow->pushed = FALSE; | |
317 | |
318 if (menurow->selected == MENUROW_ALWAYS) | |
319 menurow->always_selected = !menurow->always_selected; | |
320 | |
321 if (menurow->selected == MENUROW_DOUBLESIZE) | |
322 menurow->doublesize_selected = !menurow->doublesize_selected; | |
323 | |
324 if ((int)(menurow->selected) != -1) | |
325 g_signal_emit_by_name(widget, "release", menurow->selected); | |
326 | |
327 menurow->selected = MENUROW_NONE; | |
328 gtk_widget_queue_draw(widget); | |
329 } | |
330 | |
331 return TRUE; | |
332 } | |
333 | |
334 static gboolean ui_skinned_menurow_motion_notify(GtkWidget *widget, GdkEventMotion *event) { | |
335 g_return_val_if_fail (widget != NULL, FALSE); | |
336 g_return_val_if_fail (UI_SKINNED_IS_MENUROW (widget), FALSE); | |
337 g_return_val_if_fail (event != NULL, FALSE); | |
338 UiSkinnedMenurow *menurow = UI_SKINNED_MENUROW(widget); | |
339 | |
340 if (menurow->pushed) { | |
341 menurow->selected = menurow_find_selected(menurow, event->x, event->y); | |
342 | |
343 gtk_widget_queue_draw(widget); | |
344 g_signal_emit_by_name(widget, "change", menurow->selected); | |
345 } | |
346 | |
347 return TRUE; | |
348 } | |
349 | |
350 static void ui_skinned_menurow_toggle_doublesize(UiSkinnedMenurow *menurow) { | |
351 GtkWidget *widget = GTK_WIDGET (menurow); | |
352 | |
353 menurow->double_size = !menurow->double_size; | |
354 gtk_widget_set_size_request(widget, menurow->width*(1+menurow->double_size), menurow->height*(1+menurow->double_size)); | |
355 | |
356 gtk_widget_queue_draw(GTK_WIDGET(menurow)); | |
357 } |