equalizer.c

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

{
	equalizerwin_close->pb_allow_draw = TRUE;
	equalizerwin_shade->pb_allow_draw = TRUE;
	equalizerwin_focus = TRUE;
	draw_equalizer_window(TRUE);
}

void equalizerwin_focus_out(GtkWidget * widget, GdkEventButton * event, gpointer callback_data)
{
	equalizerwin_close->pb_allow_draw = FALSE;
	equalizerwin_shade->pb_allow_draw = FALSE;
	equalizerwin_focus = FALSE;
	draw_equalizer_window(TRUE);
}

gboolean equalizerwin_keypress(GtkWidget * w, 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:
			if (!gtk_accel_group_activate(equalizerwin_accel,
						      event->keyval,
						      event->state))
				gtk_widget_event(mainwin, (GdkEvent*) event);
			break;
	}

	return TRUE;
}

static gboolean equalizerwin_configure(GtkWidget * window, GdkEventConfigure *event, gpointer data)
{
	if (!GTK_WIDGET_VISIBLE(window))
		return FALSE;

	if (cfg.show_wm_decorations)
		gdk_window_get_root_origin(window->window,
					   &cfg.equalizer_x, &cfg.equalizer_y);
	else
		gdk_window_get_deskrelative_origin(window->window,
						   &cfg.equalizer_x,
						   &cfg.equalizer_y);
	return FALSE;
}

void equalizerwin_set_back_pixmap(void)
{
	if (cfg.doublesize && cfg.eq_doublesize_linked)
		gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg_dblsize, 0);
	else
		gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg, 0);
	gdk_window_clear(equalizerwin->window);
}

gint equalizerwin_client_event(GtkWidget *w, GdkEventClient *event, gpointer data)
{
	static GdkAtom atom_rcfiles = GDK_NONE;

	if (!atom_rcfiles)
		atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);

	if(event->message_type == atom_rcfiles)
	{
		mainwin_set_back_pixmap();
		equalizerwin_set_back_pixmap();
		playlistwin_set_back_pixmap();
		return TRUE;
	}
	return FALSE;
}

void equalizerwin_close_cb(void)
{
	equalizerwin_show(FALSE);
}

int equalizerwin_delete(GtkWidget * w, gpointer data)
{
	equalizerwin_show(FALSE);
	return TRUE;
}

static GList *equalizerwin_read_presets(gchar * fname)
{
	gchar *filename, *name;
	ConfigFile *cfgfile;
	GList *list = NULL;
	gint i, p = 0;
	EqualizerPreset *preset;

	filename = g_strdup_printf("%s/.xmms/%s", g_get_home_dir(), fname);
	if ((cfgfile = xmms_cfg_open_file(filename)) == NULL)
	{
		g_free(filename);
		return NULL;
	}
	g_free(filename);

	for (;;)
	{
		gchar section[21];
		
		sprintf(section, "Preset%d", p++);
		if (xmms_cfg_read_string(cfgfile, "Presets", section, &name))
		{
			preset = g_malloc(sizeof (EqualizerPreset));
			preset->name = name;
			xmms_cfg_read_float(cfgfile, name, "Preamp",
					    &preset->preamp);
			for (i = 0; i < 10; i++)
			{
				gchar band[7];
				sprintf(band, "Band%d", i);
				xmms_cfg_read_float(cfgfile, name, band,
						    &preset->bands[i]);
			}
			list = g_list_prepend(list, preset);
		}
		else
			break;
	}
	list = g_list_reverse(list);
	xmms_cfg_free(cfgfile);
	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;
}

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

void equalizerwin_volume_release_cb(gint pos)
{
	mainwin_adjust_volume_release();
}

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

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

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)
{
	int 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, 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)
	{
		hide_widget(equalizerwin_volume);
		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_gtk(void)
{
	equalizerwin = gtk_window_new(GTK_WINDOW_DIALOG);
	dock_add_window(dock_window_list, equalizerwin);
	gtk_widget_set_app_paintable(equalizerwin, TRUE);
	gtk_window_set_policy(GTK_WINDOW(equalizerwin), FALSE, FALSE, TRUE);
	gtk_window_set_title(GTK_WINDOW(equalizerwin), _("XMMS Equalizer"));
	gtk_window_set_wmclass(GTK_WINDOW(equalizerwin), "XMMS_Equalizer", "xmms");
	gtk_window_set_transient_for(GTK_WINDOW(equalizerwin), GTK_WINDOW(mainwin));
	if (cfg.equalizer_x != -1 && cfg.save_window_position)
		dock_set_uposition(equalizerwin, cfg.equalizer_x, cfg.equalizer_y);
	if (cfg.doublesize && cfg.eq_doublesize_linked)
		gtk_widget_set_usize(equalizerwin, 550, (cfg.equalizer_shaded ? 28 : 232));
	else
		gtk_widget_set_usize(equalizerwin, 275, (cfg.equalizer_shaded ? 14 : 116));

	gtk_widget_set_events(equalizerwin, GDK_FOCUS_CHANGE_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
	gtk_widget_realize(equalizerwin);
	hint_set_skip_winlist(equalizerwin);
	util_set_cursor(equalizerwin);
	if (!cfg.show_wm_decorations)
		gdk_window_set_decorations(equalizerwin->window, 0);

	gtk_window_add_accel_group(GTK_WINDOW(equalizerwin), equalizerwin_accel);

	equalizerwin_set_back_pixmap();
	if (cfg.doublesize && cfg.eq_doublesize_linked)
		gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg_dblsize, 0);
	else
		gdk_window_set_back_pixmap(equalizerwin->window, equalizerwin_bg, 0);

	gtk_signal_connect(GTK_OBJECT(equalizerwin), "delete_event",
			   GTK_SIGNAL_FUNC(equalizerwin_delete), NULL);
	gtk_signal_connect(GTK_OBJECT(equalizerwin), "button_press_event",
			   GTK_SIGNAL_FUNC(equalizerwin_press), NULL);
	gtk_signal_connect(GTK_OBJECT(equalizerwin), "button_release_event",
			   GTK_SIGNAL_FUNC(equalizerwin_release), NULL);
	gtk_signal_connect(GTK_OBJECT(equalizerwin), "motion_notify_event",
			   GTK_SIGNAL_FUNC(equalizerwin_motion), NULL);
	gtk_signal_connect(GTK_OBJECT(equalizerwin), "focus_in_event",
			   GTK_SIGNAL_FUNC(equalizerwin_focus_in), NULL);
	gtk_signal_connect(GTK_OBJECT(equalizerwin), "focus_out_event",
			   GTK_SIGNAL_FUNC(equalizerwin_focus_out), NULL);
	gtk_signal_connect(GTK_OBJECT(equalizerwin), "configure_event",
			   GTK_SIGNAL_FUNC(equalizerwin_configure), NULL);
	gtk_signal_connect(GTK_OBJECT(equalizerwin), "client_event",
			   GTK_SIGNAL_FUNC(equalizerwin_client_event), NULL);
	gtk_signal_connect(GTK_OBJECT(equalizerwin), "key-press-event",
			   GTK_SIGNAL_FUNC(equalizerwin_keypress), NULL);
}

void equalizerwin_create(void)
{
	equalizerwin_accel = gtk_accel_group_new();
	equalizerwin_presets_menu = gtk_item_factory_new(GTK_TYPE_MENU,
							 "<Main>",
							 equalizerwin_accel);
	gtk_item_factory_set_translate_func(equalizerwin_presets_menu,
					    util_menu_translate, NULL, NULL);
	gtk_item_factory_create_items(equalizerwin_presets_menu, equalizerwin_presets_menu_entries_num, equalizerwin_presets_menu_entries, NULL);
	equalizer_presets = equalizerwin_read_presets("eq.preset");
	equalizer_auto_presets = equalizerwin_read_presets("eq.auto_preset");

	equalizerwin_bg = gdk_pixmap_new(NULL, 275, 116, gdk_rgb_get_visual()->depth);
	equalizerwin_bg_dblsize = gdk_pixmap_new(NULL, 550, 232, gdk_rgb_get_visual()->depth);
	equalizerwin_create_gtk();
	equalizerwin_gc = gdk_gc_new(equalizerwin->window);
	equalizerwin_create_widgets();
}

void equalizerwin_recreate(void)
{
	dock_window_list = g_list_remove(dock_window_list, equalizerwin);
	gtk_widget_destroy(equalizerwin);
	equalizerwin_create_gtk();

	equalizerwin_set_shape_mask();
}

void equalizerwin_show(gboolean show)
{
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_widget(mainwin_general_menu, "/Graphical EQ")), show);
}

void equalizerwin_real_show(void)
{
	/*
	 * This function should only be called from the
	 * main menu signal handler
	 */
	if (!pposition_broken && cfg.equalizer_x != -1 &&
	    cfg.save_window_position && cfg.show_wm_decorations)
		dock_set_uposition(equalizerwin, cfg.equalizer_x, cfg.equalizer_y);
	gtk_widget_show(equalizerwin);
	if (pposition_broken && cfg.equalizer_x != -1 && cfg.save_window_position)
		dock_set_uposition(equalizerwin, cfg.equalizer_x, cfg.equalizer_y);
	if (cfg.doublesize && cfg.eq_doublesize_linked)
		gtk_widget_set_usize(equalizerwin, 550, (cfg.equalizer_shaded ? 28 : 232));
	else
		gtk_widget_set_usize(equalizerwin, 275, (cfg.equalizer_shaded ? 14 : 116));
	gdk_flush();
	draw_equalizer_window(TRUE);
	cfg.equalizer_visible = TRUE;
	tbutton_set_toggled(mainwin_eq, TRUE);
	hint_set_always(cfg.always_on_top);
	hint_set_sticky(cfg.sticky);
	hint_set_skip_winlist(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, 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, gchar * fname)
{
	gchar *filename, *tmp;
	gint i, p;
	EqualizerPreset *preset;
	ConfigFile *cfgfile;
	GList *node;

	cfgfile = xmms_cfg_new();
	p = 0;
	node = list;
	while (node)
	{
		preset = node->data;
		tmp = g_strdup_printf("Preset%d", p++);
		xmms_cfg_write_string(cfgfile, "Presets", tmp, preset->name);
		g_free(tmp);
		xmms_cfg_write_float(cfgfile, preset->name, "Preamp", preset->preamp);
		for (i = 0; i < 10; i++)
		{
			tmp = g_strdup_printf("Band%d\n", i);
			xmms_cfg_write_float(cfgfile, preset->name, tmp, preset->bands[i]);
			g_free(tmp);
		}
		node = g_list_next(node);
	}
	filename = g_strdup_printf("%s/.xmms/%s", g_get_home_dir(), fname);