Mercurial > audlegacy
diff src/audacious/ui_equalizer.c @ 2313:3149d4b1a9a9 trunk
[svn] - objective-make autodepend fixes
- move all sourcecode into src/ and adjust Makefiles accordingly
| author | nenolod |
|---|---|
| date | Fri, 12 Jan 2007 11:43:40 -0800 |
| parents | |
| children | d7ccaa59630f |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/audacious/ui_equalizer.c Fri Jan 12 11:43:40 2007 -0800 @@ -0,0 +1,1788 @@ +/* Audacious - Cross-platform multimedia player + * Copyright (C) 2005-2007 Audacious development team. + * + * Based on BMP: + * Copyright (C) 2003-2004 BMP development team. + * + * Based on XMMS: + * Copyright (C) 1998-2003 XMMS development team. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; under version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "ui_equalizer.h" + +#include <glib.h> +#include <glib/gi18n.h> +#include <gtk/gtk.h> +#include <stdio.h> +#include <math.h> +#include <string.h> + +#include "platform/smartinclude.h" +#include "widgets/widgetcore.h" +#include "dock.h" +#include "hints.h" +#include "input.h" +#include "main.h" +#include "ui_manager.h" +#include "actions-equalizer.h" +#include "playlist.h" +#include "ui_playlist.h" +#include "util.h" +#include "output.h" + +#include "libaudacious/rcfile.h" +#include "vfs.h" + +#include "images/audacious_eq.xpm" + +enum PresetViewCols { + PRESET_VIEW_COL_NAME, + PRESET_VIEW_N_COLS +}; + +struct _EqualizerPreset { + gchar *name; + gfloat preamp, bands[10]; +}; + +typedef struct _EqualizerPreset EqualizerPreset; + + +GtkWidget *equalizerwin; + +static GtkWidget *equalizerwin_load_window = NULL; +static GtkWidget *equalizerwin_load_auto_window = NULL; +static GtkWidget *equalizerwin_save_window = NULL; +static GtkWidget *equalizerwin_save_entry = NULL; +static GtkWidget *equalizerwin_save_auto_window = NULL; +static GtkWidget *equalizerwin_save_auto_entry = NULL; +static GtkWidget *equalizerwin_delete_window = NULL; +static GtkWidget *equalizerwin_delete_auto_window = NULL; + +static GdkPixmap *equalizerwin_bg, *equalizerwin_bg_x2; +static GdkGC *equalizerwin_gc; + +static GList *equalizerwin_wlist = NULL; + +static TButton *equalizerwin_on, *equalizerwin_auto; + +static PButton *equalizerwin_presets, *equalizerwin_shade; +PButton *equalizerwin_close; +static EqGraph *equalizerwin_graph; +static EqSlider *equalizerwin_preamp, *equalizerwin_bands[10]; +static HSlider *equalizerwin_volume, *equalizerwin_balance; + +static GList *equalizer_presets = NULL, *equalizer_auto_presets = NULL; + + +EqualizerPreset * +equalizer_preset_new(const gchar * name) +{ + EqualizerPreset *preset = g_new0(EqualizerPreset, 1); + preset->name = g_strdup(name); + return preset; +} + +void +equalizer_preset_free(EqualizerPreset * preset) +{ + if (!preset) + return; + + g_free(preset->name); + g_free(preset); +} + + +static void +equalizerwin_set_shape_mask(void) +{ + if (cfg.show_wm_decorations) + return; + + if (cfg.doublesize == FALSE) + gtk_widget_shape_combine_mask(equalizerwin, + skin_get_mask(bmp_active_skin, + SKIN_MASK_EQ), 0, 0); + else + gtk_widget_shape_combine_mask(equalizerwin, NULL, 0, 0); +} + +void +equalizerwin_set_doublesize(gboolean ds) +{ + gint height; + + if (cfg.equalizer_shaded) + height = 14; + else + height = 116; + + equalizerwin_set_shape_mask(); + + if (ds) { + dock_window_resize(GTK_WINDOW(equalizerwin), 550, height * 2, 550, height * 2); + gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg_x2, + 0); + } + else { + dock_window_resize(GTK_WINDOW(equalizerwin), 275, height, 275, height); + gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg, 0); + } + + draw_equalizer_window(TRUE); +} + +void +equalizerwin_set_shade_menu_cb(gboolean shaded) +{ + cfg.equalizer_shaded = shaded; + + equalizerwin_set_shape_mask(); + + if (shaded) { + dock_shade(dock_window_list, GTK_WINDOW(equalizerwin), + 14 * (EQUALIZER_DOUBLESIZE + 1)); + pbutton_set_button_data(equalizerwin_shade, -1, 3, -1, 47); + pbutton_set_skin_index1(equalizerwin_shade, SKIN_EQ_EX); + pbutton_set_button_data(equalizerwin_close, 11, 38, 11, 47); + pbutton_set_skin_index(equalizerwin_close, SKIN_EQ_EX); + widget_show(WIDGET(equalizerwin_volume)); + widget_show(WIDGET(equalizerwin_balance)); + } + else { + dock_shade(dock_window_list, GTK_WINDOW(equalizerwin), + 116 * (EQUALIZER_DOUBLESIZE + 1)); + pbutton_set_button_data(equalizerwin_shade, -1, 137, -1, 38); + pbutton_set_skin_index1(equalizerwin_shade, SKIN_EQMAIN); + pbutton_set_button_data(equalizerwin_close, 0, 116, 0, 125); + pbutton_set_skin_index(equalizerwin_close, SKIN_EQMAIN); + widget_hide(WIDGET(equalizerwin_volume)); + widget_hide(WIDGET(equalizerwin_balance)); + } + + draw_equalizer_window(TRUE); +} + +static void +equalizerwin_set_shade(gboolean shaded) +{ + GtkAction *action = gtk_action_group_get_action( + toggleaction_group_others , "roll up equalizer" ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(action) , shaded ); +} + +static void +equalizerwin_shade_toggle(void) +{ + equalizerwin_set_shade(!cfg.equalizer_shaded); +} + +static void +equalizerwin_raise(void) +{ + if (cfg.equalizer_visible) + gtk_window_present(GTK_WINDOW(equalizerwin)); +} + +void +equalizerwin_eq_changed(void) +{ + gint i; + + cfg.equalizer_preamp = eqslider_get_position(equalizerwin_preamp); + for (i = 0; i < 10; i++) + cfg.equalizer_bands[i] = eqslider_get_position(equalizerwin_bands[i]); + /* um .. i think we need both of these for xmms compatibility .. + not sure. -larne */ + input_set_eq(cfg.equalizer_active, cfg.equalizer_preamp, + cfg.equalizer_bands); + output_set_eq(cfg.equalizer_active, cfg.equalizer_preamp, + cfg.equalizer_bands); + + widget_draw(WIDGET(equalizerwin_graph)); +} + +static void +equalizerwin_on_pushed(gboolean toggled) +{ + cfg.equalizer_active = toggled; + equalizerwin_eq_changed(); +} + +static void +equalizerwin_presets_pushed(void) +{ + GdkModifierType modmask; + gint x, y; + + gdk_window_get_pointer(NULL, &x, &y, &modmask); + ui_manager_popup_menu_show(GTK_MENU(equalizerwin_presets_menu), x, y, 1, GDK_CURRENT_TIME); +} + +static void +equalizerwin_auto_pushed(gboolean toggled) +{ + cfg.equalizer_autoload = toggled; +} + +void +draw_equalizer_window(gboolean force) +{ + GdkImage *img, *img2; + GList *wl; + Widget *w; + gboolean redraw; + + widget_list_lock(equalizerwin_wlist); + + if (force) { + skin_draw_pixmap(bmp_active_skin, equalizerwin_bg, equalizerwin_gc, + SKIN_EQMAIN, 0, 0, 0, 0, 275, 116); + if (gtk_window_has_toplevel_focus(GTK_WINDOW(equalizerwin)) || + !cfg.dim_titlebar) { + if (!cfg.equalizer_shaded) + skin_draw_pixmap(bmp_active_skin, equalizerwin_bg, + equalizerwin_gc, SKIN_EQMAIN, 0, 134, 0, + 0, 275, 14); + else + skin_draw_pixmap(bmp_active_skin, equalizerwin_bg, + equalizerwin_gc, SKIN_EQ_EX, 0, 0, 0, 0, + 275, 14); + } + else { + if (!cfg.equalizer_shaded) + skin_draw_pixmap(bmp_active_skin, equalizerwin_bg, + equalizerwin_gc, SKIN_EQMAIN, 0, 149, 0, + 0, 275, 14); + else + skin_draw_pixmap(bmp_active_skin, equalizerwin_bg, + equalizerwin_gc, SKIN_EQ_EX, 0, 15, 0, 0, + 275, 14); + + } + } + + widget_list_draw(equalizerwin_wlist, &redraw, force); + + if (force || redraw) { + if (cfg.doublesize && cfg.eq_doublesize_linked) { + if (force) { + img = gdk_drawable_get_image(equalizerwin_bg, 0, 0, 275, 116); + img2 = create_dblsize_image(img); + gdk_draw_image(equalizerwin_bg_x2, equalizerwin_gc, + img2, 0, 0, 0, 0, 550, 232); + g_object_unref(img2); + g_object_unref(img); + } + else { + for (wl = equalizerwin_wlist; wl; wl = g_list_next(wl)) { + w = WIDGET(wl->data); + if (w->redraw && w->visible) { + img = gdk_drawable_get_image(equalizerwin_bg, + w->x, w->y, + w->width, w->height); + img2 = create_dblsize_image(img); + gdk_draw_image(equalizerwin_bg_x2, + equalizerwin_gc, img2, 0, 0, + w->x << 1, w->y << 1, w->width << 1, + w->height << 1); + g_object_unref(img2); + g_object_unref(img); + w->redraw = FALSE; + } + } + } + } + else + widget_list_clear_redraw(equalizerwin_wlist); + gdk_window_clear(equalizerwin->window); + gdk_flush(); + } + + widget_list_unlock(equalizerwin_wlist); +} + +static gboolean +inside_sensitive_widgets(gint x, gint y) +{ + return (widget_contains(WIDGET(equalizerwin_on), x, y) || + widget_contains(WIDGET(equalizerwin_auto), x, y) || + widget_contains(WIDGET(equalizerwin_presets), x, y) || + widget_contains(WIDGET(equalizerwin_close), x, y) || + widget_contains(WIDGET(equalizerwin_shade), x, y) || + widget_contains(WIDGET(equalizerwin_preamp), x, y) || + widget_contains(WIDGET(equalizerwin_bands[0]), x, y) || + widget_contains(WIDGET(equalizerwin_bands[1]), x, y) || + widget_contains(WIDGET(equalizerwin_bands[2]), x, y) || + widget_contains(WIDGET(equalizerwin_bands[3]), x, y) || + widget_contains(WIDGET(equalizerwin_bands[4]), x, y) || + widget_contains(WIDGET(equalizerwin_bands[5]), x, y) || + widget_contains(WIDGET(equalizerwin_bands[6]), x, y) || + widget_contains(WIDGET(equalizerwin_bands[7]), x, y) || + widget_contains(WIDGET(equalizerwin_bands[8]), x, y) || + widget_contains(WIDGET(equalizerwin_bands[9]), x, y) || + widget_contains(WIDGET(equalizerwin_volume), x, y) || + widget_contains(WIDGET(equalizerwin_balance), x, y)); +} + +gboolean +equalizerwin_press(GtkWidget * widget, GdkEventButton * event, + gpointer callback_data) +{ + gint mx, my; + gboolean grab = TRUE; + + mx = event->x; + my = event->y; + if (cfg.doublesize && cfg.eq_doublesize_linked) { + event->x /= 2; + event->y /= 2; + } + + if (event->button == 1 && event->type == GDK_BUTTON_PRESS && + ((cfg.easy_move || cfg.equalizer_shaded || event->y < 14) && + !inside_sensitive_widgets(event->x, event->y))) { + if (0 && hint_move_resize_available()) { + hint_move_resize(equalizerwin, event->x_root, + event->y_root, TRUE); + grab = FALSE; + } + else { + equalizerwin_raise(); + dock_move_press(dock_window_list, GTK_WINDOW(equalizerwin), event, + FALSE); + } + } + else if (event->button == 1 && event->type == GDK_2BUTTON_PRESS + && event->y < 14) { + equalizerwin_set_shade(!cfg.equalizer_shaded); + if (dock_is_moving(GTK_WINDOW(equalizerwin))) + dock_move_release(GTK_WINDOW(equalizerwin)); + } + else if (event->button == 3 && + !(widget_contains(WIDGET(equalizerwin_on), event->x, event->y) || + widget_contains(WIDGET(equalizerwin_auto), event->x, event->y))) { + /* + * Pop up the main menu a few pixels down to avoid + * anything to be selected initially. + */ + ui_manager_popup_menu_show(GTK_MENU(mainwin_general_menu), event->x_root, + event->y_root + 2, 3, event->time); + grab = FALSE; + } + else { + handle_press_cb(equalizerwin_wlist, widget, event); + draw_equalizer_window(FALSE); + } + if (grab) + gdk_pointer_grab(GDK_WINDOW(equalizerwin->window), FALSE, + GDK_BUTTON_MOTION_MASK | GDK_BUTTON_RELEASE_MASK, + NULL, NULL, GDK_CURRENT_TIME); + + return FALSE; +} + +static void +equalizerwin_scroll(GtkWidget * widget, GdkEventScroll * event, gpointer data) +{ + if (cfg.doublesize && cfg.eq_doublesize_linked) { + event->x /= 2; + event->y /= 2; + } + + handle_scroll_cb(equalizerwin_wlist, widget, event); + draw_equalizer_window(FALSE); +} + +static gboolean +equalizerwin_motion(GtkWidget * widget, + GdkEventMotion * event, gpointer callback_data) +{ + GdkEvent *gevent; + + if (cfg.doublesize && cfg.eq_doublesize_linked) { + event->x /= 2; + event->y /= 2; + } + if (dock_is_moving(GTK_WINDOW(equalizerwin))) + { + dock_move_motion(GTK_WINDOW(equalizerwin), event); + } + else + { + handle_motion_cb(equalizerwin_wlist, widget, event); + draw_equalizer_window(FALSE); + } + + gdk_flush(); + + while ((gevent = gdk_event_get()) != NULL) gdk_event_free(gevent); + + return FALSE; +} + +static gboolean +equalizerwin_release(GtkWidget * widget, + GdkEventButton * event, gpointer callback_data) +{ + gdk_pointer_ungrab(GDK_CURRENT_TIME); + gdk_flush(); + + if (cfg.doublesize && cfg.eq_doublesize_linked) { + event->x /= 2; + event->y /= 2; + } + if (dock_is_moving(GTK_WINDOW(equalizerwin))) { + dock_move_release(GTK_WINDOW(equalizerwin)); + } + else { + handle_release_cb(equalizerwin_wlist, widget, event); + draw_equalizer_window(FALSE); + } + + return FALSE; +} + +static gboolean +equalizerwin_focus_in(GtkWidget * widget, + GdkEvent * event, + gpointer data) +{ + equalizerwin_close->pb_allow_draw = TRUE; + equalizerwin_shade->pb_allow_draw = TRUE; + draw_equalizer_window(TRUE); + return TRUE; +} + +static gboolean +equalizerwin_focus_out(GtkWidget * widget, + GdkEventButton * event, + gpointer data) +{ + equalizerwin_close->pb_allow_draw = FALSE; + equalizerwin_shade->pb_allow_draw = FALSE; + draw_equalizer_window(TRUE); + return TRUE; +} + +static gboolean +equalizerwin_keypress(GtkWidget * widget, + GdkEventKey * event, + gpointer data) +{ + if (!cfg.equalizer_shaded) { + gtk_widget_event(mainwin, (GdkEvent *) event); + return TRUE; + } + + switch (event->keyval) { + case GDK_Left: + case GDK_KP_Left: + mainwin_set_balance_diff(-4); + break; + case GDK_Right: + case GDK_KP_Right: + mainwin_set_balance_diff(4); + break; + default: + gtk_widget_event(mainwin, (GdkEvent *) event); + break; + } + + return FALSE; +} + +static gboolean +equalizerwin_configure(GtkWidget * window, + GdkEventConfigure * event, + gpointer data) +{ + if (!GTK_WIDGET_VISIBLE(window)) + return FALSE; + + cfg.equalizer_x = event->x; + cfg.equalizer_y = event->y; + return FALSE; +} + +static void +equalizerwin_set_back_pixmap(void) +{ + if (cfg.doublesize && cfg.eq_doublesize_linked) + gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg_x2, + 0); + else + gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg, 0); + gdk_window_clear(equalizerwin->window); +} + +static void +equalizerwin_close_cb(void) +{ + equalizerwin_show(FALSE); +} + +static gboolean +equalizerwin_delete(GtkWidget * widget, + gpointer data) +{ + equalizerwin_show(FALSE); + return TRUE; +} + +static GList * +equalizerwin_read_presets(const gchar * basename) +{ + gchar *filename, *name; + RcFile *rcfile; + GList *list = NULL; + gint i, p = 0; + EqualizerPreset *preset; + + filename = g_build_filename(bmp_paths[BMP_PATH_USER_DIR], basename, NULL); + + if ((rcfile = bmp_rcfile_open(filename)) == NULL) { + g_free(filename); + return NULL; + } + + g_free(filename); + + for (;;) { + gchar section[21]; + + g_snprintf(section, sizeof(section), "Preset%d", p++); + if (bmp_rcfile_read_string(rcfile, "Presets", section, &name)) { + preset = g_new0(EqualizerPreset, 1); + preset->name = name; + bmp_rcfile_read_float(rcfile, name, "Preamp", &preset->preamp); + for (i = 0; i < 10; i++) { + gchar band[7]; + g_snprintf(band, sizeof(band), "Band%d", i); + bmp_rcfile_read_float(rcfile, name, band, &preset->bands[i]); + } + list = g_list_prepend(list, preset); + } + else + break; + } + list = g_list_reverse(list); + bmp_rcfile_free(rcfile); + return list; +} + +gint +equalizerwin_volume_frame_cb(gint pos) +{ + if (equalizerwin_volume) { + if (pos < 32) + equalizerwin_volume->hs_knob_nx = + equalizerwin_volume->hs_knob_px = 1; + else if (pos < 63) + equalizerwin_volume->hs_knob_nx = + equalizerwin_volume->hs_knob_px = 4; + else + equalizerwin_volume->hs_knob_nx = + equalizerwin_volume->hs_knob_px = 7; + } + return 1; +} + +static void +equalizerwin_volume_motion_cb(gint pos) +{ + gint v = (gint) rint(pos * 100 / 94.0); + mainwin_adjust_volume_motion(v); + mainwin_set_volume_slider(v); +} + +static void +equalizerwin_volume_release_cb(gint pos) +{ + mainwin_adjust_volume_release(); +} + +static gint +equalizerwin_balance_frame_cb(gint pos) +{ + if (equalizerwin_balance) { + if (pos < 13) + equalizerwin_balance->hs_knob_nx = + equalizerwin_balance->hs_knob_px = 11; + else if (pos < 26) + equalizerwin_balance->hs_knob_nx = + equalizerwin_balance->hs_knob_px = 14; + else + equalizerwin_balance->hs_knob_nx = + equalizerwin_balance->hs_knob_px = 17; + } + + return 1; +} + +static void +equalizerwin_balance_motion_cb(gint pos) +{ + gint b; + pos = MIN(pos, 38); /* The skin uses a even number of pixels + for the balance-slider *sigh* */ + b = (gint) rint((pos - 19) * 100 / 19.0); + mainwin_adjust_balance_motion(b); + mainwin_set_balance_slider(b); +} + +static void +equalizerwin_balance_release_cb(gint pos) +{ + mainwin_adjust_balance_release(); +} + +void +equalizerwin_set_balance_slider(gint percent) +{ + hslider_set_position(equalizerwin_balance, + (gint) rint((percent * 19 / 100.0) + 19)); +} + +void +equalizerwin_set_volume_slider(gint percent) +{ + hslider_set_position(equalizerwin_volume, + (gint) rint(percent * 94 / 100.0)); +} + +static void +equalizerwin_create_widgets(void) +{ + gint i; + + equalizerwin_on = + create_tbutton(&equalizerwin_wlist, equalizerwin_bg, + equalizerwin_gc, 14, 18, 25, 12, 10, 119, 128, 119, + 69, 119, 187, 119, equalizerwin_on_pushed, + SKIN_EQMAIN); + tbutton_set_toggled(equalizerwin_on, cfg.equalizer_active); + equalizerwin_auto = + create_tbutton(&equalizerwin_wlist, equalizerwin_bg, + equalizerwin_gc, 39, 18, 33, 12, 35, 119, 153, 119, + 94, 119, 212, 119, equalizerwin_auto_pushed, + SKIN_EQMAIN); + tbutton_set_toggled(equalizerwin_auto, cfg.equalizer_autoload); + equalizerwin_presets = + create_pbutton(&equalizerwin_wlist, equalizerwin_bg, + equalizerwin_gc, 217, 18, 44, 12, 224, 164, 224, + 176, equalizerwin_presets_pushed, SKIN_EQMAIN); + equalizerwin_close = + create_pbutton(&equalizerwin_wlist, equalizerwin_bg, + equalizerwin_gc, 264, 3, 9, 9, 0, 116, 0, 125, + equalizerwin_close_cb, SKIN_EQMAIN); + equalizerwin_close->pb_allow_draw = FALSE; + + equalizerwin_shade = + create_pbutton_ex(&equalizerwin_wlist, equalizerwin_bg, + equalizerwin_gc, 254, 3, 9, 9, 254, 137, 1, 38, + equalizerwin_shade_toggle, NULL, SKIN_EQMAIN, SKIN_EQ_EX); + equalizerwin_shade->pb_allow_draw = FALSE; + + equalizerwin_graph = + create_eqgraph(&equalizerwin_wlist, equalizerwin_bg, + equalizerwin_gc, 86, 17); + equalizerwin_preamp = + create_eqslider(&equalizerwin_wlist, equalizerwin_bg, + equalizerwin_gc, 21, 38); + eqslider_set_position(equalizerwin_preamp, cfg.equalizer_preamp); + for (i = 0; i < 10; i++) { + equalizerwin_bands[i] = + create_eqslider(&equalizerwin_wlist, equalizerwin_bg, + equalizerwin_gc, 78 + (i * 18), 38); + eqslider_set_position(equalizerwin_bands[i], cfg.equalizer_bands[i]); + } + + equalizerwin_volume = + create_hslider(&equalizerwin_wlist, equalizerwin_bg, + equalizerwin_gc, 61, 4, 97, 8, 1, 30, 1, 30, 3, 7, + 4, 61, 0, 94, equalizerwin_volume_frame_cb, + equalizerwin_volume_motion_cb, + equalizerwin_volume_release_cb, SKIN_EQ_EX); + equalizerwin_balance = + create_hslider(&equalizerwin_wlist, equalizerwin_bg, + equalizerwin_gc, 164, 4, 42, 8, 11, 30, 11, 30, 3, + 7, 4, 164, 0, 39, equalizerwin_balance_frame_cb, + equalizerwin_balance_motion_cb, + equalizerwin_balance_release_cb, SKIN_EQ_EX); + + if (!cfg.equalizer_shaded) { + widget_hide(WIDGET(equalizerwin_volume)); + widget_hide(WIDGET(equalizerwin_balance)); + } + else { + pbutton_set_button_data(equalizerwin_shade, -1, 3, -1, 47); + pbutton_set_skin_index1(equalizerwin_shade, SKIN_EQ_EX); + pbutton_set_button_data(equalizerwin_close, 11, 38, 11, 47); + pbutton_set_skin_index(equalizerwin_close, SKIN_EQ_EX); + } +} + + +static void +equalizerwin_create_window(void) +{ + GdkPixbuf *icon; + gint width, height; + + equalizerwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_title(GTK_WINDOW(equalizerwin), _("Audacious Equalizer")); + gtk_window_set_wmclass(GTK_WINDOW(equalizerwin), "equalizer", "Audacious"); + gtk_window_set_role(GTK_WINDOW(equalizerwin), "equalizer"); + + width = 275; + height = cfg.equalizer_shaded ? 14 : 116; + + if (cfg.doublesize && cfg.eq_doublesize_linked) { + width *= 2; + height *= 2; + } + + gtk_window_set_default_size(GTK_WINDOW(equalizerwin), width, height); + gtk_window_set_resizable(GTK_WINDOW(equalizerwin), FALSE); + + dock_window_list = dock_window_set_decorated(dock_window_list, + GTK_WINDOW(equalizerwin), + cfg.show_wm_decorations); + + /* this will hide only mainwin. it's annoying! yaz */ + gtk_window_set_transient_for(GTK_WINDOW(equalizerwin), + GTK_WINDOW(mainwin)); + gtk_window_set_skip_taskbar_hint(GTK_WINDOW(equalizerwin), TRUE); + + icon = gdk_pixbuf_new_from_xpm_data((const gchar **) bmp_eq_icon); + gtk_window_set_icon(GTK_WINDOW(equalizerwin), icon); + g_object_unref(icon); + + gtk_widget_set_app_paintable(equalizerwin, TRUE); + + if (cfg.equalizer_x != -1 && cfg.save_window_position) + gtk_window_move(GTK_WINDOW(equalizerwin), + cfg.equalizer_x, cfg.equalizer_y); + + gtk_widget_set_events(equalizerwin, + GDK_FOCUS_CHANGE_MASK | GDK_BUTTON_MOTION_MASK | + GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | + GDK_VISIBILITY_NOTIFY_MASK); + gtk_widget_realize(equalizerwin); + + util_set_cursor(equalizerwin); + + g_signal_connect(equalizerwin, "delete_event", + G_CALLBACK(equalizerwin_delete), NULL); + g_signal_connect(equalizerwin, "button_press_event", + G_CALLBACK(equalizerwin_press), NULL); + g_signal_connect(equalizerwin, "button_release_event", + G_CALLBACK(equalizerwin_release), NULL); + g_signal_connect(equalizerwin, "motion_notify_event", + G_CALLBACK(equalizerwin_motion), NULL); + g_signal_connect_after(equalizerwin, "focus_in_event", + G_CALLBACK(equalizerwin_focus_in), NULL); + g_signal_connect_after(equalizerwin, "focus_out_event", + G_CALLBACK(equalizerwin_focus_out), NULL); + g_signal_connect(equalizerwin, "configure_event", + G_CALLBACK(equalizerwin_configure), NULL); + g_signal_connect(equalizerwin, "style_set", + G_CALLBACK(equalizerwin_set_back_pixmap), NULL); + g_signal_connect(equalizerwin, "key_press_event", + G_CALLBACK(equalizerwin_keypress), NULL); + g_signal_connect(equalizerwin, "scroll_event", + G_CALLBACK(equalizerwin_scroll), NULL); +} + +static GtkWidget * +ui_manager_get_popup(GtkUIManager * self, const gchar * path) +{ + GtkWidget *menu_item; + + menu_item = gtk_ui_manager_get_widget(self, path); + + if (GTK_IS_MENU_ITEM(menu_item)) + return gtk_menu_item_get_submenu(GTK_MENU_ITEM(menu_item)); + else + return NULL; +} + + +void +equalizerwin_create(void) +{ + equalizer_presets = equalizerwin_read_presets("eq.preset"); + equalizer_auto_presets = equalizerwin_read_presets("eq.auto_preset"); + + equalizerwin_create_window(); + + gtk_window_add_accel_group( GTK_WINDOW(equalizerwin) , ui_manager_get_accel_group() ); + + equalizerwin_gc = gdk_gc_new(equalizerwin->window); + equalizerwin_bg = gdk_pixmap_new(equalizerwin->window, 275, 116, -1); + equalizerwin_bg_x2 = gdk_pixmap_new(equalizerwin->window, 550, 232, -1); + + equalizerwin_create_widgets(); + + equalizerwin_set_back_pixmap(); + if (cfg.doublesize && cfg.eq_doublesize_linked) + gdk_window_set_back_pixmap(equalizerwin->window, + equalizerwin_bg_x2, 0); + else + gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg, 0); +} + + +void +equalizerwin_show(gboolean show) +{ + GtkAction *action = gtk_action_group_get_action( + toggleaction_group_others , "show equalizer" ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(action) , show ); + + if (show) + equalizerwin_real_show(); + else + equalizerwin_real_hide(); +} + +void +equalizerwin_real_show(void) +{ + /* + * This function should only be called from the + * main menu signal handler + */ + + gint x, y; + + gtk_window_get_position(GTK_WINDOW(equalizerwin), &x, &y); + gtk_window_move(GTK_WINDOW(equalizerwin), x, y); + if (cfg.doublesize && cfg.eq_doublesize_linked) + gtk_widget_set_size_request(equalizerwin, 550, + (cfg.equalizer_shaded ? 28 : 232)); + else + gtk_widget_set_size_request(equalizerwin, 275, + (cfg.equalizer_shaded ? 14 : 116)); + gdk_flush(); + draw_equalizer_window(TRUE); + cfg.equalizer_visible = TRUE; + tbutton_set_toggled(mainwin_eq, TRUE); + + gtk_widget_show(equalizerwin); +} + +void +equalizerwin_real_hide(void) +{ + /* + * This function should only be called from the + * main menu signal handler + */ + gtk_widget_hide(equalizerwin); + cfg.equalizer_visible = FALSE; + tbutton_set_toggled(mainwin_eq, FALSE); +} + +static EqualizerPreset * +equalizerwin_find_preset(GList * list, const gchar * name) +{ + GList *node = list; + EqualizerPreset *preset; + + while (node) { + preset = node->data; + if (!strcasecmp(preset->name, name)) + return preset; + node = g_list_next(node); + } + return NULL; +} + +static void +equalizerwin_write_preset_file(GList * list, const gchar * basename) +{ + gchar *filename, *tmp; + gint i, p; + EqualizerPreset *preset; + RcFile *rcfile; + GList *node; + + rcfile = bmp_rcfile_new(); + p = 0; + for (node = list; node; node = g_list_next(node)) { + preset = node->data; + tmp = g_strdup_printf("Preset%d", p++); + bmp_rcfile_write_string(rcfile, "Presets", tmp, preset->name); + g_free(tmp); + bmp_rcfile_write_float(rcfile, preset->name, "Preamp", + preset->preamp); + for (i = 0; i < 10; i++) { + tmp = g_strdup_printf("Band%d\n", i); + bmp_rcfile_write_float(rcfile, preset->name, tmp, + preset->bands[i]); + g_free(tmp); + } + } + + filename = g_build_filename(bmp_paths[BMP_PATH_USER_DIR], basename, NULL); + bmp_rcfile_write(rcfile, filename); + bmp_rcfile_free(rcfile); + g_free(filename); +} + +static gboolean +equalizerwin_load_preset(GList * list, const gchar * name) +{ + EqualizerPreset *preset; + gint i; + + if ((preset = equalizerwin_find_preset(list, name)) != NULL) { + eqslider_set_position(equalizerwin_preamp, preset->preamp); + for (i = 0; i < 10; i++) + eqslider_set_position(equalizerwin_bands[i], preset->bands[i]); + equalizerwin_eq_changed(); + return TRUE; + } + return FALSE; +} + +static GList * +equalizerwin_save_preset(GList * list, const gchar * name, + const gchar * filename) +{ + gint i; + EqualizerPreset *preset; + + if (!(preset = equalizerwin_find_preset(list, name))) { + preset = g_new0(EqualizerPreset, 1); + preset->name = g_strdup(name); + list = g_list_append(list, preset); + } + + preset->preamp = eqslider_get_position(equalizerwin_preamp); + for (i = 0; i < 10; i++) + preset->bands[i] = eqslider_get_position(equalizerwin_bands[i]); + + equalizerwin_write_preset_file(list, filename); + + return list; +} + +static GList * +equalizerwin_delete_preset(GList * list, gchar * name, gchar * filename) +{ + EqualizerPreset *preset; + GList *node; + + if (!(preset = equalizerwin_find_preset(list, name))) + return list; + + if (!(node = g_list_find(list, preset))) + return list; + + list = g_list_remove_link(list, node); + equalizer_preset_free(preset); + g_list_free_1(node); + + equalizerwin_write_preset_file(list, filename); + + return list; +} + +static void +equalizerwin_delete_selected_presets(GtkTreeView *view, gchar *filename) +{ + gchar *text; + + GtkTreeSelection *selection = gtk_tree_view_get_selection(view); + GtkTreeModel *model = gtk_tree_view_get_model(view); + + /* + * first we are making a list of the selected rows, then we convert this + * list into a list of GtkTreeRowReferences, so that when you delete an + * item you can still access the other items + * finally we iterate through all GtkTreeRowReferences, convert them to + * GtkTreeIters and delete those one after the other + */ + + GList *list = gtk_tree_selection_get_selected_rows(selection, &model); + GList *rrefs = NULL; + GList *litr; + + for (litr = list; litr; litr = litr->next) + { + GtkTreePath *path = litr->data; + rrefs = g_list_append(rrefs, gtk_tree_row_reference_new(model, path)); + } + + for (litr = rrefs; litr; litr = litr->next) + { + GtkTreeRowReference *ref = litr->data; + GtkTreePath *path = gtk_tree_row_reference_get_path(ref); + GtkTreeIter iter; + gtk_tree_model_get_iter(model, &iter, path); + + gtk_tree_model_get(model, &iter, 0, &text, -1); + + if (filename == "eq.preset") + equalizer_presets = equalizerwin_delete_preset(equalizer_presets, text, filename); + else if (filename == "eq.auto_preset") + equalizer_auto_presets = equalizerwin_delete_preset(equalizer_auto_presets, text, filename); + + gtk_list_store_remove(GTK_LIST_STORE(model), &iter); + } +} + + +static GList * +import_winamp_eqf(VFSFile * file) +{ + gchar header[31]; + gchar name[257]; + gchar bands[11]; + gint i = 0; + GList *list = NULL; + EqualizerPreset *preset; + + vfs_fread(header, 1, 31, file); + if (!strncmp(header, "Winamp EQ library file v1.1", 27)) { + while (vfs_fread(name, 1, 257, file)) { + preset = equalizer_preset_new(name); + preset->preamp = 20.0 - ((bands[10] * 40.0) / 64); + + vfs_fread(bands, 1, 11, file); + + for (i = 0; i < 10; i++) + preset->bands[i] = 20.0 - ((bands[i] * 40.0) / 64); + + list = g_list_prepend(list, preset); + } + } + + list = g_list_reverse(list); + return list; +} + +static void +equalizerwin_read_winamp_eqf(VFSFile * file) +{ + gchar header[31]; + guchar bands[11]; + gint i; + + vfs_fread(header, 1, 31, file); + + if (!strncmp(header, "Winamp EQ library file v1.1", 27)) { + /* Skip name */ + if (vfs_fseek(file, 257, SEEK_CUR) == -1) + return; + + if (vfs_fread(bands, 1, 11, file) != 11) + return; + + eqslider_set_position(equalizerwin_preamp, + 20.0 - ((bands[10] * 40.0) / 63.0)); + + for (i = 0; i < 10; i++) + eqslider_set_position(equalizerwin_bands[i], + 20.0 - ((bands[i] * 40.0) / 64.0)); + } + + equalizerwin_eq_changed(); +} + +static void +equalizerwin_read_bmp_preset(RcFile * rcfile) +{ + gfloat val; + gint i; + + if (bmp_rcfile_read_float(rcfile, "Equalizer preset", "Preamp", &val)) + eqslider_set_position(equalizerwin_preamp, val); + for (i = 0; i < 10; i++) { + gchar tmp[7]; + g_snprintf(tmp, sizeof(tmp), "Band%d", i); + if (bmp_rcfile_read_float(rcfile, "Equalizer preset", tmp, &val)) + eqslider_set_position(equalizerwin_bands[i], val); + } + equalizerwin_eq_changed(); +} + +static void +equalizerwin_save_ok(GtkWidget * widget, gpointer data) +{ + const gchar *text; + + text = gtk_entry_get_text(GTK_ENTRY(equalizerwin_save_entry)); + if (strlen(text) != 0) + equalizer_presets = + equalizerwin_save_preset(equalizer_presets, text, "eq.preset"); + gtk_widget_destroy(equalizerwin_save_window); +} + +static void +equalizerwin_save_select(GtkTreeView *treeview, GtkTreePath *path, + GtkTreeViewColumn *col, gpointer data) +{ + gchar *text; + + GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview); + GtkTreeModel *model; + GtkTreeIter iter; + + if (selection) + { + if (gtk_tree_selection_get_selected(selection, &model, &iter)) + { + gtk_tree_model_get(model, &iter, 0, &text, -1); + gtk_entry_set_text(GTK_ENTRY(equalizerwin_save_entry), text); + equalizerwin_save_ok(NULL, NULL); + + g_free(text); + } + } +} + +static void +equalizerwin_load_ok(GtkWidget *widget, gpointer data) +{ + gchar *text; + + GtkTreeView* view = GTK_TREE_VIEW(data); + GtkTreeSelection *selection = gtk_tree_view_get_selection(view); + GtkTreeModel *model; + GtkTreeIter iter; + + if (selection) + { + if (gtk_tree_selection_get_selected(selection, &model, &iter)) + { + gtk_tree_model_get(model, &iter, 0, &text, -1); + equalizerwin_load_preset(equalizer_presets, text); + + g_free(text); + } + } + gtk_widget_destroy(equalizerwin_load_window); +} + +static void +equalizerwin_load_select(GtkTreeView *treeview, GtkTreePath *path, + GtkTreeViewColumn *col, gpointer data) +{ + equalizerwin_load_ok(NULL, treeview); +} + +static void +equalizerwin_delete_delete(GtkWidget *widget, gpointer data) +{ + equalizerwin_delete_selected_presets(GTK_TREE_VIEW(data), "eq.preset"); +} + +static void +equalizerwin_save_auto_ok(GtkWidget *widget, gpointer data) +{ + const gchar *text; + + text = gtk_entry_get_text(GTK_ENTRY(equalizerwin_save_auto_entry)); + if (strlen(text) != 0) + equalizer_auto_presets = + equalizerwin_save_preset(equalizer_auto_presets, text, + "eq.auto_preset"); + gtk_widget_destroy(equalizerwin_save_auto_window); +} + +static void +equalizerwin_save_auto_select(GtkTreeView *treeview, GtkTreePath *path, + GtkTreeViewColumn *col, gpointer data) +{ + gchar *text; + + GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview); + GtkTreeModel *model; + GtkTreeIter iter; + + if (selection) + { + if (gtk_tree_selection_get_selected(selection, &model, &iter)) + { + gtk_tree_model_get(model, &iter, 0, &text, -1); + gtk_entry_set_text(GTK_ENTRY(equalizerwin_save_auto_entry), text); + equalizerwin_save_auto_ok(NULL, NULL); + + g_free(text); + } + } +} + +static void +equalizerwin_load_auto_ok(GtkWidget *widget, gpointer data) +{ + gchar *text; + + GtkTreeView *view = GTK_TREE_VIEW(data); + GtkTreeSelection *selection = gtk_tree_view_get_selection(view); + GtkTreeModel *model; + GtkTreeIter iter; + + if (selection) + { + if (gtk_tree_selection_get_selected(selection, &model, &iter)) + { + gtk_tree_model_get(model, &iter, 0, &text, -1); + equalizerwin_load_preset(equalizer_auto_presets, text); + + g_free(text); + } + } + gtk_widget_destroy(equalizerwin_load_auto_window); +} + +static void +equalizerwin_load_auto_select(GtkTreeView *treeview, GtkTreePath *path, + GtkTreeViewColumn *col, gpointer data) +{ + equalizerwin_load_auto_ok(NULL, treeview); +} + +static void +equalizerwin_delete_auto_delete(GtkWidget *widget, gpointer data) +{ + equalizerwin_delete_selected_presets(GTK_TREE_VIEW(data), "eq.auto_preset"); +} + + +typedef void (*ResponseHandler)(const gchar *filename); + +static void +equalizerwin_file_chooser_on_response(GtkWidget * dialog, + gint response, + gpointer data) +{ + GtkFileChooser *file_chooser = GTK_FILE_CHOOSER(dialog); + ResponseHandler handler = (ResponseHandler) data; + gchar *filename; + + gtk_widget_hide(dialog); + + switch (response) + { + case GTK_RESPONSE_ACCEPT: + filename = gtk_file_chooser_get_filename(file_chooser); + handler(filename); + g_free(filename); + break; + + case GTK_RESPONSE_REJECT: + break; + } + + gtk_widget_destroy(dialog); +} + + + +static void +load_preset_file(const gchar *filename) +{ + RcFile *rcfile; + + if ((rcfile = bmp_rcfile_open(filename)) != NULL) { + equalizerwin_read_bmp_preset(rcfile); + bmp_rcfile_free(rcfile); + } +} + +static void +load_winamp_file(const gchar * filename) +{ + VFSFile *file; + gchar *tmp; + + if (!(file = vfs_fopen(filename, "rb"))) { + tmp = g_strconcat("Failed to load WinAmp file: ",filename,"\n",NULL); + report_error(tmp); + g_free(tmp); + return; + } + + equalizerwin_read_winamp_eqf(file); + vfs_fclose(file); +} + +static void +import_winamp_file(const gchar * filename) +{ + VFSFile *file; + gchar *tmp; + + if (!(file = vfs_fopen(filename, "rb"))) { + tmp = g_strconcat("Failed to import WinAmp file: ",filename,"\n",NULL); + report_error(tmp); + g_free(tmp); + return; + } + + equalizer_presets = g_list_concat(equalizer_presets, + import_winamp_eqf(file)); + equalizerwin_write_preset_file(equalizer_presets, "eq.preset"); + + vfs_fclose(file); +} + +static void +save_preset_file(const gchar * filename) +{ + RcFile *rcfile; + gint i; + + rcfile = bmp_rcfile_new(); + bmp_rcfile_write_float(rcfile, "Equalizer preset", "Preamp", + eqslider_get_position(equalizerwin_preamp)); + + for (i = 0; i < 10; i++) { + gchar tmp[7]; + g_snprintf(tmp, sizeof(tmp), "Band%d", i); + bmp_rcfile_write_float(rcfile, "Equalizer preset", tmp, + eqslider_get_position(equalizerwin_bands[i])); + } + + bmp_rcfile_write(rcfile, filename); + bmp_rcfile_free(rcfile); +} + +static void +save_winamp_file(const gchar * filename) +{ + VFSFile *file; + + gchar name[257]; + gint i; + guchar bands[11]; + gchar *tmp; + + if (!(file = vfs_fopen(filename, "wb"))) { + tmp = g_strconcat("Failed to save WinAmp file: ",filename,"\n",NULL); + report_error(tmp); + g_free(tmp); + return; + } + + vfs_fwrite("Winamp EQ library file v1.1\x1a!--", 1, 31, file); + + memset(name, 0, 257); + strcpy(name, "Entry1"); + vfs_fwrite(name, 1, 257, file); + + for (i = 0; i < 10; i++) + bands[i] = 63 - (((eqslider_get_position(equalizerwin_bands[i]) + 20) * 63) / 40); + bands[10] = 63 - (((eqslider_get_position(equalizerwin_preamp) + 20) * 63) / 40); + vfs_fwrite(bands, 1, 11, file); + + vfs_fclose(file); +} + +static GtkWidget * +equalizerwin_create_list_window(GList *preset_list, + const gchar *title, + GtkWidget **window, + GtkSelectionMode sel_mode, + GtkWidget **entry, + const gchar *action_name, + GCallback action_func, + GCallback select_row_func) +{ + GtkWidget *vbox, *scrolled_window, *bbox, *view; + GtkWidget *button_cancel, *button_action; + GList *node; + + GtkListStore *store; + GtkTreeIter iter; + GtkTreeModel *model; + GtkCellRenderer *renderer; + GtkTreeSelection *selection; + GtkTreeSortable *sortable; + + + + *window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_title(GTK_WINDOW(*window), title); + gtk_window_set_type_hint(GTK_WINDOW(*window), GDK_WINDOW_TYPE_HINT_DIALOG); + gtk_window_set_default_size(GTK_WINDOW(*window), 350, 300); + gtk_window_set_position(GTK_WINDOW(*window), GTK_WIN_POS_CENTER); + gtk_container_set_border_width(GTK_CONTAINER(*window), 10); + gtk_window_set_transient_for(GTK_WINDOW(*window), + GTK_WINDOW(equalizerwin)); + g_signal_connect(*window, "destroy", + G_CALLBACK(gtk_widget_destroyed), window); + + vbox = gtk_vbox_new(FALSE, 10); + gtk_container_add(GTK_CONTAINER(*window), vbox); + + scrolled_window = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), + GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); + + + /* fill the store with the names of all available presets */ + store = gtk_list_store_new(1, G_TYPE_STRING); + for (node = preset_list; node; node = g_list_next(node)) + { + gtk_list_store_append(store, &iter); + gtk_list_store_set(store, &iter, + 0, ((EqualizerPreset*)node->data)->name, + -1); + } + model = GTK_TREE_MODEL(store); + + + sortable = GTK_TREE_SORTABLE(store); + gtk_tree_sortable_set_sort_column_id(sortable, 0, GTK_SORT_ASCENDING); + + + view = gtk_tree_view_new(); + renderer = gtk_cell_renderer_text_new(); + gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, + _("Presets"), renderer, + "text", 0, NULL); + gtk_tree_view_set_model(GTK_TREE_VIEW(view), model); + g_object_unref(model); + + selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); + gtk_tree_selection_set_mode(selection, sel_mode); + + + + + gtk_container_add(GTK_CONTAINER(scrolled_window), view); + gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0); + + if (entry) { + *entry = gtk_entry_new(); + g_signal_connect(*entry, "activate", action_func, NULL); + gtk_box_pack_start(GTK_BOX(vbox), *entry, FALSE, FALSE, 0); + } + + bbox = gtk_hbutton_box_new(); + gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); + gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5); + gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0); + + button_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL); + g_signal_connect_swapped(button_cancel, "clicked", + G_CALLBACK(gtk_widget_destroy), + GTK_OBJECT(*window)); + gtk_box_pack_start(GTK_BOX(bbox), button_cancel, TRUE, TRUE, 0); + + button_action = gtk_button_new_from_stock(action_name); + g_signal_connect(button_action, "clicked", G_CALLBACK(action_func), view); + GTK_WIDGET_SET_FLAGS(button_action, GTK_CAN_DEFAULT); + + if (select_row_func) + g_signal_connect(view, "row-activated", G_CALLBACK(select_row_func), NULL); + + + gtk_box_pack_start(GTK_BOX(bbox), button_action, TRUE, TRUE, 0); + + gtk_widget_grab_default(button_action); + + + gtk_widget_show_all(*window); + + return *window; +} + +void +equalizerwin_load_auto_preset(const gchar * filename) +{ + gchar *presetfilename, *directory; + RcFile *rcfile; + + g_return_if_fail(filename != NULL); + + if (!cfg.equalizer_autoload) + return; + + presetfilename = g_strconcat(filename, ".", cfg.eqpreset_extension, NULL); + + /* First try to find a per file preset file */ + if (strlen(cfg.eqpreset_extension) > 0 && + (rcfile = bmp_rcfile_open(presetfilename)) != NULL) { + g_free(presetfilename); + equalizerwin_read_bmp_preset(rcfile); + bmp_rcfile_free(rcfile); + return; + } + + g_free(presetfilename); + + directory = g_path_get_dirname(filename); + presetfilename = g_build_filename(directory, cfg.eqpreset_default_file, + NULL); + g_free(directory); + + /* Try to find a per directory preset file */ + if (strlen(cfg.eqpreset_default_file) > 0 && + (rcfile = bmp_rcfile_open(presetfilename)) != NULL) { + equalizerwin_read_bmp_preset(rcfile); + bmp_rcfile_free(rcfile); + } + else if (!equalizerwin_load_preset + (equalizer_auto_presets, g_basename(filename))) { + /* Fall back to the oldstyle auto presets */ + equalizerwin_load_preset(equalizer_presets, "Default"); + } + + g_free(presetfilename); +} + +void +equalizerwin_set_preamp(gfloat preamp) +{ + eqslider_set_position(equalizerwin_preamp, preamp); + equalizerwin_eq_changed(); +} + +void +equalizerwin_set_band(gint band, gfloat value) +{ + g_return_if_fail(band >= 0 && band < 10); + eqslider_set_position(equalizerwin_bands[band], value); +} + +gfloat +equalizerwin_get_preamp(void) +{ + return eqslider_get_position(equalizerwin_preamp); +} + +gfloat +equalizerwin_get_band(gint band) +{ + g_return_val_if_fail(band >= 0 && band < 10, 0); + return eqslider_get_position(equalizerwin_bands[band]); +} + +void +action_equ_load_preset(void) +{ + if (equalizerwin_load_window) { + gtk_window_present(GTK_WINDOW(equalizerwin_load_window)); + return; + } + + equalizerwin_create_list_window(equalizer_presets, + Q_("Load preset"), + &equalizerwin_load_window, + GTK_SELECTION_SINGLE, NULL, + GTK_STOCK_OK, + G_CALLBACK(equalizerwin_load_ok), + G_CALLBACK(equalizerwin_load_select)); +} + +void +action_equ_load_auto_preset(void) +{ + if (equalizerwin_load_auto_window) { + gtk_window_present(GTK_WINDOW(equalizerwin_load_auto_window)); + return; + } + + equalizerwin_create_list_window(equalizer_auto_presets, + Q_("Load auto-preset"), + &equalizerwin_load_auto_window, + GTK_SELECTION_SINGLE, NULL, + GTK_STOCK_OK, + G_CALLBACK(equalizerwin_load_auto_ok), + G_CALLBACK(equalizerwin_load_auto_select)); +} + +void +action_equ_load_default_preset(void) +{ + equalizerwin_load_preset(equalizer_presets, "Default"); +} + +void +action_equ_zero_preset(void) +{ + gint i; + + eqslider_set_position(equalizerwin_preamp, 0); + for (i = 0; i < 10; i++) + eqslider_set_position(equalizerwin_bands[i], 0); + + equalizerwin_eq_changed(); +} + +void +action_equ_load_preset_file(void) +{ + GtkWidget *dialog; + + dialog = make_filebrowser(Q_("Load equalizer preset"), FALSE); + g_signal_connect(dialog , "response", + G_CALLBACK(equalizerwin_file_chooser_on_response), + load_preset_file); +} + +void +action_equ_load_preset_eqf(void) +{ + GtkWidget *dialog; + + dialog = make_filebrowser(Q_("Load equalizer preset"), FALSE); + g_signal_connect(dialog, "response", + G_CALLBACK(equalizerwin_file_chooser_on_response), + load_winamp_file); +} + +void +action_equ_import_winamp_presets(void) +{ + GtkWidget *dialog; + + dialog = make_filebrowser(Q_("Load equalizer preset"), FALSE); + g_signal_connect(dialog, "response", + G_CALLBACK(equalizerwin_file_chooser_on_response), + import_winamp_file); +} + +void +action_equ_save_preset(void) +{ + if (equalizerwin_save_window) { + gtk_window_present(GTK_WINDOW(equalizerwin_save_window)); + return; + } + + equalizerwin_create_list_window(equalizer_presets, + Q_("Save preset"), + &equalizerwin_save_window, + GTK_SELECTION_SINGLE, + &equalizerwin_save_entry, + GTK_STOCK_OK, + G_CALLBACK(equalizerwin_save_ok), + G_CALLBACK(equalizerwin_save_select)); +} + +void +action_equ_save_auto_preset(void) +{ + gchar *name; + Playlist *playlist = playlist_get_active(); + + if (equalizerwin_save_auto_window) + gtk_window_present(GTK_WINDOW(equalizerwin_save_auto_window)); + else + equalizerwin_create_list_window(equalizer_auto_presets, + Q_("Save auto-preset"), + &equalizerwin_save_auto_window, + GTK_SELECTION_SINGLE, + &equalizerwin_save_auto_entry, + GTK_STOCK_OK, + G_CALLBACK(equalizerwin_save_auto_ok), + G_CALLBACK(equalizerwin_save_auto_select)); + + name = playlist_get_filename(playlist, playlist_get_position(playlist)); + if (name) { + gtk_entry_set_text(GTK_ENTRY(equalizerwin_save_auto_entry), + g_basename(name)); + g_free(name); + } +} + +void +action_equ_save_default_preset(void) +{ + equalizer_presets = equalizerwin_save_preset(equalizer_presets, Q_("Default"), + "eq.preset"); +} + +void +action_equ_save_preset_file(void) +{ + GtkWidget *dialog; + gchar *songname; + Playlist *playlist = playlist_get_active(); + + dialog = make_filebrowser(Q_("Save equalizer preset"), TRUE); + g_signal_connect(dialog, "response", + G_CALLBACK(equalizerwin_file_chooser_on_response), + save_preset_file); + + songname = playlist_get_filename(playlist, playlist_get_position(playlist)); + if (songname) { + gchar *eqname = g_strdup_printf("%s.%s", songname, + cfg.eqpreset_extension); + g_free(songname); + gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), + eqname); + g_free(eqname); + } +} + +void +action_equ_save_preset_eqf(void) +{ + GtkWidget *dialog; + + dialog = make_filebrowser(Q_("Save equalizer preset"), TRUE); + g_signal_connect(dialog, "response", + G_CALLBACK(equalizerwin_file_chooser_on_response), + save_winamp_file); +} + +void +action_equ_delete_preset(void) +{ + if (equalizerwin_delete_window) { + gtk_window_present(GTK_WINDOW(equalizerwin_delete_window)); + return; + } + + equalizerwin_create_list_window(equalizer_presets, + Q_("Delete preset"), + &equalizerwin_delete_window, + GTK_SELECTION_EXTENDED, NULL, + GTK_STOCK_DELETE, + G_CALLBACK(equalizerwin_delete_delete), + NULL); +} + +void +action_equ_delete_auto_preset(void) +{ + if (equalizerwin_delete_auto_window) { + gtk_window_present(GTK_WINDOW(equalizerwin_delete_auto_window)); + return; + } + + equalizerwin_create_list_window(equalizer_auto_presets, + Q_("Delete auto-preset"), + &equalizerwin_delete_auto_window, + GTK_SELECTION_EXTENDED, NULL, + GTK_STOCK_DELETE, + G_CALLBACK(equalizerwin_delete_auto_delete), + NULL); +}