equalizer.c

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

		gtk_clist_append(GTK_CLIST(clist),
				 &((EqualizerPreset *) node->data)->name);
		node = node->next;
	}
	gtk_clist_set_compare_func(GTK_CLIST(clist), equalizerwin_list_sort_func);
	gtk_clist_sort(GTK_CLIST(clist));

	gtk_container_add(GTK_CONTAINER(scrolled_window), clist);
	gtk_widget_show(clist);
	gtk_widget_show(scrolled_window);

	gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);

	if (entry)
	{
		*entry = gtk_entry_new();
		gtk_signal_connect(GTK_OBJECT(*entry), "activate",
				   GTK_SIGNAL_FUNC(btn1_func), NULL);
		gtk_box_pack_start(GTK_BOX(vbox), *entry, FALSE, FALSE, 0);
		gtk_widget_show(*entry);
	}

	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);

	btn1 = gtk_button_new_with_label(btn1_caption);
	gtk_signal_connect(GTK_OBJECT(btn1), "clicked",
			   GTK_SIGNAL_FUNC(btn1_func), clist);
	GTK_WIDGET_SET_FLAGS(btn1, GTK_CAN_DEFAULT);
	gtk_box_pack_start(GTK_BOX(bbox), btn1, TRUE, TRUE, 0);
	gtk_widget_show(btn1);

	btn2 = gtk_button_new_with_label(btn2_caption);
	gtk_signal_connect_object(GTK_OBJECT(btn2), "clicked",
				  GTK_SIGNAL_FUNC(gtk_widget_destroy),
				  GTK_OBJECT(*window));
	GTK_WIDGET_SET_FLAGS(btn2, GTK_CAN_DEFAULT);
	gtk_box_pack_start(GTK_BOX(bbox), btn2, TRUE, TRUE, 0);
	gtk_widget_show(btn2);

	gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
	gtk_widget_show(bbox);

	gtk_widget_grab_default(btn1);
	gtk_widget_show(vbox);
	gtk_widget_show(*window);
	return *window;
}

void equalizerwin_presets_menu_cb(gpointer cb_data, guint action, GtkWidget * w)
{
	switch (action)
	{
		case EQUALIZER_PRESETS_LOAD_PRESET:
			if (!equalizerwin_load_window)
				equalizerwin_create_list_window(equalizer_presets, _("Load preset"), &equalizerwin_load_window, GTK_SELECTION_SINGLE, NULL, _("Ok"), _("Cancel"), equalizerwin_load_ok, equalizerwin_load_select);
			else
				gdk_window_raise(equalizerwin_load_window->window);
			break;
		case EQUALIZER_PRESETS_LOAD_AUTOPRESET:
			if (!equalizerwin_load_auto_window)
				equalizerwin_create_list_window(equalizer_auto_presets, _("Load auto-preset"), &equalizerwin_load_auto_window, GTK_SELECTION_SINGLE, NULL, _("Ok"), _("Cancel"), equalizerwin_load_auto_ok, equalizerwin_load_auto_select);
			else
				gdk_window_raise(equalizerwin_load_auto_window->window);
			break;
		case EQUALIZER_PRESETS_LOAD_DEFAULT:
			equalizerwin_load_preset(equalizer_presets, "Default");
			break;
		case EQUALIZER_PRESETS_LOAD_ZERO:
		{
			gint i;

			eqslider_set_position(equalizerwin_preamp, 0);
			for (i = 0; i < 10; i++)
				eqslider_set_position(equalizerwin_bands[i], 0);
			equalizerwin_eq_changed();
			break;
		}
		case EQUALIZER_PRESETS_LOAD_FROM_FILE:
		{
			static GtkWidget *load_filesel;
			if (load_filesel != NULL)
				break;
			
			load_filesel = gtk_file_selection_new(_("Load equalizer preset"));
			gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(load_filesel)->ok_button), "clicked", GTK_SIGNAL_FUNC(equalizerwin_load_filesel_ok), load_filesel);
			gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(load_filesel)->cancel_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(load_filesel));
			gtk_signal_connect(GTK_OBJECT(load_filesel), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &load_filesel);
			gtk_widget_show(load_filesel);
			
			break;
		}
		case EQUALIZER_PRESETS_LOAD_FROM_WINAMPFILE:
		{
			static GtkWidget *load_winamp_filesel;

			if (load_winamp_filesel != NULL)
				break;

			load_winamp_filesel = gtk_file_selection_new(_("Load equalizer preset"));
			gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(load_winamp_filesel)->ok_button), "clicked", GTK_SIGNAL_FUNC(equalizerwin_load_winamp_filesel_ok), load_winamp_filesel);
			gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(load_winamp_filesel)->cancel_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(load_winamp_filesel));
			gtk_signal_connect(GTK_OBJECT(load_winamp_filesel), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &load_winamp_filesel);
			gtk_widget_show(load_winamp_filesel);
			
			break;
		}
		case EQUALIZER_PRESETS_IMPORT_WINAMPFILE:
		{
			static GtkWidget *import_winamp_filesel;

			if (import_winamp_filesel != NULL)
				break;

			import_winamp_filesel = gtk_file_selection_new(_("Import equalizer presets"));
			gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(import_winamp_filesel)->ok_button), "clicked", GTK_SIGNAL_FUNC(equalizerwin_import_winamp_filesel_ok), import_winamp_filesel);
			gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(import_winamp_filesel)->cancel_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(import_winamp_filesel));
			gtk_signal_connect(GTK_OBJECT(import_winamp_filesel), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &import_winamp_filesel);
			gtk_widget_show(import_winamp_filesel);
			
			break;
		}
	
		case EQUALIZER_PRESETS_SAVE_PRESET:
			if (!equalizerwin_save_window)
				equalizerwin_create_list_window(equalizer_presets, _("Save preset"), &equalizerwin_save_window, GTK_SELECTION_SINGLE, &equalizerwin_save_entry, _("Ok"), _("Cancel"), equalizerwin_save_ok, equalizerwin_save_select);
			else
				gdk_window_raise(equalizerwin_save_window->window);
			break;
		case EQUALIZER_PRESETS_SAVE_AUTOPRESET:
		{
			gchar *name;

			if (!equalizerwin_save_auto_window)
				equalizerwin_create_list_window(equalizer_auto_presets, _("Save auto-preset"), &equalizerwin_save_auto_window, GTK_SELECTION_SINGLE, &equalizerwin_save_auto_entry, _("Ok"), _("Cancel"), equalizerwin_save_auto_ok, equalizerwin_save_auto_select);
			else
				gdk_window_raise(equalizerwin_save_auto_window->window);
			if ((name = playlist_get_filename(get_playlist_position())) != NULL)
			{
				gtk_entry_set_text(GTK_ENTRY(equalizerwin_save_auto_entry), g_basename(name));
				g_free(name);
			}
			break;
		}
		case EQUALIZER_PRESETS_SAVE_DEFAULT:
			equalizer_presets = equalizerwin_save_preset(equalizer_presets, "Default", "eq.preset");
			break;
		case EQUALIZER_PRESETS_SAVE_TO_FILE:
		{
			static GtkWidget *equalizerwin_save_filesel;
			gchar *songname;

			if (equalizerwin_save_filesel != NULL)
				break;

			equalizerwin_save_filesel = gtk_file_selection_new(_("Save equalizer preset"));

			if ((songname = playlist_get_filename(get_playlist_position())) != NULL)
			{
				gchar *eqname = g_strdup_printf("%s.%s", songname, cfg.eqpreset_extension);
				g_free(songname);
				gtk_file_selection_set_filename(GTK_FILE_SELECTION(equalizerwin_save_filesel), eqname);
				g_free(eqname);
			}
			
			gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(equalizerwin_save_filesel)->ok_button), "clicked", GTK_SIGNAL_FUNC(equalizerwin_save_filesel_ok), equalizerwin_save_filesel);
			gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(equalizerwin_save_filesel)->cancel_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(equalizerwin_save_filesel));
			gtk_signal_connect(GTK_OBJECT(equalizerwin_save_filesel), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &equalizerwin_save_filesel);
			gtk_widget_show(equalizerwin_save_filesel);

			break;
		}
		case EQUALIZER_PRESETS_SAVE_TO_WINAMPFILE: {
			static GtkWidget *save_winamp_filesel;
			
			if (save_winamp_filesel != NULL)
				break;

			save_winamp_filesel = gtk_file_selection_new(_("Save equalizer preset"));
			gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(save_winamp_filesel)->ok_button), "clicked", GTK_SIGNAL_FUNC(equalizerwin_save_winamp_filesel_ok), save_winamp_filesel);
			gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(save_winamp_filesel)->cancel_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(save_winamp_filesel));
			gtk_signal_connect(GTK_OBJECT(save_winamp_filesel), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &save_winamp_filesel);
			gtk_widget_show(save_winamp_filesel);
			
			break;
		}
		case EQUALIZER_PRESETS_DELETE_PRESET:
			if (!equalizerwin_delete_window)
				equalizerwin_create_list_window(equalizer_presets, _("Delete preset"), &equalizerwin_delete_window, GTK_SELECTION_EXTENDED, NULL, _("Delete"), _("Close"), equalizerwin_delete_delete, NULL);
			break;
		case EQUALIZER_PRESETS_DELETE_AUTOPRESET:
			if (!equalizerwin_delete_auto_window)
				equalizerwin_create_list_window(equalizer_auto_presets, _("Delete auto-preset"), &equalizerwin_delete_auto_window, GTK_SELECTION_EXTENDED, NULL, _("Delete"), _("Close"), equalizerwin_delete_auto_delete, NULL);
			break;
	        case EQUALIZER_PRESETS_CONFIGURE:
			if (!equalizerwin_configure_window)
			{
				equalizerwin_configure_window =
					equalizerwin_create_conf_window();
				gtk_signal_connect(GTK_OBJECT(equalizerwin_configure_window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &equalizerwin_configure_window);
			}

			break;
	}
}

void equalizerwin_load_auto_preset(gchar * filename)
{
	gchar *presetfilename, *directory;
	ConfigFile *cfgfile;
	
	if (!cfg.equalizer_autoload)
		return;

	g_return_if_fail(filename != NULL);

	presetfilename = g_strdup_printf("%s.%s", filename, cfg.eqpreset_extension);

	/*
	 * First try to find a per file preset file
	 */
	if (strlen(cfg.eqpreset_extension) > 0 &&
	    (cfgfile = xmms_cfg_open_file(presetfilename)) != NULL)
	{
		g_free(presetfilename);
		equalizerwin_read_xmms_preset(cfgfile);
		xmms_cfg_free(cfgfile);
		return;
	}

	directory = g_dirname(filename);
	g_free(presetfilename);
	presetfilename = g_strdup_printf("%s/%s", directory, cfg.eqpreset_default_file);
	g_free(directory);

	/*
	 * Try to find a per directory preset file
	 */
	if (strlen(cfg.eqpreset_default_file) > 0 &&
	    (cfgfile = xmms_cfg_open_file(presetfilename)) != NULL)
	{
		equalizerwin_read_xmms_preset(cfgfile);
		xmms_cfg_free(cfgfile);
	}
	/*
	 * Fall back to the oldstyle auto presets
	 */
	else if (!equalizerwin_load_preset(equalizer_auto_presets, g_basename(filename)))
		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]);
}

static void equalizerwin_conf_apply_changes(void)
{
	gchar *start;
	
	g_free(cfg.eqpreset_default_file);
	g_free(cfg.eqpreset_extension);

	cfg.eqpreset_default_file = gtk_editable_get_chars(GTK_EDITABLE(eqconfwin_options_eqdf_entry), 0, -1);
	cfg.eqpreset_extension = gtk_editable_get_chars(GTK_EDITABLE(eqconfwin_options_eqef_entry), 0, -1);

	g_strstrip(cfg.eqpreset_default_file);
	start = cfg.eqpreset_default_file;
	/* Strip leading '.' */
	while (*start == '.')
		start++;
	if (start != cfg.eqpreset_default_file)
		g_memmove(cfg.eqpreset_default_file, start, strlen(start) + 1);

	g_strstrip(cfg.eqpreset_extension);
	start = cfg.eqpreset_extension;
	while (*start == '.')
		start++;
	if (start != cfg.eqpreset_extension)
		g_memmove(cfg.eqpreset_extension, start, strlen(start) + 1);
}

static void equalizerwin_conf_ok_cb(GtkWidget * w, gpointer data)
{
	equalizerwin_conf_apply_changes();
	gtk_widget_destroy(equalizerwin_configure_window);
}

static void equalizerwin_conf_apply_cb(GtkWidget * w, gpointer data)
{
	equalizerwin_conf_apply_changes();
}

GtkWidget * equalizerwin_create_conf_window(void)
{
	GtkWidget *window, *notebook;
	GtkWidget *options_eqdf_box;
	GtkWidget *options_eqe_box;
	GtkWidget *options_eqdf;
	GtkWidget *options_eqe;
	GtkWidget *options_frame, *options_vbox;
	GtkWidget *options_table;
	GtkWidget *vbox, *hbox, *instructions;
	GtkWidget *ok, *cancel, *apply;

	window = gtk_window_new(GTK_WINDOW_DIALOG);
	gtk_window_set_title(GTK_WINDOW(window), _("Configure Equalizer"));
	gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
	gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(mainwin));
	gtk_container_border_width(GTK_CONTAINER(window), 10);

	vbox = gtk_vbox_new(FALSE, 10);
	gtk_container_add(GTK_CONTAINER(window), vbox);
	notebook = gtk_notebook_new();
	gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);

	options_vbox = gtk_vbox_new(FALSE, 10);
	gtk_container_border_width(GTK_CONTAINER(options_vbox), 5);
	options_frame = gtk_frame_new(_("Options"));
	gtk_box_pack_start(GTK_BOX(options_vbox), options_frame, FALSE, FALSE, 0);
	gtk_container_border_width(GTK_CONTAINER(options_frame), 0);
	options_table = gtk_table_new(1, 2, FALSE);
	gtk_table_set_col_spacings(GTK_TABLE(options_table), 10);
	gtk_container_add(GTK_CONTAINER(options_frame), options_table);
	gtk_container_border_width(GTK_CONTAINER(options_table), 5);

	options_eqdf_box = gtk_hbox_new(FALSE, 5);
	options_eqdf = gtk_label_new(_("Directory preset file:"));
	gtk_box_pack_start(GTK_BOX(options_eqdf_box), options_eqdf, FALSE, FALSE, 0);
	eqconfwin_options_eqdf_entry = gtk_entry_new_with_max_length(40);
	gtk_widget_set_usize(eqconfwin_options_eqdf_entry, 115, -1);
	gtk_box_pack_start(GTK_BOX(options_eqdf_box), eqconfwin_options_eqdf_entry, FALSE, FALSE, 0);
	gtk_table_attach_defaults(GTK_TABLE(options_table), options_eqdf_box, 0, 1, 0, 1);
	
	options_eqe_box = gtk_hbox_new(FALSE, 5);
	options_eqe = gtk_label_new(_("File preset extension:"));
	gtk_box_pack_start(GTK_BOX(options_eqe_box), options_eqe, FALSE, FALSE, 0);
	eqconfwin_options_eqef_entry = gtk_entry_new_with_max_length(20);
	gtk_widget_set_usize(eqconfwin_options_eqef_entry, 55, -1);
	gtk_box_pack_start(GTK_BOX(options_eqe_box), eqconfwin_options_eqef_entry, FALSE, FALSE, 0);
	gtk_table_attach_defaults(GTK_TABLE(options_table), options_eqe_box, 1, 2, 0, 1);
	instructions =
		gtk_label_new(_("If \"Auto\" is enabled on the equalizer, xmms "
				"will try to load equalizer presets like this:\n"
				"1: Look for a preset file in the directory of the "
				"file we are about to play.\n"
				"2: Look for a directory preset file in the same "
				"directory.\n"
				"3: Look for a preset saved with the "
				"\"auto-load\" feature\n"
				"4: Finally, try to load the \"default\" preset"));
	gtk_label_set_justify(GTK_LABEL(instructions), GTK_JUSTIFY_LEFT);
	gtk_box_pack_start_defaults(GTK_BOX(options_vbox), instructions);
	
	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), options_vbox, gtk_label_new(_("Options")));

        /* 
         * Ok, Cancel & Apply 
         */

	hbox = gtk_hbutton_box_new();
	gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
	gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbox), 5);

	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

	ok = gtk_button_new_with_label(_("Ok"));
	gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(equalizerwin_conf_ok_cb), NULL);
	GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
	gtk_box_pack_start(GTK_BOX(hbox), ok, TRUE, TRUE, 0);
	cancel = gtk_button_new_with_label(_("Cancel"));
	gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked",
				  GTK_SIGNAL_FUNC(gtk_widget_destroy),
				  GTK_OBJECT(window));
	GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
	gtk_box_pack_start(GTK_BOX(hbox), cancel, TRUE, TRUE, 0);
	apply = gtk_button_new_with_label(_("Apply"));
	gtk_signal_connect(GTK_OBJECT(apply), "clicked", GTK_SIGNAL_FUNC(equalizerwin_conf_apply_cb), NULL);
	GTK_WIDGET_SET_FLAGS(apply, GTK_CAN_DEFAULT);
	gtk_box_pack_start(GTK_BOX(hbox), apply, TRUE, TRUE, 0);

	gtk_entry_set_text(GTK_ENTRY(eqconfwin_options_eqdf_entry), cfg.eqpreset_default_file);
	gtk_entry_set_text(GTK_ENTRY(eqconfwin_options_eqef_entry), cfg.eqpreset_extension);

	gtk_widget_show_all(window);
	gtk_widget_grab_default(ok);

	return window;
}