equalizer.c

xmms-1.2.10.tar.gz学习使用的就下吧

/*  XMMS - Cross-platform multimedia player
 *  Copyright (C) 1998-2002  Peter Alm, Mikael Alm, Olle Hallnas,
 *                           Thomas Nilsson and 4Front Technologies
 *  Copyright (C) 1999-2003  Haavard Kvaalen
 *
 *  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; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
#include "xmms.h"
#include "libxmms/configfile.h"

GtkWidget *equalizerwin;

static GtkWidget *equalizerwin_load_window = NULL;
static GtkWidget *equalizerwin_load_auto_window = NULL;
static GtkWidget *equalizerwin_save_window = NULL, *equalizerwin_save_entry;
static GtkWidget *equalizerwin_save_auto_window = NULL, *equalizerwin_save_auto_entry;
static GtkWidget *equalizerwin_delete_window = NULL;
static GtkWidget *equalizerwin_delete_auto_window = NULL;
static GtkWidget *equalizerwin_configure_window = NULL;

static GtkWidget *eqconfwin_options_eqdf_entry, *eqconfwin_options_eqef_entry;

GdkPixmap *equalizerwin_bg, *equalizerwin_bg_dblsize;
GdkGC *equalizerwin_gc;

GList *equalizerwin_wlist = NULL;

static GtkAccelGroup *equalizerwin_accel;

static TButton *equalizerwin_on, *equalizerwin_auto;
extern TButton *mainwin_eq;
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 GtkItemFactory *equalizerwin_presets_menu;

gboolean equalizerwin_focus = FALSE;

typedef struct
{
	gchar *name;
	gfloat preamp, bands[10];
}
EqualizerPreset;

static GList *equalizer_presets = NULL, *equalizer_auto_presets = NULL;

void equalizerwin_presets_menu_cb(gpointer cb_data, guint action, GtkWidget * w);
GtkWidget * equalizerwin_create_conf_window(void);

enum
{
	EQUALIZER_PRESETS_LOAD_PRESET, EQUALIZER_PRESETS_LOAD_AUTOPRESET,
	EQUALIZER_PRESETS_LOAD_DEFAULT,	EQUALIZER_PRESETS_LOAD_ZERO,
	EQUALIZER_PRESETS_LOAD_FROM_FILE, EQUALIZER_PRESETS_LOAD_FROM_WINAMPFILE,
	EQUALIZER_PRESETS_IMPORT_WINAMPFILE,
	EQUALIZER_PRESETS_SAVE_PRESET, EQUALIZER_PRESETS_SAVE_AUTOPRESET,
	EQUALIZER_PRESETS_SAVE_DEFAULT,	EQUALIZER_PRESETS_SAVE_TO_FILE,
	EQUALIZER_PRESETS_SAVE_TO_WINAMPFILE, EQUALIZER_PRESETS_DELETE_PRESET,
	EQUALIZER_PRESETS_DELETE_AUTOPRESET, EQUALIZER_PRESETS_CONFIGURE
};

GtkItemFactoryEntry equalizerwin_presets_menu_entries[] =
{
	{N_("/Load"), NULL, NULL, 0, "<Branch>"},
	{N_("/Load/Preset"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_LOAD_PRESET, "<Item>"},
	{N_("/Load/Auto-load preset"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_LOAD_AUTOPRESET, "<Item>"},
	{N_("/Load/Default"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_LOAD_DEFAULT, "<Item>"},
	{N_("/Load/-"), NULL, NULL, 0, "<Separator>"},
	{N_("/Load/Zero"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_LOAD_ZERO, "<Item>"},
	{N_("/Load/-"), NULL, NULL, 0, "<Separator>"},
	{N_("/Load/From file"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_LOAD_FROM_FILE, "<Item>"},
	{N_("/Load/From WinAMP EQF file"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_LOAD_FROM_WINAMPFILE, "<Item>"},
	{N_("/Import"), NULL, NULL, 0, "<Branch>"},
	{N_("/Import/WinAMP Presets"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_IMPORT_WINAMPFILE, "<Item>"},
	{N_("/Save"), NULL, NULL, 0, "<Branch>"},
	{N_("/Save/Preset"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_SAVE_PRESET, "<Item>"},
	{N_("/Save/Auto-load preset"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_SAVE_AUTOPRESET, "<Item>"},
	{N_("/Save/Default"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_SAVE_DEFAULT, "<Item>"},
	{N_("/Save/-"), NULL, NULL, 0, "<Separator>"},
	{N_("/Save/To file"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_SAVE_TO_FILE, "<Item>"},
	{N_("/Save/To WinAMP EQF file"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_SAVE_TO_WINAMPFILE, "<Item>"},
	{N_("/Delete"), NULL, NULL, 0, "<Branch>"},
	{N_("/Delete/Preset"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_DELETE_PRESET, "<Item>"},
	{N_("/Delete/Auto-load preset"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_DELETE_AUTOPRESET, "<Item>"},
	{N_("/Configure Equalizer"), NULL, equalizerwin_presets_menu_cb, EQUALIZER_PRESETS_CONFIGURE, "<Item>"},
};

static gint equalizerwin_presets_menu_entries_num = 
	sizeof(equalizerwin_presets_menu_entries) / 
	sizeof(equalizerwin_presets_menu_entries[0]);

void equalizerwin_set_shape_mask(void)
{
	if (cfg.show_wm_decorations)
		return;

	gtk_widget_shape_combine_mask(equalizerwin, skin_get_mask(SKIN_MASK_EQ, EQUALIZER_DOUBLESIZE, cfg.equalizer_shaded), 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_resize(dock_window_list, equalizerwin, 550, height * 2);
		gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg_dblsize, 0);
	}
	else
	{
		dock_resize(dock_window_list, equalizerwin, 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, 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);
		show_widget(equalizerwin_volume);
		show_widget(equalizerwin_balance);
	}
	else
	{
		dock_shade(dock_window_list, 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);
		hide_widget(equalizerwin_volume);
		hide_widget(equalizerwin_balance);
	}
	
	draw_equalizer_window(TRUE);
}

void equalizerwin_shade_toggle(void)
{
	equalizerwin_set_shade(!cfg.equalizer_shaded);
}

void equalizerwin_set_shade(gboolean shaded)
{
	GtkWidget *widget;
        widget = gtk_item_factory_get_widget(mainwin_options_menu,
					     "/Equalizer WindowShade Mode");
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), shaded);
}

void equalizerwin_raise(void)
{
	if (cfg.equalizer_visible)
		gdk_window_raise(equalizerwin->window);
}

void equalizerwin_eq_changed(void)
{
	int 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]);
	input_set_eq(cfg.equalizer_active, cfg.equalizer_preamp, cfg.equalizer_bands);
	draw_widget(equalizerwin_graph);
}

void equalizerwin_on_pushed(gboolean toggled)
{
	cfg.equalizer_active = toggled;
	equalizerwin_eq_changed();
}

void equalizerwin_presets_pushed(void)
{
	GdkModifierType modmask;
	gint x, y;

	gdk_window_get_pointer(NULL, &x, &y, &modmask);
	util_item_factory_popup(equalizerwin_presets_menu, x, y, 1, GDK_CURRENT_TIME);
}

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;

	lock_widget_list(equalizerwin_wlist);
	if (force)
	{
		skin_draw_pixmap(equalizerwin_bg, equalizerwin_gc, SKIN_EQMAIN,
				 0, 0, 0, 0, 275, 116);
		if (equalizerwin_focus || !cfg.dim_titlebar)
		{
			if (!cfg.equalizer_shaded)
				skin_draw_pixmap(equalizerwin_bg, equalizerwin_gc,
						 SKIN_EQMAIN, 0, 134, 0, 0, 275, 14);
			else
				skin_draw_pixmap(equalizerwin_bg, equalizerwin_gc,
						 SKIN_EQ_EX, 0, 0, 0, 0, 275, 14);
		}
		else
		{
			if(!cfg.equalizer_shaded)
				skin_draw_pixmap(equalizerwin_bg, equalizerwin_gc,
						 SKIN_EQMAIN, 0, 149, 0, 0, 275, 14);
			else
				skin_draw_pixmap(equalizerwin_bg, equalizerwin_gc,
						 SKIN_EQ_EX, 0, 15, 0, 0, 275, 14);

		}
		draw_widget_list(equalizerwin_wlist, &redraw, TRUE);
	}
	else
		draw_widget_list(equalizerwin_wlist, &redraw, FALSE);

	if (force || redraw)
	{
		if (cfg.doublesize && cfg.eq_doublesize_linked)
		{
			if (force)
			{
				img = gdk_image_get(equalizerwin_bg, 0, 0, 275, 116);
				img2 = create_dblsize_image(img);
				gdk_draw_image(equalizerwin_bg_dblsize, equalizerwin_gc, img2, 0, 0, 0, 0, 550, 232);
				gdk_image_destroy(img2);
				gdk_image_destroy(img);
			}
			else
			{
				wl = equalizerwin_wlist;
				while (wl)
				{
					w = (Widget *) wl->data;
					if (w->redraw && w->visible)
					{
						img = gdk_image_get(equalizerwin_bg, w->x, w->y, w->width, w->height);
						img2 = create_dblsize_image(img);
						gdk_draw_image(equalizerwin_bg_dblsize, equalizerwin_gc, img2, 0, 0, w->x << 1, w->y << 1, w->width << 1, w->height << 1);
						gdk_image_destroy(img2);
						gdk_image_destroy(img);
						w->redraw = FALSE;
					}
					wl = wl->next;
				}
			}
		}
		else
			clear_widget_list_redraw(equalizerwin_wlist);
		gdk_window_clear(equalizerwin->window);
		gdk_flush();
	}
	unlock_widget_list(equalizerwin_wlist);
}

static gboolean inside_sensitive_widgets(gint x, gint y)
{
	return (inside_widget(x, y, equalizerwin_on) ||
		inside_widget(x, y, equalizerwin_auto) ||
		inside_widget(x, y, equalizerwin_presets) ||
		inside_widget(x, y, equalizerwin_close) ||
		inside_widget(x, y, equalizerwin_shade) ||
		inside_widget(x, y, equalizerwin_preamp) ||
		inside_widget(x, y, equalizerwin_bands[0]) ||
		inside_widget(x, y, equalizerwin_bands[1]) ||
		inside_widget(x, y, equalizerwin_bands[2]) ||
		inside_widget(x, y, equalizerwin_bands[3]) ||
		inside_widget(x, y, equalizerwin_bands[4]) ||
		inside_widget(x, y, equalizerwin_bands[5]) ||
		inside_widget(x, y, equalizerwin_bands[6]) ||
		inside_widget(x, y, equalizerwin_bands[7]) ||
		inside_widget(x, y, equalizerwin_bands[8]) ||
		inside_widget(x, y, equalizerwin_bands[9]) ||
		inside_widget(x, y, equalizerwin_volume) ||
		inside_widget(x, y, equalizerwin_balance));
}

void 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, 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(equalizerwin))
			dock_move_release(equalizerwin);
	}
	else if (event->button == 3 &&
		 !(inside_widget(event->x, event->y, equalizerwin_on) ||
		   inside_widget(event->x, event->y, equalizerwin_auto)))
	{
		/*
		 * Pop up the main menu a few pixels down to avoid
		 * anything to be selected initially.
		 */
		util_item_factory_popup(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(equalizerwin->window, FALSE,
				 GDK_BUTTON_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
				 GDK_NONE, GDK_NONE, GDK_CURRENT_TIME);
}

void equalizerwin_motion(GtkWidget * widget, GdkEventMotion * event, gpointer callback_data)
{
	XEvent ev;

	if (cfg.doublesize && cfg.eq_doublesize_linked)
	{
		event->x /= 2;
		event->y /= 2;
	}
	if (dock_is_moving(equalizerwin))
	{
		dock_move_motion(equalizerwin, event);
	}
	else
	{
		handle_motion_cb(equalizerwin_wlist, widget, event);
		draw_main_window(FALSE);
	}
	gdk_flush();
	while (XCheckMaskEvent(GDK_DISPLAY(), ButtonMotionMask, &ev)) ;

}

void equalizerwin_release(GtkWidget * widget, GdkEventButton * event, gpointer callback_data)
{
	gdk_pointer_ungrab(GDK_CURRENT_TIME);
	gdk_flush();
	if (dock_is_moving(equalizerwin))
	{
		dock_move_release(equalizerwin);
	}
	else
	{
		handle_release_cb(equalizerwin_wlist, widget, event);
		draw_equalizer_window(FALSE);
	}
}

void equalizerwin_focus_in(GtkWidget * widget, GdkEvent * event, gpointer callback_data)