2585
|
1 /*
|
|
2 * Audacious - a cross-platform multimedia player
|
|
3 * Copyright (c) 2007 Tomasz Moń
|
|
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 "ui_skinned_button.h"
|
|
22 #include "skins_cfg.h"
|
|
23 #include <math.h>
|
|
24
|
|
25 #define UI_SKINNED_BUTTON_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), ui_skinned_button_get_type(), UiSkinnedButtonPrivate))
|
|
26 typedef struct _UiSkinnedButtonPrivate UiSkinnedButtonPrivate;
|
|
27
|
|
28 enum {
|
|
29 PRESSED,
|
|
30 RELEASED,
|
|
31 CLICKED,
|
|
32 DOUBLED,
|
|
33 REDRAW,
|
|
34 LAST_SIGNAL
|
|
35 };
|
|
36
|
|
37 struct _UiSkinnedButtonPrivate {
|
|
38 //Skinned part
|
|
39 GdkGC *gc;
|
|
40 gint w;
|
|
41 gint h;
|
|
42 SkinPixmapId skin_index1;
|
|
43 SkinPixmapId skin_index2;
|
|
44 gboolean scaled;
|
|
45 gint move_x, move_y;
|
|
46
|
|
47 gint nx, ny, px, py;
|
|
48 //Toogle button needs also those
|
|
49 gint pnx, pny, ppx, ppy;
|
|
50 };
|
|
51
|
|
52
|
|
53 static GtkWidgetClass *parent_class = NULL;
|
|
54 static void ui_skinned_button_class_init(UiSkinnedButtonClass *klass);
|
|
55 static void ui_skinned_button_init(UiSkinnedButton *button);
|
|
56 static void ui_skinned_button_destroy(GtkObject *object);
|
|
57 static void ui_skinned_button_realize(GtkWidget *widget);
|
|
58 static void ui_skinned_button_unrealize(GtkWidget *widget);
|
|
59 static void ui_skinned_button_map(GtkWidget *widget);
|
|
60 static void ui_skinned_button_unmap(GtkWidget *widget);
|
|
61 static void ui_skinned_button_size_request(GtkWidget *widget, GtkRequisition *requisition);
|
|
62 static gint ui_skinned_button_expose(GtkWidget *widget,GdkEventExpose *event);
|
|
63
|
|
64 static void ui_skinned_button_size_allocate(GtkWidget *widget, GtkAllocation *allocation);
|
|
65 static void ui_skinned_button_update_state(UiSkinnedButton *button);
|
|
66
|
|
67 static guint button_signals[LAST_SIGNAL] = { 0 };
|
|
68 static gint ui_skinned_button_button_press(GtkWidget *widget, GdkEventButton *event);
|
|
69 static gint ui_skinned_button_button_release(GtkWidget *widget, GdkEventButton *event);
|
|
70 static void button_pressed(UiSkinnedButton *button);
|
|
71 static void button_released(UiSkinnedButton *button);
|
|
72 static void ui_skinned_button_pressed(UiSkinnedButton *button);
|
|
73 static void ui_skinned_button_released(UiSkinnedButton *button);
|
|
74 static void ui_skinned_button_clicked(UiSkinnedButton *button);
|
|
75 static void ui_skinned_button_set_pressed (UiSkinnedButton *button, gboolean pressed);
|
|
76
|
|
77 static void ui_skinned_button_toggle_scaled(UiSkinnedButton *button);
|
|
78
|
|
79 static gint ui_skinned_button_enter_notify(GtkWidget *widget, GdkEventCrossing *event);
|
|
80 static gint ui_skinned_button_leave_notify(GtkWidget *widget, GdkEventCrossing *event);
|
|
81 static void ui_skinned_button_redraw(UiSkinnedButton *button);
|
|
82
|
|
83 GType ui_skinned_button_get_type() {
|
|
84 static GType button_type = 0;
|
|
85 if (!button_type) {
|
|
86 static const GTypeInfo button_info = {
|
|
87 sizeof (UiSkinnedButtonClass),
|
|
88 NULL,
|
|
89 NULL,
|
|
90 (GClassInitFunc) ui_skinned_button_class_init,
|
|
91 NULL,
|
|
92 NULL,
|
|
93 sizeof (UiSkinnedButton),
|
|
94 0,
|
|
95 (GInstanceInitFunc) ui_skinned_button_init,
|
|
96 };
|
|
97 button_type = g_type_register_static (GTK_TYPE_WIDGET, "UiSkinnedButton_", &button_info, 0);
|
|
98 }
|
|
99
|
|
100 return button_type;
|
|
101 }
|
|
102
|
|
103 static void ui_skinned_button_class_init (UiSkinnedButtonClass *klass) {
|
|
104 GObjectClass *gobject_class;
|
|
105 GtkObjectClass *object_class;
|
|
106 GtkWidgetClass *widget_class;
|
|
107
|
|
108 gobject_class = G_OBJECT_CLASS(klass);
|
|
109 object_class = (GtkObjectClass*) klass;
|
|
110 widget_class = (GtkWidgetClass*) klass;
|
|
111 parent_class = gtk_type_class (gtk_widget_get_type ());
|
|
112
|
|
113 object_class->destroy = ui_skinned_button_destroy;
|
|
114
|
|
115 widget_class->realize = ui_skinned_button_realize;
|
|
116 widget_class->unrealize = ui_skinned_button_unrealize;
|
|
117 widget_class->map = ui_skinned_button_map;
|
|
118 widget_class->unmap = ui_skinned_button_unmap;
|
|
119 widget_class->expose_event = ui_skinned_button_expose;
|
|
120 widget_class->size_request = ui_skinned_button_size_request;
|
|
121 widget_class->size_allocate = ui_skinned_button_size_allocate;
|
|
122 widget_class->button_press_event = ui_skinned_button_button_press;
|
|
123 widget_class->button_release_event = ui_skinned_button_button_release;
|
|
124 widget_class->enter_notify_event = ui_skinned_button_enter_notify;
|
|
125 widget_class->leave_notify_event = ui_skinned_button_leave_notify;
|
|
126
|
|
127 klass->pressed = button_pressed;
|
|
128 klass->released = button_released;
|
|
129 klass->clicked = NULL;
|
|
130 klass->scaled = ui_skinned_button_toggle_scaled;
|
|
131 klass->redraw = ui_skinned_button_redraw;
|
|
132
|
|
133 button_signals[PRESSED] =
|
|
134 g_signal_new ("pressed", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST,
|
|
135 G_STRUCT_OFFSET (UiSkinnedButtonClass, pressed), NULL, NULL,
|
|
136 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
|
|
137
|
|
138 button_signals[RELEASED] =
|
|
139 g_signal_new ("released", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST,
|
|
140 G_STRUCT_OFFSET (UiSkinnedButtonClass, released), NULL, NULL,
|
|
141 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
|
|
142
|
|
143 button_signals[CLICKED] =
|
|
144 g_signal_new ("clicked", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
|
|
145 G_STRUCT_OFFSET (UiSkinnedButtonClass, clicked), NULL, NULL,
|
|
146 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
|
|
147
|
|
148 button_signals[DOUBLED] =
|
|
149 g_signal_new ("toggle-scaled", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
|
|
150 G_STRUCT_OFFSET (UiSkinnedButtonClass, scaled), NULL, NULL,
|
|
151 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
|
|
152
|
|
153 button_signals[REDRAW] =
|
|
154 g_signal_new ("redraw", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
|
|
155 G_STRUCT_OFFSET (UiSkinnedButtonClass, redraw), NULL, NULL,
|
|
156 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
|
|
157
|
|
158 g_type_class_add_private (gobject_class, sizeof (UiSkinnedButtonPrivate));
|
|
159 }
|
|
160
|
|
161 static void ui_skinned_button_init (UiSkinnedButton *button) {
|
|
162 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE (button);
|
|
163 button->inside = FALSE;
|
|
164 button->type = TYPE_NOT_SET;
|
|
165 priv->move_x = 0;
|
|
166 priv->move_y = 0;
|
|
167 button->event_window = NULL;
|
|
168 }
|
|
169
|
|
170 static void ui_skinned_button_destroy (GtkObject *object) {
|
|
171 UiSkinnedButton *button;
|
|
172
|
|
173 g_return_if_fail (object != NULL);
|
|
174 g_return_if_fail (UI_SKINNED_IS_BUTTON (object));
|
|
175
|
|
176 button = UI_SKINNED_BUTTON(object);
|
|
177
|
|
178 if (GTK_OBJECT_CLASS (parent_class)->destroy)
|
|
179 (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
|
|
180 }
|
|
181
|
|
182 static void ui_skinned_button_realize (GtkWidget *widget) {
|
|
183 g_return_if_fail (widget != NULL);
|
|
184 g_return_if_fail (UI_SKINNED_IS_BUTTON(widget));
|
|
185 UiSkinnedButton *button = UI_SKINNED_BUTTON (widget);
|
|
186 GdkWindowAttr attributes;
|
|
187 gint attributes_mask;
|
|
188
|
|
189 GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
|
|
190
|
|
191 attributes.x = widget->allocation.x;
|
|
192 attributes.y = widget->allocation.y;
|
|
193 attributes.width = widget->allocation.width;
|
|
194 attributes.height = widget->allocation.height;
|
|
195 attributes.window_type = GDK_WINDOW_CHILD;
|
|
196 attributes.event_mask = gtk_widget_get_events(widget);
|
|
197 attributes.event_mask |= GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK;
|
|
198
|
|
199 if (button->type == TYPE_SMALL || button->type == TYPE_NOT_SET) {
|
|
200 widget->window = gtk_widget_get_parent_window (widget);
|
|
201 g_object_ref (widget->window);
|
|
202 attributes.wclass = GDK_INPUT_ONLY;
|
|
203 attributes_mask = GDK_WA_X | GDK_WA_Y;
|
|
204 button->event_window = gdk_window_new (widget->window, &attributes, attributes_mask);
|
|
205 GTK_WIDGET_SET_FLAGS (widget, GTK_NO_WINDOW);
|
|
206 gdk_window_set_user_data(button->event_window, widget);
|
|
207 } else {
|
|
208 attributes.visual = gtk_widget_get_visual(widget);
|
|
209 attributes.colormap = gtk_widget_get_colormap(widget);
|
|
210 attributes.wclass = GDK_INPUT_OUTPUT;
|
|
211 attributes.event_mask |= GDK_EXPOSURE_MASK;
|
|
212 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
|
|
213 widget->window = gdk_window_new(widget->parent->window, &attributes, attributes_mask);
|
|
214 GTK_WIDGET_UNSET_FLAGS (widget, GTK_NO_WINDOW);
|
|
215 gdk_window_set_user_data(widget->window, widget);
|
|
216 }
|
|
217
|
|
218 widget->style = gtk_style_attach(widget->style, widget->window);
|
|
219 }
|
|
220
|
|
221 static void ui_skinned_button_unrealize (GtkWidget *widget) {
|
|
222 UiSkinnedButton *button = UI_SKINNED_BUTTON (widget);
|
|
223
|
|
224 if ( button->event_window != NULL )
|
|
225 {
|
|
226 gdk_window_set_user_data( button->event_window , NULL );
|
|
227 gdk_window_destroy( button->event_window );
|
|
228 button->event_window = NULL;
|
|
229 }
|
|
230
|
|
231 if (GTK_WIDGET_CLASS (parent_class)->unrealize)
|
|
232 (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
|
|
233 }
|
|
234
|
|
235 static void ui_skinned_button_map (GtkWidget *widget)
|
|
236 {
|
|
237 UiSkinnedButton *button = UI_SKINNED_BUTTON (widget);
|
|
238
|
|
239 if (button->event_window != NULL)
|
|
240 gdk_window_show (button->event_window);
|
|
241
|
|
242 if (GTK_WIDGET_CLASS (parent_class)->map)
|
|
243 (* GTK_WIDGET_CLASS (parent_class)->map) (widget);
|
|
244 }
|
|
245
|
|
246 static void ui_skinned_button_unmap (GtkWidget *widget)
|
|
247 {
|
|
248 UiSkinnedButton *button = UI_SKINNED_BUTTON (widget);
|
|
249
|
|
250 if (button->event_window != NULL)
|
|
251 gdk_window_hide (button->event_window);
|
|
252
|
|
253 if (GTK_WIDGET_CLASS (parent_class)->unmap)
|
|
254 (* GTK_WIDGET_CLASS (parent_class)->unmap) (widget);
|
|
255 }
|
|
256
|
|
257 static void ui_skinned_button_size_request(GtkWidget *widget, GtkRequisition *requisition) {
|
|
258 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE(widget);
|
|
259 requisition->width = priv->w*(priv->scaled ? config.scale_factor : 1);
|
|
260 requisition->height = priv->h*(priv->scaled ? config.scale_factor : 1);
|
|
261 }
|
|
262
|
|
263 static void ui_skinned_button_size_allocate(GtkWidget *widget, GtkAllocation *allocation) {
|
|
264 UiSkinnedButton *button = UI_SKINNED_BUTTON (widget);
|
|
265 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE (button);
|
|
266 widget->allocation = *allocation;
|
|
267 widget->allocation.x = ceil(widget->allocation.x*(priv->scaled ? config.scale_factor : 1));
|
|
268 widget->allocation.y = ceil(widget->allocation.y*(priv->scaled ? config.scale_factor : 1));
|
|
269
|
|
270 if (GTK_WIDGET_REALIZED (widget))
|
|
271 {
|
|
272 if ( button->event_window != NULL )
|
|
273 gdk_window_move_resize(button->event_window, ceil(allocation->x*(priv->scaled ? config.scale_factor : 1)), ceil(allocation->y*(priv->scaled ? config.scale_factor : 1)), allocation->width, allocation->height);
|
|
274 else
|
|
275 gdk_window_move_resize(widget->window, ceil(allocation->x*(priv->scaled ? config.scale_factor : 1)), ceil(allocation->y*(priv->scaled ? config.scale_factor : 1)), allocation->width, allocation->height);
|
|
276 }
|
|
277
|
|
278 if (button->x + priv->move_x == ceil(widget->allocation.x/(priv->scaled ? config.scale_factor : 1)))
|
|
279 priv->move_x = 0;
|
|
280 if (button->y + priv->move_y == ceil(widget->allocation.y/(priv->scaled ? config.scale_factor : 1)))
|
|
281 priv->move_y = 0;
|
|
282
|
|
283 button->x = ceil(widget->allocation.x/(priv->scaled ? config.scale_factor : 1));
|
|
284 button->y = ceil(widget->allocation.y/(priv->scaled ? config.scale_factor : 1));
|
|
285 }
|
|
286
|
|
287 static gboolean ui_skinned_button_expose(GtkWidget *widget, GdkEventExpose *event) {
|
|
288 g_return_val_if_fail (widget != NULL, FALSE);
|
|
289 g_return_val_if_fail (UI_SKINNED_IS_BUTTON (widget), FALSE);
|
|
290 g_return_val_if_fail (event != NULL, FALSE);
|
|
291
|
|
292 UiSkinnedButton *button = UI_SKINNED_BUTTON (widget);
|
|
293 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE (button);
|
|
294 g_return_val_if_fail (priv->w > 0 && priv->h > 0, FALSE);
|
|
295
|
|
296 //TYPE_SMALL doesn't have its own face
|
|
297 if (button->type == TYPE_SMALL || button->type == TYPE_NOT_SET)
|
|
298 return FALSE;
|
|
299
|
|
300 /* paranoia */
|
|
301 if (button->event_window != NULL)
|
|
302 return FALSE;
|
|
303
|
|
304 GdkPixbuf *obj;
|
|
305 obj = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, priv->w, priv->h);
|
|
306
|
|
307 switch (button->type) {
|
|
308 case TYPE_PUSH:
|
|
309 skin_draw_pixbuf(widget, aud_active_skin, obj,
|
|
310 button->pressed ? priv->skin_index2 : priv->skin_index1,
|
|
311 button->pressed ? priv->px : priv->nx,
|
|
312 button->pressed ? priv->py : priv->ny,
|
|
313 0, 0, priv->w, priv->h);
|
|
314 break;
|
|
315 case TYPE_TOGGLE:
|
|
316 if (button->inside)
|
|
317 skin_draw_pixbuf(widget, aud_active_skin, obj,
|
|
318 button->pressed ? priv->skin_index2 : priv->skin_index1,
|
|
319 button->pressed ? priv->ppx : priv->pnx,
|
|
320 button->pressed ? priv->ppy : priv->pny,
|
|
321 0, 0, priv->w, priv->h);
|
|
322 else
|
|
323 skin_draw_pixbuf(widget, aud_active_skin, obj,
|
|
324 button->pressed ? priv->skin_index2 : priv->skin_index1,
|
|
325 button->pressed ? priv->px : priv->nx,
|
|
326 button->pressed ? priv->py : priv->ny,
|
|
327 0, 0, priv->w, priv->h);
|
|
328 break;
|
|
329 default:
|
|
330 break;
|
|
331 }
|
|
332
|
|
333 ui_skinned_widget_draw(widget, obj, priv->w, priv->h, priv->scaled);
|
|
334 g_object_unref(obj);
|
|
335
|
|
336 return FALSE;
|
|
337 }
|
|
338
|
|
339 GtkWidget* ui_skinned_button_new () {
|
|
340 UiSkinnedButton *button = g_object_new (ui_skinned_button_get_type (), NULL);
|
|
341
|
|
342 return GTK_WIDGET(button);
|
|
343 }
|
|
344
|
|
345 void ui_skinned_push_button_setup(GtkWidget *button, GtkWidget *fixed, gint x, gint y, gint w, gint h, gint nx, gint ny, gint px, gint py, SkinPixmapId si) {
|
|
346
|
|
347 UiSkinnedButton *sbutton = UI_SKINNED_BUTTON(button);
|
|
348 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE(sbutton);
|
|
349 priv->w = w;
|
|
350 priv->h = h;
|
|
351 sbutton->x = x;
|
|
352 sbutton->y = y;
|
|
353 priv->nx = nx;
|
|
354 priv->ny = ny;
|
|
355 priv->px = px;
|
|
356 priv->py = py;
|
|
357 sbutton->type = TYPE_PUSH;
|
|
358 priv->skin_index1 = si;
|
|
359 priv->skin_index2 = si;
|
|
360 priv->scaled = FALSE;
|
|
361
|
|
362 gtk_fixed_put(GTK_FIXED(fixed), GTK_WIDGET(button), sbutton->x, sbutton->y);
|
|
363 }
|
|
364
|
|
365 void ui_skinned_toggle_button_setup(GtkWidget *button, GtkWidget *fixed, gint x, gint y, gint w, gint h, gint nx, gint ny, gint px, gint py, gint pnx, gint pny, gint ppx, gint ppy, SkinPixmapId si) {
|
|
366
|
|
367 UiSkinnedButton *sbutton = UI_SKINNED_BUTTON(button);
|
|
368 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE(sbutton);
|
|
369 priv->w = w;
|
|
370 priv->h = h;
|
|
371 sbutton->x = x;
|
|
372 sbutton->y = y;
|
|
373 priv->nx = nx;
|
|
374 priv->ny = ny;
|
|
375 priv->px = px;
|
|
376 priv->py = py;
|
|
377 priv->pnx = pnx;
|
|
378 priv->pny = pny;
|
|
379 priv->ppx = ppx;
|
|
380 priv->ppy = ppy;
|
|
381 sbutton->type = TYPE_TOGGLE;
|
|
382 priv->skin_index1 = si;
|
|
383 priv->skin_index2 = si;
|
|
384 priv->scaled = FALSE;
|
|
385
|
|
386 gtk_fixed_put(GTK_FIXED(fixed), GTK_WIDGET(button), sbutton->x, sbutton->y);
|
|
387 }
|
|
388
|
|
389 void ui_skinned_small_button_setup(GtkWidget *button, GtkWidget *fixed, gint x, gint y, gint w, gint h) {
|
|
390
|
|
391 UiSkinnedButton *sbutton = UI_SKINNED_BUTTON(button);
|
|
392 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE(sbutton);
|
|
393 priv->w = w;
|
|
394 priv->h = h;
|
|
395 sbutton->x = x;
|
|
396 sbutton->y = y;
|
|
397 sbutton->type = TYPE_SMALL;
|
|
398 priv->scaled = FALSE;
|
|
399
|
|
400 gtk_fixed_put(GTK_FIXED(fixed), GTK_WIDGET(button), sbutton->x, sbutton->y);
|
|
401 }
|
|
402
|
|
403 static void button_pressed(UiSkinnedButton *button) {
|
|
404 button->button_down = TRUE;
|
|
405 ui_skinned_button_update_state(button);
|
|
406 }
|
|
407
|
|
408 static void button_released(UiSkinnedButton *button) {
|
|
409 button->button_down = FALSE;
|
|
410 if(button->hover) ui_skinned_button_clicked(button);
|
|
411 ui_skinned_button_update_state(button);
|
|
412 }
|
|
413
|
|
414 static void ui_skinned_button_update_state(UiSkinnedButton *button) {
|
|
415 ui_skinned_button_set_pressed(button, button->button_down);
|
|
416 }
|
|
417
|
|
418 static void ui_skinned_button_set_pressed (UiSkinnedButton *button, gboolean pressed) {
|
|
419 if (pressed != button->pressed) {
|
|
420 button->pressed = pressed;
|
|
421 gtk_widget_queue_draw(GTK_WIDGET(button));
|
|
422 }
|
|
423 }
|
|
424
|
|
425 static gboolean ui_skinned_button_button_press(GtkWidget *widget, GdkEventButton *event) {
|
|
426 UiSkinnedButton *button;
|
|
427
|
|
428 if (event->type == GDK_BUTTON_PRESS) {
|
|
429 button = UI_SKINNED_BUTTON(widget);
|
|
430
|
|
431 if (event->button == 1)
|
|
432 ui_skinned_button_pressed (button);
|
|
433 else if (event->button == 3) {
|
|
434 event->x = event->x + button->x;
|
|
435 event->y = event->y + button->y;
|
|
436 return FALSE;
|
|
437 }
|
|
438 }
|
|
439
|
|
440 return TRUE;
|
|
441 }
|
|
442
|
|
443 static gboolean ui_skinned_button_button_release(GtkWidget *widget, GdkEventButton *event) {
|
|
444 UiSkinnedButton *button;
|
|
445 if (event->button == 1) {
|
|
446 button = UI_SKINNED_BUTTON(widget);
|
|
447 ui_skinned_button_released(button);
|
|
448 }
|
|
449 return TRUE;
|
|
450 }
|
|
451
|
|
452 static void ui_skinned_button_pressed(UiSkinnedButton *button) {
|
|
453 g_return_if_fail(UI_SKINNED_IS_BUTTON(button));
|
|
454 g_signal_emit(button, button_signals[PRESSED], 0);
|
|
455 }
|
|
456
|
|
457 static void ui_skinned_button_released(UiSkinnedButton *button) {
|
|
458 g_return_if_fail(UI_SKINNED_IS_BUTTON(button));
|
|
459 g_signal_emit(button, button_signals[RELEASED], 0);
|
|
460 }
|
|
461
|
|
462 static void ui_skinned_button_clicked(UiSkinnedButton *button) {
|
|
463 g_return_if_fail(UI_SKINNED_IS_BUTTON(button));
|
|
464 button->inside = !button->inside;
|
|
465 g_signal_emit(button, button_signals[CLICKED], 0);
|
|
466 }
|
|
467
|
|
468 static gboolean ui_skinned_button_enter_notify(GtkWidget *widget, GdkEventCrossing *event) {
|
|
469 UiSkinnedButton *button;
|
|
470
|
|
471 button = UI_SKINNED_BUTTON(widget);
|
|
472 button->hover = TRUE;
|
|
473 if(button->button_down) ui_skinned_button_set_pressed(button, TRUE);
|
|
474
|
|
475 return FALSE;
|
|
476 }
|
|
477
|
|
478 static gboolean ui_skinned_button_leave_notify(GtkWidget *widget, GdkEventCrossing *event) {
|
|
479 UiSkinnedButton *button;
|
|
480
|
|
481 button = UI_SKINNED_BUTTON (widget);
|
|
482 button->hover = FALSE;
|
|
483 if(button->button_down) ui_skinned_button_set_pressed(button, FALSE);
|
|
484
|
|
485 return FALSE;
|
|
486 }
|
|
487
|
|
488 static void ui_skinned_button_toggle_scaled(UiSkinnedButton *button) {
|
|
489 GtkWidget *widget = GTK_WIDGET (button);
|
|
490 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE (button);
|
|
491 priv->scaled = !priv->scaled;
|
|
492
|
|
493 gtk_widget_set_size_request(widget, priv->w*(priv->scaled ? config.scale_factor : 1), priv->h*(priv->scaled ? config.scale_factor : 1));
|
|
494
|
|
495 gtk_widget_queue_draw(widget);
|
|
496 }
|
|
497
|
|
498 static void ui_skinned_button_redraw(UiSkinnedButton *button) {
|
|
499 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE (button);
|
|
500 if (priv->move_x || priv->move_y)
|
|
501 gtk_fixed_move(GTK_FIXED(gtk_widget_get_parent(GTK_WIDGET(button))), GTK_WIDGET(button),
|
|
502 button->x+priv->move_x, button->y+priv->move_y);
|
|
503
|
|
504 gtk_widget_queue_draw(GTK_WIDGET(button));
|
|
505 }
|
|
506
|
|
507
|
|
508 void ui_skinned_set_push_button_data(GtkWidget *button, gint nx, gint ny, gint px, gint py) {
|
|
509 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE(button);
|
|
510 if (nx > -1) priv->nx = nx;
|
|
511 if (ny > -1) priv->ny = ny;
|
|
512 if (px > -1) priv->px = px;
|
|
513 if (py > -1) priv->py = py;
|
|
514 gtk_widget_queue_draw(button);
|
|
515 }
|
|
516
|
|
517 void ui_skinned_button_set_skin_index(GtkWidget *button, SkinPixmapId si) {
|
|
518 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE (button);
|
|
519 priv->skin_index1 = priv->skin_index2 = si;
|
|
520 }
|
|
521
|
|
522 void ui_skinned_button_set_skin_index1(GtkWidget *button, SkinPixmapId si) {
|
|
523 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE (button);
|
|
524 priv->skin_index1 = si;
|
|
525 }
|
|
526
|
|
527 void ui_skinned_button_set_skin_index2(GtkWidget *button, SkinPixmapId si) {
|
|
528 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE (button);
|
|
529 priv->skin_index2 = si;
|
|
530 }
|
|
531
|
|
532 void ui_skinned_button_move_relative(GtkWidget *button, gint x, gint y) {
|
|
533 UiSkinnedButtonPrivate *priv = UI_SKINNED_BUTTON_GET_PRIVATE (button);
|
|
534 priv->move_x += x;
|
|
535 priv->move_y += y;
|
|
536 }
|