Mercurial > audlegacy
annotate src/audacious/widgets/audacious_pbutton.c @ 2833:1e97a0a228b7 trunk
[svn] - reduce number of redraws
author | desowin |
---|---|
date | Wed, 13 Jun 2007 09:16:36 -0700 |
parents | 251fe210b6fd |
children | 0598469fe2a9 |
rev | line source |
---|---|
2822 | 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 "widgetcore.h" | |
21 #include "audacious_pbutton.h" | |
2827 | 22 #include "../util.h" |
2822 | 23 |
24 #include <gtk/gtkmain.h> | |
25 #include <gtk/gtkmarshal.h> | |
26 #include <gtk/gtkimage.h> | |
27 | |
28 #define AUDACIOUS_PBUTTON_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), AUDACIOUS_TYPE_PBUTTON, AudaciousPButtonPrivate)) | |
29 typedef struct _AudaciousPButtonPrivate AudaciousPButtonPrivate; | |
30 | |
31 struct _AudaciousPButtonPrivate { | |
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; | |
2827 | 40 gboolean double_size; |
2822 | 41 }; |
42 | |
43 | |
44 static GtkBinClass *parent_class = NULL; | |
45 static void audacious_pbutton_class_init(AudaciousPButtonClass *klass); | |
46 static void audacious_pbutton_init(AudaciousPButton *button); | |
47 static GObject* audacious_pbutton_constructor(GType type, guint n_construct_properties, GObjectConstructParam *construct_params); | |
48 static void audacious_pbutton_destroy(GtkObject *object); | |
49 static void audacious_pbutton_realize(GtkWidget *widget); | |
50 static void audacious_pbutton_unrealize(GtkWidget *widget); | |
51 static void audacious_pbutton_map(GtkWidget *widget); | |
52 static void audacious_pbutton_unmap(GtkWidget *widget); | |
53 static gint audacious_pbutton_expose(GtkWidget *widget,GdkEventExpose *event); | |
54 | |
55 static void audacious_pbutton_size_allocate(GtkWidget *widget, GtkAllocation *allocation); | |
56 static void audacious_pbutton_update_state(AudaciousPButton *button); | |
57 | |
58 static guint button_signals[LAST_SIGNAL] = { 0 }; | |
59 static gint audacious_pbutton_button_press(GtkWidget *widget, GdkEventButton *event); | |
60 static gint audacious_pbutton_button_release(GtkWidget *widget, GdkEventButton *event); | |
61 static void button_pressed(AudaciousPButton *button); | |
62 static void button_released(AudaciousPButton *button); | |
63 static void audacious_pbutton_add(GtkContainer *container, GtkWidget *widget); | |
2827 | 64 static void audacious_pbutton_toggle_doublesize(AudaciousPButton *button); |
2822 | 65 |
66 static gint audacious_pbutton_enter_notify(GtkWidget *widget, GdkEventCrossing *event); | |
67 static gint audacious_pbutton_leave_notify(GtkWidget *widget, GdkEventCrossing *event); | |
68 static void audacious_pbutton_paint(AudaciousPButton *button); | |
2833 | 69 static void audacious_pbutton_redraw(AudaciousPButton *button); |
2822 | 70 |
71 GType audacious_pbutton_get_type (void) { | |
72 static GType button_type = 0; | |
73 | |
74 if (!button_type) { | |
75 static const GTypeInfo button_info = { | |
76 sizeof (AudaciousPButtonClass), | |
77 NULL, /* base_init */ | |
78 NULL, /* base_finalize */ | |
79 (GClassInitFunc) audacious_pbutton_class_init, | |
80 NULL, /* class_finalize */ | |
81 NULL, /* class_data */ | |
82 sizeof (AudaciousPButton), | |
83 16, /* n_preallocs */ | |
84 (GInstanceInitFunc) audacious_pbutton_init, | |
85 }; | |
86 | |
87 button_type = g_type_register_static (GTK_TYPE_BIN, "AudaciousPButton", &button_info, 0); | |
88 } | |
89 return button_type; | |
90 } | |
91 | |
92 static void audacious_pbutton_class_init (AudaciousPButtonClass *klass) { | |
93 GObjectClass *gobject_class; | |
94 GtkObjectClass *object_class; | |
95 GtkWidgetClass *widget_class; | |
96 GtkContainerClass *container_class; | |
97 | |
98 gobject_class = G_OBJECT_CLASS(klass); | |
99 object_class = (GtkObjectClass*)klass; | |
100 widget_class = (GtkWidgetClass*)klass; | |
101 container_class = (GtkContainerClass*)klass; | |
102 | |
103 parent_class = g_type_class_peek_parent(klass); | |
104 gobject_class->constructor = audacious_pbutton_constructor; | |
105 object_class->destroy = audacious_pbutton_destroy; | |
106 | |
107 widget_class->realize = audacious_pbutton_realize; | |
108 widget_class->unrealize = audacious_pbutton_unrealize; | |
109 widget_class->map = audacious_pbutton_map; | |
110 widget_class->unmap = audacious_pbutton_unmap; | |
111 widget_class->size_allocate = audacious_pbutton_size_allocate; | |
112 widget_class->expose_event = audacious_pbutton_expose; | |
113 widget_class->button_press_event = audacious_pbutton_button_press; | |
114 widget_class->button_release_event = audacious_pbutton_button_release; | |
115 widget_class->enter_notify_event = audacious_pbutton_enter_notify; | |
116 widget_class->leave_notify_event = audacious_pbutton_leave_notify; | |
117 | |
118 container_class->add = audacious_pbutton_add; | |
119 | |
120 klass->pressed = button_pressed; | |
121 klass->released = button_released; | |
122 klass->clicked = NULL; | |
2827 | 123 klass->doubled = audacious_pbutton_toggle_doublesize; |
2833 | 124 klass->redraw = audacious_pbutton_redraw; |
2822 | 125 |
126 button_signals[PRESSED] = | |
127 g_signal_new ("pressed", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST, | |
128 G_STRUCT_OFFSET (AudaciousPButtonClass, pressed), NULL, NULL, | |
129 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); | |
130 | |
131 button_signals[RELEASED] = | |
132 g_signal_new ("released", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST, | |
133 G_STRUCT_OFFSET (AudaciousPButtonClass, released), NULL, NULL, | |
134 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); | |
135 | |
136 button_signals[CLICKED] = | |
137 g_signal_new ("clicked", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, | |
138 G_STRUCT_OFFSET (AudaciousPButtonClass, clicked), NULL, NULL, | |
139 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); | |
140 | |
141 button_signals[DOUBLED] = | |
2827 | 142 g_signal_new ("toggle-double-size", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, |
2822 | 143 G_STRUCT_OFFSET (AudaciousPButtonClass, doubled), NULL, NULL, |
144 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); | |
145 | |
2829
4eda78b785ed
[svn] - draw_main_window redraws custom gtk widgets
desowin
parents:
2828
diff
changeset
|
146 button_signals[REDRAW] = |
4eda78b785ed
[svn] - draw_main_window redraws custom gtk widgets
desowin
parents:
2828
diff
changeset
|
147 g_signal_new ("redraw", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, |
4eda78b785ed
[svn] - draw_main_window redraws custom gtk widgets
desowin
parents:
2828
diff
changeset
|
148 G_STRUCT_OFFSET (AudaciousPButtonClass, redraw), NULL, NULL, |
4eda78b785ed
[svn] - draw_main_window redraws custom gtk widgets
desowin
parents:
2828
diff
changeset
|
149 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); |
4eda78b785ed
[svn] - draw_main_window redraws custom gtk widgets
desowin
parents:
2828
diff
changeset
|
150 |
2822 | 151 g_type_class_add_private (gobject_class, sizeof (AudaciousPButtonPrivate)); |
152 } | |
153 | |
154 static void audacious_pbutton_init (AudaciousPButton *button) { | |
155 AudaciousPButtonPrivate *priv = AUDACIOUS_PBUTTON_GET_PRIVATE (button); | |
156 priv->image = gtk_image_new(); | |
2833 | 157 button->redraw = TRUE; |
158 | |
2822 | 159 g_object_set (priv->image, "visible", TRUE, NULL); |
160 gtk_container_add(GTK_CONTAINER(GTK_WIDGET(button)), priv->image); | |
161 | |
162 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_FOCUS); | |
163 GTK_WIDGET_SET_FLAGS (button, GTK_NO_WINDOW); | |
164 } | |
165 | |
166 static void audacious_pbutton_destroy (GtkObject *object) { | |
167 (*GTK_OBJECT_CLASS (parent_class)->destroy) (object); | |
168 } | |
169 | |
170 static GObject* audacious_pbutton_constructor(GType type, guint n_construct_properties, GObjectConstructParam *construct_params) { | |
171 GObject *object = (*G_OBJECT_CLASS (parent_class)->constructor)(type, n_construct_properties, construct_params); | |
172 | |
173 return object; | |
174 } | |
175 | |
176 static void audacious_pbutton_realize (GtkWidget *widget) { | |
177 AudaciousPButton *button = AUDACIOUS_PBUTTON (widget); | |
178 GdkWindowAttr attrib; | |
179 | |
180 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED); | |
181 | |
182 attrib.window_type = GDK_WINDOW_CHILD; | |
183 attrib.x = widget->allocation.x; | |
184 attrib.y = widget->allocation.y; | |
185 attrib.width = widget->allocation.width; | |
186 attrib.height = widget->allocation.height; | |
187 attrib.wclass = GDK_INPUT_ONLY; | |
188 attrib.event_mask = gtk_widget_get_events (widget); | |
189 attrib.event_mask |= (GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK); | |
190 | |
191 widget->window = gtk_widget_get_parent_window(widget); | |
192 g_object_ref(widget->window); | |
193 | |
194 button->event_window = gdk_window_new(gtk_widget_get_parent_window(widget), &attrib, GDK_WA_X | GDK_WA_Y); | |
195 gdk_window_set_user_data (button->event_window, button); | |
196 } | |
197 | |
198 static void audacious_pbutton_unrealize(GtkWidget *widget) { | |
199 AudaciousPButton *button = AUDACIOUS_PBUTTON (widget); | |
200 | |
201 if (button->event_window) { | |
202 gdk_window_set_user_data (button->event_window, NULL); | |
203 gdk_window_destroy (button->event_window); | |
204 button->event_window = NULL; | |
205 } | |
206 | |
207 GTK_WIDGET_CLASS (parent_class)->unrealize (widget); | |
208 } | |
209 | |
210 static void audacious_pbutton_map(GtkWidget *widget) { | |
211 AudaciousPButton *button = AUDACIOUS_PBUTTON (widget); | |
212 g_return_if_fail (AUDACIOUS_IS_PBUTTON (widget)); | |
213 GTK_WIDGET_CLASS (parent_class)->map(widget); | |
214 gdk_window_show (button->event_window); | |
215 } | |
216 | |
217 static void audacious_pbutton_unmap (GtkWidget *widget) { | |
218 AudaciousPButton *button = AUDACIOUS_PBUTTON (widget); | |
219 g_return_if_fail (AUDACIOUS_IS_PBUTTON(widget)); | |
220 | |
221 if (button->event_window) | |
222 gdk_window_hide (button->event_window); | |
223 | |
224 GTK_WIDGET_CLASS (parent_class)->unmap (widget); | |
225 } | |
226 | |
227 static gboolean audacious_pbutton_expose(GtkWidget *widget, GdkEventExpose *event) { | |
228 if (GTK_WIDGET_DRAWABLE (widget)) | |
229 (*GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event); | |
230 | |
231 return FALSE; | |
232 } | |
233 | |
234 GtkWidget* audacious_pbutton_new () { | |
235 return g_object_new (AUDACIOUS_TYPE_PBUTTON, NULL); | |
236 } | |
237 | |
238 void audacious_pbutton_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) { | |
239 | |
240 AudaciousPButton *pbutton = AUDACIOUS_PBUTTON(button); | |
241 AudaciousPButtonPrivate *priv = AUDACIOUS_PBUTTON_GET_PRIVATE(pbutton); | |
242 priv->gc = gc; | |
243 priv->w = w; | |
244 priv->h = h; | |
245 pbutton->x = x; | |
246 pbutton->y = y; | |
247 pbutton->nx = nx; | |
248 pbutton->ny = ny; | |
249 pbutton->px = px; | |
250 pbutton->py = py; | |
251 priv->skin_index1 = si; | |
252 priv->skin_index2 = si; | |
253 priv->fixed = fixed; | |
2827 | 254 priv->double_size = FALSE; |
2822 | 255 |
256 gtk_widget_set_size_request(button, priv->w, priv->h); | |
257 gtk_fixed_put(GTK_FIXED(priv->fixed),GTK_WIDGET(button), pbutton->x, pbutton->y); | |
258 } | |
259 | |
260 static void audacious_pbutton_size_allocate(GtkWidget *widget, GtkAllocation *allocation) { | |
261 AudaciousPButton *button = AUDACIOUS_PBUTTON (widget); | |
262 GtkAllocation child_alloc; | |
263 | |
264 widget->allocation = *allocation; | |
265 if (GTK_BIN (button)->child) { //image should fill whole widget | |
266 child_alloc.x = widget->allocation.x; | |
267 child_alloc.y = widget->allocation.y; | |
268 child_alloc.width = MAX (1, widget->allocation.width); | |
269 child_alloc.height = MAX (1, widget->allocation.height); | |
270 | |
271 gtk_widget_size_allocate (GTK_BIN (button)->child, &child_alloc); | |
272 } | |
2828 | 273 |
274 if (GDK_IS_WINDOW(button->event_window)) | |
275 gdk_window_move_resize (button->event_window, widget->allocation.x, widget->allocation.y, | |
276 widget->allocation.width, widget->allocation.height); | |
2822 | 277 } |
278 | |
279 static void button_pressed(AudaciousPButton *button) { | |
280 button->button_down = TRUE; | |
281 audacious_pbutton_update_state(button); | |
282 } | |
283 | |
284 static void button_released(AudaciousPButton *button) { | |
285 button->button_down = FALSE; | |
286 if(button->hover) audacious_pbutton_clicked(button); | |
287 audacious_pbutton_update_state(button); | |
288 } | |
289 | |
290 static void audacious_pbutton_update_state(AudaciousPButton *button) { | |
291 _audacious_pbutton_set_pressed(button, button->button_down); | |
292 } | |
293 | |
294 void _audacious_pbutton_set_pressed (AudaciousPButton *button, gboolean pressed) { | |
295 if (pressed != button->pressed) { | |
296 button->pressed = pressed; | |
2833 | 297 button->redraw = TRUE; |
2822 | 298 audacious_pbutton_paint(button); |
299 } | |
300 } | |
301 | |
302 static gboolean audacious_pbutton_button_press(GtkWidget *widget, GdkEventButton *event) { | |
303 AudaciousPButton *button; | |
304 | |
305 if (event->type == GDK_BUTTON_PRESS) { | |
306 button = AUDACIOUS_PBUTTON(widget); | |
307 | |
308 if (event->button == 1) | |
309 audacious_pbutton_pressed (button); | |
310 } | |
311 | |
312 return TRUE; | |
313 } | |
314 | |
315 static gboolean audacious_pbutton_button_release(GtkWidget *widget, GdkEventButton *event) { | |
316 AudaciousPButton *button; | |
317 if (event->button == 1) { | |
318 button = AUDACIOUS_PBUTTON(widget); | |
2833 | 319 button->redraw = TRUE; |
2822 | 320 audacious_pbutton_released(button); |
321 } | |
322 | |
323 return TRUE; | |
324 } | |
325 | |
326 void audacious_pbutton_pressed(AudaciousPButton *button) { | |
327 g_return_if_fail(AUDACIOUS_IS_PBUTTON(button)); | |
328 g_signal_emit(button, button_signals[PRESSED], 0); | |
329 } | |
330 | |
331 void audacious_pbutton_released(AudaciousPButton *button) { | |
332 g_return_if_fail(AUDACIOUS_IS_PBUTTON(button)); | |
333 g_signal_emit(button, button_signals[RELEASED], 0); | |
334 } | |
335 | |
336 void audacious_pbutton_clicked(AudaciousPButton *button) { | |
337 g_return_if_fail(AUDACIOUS_IS_PBUTTON(button)); | |
338 g_signal_emit(button, button_signals[CLICKED], 0); | |
339 } | |
340 | |
341 static gboolean audacious_pbutton_enter_notify(GtkWidget *widget, GdkEventCrossing *event) { | |
342 AudaciousPButton *button; | |
343 | |
344 button = AUDACIOUS_PBUTTON(widget); | |
345 button->hover = TRUE; | |
346 if(button->button_down) _audacious_pbutton_set_pressed(button, TRUE); | |
347 | |
348 return FALSE; | |
349 } | |
350 | |
351 static gboolean audacious_pbutton_leave_notify(GtkWidget *widget, GdkEventCrossing *event) { | |
352 AudaciousPButton *button; | |
353 | |
354 button = AUDACIOUS_PBUTTON (widget); | |
355 button->hover = FALSE; | |
356 if(button->button_down) _audacious_pbutton_set_pressed(button, FALSE); | |
357 | |
358 return FALSE; | |
359 } | |
360 | |
361 static void audacious_pbutton_add(GtkContainer *container, GtkWidget *widget) { | |
362 GTK_CONTAINER_CLASS (parent_class)->add(container, widget); | |
363 } | |
364 | |
2827 | 365 static void audacious_pbutton_toggle_doublesize(AudaciousPButton *button) { |
366 GtkWidget *widget = GTK_WIDGET (button); | |
367 AudaciousPButtonPrivate *priv = AUDACIOUS_PBUTTON_GET_PRIVATE (button); | |
368 priv->double_size = !priv->double_size; | |
369 | |
370 gtk_widget_set_size_request(widget, priv->w*(1+priv->double_size), priv->h*(1+priv->double_size)); | |
371 gtk_widget_set_uposition(widget, button->x*(1+priv->double_size), button->y*(1+priv->double_size)); | |
372 | |
2833 | 373 button->redraw = TRUE; |
2827 | 374 audacious_pbutton_paint(button); |
2822 | 375 } |
376 | |
377 static void audacious_pbutton_paint(AudaciousPButton *button) { | |
378 GtkWidget *widget = GTK_WIDGET (button); | |
379 AudaciousPButtonPrivate *priv = AUDACIOUS_PBUTTON_GET_PRIVATE (button); | |
380 | |
2833 | 381 if (button->redraw == TRUE) { |
382 button->redraw = FALSE; | |
383 GdkPixmap *obj; | |
384 obj = gdk_pixmap_new(NULL, priv->w, priv->h, gdk_rgb_get_visual()->depth); | |
385 skin_draw_pixmap(bmp_active_skin, obj, priv->gc, priv->skin_index2, | |
386 button->pressed ? button->px : button->nx, | |
387 button->pressed ? button->py : button->ny, | |
388 0, 0, priv->w, priv->h); | |
389 if(priv->double_size) { | |
390 GdkImage *img, *img2x; | |
391 img = gdk_drawable_get_image(obj, 0, 0, priv->w, priv->h); | |
392 img2x = create_dblsize_image(img); | |
393 gtk_image_set(GTK_IMAGE(priv->image), img2x, NULL); | |
394 g_object_unref(img2x); | |
395 g_object_unref(img); | |
396 } else | |
397 gtk_image_set_from_pixmap(GTK_IMAGE(priv->image), obj, NULL); | |
2831 | 398 g_object_unref(obj); |
2822 | 399 gtk_widget_queue_resize(widget); |
2833 | 400 } |
2822 | 401 } |
2833 | 402 |
403 static void audacious_pbutton_redraw(AudaciousPButton *button) { | |
404 button->redraw = TRUE; | |
405 audacious_pbutton_paint(button); | |
406 } |