create.c

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

/*
	create.c
	Create CD functions
	20.11.99 tn
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include "xcdroast.h"
#include "main.h"
#include "xpms/minidata.xpm"
#include "xpms/miniaudio.xpm"
#include "xpms/mininodata.xpm"
#include "xpms/masteradd.xpm"
#include "xpms/masterdel.xpm"

extern gint debug;
extern gchar configdir[MAXLINE];
extern GtkWidget *toplevel;
extern GtkWidget *sidespace;
extern GtkWidget *workspace;
extern GtkWidget *actionspace;
extern gint wav_in;
extern GtkWidget *wav_quit_button;
extern gint wavplay_quit;
extern gint submenu;
extern track_read_set_t trackreadset;
extern setup_data_t setupdata;
extern current_set_t curset;
extern cd_info_t cdinfo;
extern track_info_t **trackinfo;
extern GtkCList *cdlist, *imglist;
extern GtkWidget *imglist_l1, *imglist_l2, *imglist_l3;
extern GtkWidget *cdlist_l1, *cdlist_l2, *cdlist_l3, *cdlist_l4;
extern GtkWidget *vrylist_l1, *vrylist_l2, *vrylist_l3, *vrylist_l4;
extern GList *imagelist;
extern GtkWidget *ctree_okbutton;

/* some stuff for the select-functions of the sidebar buttons */
guint side_handlers2[8];
GtkWidget *side_widgets2[8];
GtkCList *imglist2;
GList *writelist;
GtkWidget *isoopts[16];
GtkWidget *isoopt_omenu;
master_param_t masterparam;
GtkWidget *bootable_frame1;
GtkWidget *bootable_frame2;
GtkWidget *isoheader[7];

extern void draw_info_menu();
extern void draw_play_tracks_menu();
extern void draw_delete_menu();
extern void devices_setup_read(gint row, GtkWidget *tbl, gint showspeed);
extern void devices_setup_image(gint row, GtkWidget *tbl);
extern void devices_setup_write(gint row, GtkWidget *tbl);
extern void readoptions_selected(GtkWidget *item, gpointer nr);
extern void verifyoptions_selected(GtkWidget *item, gpointer nr);
extern void set_image_prefix_callback(GtkWidget *widget, gpointer data);
extern void writeoptions_selected(GtkWidget *item, gpointer nr);
extern void writemode_selected(GtkWidget *item, gpointer data);
extern void cdrtype_selected(GtkWidget *item, gpointer mode);
extern void show_atip_info(GtkWidget *widget, gpointer data);
extern void blankcd_clicked(GtkWidget *widget, gpointer data);
extern void undo_selections(GtkWidget *clist, gint row, gint column,
	GdkEventButton *event, gpointer data);
extern void do_lock();
extern void do_unlock();

void fill_write_tracks();
void fill_session_view();
void set_sessionsize_unknown();

/* --------------- */

/* fill the entries in the read_tracks_menu */

void fill_read_tracks(gint dontupdatecd) {
gchar tmp[MAXLINE];
gchar tmp2[MAXLINE];
gchar tmp3[MAXLINE];
gchar titlestr[MAXLINE];
gint overwritefree, normalfree, biggestfree, overwritefreebiggest;
GtkStyle *style;
gchar *data[2];
GdkPixmap *pixmap1, *pixmap2;
GdkBitmap *mask1, *mask2;
gint i, lcount;

	/* update cd-info */
        if (curset.reader_devnr != -1) {
                get_cd_toc_and_volid(curset.reader_devnr);
        }

        /* file prefix */
        if (strcmp(curset.file_prefix,"") == 0) {
                g_free(curset.file_prefix);
                curset.file_prefix = g_strdup(IMGFILEPREFIX);
        }
        gtk_entry_set_text(GTK_ENTRY(imglist_l1), curset.file_prefix);
        gtk_entry_select_region(GTK_ENTRY(imglist_l1), 0, 
                GTK_ENTRY(imglist_l1)->text_length);

        /* now check if the current filename has any influence on
           the available space - to complicated - REMOVED*/
	overwritefree = 0;
	overwritefreebiggest = 0;
/*
        overwritefree = 
                get_free_space_by_overwriting_trackfiles(&overwritefreebiggest);
*/
        /* free size */
        normalfree = determine_free_space(&biggestfree);
        convert_kbytes2mbminstring(normalfree,tmp3);

        /* additional free space when overwriting files? */
        if (cdinfo.nr_tracks > 0 && overwritefree > 0) {
                convert_kbytes2mbstring(normalfree+overwritefree, tmp2);
                g_snprintf(tmp,MAXLINE,"%s (%s)", tmp3, tmp2);
        } else {
                strcpy(tmp,tmp3);
        }
        gtk_entry_set_text(GTK_ENTRY(imglist_l2), tmp);

        /* biggest free block */
        convert_kbytes2mbminstring(biggestfree,tmp3);

        if (cdinfo.nr_tracks > 0 && overwritefreebiggest > 0) {
                convert_kbytes2mbstring(biggestfree+overwritefreebiggest, tmp2);
                g_snprintf(tmp,MAXLINE,"%s (%s)", tmp3, tmp2);
        } else {
                strcpy(tmp,tmp3);
        }
        gtk_entry_set_text(GTK_ENTRY(imglist_l3), tmp);


	/* dont change anything on the cd side */
	if (dontupdatecd) return;

	/* fill track-listing */
        /* clean up first */
        gtk_clist_clear(cdlist);

        /* cd loaded? */
        if (cdinfo.nr_tracks == -1) {
                gtk_entry_set_text(GTK_ENTRY(cdlist_l1), text(156));    
                gtk_entry_set_text(GTK_ENTRY(cdlist_l2),"");    
                return;
        }
        if (cdinfo.nr_tracks == -2) {
                gtk_entry_set_text(GTK_ENTRY(cdlist_l1), text(196));    
                gtk_entry_set_text(GTK_ENTRY(cdlist_l2),"");    
                return;
        }

        style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(cdlist)));
        pixmap1 = gdk_pixmap_create_from_xpm_d(cdlist->clist_window,
                &mask1, &style->bg[GTK_STATE_NORMAL],(gchar **)minidata_xpm);
        pixmap2 = gdk_pixmap_create_from_xpm_d(cdlist->clist_window,
                &mask2, &style->bg[GTK_STATE_NORMAL],(gchar **)miniaudio_xpm);

        data[0] = NULL;
        lcount = 0;

        for (i = 0; i < cdinfo.nr_tracks; i++) {

		strcpy(titlestr,"");

		/* we have cd-text for this track? */
                if (setupdata.option_displaycdtext) {
                        if (trackinfo[i]->title != NULL && 
                            trackinfo[i]->title[0] != '\0' ) {
				strcpy(titlestr, trackinfo[i]->title);
                        }
                }

                /* have we a cddb-title for this track? */
                if (trackinfo[i]->cddb_ttitle != NULL) {
			strcpy(titlestr, trackinfo[i]->cddb_ttitle);
                } else
                if (trackinfo[i]->volname != NULL) {
			strcpy(titlestr, trackinfo[i]->volname);
		}

                if (trackinfo[i]->type == 0) {
                        convert_frames2mbstring(trackinfo[i]->size,tmp2);
			if (strcmp(titlestr,"") == 0) {
				strcpy(titlestr,text(109));
			}
                        g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
                                trackinfo[i]->track_nr,
                                titlestr, tmp2);
                        data[1] = tmp;
                        gtk_clist_append(cdlist,data);
                        gtk_clist_set_pixmap(cdlist,lcount,0,pixmap1,mask1);
                        lcount++;
                } else {
                        convert_frames2minstring(trackinfo[i]->size,tmp2);
			if (strcmp(titlestr,"") == 0) {
				strcpy(titlestr,text(110));
			}
                        g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
                                trackinfo[i]->track_nr,
                                titlestr, tmp2);
                        data[1] = tmp;
                        gtk_clist_append(cdlist,data);
                        gtk_clist_set_pixmap(cdlist,lcount,0,pixmap2,mask2);
                        lcount++;
                }
	}

        /* cd-label */
        if (cdinfo.title && cdinfo.artist && 
                cdinfo.title[0] != '\0' && setupdata.option_displaycdtext) {
                g_snprintf(tmp,MAXLINE,"%s / %s", cdinfo.title, cdinfo.artist);
                gtk_entry_set_text(GTK_ENTRY(cdlist_l1), tmp);
                gtk_entry_set_position(GTK_ENTRY(cdlist_l1),0);
        } else 
        if (cdinfo.cddb_dtitle != NULL) {
                gtk_entry_set_text(GTK_ENTRY(cdlist_l1), cdinfo.cddb_dtitle);   
                gtk_entry_set_position(GTK_ENTRY(cdlist_l1),0);
        } else {
                gtk_entry_set_text(GTK_ENTRY(cdlist_l1),"");    
        }

	/* nothing selected at first */
        convert_frames2mbminstring(0, tmp);
        gtk_entry_set_text(GTK_ENTRY(cdlist_l2), tmp);
}


/* update currently selected track-sizes */

void update_read_size(gint clickrow) {
GList *sel;
gint row;
gint sizecount;
gchar tmp[MAXLINE];

	sizecount = 0;

        /* loop through all selected tracks */
        sel = cdlist->selection;
        while (sel) {
                row = GPOINTER_TO_INT(sel->data);               
		sizecount += trackinfo[row]->size;
                sel = sel->next;
        }

        convert_frames2mbminstring(sizecount, tmp);
        gtk_entry_set_text(GTK_ENTRY(cdlist_l2), tmp);
}


/* callbacks for button in read-screen */

void readsometracks_clicked(GtkWidget *widget, gpointer data) {
track_read_param_t *trackparam;
gfloat per;
gint ret, tcount, sizecount,nrtracks;
gint overwrite, overwritebiggest;
GList *sel;
gint row;

        /* no cd-reader defined */
        if (curset.reader_devnr == -1) {
                show_dialog(ICO_ERROR,text(203), T_OK, NULL, NULL, 0);
                return;
        }

        /* now check if our cd-information is still valid */
        get_cd_toc_and_volid(curset.reader_devnr);

        /* cd loaded? */
        if (cdinfo.nr_tracks < 0) {
                /* update screen ... */
                fill_read_tracks(0);
                show_dialog(ICO_WARN,text(266),T_OK,NULL,NULL,0);
                return;
        }

	sizecount = 0;
	nrtracks = 0;
        /* loop through all selected tracks to get number and sum of size */
        sel = cdlist->selection;
        while (sel) {
                row = GPOINTER_TO_INT(sel->data);               
		sizecount += trackinfo[row]->size;
		nrtracks++;
                sel = sel->next;
        }

	/* no tracks selected */
	if (nrtracks == 0) {
                show_dialog(ICO_WARN,text(302),T_OK,NULL,NULL,0);
                return;
	}

        /* lets check if the file-prefix-entry is up to date */
        set_image_prefix_callback(imglist_l1, NULL); 

        /* free structure first */
	clear_trackreadset();

        /* fill structure */
        trackreadset.nrtracks = nrtracks;

	tcount = 0;
        sel = cdlist->selection;
        while (sel) {
                row = GPOINTER_TO_INT(sel->data);               

                /* allocate memory */
                trackparam = g_new0(track_read_param_t,1);

                trackparam->trackinfo_index = row;
                trackparam->starttrack = trackinfo[row]->track_nr;
                trackparam->endtrack = 0;
                trackparam->tracktype = trackinfo[row]->type;
                per = (gfloat)trackinfo[row]->size * 100.0  / sizecount;
                trackparam->percent = per;
                
                if (trackparam->tracktype == 0) {
                        /* data track */
                        trackparam->kbyte = trackinfo[row]->size *
                                (DATASECTORSIZE/1024);
                        trackparam->frames = trackinfo[row]->size;
                        trackparam->startoffset = trackinfo[row]->start_sec;
                        if (row == cdinfo.nr_tracks-1) {
                                /* last track - leadout is track-end */
                                trackparam->endoffset = cdinfo.leadout - 2;     
                        } else {
                                /* sub 150 (2 sec leadout),
                                   sub 2 (2 run out sectors) */
                                trackparam->endoffset = 
                                        trackinfo[row+1]->start_sec -150-2;       
                        }
                } else {
                        /* audio */
                        trackparam->kbyte = trackinfo[row]->size *
                                CDDAFRAME/1024;
                        trackparam->frames = trackinfo[row]->size;
                }

                trackreadset.trackparams = g_list_append(
                        trackreadset.trackparams, trackparam);

                sel = sel->next;
        }

        /* assign diskspace */
        if (allocate_track_filenames(&overwrite, &overwritebiggest) != 0) {
                /* not enough space */
                ret = show_dialog(ICO_WARN,text(299), T_ANYWAY, T_CANCEL, NULL, 1);
                if (ret == 1) {
                        /* abort */
                        return;
                }
        }

	/* assign an empty toc-filename */
        g_free(trackreadset.tocfile);
        trackreadset.tocfile = g_strdup("");

        /* now all parameters for reading are set - lets begin */
        show_and_do_read_tracks(curset.reader_devnr, 0);
}


void read_select_all(GtkWidget *widget, gpointer data) {

        gtk_clist_select_all(cdlist);
}

void read_select_none(GtkWidget *widget, gpointer data) {

        gtk_clist_unselect_all(cdlist);
}

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

        update_read_size(row);
}


/* draw read-tracks menu */

void draw_read_tracks() {
GtkWidget *hbox, *vbox;
GtkWidget *f1,*f2, *f3;
GtkWidget *b1;
GtkWidget *e1;
GtkWidget *l1;