menus.c

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

	dodebug(8, "displaying show_fileselector\n");

	/* mark our dialog as running */
	dialog_done3 = 999;

	/* create new window and position it relative to the main window */
	dialog = gtk_file_selection_new (text(83));
	/* make sure our window is always on top */
	gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));

	gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(dialog));
	if (defname != NULL) {
		gtk_file_selection_set_filename(GTK_FILE_SELECTION(dialog),
			defname);
	}

	/* translate the default-texts on the selector */
	b1 = GTK_BUTTON(GTK_FILE_SELECTION(dialog)->ok_button);
	gtk_label_set_text(GTK_LABEL(b1->child),T_OK);
	b1 = GTK_BUTTON(GTK_FILE_SELECTION(dialog)->cancel_button);
	gtk_label_set_text(GTK_LABEL(b1->child),T_CANCEL);
	dirs = GTK_CLIST(GTK_FILE_SELECTION(dialog)->dir_list);
	gtk_clist_set_column_title(dirs,0,text(85)); 
	dirs = GTK_CLIST(GTK_FILE_SELECTION(dialog)->file_list);
	gtk_clist_set_column_title(dirs,0,text(86)); 

        gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
                GTK_SIGNAL_FUNC (dialog_delete_event3), dialog);

        gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(dialog)->ok_button),
		"clicked", GTK_SIGNAL_FUNC(file_selector_ok), dialog);

        gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(dialog)->cancel_button),
		"clicked", GTK_SIGNAL_FUNC(dialog_delete_event3), dialog);
	

	/* grab cursor and change to watch */
        gtk_grab_add(dialog);
	gdk_window_get_user_data(GTK_WIDGET(toplevel)->window,
			(gpointer) &win_attr);
	normal_cursor = win_attr->cursor;
        cursor = gdk_cursor_new(GDK_WATCH);
        gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);

	/* only center window when toplevel visible */
	if ( GTK_WIDGET_VISIBLE(toplevel)) {
        	gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
        	gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
        	gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
		gtk_widget_size_request(dialog,&rq);
        	gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
	}

	/* center does not work with gtk-1.2.1, but ok with 1.2.3, well
	   what the heck... */

	gtk_widget_show(dialog);


	/* now wait until button is pressed */
	while (dialog_done3 == 999) {
		wait_and_process_events();
	}

        gtk_grab_remove(GTK_WIDGET(dialog));
	normal_cursor = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
        gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,normal_cursor);

	if (dialog_done3 != -1) {
		strcpy(retvalue,gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog)));
	} else {
		/* cancel or delete_event */
		strcpy(retvalue,"");
	}	

	/* remove dialog window */
        gtk_widget_destroy(dialog);
}


/* what to do when user selects a CD from the database */

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

	/* we selected something, unlook ok-button */
	gtk_widget_set_sensitive(cddb_info_okbutton,TRUE);

	/* got double-click? Simulate ok-button-press */
	if (event && event->type == GDK_2BUTTON_PRESS) {
		gtk_button_clicked(GTK_BUTTON(cddb_info_okbutton));
	}
}


/* called from cancel or ok button */
 
void show_cddb_btn_press(GtkWidget *widget, gpointer data) {
GList *sel;
gint row;

	/* cancel event */
	if (GPOINTER_TO_INT(data) == -1) {
		if (read_done == 999) {
			/* abort our cddb-process */
			kill_readcdda();
		}
		dialog_done = -1;
		return;
	}

	/* ok button pressed - find out which entry was selected */
	sel = cddb_clist->selection;
	if (sel != NULL) {
		row = GPOINTER_TO_INT(sel->data);
		/* now go back to network code and fetch fitting CD */
		if (continue_cddb_lookup_action(row) != 0) {
			/* disable ok-button */
			gtk_widget_set_sensitive(cddb_info_okbutton,FALSE);
		} else {
			/* data ok received */
			dialog_done = 0;
		}
	}
}


/* called when somebody closes the cddb-window via window-manager */

gint dialog_cddb_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) {

	if (read_done == 999) {
		/* abort our cddb-process */
		kill_readcdda();
	}
	dialog_done = -1;
	return(TRUE);
}


/* popup a modal window, set cursor to watch, return 0 if correct
   data was received from cddb-server, -1 if not or 
   when cancel or delete_event found.
   Centers automatically above the toplevel-widow 
*/

gint show_cddb_query() {
GtkWidget *dialog;
GtkWidget *button1;
GtkWidget *button2;
GtkWidget *box1,*box2,*hbox;
GtkWidget *f1, *cddb_logo;
GdkPixmap *p;
GdkBitmap *m;
GdkImlibImage *im;
gint w,h;
GtkWidget *b1_sep, *lbl;
GtkWidget *scrolled_win, *c_list;
GtkCList *clist;
gchar *titles[1];
gint xpos, ypos;
gint xsize, ysize;
GdkCursor *cursor,*normal_cursor;
GtkRequisition rq;
GdkWindowAttr *win_attr;
gchar tmp[MAXLINE];

	/* if another dialog is running, ignore */
	if (dialog_done == 999) {
		return -1;
	}

	dodebug(8, "displaying show_cddb_query\n");

	/* mark our dialog as running */
	dialog_done = 999;

	/* create new window and position it relative to the main window */
        dialog = gtk_window_new(GTK_WINDOW_DIALOG);
	gtk_window_set_title(GTK_WINDOW(dialog),text(2));
	gtk_widget_set_usize(dialog,tbf(450),tbf(260));
	/* make sure our window is always on top */
	gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
	cddb_window = dialog;

        gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
                GTK_SIGNAL_FUNC (dialog_cddb_delete_event), (gpointer) dialog);

	/* create layout for dialog */
        box1 = gtk_vbox_new(FALSE,5);
	gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
        gtk_container_add(GTK_CONTAINER(dialog),box1);

	hbox = gtk_hbox_new(FALSE,0);
	gtk_box_pack_start(GTK_BOX(box1),hbox,FALSE,TRUE,5);
	gtk_widget_show(hbox);

	f1 = gtk_frame_new(NULL);
	gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_IN);
	gtk_box_pack_start(GTK_BOX(hbox),f1,TRUE,TRUE,5);
	gtk_widget_show(f1);

	lbl = gtk_label_new("");
	cddb_info_label = lbl;
	gtk_container_add(GTK_CONTAINER(f1), lbl);
	gtk_misc_set_alignment(GTK_MISC(lbl),0.0,0.5);
	gtk_misc_set_padding(GTK_MISC(lbl),10,0);
	gtk_widget_show(lbl);

	/* load a gif-image and put into a pixmap */
	g_snprintf(tmp,MAXLINE,"%s/%s", sharedir,CDDBLOGO);
	im=gdk_imlib_load_image(tmp);
	if (im) {
		w=im->rgb_width;
		h=im->rgb_height;
		gdk_imlib_render(im,w,h);
		p=gdk_imlib_move_image(im);
		m=gdk_imlib_move_mask(im);
		cddb_logo = gtk_pixmap_new(p,m);
	} else {
		cddb_logo = gtk_label_new("[CDDB]");
	}
	gtk_box_pack_start(GTK_BOX(hbox),cddb_logo,FALSE,FALSE,5);
	gtk_widget_show(cddb_logo);
	
	scrolled_win = gtk_scrolled_window_new (NULL, NULL);
	gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
			GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_box_pack_start(GTK_BOX(box1),scrolled_win,TRUE,TRUE,0);
	gtk_widget_show(scrolled_win);
	
	titles[0] = text(108);
	c_list = gtk_clist_new_with_titles(1,titles);
	clist = GTK_CLIST(c_list);
	cddb_clist = clist;
	gtk_clist_set_column_auto_resize(clist, 0, TRUE);
	gtk_container_add (GTK_CONTAINER (scrolled_win), c_list);
	gtk_widget_show(c_list);
	gtk_signal_connect(GTK_OBJECT(clist), "select_row",
		GTK_SIGNAL_FUNC(cddb_select_row), NULL); 

	gtk_widget_show(box1);

	b1_sep = gtk_hseparator_new();
	gtk_box_pack_start(GTK_BOX(box1),b1_sep,FALSE,TRUE,0);
	gtk_widget_show(b1_sep);

	box2 = gtk_hbox_new(FALSE,0);
	gtk_box_pack_start(GTK_BOX(box1),box2,FALSE,TRUE,10);
	gtk_widget_show(box2);

	button1 = gtk_button_new_with_label(T_OK);
	cddb_info_okbutton = button1;
	gtk_box_pack_start(GTK_BOX(box2),button1,TRUE,TRUE,10);
	gtk_widget_show(button1);
	GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
	gtk_widget_set_sensitive(button1,FALSE);
	gtk_signal_connect(GTK_OBJECT(button1),"clicked",
		GTK_SIGNAL_FUNC(show_cddb_btn_press), GINT_TO_POINTER(0));

	button2 = gtk_button_new_with_label(T_CANCEL);
	gtk_box_pack_start(GTK_BOX(box2),button2,TRUE,TRUE,10);
	gtk_widget_show(button2);
	GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
	gtk_widget_grab_default (button2);
	gtk_signal_connect(GTK_OBJECT(button2),"clicked",
		GTK_SIGNAL_FUNC(show_cddb_btn_press), GINT_TO_POINTER(-1));


	/* grab cursor and change to watch */
        gtk_grab_add(dialog);
	gdk_window_get_user_data(GTK_WIDGET(toplevel)->window,
			(gpointer) &win_attr);
	normal_cursor = win_attr->cursor;
        cursor = gdk_cursor_new(GDK_WATCH);
        gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);

	/* only center window when toplevel visible */
	if ( GTK_WIDGET_VISIBLE(toplevel)) {
        	gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
        	gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
        	gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
		gtk_widget_size_request(dialog,&rq);
        	gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
	}

	gtk_widget_show(dialog);


	/* lets do some work */
	start_cddb_lookup_action();

	/* now wait until button is pressed */
	while (dialog_done == 999) {
		wait_and_process_events();
	}

        gtk_grab_remove(GTK_WIDGET(dialog));
	normal_cursor = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
        gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,normal_cursor);

	/* remove dialog window */
        gtk_widget_destroy(dialog);

	return dialog_done;
}


/* start the read-processes according to the trackreadset-struct.
   Update read-dialogbox and return 0 if ok, 1 on error - call
   cdda2wav in bulk mode */

gint start_read_action_bulk(gint read_devnr) {
GList *loop;
track_read_param_t *trackparam;
gfloat percent_done;
gint stat, count;
gint audiocount, datacount;

	if (strcmp(trackreadset.tocfile,"") == 0) {
		/* should not happen */
		return 1;
	}

	dolog(1, "Reading CD with toc file %s (bulk)\n", trackreadset.tocfile);

	percent_done = 0.0;
	count = 0;
	audiocount = 0;
	datacount = 0;

	/* start reading tracks */
	loop = g_list_first(trackreadset.trackparams);
	while (loop) {
		trackparam = loop->data;
		count++;
		
		/* data-track */
		if (trackparam->tracktype == 0) {
			stat = read_data_track(read_devnr,
				trackparam->starttrack,
				trackparam->kbyte,
				trackparam->trackfile,
				trackparam->startoffset,	
				trackparam->endoffset,
				trackreadset.nrtracks,				
				trackparam->percent,
				percent_done, count);
			datacount++;
			percent_done += trackparam->percent;
		} else {
			/* audio-track */
			/* dont read them here - do them as bulk later */
			audiocount++;
			stat = 0;
		}
		if (stat == 0) {
			/* no error */
			/* write inf-file */
			write_inf_file(trackparam); 
		} else {
			/* error while reading */
			return 1;
		}
		loop = loop->next;
	}

	/* ok, we have read all data tracks - now check if there 
	   are audio tracks to do */
	if (audiocount > 0) {
		if (start_bulk_read_action(read_devnr, percent_done,
		    datacount+1) != 0) {
			/* error while reading? */
			return 1;
		}
	}

	/* save the toc file (not for read single tracks) */
	if (strcmp(trackreadset.tocfile,"") != 0) {
		write_copy_cd_toc_file(trackreadset.tocfile);
	}

	/* unset current active toc-file */
	g_free(curset.tocfile);
	curset.tocfile = g_strdup("");

	/* no error reading tracks */
	gtk_label_set_text(GTK_LABEL(readtrack_info_label), text(161));
	gtk_label_set_text(GTK_LABEL(readtrack_small_info), text(165));

	/* now set progressbars to 100% - elsewhere we may end up
	   with 99% due rounding errors */
	gtk_progress_set_percentage(GTK_PROGRESS(readtrack_pbar1),1.0);
	gtk_progress_set_percentage(GTK_PROGRESS(readtrack_pbar2),1.0);

	return 0;
}


/* start the read-processes according to the trackreadset-struct.
   Update read-dialogbox and return 0 if ok, 1 on error */ 

gint start_read_action(gint read_devnr) {
GList *loop;
track_read_param_t *trackparam;
gfloat percent_done;
gint stat, count;

	if (strcmp(trackreadset.tocfile,"") != 0) {
		dolog(1, "Reading CD with toc file %s\n", trackreadset.tocfile);
	} else {
		dolog(1, "Reading single tracks\n");
	}
	percent_done = 0;
	count = 0;

	/* start reading tracks */
	loop = g_list_first(trackreadset.trackparams);
	while (loop) {
		trackparam = loop->data;
		count++;
		
		/* data-track */
		if (trackparam->tracktype == 0) {
			stat = read_data_track(read_devnr,
				trackparam->starttrack,
				trackparam->kbyte,
				trackparam->trackfile,
				trackparam->startoffset,	
				trackparam->endoffset,
				trackreadset.nrtracks,				
				trackparam->percent,
				percent_done, count);
		} else {
		/* audio-track */
			stat = read_audio_track(read_devnr,
				trackparam->starttrack,
				trackparam->endtrack,
				trackparam->kbyte,
				trackparam->trackfile,
				trackparam->startoffset,
				trackparam->endoffset,
				trackreadset.nrtracks,				
				trackparam->percent,
				percent_done, count);
		}
		if (stat == 0) {
			/* no error */
			percent_done += trackparam->percent;

			/* write inf-file */
			write_inf_file(trackparam); 
		} else {