1 /*
2 create.c
3 Create CD functions
4 20.11.99 tn
5 */
6
7 #ifdef HAVE_CONFIG_H
8 # include <config.h>
9 #endif
10
11 #include "largefile.h"
12
13 #if HAVE_LOCALE_H
14 #include <locale.h>
15 #else
16 # define setlocale(Category, Locale)
17 #endif
18 #include "gettext.h"
19
20 #include <stdio.h>
21 #include <sys/stat.h>
22 #include <stdlib.h>
23 #include <fcntl.h>
24 #include <string.h>
25 #include <strings.h>
26
27 #if ENABLE_NLS
28 # define _(String) gettext (String)
29 # define N_(String) gettext_noop (String)
30 #else
31 # define _(String) (String)
32 # define N_(String) (String)
33 #endif
34 #define GTK_ENABLE_BROKEN
35
36 #include <gtk/gtk.h>
37 #include <gdk/gdk.h>
38 #include <gdk/gdkkeysyms.h>
39
40 #include "xcdrdata.h"
41 #include "xcdroast.h"
42 #include "main.h"
43 #include "../xpms/minidata.xpm"
44 #include "../xpms/miniaudio.xpm"
45 #include "../xpms/mininodata.xpm"
46 #include "../xpms/masteradd.xpm"
47 #include "../xpms/masterdel.xpm"
48
49 extern gint debug;
50 extern gchar configdir[MAXLINE];
51 extern GtkWidget *toplevel;
52 extern GtkWidget *sidespace;
53 extern GtkWidget *workspace;
54 extern GtkWidget *actionspace;
55 extern gint wav_in;
56 extern GtkWidget *wav_quit_button;
57 extern gint wavplay_quit;
58 extern gint submenu;
59 extern track_read_set_t trackreadset;
60 extern writerreader_devices_t **writerreaderdevs;
61 extern setup_data_t setupdata;
62 extern current_set_t curset;
63 extern cd_info_t cdinfo;
64 extern track_info_t **trackinfo;
65 extern GtkCList *cdlist, *imglist;
66 extern GtkWidget *imglist_l1, *imglist_l2, *imglist_l3;
67 extern GtkWidget *cdlist_l1, *cdlist_l2, *cdlist_l3, *cdlist_l4;
68 extern GtkWidget *vrylist_l1, *vrylist_l2, *vrylist_l3, *vrylist_l4;
69 extern GList *imagelist;
70 extern GtkWidget *ctree_okbutton;
71 extern GtkWidget *crea_cd_mode_omenu, *crea_cd_burnfree_check;
72
73 /* some stuff for the select-functions of the sidebar buttons */
74 extern guint side_handlers2[8];
75 extern GtkWidget *side_widgets2[8];
76
77 GtkCList *imglist2;
78 GList *writelist;
79 GtkWidget *isoopts[24];
80 master_param_t masterparam;
81 gchar **charset_types;
82 gchar *master_fname1 = NULL;
83 gchar *master_fname2 = NULL;
84 GtkWidget *mkisofs_calc_timeout_dialog;
85 static GtkWidget *isoopt_omenu;
86 static GtkWidget *isoopt_cmenu;
87 static GtkWidget *isoopt_cmenu2;
88 static GtkWidget *bootable_frame1;
89 static GtkWidget *bootable_frame2;
90 static GtkWidget *isoheader[7];
91 static GtkWidget *master_avail_entry, *master_ms_button, *master_ms_button2;
92 static gint master_ms_button_signal, master_ms_button2_signal;
93 static gint session_current_state;
94 static GtkWidget *bootimg_entry, *master_loadsizetbl;
95
96 extern void draw_info_menu();
97 extern void draw_play_tracks_menu();
98 extern void draw_delete_menu();
99 extern void devices_setup_read(gint row, GtkWidget *tbl, gint showspeed);
100 extern void devices_setup_image(gint row, GtkWidget *tbl);
101 extern void devices_setup_write(gint row, GtkWidget *tbl);
102 extern void readoptions_selected(GtkWidget *item, gpointer nr);
103 extern void verifyoptions_selected(GtkWidget *item, gpointer nr);
104 extern void set_image_prefix_callback(GtkWidget *widget, gpointer data);
105 extern void writeoptions_selected(GtkWidget *item, gpointer nr);
106 extern void writemode_selected(GtkWidget *item, gpointer data);
107 extern void cdrtype_selected(GtkWidget *item, gpointer mode);
108 extern void show_atip_info(GtkWidget *widget, gpointer data);
109 extern void blankcd_clicked(GtkWidget *widget, gpointer data);
110 extern void adv_write_options_clicked(GtkWidget *widget, gpointer data);
111 extern void undo_selections(GtkWidget *clist, gint row, gint column,
112 GdkEventButton *event, gpointer data);
113 extern void do_lock(gint plusgrab);
114 extern void do_unlock(gint plusgrab);
115 extern void display_advisooptions();
116
117 static void fill_session_view(gint checkmedia);
118 static void set_sessionsize_unknown();
119
120 /* --------------- */
121
122 /* fill the entries in the read_tracks_menu */
123
fill_read_tracks(gint dontupdatecd)124 void fill_read_tracks(gint dontupdatecd) {
125 gchar tmp[MAXLINE];
126 gchar tmp2[MAXLINE];
127 gchar tmp3[MAXLINE];
128 gchar titlestr[MAXLINE];
129 gint overwritefree, normalfree, biggestfree, overwritefreebiggest;
130 GtkStyle *style;
131 gchar *data[2];
132 GdkPixmap *pixmap1, *pixmap2;
133 GdkBitmap *mask1, *mask2;
134 gint i, lcount;
135
136 /* update cd-info */
137 if (curset.reader_devnr != -1) {
138 get_cd_toc_and_volid(curset.reader_devnr);
139 }
140
141 /* file prefix */
142 if (strcmp(curset.file_prefix,"") == 0) {
143 g_free(curset.file_prefix);
144 curset.file_prefix = g_strdup(IMGFILEPREFIX);
145 }
146 gtk_entry_set_text(GTK_ENTRY(imglist_l1), curset.file_prefix);
147 gtk_entry_set_position(GTK_ENTRY(imglist_l1), 0);
148 /*
149 gtk_entry_select_region(GTK_ENTRY(imglist_l1), 0,
150 GTK_ENTRY(imglist_l1)->text_length);
151 */
152 /* now check if the current filename has any influence on
153 the available space - to complicated - REMOVED*/
154 overwritefree = 0;
155 overwritefreebiggest = 0;
156 /*
157 overwritefree =
158 get_free_space_by_overwriting_trackfiles(&overwritefreebiggest);
159 */
160 /* free size */
161 normalfree = determine_free_space(&biggestfree);
162 convert_kbytes2mbminstring(normalfree,tmp3);
163
164 /* additional free space when overwriting files? */
165 if (cdinfo.nr_tracks > 0 && overwritefree > 0) {
166 convert_kbytes2mbstring(normalfree+overwritefree, tmp2);
167 g_snprintf(tmp,MAXLINE,"%s (%s)", tmp3, tmp2);
168 } else {
169 strcpy(tmp,tmp3);
170 }
171 gtk_entry_set_text(GTK_ENTRY(imglist_l2), tmp);
172 gtk_entry_set_position(GTK_ENTRY(imglist_l2), 0);
173
174 /* biggest free block */
175 convert_kbytes2mbminstring(biggestfree,tmp3);
176
177 if (cdinfo.nr_tracks > 0 && overwritefreebiggest > 0) {
178 convert_kbytes2mbstring(biggestfree+overwritefreebiggest, tmp2);
179 g_snprintf(tmp,MAXLINE,"%s (%s)", tmp3, tmp2);
180 } else {
181 strcpy(tmp,tmp3);
182 }
183 gtk_entry_set_text(GTK_ENTRY(imglist_l3), tmp);
184 gtk_entry_set_position(GTK_ENTRY(imglist_l3), 0);
185
186
187 /* dont change anything on the cd side */
188 if (dontupdatecd) return;
189
190 /* fill track-listing */
191 /* clean up first */
192 gtk_clist_clear(cdlist);
193
194 /* cd loaded? */
195 if (cdinfo.nr_tracks == -1) {
196 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), _("No CD loaded"));
197 gtk_entry_set_text(GTK_ENTRY(cdlist_l2),"");
198 return;
199 }
200 if (cdinfo.nr_tracks == -2) {
201 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), return_media_type(curset.reader_devnr));
202 gtk_entry_set_text(GTK_ENTRY(cdlist_l2),"");
203 return;
204 }
205
206 style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(cdlist)));
207 pixmap1 = gdk_pixmap_create_from_xpm_d(cdlist->clist_window,
208 &mask1, &style->bg[GTK_STATE_NORMAL],(gchar **)minidata_xpm);
209 pixmap2 = gdk_pixmap_create_from_xpm_d(cdlist->clist_window,
210 &mask2, &style->bg[GTK_STATE_NORMAL],(gchar **)miniaudio_xpm);
211
212 data[0] = NULL;
213 lcount = 0;
214
215 for (i = 0; i < cdinfo.nr_tracks; i++) {
216
217 strcpy(titlestr,"");
218
219 /* we have cd-text for this track? */
220 if (setupdata.option_displaycdtext) {
221 if (trackinfo[i]->title != NULL &&
222 trackinfo[i]->title[0] != '\0' ) {
223 strcpy(titlestr, trackinfo[i]->title);
224 }
225 }
226
227 /* have we a cddb-title for this track? */
228 if (trackinfo[i]->cddb_ttitle != NULL) {
229 strcpy(titlestr, trackinfo[i]->cddb_ttitle);
230 } else
231 if (trackinfo[i]->volname != NULL) {
232 strcpy(titlestr, trackinfo[i]->volname);
233 }
234
235 if (trackinfo[i]->type == 0) {
236 convert_frames2mbstring(trackinfo[i]->size,tmp2);
237 if (strcmp(titlestr,"") == 0) {
238 strcpy(titlestr,_("data track"));
239 }
240 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
241 trackinfo[i]->track_nr,
242 titlestr, tmp2);
243 data[1] = convert_for_gtk2(tmp);
244 gtk_clist_append(cdlist,data);
245 gtk_clist_set_pixmap(cdlist,lcount,0,pixmap1,mask1);
246 lcount++;
247 } else {
248 convert_frames2minstring(trackinfo[i]->size,tmp2);
249 if (strcmp(titlestr,"") == 0) {
250 strcpy(titlestr,_("audio track"));
251 }
252 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
253 trackinfo[i]->track_nr,
254 titlestr, tmp2);
255 data[1] = convert_for_gtk2(tmp);
256 gtk_clist_append(cdlist,data);
257 gtk_clist_set_pixmap(cdlist,lcount,0,pixmap2,mask2);
258 lcount++;
259 }
260 }
261
262 /* cd-label */
263 if (cdinfo.title && cdinfo.artist &&
264 cdinfo.title[0] != '\0' && setupdata.option_displaycdtext) {
265 g_snprintf(tmp,MAXLINE,"%s / %s", cdinfo.title, cdinfo.artist);
266 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), tmp);
267 gtk_entry_set_position(GTK_ENTRY(cdlist_l1),0);
268 } else
269 if (cdinfo.cddb_dtitle != NULL) {
270 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), cdinfo.cddb_dtitle);
271 gtk_entry_set_position(GTK_ENTRY(cdlist_l1),0);
272 } else {
273 gtk_entry_set_text(GTK_ENTRY(cdlist_l1),"");
274 }
275
276 /* nothing selected at first */
277 convert_frames2mbminstring(0, tmp);
278 gtk_entry_set_text(GTK_ENTRY(cdlist_l2), tmp);
279 }
280
281
282 /* update currently selected track-sizes */
283
update_read_size(gint clickrow)284 static void update_read_size(gint clickrow) {
285 GList *sel;
286 gint row;
287 gint sizecount;
288 gchar tmp[MAXLINE];
289
290 sizecount = 0;
291
292 /* loop through all selected tracks */
293 sel = cdlist->selection;
294 while (sel) {
295 row = GPOINTER_TO_INT(sel->data);
296 sizecount += trackinfo[row]->size;
297 sel = sel->next;
298 }
299
300 convert_frames2mbminstring(sizecount, tmp);
301 gtk_entry_set_text(GTK_ENTRY(cdlist_l2), tmp);
302 }
303
304
305 /* callbacks for button in read-screen */
306
readsometracks_clicked(GtkWidget * widget,gpointer data)307 static void readsometracks_clicked(GtkWidget *widget, gpointer data) {
308 track_read_param_t *trackparam;
309 gfloat per;
310 gint ret, tcount, sizecount,nrtracks;
311 gint overwrite, overwritebiggest;
312 GList *sel;
313 gint row, sectorstoread,stat;
314 gint datacount, audiocount, sectsize;
315
316 /* no cd-reader defined */
317 if (curset.reader_devnr == -1) {
318 show_dialog(ICO_ERROR,_("No CD-Reader defined in Setup"), T_OK, NULL, NULL, 0);
319 return;
320 }
321
322 datacount = 0;
323 audiocount = 0;
324 sectsize = get_sectorsize(curset.reader_devnr);
325
326 /* now check if our cd-information is still valid */
327 get_cd_toc_and_volid(curset.reader_devnr);
328
329 /* cd loaded? */
330 if (cdinfo.nr_tracks < 0) {
331 /* update screen ... */
332 fill_read_tracks(0);
333 show_dialog(ICO_WARN,_("No CD loaded in read device"),T_OK,NULL,NULL,0);
334 return;
335 }
336
337 sizecount = 0;
338 nrtracks = 0;
339 /* loop through all selected tracks to get number and sum of size */
340 sel = cdlist->selection;
341 while (sel) {
342 row = GPOINTER_TO_INT(sel->data);
343 sizecount += trackinfo[row]->size;
344 nrtracks++;
345 sel = sel->next;
346 }
347
348 /* no tracks selected */
349 if (nrtracks == 0) {
350 show_dialog(ICO_WARN,_("No tracks selected"),T_OK,NULL,NULL,0);
351 return;
352 }
353
354 /* lets check if the file-prefix-entry is up to date */
355 set_image_prefix_callback(imglist_l1, NULL);
356
357 /* free structure first */
358 clear_trackreadset();
359
360 /* fill structure */
361 trackreadset.nrtracks = nrtracks;
362
363 tcount = 0;
364 sel = cdlist->selection;
365 while (sel) {
366 row = GPOINTER_TO_INT(sel->data);
367
368 /* allocate memory */
369 trackparam = g_new0(track_read_param_t,1);
370
371 trackparam->trackinfo_index = row;
372 trackparam->starttrack = trackinfo[row]->track_nr;
373 trackparam->endtrack = 0;
374 trackparam->tracktype = trackinfo[row]->type;
375 per = (gfloat)trackinfo[row]->size * 100.0 / sizecount;
376 trackparam->percent = per;
377
378 if (trackparam->tracktype == 0) {
379 /* data track */
380 datacount++;
381 trackparam->kbyte = trackinfo[row]->size *
382 (DATASECTORSIZE/1024);
383 trackparam->frames = trackinfo[row]->size;
384 trackparam->startoffset = trackinfo[row]->start_sec;
385 if (row == cdinfo.nr_tracks-1) {
386 /* last track - leadout is track-end */
387 trackparam->endoffset = cdinfo.leadout - 2;
388 } else {
389 /* sub 150 (2 sec leadout),
390 sub 2 (2 run out sectors) */
391 trackparam->endoffset =
392 trackinfo[row+1]->start_sec -150-2;
393 }
394 /* now do a paranoia check */
395 /* in some cases we skip to much of a track */
396 sectorstoread = trackparam->endoffset -
397 trackparam->startoffset;
398 if (sectorstoread < trackinfo[row]->isosize) {
399 trackparam->endoffset =
400 trackparam->startoffset +
401 trackinfo[row]->isosize;
402 trackparam->kbyte = trackinfo[row]->isosize * 2;
403 dodebug(1,"readsometracks_clicked: corrected data track size from %d to %d sectors.\n", sectorstoread, trackinfo[row]->isosize);
404 }
405 } else {
406 /* audio */
407 audiocount++;
408 trackparam->kbyte = trackinfo[row]->size *
409 CDDAFRAME/1024;
410 trackparam->frames = trackinfo[row]->size;
411 }
412
413 trackreadset.trackparams = g_list_append(
414 trackreadset.trackparams, trackparam);
415
416 sel = sel->next;
417 }
418
419 /* sectorsize firmware bug detection */
420 if (datacount > 0 && sectsize != 2048) {
421 ret = show_dialog(ICO_WARN,_("Your drive seems to have a faulty firmware which will not allow to read\ndata tracks reliably. Try to look for a firmwire upgrade or read your\ndata CDs with another drive. To continue is not recommended."), T_ANYWAY, T_CANCEL, NULL, 1);
422 if (ret == 1) {
423 /* abort */
424 return;
425 }
426 }
427
428 /* assign diskspace */
429 stat = allocate_track_filenames(&overwrite, &overwritebiggest);
430 if (stat == 1) {
431 /* not enough space */
432 ret = show_dialog(ICO_WARN,_("Not enough diskspace available!\nDo you want to continue anyway or to abort?"), T_ANYWAY, T_CANCEL, NULL, 1);
433 if (ret == 1) {
434 /* abort */
435 return;
436 }
437 }
438
439 /* no writeable dirs */
440 if (stat == 2) {
441 show_dialog(ICO_WARN,_("No image-directories with write permissions found.\nPlease check your settings in the Setup."), T_OK, NULL, NULL, 1);
442 return;
443 }
444
445 /* overwriting a link? */
446 if (stat == 3) {
447 /* FIX HERE USING GETTEXT FOR NEXT RELEASE */
448 show_dialog(ICO_WARN,"Not allowing to overwrite a symlink.\nChoose another \"File prefix\".", T_OK, NULL, NULL, 1);
449 return;
450 }
451
452 /* warn we are going to overwrite some files */
453 if (setupdata.option_overwritewarn == 1 && overwrite > 0) {
454 ret = show_dialog(ICO_WARN,_("You are going to overwrite old track images on your\nharddrive. Cancel now, if you don't want to do that\nand choose another \"File prefix\"."), T_ANYWAY, T_CANCEL, NULL, 1);
455 if (ret == 1) {
456 /* abort */
457 return;
458 }
459 }
460
461 /* assign an empty toc-filename */
462 g_free(trackreadset.tocfile);
463 trackreadset.tocfile = g_strdup("");
464
465 /* now all parameters for reading are set - lets begin */
466 show_and_do_read_tracks(curset.reader_devnr, 0);
467 }
468
469
read_select_all(GtkWidget * widget,gpointer data)470 static void read_select_all(GtkWidget *widget, gpointer data) {
471
472 gtk_clist_select_all(cdlist);
473 }
474
read_select_none(GtkWidget * widget,gpointer data)475 static void read_select_none(GtkWidget *widget, gpointer data) {
476
477 gtk_clist_unselect_all(cdlist);
478 }
479
read_select_row(GtkWidget * clist,gint row,gint col,GdkEventButton * event,gpointer data)480 static void read_select_row(GtkWidget *clist, gint row, gint col,
481 GdkEventButton *event, gpointer data) {
482
483 update_read_size(row);
484 }
485
486
487 /* draw read-tracks menu */
488
draw_read_tracks()489 static void draw_read_tracks() {
490 GtkWidget *hbox, *vbox;
491 GtkWidget *f1,*f2, *f3;
492 GtkWidget *b1;
493 GtkWidget *e1;
494 GtkWidget *l1;
495 GtkWidget *tbl, *check, *dummy;
496 GtkCList *clist;
497 gchar *titles[2];
498 GtkWidget *scrolled_win, *list;
499
500 /* prepare draw area */
501 clear_actionspace();
502
503 f1 = gtk_frame_new(_("Devices-Setup"));
504 set_font_and_color_frame(f1,BOLDFONT,NULL);
505 gtk_box_pack_start(GTK_BOX(actionspace),f1,FALSE,FALSE,5);
506 gtk_widget_show(f1);
507
508 tbl = gtk_table_new(2,16*4,TRUE);
509 gtk_table_set_col_spacing(GTK_TABLE(tbl),4*4-1,5);
510 gtk_table_set_col_spacing(GTK_TABLE(tbl),15*4-2,5);
511 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
512 gtk_container_add(GTK_CONTAINER(f1),tbl);
513 gtk_widget_show(tbl);
514
515 devices_setup_read(0, tbl, 1);
516 devices_setup_image(1, tbl);
517 /* devices_setup_write(2, tbl); */
518
519 /* left and right info-frames */
520 tbl = gtk_table_new(1,2,TRUE);
521 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
522 gtk_box_pack_start(GTK_BOX(actionspace),tbl,TRUE,TRUE,10);
523 gtk_widget_show(tbl);
524 vbox = gtk_vbox_new(FALSE,10);
525 gtk_table_attach_defaults(GTK_TABLE(tbl),vbox,1,2,0,1);
526 if (!curset.isProDVD) {
527 f1 = gtk_frame_new(_("CD-Information"));
528 } else {
529 f1 = gtk_frame_new(_("CD/DVD-Information"));
530 }
531 set_font_and_color_frame(f1,BOLDFONT,NULL);
532 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,0,1,0,1);
533 gtk_widget_show(f1);
534 f2 = gtk_frame_new(_("Image-Information"));
535 set_font_and_color_frame(f2,BOLDFONT,NULL);
536 gtk_box_pack_start(GTK_BOX(vbox),f2,TRUE,TRUE,0);
537 gtk_widget_show(f2);
538 f3 = gtk_frame_new(_("Read options"));
539 set_font_and_color_frame(f3,BOLDFONT,NULL);
540 gtk_box_pack_start(GTK_BOX(vbox),f3,FALSE,FALSE,0);
541 gtk_widget_show(f3);
542 gtk_widget_show(vbox);
543
544 /* button bar at the bottom */
545 hbox = gtk_hbox_new(FALSE,5);
546 gtk_box_pack_start(GTK_BOX(actionspace),hbox,FALSE,TRUE,10);
547 gtk_widget_show(hbox);
548
549 b1 = gtk_button_new_with_label(_("Select all"));
550 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
551 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
552 GTK_SIGNAL_FUNC(read_select_all), NULL);
553 define_tooltip(b1,_("Selects all tracks of the currently inserted CD for reading."));
554 gtk_widget_show(b1);
555
556 b1 = gtk_button_new_with_label(_("Select none"));
557 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
558 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
559 GTK_SIGNAL_FUNC(read_select_none), NULL);
560 define_tooltip(b1,_("Deselects all tracks of the currently inserted CD."));
561 gtk_widget_show(b1);
562
563 dummy = gtk_label_new("");
564 gtk_box_pack_start(GTK_BOX(hbox),dummy,FALSE,FALSE,10);
565 gtk_widget_show(dummy);
566
567 b1 = gtk_button_new_with_label(_("Read selected tracks"));
568 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
569 gtk_widget_show(b1);
570 define_tooltip(b1,_("Reads all selected tracks from the CD and saves them in the Image Directory."));
571 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
572 GTK_SIGNAL_FUNC(readsometracks_clicked), NULL);
573
574 /* left frame */
575 vbox = gtk_vbox_new(FALSE,0);
576 gtk_container_add(GTK_CONTAINER(f1),vbox);
577 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
578 gtk_widget_show(vbox);
579
580 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
581 gtk_box_pack_start(GTK_BOX(vbox),scrolled_win,TRUE,TRUE,0);
582 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
583 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
584 gtk_widget_show(scrolled_win);
585
586 titles[0] = "";
587 titles[1] = _("Tracks");
588 list = gtk_clist_new_with_titles(2,titles);
589 gtk_container_add (GTK_CONTAINER (scrolled_win), list);
590 gtk_widget_realize(list);
591 clist = GTK_CLIST(list);
592 cdlist = clist;
593 gtk_signal_connect(GTK_OBJECT(clist), "select_row",
594 GTK_SIGNAL_FUNC(read_select_row),NULL);
595 gtk_signal_connect(GTK_OBJECT(clist), "unselect_row",
596 GTK_SIGNAL_FUNC(read_select_row),NULL);
597 gtk_clist_set_column_width(cdlist, 0, 16);
598 gtk_clist_set_column_auto_resize(cdlist, 1, TRUE);
599 if (setupdata.option_selectionmode == 0) {
600 gtk_clist_set_selection_mode (clist, GTK_SELECTION_MULTIPLE);
601 } else {
602 gtk_clist_set_selection_mode (clist, GTK_SELECTION_EXTENDED);
603 }
604 gtk_widget_show(list);
605
606 tbl = gtk_table_new(2,8,TRUE);
607 gtk_table_set_row_spacings(GTK_TABLE(tbl),10);
608 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
609 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,10);
610 gtk_widget_show(tbl);
611
612 l1 = rightjust_gtk_label_new(_("Label:"));
613 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,0,1);
614 gtk_widget_show(l1);
615
616 e1 = gtk_entry_new();
617 cdlist_l1 = e1;
618 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
619 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,0,1);
620 gtk_widget_show(e1);
621 l1 = rightjust_gtk_label_new(_("Selected:"));
622 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,1,2);
623 gtk_widget_show(l1);
624
625 e1 = gtk_entry_new();
626 cdlist_l2 = e1;
627 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
628 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,1,2);
629 gtk_widget_show(e1);
630
631 /* right info frame */
632 vbox = gtk_vbox_new(FALSE,0);
633 gtk_container_add(GTK_CONTAINER(f2),vbox);
634 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
635 gtk_widget_show(vbox);
636
637 tbl = gtk_table_new(4,8,TRUE);
638 gtk_table_set_row_spacings(GTK_TABLE(tbl),10);
639 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
640 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,10);
641 gtk_widget_show(tbl);
642
643 l1 = rightjust_gtk_label_new(_("File prefix:"));
644 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4,0,1);
645 gtk_widget_show(l1);
646
647 e1 = gtk_entry_new();
648 imglist_l1 = e1;
649 gtk_signal_connect(GTK_OBJECT(e1), "activate",
650 GTK_SIGNAL_FUNC(set_image_prefix_callback),NULL);
651 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,4,8,0,1);
652 gtk_widget_show(e1);
653 define_tooltip(e1, _("This is the prefix of the filenames of the tracks saved to the harddrive."));
654
655 l1 = rightjust_gtk_label_new(_("Free space:"));
656 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4,1,2);
657 gtk_widget_show(l1);
658
659 e1 = gtk_entry_new();
660 imglist_l2 = e1;
661 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
662 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,4,8,1,2);
663 gtk_widget_show(e1);
664
665 l1 = leftjust_gtk_label_new(_("biggest available block of that:"));
666 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,1,8,2,3);
667 gtk_widget_show(l1);
668
669 e1 = gtk_entry_new();
670 imglist_l3 = e1;
671 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
672 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,4,8,3,4);
673 gtk_widget_show(e1);
674
675 /* options frame */
676 vbox = gtk_vbox_new(FALSE,0);
677 gtk_container_add(GTK_CONTAINER(f3),vbox);
678 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
679 gtk_widget_show(vbox);
680
681 tbl = gtk_table_new(1,8,TRUE);
682 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
683 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,10);
684 gtk_widget_show(tbl);
685
686 check = gtk_check_button_new_with_label(_("Do index scan"));
687 gtk_signal_connect(GTK_OBJECT(check),"clicked",
688 GTK_SIGNAL_FUNC(readoptions_selected),GINT_TO_POINTER(0));
689 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,8,0,1);
690 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
691 curset.indexscan);
692 define_tooltip(check, _("Scan the CD for indexes. If this option is enabled the copy will contain the same track indexes as the original CD. Please note that some drives may need a little time to scan."));
693 gtk_widget_show(check);
694
695 gtk_widget_show(actionspace);
696
697 /* fill entries */
698 fill_read_tracks(0);
699 }
700
701
702 /* fill the entries in the verify_tracks_menu */
703
fill_verify_tracks(gint dontupdateimglist)704 void fill_verify_tracks(gint dontupdateimglist) {
705 gchar tmp[MAXLINE], tmp2[MAXLINE];
706 gchar titlestr[MAXLINE];
707 GList *loop;
708 GtkStyle *style;
709 gchar *data[2];
710 GdkPixmap *pixmap1, *pixmap2, *pixmap3;
711 GdkBitmap *mask1, *mask2, *mask3;
712 gchar basename[MAXLINE], imgdir[MAXLINE], fname[MAXLINE], *p;
713 gint lcount, count;
714 image_files_t *entry;
715
716
717 /* update cd-info */
718 if (curset.reader_devnr != -1) {
719 get_cd_toc_and_volid(curset.reader_devnr);
720 }
721
722 /* cd loaded? */
723 if (cdinfo.nr_tracks == -1) {
724 gtk_entry_set_text(GTK_ENTRY(vrylist_l1), _("No CD loaded"));
725 gtk_entry_set_text(GTK_ENTRY(vrylist_l2),"");
726 gtk_entry_set_text(GTK_ENTRY(vrylist_l3),"");
727 gtk_entry_set_text(GTK_ENTRY(vrylist_l4),"");
728 }
729 if (cdinfo.nr_tracks == -2) {
730 gtk_entry_set_text(GTK_ENTRY(vrylist_l1), return_media_type(curset.reader_devnr));
731 gtk_entry_set_text(GTK_ENTRY(vrylist_l2),"");
732 gtk_entry_set_text(GTK_ENTRY(vrylist_l3),"");
733 gtk_entry_set_text(GTK_ENTRY(vrylist_l4),"");
734 }
735
736 if (cdinfo.nr_tracks > 0) {
737 /* cd-type */
738 determine_cd_type(tmp,0);
739 gtk_entry_set_text(GTK_ENTRY(vrylist_l1), tmp);
740
741 /* cd-label */
742 if (cdinfo.title && cdinfo.artist &&
743 cdinfo.title[0] != '\0' && setupdata.option_displaycdtext) {
744 g_snprintf(tmp,MAXLINE,"%s / %s", cdinfo.title, cdinfo.artist);
745 gtk_entry_set_text(GTK_ENTRY(vrylist_l2), tmp);
746 gtk_entry_set_position(GTK_ENTRY(vrylist_l2),0);
747 } else
748 if (cdinfo.cddb_dtitle != NULL) {
749 gtk_entry_set_text(GTK_ENTRY(vrylist_l2), cdinfo.cddb_dtitle);
750 gtk_entry_set_position(GTK_ENTRY(vrylist_l2),0);
751 } else {
752 gtk_entry_set_text(GTK_ENTRY(vrylist_l2),"");
753 }
754
755 /* cd-size */
756 convert_frames2mbminstring(cdinfo.total_size, tmp);
757 gtk_entry_set_text(GTK_ENTRY(vrylist_l3), tmp);
758
759 /* nr tracks */
760 g_snprintf(tmp,MAXLINE,"%d",cdinfo.nr_tracks);
761 gtk_entry_set_text(GTK_ENTRY(vrylist_l4), tmp);
762 }
763
764 /* now draw image-list */
765 if (dontupdateimglist) return;
766
767 /* clean up first */
768 gtk_clist_clear(imglist);
769
770 style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(imglist)));
771 pixmap1 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
772 &mask1, &style->bg[GTK_STATE_NORMAL],(gchar **)minidata_xpm);
773 pixmap2 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
774 &mask2, &style->bg[GTK_STATE_NORMAL],(gchar **)miniaudio_xpm);
775 pixmap3 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
776 &mask3, &style->bg[GTK_STATE_NORMAL],(gchar **)mininodata_xpm);
777
778
779 data[0] = NULL;
780 strcpy(imgdir,"");
781 count = 1;
782 lcount = 0;
783
784 /* check image-selector */
785 if (curset.image_index != -1) {
786 /* no automatic setting? */
787 strncpy(imgdir,(gchar *)g_list_nth_data(setupdata.image_dirs,
788 curset.image_index), MAXLINE);
789 }
790
791 loop = g_list_first(imagelist);
792 while (loop) {
793 entry = loop->data;
794
795 /* get the base-dirname */
796 strncpy(basename,entry->path,MAXLINE);
797 p = rindex(basename,'/');
798 *p = '\0';
799 if (strcmp(basename,"") == 0) {
800 strcpy(basename,"/");
801 }
802 strcpy(fname, p+1);
803
804 if (strcmp(basename,imgdir) != 0 && imgdir[0] != '\0') {
805 /* skip not selected dirs */
806 loop = loop->next;
807 continue;
808 }
809
810 if (entry->readable == 0) {
811 /* dont display not readable files */
812 loop = loop->next;
813 continue;
814 }
815
816 strcpy(titlestr,"");
817 assign_trackname(titlestr, entry);
818
819 /* no title found - so use filename as title */
820 if (strcmp(titlestr,"") == 0) {
821 strcpy(titlestr,fname);
822 }
823
824 /* iso9600-track/ unknown */
825 if (entry->type == 0 || entry->type == 3) {
826 convert_frames2mbstring((gint)((off_t)entry->size/DATASECTORSIZE),
827 tmp2);
828 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
829 count, titlestr, tmp2);
830 data[1] = convert_for_gtk2(tmp);
831 gtk_clist_append(imglist,data);
832 if (entry->type == 0) {
833 gtk_clist_set_pixmap(imglist,lcount,0,pixmap1,mask1);
834 } else {
835 gtk_clist_set_pixmap(imglist,lcount,0,pixmap3,mask3);
836 }
837 count++;
838 lcount++;
839 }
840
841 /* valid wav-file */
842 if (entry->type == 1) {
843 convert_frames2minstring((gint)((off_t)entry->size/CDDAFRAME), tmp2);
844 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
845 count, titlestr, tmp2);
846 data[1] = convert_for_gtk2(tmp);
847 gtk_clist_append(imglist,data);
848 gtk_clist_set_pixmap(imglist,lcount,0,pixmap2,mask2);
849 lcount++;
850 count++;
851 }
852
853 loop = loop->next;
854 }
855
856 /* nothing selected - no size of files */
857 convert_kbytes2mbminstring(0, tmp);
858 gtk_entry_set_text(GTK_ENTRY(imglist_l1), tmp);
859 }
860
861
862 /* find out which trackfilename is in which row */
863 /* this is a little complicated because I have to recreate the
864 exact order of tracks as they are filled by fill_verify_tracks */
865
get_trackname_from_row(gint row,gchar * tname)866 static gint get_trackname_from_row(gint row, gchar *tname) {
867 GList *loop;
868 image_files_t *entry;
869 gint count;
870 gchar basename[MAXLINE], imgdir[MAXLINE], fname[MAXLINE], *p;
871
872 strcpy(imgdir,"");
873 count = 0;
874
875 /* check image-selector */
876 if (curset.image_index != -1) {
877 /* no automatic setting? */
878 strncpy(imgdir,(gchar *)g_list_nth_data(setupdata.image_dirs,
879 curset.image_index), MAXLINE);
880 }
881
882 loop = g_list_first(imagelist);
883 while (loop) {
884 entry = loop->data;
885
886 /* get the base-dirname */
887 strncpy(basename,entry->path,MAXLINE);
888 p = rindex(basename,'/');
889 *p = '\0';
890 if (strcmp(basename,"") == 0) {
891 strcpy(basename,"/");
892 }
893 strcpy(fname, p+1);
894
895 if (strcmp(basename,imgdir) != 0 && imgdir[0] != '\0') {
896 /* skip not selected dirs */
897 loop = loop->next;
898 continue;
899 }
900
901 if (entry->readable == 0) {
902 /* dont display not readable files */
903 loop = loop->next;
904 continue;
905 }
906
907 if (entry->type == 0 || entry->type == 3 || entry->type == 1) {
908
909 /* matching row found */
910 if (count == row) {
911 strcpy(tname, entry->path);
912 return 0;
913 }
914 count++;
915 }
916
917 loop = loop->next;
918 }
919
920 /* no match */
921 return 1;
922 }
923
924
925 /* update currently selected track-sizes */
926
update_verify_size(gint clickrow)927 static void update_verify_size(gint clickrow) {
928 GList *sel;
929 gint row;
930 gint sizecount;
931 gchar tmp[MAXLINE];
932
933 sizecount = 0;
934
935 /* loop through all selected tracks */
936 sel = imglist->selection;
937 while (sel) {
938 row = GPOINTER_TO_INT(sel->data);
939 if (get_trackname_from_row(row, tmp) == 0) {
940 /* we get now the full track-filename in tmp */
941 /* now get its size (in bytes) */
942 sizecount+=(gint) ((off_t)get_size_from_imagelist(tmp) >>10);
943 }
944 sel = sel->next;
945 }
946 convert_kbytes2mbminstring(sizecount, tmp);
947 gtk_entry_set_text(GTK_ENTRY(imglist_l1), tmp);
948 }
949
950
951 /* callbacks for verify menu */
952
verifysometracks_clicked(GtkWidget * widget,gpointer data)953 static void verifysometracks_clicked(GtkWidget *widget, gpointer data) {
954 track_read_param_t *trackparam;
955 GList *sellist;
956 gfloat per;
957 gint tcount, sizecount,nrtracks;
958 gint tracknr, size, type, sectorstoread;
959 GList *sel;
960 gint row, stat, stat2, abort;
961 gchar tmp[MAXLINE];
962 gchar volname[MAXLINE];
963 gchar *cell;
964 gchar *pt;
965
966 /* no cd-reader defined */
967 if (curset.reader_devnr == -1) {
968 show_dialog(ICO_ERROR,_("No CD-Reader defined in Setup"), T_OK, NULL, NULL, 0);
969 return;
970 }
971 /* now check if our cd-information is still valid */
972 get_cd_toc_and_volid(curset.reader_devnr);
973 /* update screen ... */
974 fill_verify_tracks(1);
975
976 /* cd loaded? */
977 if (cdinfo.nr_tracks < 0) {
978 show_dialog(ICO_WARN,_("No CD loaded in read device"),T_OK,NULL,NULL,0);
979 return;
980 }
981
982 sizecount = 0;
983 nrtracks = 0;
984 /* loop through all selected tracks to get number */
985 sel = imglist->selection;
986 while (sel) {
987 row = GPOINTER_TO_INT(sel->data);
988 nrtracks++;
989 sel = sel->next;
990 }
991
992 /* no tracks selected */
993 if (nrtracks == 0) {
994 show_dialog(ICO_WARN,_("No tracks selected"),T_OK,NULL,NULL,0);
995 return;
996 }
997
998 /* check if all the tracks selected match the current cd */
999 abort = 0;
1000 sellist = NULL;
1001 sel = imglist->selection;
1002 while (sel) {
1003 row = GPOINTER_TO_INT(sel->data);
1004 if (get_trackname_from_row(row, tmp) == 0) {
1005 /* we get now the full track-filename in tmp */
1006 /* check if track can be verified */
1007 stat = check_vrfy_track(tmp);
1008 stat2 = 0;
1009
1010 /* get image-title from list */
1011 gtk_clist_get_text(imglist,row,1,&cell);
1012
1013 if (stat == 0) {
1014 /* all ok */
1015 sel = sel->next;
1016 continue;
1017 }
1018
1019 if (stat == 1) {
1020 /* no info file */
1021
1022 /* perhaps its a self-mastered track? */
1023 if (get_volname_from_imagelist(tmp,volname) == 0) {
1024 if (cdinfo.nr_tracks == 1) {
1025 pt = trackinfo[0]->volname;
1026 if (pt) {
1027 if (strcmp(volname,pt) == 0) {
1028 /* ah nice, the isoname of the track does match the CD - allow verifying */
1029 sel = sel->next;
1030 continue;
1031 }
1032 } else {
1033 /* special case, no volname at all set by both */
1034 if (strcmp(volname,"") == 0) {
1035 sel = sel->next;
1036 continue;
1037 }
1038 }
1039
1040 }
1041 }
1042
1043 g_snprintf(tmp,MAXLINE,_("No Info-file found for track \"%s\".\nTherefore verification is impossible.\nUnselecting this track..."),cell);
1044 stat2 = show_dialog(ICO_WARN,tmp,T_OK,T_CANCEL,_("Verify anyway"),0);
1045 }
1046 if (stat == 2) {
1047 /* track does not match to cd */
1048 g_snprintf(tmp,MAXLINE,_("Track \"%s\" does\nnot fit to the currently inserted CD. Therefore verification\nis impossible. Unselecting this track..."),cell);
1049 stat2 = show_dialog(ICO_WARN,tmp,T_OK,T_CANCEL,NULL,0);
1050 }
1051 if (stat == 3) {
1052 /* dont verify audio */
1053 g_snprintf(tmp,MAXLINE,_("Can't verify audio track \"%s\"\nbecause you choose not to verify audio tracks.\nUnselecting this track..."),cell);
1054 stat2 = show_dialog(ICO_WARN,tmp,T_OK,T_CANCEL,NULL,0);
1055 }
1056
1057 /* aborting selected */
1058 if (stat2 == 1) {
1059 abort = 1;
1060 break;
1061 }
1062
1063 /* no info file, but verify anyway */
1064 if (stat2 == 2) {
1065 sel = sel->next;
1066 continue;
1067 }
1068
1069 /* save track nr - we are not allowed to
1070 unselect tracks while we parsing the
1071 selection itself */
1072 sellist = g_list_append(sellist, GINT_TO_POINTER(row));
1073 }
1074 sel = sel->next;
1075 }
1076
1077 /* unselect all not fitting tracks */
1078 sel = g_list_first(sellist);
1079 while (sel) {
1080 row = GPOINTER_TO_INT(sel->data);
1081 gtk_clist_unselect_row(imglist, row, 0);
1082 sel = sel->next;
1083 }
1084 g_list_free(sellist);
1085
1086 /* user aborted? */
1087 if (abort) return;
1088
1089 /* now check if any tracks are still selected */
1090 /* and calculate sum of size */
1091 sizecount = 0;
1092 nrtracks = 0;
1093 /* loop through all selected tracks to get number */
1094 sel = imglist->selection;
1095 while (sel) {
1096 row = GPOINTER_TO_INT(sel->data);
1097 if (get_trackname_from_row(row, tmp) == 0) {
1098 /* we get now the full track-filename in tmp */
1099 /* now get its size (in bytes) */
1100 sizecount+=(gint) ((off_t)get_size_from_imagelist(tmp) >> 10);
1101 }
1102 nrtracks++;
1103 sel = sel->next;
1104 }
1105
1106 /* no tracks selected */
1107 if (nrtracks == 0) {
1108 show_dialog(ICO_WARN,_("No tracks selected"),T_OK,NULL,NULL,0);
1109 return;
1110 }
1111
1112 /* so...if we are here, we have at least one selected track
1113 that matches our CD */
1114
1115 /* free structure first */
1116 clear_trackreadset();
1117
1118 /* fill structure */
1119 trackreadset.nrtracks = nrtracks;
1120
1121 tcount = 0;
1122 sel = imglist->selection;
1123 while (sel) {
1124 row = GPOINTER_TO_INT(sel->data);
1125
1126 if (get_trackname_from_row(row, tmp) != 0) {
1127 sel = sel->next; continue;
1128 }
1129 /* we get now the full track-filename in tmp */
1130
1131 tracknr = get_tracknr_from_imagelist(tmp);
1132 if (get_type_from_imagelist(tmp) == 1) {
1133 /* audio */
1134 type = 1;
1135 } else {
1136 /* data */
1137 type = 0;
1138 }
1139 size = (gint) ((off_t)get_size_from_imagelist(tmp) >> 10);
1140
1141 /* no info-file, therefore tracknr 0 */
1142 if (tracknr == 0) {
1143 /* we can only guess what the track could be -
1144 track 1 seems to be the most sensible choice */
1145 tracknr = 1;
1146 }
1147
1148 /* allocate memory */
1149 trackparam = g_new0(track_read_param_t,1);
1150
1151 trackparam->trackinfo_index = tracknr-1;
1152 trackparam->starttrack = tracknr;
1153 trackparam->endtrack = 0;
1154 trackparam->tracktype = type;
1155 per = (gfloat)size / sizecount;
1156 trackparam->percent = per;
1157 g_free(trackparam->trackfile);
1158 trackparam->trackfile = g_strdup(tmp);
1159
1160 if (type == 0) {
1161 /* data track */
1162 trackparam->kbyte = trackinfo[tracknr-1]->size *
1163 (DATASECTORSIZE/1024);
1164 trackparam->frames = trackinfo[tracknr-1]->size;
1165 trackparam->startoffset = trackinfo[tracknr-1]->start_sec;
1166 if (tracknr-1 == cdinfo.nr_tracks-1) {
1167 /* last track - leadout is track-end */
1168 trackparam->endoffset = cdinfo.leadout - 2;
1169 } else {
1170 /* sub 150 (2 sec leadout),
1171 sub 2 (2 run out sectors) */
1172 trackparam->endoffset =
1173 trackinfo[tracknr]->start_sec -150-2;
1174 }
1175 /* now do a paranoia check */
1176 /* in some cases we skip to much of a track */
1177 sectorstoread = trackparam->endoffset -
1178 trackparam->startoffset;
1179 if (sectorstoread < trackinfo[tracknr-1]->isosize) {
1180 trackparam->endoffset =
1181 trackparam->startoffset +
1182 trackinfo[tracknr-1]->isosize;
1183 trackparam->kbyte = trackinfo[tracknr-1]->isosize * 2;
1184 dodebug(1,"verifysometracks_clicked: corrected data track size from %d to %d sectors.\n", sectorstoread, trackinfo[tracknr-1]->isosize);
1185 }
1186 } else {
1187 /* audio */
1188 trackparam->kbyte = trackinfo[tracknr-1]->size *
1189 CDDAFRAME/1024;
1190 trackparam->frames = trackinfo[tracknr-1]->size;
1191 }
1192
1193
1194 trackreadset.trackparams = g_list_append(
1195 trackreadset.trackparams, trackparam);
1196
1197 sel = sel->next;
1198 }
1199
1200 /* assign an empty toc-filename */
1201 g_free(trackreadset.tocfile);
1202 trackreadset.tocfile = g_strdup("");
1203
1204 /* now all parameters for verifying are set - lets begin */
1205 show_and_do_verify_tracks(curset.reader_devnr);
1206 }
1207
1208
verify_select_all(GtkWidget * widget,gpointer data)1209 static void verify_select_all(GtkWidget *widget, gpointer data) {
1210
1211 gtk_clist_select_all(imglist);
1212 }
1213
verify_select_none(GtkWidget * widget,gpointer data)1214 static void verify_select_none(GtkWidget *widget, gpointer data) {
1215
1216 gtk_clist_unselect_all(imglist);
1217 }
1218
verify_select_row(GtkWidget * clist,gint row,gint col,GdkEventButton * event,gpointer data)1219 static void verify_select_row(GtkWidget *clist, gint row, gint col,
1220 GdkEventButton *event, gpointer data) {
1221
1222 update_verify_size(row);
1223 }
1224
1225
1226 /* draw verify-tracks menu */
1227
draw_verify_tracks()1228 static void draw_verify_tracks() {
1229 GtkWidget *hbox, *vbox;
1230 GtkWidget *f1, *f2, *f3;
1231 GtkWidget *b1;
1232 GtkWidget *e1;
1233 GtkWidget *l1, *dummy;
1234 GtkWidget *tbl, *check;
1235 gchar *titles[2];
1236 GtkWidget *scrolled_win, *img_list;
1237
1238 /* prepare draw area */
1239 clear_actionspace();
1240
1241 f1 = gtk_frame_new(_("Devices-Setup"));
1242 set_font_and_color_frame(f1,BOLDFONT,NULL);
1243 gtk_box_pack_start(GTK_BOX(actionspace),f1,FALSE,FALSE,5);
1244 gtk_widget_show(f1);
1245
1246 tbl = gtk_table_new(2,16*4,TRUE);
1247 gtk_table_set_col_spacing(GTK_TABLE(tbl),4*4-1,5);
1248 gtk_table_set_col_spacing(GTK_TABLE(tbl),15*4-2,5);
1249 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
1250 gtk_container_add(GTK_CONTAINER(f1),tbl);
1251 gtk_widget_show(tbl);
1252
1253 devices_setup_read(0, tbl, 1);
1254 devices_setup_image(1, tbl);
1255
1256 /* left and right info-frames */
1257 tbl = gtk_table_new(1,2,TRUE);
1258 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
1259 gtk_box_pack_start(GTK_BOX(actionspace),tbl,TRUE,TRUE,10);
1260 gtk_widget_show(tbl);
1261 vbox = gtk_vbox_new(FALSE,10);
1262 gtk_table_attach_defaults(GTK_TABLE(tbl),vbox,0,1,0,1);
1263 if (!curset.isProDVD) {
1264 f1 = gtk_frame_new(_("CD-Information"));
1265 } else {
1266 f1 = gtk_frame_new(_("CD/DVD-Information"));
1267 }
1268 set_font_and_color_frame(f1,BOLDFONT,NULL);
1269 gtk_box_pack_start(GTK_BOX(vbox),f1,TRUE,TRUE,0);
1270 gtk_widget_show(f1);
1271 f3 = gtk_frame_new(_("Verify options"));
1272 set_font_and_color_frame(f3,BOLDFONT,NULL);
1273 gtk_box_pack_start(GTK_BOX(vbox),f3,FALSE,FALSE,0);
1274 gtk_widget_show(f3);
1275 f2 = gtk_frame_new(_("Tracks to verify"));
1276 set_font_and_color_frame(f2,BOLDFONT,NULL);
1277 gtk_table_attach_defaults(GTK_TABLE(tbl),f2,1,2,0,1);
1278 gtk_widget_show(f2);
1279 gtk_widget_show(vbox);
1280
1281 /* button bar at the bottom */
1282 hbox = gtk_hbox_new(FALSE,5);
1283 gtk_box_pack_start(GTK_BOX(actionspace),hbox,FALSE,TRUE,10);
1284 gtk_widget_show(hbox);
1285
1286 b1 = gtk_button_new_with_label(_("Select all"));
1287 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
1288 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
1289 GTK_SIGNAL_FUNC(verify_select_all), NULL);
1290 define_tooltip(b1,_("Selects all displayed images on the harddrive for verifying."));
1291 gtk_widget_show(b1);
1292
1293 b1 = gtk_button_new_with_label(_("Select none"));
1294 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
1295 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
1296 GTK_SIGNAL_FUNC(verify_select_none), NULL);
1297 define_tooltip(b1,_("Deselects all displayed images."));
1298 gtk_widget_show(b1);
1299
1300 dummy = gtk_label_new("");
1301 gtk_box_pack_start(GTK_BOX(hbox),dummy,FALSE,FALSE,10);
1302 gtk_widget_show(dummy);
1303
1304 b1 = gtk_button_new_with_label(_("Verify selected tracks"));
1305 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
1306 gtk_widget_show(b1);
1307 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
1308 GTK_SIGNAL_FUNC(verifysometracks_clicked), NULL);
1309 define_tooltip(b1,_("If the images do match the currently inserted CD, start to read the images again and compare them with their copies on the harddrive."));
1310
1311 /* left info frame */
1312 vbox = gtk_vbox_new(FALSE,0);
1313 gtk_container_add(GTK_CONTAINER(f1),vbox);
1314 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
1315 gtk_widget_show(vbox);
1316
1317 tbl = gtk_table_new(4,8,TRUE);
1318 gtk_table_set_row_spacings(GTK_TABLE(tbl),10);
1319 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
1320 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,10);
1321 gtk_widget_show(tbl);
1322
1323 l1 = rightjust_gtk_label_new(_("Type:"));
1324 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,0,1);
1325 gtk_widget_show(l1);
1326
1327 e1 = gtk_entry_new();
1328 vrylist_l1 = e1;
1329 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1330 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,0,1);
1331 gtk_widget_show(e1);
1332
1333 l1 = rightjust_gtk_label_new(_("Label:"));
1334 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,1,2);
1335 gtk_widget_show(l1);
1336
1337 e1 = gtk_entry_new();
1338 vrylist_l2 = e1;
1339 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1340 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,1,2);
1341 gtk_widget_show(e1);
1342
1343 l1 = rightjust_gtk_label_new(_("Size:"));
1344 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,2,3);
1345 gtk_widget_show(l1);
1346
1347 e1 = gtk_entry_new();
1348 vrylist_l3 = e1;
1349 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1350 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,2,3);
1351 gtk_widget_show(e1);
1352
1353 l1 = rightjust_gtk_label_new(_("Tracks:"));
1354 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,3,4);
1355 gtk_widget_show(l1);
1356
1357 e1 = gtk_entry_new();
1358 vrylist_l4 = e1;
1359 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1360 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,3,4);
1361 gtk_widget_show(e1);
1362
1363 /* options frame */
1364 vbox = gtk_vbox_new(FALSE,0);
1365 gtk_container_add(GTK_CONTAINER(f3),vbox);
1366 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
1367 gtk_widget_show(vbox);
1368
1369 tbl = gtk_table_new(2,8,TRUE);
1370 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
1371 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,10);
1372 gtk_widget_show(tbl);
1373
1374 check = gtk_check_button_new_with_label(_("Don't verify audio tracks"));
1375 gtk_signal_connect(GTK_OBJECT(check),"clicked",
1376 GTK_SIGNAL_FUNC(verifyoptions_selected),GINT_TO_POINTER(0));
1377 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,8,0,1);
1378 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
1379 curset.noaudioverify);
1380 gtk_widget_show(check);
1381 define_tooltip(check, _("Skips verification of audio tracks, because a lot of CD readers are not able to read audio data reliably."));
1382
1383 check = gtk_check_button_new_with_label(_("Abort after verify fail"));
1384 gtk_signal_connect(GTK_OBJECT(check),"clicked",
1385 GTK_SIGNAL_FUNC(verifyoptions_selected),GINT_TO_POINTER(1));
1386 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,8,1,2);
1387 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
1388 curset.verifyfailabort);
1389 gtk_widget_show(check);
1390 define_tooltip(check, _("Abort Verifying when one mismatch was found. Otherwise X-CD-Roast does continue to verify the other tracks anyway."));
1391
1392 /* right frame */
1393 vbox = gtk_vbox_new(FALSE,0);
1394 gtk_container_add(GTK_CONTAINER(f2),vbox);
1395 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
1396 gtk_widget_show(vbox);
1397
1398 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1399 gtk_box_pack_start(GTK_BOX(vbox),scrolled_win,TRUE,TRUE,0);
1400 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1401 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
1402 gtk_widget_show(scrolled_win);
1403
1404 titles[0] = g_strdup("");
1405 titles[1] = _("Images");
1406 img_list = gtk_clist_new_with_titles(2,titles);
1407 gtk_container_add (GTK_CONTAINER (scrolled_win), img_list);
1408 imglist = GTK_CLIST(img_list);
1409 gtk_signal_connect(GTK_OBJECT(imglist), "select_row",
1410 GTK_SIGNAL_FUNC(verify_select_row),NULL);
1411 gtk_signal_connect(GTK_OBJECT(imglist), "unselect_row",
1412 GTK_SIGNAL_FUNC(verify_select_row),NULL);
1413 gtk_clist_set_column_width(imglist, 0, 16);
1414 gtk_clist_set_column_auto_resize(imglist, 1, TRUE);
1415 if (setupdata.option_selectionmode == 0) {
1416 gtk_clist_set_selection_mode (imglist, GTK_SELECTION_MULTIPLE);
1417 } else {
1418 gtk_clist_set_selection_mode (imglist, GTK_SELECTION_EXTENDED);
1419 }
1420 gtk_widget_show(img_list);
1421 gtk_widget_realize(img_list);
1422
1423 tbl = gtk_table_new(1,8,TRUE);
1424 gtk_table_set_row_spacings(GTK_TABLE(tbl),10);
1425 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
1426 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,10);
1427 gtk_widget_show(tbl);
1428
1429 l1 = rightjust_gtk_label_new(_("Selected:"));
1430 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,0,1);
1431 gtk_widget_show(l1);
1432
1433 e1 = gtk_entry_new();
1434 imglist_l1 = e1;
1435 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1436 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,0,1);
1437 gtk_widget_show(e1);
1438
1439 gtk_widget_show(actionspace);
1440
1441 /* fill entries */
1442 fill_verify_tracks(0);
1443 }
1444
1445
1446 /* callback for write button */
1447
writesometracks_clicked(GtkWidget * widget,gpointer data)1448 static void writesometracks_clicked(GtkWidget *widget, gpointer data) {
1449 gint ret, stat;
1450 gint spaceneededoncd;
1451 gint64 tmpsize, tmpsize2;
1452 gchar tmptoc[MAXLINE];
1453 GList *loop;
1454 track_read_param_t *trackparam;
1455 gint cdsize, avail, found;
1456 gint msinfo1, msinfo2, m1, m2;
1457 gint msdisk1, msdisk2;
1458 gint founddata, foundaudio;
1459
1460 /* no cd-writer defined */
1461 if (curset.writer_devnr == -1) {
1462 show_dialog(ICO_ERROR,_("No CD-Writer defined in Setup"), T_OK, NULL, NULL, 0);
1463 return;
1464 }
1465
1466 /* see if we have anything selected at all */
1467 if (g_list_first(trackreadset.trackparams) == NULL) {
1468 show_dialog(ICO_WARN,_("No Tracks layouted for writing"),T_OK,NULL,NULL,0);
1469 return;
1470 }
1471
1472 msinfo1 = -1;
1473 msinfo2 = -1;
1474
1475 /* count what type of tracks we are handling */
1476 foundaudio = 0;
1477 founddata = 0;
1478 loop = g_list_first(trackreadset.trackparams);
1479 while(loop) {
1480 trackparam = loop->data;
1481 if (trackparam->trackfile != NULL) {
1482 if (trackparam->tracktype == 0)
1483 founddata++;
1484 if (trackparam->tracktype == 1)
1485 foundaudio++;
1486 }
1487 loop = loop->next;
1488 }
1489
1490 /* in multisession mode allow only to write one track at a time */
1491 if (curset.multisession == 1) {
1492
1493 /* allow only one data and no mixed tracks */
1494 if (founddata > 1) {
1495 show_dialog(ICO_WARN,_("In multi session mode only one data track can be written at a time."),T_OK,NULL,NULL,0);
1496 return;
1497 }
1498 if (founddata > 0 && foundaudio > 0) {
1499 show_dialog(ICO_WARN,_("In multi session mode you can't write both audio\nand data tracks at the same time."),T_OK,NULL,NULL,0);
1500 return;
1501 }
1502
1503 /* another sanity check */
1504 if (curset.nofixate == 1) {
1505 ret = show_dialog(ICO_WARN,_("In multi session mode it is not recommended to use\nthe \"do not fixate\" option. If you continue you will\ncreate an unreadable CD."),T_ANYWAY,T_CANCEL,NULL,1);
1506 if (ret == 1) {
1507 return;
1508 }
1509 }
1510
1511 /* ok, one file to write...get msinfo data */
1512 loop = g_list_first(trackreadset.trackparams);
1513 trackparam = loop->data;
1514 if (trackparam->trackfile != NULL
1515 && trackparam->tracktype == 0) {
1516 get_msinfo_from_imagelist(trackparam->trackfile,
1517 &msinfo1, &msinfo2);
1518 dodebug(2,"got msinfo: %d,%d from inf-file: %s\n", msinfo1, msinfo2, trackparam->trackfile);
1519 }
1520 } else {
1521 /* no multisession.. */
1522 /* see if there is a track in the list that requires
1523 multisession */
1524 found = 0;
1525 loop = g_list_first(trackreadset.trackparams);
1526 while(loop) {
1527 trackparam = loop->data;
1528 if (trackparam->trackfile != NULL) {
1529 get_msinfo_from_imagelist(trackparam->trackfile,
1530 &m1, &m2);
1531 if (m1 >= 0 || m2 >= 0) {
1532 found = 1;
1533 }
1534 }
1535 loop = loop->next;
1536 }
1537
1538 /* warn about multisession */
1539 if (found) {
1540 ret = show_dialog(ICO_WARN,_("You are trying to write a multi session image\nwithout having multi session enabled.\nThis can result in an unreadable CD."),T_ANYWAY,T_CANCEL,NULL,1);
1541 if (ret == 1) {
1542 return;
1543 }
1544 }
1545 }
1546
1547 /* now check if the CD-R is the right one for our multisession
1548 needs */
1549 if (curset.multisession == 1) {
1550 get_cd_toc_and_volid(curset.writer_devnr);
1551 if (cdinfo.nr_tracks != -1) {
1552 get_msinfo_info(curset.writer_devnr,
1553 &msdisk1, &msdisk2);
1554 } else {
1555 /* no cd loaded? abort */
1556 show_dialog(ICO_WARN,_("A CD-R/RW is required in the CD-Writer before\na session can be added.\nPlease insert a CD-R/RW and try again."),T_OK,NULL,NULL,0);
1557 return;
1558 }
1559
1560 /* does the session info match to disk? (only for data tracks) */
1561 if ((msdisk1 != msinfo1 || msdisk2 != msinfo2) && founddata > 0) {
1562 ret = show_dialog(ICO_WARN,_("You are trying to write a session to a multi session CD,\nwhere the current sessions do not match.\nThis can result in an unreadable CD."), T_ANYWAY, T_CANCEL, NULL, 1);
1563 if (ret == 1) {
1564 return;
1565 }
1566 }
1567 }
1568
1569 tmpsize = (gint64)trackreadset.cdsize * 1024;
1570 spaceneededoncd = (gint) ((gint64)tmpsize/CDDAFRAME);
1571
1572 /* first check if all tracks we need are available on hd */
1573 /* dont check for file sizes, we assume the user did not
1574 modify them since the last update of the imagelist */
1575 stat = check_write_files(1);
1576 switch(stat) {
1577 /* files with wrong size */
1578 case 1:
1579 break;
1580 /* files missing */
1581 case 2:
1582 show_dialog(ICO_ERROR,_("Some of the image files you want to write are missing.\nPlease update the image directory."),T_OK,NULL,NULL,0);
1583 return;
1584
1585 /* no permission/invalid */
1586 case 3:
1587 show_dialog(ICO_ERROR,_("You don't have permission to read all the track-files or\nthe tracks are not regular files on the hard drive."),T_OK,NULL,NULL,0);
1588 return;
1589
1590 /* invalid isrc or mcn */
1591 case 4:
1592 ret = show_dialog(ICO_WARN,_("Some of the audio files you want to write have been recorded\nwith an invalid ISRC or MCN id. X-CD-Roast can clear these\ninvalid ids for you and continue or you have to abort now."),"Clear and continue",T_CANCEL,NULL,1);
1593 if (ret == 1) {
1594 /* abort */
1595 return;
1596 } else {
1597 /* clear ids */
1598 stat = clear_isrc_mcn_from_tracks();
1599 if (stat == 1) {
1600 /* error resetting ids */
1601 show_dialog(ICO_ERROR,_("Failed to clear the ISRC or MCN id in all tracks.\nPerhaps you have no write permission on the .inf files?\nPlease correct the problem and try again."),T_OK,NULL,NULL,0);
1602 return;
1603 }
1604 }
1605 break;
1606 }
1607
1608 /* check if enough space on cd-r? */
1609 dodebug(2,"Sectors required: %d, Mediatype = %d\n", spaceneededoncd,
1610 curset.cdrtype);
1611
1612 if (curset.cdrtype < 1000) {
1613 cdsize = curset.cdrtype*60*75;
1614 } else {
1615 /* capacity of a DVD in bytes */
1616 tmpsize2 = (gint64)curset.cdrtype * 1000 * 1000;
1617 /* and now in sectors */
1618 tmpsize2 = tmpsize2 / 2048;
1619
1620 cdsize = (gint) tmpsize2;
1621 }
1622 avail = cdsize;
1623
1624 /* we want to write multisession? consider session overhead */
1625 if (curset.multisession == 1) {
1626 if (cdinfo.nr_tracks > 0) {
1627 /* additional sessions */
1628 avail -= 6900; /* about 13 MB */
1629 } else {
1630 /* first session */
1631 avail -= 11400; /* about 22 MB */
1632 }
1633 }
1634
1635 if (spaceneededoncd > avail) {
1636 if (!is_dvdwriter(curset.writer_devnr)) {
1637 ret = show_dialog(ICO_WARN,_("There may be not enough space on the CD-R available.\nYou can continue at own risk, but the resulting CD\nmight not be readable."),T_ANYWAY,T_CANCEL,NULL,1);
1638 } else {
1639 /* perhaps we want to write a dvd? */
1640 ret = show_dialog(ICO_WARN,_("There may be not enough space on the CD-R available.\nPerhaps you want to write a DVD, but you have not selected\nthe correct media size? You can continue at own\nrisk, but the resulting CD might not be readable."),T_ANYWAY,T_CANCEL,NULL,1);
1641 }
1642 if (ret == 1) {
1643 /* aborted */
1644 return;
1645 }
1646 }
1647
1648 /* ok, now we are sure that all tracks are fine ...prompt for CD-R */
1649 if (curset.multisession == 0) {
1650 ret = show_dialog(ICO_INFO,pleaseinsertmedia(),T_OK,T_CANCEL,NULL,0);
1651 } else {
1652 /* multisession */
1653 if (msinfo2 > 0) {
1654 /* add new session */
1655 ret = show_dialog(ICO_INFO,_("Ready to add a new session to a multi session CD?"),T_OK,T_CANCEL,NULL,0);
1656 } else {
1657 /* write first session */
1658 ret = show_dialog(ICO_INFO,_("Ready to write the first session of a multi session CD?"),T_OK,T_CANCEL,NULL,0);
1659 }
1660 }
1661 if (ret != 0) {
1662 return;
1663 }
1664
1665 /* if we should write CD-Text then edit the .inf files from cdda2wav */
1666 if (curset.writecdtext) {
1667 loop = g_list_first(trackreadset.trackparams);
1668 while(loop) {
1669 trackparam = loop->data;
1670 if (trackparam->trackfile != NULL) {
1671 generate_tmp_tocfile_name(tmptoc);
1672 edit_xinf_for_cd_text(trackparam->trackfile,
1673 tmptoc);
1674 }
1675 loop = loop->next;
1676 }
1677
1678 }
1679
1680 /* start writing */
1681 show_and_do_write_tracks(curset.writer_devnr, -1, 0);
1682 }
1683
1684
1685 /* callback for fixate cdr */
1686
fixate_clicked(GtkWidget * widget,gpointer data)1687 static void fixate_clicked(GtkWidget *widget, gpointer data) {
1688 gint ret;
1689
1690 /* no cd-writer defined */
1691 if (curset.writer_devnr == -1) {
1692 show_dialog(ICO_ERROR,_("No CD-Writer defined in Setup"), T_OK, NULL, NULL, 0);
1693 return;
1694 }
1695
1696 /* prompt for CD-R */
1697 ret = show_dialog(ICO_INFO,pleaseinsertmedia(),T_OK,T_CANCEL,NULL,0);
1698 if (ret != 0) {
1699 return;
1700 }
1701
1702 /* start fixating */
1703 show_and_do_write_tracks(curset.writer_devnr, -1, 2);
1704 }
1705
1706
1707 /* redraw the selected-tracks list */
1708
redraw_writelist(GtkCList * llist,GtkWidget * lentry)1709 void redraw_writelist(GtkCList *llist, GtkWidget *lentry) {
1710 GList *loop;
1711 gchar *track;
1712 gchar tmp[MAXLINE];
1713 gchar tmp2[MAXLINE];
1714 gchar titlestr[MAXLINE];
1715 GtkStyle *style;
1716 gchar *data[2];
1717 GdkPixmap *pixmap1, *pixmap2, *pixmap3;
1718 GdkBitmap *mask1, *mask2, *mask3;
1719 gchar basename[MAXLINE], fname[MAXLINE], *p;
1720 image_files_t *entry;
1721 gint count,lcount;
1722 gint sizecount;
1723 gint toprow, topcol;
1724
1725 /* get current scroll position */
1726 if(!gtk_clist_get_selection_info(llist, 0, 0, &toprow, &topcol)) {
1727 toprow = 0;
1728 topcol = 0;
1729 }
1730
1731 /* clean up first */
1732 gtk_clist_freeze(llist);
1733 gtk_clist_clear(llist);
1734
1735 style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(imglist)));
1736 pixmap1 = gdk_pixmap_create_from_xpm_d(llist->clist_window,
1737 &mask1, &style->bg[GTK_STATE_NORMAL],(gchar **)minidata_xpm);
1738 pixmap2 = gdk_pixmap_create_from_xpm_d(llist->clist_window,
1739 &mask2, &style->bg[GTK_STATE_NORMAL],(gchar **)miniaudio_xpm);
1740 pixmap3 = gdk_pixmap_create_from_xpm_d(llist->clist_window,
1741 &mask3, &style->bg[GTK_STATE_NORMAL],(gchar **)mininodata_xpm);
1742
1743 data[0] = NULL;
1744 count = 1;
1745 lcount = 0;
1746 sizecount = 0;
1747
1748 loop = g_list_first(writelist);
1749 while (loop) {
1750 track = loop->data;
1751 entry = get_entry_from_imagelist(track);
1752 if (entry == NULL) {
1753 /* should never happen */
1754 loop = loop->next;
1755 continue;
1756 }
1757 /* get the base-dirname */
1758 strncpy(basename,entry->path,MAXLINE);
1759 p = rindex(basename,'/');
1760 *p = '\0';
1761 if (strcmp(basename,"") == 0) {
1762 strcpy(basename,"/");
1763 }
1764 strcpy(fname, p+1);
1765
1766 sizecount+=(gint) ((off_t)get_size_from_imagelist(track) >> 10);
1767 strcpy(titlestr,"");
1768 assign_trackname(titlestr, entry);
1769
1770 /* no title found - so use filename as title */
1771 if (strcmp(titlestr,"") == 0) {
1772 strcpy(titlestr,fname);
1773 }
1774
1775 /* iso9600-track/ unknown */
1776 if (entry->type == 0 || entry->type == 3) {
1777 convert_frames2mbstring((gint)((off_t)entry->size/DATASECTORSIZE),
1778 tmp2);
1779 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
1780 count, titlestr, tmp2);
1781 data[1] = convert_for_gtk2(tmp);
1782 gtk_clist_append(llist,data);
1783 if (entry->type == 0) {
1784 gtk_clist_set_pixmap(llist,lcount,0,pixmap1,mask1);
1785 } else {
1786 gtk_clist_set_pixmap(llist,lcount,0,pixmap3,mask3);
1787 }
1788 count++;
1789 lcount++;
1790 }
1791
1792 /* valid wav-file */
1793 if (entry->type == 1) {
1794 convert_frames2minstring((gint)((off_t)entry->size/CDDAFRAME), tmp2);
1795 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
1796 count, titlestr, tmp2);
1797 data[1] = convert_for_gtk2(tmp);
1798 gtk_clist_append(llist,data);
1799 gtk_clist_set_pixmap(llist,lcount,0,pixmap2,mask2);
1800 lcount++;
1801 count++;
1802 }
1803
1804 loop = loop->next;
1805 }
1806
1807 /* now scroll to remembered position */
1808 gtk_clist_moveto(llist, toprow, topcol, 0.0, 0.0);
1809 gtk_clist_thaw(llist);
1810
1811 convert_kbytes2mbminstring(sizecount, tmp);
1812 gtk_entry_set_text(GTK_ENTRY(lentry), tmp);
1813 }
1814
1815
1816 /* fill the tracks-to-write list */
1817
fill_writelist2(GtkCList * llist,GtkWidget * lentry)1818 void fill_writelist2(GtkCList *llist, GtkWidget *lentry) {
1819 GList *loop;
1820 track_read_param_t *trackparam;
1821 gchar track[MAXLINE];
1822 gchar tmp[MAXLINE];
1823 gchar tmp2[MAXLINE];
1824 gchar titlestr[MAXLINE];
1825 GtkStyle *style;
1826 gchar *data[2];
1827 GdkPixmap *pixmap1, *pixmap2, *pixmap3;
1828 GdkBitmap *mask1, *mask2, *mask3;
1829 gchar basename[MAXLINE], fname[MAXLINE], *p;
1830 image_files_t *entry;
1831 gint count,lcount;
1832 gint toprow, topcol;
1833
1834 /* get current scroll position */
1835 if(!gtk_clist_get_selection_info(llist, 0, 0, &toprow, &topcol)) {
1836 toprow = 0;
1837 topcol = 0;
1838 }
1839
1840 /* clean up first */
1841 gtk_clist_freeze(llist);
1842 gtk_clist_clear(llist);
1843
1844 style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(imglist)));
1845 pixmap1 = gdk_pixmap_create_from_xpm_d(llist->clist_window,
1846 &mask1, &style->bg[GTK_STATE_NORMAL],(gchar **)minidata_xpm);
1847 pixmap2 = gdk_pixmap_create_from_xpm_d(llist->clist_window,
1848 &mask2, &style->bg[GTK_STATE_NORMAL],(gchar **)miniaudio_xpm);
1849 pixmap3 = gdk_pixmap_create_from_xpm_d(llist->clist_window,
1850 &mask3, &style->bg[GTK_STATE_NORMAL],(gchar **)mininodata_xpm);
1851
1852 data[0] = NULL;
1853 count = 1;
1854 lcount = 0;
1855
1856 loop = g_list_first(trackreadset.trackparams);
1857 while (loop) {
1858 trackparam = loop->data;
1859
1860 strcpy(track, trackparam->trackfile);
1861
1862 entry = get_entry_from_imagelist(track);
1863 if (entry == NULL) {
1864 /* should never happen */
1865 loop = loop->next;
1866 continue;
1867 }
1868 /* get the base-dirname */
1869 strncpy(basename,track,MAXLINE);
1870 p = rindex(basename,'/');
1871 *p = '\0';
1872 if (strcmp(basename,"") == 0) {
1873 strcpy(basename,"/");
1874 }
1875 strcpy(fname, p+1);
1876
1877 strcpy(titlestr,"");
1878 assign_trackname(titlestr, entry);
1879
1880 /* no title found - so use filename as title */
1881 if (strcmp(titlestr,"") == 0) {
1882 strcpy(titlestr,fname);
1883 }
1884
1885 /* data */
1886 if (trackparam->tracktype == 0) {
1887 convert_frames2mbstring((gint)((off_t)entry->size/DATASECTORSIZE),
1888 tmp2);
1889 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
1890 count, titlestr, tmp2);
1891 data[1] = convert_for_gtk2(tmp);
1892 gtk_clist_append(llist,data);
1893 if (entry->type == 0) {
1894 gtk_clist_set_pixmap(llist,lcount,0,pixmap1,mask1);
1895 } else {
1896 gtk_clist_set_pixmap(llist,lcount,0,pixmap3,mask3);
1897 }
1898 count++;
1899 lcount++;
1900 }
1901
1902 /* valid wav-file */
1903 if (entry->type == 1) {
1904 convert_frames2minstring((gint)((off_t)entry->size/CDDAFRAME), tmp2);
1905 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
1906 count, titlestr, tmp2);
1907 data[1] = convert_for_gtk2(tmp);
1908 gtk_clist_append(llist,data);
1909 gtk_clist_set_pixmap(llist,lcount,0,pixmap2,mask2);
1910 lcount++;
1911 count++;
1912 }
1913
1914 loop = loop->next;
1915 }
1916
1917 /* now scroll to remembered position */
1918 gtk_clist_moveto(llist, toprow, topcol, 0.0, 0.0);
1919 gtk_clist_thaw(llist);
1920
1921 convert_kbytes2mbminstring(trackreadset.cdsize, tmp);
1922 gtk_entry_set_text(GTK_ENTRY(lentry), tmp);
1923 }
1924
1925
write_delete_tracks(GtkWidget * widget,gpointer data)1926 static void write_delete_tracks(GtkWidget *widget, gpointer data) {
1927 gint nrtracks;
1928 GList *sel, *loop, *loop2;
1929 gint row;
1930
1931 nrtracks = 0;
1932
1933 /* get the list of track-filenames to remove from the write-list */
1934 sel = cdlist->selection;
1935 while (sel) {
1936 row = GPOINTER_TO_INT(sel->data);
1937 loop = g_list_nth(g_list_first(writelist),row);
1938 if (loop && loop->data) {
1939 /* mark as deleted */
1940 g_free(loop->data);
1941 loop->data = NULL;
1942 }
1943 nrtracks++;
1944 sel = sel->next;
1945 }
1946
1947 /* no tracks selected */
1948 if (nrtracks == 0) {
1949 show_dialog(ICO_WARN,_("No tracks selected"),T_OK,NULL,NULL,0);
1950 return;
1951 }
1952
1953 /* now really remove from list */
1954 loop = g_list_first(writelist);
1955 while (loop) {
1956 loop2 = loop->next;
1957 if (loop->data == NULL) {
1958 writelist = g_list_remove_link(writelist, loop);
1959 }
1960 loop = loop2;
1961 }
1962
1963 redraw_writelist(cdlist,cdlist_l1);
1964 fill_write_tracks();
1965 }
1966
1967
write_add_tracks(GtkWidget * widget,gpointer data)1968 static void write_add_tracks(GtkWidget *widget, gpointer data) {
1969 gint nrtracks;
1970 GList *sel;
1971 gint row;
1972 gchar tmp[MAXLINE];
1973
1974 nrtracks = 0;
1975
1976 /* get the list of track-filenames to add to the write-list */
1977 sel = imglist->selection;
1978 while (sel) {
1979 row = GPOINTER_TO_INT(sel->data);
1980 if (get_trackname_from_row(row, tmp) == 0) {
1981 /* we get now the full track-filename in tmp */
1982 /* add to list */
1983 writelist = g_list_append(writelist,g_strdup(tmp));
1984 }
1985 nrtracks++;
1986 sel = sel->next;
1987 }
1988
1989 /* no tracks selected */
1990 if (nrtracks == 0) {
1991 show_dialog(ICO_WARN,_("No tracks selected"),T_OK,NULL,NULL,0);
1992 return;
1993 }
1994
1995 redraw_writelist(cdlist,cdlist_l1);
1996 fill_write_tracks();
1997 }
1998
1999
2000 /* accept tracklayout button */
2001
accept_layout_clicked(GtkWidget * widget,gpointer notebook)2002 static void accept_layout_clicked(GtkWidget *widget, gpointer notebook) {
2003 GList *loop;
2004 track_read_param_t *trackparam;
2005 gchar *track;
2006 gint count,cdsize;
2007 image_files_t *entry;
2008 gfloat per;
2009
2010 if (notebook) {
2011 /* see if we have anything selected at all */
2012 if (g_list_first(writelist) == NULL) {
2013 show_dialog(ICO_WARN,_("No Tracks layouted for writing"),T_OK,NULL,NULL,0);
2014 return;
2015 }
2016 }
2017
2018 /* fill the trackreadset with our tracks to write */
2019 /* clear first */
2020 clear_trackreadset();
2021
2022 cdsize = 0;
2023 count = 1;
2024
2025 loop = g_list_first(writelist);
2026 while (loop) {
2027 track = loop->data;
2028 entry = get_entry_from_imagelist(track);
2029 if (entry == NULL) {
2030 /* should never happen */
2031 loop = loop->next;
2032 continue;
2033 }
2034
2035 /* allocate memory */
2036 trackparam = g_new0(track_read_param_t,1);
2037
2038 trackparam->trackinfo_index = -1;
2039 trackparam->starttrack = count;
2040 trackparam->endtrack = 0;
2041 if (entry->type == 1) {
2042 /* audio */
2043 trackparam->tracktype = 1;
2044 trackparam->frames = (gint) ((off_t)entry->size/CDDAFRAME);
2045 } else {
2046 /* data */
2047 trackparam->tracktype = 0;
2048 trackparam->frames = (gint) ((off_t)entry->size/DATASECTORSIZE);
2049 }
2050 trackparam->kbyte = (gint) ((off_t)entry->size >> 10);
2051 g_free(trackparam->trackfile);
2052 trackparam->trackfile = g_strdup(track);
2053
2054 cdsize += trackparam->kbyte;
2055 trackreadset.nrtracks++;
2056 count++;
2057
2058 trackreadset.trackparams = g_list_append(
2059 trackreadset.trackparams, trackparam);
2060
2061 loop = loop->next;
2062 }
2063
2064 trackreadset.cdsize = cdsize;
2065
2066 /* ok..all data read - now calculate the percentages */
2067 loop = g_list_first(trackreadset.trackparams);
2068 while(loop) {
2069 trackparam = loop->data;
2070 per = (gfloat)trackparam->kbyte / cdsize;
2071 trackparam->percent = per;
2072
2073 loop = loop->next;
2074 }
2075
2076 if (debug > 1)
2077 print_trackreadset();
2078
2079 /* fill listing on page 1 */
2080 fill_writelist2(imglist2,imglist_l2);
2081
2082 if (notebook) {
2083 /* now change notebook tab back to page 1 */
2084 gtk_notebook_set_page(GTK_NOTEBOOK(notebook), 1);
2085 }
2086 }
2087
2088
2089 /* called when you change tabs in the write tracks menu */
2090 /* detect when switching from layout to view mode */
2091
writetracks_notebookswitch(GtkWidget * widget,GtkNotebookPage * page,gint page_num)2092 static void writetracks_notebookswitch(GtkWidget *widget, GtkNotebookPage *page, gint page_num) {
2093 gint curpage;
2094
2095 curpage = gtk_notebook_get_current_page(GTK_NOTEBOOK(widget));
2096
2097 /* user clicked "write tracks" while in "layout tracks" */
2098 if (curpage == 0 && page_num == 1) {
2099 /* simulate click on accept layout */
2100 accept_layout_clicked(widget, NULL);
2101 }
2102 }
2103
2104
fill_write_tracks()2105 void fill_write_tracks() {
2106 gchar tmp[MAXLINE], tmp2[MAXLINE];
2107 gchar titlestr[MAXLINE];
2108 GList *loop;
2109 GtkStyle *style;
2110 gchar *data[2];
2111 GdkPixmap *pixmap1, *pixmap2, *pixmap3;
2112 GdkBitmap *mask1, *mask2, *mask3;
2113 gchar basename[MAXLINE], imgdir[MAXLINE], fname[MAXLINE], *p;
2114 gint lcount, count;
2115 image_files_t *entry;
2116 gint toprow, topcol;
2117
2118 /* get current scroll position */
2119 if(!gtk_clist_get_selection_info(imglist, 0, 0, &toprow, &topcol)) {
2120 toprow = 0;
2121 topcol = 0;
2122 }
2123
2124 /* clean up first */
2125 gtk_clist_freeze(imglist);
2126 gtk_clist_clear(imglist);
2127
2128 style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(imglist)));
2129 pixmap1 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
2130 &mask1, &style->bg[GTK_STATE_NORMAL],(gchar **)minidata_xpm);
2131 pixmap2 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
2132 &mask2, &style->bg[GTK_STATE_NORMAL],(gchar **)miniaudio_xpm);
2133 pixmap3 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
2134 &mask3, &style->bg[GTK_STATE_NORMAL],(gchar **)mininodata_xpm);
2135
2136 data[0] = NULL;
2137 strcpy(imgdir,"");
2138 count = 1;
2139 lcount = 0;
2140
2141 /* check image-selector */
2142 if (curset.image_index != -1) {
2143 /* no automatic setting? */
2144 strncpy(imgdir,(gchar *)g_list_nth_data(setupdata.image_dirs,
2145 curset.image_index), MAXLINE);
2146 }
2147
2148 loop = g_list_first(imagelist);
2149 while (loop) {
2150 entry = loop->data;
2151
2152 /* get the base-dirname */
2153 strncpy(basename,entry->path,MAXLINE);
2154 p = rindex(basename,'/');
2155 *p = '\0';
2156 if (strcmp(basename,"") == 0) {
2157 strcpy(basename,"/");
2158 }
2159 strcpy(fname, p+1);
2160
2161 if (strcmp(basename,imgdir) != 0 && imgdir[0] != '\0') {
2162 /* skip not selected dirs */
2163 loop = loop->next;
2164 continue;
2165 }
2166
2167 if (entry->readable == 0) {
2168 /* dont display not readable files */
2169 loop = loop->next;
2170 continue;
2171 }
2172
2173 strcpy(titlestr,"");
2174 assign_trackname(titlestr, entry);
2175
2176 /* no title found - so use filename as title */
2177 if (strcmp(titlestr,"") == 0) {
2178 strcpy(titlestr,fname);
2179 }
2180
2181 /* iso9600-track/ unknown */
2182 if (entry->type == 0 || entry->type == 3) {
2183 convert_frames2mbstring((gint)((off_t)entry->size/DATASECTORSIZE),
2184 tmp2);
2185 g_snprintf(tmp,MAXLINE,"%2d. %s [%s] (%s)",
2186 count, titlestr, tmp2, entry->path);
2187 data[1] = convert_for_gtk2(tmp);
2188 gtk_clist_append(imglist,data);
2189
2190 if (is_on_writelist(entry->path)) {
2191 /* already on writelist? change color */
2192 set_clist_row_color(imglist,
2193 lcount,SELECTEDCLISTCOL);
2194 }
2195
2196 if (entry->type == 0) {
2197 gtk_clist_set_pixmap(imglist,lcount,0,pixmap1,mask1);
2198 } else {
2199 gtk_clist_set_pixmap(imglist,lcount,0,pixmap3,mask3);
2200 }
2201 count++;
2202 lcount++;
2203 }
2204
2205 /* valid wav-file */
2206 if (entry->type == 1) {
2207 convert_frames2minstring((gint)((off_t)entry->size/CDDAFRAME), tmp2);
2208 g_snprintf(tmp,MAXLINE,"%2d. %s [%s] (%s)",
2209 count, titlestr, tmp2, entry->path);
2210 data[1] = convert_for_gtk2(tmp);
2211 gtk_clist_append(imglist,data);
2212
2213 if (is_on_writelist(entry->path)) {
2214 /* already on writelist? change color */
2215 set_clist_row_color(imglist,
2216 lcount,SELECTEDCLISTCOL);
2217 }
2218
2219 gtk_clist_set_pixmap(imglist,lcount,0,pixmap2,mask2);
2220 lcount++;
2221 count++;
2222 }
2223
2224 loop = loop->next;
2225 }
2226
2227 /* now scroll to remembered position */
2228 gtk_clist_moveto(imglist, toprow, topcol, 0.0, 0.0);
2229 gtk_clist_thaw(imglist);
2230
2231 /* nothing selected - no size of files */
2232 convert_kbytes2mbminstring(0, tmp);
2233 gtk_entry_set_text(GTK_ENTRY(imglist_l1), tmp);
2234
2235 /* dummy focus of entry to make sure the clists got no focus,
2236 which might be funny in drag&drop */
2237 gtk_widget_grab_focus(imglist_l1);
2238 }
2239
2240
2241 /* allow to drag tracks out of the right track window */
2242
writetracks_request_dnddata(GtkWidget * widget,GdkDragContext * dc,GtkSelectionData * selection_data,guint info,guint t,gpointer data)2243 static void writetracks_request_dnddata(GtkWidget *widget, GdkDragContext *dc,
2244 GtkSelectionData *selection_data, guint info, guint t,
2245 gpointer data) {
2246 gboolean data_sent = FALSE;
2247 GtkCList *clist;
2248 GList *sel;
2249 gint row, focusrow, bufcount;
2250 gchar tmp[MAXLINE];
2251 gchar tmp2[MAXLINE];
2252 gchar bigtmp[MAXLINE*10];
2253 gint use_selection;
2254
2255 clist = GTK_CLIST(widget);
2256 focusrow = clist->focus_row;
2257 use_selection = 0;
2258
2259 /* see if any other rows are selected */
2260 sel = clist->selection;
2261 while (sel) {
2262 row = GPOINTER_TO_INT(sel->data);
2263 if (row == focusrow) {
2264 /* we focused a row that is selected, remember */
2265 use_selection = 1;
2266 }
2267 sel = sel->next;
2268 }
2269
2270 /* Selected row in bounds? */
2271 if ((focusrow >= 0) && (focusrow < clist->rows) && (GTK_WIDGET_HAS_FOCUS(widget))) {
2272
2273 /* return single track from focused line */
2274 if (use_selection == 0) {
2275 if (get_trackname_from_row(focusrow, tmp) == 0) {
2276 g_snprintf(bigtmp,MAXLINE*10,"xcdr:%s", tmp);
2277 gtk_selection_data_set(
2278 selection_data,
2279 GDK_SELECTION_TYPE_STRING, 8,
2280 (const unsigned char *) bigtmp, strlen(bigtmp));
2281 data_sent = TRUE;
2282 }
2283 } else {
2284 /* return not from focus but all selected */
2285 strcpy(bigtmp,"");
2286 bufcount = 0;
2287 sel = clist->selection;
2288 while (sel) {
2289 row = GPOINTER_TO_INT(sel->data);
2290 if (get_trackname_from_row(row, tmp) == 0) {
2291 g_snprintf(tmp2,MAXLINE,"xcdr:%s\r\n", tmp);
2292
2293 bufcount+=strlen(tmp2);
2294 if (bufcount < MAXLINE*10) {
2295 strcat(bigtmp,tmp2);
2296 }
2297 }
2298 sel = sel->next;
2299 }
2300 if (bufcount > 0) {
2301 gtk_selection_data_set(
2302 selection_data,
2303 GDK_SELECTION_TYPE_STRING, 8,
2304 (const unsigned char *) bigtmp, strlen(bigtmp));
2305 data_sent = TRUE;
2306 }
2307 }
2308 }
2309
2310 /* we have to send something even in an error case */
2311 if (!data_sent) {
2312 const gchar *cstrptr = "Error";
2313
2314 gtk_selection_data_set(
2315 selection_data,
2316 GDK_SELECTION_TYPE_STRING, 8,
2317 (const unsigned char *) cstrptr, strlen(cstrptr));
2318 }
2319 }
2320
2321
2322 /* allow to drag tracks out of the left track window */
2323 /* to have them deleted */
2324
writetracksleft_request_dnddata(GtkWidget * widget,GdkDragContext * dc,GtkSelectionData * selection_data,guint info,guint t,gpointer data)2325 static void writetracksleft_request_dnddata(GtkWidget *widget,
2326 GdkDragContext *dc,
2327 GtkSelectionData *selection_data, guint info, guint t,
2328 gpointer data) {
2329 gboolean data_sent = FALSE;
2330 GtkCList *clist;
2331 GList *sel, *loop;
2332 gint row, focusrow, bufcount;
2333 gchar tmp2[MAXLINE];
2334 gchar bigtmp[MAXLINE*10];
2335 gint use_selection;
2336
2337 clist = GTK_CLIST(widget);
2338 focusrow = clist->focus_row;
2339 use_selection = 0;
2340
2341 /* see if any other rows are selected */
2342 sel = clist->selection;
2343 while (sel) {
2344 row = GPOINTER_TO_INT(sel->data);
2345 if (row == focusrow) {
2346 /* we focused a row that is selected, remember */
2347 use_selection = 1;
2348 }
2349 sel = sel->next;
2350 }
2351
2352 /* Selected row in bounds? */
2353 if ((focusrow >= 0) && (focusrow < clist->rows) && (GTK_WIDGET_HAS_FOCUS(widget))) {
2354
2355 /* return single track from focused line */
2356 if (use_selection == 0) {
2357 loop = g_list_nth(g_list_first(writelist),focusrow);
2358 if (loop && loop->data) {
2359 g_snprintf(bigtmp, MAXLINE, "xrmv:%d", focusrow);
2360 gtk_selection_data_set(
2361 selection_data,
2362 GDK_SELECTION_TYPE_STRING, 8,
2363 (const unsigned char *) bigtmp, strlen(bigtmp));
2364 data_sent = TRUE;
2365 }
2366 } else {
2367 /* return not from focus but all selected */
2368 strcpy(bigtmp,"");
2369 bufcount = 0;
2370 sel = clist->selection;
2371 while (sel) {
2372 row = GPOINTER_TO_INT(sel->data);
2373 loop = g_list_nth(g_list_first(writelist),row);
2374 if (loop && loop->data) {
2375 g_snprintf(tmp2, MAXLINE, "xrmv:%d\r\n", row);
2376 bufcount+=strlen(tmp2);
2377 if (bufcount < MAXLINE*10) {
2378 strcat(bigtmp,tmp2);
2379 }
2380 }
2381 sel = sel->next;
2382 }
2383 if (bufcount > 0) {
2384 gtk_selection_data_set(
2385 selection_data,
2386 GDK_SELECTION_TYPE_STRING, 8,
2387 (const unsigned char *) bigtmp, strlen(bigtmp));
2388 data_sent = TRUE;
2389 }
2390 }
2391 }
2392
2393 /* we have to send something even in an error case */
2394 if (!data_sent) {
2395 const gchar *cstrptr = "Error";
2396
2397 gtk_selection_data_set(
2398 selection_data,
2399 GDK_SELECTION_TYPE_STRING, 8,
2400 (const unsigned char *) cstrptr, strlen(cstrptr));
2401 }
2402 }
2403
2404
2405 /* move the rows from the reorderlist before the given droprow */
2406 /* quite complex because we can select more than one row to move */
2407
writetracks_drag_reorder(GList * reorderlist,gint droprow)2408 static void writetracks_drag_reorder(GList *reorderlist, gint droprow) {
2409 GList *loop, *l1;
2410 gint srcrow;
2411 gint smallest, highest;
2412 gint count;
2413
2414 /* empty list? nothing to do */
2415 if (!reorderlist)
2416 return;
2417
2418 /* sort reorderlist first */
2419 sort_int_glist(reorderlist);
2420
2421 loop = g_list_first(reorderlist);
2422 smallest = GPOINTER_TO_INT(loop->data);
2423
2424 loop = g_list_last(reorderlist);
2425 highest = GPOINTER_TO_INT(loop->data);
2426
2427 if (droprow == -1) {
2428 /* dropped beyond last track? assume its the last */
2429 droprow = g_list_length(writelist)-1;
2430 }
2431
2432 /* move up? */
2433 if (droprow < smallest) {
2434 loop = g_list_last(reorderlist);
2435 count = 0;
2436 while (loop) {
2437 srcrow = GPOINTER_TO_INT(loop->data);
2438 l1 = g_list_nth(g_list_first(writelist), srcrow+count);
2439
2440 if (srcrow+count > droprow) {
2441 writelist = g_list_insert(writelist, l1->data, droprow);
2442 writelist = g_list_remove_link(writelist, l1);
2443 } else {
2444 writelist = g_list_insert(writelist, l1->data, droprow+1);
2445 writelist = g_list_remove_link(writelist, l1);
2446 }
2447 count++;
2448
2449 loop = loop->prev;
2450 }
2451 } else
2452
2453 /* move down */
2454 if (droprow > highest) {
2455 loop = g_list_first(reorderlist);
2456 count = 0;
2457 while (loop) {
2458 srcrow = GPOINTER_TO_INT(loop->data);
2459 l1 = g_list_nth(g_list_first(writelist), srcrow-count);
2460
2461 if (srcrow-count > droprow) {
2462 writelist = g_list_insert(writelist, l1->data, droprow);
2463 writelist = g_list_remove_link(writelist, l1);
2464 } else {
2465 writelist = g_list_insert(writelist, l1->data, droprow+1);
2466 writelist = g_list_remove_link(writelist, l1);
2467 }
2468 count++;
2469
2470 loop = loop->next;
2471 }
2472 } else {
2473 /* mixed case - tracks moved around somewhere in the middle */
2474
2475 /* ignore for now */
2476 ;
2477 }
2478 }
2479
2480
2481 /* called when a drag is received on the left write-tracks clist */
2482 /* also handles reordering when drag was received from same window */
2483
writetracks_drag_received(GtkWidget * widget,GdkDragContext * dc,gint x,gint y,GtkSelectionData * selection_data,guint info,guint t,gpointer data)2484 static void writetracks_drag_received(GtkWidget *widget,
2485 GdkDragContext *dc, gint x, gint y, GtkSelectionData *selection_data,
2486 guint info, guint t, gpointer data) {
2487 GList *input, *reorderlist, *loop;
2488 GtkWidget *source_widget;
2489 GtkCList *clist;
2490 gboolean same;
2491 gchar *text;
2492 gint droprow, dropcolumn, srcrow, count;
2493 gchar *match;
2494
2495 input = NULL;
2496 reorderlist = NULL;
2497
2498 /* nothing received? ignore */
2499 if(selection_data == NULL)
2500 return;
2501 if(selection_data->length < 0)
2502 return;
2503
2504 /* Source and target widgets are the same? */
2505 source_widget = gtk_drag_get_source_widget(dc);
2506 same = (source_widget == widget) ? TRUE : FALSE;
2507
2508 clist = GTK_CLIST(widget);
2509
2510 /* Calculate the row and column at which the drop has occured
2511 * over on the clist based on the given x and y coordinates.
2512 */
2513 if(!gtk_clist_get_selection_info(
2514 clist,
2515 x,
2516 y - ((clist->flags & GTK_CLIST_SHOW_TITLES) ?
2517 clist->column_title_area.height +
2518 clist->column_title_area.y : 0),
2519 &droprow, &dropcolumn)) {
2520 droprow = -1;
2521 dropcolumn = 0;
2522 }
2523
2524 if ((info == DRAG_TAR_INFO_0) ||
2525 (info == DRAG_TAR_INFO_1) ||
2526 (info == DRAG_TAR_INFO_2)) {
2527 if (same) {
2528 /* we just reorder, watch for xrmv event */
2529 match = "xrmv:";
2530 } else {
2531 /* no reorder, but a drop from right window */
2532 match = "xcdr:";
2533 }
2534
2535 text = (char *) selection_data->data;
2536 if (extract_glist_drag_filenames(text, selection_data->length,
2537 match, &input)) {
2538
2539 loop = g_list_first(input);
2540 count = 0;
2541 while(loop) {
2542 if (loop->data != NULL) {
2543 dodebug(3,"Received from drag: %s\n", (gchar *)loop->data);
2544 if (same) {
2545 srcrow = atoi((gchar *)loop->data);
2546 reorderlist = g_list_append(reorderlist, GINT_TO_POINTER(srcrow));
2547 } else {
2548 /* insert tracks at the position of the drag */
2549 writelist = g_list_insert(writelist,g_strdup((gchar *)loop->data), droprow+count);
2550 }
2551
2552 /* take care of correct order */
2553 if (droprow != -1) {
2554 count++;
2555 }
2556 }
2557 loop = loop->next;
2558 }
2559 }
2560 if (same) {
2561 /* perform set of reorders */
2562 writetracks_drag_reorder(reorderlist, droprow);
2563 g_list_free(reorderlist);
2564 }
2565
2566 free_glist(&input);
2567 redraw_writelist(cdlist,cdlist_l1);
2568 fill_write_tracks();
2569
2570 }
2571 }
2572
2573
2574 /* called when a drag is received on the right write-tracks clist */
2575 /* which is a remove action */
2576
writetracksright_drag_received(GtkWidget * widget,GdkDragContext * dc,gint x,gint y,GtkSelectionData * selection_data,guint info,guint t,gpointer data)2577 static void writetracksright_drag_received(GtkWidget *widget,
2578 GdkDragContext *dc, gint x, gint y, GtkSelectionData *selection_data,
2579 guint info, guint t, gpointer data) {
2580 GList *input, *loop, *wrlist;
2581 gchar *text;
2582 gint row;
2583
2584 input = NULL;
2585
2586 /* nothing received? ignore */
2587 if(selection_data == NULL)
2588 return;
2589 if(selection_data->length < 0)
2590 return;
2591
2592 if ((info == DRAG_TAR_INFO_0) ||
2593 (info == DRAG_TAR_INFO_1) ||
2594 (info == DRAG_TAR_INFO_2)) {
2595 text = (char *) selection_data->data;
2596 if (extract_glist_drag_filenames(text, selection_data->length,
2597 "xrmv:", &input)) {
2598
2599 loop = g_list_first(input);
2600 while(loop) {
2601 if (loop->data != NULL) {
2602 dodebug(3,"Received from drag: %s\n", (gchar *)loop->data);
2603 /* row number we dragged off */
2604 row = atoi((gchar *)loop->data);
2605
2606 /* mark that row deleted in the writelist */
2607 wrlist = g_list_nth(g_list_first(writelist),row);
2608 if (wrlist->data) {
2609 g_free(wrlist->data);
2610 wrlist->data = NULL;
2611 }
2612 }
2613 loop = loop->next;
2614 }
2615
2616 /* now remove the marked nodes really from the list */
2617 loop = g_list_first(writelist);
2618 while (loop) {
2619 wrlist = loop->next;
2620 if (loop->data == NULL) {
2621 writelist = g_list_remove_link(writelist, loop);
2622 }
2623 loop = wrlist;
2624 }
2625 }
2626
2627 free_glist(&input);
2628 redraw_writelist(cdlist,cdlist_l1);
2629 fill_write_tracks();
2630 }
2631 }
2632
2633
2634 /* draw the write-tracks menu */
2635
draw_write_tracks()2636 static void draw_write_tracks() {
2637 gchar tmp[MAXLINE];
2638 gchar tmp2[MAXLINE];
2639 gchar tmptoc[MAXLINE];
2640 GtkWidget *hbox, *vbox;
2641 GtkWidget *f1,*f2;
2642 GtkWidget *b1, *dummy;
2643 GtkWidget *e1, *check;
2644 GtkWidget *l1;
2645 GtkWidget *tbl;
2646 GtkWidget *sep;
2647 GtkWidget *omenu;
2648 GtkWidget *menu;
2649 GtkWidget *menu_item;
2650 gint cdrtypes[] = CDR_TYPES_MIN;
2651 gint dvdtypes[] = DVD_TYPES_MB;
2652 static const gchar *writemodes[] = WRITE_MODES;
2653 static const gchar *helpwritemodes[] = HELP_WRITE_MODES;
2654 gint i, tmpval;
2655 gint menuidx, menuhistory;
2656 GtkWidget *notebook, *halign;
2657 gchar *titles[2];
2658 GtkWidget *scrolled_win, *img_list, *cd_list, *img_list2;
2659 GtkTargetEntry target_entry[3];
2660
2661 target_entry[0].target = DRAG_TAR_NAME_0;
2662 target_entry[0].flags = 0;
2663 target_entry[0].info = DRAG_TAR_INFO_0;
2664 target_entry[1].target = DRAG_TAR_NAME_1;
2665 target_entry[1].flags = 0;
2666 target_entry[1].info = DRAG_TAR_INFO_1;
2667 target_entry[2].target = DRAG_TAR_NAME_2;
2668 target_entry[2].flags = 0;
2669 target_entry[2].info = DRAG_TAR_INFO_2;
2670
2671 /* prepare draw area */
2672 clear_actionspace();
2673
2674 crea_cd_mode_omenu = NULL;
2675 crea_cd_burnfree_check = NULL;
2676
2677 f1 = gtk_frame_new(_("Devices-Setup"));
2678 set_font_and_color_frame(f1,BOLDFONT,NULL);
2679 gtk_box_pack_start(GTK_BOX(actionspace),f1,FALSE,FALSE,5);
2680 gtk_widget_show(f1);
2681
2682 tbl = gtk_table_new(2,16*4,TRUE);
2683 gtk_table_set_col_spacing(GTK_TABLE(tbl),4*4-1,5);
2684 gtk_table_set_col_spacing(GTK_TABLE(tbl),15*4-2,5);
2685 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
2686 gtk_container_add(GTK_CONTAINER(f1),tbl);
2687 gtk_widget_show(tbl);
2688
2689 devices_setup_image(0, tbl);
2690 devices_setup_write(1, tbl);
2691
2692 gtk_widget_show(actionspace);
2693
2694 /* notebook tabs */
2695 notebook = gtk_notebook_new();
2696 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
2697 gtk_box_pack_start(GTK_BOX(actionspace),notebook,TRUE,TRUE,2);
2698 gtk_widget_show(notebook);
2699
2700 gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
2701 GTK_SIGNAL_FUNC (writetracks_notebookswitch), NULL);
2702
2703
2704 /* first tab */
2705 vbox = gtk_vbox_new(FALSE,0);
2706 l1 = gtk_label_new(_("Layout tracks"));
2707 gtk_widget_show_all(vbox);
2708 gtk_notebook_append_page(GTK_NOTEBOOK (notebook),vbox,l1);
2709
2710 /* left and right info-frames */
2711 tbl = gtk_table_new(1,2,TRUE);
2712 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
2713 gtk_table_set_col_spacings(GTK_TABLE(tbl),5);
2714 gtk_box_pack_start(GTK_BOX(vbox),tbl,TRUE,TRUE,0);
2715 gtk_widget_show(tbl);
2716 f1 = gtk_frame_new(_("Tracks to write"));
2717 set_font_and_color_frame(f1,BOLDFONT,NULL);
2718 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,0,1,0,1);
2719 gtk_widget_show(f1);
2720 f2 = gtk_frame_new(_("Image-Information"));
2721 set_font_and_color_frame(f2,BOLDFONT,NULL);
2722 gtk_table_attach_defaults(GTK_TABLE(tbl),f2,1,2,0,1);
2723 gtk_widget_show(f2);
2724
2725 /* button bar at the bottom */
2726 hbox = gtk_hbox_new(TRUE,10);
2727 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,5);
2728 gtk_widget_show(hbox);
2729 halign = gtk_alignment_new(0.5, 0.5, 0.5, 0);
2730 gtk_box_pack_start(GTK_BOX(hbox),halign,TRUE,TRUE,10);
2731 gtk_widget_show(halign);
2732
2733 b1 = gtk_button_new_with_label(_("Accept track layout"));
2734 gtk_container_add(GTK_CONTAINER(halign),b1);
2735 gtk_widget_show(b1);
2736 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
2737 GTK_SIGNAL_FUNC(accept_layout_clicked), notebook);
2738 /*
2739 this crashed the eazel-gtk-engine
2740
2741 GTK_WIDGET_SET_FLAGS (b1, GTK_CAN_DEFAULT);
2742 gtk_widget_grab_default (b1);
2743 */
2744 define_tooltip(b1,_("When you are satisfied with the tracks and the order you set for writing (use drag'n'drop to reorder them), click here to transfer the selection to the write menu."));
2745
2746 /* left info frame */
2747 vbox = gtk_vbox_new(FALSE,0);
2748 gtk_container_add(GTK_CONTAINER(f1),vbox);
2749 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
2750 gtk_widget_show(vbox);
2751
2752 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
2753 gtk_box_pack_start(GTK_BOX(vbox),scrolled_win,TRUE,TRUE,0);
2754 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
2755 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
2756 gtk_widget_show(scrolled_win);
2757
2758 titles[0] = g_strdup("");
2759 titles[1] = _("Images");
2760 cd_list = gtk_clist_new_with_titles(2,titles);
2761 gtk_container_add (GTK_CONTAINER (scrolled_win), cd_list);
2762 cdlist = GTK_CLIST(cd_list);
2763 gtk_clist_set_column_width(cdlist, 0, 16);
2764 gtk_clist_set_column_auto_resize(cdlist, 1, TRUE);
2765 if (setupdata.option_selectionmode == 0) {
2766 gtk_clist_set_selection_mode (cdlist, GTK_SELECTION_MULTIPLE);
2767 } else {
2768 gtk_clist_set_selection_mode (cdlist, GTK_SELECTION_EXTENDED);
2769 }
2770 gtk_clist_set_use_drag_icons(cdlist, TRUE);
2771 gtk_widget_realize(cd_list);
2772
2773 if(!GTK_WIDGET_NO_WINDOW(cd_list)) {
2774 /* we can receive drags */
2775 gtk_drag_dest_set(
2776 cd_list,
2777 GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT |
2778 GTK_DEST_DEFAULT_DROP,
2779 target_entry,
2780 sizeof(target_entry) / sizeof(GtkTargetEntry),
2781 GDK_ACTION_MOVE | GDK_ACTION_COPY
2782 );
2783 gtk_signal_connect(GTK_OBJECT(cd_list), "drag_data_received",
2784 GTK_SIGNAL_FUNC(writetracks_drag_received),
2785 NULL);
2786
2787 /* and we can send drags */
2788 gtk_drag_source_set(
2789 cd_list,
2790 GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
2791 target_entry,
2792 sizeof(target_entry) / sizeof(GtkTargetEntry),
2793 GDK_ACTION_MOVE);
2794 gtk_signal_connect(
2795 GTK_OBJECT(cd_list), "drag_data_get",
2796 GTK_SIGNAL_FUNC(writetracksleft_request_dnddata), NULL);
2797
2798 }
2799 gtk_widget_show(cd_list);
2800
2801 tbl = gtk_table_new(1,8,TRUE);
2802 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
2803 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,5);
2804 gtk_widget_show(tbl);
2805
2806 l1 = rightjust_gtk_label_new(_("Size:"));
2807 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,0,1);
2808 gtk_widget_show(l1);
2809
2810 e1 = gtk_entry_new();
2811 cdlist_l1 = e1;
2812 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
2813 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,0,1);
2814 gtk_widget_show(e1);
2815
2816 hbox = gtk_hbox_new(FALSE,2);
2817 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,5);
2818 gtk_widget_show(hbox);
2819 b1 = gtk_button_new_with_label(_("All"));
2820 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
2821 GTK_SIGNAL_FUNC(read_select_all), NULL);
2822 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,3);
2823 gtk_widget_show(b1);
2824 define_tooltip(b1,_("Selects all displayed tracks so that you can remove them from the list with a single click."));
2825 b1 = gtk_button_new_with_label(_("None"));
2826 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
2827 GTK_SIGNAL_FUNC(read_select_none), NULL);
2828 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,3);
2829 gtk_widget_show(b1);
2830 define_tooltip(b1,_("Deselects all displayed tracks."));
2831
2832 dummy = gtk_label_new("");
2833 gtk_box_pack_start(GTK_BOX(hbox),dummy,FALSE,FALSE,5);
2834 gtk_widget_show(dummy);
2835
2836 b1 = gtk_button_new_with_label(_("Remove"));
2837 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
2838 GTK_SIGNAL_FUNC(write_delete_tracks), NULL);
2839 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,3);
2840 gtk_widget_show(b1);
2841 define_tooltip(b1,_("Remove the selected tracks from this list."));
2842
2843 /* right info frame */
2844 vbox = gtk_vbox_new(FALSE,0);
2845 gtk_container_add(GTK_CONTAINER(f2),vbox);
2846 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
2847 gtk_widget_show(vbox);
2848
2849 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
2850 gtk_box_pack_start(GTK_BOX(vbox),scrolled_win,TRUE,TRUE,0);
2851 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
2852 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
2853 gtk_widget_show(scrolled_win);
2854
2855 titles[0] = g_strdup("");
2856 titles[1] = _("Images");
2857 img_list = gtk_clist_new_with_titles(2,titles);
2858 gtk_signal_connect(GTK_OBJECT(img_list), "select_row",
2859 GTK_SIGNAL_FUNC(verify_select_row),NULL);
2860 gtk_signal_connect(GTK_OBJECT(img_list), "unselect_row",
2861 GTK_SIGNAL_FUNC(verify_select_row),NULL);
2862 gtk_container_add (GTK_CONTAINER (scrolled_win), img_list);
2863 imglist = GTK_CLIST(img_list);
2864 gtk_clist_set_column_width(imglist, 0, 16);
2865 gtk_clist_set_column_auto_resize(imglist, 1, TRUE);
2866 if (setupdata.option_selectionmode == 0) {
2867 gtk_clist_set_selection_mode (imglist, GTK_SELECTION_MULTIPLE);
2868 } else {
2869 gtk_clist_set_selection_mode (imglist, GTK_SELECTION_EXTENDED);
2870 }
2871 gtk_widget_realize(img_list);
2872
2873 if(!GTK_WIDGET_NO_WINDOW(img_list)) {
2874 /* we can drag out of the list */
2875 gtk_drag_source_set(
2876 img_list,
2877 GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
2878 target_entry,
2879 sizeof(target_entry) / sizeof(GtkTargetEntry),
2880 GDK_ACTION_MOVE);
2881 gtk_signal_connect(
2882 GTK_OBJECT(img_list), "drag_data_get",
2883 GTK_SIGNAL_FUNC(writetracks_request_dnddata), NULL);
2884
2885 /* we can receive drags */
2886 gtk_drag_dest_set(
2887 img_list,
2888 GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT |
2889 GTK_DEST_DEFAULT_DROP,
2890 target_entry,
2891 sizeof(target_entry) / sizeof(GtkTargetEntry),
2892 GDK_ACTION_MOVE | GDK_ACTION_COPY
2893 );
2894 gtk_signal_connect(GTK_OBJECT(img_list), "drag_data_received",
2895 GTK_SIGNAL_FUNC(writetracksright_drag_received),
2896 NULL);
2897 }
2898 gtk_widget_show(img_list);
2899
2900 tbl = gtk_table_new(1,8,TRUE);
2901 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
2902 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,5);
2903 gtk_widget_show(tbl);
2904
2905 l1 = rightjust_gtk_label_new(_("Selected:"));
2906 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,0,1);
2907 gtk_widget_show(l1);
2908
2909 e1 = gtk_entry_new();
2910 imglist_l1 = e1;
2911 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
2912 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,0,1);
2913 gtk_widget_show(e1);
2914
2915 hbox = gtk_hbox_new(FALSE,2);
2916 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,5);
2917 gtk_widget_show(hbox);
2918 b1 = gtk_button_new_with_label(_("All"));
2919 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
2920 GTK_SIGNAL_FUNC(verify_select_all), NULL);
2921 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,3);
2922 gtk_widget_show(b1);
2923 define_tooltip(b1,_("Selects all displayed tracks so that you can add them to the selection you want to write with a single click."));
2924 b1 = gtk_button_new_with_label(_("None"));
2925 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
2926 GTK_SIGNAL_FUNC(verify_select_none), NULL);
2927 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,3);
2928 gtk_widget_show(b1);
2929 define_tooltip(b1,_("Deselects all displayed images."));
2930
2931 dummy = gtk_label_new("");
2932 gtk_box_pack_start(GTK_BOX(hbox),dummy,FALSE,FALSE,5);
2933 gtk_widget_show(dummy);
2934
2935 b1 = gtk_button_new_with_label(_("Add"));
2936 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
2937 GTK_SIGNAL_FUNC(write_add_tracks), NULL);
2938 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,3);
2939 gtk_widget_show(b1);
2940 define_tooltip(b1,_("Add all selected images to the left list - the tracks that should be written to a CD-R/RW."));
2941
2942
2943 /* second tab */
2944 vbox = gtk_vbox_new(FALSE,0);
2945 l1 = gtk_label_new(_("Write tracks"));
2946 gtk_widget_show_all(vbox);
2947 gtk_notebook_append_page(GTK_NOTEBOOK (notebook),vbox,l1);
2948
2949 /* left and right info-frames */
2950 tbl = gtk_table_new(1,2,TRUE);
2951 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
2952 gtk_table_set_col_spacings(GTK_TABLE(tbl),5);
2953 gtk_box_pack_start(GTK_BOX(vbox),tbl,TRUE,TRUE,0);
2954 gtk_widget_show(tbl);
2955 f1 = gtk_frame_new(_("Tracks to write"));
2956 set_font_and_color_frame(f1,BOLDFONT,NULL);
2957 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,0,1,0,1);
2958 gtk_widget_show(f1);
2959 f2 = gtk_frame_new(_("Write parameters"));
2960 set_font_and_color_frame(f2,BOLDFONT,NULL);
2961 gtk_table_attach_defaults(GTK_TABLE(tbl),f2,1,2,0,1);
2962 gtk_widget_show(f2);
2963
2964 /* button bar at the bottom */
2965 hbox = gtk_hbox_new(TRUE,10);
2966 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,5);
2967 gtk_widget_show(hbox);
2968 b1 = gtk_button_new_with_label(_("Write tracks"));
2969 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
2970 gtk_widget_show(b1);
2971 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
2972 GTK_SIGNAL_FUNC(writesometracks_clicked), NULL);
2973 define_tooltip(b1,_("Write all selected track to a CD-R/RW."));
2974
2975 b1 = gtk_button_new_with_label(_("Fixate CD-R/RW only"));
2976 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
2977 gtk_widget_show(b1);
2978 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
2979 GTK_SIGNAL_FUNC(fixate_clicked), NULL);
2980 define_tooltip(b1,_("Just fixate (close) the CD, if for some reason the CD has been written but not fixated."));
2981
2982 if (!curset.isProDVD) {
2983 b1 = gtk_button_new_with_label(_("Blank CD-RW"));
2984 } else {
2985 b1 = gtk_button_new_with_label(_("Blank CD/DVD+-RW"));
2986 }
2987 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
2988 gtk_widget_show(b1);
2989 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
2990 GTK_SIGNAL_FUNC(blankcd_clicked), NULL);
2991 define_tooltip(b1,_("Blanks a CD-RW in the Write-Device."));
2992
2993 /* left info frame */
2994 vbox = gtk_vbox_new(FALSE,0);
2995 gtk_container_add(GTK_CONTAINER(f1),vbox);
2996 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
2997 gtk_widget_show(vbox);
2998
2999 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3000 gtk_box_pack_start(GTK_BOX(vbox),scrolled_win,TRUE,TRUE,0);
3001 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3002 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
3003 gtk_widget_show(scrolled_win);
3004
3005 titles[0] = g_strdup("");
3006 titles[1] = _("Images");
3007 img_list2 = gtk_clist_new_with_titles(2,titles);
3008 gtk_container_add (GTK_CONTAINER (scrolled_win), img_list2);
3009 imglist2 = GTK_CLIST(img_list2);
3010 gtk_signal_connect(GTK_OBJECT(imglist2), "select_row",
3011 GTK_SIGNAL_FUNC(undo_selections),NULL);
3012 gtk_clist_set_column_width(imglist2, 0, 16);
3013 gtk_clist_set_column_auto_resize(imglist2, 1, TRUE);
3014 gtk_widget_show(img_list2);
3015 gtk_widget_realize(img_list2);
3016
3017 tbl = gtk_table_new(2,8,TRUE);
3018 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
3019 gtk_table_set_row_spacings(GTK_TABLE(tbl),5);
3020 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,5);
3021 gtk_widget_show(tbl);
3022
3023 l1 = rightjust_gtk_label_new(_("Size:"));
3024 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,0,1);
3025 gtk_widget_show(l1);
3026
3027 e1 = gtk_entry_new();
3028 imglist_l2 = e1;
3029 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
3030 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,0,1);
3031 gtk_widget_show(e1);
3032
3033 check = gtk_check_button_new_with_label(_("Write as multi session"));
3034 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3035 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(5));
3036 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,8,1,2);
3037 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3038 curset.multisession);
3039 gtk_widget_show(check);
3040 define_tooltip(check,_("Write the CD in such a way, that it is possible to append further data (in a new session) at a later time. Please note that for the first session you need 22 MB extra space on the CD-R/RW and all additional sessions take 13 MB extra each."));
3041
3042 /* right info frame */
3043 /* write-parameters */
3044 vbox = gtk_vbox_new(FALSE,0);
3045 gtk_container_add(GTK_CONTAINER(f2),vbox);
3046 gtk_container_set_border_width (GTK_CONTAINER (vbox), 7);
3047 gtk_widget_show(vbox);
3048
3049 tbl = gtk_table_new(9,16,FALSE);
3050 gtk_table_set_row_spacing(GTK_TABLE(tbl),0,2);
3051 gtk_table_set_row_spacing(GTK_TABLE(tbl),1,5);
3052 gtk_table_set_row_spacing(GTK_TABLE(tbl),2,5);
3053 gtk_table_set_col_spacings(GTK_TABLE(tbl),2);
3054 gtk_table_set_col_spacing(GTK_TABLE(tbl),14,0);
3055 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,0);
3056 gtk_widget_show(tbl);
3057
3058 l1 = rightjust_gtk_label_new(_("Disc Type:"));
3059 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,6,0,1);
3060 gtk_widget_show(l1);
3061
3062 omenu = gtk_option_menu_new();
3063 menu = gtk_menu_new();
3064 menuidx = 0; menuhistory = 0;
3065
3066 i = 0;
3067 tmpval = curset.cdrtype;
3068 while (cdrtypes[i] != 0) {
3069 /* contruct minute-list */
3070 g_snprintf(tmp,MAXLINE,"%d min",abs(cdrtypes[i]));
3071
3072 menu_item = gtk_menu_item_new_with_label(tmp);
3073 gtk_signal_connect(GTK_OBJECT(menu_item),
3074 "activate", GTK_SIGNAL_FUNC(cdrtype_selected),
3075 GINT_TO_POINTER(abs(cdrtypes[i])));
3076 gtk_menu_append (GTK_MENU (menu), menu_item);
3077 if (tmpval == abs(cdrtypes[i])) {
3078 menuhistory = menuidx;
3079 }
3080 /* default set defined by negativ value */
3081 if (tmpval == 0 && cdrtypes[i] < 0) {
3082 menuhistory = menuidx;
3083 curset.cdrtype = abs(cdrtypes[i]);
3084 }
3085 menuidx++;
3086 gtk_widget_show (menu_item);
3087 i++;
3088 }
3089 if (curset.isProDVD) {
3090 i = 0;
3091 tmpval = curset.cdrtype;
3092 while (dvdtypes[i] != 0) {
3093 /* contruct GB-list */
3094 g_snprintf(tmp2,MAXLINE,"%.2f", (gfloat)dvdtypes[i]/1000);
3095 /* strip last 0 */
3096 if (tmp2[strlen(tmp2)-1] == '0') {
3097 tmp2[strlen(tmp2)-1] = '\0';
3098 }
3099 g_snprintf(tmp,MAXLINE,"%s GB",tmp2);
3100
3101 menu_item = gtk_menu_item_new_with_label(tmp);
3102 gtk_signal_connect(GTK_OBJECT(menu_item),
3103 "activate", GTK_SIGNAL_FUNC(cdrtype_selected),
3104 GINT_TO_POINTER(dvdtypes[i]));
3105 gtk_menu_append (GTK_MENU (menu), menu_item);
3106 if (tmpval == abs(dvdtypes[i])) {
3107 menuhistory = menuidx;
3108 }
3109 menuidx++;
3110 gtk_widget_show (menu_item);
3111 i++;
3112 }
3113 }
3114
3115 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
3116 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),menuhistory);
3117 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,6,10,0,1);
3118 gtk_widget_show(omenu);
3119 define_tooltip(omenu,_("The capacity of the currently used CD-R/RW."));
3120
3121 b1 = gtk_button_new_with_label(_("ATIP-Info"));
3122 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
3123 GTK_SIGNAL_FUNC(show_atip_info),NULL);
3124 gtk_table_attach_defaults(GTK_TABLE(tbl),b1,10,16,0,1);
3125 gtk_widget_show(b1);
3126 define_tooltip(b1,_("Read detailed information from a (empty) CD-R/RW."));
3127
3128
3129 /* write-mode */
3130 l1 = rightjust_gtk_label_new(_("Write Mode:"));
3131 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,6,1,2);
3132 gtk_widget_show(l1);
3133
3134 omenu = gtk_option_menu_new ();
3135 menu = gtk_menu_new();
3136 crea_cd_mode_omenu = omenu;
3137
3138 i = 0;
3139 while (writemodes[i]) {
3140 menu_item = gtk_menu_item_new_with_label(_(writemodes[i]));
3141 gtk_signal_connect(GTK_OBJECT(menu_item), "activate",
3142 GTK_SIGNAL_FUNC(writemode_selected),
3143 GINT_TO_POINTER(i));
3144 gtk_menu_append (GTK_MENU (menu), menu_item);
3145 gtk_widget_show (menu_item);
3146 if (helpwritemodes[i])
3147 define_tooltip(menu_item,(gchar *)_(helpwritemodes[i]));
3148 i++;
3149 }
3150
3151 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
3152 preselect_write_mode_menu(omenu, curset.writer_devnr);
3153 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,6,16,1,2);
3154 gtk_widget_show(omenu);
3155 /* concat 2 help strings */
3156 g_snprintf(tmp,MAXLINE,"%s %s",_("Choose which write mode you want to use with your CD-Writer. Not all modes are supported with all writers. Try \"DAO\" first, because its usually the best option. If the write fails, try one of the \"TAO\" modes."), _("Click an option and hold the button to get additional help for each mode."));
3157 define_tooltip(omenu,tmp);
3158
3159 if (!isroot() && !setupdata.root_option_change_writeparam) {
3160 gtk_widget_set_sensitive(omenu,FALSE);
3161 }
3162
3163 /* in multisession mode we cant select write modes */
3164 if (curset.multisession == 1) {
3165 gtk_widget_set_sensitive(omenu,FALSE);
3166 }
3167
3168 sep = gtk_hseparator_new();
3169 gtk_table_attach_defaults(GTK_TABLE(tbl),sep,0,16,2,3);
3170 gtk_widget_show(sep);
3171
3172 check = gtk_check_button_new_with_label(_("Simulation write"));
3173 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3174 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(0));
3175 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,3,4);
3176 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3177 curset.writesimul);
3178 gtk_widget_show(check);
3179 define_tooltip(check,_("Just simulate the write-process. Please be aware that aborting a simulation-write is generally a bad idea, because you can hang the SCSI-bus."));
3180
3181 check = gtk_check_button_new_with_label(_("Eject after write"));
3182 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3183 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(1));
3184 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,4,5);
3185 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3186 curset.writeeject);
3187 gtk_widget_show(check);
3188 define_tooltip(check,_("Eject the CD after the burning was completed."));
3189
3190 check = gtk_check_button_new_with_label(_("Pad Tracks"));
3191 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3192 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(2));
3193 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,5,6);
3194 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3195 curset.writepad);
3196 gtk_widget_show(check);
3197 define_tooltip(check,_("Pads data-tracks with zeros to eliminate reading problems on some systems and adapts the length of audio-tracks for CD writing. This must be enabled when you want to burn wav-files not created with X-CD-Roast."));
3198
3199 check = gtk_check_button_new_with_label(_("Do not fixate after write"));
3200 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3201 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(4));
3202 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,6,7);
3203 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3204 curset.nofixate);
3205 gtk_widget_show(check);
3206 define_tooltip(check,_("This prevents the CD-Writer from fixating (closing) the CD after writing. You can use this to create an audio CD in several steps. Just be sure to fixate after the last track. (Or use the \"Fixate CD-R/RW only\" button.) Note: This does only work in Track-At-Once-Mode."));
3207
3208 check = gtk_check_button_new_with_label(_("Enable protection from Buffer Underruns"));
3209 crea_cd_burnfree_check = check;
3210
3211 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3212 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(8));
3213 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,7,8);
3214 if (does_support_burnproof(curset.writer_devnr)) {
3215 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3216 curset.writeburnfree);
3217 }
3218 gtk_widget_show(check);
3219 define_tooltip(check,_("When available it does enable protection from Buffer Underrun errors. Supported are Sanyo BURN-Proof, Ricoh Just-Link and similar."));
3220
3221 if (!does_support_burnproof(curset.writer_devnr))
3222 gtk_widget_set_sensitive(check,FALSE);
3223
3224 check = gtk_check_button_new_with_label(_("Write CD-Text"));
3225 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3226 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(6));
3227 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,8,8,9);
3228 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3229 curset.writecdtext);
3230 gtk_widget_show(check);
3231 define_tooltip(check,_("Writes CD-Text information to the CD-R/RW when your CD Writer is supporting it. This usually works only when writing in DAO or raw96r mode."));
3232
3233 b1 = gtk_button_new_with_label(_("Edit titles"));
3234 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
3235 GTK_SIGNAL_FUNC(edit_cdtext_clicked), GINT_TO_POINTER(2));
3236 gtk_table_attach_defaults(GTK_TABLE(tbl),b1,8,16,8,9);
3237 gtk_widget_show(b1);
3238 define_tooltip(b1,_("Edits the title and performer information of your tracks before they are written to a CD-R/RW with CD-Text."));
3239
3240 b1 = gtk_button_new_with_label(_("Advanced options"));
3241 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
3242 GTK_SIGNAL_FUNC(adv_write_options_clicked), NULL);
3243 gtk_box_pack_end(GTK_BOX(vbox),b1,FALSE,FALSE,0);
3244 gtk_widget_show(b1);
3245 define_tooltip(b1,_("Set additional write options for advanced users."));
3246
3247 /* init write-list again - so each time we enter this menu
3248 we start with an empty set */
3249 free_glist(&writelist);
3250 clear_trackreadset();
3251
3252 /* write fresh tmp tocfile */
3253 generate_tmp_tocfile_name(tmptoc);
3254 create_tmp_writetracks_tocfile(tmptoc);
3255
3256 /* fill entries */
3257 fill_write_tracks();
3258 redraw_writelist(cdlist,cdlist_l1);
3259 fill_writelist2(imglist2,imglist_l2);
3260 }
3261
dirview_selected(GtkWidget * item,GtkWidget * entry)3262 static void dirview_selected(GtkWidget *item, GtkWidget *entry) {
3263 gint sel;
3264 gchar path[MAXLINE];
3265
3266 sel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
3267 masterparam.show_only_dirs = sel;
3268
3269 /* save entry */
3270 strncpy(path,gtk_entry_get_text(GTK_ENTRY(entry)),MAXLINE);
3271 convert_for_gtk2_filename(path);
3272
3273 /* redraw the tree to the current setting */
3274 ctree_change_viewmode(!masterparam.show_only_dirs,
3275 masterparam.show_hidden_files);
3276
3277 /* now expand back to the level we described in the entry-field */
3278 if (path[0] == '/') {
3279 gtk_entry_set_text(GTK_ENTRY(entry),path);
3280 }
3281 ctree_expand_manualpath(entry, NULL);
3282 }
3283
hiddenview_selected(GtkWidget * item,GtkWidget * entry)3284 static void hiddenview_selected(GtkWidget *item, GtkWidget *entry) {
3285 gint sel;
3286 gchar path[MAXLINE];
3287
3288 sel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
3289 masterparam.show_hidden_files = sel;
3290
3291 /* save entry */
3292 strncpy(path,gtk_entry_get_text(GTK_ENTRY(entry)),MAXLINE);
3293 convert_for_gtk2_filename(path);
3294
3295 /* redraw the tree to the current setting */
3296 ctree_change_viewmode(!masterparam.show_only_dirs,
3297 masterparam.show_hidden_files);
3298
3299 /* now expand back to the level we described in the entry-field */
3300 if (path[0] == '/') {
3301 gtk_entry_set_text(GTK_ENTRY(entry),path);
3302 }
3303 ctree_expand_manualpath(entry, NULL);
3304 }
3305
entry_masterdir_callback(GtkWidget * widget,gpointer data)3306 static void entry_masterdir_callback(GtkWidget *widget, gpointer data) {
3307 gchar dir[MAXLINE];
3308
3309 /* expand tilde */
3310 strcpy(dir,gtk_entry_get_text(GTK_ENTRY(widget)));
3311 check_tilde(dir);
3312 gtk_entry_set_text(GTK_ENTRY(widget), dir);
3313
3314 ctree_expand_manualpath(widget, NULL);
3315 }
3316
3317
3318 /* calculate redir path for a master path and add it */
3319
add_mult_mstr_file(gchar * path,gint stat,gchar * redir,gchar * common)3320 static gint add_mult_mstr_file(gchar *path, gint stat, gchar *redir, gchar *common) {
3321 mstr_redirect_t *mstr;
3322 gchar redir2[MAXLINE];
3323 gchar redir3[MAXLINE];
3324 gchar reducedpath[MAXLINE];
3325 gchar filename[MAXLINE];
3326
3327 /* path already added? ignore */
3328 if (check_in_mstr_glist(&masterparam.mstr_redir, path) != 0) {
3329 return 0;
3330 }
3331
3332 /* handling a file or a directory here? */
3333 if (is_directory(path)) {
3334 strcpy(filename, "");
3335 } else {
3336 get_purefile(path, filename);
3337 }
3338
3339 /* get base path of our given directory */
3340 strncpy(redir2, path, MAXLINE);
3341 get_basedir(redir2);
3342 if (redir2 == NULL) { strcpy(redir2,"/"); }
3343
3344 /* add a slash now, too */
3345 if (strlen(redir2) > 0) {
3346 if (redir2[strlen(redir2)-1] != '/') {
3347 strcat(redir2,"/");
3348 }
3349 }
3350
3351 /* and if we are adding a file, add its filename */
3352 if (strlen(redir2) + strlen(filename) < MAXLINE) {
3353 strcat(redir2, filename);
3354 }
3355
3356 /* might be needed if stat == 2 */
3357 get_reducedpath(common, reducedpath);
3358
3359 /* allocate new entry */
3360 mstr = g_new0(mstr_redirect_t,1);
3361 mstr->mstr_path = g_strdup(path);
3362 masterparam.mstr_redir = g_list_append(masterparam.mstr_redir, mstr);
3363
3364 /* add with full path */
3365 if (stat == 0) {
3366 if (strlen(redir2) > 0) {
3367 add_redir_mstr_glist( &masterparam.mstr_redir,
3368 path, redir2);
3369 }
3370 return 1;
3371 }
3372 /* add with common part removed */
3373 if (stat == 1) {
3374 strncpy(redir3,redir2+strlen(common), MAXLINE);
3375 if (strlen(redir3) > 0) {
3376 add_redir_mstr_glist( &masterparam.mstr_redir,
3377 path, redir3);
3378 }
3379 return 1;
3380 }
3381 /* add with common part removed (one level less) */
3382 if (stat == 2) {
3383 strncpy(redir3,redir2+strlen(reducedpath), MAXLINE);
3384 if (strlen(redir3) > 0) {
3385 add_redir_mstr_glist( &masterparam.mstr_redir,
3386 path, redir3);
3387 }
3388 return 1;
3389 }
3390 /* add with common part replaced */
3391 if (stat == 3) {
3392 strncpy(redir3,redir2+strlen(common), MAXLINE);
3393 strncpy(redir2,redir, MAXLINE);
3394 strcat(redir2, redir3);
3395 if (strlen(redir2) > 1) {
3396 if (redir2[0] == '/' && redir2[1] == '/') {
3397 /* on slash to much - remove it */
3398 strncpy(redir3, redir2+1, MAXLINE);
3399 strncpy(redir2, redir3, MAXLINE);
3400 }
3401 }
3402 if (strlen(redir2) > 0) {
3403 add_redir_mstr_glist( &masterparam.mstr_redir,
3404 path, redir2);
3405 }
3406 return 1;
3407 }
3408
3409 return 0;
3410 }
3411
3412
3413 /* add a glist with filenames to the master-directories */
3414
add_master_dir_multiple(GList * sel_dirs)3415 static void add_master_dir_multiple(GList *sel_dirs) {
3416 gchar redir[MAXLINE], dir[MAXLINE];
3417 mstr_redirect_t *mstr;
3418 gint stat, added;
3419 GList *loop;
3420 gchar commonstr[MAXLINE];
3421
3422 added = 0;
3423
3424 /* handling for single selected files */
3425 if (g_list_length(sel_dirs) == 1) {
3426 loop = g_list_first(sel_dirs);
3427 strncpy(dir, loop->data, MAXLINE);
3428
3429 /* valid file? */
3430 if (is_file(dir) == 0) {
3431 show_dialog(ICO_INFO,_("No valid path specified"),T_OK,NULL,NULL,0);
3432 return;
3433 }
3434
3435 /* add to glist */
3436 if (check_in_mstr_glist(&masterparam.mstr_redir, dir) == 0) {
3437
3438 /* show menu selecting where to add the file */
3439 stat = show_mstr_redir(dir, redir);
3440 if (stat == 0) {
3441 mstr = g_new0(mstr_redirect_t,1);
3442 mstr->mstr_path = g_strdup(dir);
3443 masterparam.mstr_redir = g_list_append(masterparam.mstr_redir, mstr);
3444 if (strlen(redir) > 0) {
3445 add_redir_mstr_glist(
3446 &masterparam.mstr_redir,
3447 dir, redir);
3448 }
3449 added = 1;
3450 }
3451
3452 } else {
3453 /* path already added */
3454 show_dialog(ICO_WARN,_("Path already added"),T_OK,NULL,NULL,0);
3455 return;
3456 }
3457 } else {
3458 /* multiple files selected */
3459
3460 /* get common path component */
3461 get_common_path_component(sel_dirs, commonstr);
3462
3463 stat = show_mstr_redir_multi(commonstr,
3464 g_list_length(sel_dirs), redir);
3465 if (stat >= 0) {
3466 loop = g_list_first(sel_dirs);
3467 while (loop) {
3468 added += add_mult_mstr_file(
3469 (gchar *) loop->data,
3470 stat, redir, commonstr);
3471
3472 loop = loop->next;
3473 }
3474 }
3475 }
3476
3477 if (added) {
3478 ctree_unselect_all();
3479 }
3480
3481 fill_session_view(0);
3482 }
3483
3484
3485 /* callback for add-button in master-source */
3486
add_master_dir(GtkWidget * widget,GtkWidget * entry)3487 static void add_master_dir(GtkWidget *widget, GtkWidget *entry) {
3488 gchar dir[MAXLINE];
3489 GList *sel_dirs;
3490
3491 sel_dirs = NULL;
3492
3493 strcpy(dir,gtk_entry_get_text(GTK_ENTRY(entry)));
3494 strip_string(dir);
3495
3496 /* empty string? abort */
3497 if (!*dir) return;
3498
3499 /* expand tilde */
3500 check_tilde(dir);
3501 gtk_entry_set_text(GTK_ENTRY(entry), dir);
3502 convert_for_gtk2_filename(dir);
3503
3504 if (dir[0] == '(') {
3505 /* multiple selected? get from ctree */
3506 ctree_get_selected(&sel_dirs);
3507 } else {
3508 sel_dirs=g_list_append(sel_dirs, g_strdup(dir));
3509 }
3510
3511 add_master_dir_multiple(sel_dirs);
3512 free_glist(&sel_dirs);
3513 }
3514
3515
3516 /* exclude a glist from the master directories */
3517
exclude_master_dir_multiple(GList * sel_dirs)3518 static void exclude_master_dir_multiple(GList *sel_dirs) {
3519 GList *loop;
3520 gint added;
3521
3522 added = 0;
3523
3524 loop = g_list_first(sel_dirs);
3525 while (loop) {
3526 /* add to glist */
3527 if (check_in_glist(&masterparam.exclude_paths, loop->data ) == 0) {
3528 masterparam.exclude_paths = g_list_append(
3529 masterparam.exclude_paths, g_strdup(loop->data));
3530 added = 1;
3531 } else {
3532 /* path already added */
3533 if (g_list_length(sel_dirs) == 1)
3534 show_dialog(ICO_WARN,_("Path already added"),T_OK,NULL,NULL,0);
3535 }
3536 loop = loop->next;
3537 }
3538
3539 if (added) {
3540 ctree_unselect_all();
3541 }
3542
3543 fill_session_view(0);
3544 }
3545
3546
3547 /* callback for exclude-button in master-source */
3548
exclude_master_dir(GtkWidget * widget,GtkWidget * entry)3549 static void exclude_master_dir(GtkWidget *widget, GtkWidget *entry) {
3550 gchar dir[MAXLINE];
3551 GList *sel_dirs;
3552
3553 sel_dirs = NULL;
3554
3555 /* multiple dirs selected? */
3556 strcpy(dir,gtk_entry_get_text(GTK_ENTRY(entry)));
3557 strip_string(dir);
3558 convert_for_gtk2_filename(dir);
3559
3560 /* empty string? abort */
3561 if (!*dir) return;
3562
3563 if (dir[0] == '(') {
3564 /* multiple selected? get from ctree */
3565 ctree_get_selected(&sel_dirs);
3566 } else {
3567 sel_dirs=g_list_append(sel_dirs, g_strdup(dir));
3568 }
3569
3570 /* valid file? */
3571 /* disabled..allow all here now */
3572 /*
3573 if (is_file(dir) == 0) {
3574 show_dialog(ICO_INFO,_("No valid path specified"),T_OK,NULL,NULL,0);
3575 return;
3576 }
3577 */
3578
3579 exclude_master_dir_multiple(sel_dirs);
3580 free_glist(&sel_dirs);
3581 }
3582
3583
3584 /* callback for remove-button in master-source */
3585
remove_master_dir(GtkWidget * widget,gpointer data)3586 static void remove_master_dir(GtkWidget *widget, gpointer data) {
3587 GList *sel;
3588 gint row, type;
3589 gchar *rowdata;
3590 gchar tmp2[MAXLINE];
3591 gint nrtracks = 0;
3592
3593 nrtracks = 0;
3594
3595 sel = cdlist->selection;
3596 while (sel) {
3597 row = GPOINTER_TO_INT(sel->data);
3598 type = GPOINTER_TO_INT(gtk_clist_get_row_data(cdlist,row));
3599 if (type == 0) {
3600 /* invalid row */
3601 show_dialog(ICO_WARN,_("No valid path specified"),T_OK,NULL,NULL,0);
3602 } else {
3603 gtk_clist_get_text(cdlist,row,1,&rowdata);
3604 extract_mstr_path_from_clist(rowdata, tmp2);
3605 if (type == 1) {
3606 del_mstr_glist_link(&masterparam.mstr_redir,
3607 tmp2, 1);
3608 } else {
3609 del_glist_link(&masterparam.exclude_paths,
3610 tmp2);
3611 }
3612 }
3613 nrtracks++;
3614 sel = sel->next;
3615 }
3616
3617 /* no tracks selected */
3618 if (nrtracks == 0) {
3619 show_dialog(ICO_INFO,_("No path selected to remove"),T_OK,NULL,NULL,0);
3620 } else {
3621 fill_session_view(0);
3622 }
3623 }
3624
3625
3626 /* called when path are dragged off from the master path window */
3627
remove_master_dir_by_drag(GList * sel)3628 void remove_master_dir_by_drag(GList *sel) {
3629 GList *loop;
3630 gchar *path;
3631 gint type, count;
3632 gchar tmp2[MAXLINE];
3633
3634 count = 0;
3635 loop = g_list_first(sel);
3636 while (loop) {
3637 path = (gchar *)loop->data;
3638 if (path) {
3639 /* extract type and real path */
3640 if (strlen(path) > 2 && path[1] == ';') {
3641 type = path[0] - (gint)'0';
3642 strncpy(tmp2, path+2, MAXLINE);
3643
3644 if (type == 1) {
3645 del_mstr_glist_link(
3646 &masterparam.mstr_redir,
3647 tmp2, 1);
3648 } else
3649 if (type == 2) {
3650 del_glist_link(
3651 &masterparam.exclude_paths,
3652 tmp2);
3653 }
3654 count++;
3655 }
3656 }
3657 loop = loop->next;
3658 }
3659
3660 /* we actually deleted something? */
3661 if (count > 0) {
3662 /* redraw */
3663 fill_session_view(0);
3664
3665 /* and force the focus to be somewhere else because it
3666 looks strange */
3667 gtk_widget_grab_focus(cdlist_l1);
3668 }
3669 }
3670
3671
3672 /* callback for redirect path (single and multiple) */
3673
redirect_master_dir(GtkWidget * widget,gpointer data)3674 static void redirect_master_dir(GtkWidget *widget, gpointer data) {
3675 GList *sel, *sel_dirs, *loop;
3676 gint row, type, count;
3677 gint type0, type1, type2;
3678 gchar *rowdata;
3679 gchar tmp[MAXLINE];
3680 gchar tmp2[MAXLINE];
3681 gchar tmp3[MAXLINE];
3682 gchar commonstr[MAXLINE];
3683 gchar filename[MAXLINE];
3684
3685 sel_dirs = NULL;
3686
3687 sel = cdlist->selection;
3688 count = g_list_length(sel);
3689
3690 if (count == 1) {
3691 row = GPOINTER_TO_INT(sel->data);
3692 type = GPOINTER_TO_INT(gtk_clist_get_row_data(cdlist,row));
3693 if (type == 0) {
3694 /* invalid row */
3695 show_dialog(ICO_WARN,_("No valid path specified"),T_OK,NULL,NULL,0);
3696 } else
3697 if (type == 2) {
3698 /* excluded row */
3699 show_dialog(ICO_WARN,_("An excluded path cannot be redirected"),T_OK,NULL,NULL,0);
3700 } else {
3701 gtk_clist_get_text(cdlist,row,1,&rowdata);
3702 extract_mstr_path_from_clist(rowdata, tmp2);
3703 get_redir_path_from_mstr_glist(&masterparam.mstr_redir,
3704 tmp2, tmp);
3705 if (show_request_redirect_path(tmp2, tmp) == 0) {
3706 if (strlen(tmp) > 0) {
3707 add_redir_mstr_glist(
3708 &masterparam.mstr_redir,
3709 tmp2, tmp);
3710 } else {
3711 /* remove redirection */
3712 del_mstr_glist_link(
3713 &masterparam.mstr_redir,
3714 tmp2, -1);
3715 }
3716 }
3717
3718 fill_session_view(0);
3719 }
3720 } else
3721 if (count == 0) {
3722 show_dialog(ICO_INFO,_("No path selected to redirect"),T_OK,NULL,NULL,0);
3723 } else {
3724 /* multiple paths selected */
3725
3726 /* first check if all selected paths are of same time */
3727 type0 = 0;
3728 type1 = 0;
3729 type2 = 0;
3730 loop = g_list_first(sel);
3731 while (loop) {
3732 row = GPOINTER_TO_INT(loop->data);
3733 type = GPOINTER_TO_INT(gtk_clist_get_row_data(cdlist,row));
3734 if (type == 0) {
3735 type0++;
3736 }
3737 if (type == 1) {
3738 type1++;
3739 }
3740 if (type == 2) {
3741 type2++;
3742 }
3743 loop = loop->next;
3744 }
3745 if (type0 > 0) {
3746 /* invalid row */
3747 show_dialog(ICO_WARN,_("No valid path specified"),T_OK,NULL,NULL,0);
3748 } else
3749 if (type2 > 0) {
3750 /* excluded row */
3751 show_dialog(ICO_WARN,_("An excluded path cannot be redirected"),T_OK,NULL,NULL,0);
3752 } else {
3753 /* all ok so far - only master paths selected */
3754 /* create glist with the selected paths */
3755 loop = g_list_first(sel);
3756 while (loop) {
3757 row = GPOINTER_TO_INT(loop->data);
3758 gtk_clist_get_text(cdlist,row,1,&rowdata);
3759 extract_mstr_path_from_clist(rowdata, tmp2);
3760 sel_dirs=g_list_append(sel_dirs, g_strdup(tmp2));
3761
3762 loop = loop->next;
3763 }
3764
3765 /* get common path component */
3766 get_common_path_component(sel_dirs, commonstr);
3767
3768 if (show_request_redirect_path_multiple(commonstr, g_list_length(sel_dirs), tmp) == 0) {
3769 if (strlen(tmp) > 0) {
3770
3771 loop = g_list_first(sel_dirs);
3772 while (loop) {
3773 if (is_directory(loop->data)) {
3774 add_redir_mstr_glist(
3775 &masterparam.mstr_redir,
3776 loop->data, tmp);
3777 } else {
3778 /* redirecting a file? */
3779 get_purefile(loop->data, filename);
3780 g_snprintf(tmp3,MAXLINE,"%s%s", tmp, filename);
3781 add_redir_mstr_glist(
3782 &masterparam.mstr_redir,
3783 loop->data, tmp3);
3784 }
3785 loop = loop->next;
3786 }
3787 } else {
3788 /* remove redirection */
3789 loop = g_list_first(sel_dirs);
3790 while (loop) {
3791 del_mstr_glist_link(
3792 &masterparam.mstr_redir,
3793 loop->data, -1);
3794
3795 loop = loop->next;
3796 }
3797 }
3798 }
3799
3800 fill_session_view(0);
3801
3802 }
3803 }
3804
3805 }
3806
3807
3808 /* fill the session-view clist */
3809 /* if checkmedia = -1, then dont check, but show info about update button */
3810
fill_session_view(gint checkmedia)3811 static void fill_session_view(gint checkmedia) {
3812 GtkStyle *style;
3813 gchar *data[2];
3814 GdkPixmap *pixmap1, *pixmap2, *pixmap3, *pixmap4;
3815 GdkBitmap *mask1, *mask2, *mask3, *mask4;
3816 gint i, j, lcount, orglcount;
3817 gchar tmp[MAXLINE];
3818 gchar tmp2[MAXLINE];
3819 gchar tmp3[MAXLINE];
3820 GList *loop;
3821 mstr_redirect_t *mstr;
3822 gint msinfo1, msinfo2;
3823 gint toprow, topcol;
3824
3825 /* get current scroll position */
3826 if(!gtk_clist_get_selection_info(cdlist, 0, 0, &toprow, &topcol)) {
3827 toprow = 0;
3828 topcol = 0;
3829 }
3830
3831 /* clean up first */
3832 gtk_clist_freeze(cdlist);
3833 gtk_clist_clear(cdlist);
3834
3835 style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(cdlist)));
3836 pixmap1 = gdk_pixmap_create_from_xpm_d(cdlist->clist_window,
3837 &mask1, &style->bg[GTK_STATE_NORMAL],(gchar **)minidata_xpm);
3838 pixmap2 = gdk_pixmap_create_from_xpm_d(cdlist->clist_window,
3839 &mask2, &style->bg[GTK_STATE_NORMAL],(gchar **)miniaudio_xpm);
3840 pixmap3 = gdk_pixmap_create_from_xpm_d(cdlist->clist_window,
3841 &mask3, &style->bg[GTK_STATE_NORMAL],(gchar **)masteradd_xpm);
3842 pixmap4 = gdk_pixmap_create_from_xpm_d(cdlist->clist_window,
3843 &mask4, &style->bg[GTK_STATE_NORMAL],(gchar **)masterdel_xpm);
3844
3845 lcount = 0;
3846 msinfo1 = -1;
3847 msinfo2 = -1;
3848 data[0] = NULL;
3849
3850 /* no cd loaded? */
3851 if (cdinfo.nr_tracks == -1) {
3852 strncpy(tmp3, _("No CD loaded"), MAXLINE);
3853 data[1] = convert_for_gtk2(tmp3);
3854 gtk_clist_append(cdlist,data);
3855 gtk_clist_set_row_data(cdlist,lcount,GINT_TO_POINTER(0));
3856 lcount++;
3857 } else {
3858 /* at least something in drive? try to get msinfo */
3859 if (curset.writer_devnr != -1 && checkmedia == 1) {
3860 get_msinfo_info(curset.writer_devnr, &msinfo1,
3861 &msinfo2);
3862 }
3863 }
3864
3865 if (checkmedia == 1) {
3866 /* save session info */
3867 masterparam.last_session_start = msinfo1;
3868 masterparam.next_session_start = msinfo2;
3869
3870 /* remember we requested the session info */
3871 session_current_state = 1;
3872 }
3873
3874 if (checkmedia == -1) {
3875 /* just entered menu anew? */
3876 /* set state to "we dont know session info yet" */
3877 session_current_state = 0;
3878 }
3879
3880 /* empty cd loaded */
3881 if (cdinfo.nr_tracks == -2) {
3882 strncpy(tmp3, return_media_type(curset.writer_devnr), MAXLINE);
3883 data[1] = convert_for_gtk2(tmp3);
3884 gtk_clist_append(cdlist,data);
3885 gtk_clist_set_row_data(cdlist,lcount,GINT_TO_POINTER(0));
3886 gtk_clist_set_selectable(cdlist,lcount,FALSE);
3887 lcount++;
3888 }
3889
3890 if (session_current_state == 0 && cdinfo.nr_tracks > 0) {
3891 /* CD inserted, but we havnt checked for msinfo? */
3892 /* tell the user to click 'update' to see more */
3893
3894 strncpy(tmp3, _("Click \"Update Session view\" to"), MAXLINE);
3895 data[1] = convert_for_gtk2(tmp3);
3896 gtk_clist_append(cdlist,data);
3897 gtk_clist_set_row_data(cdlist,lcount,GINT_TO_POINTER(0));
3898 gtk_clist_set_selectable(cdlist,lcount,FALSE);
3899 lcount++;
3900 strncpy(tmp3, _("check the sessions of the media."), MAXLINE);
3901 data[1] = convert_for_gtk2(tmp3);
3902 gtk_clist_append(cdlist,data);
3903 gtk_clist_set_row_data(cdlist,lcount,GINT_TO_POINTER(0));
3904 gtk_clist_set_selectable(cdlist,lcount,FALSE);
3905 lcount++;
3906
3907 /* invalidate session info */
3908 masterparam.last_session_start = -1;
3909 masterparam.next_session_start = -1;
3910
3911 } else {
3912 /* display track listing */
3913 for (i = 0; i < cdinfo.nr_tracks; i++) {
3914 if (trackinfo[i]->type == 0) {
3915 convert_frames2mbstring(trackinfo[i]->size,tmp2);
3916 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
3917 trackinfo[i]->track_nr,
3918 _("data track"), tmp2);
3919 data[1] = convert_for_gtk2(tmp);
3920 gtk_clist_append(cdlist,data);
3921 gtk_clist_set_pixmap(cdlist,lcount,0,pixmap1,mask1);
3922 gtk_clist_set_row_data(cdlist,lcount,GINT_TO_POINTER(0));
3923 lcount++;
3924 } else {
3925 convert_frames2minstring(trackinfo[i]->size,tmp2);
3926 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
3927 trackinfo[i]->track_nr,
3928 _("audio track"), tmp2);
3929 data[1] = convert_for_gtk2(tmp);
3930 gtk_clist_append(cdlist,data);
3931 gtk_clist_set_pixmap(cdlist,lcount,0,pixmap2,mask2);
3932 gtk_clist_set_row_data(cdlist,lcount,GINT_TO_POINTER(0));
3933 lcount++;
3934 }
3935 }
3936 }
3937
3938 /* draw seperator */
3939 strcpy(tmp,"_________________");
3940 data[1] = convert_for_gtk2(tmp);
3941 gtk_clist_append(cdlist,data);
3942 gtk_clist_set_row_data(cdlist,lcount,GINT_TO_POINTER(0));
3943 gtk_clist_set_selectable(cdlist,lcount,FALSE);
3944 lcount++;
3945 strcpy(tmp,"");
3946 data[1] = convert_for_gtk2(tmp);
3947 gtk_clist_append(cdlist,data);
3948 gtk_clist_set_row_data(cdlist,lcount,GINT_TO_POINTER(0));
3949 gtk_clist_set_selectable(cdlist,lcount,FALSE);
3950 lcount++;
3951
3952 orglcount = lcount;
3953
3954 /* draw master-dirs */
3955 loop = g_list_first(masterparam.mstr_redir);
3956 while (loop) {
3957 mstr = (mstr_redirect_t *) loop->data;
3958 if (mstr) {
3959 if (mstr->mstr_path && !mstr->redir_path) {
3960 /* no redir available */
3961 strncpy(tmp3, mstr->mstr_path, MAXLINE);
3962 data[1] = convert_for_gtk2(tmp3);
3963 } else
3964 if (mstr->mstr_path && mstr->redir_path) {
3965 g_snprintf(tmp,MAXLINE,"%s => %s",
3966 mstr->mstr_path, mstr->redir_path);
3967 data[1] = convert_for_gtk2(tmp);
3968 } else {
3969 data[1] = "";
3970 }
3971 } else {
3972 data[1] = "";
3973 }
3974
3975 gtk_clist_append(cdlist,data);
3976 gtk_clist_set_pixmap(cdlist,lcount,0,pixmap3,mask3);
3977 gtk_clist_set_row_data(cdlist,lcount,GINT_TO_POINTER(1));
3978 lcount++;
3979
3980 loop = loop->next;
3981 }
3982
3983 /* draw exclude-dirs */
3984 loop = g_list_first(masterparam.exclude_paths);
3985 while (loop) {
3986 strncpy(tmp3, (gchar *)loop->data, MAXLINE);
3987 data[1] = convert_for_gtk2(tmp3);
3988
3989 gtk_clist_append(cdlist,data);
3990 gtk_clist_set_pixmap(cdlist,lcount,0,pixmap4,mask4);
3991 gtk_clist_set_row_data(cdlist,lcount,GINT_TO_POINTER(2));
3992 lcount++;
3993
3994 loop = loop->next;
3995 }
3996
3997 /* make session-size invalid, because we changed the paths */
3998 set_sessionsize_unknown();
3999
4000 /* have we added any paths? No? Show help about right click */
4001 if (orglcount == lcount) {
4002 strncpy(tmp3, _("(right click for context menu)"), MAXLINE);
4003 data[1] = convert_for_gtk2(tmp3);
4004 gtk_clist_append(cdlist,data);
4005 gtk_clist_set_row_data(cdlist,lcount,GINT_TO_POINTER(0));
4006 gtk_clist_set_selectable(cdlist,lcount,FALSE);
4007 lcount++;
4008 data[1] = "";
4009 for (j = 0; j < 6; j++) {
4010 gtk_clist_append(cdlist,data);
4011 gtk_clist_set_row_data(cdlist,lcount,GINT_TO_POINTER(0));
4012 gtk_clist_set_selectable(cdlist,lcount,FALSE);
4013 lcount++;
4014 }
4015 strncpy(tmp3, _(" Drop files to exclude here ->"), MAXLINE);
4016 data[1] = convert_for_gtk2(tmp3);
4017 gtk_clist_append(cdlist,data);
4018 gtk_clist_set_row_data(cdlist,lcount,GINT_TO_POINTER(0));
4019 gtk_clist_set_selectable(cdlist,lcount,FALSE);
4020 lcount++;
4021
4022 }
4023
4024 /* now scroll to remembered position */
4025 gtk_clist_moveto(cdlist, toprow, topcol, 0.0, 0.0);
4026 gtk_clist_thaw(cdlist);
4027
4028 }
4029
4030
4031 /* calculate free and used space and display */
4032
fill_session_available()4033 static void fill_session_available() {
4034 gchar tmp[MAXLINE];
4035 gint cdsize, used, avail;
4036 gint64 tmpsize;
4037
4038 /* current available size according to media-selector */
4039 /* in sectors */
4040 if (curset.cdrtype < 1000) {
4041 cdsize = curset.cdrtype*60*75;
4042 } else {
4043 /* capacity of a DVD in bytes */
4044 tmpsize = (gint64)curset.cdrtype * 1000 * 1000;
4045 /* and now in sectors */
4046 tmpsize = tmpsize / 2048;
4047
4048 cdsize = (gint) tmpsize;
4049 }
4050 used = 0;
4051 avail = cdsize;
4052
4053 /* we want to write multisession? consider session overhead */
4054 if (curset.multisession == 1) {
4055 if (cdinfo.nr_tracks > 0) {
4056 /* additional sessions */
4057 avail -= 6900; /* about 13 MB */
4058 } else {
4059 /* first session */
4060 avail -= 11400; /* about 22 MB */
4061 }
4062
4063 /* disable write mode selector in ms mode */
4064 if (crea_cd_mode_omenu && curset.writer_devnr != -1) {
4065 gtk_widget_set_sensitive(crea_cd_mode_omenu, FALSE);
4066 }
4067 } else {
4068 if (crea_cd_mode_omenu && curset.writer_devnr != -1) {
4069 gtk_widget_set_sensitive(crea_cd_mode_omenu, TRUE);
4070 }
4071 }
4072
4073 /* multisession CD with some sessions? */
4074 if (masterparam.next_session_start > 0) {
4075 used += masterparam.next_session_start;
4076 avail -= masterparam.next_session_start;
4077 }
4078 /* transform sectors into MB */
4079 used = used * (DATASECTORSIZE/1024)/1024;
4080 avail = avail * (DATASECTORSIZE/1024)/1024;
4081
4082 /* tracks, but not yet checked for msinfo? */
4083 if (cdinfo.nr_tracks > 0 && session_current_state == 0) {
4084 strncpy(tmp,_("Unknown"), MAXLINE);
4085 } else
4086 /* tracks, but no multisession? */
4087 if (cdinfo.nr_tracks > 0 && masterparam.next_session_start == -1) {
4088 strncpy(tmp,_("CD closed"), MAXLINE);
4089 } else {
4090 /* empty/no CD or multisession CD */
4091 g_snprintf(tmp,MAXLINE,"%dMB / %dMB", used, avail);
4092 }
4093 gtk_entry_set_text(GTK_ENTRY(master_avail_entry), tmp);
4094
4095 /* tracks, but not yet checked for msinfo? */
4096 if (cdinfo.nr_tracks > 0 && session_current_state == 0) {
4097 g_snprintf(tmp,MAXLINE," - / %dMB", avail);
4098 } else
4099 /* tracks, but no multisession? (display in menu5) */
4100 if (cdinfo.nr_tracks > 0 && masterparam.next_session_start == -1) {
4101 g_snprintf(tmp,MAXLINE," - / %dMB", avail);
4102 } else {
4103 /* empty/no CD or multisession CD */
4104 g_snprintf(tmp,MAXLINE,"%dMB / %dMB", used, avail);
4105 }
4106 if (cdlist_l1) {
4107 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), tmp);
4108 }
4109 }
4110
4111
4112 /* check cd in writer-dev and redraw */
4113
session_view_update(GtkWidget * widget,gpointer data)4114 static void session_view_update(GtkWidget *widget, gpointer data) {
4115 GdkCursor *cursor;
4116
4117 do_lock(1);
4118 /* change cursor to watch */
4119 cursor = gdk_cursor_new(GDK_WATCH);
4120 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
4121
4122 while (gtk_events_pending())
4123 gtk_main_iteration();
4124
4125 if (curset.writer_devnr != -1) {
4126 get_cd_toc_and_volid(curset.writer_devnr);
4127 }
4128 /* called from button */
4129 if (widget) {
4130 fill_session_view(1);
4131 } else {
4132 /* called from startup */
4133 fill_session_view(-1);
4134 }
4135
4136 fill_session_available();
4137
4138 /* reset cursor */
4139 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
4140 gdk_cursor_destroy (cursor);
4141
4142 do_unlock(1);
4143 }
4144
4145
4146 /* called when a context menu entry is selected */
4147
context_response(gint nr)4148 static void context_response(gint nr) {
4149 gchar tmp[MAXLINE];
4150 gchar tmp2[MAXLINE];
4151 gint stat;
4152
4153 /* select all */
4154 if (nr == 0) {
4155 gtk_clist_select_all(cdlist);
4156 }
4157
4158 /* unselect all */
4159 if (nr == 1) {
4160 gtk_clist_unselect_all(cdlist);
4161 }
4162
4163 /* load list selected? */
4164 if (nr == 2) {
4165 /* show fileselector */
4166 show_file_selector(_("Load list of paths to master"), SAVEMASTERLIST,tmp);
4167
4168 if (strcmp(tmp,"") != 0) {
4169 stat = load_master_list(tmp);
4170 if (stat == 1) {
4171 /* load failed */
4172 g_snprintf(tmp2,MAXLINE,_("Error reading file %s"),tmp);
4173 show_dialog(ICO_ERROR,tmp2, T_OK, NULL, NULL, 0);
4174 }
4175 fill_session_view(0);
4176 }
4177 }
4178
4179 /* save list selected? */
4180 if (nr == 3) {
4181 /* show fileselector */
4182 show_file_selector(_("Save list of paths to master"), SAVEMASTERLIST,tmp);
4183
4184 if (strcmp(tmp,"") != 0) {
4185 stat = save_master_list(tmp);
4186 if (stat == 1) {
4187 /* save failed */
4188 g_snprintf(tmp2,MAXLINE,_("Error writing file %s"),tmp);
4189 show_dialog(ICO_ERROR,tmp2, T_OK, NULL, NULL, 0);
4190 }
4191 if (stat == 0) {
4192 /* save ok */
4193 show_dialog(ICO_INFO,_("List of paths to master saved successfully"), T_OK, NULL, NULL, 0);
4194 }
4195 }
4196 }
4197
4198 /* delete list selected ? */
4199 if (nr == 4) {
4200 stat = show_dialog(ICO_WARN,_("Are you sure you want to remove all\nthe paths from the list?"),T_YES,T_NO,NULL,0);
4201 if (stat == 1) return;
4202
4203 /* user is sure, so clear list */
4204 clear_mstr_glist(&masterparam.mstr_redir);
4205 free_glist(&masterparam.exclude_paths);
4206
4207 fill_session_view(0);
4208 }
4209 }
4210
4211
4212 /* called when a context menu entry is selected in the directory view */
4213
context_response2(gint nr)4214 static void context_response2(gint nr) {
4215
4216 /* unselect all selected? */
4217 if (nr == 0) {
4218 ctree_unselect_all();
4219 }
4220 }
4221
4222
4223 /* called by a click on the session-view or directory-view */
4224
activate_context(GtkWidget * widget,GdkEvent * event)4225 static gint activate_context(GtkWidget *widget, GdkEvent *event) {
4226
4227 if (event->button.button == 3) {
4228 /* show context menu */
4229 gtk_menu_popup(GTK_MENU(widget), NULL, NULL,
4230 NULL, NULL, event->button.button, event->button.time);
4231 return TRUE;
4232 }
4233 return FALSE;
4234 }
4235
mstr_press_event(GtkWidget * widget,GdkEventKey * event)4236 static gint mstr_press_event(GtkWidget *widget, GdkEventKey *event) {
4237
4238 /* see if backspace or delete key is pressed in master menu */
4239 if (event->keyval == GDK_BackSpace ||
4240 event->keyval == GDK_Delete) {
4241 gtk_button_clicked(GTK_BUTTON(widget));
4242 }
4243
4244 return TRUE;
4245 }
4246
4247
4248 /* called when a drag is received on the entry */
4249
entry_masterdir_drag_received(GtkWidget * widget,GdkDragContext * dc,gint x,gint y,GtkSelectionData * selection_data,guint info,guint t,gpointer data)4250 static void entry_masterdir_drag_received(GtkWidget *widget,
4251 GdkDragContext *dc, gint x, gint y, GtkSelectionData *selection_data,
4252 guint info, guint t, gpointer data) {
4253 gchar *text;
4254 gchar newdir[MAXLINE];
4255
4256 /* nothing received? ignore */
4257 if(selection_data == NULL)
4258 return;
4259 if(selection_data->length < 0)
4260 return;
4261
4262 if ((info == DRAG_TAR_INFO_0) ||
4263 (info == DRAG_TAR_INFO_1) ||
4264 (info == DRAG_TAR_INFO_2)) {
4265 text = (char *) selection_data->data;
4266 if (extract_single_drag_filename(text, selection_data->length, newdir)) {
4267 /* extracted the plain filename from drag */
4268 if (strcmp(newdir,"") != 0) {
4269 dodebug(3,"Received from drag: %s\n", newdir);
4270 gtk_entry_set_text(data, newdir);
4271
4272 /* scroll to that path in the dir browser */
4273 ctree_expand_manualpath(data, NULL);
4274 }
4275 }
4276 }
4277 }
4278
4279
4280 /* called when a drag is received on the masterdir clist */
4281
masterdirs_drag_received(GtkWidget * widget,GdkDragContext * dc,gint x,gint y,GtkSelectionData * selection_data,guint info,guint t,gpointer data)4282 static void masterdirs_drag_received(GtkWidget *widget,
4283 GdkDragContext *dc, gint x, gint y, GtkSelectionData *selection_data,
4284 guint info, guint t, gpointer data) {
4285 GList *input, *loop;
4286 gchar *text;
4287 gint action;
4288
4289 input = NULL;
4290 action = GPOINTER_TO_INT(data);
4291
4292 /* nothing received? ignore */
4293 if(selection_data == NULL)
4294 return;
4295 if(selection_data->length < 0)
4296 return;
4297
4298 if ((info == DRAG_TAR_INFO_0) ||
4299 (info == DRAG_TAR_INFO_1) ||
4300 (info == DRAG_TAR_INFO_2)) {
4301 text = (char *) selection_data->data;
4302 if (extract_glist_drag_filenames(text, selection_data->length,
4303 "file:", &input)) {
4304
4305 if (debug) {
4306 loop = g_list_first(input);
4307 while(loop) {
4308 if (loop->data != NULL)
4309 dodebug(3,"Received from drag: %s\n", (gchar *)loop->data);
4310 loop = loop->next;
4311 }
4312 }
4313
4314 /* add or exclude action? */
4315 if (action == 0) {
4316 exclude_master_dir_multiple(input);
4317 } else {
4318 add_master_dir_multiple(input);
4319 }
4320 free_glist(&input);
4321 }
4322 }
4323 }
4324
4325
4326 /* allow to drag tracks out of the left track window */
4327 /* to have them deleted */
4328
masterdirs_request_dnddata(GtkWidget * widget,GdkDragContext * dc,GtkSelectionData * selection_data,guint info,guint t,gpointer data)4329 static void masterdirs_request_dnddata(GtkWidget *widget,
4330 GdkDragContext *dc,
4331 GtkSelectionData *selection_data, guint info, guint t,
4332 gpointer data) {
4333 gboolean data_sent = FALSE;
4334 GtkCList *clist;
4335 GList *sel;
4336 gint row, focusrow, bufcount, type;
4337 gchar tmp[MAXLINE], tmp2[MAXLINE];
4338 gchar bigtmp[MAXLINE*10];
4339 gint use_selection;
4340 gchar *rowdata;
4341
4342 clist = GTK_CLIST(widget);
4343 focusrow = clist->focus_row;
4344 use_selection = 0;
4345
4346
4347 /* see if any other rows are selected */
4348 sel = clist->selection;
4349 while (sel) {
4350 row = GPOINTER_TO_INT(sel->data);
4351 if (row == focusrow) {
4352 /* we focused a row that is selected, remember */
4353 use_selection = 1;
4354 }
4355 sel = sel->next;
4356 }
4357
4358 /* Selected row in bounds? */
4359 if ((focusrow >= 0) && (focusrow < clist->rows) && (GTK_WIDGET_HAS_FOCUS(widget))) {
4360
4361 /* return single track from focused line */
4362 if (use_selection == 0) {
4363 type = GPOINTER_TO_INT(gtk_clist_get_row_data(clist,focusrow));
4364 gtk_clist_get_text(clist,focusrow,1,&rowdata);
4365 extract_mstr_path_from_clist(rowdata, tmp2);
4366
4367 g_snprintf(bigtmp, MAXLINE*10, "xrmv:%d;%s", type, tmp2);
4368 gtk_selection_data_set(
4369 selection_data,
4370 GDK_SELECTION_TYPE_STRING, 8,
4371 (const unsigned char *) bigtmp, strlen(bigtmp));
4372 data_sent = TRUE;
4373 } else {
4374 /* return not from focus but all selected */
4375 strcpy(bigtmp,"");
4376 bufcount = 0;
4377 sel = clist->selection;
4378 while (sel) {
4379 row = GPOINTER_TO_INT(sel->data);
4380 type = GPOINTER_TO_INT(gtk_clist_get_row_data(clist,row));
4381 gtk_clist_get_text(clist,row,1,&rowdata);
4382 extract_mstr_path_from_clist(rowdata, tmp);
4383 g_snprintf(tmp2, MAXLINE, "xrmv:%d;%s\r\n", type, tmp);
4384
4385 bufcount+=strlen(tmp2);
4386 if (bufcount < MAXLINE*10) {
4387 strcat(bigtmp,tmp2);
4388 }
4389
4390 sel = sel->next;
4391 }
4392 if (bufcount > 0) {
4393 gtk_selection_data_set(
4394 selection_data,
4395 GDK_SELECTION_TYPE_STRING, 8,
4396 (const unsigned char *) bigtmp, strlen(bigtmp));
4397 data_sent = TRUE;
4398 }
4399 }
4400 }
4401
4402 /* we have to send something even in an error case */
4403 if (!data_sent) {
4404 const gchar *cstrptr = "Error";
4405
4406 gtk_selection_data_set(
4407 selection_data,
4408 GDK_SELECTION_TYPE_STRING, 8,
4409 (const unsigned char *) cstrptr, strlen(cstrptr));
4410 }
4411 }
4412
4413
4414 /* first submenu of master menu */
4415
draw_master_menu1(GtkWidget * box)4416 static void draw_master_menu1(GtkWidget *box) {
4417 GtkWidget *vbox, *hbox, *hhbox;
4418 GtkWidget *f1,* f2, *f3;
4419 GtkWidget *e1, *l1, *entry1;
4420 GtkWidget *tbl, *b1, *delpixmap, *align;
4421 GtkWidget *scrolled_win, *cd_list;
4422 GtkWidget *check, *event_box;
4423 GtkCTree *ctree;
4424 GtkWidget *context_menu, *context_items, *context_menu2;
4425 static const gchar *context_text[] = CONTEXT_MSTRMENU;
4426 gint i;
4427 gchar tmp[MAXLINE];
4428 gchar base_tree[MAXLINE];
4429 gchar *p;
4430 GtkTargetEntry target_entry[3];
4431 GdkPixmap *pixmap;
4432 GdkBitmap *mask;
4433 GtkStyle *style;
4434
4435 /* required for drag&drop setup */
4436 target_entry[0].target = DRAG_TAR_NAME_0;
4437 target_entry[0].flags = 0;
4438 target_entry[0].info = DRAG_TAR_INFO_0;
4439 target_entry[1].target = DRAG_TAR_NAME_1;
4440 target_entry[1].flags = 0;
4441 target_entry[1].info = DRAG_TAR_INFO_1;
4442 target_entry[2].target = DRAG_TAR_NAME_2;
4443 target_entry[2].flags = 0;
4444 target_entry[2].info = DRAG_TAR_INFO_2;
4445
4446 cdlist_l1 = NULL;
4447
4448 /* left and right info-frames */
4449 tbl = gtk_table_new(1,2,TRUE);
4450 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
4451 gtk_table_set_col_spacings(GTK_TABLE(tbl),5);
4452 gtk_box_pack_start(GTK_BOX(box),tbl,TRUE,TRUE,0);
4453 gtk_widget_show(tbl);
4454 f1 = gtk_frame_new(_("Session view"));
4455 set_font_and_color_frame(f1,BOLDFONT,NULL);
4456 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,0,1,0,1);
4457 gtk_widget_show(f1);
4458 f2 = gtk_frame_new(_("File/Directory view"));
4459 set_font_and_color_frame(f2,BOLDFONT,NULL);
4460 gtk_table_attach_defaults(GTK_TABLE(tbl),f2,1,2,0,1);
4461 gtk_widget_show(f2);
4462
4463 /* left info frame */
4464 vbox = gtk_vbox_new(FALSE,0);
4465 gtk_container_add(GTK_CONTAINER(f1),vbox);
4466 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
4467 gtk_widget_show(vbox);
4468
4469 hhbox = gtk_hbox_new(FALSE,0);
4470 gtk_box_pack_start(GTK_BOX(vbox),hhbox,TRUE,TRUE,0);
4471 gtk_widget_show(hhbox);
4472
4473 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4474 gtk_box_pack_start(GTK_BOX(hhbox),scrolled_win,TRUE,TRUE,3);
4475 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4476 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
4477 gtk_widget_show(scrolled_win);
4478
4479 cd_list = gtk_clist_new(2);
4480 gtk_container_add (GTK_CONTAINER (scrolled_win), cd_list);
4481 cdlist = GTK_CLIST(cd_list);
4482 gtk_clist_set_column_width(cdlist, 0, 16);
4483 gtk_clist_set_column_auto_resize(cdlist, 1, TRUE);
4484 if (setupdata.option_selectionmode == 0) {
4485 gtk_clist_set_selection_mode (cdlist, GTK_SELECTION_MULTIPLE);
4486 } else {
4487 gtk_clist_set_selection_mode (cdlist, GTK_SELECTION_EXTENDED);
4488 }
4489
4490 /* init context menu */
4491 context_menu = gtk_menu_new();
4492 i = 0;
4493 while(context_text[i]) {
4494 context_items = gtk_menu_item_new_with_label(
4495 _(context_text[i]));
4496 gtk_menu_append(GTK_MENU(context_menu), context_items);
4497 gtk_signal_connect_object (GTK_OBJECT (context_items),
4498 "activate", GTK_SIGNAL_FUNC(context_response),
4499 GINT_TO_POINTER(i));
4500 gtk_widget_show(context_items);
4501 i++;
4502 }
4503
4504 gtk_signal_connect_object(GTK_OBJECT(cdlist), "button_press_event",
4505 GTK_SIGNAL_FUNC(activate_context), GTK_OBJECT(context_menu));
4506
4507 /* drag&drop setup */
4508 gtk_widget_realize(cd_list);
4509 if(!GTK_WIDGET_NO_WINDOW(cd_list)) {
4510 gtk_drag_dest_set(
4511 cd_list,
4512 GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT |
4513 GTK_DEST_DEFAULT_DROP,
4514 target_entry,
4515 sizeof(target_entry) / sizeof(GtkTargetEntry),
4516 GDK_ACTION_MOVE | GDK_ACTION_COPY
4517 );
4518 gtk_signal_connect(GTK_OBJECT(cd_list), "drag_data_received",
4519 GTK_SIGNAL_FUNC(masterdirs_drag_received),
4520 GINT_TO_POINTER(1));
4521
4522 /* we can send drags, too */
4523 gtk_drag_source_set(
4524 cd_list,
4525 GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
4526 target_entry,
4527 sizeof(target_entry) / sizeof(GtkTargetEntry),
4528 GDK_ACTION_MOVE);
4529 gtk_signal_connect(
4530 GTK_OBJECT(cd_list), "drag_data_get",
4531 GTK_SIGNAL_FUNC(masterdirs_request_dnddata), NULL);
4532 }
4533 gtk_widget_show(cd_list);
4534
4535 /* little drag-to-exclude field */
4536 f3 = gtk_frame_new(NULL);
4537 gtk_frame_set_shadow_type(GTK_FRAME(f3),GTK_SHADOW_IN);
4538 gtk_widget_set_usize(f3, 20, 0);
4539 gtk_box_pack_start(GTK_BOX(hhbox),f3,FALSE,FALSE,0);
4540 gtk_widget_show(f3);
4541
4542
4543 /* needed so we can receive events */
4544 event_box = gtk_event_box_new();
4545 gtk_container_add(GTK_CONTAINER(f3), event_box);
4546 gtk_widget_show(event_box);
4547
4548 /* top align */
4549 align = gtk_alignment_new(0.0,0.0,0,0);
4550 gtk_container_add(GTK_CONTAINER(event_box), align);
4551 gtk_widget_show(align);
4552
4553 /* all little delete icon */
4554 style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(f3)));
4555 pixmap = gdk_pixmap_create_from_xpm_d(f3->window,
4556 &mask, &style->bg[GTK_STATE_NORMAL],(gchar **)masterdel_xpm);
4557 delpixmap = gtk_pixmap_new(pixmap, mask);
4558 gtk_container_add(GTK_CONTAINER(align), delpixmap);
4559 gtk_widget_show(delpixmap);
4560
4561 /* and let us receive drags */
4562 gtk_widget_realize(event_box);
4563 if(!GTK_WIDGET_NO_WINDOW(event_box)) {
4564 gtk_drag_dest_set(event_box, GTK_DEST_DEFAULT_MOTION |
4565 GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
4566 target_entry, sizeof(target_entry) / sizeof(GtkTargetEntry),
4567 GDK_ACTION_MOVE | GDK_ACTION_COPY);
4568
4569 gtk_signal_connect(GTK_OBJECT(event_box), "drag_data_received",
4570 GTK_SIGNAL_FUNC(masterdirs_drag_received),
4571 GINT_TO_POINTER(0));
4572 }
4573
4574 define_tooltip(event_box, _("Drag files or directories on this field when you want them to be excluded from the generated ISO9660 image."));
4575
4576
4577 tbl = gtk_table_new(1,8,TRUE);
4578 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
4579 gtk_table_set_row_spacings(GTK_TABLE(tbl),3);
4580 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,5);
4581 gtk_widget_show(tbl);
4582
4583 l1 = rightjust_gtk_label_new(_("Used/Available:"));
4584 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4,0,1);
4585 gtk_widget_show(l1);
4586
4587 e1 = gtk_entry_new();
4588 master_avail_entry = e1;
4589 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
4590 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,4,8,0,1);
4591 gtk_widget_show(e1);
4592 define_tooltip(e1, _("The space already used on the CD-R/RW by old sessions and the still available space."));
4593
4594 /* buttons at bottom */
4595 hbox = gtk_hbox_new(TRUE,10);
4596 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,5);
4597 gtk_widget_show(hbox);
4598 b1 = gtk_button_new_with_label(_("Remove"));
4599 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
4600 GTK_SIGNAL_FUNC(remove_master_dir), NULL);
4601
4602 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,3);
4603 gtk_widget_show(b1);
4604 define_tooltip(b1, _("Removes the currently selected master directories."));
4605
4606 gtk_signal_connect_object(GTK_OBJECT(cdlist), "key_press_event",
4607 (GtkSignalFunc) mstr_press_event, GTK_OBJECT(b1));
4608
4609 b1 = gtk_button_new_with_label(_("Redirect"));
4610 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
4611 GTK_SIGNAL_FUNC(redirect_master_dir), NULL);
4612 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,3);
4613 gtk_widget_show(b1);
4614 define_tooltip(b1, _("Redirect the currently selected master directory to another virtual location on the CD, without changing anything in the source data."));
4615
4616 hbox = gtk_hbox_new(TRUE,0);
4617 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,0);
4618 gtk_widget_show(hbox);
4619 b1 = gtk_button_new_with_label(_("Update Session view"));
4620 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
4621 GTK_SIGNAL_FUNC(session_view_update), NULL);
4622 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,3);
4623 gtk_widget_show(b1);
4624 define_tooltip(b1, _("Rechecks the inserted CD for session information. (Useful when you just changed the CD-R/RW.)"));
4625
4626 /* right info frame */
4627 vbox = gtk_vbox_new(FALSE,0);
4628 gtk_container_add(GTK_CONTAINER(f2),vbox);
4629 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
4630 gtk_widget_show(vbox);
4631
4632 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4633 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4634 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
4635 gtk_box_pack_start(GTK_BOX(vbox),scrolled_win,TRUE,TRUE,0);
4636 gtk_widget_realize(scrolled_win);
4637 gtk_widget_show(scrolled_win);
4638
4639 entry1 = gtk_entry_new();
4640 gtk_signal_connect(GTK_OBJECT(entry1), "activate",
4641 GTK_SIGNAL_FUNC(entry_masterdir_callback),NULL);
4642 gtk_box_pack_start(GTK_BOX(vbox),entry1,FALSE,FALSE,3);
4643 gtk_widget_show(entry1);
4644 gtk_drag_dest_set(entry1, GTK_DEST_DEFAULT_MOTION |
4645 GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
4646 target_entry, sizeof(target_entry) / sizeof(GtkTargetEntry),
4647 GDK_ACTION_MOVE | GDK_ACTION_COPY);
4648 gtk_signal_connect(GTK_OBJECT(entry1), "drag_data_received",
4649 GTK_SIGNAL_FUNC(entry_masterdir_drag_received),
4650 GTK_ENTRY(entry1));
4651
4652 /* special case, use homedir as filetree base? */
4653 if (strcmp(FILETREEBASE,"$HOME") == 0) {
4654 p = get_pw_home((gint)geteuid());
4655 if (p) {
4656 strncpy(base_tree, p, MAXLINE);
4657 } else {
4658 /* fallback in case user got no home dir? */
4659 strncpy(base_tree, "/tmp", MAXLINE);
4660 }
4661 } else {
4662 strncpy(base_tree, FILETREEBASE, MAXLINE);
4663 }
4664
4665 ctree_okbutton = NULL;
4666 ctree = create_directory_ctree(base_tree,NULL,toplevel,entry1,
4667 !masterparam.show_only_dirs,
4668 masterparam.show_hidden_files, 1);
4669 gtk_clist_set_column_auto_resize(GTK_CLIST(ctree),0,TRUE);
4670 if (setupdata.option_selectionmode == 0) {
4671 gtk_clist_set_selection_mode (GTK_CLIST(ctree), GTK_SELECTION_MULTIPLE);
4672 } else {
4673 gtk_clist_set_selection_mode (GTK_CLIST(ctree), GTK_SELECTION_EXTENDED);
4674 }
4675
4676 gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (ctree));
4677 gtk_widget_show( GTK_WIDGET (ctree));
4678
4679 /* init context menu */
4680 context_menu2 = gtk_menu_new();
4681 context_items = gtk_menu_item_new_with_label(
4682 _("Unselect all"));
4683 gtk_menu_append(GTK_MENU(context_menu2), context_items);
4684 gtk_signal_connect_object (GTK_OBJECT (context_items),
4685 "activate", GTK_SIGNAL_FUNC(context_response2),
4686 GINT_TO_POINTER(0));
4687 gtk_widget_show(context_items);
4688
4689 gtk_signal_connect_object(GTK_OBJECT(ctree), "button_press_event",
4690 GTK_SIGNAL_FUNC(activate_context), GTK_OBJECT(context_menu2));
4691
4692 tbl = gtk_table_new(2,8,TRUE);
4693 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
4694 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,0);
4695 gtk_widget_show(tbl);
4696
4697 check = gtk_check_button_new_with_label(_("Display directories only"));
4698 gtk_signal_connect(GTK_OBJECT(check),"clicked",
4699 GTK_SIGNAL_FUNC(dirview_selected), entry1);
4700 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,8,0,1);
4701 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
4702 masterparam.show_only_dirs);
4703 gtk_widget_show(check);
4704 define_tooltip(check, _("Do only show directories in the fileselector above and don't display single files."));
4705
4706 check = gtk_check_button_new_with_label(_("Display hidden files"));
4707 gtk_signal_connect(GTK_OBJECT(check),"clicked",
4708 GTK_SIGNAL_FUNC(hiddenview_selected), entry1);
4709 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,8,1,2);
4710 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
4711 masterparam.show_hidden_files);
4712 gtk_widget_show(check);
4713 define_tooltip(check, _("Show hidden files (files beginning with a dot) in the fileselector above."));
4714
4715 /* buttons at bottom */
4716 hbox = gtk_hbox_new(TRUE,10);
4717 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,5);
4718 gtk_widget_show(hbox);
4719 b1 = gtk_button_new_with_label(_("Add"));
4720 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
4721 GTK_SIGNAL_FUNC(add_master_dir), entry1);
4722 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,3);
4723 gtk_widget_show(b1);
4724 define_tooltip(b1, _("Add the selected path to the master directories."));
4725
4726 b1 = gtk_button_new_with_label(_("Exclude"));
4727 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
4728 GTK_SIGNAL_FUNC(exclude_master_dir), entry1);
4729 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,3);
4730 gtk_widget_show(b1);
4731
4732 /* concat 2 help strings */
4733 g_snprintf(tmp,MAXLINE,"%s %s",_("Exclude the selected path from the master directories, which means that all data in that path will not be included in the image."), _("Or enter a shell wild-card-style pattern that matches a part of a filename to exclude. For example '*.o' and 'core' will exclude all files ending in '.o' or called 'core' from being mastered to CD. (Enter without quotes)"));
4734 define_tooltip(b1, tmp);
4735
4736 /* by default go to home dir of user in dir browser */
4737 if (g_get_home_dir()) {
4738 gtk_entry_set_text(GTK_ENTRY(entry1), g_get_home_dir());
4739 ctree_expand_manualpath(entry1, NULL);
4740 ctree_unselect_all();
4741 }
4742
4743 /* update session-view */
4744 session_view_update(NULL,NULL);
4745 }
4746
4747
4748 /* redraw the option-grid */
4749
draw_option_grid(gint val)4750 static void draw_option_grid(gint val) {
4751 gint i;
4752 gint types[][24] = MASTER_TYPES;
4753
4754 if (val == -1) {
4755 /* custom setting? */
4756 return;
4757 }
4758
4759 /* only draw the ones visiable in normal (not adv.) dialog */
4760 for(i = 0; i < 24; i++) {
4761 switch(i) {
4762 case 0:
4763 case 1:
4764 case 2:
4765 case 3:
4766 case 4:
4767 case 5:
4768 case 6:
4769 case 7:
4770 case 10:
4771 case 11:
4772 case 13:
4773 case 16:
4774 gtk_toggle_button_set_active(
4775 GTK_TOGGLE_BUTTON(isoopts[i]), types[val][i]);
4776 break;
4777 default:
4778 /* set the non-visible too */
4779 masterparam.opt[i] = types[val][i];
4780 break;
4781 }
4782 }
4783
4784 /* set joilet charset */
4785 gtk_option_menu_set_history(GTK_OPTION_MENU(isoopt_cmenu),
4786 masterparam.charset);
4787 gtk_option_menu_set_history(GTK_OPTION_MENU(isoopt_cmenu2),
4788 masterparam.outcharset);
4789
4790 }
4791
4792
4793 /* read the current option-grid and determine the fitting preset mode */
4794
read_option_grid()4795 static void read_option_grid() {
4796 static const gchar *master_texts[] = MASTER_TEXTS;
4797 gint types[][24] = MASTER_TYPES;
4798 gint i,j, nomatch;
4799 gint preset;
4800
4801 /* custom setting is default */
4802 preset = -1;
4803 i = 0;
4804 while (master_texts[i] != NULL) {
4805 nomatch = 0;
4806 for (j=0; j<24; j++) {
4807 if (types[i][j] != masterparam.opt[j]) {
4808 nomatch = 1;
4809 }
4810 }
4811 /* all settings identical? */
4812 if (nomatch == 0) {
4813 preset = i;
4814 break;
4815 }
4816 i++;
4817 }
4818
4819 if (preset == -1) {
4820 /* custom is last value in menu */
4821 preset = i;
4822 }
4823
4824 /* now we found the setting fitting for our option-grid */
4825 /* set the option menu to this value */
4826
4827 /* block callback for option menu to avoid loop */
4828 gtk_option_menu_set_history(GTK_OPTION_MENU(isoopt_omenu), preset);
4829 masterparam.image_type = preset;
4830
4831 /* set joilet charset */
4832 gtk_option_menu_set_history(GTK_OPTION_MENU(isoopt_cmenu),
4833 masterparam.charset);
4834 gtk_option_menu_set_history(GTK_OPTION_MENU(isoopt_cmenu2),
4835 masterparam.outcharset);
4836 }
4837
4838
4839 /* called when you click on the check-buttons */
4840
isooptions_selected(GtkWidget * item,gpointer nr)4841 void isooptions_selected(GtkWidget *item, gpointer nr) {
4842 gboolean sel;
4843
4844 sel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
4845
4846 masterparam.opt[GPOINTER_TO_INT(nr)] = sel;
4847
4848 /* see if new setting match predefined type */
4849 read_option_grid();
4850
4851 set_sessionsize_unknown();
4852 }
4853
4854
4855 /* called by the optionmenu */
4856
isoopts_selected(GtkWidget * item,gpointer nr)4857 static void isoopts_selected(GtkWidget *item, gpointer nr) {
4858
4859 draw_option_grid(GPOINTER_TO_INT(nr));
4860 }
4861
csetopts_selected(GtkWidget * item,gpointer nr)4862 static void csetopts_selected(GtkWidget *item, gpointer nr) {
4863
4864 masterparam.charset = GPOINTER_TO_INT(nr);
4865 }
4866
cset2opts_selected(GtkWidget * item,gpointer nr)4867 static void cset2opts_selected(GtkWidget *item, gpointer nr) {
4868
4869 masterparam.outcharset = GPOINTER_TO_INT(nr);
4870 }
4871
4872
4873 /* called by save button */
4874
save_isooptions(GtkWidget * widget,gpointer data)4875 static void save_isooptions(GtkWidget *widget, gpointer data) {
4876 gchar tmp2[MAXLINE];
4877
4878 dolog(2, "Save iso-options as default\n");
4879
4880 /* write file */
4881 if (save_isooptions_file(configdir, ISOOPTFILE) == 1) {
4882 /* save failed */
4883 g_snprintf(tmp2,MAXLINE,_("Failed to save iso-options file: %s"), ISOOPTFILE);
4884 show_dialog(ICO_WARN, tmp2, T_OK, NULL, NULL, 0);
4885 } else {
4886 /* save ok */
4887 show_dialog(ICO_INFO,_("Options saved"), T_OK, NULL, NULL, 0);
4888 }
4889 }
4890
4891
4892 /* called by advanced iso option button */
4893
adv_isooptions_clicked(GtkWidget * widget,gpointer data)4894 static void adv_isooptions_clicked(GtkWidget *widget, gpointer data) {
4895
4896 display_advisooptions();
4897 }
4898
4899
4900 /* second submenu of master menu (iso-options) */
4901
draw_master_menu2(GtkWidget * box)4902 static void draw_master_menu2(GtkWidget *box) {
4903 GtkWidget *vbox, *hbox;
4904 GtkWidget *f1,*b1;
4905 GtkWidget *l1,*l2,*tbl;
4906 GtkWidget *omenu, *cmenu, *check;
4907 GtkWidget *menu, *menu_item;
4908 static const gchar *master_texts[] = MASTER_TEXTS;
4909 gint i;
4910
4911 f1 = gtk_frame_new(_("Detailed options how to create the ISO9660 image"));
4912 set_font_and_color_frame(f1,BOLDFONT,NULL);
4913 gtk_container_set_border_width(GTK_CONTAINER (f1),5);
4914 gtk_box_pack_start(GTK_BOX(box),f1,TRUE,TRUE,0);
4915 gtk_widget_show(f1);
4916
4917 vbox = gtk_vbox_new(FALSE,0);
4918 gtk_container_add(GTK_CONTAINER(f1),vbox);
4919 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
4920 gtk_widget_show(vbox);
4921
4922 tbl = gtk_table_new(1,16,TRUE);
4923 gtk_table_set_col_spacing(GTK_TABLE(tbl),8,10);
4924 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
4925 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,0);
4926 gtk_widget_show(tbl);
4927
4928 l1 = rightjust_gtk_label_new(_("Select predefined image type:"));
4929 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,9,0,1);
4930 gtk_widget_show(l1);
4931
4932 omenu = gtk_option_menu_new ();
4933 isoopt_omenu = omenu;
4934 menu = gtk_menu_new();
4935 i = 0;
4936 while (master_texts[i] != NULL) {
4937 menu_item = gtk_menu_item_new_with_label(_(master_texts[i]));
4938 gtk_signal_connect(GTK_OBJECT(menu_item),
4939 "activate", GTK_SIGNAL_FUNC(isoopts_selected),
4940 GINT_TO_POINTER(i));
4941 gtk_menu_append(GTK_MENU (menu), menu_item);
4942 gtk_widget_show(menu_item);
4943 i++;
4944 }
4945 /* now add the custom value */
4946 menu_item = gtk_menu_item_new_with_label(_("Custom"));
4947 gtk_signal_connect(GTK_OBJECT(menu_item),
4948 "activate", GTK_SIGNAL_FUNC(isoopts_selected),
4949 GINT_TO_POINTER(-1));
4950 gtk_menu_append(GTK_MENU (menu), menu_item);
4951 gtk_widget_show(menu_item);
4952 define_tooltip(omenu, _("Select here an image type which will define how exactly the master image will be generated. For most people the default \"Rock Ridge + Joliet\" is the perfect setting."));
4953
4954 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
4955 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,9,15,0,1);
4956 gtk_widget_show(omenu);
4957
4958 f1 = gtk_frame_new(NULL);
4959 gtk_container_set_border_width(GTK_CONTAINER (f1),5);
4960 gtk_box_pack_start(GTK_BOX(vbox),f1,TRUE,TRUE,0);
4961 gtk_widget_show(f1);
4962
4963 tbl = gtk_table_new(7,8,TRUE);
4964 gtk_table_set_col_spacing(GTK_TABLE(tbl), 1, 10);
4965 gtk_table_set_col_spacing(GTK_TABLE(tbl), 5, 10);
4966 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
4967 gtk_container_add(GTK_CONTAINER(f1),tbl);
4968 gtk_widget_show(tbl);
4969
4970 /* mkisofs options */
4971
4972 /* -input-charset CHARSET */
4973 l2 = rightjust_gtk_label_new(_("Input charset:"));
4974 gtk_table_attach_defaults(GTK_TABLE(tbl),l2,0,2,6,7);
4975 gtk_widget_show(l2);
4976
4977 cmenu = gtk_option_menu_new ();
4978 isoopt_cmenu = cmenu;
4979 menu = gtk_menu_new();
4980 i = 0;
4981 while (charset_types[i] != NULL) {
4982 menu_item = gtk_menu_item_new_with_label(charset_types[i]);
4983 gtk_signal_connect(GTK_OBJECT(menu_item),
4984 "activate", GTK_SIGNAL_FUNC(csetopts_selected),
4985 GINT_TO_POINTER(i));
4986 gtk_menu_append(GTK_MENU (menu), menu_item);
4987 gtk_widget_show(menu_item);
4988 i++;
4989 }
4990 define_tooltip(cmenu, _("Specify here the local charset that should be used for translating the local file names into Joliet Unicode directory records when the CD is read on Windows systems."));
4991
4992 gtk_option_menu_set_menu (GTK_OPTION_MENU (cmenu), menu);
4993 gtk_table_attach_defaults(GTK_TABLE(tbl),cmenu,2,4,6,7);
4994 gtk_widget_show(cmenu);
4995
4996 /* -output-charset CHARSET */
4997 l2 = rightjust_gtk_label_new(_("Output charset:"));
4998 gtk_table_attach_defaults(GTK_TABLE(tbl),l2,4,6,6,7);
4999 gtk_widget_show(l2);
5000
5001 cmenu = gtk_option_menu_new ();
5002 isoopt_cmenu2 = cmenu;
5003 menu = gtk_menu_new();
5004 i = 0;
5005 while (charset_types[i] != NULL) {
5006 menu_item = gtk_menu_item_new_with_label(charset_types[i]);
5007 gtk_signal_connect(GTK_OBJECT(menu_item),
5008 "activate", GTK_SIGNAL_FUNC(cset2opts_selected),
5009 GINT_TO_POINTER(i));
5010 gtk_menu_append(GTK_MENU (menu), menu_item);
5011 gtk_widget_show(menu_item);
5012 i++;
5013 }
5014 define_tooltip(cmenu, _("Output charset that defines the characters that will be used in Rock Ridge file names."));
5015
5016 gtk_option_menu_set_menu (GTK_OPTION_MENU (cmenu), menu);
5017 gtk_table_attach_defaults(GTK_TABLE(tbl),cmenu,6,8,6,7);
5018 gtk_widget_show(cmenu);
5019
5020
5021 /* -r anon rockridge */
5022 check = gtk_check_button_new_with_label(_("Rock Ridge (anonymous)"));
5023 isoopts[0] = check;
5024 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5025 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(0));
5026 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,4,0,1);
5027 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5028 masterparam.opt[0]);
5029 gtk_widget_show(check);
5030 define_tooltip(check, _("Include enhanced information like long filenames, devices and links in the image. This information can be read by most unix operating systems. The ownership and permissions of the files are set to neutral values."));
5031
5032 /* -l allow 31 chars filenames */
5033 check = gtk_check_button_new_with_label(_("Allow 31 character ISO-filenames"));
5034 isoopts[4] = check;
5035 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5036 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(4));
5037 gtk_table_attach_defaults(GTK_TABLE(tbl),check,4,8,0,1);
5038 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5039 masterparam.opt[4]);
5040 gtk_widget_show(check);
5041 define_tooltip(check, _("Allow full 31 character ISO9660 filenames. This is not relevant for the Rock Ridge or Joliet option, because there the filenames are stored seperately."));
5042
5043 /* -R rockridge */
5044 check = gtk_check_button_new_with_label(_("Rock Ridge (backup)"));
5045 isoopts[2] = check;
5046 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5047 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(2));
5048 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,4,1,2);
5049 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5050 masterparam.opt[2]);
5051 gtk_widget_show(check);
5052 define_tooltip(check, _("This is like the other Rock Ridge option, but preserves the original permissions and file owner information. This should be used when you create CDs for backup purposes."));
5053
5054 /* -L allow isonames with starting period */
5055 check = gtk_check_button_new_with_label(_("Allow ISO-files with a starting period"));
5056 isoopts[7] = check;
5057 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5058 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(7));
5059 gtk_table_attach_defaults(GTK_TABLE(tbl),check,4,8,1,2);
5060 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5061 masterparam.opt[7]);
5062 gtk_widget_show(check);
5063 define_tooltip(check, _("Allow ISO9660 filesnames to begin with a period. Usually, a leading dot is replaced by an underscore in order to maintain MS-DOS compatibility. This has no effect on Rock Ridge or Joliet filenames."));
5064
5065 /* -J add joliet */
5066 check = gtk_check_button_new_with_label(_("Joliet extension (for Windows)"));
5067 isoopts[1] = check;
5068 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5069 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(1));
5070 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,4,2,3);
5071 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5072 masterparam.opt[1]);
5073 gtk_widget_show(check);
5074 define_tooltip(check, _("Support the Microsoft Joliet filesystem to allow long unicode filenames when the CD is read on Windows systems."));
5075
5076 /* joliet-long */
5077 check = gtk_check_button_new_with_label(_("Allow 103 character Joliet filenames"));
5078 isoopts[16] = check;
5079 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5080 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(16));
5081 gtk_table_attach_defaults(GTK_TABLE(tbl),check,4,8,2,3);
5082 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5083 masterparam.opt[16]);
5084 gtk_widget_show(check);
5085 define_tooltip(check, _("Limit Joliet filenames not to 64 characters but allow up to 103. This breaks the Joliet specification, but seems to work on most systems. Use with caution."));
5086
5087 /* -f follow symb links */
5088 check = gtk_check_button_new_with_label(_("Follow symbolic links"));
5089 isoopts[3] = check;
5090 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5091 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(3));
5092 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,4,3,4);
5093 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5094 masterparam.opt[3]);
5095 gtk_widget_show(check);
5096 define_tooltip(check, _("Resolve and follow the symbolic links in the filesystem. So a link will be entered as real file or directory."));
5097
5098 /* -U untranslated files */
5099 check = gtk_check_button_new_with_label(_("Allows \"Untranslated\" filenames"));
5100 isoopts[10] = check;
5101 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5102 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(10));
5103 gtk_table_attach_defaults(GTK_TABLE(tbl),check,4,8,3,4);
5104 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5105 masterparam.opt[10]);
5106 gtk_widget_show(check);
5107 define_tooltip(check, _("Allows filenames totally against the ISO9660 standard. This makes only sense on HP-UX systems which do not know any ISO9660 extensions."));
5108
5109 /* -D do not use deep directory relocation */
5110 check = gtk_check_button_new_with_label(_("Do not use deep directory relocation"));
5111 isoopts[6] = check;
5112 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5113 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(6));
5114 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,4,4,5);
5115 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5116 masterparam.opt[6]);
5117 gtk_widget_show(check);
5118 define_tooltip(check, _("Allow deeper directory hierarchy than 8 levels. If this option is not used, then a directory \"RR_MOVED\" will be created on the CD which can be seen on non-Rock Ridge capable Systems (usually Windows). Use with caution, because this violates the ISO9660 standard."));
5119
5120 /* -no-bak */
5121 check = gtk_check_button_new_with_label(_("Do not include backup files"));
5122 isoopts[11] = check;
5123 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5124 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(11));
5125 gtk_table_attach_defaults(GTK_TABLE(tbl),check,4,8,4,5);
5126 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5127 masterparam.opt[11]);
5128 gtk_widget_show(check);
5129 define_tooltip(check, _("Do not include typical backup files in the image. Files that contain '~' or '#' or end in '.bak' will be skipped."));
5130
5131 /* -T transtable */
5132 check = gtk_check_button_new_with_label(_("Generate TRANS.TBL files"));
5133 isoopts[5] = check;
5134 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5135 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(5));
5136 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,4,5,6);
5137 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5138 masterparam.opt[5]);
5139 gtk_widget_show(check);
5140 define_tooltip(check, _("Generate a file TRANS.TBL in each directory of the CD, which can help non-Rock Ridge capable systems to establish the correct file names."));
5141
5142 /* -hide-joliet-trans-tbl */
5143 check = gtk_check_button_new_with_label(_("Hide TRANS.TBL from Joliet tree"));
5144 isoopts[13] = check;
5145 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5146 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(13));
5147 gtk_table_attach_defaults(GTK_TABLE(tbl),check,4,8,5,6);
5148 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5149 masterparam.opt[13]);
5150 gtk_widget_show(check);
5151 define_tooltip(check, _("Hide the TRANS.TBL files (if you enabled them) from the Joliet tree, so that they are invisible on Windows systems."));
5152
5153
5154
5155 /* button bar at bottom */
5156 hbox = gtk_hbox_new(TRUE,10);
5157 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,10);
5158 gtk_widget_show(hbox);
5159
5160 b1 = gtk_button_new_with_label(_("Advanced options"));
5161 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
5162 GTK_SIGNAL_FUNC(adv_isooptions_clicked),NULL);
5163 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,5);
5164 gtk_widget_show(b1);
5165 define_tooltip(b1,_("Show more ISO9660 options for advanced users."));
5166
5167 b1 = gtk_button_new_with_label(_("Save current settings as default"));
5168 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
5169 GTK_SIGNAL_FUNC(save_isooptions),NULL);
5170 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,5);
5171 gtk_widget_show(b1);
5172 define_tooltip(b1, _("Saves the current ISO-option settings to your configuration directory to enable them automatically again at next startup of X-CD-Roast."));
5173
5174 /* first call to that menu? */
5175 if (masterparam.image_type == -1) {
5176 /* set first as default setting */
5177 draw_option_grid(0);
5178 masterparam.image_type = 0;
5179 }
5180 }
5181
5182
5183 /* make sure a text-field does not contain more chars than 128 */
5184
isoheader_text_callback(GtkWidget * widget,gpointer data)5185 static void isoheader_text_callback(GtkWidget *widget, gpointer data) {
5186 int max, cur;
5187 gchar **p;
5188 gchar *buf;
5189
5190 /* get pointer to char variable, so that we can update it directly */
5191 p = (gchar **) data;
5192
5193 max = 128;
5194 cur = gtk_text_get_length(GTK_TEXT(widget));
5195
5196 /* to much chars? */
5197 if (cur > max) {
5198 gtk_text_backward_delete(GTK_TEXT(widget), cur-max);
5199 cur = gtk_text_get_length(GTK_TEXT(widget));
5200 }
5201
5202 /* now update given variable */
5203 g_free(*p);
5204 buf = gtk_editable_get_chars(GTK_EDITABLE(widget),0,cur);
5205 *p = g_strdup(buf);
5206 }
5207
5208
5209 /* set the text of a text-widget */
5210
boottext_set_text(GtkWidget * widget,gchar * txt)5211 static void boottext_set_text(GtkWidget *widget, gchar *txt) {
5212
5213 /* delete old contents */
5214 gtk_text_backward_delete(GTK_TEXT(widget),
5215 gtk_text_get_length(GTK_TEXT(widget)));
5216 gtk_text_insert(GTK_TEXT(widget),
5217 NULL,NULL,NULL, txt, strlen(txt));
5218
5219 }
5220
isoheader_entry_callback(GtkWidget * widget,gpointer data)5221 static void isoheader_entry_callback(GtkWidget *widget, gpointer data) {
5222 gchar **p;
5223
5224 /* get pointer to char variable, so that we can update it directly */
5225 p = (gchar **) data;
5226
5227 g_free(*p);
5228 *p = g_strdup(gtk_entry_get_text(GTK_ENTRY(widget)));
5229 }
5230
5231
5232 /* clear isoheaders */
5233
isoheader_clear(GtkWidget * widget,gpointer data)5234 static void isoheader_clear(GtkWidget *widget, gpointer data) {
5235
5236 gtk_entry_set_text(GTK_ENTRY(isoheader[0]),g_strdup(""));
5237 g_free(masterparam.volid);
5238 masterparam.volid = g_strdup("");
5239
5240 gtk_text_set_point(GTK_TEXT(isoheader[1]),
5241 gtk_text_get_length(GTK_TEXT(isoheader[1])));
5242 gtk_text_backward_delete(GTK_TEXT(isoheader[1]),
5243 gtk_text_get_length(GTK_TEXT(isoheader[1])));
5244 g_free(masterparam.publisher);
5245 masterparam.publisher = g_strdup("");
5246
5247 gtk_text_set_point(GTK_TEXT(isoheader[2]),
5248 gtk_text_get_length(GTK_TEXT(isoheader[2])));
5249 gtk_text_backward_delete(GTK_TEXT(isoheader[2]),
5250 gtk_text_get_length(GTK_TEXT(isoheader[2])));
5251 g_free(masterparam.preparer);
5252 masterparam.preparer = g_strdup("");
5253
5254 /*
5255 gtk_text_set_point(GTK_TEXT(isoheader[3]),
5256 gtk_text_get_length(GTK_TEXT(isoheader[3])));
5257 gtk_text_backward_delete(GTK_TEXT(isoheader[3]),
5258 gtk_text_get_length(GTK_TEXT(isoheader[3])));
5259 g_free(masterparam.application);
5260 masterparam.application = g_strdup("");
5261 */
5262
5263 gtk_entry_set_text(GTK_ENTRY(isoheader[4]),"");
5264 g_free(masterparam.abstract);
5265 masterparam.abstract = g_strdup("");
5266
5267 gtk_entry_set_text(GTK_ENTRY(isoheader[5]),"");
5268 g_free(masterparam.biblio);
5269 masterparam.biblio = g_strdup("");
5270
5271 gtk_entry_set_text(GTK_ENTRY(isoheader[6]),"");
5272 g_free(masterparam.copyright);
5273 masterparam.copyright = g_strdup("");
5274 }
5275
5276
isoheader_save(GtkWidget * widget,gpointer data)5277 static void isoheader_save(GtkWidget *widget, gpointer data) {
5278 gchar tmp2[MAXLINE];
5279
5280 dolog(2, "Save iso-headers as default\n");
5281
5282 /* write file */
5283 if (save_isoheaders_file(configdir, ISOHEADERFILE) == 1) {
5284 /* save failed */
5285 g_snprintf(tmp2,MAXLINE,_("Failed to save iso-headers file: %s"), ISOHEADERFILE);
5286 show_dialog(ICO_WARN, tmp2, T_OK, NULL, NULL, 0);
5287 } else {
5288 /* save ok */
5289 show_dialog(ICO_INFO,_("Headers saved"), T_OK, NULL, NULL, 0);
5290 }
5291
5292 }
5293
5294
5295 /* read the iso-header data from a CD in the write-device */
5296
isoheader_readfromcd(GtkWidget * widget,gpointer data)5297 static void isoheader_readfromcd(GtkWidget *widget, gpointer data) {
5298 gint i, devnr, found;
5299 gchar buf[DATASECTORSIZE];
5300 gchar tmp[MAXLINE];
5301 GdkCursor *cursor;
5302
5303 /* no cd-writer defined */
5304 if (curset.writer_devnr == -1) {
5305 show_dialog(ICO_ERROR,_("No CD-Writer defined in Setup"), T_OK, NULL, NULL, 0);
5306 return;
5307 }
5308
5309 do_lock(1);
5310 /* change cursor to watch */
5311 cursor = gdk_cursor_new(GDK_WATCH);
5312 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
5313
5314 while (gtk_events_pending())
5315 gtk_main_iteration();
5316
5317 devnr = curset.writer_devnr;
5318 get_cd_toc(devnr);
5319 found = 0;
5320
5321 /* no cd loaded? */
5322 if (cdinfo.nr_tracks <= 0) {
5323
5324 /* reset cursor */
5325 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
5326 gdk_cursor_destroy (cursor);
5327 do_unlock(1);
5328
5329 show_dialog(ICO_WARN,_("No CD loaded in write device"), T_OK, NULL, NULL, 0);
5330 return;
5331 }
5332
5333 strcpy(tmp, "");
5334
5335
5336 /* scan every data track */
5337 #ifdef SCANEVERYTRACK
5338 for (i = 0; i < cdinfo.nr_tracks; i++) {
5339 #else
5340 for (i = 0; i < 1; i++) {
5341 #endif
5342
5343 if (trackinfo[i]->type == 0) {
5344 /* get iso-header for current track */
5345 if (read_info_sector_from_dev(devnr,buf,sizeof(buf),
5346 trackinfo[i]->start_sec) == 0)
5347 break;
5348 if (strncmp(buf, "\001CD001\001", 8) != 0)
5349 break;
5350
5351 if (found == 0) {
5352 isoheader_clear(widget, NULL);
5353 }
5354 found = 1;
5355
5356 get_subheader(buf, tmp, 40, 72);
5357 gtk_entry_set_text(GTK_ENTRY(isoheader[0]),tmp);
5358 isoheader_entry_callback(isoheader[0], &masterparam.volid);
5359 get_subheader(buf, tmp, 318, 446);
5360 boottext_set_text(isoheader[1], tmp);
5361 isoheader_text_callback(isoheader[1], &masterparam.publisher);
5362 get_subheader(buf, tmp, 446, 574);
5363 boottext_set_text(isoheader[2], tmp);
5364 isoheader_text_callback(isoheader[2], &masterparam.preparer);
5365 /*
5366 get_subheader(buf, tmp, 574, 702);
5367 boottext_set_text(isoheader[3], tmp);
5368 isoheader_text_callback(isoheader[3], &masterparam.application);
5369 */
5370
5371 get_subheader(buf, tmp, 739, 776);
5372 gtk_entry_set_text(GTK_ENTRY(isoheader[4]),tmp);
5373 isoheader_entry_callback(isoheader[4], &masterparam.abstract);
5374 get_subheader(buf, tmp, 776, 813);
5375 gtk_entry_set_text(GTK_ENTRY(isoheader[5]),tmp);
5376 isoheader_entry_callback(isoheader[5], &masterparam.biblio);
5377 get_subheader(buf, tmp, 702, 739);
5378 gtk_entry_set_text(GTK_ENTRY(isoheader[6]),tmp);
5379 isoheader_entry_callback(isoheader[6], &masterparam.copyright);
5380 }
5381 }
5382
5383 /* reset cursor */
5384 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
5385 gdk_cursor_destroy (cursor);
5386 do_unlock(1);
5387
5388 /* no data found */
5389 if (found == 0) {
5390 show_dialog(ICO_WARN,_("Header data can only be read from an ISO9660 data CD"), T_OK, NULL, NULL, 0);
5391 }
5392 }
5393
5394
5395 /* third submenu of master menu (iso-header) */
5396
5397 static void draw_master_menu3(GtkWidget *box) {
5398 GtkWidget *vbox, *hbox;
5399 GtkWidget *f1,*b1;
5400 GtkWidget *l1,*tbl;
5401 GtkWidget *e1;
5402 /* GtkWidget *scrolled_win; */
5403
5404 f1 = gtk_frame_new(_("Header data for the ISO9660 image"));
5405 set_font_and_color_frame(f1,BOLDFONT,NULL);
5406 gtk_container_set_border_width(GTK_CONTAINER (f1),5);
5407 gtk_box_pack_start(GTK_BOX(box),f1,TRUE,TRUE,0);
5408 gtk_widget_show(f1);
5409
5410 vbox = gtk_vbox_new(FALSE,0);
5411 gtk_container_add(GTK_CONTAINER(f1),vbox);
5412 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
5413 gtk_widget_show(vbox);
5414
5415 tbl = gtk_table_new(6,16,FALSE);
5416 gtk_table_set_col_spacing(GTK_TABLE(tbl),3,10);
5417 gtk_table_set_row_spacings(GTK_TABLE(tbl),10);
5418 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
5419 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,0);
5420 gtk_widget_show(tbl);
5421
5422 /* -V volid 32 chars */
5423 l1 = rightjust_gtk_label_new(_("Volume Id:"));
5424 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4,0,1);
5425 gtk_widget_show(l1);
5426
5427 e1 = gtk_entry_new_with_max_length(32);
5428 isoheader[0] = e1;
5429 gtk_signal_connect(GTK_OBJECT(e1), "changed",
5430 GTK_SIGNAL_FUNC(isoheader_entry_callback), &masterparam.volid);
5431 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,4,16,0,1);
5432 if (masterparam.volid != NULL) {
5433 gtk_entry_set_text(GTK_ENTRY(e1), masterparam.volid);
5434 }
5435 gtk_widget_show(e1);
5436 define_tooltip(e1, _("This is the name of the disc as displayed on Windows or Mac systems. On Solaris this will be used as the mount point for the volume management system."));
5437
5438 /* -P publisher_id 128 chars */
5439 l1 = rightjust_gtk_label_new(_("Publisher Id:"));
5440 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4,1,2);
5441 gtk_widget_show(l1);
5442
5443 /* scrolled_win = gtk_scrolled_window_new (NULL, NULL);
5444 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
5445 GTK_POLICY_NEVER,GTK_POLICY_AUTOMATIC);
5446 gtk_widget_set_usize(scrolled_win,0,tbf(36));
5447 gtk_table_attach_defaults(GTK_TABLE(tbl),scrolled_win,4,16,1,2);
5448 gtk_widget_show(scrolled_win);
5449 */
5450 e1 = gtk_text_new(NULL, NULL);
5451 isoheader[1] = e1;
5452 gtk_text_set_editable(GTK_TEXT(e1),TRUE);
5453 gtk_text_set_word_wrap(GTK_TEXT(e1),TRUE);
5454 gtk_widget_set_usize(e1,0,tbf(36));
5455 gtk_signal_connect(GTK_OBJECT(e1),"changed",
5456 GTK_SIGNAL_FUNC(isoheader_text_callback),
5457 &masterparam.publisher);
5458 /* gtk_container_add (GTK_CONTAINER (scrolled_win), e1); */
5459 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,4,16,1,2);
5460 if (masterparam.publisher != NULL) {
5461 boottext_set_text(e1, masterparam.publisher);
5462 }
5463 gtk_widget_show(e1);
5464 define_tooltip(e1, _("This should describe the publisher of the CD, usually with a mailing address and phone number."));
5465
5466 /* -p preparer_id 128 chars */
5467 l1 = rightjust_gtk_label_new(_("Preparer Id:"));
5468 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4,2,3);
5469 gtk_widget_show(l1);
5470
5471 /*
5472 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
5473 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
5474 GTK_POLICY_NEVER,GTK_POLICY_AUTOMATIC);
5475 gtk_widget_set_usize(scrolled_win,0,tbf(36));
5476 gtk_table_attach_defaults(GTK_TABLE(tbl),scrolled_win,4,16,2,3);
5477 gtk_widget_show(scrolled_win);
5478 */
5479
5480 e1 = gtk_text_new(NULL, NULL);
5481 isoheader[2] = e1;
5482 gtk_text_set_editable(GTK_TEXT(e1),TRUE);
5483 gtk_text_set_word_wrap(GTK_TEXT(e1),TRUE);
5484 gtk_widget_set_usize(e1,0,tbf(36));
5485 gtk_signal_connect(GTK_OBJECT(e1),"changed",
5486 GTK_SIGNAL_FUNC(isoheader_text_callback),
5487 &masterparam.preparer);
5488 /* gtk_container_add (GTK_CONTAINER (scrolled_win), e1); */
5489 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,4,16,2,3);
5490 if (masterparam.preparer != NULL) {
5491 boottext_set_text(e1, masterparam.preparer);
5492 }
5493 gtk_widget_show(e1);
5494 define_tooltip(e1, _("This should describe the preparer of the CD, usually with a mailing address and phone number."));
5495
5496 /* -A application_id 128 chars */
5497 /*
5498 l1 = rightjust_gtk_label_new(_("Application Id:"));
5499 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4,3,4);
5500 gtk_widget_show(l1);
5501
5502 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
5503 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
5504 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
5505 gtk_widget_set_usize(scrolled_win,0,tbf(36));
5506 gtk_table_attach_defaults(GTK_TABLE(tbl),scrolled_win,4,16,3,4);
5507 gtk_widget_show(scrolled_win);
5508
5509 e1 = gtk_text_new(NULL, NULL);
5510 isoheader[3] = e1;
5511 gtk_text_set_editable(GTK_TEXT(e1),TRUE);
5512 gtk_text_set_word_wrap(GTK_TEXT(e1),TRUE);
5513 gtk_signal_connect(GTK_OBJECT(e1),"changed",
5514 GTK_SIGNAL_FUNC(isoheader_text_callback),
5515 &masterparam.application);
5516 gtk_container_add (GTK_CONTAINER (scrolled_win), e1);
5517 if (masterparam.application != NULL) {
5518 boottext_set_text(e1, masterparam.application);
5519 }
5520 gtk_widget_show(e1);
5521 define_tooltip(e1, _("This should describe the application that will be on the disc."));
5522 */
5523
5524 /* -abstract file 37 chars */
5525 l1 = rightjust_gtk_label_new(_("Abstract Information:"));
5526 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4,3,4);
5527 gtk_widget_show(l1);
5528
5529 e1 = gtk_entry_new_with_max_length(37);
5530 isoheader[4] = e1;
5531 gtk_signal_connect(GTK_OBJECT(e1), "changed",
5532 GTK_SIGNAL_FUNC(isoheader_entry_callback),
5533 &masterparam.abstract);
5534 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,4,16,3,4);
5535 if (masterparam.abstract != NULL) {
5536 gtk_entry_set_text(GTK_ENTRY(e1), masterparam.abstract);
5537 }
5538 gtk_widget_show(e1);
5539 define_tooltip(e1, _("Can be used to specify a file name on the CD which contains an abstract. But you can enter anything here."));
5540
5541 /* -biblio file 37 chars */
5542 l1 = rightjust_gtk_label_new(_("Bibliographic Information:"));
5543 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4,4,5);
5544 gtk_widget_show(l1);
5545
5546 e1 = gtk_entry_new_with_max_length(37);
5547 isoheader[5] = e1;
5548 gtk_signal_connect(GTK_OBJECT(e1), "changed",
5549 GTK_SIGNAL_FUNC(isoheader_entry_callback),
5550 &masterparam.biblio);
5551 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,4,16,4,5);
5552 if (masterparam.biblio != NULL) {
5553 gtk_entry_set_text(GTK_ENTRY(e1), masterparam.biblio);
5554 }
5555 gtk_widget_show(e1);
5556 define_tooltip(e1, _("Can be used to specify the bibliographic file name."));
5557
5558 /* -copyright file 37 chars */
5559 l1 = rightjust_gtk_label_new(_("Copyright Information:"));
5560 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4,5,6);
5561 gtk_widget_show(l1);
5562
5563 e1 = gtk_entry_new_with_max_length(37);
5564 isoheader[6] = e1;
5565 gtk_signal_connect(GTK_OBJECT(e1), "changed",
5566 GTK_SIGNAL_FUNC(isoheader_entry_callback),
5567 &masterparam.copyright);
5568 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,4,16,5,6);
5569 if (masterparam.copyright != NULL) {
5570 gtk_entry_set_text(GTK_ENTRY(e1), masterparam.copyright);
5571 }
5572 gtk_widget_show(e1);
5573 define_tooltip(e1, _("Can be used to specify the copyright file name."));
5574
5575 /* not yet supported */
5576 /* -sysid 32 chars */
5577 /* -volset 128 chars */
5578
5579 /* fill block */
5580 hbox = gtk_hbox_new(TRUE,0);
5581 gtk_box_pack_start(GTK_BOX(vbox),hbox,TRUE,TRUE,5);
5582 gtk_widget_show(hbox);
5583
5584 /* button bar at bottom */
5585 hbox = gtk_hbox_new(TRUE,10);
5586 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,5);
5587 gtk_widget_show(hbox);
5588
5589 b1 = gtk_button_new_with_label(_("Save settings as default"));
5590 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
5591 GTK_SIGNAL_FUNC(isoheader_save), NULL);
5592 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,5);
5593 gtk_widget_show(b1);
5594 define_tooltip(b1, _("Saves all defined texts (with the exception of the Volume-ID) to the configuration directory for automatic restoration at next startup of X-CD-Roast."));
5595
5596 b1 = gtk_button_new_with_label(_("Read settings from CD"));
5597 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
5598 GTK_SIGNAL_FUNC(isoheader_readfromcd), NULL);
5599 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,5);
5600 gtk_widget_show(b1);
5601 define_tooltip(b1, _("Read all header texts from a CD in the writing device - Warning, this will overwrite the currently entered texts."));
5602
5603 b1 = gtk_button_new_with_label(_("Clear settings"));
5604 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
5605 GTK_SIGNAL_FUNC(isoheader_clear), NULL);
5606 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,5);
5607 gtk_widget_show(b1);
5608 define_tooltip(b1, _("Clear all entry fields."));
5609
5610 }
5611
5612
5613 /* enable/disable boot-platforms */
5614
5615 static void set_boot_platform(gint val) {
5616
5617 /* at startup these are not yet defined */
5618 if (!bootable_frame1 || !bootable_frame2) return;
5619
5620 switch(val) {
5621 case 0:
5622 gtk_widget_set_sensitive(bootable_frame1,FALSE);
5623 gtk_widget_set_sensitive(bootable_frame2,FALSE);
5624 break;
5625 case 1:
5626 gtk_widget_set_sensitive(bootable_frame1,TRUE);
5627 gtk_widget_set_sensitive(bootable_frame2,FALSE);
5628 break;
5629 case 2:
5630 gtk_widget_set_sensitive(bootable_frame1,FALSE);
5631 gtk_widget_set_sensitive(bootable_frame2,TRUE);
5632 break;
5633 }
5634 }
5635
5636
5637 static void bootmode_selected(GtkWidget *item, gpointer data) {
5638 gint val;
5639
5640 val = GPOINTER_TO_INT(data);
5641 masterparam.bootable = val;
5642
5643 set_boot_platform(val);
5644 set_sessionsize_unknown();
5645 }
5646
5647
5648 static void toritomode_selected(GtkWidget *item, gpointer data) {
5649 gint val;
5650
5651 val = GPOINTER_TO_INT(data);
5652 masterparam.boot_type = val;
5653 set_sessionsize_unknown();
5654
5655 if (val == 2) {
5656 gtk_widget_set_sensitive(master_loadsizetbl,TRUE);
5657 } else {
5658 gtk_widget_set_sensitive(master_loadsizetbl,FALSE);
5659 }
5660 }
5661
5662 static void bootfile_browse_callback(GtkWidget *widget, GtkEntry *entry) {
5663 char tmp[MAXLINE];
5664
5665 show_file_selector(_("Select boot image"), (gchar *) gtk_entry_get_text(entry),tmp);
5666 if (strcmp(tmp,"") != 0) {
5667 gtk_entry_set_text(entry,tmp);
5668 g_free(masterparam.boot_image);
5669 masterparam.boot_image = g_strdup(gtk_entry_get_text(entry));
5670 set_sessionsize_unknown();
5671 }
5672 }
5673
5674 static void bootopt_entry_callback(GtkWidget *widget, gpointer data) {
5675 gchar **p;
5676
5677 /* get pointer to char variable, so that we can update it directly */
5678 p = (gchar **) data;
5679
5680 g_free(*p);
5681 *p = g_strdup(gtk_entry_get_text(GTK_ENTRY(widget)));
5682
5683 set_sessionsize_unknown();
5684 }
5685
5686
5687 /* called when a drag is received on the entry */
5688
5689 static void entry_bootimage_drag_received(GtkWidget *widget,
5690 GdkDragContext *dc, gint x, gint y, GtkSelectionData *selection_data,
5691 guint info, guint t, gpointer data) {
5692 gchar *text;
5693 gchar newdir[MAXLINE];
5694
5695 /* nothing received? ignore */
5696 if(selection_data == NULL)
5697 return;
5698 if(selection_data->length < 0)
5699 return;
5700
5701 /* widget is disabled? */
5702 if (!GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(data))) {
5703 return;
5704 }
5705
5706 if ((info == DRAG_TAR_INFO_0) ||
5707 (info == DRAG_TAR_INFO_1) ||
5708 (info == DRAG_TAR_INFO_2)) {
5709 text = (char *) selection_data->data;
5710 if (extract_single_drag_filename(text, selection_data->length, newdir)) {
5711 /* extracted the plain filename from drag */
5712 if (strcmp(newdir,"") != 0) {
5713 dodebug(3,"Received from drag: %s\n", newdir);
5714 gtk_entry_set_text(data, newdir);
5715 /* save new path */
5716 bootopt_entry_callback(data,
5717 &masterparam.boot_image);
5718 }
5719 }
5720 }
5721 }
5722
5723 static void bootinfotable_selected(GtkWidget *item, gpointer data) {
5724
5725 masterparam.boot_info_table =
5726 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
5727 }
5728
5729 static void bootloadsize_selected(GtkWidget *item, GtkSpinButton *spin) {
5730 gint sel;
5731
5732 sel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
5733
5734 if (sel) {
5735 gtk_widget_set_sensitive(GTK_WIDGET(spin),TRUE);
5736 masterparam.boot_load_size =
5737 gtk_spin_button_get_value_as_int(spin);
5738 } else {
5739 gtk_widget_set_sensitive(GTK_WIDGET(spin),FALSE);
5740 masterparam.boot_load_size = -1;
5741 }
5742 }
5743
5744 static void bootloadsize_callback(GtkWidget *item, GtkSpinButton *spin) {
5745
5746 masterparam.boot_load_size = gtk_spin_button_get_value_as_int(spin);
5747 }
5748
5749
5750 /* fourth submenu of master menu (boot options) */
5751
5752 static void draw_master_menu4(GtkWidget *box) {
5753 GtkWidget *vbox;
5754 GtkWidget *f1,*b1;
5755 GtkWidget *l1,*tbl;
5756 GtkWidget *e1, *check;
5757 GSList *group;
5758 GtkWidget *btn, *nrsectors, *loadsizetbl;
5759 GtkTargetEntry target_entry[3];
5760 GtkObject *adj;
5761
5762 /* required for drag&drop setup */
5763 target_entry[0].target = DRAG_TAR_NAME_0;
5764 target_entry[0].flags = 0;
5765 target_entry[0].info = DRAG_TAR_INFO_0;
5766 target_entry[1].target = DRAG_TAR_NAME_1;
5767 target_entry[1].flags = 0;
5768 target_entry[1].info = DRAG_TAR_INFO_1;
5769 target_entry[2].target = DRAG_TAR_NAME_2;
5770 target_entry[2].flags = 0;
5771 target_entry[2].info = DRAG_TAR_INFO_2;
5772
5773 /* mark as not defined yet */
5774 bootable_frame1 = NULL;
5775 bootable_frame2 = NULL;
5776
5777 if (!curset.isProDVD) {
5778 f1 = gtk_frame_new(_("Options to create a bootable CD"));
5779 } else {
5780 f1 = gtk_frame_new(_("Options to create a bootable CD/DVD"));
5781 }
5782 set_font_and_color_frame(f1,BOLDFONT,NULL);
5783 gtk_container_set_border_width(GTK_CONTAINER (f1),5);
5784 gtk_box_pack_start(GTK_BOX(box),f1,TRUE,TRUE,0);
5785 gtk_widget_show(f1);
5786
5787 vbox = gtk_vbox_new(FALSE,0);
5788 gtk_container_add(GTK_CONTAINER(f1),vbox);
5789 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
5790 gtk_widget_show(vbox);
5791
5792 tbl = gtk_table_new(3,15,TRUE);
5793 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
5794 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,0);
5795 gtk_widget_show(tbl);
5796
5797 if (!curset.isProDVD) {
5798 l1 = rightjust_gtk_label_new(_("Make CD bootable?"));
5799 } else {
5800 l1 = rightjust_gtk_label_new(_("Make CD/DVD bootable?"));
5801 }
5802 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,7,0,1);
5803 gtk_widget_show(l1);
5804
5805 btn = gtk_radio_button_new_with_label(NULL,_("Not bootable"));
5806 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
5807 GTK_SIGNAL_FUNC(bootmode_selected),GINT_TO_POINTER(0));
5808 gtk_table_attach_defaults(GTK_TABLE(tbl),btn,7,15,0,1);
5809 gtk_widget_show(btn);
5810 define_tooltip(btn, _("Don't create a bootable CD."));
5811 if (masterparam.bootable == 0)
5812 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn), 1);
5813 group = gtk_radio_button_group (GTK_RADIO_BUTTON(btn));
5814
5815 btn = gtk_radio_button_new_with_label(group, _("El Torito (Standard PC)"));
5816 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
5817 GTK_SIGNAL_FUNC(bootmode_selected),GINT_TO_POINTER(1));
5818 gtk_table_attach_defaults(GTK_TABLE(tbl),btn,7,15,1,2);
5819 gtk_widget_show(btn);
5820 define_tooltip(btn, _("This CD should be bootable on Standard-PCs as defined by the El Torito Standard. You have to supply valid boot image to make this possible."));
5821 if (masterparam.bootable == 1)
5822 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn), 1);
5823 group = gtk_radio_button_group (GTK_RADIO_BUTTON(btn));
5824
5825 btn = gtk_radio_button_new_with_label(group, _("Sparc (Sun workstations)"));
5826 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
5827 GTK_SIGNAL_FUNC(bootmode_selected),GINT_TO_POINTER(2));
5828 gtk_table_attach_defaults(GTK_TABLE(tbl),btn,7,15,2,3);
5829 gtk_widget_show(btn);
5830 define_tooltip(btn, _("This CD should be bootable on Sparc systems (usually Sun workstations)."));
5831 if (masterparam.bootable == 2)
5832 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn), 1);
5833
5834 /* el torito */
5835 f1 = gtk_frame_new(_("El Torito (Standard PC)"));
5836 bootable_frame1 = f1;
5837 set_font_and_color_frame(f1,BOLDFONT,NULL);
5838 gtk_container_set_border_width(GTK_CONTAINER (f1),5);
5839 gtk_box_pack_start(GTK_BOX(vbox),f1,FALSE,FALSE,0);
5840 gtk_widget_show(f1);
5841
5842 tbl = gtk_table_new(5,32,TRUE);
5843 gtk_table_set_col_spacing(GTK_TABLE(tbl),9,5);
5844 gtk_table_set_col_spacing(GTK_TABLE(tbl),17,5);
5845 gtk_table_set_col_spacing(GTK_TABLE(tbl),25,5);
5846 gtk_table_set_row_spacing(GTK_TABLE(tbl),0,5);
5847 gtk_table_set_row_spacing(GTK_TABLE(tbl),1,5);
5848 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
5849 gtk_container_add(GTK_CONTAINER(f1),tbl);
5850 gtk_widget_show(tbl);
5851
5852 l1 = rightjust_gtk_label_new(_("Boot image:"));
5853 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,10,0,1);
5854 gtk_widget_show(l1);
5855
5856 e1 = gtk_entry_new();
5857 bootimg_entry = e1;
5858 gtk_signal_connect(GTK_OBJECT(e1), "changed",
5859 GTK_SIGNAL_FUNC(bootopt_entry_callback),
5860 &masterparam.boot_image);
5861 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,10,26,0,1);
5862 gtk_widget_show(e1);
5863 gtk_drag_dest_set(e1, GTK_DEST_DEFAULT_MOTION |
5864 GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
5865 target_entry, sizeof(target_entry) / sizeof(GtkTargetEntry),
5866 GDK_ACTION_MOVE | GDK_ACTION_COPY);
5867 gtk_signal_connect(GTK_OBJECT(e1), "drag_data_received",
5868 GTK_SIGNAL_FUNC(entry_bootimage_drag_received), GTK_ENTRY(e1));
5869
5870 if (masterparam.boot_image != NULL) {
5871 gtk_entry_set_text(GTK_ENTRY(e1), masterparam.boot_image);
5872 }
5873 define_tooltip(e1, _("This specifies the path and filename of the boot image. The boot image must be exactly the size of either a 1.2, 1.44 or 2.88 meg floppy. You can use here any image you copied from a bootable floppy."));
5874
5875 b1 = gtk_button_new_with_label(_("Browse"));
5876 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
5877 GTK_SIGNAL_FUNC(bootfile_browse_callback),GTK_ENTRY(e1));
5878 gtk_table_attach_defaults(GTK_TABLE(tbl),b1,26,32,0,1);
5879 gtk_widget_show(b1);
5880
5881 l1 = rightjust_gtk_label_new(_("Boot catalog:"));
5882 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,10,1,2);
5883 gtk_widget_show(l1);
5884
5885 e1 = gtk_entry_new();
5886 gtk_signal_connect(GTK_OBJECT(e1), "changed",
5887 GTK_SIGNAL_FUNC(bootopt_entry_callback),
5888 &masterparam.boot_catalog);
5889 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,10,26,1,2);
5890 if (masterparam.boot_catalog != NULL) {
5891 gtk_entry_set_text(GTK_ENTRY(e1), masterparam.boot_catalog);
5892 }
5893 gtk_widget_show(e1);
5894 define_tooltip(e1, _("This specifies the path and filename of the boot catalog. This file is required to make a bootable CD and will be automatically generated by mkisofs. If you are not sure just keep the default setting."));
5895
5896 /* a own table just for the no-emulation-boot-size */
5897 /* this helps to activitate or deactive it */
5898 loadsizetbl = gtk_table_new(1,16,TRUE);
5899 master_loadsizetbl = loadsizetbl;
5900 gtk_table_attach_defaults(GTK_TABLE(tbl),loadsizetbl,4,18,4,5);
5901 gtk_widget_show(loadsizetbl);
5902 if (masterparam.boot_type != 2) {
5903 /* only activate for no-emul-images */
5904 gtk_widget_set_sensitive(loadsizetbl, FALSE);
5905 }
5906
5907 btn = gtk_radio_button_new_with_label(NULL,_("Floppy image boot"));
5908 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
5909 GTK_SIGNAL_FUNC(toritomode_selected),GINT_TO_POINTER(0));
5910 gtk_table_attach_defaults(GTK_TABLE(tbl),btn,4,18,2,3);
5911 gtk_widget_show(btn);
5912 define_tooltip(btn, _("The given boot image is copied from a bootable floppy."));
5913 group = gtk_radio_button_group (GTK_RADIO_BUTTON(btn));
5914 if (masterparam.boot_type == 0)
5915 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn), 1);
5916
5917 btn = gtk_radio_button_new_with_label(group, _("Hard disk image boot"));
5918 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
5919 GTK_SIGNAL_FUNC(toritomode_selected),GINT_TO_POINTER(1));
5920 gtk_table_attach_defaults(GTK_TABLE(tbl),btn,18,32,2,3);
5921 gtk_widget_show(btn);
5922 define_tooltip(btn, _("The given boot image is a hard disk image. The hard disk image must begin with a master boot record that contains a single partition."));
5923 group = gtk_radio_button_group (GTK_RADIO_BUTTON(btn));
5924 if (masterparam.boot_type == 1)
5925 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn), 1);
5926
5927 btn = gtk_radio_button_new_with_label(group, _("No disk emulation boot"));
5928 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
5929 GTK_SIGNAL_FUNC(toritomode_selected),GINT_TO_POINTER(2));
5930 gtk_table_attach_defaults(GTK_TABLE(tbl),btn,4,18,3,4);
5931 gtk_widget_show(btn);
5932 define_tooltip(btn, _("Specifies that the boot image used to create a bootable CD is a 'no emulation' image. The system will load and execute this image without performing any disk emulation."));
5933 group = gtk_radio_button_group (GTK_RADIO_BUTTON(btn));
5934 if (masterparam.boot_type == 2)
5935 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn), 1);
5936
5937 btn = gtk_radio_button_new_with_label(group, _("Not bootable image"));
5938 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
5939 GTK_SIGNAL_FUNC(toritomode_selected),GINT_TO_POINTER(3));
5940 gtk_table_attach_defaults(GTK_TABLE(tbl),btn,18,32,3,4);
5941 gtk_widget_show(btn);
5942 define_tooltip(btn, _("Specifies that the created CD should be marked as not bootable. The system will provide an emulated drive for the image, but will boot off a standard boot device."));
5943 if (masterparam.boot_type == 3)
5944 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn), 1);
5945
5946
5947 check = gtk_check_button_new_with_label(_("No emul load size:"));
5948 gtk_table_attach_defaults(GTK_TABLE(loadsizetbl),check,0,13,0,1);
5949 if (masterparam.boot_load_size >= 0) {
5950 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5951 TRUE);
5952 }
5953 gtk_widget_show(check);
5954 define_tooltip(check, _("This is the number of virtual 512 byte sectors to load in no-emulation mode. See the mkisofs-manpage for more details (-boot-load-size)"));
5955
5956 adj = gtk_adjustment_new(0.0,0.0,2049.0,1.0,1.0,1.0);
5957 nrsectors = gtk_spin_button_new(GTK_ADJUSTMENT(adj),0,0);
5958 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
5959 GTK_SIGNAL_FUNC (bootloadsize_callback),nrsectors);
5960 gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(nrsectors),1);
5961 gtk_table_attach_defaults(GTK_TABLE(loadsizetbl),nrsectors,13,16,0,1);
5962 gtk_widget_show(nrsectors);
5963 if (masterparam.boot_load_size >= 0) {
5964 gtk_spin_button_set_value(GTK_SPIN_BUTTON(nrsectors),
5965 (gfloat)masterparam.boot_load_size);
5966 } else {
5967 gtk_widget_set_sensitive(nrsectors,FALSE);
5968 }
5969 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5970 GTK_SIGNAL_FUNC(bootloadsize_selected),nrsectors);
5971
5972 check = gtk_check_button_new_with_label(_("Modify boot info-table"));
5973 gtk_signal_connect(GTK_OBJECT(check),"clicked",
5974 GTK_SIGNAL_FUNC(bootinfotable_selected),NULL);
5975 gtk_table_attach_defaults(GTK_TABLE(tbl),check,18,32,4,5);
5976 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
5977 masterparam.boot_info_table);
5978 gtk_widget_show(check);
5979 define_tooltip(check, _("Specifies that a 56-byte table with CD-ROM layout information will be patched into the boot file. Warning - the boot file will be modified! See the mkisofs-manpage for more details (-boot-info-table)"));
5980
5981
5982 /* sparc */
5983 f1 = gtk_frame_new(_("Sparc (Sun workstations)"));
5984 bootable_frame2 = f1;
5985 set_font_and_color_frame(f1,BOLDFONT,NULL);
5986 gtk_container_set_border_width(GTK_CONTAINER (f1),5);
5987 gtk_box_pack_start(GTK_BOX(vbox),f1,FALSE,FALSE,0);
5988 gtk_widget_show(f1);
5989
5990 tbl = gtk_table_new(1,16,TRUE);
5991 gtk_table_set_col_spacing(GTK_TABLE(tbl),4,5);
5992 gtk_container_set_border_width(GTK_CONTAINER (tbl),10);
5993 gtk_container_add(GTK_CONTAINER(f1),tbl);
5994 gtk_widget_show(tbl);
5995
5996 l1 = rightjust_gtk_label_new(_("Boot image list:"));
5997 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,5,0,1);
5998 gtk_widget_show(l1);
5999
6000 e1 = gtk_entry_new();
6001 gtk_signal_connect(GTK_OBJECT(e1), "changed",
6002 GTK_SIGNAL_FUNC(bootopt_entry_callback),
6003 &masterparam.sparc_boot);
6004 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,5,13,0,1);
6005 gtk_widget_show(e1);
6006 define_tooltip(e1, _("Specifies a comma separated list of boot images that are needed to make a bootable CD for sparc systems."));
6007 if (masterparam.sparc_boot != NULL) {
6008 gtk_entry_set_text(GTK_ENTRY(e1), masterparam.sparc_boot);
6009 }
6010
6011 set_boot_platform(masterparam.bootable);
6012 }
6013
6014
6015 /* fill the entry for image-size */
6016
6017 static void update_session_size_display() {
6018 gint kb;
6019 gchar tmp[MAXLINE];
6020
6021 /* not yet activated */
6022 if (cdlist_l2 == NULL) return;
6023
6024 if (masterparam.session_size > 0) {
6025 kb = masterparam.session_size * 2;
6026 convert_kbytes2mbcorrectminstring(kb,tmp);
6027 gtk_entry_set_text(GTK_ENTRY(cdlist_l2), tmp);
6028 } else {
6029 gtk_entry_set_text(GTK_ENTRY(cdlist_l2), _("Unknown"));
6030 }
6031 }
6032
6033
6034 /* check the absolute given boot-image-file.
6035 make it relative if possible - return 0 if match was not found */
6036
6037 static gint fix_bootimage(gchar *bootimgin, gchar *ret) {
6038 GList *loop;
6039 mstr_redirect_t *mstr;
6040 gchar bootimg[MAXLINE];
6041 gchar tmp[MAXLINE], tmp2[MAXLINE], match[MAXLINE], redir[MAXLINE];
6042 gint n, longest;
6043
6044 strncpy(bootimg, bootimgin, MAXLINE);
6045 strip_string(bootimg);
6046
6047 longest = -1;
6048 strcpy(ret,"");
6049
6050 loop = g_list_first(masterparam.mstr_redir);
6051 while (loop) {
6052 mstr = (mstr_redirect_t *) loop->data;
6053 if (mstr && mstr->mstr_path) {
6054
6055 n = strlen(mstr->mstr_path);
6056 if (strncmp(bootimg, mstr->mstr_path, n) == 0) {
6057 if (n > longest) {
6058 /* remember longest (best) match */
6059 strncpy(match, mstr->mstr_path,
6060 MAXLINE);
6061 if (mstr->redir_path) {
6062 strncpy(redir, mstr->redir_path,
6063 MAXLINE);
6064 } else {
6065 strcpy(redir,"");
6066 }
6067 longest = n;
6068 }
6069 }
6070 }
6071 loop = loop->next;
6072 }
6073 if (longest == -1) {
6074 /* no match was found */
6075 return 0;
6076 } else {
6077 /* now we found a absolute path where the bootimg should be */
6078 /* remove that path from the bootimg and make it so relative */
6079
6080 /* is our match not a directory but a file? */
6081 if (is_not_directory(match)) {
6082 /* strip filename */
6083 get_basedir(match);
6084 }
6085
6086 n = strlen(match);
6087 if (n > strlen(bootimg)) return 0;
6088
6089 strncpy(tmp, bootimg+n, MAXLINE);
6090
6091 /* put redir-path in front and cut any beginning slash */
6092 if (redir[0] == '/') {
6093 strncpy(tmp2, redir+1, MAXLINE);
6094 } else {
6095 strncpy(tmp2, redir, MAXLINE);
6096 }
6097 /* remove double slashes */
6098 if (tmp2[strlen(tmp2)-1] == '/' && tmp[0] == '/') {
6099 tmp2[strlen(tmp2)-1] = '\0';
6100 }
6101 strcat(tmp2, tmp);
6102
6103 /* ok, last check to remove any beginning slashes */
6104 if (tmp2[0] == '/') {
6105 strncpy(tmp, tmp2+1, MAXLINE);
6106 } else {
6107 strncpy(tmp, tmp2, MAXLINE);
6108 }
6109
6110 /* return new relative path */
6111 strncpy(ret, tmp, MAXLINE);
6112
6113 dodebug(3,"translated boot image file: %s -> %s\n", bootimgin, tmp);
6114 }
6115 return 1;
6116 }
6117
6118
6119 /* check if the given boot image is a file and got the right size */
6120 /* return 0 if all is ok */
6121
6122 static gint verify_bootimg() {
6123 gchar bootimg[MAXLINE],tmp[MAXLINE];
6124 off_t size;
6125 struct stat buf;
6126 gint fd;
6127
6128 /* first get current boot entry - dont try global var, because
6129 we might have modified it before */
6130 strncpy(bootimg, gtk_entry_get_text(GTK_ENTRY(bootimg_entry)), MAXLINE);
6131 strip_string(bootimg);
6132
6133 if (strcmp(bootimg,"") == 0 ||
6134 strcmp(masterparam.boot_catalog,"") == 0) {
6135
6136 show_dialog(ICO_WARN,_("Please specify both the boot image and boot catalog\nfor your bootable CD."), T_OK, NULL, NULL, 0);
6137 return 1;
6138 }
6139
6140 /* only check absolute paths */
6141 if (bootimg[0] != '/')
6142 return 0;
6143
6144 if (!is_file(bootimg)) {
6145
6146 g_snprintf(tmp, MAXLINE, _("Cannot find the boot image file you specified:\n\"%s\"\nPlease give a valid file."), bootimg);
6147
6148 show_dialog(ICO_WARN, tmp, T_OK, NULL, NULL, 0);
6149 return 1;
6150 }
6151
6152 /* file readable? */
6153 fd = open(bootimg, O_RDONLY,0);
6154 if (fd == -1) {
6155 g_snprintf(tmp, MAXLINE, _("No read permission on the boot image file you specified:\n\"%s\""), bootimg);
6156
6157 show_dialog(ICO_WARN, tmp, T_OK, NULL, NULL, 0);
6158 return 1;
6159 } else {
6160 close(fd);
6161 }
6162
6163 /* get size of file */
6164 stat(bootimg, &buf);
6165 size = (off_t) buf.st_size;
6166
6167 /* check size only when using floppy images */
6168 if (size != (off_t) 1200*1024 &&
6169 size != (off_t) 1440*1024 &&
6170 size != (off_t) 2880*1024 && masterparam.boot_type == 0) {
6171
6172 show_dialog(ICO_WARN, _("Your boot image file is not valid. It must\nhave a size of either 1200, 1440 or 2880 kB."), T_OK, NULL, NULL, 0);
6173 return 1;
6174 }
6175
6176 /* bootimage added to master dirs? */
6177 if (!fix_bootimage(bootimg, tmp)) {
6178 show_dialog(ICO_WARN,_("Your boot image file seems not to be included\non the CD you are going to master. Make sure to\nadd its path to the master directories."), T_OK, NULL, NULL, 0);
6179 return 1;
6180 } else {
6181 /* we got a new image-path */
6182 g_free(masterparam.boot_image);
6183 masterparam.boot_image = g_strdup(tmp);
6184 }
6185
6186 /* file exists, is readable and got the right size! */
6187 return 0;
6188 }
6189
6190
6191 /* mark our session-size as unknown and update entry */
6192 /* this forces the user to recalculate the size */
6193
6194 static void set_sessionsize_unknown() {
6195
6196 masterparam.session_size = 0;
6197 update_session_size_display();
6198 }
6199
6200
6201 /* show a please wait window when calculating the image data takes
6202 more than a few seconds */
6203
6204 static gint mkisofs_calc_timeout_func(gpointer data) {
6205
6206 mkisofs_calc_timeout_dialog = show_dialog_wait(ICO_INFO,_("Please wait while X-CD-Roast is\ncalculating the current image size."));
6207
6208 g_print("init dialog: %p\n", mkisofs_calc_timeout_dialog);
6209
6210 return (FALSE);
6211 }
6212
6213
6214 /* called from "calculate size" button or from auto mode when entering
6215 the last page of the master menu */
6216
6217 static void calc_size_callback(GtkWidget *widget, gpointer data) {
6218 gint automode;
6219 gint ret;
6220 gint mkisofs_calc_timeout;
6221
6222 /* called from automatic? */
6223 automode = GPOINTER_TO_INT(data);
6224
6225 /* check if multisession on DVD? */
6226 if (curset.multisession == 1 && curset.cdrtype >= 1000) {
6227 ret = show_dialog(ICO_WARN,_("Warning: Its not recommended to try to create multi session\nwith DVD-Media. Its very possible that this will fail."), T_ANYWAY, T_CANCEL, NULL, 1);
6228 if (ret != 0) return;
6229 }
6230
6231 /* check if we have already some directories added */
6232 if (masterparam.mstr_redir == NULL) {
6233 if (automode == 0)
6234 show_dialog(ICO_WARN,_("Please first add some directories to master."), T_OK, NULL, NULL, 0);
6235 return;
6236 }
6237
6238 /* now check if we have specified a valid boot image */
6239 if (masterparam.bootable == 1) {
6240 /* el torito */
6241
6242 /* quick checks on the boot image */
6243 if (automode == 0) {
6244 if (verify_bootimg()) {
6245 /* not ok */
6246 return;
6247 }
6248 }
6249 }
6250 if (masterparam.bootable == 2) {
6251 /* sparc boot */
6252 if (strcmp(masterparam.sparc_boot,"") == 0) {
6253 if (automode == 0)
6254 show_dialog(ICO_WARN,_("Please specify a boot image list for your\nsparc bootable CD."), T_OK, NULL, NULL, 0);
6255 return;
6256 }
6257 }
6258
6259
6260 /* show that we are calculating now */
6261 if (cdlist_l2) {
6262 gtk_entry_set_text(GTK_ENTRY(cdlist_l2), _("Calculating..."));
6263 }
6264
6265 /* show user to wait */
6266 mkisofs_calc_timeout_dialog = NULL;
6267 mkisofs_calc_timeout = 0;
6268 if (automode == 1) {
6269 /* after 5 seconds of calculating show user whats going on */
6270 mkisofs_calc_timeout = gtk_timeout_add(5000,
6271 mkisofs_calc_timeout_func, NULL);
6272 }
6273
6274 show_mkisofs_check_output(automode, &mkisofs_calc_timeout);
6275
6276 if (mkisofs_calc_timeout) {
6277 /* remove the timeout, if it did not kick in yet */
6278 gtk_timeout_remove(mkisofs_calc_timeout);
6279 }
6280
6281 if (mkisofs_calc_timeout_dialog) {
6282 /* and remove the dialog wait window */
6283 show_dialog_wait_remove(mkisofs_calc_timeout_dialog);
6284 }
6285
6286 /* if session_size is now defined scanning was ok */
6287 update_session_size_display();
6288 }
6289
6290
6291 /* user stupidity check - some users added wav files and expected to
6292 get an audio cd mastered */
6293
6294 static gint check_for_added_wav_only() {
6295 GList *loop;
6296 mstr_redirect_t *mstr;
6297 gint found, n, count;
6298 gchar ext[MAXLINE];
6299
6300 found = 0;
6301 count = 0;
6302 loop = g_list_first(masterparam.mstr_redir);
6303 while (loop) {
6304 mstr = (mstr_redirect_t *) loop->data;
6305
6306 if (mstr && mstr->mstr_path) {
6307 n = strlen(mstr->mstr_path);
6308 if (n > 4) {
6309 /* path with .wav extension? */
6310 strncpy(ext, mstr->mstr_path + n-4, MAXLINE);
6311 if (strncasecmp(ext,".wav",4) == 0) {
6312 found++;
6313 }
6314 }
6315 count++;
6316 }
6317 loop = loop->next;
6318 }
6319
6320 if (count > 0 && count == found) {
6321 /* all added paths are wav files */
6322 return 1;
6323 } else {
6324 return 0;
6325 }
6326 }
6327
6328
6329 /* user stupidity check - some users added a single iso file and expected to
6330 get that burned within the master dialog */
6331
6332 static gint check_for_added_iso() {
6333 GList *loop;
6334 mstr_redirect_t *mstr;
6335 gint found, n, count;
6336 gchar ext[MAXLINE];
6337
6338 found = 0;
6339 count = 0;
6340 loop = g_list_first(masterparam.mstr_redir);
6341 while (loop) {
6342 mstr = (mstr_redirect_t *) loop->data;
6343
6344 if (mstr && mstr->mstr_path) {
6345 n = strlen(mstr->mstr_path);
6346 if (n > 4) {
6347 /* path with .iso extension? */
6348 strncpy(ext, mstr->mstr_path + n-4, MAXLINE);
6349 if (strncasecmp(ext,".iso",4) == 0) {
6350 found++;
6351 }
6352 if (strncasecmp(ext,".img",4) == 0) {
6353 found++;
6354 }
6355 }
6356 count++;
6357 }
6358 loop = loop->next;
6359 }
6360
6361 if (count == 1 && count == found) {
6362 /* one added path is iso */
6363 return 1;
6364 } else {
6365 return 0;
6366 }
6367 }
6368
6369
6370 /* called when the create-image button is pressed */
6371
6372 static void master_image_callback(GtkWidget *widget, gpointer data) {
6373 gint stat, ret, session_nr;
6374 gint overwritefree, overwritefreebiggest;
6375
6376 /* first check if image-size has been calculated */
6377 if (masterparam.session_size <= 0) {
6378 show_dialog(ICO_WARN,_("Please click on \"Calculate Size\" first to check if all master options\nare valid and to see how big the image will be."),T_OK,NULL,NULL,0);
6379 return;
6380 }
6381
6382 /* check if boot image settings are correct */
6383 if (masterparam.bootable == 1) {
6384 if (verify_bootimg()) {
6385 /* not ok */
6386 return;
6387 }
6388 }
6389
6390 /* check if user not only added .wav files! */
6391 if (check_for_added_wav_only() == 1) {
6392 ret = show_dialog(ICO_WARN,_("You really want to create a Data CD with only .wav files on it?\nTo create an Audio CD you use the \"Write Tracks\" menu\ninstead of mastering a CD here."),T_ANYWAY,T_CANCEL,NULL,1);
6393 if (ret == 1) {
6394 return;
6395 }
6396 }
6397
6398 /* check if user not only added .iso files! */
6399 if (check_for_added_iso() == 1) {
6400 ret = show_dialog(ICO_WARN,_("You really want to create a Data CD with one big ISO file on it?\nTo burn an ISO file as CD-image use the \"Write Tracks\" menu\ninstead."),T_ANYWAY,T_CANCEL,NULL,1);
6401 if (ret == 1) {
6402 return;
6403 }
6404 }
6405
6406 session_nr = 1;
6407
6408 /* now checks for multisession mode */
6409 if (curset.multisession == 1) {
6410 /* ask if we want do a first or additional session */
6411 ret = show_dialog(ICO_QUEST,_("You have decided to create a multi session CD.\nShould X-CD-Roast create an image for a first\nsession, or an image for an additional session?\n\nIf you want to create an additional session, load\nnow the CD-R/RW to append to in your CD-Writer\nbefore continuing."),
6412 "First session", "Additional session",
6413 T_CANCEL,2);
6414 if (ret == 0) {
6415 /* first session */
6416 masterparam.last_session_start = -1;
6417 masterparam.next_session_start = -1;
6418 }
6419 if (ret == 1) {
6420 /* additional session */
6421
6422 /* no cd-writer defined */
6423 if (curset.writer_devnr == -1) {
6424 show_dialog(ICO_ERROR,_("No CD-Writer defined in Setup"), T_OK, NULL, NULL, 0);
6425 return;
6426 }
6427
6428 /* check if CD is loaded? */
6429 get_cd_toc_and_volid(curset.writer_devnr);
6430 if (cdinfo.nr_tracks == -2) {
6431 /* empty CD */
6432 show_dialog(ICO_WARN,_("There is an empty CD-R/RW in the drive.\nAdditional sessions cannot be written on\nunwritten media."),T_CANCEL,NULL,NULL,0);
6433 return;
6434 }
6435 if (cdinfo.nr_tracks != -1) {
6436 get_msinfo_info(curset.writer_devnr,
6437 &masterparam.last_session_start,
6438 &masterparam.next_session_start);
6439 } else {
6440 /* no cd loaded? abort */
6441 show_dialog(ICO_WARN,_("A CD-R/RW is required in the CD-Writer before\na session can be mastered.\nPlease insert a CD-R/RW and try again."),T_CANCEL,NULL,NULL,0);
6442 return;
6443 }
6444
6445 /* got good session offsets? */
6446 if (masterparam.next_session_start == -1) {
6447 /* unappendable CD */
6448 show_dialog(ICO_WARN,_("This CD is closed. No further data can be written onto it."),T_CANCEL,NULL,NULL,0);
6449 return;
6450 }
6451
6452 /* use next session nr */
6453 session_nr = cdinfo.nr_tracks+1;
6454 }
6455 if (ret == 2) {
6456 /* cancel */
6457 return;
6458 }
6459
6460 /* check if rockridge is enabled */
6461 if ((masterparam.opt[0] + masterparam.opt[2]) == 0) {
6462 show_dialog(ICO_WARN,_("You have to enable Rock Ridge in the ISO9660-Options\nin order to write a multi session CD."),T_OK,NULL, NULL, 0);
6463 return;
6464 }
6465 } else {
6466 /* no multisession */
6467 masterparam.last_session_start = -1;
6468 masterparam.next_session_start = -1;
6469 }
6470
6471 /* lets check if the file-prefix-entry is up to date */
6472 set_image_prefix_callback(imglist_l1, NULL);
6473
6474 /* allocate master-filename and path */
6475 stat = allocate_master_filename(masterparam.session_size * 2,
6476 session_nr, &masterparam.image_filename, &overwritefree,
6477 &overwritefreebiggest);
6478
6479
6480 /* enough free space? */
6481 if (stat == 1) {
6482 show_dialog(ICO_WARN,_("Not enough diskspace available"), T_OK, NULL, NULL, 1);
6483 return;
6484 }
6485
6486 /* no writeable directory? */
6487 if (stat == 2) {
6488 show_dialog(ICO_WARN,_("No image-directories with write permissions found.\nPlease check your settings in the Setup."), T_OK, NULL, NULL, 1);
6489 return;
6490 }
6491
6492 /* overwriting a link? */
6493 if (stat == 3) {
6494 /* FIX HERE USING GETTEXT FOR NEXT RELEASE */
6495 show_dialog(ICO_WARN,"Not allowing to overwrite a symlink.\nChoose another \"File prefix\".", T_OK, NULL, NULL, 1);
6496 return;
6497 }
6498
6499 /* warn we are going to overwrite some files */
6500 if (setupdata.option_overwritewarn == 1 && overwritefree > 0) {
6501 ret = show_dialog(ICO_WARN,_("You are going to overwrite old track images on your\nharddrive. Cancel now, if you don't want to do that\nand choose another \"File prefix\"."), T_ANYWAY, T_CANCEL, NULL, 1);
6502 if (ret == 1) {
6503 /* abort */
6504 return;
6505 }
6506 }
6507
6508 /* start mastering */
6509 show_and_start_master();
6510
6511 /* now write xinf file with track multisession infos */
6512 write_inf_file_for_master(masterparam.image_filename, session_nr);
6513
6514 /* and take care to read updated image-information */
6515 scan_imagedirs();
6516 }
6517
6518
6519 /* called when the create-onthefly button is pressed */
6520
6521 static void master_onthefly_callback(GtkWidget *widget, gpointer data) {
6522 gint spaceneededoncd;
6523 gint ret, avail, cdsize;
6524 gint64 tmpsize;
6525
6526 /* first check if image-size has been calculated */
6527 if (masterparam.session_size <= 0) {
6528 show_dialog(ICO_WARN,_("Please click on \"Calculate Size\" first to check if all master options\nare valid and to see how big the image will be."),T_OK,NULL,NULL,0);
6529 return;
6530 }
6531
6532 /* check if boot image settings are correct */
6533 if (masterparam.bootable == 1) {
6534 if (verify_bootimg()) {
6535 /* not ok */
6536 return;
6537 }
6538 }
6539
6540 /* no cd-writer defined */
6541 if (curset.writer_devnr == -1) {
6542 show_dialog(ICO_ERROR,_("No CD-Writer defined in Setup"), T_OK, NULL, NULL, 0);
6543 return;
6544 }
6545
6546 /* check if user not only added .wav files! */
6547 if (check_for_added_wav_only() == 1) {
6548 ret = show_dialog(ICO_WARN,_("You really want to create a Data CD with only .wav files on it?\nTo create an Audio CD you use the \"Write Tracks\" menu\ninstead of mastering a CD here."),T_ANYWAY,T_CANCEL,NULL,1);
6549 if (ret == 1) {
6550 return;
6551 }
6552 }
6553
6554 /* check if user not only added .iso files! */
6555 if (check_for_added_iso() == 1) {
6556 ret = show_dialog(ICO_WARN,_("You really want to create a Data CD with one big ISO file on it?\nTo burn an ISO file as CD-image use the \"Write Tracks\" menu\ninstead."),T_ANYWAY,T_CANCEL,NULL,1);
6557 if (ret == 1) {
6558 return;
6559 }
6560 }
6561
6562 /* check if some CD is loaded? */
6563 get_cd_toc_and_volid(curset.writer_devnr);
6564 if (cdinfo.nr_tracks != -1) {
6565 get_msinfo_info(curset.writer_devnr,
6566 &masterparam.last_session_start,
6567 &masterparam.next_session_start);
6568 } else {
6569 /* no cd loaded? abort */
6570 ret = show_dialog(ICO_WARN,_("A CD-R/RW is required in the CD-Writer before\na session can be mastered.\nPlease insert a CD-R/RW and try again."),T_OK,T_ANYWAY,T_CANCEL,0);
6571 if (ret != 1) {
6572 return;
6573 }
6574 }
6575
6576 /* multisession CD in drive, but no multisession choosen? */
6577 if (curset.multisession == 0 &&
6578 masterparam.next_session_start != -1) {
6579
6580 ret = show_dialog(ICO_WARN,_("You are going to try to add data to a multi session-CD\nwithout having multi session writing enabled.\nThis can result in an unreadable CD."),"Enable multisession",T_ANYWAY,T_CANCEL,0);
6581 if (ret == 0) {
6582 curset.multisession = 1;
6583 gtk_toggle_button_set_active(
6584 GTK_TOGGLE_BUTTON(master_ms_button), 1);
6585 gtk_toggle_button_set_active(
6586 GTK_TOGGLE_BUTTON(master_ms_button2), 1);
6587 }
6588 if (ret == -1 || ret == 2) {
6589 /* cancel */
6590 return;
6591 }
6592 }
6593
6594 /* check if rockridge is enabled */
6595 if (curset.multisession == 1) {
6596 if ((masterparam.opt[0] + masterparam.opt[2]) == 0) {
6597 show_dialog(ICO_WARN,_("You have to enable Rock Ridge in the ISO9660-Options\nin order to write a multi session CD."),T_OK,NULL, NULL, 0);
6598 return;
6599 }
6600
6601 if (curset.nofixate == 1) {
6602 ret = show_dialog(ICO_WARN,_("In multi session mode it is not recommended to use\nthe \"do not fixate\" option. If you continue you will\ncreate an unreadable CD."),T_ANYWAY,T_CANCEL,NULL,1);
6603 if (ret == 1) {
6604 return;
6605 }
6606 }
6607 }
6608
6609 spaceneededoncd = masterparam.session_size;
6610
6611 /* check if enough space on cd-r? */
6612 dodebug(2,"Sectors required: %d, Mediatype = %d, Next session start = %d\n", spaceneededoncd, curset.cdrtype, masterparam.next_session_start);
6613 if (curset.cdrtype < 1000) {
6614 cdsize = curset.cdrtype*60*75;
6615 } else {
6616 /* capacity of a DVD in bytes */
6617 tmpsize = (gint64)curset.cdrtype * 1000 * 1000;
6618 /* and now in sectors */
6619 tmpsize = tmpsize / 2048;
6620
6621 cdsize = (gint) tmpsize;
6622 }
6623 avail = cdsize;
6624
6625 /* we want to write multisession? consider session overhead */
6626 if (curset.multisession == 1) {
6627 if (cdinfo.nr_tracks > 0) {
6628 /* additional sessions */
6629 avail -= 6900; /* about 13 MB */
6630 } else {
6631 /* first session */
6632 avail -= 11400; /* about 22 MB */
6633 }
6634 }
6635
6636 if (masterparam.next_session_start > 0) {
6637 avail -= masterparam.next_session_start;
6638 }
6639 if (spaceneededoncd > avail) {
6640 if (!is_dvdwriter(curset.writer_devnr)) {
6641 ret = show_dialog(ICO_WARN,_("There may be not enough space on the CD-R available.\nYou can continue at own risk, but the resulting CD\nmight not be readable."),T_ANYWAY,T_CANCEL,NULL,1);
6642 } else {
6643 /* perhaps we want to write a dvd? */
6644 ret = show_dialog(ICO_WARN,_("There may be not enough space on the CD-R available.\nPerhaps you want to write a DVD, but you have not selected\nthe correct media size? You can continue at own\nrisk, but the resulting CD might not be readable."),T_ANYWAY,T_CANCEL,NULL,1);
6645 }
6646 if (ret == 1) {
6647 /* aborted */
6648 return;
6649 }
6650 }
6651
6652 /* ok, now we are sure that all tracks are fine ...prompt for CD-R */
6653 if (curset.multisession == 0) {
6654 if (curset.cdrtype >= 1000 && is_dvdwriter(curset.writer_devnr)) {
6655 ret = show_dialog(ICO_INFO,_("Ready to write a single session DVD?"),T_OK,T_CANCEL,NULL,0);
6656 } else {
6657 ret = show_dialog(ICO_INFO,_("Ready to write a single session CD?"),T_OK,T_CANCEL,NULL,0);
6658 }
6659 } else {
6660 /* multisession */
6661 if (masterparam.next_session_start > 0) {
6662 /* add new session */
6663 if (curset.cdrtype >= 1000 && is_dvdwriter(curset.writer_devnr)) {
6664 ret = show_dialog(ICO_INFO,_("Ready to add a new session to a multi session DVD?"),T_OK,T_CANCEL,NULL,0);
6665 } else {
6666 ret = show_dialog(ICO_INFO,_("Ready to add a new session to a multi session CD?"),T_OK,T_CANCEL,NULL,0);
6667 }
6668 } else {
6669 /* write first session */
6670 if (curset.cdrtype >= 1000 && is_dvdwriter(curset.writer_devnr)) {
6671 ret = show_dialog(ICO_INFO,_("Ready to write the first session of a multi session DVD?"),T_OK,T_CANCEL,NULL,0);
6672 } else {
6673 ret = show_dialog(ICO_INFO,_("Ready to write the first session of a multi session CD?"),T_OK,T_CANCEL,NULL,0);
6674 }
6675 }
6676 }
6677 /* canceled? */
6678 if (ret != 0) {
6679 return;
6680 }
6681
6682 /* start mastering */
6683 show_and_do_write_tracks(curset.writer_devnr, -1, 3);
6684 }
6685
6686
6687 /* calculate the space that would be recycled on the harddrive
6688 when reading tracks and overwriting the ones with same names.
6689 This is used to show the user what space really is free
6690 dependant of the name he chooses for his files */
6691
6692 static gint get_free_space_by_overwriting_masterimage(gint *biggest) {
6693 gint overwrite;
6694 gint overwritebiggest;
6695
6696 if (allocate_master_filename(masterparam.session_size * 2,1,
6697 NULL, &overwrite, &overwritebiggest) == 0) {
6698 *biggest = overwritebiggest;
6699 return overwrite;
6700 } else {
6701 /* no space for image - so nothing to overwrite */
6702 *biggest = 0;
6703 return 0;
6704 }
6705 }
6706
6707
6708 /* fill the entries in the master-menu 5 */
6709
6710 void fill_master_write_menu() {
6711 gchar tmp[MAXLINE];
6712 gchar tmp2[MAXLINE];
6713 gchar tmp3[MAXLINE];
6714 gint overwritefree, normalfree, biggestfree, overwritefreebiggest;
6715
6716 /* file prefix */
6717 if (strcmp(curset.file_prefix,"") == 0) {
6718 g_free(curset.file_prefix);
6719 curset.file_prefix = g_strdup(IMGFILEPREFIX);
6720 }
6721 gtk_entry_set_text(GTK_ENTRY(imglist_l1), curset.file_prefix);
6722 /*
6723 gtk_entry_select_region(GTK_ENTRY(imglist_l1), 0,
6724 GTK_ENTRY(imglist_l1)->text_length);
6725 */
6726
6727 /* now check if the current filename has any influence on
6728 the available space */
6729 overwritefree =
6730 get_free_space_by_overwriting_masterimage(&overwritefreebiggest);
6731
6732 /* free size */
6733 normalfree = determine_free_space(&biggestfree);
6734 convert_kbytes2mbminstring(normalfree,tmp3);
6735
6736 /* additional free space when overwriting files? */
6737 if (cdinfo.nr_tracks > 0 && overwritefree > 0) {
6738 convert_kbytes2mbstring(normalfree+overwritefree, tmp2);
6739 g_snprintf(tmp,MAXLINE,"%s (%s)", tmp3, tmp2);
6740 } else {
6741 strcpy(tmp,tmp3);
6742 }
6743 gtk_entry_set_text(GTK_ENTRY(imglist_l2), tmp);
6744 gtk_entry_set_position(GTK_ENTRY(imglist_l2), 0);
6745
6746 /* biggest free block */
6747 convert_kbytes2mbminstring(biggestfree,tmp3);
6748
6749 if (cdinfo.nr_tracks > 0 && overwritefreebiggest > 0) {
6750 convert_kbytes2mbstring(biggestfree+overwritefreebiggest, tmp2);
6751 g_snprintf(tmp,MAXLINE,"%s (%s)", tmp3, tmp2);
6752 } else {
6753 strcpy(tmp,tmp3);
6754 }
6755 gtk_entry_set_text(GTK_ENTRY(imglist_l3), tmp);
6756 gtk_entry_set_position(GTK_ENTRY(imglist_l3), 0);
6757
6758 /* session information */
6759 update_session_size_display();
6760 }
6761
6762
6763 /* special version to also update the available calculator */
6764
6765 static void cdrtype_mstr_selected(GtkWidget *item, gpointer mode) {
6766
6767 curset.cdrtype = GPOINTER_TO_INT(mode);
6768 fill_session_available();
6769 }
6770
6771
6772 /* special version to also update availsize session size */
6773
6774 static void writeoptions_selected_mstr(GtkWidget *item, gpointer nr) {
6775 gint sel, btn;
6776
6777 sel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
6778 btn = GPOINTER_TO_INT(nr);
6779
6780
6781 switch(btn) {
6782 case 5:
6783 /* sync both multisession buttons first */
6784 gtk_signal_handler_block(GTK_OBJECT(master_ms_button),master_ms_button_signal);
6785 gtk_signal_handler_block(GTK_OBJECT(master_ms_button2),master_ms_button2_signal);
6786 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(master_ms_button), sel);
6787 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(master_ms_button2), sel);
6788 gtk_signal_handler_unblock(GTK_OBJECT(master_ms_button),master_ms_button_signal);
6789 gtk_signal_handler_unblock(GTK_OBJECT(master_ms_button2),master_ms_button2_signal);
6790
6791 curset.multisession = sel;
6792 fill_session_available();
6793 /* force recalc of session size if dvd */
6794 /* so he will get the multisession warning */
6795 if (curset.cdrtype >= 1000 && ( curset.isProDVD & 1 ) && curset.multisession == 1) {
6796 set_sessionsize_unknown();
6797 }
6798 break;
6799 case 9:
6800 curset.mstr_auto_calc = sel;
6801 break;
6802 default:
6803 break;
6804 }
6805 }
6806
6807
6808 /* fifth submenu of master menu (create session) */
6809
6810 static void draw_master_menu5(GtkWidget *box) {
6811 GtkWidget *vbox, *hbox, *vbox2;
6812 GtkWidget *f1, *f2, *f3, *e1;
6813 GtkWidget *tbl, *l1, *b1;
6814 GtkWidget *sep, *check;
6815 GtkWidget *omenu;
6816 GtkWidget *menu;
6817 GtkWidget *menu_item;
6818 gint menuidx, menuhistory;
6819 gint cdrtypes[] = CDR_TYPES_MIN;
6820 gint dvdtypes[] = DVD_TYPES_MB;
6821 static const gchar *writemodes[] = WRITE_MODES;
6822 static const gchar *helpwritemodes[] = HELP_WRITE_MODES;
6823 gint i, tmpval;
6824 gchar tmp[MAXLINE];
6825 gchar tmp2[MAXLINE];
6826
6827 crea_cd_burnfree_check = NULL;
6828
6829 /* left and right info-frames */
6830 tbl = gtk_table_new(1,2,TRUE);
6831 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
6832 gtk_table_set_col_spacings(GTK_TABLE(tbl),2);
6833 gtk_box_pack_start(GTK_BOX(box),tbl,TRUE,TRUE,0);
6834 gtk_widget_show(tbl);
6835
6836 vbox2 = gtk_vbox_new(FALSE,0);
6837 gtk_table_attach_defaults(GTK_TABLE(tbl),vbox2,0,1,0,1);
6838 gtk_widget_show(vbox2);
6839
6840 f1 = gtk_frame_new(_("Session information"));
6841 set_font_and_color_frame(f1,BOLDFONT,NULL);
6842 gtk_box_pack_start(GTK_BOX(vbox2),f1,TRUE,TRUE,0);
6843 gtk_widget_show(f1);
6844
6845 /* fill block */
6846 hbox = gtk_hbox_new(TRUE,0);
6847 gtk_box_pack_start(GTK_BOX(vbox2),hbox,FALSE,TRUE,2);
6848 gtk_widget_show(hbox);
6849
6850 f3 = gtk_frame_new(_("Create session on hard disk"));
6851 set_font_and_color_frame(f3,BOLDFONT,NULL);
6852 gtk_box_pack_start(GTK_BOX(vbox2),f3,TRUE,TRUE,0);
6853 gtk_widget_show(f3);
6854 f2 = gtk_frame_new(_("Write session on-the-fly"));
6855 set_font_and_color_frame(f2,BOLDFONT,NULL);
6856 gtk_table_attach_defaults(GTK_TABLE(tbl),f2,1,2,0,1);
6857 gtk_widget_show(f2);
6858
6859 /* left info frame */
6860 vbox = gtk_vbox_new(FALSE,0);
6861 gtk_container_add(GTK_CONTAINER(f1),vbox);
6862 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
6863 gtk_widget_show(vbox);
6864
6865 tbl = gtk_table_new(4,16,TRUE);
6866 gtk_table_set_row_spacings(GTK_TABLE(tbl),5);
6867 gtk_table_set_col_spacings(GTK_TABLE(tbl),5);
6868 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,0);
6869 gtk_widget_show(tbl);
6870
6871 l1 = rightjust_gtk_label_new(_("Used/Available:"));
6872 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,8,0,1);
6873 gtk_widget_show(l1);
6874
6875 e1 = gtk_entry_new();
6876 cdlist_l1 = e1;
6877 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
6878 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,8,16,0,1);
6879 gtk_widget_show(e1);
6880 define_tooltip(e1, _("The space already used on the CD-R/RW by old sessions and the still available space."));
6881
6882 l1 = rightjust_gtk_label_new(_("New session size:"));
6883 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,8,1,2);
6884 gtk_widget_show(l1);
6885
6886 e1 = gtk_entry_new();
6887 cdlist_l2 = e1;
6888 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
6889 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,8,16,1,2);
6890 gtk_widget_show(e1);
6891 define_tooltip(e1, _("The calculated size of the new session/image. If you choose to write the image to hard drive, this is the free space you need in the image-directories. When burning on-the-fly make sure there is enough space left on the CD-R/RW."));
6892
6893 b1 = gtk_button_new_with_label(_("Calculate size"));
6894 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
6895 GTK_SIGNAL_FUNC(calc_size_callback),GINT_TO_POINTER(0));
6896 gtk_table_attach_defaults(GTK_TABLE(tbl),b1,5,16,2,3);
6897 gtk_widget_show(b1);
6898 define_tooltip(b1, _("This calculates the exact size of your new session/image. Everytime you change the master-options or add/remove paths to master you have to redo this."));
6899
6900 check = gtk_check_button_new_with_label(_("Calculate automatically"));
6901 gtk_signal_connect(GTK_OBJECT(check),"clicked",
6902 GTK_SIGNAL_FUNC(writeoptions_selected_mstr),GINT_TO_POINTER(9));
6903 gtk_table_attach_defaults(GTK_TABLE(tbl),check,5,16,3,4);
6904 gtk_widget_show(check);
6905 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
6906 curset.mstr_auto_calc);
6907 define_tooltip(check, _("Calculate automatically the required space for the current session everytime you enter this menu."));
6908
6909 /* lower left info frame */
6910 vbox = gtk_vbox_new(FALSE,0);
6911 gtk_container_add(GTK_CONTAINER(f3),vbox);
6912 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
6913 gtk_widget_show(vbox);
6914
6915 tbl = gtk_table_new(5,16,TRUE);
6916 gtk_table_set_row_spacing(GTK_TABLE(tbl),0,5);
6917 gtk_table_set_row_spacing(GTK_TABLE(tbl),1,5);
6918 gtk_table_set_col_spacings(GTK_TABLE(tbl),5);
6919 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,0);
6920 gtk_widget_show(tbl);
6921
6922 l1 = rightjust_gtk_label_new(_("File prefix:"));
6923 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,8,0,1);
6924 gtk_widget_show(l1);
6925
6926 e1 = gtk_entry_new();
6927 imglist_l1 = e1;
6928 gtk_signal_connect(GTK_OBJECT(e1), "activate",
6929 GTK_SIGNAL_FUNC(set_image_prefix_callback),NULL);
6930 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,8,16,0,1);
6931 gtk_widget_show(e1);
6932 define_tooltip(e1, _("This is the prefix of the filenames of the tracks saved to the harddrive."));
6933
6934 l1 = rightjust_gtk_label_new(_("Free space:"));
6935 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,8,1,2);
6936 gtk_widget_show(l1);
6937
6938 e1 = gtk_entry_new();
6939 imglist_l2 = e1;
6940 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
6941 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,8,16,1,2);
6942 gtk_widget_show(e1);
6943
6944 l1 = leftjust_gtk_label_new(_("biggest available block of that:"));
6945 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,2,16,2,3);
6946 gtk_widget_show(l1);
6947
6948 e1 = gtk_entry_new();
6949 imglist_l3 = e1;
6950 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
6951 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,8,16,3,4);
6952 gtk_widget_show(e1);
6953
6954 check = gtk_check_button_new_with_label(_("Write as multi session"));
6955 master_ms_button2 = check;
6956 master_ms_button2_signal = gtk_signal_connect(GTK_OBJECT(check),"clicked",
6957 GTK_SIGNAL_FUNC(writeoptions_selected_mstr),GINT_TO_POINTER(5));
6958 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,4,5);
6959 gtk_widget_show(check);
6960 define_tooltip(check,_("Write the CD in such a way, that it is possible to append further data (in a new session) at a later time. Please note that for the first session you need 22 MB extra space on the CD-R/RW and all additional sessions take 13 MB extra each."));
6961
6962
6963 /* fill block */
6964 hbox = gtk_hbox_new(TRUE,0);
6965 gtk_box_pack_start(GTK_BOX(vbox),hbox,TRUE,TRUE,0);
6966 gtk_widget_show(hbox);
6967
6968 /* buttons at bottom */
6969 hbox = gtk_hbox_new(TRUE,10);
6970 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,5);
6971 gtk_widget_show(hbox);
6972 b1 = gtk_button_new_with_label(_("Master to image file"));
6973 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
6974 GTK_SIGNAL_FUNC(master_image_callback),NULL);
6975 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,3);
6976 gtk_widget_show(b1);
6977 define_tooltip(b1, _("Creates the ISO9660 image on your hard drive. You can burn this image later with the \"Write Tracks\" menu."));
6978
6979
6980 /* right info frame */
6981 vbox = gtk_vbox_new(FALSE,0);
6982 gtk_container_add(GTK_CONTAINER(f2),vbox);
6983 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
6984 gtk_widget_show(vbox);
6985
6986 tbl = gtk_table_new(12,16,FALSE);
6987 gtk_table_set_row_spacing(GTK_TABLE(tbl),0,2);
6988 gtk_table_set_row_spacing(GTK_TABLE(tbl),1,5);
6989 gtk_table_set_row_spacing(GTK_TABLE(tbl),2,5);
6990 gtk_table_set_col_spacings(GTK_TABLE(tbl),2);
6991 gtk_table_set_col_spacing(GTK_TABLE(tbl),14,0);
6992 gtk_table_set_row_spacing(GTK_TABLE(tbl),10,5);
6993 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,0);
6994 gtk_widget_show(tbl);
6995
6996 l1 = rightjust_gtk_label_new(_("Disc Type:"));
6997 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,6,0,1);
6998 gtk_widget_show(l1);
6999
7000 omenu = gtk_option_menu_new();
7001 menu = gtk_menu_new();
7002 menuidx = 0; menuhistory = 0;
7003 i = 0;
7004 tmpval = curset.cdrtype;
7005 while (cdrtypes[i] != 0) {
7006 /* contruct minute-list */
7007 g_snprintf(tmp,MAXLINE,"%d min",abs(cdrtypes[i]));
7008
7009 menu_item = gtk_menu_item_new_with_label(tmp);
7010 gtk_signal_connect(GTK_OBJECT(menu_item),
7011 "activate", GTK_SIGNAL_FUNC(cdrtype_mstr_selected),
7012 GINT_TO_POINTER(abs(cdrtypes[i])));
7013 gtk_menu_append (GTK_MENU (menu), menu_item);
7014 if (tmpval == abs(cdrtypes[i])) {
7015 menuhistory = menuidx;
7016 }
7017 /* default set definded by negativ value */
7018 if (tmpval == 0 && cdrtypes[i] < 0) {
7019 menuhistory = menuidx;
7020 curset.cdrtype = abs(cdrtypes[i]);
7021 }
7022 menuidx++;
7023 gtk_widget_show (menu_item);
7024 i++;
7025 }
7026 if (curset.isProDVD) {
7027 i = 0;
7028 tmpval = curset.cdrtype;
7029 while (dvdtypes[i] != 0) {
7030 /* contruct GB-list */
7031 g_snprintf(tmp2,MAXLINE,"%.2f", (gfloat)dvdtypes[i]/1000);
7032 /* strip last 0 */
7033 if (tmp2[strlen(tmp2)-1] == '0') {
7034 tmp2[strlen(tmp2)-1] = '\0';
7035 }
7036 g_snprintf(tmp,MAXLINE,"%s GB",tmp2);
7037
7038 menu_item = gtk_menu_item_new_with_label(tmp);
7039 gtk_signal_connect(GTK_OBJECT(menu_item),
7040 "activate", GTK_SIGNAL_FUNC(cdrtype_mstr_selected),
7041 GINT_TO_POINTER(dvdtypes[i]));
7042 gtk_menu_append (GTK_MENU (menu), menu_item);
7043 if (tmpval == abs(dvdtypes[i])) {
7044 menuhistory = menuidx;
7045 }
7046 menuidx++;
7047 gtk_widget_show (menu_item);
7048 i++;
7049 }
7050 }
7051
7052 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
7053 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),menuhistory);
7054 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,6,10,0,1);
7055 gtk_widget_show(omenu);
7056 define_tooltip(omenu,_("The capacity of the currently used CD-R/RW."));
7057
7058 b1 = gtk_button_new_with_label(_("ATIP-Info"));
7059 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
7060 GTK_SIGNAL_FUNC(show_atip_info),NULL);
7061 gtk_table_attach_defaults(GTK_TABLE(tbl),b1,10,16,0,1);
7062 gtk_widget_show(b1);
7063 define_tooltip(b1,_("Read detailed information from a (empty) CD-R/RW."));
7064
7065 /* write-mode */
7066 l1 = rightjust_gtk_label_new(_("Write Mode:"));
7067 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,6,1,2);
7068 gtk_widget_show(l1);
7069
7070 omenu = gtk_option_menu_new ();
7071 menu = gtk_menu_new();
7072 crea_cd_mode_omenu = omenu;
7073
7074 i = 0;
7075 while (writemodes[i]) {
7076 menu_item = gtk_menu_item_new_with_label(_(writemodes[i]));
7077 gtk_signal_connect(GTK_OBJECT(menu_item), "activate",
7078 GTK_SIGNAL_FUNC(writemode_selected),
7079 GINT_TO_POINTER(i));
7080 gtk_menu_append (GTK_MENU (menu), menu_item);
7081 gtk_widget_show (menu_item);
7082 if (helpwritemodes[i])
7083 define_tooltip(menu_item,(gchar *)_(helpwritemodes[i])); i++;
7084 }
7085
7086 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
7087 preselect_write_mode_menu(omenu, curset.writer_devnr);
7088 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,6,16,1,2);
7089 gtk_widget_show(omenu);
7090 /* concat 2 help strings */
7091 g_snprintf(tmp,MAXLINE,"%s %s",_("Choose which write mode you want to use with your CD-Writer. Not all modes are supported with all writers. Try \"DAO\" first, because its usually the best option. If the write fails, try one of the \"TAO\" modes."), _("Click an option and hold the button to get additional help for each mode."));
7092 define_tooltip(omenu,tmp);
7093
7094 if (!isroot() && !setupdata.root_option_change_writeparam) {
7095 gtk_widget_set_sensitive(omenu,FALSE);
7096 }
7097
7098 sep = gtk_hseparator_new();
7099 gtk_table_attach_defaults(GTK_TABLE(tbl),sep,0,16,2,3);
7100 gtk_widget_show(sep);
7101
7102 check = gtk_check_button_new_with_label(_("Write as multi session"));
7103 master_ms_button = check;
7104 master_ms_button_signal = gtk_signal_connect(GTK_OBJECT(check),"clicked",
7105 GTK_SIGNAL_FUNC(writeoptions_selected_mstr),GINT_TO_POINTER(5));
7106 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,3,4);
7107 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
7108 curset.multisession);
7109 gtk_widget_show(check);
7110 define_tooltip(check,_("Write the CD in such a way, that it is possible to append further data (in a new session) at a later time. Please note that for the first session you need 22 MB extra space on the CD-R/RW and all additional sessions take 13 MB extra each."));
7111
7112 check = gtk_check_button_new_with_label(_("Simulation write"));
7113 gtk_signal_connect(GTK_OBJECT(check),"clicked",
7114 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(0));
7115 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,4,5);
7116 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
7117 curset.writesimul);
7118 gtk_widget_show(check);
7119 define_tooltip(check,_("Just simulate the write-process. Please be aware that aborting a simulation-write is generally a bad idea, because you can hang the SCSI-bus."));
7120
7121 check = gtk_check_button_new_with_label(_("Eject after write"));
7122 gtk_signal_connect(GTK_OBJECT(check),"clicked",
7123 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(1));
7124 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,5,6);
7125 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
7126 curset.writeeject);
7127 gtk_widget_show(check);
7128 define_tooltip(check,_("Eject the CD after the burning was completed."));
7129
7130 check = gtk_check_button_new_with_label(_("Pad Tracks"));
7131 gtk_signal_connect(GTK_OBJECT(check),"clicked",
7132 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(2));
7133 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,6,7);
7134 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
7135 curset.writepad);
7136 gtk_widget_show(check);
7137 define_tooltip(check,_("Pads data-tracks with zeros to eliminate reading problems on some systems and adapts the length of audio-tracks for CD writing. This must be enabled when you want to burn wav-files not created with X-CD-Roast."));
7138
7139 check = gtk_check_button_new_with_label(_("Do not fixate after write"));
7140 gtk_signal_connect(GTK_OBJECT(check),"clicked",
7141 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(4));
7142 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,7,8);
7143 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
7144 curset.nofixate);
7145 gtk_widget_show(check);
7146 define_tooltip(check,_("This prevents the CD-Writer from fixating (closing) the CD after writing. You can use this to create an audio CD in several steps. Just be sure to fixate after the last track. (Or use the \"Fixate CD-R/RW only\" button.) Note: This does only work in Track-At-Once-Mode."));
7147
7148
7149 check = gtk_check_button_new_with_label(_("Enable protection from Buffer Underruns"));
7150 crea_cd_burnfree_check = check;
7151
7152 gtk_signal_connect(GTK_OBJECT(check),"clicked",
7153 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(8));
7154 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,8,9);
7155 if (does_support_burnproof(curset.writer_devnr)) {
7156 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
7157 curset.writeburnfree);
7158 }
7159 gtk_widget_show(check);
7160 define_tooltip(check,_("When available it does enable protection from Buffer Underrun errors. Supported are Sanyo BURN-Proof, Ricoh Just-Link and similar."));
7161
7162 if (!does_support_burnproof(curset.writer_devnr))
7163 gtk_widget_set_sensitive(check,FALSE);
7164
7165 /* seperator */
7166 l1 = gtk_label_new("");
7167 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,2,12,9,10);
7168 gtk_widget_show(l1);
7169
7170 b1 = gtk_button_new_with_label(_("Advanced options"));
7171 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
7172 GTK_SIGNAL_FUNC(adv_write_options_clicked), NULL);
7173 gtk_table_attach_defaults(GTK_TABLE(tbl),b1,2,12,10,11);
7174 gtk_widget_show(b1);
7175 define_tooltip(b1,_("Set additional write options for advanced users."));
7176 /* blank button */
7177 if (!curset.isProDVD) {
7178 b1 = gtk_button_new_with_label(_("Blank CD-RW"));
7179 } else {
7180 b1 = gtk_button_new_with_label(_("Blank CD/DVD+-RW"));
7181 }
7182 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
7183 GTK_SIGNAL_FUNC(blankcd_clicked), NULL);
7184 gtk_table_attach_defaults(GTK_TABLE(tbl),b1,2,12,11,12);
7185 gtk_widget_show(b1);
7186 define_tooltip(b1,_("Blanks a CD-RW in the Write-Device."));
7187
7188 /* fill block */
7189 hbox = gtk_hbox_new(TRUE,0);
7190 gtk_box_pack_start(GTK_BOX(vbox),hbox,TRUE,TRUE,0);
7191 gtk_widget_show(hbox);
7192
7193 /* buttons at bottom */
7194 hbox = gtk_hbox_new(TRUE,10);
7195 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,5);
7196 gtk_widget_show(hbox);
7197 b1 = gtk_button_new_with_label(_("Master and write on-the-fly"));
7198 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
7199 GTK_SIGNAL_FUNC(master_onthefly_callback),NULL);
7200 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,3);
7201 gtk_widget_show(b1);
7202 define_tooltip(b1, _("Create the ISO9660 image on-the-fly. You don't need extra storage on the hard drive and it is faster then creating first an image and later burn it. But there is the risk of a buffer underrun when your computer can't deliver the master data fast enough. In this case the CD-R is usually lost. Reducing the write speed may be a good idea."));
7203
7204 /* invalidate session info */
7205 masterparam.last_session_start = -1;
7206 masterparam.next_session_start = -1;
7207
7208 /* fill entries */
7209 fill_master_write_menu();
7210 fill_session_available();
7211 }
7212
7213
7214 /* detect when we enter the menu5 to auto calc the session size */
7215
7216 static void mastertracks_notebookswitch(GtkWidget *widget, GtkNotebookPage *page, gint page_num) {
7217 gint curpage;
7218
7219 curpage = gtk_notebook_get_current_page(GTK_NOTEBOOK(widget));
7220
7221 if (curpage != -1 && page_num == 4) {
7222 if (curset.mstr_auto_calc == 1 &&
7223 masterparam.session_size <= 0) {
7224 /* auto calc is on and session size is unknown */
7225
7226 dodebug(2,"Try automatically calculation of session size\n");
7227 calc_size_callback(NULL, GINT_TO_POINTER(1));
7228 }
7229 }
7230 }
7231
7232
7233 /* draw the master menu */
7234
7235 static void draw_master_menu() {
7236 GtkWidget *notebook;
7237 GtkWidget *tbl, *f1;
7238 GtkWidget *vbox, *l1;
7239 gchar tmp[MAXLINE];
7240
7241 /* prepare draw area */
7242 clear_actionspace();
7243
7244 /* session-size-entry, init with NULL to prevent error when
7245 drawing the notebooktabs */
7246 cdlist_l2 = NULL;
7247 crea_cd_mode_omenu = NULL;
7248
7249 f1 = gtk_frame_new(_("Devices-Setup"));
7250 set_font_and_color_frame(f1,BOLDFONT,NULL);
7251 gtk_box_pack_start(GTK_BOX(actionspace),f1,FALSE,FALSE,5);
7252 gtk_widget_show(f1);
7253
7254 tbl = gtk_table_new(2,16*4,TRUE);
7255 gtk_table_set_col_spacing(GTK_TABLE(tbl),4*4-1,5);
7256 gtk_table_set_col_spacing(GTK_TABLE(tbl),15*4-2,5);
7257 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
7258 gtk_container_add(GTK_CONTAINER(f1),tbl);
7259 gtk_widget_show(tbl);
7260
7261 devices_setup_image(0, tbl);
7262 devices_setup_write(1, tbl);
7263
7264 gtk_widget_show(actionspace);
7265
7266 /* notebook tabs */
7267 notebook = gtk_notebook_new();
7268 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
7269 gtk_box_pack_start(GTK_BOX(actionspace),notebook,TRUE,TRUE,2);
7270 gtk_widget_show(notebook);
7271
7272 gtk_signal_connect_after (GTK_OBJECT (notebook), "switch_page",
7273 GTK_SIGNAL_FUNC (mastertracks_notebookswitch), NULL);
7274
7275 vbox = gtk_vbox_new(FALSE,0);
7276 l1 = gtk_label_new(_("Master source"));
7277 gtk_widget_show_all(vbox);
7278 gtk_notebook_append_page(GTK_NOTEBOOK (notebook),vbox,l1);
7279 draw_master_menu1(vbox);
7280
7281 vbox = gtk_vbox_new(FALSE,0);
7282 l1 = gtk_label_new(_("ISO9660 options"));
7283 gtk_widget_show_all(vbox);
7284 gtk_notebook_append_page(GTK_NOTEBOOK (notebook),vbox,l1);
7285 draw_master_menu2(vbox);
7286
7287 vbox = gtk_vbox_new(FALSE,0);
7288 l1 = gtk_label_new(_("Boot options"));
7289 gtk_widget_show_all(vbox);
7290 gtk_notebook_append_page(GTK_NOTEBOOK (notebook),vbox,l1);
7291 draw_master_menu4(vbox);
7292
7293 vbox = gtk_vbox_new(FALSE,0);
7294 l1 = gtk_label_new(_("ISO9660 header"));
7295 gtk_widget_show_all(vbox);
7296 gtk_notebook_append_page(GTK_NOTEBOOK (notebook),vbox,l1);
7297 draw_master_menu3(vbox);
7298
7299 vbox = gtk_vbox_new(FALSE,0);
7300 l1 = gtk_label_new(_("Create session/image"));
7301 gtk_widget_show_all(vbox);
7302 gtk_notebook_append_page(GTK_NOTEBOOK (notebook),vbox,l1);
7303 draw_master_menu5(vbox);
7304
7305 /* now generate 2 empty files to hold our master paths */
7306 /* will be removed when the master menu is quit */
7307 if (master_fname1) {
7308 g_free(master_fname1);
7309 master_fname1 = NULL;
7310 }
7311 generate_tmp_file_name("mstr", tmp);
7312 if (*tmp) {
7313 if (write_empty_file(tmp) == 0)
7314 master_fname1 = g_strdup(tmp);
7315 }
7316 if (!master_fname1)
7317 g_warning("failed to generate temporary master file1\n");
7318
7319 if (master_fname2) {
7320 g_free(master_fname2);
7321 master_fname2 = NULL;
7322 }
7323 generate_tmp_file_name("excl", tmp);
7324 if (*tmp) {
7325 if (write_empty_file(tmp) == 0)
7326 master_fname2 = g_strdup(tmp);
7327 }
7328 if (!master_fname2)
7329 g_warning("failed to generate temporary master file2\n");
7330 }
7331
7332
7333 /* -------------------------------- */
7334
7335 /* unselects all buttons on the sidebar (except the one given)
7336 So there is always only one selected */
7337
7338 void reset_duplicate_buttons2(GtkWidget *exclude, gint fromunlock) {
7339 int i;
7340
7341 for (i = 0; i < 8; i++) {
7342 if (side_widgets2[i] != exclude) {
7343 gtk_signal_handler_block(GTK_OBJECT(side_widgets2[i]),side_handlers2[i]);
7344 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(side_widgets2[i]),0);
7345 gtk_signal_handler_unblock(GTK_OBJECT(side_widgets2[i]),side_handlers2[i]);
7346 }
7347 }
7348
7349 /* because this is called whenever somebody clicks on a
7350 sidebar button, we can here check if the wav-player
7351 process from "play track" is still running, when the
7352 user quits this menu. So lets care here that it is
7353 terminated in a nice way */
7354
7355 if (wav_in != -1) {
7356 do_lock(0);
7357
7358 /* we want to quit the wavplayer.. */
7359 wavplay_quit = 1;
7360
7361 /* simulate quit-button-press */
7362 gtk_button_clicked(GTK_BUTTON(wav_quit_button));
7363
7364 /* now wait until we are really finished */
7365 while (wav_in != -1) {
7366 wait_and_process_events();
7367 }
7368
7369 /* now give gtk some extra time to initialize */
7370 for (i = 0; i < 3; i++) {
7371 wait_and_process_events();
7372 }
7373
7374 do_unlock(0);
7375 }
7376
7377 if (!fromunlock) {
7378 /* when changing the menus, remove temporary toc files */
7379 remove_tmp_xcdr_files();
7380 }
7381 }
7382
7383 static void menu_create_info(GtkWidget *widget, gpointer data) {
7384
7385 /* if button already pressed ignore and undo click */
7386 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == 0) {
7387 gtk_signal_handler_block(GTK_OBJECT(widget),side_handlers2[0]);
7388 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),1);
7389 gtk_signal_handler_unblock(GTK_OBJECT(widget),side_handlers2[0]);
7390 return;
7391 }
7392 reset_duplicate_buttons2(widget,0);
7393
7394 dolog(2, "Entering create: info menu\n");
7395 draw_info_menu();
7396 }
7397
7398
7399 static void menu_create_read(GtkWidget *widget, gpointer data) {
7400
7401 /* if button already pressed ignore and undo click */
7402 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == 0) {
7403 gtk_signal_handler_block(GTK_OBJECT(widget),side_handlers2[1]);
7404 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),1);
7405 gtk_signal_handler_unblock(GTK_OBJECT(widget),side_handlers2[1]);
7406 return;
7407 }
7408 reset_duplicate_buttons2(widget,0);
7409
7410 dolog(2, "Entering create: read menu\n");
7411 draw_read_tracks();
7412 }
7413
7414
7415 static void menu_create_verify(GtkWidget *widget, gpointer data) {
7416
7417 /* if button already pressed ignore and undo click */
7418 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == 0) {
7419 gtk_signal_handler_block(GTK_OBJECT(widget),side_handlers2[2]);
7420 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),1);
7421 gtk_signal_handler_unblock(GTK_OBJECT(widget),side_handlers2[2]);
7422 return;
7423 }
7424 reset_duplicate_buttons2(widget,0);
7425
7426 dolog(2, "Entering create: verify menu\n");
7427 draw_verify_tracks();
7428 }
7429
7430
7431 static void menu_create_play(GtkWidget *widget, gpointer data) {
7432
7433 /* if button already pressed ignore and undo click */
7434 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == 0) {
7435 gtk_signal_handler_block(GTK_OBJECT(widget),side_handlers2[3]);
7436 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),1);
7437 gtk_signal_handler_unblock(GTK_OBJECT(widget),side_handlers2[3]);
7438 return;
7439 }
7440 reset_duplicate_buttons2(widget,0);
7441
7442 dolog(2, "Entering create: play menu\n");
7443 draw_play_tracks_menu();
7444 }
7445
7446
7447 static void menu_create_master(GtkWidget *widget, gpointer data) {
7448
7449 /* if button already pressed ignore and undo click */
7450 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == 0) {
7451 gtk_signal_handler_block(GTK_OBJECT(widget),side_handlers2[4]);
7452 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),1);
7453 gtk_signal_handler_unblock(GTK_OBJECT(widget),side_handlers2[4]);
7454 return;
7455 }
7456 reset_duplicate_buttons2(widget,0);
7457
7458 dolog(2, "Entering create: master menu\n");
7459
7460 draw_master_menu();
7461 }
7462
7463
7464 static void menu_create_write(GtkWidget *widget, gpointer data) {
7465
7466 /* if button already pressed ignore and undo click */
7467 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == 0) {
7468 gtk_signal_handler_block(GTK_OBJECT(widget),side_handlers2[5]);
7469 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),1);
7470 gtk_signal_handler_unblock(GTK_OBJECT(widget),side_handlers2[5]);
7471 return;
7472 }
7473 reset_duplicate_buttons2(widget,0);
7474
7475 dolog(2, "Entering create: write menu\n");
7476 draw_write_tracks();
7477 }
7478
7479
7480 static void menu_create_delete(GtkWidget *widget, gpointer data) {
7481
7482 /* if button already pressed ignore and undo click */
7483 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == 0) {
7484 gtk_signal_handler_block(GTK_OBJECT(widget),side_handlers2[6]);
7485 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),1);
7486 gtk_signal_handler_unblock(GTK_OBJECT(widget),side_handlers2[6]);
7487 return;
7488 }
7489 reset_duplicate_buttons2(widget,0);
7490
7491 dolog(2, "Entering create: delete menu\n");
7492 draw_delete_menu();
7493 }
7494
7495
7496 static void menu_create_back(GtkWidget *widget, gpointer data) {
7497
7498 reset_duplicate_buttons2(widget,0);
7499 create_main(0);
7500 }
7501
7502
7503 /* called by the create-button */
7504
7505 void create_create() {
7506 GtkWidget *side_t;
7507 GtkWidget *head,*head_l;
7508 GtkWidget *b1;
7509
7510 submenu = 2;
7511 clear_sidespace();
7512 clear_workspace();
7513
7514 side_t = gtk_table_new(10,1, TRUE);
7515 gtk_table_set_row_spacings(GTK_TABLE(side_t),10);
7516 gtk_box_pack_start(GTK_BOX(sidespace), side_t,TRUE,TRUE,0);
7517
7518 b1 = gtk_toggle_button_new_with_label(_("CD/Image Info"));
7519 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,1,2);
7520 /* preselect the first button */
7521 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(b1),1);
7522 gtk_widget_show(b1);
7523 side_handlers2[0] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
7524 GTK_SIGNAL_FUNC(menu_create_info),NULL);
7525 side_widgets2[0] = b1;
7526 define_tooltip(b1,_("Displays information about the currently inserted CD and tracks stored on the harddrive."));
7527
7528 b1 = gtk_toggle_button_new_with_label(_("Read Tracks"));
7529 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,2,3);
7530 gtk_widget_show(b1);
7531 side_handlers2[1] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
7532 GTK_SIGNAL_FUNC(menu_create_read),NULL);
7533 side_widgets2[1] = b1;
7534 define_tooltip(b1,_("Reads selected tracks from a CD and stores them on the harddrive."));
7535
7536 b1 = gtk_toggle_button_new_with_label(_("Verify Tracks"));
7537 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,3,4);
7538 gtk_widget_show(b1);
7539 side_handlers2[2] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
7540 GTK_SIGNAL_FUNC(menu_create_verify),NULL);
7541 side_widgets2[2] = b1;
7542 define_tooltip(b1,_("Reads selected tracks again from CD and compares them with the saved tracks on the harddrive."));
7543
7544 b1 = gtk_toggle_button_new_with_label(_("Play Audio-Tracks"));
7545 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,4,5);
7546 gtk_widget_show(b1);
7547 side_handlers2[3] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
7548 GTK_SIGNAL_FUNC(menu_create_play),NULL);
7549 side_widgets2[3] = b1;
7550 define_tooltip(b1,_("Plays audio tracks (.wav files) from the harddrive via soundcard."));
7551
7552 b1 = gtk_toggle_button_new_with_label(_("Master Tracks"));
7553 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,5,6);
7554 gtk_widget_show(b1);
7555 side_handlers2[4] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
7556 GTK_SIGNAL_FUNC(menu_create_master),NULL);
7557 side_widgets2[4] = b1;
7558 define_tooltip(b1,_("Creates an ISO9660-image of files and directories on your harddrive. Use this to create your own data-CDs."));
7559
7560 b1 = gtk_toggle_button_new_with_label(_("Write Tracks"));
7561 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,6,7);
7562 gtk_widget_show(b1);
7563 side_handlers2[5] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
7564 GTK_SIGNAL_FUNC(menu_create_write),NULL);
7565 side_widgets2[5] = b1;
7566 define_tooltip(b1,_("Writes any tracks from your harddrive in an arbitrary order to a CD-R/RW."));
7567
7568 b1 = gtk_toggle_button_new_with_label(_("Delete Tracks"));
7569 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,7,8);
7570 gtk_widget_show(b1);
7571 side_handlers2[6] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
7572 GTK_SIGNAL_FUNC(menu_create_delete),NULL);
7573 side_widgets2[6] = b1;
7574 define_tooltip(b1,_("Deletes saved Tracks from the harddrive to free up space."));
7575
7576
7577 b1 = gtk_toggle_button_new_with_label(_("Back to main menu"));
7578 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,8,9);
7579 gtk_widget_show(b1);
7580 side_handlers2[7] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
7581 GTK_SIGNAL_FUNC(menu_create_back),NULL);
7582 side_widgets2[7] = b1;
7583 define_tooltip(b1,_("Quits the create menu and returns to the main menu."));
7584
7585 gtk_widget_show(side_t);
7586 gtk_widget_show(sidespace);
7587
7588 /* draw workspace */
7589
7590 head = gtk_frame_new(NULL);
7591 gtk_frame_set_shadow_type(GTK_FRAME(head),GTK_SHADOW_IN);
7592 gtk_widget_set_usize(head,0,45);
7593 gtk_box_pack_start(GTK_BOX(workspace), head,FALSE,TRUE,0);
7594 gtk_widget_show(head);
7595 head_l = gtk_label_new(_("Create CD"));
7596 set_font_and_color(head_l,BIGFONT,NULL);
7597 gtk_container_add(GTK_CONTAINER(head),head_l);
7598 gtk_widget_show(head_l);
7599 gtk_widget_show(workspace);
7600
7601 /* space where sub-windows are placed */
7602 actionspace = gtk_vbox_new(FALSE,0);
7603 gtk_box_pack_start(GTK_BOX(workspace), actionspace,TRUE,FALSE,5);
7604
7605 /* the default submenu for a start */
7606 draw_info_menu();
7607 }
7608
7609