1 /*
2 duplicate.c
3 Duplicate CD functions
4 15.5.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 <stdlib.h>
22 #include <string.h>
23 #include <strings.h>
24
25 #if ENABLE_NLS
26 # define _(String) gettext (String)
27 # define N_(String) gettext_noop (String)
28 #else
29 # define _(String) (String)
30 # define N_(String) (String)
31 #endif
32
33 #include <gtk/gtk.h>
34 #include <gdk/gdk.h>
35 #include "xcdrdata.h"
36 #include "xcdroast.h"
37 #include "main.h"
38 #include "../xpms/minidata.xpm"
39 #include "../xpms/miniaudio.xpm"
40 #include "../xpms/mininodata.xpm"
41 #include "../xpms/mininoaudio.xpm"
42 #include "../xpms/minitoc.xpm"
43 #include "../xpms/disc_eject.xpm"
44 #include "../xpms/disc_load.xpm"
45
46 extern GtkWidget *toplevel;
47 extern GtkWidget *sidespace;
48 extern GtkWidget *workspace;
49
50 extern GList *imagelist;
51 extern writerreader_devices_t **writerreaderdevs;
52 extern track_read_set_t trackreadset;
53 extern GList *tocfiles;
54 extern setup_data_t setupdata;
55 extern current_set_t curset;
56 extern cd_info_t cdinfo;
57 extern track_info_t **trackinfo;
58 extern gint wav_in;
59 extern GtkWidget *wav_quit_button;
60 extern gint wavplay_quit;
61 extern gint submenu;
62
63 GtkWidget *actionspace;
64 GtkCList *cdlist, *imglist, *play_clist;
65 GtkWidget *cdlist_l1, *cdlist_l2, *cdlist_l3, *cdlist_l4;
66 GtkWidget *vrylist_l1, *vrylist_l2, *vrylist_l3, *vrylist_l4;
67 GtkWidget *imglist_l1, *imglist_l2, *imglist_l3;
68 GtkWidget *crea_cd_mode_omenu, *crea_cd_burnfree_check;
69 guint side_handlers2[8];
70 GtkWidget *side_widgets2[8];
71
72 static GtkWidget *write_toc_menu;
73 static GtkWidget *edit_cdtext_btn;
74 static GtkWidget *dupl_cd_mode_omenu, *dupl_cd_burnfree_check;
75 static GtkWidget *rdr_spd_spin, *cdr_spd_spin;
76
77 /* some stuff for the select-functions of the sidebar buttons */
78 static guint side_handlers[7];
79 static GtkWidget *side_widgets[7];
80 static GtkWidget *locked_button;
81
82 extern void fill_read_tracks(gint dontupdatecd);
83 extern void fill_verify_tracks(gint dontupdateimglist);
84 extern void fill_write_tracks();
85 extern void fill_master_write_menu();
86 extern void reset_duplicate_buttons2(GtkWidget *exclude, gint fromunlock);
87
88 static void reset_duplicate_buttons(GtkWidget *exclude);
89 static void fill_read_menu();
90 static void fill_verify_menu();
91 static void fill_write_menu();
92 static void fill_delete_menu();
93 static void tocwrite_selected(GtkWidget *item, gpointer val);
94 void set_image_prefix_callback(GtkWidget *widget, gpointer data);
95
96
97 /* lock complete sidebar when doing stuff that takes a while (e.g. reload) */
98
do_lock(gint plusgrab)99 void do_lock(gint plusgrab) {
100 int i;
101
102 if (submenu == 1) {
103 /* lock all and save currently selected button */
104 for (i = 0; i < 7; i++) {
105 gtk_signal_handler_block(GTK_OBJECT(side_widgets[i]),
106 side_handlers[i]);
107 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
108 side_widgets[i])) == 1) {
109 locked_button = side_widgets[i];
110 }
111 }
112 }
113 if (submenu == 2) {
114 /* lock all and save currently selected button */
115 for (i = 0; i < 8; i++) {
116 gtk_signal_handler_block(GTK_OBJECT(side_widgets2[i]),
117 side_handlers2[i]);
118 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
119 side_widgets2[i])) == 1) {
120 locked_button = side_widgets2[i];
121 }
122 }
123 }
124
125 /* grab the button, so everything else is not active */
126 if (plusgrab) {
127 gtk_grab_add(locked_button);
128 }
129 }
130
131
132 /* free the lock after we are done */
133
do_unlock(gint plusgrab)134 void do_unlock(gint plusgrab) {
135 int i;
136
137 if (plusgrab) {
138 gtk_grab_remove(locked_button);
139 }
140
141 if (submenu == 1) {
142 for (i = 0; i < 7; i++) {
143 gtk_signal_handler_unblock(GTK_OBJECT(side_widgets[i]),
144 side_handlers[i]);
145 }
146 reset_duplicate_buttons(locked_button);
147 }
148 if (submenu == 2) {
149 for (i = 0; i < 8; i++) {
150 gtk_signal_handler_unblock(GTK_OBJECT(side_widgets2[i]),
151 side_handlers2[i]);
152 }
153 reset_duplicate_buttons2(locked_button, 1);
154 }
155 }
156
157
158 /* fill the cd-info-list with data */
159
fill_cdlist()160 void fill_cdlist() {
161 GtkStyle *style;
162 gchar *data[2];
163 GdkPixmap *pixmap1, *pixmap2;
164 GdkBitmap *mask1, *mask2;
165 gint i, lcount;
166 gchar tmp[MAXLINE];
167 gchar tmp2[MAXLINE];
168
169 /* clean up first */
170 gtk_clist_clear(cdlist);
171
172 /* cd loaded? */
173 if (cdinfo.nr_tracks == -1) {
174 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), _("No CD loaded"));
175 gtk_entry_set_text(GTK_ENTRY(cdlist_l2),"");
176 gtk_entry_set_text(GTK_ENTRY(cdlist_l3),"");
177 return;
178 }
179 if (cdinfo.nr_tracks == -2) {
180 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), return_media_type(curset.reader_devnr));
181 gtk_entry_set_text(GTK_ENTRY(cdlist_l2),"");
182 gtk_entry_set_text(GTK_ENTRY(cdlist_l3),"");
183 return;
184 }
185
186 style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(cdlist)));
187 pixmap1 = gdk_pixmap_create_from_xpm_d(cdlist->clist_window,
188 &mask1, &style->bg[GTK_STATE_NORMAL],(gchar **)minidata_xpm);
189 pixmap2 = gdk_pixmap_create_from_xpm_d(cdlist->clist_window,
190 &mask2, &style->bg[GTK_STATE_NORMAL],(gchar **)miniaudio_xpm);
191
192 data[0] = NULL;
193 lcount = 0;
194
195 for (i = 0; i < cdinfo.nr_tracks; i++) {
196 if (trackinfo[i]->type == 0) {
197 convert_frames2mbstring(trackinfo[i]->size,tmp2);
198 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
199 trackinfo[i]->track_nr,
200 _("data track"), tmp2);
201 data[1] = convert_for_gtk2(tmp);
202 gtk_clist_append(cdlist,data);
203 gtk_clist_set_pixmap(cdlist,lcount,0,pixmap1,mask1);
204 lcount++;
205 } else {
206 convert_frames2minstring(trackinfo[i]->size,tmp2);
207 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
208 trackinfo[i]->track_nr,
209 _("audio track"), tmp2);
210 data[1] = convert_for_gtk2(tmp);
211 gtk_clist_append(cdlist,data);
212 gtk_clist_set_pixmap(cdlist,lcount,0,pixmap2,mask2);
213 lcount++;
214 }
215
216 /* we have cd-text for this track? */
217 if (setupdata.option_displaycdtext) {
218 if (trackinfo[i]->title != NULL &&
219 trackinfo[i]->title[0] != '\0' ) {
220 g_snprintf(tmp,MAXLINE," CD-Text: %s",
221 trackinfo[i]->title);
222 data[1] = convert_for_gtk2(tmp);
223 gtk_clist_append(cdlist,data);
224 set_clist_row_font(cdlist,lcount, SLANTFONT);
225 lcount++;
226 }
227 }
228
229 /* have we a cddb-title for this track? */
230 if (trackinfo[i]->cddb_ttitle != NULL) {
231 g_snprintf(tmp,MAXLINE," CDDB: %s",
232 trackinfo[i]->cddb_ttitle);
233 data[1] = convert_for_gtk2(tmp);
234 gtk_clist_append(cdlist,data);
235 set_clist_row_font(cdlist,lcount, SLANTFONT);
236 lcount++;
237 } else
238 if (trackinfo[i]->volname != NULL) {
239 convert_kbytes2mbstring(trackinfo[i]->isosize*2,tmp2);
240 g_snprintf(tmp,MAXLINE," ISO9660: %s [%s]",
241 trackinfo[i]->volname,tmp2);
242 data[1] = convert_for_gtk2(tmp);
243 gtk_clist_append(cdlist,data);
244 set_clist_row_font(cdlist,lcount, SLANTFONT);
245 lcount++;
246 }
247
248 }
249
250 /* get cd-type */
251 determine_cd_type(tmp,0);
252 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), tmp);
253
254 /* cd-label */
255 if (cdinfo.title && cdinfo.artist &&
256 cdinfo.title[0] != '\0' && setupdata.option_displaycdtext) {
257 g_snprintf(tmp,MAXLINE,"%s / %s", cdinfo.title, cdinfo.artist);
258 gtk_entry_set_text(GTK_ENTRY(cdlist_l2), tmp);
259 gtk_entry_set_position(GTK_ENTRY(cdlist_l2),0);
260 } else
261 if (cdinfo.cddb_dtitle != NULL) {
262 gtk_entry_set_text(GTK_ENTRY(cdlist_l2), cdinfo.cddb_dtitle);
263 gtk_entry_set_position(GTK_ENTRY(cdlist_l2),0);
264 } else {
265 gtk_entry_set_text(GTK_ENTRY(cdlist_l2),"");
266 }
267
268 /* cd-size */
269 convert_frames2mbminstring(cdinfo.total_size, tmp);
270 gtk_entry_set_text(GTK_ENTRY(cdlist_l3), tmp);
271
272 }
273
274
275 /* fill the image-info-list with data */
276
fill_imglist()277 void fill_imglist() {
278 GtkStyle *style;
279 gchar *data[2];
280 GdkPixmap *pixmap1, *pixmap2, *pixmap3, *pixmap4, *pixmap5;
281 GdkBitmap *mask1, *mask2, *mask3, *mask4, *mask5;
282 gchar tmp[MAXLINE];
283 gchar tmp2[MAXLINE];
284 gchar basename[MAXLINE], oldbase[MAXLINE], fname[MAXLINE], *p;
285 GList *loop;
286 image_files_t *entry;
287 gint lcount, count;
288 gint sizecount;
289
290 /* clean up first */
291 gtk_clist_clear(imglist);
292
293 style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(imglist)));
294 pixmap1 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
295 &mask1, &style->bg[GTK_STATE_NORMAL],(gchar **)minidata_xpm);
296 pixmap2 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
297 &mask2, &style->bg[GTK_STATE_NORMAL],(gchar **)miniaudio_xpm);
298 pixmap3 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
299 &mask3, &style->bg[GTK_STATE_NORMAL],(gchar **)mininodata_xpm);
300 pixmap4 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
301 &mask4, &style->bg[GTK_STATE_NORMAL],(gchar **)mininoaudio_xpm);
302 pixmap5 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
303 &mask5, &style->bg[GTK_STATE_NORMAL],(gchar **)minitoc_xpm);
304
305 data[0] = NULL;
306 strcpy(oldbase,"");
307 lcount = 0;
308 count = 1;
309 sizecount = 0;
310
311 loop = g_list_first(imagelist);
312 while (loop) {
313 entry = loop->data;
314
315 /* get the base-dirname */
316 strncpy(basename,entry->path,MAXLINE);
317 p = rindex(basename,'/');
318 *p = '\0';
319 if (strcmp(basename,"") == 0) {
320 strcpy(basename,"/");
321 }
322 strcpy(fname,p+1);
323
324 /* new path found? */
325 if (strcmp(basename,oldbase) != 0) {
326 g_snprintf(tmp,MAXLINE,"%s: %s",_("Path"), basename);
327 data[1] = convert_for_gtk2(tmp);
328 gtk_clist_append(imglist,data);
329 set_clist_row_font(imglist,lcount, BOLDFONT);
330 lcount++;
331 strcpy(oldbase,basename);
332 }
333
334 /* iso9600-track/ unknown */
335 if (entry->type == 0 || entry->type == 3) {
336 convert_frames2mbstring((gint)((off_t)entry->size/DATASECTORSIZE),
337 tmp2);
338 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
339 count, fname, tmp2);
340 data[1] = convert_for_gtk2(tmp);
341 gtk_clist_append(imglist,data);
342 if (entry->readable == 1 && entry->type == 0) {
343 gtk_clist_set_pixmap(imglist,lcount,0,pixmap1,mask1);
344 } else {
345 gtk_clist_set_pixmap(imglist,lcount,0,pixmap3,mask3);
346 }
347 lcount++;
348 sizecount+=(gint)((off_t)entry->size >> 10);
349 count++;
350 }
351
352 /* valid/invalid wav-file */
353 if (entry->type == 1 || entry->type == 2) {
354 convert_frames2minstring((gint)((off_t)entry->size/CDDAFRAME), tmp2);
355 g_snprintf(tmp,MAXLINE,"%2d. %s [%s]",
356 count, fname, tmp2);
357 data[1] = convert_for_gtk2(tmp);
358 gtk_clist_append(imglist,data);
359 if (entry->readable == 1 && entry->type == 1) {
360 gtk_clist_set_pixmap(imglist,lcount,0,pixmap2,mask2);
361 } else {
362 gtk_clist_set_pixmap(imglist,lcount,0,pixmap4,mask4);
363 }
364 lcount++;
365 sizecount+=(gint)((off_t)entry->size >> 10);
366 count++;
367 }
368
369 /* toc-file */
370 if (entry->type == 4) {
371 g_snprintf(tmp,MAXLINE,"--. %s",fname);
372 data[1] = convert_for_gtk2(tmp);
373 gtk_clist_append(imglist,data);
374 gtk_clist_set_pixmap(imglist,lcount,0,pixmap5, mask5);
375 lcount++;
376 }
377
378 /* cd-text */
379 if (entry->title && entry->artist &&
380 strcmp(entry->title,"") && strcmp(entry->artist,"")) {
381 g_snprintf(tmp,MAXLINE," (%s / %s)",
382 entry->title, entry->artist);
383 data[1] = convert_for_gtk2(tmp);
384 gtk_clist_append(imglist,data);
385 set_clist_row_font(imglist,lcount, SLANTFONT);
386 lcount++;
387 } else
388 if (entry->title && strcmp(entry->title,"")) {
389 g_snprintf(tmp,MAXLINE," (%s)",
390 entry->title);
391 data[1] = convert_for_gtk2(tmp);
392 gtk_clist_append(imglist,data);
393 set_clist_row_font(imglist,lcount, SLANTFONT);
394 lcount++;
395 } else
396 if (entry->cddb_ttitle && strcmp(entry->cddb_ttitle,"")) {
397 g_snprintf(tmp,MAXLINE," (%s)",
398 entry->cddb_ttitle);
399 data[1] = convert_for_gtk2(tmp);
400 gtk_clist_append(imglist,data);
401 set_clist_row_font(imglist,lcount, SLANTFONT);
402 lcount++;
403 } else
404 if (entry->volname && strcmp(entry->volname,"")) {
405 if (entry->next_session_start > 0) {
406 g_snprintf(tmp,MAXLINE,
407 " (%s / ISO9660-multisession)",
408 entry->volname);
409 } else {
410 g_snprintf(tmp,MAXLINE," (%s / ISO9660)",
411 entry->volname);
412 }
413 data[1] = convert_for_gtk2(tmp);
414 gtk_clist_append(imglist,data);
415 set_clist_row_font(imglist,lcount, SLANTFONT);
416 lcount++;
417 } else
418 if (entry->type == 0 && entry->next_session_start > 0) {
419 strcpy(tmp," (ISO9660-multisession)");
420 data[1] = convert_for_gtk2(tmp);
421 gtk_clist_append(imglist,data);
422 set_clist_row_font(imglist,lcount, SLANTFONT);
423 lcount++;
424 }
425
426 loop = loop->next;
427 }
428
429 /* total size of files */
430 convert_kbytes2mbminstring(sizecount, tmp);
431 gtk_entry_set_text(GTK_ENTRY(imglist_l1), tmp);
432 }
433
434
435 /* callbacks for button in info-screen */
436
cddb_clicked(GtkWidget * widget,gpointer data)437 static void cddb_clicked(GtkWidget *widget, gpointer data) {
438
439 /* no cd loaded */
440 if (cdinfo.nr_tracks < 0) {
441 show_dialog(ICO_WARN,_("No CD loaded in read device"),T_OK,NULL,NULL,0);
442 return;
443 }
444
445 if (show_cddb_query(NULL, 0) == 0) {
446 /* new data received - update display */
447 fill_cdlist();
448 }
449 }
450
edit_cdtext_clicked(GtkWidget * widget,gpointer data)451 void edit_cdtext_clicked(GtkWidget *widget, gpointer data) {
452 gint mode;
453
454 mode = GPOINTER_TO_INT(data);
455
456 if (mode == 0)
457 show_edit_cdtext(mode, NULL);
458 else if (mode == 1) {
459 if (strcmp(curset.tocfile,"-") == 0) {
460 /* on-the-fly setting? */
461 show_edit_cdtext(3, write_toc_menu);
462 } else {
463 show_edit_cdtext(1, write_toc_menu);
464 }
465 }
466 else if (mode == 2)
467 show_edit_cdtext(mode, NULL);
468 }
469
470
update_clicked(GtkWidget * widget,gpointer data)471 static void update_clicked(GtkWidget *widget, gpointer data) {
472 GdkCursor *cursor;
473
474 do_lock(1);
475 /* change cursor to watch */
476 cursor = gdk_cursor_new(GDK_WATCH);
477 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
478
479 while (gtk_events_pending())
480 gtk_main_iteration();
481
482 if (curset.reader_devnr != -1) {
483 get_cd_toc_and_volid(curset.reader_devnr);
484 fill_cdlist();
485 }
486 scan_imagedirs();
487 fill_imglist();
488
489 /* reset cursor */
490 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
491 gdk_cursor_destroy (cursor);
492 do_unlock(1);
493
494 }
495
496 /* the update-button in the read menu */
497
update_readvrfy_clicked(GtkWidget * widget,gpointer read)498 static void update_readvrfy_clicked(GtkWidget *widget, gpointer read) {
499 GdkCursor *cursor;
500 gint isread;
501
502 isread = GPOINTER_TO_INT(read);
503
504 do_lock(1);
505 /* change cursor to watch */
506 cursor = gdk_cursor_new(GDK_WATCH);
507 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
508
509 while (gtk_events_pending())
510 gtk_main_iteration();
511
512 if (curset.reader_devnr != -1) {
513 get_cd_toc_and_volid(curset.reader_devnr);
514 }
515 if (isread) {
516 fill_read_menu();
517 } else {
518 fill_verify_menu();
519 }
520 /* reset cursor */
521 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
522 gdk_cursor_destroy (cursor);
523 do_unlock(1);
524 }
525
526
eject_clicked(GtkWidget * widget,gpointer load)527 static void eject_clicked(GtkWidget *widget, gpointer load) {
528 GdkCursor *cursor;
529
530 do_lock(1);
531 /* change cursor to watch */
532 cursor = gdk_cursor_new(GDK_WATCH);
533 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
534
535 while (gtk_events_pending())
536 gtk_main_iteration();
537
538 if (curset.reader_devnr != -1) {
539 if (GPOINTER_TO_INT(load))
540 load_cd(curset.reader_devnr);
541 else
542 eject_cd(curset.reader_devnr);
543 }
544
545 /* reset cursor */
546 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
547 gdk_cursor_destroy (cursor);
548
549 /* after we ejected or loaded automatically update screen */
550
551 /* in which menu are we right now? */
552 /* info menu? */
553 if (submenu == 1 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets[0])) == 1) {
554 update_clicked(widget,0);
555 }
556 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[0])) == 1) {
557 update_clicked(widget,0);
558 }
559 do_unlock(1);
560 }
561
562
563 /* callbacks for devices_setup_read */
564
readdev_selected(GtkWidget * item,gpointer devnr)565 static void readdev_selected(GtkWidget *item, gpointer devnr) {
566 GdkCursor *cursor;
567 gint i;
568
569 do_lock(1);
570 /* change cursor to watch */
571 cursor = gdk_cursor_new(GDK_WATCH);
572 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
573
574 while (gtk_events_pending())
575 gtk_main_iteration();
576
577 curset.reader_devnr = GPOINTER_TO_INT(devnr);
578 i = get_writerreaderdevs_index(curset.reader_devnr);
579
580 /* update speed display */
581 if (rdr_spd_spin) {
582 gtk_spin_button_set_value(GTK_SPIN_BUTTON(rdr_spd_spin),
583 (gfloat)writerreaderdevs[i]->audioread_speed);
584 }
585 if (curset.reader_devnr != -1) {
586 get_cd_toc_and_volid(curset.reader_devnr);
587 }
588
589 /* in which menu are we right now? */
590 /* info menu? */
591 if (submenu == 1 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets[0])) == 1) {
592 fill_cdlist();
593 }
594 /* info menu 2? */
595 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[0])) == 1) {
596 fill_cdlist();
597 }
598 /* read menu? */
599 if (submenu == 1 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets[1])) == 1) {
600 fill_read_menu();
601 }
602 /* read menu 2? */
603 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[1])) == 1) {
604 fill_read_tracks(0);
605 }
606 /* verify menu? */
607 if (submenu == 1 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets[2])) == 1) {
608 fill_verify_menu();
609 }
610 /* verify menu2? */
611 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[2])) == 1) {
612 fill_verify_tracks(1);
613 }
614 /* write menu? */
615 if (submenu == 1 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets[4])) == 1) {
616 fill_write_menu();
617 }
618 /* write menu2? */
619 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[5])) == 1) {
620 fill_write_tracks();
621 }
622
623 /* reset cursor */
624 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
625 gdk_cursor_destroy (cursor);
626 do_unlock(1);
627 }
628
629
readdev_speed(GtkWidget * item,GtkSpinButton * spin)630 static void readdev_speed(GtkWidget *item, GtkSpinButton *spin) {
631 gint i;
632
633 i = get_writerreaderdevs_index(curset.reader_devnr);
634 writerreaderdevs[i]->audioread_speed = gtk_spin_button_get_value_as_int(spin);
635 }
636
637
638 /* draw the device-setup-read line */
639
devices_setup_read(gint row,GtkWidget * tbl,gint showspeed)640 void devices_setup_read(gint row, GtkWidget *tbl, gint showspeed) {
641 GtkWidget *omenu;
642 GtkWidget *menu;
643 GtkWidget *menu_item;
644 GtkWidget *l1;
645 GtkWidget *eject_btn, *eject_xpm;
646 GtkWidget *load_btn, *load_xpm;
647 GdkPixmap *pmap;
648 GdkBitmap *mask;
649 GtkStyle *style;
650 gchar tmp[MAXLINE];
651 GtkWidget *speed1;
652 GtkObject *adj;
653 gint menuidx, menuhistory;
654 gint i;
655
656 rdr_spd_spin = NULL;
657
658 /* no reader so far selected? set default primary reader */
659 if (curset.reader_devnr == -1) {
660 curset.reader_devnr = setupdata.reader_devnr;
661 }
662
663 /* device still valid? */
664 if (get_writerreaderdevs_index(curset.reader_devnr) == -1) {
665 /* invalid device, pick the first available instead */
666 if (writerreaderdevs[0]) {
667 curset.reader_devnr = writerreaderdevs[0]->devnr;
668 }
669 }
670
671 /* read device */
672 l1 = rightjust_gtk_label_new(_("Read Device:"));
673 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4*4,row,row+1);
674 gtk_widget_show(l1);
675
676 omenu = gtk_option_menu_new ();
677 menu = gtk_menu_new();
678 menuidx = 0; menuhistory = -1;
679 i = 0;
680
681 while(writerreaderdevs[i] != NULL) {
682 if (convert_devnr2devstring(writerreaderdevs[i]->devnr,tmp) == 0) {
683 menu_item = gtk_menu_item_new_with_label(tmp);
684 gtk_signal_connect(GTK_OBJECT(menu_item),
685 "activate", GTK_SIGNAL_FUNC(readdev_selected),
686 GINT_TO_POINTER(writerreaderdevs[i]->devnr));
687 gtk_menu_append (GTK_MENU (menu), menu_item);
688
689 if (curset.reader_devnr == writerreaderdevs[i]->devnr) { menuhistory = menuidx; }
690 menuidx++;
691 gtk_widget_show (menu_item);
692 }
693 i++;
694 }
695
696 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
697 if (menuhistory != -1) {
698 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu), menuhistory);
699 } else {
700 /* if we are here we have an invalid reader setting */
701 /* set to default */
702 curset.reader_devnr = setupdata.reader_devnr;
703 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu), 0);
704 }
705 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,4*4,12*4,row,row+1);
706 gtk_widget_show(omenu);
707 define_tooltip(omenu, _("Select the device you want use for all read-operations on CDs."));
708
709 if (showspeed) {
710 l1 = rightjust_gtk_label_new(_("Speed:"));
711 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,12*4,15*4-1,row,row+1);
712 gtk_widget_show(l1);
713
714 adj = gtk_adjustment_new(0.0,0.0,64.0,1.0,1.0,1.0);
715 speed1 = gtk_spin_button_new(GTK_ADJUSTMENT(adj),0,0);
716 rdr_spd_spin = speed1;
717 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
718 GTK_SIGNAL_FUNC (readdev_speed),speed1);
719 gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(speed1),1);
720 gtk_table_attach_defaults(GTK_TABLE(tbl),speed1,15*4-1,16*4,row,row+1);
721 i = get_writerreaderdevs_index(curset.reader_devnr);
722 if (i >= 0) {
723 gtk_spin_button_set_value(GTK_SPIN_BUTTON(speed1),
724 (gfloat)writerreaderdevs[i]->audioread_speed);
725 } else {
726 gtk_widget_set_sensitive(speed1,FALSE);
727 }
728 gtk_widget_show(speed1);
729 define_tooltip(speed1, _("Select the speed which should be used for audio-extraction."));
730
731 if (!isroot() && !setupdata.root_option_change_readparam) {
732 gtk_widget_set_sensitive(speed1,FALSE);
733 }
734 } else {
735 /* if not showing speed, show eject/load buttons */
736 gtk_widget_realize(tbl);
737 style = gtk_widget_get_style(tbl);
738
739 pmap = gdk_pixmap_create_from_xpm_d(tbl->window, &mask,
740 &style->bg[GTK_STATE_NORMAL], (gchar **) disc_eject);
741 eject_xpm = gtk_pixmap_new(pmap,mask);
742 eject_btn = gtk_button_new();
743 gtk_signal_connect (GTK_OBJECT (eject_btn), "clicked",
744 GTK_SIGNAL_FUNC (eject_clicked), GINT_TO_POINTER(0));
745 gtk_table_attach_defaults(GTK_TABLE(tbl),eject_btn,
746 14*4,15*4,row,row+1);
747 gtk_widget_show(eject_btn);
748 gtk_container_add(GTK_CONTAINER(eject_btn), eject_xpm);
749 gtk_widget_show(eject_xpm);
750 define_tooltip(eject_btn, _("Ejects a CD from this device."));
751
752 pmap = gdk_pixmap_create_from_xpm_d(tbl->window, &mask,
753 &style->bg[GTK_STATE_NORMAL], (gchar **) disc_load);
754 load_xpm = gtk_pixmap_new(pmap,mask);
755 load_btn = gtk_button_new();
756 gtk_signal_connect (GTK_OBJECT (load_btn), "clicked",
757 GTK_SIGNAL_FUNC (eject_clicked), GINT_TO_POINTER(1));
758 gtk_table_attach_defaults(GTK_TABLE(tbl),load_btn,
759 15*4,16*4,row,row+1);
760 gtk_widget_show(load_btn);
761 gtk_container_add(GTK_CONTAINER(load_btn), load_xpm);
762 gtk_widget_show(load_xpm);
763 define_tooltip(load_btn, _("Loads a CD in this device."));
764 }
765 }
766
767
imagedir_selected(GtkWidget * item,gpointer val)768 static void imagedir_selected(GtkWidget *item, gpointer val) {
769 GdkCursor *cursor;
770
771 do_lock(1);
772 /* change cursor to watch */
773 cursor = gdk_cursor_new(GDK_WATCH);
774 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
775
776 while (gtk_events_pending())
777 gtk_main_iteration();
778
779 curset.image_index = GPOINTER_TO_INT(val);
780
781 /* which sub-menu are we in? */
782 /* read menu? */
783 if (submenu == 1 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets[1])) == 1) {
784 fill_read_menu();
785 }
786 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[1])) == 1) {
787 fill_read_tracks(1);
788 }
789 /* verify menu? */
790 if (submenu == 1 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets[2])) == 1) {
791 fill_verify_menu();
792 }
793 /* verify menu2? */
794 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[2])) == 1) {
795 fill_verify_tracks(0);
796 }
797 /* write menu? */
798 if (submenu == 1 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets[4])) == 1) {
799 fill_write_menu();
800 }
801 /* write menu2? */
802 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[5])) == 1) {
803 fill_write_tracks();
804 }
805 /* delete menu? */
806 if (submenu == 1 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets[5])) == 1) {
807 fill_delete_menu();
808 }
809 /* delete menu2? */
810 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[6])) == 1) {
811 fill_delete_menu();
812 }
813 /* master menu */
814 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[4])) == 1) {
815 fill_master_write_menu();
816 }
817 /* reset cursor */
818 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
819 gdk_cursor_destroy (cursor);
820 do_unlock(1);
821 }
822
823
824 /* draw the device-setup-image line */
825
devices_setup_image(gint row,GtkWidget * tbl)826 void devices_setup_image(gint row, GtkWidget *tbl) {
827 GtkWidget *omenu;
828 GtkWidget *menu;
829 GtkWidget *menu_item;
830 GtkWidget *l1;
831 GList *loop;
832 gchar tmp[MAXLINE];
833 gint i, menuidx, menuhistory;
834
835 /* default curset.image_index is -1...so we are fine here */
836
837 /* image directory */
838 l1 = rightjust_gtk_label_new(_("Image Directory:"));
839 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4*4,row,row+1);
840 gtk_widget_show(l1);
841
842 omenu = gtk_option_menu_new ();
843 menu = gtk_menu_new();
844
845 /* automatic setting */
846 menuidx = 0; menuhistory = -1;
847 menu_item = gtk_menu_item_new_with_label(_("Automatic"));
848 gtk_signal_connect(GTK_OBJECT(menu_item),
849 "activate", GTK_SIGNAL_FUNC(imagedir_selected),
850 GINT_TO_POINTER(-1));
851 gtk_menu_append (GTK_MENU (menu), menu_item);
852 if (curset.image_index == -1) { menuhistory = menuidx; }
853 menuidx++;
854 gtk_widget_show (menu_item);
855
856 /* add image dirs */
857 i = 0;
858 loop = g_list_first(setupdata.image_dirs);
859 while(loop) {
860 strcpy(tmp,(gchar *)loop->data);
861
862 menu_item = gtk_menu_item_new_with_label(tmp);
863 gtk_signal_connect(GTK_OBJECT(menu_item),
864 "activate", GTK_SIGNAL_FUNC(imagedir_selected),
865 GINT_TO_POINTER(i));
866 gtk_menu_append (GTK_MENU (menu), menu_item);
867 if (curset.image_index == i) { menuhistory = menuidx; }
868 menuidx++;
869 gtk_widget_show (menu_item);
870
871 loop = loop->next;
872 i++;
873 }
874
875 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
876 if (menuhistory != -1) {
877 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),menuhistory);
878 } else {
879 /* looks we got an invalid setting...set to default */
880 curset.image_index = -1;
881 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),0);
882
883 }
884 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,4*4,12*4,row,row+1);
885 gtk_widget_show(omenu);
886 define_tooltip(omenu, _("The directory on the harddrive you want to store/read tracks from. The setting \"Automatic\" selects all available directories at once."));
887 }
888
889
890 /* configure an optionmenu with writes modes for a given device */
891
preselect_write_mode_menu(GtkWidget * omenu,gint devnr)892 void preselect_write_mode_menu(GtkWidget *omenu, gint devnr) {
893 gint i,j;
894 GtkMenuShell *menu_shell;
895 GtkWidget *menuitem;
896 GList *loop;
897
898 i = get_writerreaderdevs_index(devnr);
899
900 if (i == -1) {
901 gtk_widget_set_sensitive(omenu, FALSE);
902 return;
903 }
904
905 /* set write mode and update possible settings */
906 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),
907 writerreaderdevs[i]->writer_mode);
908 menu_shell = GTK_MENU_SHELL(GTK_OPTION_MENU (omenu)->menu);
909
910 /* loop through all given menu entries */
911 j = 0;
912 loop = g_list_first(menu_shell->children);
913 while(loop) {
914 menuitem = loop->data;
915 if (!writemode_supported(j, devnr)) {
916 gtk_widget_set_sensitive(menuitem, FALSE);
917 } else {
918 gtk_widget_set_sensitive(menuitem, TRUE);
919 }
920 j++;
921 loop = loop->next;
922 }
923 }
924
925
926 /* callbacks for devices_setup_write */
927
writedev_selected(GtkWidget * item,gpointer devnr)928 static void writedev_selected(GtkWidget *item, gpointer devnr) {
929 GdkCursor *cursor;
930 gint i;
931
932 do_lock(1);
933 /* change cursor to watch */
934 cursor = gdk_cursor_new(GDK_WATCH);
935 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
936
937 while (gtk_events_pending())
938 gtk_main_iteration();
939
940 curset.writer_devnr = GPOINTER_TO_INT(devnr);
941 i = get_writerreaderdevs_index(curset.writer_devnr);
942
943 /* update speed display */
944 if (cdr_spd_spin) {
945 gtk_spin_button_set_value(GTK_SPIN_BUTTON(cdr_spd_spin),
946 (gfloat)writerreaderdevs[i]->writer_speed);
947 }
948
949 /* update any writer specific stuff for a given menu */
950
951 /* write menu? */
952 if (submenu == 1 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets[4])) == 1) {
953 if (dupl_cd_mode_omenu) {
954 preselect_write_mode_menu(dupl_cd_mode_omenu,
955 curset.writer_devnr);
956 }
957 if (dupl_cd_burnfree_check) {
958 if (!does_support_burnproof(curset.writer_devnr)) {
959 gtk_widget_set_sensitive(dupl_cd_burnfree_check,FALSE);
960 } else {
961 gtk_widget_set_sensitive(dupl_cd_burnfree_check,TRUE);
962 }
963 }
964 }
965
966 /* write menu2? */
967 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[5])) == 1) {
968 if (crea_cd_mode_omenu) {
969 preselect_write_mode_menu(crea_cd_mode_omenu,
970 curset.writer_devnr);
971 }
972 if (crea_cd_burnfree_check) {
973 if (!does_support_burnproof(curset.writer_devnr)) {
974 gtk_widget_set_sensitive(crea_cd_burnfree_check,FALSE);
975 } else {
976 gtk_widget_set_sensitive(crea_cd_burnfree_check,TRUE);
977 }
978 }
979 }
980
981 /* master menu */
982 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[4])) == 1) {
983 if (crea_cd_mode_omenu) {
984 preselect_write_mode_menu(crea_cd_mode_omenu,
985 curset.writer_devnr);
986 }
987 if (crea_cd_burnfree_check) {
988 if (!does_support_burnproof(curset.writer_devnr)) {
989 gtk_widget_set_sensitive(crea_cd_burnfree_check,FALSE);
990 } else {
991 gtk_widget_set_sensitive(crea_cd_burnfree_check,TRUE);
992 }
993 }
994 }
995
996 /* reset cursor */
997 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
998 gdk_cursor_destroy (cursor);
999 do_unlock(1);
1000 }
1001
1002
writedev_speed(GtkWidget * item,GtkSpinButton * spin)1003 static void writedev_speed(GtkWidget *item, GtkSpinButton *spin) {
1004 gint i;
1005
1006 i = get_writerreaderdevs_index(curset.writer_devnr);
1007 writerreaderdevs[i]->writer_speed = gtk_spin_button_get_value_as_int(spin);
1008 }
1009
1010
1011 /* draw the device-setup-write line */
1012
devices_setup_write(gint row,GtkWidget * tbl)1013 void devices_setup_write(gint row, GtkWidget *tbl) {
1014 GtkWidget *omenu;
1015 GtkWidget *menu;
1016 GtkWidget *menu_item;
1017 GtkWidget *l1;
1018 GtkWidget *speed1;
1019 GtkObject *adj;
1020 gint menuidx, menuhistory;
1021 gchar tmp[MAXLINE];
1022 gint i;
1023
1024 cdr_spd_spin = NULL;
1025
1026 /* select primary writer */
1027 if (curset.writer_devnr == -1) {
1028 curset.writer_devnr = setupdata.writer_devnr;
1029 }
1030
1031 /* device still valid? */
1032 if (get_writerreaderdevs_index(curset.writer_devnr) == -1) {
1033 /* invalid device, pick the first available instead */
1034 i = 0;
1035 while(writerreaderdevs[i] != NULL) {
1036 if (writerreaderdevs[i]->is_cdrwriter ||
1037 writerreaderdevs[i]->is_dvdwriter) {
1038
1039 curset.writer_devnr = writerreaderdevs[i]->devnr;
1040 break;
1041 }
1042 i++;
1043 }
1044 }
1045
1046 /* write device */
1047 l1 = rightjust_gtk_label_new(_("Write Device:"));
1048 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4*4,row,row+1);
1049 gtk_widget_show(l1);
1050
1051 omenu = gtk_option_menu_new ();
1052 menu = gtk_menu_new();
1053 menuidx = 0; menuhistory = -1;
1054 i = 0;
1055
1056 while(writerreaderdevs[i] != NULL) {
1057
1058 /* only show writers here */
1059 if (writerreaderdevs[i]->is_cdrwriter ||
1060 writerreaderdevs[i]->is_dvdwriter) {
1061
1062 if (convert_devnr2devstring(writerreaderdevs[i]->devnr,tmp) == 0) {
1063 menu_item = gtk_menu_item_new_with_label(tmp);
1064 gtk_signal_connect(GTK_OBJECT(menu_item),
1065 "activate", GTK_SIGNAL_FUNC(writedev_selected),
1066 GINT_TO_POINTER(writerreaderdevs[i]->devnr));
1067 gtk_menu_append (GTK_MENU (menu), menu_item);
1068 if (curset.writer_devnr == writerreaderdevs[i]->devnr) { menuhistory = menuidx; }
1069 menuidx++;
1070 gtk_widget_show (menu_item);
1071 }
1072 }
1073 i++;
1074 }
1075
1076 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
1077 if (menuhistory != -1) {
1078 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),menuhistory);
1079 } else {
1080 /* nothing valid preselected */
1081 curset.writer_devnr = setupdata.writer_devnr;
1082 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu), 0);
1083 }
1084 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,4*4,12*4,row,row+1);
1085 gtk_widget_show(omenu);
1086 define_tooltip(omenu, _("The Writer you want to use to burn any CDs or DVDs."));
1087
1088 l1 = rightjust_gtk_label_new(_("Speed:"));
1089 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,12*4,15*4-1,row,row+1);
1090 gtk_widget_show(l1);
1091
1092 adj = gtk_adjustment_new(0.0,0.0,64.0,1.0,1.0,1.0);
1093 speed1 = gtk_spin_button_new(GTK_ADJUSTMENT(adj),0,0);
1094 cdr_spd_spin = speed1;
1095 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
1096 GTK_SIGNAL_FUNC (writedev_speed),speed1);
1097 gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(speed1),1);
1098 gtk_table_attach_defaults(GTK_TABLE(tbl),speed1,15*4-1,16*4,row,row+1);
1099
1100 i = get_writerreaderdevs_index(curset.writer_devnr);
1101 if (i >= 0) {
1102 gtk_spin_button_set_value(GTK_SPIN_BUTTON(speed1),
1103 (gfloat)writerreaderdevs[i]->writer_speed);
1104 } else {
1105 gtk_widget_set_sensitive(speed1,FALSE);
1106 }
1107 gtk_widget_show(speed1);
1108 define_tooltip(speed1, _("The speed you want to burn CDs with. (Depends on your current Writer)"));
1109
1110 if (!isroot() && !setupdata.root_option_change_writeparam) {
1111 gtk_widget_set_sensitive(speed1,FALSE);
1112 }
1113 }
1114
1115
1116 /* function to remove all selections on a clist */
undo_selections(GtkWidget * clist,gint row,gint column,GdkEventButton * event,gpointer data)1117 void undo_selections(GtkWidget *clist, gint row, gint column,
1118 GdkEventButton *event, gpointer data) {
1119
1120 gtk_clist_unselect_all(GTK_CLIST(clist));
1121 }
1122
1123
1124 /* draw the cd-info-menu */
1125
draw_info_menu()1126 void draw_info_menu() {
1127 GtkWidget *hbox, *vbox;
1128 GtkWidget *f1,*f2;
1129 GtkWidget *b1, *b_update;
1130 GtkWidget *e1;
1131 GtkWidget *l1;
1132 GtkWidget *tbl;
1133 GtkWidget *cd_list, *img_list;
1134 gchar *titles[2];
1135 GtkWidget *scrolled_win;
1136
1137 /* prepare draw area */
1138 clear_actionspace();
1139
1140 f1 = gtk_frame_new(_("Devices-Setup"));
1141 set_font_and_color_frame(f1,BOLDFONT,NULL);
1142 gtk_box_pack_start(GTK_BOX(actionspace),f1,FALSE,FALSE,5);
1143 gtk_widget_show(f1);
1144
1145 tbl = gtk_table_new(1,16*4,TRUE);
1146 gtk_table_set_col_spacing(GTK_TABLE(tbl),4*4-1,5);
1147 gtk_table_set_col_spacing(GTK_TABLE(tbl),15*4-1,5);
1148 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
1149 gtk_container_add(GTK_CONTAINER(f1),tbl);
1150 gtk_widget_show(tbl);
1151
1152 devices_setup_read(0, tbl, 0);
1153
1154 /* left and right info-frames */
1155 tbl = gtk_table_new(1,2,TRUE);
1156 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
1157 gtk_box_pack_start(GTK_BOX(actionspace),tbl,TRUE,TRUE,10);
1158 gtk_widget_show(tbl);
1159 if (!curset.isProDVD) {
1160 f1 = gtk_frame_new(_("CD-Information"));
1161 } else {
1162 f1 = gtk_frame_new(_("CD/DVD-Information"));
1163 }
1164 set_font_and_color_frame(f1,BOLDFONT,NULL);
1165 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,0,1,0,1);
1166 gtk_widget_show(f1);
1167 f2 = gtk_frame_new(_("Image-Information"));
1168 set_font_and_color_frame(f2,BOLDFONT,NULL);
1169 gtk_table_attach_defaults(GTK_TABLE(tbl),f2,1,2,0,1);
1170 gtk_widget_show(f2);
1171
1172 /* button bar at the bottom */
1173 hbox = gtk_hbox_new(TRUE,10);
1174 gtk_box_pack_start(GTK_BOX(actionspace),hbox,FALSE,TRUE,10);
1175 gtk_widget_show(hbox);
1176 b1 = gtk_button_new_with_label(_("Query CDDB"));
1177 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
1178 gtk_widget_show(b1);
1179 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
1180 GTK_SIGNAL_FUNC(cddb_clicked), NULL);
1181 define_tooltip(b1,_("Download the track titles for current CD. Requires a connection to the Internet."));
1182
1183 b1 = gtk_button_new_with_label(_("Edit titles for CD-Text"));
1184 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
1185 gtk_widget_show(b1);
1186 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
1187 GTK_SIGNAL_FUNC(edit_cdtext_clicked), GINT_TO_POINTER(0));
1188 define_tooltip(b1,_("Edits the title and performer information before any tracks are read from the inserted CD. Only required to author a CD with CD-Text."));
1189
1190 /*
1191 b1 = gtk_button_new_with_label(_("Eject CD"));
1192 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
1193 gtk_widget_show(b1);
1194 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
1195 GTK_SIGNAL_FUNC(eject_clicked), NULL);
1196 define_tooltip(b1,_("Ejects the CD in the current read device."));
1197 */
1198
1199 b_update = gtk_button_new_with_label(_("Update"));
1200 gtk_box_pack_start(GTK_BOX(hbox),b_update,TRUE,TRUE,10);
1201 gtk_widget_show(b_update);
1202 gtk_signal_connect(GTK_OBJECT(b_update), "clicked",
1203 GTK_SIGNAL_FUNC(update_clicked), NULL);
1204 define_tooltip(b_update,_("Refreshes the content of the information windows. (e.g. after a CD change)"));
1205
1206 /* left info frame */
1207 vbox = gtk_vbox_new(FALSE,0);
1208 gtk_container_add(GTK_CONTAINER(f1),vbox);
1209 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
1210 gtk_widget_show(vbox);
1211
1212 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1213 gtk_box_pack_start(GTK_BOX(vbox),scrolled_win,TRUE,TRUE,0);
1214 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1215 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
1216 gtk_widget_show(scrolled_win);
1217
1218 titles[0] = g_strdup("");
1219 titles[1] = _("Tracks");
1220 cd_list = gtk_clist_new_with_titles(2,titles);
1221 gtk_signal_connect(GTK_OBJECT(cd_list), "select_row",
1222 GTK_SIGNAL_FUNC(undo_selections), NULL);
1223 gtk_container_add (GTK_CONTAINER (scrolled_win), cd_list);
1224 cdlist = GTK_CLIST(cd_list);
1225 gtk_clist_set_column_width(cdlist, 0, 16);
1226 gtk_clist_set_column_auto_resize(cdlist, 1, TRUE);
1227 gtk_widget_show(cd_list);
1228
1229 tbl = gtk_table_new(3,8,TRUE);
1230 gtk_table_set_row_spacings(GTK_TABLE(tbl),10);
1231 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
1232 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,10);
1233 gtk_widget_show(tbl);
1234
1235 l1 = rightjust_gtk_label_new(_("Type:"));
1236 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,0,1);
1237 gtk_widget_show(l1);
1238
1239 e1 = gtk_entry_new();
1240 cdlist_l1 = e1;
1241 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1242 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,0,1);
1243 gtk_widget_show(e1);
1244
1245 l1 = rightjust_gtk_label_new(_("Label:"));
1246 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,1,2);
1247 gtk_widget_show(l1);
1248
1249 e1 = gtk_entry_new();
1250 cdlist_l2 = e1;
1251 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1252 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,1,2);
1253 gtk_widget_show(e1);
1254
1255 l1 = rightjust_gtk_label_new(_("Size:"));
1256 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,2,3);
1257 gtk_widget_show(l1);
1258
1259 e1 = gtk_entry_new();
1260 cdlist_l3 = e1;
1261 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1262 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,2,3);
1263 gtk_widget_show(e1);
1264
1265
1266 /* right info frame */
1267 vbox = gtk_vbox_new(FALSE,0);
1268 gtk_container_add(GTK_CONTAINER(f2),vbox);
1269 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
1270 gtk_widget_show(vbox);
1271
1272 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1273 gtk_box_pack_start(GTK_BOX(vbox),scrolled_win,TRUE,TRUE,0);
1274 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1275 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
1276 gtk_widget_show(scrolled_win);
1277
1278 titles[0] = g_strdup("");
1279 titles[1] = _("Images");
1280 img_list = gtk_clist_new_with_titles(2,titles);
1281 gtk_signal_connect(GTK_OBJECT(img_list), "select_row",
1282 GTK_SIGNAL_FUNC(undo_selections), NULL);
1283 gtk_container_add (GTK_CONTAINER (scrolled_win), img_list);
1284 imglist = GTK_CLIST(img_list);
1285 gtk_clist_set_column_width(imglist, 0, 16);
1286 gtk_clist_set_column_auto_resize(imglist, 1, TRUE);
1287 gtk_widget_show(img_list);
1288
1289 tbl = gtk_table_new(1,8,TRUE);
1290 gtk_table_set_row_spacings(GTK_TABLE(tbl),10);
1291 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
1292 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,10);
1293 gtk_widget_show(tbl);
1294
1295 l1 = rightjust_gtk_label_new(_("Total Size:"));
1296 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,3,0,1);
1297 gtk_widget_show(l1);
1298
1299 e1 = gtk_entry_new();
1300 imglist_l1 = e1;
1301 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1302 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,3,8,0,1);
1303 gtk_widget_show(e1);
1304
1305 gtk_widget_show(actionspace);
1306
1307 while (gtk_events_pending())
1308 gtk_main_iteration();
1309
1310 /* now update screen */
1311 gtk_button_clicked(GTK_BUTTON(b_update));
1312 }
1313
1314
1315 /* calculate the space that would be recycled on the harddrive
1316 when reading tracks and overwriting the ones with same names.
1317 This is used to show the user what space really is free
1318 dependant of the name he chooses for his files */
1319
get_free_space_by_overwriting_trackfiles(gint * biggest)1320 static gint get_free_space_by_overwriting_trackfiles(gint *biggest) {
1321 track_read_param_t *trackparam;
1322 gfloat per;
1323 gint i;
1324 gint overwrite;
1325 gint overwritebiggest;
1326
1327 /* cd loaded? */
1328 if (cdinfo.nr_tracks < 0) {
1329 /* no cd in drive - no files to read */
1330 *biggest = 0;
1331 return 0;
1332 }
1333
1334 /* free structure first */
1335 clear_trackreadset();
1336
1337 /* fill structure */
1338 trackreadset.nrtracks = cdinfo.nr_tracks;
1339
1340 for(i=0; i<cdinfo.nr_tracks; i++) {
1341
1342 /* allocate memory */
1343 trackparam = g_new0(track_read_param_t,1);
1344
1345 trackparam->trackinfo_index = i;
1346 trackparam->starttrack = trackinfo[i]->track_nr;
1347 trackparam->endtrack = 0;
1348 trackparam->tracktype = trackinfo[i]->type;
1349 per = (gfloat)trackinfo[i]->size * 100.0 / cdinfo.total_size;
1350 trackparam->percent = per;
1351
1352 if (trackparam->tracktype == 0) {
1353 /* data track */
1354 trackparam->kbyte = trackinfo[i]->size *
1355 (DATASECTORSIZE/1024);
1356 trackparam->frames = trackinfo[i]->size;
1357 trackparam->startoffset = trackinfo[i]->start_sec;
1358 if (i == cdinfo.nr_tracks-1) {
1359 /* last track - leadout is track-end */
1360 trackparam->endoffset = cdinfo.leadout - 2;
1361 } else {
1362 /* sub 150 (2 sec leadout),
1363 sub 2 (2 run out sectors) */
1364 trackparam->endoffset =
1365 trackinfo[i+1]->start_sec -150-2;
1366 }
1367 } else {
1368 /* audio */
1369 trackparam->kbyte = trackinfo[i]->size *
1370 CDDAFRAME/1024;
1371 trackparam->frames = trackinfo[i]->size;
1372 }
1373
1374 trackreadset.trackparams = g_list_append(
1375 trackreadset.trackparams, trackparam);
1376 }
1377
1378 /* assign diskspace */
1379 allocate_track_filenames(&overwrite, &overwritebiggest);
1380
1381 *biggest = overwritebiggest;
1382 return overwrite;
1383 }
1384
1385
1386 /* callbacks for button in read-screen */
1387
readalltracks_clicked(GtkWidget * widget,gpointer data)1388 static void readalltracks_clicked(GtkWidget *widget, gpointer data) {
1389 gchar path[MAXLINE];
1390 gchar tmp[MAXLINE];
1391 track_read_param_t *trackparam;
1392 gfloat per;
1393 gint i, ret, sectorstoread;
1394 gint overwrite, overwritebiggest, stat;
1395 gint datacount, audiocount, sectsize;
1396 GList *loop;
1397
1398 /* no cd-reader defined */
1399 if (curset.reader_devnr == -1) {
1400 show_dialog(ICO_ERROR,_("No CD-Reader defined in Setup"), T_OK, NULL, NULL, 0);
1401 return;
1402 }
1403
1404 datacount = 0;
1405 audiocount = 0;
1406 sectsize = get_sectorsize(curset.reader_devnr);
1407
1408
1409 /* now check if our cd-information is still valid */
1410 get_cd_toc_and_volid(curset.reader_devnr);
1411
1412 /* cd loaded? */
1413 if (cdinfo.nr_tracks < 0) {
1414 /* update screen ... */
1415 fill_read_menu();
1416 show_dialog(ICO_WARN,_("No CD loaded in read device"),T_OK,NULL,NULL,0);
1417 return;
1418 }
1419
1420 /* now check for cd-extra because we dont handle this
1421 currently */
1422 if (determine_cd_type(tmp,0) == 3) {
1423 show_dialog(ICO_INFO,_("This test release does currently not\nsupport copying of CD-Extra."),T_OK,NULL,NULL,0);
1424 return;
1425 }
1426
1427 /* ok, the user wants to read all tracks */
1428 /* lets check if the file-prefix-entry is up to date */
1429 set_image_prefix_callback(imglist_l1, NULL);
1430
1431 /* free structure first */
1432 clear_trackreadset();
1433
1434 /* fill structure */
1435 trackreadset.nrtracks = cdinfo.nr_tracks;
1436
1437 for(i=0; i<cdinfo.nr_tracks; i++) {
1438
1439 /* allocate memory */
1440 trackparam = g_new0(track_read_param_t,1);
1441
1442 trackparam->trackinfo_index = i;
1443 trackparam->starttrack = trackinfo[i]->track_nr;
1444 trackparam->endtrack = 0;
1445 trackparam->tracktype = trackinfo[i]->type;
1446 per = (gfloat)trackinfo[i]->size * 100.0 / cdinfo.total_size;
1447 trackparam->percent = per;
1448
1449 if (trackparam->tracktype == 0) {
1450 /* data track */
1451 datacount++;
1452 trackparam->kbyte = trackinfo[i]->size *
1453 (DATASECTORSIZE/1024);
1454 trackparam->frames = trackinfo[i]->size;
1455 trackparam->startoffset = trackinfo[i]->start_sec;
1456 if (i == cdinfo.nr_tracks-1) {
1457 /* last track - leadout is track-end */
1458 trackparam->endoffset = cdinfo.leadout - 2;
1459 } else {
1460 /* sub 150 (2 sec leadout),
1461 sub 2 (2 run out sectors) */
1462 trackparam->endoffset =
1463 trackinfo[i+1]->start_sec -150-2;
1464 }
1465 /* now do a paranoia check */
1466 /* in some cases we skip to much of a track */
1467 sectorstoread = trackparam->endoffset -
1468 trackparam->startoffset;
1469 if (sectorstoread < trackinfo[i]->isosize) {
1470 trackparam->endoffset =
1471 trackparam->startoffset +
1472 trackinfo[i]->isosize;
1473 trackparam->kbyte = trackinfo[i]->isosize * 2;
1474 dodebug(1,"readalltracks_clicked: corrected data track size from %d to %d sectors.\n", sectorstoread, trackinfo[i]->isosize);
1475 }
1476 } else {
1477 /* audio */
1478 audiocount++;
1479 trackparam->kbyte = trackinfo[i]->size *
1480 CDDAFRAME/1024;
1481 trackparam->frames = trackinfo[i]->size;
1482 }
1483
1484 trackreadset.trackparams = g_list_append(
1485 trackreadset.trackparams, trackparam);
1486 }
1487
1488 /* sectorsize firmware bug detection */
1489 if (datacount > 0 && sectsize != 2048) {
1490 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);
1491 if (ret == 1) {
1492 /* abort */
1493 return;
1494 }
1495 }
1496
1497
1498 /* assign diskspace */
1499 stat = allocate_track_filenames(&overwrite, &overwritebiggest);
1500
1501 if (stat == 1) {
1502 /* not enough space */
1503 ret = show_dialog(ICO_WARN,_("Not enough diskspace available!\nDo you want to continue anyway or to abort?"), T_ANYWAY, T_CANCEL, NULL, 1);
1504 if (ret == 1) {
1505 /* abort */
1506 return;
1507 }
1508 }
1509
1510 /* no writeable dirs */
1511 if (stat == 2) {
1512 show_dialog(ICO_WARN,_("No image-directories with write permissions found.\nPlease check your settings in the Setup."), T_OK, NULL, NULL, 1);
1513 return;
1514 }
1515
1516 /* overwriting a link? */
1517 if (stat == 3) {
1518 /* FIX HERE USING GETTEXT FOR NEXT RELEASE */
1519 show_dialog(ICO_WARN,"Not allowing to overwrite a symlink.\nChoose another \"File prefix\".", T_OK, NULL, NULL, 1);
1520 return;
1521 }
1522
1523 /* warn we are going to overwrite some files */
1524 if (setupdata.option_overwritewarn == 1 && overwrite > 0) {
1525 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);
1526 if (ret == 1) {
1527 /* abort */
1528 return;
1529 }
1530 }
1531
1532 /* assign now a toc-file name */
1533 strcpy(path, "");
1534 if (curset.image_index == -1) {
1535 /* automatic setting */
1536 loop = g_list_first(setupdata.image_dirs);
1537 while(loop) {
1538 strncpy(path,(gchar *)loop->data, MAXLINE);
1539
1540 /* dir writeable? */
1541 if (is_dir_writeable(path) == 0) {
1542 /* yes? take this */
1543 break;
1544 }
1545 loop = loop->next;
1546 }
1547 } else {
1548 strncpy(path,(gchar *)g_list_nth_data(setupdata.image_dirs,
1549 curset.image_index), MAXLINE);
1550 }
1551 g_snprintf(tmp,MAXLINE,"%s/%s.toc",path,curset.file_prefix);
1552 g_free(trackreadset.tocfile);
1553 trackreadset.tocfile = g_strdup(tmp);
1554
1555 /* now all parameters for reading are set - lets begin */
1556 show_and_do_read_tracks(curset.reader_devnr, 1);
1557 }
1558
1559
1560 /* fill the entries in the read_cd_menu */
1561
fill_read_menu()1562 static void fill_read_menu() {
1563 gchar tmp[MAXLINE];
1564 gchar tmp2[MAXLINE];
1565 gchar tmp3[MAXLINE];
1566 gint overwritefree, normalfree, biggestfree, overwritefreebiggest;
1567
1568 /* file prefix */
1569 if (strcmp(curset.file_prefix,"") == 0) {
1570 g_free(curset.file_prefix);
1571 curset.file_prefix = g_strdup(IMGFILEPREFIX);
1572 }
1573 gtk_entry_set_text(GTK_ENTRY(imglist_l1), curset.file_prefix);
1574 gtk_entry_set_position(GTK_ENTRY(imglist_l1), 0);
1575 /*
1576 gtk_entry_select_region(GTK_ENTRY(imglist_l1), 0,
1577 GTK_ENTRY(imglist_l1)->text_length);
1578 */
1579
1580 /* now check if the current filename has any influence on
1581 the available space */
1582 overwritefree =
1583 get_free_space_by_overwriting_trackfiles(&overwritefreebiggest);
1584
1585 /* free size */
1586 normalfree = determine_free_space(&biggestfree);
1587 convert_kbytes2mbminstring(normalfree,tmp3);
1588
1589 /* additional free space when overwriting files? */
1590 if (cdinfo.nr_tracks > 0 && overwritefree > 0) {
1591 convert_kbytes2mbstring(normalfree+overwritefree, tmp2);
1592 g_snprintf(tmp,MAXLINE,"%s (%s)", tmp3, tmp2);
1593 } else {
1594 strcpy(tmp,tmp3);
1595 }
1596 gtk_entry_set_text(GTK_ENTRY(imglist_l2), tmp);
1597 gtk_entry_set_position(GTK_ENTRY(imglist_l2), 0);
1598
1599 /* biggest free block */
1600 convert_kbytes2mbminstring(biggestfree,tmp3);
1601
1602 if (cdinfo.nr_tracks > 0 && overwritefreebiggest > 0) {
1603 convert_kbytes2mbstring(biggestfree+overwritefreebiggest, tmp2);
1604 g_snprintf(tmp,MAXLINE,"%s (%s)", tmp3, tmp2);
1605 } else {
1606 strcpy(tmp,tmp3);
1607 }
1608 gtk_entry_set_text(GTK_ENTRY(imglist_l3), tmp);
1609 gtk_entry_set_position(GTK_ENTRY(imglist_l3), 0);
1610
1611
1612 /* cd loaded? */
1613 if (cdinfo.nr_tracks == -1) {
1614 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), _("No CD loaded"));
1615 gtk_entry_set_text(GTK_ENTRY(cdlist_l2),"");
1616 gtk_entry_set_text(GTK_ENTRY(cdlist_l3),"");
1617 gtk_entry_set_text(GTK_ENTRY(cdlist_l4),"");
1618 return;
1619 }
1620 if (cdinfo.nr_tracks == -2) {
1621 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), return_media_type(curset.reader_devnr));
1622 gtk_entry_set_text(GTK_ENTRY(cdlist_l2),"");
1623 gtk_entry_set_text(GTK_ENTRY(cdlist_l3),"");
1624 gtk_entry_set_text(GTK_ENTRY(cdlist_l4),"");
1625 return;
1626 }
1627
1628 /* cd-type */
1629 determine_cd_type(tmp,0);
1630 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), tmp);
1631
1632 /* cd-label */
1633 if (cdinfo.title && cdinfo.artist &&
1634 cdinfo.title[0] != '\0' && setupdata.option_displaycdtext) {
1635 g_snprintf(tmp,MAXLINE,"%s / %s", cdinfo.title, cdinfo.artist);
1636 gtk_entry_set_text(GTK_ENTRY(cdlist_l2), tmp);
1637 gtk_entry_set_position(GTK_ENTRY(cdlist_l2),0);
1638 } else
1639 if (cdinfo.cddb_dtitle != NULL) {
1640 gtk_entry_set_text(GTK_ENTRY(cdlist_l2), cdinfo.cddb_dtitle);
1641 gtk_entry_set_position(GTK_ENTRY(cdlist_l2),0);
1642 } else {
1643 gtk_entry_set_text(GTK_ENTRY(cdlist_l2),"");
1644 }
1645
1646 /* cd-size */
1647 convert_frames2mbminstring(cdinfo.total_size, tmp);
1648 gtk_entry_set_text(GTK_ENTRY(cdlist_l3), tmp);
1649
1650 /* nr tracks */
1651 g_snprintf(tmp,MAXLINE,"%d",cdinfo.nr_tracks);
1652 gtk_entry_set_text(GTK_ENTRY(cdlist_l4), tmp);
1653 }
1654
1655
set_image_prefix_callback(GtkWidget * widget,gpointer data)1656 void set_image_prefix_callback(GtkWidget *widget, gpointer data) {
1657 gchar tmp[MAXLINE];
1658
1659 g_free(curset.file_prefix);
1660 strcpy(tmp,gtk_entry_get_text(GTK_ENTRY(widget)));
1661 /* now check for illegal chars */
1662 if (remove_illegal_chars(tmp) == 1) {
1663 gtk_entry_set_text(GTK_ENTRY(widget), tmp);
1664 show_dialog(ICO_WARN,_("Illegal chars found in entry field.\nSubstituted them by \"_\" chars"),T_OK,NULL,NULL, 0);
1665 }
1666 curset.file_prefix = g_strdup(tmp);
1667
1668 /* empty-file? */
1669 if (strcmp(curset.file_prefix,"") == 0) {
1670 g_free(curset.file_prefix);
1671 curset.file_prefix = g_strdup(IMGFILEPREFIX);
1672 gtk_entry_set_text(GTK_ENTRY(widget), curset.file_prefix);
1673 }
1674 /*
1675 gtk_entry_select_region(GTK_ENTRY(widget), 0,
1676 GTK_ENTRY(widget)->text_length);
1677 */
1678 /* update free overwrite size */
1679 if (submenu == 1) {
1680 fill_read_menu();
1681 }
1682
1683 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[1])) == 1) {
1684 fill_read_tracks(1);
1685 }
1686 if (submenu == 2 && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(side_widgets2[4])) == 1) {
1687 fill_master_write_menu();
1688 }
1689
1690 }
1691
1692
readoptions_selected(GtkWidget * item,gpointer nr)1693 void readoptions_selected(GtkWidget *item, gpointer nr) {
1694 gint sel;
1695
1696 sel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
1697
1698 switch(GPOINTER_TO_INT(nr)) {
1699 case 0:
1700 curset.indexscan = sel;
1701 break;
1702 }
1703 }
1704
1705
1706 /* draw the read-menu */
1707
draw_read_menu()1708 static void draw_read_menu() {
1709 GtkWidget *hbox, *vbox;
1710 GtkWidget *f1,*f2, *f3;
1711 GtkWidget *b1, *b_update;
1712 GtkWidget *e1;
1713 GtkWidget *l1;
1714 GtkWidget *tbl, *check;
1715
1716 /* prepare draw area */
1717 clear_actionspace();
1718
1719 f1 = gtk_frame_new(_("Devices-Setup"));
1720 set_font_and_color_frame(f1,BOLDFONT,NULL);
1721 gtk_box_pack_start(GTK_BOX(actionspace),f1,FALSE,FALSE,5);
1722 gtk_widget_show(f1);
1723
1724 tbl = gtk_table_new(2,16*4,TRUE);
1725 gtk_table_set_col_spacing(GTK_TABLE(tbl),4*4-1,5);
1726 gtk_table_set_col_spacing(GTK_TABLE(tbl),15*4-2 ,5);
1727 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
1728 gtk_container_add(GTK_CONTAINER(f1),tbl);
1729 gtk_widget_show(tbl);
1730
1731 devices_setup_read(0, tbl, 1);
1732 devices_setup_image(1, tbl);
1733 /* devices_setup_write(2, tbl); */
1734
1735 /* left and right info-frames */
1736 tbl = gtk_table_new(1,2,TRUE);
1737 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
1738 gtk_box_pack_start(GTK_BOX(actionspace),tbl,TRUE,TRUE,10);
1739 gtk_widget_show(tbl);
1740 vbox = gtk_vbox_new(FALSE,10);
1741 gtk_table_attach_defaults(GTK_TABLE(tbl),vbox,0,1,0,1);
1742 if (!curset.isProDVD) {
1743 f1 = gtk_frame_new(_("CD-Information"));
1744 } else {
1745 f1 = gtk_frame_new(_("CD/DVD-Information"));
1746 }
1747 set_font_and_color_frame(f1,BOLDFONT,NULL);
1748 gtk_box_pack_start(GTK_BOX(vbox),f1,TRUE,TRUE,0);
1749 gtk_widget_show(f1);
1750 f3 = gtk_frame_new(_("Read options"));
1751 set_font_and_color_frame(f3,BOLDFONT,NULL);
1752 gtk_box_pack_start(GTK_BOX(vbox),f3,FALSE,FALSE,0);
1753 gtk_widget_show(f3);
1754 f2 = gtk_frame_new(_("Image-Information"));
1755 set_font_and_color_frame(f2,BOLDFONT,NULL);
1756 gtk_table_attach_defaults(GTK_TABLE(tbl),f2,1,2,0,1);
1757 gtk_widget_show(f2);
1758 gtk_widget_show(vbox);
1759
1760 /* button bar at the bottom */
1761 hbox = gtk_hbox_new(TRUE,10);
1762 gtk_box_pack_start(GTK_BOX(actionspace),hbox,FALSE,TRUE,10);
1763 gtk_widget_show(hbox);
1764 b1 = gtk_button_new_with_label(_("Read all tracks"));
1765 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
1766 gtk_widget_show(b1);
1767 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
1768 GTK_SIGNAL_FUNC(readalltracks_clicked), NULL);
1769 define_tooltip(b1, _("Reads all tracks from the current CD and saves them in the image directories on the harddrive."));
1770
1771 b_update = gtk_button_new_with_label(_("Update"));
1772 gtk_box_pack_start(GTK_BOX(hbox),b_update,TRUE,TRUE,10);
1773 gtk_widget_show(b_update);
1774 gtk_signal_connect(GTK_OBJECT(b_update), "clicked",
1775 GTK_SIGNAL_FUNC(update_readvrfy_clicked), GINT_TO_POINTER(1));
1776 define_tooltip(b_update,_("Refreshes the content of the information windows. (e.g. after a CD change)"));
1777
1778 /*
1779 b1 = gtk_button_new_with_label(_("Read/Write on-the-fly"));
1780 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
1781 gtk_widget_show(b1);
1782 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
1783 GTK_SIGNAL_FUNC(eject_clicked), NULL);
1784 */
1785
1786 /* left info frame */
1787 vbox = gtk_vbox_new(FALSE,0);
1788 gtk_container_add(GTK_CONTAINER(f1),vbox);
1789 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
1790 gtk_widget_show(vbox);
1791
1792 tbl = gtk_table_new(4,8,TRUE);
1793 gtk_table_set_row_spacings(GTK_TABLE(tbl),10);
1794 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
1795 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,10);
1796 gtk_widget_show(tbl);
1797
1798 l1 = rightjust_gtk_label_new(_("Type:"));
1799 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,0,1);
1800 gtk_widget_show(l1);
1801
1802 e1 = gtk_entry_new();
1803 cdlist_l1 = e1;
1804 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1805 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,0,1);
1806 gtk_widget_show(e1);
1807
1808 l1 = rightjust_gtk_label_new(_("Label:"));
1809 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,1,2);
1810 gtk_widget_show(l1);
1811
1812 e1 = gtk_entry_new();
1813 cdlist_l2 = e1;
1814 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1815 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,1,2);
1816 gtk_widget_show(e1);
1817
1818 l1 = rightjust_gtk_label_new(_("Size:"));
1819 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,2,3);
1820 gtk_widget_show(l1);
1821
1822 e1 = gtk_entry_new();
1823 cdlist_l3 = e1;
1824 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1825 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,2,3);
1826 gtk_widget_show(e1);
1827
1828 l1 = rightjust_gtk_label_new(_("Tracks:"));
1829 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,3,4);
1830 gtk_widget_show(l1);
1831
1832 e1 = gtk_entry_new();
1833 cdlist_l4 = e1;
1834 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1835 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,3,4);
1836 gtk_widget_show(e1);
1837
1838 /* options frame */
1839 vbox = gtk_vbox_new(FALSE,0);
1840 gtk_container_add(GTK_CONTAINER(f3),vbox);
1841 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
1842 gtk_widget_show(vbox);
1843
1844 tbl = gtk_table_new(1,8,TRUE);
1845 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
1846 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,10);
1847 gtk_widget_show(tbl);
1848
1849 check = gtk_check_button_new_with_label(_("Do index scan"));
1850 gtk_signal_connect(GTK_OBJECT(check),"clicked",
1851 GTK_SIGNAL_FUNC(readoptions_selected),GINT_TO_POINTER(0));
1852 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,8,0,1);
1853 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
1854 curset.indexscan);
1855 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."));
1856 gtk_widget_show(check);
1857
1858
1859 /* right info frame */
1860 vbox = gtk_vbox_new(FALSE,0);
1861 gtk_container_add(GTK_CONTAINER(f2),vbox);
1862 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
1863 gtk_widget_show(vbox);
1864
1865 tbl = gtk_table_new(4,8,TRUE);
1866 gtk_table_set_row_spacings(GTK_TABLE(tbl),10);
1867 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
1868 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,10);
1869 gtk_widget_show(tbl);
1870
1871 l1 = rightjust_gtk_label_new(_("File prefix:"));
1872 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4,0,1);
1873 gtk_widget_show(l1);
1874
1875 e1 = gtk_entry_new();
1876 imglist_l1 = e1;
1877 gtk_signal_connect(GTK_OBJECT(e1), "activate",
1878 GTK_SIGNAL_FUNC(set_image_prefix_callback),NULL);
1879 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,4,8,0,1);
1880 gtk_widget_show(e1);
1881 define_tooltip(e1, _("This is the prefix of the filenames of the tracks saved to the harddrive."));
1882
1883 l1 = rightjust_gtk_label_new(_("Free space:"));
1884 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,4,1,2);
1885 gtk_widget_show(l1);
1886
1887 e1 = gtk_entry_new();
1888 imglist_l2 = e1;
1889 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1890 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,4,8,1,2);
1891 gtk_widget_show(e1);
1892
1893 l1 = leftjust_gtk_label_new(_("biggest available block of that:"));
1894 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,1,8,2,3);
1895 gtk_widget_show(l1);
1896
1897 e1 = gtk_entry_new();
1898 imglist_l3 = e1;
1899 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
1900 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,4,8,3,4);
1901 gtk_widget_show(e1);
1902
1903 gtk_widget_show(actionspace);
1904
1905 /* fill entries */
1906 fill_read_menu();
1907 }
1908
1909
1910 /* fill the entries in the verify_cd_menu */
1911
fill_verify_menu()1912 static void fill_verify_menu() {
1913 gchar tmp[MAXLINE];
1914 GList *loop;
1915 GtkWidget *menu;
1916 GtkWidget *menu_item, *menuselitem;
1917 gint menuidx, menuhistory;
1918 gint i,len;
1919
1920 /* get list of toc-files (save in tocfiles var) */
1921 scan_for_toc_files();
1922
1923 /* clear out the old menu first (if any) */
1924 gtk_option_menu_remove_menu(GTK_OPTION_MENU (write_toc_menu));
1925
1926 menu = gtk_menu_new();
1927 menuselitem = NULL;
1928 menu_item = NULL;
1929 menuidx = 0; menuhistory = 0;
1930 i = 0;
1931 loop = g_list_first(tocfiles);
1932 while (loop) {
1933 /* a bug in gtk wont allow longer option-menus...
1934 well, then strip the strings down (not nice, but
1935 so far the only way I can think of */
1936 len = strlen((gchar *)loop->data);
1937 if (len > 24) {
1938 strcpy(tmp, ".. ");
1939 strcat(tmp, (gchar *)loop->data + len - 24);
1940 } else {
1941 strcpy(tmp, (gchar *)loop->data);
1942 }
1943 menu_item = gtk_menu_item_new_with_label(tmp);
1944 if (menuselitem == NULL) {
1945 /* default first element */
1946 menuselitem = menu_item;
1947 }
1948 gtk_signal_connect(GTK_OBJECT(menu_item),
1949 "activate", GTK_SIGNAL_FUNC(tocwrite_selected),
1950 GINT_TO_POINTER(i));
1951 if (strcmp(curset.tocfile, (gchar *)loop->data) == 0) {
1952 menuhistory = menuidx;
1953 menuselitem = menu_item;
1954 }
1955 gtk_menu_append (GTK_MENU (menu), menu_item);
1956 gtk_widget_show (menu_item);
1957 loop = loop->next;
1958 menuidx++;
1959 i++;
1960 }
1961
1962 /* no toc file found? */
1963 if (i == 0) {
1964
1965 menu_item = gtk_menu_item_new_with_label(_(" - "));
1966 gtk_signal_connect(GTK_OBJECT(menu_item),
1967 "activate", GTK_SIGNAL_FUNC(tocwrite_selected),
1968 GINT_TO_POINTER(-2));
1969 if (strcmp(curset.tocfile, "-") == 0) {
1970 menuhistory = menuidx;
1971 menuselitem = menu_item;
1972 }
1973 gtk_menu_append (GTK_MENU (menu), menu_item);
1974 gtk_widget_show (menu_item);
1975 }
1976 gtk_option_menu_set_menu (GTK_OPTION_MENU (write_toc_menu), menu);
1977 gtk_option_menu_set_history(GTK_OPTION_MENU (write_toc_menu),menuhistory);
1978 /* toggle currently active menu */
1979 if (menuselitem != NULL) {
1980 gtk_menu_item_activate(GTK_MENU_ITEM (menuselitem));
1981 } else {
1982 /* if no active menu, activate the last set */
1983 /* (one the fly in this case) */
1984 gtk_menu_item_activate(GTK_MENU_ITEM (menu_item));
1985 }
1986
1987
1988 /* ---------------- */
1989
1990 /* cd loaded? */
1991 if (cdinfo.nr_tracks == -1) {
1992 gtk_entry_set_text(GTK_ENTRY(vrylist_l1), _("No CD loaded"));
1993 gtk_entry_set_text(GTK_ENTRY(vrylist_l2),"");
1994 gtk_entry_set_text(GTK_ENTRY(vrylist_l3),"");
1995 gtk_entry_set_text(GTK_ENTRY(vrylist_l4),"");
1996 return;
1997 }
1998 if (cdinfo.nr_tracks == -2) {
1999 gtk_entry_set_text(GTK_ENTRY(vrylist_l1), return_media_type(curset.reader_devnr));
2000 gtk_entry_set_text(GTK_ENTRY(vrylist_l2),"");
2001 gtk_entry_set_text(GTK_ENTRY(vrylist_l3),"");
2002 gtk_entry_set_text(GTK_ENTRY(vrylist_l4),"");
2003 return;
2004 }
2005
2006 /* cd-type */
2007 determine_cd_type(tmp,0);
2008 gtk_entry_set_text(GTK_ENTRY(vrylist_l1), tmp);
2009
2010 /* cd-label */
2011 if (cdinfo.title && cdinfo.artist &&
2012 cdinfo.title[0] != '\0' && setupdata.option_displaycdtext) {
2013 g_snprintf(tmp,MAXLINE,"%s / %s", cdinfo.title, cdinfo.artist);
2014 gtk_entry_set_text(GTK_ENTRY(vrylist_l2), tmp);
2015 gtk_entry_set_position(GTK_ENTRY(vrylist_l2),0);
2016 } else
2017 if (cdinfo.cddb_dtitle != NULL) {
2018 gtk_entry_set_text(GTK_ENTRY(vrylist_l2), cdinfo.cddb_dtitle);
2019 gtk_entry_set_position(GTK_ENTRY(vrylist_l2),0);
2020 } else {
2021 gtk_entry_set_text(GTK_ENTRY(vrylist_l2),"");
2022 }
2023
2024 /* cd-size */
2025 convert_frames2mbminstring(cdinfo.total_size, tmp);
2026 gtk_entry_set_text(GTK_ENTRY(vrylist_l3), tmp);
2027
2028 /* nr tracks */
2029 g_snprintf(tmp,MAXLINE,"%d",cdinfo.nr_tracks);
2030 gtk_entry_set_text(GTK_ENTRY(vrylist_l4), tmp);
2031
2032 }
2033
2034
2035 /* callbacks for verify-screen */
2036
verify_clicked(GtkWidget * widget,gpointer data)2037 static void verify_clicked(GtkWidget *widget, gpointer data) {
2038 gint stat;
2039 gint ret;
2040 track_read_param_t *trackparam;
2041 GList *loop;
2042 gint i, sectorstoread;
2043 gint datat,audio;
2044 gint datasize;
2045
2046 /* no cd-reader defined */
2047 if (curset.reader_devnr == -1) {
2048 show_dialog(ICO_ERROR,_("No CD-Reader defined in Setup"), T_OK, NULL, NULL, 0);
2049 return;
2050 }
2051
2052 /* now check if our cd-information is still valid */
2053 get_cd_toc_and_volid(curset.reader_devnr);
2054
2055 /* cd loaded? */
2056 if (cdinfo.nr_tracks < 0) {
2057 fill_verify_menu();
2058 show_dialog(ICO_WARN,_("No CD loaded in read device"),T_OK,NULL,NULL,0);
2059 return;
2060 }
2061
2062 /* no tocfile selected */
2063 if (strcmp(curset.tocfile,"-") == 0) {
2064 show_dialog(ICO_WARN,_("No TOC file selected which specifies\nwhich tracks are to verify."),T_OK,NULL,NULL,0);
2065 return;
2066 }
2067
2068 /* first check if all tracks we need are available on hd */
2069 stat = check_write_files(0);
2070 switch(stat) {
2071 /* files with wrong size */
2072 case 1:
2073 ret = show_dialog(ICO_QUEST,_("Some tracks do have a different file-size as expected.\nPerhaps the tracks are outdated or belong to another CD.\nDo you want to continue anyway or to abort?"),T_ANYWAY,T_CANCEL,
2074 NULL, 1);
2075 if (ret == 1) {
2076 /* aborted */
2077 return;
2078 }
2079 break;
2080 /* files missing */
2081 case 2:
2082 show_dialog(ICO_ERROR,_("Some tracks belonging to the CD you want to write are missing.\nPerhaps the TOC file is outdated and the tracks\nwere already removed from the hard drive."),T_OK,NULL,NULL,0);
2083 return;
2084
2085 /* no permission/invalid */
2086 case 3:
2087 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);
2088 return;
2089
2090 default:
2091 break;
2092 }
2093
2094 /* now check if we have the correct cd to verify in the drive */
2095 /* allow an offset of 15 sectors (padding) */
2096 if (trackreadset.nrtracks != cdinfo.nr_tracks ||
2097 (cdinfo.total_size-trackreadset.cdsize) > 15) {
2098
2099 show_dialog(ICO_WARN,_("TOC file does not match the CD in the drive.\nVerifying is therefore impossible."),T_OK,NULL,NULL,0);
2100 return;
2101 }
2102
2103
2104 datat = 0;
2105 audio = 0;
2106 datasize = 0;
2107
2108 /* fill some additional data in the trackreadset-structure */
2109 loop = g_list_first(trackreadset.trackparams);
2110 for(i=0; i<cdinfo.nr_tracks; i++) {
2111
2112 if (loop == NULL) {
2113 /* should never happen */
2114 show_dialog(ICO_WARN,_("TOC file does not match the CD in the drive.\nVerifying is therefore impossible."),T_OK,NULL,NULL,0);
2115 return;
2116 }
2117 trackparam = loop->data;
2118
2119 trackparam->trackinfo_index = i;
2120
2121 /* does the tracktypes match? */
2122 if (trackparam->tracktype != trackinfo[i]->type) {
2123 show_dialog(ICO_WARN,_("TOC file does not match the CD in the drive.\nVerifying is therefore impossible."),T_OK,NULL,NULL,0);
2124 return;
2125 }
2126
2127 if (trackparam->tracktype == 0) {
2128 /* data track */
2129 trackparam->kbyte = trackinfo[i]->size *
2130 (DATASECTORSIZE/1024);
2131 trackparam->startoffset = trackinfo[i]->start_sec;
2132 if (i == cdinfo.nr_tracks-1) {
2133 /* last track - leadout is track-end */
2134 trackparam->endoffset = cdinfo.leadout - 2;
2135 } else {
2136 /* sub 150 (2 sec leadout),
2137 sub 2 (2 run out sectors) */
2138 trackparam->endoffset =
2139 trackinfo[i+1]->start_sec -150-2;
2140 }
2141 /* now do a paranoia check */
2142 /* in some cases we skip to much of a track */
2143 sectorstoread = trackparam->endoffset -
2144 trackparam->startoffset;
2145 if (sectorstoread < trackinfo[i]->isosize) {
2146 trackparam->endoffset =
2147 trackparam->startoffset +
2148 trackinfo[i]->isosize;
2149 trackparam->kbyte = trackinfo[i]->isosize * 2;
2150 dodebug(1,"verify_clicked: corrected data track size from %d to %d sectors.\n", sectorstoread, trackinfo[i]->isosize);
2151 }
2152
2153 datat++;
2154 datasize += trackparam->frames;
2155 } else {
2156 /* audio */
2157 trackparam->kbyte = trackinfo[i]->size *
2158 CDDAFRAME/1024;
2159 audio++;
2160 }
2161 loop = loop->next;
2162 }
2163
2164
2165 /* OK...now we know we have the correct CD in the drive and a fully
2166 functional set of image-files on the HD. All set for verifying */
2167
2168 /* check if are allowed to verify audio */
2169 if (curset.noaudioverify == 1 && datat == 0 && audio > 0) {
2170 show_dialog(ICO_WARN,_("CD contains only audio tracks and you set that\naudio tracks should not be verified. Verifying is therefore impossible."), T_OK, NULL, NULL, 0);
2171 return;
2172 }
2173
2174 /* do we have to recalc the percentages because we dont want
2175 to verify audio? */
2176 if (curset.noaudioverify == 1 && audio > 0 && datat > 0) {
2177 loop = g_list_first(trackreadset.trackparams);
2178 while(loop) {
2179 trackparam = loop->data;
2180 /* only take data-tracks in account */
2181 trackparam->percent =
2182 (gfloat)trackparam->frames / datasize;
2183 loop = loop->next;
2184 }
2185 }
2186
2187 show_and_do_verify_tracks(curset.reader_devnr);
2188 }
2189
2190
verifyoptions_selected(GtkWidget * item,gpointer nr)2191 void verifyoptions_selected(GtkWidget *item, gpointer nr) {
2192 gint sel;
2193
2194 sel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
2195
2196 switch(GPOINTER_TO_INT(nr)) {
2197 case 0:
2198 curset.noaudioverify = sel;
2199 break;
2200 case 1:
2201 curset.verifyfailabort = sel;
2202 break;
2203 }
2204 }
2205
2206
2207 /* draw the verify-info-menu */
2208
draw_verify_menu()2209 static void draw_verify_menu() {
2210 GtkWidget *hbox, *vbox;
2211 GtkWidget *f1, *f2, *f3;
2212 GtkWidget *b1, *b_update;
2213 GtkWidget *e1;
2214 GtkWidget *l1;
2215 GtkWidget *tbl, *omenu, *check;
2216
2217 /* prepare draw area */
2218 clear_actionspace();
2219
2220 edit_cdtext_btn = NULL;
2221
2222 f1 = gtk_frame_new(_("Devices-Setup"));
2223 set_font_and_color_frame(f1,BOLDFONT,NULL);
2224 gtk_box_pack_start(GTK_BOX(actionspace),f1,FALSE,FALSE,5);
2225 gtk_widget_show(f1);
2226
2227 tbl = gtk_table_new(2,16*4,TRUE);
2228 gtk_table_set_col_spacing(GTK_TABLE(tbl),4*4-1,5);
2229 gtk_table_set_col_spacing(GTK_TABLE(tbl),15*4-2,5);
2230 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
2231 gtk_container_add(GTK_CONTAINER(f1),tbl);
2232 gtk_widget_show(tbl);
2233
2234 devices_setup_read(0, tbl, 1);
2235 devices_setup_image(1, tbl);
2236
2237 /* left and right info-frames */
2238 tbl = gtk_table_new(1,2,TRUE);
2239 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
2240 gtk_box_pack_start(GTK_BOX(actionspace),tbl,TRUE,TRUE,10);
2241 gtk_widget_show(tbl);
2242 vbox = gtk_vbox_new(FALSE,10);
2243 gtk_table_attach_defaults(GTK_TABLE(tbl),vbox,0,1,0,1);
2244 if (!curset.isProDVD) {
2245 f1 = gtk_frame_new(_("CD-Information"));
2246 } else {
2247 f1 = gtk_frame_new(_("CD/DVD-Information"));
2248 }
2249 set_font_and_color_frame(f1,BOLDFONT,NULL);
2250 gtk_box_pack_start(GTK_BOX(vbox),f1,TRUE,TRUE,0);
2251 gtk_widget_show(f1);
2252 f3 = gtk_frame_new(_("Verify options"));
2253 set_font_and_color_frame(f3,BOLDFONT,NULL);
2254 gtk_box_pack_start(GTK_BOX(vbox),f3,FALSE,FALSE,0);
2255 gtk_widget_show(f3);
2256 f2 = gtk_frame_new(_("Tracks to verify"));
2257 set_font_and_color_frame(f2,BOLDFONT,NULL);
2258 gtk_table_attach_defaults(GTK_TABLE(tbl),f2,1,2,0,1);
2259 gtk_widget_show(f2);
2260 gtk_widget_show(vbox);
2261
2262 /* button bar at the bottom */
2263 hbox = gtk_hbox_new(TRUE,10);
2264 gtk_box_pack_start(GTK_BOX(actionspace),hbox,FALSE,TRUE,10);
2265 gtk_widget_show(hbox);
2266 b1 = gtk_button_new_with_label(_("Verify tracks"));
2267 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
2268 gtk_widget_show(b1);
2269 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
2270 GTK_SIGNAL_FUNC(verify_clicked), NULL);
2271 define_tooltip(b1, _("Reads all tracks from the current CD again and does compare them with the tracks on the harddrive as specified in the selected TOC file."));
2272
2273 b_update = gtk_button_new_with_label(_("Update"));
2274 gtk_box_pack_start(GTK_BOX(hbox),b_update,TRUE,TRUE,10);
2275 gtk_widget_show(b_update);
2276 gtk_signal_connect(GTK_OBJECT(b_update), "clicked",
2277 GTK_SIGNAL_FUNC(update_readvrfy_clicked), GINT_TO_POINTER(0));
2278 define_tooltip(b_update,_("Refreshes the content of the information windows. (e.g. after a CD change)"));
2279
2280 /*
2281 b1 = gtk_button_new_with_label(_("Read/Write on-the-fly"));
2282 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
2283 gtk_widget_show(b1);
2284 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
2285 GTK_SIGNAL_FUNC(eject_clicked), NULL);
2286 */
2287
2288 /* left info frame */
2289 vbox = gtk_vbox_new(FALSE,0);
2290 gtk_container_add(GTK_CONTAINER(f1),vbox);
2291 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
2292 gtk_widget_show(vbox);
2293
2294 tbl = gtk_table_new(4,8,TRUE);
2295 gtk_table_set_row_spacings(GTK_TABLE(tbl),10);
2296 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
2297 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,10);
2298 gtk_widget_show(tbl);
2299
2300 l1 = rightjust_gtk_label_new(_("Type:"));
2301 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,0,1);
2302 gtk_widget_show(l1);
2303
2304 e1 = gtk_entry_new();
2305 vrylist_l1 = e1;
2306 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
2307 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,0,1);
2308 gtk_widget_show(e1);
2309
2310 l1 = rightjust_gtk_label_new(_("Label:"));
2311 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,1,2);
2312 gtk_widget_show(l1);
2313
2314 e1 = gtk_entry_new();
2315 vrylist_l2 = e1;
2316 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
2317 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,1,2);
2318 gtk_widget_show(e1);
2319
2320 l1 = rightjust_gtk_label_new(_("Size:"));
2321 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,2,3);
2322 gtk_widget_show(l1);
2323
2324 e1 = gtk_entry_new();
2325 vrylist_l3 = e1;
2326 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
2327 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,2,3);
2328 gtk_widget_show(e1);
2329
2330 l1 = rightjust_gtk_label_new(_("Tracks:"));
2331 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,3,4);
2332 gtk_widget_show(l1);
2333
2334 e1 = gtk_entry_new();
2335 vrylist_l4 = e1;
2336 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
2337 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,8,3,4);
2338 gtk_widget_show(e1);
2339
2340 /* options frame */
2341 vbox = gtk_vbox_new(FALSE,0);
2342 gtk_container_add(GTK_CONTAINER(f3),vbox);
2343 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
2344 gtk_widget_show(vbox);
2345
2346 tbl = gtk_table_new(2,8,TRUE);
2347 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
2348 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,10);
2349 gtk_widget_show(tbl);
2350
2351 check = gtk_check_button_new_with_label(_("Don't verify audio tracks"));
2352 gtk_signal_connect(GTK_OBJECT(check),"clicked",
2353 GTK_SIGNAL_FUNC(verifyoptions_selected),GINT_TO_POINTER(0));
2354 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,8,0,1);
2355 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
2356 curset.noaudioverify);
2357 gtk_widget_show(check);
2358 define_tooltip(check, _("Skips verification of audio tracks, because a lot of CD readers are not able to read audio data reliably."));
2359
2360 check = gtk_check_button_new_with_label(_("Abort after verify fail"));
2361 gtk_signal_connect(GTK_OBJECT(check),"clicked",
2362 GTK_SIGNAL_FUNC(verifyoptions_selected),GINT_TO_POINTER(1));
2363 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,8,1,2);
2364 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
2365 curset.verifyfailabort);
2366 gtk_widget_show(check);
2367 define_tooltip(check, _("Abort Verifying when one mismatch was found. Otherwise X-CD-Roast does continue to verify the other tracks anyway."));
2368
2369 /* right info frame */
2370 vbox = gtk_vbox_new(FALSE,0);
2371 gtk_container_add(GTK_CONTAINER(f2),vbox);
2372 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
2373 gtk_widget_show(vbox);
2374
2375 tbl = gtk_table_new(5,8,FALSE);
2376 gtk_table_set_row_spacings(GTK_TABLE(tbl),10);
2377 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
2378 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,0);
2379 gtk_widget_show(tbl);
2380
2381 l1 = rightjust_gtk_label_new(_("TOC-File:"));
2382 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,3,0,1);
2383 gtk_widget_show(l1);
2384
2385 omenu = gtk_option_menu_new();
2386 write_toc_menu = omenu;
2387 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,3,8,0,1);
2388 gtk_widget_show(omenu);
2389 define_tooltip(omenu, _("Select which tracks should be verified against the current CD. The TOC file must match the CD, of course."));
2390
2391 l1 = rightjust_gtk_label_new(_("Type:"));
2392 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,3,1,2);
2393 gtk_widget_show(l1);
2394
2395 e1 = gtk_entry_new();
2396 cdlist_l1 = e1;
2397 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
2398 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,3,8,1,2);
2399 gtk_widget_show(e1);
2400
2401 l1 = rightjust_gtk_label_new(_("Label:"));
2402 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,3,2,3);
2403 gtk_widget_show(l1);
2404
2405 e1 = gtk_entry_new();
2406 cdlist_l2 = e1;
2407 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
2408 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,3,8,2,3);
2409 gtk_widget_show(e1);
2410
2411 l1 = rightjust_gtk_label_new(_("Size:"));
2412 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,3,3,4);
2413 gtk_widget_show(l1);
2414
2415 e1 = gtk_entry_new();
2416 cdlist_l3 = e1;
2417 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
2418 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,3,8,3,4);
2419 gtk_widget_show(e1);
2420
2421 l1 = rightjust_gtk_label_new(_("Tracks:"));
2422 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,3,4,5);
2423 gtk_widget_show(l1);
2424
2425 e1 = gtk_entry_new();
2426 cdlist_l4 = e1;
2427 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
2428 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,3,8,4,5);
2429 gtk_widget_show(e1);
2430
2431
2432 gtk_widget_show(actionspace);
2433
2434 /* fill entries */
2435 fill_verify_menu();
2436 }
2437
2438
2439 /* what do to when user selects a track from the list */
2440
playlist_select_row(GtkWidget * clist,gint row,gint col,GdkEventButton * event,gpointer data)2441 static void playlist_select_row(GtkWidget *clist, gint row, gint col,
2442 GdkEventButton *event, gpointer data) {
2443
2444 /* double click? */
2445 if (event && event->type == GDK_2BUTTON_PRESS) {
2446 /* stop current song and play selected */
2447 wavplay_dodouble();
2448 }
2449 }
2450
2451
2452 /* draw the play-tracks-menu */
2453
draw_play_tracks_menu()2454 void draw_play_tracks_menu() {
2455 GtkWidget *scrolled_win;
2456 gchar tmp[MAXLINE];
2457 gchar tmp2[MAXLINE];
2458 gchar tmp3[MAXLINE];
2459 gchar tmp4[MAXLINE];
2460 gchar *titles[5];
2461 gchar *data[5];
2462 GtkWidget *list;
2463 GtkCList *clist;
2464 GdkPixmap *pixmap1;
2465 GdkBitmap *mask1;
2466 GtkStyle *style;
2467 GList *loop;
2468 image_files_t *entry;
2469 gint count;
2470
2471 /* prepare draw area */
2472 clear_actionspace();
2473
2474 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
2475 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
2476 gtk_box_pack_start(GTK_BOX(actionspace),scrolled_win,TRUE,TRUE,5);
2477 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
2478 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
2479 gtk_widget_show(scrolled_win);
2480
2481 titles[0] = "";
2482 titles[1] = _("Nr.");
2483 titles[2] = _("Track title");
2484 titles[3] = _("Length");
2485 titles[4] = _("Filename");
2486
2487 list = gtk_clist_new_with_titles(5,titles);
2488 gtk_container_add (GTK_CONTAINER (scrolled_win), list);
2489 gtk_widget_realize(list);
2490 clist = GTK_CLIST(list);
2491 gtk_clist_set_column_auto_resize(clist, 4, TRUE);
2492 play_clist = clist;
2493 gtk_signal_connect(GTK_OBJECT(list), "select_row",
2494 GTK_SIGNAL_FUNC(playlist_select_row), NULL);
2495
2496 style = gtk_style_copy(gtk_widget_get_style(list));
2497 pixmap1 = gdk_pixmap_create_from_xpm_d(clist->clist_window,
2498 &mask1, &style->bg[GTK_STATE_NORMAL],(gchar **)miniaudio_xpm);
2499 data[0] = NULL;
2500
2501 gtk_clist_set_row_height(clist, tbf(20));
2502 gtk_clist_set_column_width(clist, 0, tbf(20));
2503 gtk_clist_set_column_width(clist, 1, tbf(30));
2504 gtk_clist_set_column_justification(clist, 1, GTK_JUSTIFY_CENTER);
2505 gtk_clist_set_column_width(clist, 2, tbf(250));
2506 gtk_clist_set_column_width(clist, 3, tbf(80));
2507 gtk_widget_show(list);
2508
2509 /* fill clist with valid audio-tracks */
2510 count = 1;
2511 loop = g_list_first(imagelist);
2512 while (loop) {
2513 entry = loop->data;
2514 if (entry->type == 1) {
2515 g_snprintf(tmp,MAXLINE,"%d.",count);
2516 data[1] = convert_for_gtk2(tmp);
2517 if (entry->title && entry->artist &&
2518 strcmp(entry->title,"") && strcmp(entry->artist,"")) {
2519 g_snprintf(tmp3,MAXLINE,"%s / %s",
2520 entry->title, entry->artist);
2521 data[2] = convert_for_gtk2(tmp3);
2522 } else
2523 if (entry->title && strcmp(entry->title,"")) {
2524 strncpy(tmp3, entry->title, MAXLINE);
2525 data[2] = convert_for_gtk2(tmp3);
2526 } else
2527 if (entry->cddb_ttitle && strcmp(entry->cddb_ttitle,"")) {
2528 strncpy(tmp3, entry->cddb_ttitle, MAXLINE);
2529 data[2] = convert_for_gtk2(tmp3);
2530 } else {
2531 data[2] = NULL;
2532 }
2533 convert_frames2minstring((gint)((off_t)entry->size/CDDAFRAME), tmp2);
2534 data[3] = convert_for_gtk2(tmp2);
2535 strncpy(tmp4, entry->path, MAXLINE);
2536 data[4] = convert_for_gtk2(tmp4);
2537 gtk_clist_append(clist,data);
2538 gtk_clist_set_pixmap(clist,count-1,0,pixmap1,mask1);
2539
2540 count++;
2541 }
2542 loop = loop->next;
2543 }
2544
2545 /* add wavplayer */
2546 wavplay_frontend(actionspace);
2547
2548 gtk_widget_show(actionspace);
2549 }
2550
2551
2552 /* callbacks for buttons in write-screen */
2553
blankcd_clicked(GtkWidget * widget,gpointer data)2554 void blankcd_clicked(GtkWidget *widget, gpointer data) {
2555
2556 /* no cd-writer defined */
2557 if (curset.writer_devnr == -1) {
2558 show_dialog(ICO_ERROR,_("No CD-Writer defined in Setup"), T_OK, NULL, NULL, 0);
2559 return;
2560 }
2561
2562 display_blank_cdrw(curset.writer_devnr);
2563 }
2564
adv_write_options_clicked(GtkWidget * widget,gpointer data)2565 void adv_write_options_clicked(GtkWidget *widget, gpointer data) {
2566
2567 /* no cd-writer defined */
2568 if (curset.writer_devnr == -1) {
2569 show_dialog(ICO_ERROR,_("No CD-Writer defined in Setup"), T_OK, NULL, NULL, 0);
2570 return;
2571 }
2572
2573 display_advwriteoptions(curset.writer_devnr);
2574 }
2575
show_atip_info(GtkWidget * widget,gpointer data)2576 void show_atip_info(GtkWidget *widget, gpointer data) {
2577
2578 /* no cd-writer defined */
2579 if (curset.writer_devnr == -1) {
2580 show_dialog(ICO_ERROR,_("No CD-Writer defined in Setup"), T_OK, NULL, NULL, 0);
2581 return;
2582 }
2583
2584 display_atip_info(curset.writer_devnr);
2585 }
2586
cdrtype_selected(GtkWidget * item,gpointer mode)2587 void cdrtype_selected(GtkWidget *item, gpointer mode) {
2588
2589 curset.cdrtype = GPOINTER_TO_INT(mode);
2590 }
2591
writemode_selected(GtkWidget * item,gpointer data)2592 void writemode_selected(GtkWidget *item, gpointer data) {
2593 gint i;
2594 i = get_writerreaderdevs_index(curset.writer_devnr);
2595 writerreaderdevs[i]->writer_mode = GPOINTER_TO_INT(data);
2596 }
2597
writeoptions_selected(GtkWidget * item,gpointer nr)2598 void writeoptions_selected(GtkWidget *item, gpointer nr) {
2599 gint sel;
2600
2601 sel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
2602
2603 switch(GPOINTER_TO_INT(nr)) {
2604 case 0:
2605 curset.writesimul = sel;
2606 break;
2607 case 1:
2608 curset.writeeject = sel;
2609 break;
2610 case 2:
2611 curset.writepad = sel;
2612 break;
2613 case 3:
2614 curset.writeswap = sel;
2615 break;
2616 case 4:
2617 curset.nofixate = sel;
2618 break;
2619 case 5:
2620 curset.multisession = sel;
2621 /* disable write-mode selector in ms mode */
2622 if (sel) {
2623 if (crea_cd_mode_omenu && curset.writer_devnr != -1) {
2624 gtk_widget_set_sensitive(crea_cd_mode_omenu, FALSE);
2625 }
2626 } else {
2627 if (crea_cd_mode_omenu && curset.writer_devnr != -1) {
2628 gtk_widget_set_sensitive(crea_cd_mode_omenu, TRUE);
2629 }
2630 }
2631 break;
2632 case 6:
2633 curset.writecdtext = sel;
2634 break;
2635 case 7:
2636 curset.writeoverburn = sel;
2637 break;
2638 case 8:
2639 curset.writeburnfree = sel;
2640 break;
2641 case 9:
2642 curset.writeaudiomaster = sel;
2643 break;
2644 case 10:
2645 curset.writeforcespeed = sel;
2646 break;
2647 case 11:
2648 curset.writeignsize = sel;
2649 break;
2650 case 12:
2651 curset.writeimmed = sel;
2652 break;
2653 }
2654 }
2655
2656
2657 /* call back for toc-selector in write menu */
2658
tocwrite_selected(GtkWidget * item,gpointer val)2659 static void tocwrite_selected(GtkWidget *item, gpointer val) {
2660 GList *lelement;
2661 gchar tmp[MAXLINE];
2662 GdkCursor *cursor;
2663
2664 strcpy(tmp,"");
2665 if (GPOINTER_TO_INT(val) >= 0) {
2666 lelement = g_list_nth(tocfiles, GPOINTER_TO_INT(val));
2667 if (lelement != NULL) {
2668 strcpy(tmp,(gchar *)lelement->data);
2669 }
2670 } else
2671 if (GPOINTER_TO_INT(val) == -1) {
2672 /* on the fly setting */
2673 strcpy(tmp,"-");
2674 } else {
2675 /* empty setting (verify menu) */
2676 g_free(curset.tocfile);
2677 curset.tocfile = g_strdup("-");
2678 gtk_entry_set_text(GTK_ENTRY(cdlist_l1),"");
2679 gtk_entry_set_text(GTK_ENTRY(cdlist_l2),"");
2680 gtk_entry_set_text(GTK_ENTRY(cdlist_l3),"");
2681 gtk_entry_set_text(GTK_ENTRY(cdlist_l4),"");
2682 return;
2683 }
2684
2685 /* save current setting */
2686 /* use full path string here because the index-number can get
2687 lost too easily */
2688 g_free(curset.tocfile);
2689 curset.tocfile = g_strdup(tmp);
2690
2691 do_lock(1);
2692 /* ok, now do some work - change cursor to watch */
2693 cursor = gdk_cursor_new(GDK_WATCH);
2694 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
2695
2696 while (gtk_events_pending())
2697 gtk_main_iteration();
2698
2699 if (strcmp(curset.tocfile,"-") != 0) {
2700 read_copy_cd_toc_file(curset.tocfile);
2701
2702 /* cd type */
2703 determine_cd_type(tmp,1);
2704 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), tmp);
2705
2706 /* cd title */
2707 gtk_entry_set_text(GTK_ENTRY(cdlist_l2),
2708 trackreadset.cdtitle);
2709
2710 /* cd-size */
2711 convert_frames2mbminstring(trackreadset.cdsize, tmp);
2712 gtk_entry_set_text(GTK_ENTRY(cdlist_l3), tmp);
2713
2714 /* nr tracks */
2715 g_snprintf(tmp,MAXLINE,"%d",trackreadset.nrtracks);
2716 gtk_entry_set_text(GTK_ENTRY(cdlist_l4), tmp);
2717
2718 #if 0
2719 if (edit_cdtext_btn)
2720 gtk_widget_set_sensitive(edit_cdtext_btn, TRUE);
2721 #endif
2722 } else {
2723 /* we copy on the fly... */
2724 gtk_entry_set_text(GTK_ENTRY(cdlist_l2),"");
2725 gtk_entry_set_text(GTK_ENTRY(cdlist_l3),"");
2726 gtk_entry_set_text(GTK_ENTRY(cdlist_l4),"");
2727 if (cdinfo.nr_tracks == -1) {
2728 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), _("No CD loaded"));
2729 } else
2730 if (cdinfo.nr_tracks == -2) {
2731 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), return_media_type(curset.reader_devnr));
2732 } else {
2733 /* cd is inserted - show info */
2734 determine_cd_type(tmp,0);
2735 gtk_entry_set_text(GTK_ENTRY(cdlist_l1), tmp);
2736
2737 /* cd-label */
2738 if (cdinfo.title && cdinfo.artist &&
2739 cdinfo.title[0] != '\0' &&
2740 setupdata.option_displaycdtext) {
2741 g_snprintf(tmp,MAXLINE,"%s / %s",
2742 cdinfo.title, cdinfo.artist);
2743 gtk_entry_set_text(GTK_ENTRY(cdlist_l2), tmp);
2744 gtk_entry_set_position(GTK_ENTRY(cdlist_l2),0);
2745 } else
2746 if (cdinfo.cddb_dtitle != NULL) {
2747 gtk_entry_set_text(GTK_ENTRY(cdlist_l2),
2748 cdinfo.cddb_dtitle);
2749 gtk_entry_set_position(GTK_ENTRY(cdlist_l2),0);
2750 }
2751
2752 /* cd-size */
2753 convert_frames2mbminstring(cdinfo.total_size, tmp);
2754 gtk_entry_set_text(GTK_ENTRY(cdlist_l3), tmp);
2755
2756 /* nr tracks */
2757 g_snprintf(tmp,MAXLINE,"%d",cdinfo.nr_tracks);
2758 gtk_entry_set_text(GTK_ENTRY(cdlist_l4), tmp);
2759 }
2760
2761 #if 0
2762 /* on the fly copy, disable "Edit CD-Text" button */
2763 if (edit_cdtext_btn) {
2764 gtk_widget_set_sensitive(edit_cdtext_btn, FALSE);
2765 }
2766 #endif
2767 }
2768
2769 /* reset cursor */
2770 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
2771 gdk_cursor_destroy (cursor);
2772 do_unlock(1);
2773 }
2774
2775
2776 /* write button in write menu */
2777
writetracks_clicked(GtkWidget * widget,gpointer data)2778 static void writetracks_clicked(GtkWidget *widget, gpointer data) {
2779 gint stat;
2780 gint ret,i;
2781 gint onthefly;
2782 gint spaceneededoncd;
2783 gint outofspace;
2784 gint64 tmpsize;
2785 GList *loop;
2786 track_read_param_t *trackparam;
2787 gint datacount, audiocount;
2788 gint readspeed, writespeed;
2789
2790 /* no cd-writer defined */
2791 if (curset.writer_devnr == -1) {
2792 show_dialog(ICO_ERROR,_("No CD-Writer defined in Setup"), T_OK, NULL, NULL, 0);
2793 return;
2794 }
2795
2796 /* on the fly setting? */
2797 if (strcmp(curset.tocfile,"-") == 0) {
2798 onthefly = 1;
2799
2800 spaceneededoncd = cdinfo.total_size;
2801
2802 if (cdinfo.nr_tracks < 0) {
2803 show_dialog(ICO_WARN,_("No CD loaded in read device"),T_OK,NULL,NULL,0);
2804 return;
2805 }
2806
2807 /* now check if read device is different from write device */
2808 if (curset.reader_devnr == curset.writer_devnr) {
2809 show_dialog(ICO_WARN,_("Read device is the same as the write device!\nOn the fly copy is only possible with different devices\n"),T_OK,NULL,NULL,0);
2810 return;
2811 }
2812
2813 /* check write speeds */
2814 i = get_writerreaderdevs_index(curset.reader_devnr);
2815 readspeed = writerreaderdevs[i]->audioread_speed;
2816 i = get_writerreaderdevs_index(curset.writer_devnr);
2817 writespeed = writerreaderdevs[i]->writer_speed;
2818
2819 if (writespeed > readspeed && readspeed != 0) {
2820 ret = show_dialog(ICO_WARN,_("When copy on the fly it is not advised to use a\nhigher speed to write then to read."),T_ANYWAY,T_CANCEL,
2821 NULL, 1);
2822 if (ret == 1) {
2823 /* aborted */
2824 return;
2825 }
2826 }
2827
2828 audiocount = 0;
2829 datacount = 0;
2830 /* check cdinfo-structure */
2831 for (i = 0; i < cdinfo.nr_tracks; i++) {
2832 if (trackinfo[i]->type == 0) {
2833 datacount++;
2834 } else {
2835 audiocount++;
2836 }
2837 }
2838
2839 if (curset.support_ontheflyaudio == 0) {
2840 /* now check if we have a pure data cd (other we cannot
2841 copy currently on the fly) */
2842 if (cdinfo.nr_tracks != 1 || trackinfo[0]->type != 0) {
2843 show_dialog(ICO_WARN,_("With your version of the cdrtools only pure data CDs\nare supported for on-the-fly copy. A newer version might\nsupport audio on-the-fly copy."),T_OK,NULL,NULL,0);
2844 return;
2845 }
2846 } else {
2847 /* alpha version of the cdrtools installed, allow
2848 copy of audio (and simple data and cd-extra) */
2849 if ((datacount > 0 && audiocount > 0 && trackinfo[0]->type != 1) ||
2850 datacount > 1) {
2851 show_dialog(ICO_WARN,_("Currently on-the-fly copy is only supported\nfor simple data CDs, audio CDs or CDs with a data track\nafter several audio tracks (CD-Extra)."),T_OK,NULL,NULL,0);
2852 return;
2853 }
2854
2855 /* warn when cd-extra */
2856 if (datacount > 0 && audiocount > 0 && trackinfo[0]->type == 1) {
2857 ret = show_dialog(ICO_WARN,_("That CD contains both audio and data tracks. X-CD-Roast\nwill only copy the audio tracks in on-the-fly mode."),T_OK,T_CANCEL,NULL,0);
2858 if (ret == 1) {
2859 return;
2860 }
2861 }
2862 }
2863 /* ok...everything seems to be fine */
2864
2865 } else {
2866 onthefly = 0;
2867 spaceneededoncd = trackreadset.cdsize;
2868
2869 /* first check if all tracks we need are available on hd */
2870 stat = check_write_files(0);
2871 switch(stat) {
2872 /* files with wrong size */
2873 case 1:
2874 ret = show_dialog(ICO_QUEST,_("Some tracks do have a different file-size as expected.\nPerhaps the tracks are outdated or belong to another CD.\nDo you want to continue anyway or to abort?"),T_ANYWAY,T_CANCEL,
2875 NULL, 1);
2876 if (ret == 1) {
2877 /* aborted */
2878 return;
2879 }
2880 break;
2881 /* files missing */
2882 case 2:
2883 show_dialog(ICO_ERROR,_("Some tracks belonging to the CD you want to write are missing.\nPerhaps the TOC file is outdated and the tracks\nwere already removed from the hard drive."),T_OK,NULL,NULL,0);
2884 return;
2885
2886 /* no permission/invalid */
2887 case 3:
2888 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);
2889 return;
2890
2891 /* invalid isrc or mcn */
2892 case 4:
2893 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);
2894 if (ret == 1) {
2895 /* abort */
2896 return;
2897 } else {
2898 /* clear ids */
2899 stat = clear_isrc_mcn_from_tracks();
2900 if (stat == 1) {
2901 /* error resetting ids */
2902 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);
2903 return;
2904 }
2905 }
2906 break;
2907 }
2908 }
2909
2910 /* check if enough space on cd-r? */
2911 dodebug(2,"Sectors required: %d, Mediatype = %d\n", spaceneededoncd,
2912 curset.cdrtype);
2913 outofspace = 0;
2914 if (curset.cdrtype < 1000) {
2915 /* minutes to check */
2916 if (spaceneededoncd > (curset.cdrtype*60*75)) {
2917 outofspace = 1;
2918 }
2919 } else {
2920 /* dvd sizes in MB */
2921 /* capacity of a DVD in bytes */
2922 tmpsize = (gint64)curset.cdrtype * 1000 * 1000;
2923 /* and now in sectors */
2924 tmpsize = tmpsize / 2048;
2925
2926 if (spaceneededoncd > (gint)tmpsize) {
2927 outofspace = 1;
2928 }
2929 }
2930 if (outofspace) {
2931 if (!is_dvdwriter(curset.writer_devnr)) {
2932 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);
2933 } else {
2934 /* perhaps we want to write a dvd? */
2935 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);
2936 }
2937 if (ret == 1) {
2938 /* aborted */
2939 return;
2940 }
2941 }
2942
2943 /* ok, now we are sure that all tracks are fine ...prompt for CD-R */
2944 ret = show_dialog(ICO_INFO,pleaseinsertmedia(),T_OK,T_CANCEL,NULL,0);
2945 if (ret != 0) {
2946 return;
2947 }
2948
2949 /* if we should write CD-Text then edit the .inf files from cdda2wav */
2950 if (curset.writecdtext && !onthefly) {
2951 loop = g_list_first(trackreadset.trackparams);
2952 while(loop) {
2953 trackparam = loop->data;
2954 if (trackparam->trackfile != NULL) {
2955 edit_xinf_for_cd_text(trackparam->trackfile,
2956 curset.tocfile);
2957 }
2958 loop = loop->next;
2959 }
2960
2961 }
2962
2963 show_and_do_write_tracks(curset.writer_devnr, curset.reader_devnr,
2964 onthefly);
2965 }
2966
2967
2968 /* fill the entries in the write_cd-menu */
2969
fill_write_menu()2970 static void fill_write_menu() {
2971 GList *loop;
2972 GtkWidget *menu;
2973 GtkWidget *menu_item, *menuselitem;
2974 gchar tmp[MAXLINE];
2975 gint menuidx, menuhistory;
2976 gint i, len;
2977
2978 /* get list of toc-files (save in tocfiles var) */
2979 scan_for_toc_files();
2980
2981 /* clear out the old menu first (if any) */
2982 gtk_option_menu_remove_menu(GTK_OPTION_MENU (write_toc_menu));
2983
2984 menu = gtk_menu_new();
2985 menuselitem = NULL;
2986 menuidx = 0; menuhistory = 0;
2987 i = 0;
2988 loop = g_list_first(tocfiles);
2989 while (loop) {
2990 /* a bug in gtk wont allow longer option-menus...
2991 well, then strip the strings down (not nice, but
2992 so far the only way I can think of */
2993 len = strlen((gchar *)loop->data);
2994 if (len > 24) {
2995 strcpy(tmp, ".. ");
2996 strcat(tmp, (gchar *)loop->data + len - 24);
2997 } else {
2998 strcpy(tmp, (gchar *)loop->data);
2999 }
3000 menu_item = gtk_menu_item_new_with_label(tmp);
3001 if (menuselitem == NULL) {
3002 /* default first element */
3003 menuselitem = menu_item;
3004 }
3005 gtk_signal_connect(GTK_OBJECT(menu_item),
3006 "activate", GTK_SIGNAL_FUNC(tocwrite_selected),
3007 GINT_TO_POINTER(i));
3008 if (strcmp(curset.tocfile, (gchar *)loop->data) == 0) {
3009 menuhistory = menuidx;
3010 menuselitem = menu_item;
3011 }
3012 gtk_menu_append (GTK_MENU (menu), menu_item);
3013 gtk_widget_show (menu_item);
3014 loop = loop->next;
3015 menuidx++;
3016 i++;
3017 }
3018 /* on the fly setting */
3019 menu_item = gtk_menu_item_new_with_label(_("Copy on the fly"));
3020 gtk_signal_connect(GTK_OBJECT(menu_item),
3021 "activate", GTK_SIGNAL_FUNC(tocwrite_selected),
3022 GINT_TO_POINTER(-1));
3023 if (strcmp(curset.tocfile, "-") == 0) {
3024 menuhistory = menuidx;
3025 menuselitem = menu_item;
3026 }
3027 gtk_menu_append (GTK_MENU (menu), menu_item);
3028 gtk_widget_show (menu_item);
3029
3030 gtk_option_menu_set_menu (GTK_OPTION_MENU (write_toc_menu), menu);
3031 gtk_option_menu_set_history(GTK_OPTION_MENU (write_toc_menu),menuhistory);
3032 /* toggle currently active menu */
3033 if (menuselitem != NULL) {
3034 gtk_menu_item_activate(GTK_MENU_ITEM (menuselitem));
3035 } else {
3036 /* if no active menu, activate the last set */
3037 /* (one the fly in this case) */
3038 gtk_menu_item_activate(GTK_MENU_ITEM (menu_item));
3039 }
3040
3041 }
3042
3043
3044 /* draw the write-CD menu */
3045
draw_write_menu()3046 static void draw_write_menu() {
3047 gchar tmp[MAXLINE];
3048 gchar tmp2[MAXLINE];
3049 GtkWidget *hbox, *vbox;
3050 GtkWidget *f1,*f2;
3051 GtkWidget *b1;
3052 GtkWidget *e1, *check;
3053 GtkWidget *l1;
3054 GtkWidget *tbl;
3055 GtkWidget *sep;
3056 GtkWidget *omenu;
3057 GtkWidget *menu;
3058 GtkWidget *menu_item;
3059 gint cdrtypes[] = CDR_TYPES_MIN;
3060 gint dvdtypes[] = DVD_TYPES_MB;
3061 static const gchar *writemodes[] = WRITE_MODES;
3062 static const gchar *helpwritemodes[] = HELP_WRITE_MODES;
3063 gint i, tmpval;
3064 gint menuidx, menuhistory;
3065
3066 /* prepare draw area */
3067 clear_actionspace();
3068
3069 dupl_cd_mode_omenu = NULL;
3070 dupl_cd_burnfree_check = NULL;
3071
3072 f1 = gtk_frame_new(_("Devices-Setup"));
3073 set_font_and_color_frame(f1,BOLDFONT,NULL);
3074 gtk_box_pack_start(GTK_BOX(actionspace),f1,FALSE,FALSE,5);
3075 gtk_widget_show(f1);
3076
3077 tbl = gtk_table_new(3,16*4,TRUE);
3078 gtk_table_set_col_spacing(GTK_TABLE(tbl),4*4-1,5);
3079 gtk_table_set_col_spacing(GTK_TABLE(tbl),15*4-2,5);
3080 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
3081 gtk_container_add(GTK_CONTAINER(f1),tbl);
3082 gtk_widget_show(tbl);
3083
3084 devices_setup_read(0, tbl, 1);
3085 devices_setup_image(1, tbl);
3086 devices_setup_write(2, tbl);
3087
3088 /* left and right info-frames */
3089 tbl = gtk_table_new(1,2,TRUE);
3090 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
3091 gtk_box_pack_start(GTK_BOX(actionspace),tbl,TRUE,TRUE,10);
3092 gtk_widget_show(tbl);
3093 if (!curset.isProDVD) {
3094 f1 = gtk_frame_new(_("CD to write"));
3095 } else {
3096 f1 = gtk_frame_new(_("CD/DVD to write"));
3097 }
3098 set_font_and_color_frame(f1,BOLDFONT,NULL);
3099 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,0,1,0,1);
3100 gtk_widget_show(f1);
3101 f2 = gtk_frame_new(_("Write parameters"));
3102 set_font_and_color_frame(f2,BOLDFONT,NULL);
3103 gtk_table_attach_defaults(GTK_TABLE(tbl),f2,1,2,0,1);
3104 gtk_widget_show(f2);
3105
3106 /* button bar at the bottom */
3107 hbox = gtk_hbox_new(TRUE,10);
3108 gtk_box_pack_start(GTK_BOX(actionspace),hbox,FALSE,TRUE,5);
3109 gtk_widget_show(hbox);
3110 if (!curset.isProDVD) {
3111 b1 = gtk_button_new_with_label(_("Write CD"));
3112 } else {
3113 b1 = gtk_button_new_with_label(_("Write CD/DVD"));
3114 }
3115 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
3116 gtk_widget_show(b1);
3117 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
3118 GTK_SIGNAL_FUNC(writetracks_clicked), NULL);
3119 define_tooltip(b1,_("Writes all tracks specified by the TOC file to a CD."));
3120
3121 if (!curset.isProDVD) {
3122 b1 = gtk_button_new_with_label(_("Blank CD-RW"));
3123 } else {
3124 b1 = gtk_button_new_with_label(_("Blank CD/DVD+-RW"));
3125 }
3126 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
3127 gtk_widget_show(b1);
3128 gtk_signal_connect(GTK_OBJECT(b1), "clicked",
3129 GTK_SIGNAL_FUNC(blankcd_clicked), NULL);
3130 define_tooltip(b1,_("Blanks a CD-RW in the Write-Device."));
3131
3132
3133 /* left info frame */
3134 vbox = gtk_vbox_new(FALSE,0);
3135 gtk_container_add(GTK_CONTAINER(f1),vbox);
3136 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
3137 gtk_widget_show(vbox);
3138
3139 tbl = gtk_table_new(5,8,FALSE);
3140 gtk_table_set_row_spacings(GTK_TABLE(tbl),10);
3141 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
3142 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,0);
3143 gtk_widget_show(tbl);
3144
3145 l1 = rightjust_gtk_label_new(_("TOC-File:"));
3146 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,3,0,1);
3147 gtk_widget_show(l1);
3148
3149 omenu = gtk_option_menu_new();
3150 write_toc_menu = omenu;
3151 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,3,8,0,1);
3152 gtk_widget_show(omenu);
3153 define_tooltip(omenu,_("Select the TOC file that specifies which tracks should be written to CD. The setting \"Copy on the fly\" will read the tracks directly from the Read-Device instead from the harddisk."));
3154
3155 l1 = rightjust_gtk_label_new(_("Type:"));
3156 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,3,1,2);
3157 gtk_widget_show(l1);
3158
3159 e1 = gtk_entry_new();
3160 cdlist_l1 = e1;
3161 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
3162 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,3,8,1,2);
3163 gtk_widget_show(e1);
3164
3165 l1 = rightjust_gtk_label_new(_("Label:"));
3166 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,3,2,3);
3167 gtk_widget_show(l1);
3168
3169 e1 = gtk_entry_new();
3170 cdlist_l2 = e1;
3171 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
3172 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,3,8,2,3);
3173 gtk_widget_show(e1);
3174
3175 l1 = rightjust_gtk_label_new(_("Size:"));
3176 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,3,3,4);
3177 gtk_widget_show(l1);
3178
3179 e1 = gtk_entry_new();
3180 cdlist_l3 = e1;
3181 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
3182 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,3,8,3,4);
3183 gtk_widget_show(e1);
3184
3185 l1 = rightjust_gtk_label_new(_("Tracks:"));
3186 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,3,4,5);
3187 gtk_widget_show(l1);
3188
3189 e1 = gtk_entry_new();
3190 cdlist_l4 = e1;
3191 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
3192 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,3,8,4,5);
3193 gtk_widget_show(e1);
3194
3195
3196 /* right info frame */
3197 /* write-parameters */
3198 vbox = gtk_vbox_new(FALSE,0);
3199 gtk_container_add(GTK_CONTAINER(f2),vbox);
3200 gtk_container_set_border_width (GTK_CONTAINER (vbox), 7);
3201 gtk_widget_show(vbox);
3202
3203 tbl = gtk_table_new(8,16,FALSE);
3204 gtk_table_set_row_spacing(GTK_TABLE(tbl),0,2);
3205 gtk_table_set_row_spacing(GTK_TABLE(tbl),1,5);
3206 gtk_table_set_row_spacing(GTK_TABLE(tbl),2,5);
3207 gtk_table_set_col_spacings(GTK_TABLE(tbl),2);
3208 gtk_box_pack_start(GTK_BOX(vbox),tbl,FALSE,FALSE,0);
3209 gtk_widget_show(tbl);
3210
3211 l1 = rightjust_gtk_label_new(_("Disc Type:"));
3212 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,6,0,1);
3213 gtk_widget_show(l1);
3214
3215 omenu = gtk_option_menu_new();
3216 menu = gtk_menu_new();
3217 menuidx = 0; menuhistory = 0;
3218
3219 i = 0;
3220 tmpval = curset.cdrtype;
3221 while (cdrtypes[i] != 0) {
3222 /* contruct minute-list */
3223 g_snprintf(tmp,MAXLINE,"%d min",abs(cdrtypes[i]));
3224
3225 menu_item = gtk_menu_item_new_with_label(tmp);
3226 gtk_signal_connect(GTK_OBJECT(menu_item),
3227 "activate", GTK_SIGNAL_FUNC(cdrtype_selected),
3228 GINT_TO_POINTER(abs(cdrtypes[i])));
3229 gtk_menu_append (GTK_MENU (menu), menu_item);
3230 if (tmpval == abs(cdrtypes[i])) {
3231 menuhistory = menuidx;
3232 }
3233 /* default set defined by negativ value */
3234 if (tmpval == 0 && cdrtypes[i] < 0) {
3235 menuhistory = menuidx;
3236 curset.cdrtype = abs(cdrtypes[i]);
3237 }
3238 menuidx++;
3239 gtk_widget_show (menu_item);
3240 i++;
3241 }
3242 if (curset.isProDVD) {
3243 i = 0;
3244 tmpval = curset.cdrtype;
3245 while (dvdtypes[i] != 0) {
3246 /* contruct GB-list */
3247 g_snprintf(tmp2,MAXLINE,"%.2f", (gfloat)dvdtypes[i]/1000);
3248 /* strip last 0 */
3249 if (tmp2[strlen(tmp2)-1] == '0') {
3250 tmp2[strlen(tmp2)-1] = '\0';
3251 }
3252 g_snprintf(tmp,MAXLINE,"%s GB",tmp2);
3253
3254 menu_item = gtk_menu_item_new_with_label(tmp);
3255 gtk_signal_connect(GTK_OBJECT(menu_item),
3256 "activate", GTK_SIGNAL_FUNC(cdrtype_selected),
3257 GINT_TO_POINTER(dvdtypes[i]));
3258 gtk_menu_append (GTK_MENU (menu), menu_item);
3259 if (tmpval == abs(dvdtypes[i])) {
3260 menuhistory = menuidx;
3261 }
3262 menuidx++;
3263 gtk_widget_show (menu_item);
3264 i++;
3265 }
3266 }
3267
3268 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
3269 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),menuhistory);
3270 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,6,10,0,1);
3271 gtk_widget_show(omenu);
3272 define_tooltip(omenu,_("The capacity of the currently used CD-R/RW."));
3273
3274 b1 = gtk_button_new_with_label(_("ATIP-Info"));
3275 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
3276 GTK_SIGNAL_FUNC(show_atip_info),NULL);
3277 gtk_table_attach_defaults(GTK_TABLE(tbl),b1,10,16,0,1);
3278 gtk_widget_show(b1);
3279 define_tooltip(b1,_("Read detailed information from a (empty) CD-R/RW."));
3280
3281
3282 /* write-mode */
3283 l1 = rightjust_gtk_label_new(_("Write Mode:"));
3284 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,6,1,2);
3285 gtk_widget_show(l1);
3286
3287
3288 omenu = gtk_option_menu_new ();
3289 menu = gtk_menu_new();
3290 dupl_cd_mode_omenu = omenu;
3291
3292 i = 0;
3293 while (writemodes[i]) {
3294 menu_item = gtk_menu_item_new_with_label(_(writemodes[i]));
3295 gtk_signal_connect(GTK_OBJECT(menu_item), "activate",
3296 GTK_SIGNAL_FUNC(writemode_selected),
3297 GINT_TO_POINTER(i));
3298 gtk_menu_append (GTK_MENU (menu), menu_item);
3299 gtk_widget_show (menu_item);
3300 if (helpwritemodes[i])
3301 define_tooltip(menu_item,(gchar *)_(helpwritemodes[i]));
3302 i++;
3303 }
3304
3305 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
3306 preselect_write_mode_menu(omenu, curset.writer_devnr);
3307 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,6,16,1,2);
3308 gtk_widget_show(omenu);
3309 /* concat 2 help strings */
3310 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."));
3311 define_tooltip(omenu,tmp);
3312
3313
3314 if (!isroot() && !setupdata.root_option_change_writeparam) {
3315 gtk_widget_set_sensitive(omenu,FALSE);
3316 }
3317
3318 sep = gtk_hseparator_new();
3319 gtk_table_attach_defaults(GTK_TABLE(tbl),sep,0,16,2,3);
3320 gtk_widget_show(sep);
3321
3322 check = gtk_check_button_new_with_label(_("Simulation write"));
3323 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3324 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(0));
3325 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,3,4);
3326 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3327 curset.writesimul);
3328 gtk_widget_show(check);
3329 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."));
3330
3331 check = gtk_check_button_new_with_label(_("Eject after write"));
3332 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3333 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(1));
3334 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,4,5);
3335 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3336 curset.writeeject);
3337 gtk_widget_show(check);
3338 define_tooltip(check,_("Eject the CD after the burning was completed."));
3339
3340 check = gtk_check_button_new_with_label(_("Pad Tracks"));
3341 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3342 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(2));
3343 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,5,6);
3344 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3345 curset.writepad);
3346 gtk_widget_show(check);
3347 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."));
3348
3349
3350 check = gtk_check_button_new_with_label(_("Enable protection from Buffer Underruns"));
3351 dupl_cd_burnfree_check = check;
3352
3353 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3354 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(8));
3355 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,16,6,7);
3356 if (does_support_burnproof(curset.writer_devnr)) {
3357 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3358 curset.writeburnfree);
3359 }
3360 gtk_widget_show(check);
3361 define_tooltip(check,_("When available it does enable protection from Buffer Underrun errors. Supported are Sanyo BURN-Proof, Ricoh Just-Link and similar."));
3362
3363 if (!does_support_burnproof(curset.writer_devnr))
3364 gtk_widget_set_sensitive(check,FALSE);
3365
3366 check = gtk_check_button_new_with_label(_("Write CD-Text"));
3367 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3368 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(6));
3369 gtk_table_attach_defaults(GTK_TABLE(tbl),check,2,8,7,8);
3370 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3371 curset.writecdtext);
3372 gtk_widget_show(check);
3373 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."));
3374
3375 b1 = gtk_button_new_with_label(_("Edit titles"));
3376 edit_cdtext_btn = b1;
3377 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
3378 GTK_SIGNAL_FUNC(edit_cdtext_clicked), GINT_TO_POINTER(1));
3379 gtk_table_attach_defaults(GTK_TABLE(tbl),b1,8,16,7,8);
3380 gtk_widget_show(b1);
3381 define_tooltip(b1,_("Edits the title and performer information of your tracks before they are written to a CD-R/RW with CD-Text."));
3382
3383
3384 b1 = gtk_button_new_with_label(_("Advanced options"));
3385 gtk_signal_connect (GTK_OBJECT (b1), "clicked",
3386 GTK_SIGNAL_FUNC(adv_write_options_clicked), NULL);
3387 gtk_box_pack_end(GTK_BOX(vbox),b1,FALSE,FALSE,0);
3388 gtk_widget_show(b1);
3389 define_tooltip(b1,_("Set additional write options for advanced users."));
3390
3391
3392 gtk_widget_show(actionspace);
3393
3394
3395 /* fill entries */
3396 fill_write_menu();
3397
3398 }
3399
3400
3401 /* fill the list with the tracks to delete */
3402
fill_delete_menu()3403 static void fill_delete_menu() {
3404 GtkStyle *style;
3405 gchar *data[5];
3406 GdkPixmap *pixmap1, *pixmap2, *pixmap3, *pixmap4, *pixmap5;
3407 GdkBitmap *mask1, *mask2, *mask3, *mask4, *mask5;
3408 gchar tmp[MAXLINE];
3409 gchar tmp2[MAXLINE];
3410 gchar tmp3[MAXLINE];
3411 gchar tmp4[MAXLINE];
3412 gchar basename[MAXLINE], imgdir[MAXLINE], *p;
3413 GList *loop;
3414 image_files_t *entry;
3415 gint lcount, count;
3416 gint sizecount;
3417 gint dummy;
3418
3419 /* clean up first */
3420 gtk_clist_clear(imglist);
3421
3422 style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(imglist)));
3423 pixmap1 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
3424 &mask1, &style->bg[GTK_STATE_NORMAL],(gchar **)minidata_xpm);
3425 pixmap2 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
3426 &mask2, &style->bg[GTK_STATE_NORMAL],(gchar **)miniaudio_xpm);
3427 pixmap3 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
3428 &mask3, &style->bg[GTK_STATE_NORMAL],(gchar **)mininodata_xpm);
3429 pixmap4 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
3430 &mask4, &style->bg[GTK_STATE_NORMAL],(gchar **)mininoaudio_xpm);
3431 pixmap5 = gdk_pixmap_create_from_xpm_d(imglist->clist_window,
3432 &mask5, &style->bg[GTK_STATE_NORMAL],(gchar **)minitoc_xpm);
3433
3434 data[0] = NULL;
3435 strcpy(imgdir,"");
3436 lcount = 0;
3437 count = 1;
3438 sizecount = 0;
3439
3440 /* check image-selector */
3441 if (curset.image_index != -1) {
3442 /* no automatic setting? */
3443 strncpy(imgdir,(gchar *)g_list_nth_data(setupdata.image_dirs,
3444 curset.image_index), MAXLINE);
3445 }
3446
3447 loop = g_list_first(imagelist);
3448 while (loop) {
3449 entry = loop->data;
3450
3451 /* get the base-dirname */
3452 strncpy(basename,entry->path,MAXLINE);
3453 p = rindex(basename,'/');
3454 *p = '\0';
3455 if (strcmp(basename,"") == 0) {
3456 strcpy(basename,"/");
3457 }
3458 if (strcmp(basename,imgdir) != 0 && imgdir[0] != '\0') {
3459 /* skip not selected dirs */
3460 loop = loop->next;
3461 continue;
3462 }
3463
3464 /* count */
3465 g_snprintf(tmp,MAXLINE,"%d.",count);
3466 data[1] = convert_for_gtk2(tmp);
3467
3468 /* title */
3469 if (entry->title && entry->artist &&
3470 strcmp(entry->title,"") && strcmp(entry->artist,"")) {
3471 g_snprintf(tmp3,MAXLINE,"%s / %s",
3472 entry->title, entry->artist);
3473 data[2] = convert_for_gtk2(tmp3);
3474 } else
3475 if (entry->title && strcmp(entry->title,"")) {
3476 strncpy(tmp3, entry->title, MAXLINE);
3477 data[2] = convert_for_gtk2(tmp3);
3478 } else
3479 if (entry->cddb_ttitle && strcmp(entry->cddb_ttitle,"")) {
3480 strncpy(tmp3, entry->cddb_ttitle, MAXLINE);
3481 data[2] = convert_for_gtk2(tmp3);
3482 } else
3483 if (entry->volname && strcmp(entry->volname,"")) {
3484 g_snprintf(tmp3,MAXLINE,"%s / ISO9660",
3485 entry->volname);
3486 data[2] = convert_for_gtk2(tmp3);
3487 } else {
3488 data[2] = NULL;
3489 }
3490
3491 /* path */
3492 strncpy(tmp4, entry->path, MAXLINE);
3493 data[4] = convert_for_gtk2(tmp4);
3494
3495 /* iso9600-track/ unknown */
3496 if (entry->type == 0 || entry->type == 3) {
3497 convert_frames2mbstring((gint)((off_t)entry->size/DATASECTORSIZE),
3498 tmp2);
3499 data[3] = convert_for_gtk2(tmp2);
3500 gtk_clist_append(imglist,data);
3501 if (entry->readable == 1 && entry->type == 0) {
3502 gtk_clist_set_pixmap(imglist,lcount,0,pixmap1,mask1);
3503 } else {
3504 gtk_clist_set_pixmap(imglist,lcount,0,pixmap3,mask3);
3505 }
3506 lcount++;
3507 sizecount+=(gint)((off_t)entry->size >> 10);
3508 count++;
3509 }
3510
3511 /* valid/invalid wav-file */
3512 if (entry->type == 1 || entry->type == 2) {
3513 convert_frames2minstring((gint)((off_t)entry->size/CDDAFRAME), tmp2);
3514 data[3] = convert_for_gtk2(tmp2);
3515 gtk_clist_append(imglist,data);
3516 if (entry->readable == 1 && entry->type == 1) {
3517 gtk_clist_set_pixmap(imglist,lcount,0,pixmap2,mask2);
3518 } else {
3519 gtk_clist_set_pixmap(imglist,lcount,0,pixmap4,mask4);
3520 }
3521 lcount++;
3522 sizecount+=(gint)((off_t)entry->size >> 10);
3523 count++;
3524 }
3525
3526 /* toc-file */
3527 if (entry->type == 4) {
3528 data[3] = NULL;
3529 gtk_clist_append(imglist,data);
3530 gtk_clist_set_pixmap(imglist,lcount,0,pixmap5, mask5);
3531 count++;
3532 lcount++;
3533 }
3534
3535 loop = loop->next;
3536 }
3537
3538 /* nothing selected - no size of files */
3539 convert_kbytes2mbminstring(0, tmp);
3540 gtk_entry_set_text(GTK_ENTRY(imglist_l1), tmp);
3541
3542 /* free size */
3543 convert_kbytes2mbminstring(determine_free_space(&dummy),tmp);
3544 gtk_entry_set_text(GTK_ENTRY(imglist_l2), tmp);
3545 }
3546
3547
3548 /* select a row with a given filename */
3549
select_delete_row_by_filename(gchar * fname)3550 static void select_delete_row_by_filename(gchar *fname) {
3551 gint i;
3552 gchar *cell;
3553
3554 /* loop through all rows */
3555 for (i = 0; i < imglist->rows; i++) {
3556 gtk_clist_get_text(imglist,i,4,&cell);
3557 if (strcmp(cell, fname) == 0) {
3558 /* match found - select row */
3559 gtk_clist_select_row(imglist, i, 0);
3560 }
3561 }
3562 }
3563
3564
3565 /* update currently selected track-size */
3566
update_delete_size(gint doubleclick,gint clickrow)3567 static void update_delete_size(gint doubleclick, gint clickrow) {
3568 GList *sel;
3569 gint row,type;
3570 gchar *cell;
3571 off_t size;
3572 gint sizecount;
3573 gchar tmp[MAXLINE];
3574 GList *loop;
3575 track_read_param_t *trackparam;
3576
3577 sizecount = 0;
3578
3579 /* check for doubleclick on list */
3580 if (doubleclick) {
3581 gtk_clist_get_text(imglist,clickrow,4,&cell);
3582 type = get_type_from_imagelist(cell);
3583 /* is it a toc-file? (type 4) */
3584 if (type == 4) {
3585 /* now scan toc file */
3586 read_copy_cd_toc_file(cell);
3587
3588 /* select all files to delete which are in the
3589 toc-file */
3590 loop = g_list_first(trackreadset.trackparams);
3591 while(loop) {
3592 trackparam = loop->data;
3593 select_delete_row_by_filename(
3594 trackparam->trackfile);
3595
3596 loop = loop->next;
3597 }
3598 }
3599 }
3600
3601 /* loop through all selected tracks */
3602 sel = imglist->selection;
3603 while (sel) {
3604 row = GPOINTER_TO_INT(sel->data);
3605 gtk_clist_get_text(imglist,row,4,&cell);
3606 size = get_size_from_imagelist(cell);
3607 sizecount += (gint)((off_t)size >> 10);
3608 sel = sel->next;
3609 }
3610
3611 convert_kbytes2mbminstring(sizecount, tmp);
3612 gtk_entry_set_text(GTK_ENTRY(imglist_l1), tmp);
3613 }
3614
3615
3616 /* start the delete job */
3617
do_delete_press(GtkWidget * widget,gpointer data)3618 static void do_delete_press(GtkWidget *widget, gpointer data) {
3619 GList *sel;
3620 gint row;
3621 gchar *cell;
3622 gint count,ret;
3623 gchar tmp[MAXLINE];
3624 GList *delfiles;
3625
3626 delfiles = NULL;
3627 count = 0;
3628 /* loop through all selected tracks */
3629 /* create a glist containing all files names to delete */
3630 sel = imglist->selection;
3631 while (sel) {
3632 row = GPOINTER_TO_INT(sel->data);
3633 gtk_clist_get_text(imglist,row,4,&cell);
3634 delfiles = g_list_append(delfiles,g_strdup(cell));
3635 count++;
3636 sel = sel->next;
3637 }
3638
3639 if (count == 0) {
3640 show_dialog(ICO_WARN,_("No tracks selected to delete"), T_OK, NULL, NULL, 0);
3641 return;
3642 } else
3643 if (count == 1) {
3644 ret = show_dialog(ICO_QUEST,_("Are you sure you want to delete one track?"),T_YES,T_NO,NULL,0);
3645 } else {
3646 g_snprintf(tmp,MAXLINE,_("Are you sure you want to delete %d tracks?"),count);
3647 ret = show_dialog(ICO_QUEST,tmp,T_YES,T_NO,NULL,0);
3648 }
3649
3650 if (ret == 1) {
3651 /* not sure - abort */
3652 return;
3653 }
3654
3655 /* create menu showing deletion */
3656 show_and_do_delete(delfiles);
3657
3658 free_glist(&delfiles);
3659
3660 /* now update image-list */
3661 scan_imagedirs();
3662 fill_delete_menu();
3663 }
3664
delete_select_all(GtkWidget * widget,gpointer data)3665 static void delete_select_all(GtkWidget *widget, gpointer data) {
3666
3667 gtk_clist_select_all(imglist);
3668 }
3669
delete_select_none(GtkWidget * widget,gpointer data)3670 static void delete_select_none(GtkWidget *widget, gpointer data) {
3671
3672 gtk_clist_unselect_all(imglist);
3673 }
3674
delete_select_row(GtkWidget * clist,gint row,gint col,GdkEventButton * event,gpointer data)3675 static void delete_select_row(GtkWidget *clist, gint row, gint col,
3676 GdkEventButton *event, gpointer data) {
3677
3678 /* double click? */
3679 if (event && event->type == GDK_2BUTTON_PRESS) {
3680 update_delete_size(1, row);
3681 } else {
3682 update_delete_size(0, row);
3683 }
3684 }
3685
3686
3687 /* draw the delete-tracks menu */
3688
draw_delete_menu()3689 void draw_delete_menu() {
3690 GtkWidget *hbox;
3691 GtkWidget *f1;
3692 GtkWidget *b1;
3693 GtkWidget *list;
3694 gchar *titles[5];
3695 GtkCList *clist;
3696 GtkWidget *e1;
3697 GtkWidget *l1;
3698 GtkWidget *tbl;
3699 GtkWidget *sep, *dummy;
3700 GtkWidget *scrolled_win;
3701
3702 /* prepare draw area */
3703 clear_actionspace();
3704
3705 f1 = gtk_frame_new(_("Devices-Setup"));
3706 set_font_and_color_frame(f1,BOLDFONT,NULL);
3707 gtk_box_pack_start(GTK_BOX(actionspace),f1,FALSE,FALSE,5);
3708 gtk_widget_show(f1);
3709
3710 tbl = gtk_table_new(1,16*4,TRUE);
3711 gtk_table_set_col_spacing(GTK_TABLE(tbl),4*4-1,5);
3712 gtk_table_set_col_spacing(GTK_TABLE(tbl),15*4-2,5);
3713 gtk_container_set_border_width(GTK_CONTAINER (tbl),5);
3714 gtk_container_add(GTK_CONTAINER(f1),tbl);
3715 gtk_widget_show(tbl);
3716
3717 devices_setup_image(0, tbl);
3718
3719 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3720 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 10);
3721 gtk_box_pack_start(GTK_BOX(actionspace),scrolled_win,TRUE,TRUE,0);
3722 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3723 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
3724 gtk_widget_show(scrolled_win);
3725
3726 titles[0] = "";
3727 titles[1] = _("Nr.");
3728 titles[2] = _("Track title");
3729 titles[3] = _("Length");
3730 titles[4] = _("Filename");
3731
3732 list = gtk_clist_new_with_titles(5,titles);
3733 gtk_container_add (GTK_CONTAINER (scrolled_win), list);
3734 gtk_widget_realize(list);
3735 clist = GTK_CLIST(list);
3736 imglist = clist;
3737 gtk_clist_set_column_auto_resize(clist, 4, TRUE);
3738 gtk_signal_connect(GTK_OBJECT(clist), "select_row",
3739 GTK_SIGNAL_FUNC(delete_select_row),NULL);
3740 gtk_signal_connect(GTK_OBJECT(clist), "unselect_row",
3741 GTK_SIGNAL_FUNC(delete_select_row),NULL);
3742
3743 gtk_clist_set_row_height(clist, tbf(20));
3744 gtk_clist_set_column_width(clist, 0, tbf(20));
3745 gtk_clist_set_column_width(clist, 1, tbf(30));
3746 gtk_clist_set_column_justification(clist, 1, GTK_JUSTIFY_CENTER);
3747 gtk_clist_set_column_width(clist, 2, tbf(250));
3748 gtk_clist_set_column_width(clist, 3, tbf(80));
3749 if (setupdata.option_selectionmode == 0) {
3750 gtk_clist_set_selection_mode (clist, GTK_SELECTION_MULTIPLE);
3751 } else {
3752 gtk_clist_set_selection_mode (clist, GTK_SELECTION_EXTENDED);
3753 }
3754 gtk_widget_show(list);
3755
3756 tbl = gtk_table_new(2,16,TRUE);
3757 gtk_table_set_row_spacings(GTK_TABLE(tbl),10);
3758 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
3759 gtk_box_pack_start(GTK_BOX(actionspace),tbl,FALSE,FALSE,10);
3760 gtk_widget_show(tbl);
3761
3762 l1 = rightjust_gtk_label_new(_("Size of selected tracks:"));
3763 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,6,0,1);
3764 gtk_widget_show(l1);
3765 e1 = gtk_entry_new();
3766 imglist_l1 = e1;
3767 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
3768 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,6,10,0,1);
3769 gtk_widget_show(e1);
3770
3771 l1 = rightjust_gtk_label_new(_("Free space:"));
3772 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,6,1,2);
3773 gtk_widget_show(l1);
3774 e1 = gtk_entry_new();
3775 imglist_l2 = e1;
3776 gtk_entry_set_editable(GTK_ENTRY(e1),FALSE);
3777 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,6,10,1,2);
3778 gtk_widget_show(e1);
3779
3780 sep = gtk_hseparator_new();
3781 gtk_box_pack_start(GTK_BOX(actionspace),sep,FALSE,FALSE,10);
3782 gtk_widget_show(sep);
3783
3784 /* button bar at the bottom */
3785 hbox = gtk_hbox_new(FALSE,5);
3786 gtk_box_pack_start(GTK_BOX(actionspace),hbox,FALSE,TRUE,0);
3787 gtk_widget_show(hbox);
3788
3789 b1 = gtk_button_new_with_label(_("Select all"));
3790 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
3791 gtk_widget_show(b1);
3792 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
3793 GTK_SIGNAL_FUNC(delete_select_all), NULL);
3794 define_tooltip(b1,_("Selects all displayed tracks."));
3795
3796 b1 = gtk_button_new_with_label(_("Select none"));
3797 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
3798 gtk_widget_show(b1);
3799 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
3800 GTK_SIGNAL_FUNC(delete_select_none), NULL);
3801 define_tooltip(b1,_("Deselects all tracks."));
3802
3803 dummy = gtk_label_new("");
3804 gtk_box_pack_start(GTK_BOX(hbox),dummy,FALSE,FALSE,10);
3805 gtk_widget_show(dummy);
3806
3807 b1 = gtk_button_new_with_label(_("Delete selected tracks"));
3808 gtk_box_pack_start(GTK_BOX(hbox),b1,TRUE,TRUE,10);
3809 gtk_widget_show(b1);
3810 gtk_signal_connect(GTK_OBJECT(b1),"clicked",
3811 GTK_SIGNAL_FUNC(do_delete_press), NULL);
3812 define_tooltip(b1,_("Deletes all selected Tracks. Hint: A doubleclick on a TOC-file in the list will select all tracks specified in it."));
3813
3814 gtk_widget_show(actionspace);
3815
3816 /* fill entries */
3817 fill_delete_menu();
3818 }
3819
3820
3821 /* unselects all buttons on the sidebar (except the one given)
3822 So there is always only one selected */
3823
reset_duplicate_buttons(GtkWidget * exclude)3824 static void reset_duplicate_buttons(GtkWidget *exclude) {
3825 int i;
3826
3827 for (i = 0; i < 7; i++) {
3828 if (side_widgets[i] != exclude) {
3829 gtk_signal_handler_block(GTK_OBJECT(side_widgets[i]),side_handlers[i]);
3830 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(side_widgets[i]),0);
3831 gtk_signal_handler_unblock(GTK_OBJECT(side_widgets[i]),side_handlers[i]);
3832 }
3833 }
3834
3835 /* because this is called whenever somebody clicks on a
3836 sidebar button, we can here check if the wav-player
3837 process from "play track" is still running, when the
3838 user quits this menu. So lets care here that it is
3839 terminated in a nice way */
3840
3841 if (wav_in != -1) {
3842 do_lock(0);
3843
3844 /* we want to quit the wavplayer.. */
3845 wavplay_quit = 1;
3846
3847 /* simulate quit-button-press */
3848 gtk_button_clicked(GTK_BUTTON(wav_quit_button));
3849
3850 /* now wait until we are really finished */
3851 while (wav_in != -1) {
3852 wait_and_process_events();
3853 }
3854
3855 /* now give gtk some extra time to initialize */
3856 for (i = 0; i < 3; i++) {
3857 wait_and_process_events();
3858 }
3859
3860 do_unlock(0);
3861 }
3862 }
3863
menu_duplicate_info(GtkWidget * widget,gpointer data)3864 static void menu_duplicate_info(GtkWidget *widget, gpointer data) {
3865
3866 /* if button already pressed ignore and undo click */
3867 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == 0) {
3868 gtk_signal_handler_block(GTK_OBJECT(widget),side_handlers[0]);
3869 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),1);
3870 gtk_signal_handler_unblock(GTK_OBJECT(widget),side_handlers[0]);
3871 return;
3872 }
3873 reset_duplicate_buttons(widget);
3874
3875 dolog(2, "Entering duplicate: info menu\n");
3876 draw_info_menu();
3877 }
3878
menu_duplicate_read(GtkWidget * widget,gpointer data)3879 static void menu_duplicate_read(GtkWidget *widget, gpointer data) {
3880
3881 /* if button already pressed ignore and undo click */
3882 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == 0) {
3883 gtk_signal_handler_block(GTK_OBJECT(widget),side_handlers[1]);
3884 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),1);
3885 gtk_signal_handler_unblock(GTK_OBJECT(widget),side_handlers[1]);
3886 return;
3887 }
3888 reset_duplicate_buttons(widget);
3889
3890 dolog(2, "Entering duplicate: read menu\n");
3891 draw_read_menu();
3892 }
3893
menu_duplicate_verify(GtkWidget * widget,gpointer data)3894 static void menu_duplicate_verify(GtkWidget *widget, gpointer data) {
3895
3896 /* if button already pressed ignore and undo click */
3897 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == 0) {
3898 gtk_signal_handler_block(GTK_OBJECT(widget),side_handlers[2]);
3899 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),1);
3900 gtk_signal_handler_unblock(GTK_OBJECT(widget),side_handlers[2]);
3901 return;
3902 }
3903 reset_duplicate_buttons(widget);
3904
3905 dolog(2, "Entering duplicate: verify menu\n");
3906 draw_verify_menu();
3907 }
3908
menu_duplicate_play(GtkWidget * widget,gpointer data)3909 static void menu_duplicate_play(GtkWidget *widget, gpointer data) {
3910
3911 /* if button already pressed ignore and undo click */
3912 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == 0) {
3913 gtk_signal_handler_block(GTK_OBJECT(widget),side_handlers[3]);
3914 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),1);
3915 gtk_signal_handler_unblock(GTK_OBJECT(widget),side_handlers[3]);
3916 return;
3917 }
3918 reset_duplicate_buttons(widget);
3919
3920 dolog(2, "Entering duplicate: play menu\n");
3921 draw_play_tracks_menu();
3922 }
3923
menu_duplicate_write(GtkWidget * widget,gpointer data)3924 static void menu_duplicate_write(GtkWidget *widget, gpointer data) {
3925
3926 /* if button already pressed ignore and undo click */
3927 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == 0) {
3928 gtk_signal_handler_block(GTK_OBJECT(widget),side_handlers[4]);
3929 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),1);
3930 gtk_signal_handler_unblock(GTK_OBJECT(widget),side_handlers[4]);
3931 return;
3932 }
3933 reset_duplicate_buttons(widget);
3934
3935 dolog(2, "Entering duplicate: write menu\n");
3936 draw_write_menu();
3937 }
3938
menu_duplicate_delete(GtkWidget * widget,gpointer data)3939 static void menu_duplicate_delete(GtkWidget *widget, gpointer data) {
3940
3941 /* if button already pressed ignore and undo click */
3942 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) == 0) {
3943 gtk_signal_handler_block(GTK_OBJECT(widget),side_handlers[5]);
3944 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),1);
3945 gtk_signal_handler_unblock(GTK_OBJECT(widget),side_handlers[5]);
3946 return;
3947 }
3948
3949 reset_duplicate_buttons(widget);
3950
3951 dolog(2, "Entering duplicate: delete menu\n");
3952 draw_delete_menu();
3953 }
3954
menu_duplicate_back(GtkWidget * widget,gpointer data)3955 static void menu_duplicate_back(GtkWidget *widget, gpointer data) {
3956
3957 reset_duplicate_buttons(widget);
3958 create_main(0);
3959 }
3960
3961
3962 /* called by the duplicate-button */
3963
create_duplicate()3964 void create_duplicate() {
3965 GtkWidget *side_t;
3966 GtkWidget *head,*head_l;
3967 GtkWidget *b1;
3968
3969 submenu = 1;
3970 clear_sidespace();
3971 clear_workspace();
3972
3973 side_t = gtk_table_new(10,1, TRUE);
3974 gtk_table_set_row_spacings(GTK_TABLE(side_t),10);
3975 gtk_box_pack_start(GTK_BOX(sidespace), side_t,TRUE,TRUE,0);
3976
3977 b1 = gtk_toggle_button_new_with_label(_("CD/Image Info"));
3978 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,1,2);
3979 /* preselect the first button */
3980 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(b1),1);
3981 gtk_widget_show(b1);
3982 side_handlers[0] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
3983 GTK_SIGNAL_FUNC(menu_duplicate_info),NULL);
3984 side_widgets[0] = b1;
3985 define_tooltip(b1,_("Displays information about the currently inserted CD and tracks stored on the harddrive."));
3986
3987 if (!curset.isProDVD) {
3988 b1 = gtk_toggle_button_new_with_label(_("Read CD"));
3989 } else {
3990 b1 = gtk_toggle_button_new_with_label(_("Read CD/DVD"));
3991 }
3992 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,2,3);
3993 gtk_widget_show(b1);
3994 side_handlers[1] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
3995 GTK_SIGNAL_FUNC(menu_duplicate_read),NULL);
3996 side_widgets[1] = b1;
3997 define_tooltip(b1,_("Reads all tracks of a CD and copy them to the harddrive."));
3998
3999 if (!curset.isProDVD) {
4000 b1 = gtk_toggle_button_new_with_label(_("Verify CD"));
4001 } else {
4002 b1 = gtk_toggle_button_new_with_label(_("Verify CD/DVD"));
4003 }
4004 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,3,4);
4005 gtk_widget_show(b1);
4006 side_handlers[2] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
4007 GTK_SIGNAL_FUNC(menu_duplicate_verify),NULL);
4008 side_widgets[2] = b1;
4009 define_tooltip(b1,_("Reads all tracks of a CD again and compares them with the tracks saved on the harddrive."));
4010
4011 b1 = gtk_toggle_button_new_with_label(_("Play Audio-Tracks"));
4012 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,4,5);
4013 gtk_widget_show(b1);
4014 side_handlers[3] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
4015 GTK_SIGNAL_FUNC(menu_duplicate_play),NULL);
4016 side_widgets[3] = b1;
4017 define_tooltip(b1,_("Plays audio tracks (.wav files) from the harddrive via soundcard."));
4018
4019 if (!curset.isProDVD) {
4020 b1 = gtk_toggle_button_new_with_label(_("Write CD"));
4021 } else {
4022 b1 = gtk_toggle_button_new_with_label(_("Write CD/DVD"));
4023 }
4024 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,5,6);
4025 gtk_widget_show(b1);
4026 side_handlers[4] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
4027 GTK_SIGNAL_FUNC(menu_duplicate_write),NULL);
4028 side_widgets[4] = b1;
4029 define_tooltip(b1,_("Writes tracks to a CD-R/RW. Will read the tracks from the harddrive or copies them on-the-fly from a CD in a CD-Reader."));
4030
4031 b1 = gtk_toggle_button_new_with_label(_("Delete Tracks"));
4032 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,6,7);
4033 gtk_widget_show(b1);
4034 side_handlers[5] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
4035 GTK_SIGNAL_FUNC(menu_duplicate_delete),NULL);
4036 side_widgets[5] = b1;
4037 define_tooltip(b1,_("Deletes saved Tracks from the harddrive to free up space."));
4038
4039 b1 = gtk_toggle_button_new_with_label(_("Back to main menu"));
4040 gtk_table_attach_defaults(GTK_TABLE(side_t), b1, 0,1,8,9);
4041 gtk_widget_show(b1);
4042 side_handlers[6] = gtk_signal_connect (GTK_OBJECT (b1), "clicked",
4043 GTK_SIGNAL_FUNC(menu_duplicate_back),NULL);
4044 side_widgets[6] = b1;
4045 define_tooltip(b1,_("Quits the duplicate menu and returns to the main menu."));
4046
4047 gtk_widget_show(side_t);
4048 gtk_widget_show(sidespace);
4049
4050 /* draw workspace */
4051
4052 head = gtk_frame_new(NULL);
4053 gtk_frame_set_shadow_type(GTK_FRAME(head),GTK_SHADOW_IN);
4054 gtk_widget_set_usize(head,0,45);
4055 gtk_box_pack_start(GTK_BOX(workspace), head,FALSE,FALSE,0);
4056 gtk_widget_show(head);
4057 head_l = gtk_label_new(_("Duplicate CD"));
4058 set_font_and_color(head_l,BIGFONT,NULL);
4059 gtk_container_add(GTK_CONTAINER(head),head_l);
4060 gtk_widget_show(head_l);
4061
4062 /* space where sub-windows are placed */
4063 actionspace = gtk_vbox_new(FALSE,0);
4064 gtk_box_pack_start(GTK_BOX(workspace), actionspace,TRUE,FALSE,0);
4065
4066 gtk_widget_show(workspace);
4067
4068 /* the default submenu for a start */
4069 draw_info_menu();
4070 }
4071
4072