configure.c

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

/*  XMMS - Cross-platform multimedia player
 *  Copyright (C) 1998-2003  Peter Alm, Mikael Alm, Olle Hallnas,
 *                           Thomas Nilsson and 4Front Technologies
 *  Copyright (C) 1999-2004  Haavard Kvaalen <[e-mail]>
 *
 *  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/i18n.h"
#include "cdaudio.h"
#include "libxmms/titlestring.h"

#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#define GET_TB(b) gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b))
#define SET_TB(b) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(b), TRUE)

struct driveconfig {
	GtkWidget *device, *directory;
	GtkWidget *mixer_oss, *mixer_drive;
	GtkWidget *remove_button;
	GtkWidget *dae;
};

static GList *drives;

static GtkWidget *cdda_configure_win;
static GtkWidget *cdi_name, *cdi_name_override;
static GtkWidget *cdi_use_cddb, *cdi_cddb_server /*, *cdi_use_cdin, *cdi_cdin_server */;

void cdda_cddb_show_server_dialog(GtkWidget *w, gpointer data);
void cdda_cddb_show_network_window(GtkWidget *w, gpointer data);
void cdda_cddb_set_server(char *new_server);

static GtkWidget* configurewin_add_drive(struct driveinfo *drive, void *nb);

static void cdda_configurewin_ok_cb(GtkWidget * w, gpointer data)
{
	ConfigFile *cfgfile;
	struct driveinfo *drive;
	GList *node;
	int olddrives, ndrives, i;

	olddrives = g_list_length(cdda_cfg.drives);
	for (node = cdda_cfg.drives; node; node = node->next)
	{
		drive = node->data;
		g_free(drive->device);
		g_free(drive->directory);
		g_free(drive);
	}
	g_list_free(cdda_cfg.drives);
	cdda_cfg.drives = NULL;

	for (node = drives; node; node = node->next)
	{
		struct driveconfig *config = node->data;
		char *tmp;

		drive = g_malloc0(sizeof (*drive));
		drive->device = g_strdup(gtk_entry_get_text(GTK_ENTRY(config->device)));

		tmp = gtk_entry_get_text(GTK_ENTRY(config->directory));
		if (strlen(tmp) < 2 || tmp[strlen(tmp) - 1] == '/')
			drive->directory = g_strdup(tmp);
		else
			drive->directory = g_strconcat(tmp, "/", NULL);

		if (GET_TB(config->mixer_oss))
			drive->mixer = CDDA_MIXER_OSS;
		else if (GET_TB(config->mixer_drive))
			drive->mixer = CDDA_MIXER_DRIVE;
		else
			drive->mixer = CDDA_MIXER_NONE;
		if (GET_TB(config->dae))
			drive->dae = CDDA_READ_DAE;
		else
			drive->dae = CDDA_READ_ANALOG;
#ifdef HAVE_OSS
		drive->oss_mixer = SOUND_MIXER_CD;
#endif

		cdda_cfg.drives = g_list_append(cdda_cfg.drives, drive);
	}

	cdda_cfg.title_override = GET_TB(cdi_name_override);
	g_free(cdda_cfg.name_format);
	cdda_cfg.name_format = g_strdup(gtk_entry_get_text(GTK_ENTRY(cdi_name)));

	cdda_cfg.use_cddb = GET_TB(cdi_use_cddb);
	cdda_cddb_set_server(gtk_entry_get_text(GTK_ENTRY(cdi_cddb_server)));

#if 0
	cdda_cfg.use_cdin = GET_TB(cdi_use_cdin);
	if (strcmp(cdda_cfg.cdin_server, gtk_entry_get_text(GTK_ENTRY(cdi_cdin_server))))
	{
		g_free(cdda_cfg.cdin_server);
		cdda_cfg.cdin_server = g_strdup(gtk_entry_get_text(GTK_ENTRY(cdi_cdin_server)));
	}
#endif

	cfgfile = xmms_cfg_open_default_file();

	drive = cdda_cfg.drives->data;
	xmms_cfg_write_string(cfgfile, "CDDA", "device", drive->device);
	xmms_cfg_write_string(cfgfile, "CDDA", "directory", drive->directory);
  	xmms_cfg_write_int(cfgfile, "CDDA", "mixer", drive->mixer);
	xmms_cfg_write_int(cfgfile, "CDDA", "readmode", drive->dae);

/*  	xmms_cfg_write_boolean(cfgfile, "CDDA", "use_oss_mixer", cdda_cfg.use_oss_mixer); */
	
	for (node = cdda_cfg.drives->next, i = 1; node; node = node->next, i++)
	{
		char label[20];
		drive = node->data;

		sprintf(label, "device%d", i);
		xmms_cfg_write_string(cfgfile, "CDDA", label, drive->device);
		
		sprintf(label, "directory%d", i);
		xmms_cfg_write_string(cfgfile, "CDDA", label, drive->directory);

		sprintf(label, "mixer%d", i);
		xmms_cfg_write_int(cfgfile, "CDDA", label, drive->mixer);

		sprintf(label, "readmode%d", i);
		xmms_cfg_write_int(cfgfile, "CDDA", label, drive->dae);
	}

	ndrives = g_list_length(cdda_cfg.drives);

	for (i = ndrives; i < olddrives; i++)
		/* FIXME: Clear old entries */;

	xmms_cfg_write_int(cfgfile, "CDDA", "num_drives", ndrives);

	xmms_cfg_write_boolean(cfgfile, "CDDA", "title_override", cdda_cfg.title_override);
	xmms_cfg_write_string(cfgfile, "CDDA", "name_format", cdda_cfg.name_format);
	xmms_cfg_write_boolean(cfgfile, "CDDA", "use_cddb", cdda_cfg.use_cddb);
	xmms_cfg_write_string(cfgfile, "CDDA", "cddb_server", cdda_cfg.cddb_server);
	xmms_cfg_write_int(cfgfile, "CDDA", "cddb_protocol_level", cdda_cfg.cddb_protocol_level);
	xmms_cfg_write_boolean(cfgfile, "CDDA", "use_cdin", cdda_cfg.use_cdin);
	xmms_cfg_write_string(cfgfile, "CDDA", "cdin_server", cdda_cfg.cdin_server);
	xmms_cfg_write_default_file(cfgfile);
	xmms_cfg_free(cfgfile);
}

static void configurewin_close(GtkButton *w, gpointer data)
{
	GList *node;

	for (node = drives; node; node = node->next)
		g_free(node->data);
	g_list_free(drives);
	drives = NULL;

	gtk_widget_destroy(cdda_configure_win);
}

static void toggle_set_sensitive_cb(GtkToggleButton * w, gpointer data)
{
	gboolean set = gtk_toggle_button_get_active(w);
	gtk_widget_set_sensitive(GTK_WIDGET(data), set);
}

static void configurewin_add_page(GtkButton *w, gpointer data)
{
	GtkNotebook *nb = GTK_NOTEBOOK(data);
	GtkWidget *box = configurewin_add_drive(NULL, nb);
	char *label = g_strdup_printf(_("Drive %d"), g_list_length(drives));
	
	gtk_widget_show_all(box);
	gtk_notebook_append_page(GTK_NOTEBOOK(nb), box,
				 gtk_label_new(label));
	g_free(label);
}

static void redo_nb_labels(GtkNotebook *nb)
{
	int i;
	GtkWidget *child;
	
	for (i = 0; (child = gtk_notebook_get_nth_page(nb, i)) != NULL; i++)
	{
		char *label = g_strdup_printf(_("Drive %d"), i + 1);

		gtk_notebook_set_tab_label_text(nb, child, label);
		g_free(label);
	}
}
	

static void configurewin_remove_page(GtkButton *w, gpointer data)
{
	GList *node;
	GtkNotebook *nb = GTK_NOTEBOOK(data);
	gtk_notebook_remove_page(nb, gtk_notebook_get_current_page(nb));
	for (node = drives; node; node = node->next)
	{
		struct driveconfig *drive = node->data;

		if (GTK_WIDGET(w) == drive->remove_button)
		{
			if (node->next)
				redo_nb_labels(nb);
			drives = g_list_remove(drives, drive);
			g_free(drive);
			break;
		}
	}
	if (g_list_length(drives) == 1)
	{
		struct driveconfig *drive = drives->data;
		gtk_widget_set_sensitive(drive->remove_button, FALSE);
	}
}


static void configurewin_check_drive(GtkButton *w, gpointer data)
{
	struct driveconfig *drive = data;
	GtkWidget *window, *vbox, *label, *bbox, *closeb;
	char *device, *directory;
	int fd, dae_track = -1;
	GString *str = g_string_new("");
	struct stat stbuf;

	device = gtk_entry_get_text(GTK_ENTRY(drive->device));
	directory = gtk_entry_get_text(GTK_ENTRY(drive->directory));

	if ((fd = open(device, CDOPENFLAGS)) < 0)
		g_string_sprintfa(str, _("Failed to open device %s\n"
					 "Error: %s\n\n"),
				  device, strerror(errno));
	else
	{
		cdda_disc_toc_t toc;
		if (!cdda_get_toc(&toc, device))
			g_string_append(str,
					_("Failed to read \"Table of Contents\""
					  "\nMaybe no disc in the drive?\n\n"));
		else
		{
			int i, data = 0;
			g_string_sprintfa(str, _("Device %s OK.\n"
						 "Disc has %d tracks"), device,
					  toc.last_track - toc.first_track + 1);
			for (i = toc.first_track; i <= toc.last_track; i++)
				if (toc.track[i].flags.data_track)
					data++;
				else if (dae_track < 0)
					dae_track = i;
			if (data > 0)
				g_string_sprintfa(str, _(" (%d data tracks)"),
						  data);
			g_string_sprintfa(str, _("\nTotal length: %d:%.2d\n"),
					  toc.leadout.minute,
					  toc.leadout.second);
#ifdef CDDA_HAS_READAUDIO
			if (dae_track == -1)
				g_string_sprintfa(str,
						  _("Digital audio extraction "
						    "not tested as the disc has "
						    "no audio tracks\n"));
			else
			{
				int start, end, fr;
				char buffer[CD_FRAMESIZE_RAW];
				start = LBA(toc.track[dae_track]);

				if (dae_track == toc.last_track)
					end = LBA(toc.leadout);
				else
					end = LBA(toc.track[dae_track + 1]);
				fr = read_audio_data(fd, start + (end - start) / 2,
						     1, buffer);
				if (fr > 0)
					g_string_sprintfa(str,
						_("Digital audio extraction "
						  "test: OK\n\n"));
				else
					g_string_sprintfa(str,
						_("Digital audio extraction "
						  "test failed: %s\n\n"),
						strerror(-fr));
			}
#else
			g_string_sprintfa(str, "\n");
#endif
		}
		close(fd);
	}

	if (stat(directory, &stbuf) < 0)
	{
		g_string_sprintfa(str, _("Failed to check directory %s\n"
					 "Error: %s"),
				  directory, strerror(errno));
	}
	else
	{
		if (!S_ISDIR(stbuf.st_mode))
			g_string_sprintfa(str,
				_("Error: %s exists, but is not a directory"),
				directory);
		else
			g_string_sprintfa(str, _("Directory %s OK."),
					  directory);
	}
			
	window = gtk_window_new(GTK_WINDOW_DIALOG);
	gtk_window_set_transient_for(GTK_WINDOW(window),
				     GTK_WINDOW(cdda_configure_win));
	gtk_container_set_border_width(GTK_CONTAINER(window), 10);
	vbox = gtk_vbox_new(FALSE, 10);
	gtk_container_add(GTK_CONTAINER(window), vbox);
	label = gtk_label_new(str->str);
	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
	gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);

	bbox = gtk_hbutton_box_new();
	gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_SPREAD);
	gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);