Mercurial > audlegacy

comparison src/audacious/ui_skinned_equalizer_slider.c @ 3098:821a712c08a3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
replace EqSlider with UiSkinnedEqualizerSlider
author Tomasz Mon <desowin@gmail.com>
date Thu, 19 Jul 2007 11:16:38 +0200
parents
children 38ca234df0d9
comparison
equal deleted inserted replaced
3095:5a7dea5211f3 3098:821a712c08a3
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_equalizer_slider.h"
27 #include "util.h"
28 #include "ui_equalizer.h"
29 #include "ui_main.h"
30 #include <glib/gi18n.h>
31
32 #define UI_TYPE_SKINNED_EQUALIZER_SLIDER (ui_skinned_equalizer_slider_get_type())
33 #define UI_SKINNED_EQUALIZER_SLIDER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), UI_TYPE_SKINNED_EQUALIZER_SLIDER, UiSkinnedEqualizerSliderPrivate))
34 typedef struct _UiSkinnedEqualizerSliderPrivate UiSkinnedEqualizerSliderPrivate;
35
36 enum {
37 DOUBLED,
38 LAST_SIGNAL
39 };
40
41 struct _UiSkinnedEqualizerSliderPrivate {
42 GtkWidget *fixed;
43 SkinPixmapId skin_index;
44 gboolean double_size;
45 gint position;
46 gint width, height;
47 gboolean pressed;
48 gint drag_y;
49 };
50
51 static void ui_skinned_equalizer_slider_class_init (UiSkinnedEqualizerSliderClass *klass);
52 static void ui_skinned_equalizer_slider_init (UiSkinnedEqualizerSlider *equalizer_slider);
53 static void ui_skinned_equalizer_slider_destroy (GtkObject *object);
54 static void ui_skinned_equalizer_slider_realize (GtkWidget *widget);
55 static void ui_skinned_equalizer_slider_size_request (GtkWidget *widget, GtkRequisition *requisition);
56 static void ui_skinned_equalizer_slider_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
57 static gboolean ui_skinned_equalizer_slider_expose (GtkWidget *widget, GdkEventExpose *event);
58 static gboolean ui_skinned_equalizer_slider_button_press (GtkWidget *widget, GdkEventButton *event);
59 static gboolean ui_skinned_equalizer_slider_button_release (GtkWidget *widget, GdkEventButton *event);
60 static gboolean ui_skinned_equalizer_slider_motion_notify (GtkWidget *widget, GdkEventMotion *event);
61 static gboolean ui_skinned_equalizer_slider_scroll (GtkWidget *widget, GdkEventScroll *event);
62 static void ui_skinned_equalizer_slider_toggle_doublesize (UiSkinnedEqualizerSlider *equalizer_slider);
63 void ui_skinned_equalizer_slider_set_mainwin_text (UiSkinnedEqualizerSlider * es);
64
65 static GtkWidgetClass *parent_class = NULL;
66 static guint equalizer_slider_signals[LAST_SIGNAL] = { 0 };
67
68 GType ui_skinned_equalizer_slider_get_type() {
69 static GType equalizer_slider_type = 0;
70 if (!equalizer_slider_type) {
71 static const GTypeInfo equalizer_slider_info = {
72 sizeof (UiSkinnedEqualizerSliderClass),
73 NULL,
74 NULL,
75 (GClassInitFunc) ui_skinned_equalizer_slider_class_init,
76 NULL,
77 NULL,
78 sizeof (UiSkinnedEqualizerSlider),
79 0,
80 (GInstanceInitFunc) ui_skinned_equalizer_slider_init,
81 };
82 equalizer_slider_type = g_type_register_static (GTK_TYPE_WIDGET, "UiSkinnedEqualizerSlider", &equalizer_slider_info, 0);
83 }
84
85 return equalizer_slider_type;
86 }
87
88 static void ui_skinned_equalizer_slider_class_init(UiSkinnedEqualizerSliderClass *klass) {
89 GObjectClass *gobject_class;
90 GtkObjectClass *object_class;
91 GtkWidgetClass *widget_class;
92
93 gobject_class = G_OBJECT_CLASS(klass);
94 object_class = (GtkObjectClass*) klass;
95 widget_class = (GtkWidgetClass*) klass;
96 parent_class = gtk_type_class (gtk_widget_get_type ());
97
98 object_class->destroy = ui_skinned_equalizer_slider_destroy;
99
100 widget_class->realize = ui_skinned_equalizer_slider_realize;
101 widget_class->expose_event = ui_skinned_equalizer_slider_expose;
102 widget_class->size_request = ui_skinned_equalizer_slider_size_request;
103 widget_class->size_allocate = ui_skinned_equalizer_slider_size_allocate;
104 widget_class->button_press_event = ui_skinned_equalizer_slider_button_press;
105 widget_class->button_release_event = ui_skinned_equalizer_slider_button_release;
106 widget_class->motion_notify_event = ui_skinned_equalizer_slider_motion_notify;
107 widget_class->scroll_event = ui_skinned_equalizer_slider_scroll;
108
109 klass->doubled = ui_skinned_equalizer_slider_toggle_doublesize;
110
111 equalizer_slider_signals[DOUBLED] =
112 g_signal_new ("toggle-double-size", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
113 G_STRUCT_OFFSET (UiSkinnedEqualizerSliderClass, doubled), NULL, NULL,
114 gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
115
116 g_type_class_add_private (gobject_class, sizeof (UiSkinnedEqualizerSliderPrivate));
117 }
118
119 static void ui_skinned_equalizer_slider_init(UiSkinnedEqualizerSlider *equalizer_slider) {
120 UiSkinnedEqualizerSliderPrivate *priv = UI_SKINNED_EQUALIZER_SLIDER_GET_PRIVATE(equalizer_slider);
121 priv->pressed = FALSE;
122 }
123
124 GtkWidget* ui_skinned_equalizer_slider_new(GtkWidget *fixed, gint x, gint y) {
125 UiSkinnedEqualizerSlider *es = g_object_new (ui_skinned_equalizer_slider_get_type (), NULL);
126 UiSkinnedEqualizerSliderPrivate *priv = UI_SKINNED_EQUALIZER_SLIDER_GET_PRIVATE(es);
127
128 es->x = x;
129 es->y = y;
130 priv->width = 14;
131 priv->height = 63;
132 priv->skin_index = SKIN_EQMAIN;
133 priv->fixed = fixed;
134
135 gtk_fixed_put(GTK_FIXED(priv->fixed), GTK_WIDGET(es), es->x, es->y);
136
137 return GTK_WIDGET(es);
138 }
139
140 static void ui_skinned_equalizer_slider_destroy(GtkObject *object) {
141 UiSkinnedEqualizerSlider *equalizer_slider;
142
143 g_return_if_fail (object != NULL);
144 g_return_if_fail (UI_SKINNED_IS_EQUALIZER_SLIDER (object));
145
146 equalizer_slider = UI_SKINNED_EQUALIZER_SLIDER (object);
147
148 if (GTK_OBJECT_CLASS (parent_class)->destroy)
149 (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
150 }
151
152 static void ui_skinned_equalizer_slider_realize(GtkWidget *widget) {
153 UiSkinnedEqualizerSlider *equalizer_slider;
154 GdkWindowAttr attributes;
155 gint attributes_mask;
156
157 g_return_if_fail (widget != NULL);
158 g_return_if_fail (UI_SKINNED_IS_EQUALIZER_SLIDER(widget));
159
160 GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
161 equalizer_slider = UI_SKINNED_EQUALIZER_SLIDER(widget);
162
163 attributes.x = widget->allocation.x;
164 attributes.y = widget->allocation.y;
165 attributes.width = widget->allocation.width;
166 attributes.height = widget->allocation.height;
167 attributes.wclass = GDK_INPUT_OUTPUT;
168 attributes.window_type = GDK_WINDOW_CHILD;
169 attributes.event_mask = gtk_widget_get_events(widget);
170 attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
171 GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK;
172 attributes.visual = gtk_widget_get_visual(widget);
173 attributes.colormap = gtk_widget_get_colormap(widget);
174
175 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
176 widget->window = gdk_window_new(widget->parent->window, &attributes, attributes_mask);
177
178 widget->style = gtk_style_attach(widget->style, widget->window);
179 gdk_window_set_user_data(widget->window, widget);
180 }
181
182 static void ui_skinned_equalizer_slider_size_request(GtkWidget *widget, GtkRequisition *requisition) {
183 UiSkinnedEqualizerSliderPrivate *priv = UI_SKINNED_EQUALIZER_SLIDER_GET_PRIVATE(widget);
184
185 requisition->width = priv->width*(1+priv->double_size);
186 requisition->height = priv->height*(1+priv->double_size);
187 }
188
189 static void ui_skinned_equalizer_slider_size_allocate(GtkWidget *widget, GtkAllocation *allocation) {
190 UiSkinnedEqualizerSlider *equalizer_slider = UI_SKINNED_EQUALIZER_SLIDER (widget);
191 UiSkinnedEqualizerSliderPrivate *priv = UI_SKINNED_EQUALIZER_SLIDER_GET_PRIVATE(equalizer_slider);
192
193 widget->allocation = *allocation;
194 widget->allocation.x *= (1+priv->double_size);
195 widget->allocation.y *= (1+priv->double_size);
196 if (GTK_WIDGET_REALIZED (widget))
197 gdk_window_move_resize(widget->window, widget->allocation.x, widget->allocation.y, allocation->width, allocation->height);
198
199 equalizer_slider->x = widget->allocation.x/(priv->double_size ? 2 : 1);
200 equalizer_slider->y = widget->allocation.y/(priv->double_size ? 2 : 1);
201 }
202
203 static gboolean ui_skinned_equalizer_slider_expose(GtkWidget *widget, GdkEventExpose *event) {
204 g_return_val_if_fail (widget != NULL, FALSE);
205 g_return_val_if_fail (UI_SKINNED_IS_EQUALIZER_SLIDER (widget), FALSE);
206 g_return_val_if_fail (event != NULL, FALSE);
207
208 UiSkinnedEqualizerSlider *es = UI_SKINNED_EQUALIZER_SLIDER (widget);
209 UiSkinnedEqualizerSliderPrivate *priv = UI_SKINNED_EQUALIZER_SLIDER_GET_PRIVATE(es);
210
211 GdkPixmap *obj = NULL;
212 GdkGC *gc;
213
214 obj = gdk_pixmap_new(NULL, priv->width, priv->height, gdk_rgb_get_visual()->depth);
215 gc = gdk_gc_new(obj);
216
217 gint frame;
218 frame = 27 - ((priv->position * 27) / 50);
219 if (frame < 14)
220 skin_draw_pixmap(bmp_active_skin, obj, gc, priv->skin_index, (frame * 15) + 13, 164, 0, 0, priv->width, priv->height);
221 else
222 skin_draw_pixmap(bmp_active_skin, obj, gc, priv->skin_index, ((frame - 14) * 15) + 13, 229, 0, 0, priv->width, priv->height);
223
224 if (priv->pressed)
225 skin_draw_pixmap(bmp_active_skin, obj, gc, priv->skin_index, 0, 176, 1, priv->position, 11, 11);
226 else
227 skin_draw_pixmap(bmp_active_skin, obj, gc, priv->skin_index, 0, 164, 1, priv->position, 11, 11);
228
229 GdkPixmap *image = NULL;
230
231 if (priv->double_size) {
232 image = create_dblsize_pixmap(obj);
233 } else {
234 image = gdk_pixmap_new(NULL, priv->width, priv->height, gdk_rgb_get_visual()->depth);
235 gdk_draw_drawable (image, gc, obj, 0, 0, 0, 0, priv->width, priv->height);
236 }
237
238 g_object_unref(obj);
239
240 gdk_draw_drawable (widget->window, gc, image, 0, 0, 0, 0,
241 priv->width*(1+priv->double_size), priv->height*(1+priv->double_size));
242 g_object_unref(gc);
243 g_object_unref(image);
244
245 return FALSE;
246 }
247
248 static gboolean ui_skinned_equalizer_slider_button_press(GtkWidget *widget, GdkEventButton *event) {
249 g_return_val_if_fail (widget != NULL, FALSE);
250 g_return_val_if_fail (UI_SKINNED_IS_EQUALIZER_SLIDER (widget), FALSE);
251 g_return_val_if_fail (event != NULL, FALSE);
252
253 UiSkinnedEqualizerSlider *es = UI_SKINNED_EQUALIZER_SLIDER (widget);
254 UiSkinnedEqualizerSliderPrivate *priv = UI_SKINNED_EQUALIZER_SLIDER_GET_PRIVATE(es);
255
256 gint y;
257
258 if (event->type == GDK_BUTTON_PRESS) {
259 if (event->button == 1) {
260 priv->pressed = TRUE;
261 y = event->y;
262
263 if (y >= priv->position && y < priv->position + 11)
264 priv->drag_y = y - priv->position;
265 else {
266 priv->position = y - 5;
267 priv->drag_y = 5;
268 if (priv->position < 0)
269 priv->position = 0;
270 if (priv->position > 50)
271 priv->position = 50;
272 if (priv->position >= 24 && priv->position <= 26)
273 priv->position = 25;
274 equalizerwin_eq_changed();
275 }
276
277 ui_skinned_equalizer_slider_set_mainwin_text(es);
278 gtk_widget_queue_draw(widget);
279 }
280 }
281
282 return TRUE;
283 }
284
285 static gboolean ui_skinned_equalizer_slider_button_release(GtkWidget *widget, GdkEventButton *event) {
286 UiSkinnedEqualizerSliderPrivate *priv = UI_SKINNED_EQUALIZER_SLIDER_GET_PRIVATE(widget);
287
288 if (event->button == 1) {
289 priv->pressed = FALSE;
290 mainwin_release_info_text();
291 gtk_widget_queue_draw(widget);
292 }
293 return TRUE;
294 }
295
296 static gboolean ui_skinned_equalizer_slider_motion_notify(GtkWidget *widget, GdkEventMotion *event) {
297 g_return_val_if_fail (widget != NULL, FALSE);
298 g_return_val_if_fail (UI_SKINNED_IS_EQUALIZER_SLIDER (widget), FALSE);
299 g_return_val_if_fail (event != NULL, FALSE);
300 UiSkinnedEqualizerSlider *es = UI_SKINNED_EQUALIZER_SLIDER(widget);
301 UiSkinnedEqualizerSliderPrivate *priv = UI_SKINNED_EQUALIZER_SLIDER_GET_PRIVATE(widget);
302
303 if (priv->pressed) {
304 gint y;
305
306 y = event->y;
307 priv->position = y - priv->drag_y;
308
309 if (priv->position < 0)
310 priv->position = 0;
311 if (priv->position > 50)
312 priv->position = 50;
313 if (priv->position >= 24 && priv->position <= 26)
314 priv->position = 25;
315
316 ui_skinned_equalizer_slider_set_mainwin_text(es);
317 equalizerwin_eq_changed();
318 gtk_widget_queue_draw(widget);
319 }
320
321 return TRUE;
322 }
323
324 static gboolean ui_skinned_equalizer_slider_scroll(GtkWidget *widget, GdkEventScroll *event) {
325 g_return_val_if_fail (UI_SKINNED_IS_EQUALIZER_SLIDER (widget), FALSE);
326 g_return_val_if_fail (event != NULL, FALSE);
327 UiSkinnedEqualizerSliderPrivate *priv = UI_SKINNED_EQUALIZER_SLIDER_GET_PRIVATE(widget);
328
329 if (event->direction == GDK_SCROLL_UP) {
330 priv->position -= 2;
331
332 if (priv->position < 0)
333 priv->position = 0;
334 }
335 else {
336 priv->position += 2;
337
338 if (priv->position > 50)
339 priv->position = 50;
340 }
341
342 equalizerwin_eq_changed();
343 gtk_widget_queue_draw(widget);
344 return TRUE;
345 }
346
347 static void ui_skinned_equalizer_slider_toggle_doublesize(UiSkinnedEqualizerSlider *equalizer_slider) {
348 GtkWidget *widget = GTK_WIDGET (equalizer_slider);
349 UiSkinnedEqualizerSliderPrivate *priv = UI_SKINNED_EQUALIZER_SLIDER_GET_PRIVATE(equalizer_slider);
350
351 priv->double_size = !priv->double_size;
352
353 gtk_widget_set_size_request(widget, priv->width*(1+priv->double_size), priv->height*(1+priv->double_size));
354
355 gtk_widget_queue_draw(GTK_WIDGET(equalizer_slider));
356 }
357
358 void ui_skinned_equalizer_slider_set_position(GtkWidget *widget, gint pos) {
359 g_return_if_fail (UI_SKINNED_IS_EQUALIZER_SLIDER (widget));
360 UiSkinnedEqualizerSliderPrivate *priv = UI_SKINNED_EQUALIZER_SLIDER_GET_PRIVATE(widget);
361
362 if (priv->pressed)
363 return;
364
365 priv->position = 25 - (gint) ((pos * 25.0) / 20.0);
366
367 if (priv->position < 0)
368 priv->position = 0;
369
370 if (priv->position > 50)
371 priv->position = 50;
372
373 if (priv->position >= 24 && priv->position <= 26)
374 priv->position = 25;
375
376 gtk_widget_queue_draw(widget);
377 }
378
379 gfloat ui_skinned_equalizer_slider_get_position(GtkWidget *widget) {
380 g_return_val_if_fail (UI_SKINNED_IS_EQUALIZER_SLIDER (widget), -1);
381 UiSkinnedEqualizerSliderPrivate *priv = UI_SKINNED_EQUALIZER_SLIDER_GET_PRIVATE(widget);
382 return (20.0 - (((gfloat) priv->position * 20.0) / 25.0));
383 }
384
385 void ui_skinned_equalizer_slider_set_mainwin_text(UiSkinnedEqualizerSlider * es) {
386 gint band = 0;
387 const gchar *bandname[11] = { N_("PREAMP"), N_("60HZ"), N_("170HZ"),
388 N_("310HZ"), N_("600HZ"), N_("1KHZ"),
389 N_("3KHZ"), N_("6KHZ"), N_("12KHZ"),
390 N_("14KHZ"), N_("16KHZ")
391 };
392 gchar *tmp;
393
394 if (es->x > 21)
395 band = ((es->x - 78) / 18) + 1;
396
397 tmp =
398 g_strdup_printf("EQ: %s: %+.1f DB", _(bandname[band]),
399 ui_skinned_equalizer_slider_get_position(GTK_WIDGET(es)));
400 mainwin_lock_info_text(tmp);
401 g_free(tmp);
402 }