setup.c

-一个LINUX下的使用方&#63845 的CD-ROM刻录软件,开放源码

/*
	setup.c
	28.3.99 tn
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include "xcdroast.h"
#include "main.h"
#include "xpms/scsi_cdrom.xpm"
#include "xpms/scsi_hd.xpm"
#include "xpms/scsi_hdrmb.xpm"
#include "xpms/scsi_misc.xpm"
#include "xpms/scsi_tape.xpm"
#include "xpms/scsi_worm.xpm"
#include "xpms/scsi_scanner.xpm"

extern GtkWidget *toplevel;
extern GtkWidget *sidespace;
extern GtkWidget *workspace;
extern scsi_devices_t **scsidevices;
extern writer_driver_t **drivers;
extern gint language;
extern language_list_t **langarray;
extern setup_data_t setupdata;
extern gchar configdir[MAXLINE];
extern gchar xcdroast_version_loaded[MAXLINE];

setup_data_t bak_setupdata;
GtkCList *clist_list;
GtkWidget *clist_entry;
GtkWidget *updatesum_label, *updatebutton;
GtkWidget *cddb_entry1, *cddb_entry2, *log_entry;
GtkWidget *btn_testdsp;

/* main functions of the setup-menu */
/* called by cancel-button */

void menu_setup_cancel(GtkWidget *widget, gpointer data) {

	dodebug(8, "canceling setup\n");
	dolog(2, "Cancel setup\n");
 
	/* restore the saved data - therefore deletes all changes */
	free_glist(&setupdata.image_dirs);
	memcpy(&setupdata,&bak_setupdata,sizeof(setup_data_t));
	setupdata.image_dirs = NULL;
	copy_glist(&setupdata.image_dirs, bak_setupdata.image_dirs);
	free_glist(&bak_setupdata.image_dirs);
	setupdata.dsp_device = g_strdup(bak_setupdata.dsp_device);
	g_free(bak_setupdata.dsp_device);
	setupdata.mix_device = g_strdup(bak_setupdata.mix_device);
	g_free(bak_setupdata.mix_device);
	setupdata.cddb_host = g_strdup(bak_setupdata.cddb_host);
	g_free(bak_setupdata.cddb_host);
	setupdata.logfile = g_strdup(bak_setupdata.logfile);
	g_free(bak_setupdata.logfile);
 
	/* check if cancel and no config-file loaded */
	if (strcmp(xcdroast_version_loaded, "") == 0) {
		/* no config file - continue to lock duplicate and create
		   buttons */
        	create_main(1);
	} else {
		create_main(0);
	}
}


/* calculate all setup-data before leaving setup-menu */

gint menu_setup_ok_work(GtkWidget *widget, gpointer data) {
gint i;
gchar *rowdata[2];
gchar tmp[MAXLINE];

	dodebug(8, "confirming setup\n");

	/* create glist of image-dirs */
	free_glist(&setupdata.image_dirs);
	for (i = 0; i < clist_list->rows; i++) {
		gtk_clist_get_text(clist_list,i,0,rowdata);	
		setupdata.image_dirs = g_list_append(setupdata.image_dirs,
			g_strdup(rowdata[0]));
	}

	/* no image-dirs? */
	if (i == 0) {
		show_dialog(ICO_ERROR, text(283), T_CANCEL, NULL, NULL, 0);
		return 1;
	}

	/* now fill vendor/model data */
	convert_devnr2vendor(setupdata.writer_devnr,tmp);
	strncpy(setupdata.writer_vendor,tmp,9);
	convert_devnr2model(setupdata.writer_devnr,tmp);
	strncpy(setupdata.writer_model,tmp,17);
	convert_devnr2vendor(setupdata.readdev1_devnr,tmp);
	strncpy(setupdata.readdev1_vendor,tmp,9);
	convert_devnr2model(setupdata.readdev1_devnr,tmp);
	strncpy(setupdata.readdev1_model,tmp,17);
	convert_devnr2vendor(setupdata.readdev2_devnr,tmp);
	strncpy(setupdata.readdev2_vendor,tmp,9);
	convert_devnr2model(setupdata.readdev2_devnr,tmp);
	strncpy(setupdata.readdev2_model,tmp,17);

	if (setupdata.language >= 0) {
		language = setupdata.language;
	} else {
		/* get language from locale */
		scan_lang();
	}

	/* now generate mixer-device from dsp-device */
	g_free(setupdata.mix_device);
	if (setupdata.dsp_device != NULL) {
		setupdata.mix_device = g_strdup(
			gen_mix_from_dspdev(setupdata.dsp_device,tmp));
	}

	/* now get cddb/log-entries */
	g_free(setupdata.cddb_host);
	strcpy(tmp, gtk_entry_get_text(GTK_ENTRY(cddb_entry1)));
	strip_string(tmp);
	setupdata.cddb_host = g_strdup(tmp);
	setupdata.cddb_port = atoi(
		gtk_entry_get_text(GTK_ENTRY(cddb_entry2)));
	g_free(setupdata.logfile);
	strcpy(tmp, gtk_entry_get_text(GTK_ENTRY(log_entry)));
	check_tilde(tmp);
	setupdata.logfile = g_strdup(tmp);

	/* if the writer changed, lets lookup new driver options */
	scanoptions(setupdata.writer_devnr);

	return 0;
}


/* called by ok-button */

void menu_setup_ok(GtkWidget *widget, gpointer data) {

	dolog(2, "Confirm setup\n");

	if (menu_setup_ok_work(widget,data)) 
		return;

	/* free memory of backup-config */
	g_free(bak_setupdata.logfile);
	g_free(bak_setupdata.cddb_host);
	g_free(bak_setupdata.dsp_device);
	g_free(bak_setupdata.mix_device);
	free_glist(&bak_setupdata.image_dirs);

	strcpy(xcdroast_version_loaded, XCDROAST_VERSION);

        create_main(0);
}


/* called by save button */

void menu_setup_save(GtkWidget *widget, gpointer data) {
gchar tmp2[MAXLINE];

	if (menu_setup_ok_work(widget,data))
		return;

	dolog(2, "Save setup configuration\n");

	/* write config file */
	if (save_setup_config(configdir, CONFFILE) == 1) {
		/* save failed */
		g_snprintf(tmp2,MAXLINE,text(281), CONFFILE);
		show_dialog(ICO_WARN, tmp2, T_OK, NULL, NULL, 0);
	} else {
		/* save ok */
		show_dialog(ICO_INFO,text(271), T_OK, NULL, NULL, 0);
	}
}


/* click on device-list */

void device_select_row(GtkWidget *clist, gint row, gint col,
                     GdkEventButton *event, gpointer data) {

	/* double click? */
	if (event && event->type == GDK_2BUTTON_PRESS) {
		show_device_detail(scsidevices[row]->devnr);
	}	
}


/* draw scsi-scan screen */

void draw_scsi_scan(GtkWidget *win) {
gchar *titles[6];
gchar *data[6];
GtkWidget *list;
GtkCList *clist;
gchar tmp[MAXLINE];
gchar tmp2[MAXLINE];
gint count;
gint type;
gint removable;
GdkPixmap *pixmap;
GdkBitmap *mask;
gchar **xpm;
GtkWidget *scrolled_win;
GtkStyle *style;
#ifdef PRIV_COLS 
GdkColor c;
#endif
	scrolled_win = gtk_scrolled_window_new (NULL, NULL);
	gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
	gtk_container_add(GTK_CONTAINER(win),scrolled_win);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
		GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);

	titles[0] = text(24);
	titles[1] = text(25);
	titles[2] = text(26);
	titles[3] = text(27);
	titles[4] = text(28);
	titles[5] = text(249);

	list = gtk_clist_new_with_titles(6,titles);
	gtk_container_add (GTK_CONTAINER (scrolled_win), list);
	gtk_widget_realize(list);

	clist = GTK_CLIST(list);
	gtk_clist_set_column_auto_resize(clist, 5, TRUE);

	style = gtk_style_copy(gtk_widget_get_style(list));
#ifdef PRIV_COLS 
	gdk_color_parse(GTKLISTCOL,&c);
	gdk_color_alloc(gtk_widget_get_colormap(list),&c);

	style->base[GTK_STATE_NORMAL] = c;
	gtk_widget_set_style(GTK_WIDGET(list),style);
#endif

	gtk_clist_set_row_height(clist, 48);
	gtk_clist_set_column_width(clist, 0, 48);
	gtk_clist_set_column_justification(clist, 0, GTK_JUSTIFY_CENTER);
	gtk_clist_set_column_width(clist, 1, tbf(50));
	gtk_clist_set_column_justification(clist, 1, GTK_JUSTIFY_CENTER);
	gtk_clist_set_column_width(clist, 2, tbf(80));
	gtk_clist_set_column_width(clist, 3, tbf(140));
	gtk_clist_set_column_width(clist, 4, tbf(50));
	gtk_signal_connect(GTK_OBJECT(clist), "select_row",
		GTK_SIGNAL_FUNC(device_select_row), NULL);
	
	count = 0;
	while(scsidevices[count] != NULL) {
		g_snprintf(tmp,MAXLINE,"[%d,%d]",scsidevices[count]->bus,
			scsidevices[count]->id);
		data[0] = NULL;
		data[1] = tmp;
		data[2] = scsidevices[count]->vendor;
		data[3] = scsidevices[count]->model;
		data[4] = scsidevices[count]->rev;
		removable = scsidevices[count]->removable;
		type = scsidevices[count]->type;
		get_scsi_type_string(tmp2, type, removable);	
		data[5] = tmp2;
		gtk_clist_append(clist,data);

		xpm = scsi_misc_xpm;

		if (type == 0) {
			if (removable == 0) {
				xpm = scsi_hd_xpm;
			} else {
				xpm = scsi_hdrmb_xpm;
			}
		}
		if (type == 1) {
			xpm = scsi_tape_xpm;
		}
		if (type == 3) {
			/* most scanners seem to register themselves as 
			   processor..*/
			xpm = scsi_scanner_xpm;
		}
		if (type == 4) {
			xpm = scsi_worm_xpm;
		}
		if (type == 5) {
			xpm = scsi_cdrom_xpm;
		}
		if (type == 6) {
			xpm = scsi_scanner_xpm;
		}
		if (type == 7) {
			xpm = scsi_hdrmb_xpm;
		}


		pixmap = gdk_pixmap_create_from_xpm_d(clist->clist_window, 
			&mask, &style->bg[GTK_STATE_NORMAL],(gchar **)xpm);
		gtk_clist_set_pixmap(clist,count,0,pixmap,mask);
		
		count++;
	}

	gtk_widget_show(list);
	gtk_widget_show(scrolled_win);
}


/* following functions are the callbacks for the cd-setup-menu */

void speed_changed(GtkAdjustment *adj, GtkWidget *label) {
gchar tmp[MAXLINE];

	g_snprintf(tmp, MAXLINE,"%dx",(gint)adj->value);
	gtk_label_set_text(GTK_LABEL(label),tmp);

	setupdata.writer_speed = (gint)adj->value;
}


void fifo_changed(GtkAdjustment *adj, GtkWidget *label) {
gchar tmp[MAXLINE];

	g_snprintf(tmp, MAXLINE,"%.1fMB",(gfloat)adj->value);
	gtk_label_set_text(GTK_LABEL(label),tmp);

	setupdata.writer_fifo  = (gint)(adj->value * 1024);
}

void audio_speed_changed(GtkAdjustment *adj, GtkWidget *label) {
gchar tmp[MAXLINE];

	g_snprintf(tmp, MAXLINE,"%dx",(gint)adj->value);
	gtk_label_set_text(GTK_LABEL(label),tmp);
	
	setupdata.audioread_speed = (gint)adj->value;
}

void sectors_changed(GtkAdjustment *adj, GtkWidget *label) {
gchar tmp[MAXLINE];

	g_snprintf(tmp, MAXLINE,"%d",(gint)adj->value);
	gtk_label_set_text(GTK_LABEL(label),tmp);

	setupdata.audioread_overlap = (gint)adj->value;

}

void sectors2_changed(GtkAdjustment *adj, GtkWidget *label) {
gchar tmp[MAXLINE];

	g_snprintf(tmp, MAXLINE,"%d",(gint)adj->value);
	gtk_label_set_text(GTK_LABEL(label),tmp);

	setupdata.audioread_sectorburst = (gint)adj->value;
}

void writer_selected(GtkWidget *item, gpointer devnr) {

	setupdata.writer_devnr = GPOINTER_TO_INT(devnr);
}

void writermode_selected(GtkWidget *item, gpointer mode) {

	setupdata.writer_mode = GPOINTER_TO_INT(mode);
}

void readdev1_selected(GtkWidget *item, gpointer devnr) {

	setupdata.readdev1_devnr = GPOINTER_TO_INT(devnr);
}

void readdev2_selected(GtkWidget *item, gpointer devnr) {

	setupdata.readdev2_devnr = GPOINTER_TO_INT(devnr);
}

void audiointerface_selected(GtkWidget *item, gpointer data) {

	setupdata.audioread_interface = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
}


/* draw cd-setup screen */

void draw_cd_setup(GtkWidget *win) {
GtkWidget *omenu;
GtkWidget *menu;
GtkWidget *menu_item;
GtkWidget *l1;
GtkWidget *f1;
GtkWidget *vbox;
GtkWidget *tbl;
GtkObject *adj1,*adj2,*adj3,*adj4,*adj5;
GtkWidget *scale;
GtkWidget *spdlabel, *fifolabel;
gchar tmp[MAXLINE];
#ifdef WEWANTUSEAUDIOINTERFACESELECTOR
GSList *group;
GtkWidget *btn;
#endif
gint i;
gint menuhistory, menuidx, firstdevnr;

	vbox = gtk_vbox_new(FALSE,0);
	gtk_container_add(GTK_CONTAINER(win),vbox);
	gtk_container_set_border_width(GTK_CONTAINER(vbox),10);

	gtk_widget_show(vbox);

	f1 = gtk_frame_new(text(18));
	set_font_and_color(f1,BOLDFONT,NULL);
	gtk_box_pack_start(GTK_BOX(vbox),f1,FALSE,TRUE,0);
	gtk_widget_show(f1);

	tbl = gtk_table_new(4,8,TRUE);
	gtk_table_set_col_spacing(GTK_TABLE(tbl),3,10);
	gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
	gtk_container_add(GTK_CONTAINER(f1),tbl);
	gtk_widget_show(tbl);

	l1 = rightjust_gtk_label_new(text(19));
	gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4,0,1);
	gtk_widget_show(l1);
	
	omenu = gtk_option_menu_new ();
	menu = gtk_menu_new();

	menuidx = 0; menuhistory = -1; firstdevnr = -1;
	i = 0;
	while(scsidevices[i] != NULL) {
		if (scsidevices[i]->type == 4 || scsidevices[i]->type == 5 ) {

			if (firstdevnr == -1) {
				firstdevnr = scsidevices[i]->devnr;
			}
			if (convert_devnr2devstring(scsidevices[i]->devnr,tmp) == 0) {
				menu_item = gtk_menu_item_new_with_label(tmp);
				gtk_signal_connect(GTK_OBJECT(menu_item),
					"activate", GTK_SIGNAL_FUNC(writer_selected),
					GINT_TO_POINTER(scsidevices[i]->devnr));
				gtk_menu_append (GTK_MENU (menu), menu_item);