1653
|
1 /* Audacious - Cross-platform multimedia player
|
|
2 * Copyright (C) 2005-2006 Audacious development team.
|
|
3 *
|
|
4 * BMP - Cross-platform multimedia player
|
|
5 * Copyright (C) 2003-2004 BMP development team.
|
|
6 *
|
|
7 * Based on XMMS:
|
|
8 * Copyright (C) 1998-2003 XMMS development team.
|
|
9 *
|
|
10 * This program is free software; you can redistribute it and/or modify
|
|
11 * it under the terms of the GNU General Public License as published by
|
|
12 * the Free Software Foundation; either version 2 of the License, or
|
|
13 * (at your option) any later version.
|
|
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 #ifdef HAVE_CONFIG_H
|
|
26 # include "config.h"
|
|
27 #endif
|
|
28
|
|
29 #include "equalizer.h"
|
|
30
|
|
31 #include <glib.h>
|
|
32 #include <glib/gi18n.h>
|
|
33 #include <gtk/gtk.h>
|
|
34 #include <stdio.h>
|
|
35 #include <math.h>
|
|
36 #include <string.h>
|
|
37
|
|
38 #include "platform/smartinclude.h"
|
|
39 #include "widgets/widgetcore.h"
|
|
40 #include "dock.h"
|
|
41 #include "hints.h"
|
|
42 #include "input.h"
|
|
43 #include "main.h"
|
|
44 #include "playlist.h"
|
|
45 #include "ui_playlist.h"
|
|
46 #include "util.h"
|
|
47 #include "output.h"
|
|
48
|
|
49 #include "libaudacious/rcfile.h"
|
|
50 #include "libaudacious/vfs.h"
|
|
51
|
|
52 #include "images/audacious_eq.xpm"
|
|
53
|
|
54 enum PresetViewCols {
|
|
55 PRESET_VIEW_COL_NAME,
|
|
56 PRESET_VIEW_N_COLS
|
|
57 };
|
|
58
|
|
59 enum {
|
|
60 EQUALIZER_PRESETS_LOAD_PRESET,
|
|
61 EQUALIZER_PRESETS_LOAD_AUTOPRESET,
|
|
62 EQUALIZER_PRESETS_LOAD_DEFAULT,
|
|
63 EQUALIZER_PRESETS_LOAD_ZERO,
|
|
64 EQUALIZER_PRESETS_LOAD_FROM_FILE,
|
|
65 EQUALIZER_PRESETS_LOAD_FROM_WINAMPFILE,
|
|
66 EQUALIZER_PRESETS_IMPORT_WINAMPFILE,
|
|
67 EQUALIZER_PRESETS_SAVE_PRESET,
|
|
68 EQUALIZER_PRESETS_SAVE_AUTOPRESET,
|
|
69 EQUALIZER_PRESETS_SAVE_DEFAULT,
|
|
70 EQUALIZER_PRESETS_SAVE_TO_FILE,
|
|
71 EQUALIZER_PRESETS_SAVE_TO_WINAMPFILE,
|
|
72 EQUALIZER_PRESETS_DELETE_PRESET,
|
|
73 EQUALIZER_PRESETS_DELETE_AUTOPRESET
|
|
74 };
|
|
75
|
|
76
|
|
77 struct _EqualizerPreset {
|
|
78 gchar *name;
|
|
79 gfloat preamp, bands[10];
|
|
80 };
|
|
81
|
|
82 typedef struct _EqualizerPreset EqualizerPreset;
|
|
83
|
|
84
|
|
85 GtkWidget *equalizerwin;
|
|
86
|
|
87 static GtkWidget *equalizerwin_load_window = NULL;
|
|
88 static GtkWidget *equalizerwin_load_auto_window = NULL;
|
|
89 static GtkWidget *equalizerwin_save_window = NULL;
|
|
90 static GtkWidget *equalizerwin_save_entry;
|
|
91 static GtkWidget *equalizerwin_save_auto_window = NULL;
|
|
92 static GtkWidget *equalizerwin_save_auto_entry;
|
|
93 static GtkWidget *equalizerwin_delete_window = NULL;
|
|
94 static GtkWidget *equalizerwin_delete_auto_window = NULL;
|
|
95
|
1938
|
96 static GdkPixmap *equalizerwin_bg, *equalizerwin_bg_x2;
|
1653
|
97 static GdkGC *equalizerwin_gc;
|
|
98
|
|
99 static GList *equalizerwin_wlist = NULL;
|
|
100
|
|
101 static GtkAccelGroup *equalizerwin_accel;
|
|
102
|
|
103 static TButton *equalizerwin_on, *equalizerwin_auto;
|
|
104
|
|
105 static PButton *equalizerwin_presets, *equalizerwin_shade;
|
|
106 PButton *equalizerwin_close;
|
|
107 static EqGraph *equalizerwin_graph;
|
|
108 static EqSlider *equalizerwin_preamp, *equalizerwin_bands[10];
|
|
109 static HSlider *equalizerwin_volume, *equalizerwin_balance;
|
|
110
|
|
111 static GtkItemFactory *equalizerwin_presets_menu;
|
|
112
|
|
113 static GList *equalizer_presets = NULL, *equalizer_auto_presets = NULL;
|
|
114
|
|
115
|
|
116 static void equalizerwin_presets_menu_cb(gpointer cb_data, guint action,
|
|
117 GtkWidget * w);
|
|
118
|
|
119 static GtkItemFactoryEntry equalizerwin_presets_menu_entries[] = {
|
|
120 {N_("/Load"), NULL, NULL, 0, "<Branch>", NULL},
|
|
121 {N_("/Load/Preset"), NULL, equalizerwin_presets_menu_cb,
|
|
122 EQUALIZER_PRESETS_LOAD_PRESET, "<Item>", NULL},
|
|
123 {N_("/Load/Auto-load preset"), NULL, equalizerwin_presets_menu_cb,
|
|
124 EQUALIZER_PRESETS_LOAD_AUTOPRESET, "<Item>", NULL},
|
|
125 {N_("/Load/Default"), NULL, equalizerwin_presets_menu_cb,
|
|
126 EQUALIZER_PRESETS_LOAD_DEFAULT, "<Item>", NULL},
|
|
127 {"/Load/-", NULL, NULL, 0, "<Separator>", NULL},
|
|
128 {N_("/Load/Zero"), NULL, equalizerwin_presets_menu_cb,
|
|
129 EQUALIZER_PRESETS_LOAD_ZERO, "<Item>", NULL},
|
|
130 {"/Load/-", NULL, NULL, 0, "<Separator>", NULL},
|
|
131 {N_("/Load/From file"), NULL, equalizerwin_presets_menu_cb,
|
|
132 EQUALIZER_PRESETS_LOAD_FROM_FILE, "<Item>", NULL},
|
|
133 {N_("/Load/From WinAMP EQF file"), NULL, equalizerwin_presets_menu_cb,
|
|
134 EQUALIZER_PRESETS_LOAD_FROM_WINAMPFILE, "<Item>", NULL},
|
|
135 {N_("/Import"), NULL, NULL, 0, "<Branch>", NULL},
|
|
136 {N_("/Import/WinAMP Presets"), NULL, equalizerwin_presets_menu_cb,
|
|
137 EQUALIZER_PRESETS_IMPORT_WINAMPFILE, "<Item>", NULL},
|
|
138 {N_("/Save"), NULL, NULL, 0, "<Branch>", NULL},
|
|
139 {N_("/Save/Preset"), NULL, equalizerwin_presets_menu_cb,
|
|
140 EQUALIZER_PRESETS_SAVE_PRESET, "<Item>", NULL},
|
|
141 {N_("/Save/Auto-load preset"), NULL, equalizerwin_presets_menu_cb,
|
|
142 EQUALIZER_PRESETS_SAVE_AUTOPRESET, "<Item>", NULL},
|
|
143 {N_("/Save/Default"), NULL, equalizerwin_presets_menu_cb,
|
|
144 EQUALIZER_PRESETS_SAVE_DEFAULT, "<Item>", NULL},
|
|
145 {"/Save/-", NULL, NULL, 0, "<Separator>", NULL},
|
|
146 {N_("/Save/To file"), NULL, equalizerwin_presets_menu_cb,
|
|
147 EQUALIZER_PRESETS_SAVE_TO_FILE, "<Item>", NULL},
|
|
148 {N_("/Save/To WinAMP EQF file"), NULL, equalizerwin_presets_menu_cb,
|
|
149 EQUALIZER_PRESETS_SAVE_TO_WINAMPFILE, "<Item>", NULL},
|
|
150 {N_("/Delete"), NULL, NULL, 0, "<Branch>", NULL},
|
|
151 {N_("/Delete/Preset"), NULL, equalizerwin_presets_menu_cb,
|
|
152 EQUALIZER_PRESETS_DELETE_PRESET, "<Item>", NULL},
|
|
153 {N_("/Delete/Auto-load preset"), NULL, equalizerwin_presets_menu_cb,
|
|
154 EQUALIZER_PRESETS_DELETE_AUTOPRESET, "<Item>", NULL},
|
|
155 };
|
|
156
|
|
157 static gint equalizerwin_presets_menu_entries_num =
|
|
158 G_N_ELEMENTS(equalizerwin_presets_menu_entries);
|
|
159
|
|
160
|
|
161 EqualizerPreset *
|
|
162 equalizer_preset_new(const gchar * name)
|
|
163 {
|
|
164 EqualizerPreset *preset = g_new0(EqualizerPreset, 1);
|
|
165 preset->name = g_strdup(name);
|
|
166 return preset;
|
|
167 }
|
|
168
|
|
169 void
|
|
170 equalizer_preset_free(EqualizerPreset * preset)
|
|
171 {
|
|
172 if (!preset)
|
|
173 return;
|
|
174
|
|
175 g_free(preset->name);
|
|
176 g_free(preset);
|
|
177 }
|
|
178
|
|
179
|
|
180 static void
|
|
181 equalizerwin_set_shape_mask(void)
|
|
182 {
|
|
183 if (cfg.show_wm_decorations)
|
|
184 return;
|
|
185
|
1938
|
186 if (cfg.doublesize == FALSE)
|
|
187 gtk_widget_shape_combine_mask(equalizerwin,
|
|
188 skin_get_mask(bmp_active_skin,
|
|
189 SKIN_MASK_EQ), 0, 0);
|
|
190 else
|
|
191 gtk_widget_shape_combine_mask(equalizerwin, NULL, 0, 0);
|
1653
|
192 }
|
|
193
|
1938
|
194 void
|
|
195 equalizerwin_set_doublesize(gboolean ds)
|
|
196 {
|
|
197 gint height;
|
|
198
|
|
199 if (cfg.equalizer_shaded)
|
|
200 height = 14;
|
|
201 else
|
|
202 height = 116;
|
|
203
|
|
204 equalizerwin_set_shape_mask();
|
|
205
|
|
206 if (ds) {
|
|
207 dock_window_resize(equalizerwin, 275, height, 550, height * 2);
|
|
208 gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg_x2,
|
|
209 0);
|
|
210 }
|
|
211 else {
|
|
212 dock_window_resize(equalizerwin, 275, height, 275, height);
|
|
213 gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg, 0);
|
|
214 }
|
|
215
|
|
216 draw_equalizer_window(TRUE);
|
|
217 }
|
1653
|
218
|
|
219 void
|
|
220 equalizerwin_set_shade_menu_cb(gboolean shaded)
|
|
221 {
|
|
222 cfg.equalizer_shaded = shaded;
|
|
223
|
|
224 equalizerwin_set_shape_mask();
|
|
225
|
|
226 if (shaded) {
|
1938
|
227 dock_shade(dock_window_list, GTK_WINDOW(equalizerwin),
|
|
228 14 * (EQUALIZER_DOUBLESIZE + 1));
|
1653
|
229 pbutton_set_button_data(equalizerwin_shade, -1, 3, -1, 47);
|
|
230 pbutton_set_skin_index1(equalizerwin_shade, SKIN_EQ_EX);
|
|
231 pbutton_set_button_data(equalizerwin_close, 11, 38, 11, 47);
|
|
232 pbutton_set_skin_index(equalizerwin_close, SKIN_EQ_EX);
|
|
233 widget_show(WIDGET(equalizerwin_volume));
|
|
234 widget_show(WIDGET(equalizerwin_balance));
|
|
235 }
|
|
236 else {
|
1938
|
237 dock_shade(dock_window_list, GTK_WINDOW(equalizerwin),
|
|
238 116 * (EQUALIZER_DOUBLESIZE + 1));
|
1653
|
239 pbutton_set_button_data(equalizerwin_shade, -1, 137, -1, 38);
|
|
240 pbutton_set_skin_index1(equalizerwin_shade, SKIN_EQMAIN);
|
|
241 pbutton_set_button_data(equalizerwin_close, 0, 116, 0, 125);
|
|
242 pbutton_set_skin_index(equalizerwin_close, SKIN_EQMAIN);
|
|
243 widget_hide(WIDGET(equalizerwin_volume));
|
|
244 widget_hide(WIDGET(equalizerwin_balance));
|
|
245 }
|
|
246
|
|
247 draw_equalizer_window(TRUE);
|
|
248 }
|
|
249
|
|
250 static void
|
|
251 equalizerwin_set_shade(gboolean shaded)
|
|
252 {
|
|
253 GtkWidget *widget;
|
|
254 widget = gtk_item_factory_get_widget(mainwin_view_menu,
|
|
255 "/Roll up Equalizer");
|
|
256 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), shaded);
|
|
257 }
|
|
258
|
|
259 static void
|
|
260 equalizerwin_shade_toggle(void)
|
|
261 {
|
|
262 equalizerwin_set_shade(!cfg.equalizer_shaded);
|
|
263 }
|
|
264
|
|
265 static void
|
|
266 equalizerwin_raise(void)
|
|
267 {
|
|
268 if (cfg.equalizer_visible)
|
|
269 gtk_window_present(GTK_WINDOW(equalizerwin));
|
|
270 }
|
|
271
|
|
272 void
|
|
273 equalizerwin_eq_changed(void)
|
|
274 {
|
|
275 gint i;
|
|
276
|
|
277 cfg.equalizer_preamp = eqslider_get_position(equalizerwin_preamp);
|
|
278 for (i = 0; i < 10; i++)
|
|
279 cfg.equalizer_bands[i] = eqslider_get_position(equalizerwin_bands[i]);
|
|
280 /* um .. i think we need both of these for xmms compatibility ..
|
|
281 not sure. -larne */
|
|
282 input_set_eq(cfg.equalizer_active, cfg.equalizer_preamp,
|
|
283 cfg.equalizer_bands);
|
|
284 output_set_eq(cfg.equalizer_active, cfg.equalizer_preamp,
|
|
285 cfg.equalizer_bands);
|
|
286
|
|
287 widget_draw(WIDGET(equalizerwin_graph));
|
|
288 }
|
|
289
|
|
290 static void
|
|
291 equalizerwin_on_pushed(gboolean toggled)
|
|
292 {
|
|
293 cfg.equalizer_active = toggled;
|
|
294 equalizerwin_eq_changed();
|
|
295 }
|
|
296
|
|
297 static void
|
|
298 equalizerwin_presets_pushed(void)
|
|
299 {
|
|
300 GdkModifierType modmask;
|
|
301 gint x, y;
|
|
302
|
|
303 gdk_window_get_pointer(NULL, &x, &y, &modmask);
|
|
304 util_item_factory_popup(equalizerwin_presets_menu, x, y, 1,
|
|
305 GDK_CURRENT_TIME);
|
|
306 }
|
|
307
|
|
308 static void
|
|
309 equalizerwin_auto_pushed(gboolean toggled)
|
|
310 {
|
|
311 cfg.equalizer_autoload = toggled;
|
|
312 }
|
|
313
|
|
314 void
|
|
315 draw_equalizer_window(gboolean force)
|
|
316 {
|
1938
|
317 GdkImage *img, *img2;
|
|
318 GList *wl;
|
|
319 Widget *w;
|
1653
|
320 gboolean redraw;
|
|
321
|
|
322 widget_list_lock(equalizerwin_wlist);
|
|
323
|
|
324 if (force) {
|
|
325 skin_draw_pixmap(bmp_active_skin, equalizerwin_bg, equalizerwin_gc,
|
|
326 SKIN_EQMAIN, 0, 0, 0, 0, 275, 116);
|
|
327 if (gtk_window_has_toplevel_focus(GTK_WINDOW(equalizerwin)) ||
|
|
328 !cfg.dim_titlebar) {
|
|
329 if (!cfg.equalizer_shaded)
|
|
330 skin_draw_pixmap(bmp_active_skin, equalizerwin_bg,
|
|
331 equalizerwin_gc, SKIN_EQMAIN, 0, 134, 0,
|
|
332 0, 275, 14);
|
|
333 else
|
|
334 skin_draw_pixmap(bmp_active_skin, equalizerwin_bg,
|
|
335 equalizerwin_gc, SKIN_EQ_EX, 0, 0, 0, 0,
|
|
336 275, 14);
|
|
337 }
|
|
338 else {
|
|
339 if (!cfg.equalizer_shaded)
|
|
340 skin_draw_pixmap(bmp_active_skin, equalizerwin_bg,
|
|
341 equalizerwin_gc, SKIN_EQMAIN, 0, 149, 0,
|
|
342 0, 275, 14);
|
|
343 else
|
|
344 skin_draw_pixmap(bmp_active_skin, equalizerwin_bg,
|
|
345 equalizerwin_gc, SKIN_EQ_EX, 0, 15, 0, 0,
|
|
346 275, 14);
|
|
347
|
|
348 }
|
|
349 }
|
|
350
|
|
351 widget_list_draw(equalizerwin_wlist, &redraw, force);
|
|
352
|
|
353 if (force || redraw) {
|
1938
|
354 if (cfg.doublesize && cfg.eq_doublesize_linked) {
|
|
355 if (force) {
|
|
356 img = gdk_drawable_get_image(equalizerwin_bg, 0, 0, 275, 116);
|
|
357 img2 = create_dblsize_image(img);
|
|
358 gdk_draw_image(equalizerwin_bg_x2, equalizerwin_gc,
|
|
359 img2, 0, 0, 0, 0, 550, 232);
|
|
360 gdk_image_destroy(img2);
|
|
361 gdk_image_destroy(img);
|
|
362 }
|
|
363 else {
|
|
364 for (wl = equalizerwin_wlist; wl; wl = g_list_next(wl)) {
|
|
365 w = WIDGET(wl->data);
|
|
366 if (w->redraw && w->visible) {
|
|
367 img = gdk_drawable_get_image(equalizerwin_bg,
|
|
368 w->x, w->y,
|
|
369 w->width, w->height);
|
|
370 img2 = create_dblsize_image(img);
|
|
371 gdk_draw_image(equalizerwin_bg_x2,
|
|
372 equalizerwin_gc, img2, 0, 0,
|
|
373 w->x << 1, w->y << 1, w->width << 1,
|
|
374 w->height << 1);
|
|
375 gdk_image_destroy(img2);
|
|
376 gdk_image_destroy(img);
|
|
377 w->redraw = FALSE;
|
|
378 }
|
|
379 }
|
|
380 }
|
|
381 }
|
|
382 else
|
|
383 widget_list_clear_redraw(equalizerwin_wlist);
|
1653
|
384 gdk_window_clear(equalizerwin->window);
|
|
385 gdk_flush();
|
|
386 }
|
|
387
|
|
388 widget_list_unlock(equalizerwin_wlist);
|
|
389 }
|
|
390
|
|
391 static gboolean
|
|
392 inside_sensitive_widgets(gint x, gint y)
|
|
393 {
|
|
394 return (widget_contains(WIDGET(equalizerwin_on), x, y) ||
|
|
395 widget_contains(WIDGET(equalizerwin_auto), x, y) ||
|
|
396 widget_contains(WIDGET(equalizerwin_presets), x, y) ||
|
|
397 widget_contains(WIDGET(equalizerwin_close), x, y) ||
|
|
398 widget_contains(WIDGET(equalizerwin_shade), x, y) ||
|
|
399 widget_contains(WIDGET(equalizerwin_preamp), x, y) ||
|
|
400 widget_contains(WIDGET(equalizerwin_bands[0]), x, y) ||
|
|
401 widget_contains(WIDGET(equalizerwin_bands[1]), x, y) ||
|
|
402 widget_contains(WIDGET(equalizerwin_bands[2]), x, y) ||
|
|
403 widget_contains(WIDGET(equalizerwin_bands[3]), x, y) ||
|
|
404 widget_contains(WIDGET(equalizerwin_bands[4]), x, y) ||
|
|
405 widget_contains(WIDGET(equalizerwin_bands[5]), x, y) ||
|
|
406 widget_contains(WIDGET(equalizerwin_bands[6]), x, y) ||
|
|
407 widget_contains(WIDGET(equalizerwin_bands[7]), x, y) ||
|
|
408 widget_contains(WIDGET(equalizerwin_bands[8]), x, y) ||
|
|
409 widget_contains(WIDGET(equalizerwin_bands[9]), x, y) ||
|
|
410 widget_contains(WIDGET(equalizerwin_volume), x, y) ||
|
|
411 widget_contains(WIDGET(equalizerwin_balance), x, y));
|
|
412 }
|
|
413
|
|
414 gboolean
|
|
415 equalizerwin_press(GtkWidget * widget, GdkEventButton * event,
|
|
416 gpointer callback_data)
|
|
417 {
|
|
418 gint mx, my;
|
|
419 gboolean grab = TRUE;
|
|
420
|
|
421 mx = event->x;
|
|
422 my = event->y;
|
1938
|
423 if (cfg.doublesize && cfg.eq_doublesize_linked) {
|
|
424 event->x /= 2;
|
|
425 event->y /= 2;
|
|
426 }
|
1653
|
427
|
|
428 if (event->button == 1 && event->type == GDK_BUTTON_PRESS &&
|
1938
|
429 ((cfg.easy_move || cfg.equalizer_shaded || event->y < 14) &&
|
1653
|
430 !inside_sensitive_widgets(event->x, event->y))) {
|
|
431 if (0 && hint_move_resize_available()) {
|
|
432 hint_move_resize(equalizerwin, event->x_root,
|
|
433 event->y_root, TRUE);
|
|
434 grab = FALSE;
|
|
435 }
|
|
436 else {
|
|
437 equalizerwin_raise();
|
|
438 dock_move_press(dock_window_list, GTK_WINDOW(equalizerwin), event,
|
|
439 FALSE);
|
|
440 }
|
|
441 }
|
|
442 else if (event->button == 1 && event->type == GDK_2BUTTON_PRESS
|
|
443 && event->y < 14) {
|
|
444 equalizerwin_set_shade(!cfg.equalizer_shaded);
|
|
445 if (dock_is_moving(GTK_WINDOW(equalizerwin)))
|
|
446 dock_move_release(GTK_WINDOW(equalizerwin));
|
|
447 }
|
|
448 else if (event->button == 3 &&
|
|
449 !(widget_contains(WIDGET(equalizerwin_on), event->x, event->y) ||
|
|
450 widget_contains(WIDGET(equalizerwin_auto), event->x, event->y))) {
|
|
451 /*
|
|
452 * Pop up the main menu a few pixels down to avoid
|
|
453 * anything to be selected initially.
|
|
454 */
|
|
455 util_item_factory_popup(mainwin_general_menu, event->x_root,
|
|
456 event->y_root + 2, 3, event->time);
|
|
457 grab = FALSE;
|
|
458 }
|
|
459 else {
|
|
460 handle_press_cb(equalizerwin_wlist, widget, event);
|
|
461 draw_equalizer_window(FALSE);
|
|
462 }
|
|
463 if (grab)
|
|
464 gdk_pointer_grab(GDK_WINDOW(equalizerwin->window), FALSE,
|
|
465 GDK_BUTTON_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
|
|
466 NULL, NULL, GDK_CURRENT_TIME);
|
|
467
|
|
468 return FALSE;
|
|
469 }
|
|
470
|
|
471 static void
|
|
472 equalizerwin_scroll(GtkWidget * widget, GdkEventScroll * event, gpointer data)
|
|
473 {
|
1938
|
474 if (cfg.doublesize && cfg.eq_doublesize_linked) {
|
|
475 event->x /= 2;
|
|
476 event->y /= 2;
|
|
477 }
|
|
478
|
1653
|
479 handle_scroll_cb(equalizerwin_wlist, widget, event);
|
|
480 draw_equalizer_window(FALSE);
|
|
481 }
|
|
482
|
|
483 static gboolean
|
|
484 equalizerwin_motion(GtkWidget * widget,
|
|
485 GdkEventMotion * event, gpointer callback_data)
|
|
486 {
|
|
487 GdkEvent *gevent;
|
|
488
|
|
489 if (dock_is_moving(GTK_WINDOW(equalizerwin)))
|
|
490 {
|
|
491 dock_move_motion(GTK_WINDOW(equalizerwin), event);
|
|
492 }
|
|
493 else
|
|
494 {
|
|
495 handle_motion_cb(equalizerwin_wlist, widget, event);
|
|
496 draw_equalizer_window(FALSE);
|
|
497 }
|
|
498
|
|
499 gdk_flush();
|
|
500
|
|
501 while ((gevent = gdk_event_get()) != NULL) gdk_event_free(gevent);
|
|
502
|
|
503 return FALSE;
|
|
504 }
|
|
505
|
|
506 static gboolean
|
|
507 equalizerwin_release(GtkWidget * widget,
|
|
508 GdkEventButton * event, gpointer callback_data)
|
|
509 {
|
|
510 gdk_pointer_ungrab(GDK_CURRENT_TIME);
|
|
511 gdk_flush();
|
|
512
|
1938
|
513 if (cfg.doublesize && cfg.eq_doublesize_linked) {
|
|
514 event->x /= 2;
|
|
515 event->y /= 2;
|
|
516 }
|
1653
|
517 if (dock_is_moving(GTK_WINDOW(equalizerwin))) {
|
|
518 dock_move_release(GTK_WINDOW(equalizerwin));
|
|
519 }
|
|
520 else {
|
|
521 handle_release_cb(equalizerwin_wlist, widget, event);
|
|
522 draw_equalizer_window(FALSE);
|
|
523 }
|
|
524
|
|
525 return FALSE;
|
|
526 }
|
|
527
|
|
528 static gboolean
|
|
529 equalizerwin_focus_in(GtkWidget * widget,
|
|
530 GdkEvent * event,
|
|
531 gpointer data)
|
|
532 {
|
|
533 equalizerwin_close->pb_allow_draw = TRUE;
|
|
534 equalizerwin_shade->pb_allow_draw = TRUE;
|
|
535 draw_equalizer_window(TRUE);
|
|
536 return TRUE;
|
|
537 }
|
|
538
|
|
539 static gboolean
|
|
540 equalizerwin_focus_out(GtkWidget * widget,
|
|
541 GdkEventButton * event,
|
|
542 gpointer data)
|
|
543 {
|
|
544 equalizerwin_close->pb_allow_draw = FALSE;
|
|
545 equalizerwin_shade->pb_allow_draw = FALSE;
|
|
546 draw_equalizer_window(TRUE);
|
|
547 return TRUE;
|
|
548 }
|
|
549
|
|
550 static gboolean
|
|
551 equalizerwin_keypress(GtkWidget * widget,
|
|
552 GdkEventKey * event,
|
|
553 gpointer data)
|
|
554 {
|
|
555 if (!cfg.equalizer_shaded) {
|
|
556 gtk_widget_event(mainwin, (GdkEvent *) event);
|
|
557 return TRUE;
|
|
558 }
|
|
559
|
|
560 switch (event->keyval) {
|
|
561 case GDK_Left:
|
|
562 case GDK_KP_Left:
|
|
563 mainwin_set_balance_diff(-4);
|
|
564 break;
|
|
565 case GDK_Right:
|
|
566 case GDK_KP_Right:
|
|
567 mainwin_set_balance_diff(4);
|
|
568 break;
|
|
569 default:
|
|
570 gtk_widget_event(mainwin, (GdkEvent *) event);
|
|
571 break;
|
|
572 }
|
|
573
|
|
574 return FALSE;
|
|
575 }
|
|
576
|
|
577 static gboolean
|
|
578 equalizerwin_configure(GtkWidget * window,
|
|
579 GdkEventConfigure * event,
|
|
580 gpointer data)
|
|
581 {
|
|
582 if (!GTK_WIDGET_VISIBLE(window))
|
|
583 return FALSE;
|
|
584
|
|
585 cfg.equalizer_x = event->x;
|
|
586 cfg.equalizer_y = event->y;
|
|
587 return FALSE;
|
|
588 }
|
|
589
|
|
590 static void
|
|
591 equalizerwin_set_back_pixmap(void)
|
|
592 {
|
1938
|
593 if (cfg.doublesize && cfg.eq_doublesize_linked)
|
|
594 gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg_x2,
|
|
595 0);
|
|
596 else
|
|
597 gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg, 0);
|
1653
|
598 gdk_window_clear(equalizerwin->window);
|
|
599 }
|
|
600
|
|
601 static void
|
|
602 equalizerwin_close_cb(void)
|
|
603 {
|
|
604 equalizerwin_show(FALSE);
|
|
605 }
|
|
606
|
|
607 static gboolean
|
|
608 equalizerwin_delete(GtkWidget * widget,
|
|
609 gpointer data)
|
|
610 {
|
|
611 equalizerwin_show(FALSE);
|
|
612 return TRUE;
|
|
613 }
|
|
614
|
|
615 static GList *
|
|
616 equalizerwin_read_presets(const gchar * basename)
|
|
617 {
|
|
618 gchar *filename, *name;
|
|
619 RcFile *rcfile;
|
|
620 GList *list = NULL;
|
|
621 gint i, p = 0;
|
|
622 EqualizerPreset *preset;
|
|
623
|
|
624 filename = g_build_filename(bmp_paths[BMP_PATH_USER_DIR], basename, NULL);
|
|
625
|
|
626 if ((rcfile = bmp_rcfile_open(filename)) == NULL) {
|
|
627 g_free(filename);
|
|
628 return NULL;
|
|
629 }
|
|
630
|
|
631 g_free(filename);
|
|
632
|
|
633 for (;;) {
|
|
634 gchar section[21];
|
|
635
|
|
636 g_snprintf(section, sizeof(section), "Preset%d", p++);
|
|
637 if (bmp_rcfile_read_string(rcfile, "Presets", section, &name)) {
|
|
638 preset = g_new0(EqualizerPreset, 1);
|
|
639 preset->name = name;
|
|
640 bmp_rcfile_read_float(rcfile, name, "Preamp", &preset->preamp);
|
|
641 for (i = 0; i < 10; i++) {
|
|
642 gchar band[7];
|
|
643 g_snprintf(band, sizeof(band), "Band%d", i);
|
|
644 bmp_rcfile_read_float(rcfile, name, band, &preset->bands[i]);
|
|
645 }
|
|
646 list = g_list_prepend(list, preset);
|
|
647 }
|
|
648 else
|
|
649 break;
|
|
650 }
|
|
651 list = g_list_reverse(list);
|
|
652 bmp_rcfile_free(rcfile);
|
|
653 return list;
|
|
654 }
|
|
655
|
|
656 gint
|
|
657 equalizerwin_volume_frame_cb(gint pos)
|
|
658 {
|
|
659 if (equalizerwin_volume) {
|
|
660 if (pos < 32)
|
|
661 equalizerwin_volume->hs_knob_nx =
|
|
662 equalizerwin_volume->hs_knob_px = 1;
|
|
663 else if (pos < 63)
|
|
664 equalizerwin_volume->hs_knob_nx =
|
|
665 equalizerwin_volume->hs_knob_px = 4;
|
|
666 else
|
|
667 equalizerwin_volume->hs_knob_nx =
|
|
668 equalizerwin_volume->hs_knob_px = 7;
|
|
669 }
|
|
670 return 1;
|
|
671 }
|
|
672
|
|
673 static void
|
|
674 equalizerwin_volume_motion_cb(gint pos)
|
|
675 {
|
|
676 gint v = (gint) rint(pos * 100 / 94.0);
|
|
677 mainwin_adjust_volume_motion(v);
|
|
678 mainwin_set_volume_slider(v);
|
|
679 }
|
|
680
|
|
681 static void
|
|
682 equalizerwin_volume_release_cb(gint pos)
|
|
683 {
|
|
684 mainwin_adjust_volume_release();
|
|
685 }
|
|
686
|
|
687 static gint
|
|
688 equalizerwin_balance_frame_cb(gint pos)
|
|
689 {
|
|
690 if (equalizerwin_balance) {
|
|
691 if (pos < 13)
|
|
692 equalizerwin_balance->hs_knob_nx =
|
|
693 equalizerwin_balance->hs_knob_px = 11;
|
|
694 else if (pos < 26)
|
|
695 equalizerwin_balance->hs_knob_nx =
|
|
696 equalizerwin_balance->hs_knob_px = 14;
|
|
697 else
|
|
698 equalizerwin_balance->hs_knob_nx =
|
|
699 equalizerwin_balance->hs_knob_px = 17;
|
|
700 }
|
|
701
|
|
702 return 1;
|
|
703 }
|
|
704
|
|
705 static void
|
|
706 equalizerwin_balance_motion_cb(gint pos)
|
|
707 {
|
|
708 gint b;
|
|
709 pos = MIN(pos, 38); /* The skin uses a even number of pixels
|
|
710 for the balance-slider *sigh* */
|
|
711 b = (gint) rint((pos - 19) * 100 / 19.0);
|
|
712 mainwin_adjust_balance_motion(b);
|
|
713 mainwin_set_balance_slider(b);
|
|
714 }
|
|
715
|
|
716 static void
|
|
717 equalizerwin_balance_release_cb(gint pos)
|
|
718 {
|
|
719 mainwin_adjust_balance_release();
|
|
720 }
|
|
721
|
|
722 void
|
|
723 equalizerwin_set_balance_slider(gint percent)
|
|
724 {
|
|
725 hslider_set_position(equalizerwin_balance,
|
|
726 (gint) rint((percent * 19 / 100.0) + 19));
|
|
727 }
|
|
728
|
|
729 void
|
|
730 equalizerwin_set_volume_slider(gint percent)
|
|
731 {
|
|
732 hslider_set_position(equalizerwin_volume,
|
|
733 (gint) rint(percent * 94 / 100.0));
|
|
734 }
|
|
735
|
|
736 static void
|
|
737 equalizerwin_create_widgets(void)
|
|
738 {
|
|
739 gint i;
|
|
740
|
|
741 equalizerwin_on =
|
|
742 create_tbutton(&equalizerwin_wlist, equalizerwin_bg,
|
|
743 equalizerwin_gc, 14, 18, 25, 12, 10, 119, 128, 119,
|
|
744 69, 119, 187, 119, equalizerwin_on_pushed,
|
|
745 SKIN_EQMAIN);
|
|
746 tbutton_set_toggled(equalizerwin_on, cfg.equalizer_active);
|
|
747 equalizerwin_auto =
|
|
748 create_tbutton(&equalizerwin_wlist, equalizerwin_bg,
|
|
749 equalizerwin_gc, 39, 18, 33, 12, 35, 119, 153, 119,
|
|
750 94, 119, 212, 119, equalizerwin_auto_pushed,
|
|
751 SKIN_EQMAIN);
|
|
752 tbutton_set_toggled(equalizerwin_auto, cfg.equalizer_autoload);
|
|
753 equalizerwin_presets =
|
|
754 create_pbutton(&equalizerwin_wlist, equalizerwin_bg,
|
|
755 equalizerwin_gc, 217, 18, 44, 12, 224, 164, 224,
|
|
756 176, equalizerwin_presets_pushed, SKIN_EQMAIN);
|
|
757 equalizerwin_close =
|
|
758 create_pbutton(&equalizerwin_wlist, equalizerwin_bg,
|
|
759 equalizerwin_gc, 264, 3, 9, 9, 0, 116, 0, 125,
|
|
760 equalizerwin_close_cb, SKIN_EQMAIN);
|
|
761 equalizerwin_close->pb_allow_draw = FALSE;
|
|
762
|
|
763 equalizerwin_shade =
|
|
764 create_pbutton_ex(&equalizerwin_wlist, equalizerwin_bg,
|
|
765 equalizerwin_gc, 254, 3, 9, 9, 254, 137, 1, 38,
|
|
766 equalizerwin_shade_toggle, NULL, SKIN_EQMAIN, SKIN_EQ_EX);
|
|
767 equalizerwin_shade->pb_allow_draw = FALSE;
|
|
768
|
|
769 equalizerwin_graph =
|
|
770 create_eqgraph(&equalizerwin_wlist, equalizerwin_bg,
|
|
771 equalizerwin_gc, 86, 17);
|
|
772 equalizerwin_preamp =
|
|
773 create_eqslider(&equalizerwin_wlist, equalizerwin_bg,
|
|
774 equalizerwin_gc, 21, 38);
|
|
775 eqslider_set_position(equalizerwin_preamp, cfg.equalizer_preamp);
|
|
776 for (i = 0; i < 10; i++) {
|
|
777 equalizerwin_bands[i] =
|
|
778 create_eqslider(&equalizerwin_wlist, equalizerwin_bg,
|
|
779 equalizerwin_gc, 78 + (i * 18), 38);
|
|
780 eqslider_set_position(equalizerwin_bands[i], cfg.equalizer_bands[i]);
|
|
781 }
|
|
782
|
|
783 equalizerwin_volume =
|
|
784 create_hslider(&equalizerwin_wlist, equalizerwin_bg,
|
|
785 equalizerwin_gc, 61, 4, 97, 8, 1, 30, 1, 30, 3, 7,
|
|
786 4, 61, 0, 94, equalizerwin_volume_frame_cb,
|
|
787 equalizerwin_volume_motion_cb,
|
|
788 equalizerwin_volume_release_cb, SKIN_EQ_EX);
|
|
789 equalizerwin_balance =
|
|
790 create_hslider(&equalizerwin_wlist, equalizerwin_bg,
|
|
791 equalizerwin_gc, 164, 4, 42, 8, 11, 30, 11, 30, 3,
|
|
792 7, 4, 164, 0, 39, equalizerwin_balance_frame_cb,
|
|
793 equalizerwin_balance_motion_cb,
|
|
794 equalizerwin_balance_release_cb, SKIN_EQ_EX);
|
|
795
|
|
796 if (!cfg.equalizer_shaded) {
|
|
797 widget_hide(WIDGET(equalizerwin_volume));
|
|
798 widget_hide(WIDGET(equalizerwin_balance));
|
|
799 }
|
|
800 else {
|
|
801 pbutton_set_button_data(equalizerwin_shade, -1, 3, -1, 47);
|
|
802 pbutton_set_skin_index1(equalizerwin_shade, SKIN_EQ_EX);
|
|
803 pbutton_set_button_data(equalizerwin_close, 11, 38, 11, 47);
|
|
804 pbutton_set_skin_index(equalizerwin_close, SKIN_EQ_EX);
|
|
805 }
|
|
806 }
|
|
807
|
|
808
|
|
809 static void
|
|
810 equalizerwin_create_window(void)
|
|
811 {
|
|
812 GdkPixbuf *icon;
|
|
813 gint width, height;
|
|
814
|
|
815 equalizerwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
|
816 gtk_window_set_title(GTK_WINDOW(equalizerwin), _("Audacious Equalizer"));
|
|
817 gtk_window_set_wmclass(GTK_WINDOW(equalizerwin), "equalizer", "Audacious");
|
|
818 gtk_window_set_role(GTK_WINDOW(equalizerwin), "equalizer");
|
|
819
|
|
820 width = 275;
|
|
821 height = cfg.equalizer_shaded ? 14 : 116;
|
|
822
|
1938
|
823 if (cfg.doublesize && cfg.eq_doublesize_linked) {
|
|
824 width *= 2;
|
|
825 height *= 2;
|
|
826 }
|
|
827
|
1653
|
828 gtk_window_set_default_size(GTK_WINDOW(equalizerwin), width, height);
|
|
829 gtk_window_set_resizable(GTK_WINDOW(equalizerwin), FALSE);
|
|
830
|
|
831 dock_window_list = dock_window_set_decorated(dock_window_list,
|
|
832 GTK_WINDOW(equalizerwin),
|
|
833 cfg.show_wm_decorations);
|
|
834
|
|
835 /* this will hide only mainwin. it's annoying! yaz */
|
|
836 gtk_window_set_transient_for(GTK_WINDOW(equalizerwin),
|
|
837 GTK_WINDOW(mainwin));
|
|
838 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(equalizerwin), TRUE);
|
|
839
|
|
840 icon = gdk_pixbuf_new_from_xpm_data((const gchar **) bmp_eq_icon);
|
|
841 gtk_window_set_icon(GTK_WINDOW(equalizerwin), icon);
|
|
842 g_object_unref(icon);
|
|
843
|
|
844 gtk_widget_set_app_paintable(equalizerwin, TRUE);
|
|
845
|
|
846 if (cfg.equalizer_x != -1 && cfg.save_window_position)
|
|
847 gtk_window_move(GTK_WINDOW(equalizerwin),
|
|
848 cfg.equalizer_x, cfg.equalizer_y);
|
|
849
|
|
850 gtk_widget_set_events(equalizerwin,
|
|
851 GDK_FOCUS_CHANGE_MASK | GDK_BUTTON_MOTION_MASK |
|
|
852 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
|
|
853 GDK_VISIBILITY_NOTIFY_MASK);
|
|
854 gtk_widget_realize(equalizerwin);
|
|
855
|
|
856 util_set_cursor(equalizerwin);
|
|
857
|
|
858 g_signal_connect(equalizerwin, "delete_event",
|
|
859 G_CALLBACK(equalizerwin_delete), NULL);
|
|
860 g_signal_connect(equalizerwin, "button_press_event",
|
|
861 G_CALLBACK(equalizerwin_press), NULL);
|
|
862 g_signal_connect(equalizerwin, "button_release_event",
|
|
863 G_CALLBACK(equalizerwin_release), NULL);
|
|
864 g_signal_connect(equalizerwin, "motion_notify_event",
|
|
865 G_CALLBACK(equalizerwin_motion), NULL);
|
|
866 g_signal_connect_after(equalizerwin, "focus_in_event",
|
|
867 G_CALLBACK(equalizerwin_focus_in), NULL);
|
|
868 g_signal_connect_after(equalizerwin, "focus_out_event",
|
|
869 G_CALLBACK(equalizerwin_focus_out), NULL);
|
|
870 g_signal_connect(equalizerwin, "configure_event",
|
|
871 G_CALLBACK(equalizerwin_configure), NULL);
|
|
872 g_signal_connect(equalizerwin, "style_set",
|
|
873 G_CALLBACK(equalizerwin_set_back_pixmap), NULL);
|
|
874 g_signal_connect(equalizerwin, "key_press_event",
|
|
875 G_CALLBACK(equalizerwin_keypress), NULL);
|
|
876 g_signal_connect(equalizerwin, "scroll_event",
|
|
877 G_CALLBACK(equalizerwin_scroll), NULL);
|
|
878 }
|
|
879
|
|
880 void
|
|
881 equalizerwin_create_popup_menus(void)
|
|
882 {
|
|
883 equalizerwin_accel = gtk_accel_group_new();
|
|
884 gtk_window_add_accel_group(GTK_WINDOW(equalizerwin), equalizerwin_accel);
|
|
885
|
|
886 equalizerwin_presets_menu = create_menu(equalizerwin_presets_menu_entries,
|
|
887 equalizerwin_presets_menu_entries_num,
|
|
888 NULL);
|
|
889 }
|
|
890
|
|
891 void
|
|
892 equalizerwin_create(void)
|
|
893 {
|
|
894 equalizer_presets = equalizerwin_read_presets("eq.preset");
|
|
895 equalizer_auto_presets = equalizerwin_read_presets("eq.auto_preset");
|
|
896
|
|
897 equalizerwin_create_window();
|
|
898 equalizerwin_create_popup_menus();
|
|
899
|
|
900 equalizerwin_gc = gdk_gc_new(equalizerwin->window);
|
|
901 equalizerwin_bg = gdk_pixmap_new(equalizerwin->window, 275, 116, -1);
|
1938
|
902 equalizerwin_bg_x2 = gdk_pixmap_new(equalizerwin->window, 550, 232, -1);
|
1653
|
903
|
|
904 equalizerwin_create_widgets();
|
|
905
|
|
906 equalizerwin_set_back_pixmap();
|
1938
|
907 if (cfg.doublesize && cfg.eq_doublesize_linked)
|
|
908 gdk_window_set_back_pixmap(equalizerwin->window,
|
|
909 equalizerwin_bg_x2, 0);
|
|
910 else
|
|
911 gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg, 0);
|
1653
|
912 }
|
|
913
|
|
914
|
|
915 void
|
|
916 equalizerwin_show(gboolean show)
|
|
917 {
|
|
918 GtkWidget *item = gtk_item_factory_get_widget(mainwin_view_menu,
|
|
919 "/Show Equalizer");
|
|
920 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), show);
|
|
921 }
|
|
922
|
|
923 void
|
|
924 equalizerwin_real_show(void)
|
|
925 {
|
|
926 /*
|
|
927 * This function should only be called from the
|
|
928 * main menu signal handler
|
|
929 */
|
|
930
|
|
931 gint x, y;
|
|
932
|
|
933 gtk_window_get_position(GTK_WINDOW(equalizerwin), &x, &y);
|
|
934 gtk_window_move(GTK_WINDOW(equalizerwin), x, y);
|
1938
|
935 if (cfg.doublesize && cfg.eq_doublesize_linked)
|
|
936 gtk_widget_set_size_request(equalizerwin, 550,
|
|
937 (cfg.equalizer_shaded ? 28 : 232));
|
|
938 else
|
|
939 gtk_widget_set_size_request(equalizerwin, 275,
|
|
940 (cfg.equalizer_shaded ? 14 : 116));
|
1653
|
941 gdk_flush();
|
|
942 draw_equalizer_window(TRUE);
|
|
943 cfg.equalizer_visible = TRUE;
|
|
944 tbutton_set_toggled(mainwin_eq, TRUE);
|
|
945
|
|
946 gtk_widget_show(equalizerwin);
|
|
947 }
|
|
948
|
|
949 void
|
|
950 equalizerwin_real_hide(void)
|
|
951 {
|
|
952 /*
|
|
953 * This function should only be called from the
|
|
954 * main menu signal handler
|
|
955 */
|
|
956 gtk_widget_hide(equalizerwin);
|
|
957 cfg.equalizer_visible = FALSE;
|
|
958 tbutton_set_toggled(mainwin_eq, FALSE);
|
|
959 }
|
|
960
|
|
961 static EqualizerPreset *
|
|
962 equalizerwin_find_preset(GList * list, const gchar * name)
|
|
963 {
|
|
964 GList *node = list;
|
|
965 EqualizerPreset *preset;
|
|
966
|
|
967 while (node) {
|
|
968 preset = node->data;
|
|
969 if (!strcasecmp(preset->name, name))
|
|
970 return preset;
|
|
971 node = g_list_next(node);
|
|
972 }
|
|
973 return NULL;
|
|
974 }
|
|
975
|
|
976 static void
|
|
977 equalizerwin_write_preset_file(GList * list, const gchar * basename)
|
|
978 {
|
|
979 gchar *filename, *tmp;
|
|
980 gint i, p;
|
|
981 EqualizerPreset *preset;
|
|
982 RcFile *rcfile;
|
|
983 GList *node;
|
|
984
|
|
985 rcfile = bmp_rcfile_new();
|
|
986 p = 0;
|
|
987 for (node = list; node; node = g_list_next(node)) {
|
|
988 preset = node->data;
|
|
989 tmp = g_strdup_printf("Preset%d", p++);
|
|
990 bmp_rcfile_write_string(rcfile, "Presets", tmp, preset->name);
|
|
991 g_free(tmp);
|
|
992 bmp_rcfile_write_float(rcfile, preset->name, "Preamp",
|
|
993 preset->preamp);
|
|
994 for (i = 0; i < 10; i++) {
|
|
995 tmp = g_strdup_printf("Band%d\n", i);
|
|
996 bmp_rcfile_write_float(rcfile, preset->name, tmp,
|
|
997 preset->bands[i]);
|
|
998 g_free(tmp);
|
|
999 }
|
|
1000 }
|
|
1001
|
|
1002 filename = g_build_filename(bmp_paths[BMP_PATH_USER_DIR], basename, NULL);
|
|
1003 bmp_rcfile_write(rcfile, filename);
|
|
1004 bmp_rcfile_free(rcfile);
|
|
1005 g_free(filename);
|
|
1006 }
|
|
1007
|
|
1008 static gboolean
|
|
1009 equalizerwin_load_preset(GList * list, const gchar * name)
|
|
1010 {
|
|
1011 EqualizerPreset *preset;
|
|
1012 gint i;
|
|
1013
|
|
1014 if ((preset = equalizerwin_find_preset(list, name)) != NULL) {
|
|
1015 eqslider_set_position(equalizerwin_preamp, preset->preamp);
|
|
1016 for (i = 0; i < 10; i++)
|
|
1017 eqslider_set_position(equalizerwin_bands[i], preset->bands[i]);
|
|
1018 equalizerwin_eq_changed();
|
|
1019 return TRUE;
|
|
1020 }
|
|
1021 return FALSE;
|
|
1022 }
|
|
1023
|
|
1024 static GList *
|
|
1025 equalizerwin_save_preset(GList * list, const gchar * name,
|
|
1026 const gchar * filename)
|
|
1027 {
|
|
1028 gint i;
|
|
1029 EqualizerPreset *preset;
|
|
1030
|
|
1031 if (!(preset = equalizerwin_find_preset(list, name))) {
|
|
1032 preset = g_new0(EqualizerPreset, 1);
|
|
1033 preset->name = g_strdup(name);
|
|
1034 list = g_list_append(list, preset);
|
|
1035 }
|
|
1036
|
|
1037 preset->preamp = eqslider_get_position(equalizerwin_preamp);
|
|
1038 for (i = 0; i < 10; i++)
|
|
1039 preset->bands[i] = eqslider_get_position(equalizerwin_bands[i]);
|
|
1040
|
|
1041 equalizerwin_write_preset_file(list, filename);
|
|
1042
|
|
1043 return list;
|
|
1044 }
|
|
1045
|
|
1046 static GList *
|
|
1047 equalizerwin_delete_preset(GList * list, gchar * name, gchar * filename)
|
|
1048 {
|
|
1049 EqualizerPreset *preset;
|
|
1050 GList *node;
|
|
1051
|
|
1052 if (!(preset = equalizerwin_find_preset(list, name)))
|
|
1053 return list;
|
|
1054
|
|
1055 if (!(node = g_list_find(list, preset)))
|
|
1056 return list;
|
|
1057
|
|
1058 list = g_list_remove_link(list, node);
|
|
1059 equalizer_preset_free(preset);
|
|
1060 g_list_free_1(node);
|
|
1061
|
|
1062 equalizerwin_write_preset_file(list, filename);
|
|
1063
|
|
1064 return list;
|
|
1065 }
|
|
1066
|
|
1067
|
|
1068 static GList *
|
|
1069 import_winamp_eqf(VFSFile * file)
|
|
1070 {
|
|
1071 gchar header[31];
|
|
1072 gchar name[257];
|
|
1073 gchar bands[11];
|
|
1074 gint i = 0;
|
|
1075 GList *list = NULL;
|
|
1076 EqualizerPreset *preset;
|
|
1077
|
|
1078 vfs_fread(header, 1, 31, file);
|
|
1079 if (!strncmp(header, "Winamp EQ library file v1.1", 27)) {
|
|
1080 while (vfs_fread(name, 1, 257, file)) {
|
|
1081 preset = equalizer_preset_new(name);
|
|
1082 preset->preamp = 20.0 - ((bands[10] * 40.0) / 64);
|
|
1083
|
|
1084 vfs_fread(bands, 1, 11, file);
|
|
1085
|
|
1086 for (i = 0; i < 10; i++)
|
|
1087 preset->bands[i] = 20.0 - ((bands[i] * 40.0) / 64);
|
|
1088
|
|
1089 list = g_list_prepend(list, preset);
|
|
1090 }
|
|
1091 }
|
|
1092
|
|
1093 list = g_list_reverse(list);
|
|
1094 return list;
|
|
1095 }
|
|
1096
|
|
1097 static void
|
|
1098 equalizerwin_read_winamp_eqf(VFSFile * file)
|
|
1099 {
|
|
1100 gchar header[31];
|
|
1101 guchar bands[11];
|
|
1102 gint i;
|
|
1103
|
|
1104 vfs_fread(header, 1, 31, file);
|
|
1105
|
|
1106 if (!strncmp(header, "Winamp EQ library file v1.1", 27)) {
|
|
1107 /* Skip name */
|
|
1108 if (vfs_fseek(file, 257, SEEK_CUR) == -1)
|
|
1109 return;
|
|
1110
|
|
1111 if (vfs_fread(bands, 1, 11, file) != 11)
|
|
1112 return;
|
|
1113
|
|
1114 eqslider_set_position(equalizerwin_preamp,
|
|
1115 20.0 - ((bands[10] * 40.0) / 63.0));
|
|
1116
|
|
1117 for (i = 0; i < 10; i++)
|
|
1118 eqslider_set_position(equalizerwin_bands[i],
|
|
1119 20.0 - ((bands[i] * 40.0) / 64.0));
|
|
1120 }
|
|
1121
|
|
1122 equalizerwin_eq_changed();
|
|
1123 }
|
|
1124
|
|
1125 static void
|
|
1126 equalizerwin_read_bmp_preset(RcFile * rcfile)
|
|
1127 {
|
|
1128 gfloat val;
|
|
1129 gint i;
|
|
1130
|
|
1131 if (bmp_rcfile_read_float(rcfile, "Equalizer preset", "Preamp", &val))
|
|
1132 eqslider_set_position(equalizerwin_preamp, val);
|
|
1133 for (i = 0; i < 10; i++) {
|
|
1134 gchar tmp[7];
|
|
1135 g_snprintf(tmp, sizeof(tmp), "Band%d", i);
|
|
1136 if (bmp_rcfile_read_float(rcfile, "Equalizer preset", tmp, &val))
|
|
1137 eqslider_set_position(equalizerwin_bands[i], val);
|
|
1138 }
|
|
1139 equalizerwin_eq_changed();
|
|
1140 }
|
|
1141
|
|
1142 static void
|
|
1143 equalizerwin_save_ok(GtkWidget * widget, gpointer data)
|
|
1144 {
|
|
1145 const gchar *text;
|
|
1146
|
|
1147 text = gtk_entry_get_text(GTK_ENTRY(equalizerwin_save_entry));
|
|
1148 if (strlen(text) != 0)
|
|
1149 equalizer_presets =
|
|
1150 equalizerwin_save_preset(equalizer_presets, text, "eq.preset");
|
|
1151 gtk_widget_destroy(equalizerwin_save_window);
|
|
1152 }
|
|
1153
|
|
1154 static void
|
|
1155 equalizerwin_save_select(GtkCList * clist, gint row,
|
|
1156 gint column, GdkEventButton * event, gpointer data)
|
|
1157 {
|
|
1158 gchar *text;
|
|
1159
|
|
1160 gtk_clist_get_text(clist, row, 0, &text);
|
|
1161
|
|
1162 gtk_entry_set_text(GTK_ENTRY(equalizerwin_save_entry), text);
|
|
1163 if (event->type == GDK_2BUTTON_PRESS)
|
|
1164 equalizerwin_save_ok(NULL, NULL);
|
|
1165
|
|
1166 }
|
|
1167
|
|
1168 static void
|
|
1169 equalizerwin_load_ok(GtkWidget * widget, gpointer data)
|
|
1170 {
|
|
1171 gchar *text;
|
|
1172 GtkCList *clist = GTK_CLIST(data);
|
|
1173
|
|
1174 if (clist && clist->selection) {
|
|
1175 gtk_clist_get_text(clist, GPOINTER_TO_INT(clist->selection->data),
|
|
1176 0, &text);
|
|
1177 equalizerwin_load_preset(equalizer_presets, text);
|
|
1178 }
|
|
1179 gtk_widget_destroy(equalizerwin_load_window);
|
|
1180 }
|
|
1181
|
|
1182 static void
|
|
1183 equalizerwin_load_apply(GtkWidget * widget, gpointer data)
|
|
1184 {
|
|
1185 gchar *text;
|
|
1186 GtkCList *clist = GTK_CLIST(data);
|
|
1187
|
|
1188 if (clist && clist->selection) {
|
|
1189 gtk_clist_get_text(clist, GPOINTER_TO_INT(clist->selection->data),
|
|
1190 0, &text);
|
|
1191 equalizerwin_load_preset(equalizer_presets, text);
|
|
1192 }
|
|
1193 }
|
|
1194
|
|
1195
|
|
1196 static void
|
|
1197 equalizerwin_load_select(GtkCList * widget, gint row,
|
|
1198 gint column, GdkEventButton * event, gpointer data)
|
|
1199 {
|
|
1200 if (event->type == GDK_2BUTTON_PRESS)
|
|
1201 equalizerwin_load_ok(NULL, widget);
|
|
1202 }
|
|
1203
|
|
1204 static void
|
|
1205 equalizerwin_delete_delete(GtkWidget * widget, gpointer data)
|
|
1206 {
|
|
1207 gchar *text;
|
|
1208 GList *list, *next;
|
|
1209 GtkCList *clist = GTK_CLIST(data);
|
|
1210
|
|
1211 g_return_if_fail(clist != NULL);
|
|
1212
|
|
1213 list = clist->selection;
|
|
1214 gtk_clist_freeze(clist);
|
|
1215 while (list) {
|
|
1216 next = g_list_next(list);
|
|
1217 gtk_clist_get_text(clist, GPOINTER_TO_INT(list->data), 0, &text);
|
|
1218 equalizer_auto_presets =
|
|
1219 equalizerwin_delete_preset(equalizer_presets, text, "eq.preset");
|
|
1220 gtk_clist_remove(clist, GPOINTER_TO_INT(list->data));
|
|
1221 list = next;
|
|
1222 }
|
|
1223 gtk_clist_thaw(clist);
|
|
1224 }
|
|
1225
|
|
1226 static void
|
|
1227 equalizerwin_save_auto_ok(GtkWidget * widget, gpointer data)
|
|
1228 {
|
|
1229 const gchar *text;
|
|
1230
|
|
1231 text = gtk_entry_get_text(GTK_ENTRY(equalizerwin_save_auto_entry));
|
|
1232 if (strlen(text) != 0)
|
|
1233 equalizer_auto_presets =
|
|
1234 equalizerwin_save_preset(equalizer_auto_presets, text,
|
|
1235 "eq.auto_preset");
|
|
1236 gtk_widget_destroy(equalizerwin_save_auto_window);
|
|
1237 }
|
|
1238
|
|
1239 static void
|
|
1240 equalizerwin_save_auto_select(GtkCList * clist, gint row,
|
|
1241 gint column,
|
|
1242 GdkEventButton * event, gpointer data)
|
|
1243 {
|
|
1244 gchar *text;
|
|
1245
|
|
1246 gtk_clist_get_text(clist, row, 0, &text);
|
|
1247
|
|
1248 gtk_entry_set_text(GTK_ENTRY(equalizerwin_save_auto_entry), text);
|
|
1249 if (event->type == GDK_2BUTTON_PRESS)
|
|
1250 equalizerwin_save_auto_ok(NULL, NULL);
|
|
1251
|
|
1252 }
|
|
1253
|
|
1254 static void
|
|
1255 equalizerwin_load_auto_ok(GtkWidget * widget, gpointer data)
|
|
1256 {
|
|
1257 gchar *text;
|
|
1258 GtkCList *clist = GTK_CLIST(data);
|
|
1259
|
|
1260 if (clist && clist->selection) {
|
|
1261 gtk_clist_get_text(clist, GPOINTER_TO_INT(clist->selection->data),
|
|
1262 0, &text);
|
|
1263 equalizerwin_load_preset(equalizer_auto_presets, text);
|
|
1264 }
|
|
1265 gtk_widget_destroy(equalizerwin_load_auto_window);
|
|
1266 }
|
|
1267
|
|
1268 static void
|
|
1269 equalizerwin_load_auto_select(GtkWidget * widget, gint row,
|
|
1270 gint column,
|
|
1271 GdkEventButton * event, gpointer data)
|
|
1272 {
|
|
1273 if (event->type == GDK_2BUTTON_PRESS)
|
|
1274 equalizerwin_load_auto_ok(NULL, widget);
|
|
1275 }
|
|
1276
|
|
1277 static void
|
|
1278 equalizerwin_delete_auto_delete(GtkWidget * widget, gpointer data)
|
|
1279 {
|
|
1280 gchar *text;
|
|
1281 GList *list, *next;
|
|
1282 GtkCList *clist = GTK_CLIST(data);
|
|
1283
|
|
1284 g_return_if_fail(clist != NULL);
|
|
1285
|
|
1286 list = clist->selection;
|
|
1287 gtk_clist_freeze(clist);
|
|
1288 while (list) {
|
|
1289 next = g_list_next(list);
|
|
1290 gtk_clist_get_text(clist, GPOINTER_TO_INT(list->data), 0, &text);
|
|
1291 equalizer_auto_presets =
|
|
1292 equalizerwin_delete_preset(equalizer_auto_presets, text,
|
|
1293 "eq.auto_preset");
|
|
1294 gtk_clist_remove(clist, GPOINTER_TO_INT(list->data));
|
|
1295 list = next;
|
|
1296 }
|
|
1297 gtk_clist_thaw(clist);
|
|
1298 }
|
|
1299
|
|
1300
|
|
1301 typedef void (*ResponseHandler)(const gchar *filename);
|
|
1302
|
|
1303 static void
|
|
1304 equalizerwin_file_chooser_on_response(GtkWidget * dialog,
|
|
1305 gint response,
|
|
1306 gpointer data)
|
|
1307 {
|
|
1308 GtkFileChooser *file_chooser = GTK_FILE_CHOOSER(dialog);
|
|
1309 ResponseHandler handler = (ResponseHandler) data;
|
|
1310 gchar *filename;
|
|
1311
|
|
1312 gtk_widget_hide(dialog);
|
|
1313
|
|
1314 switch (response)
|
|
1315 {
|
|
1316 case GTK_RESPONSE_ACCEPT:
|
|
1317 filename = gtk_file_chooser_get_filename(file_chooser);
|
|
1318 handler(filename);
|
|
1319 g_free(filename);
|
|
1320 break;
|
|
1321
|
|
1322 case GTK_RESPONSE_REJECT:
|
|
1323 break;
|
|
1324 }
|
|
1325
|
|
1326 gtk_widget_destroy(dialog);
|
|
1327 }
|
|
1328
|
|
1329
|
|
1330
|
|
1331 static void
|
|
1332 load_preset_file(const gchar *filename)
|
|
1333 {
|
|
1334 RcFile *rcfile;
|
|
1335
|
|
1336 if ((rcfile = bmp_rcfile_open(filename)) != NULL) {
|
|
1337 equalizerwin_read_bmp_preset(rcfile);
|
|
1338 bmp_rcfile_free(rcfile);
|
|
1339 }
|
|
1340 }
|
|
1341
|
|
1342 static void
|
|
1343 load_winamp_file(const gchar * filename)
|
|
1344 {
|
|
1345 VFSFile *file;
|
|
1346 gchar *tmp;
|
|
1347
|
|
1348 if (!(file = vfs_fopen(filename, "rb"))) {
|
|
1349 tmp = g_strconcat("Failed to load WinAmp file: ",filename,"\n",NULL);
|
|
1350 report_error(tmp);
|
|
1351 g_free(tmp);
|
|
1352 return;
|
|
1353 }
|
|
1354
|
|
1355 equalizerwin_read_winamp_eqf(file);
|
|
1356 vfs_fclose(file);
|
|
1357 }
|
|
1358
|
|
1359 static void
|
|
1360 import_winamp_file(const gchar * filename)
|
|
1361 {
|
|
1362 VFSFile *file;
|
|
1363 gchar *tmp;
|
|
1364
|
|
1365 if (!(file = vfs_fopen(filename, "rb"))) {
|
|
1366 tmp = g_strconcat("Failed to import WinAmp file: ",filename,"\n",NULL);
|
|
1367 report_error(tmp);
|
|
1368 g_free(tmp);
|
|
1369 return;
|
|
1370 }
|
|
1371
|
|
1372 equalizer_presets = g_list_concat(equalizer_presets,
|
|
1373 import_winamp_eqf(file));
|
|
1374 equalizerwin_write_preset_file(equalizer_presets, "eq.preset");
|
|
1375
|
|
1376 vfs_fclose(file);
|
|
1377 }
|
|
1378
|
|
1379 static void
|
|
1380 save_preset_file(const gchar * filename)
|
|
1381 {
|
|
1382 RcFile *rcfile;
|
|
1383 gint i;
|
|
1384
|
|
1385 rcfile = bmp_rcfile_new();
|
|
1386 bmp_rcfile_write_float(rcfile, "Equalizer preset", "Preamp",
|
|
1387 eqslider_get_position(equalizerwin_preamp));
|
|
1388
|
|
1389 for (i = 0; i < 10; i++) {
|
|
1390 gchar tmp[7];
|
|
1391 g_snprintf(tmp, sizeof(tmp), "Band%d", i);
|
|
1392 bmp_rcfile_write_float(rcfile, "Equalizer preset", tmp,
|
|
1393 eqslider_get_position(equalizerwin_bands[i]));
|
|
1394 }
|
|
1395
|
|
1396 bmp_rcfile_write(rcfile, filename);
|
|
1397 bmp_rcfile_free(rcfile);
|
|
1398 }
|
|
1399
|
|
1400 static void
|
|
1401 save_winamp_file(const gchar * filename)
|
|
1402 {
|
|
1403 VFSFile *file;
|
|
1404
|
|
1405 gchar name[257];
|
|
1406 gint i;
|
|
1407 guchar bands[11];
|
|
1408 gchar *tmp;
|
|
1409
|
|
1410 if (!(file = vfs_fopen(filename, "wb"))) {
|
|
1411 tmp = g_strconcat("Failed to save WinAmp file: ",filename,"\n",NULL);
|
|
1412 report_error(tmp);
|
|
1413 g_free(tmp);
|
|
1414 return;
|
|
1415 }
|
|
1416
|
|
1417 vfs_fwrite("Winamp EQ library file v1.1\x1a!--", 1, 31, file);
|
|
1418
|
|
1419 memset(name, 0, 257);
|
|
1420 strcpy(name, "Entry1");
|
|
1421 vfs_fwrite(name, 1, 257, file);
|
|
1422
|
|
1423 for (i = 0; i < 10; i++)
|
|
1424 bands[i] = 63 - (((eqslider_get_position(equalizerwin_bands[i]) + 20) * 63) / 40);
|
|
1425 bands[10] = 63 - (((eqslider_get_position(equalizerwin_preamp) + 20) * 63) / 40);
|
|
1426 vfs_fwrite(bands, 1, 11, file);
|
|
1427
|
|
1428 vfs_fclose(file);
|
|
1429 }
|
|
1430
|
|
1431 static gint
|
|
1432 equalizerwin_list_sort_func(GtkCList * clist,
|
|
1433 gconstpointer ptr1, gconstpointer ptr2)
|
|
1434 {
|
|
1435 GtkCListRow *row1 = (GtkCListRow *) ptr1;
|
|
1436 GtkCListRow *row2 = (GtkCListRow *) ptr2;
|
|
1437
|
|
1438 return strcasecmp(GTK_CELL_TEXT(row1->cell[clist->sort_column])->text,
|
|
1439 GTK_CELL_TEXT(row2->cell[clist->sort_column])->text);
|
|
1440 }
|
|
1441
|
|
1442
|
|
1443 static GtkListStore *
|
|
1444 preset_list_store_new(GList * preset)
|
|
1445 {
|
|
1446 GtkListStore *store;
|
|
1447 GtkTreeIter iter;
|
|
1448 GList *node;
|
|
1449
|
|
1450 store = gtk_list_store_new(PRESET_VIEW_N_COLS, G_TYPE_STRING);
|
|
1451
|
|
1452 for (node = preset; node; node = g_list_next(node)) {
|
|
1453 gtk_list_store_append(store, &iter);
|
|
1454 gtk_list_store_set(store, &iter,
|
|
1455 PRESET_VIEW_COL_NAME,
|
|
1456 &((EqualizerPreset *) node->data)->name, -1);
|
|
1457 }
|
|
1458
|
|
1459 return store;
|
|
1460 }
|
|
1461
|
|
1462
|
|
1463 GtkWidget *
|
|
1464 preset_view_new(GList * preset)
|
|
1465 {
|
|
1466 GtkWidget *treeview;
|
|
1467 GtkTreeModel *model;
|
|
1468 GtkTreeViewColumn *column;
|
|
1469 GtkCellRenderer *renderer;
|
|
1470 GtkListStore *store;
|
|
1471
|
|
1472 store = preset_list_store_new(preset);
|
|
1473
|
|
1474 model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(store));
|
|
1475 gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model),
|
|
1476 PRESET_VIEW_COL_NAME,
|
|
1477 GTK_SORT_ASCENDING);
|
|
1478
|
|
1479 treeview = gtk_tree_view_new_with_model(model);
|
|
1480 gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(treeview), TRUE);
|
|
1481 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE);
|
|
1482
|
|
1483 renderer = gtk_cell_renderer_text_new();
|
|
1484 column = gtk_tree_view_column_new_with_attributes(_("Preset"), renderer,
|
|
1485 "text",
|
|
1486 PRESET_VIEW_COL_NAME,
|
|
1487 NULL);
|
|
1488 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
|
|
1489
|
|
1490 return treeview;
|
|
1491 }
|
|
1492
|
|
1493
|
|
1494 static GtkWidget *
|
|
1495 equalizerwin_create_list_window(GList * preset_list,
|
|
1496 const gchar * title,
|
|
1497 GtkWidget ** window,
|
|
1498 GtkSelectionMode sel_mode,
|
|
1499 GtkWidget ** entry,
|
|
1500 const gchar * btn2_stock_name,
|
|
1501 const gchar * btn3_stock_name,
|
|
1502 const gchar * btn1_stock_name,
|
|
1503 GCallback btn2_func,
|
|
1504 GCallback btn3_func,
|
|
1505 GCallback select_row_func)
|
|
1506 {
|
|
1507 GtkWidget *vbox, *scrolled_window, *bbox, *btn1, *btn2, *btn3, *clist;
|
|
1508 gchar *preset_text[1];
|
|
1509 GList *node;
|
|
1510
|
|
1511 *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
|
1512 gtk_window_set_title(GTK_WINDOW(*window), title);
|
|
1513 gtk_window_set_type_hint(GTK_WINDOW(*window), GDK_WINDOW_TYPE_HINT_DIALOG);
|
|
1514 gtk_window_set_default_size(GTK_WINDOW(*window), 350, 300);
|
|
1515 gtk_window_set_position(GTK_WINDOW(*window), GTK_WIN_POS_CENTER);
|
|
1516 gtk_container_set_border_width(GTK_CONTAINER(*window), 10);
|
|
1517 gtk_window_set_transient_for(GTK_WINDOW(*window),
|
|
1518 GTK_WINDOW(equalizerwin));
|
|
1519 g_signal_connect(*window, "destroy",
|
|
1520 G_CALLBACK(gtk_widget_destroyed), window);
|
|
1521
|
|
1522 vbox = gtk_vbox_new(FALSE, 10);
|
|
1523 gtk_container_add(GTK_CONTAINER(*window), vbox);
|
|
1524
|
|
1525 scrolled_window = gtk_scrolled_window_new(NULL, NULL);
|
|
1526 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
|
|
1527 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
|
|
1528
|
|
1529 preset_text[0] = _("Presets");
|
|
1530 clist = gtk_clist_new_with_titles(1, preset_text);
|
|
1531 if (select_row_func)
|
|
1532 g_signal_connect(clist, "select_row",
|
|
1533 G_CALLBACK(select_row_func), NULL);
|
|
1534 gtk_clist_column_titles_passive(GTK_CLIST(clist));
|
|
1535 gtk_clist_set_selection_mode(GTK_CLIST(clist), sel_mode);
|
|
1536
|
|
1537 for (node = preset_list; node; node = g_list_next(node)) {
|
|
1538 gtk_clist_append(GTK_CLIST(clist),
|
|
1539 &((EqualizerPreset *) node->data)->name);
|
|
1540 }
|
|
1541 gtk_clist_set_compare_func(GTK_CLIST(clist), equalizerwin_list_sort_func);
|
|
1542 gtk_clist_sort(GTK_CLIST(clist));
|
|
1543
|
|
1544 gtk_container_add(GTK_CONTAINER(scrolled_window), clist);
|
|
1545 gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);
|
|
1546
|
|
1547 if (entry) {
|
|
1548 *entry = gtk_entry_new();
|
|
1549 g_signal_connect(*entry, "activate", btn2_func, NULL);
|
|
1550 gtk_box_pack_start(GTK_BOX(vbox), *entry, FALSE, FALSE, 0);
|
|
1551 }
|
|
1552
|
|
1553 bbox = gtk_hbutton_box_new();
|
|
1554 gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
|
|
1555 gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
|
|
1556 gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
|
|
1557
|
|
1558 btn1 = gtk_button_new_from_stock(btn1_stock_name);
|
|
1559 g_signal_connect_swapped(btn1, "clicked",
|
|
1560 G_CALLBACK(gtk_widget_destroy),
|
|
1561 GTK_OBJECT(*window));
|
|
1562 gtk_box_pack_start(GTK_BOX(bbox), btn1, TRUE, TRUE, 0);
|
|
1563
|
|
1564 if (btn3_stock_name) {
|
|
1565 btn3 = gtk_button_new_from_stock(btn3_stock_name);
|
|
1566 g_signal_connect(btn3, "clicked", G_CALLBACK(btn3_func), clist);
|
|
1567 gtk_box_pack_start(GTK_BOX(bbox), btn3, TRUE, TRUE, 0);
|
|
1568 }
|
|
1569
|
|
1570 btn2 = gtk_button_new_from_stock(btn2_stock_name);
|
|
1571 g_signal_connect(btn2, "clicked", G_CALLBACK(btn2_func), clist);
|
|
1572 GTK_WIDGET_SET_FLAGS(btn2, GTK_CAN_DEFAULT);
|
|
1573
|
|
1574 gtk_box_pack_start(GTK_BOX(bbox), btn2, TRUE, TRUE, 0);
|
|
1575
|
|
1576 gtk_widget_grab_default(btn2);
|
|
1577
|
|
1578
|
|
1579 gtk_widget_show_all(*window);
|
|
1580
|
|
1581 return *window;
|
|
1582 }
|
|
1583
|
|
1584 void
|
|
1585 equalizerwin_presets_menu_cb(gpointer cb_data, guint action, GtkWidget * w)
|
|
1586 {
|
|
1587 GtkWidget *dialog;
|
|
1588
|
|
1589 switch (action) {
|
|
1590 case EQUALIZER_PRESETS_LOAD_PRESET:
|
|
1591 if (!equalizerwin_load_window)
|
|
1592 equalizerwin_create_list_window(equalizer_presets,
|
|
1593 _("Load preset"),
|
|
1594 &equalizerwin_load_window,
|
|
1595 GTK_SELECTION_SINGLE, NULL,
|
|
1596 GTK_STOCK_OK, GTK_STOCK_APPLY, GTK_STOCK_CANCEL,
|
|
1597 G_CALLBACK
|
|
1598 (equalizerwin_load_ok),
|
|
1599 G_CALLBACK
|
|
1600 (equalizerwin_load_apply),
|
|
1601 G_CALLBACK
|
|
1602 (equalizerwin_load_select));
|
|
1603 else
|
|
1604 gtk_window_present(GTK_WINDOW(equalizerwin_load_window));
|
|
1605 break;
|
|
1606 case EQUALIZER_PRESETS_LOAD_AUTOPRESET:
|
|
1607 if (!equalizerwin_load_auto_window)
|
|
1608 equalizerwin_create_list_window(equalizer_auto_presets,
|
|
1609 _("Load auto-preset"),
|
|
1610 &equalizerwin_load_auto_window,
|
|
1611 GTK_SELECTION_SINGLE, NULL,
|
|
1612 GTK_STOCK_OK, NULL, GTK_STOCK_CANCEL,
|
|
1613 G_CALLBACK
|
|
1614 (equalizerwin_load_auto_ok),
|
|
1615 NULL,
|
|
1616 G_CALLBACK
|
|
1617 (equalizerwin_load_auto_select));
|
|
1618 else
|
|
1619 gtk_window_present(GTK_WINDOW(equalizerwin_load_auto_window));
|
|
1620 break;
|
|
1621 case EQUALIZER_PRESETS_LOAD_DEFAULT:
|
|
1622 equalizerwin_load_preset(equalizer_presets, "Default");
|
|
1623 break;
|
|
1624 case EQUALIZER_PRESETS_LOAD_ZERO:
|
|
1625 {
|
|
1626 gint i;
|
|
1627
|
|
1628 eqslider_set_position(equalizerwin_preamp, 0);
|
|
1629 for (i = 0; i < 10; i++)
|
|
1630 eqslider_set_position(equalizerwin_bands[i], 0);
|
|
1631 equalizerwin_eq_changed();
|
|
1632 break;
|
|
1633 }
|
|
1634 case EQUALIZER_PRESETS_LOAD_FROM_FILE:
|
|
1635 dialog = make_filebrowser(_("Load equalizer preset"), FALSE);
|
|
1636 g_signal_connect(dialog , "response",
|
|
1637 G_CALLBACK(equalizerwin_file_chooser_on_response),
|
|
1638 load_preset_file);
|
|
1639 break;
|
|
1640 case EQUALIZER_PRESETS_LOAD_FROM_WINAMPFILE:
|
|
1641 dialog = make_filebrowser(_("Load equalizer preset"), FALSE);
|
|
1642 g_signal_connect(dialog, "response",
|
|
1643 G_CALLBACK(equalizerwin_file_chooser_on_response),
|
|
1644 load_winamp_file);
|
|
1645 break;
|
|
1646
|
|
1647 case EQUALIZER_PRESETS_IMPORT_WINAMPFILE:
|
|
1648 dialog = make_filebrowser(_("Load equalizer preset"), FALSE);
|
|
1649 g_signal_connect(dialog, "response",
|
|
1650 G_CALLBACK(equalizerwin_file_chooser_on_response),
|
|
1651 import_winamp_file);
|
|
1652 break;
|
|
1653
|
|
1654 case EQUALIZER_PRESETS_SAVE_PRESET:
|
|
1655 if (!equalizerwin_save_window)
|
|
1656 equalizerwin_create_list_window(equalizer_presets,
|
|
1657 _("Save preset"),
|
|
1658 &equalizerwin_save_window,
|
|
1659 GTK_SELECTION_SINGLE,
|
|
1660 &equalizerwin_save_entry,
|
|
1661 GTK_STOCK_OK, NULL, GTK_STOCK_CANCEL,
|
|
1662 G_CALLBACK
|
|
1663 (equalizerwin_save_ok),
|
|
1664 NULL,
|
|
1665 G_CALLBACK
|
|
1666 (equalizerwin_save_select));
|
|
1667 else
|
|
1668 gtk_window_present(GTK_WINDOW(equalizerwin_save_window));
|
|
1669 break;
|
|
1670
|
|
1671 case EQUALIZER_PRESETS_SAVE_AUTOPRESET:
|
|
1672 {
|
|
1673 gchar *name;
|
|
1674
|
|
1675 if (!equalizerwin_save_auto_window)
|
|
1676 equalizerwin_create_list_window(equalizer_auto_presets,
|
|
1677 _("Save auto-preset"),
|
|
1678 &equalizerwin_save_auto_window,
|
|
1679 GTK_SELECTION_SINGLE,
|
|
1680 &equalizerwin_save_auto_entry,
|
|
1681 GTK_STOCK_OK,
|
|
1682 NULL,
|
|
1683 GTK_STOCK_CANCEL,
|
|
1684 G_CALLBACK
|
|
1685 (equalizerwin_save_auto_ok),
|
|
1686 NULL,
|
|
1687 G_CALLBACK
|
|
1688 (equalizerwin_save_auto_select));
|
|
1689 else
|
|
1690 gtk_window_present(GTK_WINDOW(equalizerwin_save_auto_window));
|
|
1691
|
|
1692 name = playlist_get_filename(playlist_get_position());
|
|
1693
|
|
1694 if (name) {
|
|
1695 gtk_entry_set_text(GTK_ENTRY(equalizerwin_save_auto_entry),
|
|
1696 g_basename(name));
|
|
1697 g_free(name);
|
|
1698 }
|
|
1699 break;
|
|
1700 }
|
|
1701
|
|
1702 case EQUALIZER_PRESETS_SAVE_DEFAULT:
|
|
1703 equalizer_presets =
|
|
1704 equalizerwin_save_preset(equalizer_presets, "Default",
|
|
1705 "eq.preset");
|
|
1706 break;
|
|
1707
|
|
1708 case EQUALIZER_PRESETS_SAVE_TO_FILE:
|
|
1709 {
|
|
1710 gchar *songname;
|
|
1711
|
|
1712 dialog = make_filebrowser(_("Save equalizer preset"), TRUE);
|
|
1713 g_signal_connect(dialog, "response",
|
|
1714 G_CALLBACK(equalizerwin_file_chooser_on_response),
|
|
1715 save_preset_file);
|
|
1716
|
|
1717 songname = playlist_get_filename(playlist_get_position());
|
|
1718 if (songname) {
|
|
1719 gchar *eqname = g_strdup_printf("%s.%s", songname,
|
|
1720 cfg.eqpreset_extension);
|
|
1721 g_free(songname);
|
|
1722 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
|
|
1723 eqname);
|
|
1724 g_free(eqname);
|
|
1725 }
|
|
1726
|
|
1727 break;
|
|
1728 }
|
|
1729
|
|
1730 case EQUALIZER_PRESETS_SAVE_TO_WINAMPFILE:
|
|
1731 dialog = make_filebrowser(_("Save equalizer preset"), TRUE);
|
|
1732 g_signal_connect(dialog, "response",
|
|
1733 G_CALLBACK(equalizerwin_file_chooser_on_response),
|
|
1734 save_winamp_file);
|
|
1735 break;
|
|
1736
|
|
1737 case EQUALIZER_PRESETS_DELETE_PRESET:
|
|
1738 if (!equalizerwin_delete_window)
|
|
1739 equalizerwin_create_list_window(equalizer_presets,
|
|
1740 _("Delete preset"),
|
|
1741 &equalizerwin_delete_window,
|
|
1742 GTK_SELECTION_EXTENDED, NULL,
|
|
1743 GTK_STOCK_DELETE,
|
|
1744 NULL,
|
|
1745 GTK_STOCK_CLOSE,
|
|
1746 G_CALLBACK
|
|
1747 (equalizerwin_delete_delete),
|
|
1748 NULL,
|
|
1749 NULL);
|
|
1750 else
|
|
1751 gtk_window_present(GTK_WINDOW(equalizerwin_delete_window));
|
|
1752
|
|
1753 break;
|
|
1754
|
|
1755 case EQUALIZER_PRESETS_DELETE_AUTOPRESET:
|
|
1756 if (!equalizerwin_delete_auto_window)
|
|
1757 equalizerwin_create_list_window(equalizer_auto_presets,
|
|
1758 _("Delete auto-preset"),
|
|
1759 &equalizerwin_delete_auto_window,
|
|
1760 GTK_SELECTION_EXTENDED, NULL,
|
|
1761 GTK_STOCK_DELETE,
|
|
1762 NULL,
|
|
1763 GTK_STOCK_CLOSE,
|
|
1764 G_CALLBACK
|
|
1765 (equalizerwin_delete_auto_delete),
|
|
1766 NULL,
|
|
1767 NULL);
|
|
1768 else
|
|
1769 gtk_window_present(GTK_WINDOW(equalizerwin_delete_auto_window));
|
|
1770
|
|
1771 break;
|
|
1772 }
|
|
1773 }
|
|
1774
|
|
1775 void
|
|
1776 equalizerwin_load_auto_preset(const gchar * filename)
|
|
1777 {
|
|
1778 gchar *presetfilename, *directory;
|
|
1779 RcFile *rcfile;
|
|
1780
|
|
1781 g_return_if_fail(filename != NULL);
|
|
1782
|
|
1783 if (!cfg.equalizer_autoload)
|
|
1784 return;
|
|
1785
|
|
1786 presetfilename = g_strconcat(filename, ".", cfg.eqpreset_extension, NULL);
|
|
1787
|
|
1788 /* First try to find a per file preset file */
|
|
1789 if (strlen(cfg.eqpreset_extension) > 0 &&
|
|
1790 (rcfile = bmp_rcfile_open(presetfilename)) != NULL) {
|
|
1791 g_free(presetfilename);
|
|
1792 equalizerwin_read_bmp_preset(rcfile);
|
|
1793 bmp_rcfile_free(rcfile);
|
|
1794 return;
|
|
1795 }
|
|
1796
|
|
1797 g_free(presetfilename);
|
|
1798
|
|
1799 directory = g_path_get_dirname(filename);
|
|
1800 presetfilename = g_build_filename(directory, cfg.eqpreset_default_file,
|
|
1801 NULL);
|
|
1802 g_free(directory);
|
|
1803
|
|
1804 /* Try to find a per directory preset file */
|
|
1805 if (strlen(cfg.eqpreset_default_file) > 0 &&
|
|
1806 (rcfile = bmp_rcfile_open(presetfilename)) != NULL) {
|
|
1807 equalizerwin_read_bmp_preset(rcfile);
|
|
1808 bmp_rcfile_free(rcfile);
|
|
1809 }
|
|
1810 else if (!equalizerwin_load_preset
|
|
1811 (equalizer_auto_presets, g_basename(filename))) {
|
|
1812 /* Fall back to the oldstyle auto presets */
|
|
1813 equalizerwin_load_preset(equalizer_presets, "Default");
|
|
1814 }
|
|
1815
|
|
1816 g_free(presetfilename);
|
|
1817 }
|
|
1818
|
|
1819 void
|
|
1820 equalizerwin_set_preamp(gfloat preamp)
|
|
1821 {
|
|
1822 eqslider_set_position(equalizerwin_preamp, preamp);
|
|
1823 equalizerwin_eq_changed();
|
|
1824 }
|
|
1825
|
|
1826 void
|
|
1827 equalizerwin_set_band(gint band, gfloat value)
|
|
1828 {
|
|
1829 g_return_if_fail(band >= 0 && band < 10);
|
|
1830 eqslider_set_position(equalizerwin_bands[band], value);
|
|
1831 }
|
|
1832
|
|
1833 gfloat
|
|
1834 equalizerwin_get_preamp(void)
|
|
1835 {
|
|
1836 return eqslider_get_position(equalizerwin_preamp);
|
|
1837 }
|
|
1838
|
|
1839 gfloat
|
|
1840 equalizerwin_get_band(gint band)
|
|
1841 {
|
|
1842 g_return_val_if_fail(band >= 0 && band < 10, 0);
|
|
1843 return eqslider_get_position(equalizerwin_bands[band]);
|
|
1844 }
|