Mercurial > audlegacy

comparison src/audacious/ui_skinned_button.c @ 2842:c2622a939e9e trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
rename audacious_pbutton to ui_skinned_button
author Tomasz Mon <desowin@gmail.com>
date Sun, 17 Jun 2007 12:54:59 +0200
parents src/audacious/widgets/audacious_pbutton.c@0598469fe2a9
children 91ef09fe7936
comparison
equal deleted inserted replaced
2841:b2fb6a4e02b8 2842:c2622a939e9e
1 /*
2 * Audacious - a cross-platform multimedia player
3 * Copyright (c) 2007 Audacious development team.
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; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 */
19
20 #include "widgets/widgetcore.h"
21 #include "ui_skinned_button.h"
22 #include "util.h"
23
24 #include <gtk/gtkmain.h>
25 #include <gtk/gtkmarshal.h>
26 #include <gtk/gtkimage.h>
27
28 #define UI_SKINNED_BUTTON_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), UI_TYPE_SKINNED_BUTTON, UiSkinnedButtonPrivate))
29 typedef struct _UiSkinnedButtonPrivate UiSkinnedButtonPrivate;
30
31 struct _UiSkinnedButtonPrivate {
32 //Skinned part
33 GtkWidget *image;
34 GdkGC *gc;
35 gint w;
36 gint h;
37 SkinPixmapId skin_index1;
38 SkinPixmapId skin_index2;
39 GtkWidget *fixed;
40 gboolean double_size;
41 };
42
43
44 static GtkBinClass *parent_class = NULL;
45 static void ui_skinned_button_class_init(UiSkinnedButtonClass *klass);
46 static void ui_skinned_button_init(UiSkinnedButton *button);
47 static GObject* ui_skinned_button_constructor(GType type, guint n_construct_properties, GObjectConstructParam *construct_params);
48 static void ui_skinned_button_destroy(GtkObject *object);
49 static void ui_skinned_button_realize(GtkWidget *widget);
50 static void ui_skinned_button_unrealize(GtkWidget *widget);
51 static void ui_skinned_button_map(GtkWidget *widget);
52 static void ui_skinned_button_unmap(GtkWidget *widget);
53 static gint ui_skinned_button_expose(GtkWidget *widget,GdkEventExpose *event);
54
55 static void ui_skinned_button_size_allocate(GtkWidget *widget, GtkAllocation *allocation);
56 static void ui_skinned_button_update_state(UiSkinnedButton *button);
57
58 static guint button_signals[LAST_SIGNAL] = { 0 };
59 static gint ui_skinned_button_button_press(GtkWidget *widget, GdkEventButton *event);
60 static gint ui_skinned_button_button_release(GtkWidget *widget, GdkEventButton *event);
61 static void button_pressed(UiSkinnedButton *button);
62 static void button_released(UiSkinnedButton *button);
63 static void ui_skinned_button_pressed(UiSkinnedButton *button);
64 static void ui_skinned_button_released(UiSkinnedButton *button);
65 static void ui_skinned_button_clicked(UiSkinnedButton *button);
66 static void ui_skinned_button_set_pressed (UiSkinnedButton *button, gboolean pressed);
67
68 static void ui_skinned_button_add(GtkContainer *container, GtkWidget *widget);
69 static void ui_skinned_button_toggle_doublesize(UiSkinnedButton *button);
70
71 static gint ui_skinned_button_enter_notify(GtkWidget *widget, GdkEventCrossing *event);
72 static gint ui_skinned_button_leave_notify(GtkWidget *widget, GdkEventCrossing *event);
73 static void ui_skinned_button_paint(UiSkinnedButton *button);
74 static void ui_skinned_button_redraw(UiSkinnedButton *button);
75
76 GType ui_skinned_button_get_type (void) {
77 static GType button_type = 0;
78
79 if (!button_type) {
80 static const GTypeInfo button_info = {
81 sizeof (UiSkinnedButtonClass),
82 NULL, /* base_init */
83 NULL, /* base_finalize */
84 (GClassInitFunc) ui_skinned_button_class_init,
85 NULL, /* class_finalize */
86 NULL, /* class_data */
87 sizeof (UiSkinnedButton),
88 16, /* n_preallocs */
89 (GInstanceInitFunc) ui_skinned_button_init,
90 };
91
92 button_type = g_type_register_static (GTK_TYPE_BIN, "UiSkinnedButton", &button_info, 0);
93 }
94 return button_type;
95 }
96
97 static void ui_skinned_button_class_init (UiSkinnedButtonClass *klass) {
98 GObjectClass *gobject_class;
99 GtkObjectClass *object_class;
100 GtkWidgetClass *widget_class;
101 GtkContainerClass *container_class;
102
103 gobject_class = G_OBJECT_CLASS(klass);
104 object_class = (GtkObjectClass*)klass;
105 widget_class = (GtkWidgetClass*)klass;
106 container_class = (GtkContainerClass*)klass;
107
108 parent_class = g_type_class_peek_parent(klass);
109 gobject_class->constructor = ui_skinned_button_constructor;
110 object_class->destroy = ui_skinned_button_destroy;
111
112 widget_class->realize = ui_skinned_button_realize;
113 widget_class->unrealize = ui_skinned_button_unrealize;
114 widget_class->map = ui_skinned_button_map;
115 widget_class->unmap = ui_skinned_button_unmap;
116 widget_class->size_allocate = ui_skinned_button_size_allocate;
117 widget_class->expose_event = ui_skinned_button_expose;
118 widget_class->button_press_event = ui_skinned_button_button_press;
119 widget_class->button_release_event = ui_skinned_button_button_release;
120 widget_class->enter_notify_event = ui_skinned_button_enter_notify;
121 widget_class->leave_notify_event = ui_skinned_button_leave_notify;
122
123 container_class->add = ui_skinned_button_add;
124
125 klass->pressed = button_pressed;
126 klass->released = button_released;
127 klass->clicked = NULL;
128 klass->doubled = ui_skinned_button_toggle_doublesize;
129 klass->redraw = ui_skinned_button_redraw;
130
131 button_signals[PRESSED] =
132 g_signal_new ("pressed", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST,
133 G_STRUCT_OFFSET (UiSkinnedButtonClass, pressed), NULL, NULL,
134 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
135
136 button_signals[RELEASED] =
137 g_signal_new ("released", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST,
138 G_STRUCT_OFFSET (UiSkinnedButtonClass, released), NULL, NULL,
139 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
140
141 button_signals[CLICKED] =
142 g_signal_new ("clicked", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
143 G_STRUCT_OFFSET (UiSkinnedButtonClass, clicked), NULL, NULL,
144 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
145
146 button_signals[DOUBLED] =
147 g_signal_new ("toggle-double-size", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
148 G_STRUCT_OFFSET (UiSkinnedButtonClass, doubled), NULL, NULL,
149 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
150
151 button_signals[REDRAW] =
152 g_signal_new ("redraw", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
153 G_STRUCT_OFFSET (UiSkinnedButtonClass, redraw), NULL, NULL,
154 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
155
156 g_type_class_add_private (gobject_class, sizeof (UiSkinnedButtonPrivate));
157 }
158
159 static void ui_skinned_button_init (UiSkinnedButton *button) {
160 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE (button);
161 priv->image = gtk_image_new();
162 button->redraw = TRUE;
163
164 g_object_set (priv->image, "visible", TRUE, NULL);
165 gtk_container_add(GTK_CONTAINER(GTK_WIDGET(button)), priv->image);
166
167 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_FOCUS);
168 GTK_WIDGET_SET_FLAGS (button, GTK_NO_WINDOW);
169 }
170
171 static void ui_skinned_button_destroy (GtkObject *object) {
172 (*GTK_OBJECT_CLASS (parent_class)->destroy) (object);
173 }
174
175 static GObject* ui_skinned_button_constructor(GType type, guint n_construct_properties, GObjectConstructParam *construct_params) {
176 GObject *object = (*G_OBJECT_CLASS (parent_class)->constructor)(type, n_construct_properties, construct_params);
177
178 return object;
179 }
180
181 static void ui_skinned_button_realize (GtkWidget *widget) {
182 UiSkinnedButton *button = UI_SKINNED_BUTTON (widget);
183 GdkWindowAttr attrib;
184
185 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
186
187 attrib.window_type = GDK_WINDOW_CHILD;
188 attrib.x = widget->allocation.x;
189 attrib.y = widget->allocation.y;
190 attrib.width = widget->allocation.width;
191 attrib.height = widget->allocation.height;
192 attrib.wclass = GDK_INPUT_ONLY;
193 attrib.event_mask = gtk_widget_get_events (widget);
194 attrib.event_mask |= (GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
195
196 widget->window = gtk_widget_get_parent_window(widget);
197 g_object_ref(widget->window);
198
199 button->event_window = gdk_window_new(gtk_widget_get_parent_window(widget), &attrib, GDK_WA_X | GDK_WA_Y);
200 gdk_window_set_user_data (button->event_window, button);
201 }
202
203 static void ui_skinned_button_unrealize(GtkWidget *widget) {
204 UiSkinnedButton *button = UI_SKINNED_BUTTON (widget);
205
206 if (button->event_window) {
207 gdk_window_set_user_data (button->event_window, NULL);
208 gdk_window_destroy (button->event_window);
209 button->event_window = NULL;
210 }
211
212 GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
213 }
214
215 static void ui_skinned_button_map(GtkWidget *widget) {
216 UiSkinnedButton *button = UI_SKINNED_BUTTON (widget);
217 g_return_if_fail (UI_IS_SKINNED_BUTTON (widget));
218 GTK_WIDGET_CLASS (parent_class)->map(widget);
219 gdk_window_show (button->event_window);
220 }
221
222 static void ui_skinned_button_unmap (GtkWidget *widget) {
223 UiSkinnedButton *button = UI_SKINNED_BUTTON (widget);
224 g_return_if_fail (UI_IS_SKINNED_BUTTON(widget));
225
226 if (button->event_window)
227 gdk_window_hide (button->event_window);
228
229 GTK_WIDGET_CLASS (parent_class)->unmap (widget);
230 }
231
232 static gboolean ui_skinned_button_expose(GtkWidget *widget, GdkEventExpose *event) {
233 if (GTK_WIDGET_DRAWABLE (widget))
234 (*GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
235
236 return FALSE;
237 }
238
239 GtkWidget* ui_skinned_button_new () {
240 return g_object_new (UI_TYPE_SKINNED_BUTTON, NULL);
241 }
242
243 void ui_skinned_push_button_setup(GtkWidget *button, GtkWidget *fixed, GdkPixmap *parent, GdkGC *gc, gint x, gint y, gint w, gint h, gint nx, gint ny, gint px, gint py, SkinPixmapId si) {
244
245 UiSkinnedButton *sbutton = UI_SKINNED_BUTTON(button);
246 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE(sbutton);
247 priv->gc = gc;
248 priv->w = w;
249 priv->h = h;
250 sbutton->x = x;
251 sbutton->y = y;
252 sbutton->nx = nx;
253 sbutton->ny = ny;
254 sbutton->px = px;
255 sbutton->py = py;
256 priv->skin_index1 = si;
257 priv->skin_index2 = si;
258 priv->fixed = fixed;
259 priv->double_size = FALSE;
260
261 gtk_widget_set_size_request(button, priv->w, priv->h);
262 gtk_fixed_put(GTK_FIXED(priv->fixed),GTK_WIDGET(button), sbutton->x, sbutton->y);
263 }
264
265 static void ui_skinned_button_size_allocate(GtkWidget *widget, GtkAllocation *allocation) {
266 UiSkinnedButton *button = UI_SKINNED_BUTTON (widget);
267 GtkAllocation child_alloc;
268
269 widget->allocation = *allocation;
270 if (GTK_BIN (button)->child) { //image should fill whole widget
271 child_alloc.x = widget->allocation.x;
272 child_alloc.y = widget->allocation.y;
273 child_alloc.width = MAX (1, widget->allocation.width);
274 child_alloc.height = MAX (1, widget->allocation.height);
275
276 gtk_widget_size_allocate (GTK_BIN (button)->child, &child_alloc);
277 }
278
279 if (GDK_IS_WINDOW(button->event_window))
280 gdk_window_move_resize (button->event_window, widget->allocation.x, widget->allocation.y,
281 widget->allocation.width, widget->allocation.height);
282 }
283
284 static void button_pressed(UiSkinnedButton *button) {
285 button->button_down = TRUE;
286 ui_skinned_button_update_state(button);
287 }
288
289 static void button_released(UiSkinnedButton *button) {
290 button->button_down = FALSE;
291 if(button->hover) ui_skinned_button_clicked(button);
292 ui_skinned_button_update_state(button);
293 }
294
295 static void ui_skinned_button_update_state(UiSkinnedButton *button) {
296 ui_skinned_button_set_pressed(button, button->button_down);
297 }
298
299 static void ui_skinned_button_set_pressed (UiSkinnedButton *button, gboolean pressed) {
300 if (pressed != button->pressed) {
301 button->pressed = pressed;
302 button->redraw = TRUE;
303 ui_skinned_button_paint(button);
304 }
305 }
306
307 static gboolean ui_skinned_button_button_press(GtkWidget *widget, GdkEventButton *event) {
308 UiSkinnedButton *button;
309
310 if (event->type == GDK_BUTTON_PRESS) {
311 button = UI_SKINNED_BUTTON(widget);
312
313 if (event->button == 1)
314 ui_skinned_button_pressed (button);
315 }
316
317 return TRUE;
318 }
319
320 static gboolean ui_skinned_button_button_release(GtkWidget *widget, GdkEventButton *event) {
321 UiSkinnedButton *button;
322 if (event->button == 1) {
323 button = UI_SKINNED_BUTTON(widget);
324 button->redraw = TRUE;
325 ui_skinned_button_released(button);
326 }
327
328 return TRUE;
329 }
330
331 static void ui_skinned_button_pressed(UiSkinnedButton *button) {
332 g_return_if_fail(UI_IS_SKINNED_BUTTON(button));
333 g_signal_emit(button, button_signals[PRESSED], 0);
334 }
335
336 static void ui_skinned_button_released(UiSkinnedButton *button) {
337 g_return_if_fail(UI_IS_SKINNED_BUTTON(button));
338 g_signal_emit(button, button_signals[RELEASED], 0);
339 }
340
341 static void ui_skinned_button_clicked(UiSkinnedButton *button) {
342 g_return_if_fail(UI_IS_SKINNED_BUTTON(button));
343 g_signal_emit(button, button_signals[CLICKED], 0);
344 }
345
346 static gboolean ui_skinned_button_enter_notify(GtkWidget *widget, GdkEventCrossing *event) {
347 UiSkinnedButton *button;
348
349 button = UI_SKINNED_BUTTON(widget);
350 button->hover = TRUE;
351 if(button->button_down) ui_skinned_button_set_pressed(button, TRUE);
352
353 return FALSE;
354 }
355
356 static gboolean ui_skinned_button_leave_notify(GtkWidget *widget, GdkEventCrossing *event) {
357 UiSkinnedButton *button;
358
359 button = UI_SKINNED_BUTTON (widget);
360 button->hover = FALSE;
361 if(button->button_down) ui_skinned_button_set_pressed(button, FALSE);
362
363 return FALSE;
364 }
365
366 static void ui_skinned_button_add(GtkContainer *container, GtkWidget *widget) {
367 GTK_CONTAINER_CLASS (parent_class)->add(container, widget);
368 }
369
370 static void ui_skinned_button_toggle_doublesize(UiSkinnedButton *button) {
371 GtkWidget *widget = GTK_WIDGET (button);
372 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE (button);
373 priv->double_size = !priv->double_size;
374
375 gtk_widget_set_size_request(widget, priv->w*(1+priv->double_size), priv->h*(1+priv->double_size));
376 gtk_widget_set_uposition(widget, button->x*(1+priv->double_size), button->y*(1+priv->double_size));
377
378 button->redraw = TRUE;
379 ui_skinned_button_paint(button);
380 }
381
382 static void ui_skinned_button_paint(UiSkinnedButton *button) {
383 GtkWidget *widget = GTK_WIDGET (button);
384 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE (button);
385
386 if (button->redraw == TRUE) {
387 button->redraw = FALSE;
388 GdkPixmap *obj;
389 obj = gdk_pixmap_new(NULL, priv->w, priv->h, gdk_rgb_get_visual()->depth);
390 skin_draw_pixmap(bmp_active_skin, obj, priv->gc, priv->skin_index2,
391 button->pressed ? button->px : button->nx,
392 button->pressed ? button->py : button->ny,
393 0, 0, priv->w, priv->h);
394 if(priv->double_size) {
395 GdkImage *img, *img2x;
396 img = gdk_drawable_get_image(obj, 0, 0, priv->w, priv->h);
397 img2x = create_dblsize_image(img);
398 gtk_image_set(GTK_IMAGE(priv->image), img2x, NULL);
399 g_object_unref(img2x);
400 g_object_unref(img);
401 } else
402 gtk_image_set_from_pixmap(GTK_IMAGE(priv->image), obj, NULL);
403 g_object_unref(obj);
404 gtk_widget_queue_resize(widget);
405 }
406 }
407
408 static void ui_skinned_button_redraw(UiSkinnedButton *button) {
409 button->redraw = TRUE;
410 ui_skinned_button_paint(button);
411 }