1 /*
2 menus.c
3 27.3.99 tn
4 */
5
6 #ifdef HAVE_CONFIG_H
7 #include <config.h>
8 #endif
9
10 #define GTK_ENABLE_BROKEN
11
12 #include <gtk/gtk.h>
13 #if GTK_MAJOR_VERSION < 2
14 #include <gdk/gdk.h>
15 #include <gdk-pixbuf/gdk-pixbuf.h>
16 #endif
17
18 #include "largefile.h"
19
20 #if HAVE_LOCALE_H
21 #include <locale.h>
22 #else
23 # define setlocale(Category, Locale)
24 #endif
25 #include "gettext.h"
26
27 #include <stdio.h>
28 #include <sys/stat.h>
29 #include <unistd.h>
30 #include <string.h>
31 #include <strings.h>
32 #include <dirent.h>
33 #include <fcntl.h>
34 #include <sys/types.h>
35 #include <errno.h>
36 #include <ctype.h>
37
38 #if ENABLE_NLS
39 # define _(String) gettext (String)
40 # define N_(String) gettext_noop (String)
41 #else
42 # define _(String) (String)
43 # define N_(String) (String)
44 #endif
45
46 #include "xcdrdata.h"
47 #include "xcdroast.h"
48 #include "main.h"
49 #include "../xpms/treefolderopen.xpm"
50 #include "../xpms/treefolderclosed.xpm"
51 #include "../xpms/filesmall.xpm"
52 #include "../xpms/minidata.xpm"
53 #include "../xpms/miniaudio.xpm"
54 #include "../xpms/mininodata.xpm"
55
56 extern gint debug;
57 extern GtkWidget *toplevel;
58 extern GtkWidget *splitspace;
59 extern GtkWidget *sidespace;
60 extern GtkWidget *workspace;
61 extern GtkWidget *actionspace;
62 extern scsi_devices_t **scsidevices;
63 extern writer_driver_t **blankmodes;
64 extern setup_data_t setupdata;
65 extern master_param_t masterparam;
66 extern cd_info_t cdinfo;
67 extern track_info_t **trackinfo;
68 extern GList *imagelist;
69 extern current_set_t curset;
70 extern track_read_set_t trackreadset;
71 extern gint read_done;
72 extern GList *tocfiles;
73 extern gint read_abort_mark;
74 extern gchar sharedir[MAXLINE];
75 extern GtkWidget *cdlist_l1, *imglist_l2;
76 extern GtkCList *cdlist, *imglist2;
77 extern gchar configdir[MAXLINE];
78 extern GtkWidget *isoopts[24];
79 extern master_param_t masterparam;
80 extern GtkWidget *mkisofs_calc_timeout_dialog;
81 extern GdkFont *fixedfont;
82
83 GtkWidget *ctree_okbutton;
84 GtkWidget *cddb_info_label;
85 GtkCList *cddb_clist;
86 GtkWidget *viewmode_dialog;
87 GtkWidget *readtrack_info_label, *readtrack_textview;
88 GtkWidget *readtrack_pbar1, *readtrack_pbar2;
89 GtkWidget *readtrack_pbar3, *readtrack_pbar4, *readtrack_spd;
90 GtkWidget *readtrack_small_info, *readtrack_small_info2, *readtrack_info_tbl;
91 gint dialog_done, dialog_done2, dialog_done3;
92
93 static GtkWidget *ctree_window;
94 static GtkWidget *ctree_entry;
95 static gint ctree_showfiles, ctree_showhidden;
96 static GtkCTreeNode *parent_node, *lastactive_node;
97 static GtkCTree *ctree_base;
98 static gchar *ctree_basedir;
99 static GtkWidget *cddb_info_okbutton;
100 static GtkWidget *cddb_window;
101 static GtkWidget *readtrack_button, *readtrack_savebutton;
102 static GtkWidget *readtrack_info_frame;
103 static GdkPixmap *pixmap1, *pixmap2, *pixmap3;
104 static GdkBitmap *mask1, *mask2, *mask3;
105 static GtkWidget *viewmode_scrolled;
106 static GtkWidget *blank_infolabel;
107 static GtkWidget *blank_text_window;
108 static GtkWidget *redir_entry;
109 static gint misc_timer;
110 static GtkWidget *cdtext_entry1[MAXTRACKS+1];
111 static GtkWidget *cdtext_entry2[MAXTRACKS+1];
112 static GtkWidget *varirec_label, *varirec_scale;
113 static GtkWidget *isolevel_label, *isolevel_scale;
114
115 extern void writeoptions_selected(GtkWidget *item, gpointer nr);
116 extern void isooptions_selected(GtkWidget *item, gpointer nr);
117
118
119
dialog_delete_event(GtkWidget * widget,GdkEvent * event,gpointer data)120 static gint dialog_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) {
121
122 dialog_done = -1;
123 return(TRUE);
124 }
125
dialog_delete_event2(GtkWidget * widget,GdkEvent * event,gpointer data)126 static gint dialog_delete_event2(GtkWidget *widget, GdkEvent *event, gpointer data) {
127
128 dialog_done2 = -1;
129 return(TRUE);
130 }
131
dialog_delete_event3(GtkWidget * widget,GdkEvent * event,gpointer data)132 static gint dialog_delete_event3(GtkWidget *widget, GdkEvent *event, gpointer data) {
133
134 dialog_done3 = -1;
135 return(TRUE);
136 }
137
dialog_btn_press(GtkWidget * widget,gpointer data)138 static void dialog_btn_press(GtkWidget *widget, gpointer data) {
139
140 dialog_done = GPOINTER_TO_INT(data);
141 }
142
dialog_btn_press2(GtkWidget * widget,gpointer data)143 static void dialog_btn_press2(GtkWidget *widget, gpointer data) {
144
145 dialog_done2 = GPOINTER_TO_INT(data);
146 }
147
148
149 /* popup a modal window, set cursor to watch, return button pressed
150 or -1 when delete_event found.
151 Up to three buttons. Set unused buttons to NULL
152 Centers automatically above the toplevel-widow
153 if no toplevel window available center on display
154
155 specialcase: when defbutton -1, then dont set the window cursor
156
157 */
158
show_dialog(gchar * icon_file,gchar * ttext,gchar * btn1,gchar * btn2,gchar * btn3,gint defbutton)159 gint show_dialog(gchar *icon_file, gchar *ttext, gchar *btn1, gchar *btn2, gchar *btn3, gint defbutton) {
160 GtkWidget *dialog;
161 GtkWidget *button1;
162 GtkWidget *button2;
163 GtkWidget *button3;
164 GtkWidget *box1,*box2;
165 GtkWidget *b1_t,*b1_sep,*pix,*lab;
166 gint xpos, ypos;
167 gint xsize, ysize;
168 GdkCursor *cursor;
169 /* GtkStyle *style; */
170 GtkRequisition rq;
171 #if GTK_MAJOR_VERSION < 2
172 GdkPixbuf *im;
173 GdkPixmap *pixmap;
174 GdkBitmap *mask;
175 gchar tmp[MAXLINE];
176 #else
177 gchar *ico;
178 #endif
179 /* if another dialog is running, ignore */
180 if (dialog_done == 999) {
181 return -1;
182 }
183
184 dodebug(8, "displaying show_dialog: %s\n", ttext);
185
186 /* mark our dialog as running */
187 dialog_done = 999;
188
189 /* create new window and position it relative to the main window */
190 dialog = my_gtk_dialog_new();
191 set_xcdr_title(dialog, NULL, -1);
192 /* make sure our window is always on top */
193 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
194
195 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
196 GTK_SIGNAL_FUNC (dialog_delete_event), (gpointer) dialog);
197
198
199 /* create layout for dialog */
200 box1 = gtk_vbox_new(FALSE,0);
201 gtk_container_add(GTK_CONTAINER(dialog),box1);
202
203 b1_t = gtk_table_new(1,10, TRUE);
204 gtk_container_border_width(GTK_CONTAINER(b1_t),10);
205
206 gtk_box_pack_start(GTK_BOX(box1),b1_t,FALSE,TRUE,10);
207
208 /* realize table to be able to put a pixmap in it */
209 gtk_widget_realize(b1_t);
210
211 /* style = gtk_widget_get_style(b1_t);
212 pixmap = gdk_pixmap_create_from_xpm_d(b1_t->window, &mask,
213 &style->bg[GTK_STATE_NORMAL],(gchar **)icon_xpm);
214 */
215 #if GTK_MAJOR_VERSION < 2
216 g_snprintf(tmp,MAXLINE,"%s/%s", sharedir,icon_file);
217 dodebug(9, "dialog: trying to load %s\n", tmp);
218
219 im=gdk_pixbuf_new_from_file(tmp);
220 if (im) {
221 gdk_pixbuf_render_pixmap_and_mask(im, &pixmap, &mask, 128);
222 pix = gtk_pixmap_new(pixmap,mask);
223 gtk_table_attach_defaults(GTK_TABLE(b1_t), pix, 0,2,0,1);
224 gtk_widget_show(pix);
225 gdk_pixbuf_unref(im);
226 }
227 #else
228 ico = lookup_stock_icon(icon_file);
229 if (ico) {
230 pix = gtk_image_new_from_stock(ico, GTK_ICON_SIZE_DIALOG);
231 gtk_table_attach_defaults(GTK_TABLE(b1_t), pix, 0,2,0,1);
232 gtk_widget_show(pix);
233 }
234 #endif
235
236 lab = gtk_label_new(ttext);
237 gtk_table_attach_defaults(GTK_TABLE(b1_t), lab, 2,10,0,1);
238
239 b1_sep = gtk_hseparator_new();
240 gtk_box_pack_start(GTK_BOX(box1),b1_sep,FALSE,TRUE,0);
241
242 box2 = gtk_hbox_new(FALSE,0);
243 gtk_box_pack_start(GTK_BOX(box1),box2,FALSE,TRUE,10);
244
245 if (btn1 != NULL) {
246 button1 = gtk_button_new_with_label (btn1);
247 gtk_box_pack_start(GTK_BOX(box2),button1,TRUE,TRUE,10);
248 gtk_widget_show(button1);
249 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
250 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(0));
251 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
252 if (defbutton == 0) gtk_widget_grab_default (button1);
253 }
254 if (btn2 != NULL) {
255 button2 = gtk_button_new_with_label (btn2);
256 gtk_box_pack_start(GTK_BOX(box2),button2,TRUE,TRUE,10);
257 gtk_widget_show(button2);
258 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
259 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(1));
260 GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
261 if (defbutton == 1) gtk_widget_grab_default (button2);
262 }
263 if (btn3 != NULL) {
264 button3 = gtk_button_new_with_label (btn3);
265 gtk_box_pack_start(GTK_BOX(box2),button3,TRUE,TRUE,10);
266 gtk_widget_show(button3);
267 gtk_signal_connect(GTK_OBJECT(button3),"clicked",
268 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(2));
269 GTK_WIDGET_SET_FLAGS (button3, GTK_CAN_DEFAULT);
270 if (defbutton == 2) gtk_widget_grab_default (button3);
271 }
272
273 gtk_widget_show(box2);
274 gtk_widget_show(b1_sep);
275 gtk_widget_show(lab);
276 gtk_widget_show(b1_t);
277 gtk_widget_show(box1);
278
279
280 cursor = NULL;
281 /* grab cursor and change to watch */
282 if (GTK_WIDGET_MAPPED(toplevel)) {
283 gtk_grab_add(dialog);
284
285 if (defbutton != -1) {
286 cursor = gdk_cursor_new(GDK_WATCH);
287 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
288 dodebug(9, "showdialog: set cursor\n");
289 }
290 }
291
292 /* only center window when toplevel visible */
293 if ( GTK_WIDGET_VISIBLE(toplevel)) {
294 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
295 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
296 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
297 gtk_widget_size_request(dialog,&rq);
298 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
299 } else {
300 /* otherwise center in screen */
301 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
302 xsize = gdk_screen_width();
303 ysize = gdk_screen_height();
304 gtk_widget_size_request(dialog,&rq);
305 gtk_widget_set_uposition(GTK_WIDGET(dialog),xsize/2-rq.width/2,ysize/2-rq.height/2);
306
307 }
308
309 gtk_widget_show(dialog);
310
311 /* if this is a warning sound bell (if requested in setup) */
312 if (strcmp(icon_file, ICO_WARN) == 0) {
313 dobeep(2);
314 }
315
316 /* now wait until button is pressed */
317 while (dialog_done == 999) {
318 wait_and_process_events();
319 }
320
321 if (GTK_WIDGET_MAPPED(toplevel)) {
322 gtk_grab_remove(GTK_WIDGET(dialog));
323 if (defbutton != -1) {
324 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
325 if (cursor) gdk_cursor_destroy (cursor);
326 dodebug(9, "showdialog: restored cursor\n");
327 }
328 }
329
330 /* remove dialog window */
331 gtk_widget_destroy(dialog);
332
333 return dialog_done;
334 }
335
336
337 /* another version of the dialog -> with nice xcdroast logo on top */
338
show_fancy_dialog(gchar * htext,gchar * ttext,gchar * btn1)339 gint show_fancy_dialog(gchar *htext, gchar *ttext, gchar *btn1) {
340 GtkWidget *dialog, *xcdroast_logo, *vbox;
341 GdkPixbuf *im, *im2;
342 GdkPixmap *p;
343 GdkBitmap *m;
344 GtkWidget *button1;
345 GtkWidget *box1,*box2, *f1, *l1, *lab;
346 gint xpos, ypos;
347 gint xsize, ysize;
348 GdkCursor *cursor;
349 GtkRequisition rq;
350 gchar tmp[MAXLINE];
351
352 /* if another dialog is running, ignore */
353 if (dialog_done == 999) {
354 return -1;
355 }
356
357 dodebug(8, "displaying show_fancy_dialog: %s\n", ttext);
358
359 /* mark our dialog as running */
360 dialog_done = 999;
361
362 /* create new window and position it relative to the main window */
363 dialog = my_gtk_dialog_new();
364 set_xcdr_title(dialog, NULL, -1);
365 /* make sure our window is always on top */
366 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
367
368 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
369 GTK_SIGNAL_FUNC (dialog_delete_event), (gpointer) dialog);
370
371
372 /* create layout for dialog */
373 box1 = gtk_vbox_new(FALSE,0);
374 gtk_container_add(GTK_CONTAINER(dialog),box1);
375 gtk_widget_show(box1);
376
377 /* load the half scaled logo */
378 g_snprintf(tmp,MAXLINE,"%s/%s", sharedir, XCDRLOGO);
379 #if GTK_MAJOR_VERSION < 2
380 im=gdk_pixbuf_new_from_file(tmp);
381 #else
382 im=gdk_pixbuf_new_from_file(tmp,NULL);
383 #endif
384 if (im) {
385 im2 = gdk_pixbuf_scale_simple(im,
386 gdk_pixbuf_get_width(im)/2,
387 gdk_pixbuf_get_height(im)/2,
388 GDK_INTERP_TILES);
389 gdk_pixbuf_render_pixmap_and_mask(im2, &p, &m, 128);
390 xcdroast_logo = gtk_pixmap_new(p,m);
391 gdk_pixbuf_unref(im);
392 gdk_pixbuf_unref(im2);
393 } else {
394 xcdroast_logo = gtk_label_new("[LOGO]");
395 }
396 gtk_box_pack_start(GTK_BOX(box1),xcdroast_logo,FALSE,FALSE,0);
397 gtk_widget_show(xcdroast_logo);
398
399 g_snprintf(tmp,MAXLINE,_("Version %s"),XCDROAST_VERSION);
400 l1 = gtk_label_new(tmp);
401 gtk_label_set_justify(GTK_LABEL(l1),GTK_JUSTIFY_CENTER);
402 set_font_and_color(l1,NULL,"red");
403 gtk_box_pack_start(GTK_BOX(box1),l1,FALSE,FALSE,0);
404 gtk_widget_show(l1);
405
406 f1 = gtk_frame_new(NULL);
407 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
408 gtk_container_set_border_width(GTK_CONTAINER (f1),5);
409 gtk_widget_show(f1);
410
411 vbox = gtk_vbox_new(FALSE,0);
412 gtk_container_set_border_width(GTK_CONTAINER (vbox),10);
413 gtk_container_add(GTK_CONTAINER(f1),vbox);
414 gtk_widget_show(vbox);
415
416 /* print header text? */
417 if (htext) {
418 lab = gtk_label_new(htext);
419 set_font_and_color(lab,BOLDFONT,NULL);
420 gtk_label_set_justify(GTK_LABEL(lab),GTK_JUSTIFY_CENTER);
421 gtk_box_pack_start(GTK_BOX(vbox),lab,FALSE,FALSE,0);
422 gtk_widget_show(lab);
423 }
424
425 lab = gtk_label_new(ttext);
426 gtk_label_set_justify(GTK_LABEL(lab),GTK_JUSTIFY_CENTER);
427 gtk_box_pack_start(GTK_BOX(vbox),lab,FALSE,FALSE, 5);
428 gtk_widget_show(lab);
429
430 box2 = gtk_hbox_new(FALSE,0);
431 gtk_box_pack_start(GTK_BOX(box1),box2,FALSE,TRUE,10);
432 gtk_widget_show(box2);
433
434 if (btn1 != NULL) {
435 button1 = gtk_button_new_with_label (btn1);
436 gtk_box_pack_start(GTK_BOX(box2),button1,TRUE,TRUE,10);
437 gtk_widget_show(button1);
438 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
439 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(0));
440 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
441 gtk_widget_grab_default (button1);
442 }
443
444
445 cursor = NULL;
446 /* grab cursor and change to watch */
447 if (GTK_WIDGET_MAPPED(toplevel)) {
448 gtk_grab_add(dialog);
449
450 cursor = gdk_cursor_new(GDK_WATCH);
451 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
452 dodebug(9, "showdialog: set cursor\n");
453 }
454
455 /* only center window when toplevel visible */
456 if ( GTK_WIDGET_VISIBLE(toplevel)) {
457 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
458 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
459 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
460 gtk_widget_size_request(dialog,&rq);
461 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
462 } else {
463 /* otherwise center in screen */
464 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
465 xsize = gdk_screen_width();
466 ysize = gdk_screen_height();
467 gtk_widget_size_request(dialog,&rq);
468 gtk_widget_set_uposition(GTK_WIDGET(dialog),xsize/2-rq.width/2,ysize/2-rq.height/2);
469
470 }
471
472 gtk_widget_show(dialog);
473
474 /* now wait until button is pressed */
475 while (dialog_done == 999) {
476 wait_and_process_events();
477 }
478
479 if (GTK_WIDGET_MAPPED(toplevel)) {
480 gtk_grab_remove(GTK_WIDGET(dialog));
481 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
482 if (cursor) gdk_cursor_destroy (cursor);
483 dodebug(9, "showdialog: restored cursor\n");
484 }
485
486 /* remove dialog window */
487 gtk_widget_destroy(dialog);
488
489 return dialog_done;
490 }
491
492
493 /* clears the left sidebar */
494
clear_sidespace()495 void clear_sidespace() {
496
497 gtk_widget_destroy(sidespace);
498 sidespace = gtk_vbox_new(FALSE,0);
499 gtk_paned_add1(GTK_PANED(splitspace), sidespace);
500 set_sidebar_width();
501 }
502
503
504 /* clears the right workspace */
505
clear_workspace()506 void clear_workspace() {
507
508 gtk_widget_destroy(workspace);
509 workspace = gtk_vbox_new(FALSE,0);
510 gtk_paned_add2(GTK_PANED(splitspace), workspace);
511 }
512
513
514 /* clears the actionspace subwindow */
515
clear_actionspace()516 void clear_actionspace() {
517
518 gtk_widget_destroy(actionspace);
519 actionspace = gtk_vbox_new(FALSE,0);
520 gtk_box_pack_start(GTK_BOX(workspace), actionspace,TRUE,TRUE,0);
521
522 /* strange, why we need that...*/
523 while (gtk_events_pending())
524 gtk_main_iteration();
525
526 }
527
528
529 /* add subdirectory nodes to an existing ctree */
530
ctree_add_dir_nodes(gchar * path,GtkCTree * ctree,GtkCTreeNode * parent,gint showfiles,gint showhidden)531 static void ctree_add_dir_nodes(gchar *path, GtkCTree *ctree, GtkCTreeNode *parent, gint showfiles, gint showhidden) {
532 struct dirent *ent;
533 DIR *dir;
534 gchar *text[1];
535 gchar tmp[MAXLINE];
536 gchar tmp2[MAXLINE];
537 GtkCTreeNode *sibling;
538 gchar *textdata;
539 GList *dir_list;
540 GList *file_list;
541
542 dir_list = NULL;
543 file_list = NULL;
544 dir = opendir(path);
545
546 /* invalid directory */
547 if (dir == NULL)
548 return;
549
550 /* read entries */
551 while ( (ent = readdir(dir)) ) {
552
553 if (strcmp(ent->d_name,".") == 0 ||
554 strcmp(ent->d_name,"..") == 0)
555 continue;
556
557 if (!showhidden) {
558 /* skip files starting with a dot */
559 if (ent->d_name[0] == '.')
560 continue;
561 }
562
563 strcpy(tmp,path);
564 /* add slash when not there */
565 if (tmp[strlen(tmp)-1] != '/')
566 strcat(tmp,"/");
567 strcat(tmp,ent->d_name);
568
569 /* add only directories */
570 if (is_directory(tmp) == 1) {
571
572 dir_list = g_list_append(dir_list, g_strdup(ent->d_name));
573 } else {
574 if (showfiles)
575 file_list = g_list_append(file_list, g_strdup(ent->d_name));
576 }
577 }
578 closedir(dir);
579
580 /* sort the directory-list */
581 if (dir_list == NULL && showfiles == 0)
582 return;
583
584 sort_glist(dir_list);
585
586 /* sort the file-list */
587 if (file_list != NULL && showfiles) {
588 sort_glist(file_list);
589 }
590
591 /* draw entries */
592 while (dir_list) {
593 /* allocate directory names */
594 strncpy(tmp2, dir_list->data, MAXLINE);
595 convert_for_gtk2(tmp2);
596 text[0] = tmp2;
597
598 strcpy(tmp,path);
599 /* add slash when not there */
600 if (tmp[strlen(tmp)-1] != '/')
601 strcat(tmp,"/");
602 if ((strlen(tmp) + strlen(dir_list->data)) > MAXLINE-1) {
603 /* getting to long..writing dummy*/
604 strcat(tmp,"+");
605 } else {
606 strcat(tmp,dir_list->data);
607 }
608 textdata = g_strdup(tmp);
609
610
611 /* now check if there are subdirs in that dir */
612 if (is_subdirs(tmp)) {
613 sibling = gtk_ctree_insert_node (ctree,parent,
614 NULL,text,3,pixmap1,mask1,
615 pixmap2,mask2,FALSE,FALSE);
616
617 /* create dummy node */
618 gtk_ctree_insert_node (ctree,sibling,
619 NULL,text,3,NULL,NULL,NULL,NULL,TRUE,FALSE);
620 } else {
621 /* no subdirs */
622 if (!showfiles || !is_subfiles(tmp)) {
623 /* if do not show files, dont allow
624 changing into empty directory */
625 sibling = gtk_ctree_insert_node (ctree,parent,
626 NULL,text,3,pixmap1,mask1,
627 pixmap2,mask2,TRUE,FALSE);
628 } else {
629 /* let user browse directory */
630 sibling = gtk_ctree_insert_node (ctree,parent,
631 NULL,text,3,pixmap1,mask1,
632 pixmap2,mask2,FALSE,FALSE);
633 gtk_ctree_insert_node (ctree,sibling,
634 NULL,text,3,NULL,NULL,NULL,NULL,TRUE,FALSE);
635 }
636 }
637
638 /* save the full path name in the node-data */
639 gtk_ctree_node_set_row_data(ctree,sibling,textdata);
640
641 dir_list = dir_list->next;
642 }
643
644 /* add files */
645 while (file_list) {
646 strncpy(tmp2, file_list->data, MAXLINE);
647 convert_for_gtk2(tmp2);
648 text[0] = tmp2;
649
650 strcpy(tmp,path);
651 /* add slash when not there */
652 if (tmp[strlen(tmp)-1] != '/')
653 strcat(tmp,"/");
654 if ((strlen(tmp) + strlen(file_list->data)) > MAXLINE-1) {
655 /* getting to long..writing dummy*/
656 strcat(tmp,"+");
657 } else {
658 strcat(tmp,file_list->data);
659 }
660 textdata = g_strdup(tmp);
661
662 sibling = gtk_ctree_insert_node (ctree,parent,
663 NULL,text,3,pixmap3,mask3,
664 pixmap3,mask3,TRUE,FALSE);
665
666 /* save the full path name in the node-data */
667 gtk_ctree_node_set_row_data(ctree,sibling,textdata);
668
669 file_list = file_list->next;
670 }
671
672 /* free list */
673 free_glist(&dir_list);
674 free_glist(&file_list);
675 }
676
677
678 /* recursively remove all children of a node in a ctree */
679
ctree_remove_children(GtkCTree * tree,GtkCTreeNode * node)680 static void ctree_remove_children(GtkCTree * tree, GtkCTreeNode * node) {
681 GtkCTreeNode *child;
682 GList *sibling_list;
683 gchar *strpnt;
684
685 /* Get the child node and make sure it's not NULL. */
686 child = GTK_CTREE_ROW (node)->children;
687 if (child == NULL)
688 return;
689
690 /* Get the list of siblings. */
691 sibling_list = NULL;
692 for (; child; child = GTK_CTREE_ROW (child)->sibling)
693 sibling_list = g_list_append (sibling_list, child);
694
695 /* break out from recusion */
696 if (sibling_list == NULL)
697 return;
698
699 /* Remove all of the sibling nodes. */
700 gtk_clist_freeze (GTK_CLIST (tree));
701 for (; sibling_list; sibling_list = sibling_list->next) {
702
703 /* go recursive */
704 ctree_remove_children(tree, GTK_CTREE_NODE(sibling_list->data));
705
706 /* free allocated node-data */
707 strpnt = gtk_ctree_node_get_row_data (tree,
708 GTK_CTREE_NODE (sibling_list->data));
709 g_free(strpnt);
710
711 gtk_ctree_remove_node (tree,
712 GTK_CTREE_NODE (sibling_list->data));
713
714 }
715 gtk_clist_thaw (GTK_CLIST (tree));
716
717 /* Free up memory. */
718 g_list_free (g_list_first(sibling_list));
719
720 }
721
722
723 /* called when the users expands a directory in the ctree */
724
ctree_expand(GtkCTree * tree,GtkCTreeNode * node,gpointer data)725 static gint ctree_expand (GtkCTree *tree, GtkCTreeNode *node, gpointer data) {
726 gchar *newdir;
727 GdkCursor *clock_cursor;
728
729 /* fetch full path the node stands for */
730 newdir = gtk_ctree_node_get_row_data (tree, node);
731
732 /* save clicked node */
733 lastactive_node = node;
734
735 /* skip root-dir */
736 if (newdir == NULL) return TRUE;
737
738 clock_cursor = gdk_cursor_new (GDK_WATCH);
739 gdk_window_set_cursor (GTK_WIDGET (ctree_window)->window, clock_cursor);
740
741 /* gives gtk a break and time to update REALLY the cursor */
742 /* I dont think this slowes things down */
743 gtk_main_iteration_do(FALSE);
744
745 gtk_clist_freeze (GTK_CLIST (tree));
746
747 /* remove first everything and then add new nodes */
748 ctree_remove_children(tree,node);
749 ctree_add_dir_nodes(newdir,tree,node,ctree_showfiles,ctree_showhidden);
750
751 /* now scroll to position (OPTIONAL) */
752 /* gtk_ctree_node_moveto(tree,node,0,0.1,0); */
753
754 /* unfreeze and change cursor back */
755 gtk_clist_thaw (GTK_CLIST (tree));
756 gdk_window_set_cursor (GTK_WIDGET (ctree_window)->window, NULL);
757 gdk_cursor_destroy (clock_cursor);
758
759 return TRUE;
760 }
761
762
763 /* just save the last clicked node */
764
ctree_collapse(GtkCTree * tree,GtkCTreeNode * node,gpointer data)765 static gint ctree_collapse (GtkCTree *tree, GtkCTreeNode *node, gpointer data) {
766
767 /* save clicked node */
768 lastactive_node = node;
769
770 /* process default callback now */
771 return FALSE;
772 }
773
774 /* returns a list of the selected paths */
775 /* you have to free that list afterwards */
776
ctree_get_selected(GList ** retsel)777 void ctree_get_selected(GList **retsel) {
778 GList *sel;
779 GtkCList *clist;
780 GtkCTreeNode *lnode;
781 gchar *p;
782
783 clist = GTK_CLIST(ctree_base);
784 sel = clist->selection;
785 while (sel) {
786 lnode = sel->data;
787 p = gtk_ctree_node_get_row_data (ctree_base, lnode);
788 if (p) {
789 *retsel = g_list_append(*retsel, g_strdup(p));
790 }
791 sel = sel->next;
792 }
793 }
794
795
796 /* called when the user selects a row in a ctree */
797
ctree_select_row(GtkCTree * tree,GtkCTreeNode * node,gpointer data)798 static gint ctree_select_row (GtkCTree *tree, GtkCTreeNode *node, gpointer data) {
799 gchar *pnt;
800 GList *sel;
801 GtkCList *clist;
802 gint selcount;
803 gchar tmp[MAXLINE];
804 gchar tmp2[MAXLINE];
805
806 /* how many paths selected right now? */
807 clist = GTK_CLIST(tree);
808 sel = clist->selection;
809 selcount = g_list_length(sel);
810
811 pnt = gtk_ctree_node_get_row_data (tree, node);
812 if (selcount <= 1) {
813 if (pnt == NULL) {
814 /* no path set */
815 gtk_entry_set_text(GTK_ENTRY(ctree_entry),"");
816 if (ctree_okbutton)
817 gtk_widget_set_sensitive(ctree_okbutton,FALSE);
818 } else {
819 strncpy(tmp2, pnt, MAXLINE);
820 convert_for_gtk2(tmp2);
821 gtk_entry_set_text(GTK_ENTRY(ctree_entry),tmp2);
822 if (ctree_okbutton)
823 gtk_widget_set_sensitive(ctree_okbutton,TRUE);
824 }
825 } else {
826 /* more than one path selected */
827 g_snprintf(tmp,MAXLINE,_("(%d paths selected)"), selcount);
828 gtk_entry_set_text(GTK_ENTRY(ctree_entry),tmp);
829 if (ctree_okbutton)
830 gtk_widget_set_sensitive(ctree_okbutton,TRUE);
831 }
832
833 return TRUE;
834 }
835
836
837 /* called when the user unselects a row in a ctree */
838
ctree_unselect_row(GtkCTree * tree,GtkCTreeNode * node,gpointer data)839 static gint ctree_unselect_row (GtkCTree *tree, GtkCTreeNode *node, gpointer data) {
840 gchar *pnt;
841 GList *sel;
842 GtkCList *clist;
843 gint selcount;
844 gchar tmp[MAXLINE];
845 gchar tmp2[MAXLINE];
846
847 /* how many paths selected right now? */
848 clist = GTK_CLIST(tree);
849 sel = clist->selection;
850 selcount = g_list_length(sel);
851
852 if (selcount == 0) {
853 /* no path set */
854 gtk_entry_set_text(GTK_ENTRY(ctree_entry),"");
855 if (ctree_okbutton)
856 gtk_widget_set_sensitive(ctree_okbutton,FALSE);
857 } else
858 if (selcount == 1) {
859 pnt = gtk_ctree_node_get_row_data (tree, sel->data);
860 if (pnt) {
861 strncpy(tmp2, pnt, MAXLINE);
862 convert_for_gtk2(tmp2);
863 gtk_entry_set_text(GTK_ENTRY(ctree_entry),tmp2);
864 if (ctree_okbutton)
865 gtk_widget_set_sensitive(ctree_okbutton,TRUE);
866 }
867 } else {
868 /* more than one path selected */
869 g_snprintf(tmp,MAXLINE,_("(%d paths selected)"), selcount);
870 gtk_entry_set_text(GTK_ENTRY(ctree_entry),tmp);
871 if (ctree_okbutton)
872 gtk_widget_set_sensitive(ctree_okbutton,TRUE);
873 }
874
875 return TRUE;
876 }
877
878
879 /* unselect all in ctree */
880
ctree_unselect_all()881 void ctree_unselect_all() {
882
883 gtk_clist_unselect_all(GTK_CLIST(ctree_base));
884 gtk_entry_set_text(GTK_ENTRY(ctree_entry),"");
885 }
886
887
888 /* frees the ctree from memory */
889
ctree_cleanup()890 static void ctree_cleanup() {
891
892 ctree_remove_children(ctree_base,parent_node);
893 gtk_ctree_collapse_recursive(ctree_base, parent_node);
894 }
895
896
897 /* can be used to change the view mode (dirs only or with files) */
898 /* will collaps the tree to its base mode */
899
ctree_change_viewmode(gint showfiles,gint showhidden)900 void ctree_change_viewmode(gint showfiles, gint showhidden) {
901 gchar *text;
902 gchar tmp[MAXLINE];
903
904 /* do nothing if the state is the same */
905 if (showfiles == ctree_showfiles && showhidden == ctree_showhidden)
906 return;
907
908 /* remember the last touched node */
909 strcpy(tmp,"");
910 if (lastactive_node) {
911 text = gtk_ctree_node_get_row_data(ctree_base, lastactive_node);
912 if (text) {
913 strncpy(tmp,text,MAXLINE);
914 }
915 }
916
917 gtk_clist_freeze(GTK_CLIST(ctree_base));
918
919 ctree_showfiles = showfiles;
920 ctree_showhidden = showhidden;
921
922 /* collapse whole tree to ensure correct redraw */
923 ctree_remove_children(ctree_base,parent_node);
924 gtk_ctree_collapse_recursive(ctree_base, parent_node);
925
926 /* now redraw with correct setting */
927 ctree_add_dir_nodes(ctree_basedir,ctree_base,parent_node,
928 ctree_showfiles, ctree_showhidden);
929 gtk_ctree_expand(ctree_base,parent_node);
930
931 /* jump to last clicked position */
932 if (strcmp(tmp,"")) {
933 ctree_expand_manualpath(NULL, tmp);
934 }
935 gtk_clist_thaw(GTK_CLIST(ctree_base));
936
937 }
938
939
940 /* search current branch of ctree for a certain string */
941
ctree_search_nodes(GtkCTree * tree,GtkCTreeNode * node,gchar * cmpstr)942 static GtkCTreeNode *ctree_search_nodes(GtkCTree *tree, GtkCTreeNode *node,
943 gchar *cmpstr) {
944 GtkCTreeNode *child;
945 GList *sibling_list;
946 gchar *strpnt;
947
948 /* Get the child node and make sure it's not NULL. */
949 child = GTK_CTREE_ROW (node)->children;
950 if (child == NULL)
951 return NULL;
952
953 /* Get the list of siblings. */
954 sibling_list = NULL;
955 for (; child; child = GTK_CTREE_ROW (child)->sibling)
956 sibling_list = g_list_append (sibling_list, child);
957
958 for (; sibling_list; sibling_list = sibling_list->next) {
959 /* get data entry */
960 child = GTK_CTREE_NODE (sibling_list->data);
961 strpnt = gtk_ctree_node_get_row_data (tree, child);
962 if (strpnt && (strcmp(strpnt,cmpstr) == 0)) {
963 g_list_free (g_list_first(sibling_list));
964 return child;
965 }
966 }
967
968 /* nothing found */
969 g_list_free (g_list_first(sibling_list));
970 return NULL;
971 }
972
973
974 /* interprets a manual entered path and adopts the tree-listing */
975
ctree_expand_manualpath(GtkWidget * entry,gchar * altstring)976 void ctree_expand_manualpath(GtkWidget* entry, gchar *altstring) {
977 gchar *p1;
978 gchar path[MAXLINE];
979 gchar tmp[MAXLINE];
980 gchar tmp2[MAXLINE];
981 GtkCTreeNode *sibling, *node;
982
983 if (entry) {
984 strncpy(path,gtk_entry_get_text(GTK_ENTRY(entry)),MAXLINE);
985 convert_for_gtk2_filename(path);
986 } else {
987 if (altstring) {
988 strncpy(path, altstring, MAXLINE);
989 } else
990 return;
991 }
992
993 /* must begin with a slash */
994 if (path[0] != '/')
995 return;
996 if (strlen(path) > MAXLINE)
997 return;
998
999 /* walk through directory tree as if user clicked */
1000 sibling = parent_node;
1001 strcpy(tmp,path);
1002 strcpy(tmp2,"");
1003 p1 = strtok(tmp,"/");
1004 while (p1) {
1005 strcat(tmp2,"/");
1006 strcat(tmp2,p1);
1007
1008 /* now look in current sibling for a matching string */
1009 node = ctree_search_nodes(ctree_base, sibling, tmp2);
1010
1011 /* something found? */
1012 if (node) {
1013 /* now expand this node if possible */
1014 ctree_expand(ctree_base, node, NULL);
1015 gtk_ctree_expand(ctree_base,node);
1016 gtk_clist_unselect_all(GTK_CLIST(ctree_base));
1017
1018 /* select only if data from entry */
1019 if (entry)
1020 gtk_ctree_select(ctree_base,node);
1021
1022 /* now scroll to position */
1023 gtk_ctree_node_moveto(ctree_base,node,0,0.1,0);
1024
1025 /* prepare next level */
1026 sibling = node;
1027 }
1028
1029 p1 = strtok(NULL,"/");
1030 }
1031
1032 /* restore entry string */
1033 if (entry) {
1034 convert_for_gtk2(path);
1035 gtk_entry_set_text(GTK_ENTRY(entry),path);
1036 }
1037 }
1038
1039
1040 /* return the current selected directories via drag & drop */
1041
ctree_request_dnddata(GtkWidget * widget,GdkDragContext * dc,GtkSelectionData * selection_data,guint info,guint t,gpointer data)1042 static void ctree_request_dnddata(GtkWidget *widget, GdkDragContext *dc,
1043 GtkSelectionData *selection_data, guint info, guint t,
1044 gpointer data) {
1045 gboolean data_sent = FALSE;
1046 gint focusrow, bufcount;
1047 GtkCTree *ctree;
1048 GtkCList *clist;
1049 GtkCTreeNode *focusnode, *lnode;
1050 GList *sel;
1051 gchar *text;
1052 gint use_selection;
1053 gchar tmp[MAXLINE];
1054 gchar bigtmp[MAXLINE*10];
1055
1056 use_selection = 0;
1057 ctree = GTK_CTREE(widget);
1058
1059 /* Get the focused row on the clist (we clicked on it) */
1060 clist = GTK_CLIST(ctree);
1061 focusrow = clist->focus_row;
1062 focusnode = gtk_ctree_node_nth(ctree, focusrow);
1063
1064 /* see if any other rows are selected */
1065 sel = clist->selection;
1066 while (sel) {
1067 lnode = sel->data;
1068 if (lnode == focusnode) {
1069 /* we focused a row that is selected, remember */
1070 use_selection = 1;
1071 }
1072 sel = sel->next;
1073 }
1074
1075 /* Selected row in bounds? */
1076 if ((focusrow >= 0) && (focusrow < clist->rows)) {
1077
1078 /* return single directory from focused line */
1079 if (use_selection == 0) {
1080 /* determine what node got focus */
1081 lnode = gtk_ctree_node_nth(ctree, focusrow);
1082 text = gtk_ctree_node_get_row_data(ctree, lnode);
1083
1084 if (text) {
1085 g_snprintf(tmp,MAXLINE,"file:%s", text);
1086 gtk_selection_data_set(
1087 selection_data,
1088 GDK_SELECTION_TYPE_STRING, 8,
1089 (const unsigned char *) tmp, strlen(tmp));
1090 data_sent = TRUE;
1091 }
1092 } else {
1093 /* return not from focus but all selected */
1094 strcpy(bigtmp,"");
1095 bufcount = 0;
1096 sel = clist->selection;
1097 while (sel) {
1098 lnode = sel->data;
1099 if (lnode) {
1100 text = gtk_ctree_node_get_row_data(ctree, lnode);
1101 if (text) {
1102 g_snprintf(tmp,MAXLINE,"file:%s\r\n", text);
1103
1104 bufcount+=strlen(tmp);
1105 if (bufcount < MAXLINE*10) {
1106 strcat(bigtmp,tmp);
1107 }
1108 }
1109 }
1110 sel = sel->next;
1111 }
1112 if (bufcount > 0) {
1113 gtk_selection_data_set(
1114 selection_data,
1115 GDK_SELECTION_TYPE_STRING, 8,
1116 (const unsigned char *) bigtmp, strlen(bigtmp));
1117 data_sent = TRUE;
1118 }
1119 }
1120 }
1121
1122 /* we have to send something even in an error case */
1123 if (!data_sent) {
1124 const gchar *cstrptr = "Error";
1125
1126 gtk_selection_data_set(
1127 selection_data,
1128 GDK_SELECTION_TYPE_STRING, 8,
1129 (const unsigned char *) cstrptr, strlen(cstrptr));
1130 }
1131 }
1132
1133
1134 /* we received a drag on the ctree */
1135
ctree_drag_received(GtkWidget * widget,GdkDragContext * dc,gint x,gint y,GtkSelectionData * selection_data,guint info,guint t,gpointer data)1136 static void ctree_drag_received(GtkWidget *widget,
1137 GdkDragContext *dc, gint x, gint y, GtkSelectionData *selection_data,
1138 guint info, guint t, gpointer data) {
1139 gchar *text;
1140 gchar newdir[MAXLINE];
1141 gint mastermenu;
1142 GList *input;
1143
1144 input = NULL;
1145 mastermenu = GPOINTER_TO_INT(data);
1146
1147 /* nothing received? ignore */
1148 if(selection_data == NULL)
1149 return;
1150 if(selection_data->length < 0)
1151 return;
1152
1153 if ((info == DRAG_TAR_INFO_0) ||
1154 (info == DRAG_TAR_INFO_1) ||
1155 (info == DRAG_TAR_INFO_2)) {
1156 text = (char *) selection_data->data;
1157
1158 /* this drag was received in the master menu file tree */
1159 if (mastermenu) {
1160 /* check if it was a remove operation */
1161 if (extract_glist_drag_filenames(text, selection_data->length, "xrmv:", &input)) {
1162 /* handle the remove from the master path list */
1163 remove_master_dir_by_drag(input);
1164
1165 free_glist(&input);
1166 return;
1167 }
1168 }
1169 if (extract_single_drag_filename(text, selection_data->length, newdir)) {
1170 /* extracted the plain filename from drag */
1171 if (strcmp(newdir,"") != 0) {
1172 dodebug(3,"Received from drag: %s\n", newdir);
1173 convert_for_gtk2(newdir);
1174 gtk_entry_set_text(GTK_ENTRY(ctree_entry), newdir);
1175 /* scroll to received path */
1176 ctree_expand_manualpath(ctree_entry, NULL);
1177 }
1178 }
1179 }
1180 }
1181
1182
1183 /* creates a ctree for directory browsing */
1184
create_directory_ctree(gchar * basedir,gchar * title,GtkWidget * win,GtkWidget * entry,gint showfiles,gint showhidden,gint mastermenu)1185 GtkCTree *create_directory_ctree(gchar *basedir,gchar *title, GtkWidget *win, GtkWidget *entry, gint showfiles, gint showhidden, gint mastermenu) {
1186 gchar tmp[MAXLINE];
1187 GtkCTree *ctree;
1188 GtkCTreeNode *parent;
1189 gchar *titles[1];
1190 gchar *text[1];
1191 GtkStyle *style;
1192 GtkTargetEntry target_entry[3];
1193
1194 target_entry[0].target = DRAG_TAR_NAME_0;
1195 target_entry[0].flags = 0;
1196 target_entry[0].info = DRAG_TAR_INFO_0;
1197 target_entry[1].target = DRAG_TAR_NAME_1;
1198 target_entry[1].flags = 0;
1199 target_entry[1].info = DRAG_TAR_INFO_1;
1200 target_entry[2].target = DRAG_TAR_NAME_2;
1201 target_entry[2].flags = 0;
1202 target_entry[2].info = DRAG_TAR_INFO_2;
1203
1204 /* save the parent window for cursor handling */
1205 ctree_window = win;
1206 ctree_entry = entry;
1207 ctree_showfiles = showfiles;
1208 ctree_showhidden = showhidden;
1209 ctree_basedir = basedir;
1210
1211 lastactive_node = NULL;
1212
1213 /* do we want a title? */
1214 if (title == NULL) {
1215 ctree = GTK_CTREE (gtk_ctree_new (1, 0));
1216 } else {
1217 titles[0] = title;
1218 ctree = GTK_CTREE (gtk_ctree_new_with_titles (1, 0, titles));
1219 }
1220 ctree_base = ctree;
1221 gtk_clist_set_row_height(GTK_CLIST(ctree),tbf(16));
1222
1223 /* create folder pixmaps */
1224 style = gtk_widget_get_style(GTK_WIDGET(ctree));
1225 pixmap1 = gdk_pixmap_create_from_xpm_d(win->window,
1226 &mask1,&style->bg[GTK_STATE_NORMAL],
1227 (gchar **) treefolderclosed_xpm);
1228 pixmap2 = gdk_pixmap_create_from_xpm_d(win->window,
1229 &mask2,&style->bg[GTK_STATE_NORMAL],
1230 (gchar **) treefolderopen_xpm);
1231 pixmap3 = gdk_pixmap_create_from_xpm_d(win->window,
1232 &mask3,&style->bg[GTK_STATE_NORMAL],
1233 (gchar **) filesmall_xpm);
1234
1235 /* connect our signal stuff */
1236 gtk_signal_connect(GTK_OBJECT(ctree),"tree_expand",
1237 GTK_SIGNAL_FUNC(ctree_expand),NULL);
1238 gtk_signal_connect(GTK_OBJECT(ctree),"tree_collapse",
1239 GTK_SIGNAL_FUNC(ctree_collapse),NULL);
1240 gtk_signal_connect(GTK_OBJECT(ctree),"tree_select_row",
1241 GTK_SIGNAL_FUNC(ctree_select_row),NULL);
1242 gtk_signal_connect(GTK_OBJECT(ctree),"tree_unselect_row",
1243 GTK_SIGNAL_FUNC(ctree_unselect_row),NULL);
1244
1245 /* setup drag&drop */
1246 if (!GTK_WIDGET_NO_WINDOW(GTK_WIDGET(ctree))) {
1247 /* we can drag out of the tree */
1248 gtk_drag_source_set(
1249 GTK_WIDGET(ctree),
1250 GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
1251 target_entry,
1252 sizeof(target_entry) / sizeof(GtkTargetEntry),
1253 GDK_ACTION_MOVE | GDK_ACTION_COPY);
1254 gtk_signal_connect(
1255 GTK_OBJECT(ctree), "drag_data_get",
1256 GTK_SIGNAL_FUNC(ctree_request_dnddata), NULL);
1257
1258 /* and we can receive drags */
1259 gtk_drag_dest_set(GTK_WIDGET(ctree), GTK_DEST_DEFAULT_MOTION |
1260 GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
1261 target_entry, sizeof(target_entry) / sizeof(GtkTargetEntry),
1262 GDK_ACTION_COPY | GDK_ACTION_MOVE);
1263 gtk_signal_connect(GTK_OBJECT(ctree), "drag_data_received",
1264 GTK_SIGNAL_FUNC(ctree_drag_received), GINT_TO_POINTER(mastermenu));
1265 }
1266
1267 /* make root entry in clist */
1268 strcpy(tmp,basedir);
1269 convert_for_gtk2(tmp);
1270 text[0]=tmp;
1271 parent = gtk_ctree_insert_node (ctree,NULL,
1272 NULL,text,3,pixmap1,mask1,pixmap2,mask2,FALSE,TRUE);
1273 gtk_ctree_node_set_row_data(ctree,parent,g_strdup(basedir));
1274 parent_node = parent;
1275
1276 ctree_add_dir_nodes(basedir,ctree,parent,
1277 ctree_showfiles,ctree_showhidden);
1278
1279 return ctree;
1280 }
1281
1282
show_dir_btn_press(GtkWidget * widget,gpointer data)1283 static void show_dir_btn_press(GtkWidget *widget, gpointer data) {
1284
1285 dialog_done = GPOINTER_TO_INT(data);
1286 }
1287
1288
1289 /* popup a modal window, set cursor to watch, return path or NULL-string
1290 when cancel or delete_event found.
1291 Centers automatically above the toplevel-widow
1292 */
1293
show_dir_tree(gchar * retvalue)1294 void show_dir_tree(gchar *retvalue) {
1295 GtkWidget *dialog;
1296 GtkWidget *button1;
1297 GtkWidget *button2;
1298 GtkWidget *box1,*box2,*box3;
1299 GtkWidget *entry1,*b1_sep;
1300 GtkWidget *scrolled_win;
1301 gchar base_tree[MAXLINE];
1302 gchar *p;
1303 GtkCTree *ctree;
1304 gint xpos, ypos;
1305 gint xsize, ysize;
1306 GdkCursor *cursor;
1307 GtkRequisition rq;
1308
1309 /* if another dialog is running, ignore */
1310 if (dialog_done == 999) {
1311 return;
1312 }
1313
1314 dodebug(8, "displaying show_dir_tree\n");
1315
1316 /* mark our dialog as running */
1317 dialog_done = 999;
1318
1319 /* create new window and position it relative to the main window */
1320 dialog = my_gtk_dialog_new();
1321 set_xcdr_title(dialog, NULL, -1);
1322 gtk_widget_set_usize(dialog,tbf(350),tbf(300));
1323 /* make sure our window is always on top */
1324 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
1325
1326 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
1327 GTK_SIGNAL_FUNC (dialog_delete_event), (gpointer) dialog);
1328
1329 /* create layout for dialog */
1330 box1 = gtk_vbox_new(FALSE,0);
1331 gtk_container_add(GTK_CONTAINER(dialog),box1);
1332
1333 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1334 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
1335 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1336 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1337 gtk_box_pack_start(GTK_BOX(box1),scrolled_win,TRUE,TRUE,0);
1338 gtk_widget_realize(scrolled_win);
1339 gtk_widget_show(scrolled_win);
1340
1341 box3 = gtk_hbox_new(FALSE,0);
1342 gtk_box_pack_start(GTK_BOX(box1),box3,FALSE,TRUE,10);
1343 entry1 = gtk_entry_new();
1344 gtk_entry_set_editable(GTK_ENTRY(entry1),FALSE);
1345 gtk_box_pack_start(GTK_BOX(box3),entry1,TRUE,TRUE,10);
1346 gtk_widget_show(entry1);
1347
1348 /* special case, use homedir as filetree base? */
1349 if (strcmp(FILETREEBASE,"$HOME") == 0) {
1350 p = get_pw_home((gint)geteuid());
1351 if (p) {
1352 strncpy(base_tree, p, MAXLINE);
1353 } else {
1354 /* fallback in case user got no home dir? */
1355 strncpy(base_tree, "/tmp", MAXLINE);
1356 }
1357 } else {
1358 strncpy(base_tree, FILETREEBASE, MAXLINE);
1359 }
1360
1361 ctree = create_directory_ctree(base_tree,_("Select Directory"),dialog,entry1,0,1,0);
1362 gtk_clist_set_column_auto_resize(GTK_CLIST(ctree),0,TRUE);
1363 gtk_clist_set_selection_mode (GTK_CLIST(ctree), GTK_SELECTION_BROWSE);
1364
1365 gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (ctree));
1366 gtk_widget_show( GTK_WIDGET (ctree));
1367
1368 gtk_widget_show(box3);
1369 gtk_widget_show(box1);
1370
1371 b1_sep = gtk_hseparator_new();
1372 gtk_box_pack_start(GTK_BOX(box1),b1_sep,FALSE,TRUE,0);
1373 gtk_widget_show(b1_sep);
1374
1375 box2 = gtk_hbox_new(FALSE,0);
1376 gtk_box_pack_start(GTK_BOX(box1),box2,FALSE,TRUE,10);
1377 gtk_widget_show(box2);
1378
1379 button1 = gtk_button_new_with_label(T_OK);
1380 ctree_okbutton = button1;
1381 gtk_box_pack_start(GTK_BOX(box2),button1,TRUE,TRUE,10);
1382 gtk_widget_show(button1);
1383 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
1384 gtk_widget_set_sensitive(button1,FALSE);
1385 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
1386 GTK_SIGNAL_FUNC(show_dir_btn_press), GINT_TO_POINTER(0));
1387
1388 button2 = gtk_button_new_with_label(T_CANCEL);
1389 gtk_box_pack_start(GTK_BOX(box2),button2,TRUE,TRUE,10);
1390 gtk_widget_show(button2);
1391 GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
1392 gtk_widget_grab_default (button2);
1393 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
1394 GTK_SIGNAL_FUNC(show_dir_btn_press), GINT_TO_POINTER(-1));
1395
1396
1397 /* grab cursor and change to watch */
1398 gtk_grab_add(dialog);
1399 cursor = gdk_cursor_new(GDK_WATCH);
1400 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
1401
1402 /* only center window when toplevel visible */
1403 if ( GTK_WIDGET_VISIBLE(toplevel)) {
1404 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
1405 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
1406 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
1407 gtk_widget_size_request(dialog,&rq);
1408 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
1409 }
1410
1411 gtk_widget_show(dialog);
1412
1413
1414 /* now wait until button is pressed */
1415 while (dialog_done == 999) {
1416 wait_and_process_events();
1417 }
1418
1419 gtk_grab_remove(GTK_WIDGET(dialog));
1420 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
1421 gdk_cursor_destroy (cursor);
1422
1423 if (dialog_done != -1) {
1424 strcpy(retvalue,gtk_entry_get_text(GTK_ENTRY(entry1)));
1425 convert_for_gtk2_filename(retvalue);
1426 } else {
1427 /* cancel or delete_event */
1428 strcpy(retvalue,"");
1429 }
1430
1431 /* free ctree */
1432 ctree_cleanup();
1433 ctree_okbutton = NULL;
1434
1435 /* remove dialog window */
1436 gtk_widget_destroy(dialog);
1437 }
1438
1439
1440 /* fileselector-box ok-button callback */
1441
file_selector_ok(GtkWidget * widget,GtkFileSelection * fs)1442 static void file_selector_ok(GtkWidget *widget, GtkFileSelection *fs) {
1443
1444 dialog_done3 = 1;
1445 }
1446
1447
1448 /* display a file-selector box with defname preselected. Return ""
1449 or filename in retvalue */
1450
show_file_selector(gchar * title,gchar * defname,gchar * retvalue)1451 void show_file_selector(gchar *title, gchar *defname, gchar *retvalue) {
1452 GtkWidget *dialog;
1453 gint xpos, ypos;
1454 gint xsize, ysize;
1455 GdkCursor *cursor;
1456 GtkRequisition rq;
1457 GtkButton *b1;
1458 #if GTK_MAJOR_VERSION < 2
1459 GtkCList *dirs;
1460 #else
1461 /*
1462 GtkTreeView *dirs;
1463 GtkTreeViewColumn *col;
1464 */
1465 #endif
1466 /* if another dialog is running, ignore */
1467 if (dialog_done3 == 999) {
1468 return;
1469 }
1470
1471 dodebug(8, "displaying show_fileselector\n");
1472
1473 /* mark our dialog as running */
1474 dialog_done3 = 999;
1475
1476 /* create new window and position it relative to the main window */
1477 dialog = gtk_file_selection_new (title);
1478 /* make sure our window is always on top */
1479 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
1480
1481 gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(dialog));
1482 if (defname != NULL) {
1483 gtk_file_selection_set_filename(GTK_FILE_SELECTION(dialog),
1484 defname);
1485 }
1486
1487 /* translate the default-texts on the selector */
1488 b1 = GTK_BUTTON(GTK_FILE_SELECTION(dialog)->ok_button);
1489 #if GTK_MAJOR_VERSION < 2
1490 gtk_label_set_text(GTK_LABEL(b1->child),T_OK);
1491 #else
1492 gtk_button_set_label(GTK_BUTTON(b1),T_OK);
1493 #endif
1494 b1 = GTK_BUTTON(GTK_FILE_SELECTION(dialog)->cancel_button);
1495 #if GTK_MAJOR_VERSION < 2
1496 gtk_label_set_text(GTK_LABEL(b1->child),T_CANCEL);
1497 #else
1498 gtk_button_set_label(GTK_BUTTON(b1),T_CANCEL);
1499 #endif
1500
1501 #if GTK_MAJOR_VERSION < 2
1502 dirs = GTK_CLIST(GTK_FILE_SELECTION(dialog)->dir_list);
1503 gtk_clist_set_column_title(dirs,0,_("Directories"));
1504 #else
1505 /*
1506 dirs = GTK_TREE_VIEW(GTK_FILE_SELECTION(dialog)->dir_list);
1507 col = gtk_tree_view_get_column(dirs, 0);
1508 gtk_tree_view_column_set_title(col, _("Directories"));
1509 */
1510 #endif
1511
1512 #if GTK_MAJOR_VERSION < 2
1513 dirs = GTK_CLIST(GTK_FILE_SELECTION(dialog)->file_list);
1514 gtk_clist_set_column_title(dirs,0,_("Files"));
1515 #else
1516 /*
1517 dirs = GTK_TREE_VIEW(GTK_FILE_SELECTION(dialog)->file_list);
1518 col = gtk_tree_view_get_column(dirs, 0);
1519 gtk_tree_view_column_set_title(col, _("Files"));
1520 */
1521 #endif
1522
1523 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
1524 GTK_SIGNAL_FUNC (dialog_delete_event3), dialog);
1525
1526 gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(dialog)->ok_button),
1527 "clicked", GTK_SIGNAL_FUNC(file_selector_ok), dialog);
1528
1529 gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(dialog)->cancel_button),
1530 "clicked", GTK_SIGNAL_FUNC(dialog_delete_event3), dialog);
1531
1532
1533 /* grab cursor and change to watch */
1534 gtk_grab_add(dialog);
1535 cursor = gdk_cursor_new(GDK_WATCH);
1536 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
1537
1538 /* only center window when toplevel visible */
1539 if ( GTK_WIDGET_VISIBLE(toplevel)) {
1540 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
1541 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
1542 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
1543 gtk_widget_size_request(dialog,&rq);
1544 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
1545 }
1546
1547 /* center does not work with gtk-1.2.1, but ok with 1.2.3, well
1548 what the heck... */
1549
1550 gtk_widget_show(dialog);
1551
1552
1553 /* now wait until button is pressed */
1554 while (dialog_done3 == 999) {
1555 wait_and_process_events();
1556 }
1557
1558 gtk_grab_remove(GTK_WIDGET(dialog));
1559 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
1560 gdk_cursor_destroy (cursor);
1561
1562 if (dialog_done3 != -1) {
1563 strcpy(retvalue,gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog)));
1564 } else {
1565 /* cancel or delete_event */
1566 strcpy(retvalue,"");
1567 }
1568
1569 /* remove dialog window */
1570 gtk_widget_destroy(dialog);
1571 }
1572
1573
1574 /* what to do when user selects a CD from the database */
1575
cddb_select_row(GtkWidget * clist,gint row,gint col,GdkEventButton * event,gpointer data)1576 static void cddb_select_row(GtkWidget *clist, gint row, gint col,
1577 GdkEventButton *event, gpointer data) {
1578
1579 /* we selected something, unlook ok-button */
1580 gtk_widget_set_sensitive(cddb_info_okbutton,TRUE);
1581
1582 /* got double-click? Simulate ok-button-press */
1583 if (event && event->type == GDK_2BUTTON_PRESS) {
1584 gtk_button_clicked(GTK_BUTTON(cddb_info_okbutton));
1585 }
1586 }
1587
1588
1589 /* called from cancel or ok button */
1590
show_cddb_btn_press(GtkWidget * widget,gpointer data)1591 static void show_cddb_btn_press(GtkWidget *widget, gpointer data) {
1592 GList *sel;
1593 gint row;
1594
1595 /* cancel event */
1596 if (GPOINTER_TO_INT(data) == -1) {
1597 if (read_done == 999) {
1598 /* abort our cddb-process */
1599 kill_readcdda();
1600 }
1601 dialog_done = -1;
1602 return;
1603 }
1604
1605 /* ok button pressed - find out which entry was selected */
1606 sel = cddb_clist->selection;
1607 if (sel != NULL) {
1608 row = GPOINTER_TO_INT(sel->data);
1609 /* now go back to network code and fetch fitting CD */
1610 if (continue_cddb_lookup_action(row) != 0) {
1611 /* disable ok-button */
1612 gtk_widget_set_sensitive(cddb_info_okbutton,FALSE);
1613 } else {
1614 /* data ok received */
1615 dialog_done = 0;
1616 }
1617 }
1618 }
1619
1620
1621 /* called when somebody closes the cddb-window via window-manager */
1622
dialog_cddb_delete_event(GtkWidget * widget,GdkEvent * event,gpointer data)1623 static gint dialog_cddb_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) {
1624
1625 if (read_done == 999) {
1626 /* abort our cddb-process */
1627 kill_readcdda();
1628 }
1629 dialog_done = -1;
1630 return(TRUE);
1631 }
1632
1633
1634 /* popup a modal window, set cursor to watch, return 0 if correct
1635 data was received from cddb-server, -1 if not or
1636 when cancel or delete_event found.
1637 Centers automatically above the toplevel-widow
1638 */
1639
show_cddb_query(GtkWidget * cdtext_parent,gint onthefly)1640 gint show_cddb_query(GtkWidget *cdtext_parent, gint onthefly) {
1641 GtkWidget *dialog;
1642 GtkWidget *button1;
1643 GtkWidget *button2;
1644 GtkWidget *box1,*box2,*hbox;
1645 GtkWidget *f1, *cddb_logo;
1646 GdkPixmap *p;
1647 GdkBitmap *m;
1648 GdkPixbuf *im;
1649 GtkWidget *b1_sep, *lbl;
1650 GtkWidget *scrolled_win, *c_list;
1651 GtkCList *clist;
1652 gchar *titles[1];
1653 gint xpos, ypos;
1654 gint xsize, ysize;
1655 GdkCursor *cursor;
1656 GtkRequisition rq;
1657 gchar tmp[MAXLINE];
1658
1659 /* if another dialog is running, ignore */
1660 if (dialog_done == 999) {
1661 return -1;
1662 }
1663
1664 dodebug(8, "displaying show_cddb_query\n");
1665
1666 /* mark our dialog as running */
1667 dialog_done = 999;
1668
1669 /* create new window and position it relative to the main window */
1670 dialog = my_gtk_dialog_new();
1671 set_xcdr_title(dialog, NULL, -1);
1672 gtk_widget_set_usize(dialog,tbf(450),tbf(260));
1673 /* make sure our window is always on top */
1674 if (cdtext_parent) {
1675 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(cdtext_parent));
1676 } else {
1677 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
1678 }
1679 cddb_window = dialog;
1680
1681 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
1682 GTK_SIGNAL_FUNC (dialog_cddb_delete_event), (gpointer) dialog);
1683
1684 /* create layout for dialog */
1685 box1 = gtk_vbox_new(FALSE,5);
1686 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
1687 gtk_container_add(GTK_CONTAINER(dialog),box1);
1688
1689 hbox = gtk_hbox_new(FALSE,0);
1690 gtk_box_pack_start(GTK_BOX(box1),hbox,FALSE,TRUE,5);
1691 gtk_widget_show(hbox);
1692
1693 f1 = gtk_frame_new(NULL);
1694 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_IN);
1695 gtk_box_pack_start(GTK_BOX(hbox),f1,TRUE,TRUE,5);
1696 gtk_widget_show(f1);
1697
1698 lbl = gtk_label_new("");
1699 cddb_info_label = lbl;
1700 gtk_container_add(GTK_CONTAINER(f1), lbl);
1701 gtk_misc_set_alignment(GTK_MISC(lbl),0.0,0.5);
1702 gtk_misc_set_padding(GTK_MISC(lbl),10,0);
1703 gtk_widget_show(lbl);
1704
1705 /* load a gif-image and put into a pixmap */
1706 g_snprintf(tmp,MAXLINE,"%s/%s", sharedir,CDDBLOGO);
1707 #if GTK_MAJOR_VERSION < 2
1708 im=gdk_pixbuf_new_from_file(tmp);
1709 #else
1710 im=gdk_pixbuf_new_from_file(tmp,NULL);
1711 #endif
1712 if (im) {
1713 gdk_pixbuf_render_pixmap_and_mask(im, &p, &m, 128);
1714 cddb_logo = gtk_pixmap_new(p,m);
1715 gdk_pixbuf_unref(im);
1716 } else {
1717 cddb_logo = gtk_label_new("[CDDB]");
1718 }
1719 gtk_box_pack_start(GTK_BOX(hbox),cddb_logo,FALSE,FALSE,5);
1720 gtk_widget_show(cddb_logo);
1721
1722 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1723 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
1724 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1725 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1726 gtk_box_pack_start(GTK_BOX(box1),scrolled_win,TRUE,TRUE,0);
1727 gtk_widget_show(scrolled_win);
1728
1729 titles[0] = _("Matching database entries");
1730 c_list = gtk_clist_new_with_titles(1,titles);
1731 clist = GTK_CLIST(c_list);
1732 cddb_clist = clist;
1733 gtk_clist_set_column_auto_resize(clist, 0, TRUE);
1734 gtk_container_add (GTK_CONTAINER (scrolled_win), c_list);
1735 gtk_widget_show(c_list);
1736 gtk_signal_connect(GTK_OBJECT(clist), "select_row",
1737 GTK_SIGNAL_FUNC(cddb_select_row), NULL);
1738
1739 gtk_widget_show(box1);
1740
1741 b1_sep = gtk_hseparator_new();
1742 gtk_box_pack_start(GTK_BOX(box1),b1_sep,FALSE,TRUE,0);
1743 gtk_widget_show(b1_sep);
1744
1745 box2 = gtk_hbox_new(FALSE,0);
1746 gtk_box_pack_start(GTK_BOX(box1),box2,FALSE,TRUE,10);
1747 gtk_widget_show(box2);
1748
1749 button1 = gtk_button_new_with_label(T_OK);
1750 cddb_info_okbutton = button1;
1751 gtk_box_pack_start(GTK_BOX(box2),button1,TRUE,TRUE,10);
1752 gtk_widget_show(button1);
1753 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
1754 gtk_widget_set_sensitive(button1,FALSE);
1755 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
1756 GTK_SIGNAL_FUNC(show_cddb_btn_press), GINT_TO_POINTER(0));
1757
1758 button2 = gtk_button_new_with_label(T_CANCEL);
1759 gtk_box_pack_start(GTK_BOX(box2),button2,TRUE,TRUE,10);
1760 gtk_widget_show(button2);
1761 GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
1762 gtk_widget_grab_default (button2);
1763 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
1764 GTK_SIGNAL_FUNC(show_cddb_btn_press), GINT_TO_POINTER(-1));
1765
1766
1767 /* grab cursor and change to watch */
1768 gtk_grab_add(dialog);
1769 cursor = gdk_cursor_new(GDK_WATCH);
1770 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
1771
1772 /* only center window when toplevel visible */
1773 if ( GTK_WIDGET_VISIBLE(toplevel)) {
1774 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
1775 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
1776 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
1777 gtk_widget_size_request(dialog,&rq);
1778 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
1779 }
1780
1781 gtk_widget_show(dialog);
1782
1783
1784 /* lets do some work */
1785 if (cdtext_parent) {
1786 /* special case when on-the-fly */
1787 if (onthefly) {
1788 start_cddb_lookup_action(2);
1789 } else {
1790 start_cddb_lookup_action(1);
1791 }
1792 } else {
1793 start_cddb_lookup_action(0);
1794 }
1795
1796 /* now wait until button is pressed */
1797 while (dialog_done == 999) {
1798 wait_and_process_events();
1799 }
1800
1801 gtk_grab_remove(GTK_WIDGET(dialog));
1802 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
1803 gdk_cursor_destroy (cursor);
1804
1805 /* remove dialog window */
1806 gtk_widget_destroy(dialog);
1807
1808 return dialog_done;
1809 }
1810
1811
1812 /* start the read-processes according to the trackreadset-struct.
1813 Update read-dialogbox and return 0 if ok, 1 on error - call
1814 cdda2wav in bulk mode */
1815
start_read_action_bulk(gint read_devnr)1816 static gint start_read_action_bulk(gint read_devnr) {
1817 GList *loop;
1818 track_read_param_t *trackparam;
1819 gfloat percent_done;
1820 gint stat, count;
1821 gint audiocount, datacount;
1822
1823 if (strcmp(trackreadset.tocfile,"") == 0) {
1824 /* should not happen */
1825 return 1;
1826 }
1827
1828 dolog(1, "Reading CD with toc file %s (bulk)\n", trackreadset.tocfile);
1829
1830 percent_done = 0.0;
1831 count = 0;
1832 audiocount = 0;
1833 datacount = 0;
1834
1835 /* start reading tracks */
1836 loop = g_list_first(trackreadset.trackparams);
1837 while (loop) {
1838 trackparam = loop->data;
1839 count++;
1840
1841 /* data-track */
1842 if (trackparam->tracktype == 0) {
1843 stat = read_data_track(read_devnr,
1844 trackparam->starttrack,
1845 trackparam->kbyte,
1846 trackparam->trackfile,
1847 trackparam->startoffset,
1848 trackparam->endoffset,
1849 trackreadset.nrtracks,
1850 trackparam->percent,
1851 percent_done, count);
1852 datacount++;
1853 percent_done += trackparam->percent;
1854 } else {
1855 /* audio-track */
1856 /* dont read them here - do them as bulk later */
1857 audiocount++;
1858 stat = 0;
1859 }
1860 if (stat == 0) {
1861 /* no error */
1862 /* write inf-file */
1863 write_inf_file(trackparam);
1864 } else {
1865 /* error while reading */
1866 return 1;
1867 }
1868 loop = loop->next;
1869 }
1870
1871 /* ok, we have read all data tracks - now check if there
1872 are audio tracks to do */
1873 if (audiocount > 0) {
1874 if (start_bulk_read_action(read_devnr, percent_done,
1875 datacount+1) != 0) {
1876 /* error while reading? */
1877 return 1;
1878 }
1879 }
1880
1881 /* save the toc file (not for read single tracks) */
1882 if (strcmp(trackreadset.tocfile,"") != 0) {
1883 write_copy_cd_toc_file(trackreadset.tocfile);
1884 }
1885
1886 /* unset current active toc-file */
1887 g_free(curset.tocfile);
1888 curset.tocfile = g_strdup("");
1889
1890 /* no error reading tracks */
1891 gtk_label_set_text(GTK_LABEL(readtrack_info_label), _("Tracks successfully read"));
1892 gtk_label_set_text(GTK_LABEL(readtrack_small_info), _("Successful:"));
1893
1894 /* now set progressbars to 100% - elsewhere we may end up
1895 with 99% due rounding errors */
1896 gtk_progress_set_percentage(GTK_PROGRESS(readtrack_pbar1),1.0);
1897 gtk_progress_set_percentage(GTK_PROGRESS(readtrack_pbar2),1.0);
1898 set_xcdr_title(toplevel,viewmode_dialog,100);
1899
1900 return 0;
1901 }
1902
1903
1904 /* start the read-processes according to the trackreadset-struct.
1905 Update read-dialogbox and return 0 if ok, 1 on error */
1906
start_read_action(gint read_devnr)1907 static gint start_read_action(gint read_devnr) {
1908 GList *loop;
1909 track_read_param_t *trackparam;
1910 gfloat percent_done;
1911 gint stat, count;
1912
1913 if (strcmp(trackreadset.tocfile,"") != 0) {
1914 dolog(1, "Reading CD with toc file %s\n", trackreadset.tocfile);
1915 } else {
1916 dolog(1, "Reading single tracks\n");
1917 }
1918 percent_done = 0;
1919 count = 0;
1920
1921 /* start reading tracks */
1922 loop = g_list_first(trackreadset.trackparams);
1923 while (loop) {
1924 trackparam = loop->data;
1925 count++;
1926
1927 /* data-track */
1928 if (trackparam->tracktype == 0) {
1929 stat = read_data_track(read_devnr,
1930 trackparam->starttrack,
1931 trackparam->kbyte,
1932 trackparam->trackfile,
1933 trackparam->startoffset,
1934 trackparam->endoffset,
1935 trackreadset.nrtracks,
1936 trackparam->percent,
1937 percent_done, count);
1938 } else {
1939 /* audio-track */
1940 stat = read_audio_track(read_devnr,
1941 trackparam->starttrack,
1942 trackparam->endtrack,
1943 trackparam->kbyte,
1944 trackparam->trackfile,
1945 trackparam->startoffset,
1946 trackparam->endoffset,
1947 trackreadset.nrtracks,
1948 trackparam->percent,
1949 percent_done, count);
1950 }
1951 if (stat == 0) {
1952 /* no error */
1953 percent_done += trackparam->percent;
1954
1955 /* write inf-file */
1956 write_inf_file(trackparam);
1957 } else {
1958 /* error while reading */
1959 return 1;
1960 }
1961 loop = loop->next;
1962 }
1963
1964 /* save the toc file (not for read single tracks) */
1965 if (strcmp(trackreadset.tocfile,"") != 0) {
1966 write_copy_cd_toc_file(trackreadset.tocfile);
1967 }
1968
1969 /* unset current active toc-file */
1970 g_free(curset.tocfile);
1971 curset.tocfile = g_strdup("");
1972
1973 /* no error reading tracks */
1974 gtk_label_set_text(GTK_LABEL(readtrack_info_label), _("Tracks successfully read"));
1975 gtk_label_set_text(GTK_LABEL(readtrack_small_info), _("Successful:"));
1976
1977 /* now set progressbars to 100% - elsewhere we may end up
1978 with 99% due rounding errors */
1979 gtk_progress_set_percentage(GTK_PROGRESS(readtrack_pbar1),1.0);
1980 gtk_progress_set_percentage(GTK_PROGRESS(readtrack_pbar2),1.0);
1981 set_xcdr_title(toplevel,viewmode_dialog,100);
1982
1983 return 0;
1984 }
1985
1986
1987 /* called from cancel or ok button */
1988
show_readtrack_btn_press(GtkWidget * widget,gpointer data)1989 static void show_readtrack_btn_press(GtkWidget *widget, gpointer data) {
1990
1991 /* read-process running? */
1992 if (read_done == 999) {
1993 read_abort_mark = 1;
1994 /* abort our read-process */
1995 kill_readcdda();
1996 return;
1997 }
1998
1999 /* cancel event */
2000 if (GPOINTER_TO_INT(data) == -1) {
2001 dialog_done = -1;
2002 return;
2003 }
2004 }
2005
show_readtrack_save_press(GtkWidget * widget,gpointer data)2006 static void show_readtrack_save_press(GtkWidget *widget, gpointer data) {
2007 char tmp[MAXLINE];
2008
2009 /* show fileselector */
2010 show_file_selector(_("Save Output"), SAVEREADTRACKS,tmp);
2011
2012 /* not cancel pressed? */
2013 if (strcmp(tmp,"") != 0) {
2014 if (save_text2file(tmp, readtrack_textview) == 0) {
2015 show_dialog(ICO_INFO,_("Saving output successful"), T_OK, NULL, NULL, 0);
2016 }
2017 }
2018 }
2019
readtrack_dialog_delete_event(GtkWidget * widget,GdkEvent * event,gpointer data)2020 static gint readtrack_dialog_delete_event(GtkWidget *widget, GdkEvent *event,
2021 gpointer data) {
2022
2023 /* read-process running? */
2024 if (read_done == 999) {
2025 read_abort_mark = 1;
2026 /* abort our read-process */
2027 kill_readcdda();
2028 return(TRUE);
2029 }
2030
2031 dialog_done = -1;
2032 return(TRUE);
2033 }
2034
2035
2036 /* change the read-tracks menu according to view-setting */
viewmode_selected(GtkWidget * item,gpointer val)2037 static void viewmode_selected(GtkWidget *item, gpointer val) {
2038
2039 curset.proc_view = GPOINTER_TO_INT(val);
2040
2041 gtk_window_set_policy(GTK_WINDOW(viewmode_dialog), FALSE, TRUE, TRUE );
2042 if (GPOINTER_TO_INT(val) == 2) {
2043 /* extended view */
2044 gtk_widget_show(readtrack_info_frame);
2045 gtk_widget_show(readtrack_info_tbl);
2046 gtk_widget_show(viewmode_scrolled);
2047 gtk_widget_show(readtrack_savebutton);
2048 gtk_widget_hide(readtrack_small_info);
2049 gtk_widget_hide(readtrack_small_info2);
2050 } else if (GPOINTER_TO_INT(val) == 1) {
2051 /* normal view */
2052 gtk_widget_show(readtrack_info_frame);
2053 gtk_widget_show(readtrack_info_tbl);
2054 gtk_widget_hide(viewmode_scrolled);
2055 gtk_widget_hide(readtrack_savebutton);
2056 gtk_widget_hide(readtrack_small_info);
2057 gtk_widget_hide(readtrack_small_info2);
2058 } else {
2059 /* small view */
2060 gtk_widget_hide(readtrack_info_frame);
2061 gtk_widget_hide(readtrack_info_tbl);
2062 gtk_widget_hide(viewmode_scrolled);
2063 gtk_widget_hide(readtrack_savebutton);
2064 gtk_widget_show(readtrack_small_info);
2065 gtk_widget_show(readtrack_small_info2);
2066 }
2067
2068 while (gtk_events_pending())
2069 gtk_main_iteration();
2070
2071 gtk_window_set_policy(GTK_WINDOW(viewmode_dialog), FALSE, TRUE, FALSE);
2072 }
2073
2074
2075 /* popup a modal window, set cursor to watch, trigger read tracks
2076 and return 0 if all ok, -1 if not or
2077 when cancel or delete_event found.
2078 Centers automatically above the toplevel-widow
2079 */
2080
show_and_do_read_tracks(gint devnr,gint bulk)2081 gint show_and_do_read_tracks(gint devnr, gint bulk) {
2082 GtkWidget *omenu;
2083 GtkWidget *menu;
2084 GtkWidget *menu_item;
2085 GtkWidget *dialog;
2086 GtkWidget *l1;
2087 GtkWidget *button1, *button2;
2088 GtkWidget *box1,*box2,*txt;
2089 GtkWidget *f1, *tbl;
2090 GtkWidget *b1_sep, *lbl;
2091 GtkWidget *scrolled_win;
2092 gint xpos, ypos;
2093 gint xsize, ysize;
2094 GdkCursor *cursor;
2095 GtkRequisition rq;
2096 GtkAdjustment *adj1, *adj2;
2097 GtkWidget *pbar1, *pbar2;
2098 gint i, menuidx, menuhistory;
2099 static const gchar *viewmodes[] = VIEW_MODES;
2100
2101 /* if another dialog is running, ignore */
2102 if (dialog_done == 999) {
2103 return -1;
2104 }
2105
2106 dodebug(8, "displaying show_and_do_read_tracks\n");
2107
2108 /* mark our dialog as running */
2109 dialog_done = 999;
2110
2111 /* create new window and position it relative to the main window */
2112 dialog = my_gtk_dialog_new();
2113 viewmode_dialog = dialog;
2114 set_xcdr_title(dialog, toplevel, 0);
2115 gtk_widget_set_usize(dialog,tbf(400),0);
2116 /* make sure our window is always on top */
2117 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
2118
2119 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
2120 GTK_SIGNAL_FUNC (readtrack_dialog_delete_event),
2121 (gpointer) dialog);
2122
2123 /* create layout for dialog */
2124 box1 = gtk_vbox_new(FALSE,5);
2125 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
2126 gtk_container_add(GTK_CONTAINER(dialog),box1);
2127
2128 f1 = gtk_frame_new(NULL);
2129 readtrack_info_frame = f1;
2130 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_IN);
2131 gtk_widget_set_usize(f1,0,36);
2132 gtk_box_pack_start(GTK_BOX(box1),f1,FALSE,TRUE,5);
2133 if (curset.proc_view > 0)
2134 gtk_widget_show(f1);
2135
2136 lbl = gtk_label_new("");
2137 readtrack_info_label = lbl;
2138 gtk_container_add(GTK_CONTAINER(f1), lbl);
2139 gtk_misc_set_alignment(GTK_MISC(lbl),0.5,0.5);
2140 gtk_misc_set_padding(GTK_MISC(lbl),10,0);
2141 gtk_widget_show(lbl);
2142
2143 tbl = gtk_table_new(2, 10, TRUE);
2144 readtrack_info_tbl = tbl;
2145 gtk_table_set_col_spacing(GTK_TABLE(tbl),1,10);
2146 gtk_table_set_row_spacings(GTK_TABLE(tbl),5);
2147 gtk_box_pack_start(GTK_BOX(box1),tbl,FALSE,TRUE,5);
2148 if (curset.proc_view > 0)
2149 gtk_widget_show(tbl);
2150
2151 l1 = rightjust_gtk_label_new(_("Track:"));
2152 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,0,1);
2153 gtk_widget_show(l1);
2154
2155 adj1 = (GtkAdjustment *)gtk_adjustment_new(0, 0, 100, 0, 0, 0);
2156 pbar1 = gtk_progress_bar_new_with_adjustment(adj1);
2157 readtrack_pbar1 = pbar1;
2158 gtk_progress_set_format_string(GTK_PROGRESS(pbar1),"%p%%");
2159 gtk_progress_set_show_text(GTK_PROGRESS(pbar1),TRUE);
2160 gtk_table_attach_defaults(GTK_TABLE(tbl),pbar1,2,10,0,1);
2161 gtk_widget_show(pbar1);
2162
2163 l1 = rightjust_gtk_label_new(_("Total:"));
2164 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,1,2);
2165 gtk_widget_show(l1);
2166
2167 adj2 = (GtkAdjustment *)gtk_adjustment_new(0, 0, 100, 0, 0, 0);
2168 pbar2 = gtk_progress_bar_new_with_adjustment(adj2);
2169 readtrack_pbar2 = pbar2;
2170 gtk_progress_set_format_string(GTK_PROGRESS(pbar2),"%p%%");
2171 gtk_progress_set_show_text(GTK_PROGRESS(pbar2),TRUE);
2172 gtk_table_attach_defaults(GTK_TABLE(tbl),pbar2,2,10,1,2);
2173 gtk_widget_show(pbar2);
2174
2175 tbl = gtk_table_new(1, 10, TRUE);
2176 gtk_table_set_col_spacing(GTK_TABLE(tbl),6,10);
2177 gtk_table_set_row_spacings(GTK_TABLE(tbl),5);
2178 gtk_box_pack_start(GTK_BOX(box1),tbl,FALSE,TRUE,0);
2179 gtk_widget_show(tbl);
2180
2181 lbl = gtk_label_new("");
2182 readtrack_small_info = lbl;
2183 gtk_table_attach_defaults(GTK_TABLE(tbl),lbl,0,3,0,1);
2184 if (curset.proc_view == 0)
2185 gtk_widget_show(lbl);
2186
2187 lbl = gtk_label_new("");
2188 readtrack_small_info2 = lbl;
2189 gtk_table_attach_defaults(GTK_TABLE(tbl),lbl,3,5,0,1);
2190 if (curset.proc_view == 0)
2191 gtk_widget_show(lbl);
2192
2193 l1 = rightjust_gtk_label_new(_("View:"));
2194 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,5,7,0,1);
2195 gtk_widget_show(l1);
2196
2197 omenu = gtk_option_menu_new();
2198 menu = gtk_menu_new();
2199 menuidx = 0; menuhistory = -1;
2200
2201 for (i=0; i<3; i++) {
2202 menu_item = gtk_menu_item_new_with_label(_(viewmodes[i]));
2203 gtk_signal_connect(GTK_OBJECT(menu_item),
2204 "activate", GTK_SIGNAL_FUNC(viewmode_selected),
2205 GINT_TO_POINTER(i));
2206 gtk_menu_append (GTK_MENU (menu), menu_item);
2207 if (curset.proc_view == i) { menuhistory = menuidx; }
2208 menuidx++;
2209 gtk_widget_show (menu_item);
2210 }
2211 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
2212 if (menuhistory != -1) {
2213 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),menuhistory);
2214 } else {
2215 curset.proc_view = 1;
2216 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),1);
2217 }
2218 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,7,10,0,1);
2219 gtk_widget_show(omenu);
2220
2221 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
2222 viewmode_scrolled = scrolled_win;
2223 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
2224 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
2225 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2226 gtk_box_pack_start(GTK_BOX(box1),scrolled_win,TRUE,TRUE,0);
2227
2228 /* show only in extended view */
2229 if (curset.proc_view == 2)
2230 gtk_widget_show(scrolled_win);
2231
2232 txt = gtk_text_new(NULL,NULL);
2233 readtrack_textview = txt;
2234 gtk_text_set_editable(GTK_TEXT(txt),FALSE);
2235 gtk_text_set_word_wrap(GTK_TEXT(txt),TRUE);
2236 gtk_container_add(GTK_CONTAINER(scrolled_win), txt);
2237 gtk_widget_show(txt);
2238
2239 gtk_widget_show(box1);
2240
2241 b1_sep = gtk_hseparator_new();
2242 gtk_box_pack_start(GTK_BOX(box1),b1_sep,FALSE,TRUE,0);
2243 gtk_widget_show(b1_sep);
2244
2245 box2 = gtk_hbox_new(FALSE,0);
2246 gtk_box_pack_start(GTK_BOX(box1),box2,FALSE,TRUE,10);
2247 gtk_widget_show(box2);
2248
2249 button1 = gtk_button_new_with_label(T_CANCEL);
2250 readtrack_button = button1;
2251 gtk_box_pack_start(GTK_BOX(box2),button1,TRUE,TRUE,10);
2252 gtk_widget_show(button1);
2253 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
2254 gtk_widget_grab_default (button1);
2255 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
2256 GTK_SIGNAL_FUNC(show_readtrack_btn_press), GINT_TO_POINTER(-1));
2257
2258 button2 = gtk_button_new_with_label(_("Save Output"));
2259 readtrack_savebutton = button2;
2260 gtk_box_pack_start(GTK_BOX(box2),button2,TRUE,TRUE,10);
2261 GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
2262 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
2263 GTK_SIGNAL_FUNC(show_readtrack_save_press), GINT_TO_POINTER(-1));
2264 /* show only in extended view */
2265 if (curset.proc_view == 2)
2266 gtk_widget_show(button2);
2267
2268
2269 /* grab cursor and change to watch */
2270 gtk_grab_add(dialog);
2271 cursor = gdk_cursor_new(GDK_WATCH);
2272 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
2273
2274 /* only center window when toplevel visible */
2275 if (!set_win_geometry(GTK_WIDGET(dialog)) && GTK_WIDGET_VISIBLE(toplevel)) {
2276 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
2277 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
2278 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
2279 gtk_widget_size_request(dialog,&rq);
2280 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
2281 }
2282
2283 gtk_widget_show(dialog);
2284
2285 /* here is the action */
2286 if (bulk == 0) {
2287 /* read all selected tracks one at a time */
2288 start_read_action(devnr);
2289 } else {
2290 /* use bulk mode of cdda2wav */
2291 start_read_action_bulk(devnr);
2292 }
2293
2294 /* update image-dir-lists */
2295 scan_imagedirs();
2296
2297 /* when done with reading rename button to OK */
2298 gtk_label_set_text(GTK_LABEL(GTK_BIN(readtrack_button)->child),T_OK);
2299
2300 dobeep(1);
2301
2302 /* now wait until button is pressed */
2303 while (dialog_done == 999) {
2304 wait_and_process_events();
2305 }
2306
2307 store_win_geometry(GTK_WIDGET(dialog));
2308 set_xcdr_title(dialog, toplevel, -1);
2309
2310 gtk_grab_remove(GTK_WIDGET(dialog));
2311 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
2312 gdk_cursor_destroy (cursor);
2313
2314 /* remove dialog window */
2315 gtk_widget_destroy(dialog);
2316
2317 return dialog_done;
2318 }
2319
2320
2321 /* popup a modal window, set cursor to watch, return path or NULL-string
2322 when cancel or delete_event found.
2323 Centers automatically above the toplevel-widow
2324 */
2325
show_device_detail(gint devnr)2326 void show_device_detail(gint devnr) {
2327 GtkWidget *dialog;
2328 GtkWidget *button1;
2329 GtkWidget *box1,*box2,*txt;
2330 GtkWidget *f1;
2331 GtkWidget *scrolled_win;
2332 gint xpos, ypos;
2333 gint xsize, ysize;
2334 GdkCursor *cursor;
2335 GtkRequisition rq;
2336
2337 /* if another dialog is running, ignore */
2338 if (dialog_done == 999) {
2339 return;
2340 }
2341
2342 dodebug(8, "displaying show_device_detail\n");
2343
2344 /* mark our dialog as running */
2345 dialog_done = 999;
2346
2347 /* create new window and position it relative to the main window */
2348 dialog = my_gtk_dialog_new();
2349 set_xcdr_title(dialog, NULL, -1);
2350 gtk_widget_set_usize(dialog,tbf(550),tbf(300));
2351 /* make sure our window is always on top */
2352 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
2353
2354 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
2355 GTK_SIGNAL_FUNC (dialog_delete_event), (gpointer) dialog);
2356
2357 /* create layout for dialog */
2358 box1 = gtk_vbox_new(FALSE,0);
2359 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
2360 gtk_container_add(GTK_CONTAINER(dialog),box1);
2361
2362 f1 = gtk_frame_new(_("Detailed Device Information:"));
2363 set_font_and_color_frame(f1,BOLDFONT,NULL);
2364 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
2365 gtk_widget_show(f1);
2366
2367 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
2368 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
2369 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
2370 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2371 gtk_container_add(GTK_CONTAINER(f1),scrolled_win);
2372 gtk_widget_show(scrolled_win);
2373
2374 txt = gtk_text_new(NULL,NULL);
2375 gtk_text_set_editable(GTK_TEXT(txt),FALSE);
2376 gtk_text_set_word_wrap(GTK_TEXT(txt),TRUE);
2377 gtk_container_add(GTK_CONTAINER(scrolled_win), txt);
2378 gtk_widget_show(txt);
2379
2380 gtk_widget_show(box1);
2381
2382 box2 = gtk_hbox_new(FALSE,0);
2383 gtk_box_pack_start(GTK_BOX(box1),box2,FALSE,TRUE,5);
2384 gtk_widget_show(box2);
2385
2386 button1 = gtk_button_new_with_label(T_OK);
2387 gtk_box_pack_start(GTK_BOX(box2),button1,TRUE,TRUE,10);
2388 gtk_widget_show(button1);
2389 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
2390 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
2391 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(0));
2392
2393
2394 /* grab cursor and change to watch */
2395 gtk_grab_add(dialog);
2396 cursor = gdk_cursor_new(GDK_WATCH);
2397 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
2398
2399 /* only center window when toplevel visible */
2400 if ( GTK_WIDGET_VISIBLE(toplevel)) {
2401 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
2402 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
2403 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
2404 gtk_widget_size_request(dialog,&rq);
2405 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
2406 }
2407
2408
2409 /* now fill text-widget with infos */
2410 fill_device_info(devnr, txt);
2411 gtk_text_set_point(GTK_TEXT(txt),0);
2412 gtk_widget_show(dialog);
2413
2414
2415 /* now wait until button is pressed */
2416 while (dialog_done == 999) {
2417 wait_and_process_events();
2418 }
2419
2420 gtk_grab_remove(GTK_WIDGET(dialog));
2421 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
2422 gdk_cursor_destroy (cursor);
2423
2424 /* remove dialog window */
2425 gtk_widget_destroy(dialog);
2426 }
2427
2428
2429 /* popup a modal window, set cursor to watch, return path or NULL-string
2430 when cancel or delete_event found.
2431 Centers automatically above the toplevel-widow
2432 */
2433
display_atip_info(gint devnr)2434 void display_atip_info(gint devnr) {
2435 GtkWidget *dialog;
2436 GtkWidget *button1;
2437 GtkWidget *box1,*box2,*txt;
2438 GtkWidget *f1;
2439 GtkWidget *scrolled_win;
2440 gint xpos, ypos;
2441 gint xsize, ysize;
2442 GdkCursor *cursor;
2443 GtkRequisition rq;
2444
2445 /* if another dialog is running, ignore */
2446 if (dialog_done == 999) {
2447 return;
2448 }
2449
2450 dodebug(8, "displaying display_atip_info\n");
2451
2452 /* mark our dialog as running */
2453 dialog_done = 999;
2454
2455 /* create new window and position it relative to the main window */
2456 dialog = my_gtk_dialog_new();
2457 set_xcdr_title(dialog, NULL, -1);
2458 gtk_widget_set_usize(dialog,tbf(400),tbf(300));
2459 /* make sure our window is always on top */
2460 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
2461
2462 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
2463 GTK_SIGNAL_FUNC (dialog_delete_event), (gpointer) dialog);
2464
2465 /* create layout for dialog */
2466 box1 = gtk_vbox_new(FALSE,0);
2467 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
2468 gtk_container_add(GTK_CONTAINER(dialog),box1);
2469
2470 f1 = gtk_frame_new(_("ATIP (absolute Time in Pregroove)-Information:"));
2471 set_font_and_color_frame(f1,BOLDFONT,NULL);
2472 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
2473 gtk_widget_show(f1);
2474
2475 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
2476 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
2477 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
2478 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2479 gtk_container_add(GTK_CONTAINER(f1),scrolled_win);
2480 gtk_widget_show(scrolled_win);
2481
2482 txt = gtk_text_new(NULL,NULL);
2483 gtk_text_set_editable(GTK_TEXT(txt),FALSE);
2484 gtk_text_set_word_wrap(GTK_TEXT(txt),TRUE);
2485 gtk_container_add(GTK_CONTAINER(scrolled_win), txt);
2486 gtk_widget_show(txt);
2487
2488 gtk_widget_show(box1);
2489
2490 box2 = gtk_hbox_new(FALSE,0);
2491 gtk_box_pack_start(GTK_BOX(box1),box2,FALSE,TRUE,5);
2492 gtk_widget_show(box2);
2493
2494 button1 = gtk_button_new_with_label(T_OK);
2495 gtk_box_pack_start(GTK_BOX(box2),button1,TRUE,TRUE,10);
2496 gtk_widget_show(button1);
2497 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
2498 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
2499 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(0));
2500
2501
2502 /* grab cursor and change to watch */
2503 gtk_grab_add(dialog);
2504 cursor = gdk_cursor_new(GDK_WATCH);
2505 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
2506
2507 /* only center window when toplevel visible */
2508 if ( GTK_WIDGET_VISIBLE(toplevel)) {
2509 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
2510 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
2511 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
2512 gtk_widget_size_request(dialog,&rq);
2513 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
2514 }
2515
2516 /* now fill text-widget with infos */
2517 get_atip_info(devnr, txt);
2518 gtk_text_set_point(GTK_TEXT(txt),0);
2519
2520 gtk_widget_show(dialog);
2521
2522 /* now wait until button is pressed */
2523 while (dialog_done == 999) {
2524 wait_and_process_events();
2525 }
2526
2527 gtk_grab_remove(GTK_WIDGET(dialog));
2528 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
2529 gdk_cursor_destroy (cursor);
2530
2531 /* remove dialog window */
2532 gtk_widget_destroy(dialog);
2533 }
2534
2535
2536 /* callbacks for blank-menu */
2537
blankmode_selected(GtkWidget * item,gpointer mode)2538 static void blankmode_selected(GtkWidget *item, gpointer mode) {
2539
2540 curset.blankmode = GPOINTER_TO_INT(mode);
2541 }
2542
blankoptions_selected(GtkWidget * item,gpointer nr)2543 static void blankoptions_selected(GtkWidget *item, gpointer nr) {
2544 gint sel;
2545
2546 sel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
2547
2548 switch(GPOINTER_TO_INT(nr)) {
2549 case 0:
2550 curset.blank_force = sel;
2551 break;
2552 case 1:
2553 curset.blank_eject = sel;
2554 break;
2555 }
2556 }
2557
2558
2559 /* timer function for blanking */
2560
blank_timer(gpointer data)2561 static gint blank_timer(gpointer data) {
2562 time_t start_time;
2563 time_t curtime;
2564 gint secs;
2565 char tmp[MAXLINE];
2566
2567 /* how many seconds have passed since first start? */
2568 start_time = (time_t)data;
2569 curtime = time((time_t *) 0);
2570 secs = (gint) curtime - start_time;
2571
2572 /* set new label */
2573 g_snprintf(tmp,MAXLINE,_("Blanking in progress for %2d:%02d min."),secs/60,secs%60);
2574 gtk_label_set_text(GTK_LABEL(blank_infolabel),tmp);
2575
2576 return(TRUE);
2577 }
2578
2579
2580 /* called by ok-button in blank-window */
2581
blank_start(GtkWidget * widget,gpointer data)2582 static void blank_start(GtkWidget *widget, gpointer data) {
2583 time_t start_time;
2584 time_t curtime;
2585 gint secs;
2586 gint stat;
2587 char tmp[MAXLINE];
2588
2589 /* get current time */
2590 start_time = time((time_t *) 0);
2591 misc_timer = gtk_timeout_add(1000, blank_timer, GINT_TO_POINTER(start_time));
2592
2593 /* disable ok button */
2594 gtk_widget_set_sensitive(widget, FALSE);
2595 gtk_label_set_text(GTK_LABEL(GTK_BIN(readtrack_button)->child),T_CANCEL);
2596
2597 /* clear text-window */
2598 gtk_text_set_point(GTK_TEXT(blank_text_window),
2599 gtk_text_get_length(GTK_TEXT(blank_text_window)));
2600 gtk_text_backward_delete(GTK_TEXT(blank_text_window),
2601 gtk_text_get_length(GTK_TEXT(blank_text_window)));
2602
2603 /* now this waits here until blanking is done */
2604 stat = start_blanking_process(curset.writer_devnr, blank_text_window);
2605
2606 if (stat == 1) {
2607 /* error? */
2608 gtk_label_set_text(GTK_LABEL(blank_infolabel),_("Error while blanking."));
2609 } else
2610 if (stat == 0) {
2611 /* ok */
2612 curtime = time((time_t *) 0);
2613 secs = (gint) curtime - start_time;
2614 g_snprintf(tmp,MAXLINE,_("Blanking successful. Time: %2d:%02d min."),secs/60,secs%60);
2615 gtk_label_set_text(GTK_LABEL(blank_infolabel),tmp);
2616 } else {
2617 /* aborted */
2618 curtime = time((time_t *) 0);
2619 secs = (gint) curtime - start_time;
2620 g_snprintf(tmp,MAXLINE,_("Blanking aborted after %2d:%02d min."),secs/60,secs%60);
2621 gtk_label_set_text(GTK_LABEL(blank_infolabel),tmp);
2622 }
2623
2624 if (misc_timer != 0)
2625 gtk_timeout_remove(misc_timer);
2626 misc_timer = 0;
2627
2628 /* enable ok button */
2629 gtk_widget_set_sensitive(widget, TRUE);
2630
2631 /* restore close button */
2632 gtk_label_set_text(GTK_LABEL(GTK_BIN(readtrack_button)->child),T_CLOSE);
2633
2634 dobeep(1);
2635
2636 }
2637
2638
2639 /* called by cancel-button in blank-window */
2640
blank_cancel(GtkWidget * widget,gpointer data)2641 static void blank_cancel(GtkWidget *widget, gpointer data) {
2642
2643 /* nothing more to here, because actual killing is handled
2644 in start_blanking_process() */
2645 dialog_done2 = -1;
2646 }
2647
blank_delete_event(GtkWidget * widget,GdkEvent * event,gpointer data)2648 static gint blank_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) {
2649
2650 blank_cancel(widget,data);
2651 return(TRUE);
2652 }
2653
2654
2655 /* popup a modal window, set cursor to watch, return path or NULL-string
2656 when cancel or delete_event found.
2657 Centers automatically above the toplevel-widow
2658 */
2659
display_blank_cdrw(gint devnr)2660 void display_blank_cdrw(gint devnr) {
2661 GtkWidget *dialog, *tbl;
2662 GtkWidget *button1, *button2;
2663 GtkWidget *box1,*box2,*box3,*txt;
2664 GtkWidget *f1, *l1, *check, *sep;
2665 GtkWidget *omenu;
2666 GtkWidget *menu;
2667 GtkWidget *menu_item;
2668 GtkWidget *scrolled_win;
2669 gint xpos, ypos;
2670 gint xsize, ysize;
2671 GdkCursor *cursor;
2672 GtkRequisition rq;
2673 gint i,j, menuhistory, menuidx;
2674 gchar tmp[MAXLINE];
2675 gchar tmp2[MAXLINE];
2676 static const gchar *blanktrans[] = BLANK_MODES;
2677
2678 /* if another dialog is running, ignore */
2679 if (dialog_done2 == 999) {
2680 return;
2681 }
2682
2683 dodebug(8, "displaying display_blank_cdrw\n");
2684
2685 /* mark our dialog as running */
2686 dialog_done2 = 999;
2687 misc_timer = 0;
2688
2689 /* create new window and position it relative to the main window */
2690 dialog = my_gtk_dialog_new();
2691 set_xcdr_title(dialog, NULL, -1);
2692 gtk_widget_set_usize(dialog,tbf(470),tbf(250));
2693 /* make sure our window is always on top */
2694 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
2695
2696 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
2697 GTK_SIGNAL_FUNC (blank_delete_event), (gpointer) dialog);
2698
2699 /* create layout for dialog */
2700 box1 = gtk_vbox_new(FALSE,0);
2701 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
2702 gtk_container_add(GTK_CONTAINER(dialog),box1);
2703
2704 if (!curset.isProDVD) {
2705 f1 = gtk_frame_new(_("Blank CD-RW"));
2706 } else {
2707 f1 = gtk_frame_new(_("Blank CD/DVD+-RW"));
2708 }
2709 set_font_and_color_frame(f1,BOLDFONT,NULL);
2710 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
2711 gtk_widget_show(f1);
2712
2713 box2 = gtk_vbox_new(FALSE,0);
2714 gtk_container_set_border_width (GTK_CONTAINER (box2), 5);
2715 gtk_container_add(GTK_CONTAINER(f1),box2);
2716 gtk_widget_show(box2);
2717
2718 tbl = gtk_table_new(5, 8, FALSE);
2719 gtk_table_set_col_spacings(GTK_TABLE(tbl),10);
2720 gtk_box_pack_start(GTK_BOX(box2),tbl,FALSE,TRUE,0);
2721 gtk_widget_show(tbl);
2722
2723 l1 = rightjust_gtk_label_new(_("Blank-Mode:"));
2724 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,3,0,1);
2725 gtk_widget_show(l1);
2726
2727 omenu = gtk_option_menu_new();
2728 menu = gtk_menu_new();
2729 menuidx = 0; menuhistory = 0;
2730
2731 i = 0;
2732 while (blankmodes[i] != NULL) {
2733
2734 strncpy(tmp, blankmodes[i]->desc, MAXLINE);
2735
2736 /* get translation to blank mode if available */
2737 j = 0;
2738 while (blanktrans[j]) {
2739 if (strcmp(blankmodes[i]->desc,
2740 blanktrans[j]) == 0) {
2741 strncpy(tmp, _(blanktrans[j]), MAXLINE);
2742 }
2743 j++;
2744 }
2745
2746 menu_item = gtk_menu_item_new_with_label(tmp);
2747 gtk_signal_connect(GTK_OBJECT(menu_item),
2748 "activate", GTK_SIGNAL_FUNC(blankmode_selected),
2749 GINT_TO_POINTER(i));
2750 gtk_menu_append (GTK_MENU (menu), menu_item);
2751 if (curset.blankmode == i) { menuhistory = menuidx; }
2752 menuidx++;
2753 gtk_widget_show (menu_item);
2754 i++;
2755 }
2756
2757 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
2758 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),menuhistory);
2759 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,3,8,0,1);
2760 gtk_widget_show(omenu);
2761
2762 check = gtk_check_button_new_with_label(_("Force blanking"));
2763 gtk_signal_connect(GTK_OBJECT(check),"clicked",
2764 GTK_SIGNAL_FUNC(blankoptions_selected),GINT_TO_POINTER(0));
2765 gtk_table_attach_defaults(GTK_TABLE(tbl),check,3,8,1,2);
2766 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
2767 curset.blank_force);
2768 gtk_widget_show(check);
2769
2770 check = gtk_check_button_new_with_label(_("Eject CD after blank"));
2771 gtk_signal_connect(GTK_OBJECT(check),"clicked",
2772 GTK_SIGNAL_FUNC(blankoptions_selected),GINT_TO_POINTER(1));
2773 gtk_table_attach_defaults(GTK_TABLE(tbl),check,3,8,2,3);
2774 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
2775 curset.blank_eject);
2776 gtk_widget_show(check);
2777
2778 sep = gtk_hseparator_new();
2779 gtk_table_attach_defaults(GTK_TABLE(tbl),sep,0,8,3,4);
2780 gtk_widget_show(sep);
2781
2782 f1 = gtk_frame_new(NULL);
2783
2784 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_IN);
2785 gtk_container_set_border_width (GTK_CONTAINER (f1), 5);
2786 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,0,8,4,5);
2787 gtk_widget_show(f1);
2788
2789 l1 = gtk_label_new("");
2790 blank_infolabel = l1;
2791 gtk_container_add(GTK_CONTAINER(f1),l1);
2792 gtk_widget_show(l1);
2793
2794 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
2795 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
2796 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
2797 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2798 gtk_container_add(GTK_CONTAINER(box2),scrolled_win);
2799 gtk_widget_show(scrolled_win);
2800
2801 txt = gtk_text_new(NULL,NULL);
2802 blank_text_window = txt;
2803 gtk_text_set_editable(GTK_TEXT(txt),FALSE);
2804 gtk_text_set_word_wrap(GTK_TEXT(txt),TRUE);
2805 gtk_container_add(GTK_CONTAINER(scrolled_win), txt);
2806 gtk_widget_show(txt);
2807
2808 gtk_widget_show(box1);
2809
2810 box3 = gtk_hbox_new(FALSE,0);
2811 gtk_box_pack_start(GTK_BOX(box1),box3,FALSE,TRUE,5);
2812 gtk_widget_show(box3);
2813
2814 if (!curset.isProDVD) {
2815 button1 = gtk_button_new_with_label(_("Blank CD-RW"));
2816 } else {
2817 button1 = gtk_button_new_with_label(_("Blank CD/DVD+-RW"));
2818 }
2819 gtk_box_pack_start(GTK_BOX(box3),button1,TRUE,TRUE,10);
2820 gtk_widget_show(button1);
2821 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
2822 GTK_SIGNAL_FUNC(blank_start), NULL);
2823
2824 button2 = gtk_button_new_with_label(T_CLOSE);
2825 readtrack_button = button2;
2826 gtk_box_pack_start(GTK_BOX(box3),button2,TRUE,TRUE,10);
2827 gtk_widget_show(button2);
2828 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
2829 GTK_SIGNAL_FUNC(blank_cancel), GINT_TO_POINTER(-1));
2830
2831
2832 /* grab cursor and change to watch */
2833 gtk_grab_add(dialog);
2834 cursor = gdk_cursor_new(GDK_WATCH);
2835 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
2836
2837 /* only center window when toplevel visible */
2838 if ( GTK_WIDGET_VISIBLE(toplevel)) {
2839 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
2840 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
2841 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
2842 gtk_widget_size_request(dialog,&rq);
2843 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
2844 }
2845
2846 /* now fill text-widget with infos */
2847 strncpy(tmp2, _("Note: Full blanking an entire disk takes about 74 min at single speed and about 37 min on double speed CD-RW-Writers. Minimally Blanking is done in a few minutes."), MAXLINE);
2848 convert_for_gtk2_textwidget(tmp2);
2849 gtk_text_insert(GTK_TEXT(txt),NULL,NULL,NULL,
2850 tmp2, strlen(tmp2));
2851
2852 gtk_widget_show(dialog);
2853
2854
2855 /* now wait until button is pressed */
2856 while (dialog_done2 == 999) {
2857 wait_and_process_events();
2858 }
2859
2860 gtk_grab_remove(GTK_WIDGET(dialog));
2861 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
2862 gdk_cursor_destroy (cursor);
2863
2864 /* remove dialog window */
2865 gtk_widget_destroy(dialog);
2866 }
2867
2868
advoptions_close(GtkWidget * widget,gpointer data)2869 static void advoptions_close(GtkWidget *widget, gpointer data) {
2870
2871 dialog_done2 = -1;
2872 }
2873
advoptions_delete_event(GtkWidget * widget,GdkEvent * event,gpointer data)2874 static gint advoptions_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) {
2875 dialog_done2 = -1;
2876 return(TRUE);
2877 }
2878
advoptions_save(GtkWidget * widget,gpointer data)2879 static void advoptions_save(GtkWidget *widget, gpointer data) {
2880 gchar tmp2[MAXLINE];
2881
2882 dolog(2, "Save write-options as default\n");
2883
2884 /* write file */
2885 if (save_writeoptions_file(configdir, WRITEOPTFILE) == 1) {
2886 /* save failed */
2887 g_snprintf(tmp2,MAXLINE,_("Failed to save write options file: %s"), ISOOPTFILE);
2888 show_dialog(ICO_WARN, tmp2, T_OK, NULL, NULL, 0);
2889 } else {
2890 /* save ok */
2891 show_dialog(ICO_INFO,_("Options saved"), T_OK, NULL, NULL, 0);
2892 }
2893 }
2894
varirec_selected(GtkWidget * item,gpointer data)2895 static void varirec_selected(GtkWidget *item, gpointer data) {
2896 gchar tmp[MAXLINE];
2897 gint sel;
2898
2899 sel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
2900
2901 if (!sel) {
2902 /* disable varirec */
2903 g_snprintf(tmp, MAXLINE,"%d", curset.writevarirec);
2904 if (curset.writevarirec < 50 && does_support_varirec(curset.writer_devnr))
2905 curset.writevarirec += 100;
2906 gtk_widget_set_sensitive(varirec_scale, FALSE);
2907 set_labelcolor(varirec_label, DISABLEDCOLOR);
2908 } else {
2909 if (curset.writevarirec > 50)
2910 curset.writevarirec -= 100;
2911 gtk_widget_set_sensitive(varirec_scale, TRUE);
2912 set_labelcolor(varirec_label, ENABLEDCOLOR);
2913 g_snprintf(tmp, MAXLINE,"%d", curset.writevarirec);
2914 }
2915 gtk_label_set_text(GTK_LABEL(varirec_label),tmp);
2916 }
2917
varirec_changed(GtkAdjustment * adj,GtkWidget * label)2918 static void varirec_changed(GtkAdjustment *adj, GtkWidget *label) {
2919 gchar tmp[MAXLINE];
2920
2921 g_snprintf(tmp, MAXLINE,"%d",(gint)adj->value);
2922 gtk_label_set_text(GTK_LABEL(label),tmp);
2923
2924 curset.writevarirec = (gint)adj->value;
2925 }
2926
2927
2928 /* popup a modal window, set cursor to watch, return path or NULL-string
2929 when cancel or delete_event found.
2930 Centers automatically above the toplevel-widow
2931 */
2932
display_advwriteoptions(gint devnr)2933 void display_advwriteoptions(gint devnr) {
2934 GtkWidget *dialog, *tbl;
2935 GtkWidget *button1, *button2;
2936 GtkWidget *box1,*box2,*box3;
2937 GtkWidget *f1, *check, *l1, *scale;
2938 gint xpos, ypos;
2939 gint xsize, ysize;
2940 GdkCursor *cursor;
2941 GtkRequisition rq;
2942 GtkObject *adj1;
2943 gfloat fval;
2944
2945 /* if another dialog is running, ignore */
2946 if (dialog_done2 == 999) {
2947 return;
2948 }
2949
2950 dodebug(8, "displaying display_advwriteoptions\n");
2951
2952 /* mark our dialog as running */
2953 dialog_done2 = 999;
2954 misc_timer = 0;
2955
2956 /* create new window and position it relative to the main window */
2957 dialog = my_gtk_dialog_new();
2958 set_xcdr_title(dialog, NULL, -1);
2959 gtk_widget_set_usize(dialog,tbf(300),tbf(270));
2960
2961 /* make sure our window is always on top */
2962 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
2963
2964 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
2965 GTK_SIGNAL_FUNC (advoptions_delete_event), (gpointer) dialog);
2966
2967 /* create layout for dialog */
2968 box1 = gtk_vbox_new(FALSE,0);
2969 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
2970 gtk_container_add(GTK_CONTAINER(dialog),box1);
2971 gtk_widget_show(box1);
2972
2973 f1 = gtk_frame_new(_("Advanced write parameters"));
2974 set_font_and_color_frame(f1,BOLDFONT,NULL);
2975 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
2976 gtk_widget_show(f1);
2977
2978 box2 = gtk_vbox_new(FALSE,0);
2979 gtk_container_set_border_width (GTK_CONTAINER (box2), 5);
2980 gtk_container_add(GTK_CONTAINER(f1),box2);
2981 gtk_widget_show(box2);
2982
2983 tbl = gtk_table_new(8, 16, FALSE);
2984 gtk_table_set_col_spacings(GTK_TABLE(tbl),5);
2985 gtk_box_pack_start(GTK_BOX(box2),tbl,FALSE,TRUE,0);
2986 gtk_widget_show(tbl);
2987
2988 check = gtk_check_button_new_with_label(_("Swap Audio byte order"));
2989 gtk_signal_connect(GTK_OBJECT(check),"clicked",
2990 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(3));
2991 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,16,0,1);
2992 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
2993 curset.writeswap);
2994 gtk_widget_show(check);
2995 define_tooltip(check,_("Swaps the byte-order of audio-tracks. This is needed when you end up with an audio-CD which only contains static noise."));
2996
2997 check = gtk_check_button_new_with_label(_("Allow overburning"));
2998 gtk_signal_connect(GTK_OBJECT(check),"clicked",
2999 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(7));
3000 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,16,1,2);
3001 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3002 curset.writeoverburn);
3003 gtk_widget_show(check);
3004 define_tooltip(check,_("Allows to write more than the official size of a medium. Most CD Writers support it only in DAO mode. It may however do not work at all, you have to test it. (If X-CD-Roast still warns about non-fitting data, ignore this.)"));
3005
3006 check = gtk_check_button_new_with_label(_("Ignore medium size"));
3007 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3008 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(11));
3009 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,16,2,3);
3010 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3011 curset.writeignsize);
3012 gtk_widget_show(check);
3013 define_tooltip(check,_("Ignore the known size of the medium. This option should be used with extreme care and is only required for debugging purposes."));
3014
3015 check = gtk_check_button_new_with_label(_("Set SCSI IMMED flag"));
3016 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3017 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(12));
3018 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,16,3,4);
3019 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3020 curset.writeimmed);
3021 gtk_widget_show(check);
3022 define_tooltip(check,_("If you have problems with a freezing system when blanking or fixating a CD-R/RW you can try to enable this option. It also might reduce stress on systems where the writer is on the same IDE bus as the hard drive. Use at own risk only."));
3023
3024 check = gtk_check_button_new_with_label(_("Enable Yamaha Audio Master mode"));
3025 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3026 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(9));
3027 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,16,4,5);
3028 if (does_support_audiomaster(curset.writer_devnr)) {
3029 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3030 curset.writeaudiomaster);
3031 }
3032 gtk_widget_show(check);
3033 define_tooltip(check,_("Turn on the Yahama Audio Master Q. R. feature which usually should result in high quality CDs that have less reading problems in HiFi players. This reduces the capacity of a 74 minute CD to 63 minutes and a 80 minute CD to 68 minutes. (Only works in DAO mode)"));
3034
3035 if (!does_support_audiomaster(curset.writer_devnr))
3036 gtk_widget_set_sensitive(check,FALSE);
3037
3038 check = gtk_check_button_new_with_label(_("Enable Forcespeed mode"));
3039 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3040 GTK_SIGNAL_FUNC(writeoptions_selected),GINT_TO_POINTER(10));
3041 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,16,5,6);
3042 if (does_support_forcespeed(curset.writer_devnr)) {
3043 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3044 curset.writeforcespeed);
3045 }
3046 gtk_widget_show(check);
3047 define_tooltip(check,_("This option forces a drive to ignore the medium quality (and a possible automatic write speed reduction) and to use the selected speed. Should only be used with extreme care."));
3048
3049 if (!does_support_forcespeed(curset.writer_devnr))
3050 gtk_widget_set_sensitive(check,FALSE);
3051
3052 check = gtk_check_button_new_with_label(_("Enable Plextor VariRec mode:"));
3053 gtk_table_attach_defaults(GTK_TABLE(tbl),check,1,16,6,7);
3054 if (curset.writevarirec < 50 && does_support_varirec(curset.writer_devnr)) {
3055 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3056 TRUE);
3057 }
3058 gtk_widget_show(check);
3059 define_tooltip(check,_("The VariRec option changes the laser power used to write CDs. This can increase compatibility with some playback devices. Values from -2 to 2 are valid and please note that the write speed will drop to 4x."));
3060
3061 if (!does_support_varirec(curset.writer_devnr))
3062 gtk_widget_set_sensitive(check,FALSE);
3063
3064 f1 = gtk_frame_new(NULL);
3065 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_IN);
3066 gtk_container_border_width(GTK_CONTAINER(f1),3);
3067 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,4,7,7,8);
3068 gtk_widget_show(f1);
3069
3070 l1 = gtk_label_new("");
3071 varirec_label = l1;
3072 gtk_container_add(GTK_CONTAINER(f1),l1);
3073 gtk_widget_show(l1);
3074
3075
3076 adj1 = gtk_adjustment_new(0.0,-2.0,3.0,1.0,1.0,1.0);
3077 gtk_signal_connect(GTK_OBJECT(adj1), "value_changed",
3078 GTK_SIGNAL_FUNC(varirec_changed), l1);
3079 scale = gtk_hscale_new(GTK_ADJUSTMENT (adj1));
3080 varirec_scale = scale;
3081 gtk_scale_set_value_pos (GTK_SCALE(scale), GTK_POS_LEFT);
3082 gtk_scale_set_digits(GTK_SCALE(scale),0);
3083 gtk_scale_set_draw_value(GTK_SCALE(scale),FALSE);
3084 gtk_table_attach_defaults(GTK_TABLE(tbl),scale,7,15,7,8);
3085 if (curset.writevarirec < 50) {
3086 /* work around stupid slider bugs in GTK */
3087 if (curset.writevarirec < 0) {
3088 fval = (gfloat)curset.writevarirec-0.1;
3089 } else {
3090 fval = (gfloat)curset.writevarirec+0.1;
3091 }
3092 gtk_adjustment_set_value(GTK_ADJUSTMENT(adj1),fval);
3093 } else {
3094 /* work around stupid slider bugs in GTK */
3095 if ((curset.writevarirec-100) < 0) {
3096 fval = (gfloat)(curset.writevarirec-100)-0.1;
3097 } else {
3098 fval = (gfloat)(curset.writevarirec-100)+0.1;
3099 }
3100 gtk_adjustment_set_value(GTK_ADJUSTMENT(adj1),fval);
3101 }
3102 gtk_widget_show(scale);
3103
3104 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3105 GTK_SIGNAL_FUNC(varirec_selected),NULL);
3106 varirec_selected(check, NULL);
3107
3108
3109 box3 = gtk_hbox_new(FALSE,0);
3110 gtk_box_pack_start(GTK_BOX(box1),box3,FALSE,TRUE,5);
3111 gtk_widget_show(box3);
3112
3113 button1 = gtk_button_new_with_label(T_CLOSE);
3114 readtrack_button = button1;
3115 gtk_box_pack_start(GTK_BOX(box3),button1,TRUE,TRUE,10);
3116 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
3117 GTK_SIGNAL_FUNC(advoptions_close), GINT_TO_POINTER(-1));
3118 gtk_widget_show(button1);
3119
3120 button2 = gtk_button_new_with_label(_("Save"));
3121 gtk_box_pack_start(GTK_BOX(box3),button2,TRUE,TRUE,10);
3122 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
3123 GTK_SIGNAL_FUNC(advoptions_save), NULL);
3124 gtk_widget_show(button2);
3125 define_tooltip(button2,_("Saves the current set of write parameters as default values for the next startup of X-CD-Roast."));
3126
3127 /* grab cursor and change to watch */
3128 gtk_grab_add(dialog);
3129 cursor = gdk_cursor_new(GDK_WATCH);
3130 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
3131
3132 /* only center window when toplevel visible */
3133 if ( GTK_WIDGET_VISIBLE(toplevel)) {
3134 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
3135 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
3136 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
3137 gtk_widget_size_request(dialog,&rq);
3138 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
3139 }
3140
3141 gtk_widget_show(dialog);
3142
3143
3144 /* now wait until button is pressed */
3145 while (dialog_done2 == 999) {
3146 wait_and_process_events();
3147 }
3148
3149 gtk_grab_remove(GTK_WIDGET(dialog));
3150 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
3151 gdk_cursor_destroy (cursor);
3152
3153 /* remove dialog window */
3154 gtk_widget_destroy(dialog);
3155 }
3156
3157
isolevel_selected(GtkWidget * item,gpointer data)3158 static void isolevel_selected(GtkWidget *item, gpointer data) {
3159 gchar tmp[MAXLINE];
3160 gint sel;
3161 GtkAdjustment *adj;
3162 GtkRange *range;
3163
3164 sel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
3165
3166 if (!sel) {
3167 g_snprintf(tmp, MAXLINE,"%d", masterparam.opt[23]);
3168 masterparam.opt[23] = 0;
3169 gtk_widget_set_sensitive(isolevel_scale, FALSE);
3170 set_labelcolor(isolevel_label, DISABLEDCOLOR);
3171 } else {
3172 gtk_widget_set_sensitive(isolevel_scale, TRUE);
3173 set_labelcolor(isolevel_label, ENABLEDCOLOR);
3174
3175 /* get value from scale */
3176 range = GTK_RANGE(isolevel_scale);
3177 adj = range->adjustment;
3178 masterparam.opt[23] = (gint)adj->value;
3179 g_snprintf(tmp, MAXLINE,"%d", masterparam.opt[23]);
3180
3181 }
3182 gtk_label_set_text(GTK_LABEL(isolevel_label),tmp);
3183 }
3184
isolevel_changed(GtkAdjustment * adj,GtkWidget * label)3185 static void isolevel_changed(GtkAdjustment *adj, GtkWidget *label) {
3186 gchar tmp[MAXLINE];
3187
3188 g_snprintf(tmp, MAXLINE,"%d",(gint)adj->value);
3189 gtk_label_set_text(GTK_LABEL(label),tmp);
3190
3191 masterparam.opt[23] = (gint)adj->value;
3192 }
3193
3194
3195 /* popup a modal window, set cursor to watch, return path or NULL-string
3196 when cancel or delete_event found.
3197 Centers automatically above the toplevel-widow
3198 */
3199
display_advisooptions()3200 void display_advisooptions() {
3201 GtkWidget *dialog, *tbl;
3202 GtkWidget *button1;
3203 GtkWidget *box1,*box2,*box3;
3204 GtkWidget *l1, *f1, *check, *scale;
3205 GtkObject *adj1;
3206 gint xpos, ypos;
3207 gint xsize, ysize;
3208 GdkCursor *cursor;
3209 GtkRequisition rq;
3210
3211 /* if another dialog is running, ignore */
3212 if (dialog_done2 == 999) {
3213 return;
3214 }
3215
3216 dodebug(8, "displaying display_advisooptions\n");
3217
3218 /* mark our dialog as running */
3219 dialog_done2 = 999;
3220 misc_timer = 0;
3221
3222 /* create new window and position it relative to the main window */
3223 dialog = my_gtk_dialog_new();
3224 set_xcdr_title(dialog, NULL, -1);
3225 gtk_widget_set_usize(dialog,tbf(350),tbf(390));
3226
3227 /* make sure our window is always on top */
3228 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
3229
3230 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
3231 GTK_SIGNAL_FUNC (advoptions_delete_event), (gpointer) dialog);
3232
3233 /* create layout for dialog */
3234 box1 = gtk_vbox_new(FALSE,0);
3235 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
3236 gtk_container_add(GTK_CONTAINER(dialog),box1);
3237 gtk_widget_show(box1);
3238
3239 f1 = gtk_frame_new(_("Advanced ISO9660 options"));
3240 set_font_and_color_frame(f1,BOLDFONT,NULL);
3241 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
3242 gtk_widget_show(f1);
3243
3244 box2 = gtk_vbox_new(FALSE,0);
3245 gtk_container_set_border_width (GTK_CONTAINER (box2), 5);
3246 gtk_container_add(GTK_CONTAINER(f1),box2);
3247 gtk_widget_show(box2);
3248
3249 tbl = gtk_table_new(13, 16, FALSE);
3250 gtk_table_set_col_spacings(GTK_TABLE(tbl),5);
3251 gtk_box_pack_start(GTK_BOX(box2),tbl,FALSE,TRUE,0);
3252 gtk_widget_show(tbl);
3253
3254
3255 /* -allow-lowercase */
3256 check = gtk_check_button_new_with_label(_("Allow lowercase ISO9660 filenames"));
3257 isoopts[17] = check;
3258 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3259 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(17));
3260 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,16,0,1);
3261 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3262 masterparam.opt[17]);
3263 gtk_widget_show(check);
3264 define_tooltip(check, _("This options allows lower case characters to appear in ISO9660 filenames. This violates the ISO9660 standard, but happens to work on some systems. Use with caution."));
3265
3266 /* -allow-multidot */
3267 check = gtk_check_button_new_with_label(_("Allow multiple dots in ISO9660 filenames"));
3268 isoopts[18] = check;
3269 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3270 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(18));
3271 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,16,1,2);
3272 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3273 masterparam.opt[18]);
3274 gtk_widget_show(check);
3275 define_tooltip(check, _("This options allows more than one dot to appear in ISO9660 filenames. Leading dots are not affected by this option. This violates the ISO9660 standard, but happens to work on many systems. Use with caution."));
3276
3277 /* -no-iso-translate */
3278 check = gtk_check_button_new_with_label(_("Do not translate the characters '~' and '#'"));
3279 isoopts[15] = check;
3280 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3281 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(15));
3282 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,16,2,3);
3283 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3284 masterparam.opt[15]);
3285 gtk_widget_show(check);
3286 define_tooltip(check, _("Do not translate the characters '#' and '~' which are invalid for ISO9660 filenames but often used by Microsoft systems."));
3287
3288 /* -max-iso9660-filenames */
3289 check = gtk_check_button_new_with_label(_("Allow 37 characters in ISO9660 filenames"));
3290 isoopts[19] = check;
3291 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3292 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(19));
3293 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,16,3,4);
3294 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3295 masterparam.opt[19]);
3296 gtk_widget_show(check);
3297 define_tooltip(check, _("Allow 37 chars in ISO9660 filenames. This option will remove the ISO9660 version numbers to get the extra space. Use with extreme care."));
3298
3299 /* -relaxed-filenames */
3300 check = gtk_check_button_new_with_label(_("Relaxed ISO9660 filenames"));
3301 isoopts[20] = check;
3302 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3303 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(20));
3304 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,16,4,5);
3305 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3306 masterparam.opt[20]);
3307 gtk_widget_show(check);
3308 define_tooltip(check, _("Allow ISO9660 filenames to include digits, uppercase characters and all other 7 bit ASCII characters. This violates the ISO9660 standard, but it happens to work on many systems. Use with caution."));
3309
3310 /* -dvd-video */
3311 check = gtk_check_button_new_with_label(_("Generate DVD-Video compliant UDF file system"));
3312 isoopts[21] = check;
3313 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3314 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(21));
3315 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,16,5,6);
3316 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3317 masterparam.opt[21]);
3318 gtk_widget_show(check);
3319 define_tooltip(check, _("Generate DVD-Video compliant UDF file system. This is done by sorting the order of the content of the appropriate files and by adding padding between the files if needed."));
3320
3321 /* -d omit trailing period */
3322 check = gtk_check_button_new_with_label(_("Omit trailing periods"));
3323 isoopts[8] = check;
3324 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3325 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(8));
3326 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,16,6,7);
3327 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3328 masterparam.opt[8]);
3329 gtk_widget_show(check);
3330 define_tooltip(check, _("Omit trailing period from files that do not have a period. This violates the ISO9660 standard but has no effect on Rock Ridge or Joliet filenames."));
3331
3332 /* -N omit version numbers */
3333 check = gtk_check_button_new_with_label(_("Omit ISO9660 version numbers"));
3334 isoopts[9] = check;
3335 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3336 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(9));
3337 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,16,7,8);
3338 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3339 masterparam.opt[9]);
3340 gtk_widget_show(check);
3341 define_tooltip(check, _("Omit version numbers from ISO9660 file names. May be necessary on some exotic systems. Use with caution."));
3342
3343 /* -hide-rr-moved */
3344 check = gtk_check_button_new_with_label(_("Hide the RR_MOVED directory"));
3345 isoopts[12] = check;
3346 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3347 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(12));
3348 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,16,8,9);
3349 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3350 masterparam.opt[12]);
3351 gtk_widget_show(check);
3352 define_tooltip(check, _("Rename the automatically generated directory \"RR_MOVED\" to \".rr_moved\" in Rock Ridge images."));
3353
3354 /* -no-rr */
3355 check = gtk_check_button_new_with_label(_("Do not use RR attributes from old sessions"));
3356 isoopts[14] = check;
3357 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3358 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(14));
3359 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,16,9,10);
3360 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3361 masterparam.opt[14]);
3362 gtk_widget_show(check);
3363 define_tooltip(check, _("Do not use the Rock Ridge attributes from previous sessions. This may help to avoid getting into trouble when mkisofs finds illegal Rock Ridge signatures on an old session."));
3364
3365 /* verbose executution */
3366 check = gtk_check_button_new_with_label(_("Verbose mkisofs execution"));
3367 isoopts[22] = check;
3368 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3369 GTK_SIGNAL_FUNC(isooptions_selected),GINT_TO_POINTER(22));
3370 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,16,10,11);
3371 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3372 masterparam.opt[22]);
3373 gtk_widget_show(check);
3374 define_tooltip(check, _("Generate more output when generating the ISO9660 image. This is helpful to debug any problems that might occur."));
3375
3376 /* allow to set iso-level */
3377 check = gtk_check_button_new_with_label(_("Set ISO9660 conformance level:"));
3378 isoopts[23] = check;
3379 gtk_table_attach_defaults(GTK_TABLE(tbl),check,0,16,11,12);
3380 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
3381 masterparam.opt[23]);
3382 gtk_widget_show(check);
3383 define_tooltip(check, _("Force the restrictions of the ISO9660 conformance levels. Only required for very special uses like CDs for MP3-Players."));
3384
3385 f1 = gtk_frame_new(NULL);
3386 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_IN);
3387 gtk_container_border_width(GTK_CONTAINER(f1),3);
3388 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,4,7,12,13);
3389 gtk_widget_show(f1);
3390
3391 l1 = gtk_label_new("");
3392 isolevel_label = l1;
3393 gtk_container_add(GTK_CONTAINER(f1),l1);
3394 gtk_widget_show(l1);
3395
3396 adj1 = gtk_adjustment_new(0.0,1.0,4.0,1.0,1.0,1.0);
3397 gtk_signal_connect(GTK_OBJECT(adj1), "value_changed",
3398 GTK_SIGNAL_FUNC(isolevel_changed), l1);
3399 scale = gtk_hscale_new(GTK_ADJUSTMENT (adj1));
3400 isolevel_scale = scale;
3401 gtk_scale_set_value_pos (GTK_SCALE(scale), GTK_POS_LEFT);
3402 gtk_scale_set_digits(GTK_SCALE(scale),0);
3403 gtk_scale_set_draw_value(GTK_SCALE(scale),FALSE);
3404 gtk_table_attach_defaults(GTK_TABLE(tbl),scale,7,15,12,13);
3405 gtk_adjustment_set_value(GTK_ADJUSTMENT(adj1),(gfloat)masterparam.opt[23]);
3406 gtk_widget_show(scale);
3407
3408 gtk_signal_connect(GTK_OBJECT(check),"clicked",
3409 GTK_SIGNAL_FUNC(isolevel_selected),NULL);
3410 isolevel_selected(check, NULL);
3411
3412
3413 box3 = gtk_hbox_new(FALSE,0);
3414 gtk_box_pack_start(GTK_BOX(box1),box3,FALSE,TRUE,5);
3415 gtk_widget_show(box3);
3416
3417 button1 = gtk_button_new_with_label(T_CLOSE);
3418 readtrack_button = button1;
3419 gtk_box_pack_start(GTK_BOX(box3),button1,TRUE,TRUE,10);
3420 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
3421 GTK_SIGNAL_FUNC(advoptions_close), GINT_TO_POINTER(-1));
3422 gtk_widget_show(button1);
3423
3424 /* grab cursor and change to watch */
3425 gtk_grab_add(dialog);
3426 cursor = gdk_cursor_new(GDK_WATCH);
3427 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
3428
3429 /* only center window when toplevel visible */
3430 if ( GTK_WIDGET_VISIBLE(toplevel)) {
3431 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
3432 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
3433 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
3434 gtk_widget_size_request(dialog,&rq);
3435 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
3436 }
3437
3438 gtk_widget_show(dialog);
3439
3440
3441 /* now wait until button is pressed */
3442 while (dialog_done2 == 999) {
3443 wait_and_process_events();
3444 }
3445
3446 gtk_grab_remove(GTK_WIDGET(dialog));
3447 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
3448 gdk_cursor_destroy (cursor);
3449
3450 /* remove dialog window */
3451 gtk_widget_destroy(dialog);
3452 }
3453
3454
3455 /* save output of write process */
3456
show_writetrack_save_press(GtkWidget * widget,gpointer data)3457 static void show_writetrack_save_press(GtkWidget *widget, gpointer data) {
3458 char tmp[MAXLINE];
3459
3460 /* show fileselector */
3461 show_file_selector(_("Save Output"), SAVEOUTCDRECORD,tmp);
3462
3463 /* not cancel pressed? */
3464 if (strcmp(tmp,"") != 0) {
3465 if (save_text2file(tmp, readtrack_textview) == 0) {
3466 show_dialog(ICO_INFO,_("Saving output successful"), T_OK, NULL, NULL, 0);
3467 }
3468 }
3469 }
3470
3471
3472 /* called by cancel-button in write-window */
3473
write_cancel(GtkWidget * widget,gpointer data)3474 static void write_cancel(GtkWidget *widget, gpointer data) {
3475
3476 /* nothing more to here, because actual killing is handled
3477 in start_write_action() */
3478 dialog_done2 = -1;
3479 }
3480
write_delete_event(GtkWidget * widget,GdkEvent * event,gpointer data)3481 static gint write_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) {
3482
3483 write_cancel(widget,data);
3484 return(TRUE);
3485 }
3486
3487
3488 /* create the write-tracks-box */
3489 /* when ontheflysetting set to 2 just fixate */
3490 /* when ontheflysetting set to 3 do master on the fly */
3491
show_and_do_write_tracks(gint devnr,gint read_devnr,gint onthefly)3492 gint show_and_do_write_tracks(gint devnr, gint read_devnr, gint onthefly) {
3493 GtkWidget *omenu;
3494 GtkWidget *menu;
3495 GtkWidget *menu_item;
3496 GtkWidget *dialog;
3497 GtkWidget *l1;
3498 GtkWidget *button1, *button2;
3499 GtkWidget *box1,*box2,*txt;
3500 GtkWidget *f1, *tbl, *spdlabel;
3501 GtkWidget *b1_sep, *lbl;
3502 GtkWidget *scrolled_win;
3503 gint xpos, ypos;
3504 gint xsize, ysize;
3505 GdkCursor *cursor;
3506 GtkRequisition rq;
3507 GtkAdjustment *adj1, *adj2, *adj3, *adj4;
3508 GtkWidget *pbar1, *pbar2, *pbar3, *pbar4;
3509 gint i, menuidx, menuhistory;
3510 static const gchar *viewmodes[] = VIEW_MODES;
3511
3512 /* if another dialog is running, ignore */
3513 if (dialog_done2 == 999) {
3514 return -1;
3515 }
3516
3517 dodebug(8, "displaying show_and_do_write_tracks\n");
3518
3519 /* mark our dialog as running */
3520 dialog_done2 = 999;
3521
3522 /* create new window and position it relative to the main window */
3523 dialog = my_gtk_dialog_new();
3524 viewmode_dialog = dialog;
3525 set_xcdr_title(dialog, toplevel, 0);
3526 gtk_widget_set_usize(dialog,tbf(400),0);
3527 /* make sure our window is always on top */
3528 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
3529
3530 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
3531 GTK_SIGNAL_FUNC (write_delete_event),
3532 (gpointer) dialog);
3533
3534 /* create layout for dialog */
3535 box1 = gtk_vbox_new(FALSE,5);
3536 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
3537 gtk_container_add(GTK_CONTAINER(dialog),box1);
3538
3539 f1 = gtk_frame_new(NULL);
3540 readtrack_info_frame = f1;
3541 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_IN);
3542 gtk_widget_set_usize(f1,0,36);
3543 gtk_box_pack_start(GTK_BOX(box1),f1,FALSE,TRUE,5);
3544 if (curset.proc_view > 0)
3545 gtk_widget_show(f1);
3546
3547 lbl = gtk_label_new("");
3548 readtrack_info_label = lbl;
3549 gtk_container_add(GTK_CONTAINER(f1), lbl);
3550 gtk_misc_set_alignment(GTK_MISC(lbl),0.5,0.5);
3551 gtk_misc_set_padding(GTK_MISC(lbl),10,0);
3552 gtk_widget_show(lbl);
3553
3554 tbl = gtk_table_new(4, 20, TRUE);
3555 readtrack_info_tbl = tbl;
3556 gtk_table_set_col_spacing(GTK_TABLE(tbl),4,5);
3557 gtk_table_set_col_spacing(GTK_TABLE(tbl),16,5);
3558 gtk_table_set_row_spacings(GTK_TABLE(tbl),5);
3559 gtk_box_pack_start(GTK_BOX(box1),tbl,FALSE,TRUE,5);
3560 if (curset.proc_view > 0)
3561 gtk_widget_show(tbl);
3562
3563 l1 = rightjust_gtk_label_new(_("Track:"));
3564 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,5,0,1);
3565 gtk_widget_show(l1);
3566
3567 adj1 = (GtkAdjustment *)gtk_adjustment_new(0, 0, 100, 0, 0, 0);
3568 pbar1 = gtk_progress_bar_new_with_adjustment(adj1);
3569 readtrack_pbar1 = pbar1;
3570 gtk_progress_set_format_string(GTK_PROGRESS(pbar1),"%p%%");
3571 gtk_progress_set_show_text(GTK_PROGRESS(pbar1),TRUE);
3572 gtk_table_attach_defaults(GTK_TABLE(tbl),pbar1,5,20,0,1);
3573 gtk_widget_show(pbar1);
3574
3575 l1 = rightjust_gtk_label_new(_("Total:"));
3576 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,5,1,2);
3577 gtk_widget_show(l1);
3578
3579 adj2 = (GtkAdjustment *)gtk_adjustment_new(0, 0, 100, 0, 0, 0);
3580 pbar2 = gtk_progress_bar_new_with_adjustment(adj2);
3581 readtrack_pbar2 = pbar2;
3582 gtk_progress_set_format_string(GTK_PROGRESS(pbar2),"%p%%");
3583 gtk_progress_set_show_text(GTK_PROGRESS(pbar2),TRUE);
3584 gtk_table_attach_defaults(GTK_TABLE(tbl),pbar2,5,20,1,2);
3585 gtk_widget_show(pbar2);
3586
3587 l1 = rightjust_gtk_label_new(_("Fifo:"));
3588 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,5,2,3);
3589 gtk_widget_show(l1);
3590
3591 adj3 = (GtkAdjustment *)gtk_adjustment_new(0, 0, 100, 0, 0, 0);
3592 pbar3 = gtk_progress_bar_new_with_adjustment(adj3);
3593 readtrack_pbar3 = pbar3;
3594 gtk_progress_set_format_string(GTK_PROGRESS(pbar3),"%p%%");
3595 gtk_progress_set_show_text(GTK_PROGRESS(pbar3),TRUE);
3596 gtk_table_attach_defaults(GTK_TABLE(tbl),pbar3,5,20,2,3);
3597 gtk_widget_show(pbar3);
3598
3599 l1 = rightjust_gtk_label_new(_("Writer-Buffer:"));
3600 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,5,3,4);
3601 gtk_widget_show(l1);
3602
3603 adj4 = (GtkAdjustment *)gtk_adjustment_new(0, 0, 100, 0, 0, 0);
3604 pbar4 = gtk_progress_bar_new_with_adjustment(adj4);
3605 readtrack_pbar4 = pbar4;
3606 gtk_progress_set_format_string(GTK_PROGRESS(pbar4),"%p%%");
3607 gtk_progress_set_show_text(GTK_PROGRESS(pbar4),TRUE);
3608 gtk_table_attach_defaults(GTK_TABLE(tbl),pbar4,5,11,3,4);
3609 gtk_widget_show(pbar4);
3610
3611 l1 = rightjust_gtk_label_new(_("Speed:"));
3612 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,11,17,3,4);
3613 gtk_widget_show(l1);
3614
3615 f1 = gtk_frame_new(NULL);
3616 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_IN);
3617 gtk_container_border_width(GTK_CONTAINER(f1),0);
3618 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,17,20,3,4);
3619 gtk_widget_show(f1);
3620
3621 spdlabel = gtk_label_new("");
3622 readtrack_spd = spdlabel;
3623 gtk_container_add(GTK_CONTAINER(f1),spdlabel);
3624 gtk_widget_show(spdlabel);
3625
3626
3627 tbl = gtk_table_new(1, 10, TRUE);
3628 gtk_table_set_col_spacing(GTK_TABLE(tbl),6,10);
3629 gtk_table_set_row_spacings(GTK_TABLE(tbl),5);
3630 gtk_box_pack_start(GTK_BOX(box1),tbl,FALSE,TRUE,0);
3631 gtk_widget_show(tbl);
3632
3633 lbl = gtk_label_new("");
3634 readtrack_small_info = lbl;
3635 gtk_table_attach_defaults(GTK_TABLE(tbl),lbl,0,3,0,1);
3636 if (curset.proc_view == 0)
3637 gtk_widget_show(lbl);
3638
3639 lbl = gtk_label_new("");
3640 readtrack_small_info2 = lbl;
3641 gtk_table_attach_defaults(GTK_TABLE(tbl),lbl,3,5,0,1);
3642 if (curset.proc_view == 0)
3643 gtk_widget_show(lbl);
3644
3645 l1 = rightjust_gtk_label_new(_("View:"));
3646 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,5,7,0,1);
3647 gtk_widget_show(l1);
3648
3649 omenu = gtk_option_menu_new();
3650 menu = gtk_menu_new();
3651 menuidx = 0; menuhistory = -1;
3652
3653 for (i=0; i<3; i++) {
3654 menu_item = gtk_menu_item_new_with_label(_(viewmodes[i]));
3655 gtk_signal_connect(GTK_OBJECT(menu_item),
3656 "activate", GTK_SIGNAL_FUNC(viewmode_selected),
3657 GINT_TO_POINTER(i));
3658 gtk_menu_append (GTK_MENU (menu), menu_item);
3659 if (curset.proc_view == i) { menuhistory = menuidx; }
3660 menuidx++;
3661 gtk_widget_show (menu_item);
3662 }
3663 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
3664 if (menuhistory != -1) {
3665 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),menuhistory);
3666 } else {
3667 curset.proc_view = 1;
3668 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),1);
3669 }
3670 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,7,10,0,1);
3671 gtk_widget_show(omenu);
3672
3673 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3674 viewmode_scrolled = scrolled_win;
3675 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
3676 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3677 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3678 gtk_box_pack_start(GTK_BOX(box1),scrolled_win,TRUE,TRUE,0);
3679
3680 /* show only in extended view */
3681 if (curset.proc_view == 2)
3682 gtk_widget_show(scrolled_win);
3683
3684 txt = gtk_text_new(NULL,NULL);
3685 readtrack_textview = txt;
3686 gtk_text_set_editable(GTK_TEXT(txt),FALSE);
3687 gtk_text_set_word_wrap(GTK_TEXT(txt),TRUE);
3688 gtk_container_add(GTK_CONTAINER(scrolled_win), txt);
3689 gtk_widget_show(txt);
3690
3691 gtk_widget_show(box1);
3692
3693 b1_sep = gtk_hseparator_new();
3694 gtk_box_pack_start(GTK_BOX(box1),b1_sep,FALSE,TRUE,0);
3695 gtk_widget_show(b1_sep);
3696
3697 box2 = gtk_hbox_new(FALSE,0);
3698 gtk_box_pack_start(GTK_BOX(box1),box2,FALSE,TRUE,10);
3699 gtk_widget_show(box2);
3700
3701 button1 = gtk_button_new_with_label(T_CANCEL);
3702 readtrack_button = button1;
3703 gtk_box_pack_start(GTK_BOX(box2),button1,TRUE,TRUE,10);
3704 gtk_widget_show(button1);
3705 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
3706 gtk_widget_grab_default (button1);
3707 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
3708 GTK_SIGNAL_FUNC(write_cancel), GINT_TO_POINTER(-1));
3709
3710 button2 = gtk_button_new_with_label(_("Save Output"));
3711 readtrack_savebutton = button2;
3712 gtk_box_pack_start(GTK_BOX(box2),button2,TRUE,TRUE,10);
3713 GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
3714 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
3715 GTK_SIGNAL_FUNC(show_writetrack_save_press), GINT_TO_POINTER(-1));
3716 /* show only in extended view */
3717 if (curset.proc_view == 2)
3718 gtk_widget_show(button2);
3719
3720
3721 /* grab cursor and change to watch */
3722 gtk_grab_add(dialog);
3723 cursor = gdk_cursor_new(GDK_WATCH);
3724 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
3725
3726 /* only center window when toplevel visible */
3727 if (!set_win_geometry(GTK_WIDGET(dialog)) && GTK_WIDGET_VISIBLE(toplevel)) {
3728 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
3729 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
3730 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
3731 gtk_widget_size_request(dialog,&rq);
3732 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
3733 }
3734
3735 gtk_widget_show(dialog);
3736
3737 /* here is the action */
3738 if (onthefly == 0) {
3739 start_write_action(devnr);
3740 } else
3741 if (onthefly == 1) {
3742 start_write_onthefly_action(read_devnr, devnr);
3743 } else
3744 if (onthefly == 2) {
3745 start_write_fixate_only(devnr);
3746 } else {
3747 /* master on the fly */
3748 start_onthefly_master_action(devnr);
3749 }
3750
3751 /* when done with reading rename button to OK */
3752 gtk_label_set_text(GTK_LABEL(GTK_BIN(readtrack_button)->child),T_OK);
3753
3754
3755 dobeep(1);
3756
3757 /* now wait until button is pressed */
3758 while (dialog_done2 == 999) {
3759 wait_and_process_events();
3760 }
3761
3762 store_win_geometry(GTK_WIDGET(dialog));
3763 set_xcdr_title(dialog, toplevel, -1);
3764
3765 gtk_grab_remove(GTK_WIDGET(dialog));
3766 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
3767 gdk_cursor_destroy (cursor);
3768
3769 /* remove dialog window */
3770 gtk_widget_destroy(dialog);
3771
3772 return dialog_done2;
3773 }
3774
3775
3776 /* called by cancel-button in delete-window */
3777
delete_cancel(GtkWidget * widget,gpointer data)3778 static void delete_cancel(GtkWidget *widget, gpointer data) {
3779
3780 /* delete running? */
3781 if (read_done == 999) {
3782 /* abort */
3783 kill_readcdda();
3784 } else {
3785 dialog_done2 = -1;
3786 }
3787 }
3788
delete_delete_event(GtkWidget * widget,GdkEvent * event,gpointer data)3789 static gint delete_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) {
3790
3791 write_cancel(widget,data);
3792 return(TRUE);
3793 }
3794
3795
3796 /* display a menu and do delete tracks */
3797
show_and_do_delete(GList * delfiles)3798 gint show_and_do_delete(GList *delfiles) {
3799 GtkWidget *dialog;
3800 GtkWidget *button1;
3801 GtkWidget *box1,*box2;
3802 GtkWidget *f1;
3803 GtkWidget *b1_sep, *lbl;
3804 GtkWidget *scrolled_win, *txt;
3805 gint xpos, ypos;
3806 gint xsize, ysize;
3807 GdkCursor *cursor;
3808 GtkRequisition rq;
3809 GtkAdjustment *adj1;
3810 GtkWidget *pbar1;
3811
3812
3813 /* if another dialog is running, ignore */
3814 if (dialog_done2 == 999) {
3815 return -1;
3816 }
3817
3818 dodebug(8, "displaying show_and_do_delete\n");
3819
3820 /* mark our dialog as running */
3821 dialog_done2 = 999;
3822
3823 /* create new window and position it relative to the main window */
3824 dialog = my_gtk_dialog_new();
3825 viewmode_dialog = dialog;
3826 set_xcdr_title(dialog, toplevel, 0);
3827 gtk_widget_set_usize(dialog,tbf(400),0);
3828 /* make sure our window is always on top */
3829 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
3830
3831 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
3832 GTK_SIGNAL_FUNC (delete_delete_event),
3833 (gpointer) dialog);
3834
3835 /* create layout for dialog */
3836 box1 = gtk_vbox_new(FALSE,5);
3837 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
3838 gtk_container_add(GTK_CONTAINER(dialog),box1);
3839 gtk_widget_show(box1);
3840
3841 f1 = gtk_frame_new(NULL);
3842 readtrack_info_frame = f1;
3843 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_IN);
3844 gtk_widget_set_usize(f1,0,36);
3845 gtk_box_pack_start(GTK_BOX(box1),f1,FALSE,TRUE,5);
3846 gtk_widget_show(f1);
3847
3848 lbl = gtk_label_new("");
3849 readtrack_info_label = lbl;
3850 gtk_container_add(GTK_CONTAINER(f1), lbl);
3851 gtk_misc_set_alignment(GTK_MISC(lbl),0.5,0.5);
3852 gtk_misc_set_padding(GTK_MISC(lbl),10,0);
3853 gtk_widget_show(lbl);
3854
3855 adj1 = (GtkAdjustment *)gtk_adjustment_new(0, 0, 100, 0, 0, 0);
3856 pbar1 = gtk_progress_bar_new_with_adjustment(adj1);
3857 readtrack_pbar1 = pbar1;
3858 gtk_progress_set_format_string(GTK_PROGRESS(pbar1),"%p%%");
3859 gtk_progress_set_show_text(GTK_PROGRESS(pbar1),TRUE);
3860 gtk_box_pack_start(GTK_BOX(box1),pbar1,FALSE,TRUE,5);
3861 gtk_widget_show(pbar1);
3862
3863 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3864 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
3865 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3866 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3867 gtk_container_add(GTK_CONTAINER(box1),scrolled_win);
3868 gtk_widget_show(scrolled_win);
3869
3870 txt = gtk_text_new(NULL,NULL);
3871 readtrack_textview = txt;
3872 gtk_text_set_editable(GTK_TEXT(txt),FALSE);
3873 gtk_text_set_word_wrap(GTK_TEXT(txt),TRUE);
3874 gtk_container_add(GTK_CONTAINER(scrolled_win), txt);
3875 gtk_widget_show(txt);
3876
3877 b1_sep = gtk_hseparator_new();
3878 gtk_box_pack_start(GTK_BOX(box1),b1_sep,FALSE,TRUE,0);
3879 gtk_widget_show(b1_sep);
3880
3881 box2 = gtk_hbox_new(FALSE,0);
3882 gtk_box_pack_start(GTK_BOX(box1),box2,FALSE,TRUE,10);
3883 gtk_widget_show(box2);
3884
3885 button1 = gtk_button_new_with_label(T_CANCEL);
3886 readtrack_button = button1;
3887 gtk_box_pack_start(GTK_BOX(box2),button1,TRUE,TRUE,10);
3888 gtk_widget_show(button1);
3889 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
3890 gtk_widget_grab_default (button1);
3891 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
3892 GTK_SIGNAL_FUNC(delete_cancel), GINT_TO_POINTER(-1));
3893
3894 /* grab cursor and change to watch */
3895 gtk_grab_add(dialog);
3896 cursor = gdk_cursor_new(GDK_WATCH);
3897 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
3898
3899 /* only center window when toplevel visible */
3900 if ( GTK_WIDGET_VISIBLE(toplevel)) {
3901 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
3902 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
3903 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
3904 gtk_widget_size_request(dialog,&rq);
3905 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
3906 }
3907
3908 gtk_widget_show(dialog);
3909
3910 /* here is the action */
3911 start_delete_action(delfiles);
3912
3913 /* when done with delete rename button to OK */
3914 gtk_label_set_text(GTK_LABEL(GTK_BIN(readtrack_button)->child),T_OK);
3915
3916 /* now wait until button is pressed */
3917 while (dialog_done2 == 999) {
3918 wait_and_process_events();
3919 }
3920
3921 set_xcdr_title(dialog, toplevel, -1);
3922
3923 gtk_grab_remove(GTK_WIDGET(dialog));
3924 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
3925 gdk_cursor_destroy (cursor);
3926
3927 /* remove dialog window */
3928 gtk_widget_destroy(dialog);
3929
3930 return dialog_done2;
3931 }
3932
3933
3934 /* start the read-processes according to the trackreadset-struct.
3935 Update verify-dialogbox and return 0 if ok, 1 on error */
3936
start_verify_action(gint read_devnr)3937 static gint start_verify_action(gint read_devnr) {
3938 GList *loop;
3939 track_read_param_t *trackparam;
3940 gfloat percent_done;
3941 gint stat, count;
3942 gint errcount;
3943
3944 if (strcmp(trackreadset.tocfile,"") != 0) {
3945 dolog(1, "Verify CD with toc file %s\n", trackreadset.tocfile);
3946 } else {
3947 dolog(1, "Verifying single tracks\n");
3948 }
3949 percent_done = 0;
3950 count = 0;
3951 errcount = 0;
3952
3953 /* start verifying all tracks */
3954 loop = g_list_first(trackreadset.trackparams);
3955 while (loop) {
3956 trackparam = loop->data;
3957
3958 /* data-track */
3959 if (trackparam->tracktype == 0) {
3960 count++;
3961 stat = verify_data_track(read_devnr,
3962 trackparam->starttrack,
3963 trackparam->kbyte,
3964 trackparam->trackfile,
3965 trackparam->startoffset,
3966 trackparam->endoffset,
3967 trackreadset.nrtracks,
3968 trackparam->percent,
3969 percent_done, count);
3970 percent_done += trackparam->percent;
3971 } else {
3972 /* audio-track */
3973 if (curset.noaudioverify == 0) {
3974 count++;
3975 stat = verify_audio_track(read_devnr,
3976 trackparam->starttrack,
3977 trackparam->endtrack,
3978 trackparam->kbyte,
3979 trackparam->trackfile,
3980 trackparam->startoffset,
3981 trackparam->endoffset,
3982 trackreadset.nrtracks,
3983 trackparam->percent,
3984 percent_done, count);
3985 percent_done += trackparam->percent;
3986 } else {
3987 /* we dont want to verify audio */
3988 stat = 0;
3989 }
3990 }
3991 if (stat == 2) {
3992 /* user abort */
3993 return 1;
3994 }
3995 if (stat != 0) {
3996 /* error while reading */
3997 if (curset.verifyfailabort == 1)
3998 return 1;
3999 errcount++;
4000 }
4001 loop = loop->next;
4002 }
4003
4004 /* if we only got a single error we failed */
4005 if (errcount > 0) {
4006 return 1;
4007 }
4008 /* no error verifying tracks */
4009 gtk_label_set_text(GTK_LABEL(readtrack_info_label), _("Tracks successfully verified"));
4010 gtk_label_set_text(GTK_LABEL(readtrack_small_info), _("Successful:"));
4011
4012 /* now set progressbars to 100% - elsewhere we may end up
4013 with 99% due rounding errors */
4014 gtk_progress_set_percentage(GTK_PROGRESS(readtrack_pbar1),1.0);
4015 gtk_progress_set_percentage(GTK_PROGRESS(readtrack_pbar2),1.0);
4016 set_xcdr_title(toplevel,viewmode_dialog,100);
4017
4018 return 0;
4019 }
4020
4021
4022 /* called from cancel or ok button */
4023
show_verifytrack_btn_press(GtkWidget * widget,gpointer data)4024 static void show_verifytrack_btn_press(GtkWidget *widget, gpointer data) {
4025
4026 /* read-process running? */
4027 if (read_done == 999) {
4028 /* mark aborted */
4029 read_abort_mark = 1;
4030 /* abort our read-process */
4031 kill_readcdda();
4032 return;
4033 }
4034
4035 /* cancel event */
4036 if (GPOINTER_TO_INT(data) == -1) {
4037 dialog_done = -1;
4038 return;
4039 }
4040 }
4041
4042
show_verifytrack_save_press(GtkWidget * widget,gpointer data)4043 static void show_verifytrack_save_press(GtkWidget *widget, gpointer data) {
4044 char tmp[MAXLINE];
4045
4046 /* show fileselector */
4047 show_file_selector(_("Save Output"), SAVEVERIFYTRACKS,tmp);
4048
4049 /* not cancel pressed? */
4050 if (strcmp(tmp,"") != 0) {
4051 if (save_text2file(tmp, readtrack_textview) == 0) {
4052 show_dialog(ICO_INFO,_("Saving output successful"), T_OK, NULL, NULL, 0);
4053 }
4054 }
4055 }
4056
verifytrack_dialog_delete_event(GtkWidget * widget,GdkEvent * event,gpointer data)4057 static gint verifytrack_dialog_delete_event(GtkWidget *widget, GdkEvent *event,
4058 gpointer data) {
4059
4060 /* read-process running? */
4061 if (read_done == 999) {
4062 /* mark aborted */
4063 read_abort_mark = 1;
4064 /* abort our read-process */
4065 kill_readcdda();
4066 return(TRUE);
4067 }
4068
4069 dialog_done = -1;
4070 return(TRUE);
4071 }
4072
4073
4074 /* popup a modal window, set cursor to watch, trigger read tracks
4075 and return 0 if all ok, -1 if not or
4076 when cancel or delete_event found.
4077 Centers automatically above the toplevel-widow
4078 */
4079
show_and_do_verify_tracks(gint devnr)4080 gint show_and_do_verify_tracks(gint devnr) {
4081 GtkWidget *omenu;
4082 GtkWidget *menu;
4083 GtkWidget *menu_item;
4084 GtkWidget *dialog;
4085 GtkWidget *l1;
4086 GtkWidget *button1, *button2;
4087 GtkWidget *box1,*box2,*txt;
4088 GtkWidget *f1, *tbl;
4089 GtkWidget *b1_sep, *lbl;
4090 GtkWidget *scrolled_win;
4091 gint xpos, ypos;
4092 gint xsize, ysize;
4093 GdkCursor *cursor;
4094 GtkRequisition rq;
4095 GtkAdjustment *adj1, *adj2;
4096 GtkWidget *pbar1, *pbar2;
4097 gint i, menuidx, menuhistory;
4098 static const gchar *viewmodes[] = VIEW_MODES;
4099
4100 /* if another dialog is running, ignore */
4101 if (dialog_done == 999) {
4102 return -1;
4103 }
4104
4105 dodebug(8, "displaying show_and_do_verify_tracks\n");
4106
4107 /* mark our dialog as running */
4108 dialog_done = 999;
4109
4110 /* create new window and position it relative to the main window */
4111 dialog = my_gtk_dialog_new();
4112 viewmode_dialog = dialog;
4113 set_xcdr_title(dialog, toplevel, 0);
4114 gtk_widget_set_usize(dialog,tbf(400),0);
4115 /* make sure our window is always on top */
4116 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
4117
4118 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
4119 GTK_SIGNAL_FUNC (verifytrack_dialog_delete_event),
4120 (gpointer) dialog);
4121
4122 /* create layout for dialog */
4123 box1 = gtk_vbox_new(FALSE,5);
4124 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
4125 gtk_container_add(GTK_CONTAINER(dialog),box1);
4126
4127 f1 = gtk_frame_new(NULL);
4128 readtrack_info_frame = f1;
4129 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_IN);
4130 gtk_widget_set_usize(f1,0,36);
4131 gtk_box_pack_start(GTK_BOX(box1),f1,FALSE,TRUE,5);
4132 if (curset.proc_view > 0)
4133 gtk_widget_show(f1);
4134
4135 lbl = gtk_label_new("");
4136 readtrack_info_label = lbl;
4137 gtk_container_add(GTK_CONTAINER(f1), lbl);
4138 gtk_misc_set_alignment(GTK_MISC(lbl),0.5,0.5);
4139 gtk_misc_set_padding(GTK_MISC(lbl),10,0);
4140 gtk_widget_show(lbl);
4141
4142 tbl = gtk_table_new(2, 10, TRUE);
4143 readtrack_info_tbl = tbl;
4144 gtk_table_set_col_spacing(GTK_TABLE(tbl),1,10);
4145 gtk_table_set_row_spacings(GTK_TABLE(tbl),5);
4146 gtk_box_pack_start(GTK_BOX(box1),tbl,FALSE,TRUE,5);
4147 if (curset.proc_view > 0)
4148 gtk_widget_show(tbl);
4149
4150 l1 = rightjust_gtk_label_new(_("Track:"));
4151 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,0,1);
4152 gtk_widget_show(l1);
4153
4154 adj1 = (GtkAdjustment *)gtk_adjustment_new(0, 0, 100, 0, 0, 0);
4155 pbar1 = gtk_progress_bar_new_with_adjustment(adj1);
4156 readtrack_pbar1 = pbar1;
4157 gtk_progress_set_format_string(GTK_PROGRESS(pbar1),"%p%%");
4158 gtk_progress_set_show_text(GTK_PROGRESS(pbar1),TRUE);
4159 gtk_table_attach_defaults(GTK_TABLE(tbl),pbar1,2,10,0,1);
4160 gtk_widget_show(pbar1);
4161
4162 l1 = rightjust_gtk_label_new(_("Total:"));
4163 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,1,2);
4164 gtk_widget_show(l1);
4165
4166 adj2 = (GtkAdjustment *)gtk_adjustment_new(0, 0, 100, 0, 0, 0);
4167 pbar2 = gtk_progress_bar_new_with_adjustment(adj2);
4168 readtrack_pbar2 = pbar2;
4169 gtk_progress_set_format_string(GTK_PROGRESS(pbar2),"%p%%");
4170 gtk_progress_set_show_text(GTK_PROGRESS(pbar2),TRUE);
4171 gtk_table_attach_defaults(GTK_TABLE(tbl),pbar2,2,10,1,2);
4172 gtk_widget_show(pbar2);
4173
4174 tbl = gtk_table_new(1, 10, TRUE);
4175 gtk_table_set_col_spacing(GTK_TABLE(tbl),6,10);
4176 gtk_table_set_row_spacings(GTK_TABLE(tbl),5);
4177 gtk_box_pack_start(GTK_BOX(box1),tbl,FALSE,TRUE,0);
4178 gtk_widget_show(tbl);
4179
4180 lbl = gtk_label_new("");
4181 readtrack_small_info = lbl;
4182 gtk_table_attach_defaults(GTK_TABLE(tbl),lbl,0,3,0,1);
4183 if (curset.proc_view == 0)
4184 gtk_widget_show(lbl);
4185
4186 lbl = gtk_label_new("");
4187 readtrack_small_info2 = lbl;
4188 gtk_table_attach_defaults(GTK_TABLE(tbl),lbl,3,5,0,1);
4189 if (curset.proc_view == 0)
4190 gtk_widget_show(lbl);
4191
4192 l1 = rightjust_gtk_label_new(_("View:"));
4193 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,5,7,0,1);
4194 gtk_widget_show(l1);
4195
4196 omenu = gtk_option_menu_new();
4197 menu = gtk_menu_new();
4198 menuidx = 0; menuhistory = -1;
4199
4200 for (i=0; i<3; i++) {
4201 menu_item = gtk_menu_item_new_with_label(_(viewmodes[i]));
4202 gtk_signal_connect(GTK_OBJECT(menu_item),
4203 "activate", GTK_SIGNAL_FUNC(viewmode_selected),
4204 GINT_TO_POINTER(i));
4205 gtk_menu_append (GTK_MENU (menu), menu_item);
4206 if (curset.proc_view == i) { menuhistory = menuidx; }
4207 menuidx++;
4208 gtk_widget_show (menu_item);
4209 }
4210 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
4211 if (menuhistory != -1) {
4212 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),menuhistory);
4213 } else {
4214 curset.proc_view = 1;
4215 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),1);
4216 }
4217 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,7,10,0,1);
4218 gtk_widget_show(omenu);
4219
4220 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4221 viewmode_scrolled = scrolled_win;
4222 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
4223 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4224 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
4225 gtk_box_pack_start(GTK_BOX(box1),scrolled_win,TRUE,TRUE,0);
4226
4227 /* show only in extended view */
4228 if (curset.proc_view == 2)
4229 gtk_widget_show(scrolled_win);
4230
4231 txt = gtk_text_new(NULL,NULL);
4232 readtrack_textview = txt;
4233 gtk_text_set_editable(GTK_TEXT(txt),FALSE);
4234 gtk_text_set_word_wrap(GTK_TEXT(txt),TRUE);
4235 gtk_container_add(GTK_CONTAINER(scrolled_win), txt);
4236 gtk_widget_show(txt);
4237
4238 gtk_widget_show(box1);
4239
4240 b1_sep = gtk_hseparator_new();
4241 gtk_box_pack_start(GTK_BOX(box1),b1_sep,FALSE,TRUE,0);
4242 gtk_widget_show(b1_sep);
4243
4244 box2 = gtk_hbox_new(FALSE,0);
4245 gtk_box_pack_start(GTK_BOX(box1),box2,FALSE,TRUE,10);
4246 gtk_widget_show(box2);
4247
4248 button1 = gtk_button_new_with_label(T_CANCEL);
4249 readtrack_button = button1;
4250 gtk_box_pack_start(GTK_BOX(box2),button1,TRUE,TRUE,10);
4251 gtk_widget_show(button1);
4252 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
4253 gtk_widget_grab_default (button1);
4254 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
4255 GTK_SIGNAL_FUNC(show_verifytrack_btn_press), GINT_TO_POINTER(-1));
4256
4257 button2 = gtk_button_new_with_label(_("Save Output"));
4258 readtrack_savebutton = button2;
4259 gtk_box_pack_start(GTK_BOX(box2),button2,TRUE,TRUE,10);
4260 GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
4261 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
4262 GTK_SIGNAL_FUNC(show_verifytrack_save_press), GINT_TO_POINTER(-1));
4263 /* show only in extended view */
4264 if (curset.proc_view == 2)
4265 gtk_widget_show(button2);
4266
4267
4268 /* grab cursor and change to watch */
4269 gtk_grab_add(dialog);
4270 cursor = gdk_cursor_new(GDK_WATCH);
4271 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
4272
4273 /* only center window when toplevel visible */
4274 if (!set_win_geometry(GTK_WIDGET(dialog)) && GTK_WIDGET_VISIBLE(toplevel)) {
4275 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
4276 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
4277 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
4278 gtk_widget_size_request(dialog,&rq);
4279 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
4280 }
4281
4282 gtk_widget_show(dialog);
4283
4284 /* here is the action */
4285 start_verify_action(devnr);
4286
4287 /* when done with reading rename button to OK */
4288 gtk_label_set_text(GTK_LABEL(GTK_BIN(readtrack_button)->child),T_OK);
4289
4290 dobeep(1);
4291
4292 /* now wait until button is pressed */
4293 while (dialog_done == 999) {
4294 wait_and_process_events();
4295 }
4296
4297 store_win_geometry(GTK_WIDGET(dialog));
4298 set_xcdr_title(dialog, toplevel, -1);
4299
4300 gtk_grab_remove(GTK_WIDGET(dialog));
4301 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
4302 gdk_cursor_destroy (cursor);
4303
4304 /* remove dialog window */
4305 gtk_widget_destroy(dialog);
4306
4307 return dialog_done;
4308 }
4309
4310
4311 /* called by buttons in dsptest-window */
4312
dsptest_start(GtkWidget * widget,gpointer data)4313 static void dsptest_start(GtkWidget *widget, gpointer data) {
4314
4315 test_dspdevice_play();
4316 }
4317
dsptest_cancel(GtkWidget * widget,gpointer data)4318 static void dsptest_cancel(GtkWidget *widget, gpointer data) {
4319
4320 dialog_done2 = -1;
4321 }
4322
dsptest_delete_event(GtkWidget * widget,GdkEvent * event,gpointer data)4323 static gint dsptest_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) {
4324
4325 dsptest_cancel(widget,data);
4326 return(TRUE);
4327 }
4328
4329 /* popup a modal window, set cursor to watch, return 0 if correct
4330 data was received from cddb-server, -1 if not or
4331 when cancel or delete_event found.
4332 Centers automatically above the toplevel-widow
4333 */
4334
show_setup_dsptest()4335 void show_setup_dsptest() {
4336 GtkWidget *dialog;
4337 GtkWidget *button1, *button2;
4338 GtkWidget *box1,*box2,*box3,*txt;
4339 GtkWidget *f1;
4340 gint xpos, ypos;
4341 gint xsize, ysize;
4342 GdkCursor *cursor;
4343 GtkRequisition rq;
4344 gchar tmp[MAXLINE];
4345
4346 /* if another dialog is running, ignore */
4347 if (dialog_done2 == 999) {
4348 return;
4349 }
4350
4351 dodebug(8, "displaying show_setup_dsptest\n");
4352
4353 /* mark our dialog as running */
4354 dialog_done2 = 999;
4355 misc_timer = 0;
4356
4357 /* create new window and position it relative to the main window */
4358 dialog = my_gtk_dialog_new();
4359 set_xcdr_title(dialog, NULL, -1);
4360 gtk_widget_set_usize(dialog,tbf(420),tbf(160));
4361 /* make sure our window is always on top */
4362 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
4363
4364 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
4365 GTK_SIGNAL_FUNC (dsptest_delete_event), (gpointer) dialog);
4366
4367 /* create layout for dialog */
4368 box1 = gtk_vbox_new(FALSE,0);
4369 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
4370 gtk_container_add(GTK_CONTAINER(dialog),box1);
4371
4372 f1 = gtk_frame_new(_("Test DSP-Device"));
4373 set_font_and_color_frame(f1,BOLDFONT,NULL);
4374 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
4375 gtk_widget_show(f1);
4376
4377 box2 = gtk_vbox_new(FALSE,0);
4378 gtk_container_set_border_width (GTK_CONTAINER (box2), 5);
4379 gtk_container_add(GTK_CONTAINER(f1),box2);
4380 gtk_widget_show(box2);
4381
4382
4383 txt = gtk_text_new(NULL,NULL);
4384 blank_text_window = txt;
4385 gtk_text_set_editable(GTK_TEXT(txt),FALSE);
4386 gtk_text_set_word_wrap(GTK_TEXT(txt),TRUE);
4387 gtk_box_pack_start(GTK_BOX(box2),txt,TRUE,TRUE,0);
4388 gtk_widget_show(txt);
4389
4390 gtk_widget_show(box1);
4391
4392 box3 = gtk_hbox_new(FALSE,0);
4393 gtk_box_pack_start(GTK_BOX(box1),box3,FALSE,TRUE,5);
4394 gtk_widget_show(box3);
4395
4396 button1 = gtk_button_new_with_label(_("Play demo sample"));
4397 gtk_box_pack_start(GTK_BOX(box3),button1,TRUE,TRUE,10);
4398 gtk_widget_show(button1);
4399 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
4400 GTK_SIGNAL_FUNC(dsptest_start), NULL);
4401
4402 button2 = gtk_button_new_with_label(T_CLOSE);
4403 readtrack_button = button2;
4404 gtk_box_pack_start(GTK_BOX(box3),button2,TRUE,TRUE,10);
4405 gtk_widget_show(button2);
4406 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
4407 GTK_SIGNAL_FUNC(dsptest_cancel), GINT_TO_POINTER(-1));
4408
4409
4410 /* grab cursor and change to watch */
4411 gtk_grab_add(dialog);
4412 cursor = gdk_cursor_new(GDK_WATCH);
4413 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
4414
4415 /* only center window when toplevel visible */
4416 if ( GTK_WIDGET_VISIBLE(toplevel)) {
4417 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
4418 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
4419 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
4420 gtk_widget_size_request(dialog,&rq);
4421 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
4422 }
4423
4424 /* now fill text-widget with infos */
4425 strncpy(tmp,_("Here you can test if X-CD-Roast is able to access your sound\nhardware to play audio tracks in CD quality.\nWhen you press the \"Play demo sample\" button, you should be\nable to hear a chime from your soundcard. Otherwise your\nDSP-Device is either not supported, or turned off or busy by\nanother program."),MAXLINE);
4426
4427 convert_for_gtk2_textwidget(tmp);
4428 gtk_text_insert(GTK_TEXT(txt),NULL,NULL,NULL,
4429 tmp, strlen(tmp));
4430
4431 gtk_widget_show(dialog);
4432
4433
4434 /* now wait until button is pressed */
4435 while (dialog_done2 == 999) {
4436 wait_and_process_events();
4437 }
4438
4439 gtk_grab_remove(GTK_WIDGET(dialog));
4440 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
4441 gdk_cursor_destroy (cursor);
4442
4443 /* remove dialog window */
4444 gtk_widget_destroy(dialog);
4445 }
4446
4447
redirect_ok(GtkWidget * widget,gpointer data)4448 static void redirect_ok(GtkWidget *widget, gpointer data) {
4449
4450 dialog_done2 = 0;
4451 }
4452
redirect_cancel(GtkWidget * widget,gpointer data)4453 static void redirect_cancel(GtkWidget *widget, gpointer data) {
4454
4455 dialog_done2 = -1;
4456 }
4457
redirect_delete_event(GtkWidget * widget,GdkEvent * event,gpointer data)4458 static gint redirect_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) {
4459
4460 redirect_cancel(widget,data);
4461 return(TRUE);
4462 }
4463
4464
4465 /* popup a modal window, set cursor to watch, return 0 if correct
4466 data was entered, -1 if not or
4467 when cancel or delete_event found.
4468 Centers automatically above the toplevel-widow
4469 */
4470
show_request_redirect_path(gchar * path,gchar * ret)4471 gint show_request_redirect_path(gchar *path, gchar *ret) {
4472 GtkWidget *dialog;
4473 GtkWidget *button1, *button2;
4474 GtkWidget *box1,*box2,*box3;
4475 GtkWidget *f1, *l1, *entry;
4476 gint xpos, ypos;
4477 gint xsize, ysize;
4478 GdkCursor *cursor;
4479 GtkRequisition rq;
4480 gchar tmp[MAXLINE];
4481 gchar tmp2[MAXLINE];
4482
4483 /* if another dialog is running, ignore */
4484 if (dialog_done2 == 999) {
4485 return -1;
4486 }
4487
4488 dodebug(8, "displaying show_request_redirect_path\n");
4489
4490 /* mark our dialog as running */
4491 dialog_done2 = 999;
4492
4493 /* create new window and position it relative to the main window */
4494 dialog = my_gtk_dialog_new();
4495 set_xcdr_title(dialog, NULL, -1);
4496 gtk_widget_set_usize(dialog,tbf(420),0);
4497 /* make sure our window is always on top */
4498 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
4499
4500 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
4501 GTK_SIGNAL_FUNC (redirect_delete_event), (gpointer) dialog);
4502
4503 /* create layout for dialog */
4504 box1 = gtk_vbox_new(FALSE,0);
4505 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
4506 gtk_container_add(GTK_CONTAINER(dialog),box1);
4507 gtk_widget_show(box1);
4508
4509 f1 = gtk_frame_new(_("Redirect a master directory"));
4510 set_font_and_color_frame(f1,BOLDFONT,NULL);
4511 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
4512 gtk_widget_show(f1);
4513
4514 box2 = gtk_vbox_new(FALSE,5);
4515 gtk_container_set_border_width (GTK_CONTAINER (box2), 5);
4516 gtk_container_add(GTK_CONTAINER(f1),box2);
4517 gtk_widget_show(box2);
4518
4519 l1 = gtk_label_new(_("Please specify where this path in the source data\nshould be redirected to on the destination CD:"));
4520 gtk_box_pack_start(GTK_BOX(box2),l1,FALSE,FALSE,0);
4521 gtk_widget_show(l1);
4522
4523 f1 = gtk_frame_new(NULL);
4524
4525 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_IN);
4526 gtk_box_pack_start(GTK_BOX(box2),f1,FALSE,FALSE,5);
4527 gtk_widget_show(f1);
4528
4529 strncpy(tmp2, path, MAXLINE);
4530 convert_for_gtk2(tmp2);
4531 l1 = gtk_label_new(tmp2);
4532 gtk_container_add(GTK_CONTAINER(f1),l1);
4533 gtk_widget_show(l1);
4534
4535 l1 = gtk_label_new("=>");
4536 gtk_box_pack_start(GTK_BOX(box2),l1,FALSE,FALSE,0);
4537 gtk_widget_show(l1);
4538
4539 entry = gtk_entry_new();
4540 gtk_box_pack_start(GTK_BOX(box2),entry,FALSE,FALSE,5);
4541 gtk_widget_show(entry);
4542
4543 strncpy(tmp2, ret, MAXLINE);
4544 convert_for_gtk2(tmp2);
4545 gtk_entry_set_text(GTK_ENTRY(entry), tmp2);
4546
4547 box3 = gtk_hbox_new(FALSE,0);
4548 gtk_box_pack_start(GTK_BOX(box1),box3,FALSE,TRUE,10);
4549 gtk_widget_show(box3);
4550
4551 button1 = gtk_button_new_with_label(T_OK);
4552 gtk_box_pack_start(GTK_BOX(box3),button1,TRUE,TRUE,10);
4553 gtk_widget_show(button1);
4554 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
4555 GTK_SIGNAL_FUNC(redirect_ok), NULL);
4556
4557 button2 = gtk_button_new_with_label(T_CANCEL);
4558 readtrack_button = button2;
4559 gtk_box_pack_start(GTK_BOX(box3),button2,TRUE,TRUE,10);
4560 gtk_widget_show(button2);
4561 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
4562 GTK_SIGNAL_FUNC(redirect_cancel), GINT_TO_POINTER(-1));
4563
4564
4565 /* grab cursor and change to watch */
4566 gtk_grab_add(dialog);
4567 cursor = gdk_cursor_new(GDK_WATCH);
4568 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
4569
4570 /* only center window when toplevel visible */
4571 if ( GTK_WIDGET_VISIBLE(toplevel)) {
4572 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
4573 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
4574 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
4575 gtk_widget_size_request(dialog,&rq);
4576 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
4577 }
4578
4579 gtk_widget_show(dialog);
4580
4581
4582 /* now wait until button is pressed */
4583 while (dialog_done2 == 999) {
4584 wait_and_process_events();
4585 }
4586
4587 /* ok pressed? */
4588 if (dialog_done2 == 0) {
4589 strncpy(tmp, gtk_entry_get_text(GTK_ENTRY(entry)), MAXLINE);
4590 strip_string(tmp);
4591 convert_for_gtk2_filename(tmp);
4592
4593 /* if our master-path is a directory, add a slash to
4594 the redirection */
4595 if (is_directory(path) && strlen(tmp) > 0) {
4596 if (tmp[strlen(tmp)-1] != '/') {
4597 strcat(tmp,"/");
4598 }
4599 }
4600
4601 strcpy(ret, tmp);
4602 } else {
4603 /* aborted */
4604 strcpy(ret,"");
4605 }
4606
4607 gtk_grab_remove(GTK_WIDGET(dialog));
4608 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
4609 gdk_cursor_destroy (cursor);
4610
4611 /* remove dialog window */
4612 gtk_widget_destroy(dialog);
4613
4614 return dialog_done2;
4615 }
4616
4617
4618 /* popup a modal window, set cursor to watch, return 0 if correct
4619 data was entered, -1 if not or
4620 when cancel or delete_event found.
4621 Centers automatically above the toplevel-widow
4622 */
4623
show_request_redirect_path_multiple(gchar * commonstr,gint nrpaths,gchar * ret)4624 gint show_request_redirect_path_multiple(gchar *commonstr, gint nrpaths, gchar *ret) {
4625 GtkWidget *dialog;
4626 GtkWidget *button1, *button2;
4627 GtkWidget *box1,*box2,*box3;
4628 GtkWidget *f1, *l1, *entry;
4629 gint xpos, ypos;
4630 gint xsize, ysize;
4631 GdkCursor *cursor;
4632 GtkRequisition rq;
4633 gchar tmp[MAXLINE];
4634 gchar tmp2[MAXLINE];
4635
4636 /* if another dialog is running, ignore */
4637 if (dialog_done2 == 999) {
4638 return -1;
4639 }
4640
4641 dodebug(8, "displaying show_request_redirect_path_multiple\n");
4642
4643 /* mark our dialog as running */
4644 dialog_done2 = 999;
4645
4646 /* create new window and position it relative to the main window */
4647 dialog = my_gtk_dialog_new();
4648 set_xcdr_title(dialog, NULL, -1);
4649 gtk_widget_set_usize(dialog,tbf(420),0);
4650 /* make sure our window is always on top */
4651 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
4652
4653 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
4654 GTK_SIGNAL_FUNC (redirect_delete_event), (gpointer) dialog);
4655
4656 /* create layout for dialog */
4657 box1 = gtk_vbox_new(FALSE,0);
4658 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
4659 gtk_container_add(GTK_CONTAINER(dialog),box1);
4660 gtk_widget_show(box1);
4661
4662 f1 = gtk_frame_new(_("Redirect several master directories"));
4663 set_font_and_color_frame(f1,BOLDFONT,NULL);
4664 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
4665 gtk_widget_show(f1);
4666
4667 box2 = gtk_vbox_new(FALSE,5);
4668 gtk_container_set_border_width (GTK_CONTAINER (box2), 5);
4669 gtk_container_add(GTK_CONTAINER(f1),box2);
4670 gtk_widget_show(box2);
4671
4672 l1 = gtk_label_new(_("Please choose to which directory on the destination\nCD the selected paths should be redirected to:"));
4673 gtk_box_pack_start(GTK_BOX(box2),l1,FALSE,FALSE,0);
4674 gtk_widget_show(l1);
4675
4676 f1 = gtk_frame_new(NULL);
4677
4678 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_IN);
4679 gtk_box_pack_start(GTK_BOX(box2),f1,FALSE,FALSE,5);
4680 gtk_widget_show(f1);
4681
4682 strncpy(tmp2, commonstr, MAXLINE);
4683 convert_for_gtk2(tmp2);
4684 g_snprintf(tmp,MAXLINE,_("%s/... (%d paths)"), tmp2, nrpaths);
4685 l1 = gtk_label_new(tmp);
4686 gtk_container_add(GTK_CONTAINER(f1),l1);
4687 gtk_misc_set_alignment(GTK_MISC(l1),0.5,0.5);
4688 gtk_misc_set_padding(GTK_MISC(l1),5,5);
4689 gtk_widget_show(l1);
4690
4691 l1 = gtk_label_new("=>");
4692 gtk_box_pack_start(GTK_BOX(box2),l1,FALSE,FALSE,0);
4693 gtk_widget_show(l1);
4694
4695 entry = gtk_entry_new();
4696 gtk_box_pack_start(GTK_BOX(box2),entry,FALSE,FALSE,5);
4697 gtk_widget_show(entry);
4698 gtk_entry_set_text(GTK_ENTRY(entry), "/");
4699
4700 box3 = gtk_hbox_new(FALSE,0);
4701 gtk_box_pack_start(GTK_BOX(box1),box3,FALSE,TRUE,10);
4702 gtk_widget_show(box3);
4703
4704 button1 = gtk_button_new_with_label(T_OK);
4705 gtk_box_pack_start(GTK_BOX(box3),button1,TRUE,TRUE,10);
4706 gtk_widget_show(button1);
4707 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
4708 GTK_SIGNAL_FUNC(redirect_ok), NULL);
4709
4710 button2 = gtk_button_new_with_label(T_CANCEL);
4711 readtrack_button = button2;
4712 gtk_box_pack_start(GTK_BOX(box3),button2,TRUE,TRUE,10);
4713 gtk_widget_show(button2);
4714 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
4715 GTK_SIGNAL_FUNC(redirect_cancel), GINT_TO_POINTER(-1));
4716
4717
4718 /* grab cursor and change to watch */
4719 gtk_grab_add(dialog);
4720 cursor = gdk_cursor_new(GDK_WATCH);
4721 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
4722
4723 /* only center window when toplevel visible */
4724 if ( GTK_WIDGET_VISIBLE(toplevel)) {
4725 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
4726 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
4727 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
4728 gtk_widget_size_request(dialog,&rq);
4729 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
4730 }
4731
4732 gtk_widget_show(dialog);
4733
4734
4735 /* now wait until button is pressed */
4736 while (dialog_done2 == 999) {
4737 wait_and_process_events();
4738 }
4739
4740 /* ok pressed? */
4741 if (dialog_done2 == 0) {
4742 strncpy(tmp, gtk_entry_get_text(GTK_ENTRY(entry)), MAXLINE);
4743 strip_string(tmp);
4744 convert_for_gtk2_filename(tmp);
4745
4746 /* if our master-path is a directory, add a slash to
4747 the redirection */
4748 if (strlen(tmp) > 0) {
4749 if (tmp[strlen(tmp)-1] != '/') {
4750 strcat(tmp,"/");
4751 }
4752 }
4753
4754 strcpy(ret, tmp);
4755 } else {
4756 /* aborted */
4757 strcpy(ret,"");
4758 }
4759
4760 gtk_grab_remove(GTK_WIDGET(dialog));
4761 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
4762 gdk_cursor_destroy (cursor);
4763
4764 /* remove dialog window */
4765 gtk_widget_destroy(dialog);
4766
4767 return dialog_done2;
4768 }
4769
show_mstrcalc_save_press(GtkWidget * widget,gpointer data)4770 static void show_mstrcalc_save_press(GtkWidget *widget, gpointer data) {
4771 char tmp[MAXLINE];
4772
4773 /* show fileselector */
4774 show_file_selector(_("Save Output"), SAVEMASTERCALC,tmp);
4775
4776 /* not cancel pressed? */
4777 if (strcmp(tmp,"") != 0) {
4778 if (save_text2file(tmp, readtrack_textview) == 0) {
4779 show_dialog(ICO_INFO,_("Saving output successful"), T_OK, NULL, NULL, 0);
4780 }
4781 }
4782 }
4783
4784 /* popup a modal window, set cursor to watch, return path or NULL-string
4785 when cancel or delete_event found.
4786 Centers automatically above the toplevel-widow
4787 */
4788
show_mkisofs_check_output(gint automode,gint * timeout)4789 void show_mkisofs_check_output(gint automode, gint *timeout) {
4790 GtkWidget *dialog;
4791 GtkWidget *button1, *button2;
4792 GtkWidget *box1,*box2,*txt;
4793 GtkWidget *f1;
4794 GtkWidget *scrolled_win;
4795 gint xpos, ypos;
4796 gint xsize, ysize;
4797 GdkCursor *cursor;
4798 GtkRequisition rq;
4799 gchar tmp[MAXLINE];
4800 GdkColor c;
4801
4802 /* if another dialog is running, ignore */
4803 if (dialog_done == 999) {
4804 return;
4805 }
4806
4807 dodebug(8, "displaying show_mkisofs_check_output (automode = %d)\n", automode);
4808
4809 /* mark our dialog as running */
4810 dialog_done = 999;
4811
4812 /* create new window and position it relative to the main window */
4813 dialog = my_gtk_dialog_new();
4814 set_xcdr_title(dialog, NULL, -1);
4815 gtk_widget_set_usize(dialog,tbf(500),tbf(300));
4816 /* make sure our window is always on top */
4817 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
4818
4819 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
4820 GTK_SIGNAL_FUNC (dialog_delete_event), (gpointer) dialog);
4821
4822 /* create layout for dialog */
4823 box1 = gtk_vbox_new(FALSE,0);
4824 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
4825 gtk_container_add(GTK_CONTAINER(dialog),box1);
4826
4827 f1 = gtk_frame_new(_("ISO9660-filesystem build informations/warnings"));
4828 set_font_and_color_frame(f1,BOLDFONT,NULL);
4829 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
4830 gtk_widget_show(f1);
4831
4832 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4833 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
4834 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4835 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
4836 gtk_container_add(GTK_CONTAINER(f1),scrolled_win);
4837 gtk_widget_show(scrolled_win);
4838
4839 txt = gtk_text_new(NULL,NULL);
4840 readtrack_textview = txt;
4841 gtk_text_set_editable(GTK_TEXT(txt),FALSE);
4842 gtk_text_set_word_wrap(GTK_TEXT(txt),TRUE);
4843 gtk_container_add(GTK_CONTAINER(scrolled_win), txt);
4844 gtk_widget_show(txt);
4845
4846 gtk_widget_show(box1);
4847
4848 box2 = gtk_hbox_new(FALSE,0);
4849 gtk_box_pack_start(GTK_BOX(box1),box2,FALSE,TRUE,5);
4850 gtk_widget_show(box2);
4851
4852 button1 = gtk_button_new_with_label(T_CANCEL);
4853 readtrack_button = button1;
4854 gtk_box_pack_start(GTK_BOX(box2),button1,TRUE,TRUE,10);
4855 gtk_widget_show(button1);
4856 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
4857 gtk_widget_grab_default (button1);
4858 gtk_signal_connect(GTK_OBJECT(readtrack_button),"clicked",
4859 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(0));
4860
4861 button2 = gtk_button_new_with_label(_("Save Output"));
4862 readtrack_savebutton = button2;
4863 gtk_box_pack_start(GTK_BOX(box2),button2,TRUE,TRUE,10);
4864 gtk_widget_show(button2);
4865 GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
4866 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
4867 GTK_SIGNAL_FUNC(show_mstrcalc_save_press), GINT_TO_POINTER(-1));
4868
4869
4870 /* grab cursor and change to watch */
4871 gtk_grab_add(dialog);
4872 cursor = gdk_cursor_new(GDK_WATCH);
4873 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
4874
4875 /* only center window when toplevel visible */
4876 if ( GTK_WIDGET_VISIBLE(toplevel)) {
4877 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
4878 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
4879 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
4880 gtk_widget_size_request(dialog,&rq);
4881 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
4882 }
4883
4884 /* show only when not in automatic mode */
4885 if (automode == 0)
4886 gtk_widget_show(dialog);
4887
4888 /* now fill text-widget with infos */
4889 fill_mkisofs_check_info(txt);
4890 /* gtk_text_set_point(GTK_TEXT(txt),0); */
4891
4892 /* when done with reading rename button to OK */
4893 gtk_label_set_text(GTK_LABEL(GTK_BIN(readtrack_button)->child),T_OK);
4894
4895 /* getting size failed in auto mode */
4896 if (automode && masterparam.session_size == 0) {
4897
4898 /* hide timeoutwindow if it was present */
4899 if (mkisofs_calc_timeout_dialog) {
4900 gtk_widget_hide(mkisofs_calc_timeout_dialog);
4901 }
4902 /* remove the timeout, if it did not kick in yet */
4903 if (*timeout) {
4904 gtk_timeout_remove(*timeout);
4905 *timeout = 0;
4906 }
4907
4908 /* display dialog now to show the problem */
4909 gtk_widget_show(dialog);
4910
4911 /* scroll to last line */
4912 gtk_text_set_point(GTK_TEXT(txt),
4913 gtk_text_get_length(GTK_TEXT(txt)));
4914 g_snprintf(tmp,MAXLINE,"\n%s\n", _("-> mkisofs reported an error while calculating the session size!"));
4915 convert_for_gtk2_textwidget(tmp);
4916
4917 gdk_color_parse("red",&c);
4918 if (!gdk_color_alloc(gtk_widget_get_colormap(dialog),&c)) {
4919 /* getting color failed, dont use it */
4920 gtk_text_insert(GTK_TEXT(txt), fixedfont, NULL, NULL,
4921 tmp, strlen(tmp));
4922 } else {
4923 gtk_text_insert(GTK_TEXT(txt), fixedfont, &c, NULL,
4924 tmp, strlen(tmp));
4925 }
4926 }
4927
4928 /* getting size successful in auto mode? */
4929 if (automode && masterparam.session_size > 0) {
4930 /* trigger not to wait for a button */
4931 dialog_done = 0;
4932 }
4933
4934 /* now wait until button is pressed */
4935 while (dialog_done == 999) {
4936 wait_and_process_events();
4937 }
4938
4939 gtk_grab_remove(GTK_WIDGET(dialog));
4940 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
4941 gdk_cursor_destroy (cursor);
4942
4943 /* remove dialog window */
4944 gtk_widget_destroy(dialog);
4945 }
4946
4947
show_master_save_press(GtkWidget * widget,gpointer data)4948 static void show_master_save_press(GtkWidget *widget, gpointer data) {
4949 char tmp[MAXLINE];
4950
4951 /* show fileselector */
4952 show_file_selector(_("Save Output"), SAVEMASTERTRACK,tmp);
4953
4954 /* not cancel pressed? */
4955 if (strcmp(tmp,"") != 0) {
4956 if (save_text2file(tmp, readtrack_textview) == 0) {
4957 show_dialog(ICO_INFO,_("Saving output successful"), T_OK, NULL, NULL, 0);
4958 }
4959 }
4960 }
4961
4962
4963 /* popup a modal window and start to master a image to the harddisk */
4964
show_and_start_master()4965 gint show_and_start_master() {
4966 GtkWidget *omenu;
4967 GtkWidget *menu;
4968 GtkWidget *menu_item;
4969 GtkWidget *dialog;
4970 GtkWidget *l1;
4971 GtkWidget *button1, *button2;
4972 GtkWidget *box1,*box2,*txt;
4973 GtkWidget *f1, *tbl;
4974 GtkWidget *b1_sep, *lbl;
4975 GtkWidget *scrolled_win;
4976 gint xpos, ypos;
4977 gint xsize, ysize;
4978 GdkCursor *cursor;
4979 GtkRequisition rq;
4980 GtkAdjustment *adj1;
4981 GtkWidget *pbar1;
4982 gint i, menuidx, menuhistory;
4983 static const gchar *viewmodes[] = VIEW_MODES;
4984
4985 /* if another dialog is running, ignore */
4986 if (dialog_done == 999) {
4987 return -1;
4988 }
4989
4990 dodebug(8, "displaying show_and_start_master\n");
4991
4992 /* mark our dialog as running */
4993 dialog_done = 999;
4994
4995 /* create new window and position it relative to the main window */
4996 dialog = my_gtk_dialog_new();
4997 viewmode_dialog = dialog;
4998 set_xcdr_title(dialog, toplevel, 0);
4999 gtk_widget_set_usize(dialog,tbf(400),0);
5000 /* make sure our window is always on top */
5001 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
5002
5003 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
5004 GTK_SIGNAL_FUNC (readtrack_dialog_delete_event),
5005 (gpointer) dialog);
5006
5007 /* create layout for dialog */
5008 box1 = gtk_vbox_new(FALSE,5);
5009 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
5010 gtk_container_add(GTK_CONTAINER(dialog),box1);
5011
5012 f1 = gtk_frame_new(NULL);
5013 readtrack_info_frame = f1;
5014 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_IN);
5015 gtk_widget_set_usize(f1,0,36);
5016 gtk_box_pack_start(GTK_BOX(box1),f1,FALSE,TRUE,5);
5017 if (curset.proc_view > 0)
5018 gtk_widget_show(f1);
5019
5020 lbl = gtk_label_new("");
5021 readtrack_info_label = lbl;
5022 gtk_container_add(GTK_CONTAINER(f1), lbl);
5023 gtk_misc_set_alignment(GTK_MISC(lbl),0.5,0.5);
5024 gtk_misc_set_padding(GTK_MISC(lbl),10,0);
5025 gtk_widget_show(lbl);
5026
5027 tbl = gtk_table_new(1, 10, TRUE);
5028 readtrack_info_tbl = tbl;
5029 gtk_table_set_col_spacing(GTK_TABLE(tbl),1,10);
5030 gtk_table_set_row_spacings(GTK_TABLE(tbl),5);
5031 gtk_box_pack_start(GTK_BOX(box1),tbl,FALSE,TRUE,5);
5032 if (curset.proc_view > 0)
5033 gtk_widget_show(tbl);
5034
5035 l1 = rightjust_gtk_label_new(_("Track:"));
5036 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,0,2,0,1);
5037 gtk_widget_show(l1);
5038
5039 adj1 = (GtkAdjustment *)gtk_adjustment_new(0, 0, 100, 0, 0, 0);
5040 pbar1 = gtk_progress_bar_new_with_adjustment(adj1);
5041 readtrack_pbar1 = pbar1;
5042 gtk_progress_set_format_string(GTK_PROGRESS(pbar1),"%p%%");
5043 gtk_progress_set_show_text(GTK_PROGRESS(pbar1),TRUE);
5044 gtk_table_attach_defaults(GTK_TABLE(tbl),pbar1,2,10,0,1);
5045 gtk_widget_show(pbar1);
5046
5047 tbl = gtk_table_new(1, 10, TRUE);
5048 gtk_table_set_col_spacing(GTK_TABLE(tbl),6,10);
5049 gtk_table_set_row_spacings(GTK_TABLE(tbl),5);
5050 gtk_box_pack_start(GTK_BOX(box1),tbl,FALSE,TRUE,0);
5051 gtk_widget_show(tbl);
5052
5053 lbl = gtk_label_new("");
5054 readtrack_small_info = lbl;
5055 gtk_table_attach_defaults(GTK_TABLE(tbl),lbl,0,3,0,1);
5056 if (curset.proc_view == 0)
5057 gtk_widget_show(lbl);
5058
5059 lbl = gtk_label_new("");
5060 readtrack_small_info2 = lbl;
5061 gtk_table_attach_defaults(GTK_TABLE(tbl),lbl,3,5,0,1);
5062 if (curset.proc_view == 0)
5063 gtk_widget_show(lbl);
5064
5065 l1 = rightjust_gtk_label_new(_("View:"));
5066 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,5,7,0,1);
5067 gtk_widget_show(l1);
5068
5069 omenu = gtk_option_menu_new();
5070 menu = gtk_menu_new();
5071 menuidx = 0; menuhistory = -1;
5072
5073 for (i=0; i<3; i++) {
5074 menu_item = gtk_menu_item_new_with_label(_(viewmodes[i]));
5075 gtk_signal_connect(GTK_OBJECT(menu_item),
5076 "activate", GTK_SIGNAL_FUNC(viewmode_selected),
5077 GINT_TO_POINTER(i));
5078 gtk_menu_append (GTK_MENU (menu), menu_item);
5079 if (curset.proc_view == i) { menuhistory = menuidx; }
5080 menuidx++;
5081 gtk_widget_show (menu_item);
5082 }
5083 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
5084 if (menuhistory != -1) {
5085 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),menuhistory);
5086 } else {
5087 curset.proc_view = 1;
5088 gtk_option_menu_set_history(GTK_OPTION_MENU (omenu),1);
5089 }
5090 gtk_table_attach_defaults(GTK_TABLE(tbl),omenu,7,10,0,1);
5091 gtk_widget_show(omenu);
5092
5093 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
5094 viewmode_scrolled = scrolled_win;
5095 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
5096 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
5097 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
5098 gtk_box_pack_start(GTK_BOX(box1),scrolled_win,TRUE,TRUE,0);
5099
5100 /* show only in extended view */
5101 if (curset.proc_view == 2)
5102 gtk_widget_show(scrolled_win);
5103
5104 txt = gtk_text_new(NULL,NULL);
5105 readtrack_textview = txt;
5106 gtk_text_set_editable(GTK_TEXT(txt),FALSE);
5107 gtk_text_set_word_wrap(GTK_TEXT(txt),TRUE);
5108 gtk_container_add(GTK_CONTAINER(scrolled_win), txt);
5109 gtk_widget_show(txt);
5110
5111 gtk_widget_show(box1);
5112
5113 b1_sep = gtk_hseparator_new();
5114 gtk_box_pack_start(GTK_BOX(box1),b1_sep,FALSE,TRUE,0);
5115 gtk_widget_show(b1_sep);
5116
5117 box2 = gtk_hbox_new(FALSE,0);
5118 gtk_box_pack_start(GTK_BOX(box1),box2,FALSE,TRUE,10);
5119 gtk_widget_show(box2);
5120
5121 button1 = gtk_button_new_with_label(T_CANCEL);
5122 readtrack_button = button1;
5123 gtk_box_pack_start(GTK_BOX(box2),button1,TRUE,TRUE,10);
5124 gtk_widget_show(button1);
5125 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
5126 gtk_widget_grab_default (button1);
5127 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
5128 GTK_SIGNAL_FUNC(show_readtrack_btn_press), GINT_TO_POINTER(-1));
5129
5130 button2 = gtk_button_new_with_label(_("Save Output"));
5131 readtrack_savebutton = button2;
5132 gtk_box_pack_start(GTK_BOX(box2),button2,TRUE,TRUE,10);
5133 GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
5134 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
5135 GTK_SIGNAL_FUNC(show_master_save_press), GINT_TO_POINTER(-1));
5136 /* show only in extended view */
5137 if (curset.proc_view == 2)
5138 gtk_widget_show(button2);
5139
5140
5141 /* grab cursor and change to watch */
5142 gtk_grab_add(dialog);
5143 cursor = gdk_cursor_new(GDK_WATCH);
5144 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
5145
5146 /* only center window when toplevel visible */
5147 if (!set_win_geometry(GTK_WIDGET(dialog)) && GTK_WIDGET_VISIBLE(toplevel)) {
5148 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
5149 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
5150 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
5151 gtk_widget_size_request(dialog,&rq);
5152 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
5153 }
5154
5155 gtk_widget_show(dialog);
5156
5157 /* here is the action */
5158 start_master_action();
5159
5160 /* update image-dir-lists */
5161 scan_imagedirs();
5162
5163 /* when done with reading rename button to OK */
5164 gtk_label_set_text(GTK_LABEL(GTK_BIN(readtrack_button)->child),T_OK);
5165
5166 dobeep(1);
5167
5168 /* now wait until button is pressed */
5169 while (dialog_done == 999) {
5170 wait_and_process_events();
5171 }
5172
5173 store_win_geometry(GTK_WIDGET(dialog));
5174 set_xcdr_title(dialog, toplevel, -1);
5175
5176 gtk_grab_remove(GTK_WIDGET(dialog));
5177 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
5178 gdk_cursor_destroy (cursor);
5179
5180 /* remove dialog window */
5181 gtk_widget_destroy(dialog);
5182
5183 return dialog_done;
5184 }
5185
5186
5187 /* called from radio buttons in redir menu */
5188
redir_type_selected(GtkWidget * item,gpointer data)5189 static void redir_type_selected(GtkWidget *item, gpointer data) {
5190
5191 masterparam.redirtype = GPOINTER_TO_INT(data);
5192
5193 if (!redir_entry) return;
5194
5195 if (masterparam.redirtype != 3) {
5196 gtk_widget_set_sensitive(redir_entry, FALSE);
5197 } else {
5198 gtk_widget_set_sensitive(redir_entry, TRUE);
5199 }
5200 }
5201
5202
5203 /* called from radio buttons in redir_multi menu */
5204
redir_type_selected2(GtkWidget * item,gpointer data)5205 static void redir_type_selected2(GtkWidget *item, gpointer data) {
5206
5207 masterparam.redirtype2 = GPOINTER_TO_INT(data);
5208
5209 if (!redir_entry) return;
5210
5211 if (masterparam.redirtype2 != 3) {
5212 gtk_widget_set_sensitive(redir_entry, FALSE);
5213 } else {
5214 gtk_widget_set_sensitive(redir_entry, TRUE);
5215 }
5216 }
5217
5218
5219 /* popup a modal window, where the user can choose where
5220 to add the new directory on the target CD.
5221 Centers automatically above the toplevel-widow
5222 */
5223
show_mstr_redir(gchar * dir,gchar * ret)5224 gint show_mstr_redir(gchar *dir, gchar *ret) {
5225 GtkWidget *dialog;
5226 GtkWidget *button1;
5227 GtkWidget *button2, *entry;
5228 GtkWidget *box1,*box2,*box3;
5229 GtkWidget *f1, *f2, *f3, *l1;
5230 GtkWidget *b1_sep, *lbl, *btn;
5231 GSList *group;
5232 gint xpos, ypos;
5233 gint xsize, ysize;
5234 GdkCursor *cursor;
5235 GtkRequisition rq;
5236 gchar redir[MAXLINE], redir2[MAXLINE], tmp2[MAXLINE];
5237 gchar filename[MAXLINE];
5238 gint is_dir;
5239 gint bak_redirtype;
5240 gchar *p;
5241 gchar tmp[MAXLINE];
5242
5243 /* if another dialog is running, ignore */
5244 if (dialog_done == 999) {
5245 return -1;
5246 }
5247
5248 dodebug(8, "displaying show_mstr_redir\n");
5249
5250 /* mark our dialog as running */
5251 dialog_done = 999;
5252
5253 bak_redirtype = masterparam.redirtype;
5254 redir_entry = NULL;
5255
5256 /* create new window and position it relative to the main window */
5257 dialog = my_gtk_dialog_new();
5258 set_xcdr_title(dialog, NULL, -1);
5259 gtk_widget_set_usize(dialog,tbf(450),tbf(320));
5260 /* make sure our window is always on top */
5261 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
5262 cddb_window = dialog;
5263
5264 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
5265 GTK_SIGNAL_FUNC (dialog_delete_event), (gpointer) dialog);
5266
5267 /* create layout for dialog */
5268 box1 = gtk_vbox_new(FALSE,5);
5269 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
5270 gtk_container_add(GTK_CONTAINER(dialog),box1);
5271 gtk_widget_show(box1);
5272
5273 f1 = gtk_frame_new(_("Adding path to master directories"));
5274 set_font_and_color_frame(f1,BOLDFONT,NULL);
5275 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
5276 gtk_widget_show(f1);
5277
5278 box2 = gtk_vbox_new(FALSE,0);
5279 gtk_container_set_border_width (GTK_CONTAINER (box2), 5);
5280 gtk_container_add(GTK_CONTAINER(f1),box2);
5281 gtk_widget_show(box2);
5282
5283 f2 = gtk_frame_new(NULL);
5284 gtk_frame_set_shadow_type(GTK_FRAME(f2),GTK_SHADOW_IN);
5285 gtk_box_pack_start(GTK_BOX(box2),f2,FALSE,TRUE,5);
5286 gtk_widget_show(f2);
5287
5288 strncpy(tmp2, dir, MAXLINE);
5289 convert_for_gtk2(tmp2);
5290 l1 = gtk_label_new(tmp2);
5291 gtk_container_add(GTK_CONTAINER(f2),l1);
5292 gtk_misc_set_alignment(GTK_MISC(l1),0.5,0.5);
5293 gtk_misc_set_padding(GTK_MISC(l1),5,5);
5294 gtk_widget_show(l1);
5295
5296 /* handling a file or a directory here? */
5297 is_dir = is_directory(dir);
5298
5299 if (is_dir) {
5300 strcpy(filename, "");
5301 lbl = gtk_label_new(_("Please choose where the contents of this directory\nshould be located on the CD:"));
5302 } else {
5303
5304 /* its a file, so store its filename without path */
5305 get_purefile(dir, filename);
5306 lbl = gtk_label_new(_("Please choose where this file should be located on the CD:"));
5307 }
5308 gtk_box_pack_start(GTK_BOX(box2),lbl,FALSE,TRUE,5);
5309 gtk_widget_show(lbl);
5310
5311 b1_sep = gtk_hseparator_new();
5312 gtk_box_pack_start(GTK_BOX(box2),b1_sep,FALSE,TRUE,5);
5313 gtk_widget_show(b1_sep);
5314
5315 btn = gtk_radio_button_new_with_label(NULL,_("Add to root directory of CD (\"/\")"));
5316 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
5317 GTK_SIGNAL_FUNC(redir_type_selected),GINT_TO_POINTER(0));
5318
5319 gtk_box_pack_start(GTK_BOX(box2),btn,FALSE,TRUE,0);
5320 gtk_widget_show(btn);
5321 define_tooltip(btn,_("Will put this file or directory content in the root directory of the destination CD. (Strips off its current path completely.)"));
5322 if (masterparam.redirtype == 0)
5323 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn),1);
5324 group = gtk_radio_button_group (GTK_RADIO_BUTTON(btn));
5325
5326 strncpy(redir,dir,MAXLINE);
5327 get_basedir(redir);
5328 if (redir == NULL) {
5329 strcpy(redir,"/");
5330 } else {
5331 /* look for last slash */
5332 p = rindex(redir,'/');
5333 if (p) {
5334 /* use only the part beginning from last slash */
5335 strncpy(tmp2, p, MAXLINE);
5336 strncpy(redir, tmp2, MAXLINE);
5337 } else {
5338 strcpy(redir,"/");
5339 }
5340 }
5341
5342 strncpy(tmp2, redir, MAXLINE);
5343 convert_for_gtk2(tmp2);
5344 g_snprintf(tmp,MAXLINE,_("Add with last path component (\"%s\")"), tmp2);
5345
5346 btn = gtk_radio_button_new_with_label(group,tmp);
5347 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
5348 GTK_SIGNAL_FUNC(redir_type_selected),GINT_TO_POINTER(1));
5349 gtk_box_pack_start(GTK_BOX(box2),btn,FALSE,TRUE,0);
5350 gtk_widget_show(btn);
5351 define_tooltip(btn,_("Will put this file or directory on the destination CD while keeping its last part of the directory intact. (e.g. a directory /home/user will become /user on the CD.)"));
5352 if (masterparam.redirtype == 1)
5353 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn),1);
5354 group = gtk_radio_button_group (GTK_RADIO_BUTTON(btn));
5355
5356 strncpy(redir2,dir,MAXLINE);
5357 get_basedir(redir2);
5358 if (redir2 == NULL) { strcpy(redir2,"/"); }
5359
5360 strncpy(tmp2, redir2, MAXLINE);
5361 convert_for_gtk2(tmp2);
5362 g_snprintf(tmp,MAXLINE,_("Add with full path (\"%s\")"), tmp2);
5363
5364 btn = gtk_radio_button_new_with_label(group,tmp);
5365 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
5366 GTK_SIGNAL_FUNC(redir_type_selected),GINT_TO_POINTER(2));
5367 gtk_box_pack_start(GTK_BOX(box2),btn,FALSE,TRUE,0);
5368 gtk_widget_show(btn);
5369 define_tooltip(btn,_("Will put this file or directory in the same path on the destination CD, as it is on the hard drive now. (e.g. a directory /home/user will also become /home/user on the CD.)"));
5370 if (masterparam.redirtype == 2)
5371 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn),1);
5372 group = gtk_radio_button_group (GTK_RADIO_BUTTON(btn));
5373
5374 btn = gtk_radio_button_new_with_label(group,_("Add with custom path:"));
5375 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
5376 GTK_SIGNAL_FUNC(redir_type_selected),GINT_TO_POINTER(3));
5377 gtk_box_pack_start(GTK_BOX(box2),btn,FALSE,TRUE,0);
5378 gtk_widget_show(btn);
5379 define_tooltip(btn,_("Lets you specify exactly where the file or directory content should be mapped to on the destination CD. (e.g. a directory /home/user can be mapped to /backup/home-dirs/user.)"));
5380 if (masterparam.redirtype == 3)
5381 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn),1);
5382
5383 f3 = gtk_hbox_new(FALSE,0);
5384 gtk_box_pack_start(GTK_BOX(box2),f3,FALSE,FALSE,5);
5385 gtk_widget_show(f3);
5386
5387 entry = gtk_entry_new();
5388 redir_entry = entry;
5389 gtk_box_pack_start(GTK_BOX(f3),entry,TRUE,TRUE,20);
5390 gtk_widget_show(entry);
5391 gtk_entry_set_text(GTK_ENTRY(entry), masterparam.lastredirpath);
5392 if (masterparam.redirtype != 3)
5393 gtk_widget_set_sensitive(redir_entry, FALSE);
5394
5395 box3 = gtk_hbox_new(FALSE,0);
5396 gtk_box_pack_start(GTK_BOX(box1),box3,FALSE,TRUE,10);
5397 gtk_widget_show(box3);
5398
5399 button1 = gtk_button_new_with_label(T_OK);
5400 cddb_info_okbutton = button1;
5401 gtk_box_pack_start(GTK_BOX(box3),button1,TRUE,TRUE,10);
5402 gtk_widget_show(button1);
5403 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
5404 gtk_widget_grab_default (button1);
5405 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
5406 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(0));
5407
5408 button2 = gtk_button_new_with_label(T_CANCEL);
5409 gtk_box_pack_start(GTK_BOX(box3),button2,TRUE,TRUE,10);
5410 gtk_widget_show(button2);
5411 GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
5412 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
5413 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(-1));
5414
5415
5416 /* grab cursor and change to watch */
5417 gtk_grab_add(dialog);
5418 cursor = gdk_cursor_new(GDK_WATCH);
5419 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
5420
5421 /* only center window when toplevel visible */
5422 if ( GTK_WIDGET_VISIBLE(toplevel)) {
5423 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
5424 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
5425 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
5426 gtk_widget_size_request(dialog,&rq);
5427 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
5428 }
5429
5430 gtk_widget_show(dialog);
5431
5432
5433 /* now wait until button is pressed */
5434 while (dialog_done == 999) {
5435 wait_and_process_events();
5436 }
5437
5438 gtk_grab_remove(GTK_WIDGET(dialog));
5439 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
5440 gdk_cursor_destroy (cursor);
5441
5442 if (dialog_done != 0) {
5443 /* restore original value of type */
5444 masterparam.redirtype = bak_redirtype;
5445 strcpy(redir,"");
5446 } else {
5447 /* ok pressed, do some business */
5448 g_free(masterparam.lastredirpath);
5449 strncpy(tmp, gtk_entry_get_text(GTK_ENTRY(redir_entry)), MAXLINE);
5450 convert_for_gtk2_filename(tmp);
5451
5452 masterparam.lastredirpath = g_strdup(tmp);
5453
5454 if (masterparam.redirtype == 0) {
5455 strcpy(redir,"/");
5456 }
5457
5458 if (masterparam.redirtype == 2) {
5459 strcpy(redir,redir2);
5460 }
5461
5462 if (masterparam.redirtype == 3) {
5463 strncpy(redir,masterparam.lastredirpath, MAXLINE);
5464 }
5465 strip_string(redir);
5466
5467 /* because we handle only directories here, add a slash */
5468 if (strlen(redir) > 0) {
5469 if (redir[strlen(redir)-1] != '/') {
5470 strcat(redir,"/");
5471 }
5472 }
5473
5474 /* and if we are adding a file, add its filename */
5475 if (strlen(redir) + strlen(filename) < MAXLINE) {
5476 strcat(redir, filename);
5477 }
5478 }
5479
5480 /* remove dialog window */
5481 gtk_widget_destroy(dialog);
5482
5483 /* now "redir" contains the string where we want to go */
5484 strncpy(ret, redir, MAXLINE);
5485
5486 return dialog_done;
5487 }
5488
5489
5490 /* radio button to sync all cdtext artists */
5491
cdtext_sync_artist(GtkWidget * item,gpointer data)5492 static void cdtext_sync_artist(GtkWidget *item, gpointer data) {
5493 gint i;
5494 gchar *p;
5495
5496 curset.sync_cdtext_artist = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(item));
5497
5498 i = 1;
5499 /* sync all */
5500 if (curset.sync_cdtext_artist == 1) {
5501 /* get artist of disk */
5502 p = (gchar *) gtk_entry_get_text(GTK_ENTRY(cdtext_entry2[0]));
5503 if (!p) return;
5504 while(cdtext_entry2[i]) {
5505 /* copy artist to all artists */
5506 gtk_entry_set_text(GTK_ENTRY(cdtext_entry2[i]), p);
5507 gtk_widget_set_sensitive(cdtext_entry2[i], FALSE);
5508 i++;
5509 }
5510 } else {
5511 /* no longer sync all */
5512 while(cdtext_entry2[i]) {
5513 gtk_widget_set_sensitive(cdtext_entry2[i], TRUE);
5514 i++;
5515 }
5516 }
5517 }
5518
5519
5520 /* called when the cdtext artist of the disk is changed */
5521
cdtext_artist_changed(GtkWidget * item,gpointer data)5522 static void cdtext_artist_changed(GtkWidget *item, gpointer data) {
5523 gint i;
5524 gchar *p;
5525
5526 i = 1;
5527 if (curset.sync_cdtext_artist == 1) {
5528 p = (gchar *) gtk_entry_get_text(GTK_ENTRY(cdtext_entry2[0]));
5529 if (!p) return;
5530 while(cdtext_entry2[i]) {
5531 /* copy current status to all fields */
5532 gtk_entry_set_text(GTK_ENTRY(cdtext_entry2[i]), p);
5533 i++;
5534 }
5535 }
5536 }
5537
5538
5539 /* called by clear all button */
5540
cdtext_clear_all(GtkWidget * item,gpointer data)5541 static void cdtext_clear_all(GtkWidget *item, gpointer data) {
5542 gint i;
5543
5544 i = 0;
5545 while(cdtext_entry1[i]) {
5546 gtk_entry_set_text(GTK_ENTRY(cdtext_entry1[i]),"");
5547 gtk_entry_set_text(GTK_ENTRY(cdtext_entry2[i]),"");
5548 i++;
5549 }
5550 }
5551
5552
5553 /* set artist and disc title from cddb */
5554
cdtext_set_dtitle(gchar * dtitle)5555 void cdtext_set_dtitle(gchar *dtitle) {
5556 gchar title[MAXLINE];
5557 gchar artist[MAXLINE];
5558
5559 get_artist_and_title_from_cddb(dtitle, title, artist);
5560 if (cdtext_entry1[0])
5561 gtk_entry_set_text(GTK_ENTRY(cdtext_entry1[0]),convert_for_gtk2(title));
5562 if (cdtext_entry2[0])
5563 gtk_entry_set_text(GTK_ENTRY(cdtext_entry2[0]),convert_for_gtk2(artist));
5564 }
5565
5566
5567 /* set track-title from cddb */
5568
cdtext_set_ttitle(gchar * ttitle,gint nr)5569 void cdtext_set_ttitle(gchar *ttitle, gint nr) {
5570 gchar tmp[MAXLINE];
5571
5572 strncpy(tmp, ttitle, MAXLINE);
5573
5574 if (cdtext_entry1[nr])
5575 gtk_entry_set_text(GTK_ENTRY(cdtext_entry1[nr]),convert_for_gtk2(tmp));
5576 if (cdtext_entry2[nr])
5577 gtk_entry_set_text(GTK_ENTRY(cdtext_entry2[nr]),"");
5578
5579 }
5580
5581
5582 /* called on ok button of cdtext editor (mode 0) */
5583 /* copies the entered cdtext data to memory structure */
5584
cdtext_edit_ok_mode0()5585 static void cdtext_edit_ok_mode0() {
5586 gint i;
5587
5588 /* set cd-info first */
5589 g_free(cdinfo.title);
5590 cdinfo.title = g_strdup(gtk_entry_get_text(GTK_ENTRY(cdtext_entry1[0])));
5591 g_free(cdinfo.artist);
5592 cdinfo.artist = g_strdup(gtk_entry_get_text(GTK_ENTRY(cdtext_entry2[0])));
5593 /* free cddb info now */
5594 if (cdinfo.cddb_dtitle) {
5595 g_free(cdinfo.cddb_dtitle);
5596 cdinfo.cddb_dtitle = NULL;
5597 }
5598
5599 i = 1;
5600 while(cdtext_entry2[i]) {
5601 /* copy the new entered data to my cd-text data */
5602
5603 g_free(trackinfo[i-1]->title);
5604 trackinfo[i-1]->title = g_strdup(gtk_entry_get_text(GTK_ENTRY(cdtext_entry1[i])));
5605 g_free(trackinfo[i-1]->artist);
5606 trackinfo[i-1]->artist = g_strdup(gtk_entry_get_text(GTK_ENTRY(cdtext_entry2[i])));
5607
5608 /* free cddb info now */
5609 if (trackinfo[i-1]->cddb_ttitle) {
5610 g_free(trackinfo[i-1]->cddb_ttitle);
5611 trackinfo[i-1]->cddb_ttitle = NULL;
5612 }
5613 /*
5614 g_print("%s / %s\n",
5615 gtk_entry_get_text(GTK_ENTRY(cdtext_entry1[i])),
5616 gtk_entry_get_text(GTK_ENTRY(cdtext_entry2[i])));
5617 */
5618 i++;
5619 }
5620
5621 /* now the cd-text information is copied to the track-structure..*/
5622 /* force display of cd-text now */
5623 setupdata.option_displaycdtext = 1;
5624
5625 }
5626
5627
5628 /* called on ok button of cdtext editor (mode 1 and 2) */
5629 /* write the entered cd-text info to xinf-files and toc */
5630
cdtext_edit_ok_mode12(gchar * tmptoc)5631 static void cdtext_edit_ok_mode12(gchar *tmptoc) {
5632 gint i;
5633 track_read_param_t *trackparam;
5634 GList *loop;
5635
5636 /* first edit the toc file */
5637 if (!tmptoc) {
5638 if (curset.tocfile && curset.tocfile[0] != '\0') {
5639 edit_title_artist_in_toc_file(curset.tocfile,
5640 (gchar *) gtk_entry_get_text(GTK_ENTRY(cdtext_entry1[0])),
5641 (gchar *) gtk_entry_get_text(GTK_ENTRY(cdtext_entry2[0])));
5642 }
5643 } else {
5644 /* use temporary toc file to edit */
5645 edit_title_artist_in_toc_file(tmptoc,
5646 (gchar *) gtk_entry_get_text(GTK_ENTRY(cdtext_entry1[0])),
5647 (gchar *) gtk_entry_get_text(GTK_ENTRY(cdtext_entry2[0])));
5648 }
5649
5650 /*
5651 g_print("edit toc: %s\n", curset.tocfile);
5652 g_print("title/artist: %s / %s\n",
5653 gtk_entry_get_text(GTK_ENTRY(cdtext_entry1[0])),
5654 gtk_entry_get_text(GTK_ENTRY(cdtext_entry2[0])));
5655 */
5656 i = 1;
5657 loop = g_list_first(trackreadset.trackparams);
5658 while(cdtext_entry2[i]) {
5659 if (!loop) {
5660 g_error("toc-file inconsistent....should never happen.\n");
5661 }
5662 trackparam = loop->data;
5663 edit_title_artist_in_xinf_file(trackparam->trackfile,
5664 (gchar *) gtk_entry_get_text(GTK_ENTRY(cdtext_entry1[i])),
5665 (gchar *) gtk_entry_get_text(GTK_ENTRY(cdtext_entry2[i])));
5666
5667 /*
5668 g_print("edit xinf: %s\n", trackparam->trackfile);
5669 g_print("title/artist: %s / %s\n",
5670 gtk_entry_get_text(GTK_ENTRY(cdtext_entry1[i])),
5671 gtk_entry_get_text(GTK_ENTRY(cdtext_entry2[i])));
5672 */
5673 loop = loop->next;
5674 i++;
5675 }
5676
5677 }
5678
5679
5680 /* Lookup the titles on CDDB just via the toc file */
5681
edit_cdtext_cddb(GtkWidget * widget,gpointer data)5682 static void edit_cdtext_cddb(GtkWidget *widget, gpointer data) {
5683 gint onthefly;
5684
5685 if (strcmp(curset.tocfile,"-") == 0) {
5686 onthefly = 1;
5687 } else {
5688 onthefly = 0;
5689 }
5690 if (show_cddb_query(GTK_WIDGET(data), onthefly) == 0) {
5691 /* trigger artist sync */
5692 cdtext_artist_changed(NULL, NULL);
5693 }
5694 }
5695
5696
5697 /* show the edit window for cd-text */
5698 /* mode = 0 when called from info-dialog,
5699 mode = 1 when called from duplicate write-dialog
5700 mode = 2 when called from create write-dialog
5701 mode = 3 when called from duplicate write-dialog (on-the-fly)
5702 */
5703
show_edit_cdtext(gint mode,GtkWidget * writetoc_menu)5704 gint show_edit_cdtext(gint mode, GtkWidget *writetoc_menu) {
5705 GtkWidget *dialog;
5706 GtkWidget *button1;
5707 GtkWidget *button2, *button3;
5708 GtkWidget *box1, *box2, *box3, *box4, *scrolled_window;
5709 GtkWidget *f1, *l1, *tbl, *pic;
5710 GtkWidget *lbl, *btn, *e1;
5711 GtkWidget *menu, *menuitem;
5712 gint xpos, ypos;
5713 gint xsize, ysize;
5714 GdkCursor *cursor;
5715 GtkRequisition rq;
5716 gint i, canlookup;
5717 gchar tmp[MAXLINE], tmp2[MAXLINE];
5718 gchar tmptoc[MAXLINE];
5719 gchar title[MAXLINE], artist[MAXLINE];
5720 gint nrtracks, orgcdtextused;
5721 GtkStyle *style;
5722 GdkPixmap *pixmap1, *pixmap2, *pixmap3;
5723 GdkBitmap *mask1, *mask2, *mask3;
5724 gint bak_sync_cdtext_artist;
5725 track_read_param_t *trackparam;
5726 GList *loop;
5727 image_files_t *entry;
5728 GtkTooltips *tip;
5729
5730 /* if another dialog is running, ignore */
5731 if (dialog_done2 == 999) {
5732 return -1;
5733 }
5734
5735 bak_sync_cdtext_artist = curset.sync_cdtext_artist;
5736 trackparam = NULL;
5737 loop = NULL;
5738
5739 /* cd loaded? */
5740 if (mode == 0 || mode == 3) {
5741 nrtracks = cdinfo.nr_tracks;
5742 if (nrtracks < 0) {
5743 nrtracks = 0;
5744 }
5745 } else
5746 if (mode == 1 || mode == 2) {
5747 nrtracks = trackreadset.nrtracks;
5748 loop = g_list_first(trackreadset.trackparams);
5749 } else {
5750 return -1;
5751 }
5752
5753 /* delete old entry-pointers */
5754 for (i = 0; i < MAXTRACKS+1; i++) {
5755 cdtext_entry1[i] = NULL;
5756 cdtext_entry2[i] = NULL;
5757 }
5758
5759 dodebug(8, "displaying show_edit_cdtext\n");
5760
5761 /* mark our dialog as running */
5762 dialog_done2 = 999;
5763
5764 /* create new window and position it relative to the main window */
5765 dialog = my_gtk_dialog_new();
5766 set_xcdr_title(dialog, NULL, -1);
5767 gtk_widget_set_usize(dialog,tbf(600),tbf(400));
5768 /* make sure our window is always on top */
5769 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
5770
5771 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
5772 GTK_SIGNAL_FUNC (dialog_delete_event2), (gpointer) dialog);
5773
5774 /* create layout for dialog */
5775 box1 = gtk_vbox_new(FALSE,5);
5776 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
5777 gtk_container_add(GTK_CONTAINER(dialog),box1);
5778 gtk_widget_show(box1);
5779
5780 f1 = gtk_frame_new(_("Edit CD-Text information"));
5781 set_font_and_color_frame(f1,BOLDFONT,NULL);
5782 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
5783 gtk_widget_show(f1);
5784
5785 box2 = gtk_vbox_new(FALSE,0);
5786 gtk_container_set_border_width (GTK_CONTAINER (box2), 5);
5787 gtk_container_add(GTK_CONTAINER(f1),box2);
5788 gtk_widget_show(box2);
5789
5790 tbl = gtk_table_new(2, 10, TRUE);
5791 gtk_table_set_row_spacings(GTK_TABLE(tbl),2);
5792 gtk_table_set_col_spacings(GTK_TABLE(tbl),5);
5793 gtk_box_pack_start(GTK_BOX(box2),tbl,FALSE,TRUE,0);
5794 gtk_widget_show(tbl);
5795
5796 strcpy(title,"");
5797 strcpy(artist,"");
5798
5799 /* called from info-screen, get info from cdinfo struct */
5800 if (mode == 0 || mode == 3) {
5801
5802 /* get title and artist for the current cd */
5803 orgcdtextused = 0;
5804 if (setupdata.option_displaycdtext) {
5805 if (cdinfo.title && cdinfo.artist && cdinfo.title[0] != '\0') {
5806 strncpy(title, cdinfo.title, MAXLINE);
5807 strncpy(artist, cdinfo.artist, MAXLINE);
5808 orgcdtextused = 1;
5809 }
5810 }
5811 if (orgcdtextused == 0) {
5812 if (cdinfo.cddb_dtitle) {
5813 get_artist_and_title_from_cddb(cdinfo.cddb_dtitle,
5814 artist, title);
5815 } else {
5816 /* try cd-text as fallback */
5817 if (cdinfo.title && cdinfo.artist &&
5818 cdinfo.title[0] != '\0') {
5819 strncpy(title, cdinfo.title, MAXLINE);
5820 strncpy(artist, cdinfo.artist, MAXLINE);
5821 }
5822 }
5823 }
5824 } else
5825 /* read info from trackreadset (dupicate cd-write menu) */
5826 if (mode == 1) {
5827 if (trackreadset.cdtitle && trackreadset.cdtitle[0]) {
5828 get_artist_and_title_from_cddb(trackreadset.cdtitle,
5829 artist, title);
5830 }
5831 } else
5832 /* read cdtitle from temporary toc file for the write-tracks menu */
5833 if (mode == 2) {
5834 generate_tmp_tocfile_name(tmptoc);
5835 get_cdtitle_from_tmp_tocfile(tmptoc, tmp);
5836 get_artist_and_title_from_cddb(tmp,
5837 artist, title);
5838 }
5839
5840 lbl = gtk_label_new(_("Album title:"));
5841 gtk_table_attach_defaults(GTK_TABLE(tbl),lbl,0,2,0,1);
5842 gtk_widget_show(lbl);
5843
5844 /* cd-title */
5845 e1 = gtk_entry_new();
5846 cdtext_entry1[0] = e1;
5847 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,6,0,1);
5848 gtk_entry_set_text(GTK_ENTRY(e1), convert_for_gtk2(title));
5849 gtk_entry_set_position(GTK_ENTRY(e1), 0);
5850 if (nrtracks == 0)
5851 gtk_widget_set_sensitive(e1, FALSE);
5852 gtk_widget_show(e1);
5853
5854 btn = gtk_button_new_with_label(_("Clear all"));
5855 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
5856 GTK_SIGNAL_FUNC(cdtext_clear_all),NULL);
5857 gtk_table_attach_defaults(GTK_TABLE(tbl),btn,7,10,0,1);
5858 gtk_widget_show(btn);
5859 define_tooltip(btn,_("Clears all the CD-Text fields."));
5860
5861 lbl = gtk_label_new(_("Performer:"));
5862 gtk_table_attach_defaults(GTK_TABLE(tbl),lbl,0,2,1,2);
5863 gtk_widget_show(lbl);
5864
5865
5866 /* cd-artist */
5867 e1 = gtk_entry_new();
5868 cdtext_entry2[0] = e1;
5869 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,6,1,2);
5870 gtk_signal_connect(GTK_OBJECT(e1),"changed",
5871 GTK_SIGNAL_FUNC(cdtext_artist_changed),NULL);
5872 gtk_entry_set_text(GTK_ENTRY(e1), convert_for_gtk2(artist));
5873 gtk_entry_set_position(GTK_ENTRY(e1), 0);
5874 if (nrtracks == 0)
5875 gtk_widget_set_sensitive(e1, FALSE);
5876 gtk_widget_show(e1);
5877
5878 btn = gtk_check_button_new_with_label(_("Use for all tracks"));
5879 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
5880 GTK_SIGNAL_FUNC(cdtext_sync_artist),NULL);
5881 gtk_table_attach_defaults(GTK_TABLE(tbl),btn,6,10,1,2);
5882 if (nrtracks == 0)
5883 gtk_widget_set_sensitive(btn, FALSE);
5884 gtk_widget_show(btn);
5885 define_tooltip(btn,_("Use the album performer also for all the tracks. This will copy the current album performer over all track performers."));
5886
5887 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
5888 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
5889 GTK_POLICY_AUTOMATIC,
5890 GTK_POLICY_AUTOMATIC);
5891 gtk_box_pack_start(GTK_BOX(box2),scrolled_window,TRUE,TRUE,5);
5892 gtk_widget_show(scrolled_window);
5893
5894 box4 = gtk_vbox_new(FALSE,0);
5895 gtk_scrolled_window_add_with_viewport (
5896 GTK_SCROLLED_WINDOW (scrolled_window),box4);
5897 gtk_widget_show(box4);
5898
5899 tbl = gtk_table_new(nrtracks+1, 21, TRUE);
5900 gtk_table_set_row_spacings(GTK_TABLE(tbl),2);
5901 gtk_box_pack_start(GTK_BOX(box4),tbl,FALSE,TRUE,0);
5902 gtk_widget_realize(tbl);
5903 gtk_widget_show(tbl);
5904
5905 style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(tbl)));
5906 pixmap1 = gdk_pixmap_create_from_xpm_d(tbl->window,
5907 &mask1, &style->bg[GTK_STATE_NORMAL],(gchar **)minidata_xpm);
5908 pixmap2 = gdk_pixmap_create_from_xpm_d(tbl->window,
5909 &mask2, &style->bg[GTK_STATE_NORMAL],(gchar **)miniaudio_xpm);
5910 pixmap3 = gdk_pixmap_create_from_xpm_d(tbl->window,
5911 &mask3, &style->bg[GTK_STATE_NORMAL],(gchar **)mininodata_xpm);
5912
5913 /* create title bar */
5914 f1 = gtk_frame_new(NULL);
5915 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_OUT);
5916 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,0,1,0,1);
5917 gtk_widget_show(f1);
5918
5919 f1 = gtk_frame_new(NULL);
5920 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_OUT);
5921 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,1,2,0,1);
5922 gtk_widget_show(f1);
5923 l1 = gtk_label_new(_("Nr."));
5924 gtk_container_add(GTK_CONTAINER(f1),l1);
5925 gtk_widget_show(l1);
5926
5927 f1 = gtk_frame_new(NULL);
5928 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_OUT);
5929 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,2,10,0,1);
5930 gtk_widget_show(f1);
5931 l1 = gtk_label_new(_("Track title"));
5932 gtk_misc_set_alignment(GTK_MISC(l1),0.0,0.5);
5933 gtk_container_add(GTK_CONTAINER(f1),l1);
5934 gtk_widget_show(l1);
5935
5936 f1 = gtk_frame_new(NULL);
5937 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_OUT);
5938 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,10,18,0,1);
5939 gtk_widget_show(f1);
5940 l1 = gtk_label_new(_("Performer"));
5941 gtk_misc_set_alignment(GTK_MISC(l1),0.0,0.5);
5942 gtk_container_add(GTK_CONTAINER(f1),l1);
5943 gtk_widget_show(l1);
5944
5945 f1 = gtk_frame_new(NULL);
5946 gtk_frame_set_shadow_type(GTK_FRAME(f1),GTK_SHADOW_OUT);
5947 gtk_table_attach_defaults(GTK_TABLE(tbl),f1,18,21,0,1);
5948 gtk_widget_show(f1);
5949 l1 = gtk_label_new(_("Length"));
5950 gtk_container_add(GTK_CONTAINER(f1),l1);
5951 gtk_widget_show(l1);
5952
5953 /* fill track information */
5954
5955 for (i = 0; i < nrtracks; i++) {
5956 if (mode == 0 || mode == 3) {
5957 if (trackinfo[i]->type == 0) {
5958 pic = gtk_pixmap_new(pixmap1, mask1);
5959 convert_frames2mbstring(trackinfo[i]->size,tmp2);
5960 } else {
5961 pic = gtk_pixmap_new(pixmap2, mask2);
5962 convert_frames2minstring(trackinfo[i]->size,tmp2);
5963 }
5964
5965 gtk_table_attach_defaults(GTK_TABLE(tbl),pic,0,1,i+1,i+2);
5966 gtk_widget_show(pic);
5967
5968 g_snprintf(tmp,MAXLINE,"%2d.", trackinfo[i]->track_nr);
5969 l1 = gtk_label_new(tmp);
5970 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,1,2,i+1,i+2);
5971 gtk_widget_show(l1);
5972
5973 /* get strings to use for cd-text */
5974 strcpy(title,"");
5975 strcpy(artist,"");
5976 orgcdtextused = 0;
5977 if (setupdata.option_displaycdtext) {
5978 if (trackinfo[i]->title != NULL &&
5979 trackinfo[i]->title[0] != '\0' ) {
5980 /* cd-text found.. use it */
5981 strncpy(title, trackinfo[i]->title, MAXLINE);
5982 orgcdtextused = 1;
5983 }
5984 if (trackinfo[i]->artist != NULL &&
5985 trackinfo[i]->artist[0] != '\0' ) {
5986 strncpy(artist, trackinfo[i]->artist, MAXLINE);
5987 }
5988 }
5989
5990 /* no cd-text in use? try cddb */
5991 if (orgcdtextused == 0) {
5992 if (trackinfo[i]->cddb_ttitle != NULL) {
5993 /* use cddb-information */
5994 strncpy(title, trackinfo[i]->cddb_ttitle,
5995 MAXLINE);
5996 } else {
5997 /* fall back to try cd-text again */
5998 if (trackinfo[i]->title != NULL &&
5999 trackinfo[i]->title[0] != '\0' ) {
6000 strncpy(title, trackinfo[i]->title, MAXLINE);
6001 }
6002 if (trackinfo[i]->artist != NULL &&
6003 trackinfo[i]->artist[0] != '\0' ) {
6004 strncpy(artist, trackinfo[i]->artist, MAXLINE);
6005 }
6006 }
6007 }
6008 } else
6009
6010 /* get info from trackparams list */
6011 if (mode == 1) {
6012 if (!loop) {
6013 g_error("Toc file inconsistent....should never happen.\n");
6014 }
6015 trackparam = loop->data;
6016 if (!trackparam) {
6017 g_warning("trackparam pointer NULL?\n");
6018 loop = loop->next;
6019 continue;
6020 }
6021 if (trackparam->tracktype == 0) {
6022 pic = gtk_pixmap_new(pixmap1, mask1);
6023 convert_frames2mbstring(trackparam->frames,tmp2);
6024 } else {
6025 pic = gtk_pixmap_new(pixmap2, mask2);
6026 convert_frames2minstring(trackparam->frames,tmp2);
6027 }
6028
6029 gtk_table_attach_defaults(GTK_TABLE(tbl),pic,0,1,i+1,i+2);
6030 gtk_widget_show(pic);
6031
6032 g_snprintf(tmp,MAXLINE,"%2d.", trackparam->starttrack);
6033 l1 = gtk_label_new(tmp);
6034 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,1,2,i+1,i+2);
6035 gtk_widget_show(l1);
6036
6037 /* get title and artist from xinf file */
6038 strcpy(title,"");
6039 strcpy(artist,"");
6040 if (trackparam->trackfile) {
6041 get_title_artist_from_xinf(trackparam->trackfile,
6042 artist, title);
6043 }
6044 loop = loop->next;
6045 } else
6046
6047 /* from write tracks menu in create cd */
6048 if (mode == 2) {
6049 if (!loop) {
6050 g_error("trackreadset inconsistent....should never happen.\n");
6051 }
6052 trackparam = loop->data;
6053
6054 entry = get_entry_from_imagelist(trackparam->trackfile);
6055 if (entry == NULL) {
6056 /* should never happen */
6057 loop = loop->next;
6058 continue;
6059 }
6060
6061 if (trackparam->tracktype == 0) {
6062 if (entry->type == 0) {
6063 pic = gtk_pixmap_new(pixmap1, mask1);
6064 } else {
6065 pic = gtk_pixmap_new(pixmap3, mask3);
6066 }
6067 convert_frames2mbstring((gint)((off_t)entry->size/DATASECTORSIZE),
6068 tmp2);
6069 } else {
6070 pic = gtk_pixmap_new(pixmap2, mask2);
6071 convert_frames2minstring((gint)((off_t)entry->size/CDDAFRAME), tmp2);
6072 }
6073
6074 gtk_table_attach_defaults(GTK_TABLE(tbl),pic,0,1,i+1,i+2);
6075 gtk_widget_show(pic);
6076
6077 g_snprintf(tmp,MAXLINE,"%2d.", trackparam->starttrack);
6078 l1 = gtk_label_new(tmp);
6079 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,1,2,i+1,i+2);
6080 gtk_widget_show(l1);
6081
6082 /* get title and artist from xinf file */
6083 strcpy(title,"");
6084 strcpy(artist,"");
6085 if (trackparam->trackfile) {
6086 get_title_artist_from_xinf(trackparam->trackfile,
6087 artist, title);
6088 }
6089 loop = loop->next;
6090 }
6091 /* title entry */
6092 e1 = gtk_entry_new();
6093 cdtext_entry1[i+1] = e1;
6094 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,2,10,i+1,i+2);
6095 gtk_entry_set_text(GTK_ENTRY(e1), convert_for_gtk2(title));
6096 gtk_entry_set_position(GTK_ENTRY(e1), 0);
6097 gtk_widget_show(e1);
6098
6099 /* set a tooltip with the original filename */
6100 if (mode != 0 && mode != 3 && trackparam->trackfile) {
6101 tip = gtk_tooltips_new();
6102 g_snprintf(tmp,MAXLINE,"%s", trackparam->trackfile);
6103 gtk_tooltips_set_tip(tip,e1,tmp,NULL);
6104 }
6105
6106 /* artist entry */
6107 e1 = gtk_entry_new();
6108 cdtext_entry2[i+1] = e1;
6109 gtk_table_attach_defaults(GTK_TABLE(tbl),e1,10,18,i+1,i+2);
6110 gtk_entry_set_text(GTK_ENTRY(e1), convert_for_gtk2(artist));
6111 gtk_entry_set_position(GTK_ENTRY(e1), 0);
6112 gtk_widget_show(e1);
6113
6114 l1 = gtk_label_new(tmp2);
6115 gtk_table_attach_defaults(GTK_TABLE(tbl),l1,18,21,i+1,i+2);
6116 gtk_widget_show(l1);
6117 }
6118
6119 /* terminate entry list */
6120 cdtext_entry1[i+1] = NULL;
6121 cdtext_entry2[i+1] = NULL;
6122
6123 box3 = gtk_hbox_new(FALSE,0);
6124 gtk_box_pack_start(GTK_BOX(box1),box3,FALSE,TRUE,10);
6125 gtk_widget_show(box3);
6126
6127 button1 = gtk_button_new_with_label(T_OK);
6128 cddb_info_okbutton = button1;
6129 gtk_box_pack_start(GTK_BOX(box3),button1,TRUE,TRUE,10);
6130 gtk_widget_show(button1);
6131 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
6132 gtk_widget_grab_default (button1);
6133 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
6134 GTK_SIGNAL_FUNC(dialog_btn_press2), GINT_TO_POINTER(0));
6135
6136 /* in duplicate mode allow lookup from CDDB too */
6137 if (mode == 1 || mode == 3) {
6138 button3 = gtk_button_new_with_label(_("Lookup titles on CDDB"));
6139 gtk_box_pack_start(GTK_BOX(box3),button3,TRUE,TRUE,0);
6140 gtk_widget_show(button3);
6141 GTK_WIDGET_SET_FLAGS (button3, GTK_CAN_DEFAULT);
6142 gtk_signal_connect(GTK_OBJECT(button3),"clicked",
6143 GTK_SIGNAL_FUNC(edit_cdtext_cddb), dialog);
6144 define_tooltip(button3,_("Connect to the CDDB database to download the track titles that belong to that CD. This will overwrite the current entries!"));
6145
6146 if (mode == 1) {
6147 /* check if we got enough data to lookup anyway */
6148 canlookup = 0;
6149 loop = g_list_last(trackreadset.trackparams);
6150 if (loop) {
6151 trackparam = loop->data;
6152 if (trackparam) {
6153 canlookup = trackparam->start_sec;
6154 }
6155 }
6156 /* no data from toc file - lock button */
6157 if (trackreadset.nrtracks == 0 || canlookup == 0) {
6158 gtk_widget_set_sensitive(button3, FALSE);
6159 }
6160 }
6161 }
6162
6163 button2 = gtk_button_new_with_label(T_CANCEL);
6164 gtk_box_pack_start(GTK_BOX(box3),button2,TRUE,TRUE,10);
6165 gtk_widget_show(button2);
6166 GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
6167 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
6168 GTK_SIGNAL_FUNC(dialog_btn_press2), GINT_TO_POINTER(-1));
6169
6170
6171 /* callback for cd-text set-all artist */
6172 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn),
6173 curset.sync_cdtext_artist);
6174
6175 /* grab cursor and change to watch */
6176 gtk_grab_add(dialog);
6177 cursor = gdk_cursor_new(GDK_WATCH);
6178 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
6179
6180 /* only center window when toplevel visible */
6181 if ( GTK_WIDGET_VISIBLE(toplevel)) {
6182 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
6183 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
6184 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
6185 gtk_widget_size_request(dialog,&rq);
6186 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
6187 }
6188
6189 gtk_widget_show(dialog);
6190
6191
6192 /* now wait until button is pressed */
6193 while (dialog_done2 == 999) {
6194 wait_and_process_events();
6195 }
6196
6197
6198 /* ok button pressed */
6199 if (dialog_done2 == 0) {
6200 if (mode == 0) {
6201 /* get info from entries and save to cdinfo-struct */
6202 cdtext_edit_ok_mode0();
6203
6204 /* update cdlist with new info on screen */
6205 fill_cdlist();
6206 } else
6207 if (mode == 1) {
6208 /* get info from entries and change in xinf files */
6209 cdtext_edit_ok_mode12(NULL);
6210
6211 /* update toc selector with new info */
6212 if ( writetoc_menu && GTK_WIDGET_VISIBLE(writetoc_menu)) {
6213 /* simulate click on toc selector */
6214 menu = gtk_option_menu_get_menu(GTK_OPTION_MENU (writetoc_menu));
6215 menuitem = gtk_menu_get_active(GTK_MENU(menu));
6216 gtk_menu_item_activate(GTK_MENU_ITEM(menuitem));
6217 }
6218
6219 /* now reload the image list */
6220 scan_imagedirs();
6221 } else
6222 if (mode == 2) {
6223 /* get info from entries and change in xinf files */
6224 generate_tmp_tocfile_name(tmptoc);
6225 cdtext_edit_ok_mode12(tmptoc);
6226
6227 /* now reload the image list */
6228 scan_imagedirs();
6229
6230 /* redraw now the image display */
6231 fill_write_tracks();
6232 redraw_writelist(cdlist,cdlist_l1);
6233 fill_writelist2(imglist2,imglist_l2);
6234
6235 } else
6236 if (mode == 3) {
6237 /* get info from entries and save to cdinfo-struct */
6238 cdtext_edit_ok_mode0();
6239
6240 /* update toc selector with new info */
6241 if ( writetoc_menu && GTK_WIDGET_VISIBLE(writetoc_menu)) {
6242 /* simulate click on toc selector */
6243 menu = gtk_option_menu_get_menu(GTK_OPTION_MENU (writetoc_menu));
6244 menuitem = gtk_menu_get_active(GTK_MENU(menu));
6245 gtk_menu_item_activate(GTK_MENU_ITEM(menuitem));
6246 }
6247 }
6248 } else {
6249 /* cancel? restore sync_all_button */
6250 curset.sync_cdtext_artist = bak_sync_cdtext_artist;
6251 }
6252
6253 gtk_grab_remove(GTK_WIDGET(dialog));
6254 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
6255 gdk_cursor_destroy (cursor);
6256
6257 /* remove dialog window */
6258 gtk_widget_destroy(dialog);
6259
6260 return dialog_done2;
6261 }
6262
6263
6264 /* popup a modal window, where the user can choose where
6265 to add several directories on the target CD.
6266 Centers automatically above the toplevel-widow
6267 return -1 on cancel and 0,1,2,3 according to settings
6268 */
6269
show_mstr_redir_multi(gchar * commondir,gint nrpaths,gchar * ret)6270 gint show_mstr_redir_multi(gchar *commondir, gint nrpaths, gchar *ret) {
6271 GtkWidget *dialog;
6272 GtkWidget *button1;
6273 GtkWidget *button2, *entry;
6274 GtkWidget *box1,*box2,*box3;
6275 GtkWidget *f1, *f2, *f3, *l1;
6276 GtkWidget *b1_sep, *lbl, *btn;
6277 GSList *group;
6278 gint xpos, ypos;
6279 gint xsize, ysize;
6280 GdkCursor *cursor;
6281 GtkRequisition rq;
6282 gchar redir[MAXLINE], tmp2[MAXLINE];
6283 gint bak_redirtype;
6284 gchar tmp[MAXLINE];
6285 gchar tmp3[MAXLINE];
6286 gchar reducedpath[MAXLINE];
6287 gint returncode;
6288
6289 /* if another dialog is running, ignore */
6290 if (dialog_done == 999) {
6291 return -1;
6292 }
6293
6294 dodebug(8, "displaying show_mstr_redir_multi\n");
6295
6296 /* mark our dialog as running */
6297 dialog_done = 999;
6298
6299 bak_redirtype = masterparam.redirtype2;
6300 redir_entry = NULL;
6301
6302 get_reducedpath(commondir, reducedpath);
6303
6304 /* no common dir? dont try to prompt for option 2 */
6305 if (strcmp(commondir,"") == 0 && masterparam.redirtype2 == 1) {
6306 masterparam.redirtype2 = 0;
6307 }
6308
6309 /* create new window and position it relative to the main window */
6310 dialog = my_gtk_dialog_new();
6311 set_xcdr_title(dialog, NULL, -1);
6312 gtk_widget_set_usize(dialog,tbf(450),0);
6313 /* make sure our window is always on top */
6314 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
6315 cddb_window = dialog;
6316
6317 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
6318 GTK_SIGNAL_FUNC (dialog_delete_event), (gpointer) dialog);
6319
6320 /* create layout for dialog */
6321 box1 = gtk_vbox_new(FALSE,5);
6322 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
6323 gtk_container_add(GTK_CONTAINER(dialog),box1);
6324 gtk_widget_show(box1);
6325
6326 f1 = gtk_frame_new(_("Adding several paths to master directories"));
6327 set_font_and_color_frame(f1,BOLDFONT,NULL);
6328 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
6329 gtk_widget_show(f1);
6330
6331 box2 = gtk_vbox_new(FALSE,0);
6332 gtk_container_set_border_width (GTK_CONTAINER (box2), 5);
6333 gtk_container_add(GTK_CONTAINER(f1),box2);
6334 gtk_widget_show(box2);
6335
6336 f2 = gtk_frame_new(NULL);
6337 gtk_frame_set_shadow_type(GTK_FRAME(f2),GTK_SHADOW_IN);
6338 gtk_box_pack_start(GTK_BOX(box2),f2,FALSE,TRUE,5);
6339 gtk_widget_show(f2);
6340
6341 strncpy(tmp3, commondir, MAXLINE);
6342 convert_for_gtk2(tmp3);
6343 g_snprintf(tmp,MAXLINE,_("%s/... (%d paths)"), tmp3, nrpaths);
6344 l1 = gtk_label_new(tmp);
6345 gtk_container_add(GTK_CONTAINER(f2),l1);
6346 gtk_misc_set_alignment(GTK_MISC(l1),0.5,0.5);
6347 gtk_misc_set_padding(GTK_MISC(l1),5,5);
6348 gtk_widget_show(l1);
6349
6350 lbl = gtk_label_new(_("Please choose where all the selected paths should be mapped on the CD.\nDo note that selecting only one path at a time would give much greater\ncontrol about the CD layout."));
6351 gtk_box_pack_start(GTK_BOX(box2),lbl,FALSE,TRUE,5);
6352 gtk_widget_show(lbl);
6353
6354 b1_sep = gtk_hseparator_new();
6355 gtk_box_pack_start(GTK_BOX(box2),b1_sep,FALSE,TRUE,5);
6356 gtk_widget_show(b1_sep);
6357
6358 btn = gtk_radio_button_new_with_label(NULL,_("Add all with full path"));
6359 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
6360 GTK_SIGNAL_FUNC(redir_type_selected2),GINT_TO_POINTER(0));
6361
6362 gtk_box_pack_start(GTK_BOX(box2),btn,FALSE,TRUE,0);
6363 gtk_widget_show(btn);
6364 define_tooltip(btn,_("Will put all selected files or directories in the same path on the destination CD, as they are on the hard drive now. (e.g. the directories /home/user1 and /home/user2 will also become /home/user1 and /home/user2 on the CD.)"));
6365 if (masterparam.redirtype2 == 0)
6366 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn),1);
6367 group = gtk_radio_button_group (GTK_RADIO_BUTTON(btn));
6368
6369 if (strcmp(commondir,"") != 0) {
6370 g_snprintf(tmp2,MAXLINE,_("Add all with path component \"%s\" removed"), tmp3);
6371 btn = gtk_radio_button_new_with_label(group,tmp2);
6372 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
6373 GTK_SIGNAL_FUNC(redir_type_selected2),
6374 GINT_TO_POINTER(1));
6375 gtk_box_pack_start(GTK_BOX(box2),btn,FALSE,TRUE,0);
6376 gtk_widget_show(btn);
6377 define_tooltip(btn,_("Will strip off the shown path component of all selected files and directories on the destination CD. (e.g. the directories /export/home/user1 and /export/home/user2/src get their common path /export/home stripped and become /user1 and /user2/src on the CD.)"));
6378 if (masterparam.redirtype2 == 1)
6379 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn),1);
6380 group = gtk_radio_button_group (GTK_RADIO_BUTTON(btn));
6381 }
6382
6383 if (strcmp(commondir,"") != 0 && strcmp(reducedpath,"") != 0) {
6384 strncpy(tmp3, reducedpath, MAXLINE);
6385 convert_for_gtk2(tmp3);
6386 g_snprintf(tmp2,MAXLINE,_("Add all with path component \"%s\" removed"), tmp3);
6387 btn = gtk_radio_button_new_with_label(group,tmp2);
6388 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
6389 GTK_SIGNAL_FUNC(redir_type_selected2),
6390 GINT_TO_POINTER(2));
6391 gtk_box_pack_start(GTK_BOX(box2),btn,FALSE,TRUE,0);
6392 gtk_widget_show(btn);
6393 define_tooltip(btn,_("Will strip off the shown path component of all selected files and directories on the destination CD. (e.g. the directories /export/home/user1 and /export/home/user2/src get their common path /export stripped and become /home/user1 and /home/user2/src on the CD.)"));
6394 if (masterparam.redirtype2 == 2)
6395 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn),1);
6396 group = gtk_radio_button_group (GTK_RADIO_BUTTON(btn));
6397 }
6398
6399 if (strcmp(commondir,"") != 0) {
6400 strncpy(tmp3, commondir, MAXLINE);
6401 convert_for_gtk2(tmp3);
6402 g_snprintf(tmp2,MAXLINE,_("Add all with path component \"%s\" replaced by:"), tmp3);
6403 } else {
6404 strncpy(tmp2, _("Add all with a prefixed path:"), MAXLINE);
6405 }
6406 btn = gtk_radio_button_new_with_label(group,tmp2);
6407 gtk_signal_connect(GTK_OBJECT(btn),"clicked",
6408 GTK_SIGNAL_FUNC(redir_type_selected2),GINT_TO_POINTER(3));
6409 gtk_box_pack_start(GTK_BOX(box2),btn,FALSE,TRUE,0);
6410 gtk_widget_show(btn);
6411 if (strcmp(commondir,"") != 0) {
6412 define_tooltip(btn,_("Will strip off the shown path component of all selected files and directories and insert a new path instead on the destination CD. (e.g. the directories /export/home/user1 and /export/home/user2/src get their common path /export/home stripped and replaced by /bak1 - they show up as /bak1/user1 and /bak1/user2/src on the CD.)"));
6413 } else {
6414 define_tooltip(btn,_("Will prefix all the selected files and directories with a new path on the destination CD. (e.g. the directories /home/user1 and /opt/backup can be prefixed with /old to become /old/home/user1 and /old/opt/backup on the CD.)"));
6415 }
6416 if (masterparam.redirtype2 == 3)
6417 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn),1);
6418
6419 f3 = gtk_hbox_new(FALSE,0);
6420 gtk_box_pack_start(GTK_BOX(box2),f3,FALSE,FALSE,5);
6421 gtk_widget_show(f3);
6422
6423 entry = gtk_entry_new();
6424 redir_entry = entry;
6425 gtk_box_pack_start(GTK_BOX(f3),entry,TRUE,TRUE,20);
6426 gtk_widget_show(entry);
6427 gtk_entry_set_text(GTK_ENTRY(entry), masterparam.lastredirpath2);
6428 if (masterparam.redirtype2 != 3)
6429 gtk_widget_set_sensitive(redir_entry, FALSE);
6430
6431 box3 = gtk_hbox_new(FALSE,0);
6432 gtk_box_pack_start(GTK_BOX(box1),box3,FALSE,TRUE,10);
6433 gtk_widget_show(box3);
6434
6435 button1 = gtk_button_new_with_label(T_OK);
6436 cddb_info_okbutton = button1;
6437 gtk_box_pack_start(GTK_BOX(box3),button1,TRUE,TRUE,10);
6438 gtk_widget_show(button1);
6439 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
6440 gtk_widget_grab_default (button1);
6441 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
6442 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(0));
6443
6444 button2 = gtk_button_new_with_label(T_CANCEL);
6445 gtk_box_pack_start(GTK_BOX(box3),button2,TRUE,TRUE,10);
6446 gtk_widget_show(button2);
6447 GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
6448 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
6449 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(-1));
6450
6451
6452 /* grab cursor and change to watch */
6453 gtk_grab_add(dialog);
6454 cursor = gdk_cursor_new(GDK_WATCH);
6455 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
6456
6457 /* only center window when toplevel visible */
6458 if ( GTK_WIDGET_VISIBLE(toplevel)) {
6459 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
6460 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
6461 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
6462 gtk_widget_size_request(dialog,&rq);
6463 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
6464 }
6465
6466 gtk_widget_show(dialog);
6467
6468
6469 /* now wait until button is pressed */
6470 while (dialog_done == 999) {
6471 wait_and_process_events();
6472 }
6473
6474 gtk_grab_remove(GTK_WIDGET(dialog));
6475 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
6476 gdk_cursor_destroy (cursor);
6477
6478 if (dialog_done != 0) {
6479 /* restore original value of type */
6480 masterparam.redirtype2 = bak_redirtype;
6481 strcpy(redir,"");
6482 returncode = -1;
6483 } else {
6484 /* ok pressed, do some business */
6485 g_free(masterparam.lastredirpath2);
6486 masterparam.lastredirpath2 = g_strdup(
6487 gtk_entry_get_text(GTK_ENTRY(redir_entry)));
6488
6489 if (masterparam.redirtype2 == 0) {
6490 strcpy(redir,"");
6491 }
6492
6493 if (masterparam.redirtype2 == 1) {
6494 strcpy(redir,"");
6495 }
6496
6497 if (masterparam.redirtype2 == 2) {
6498 strcpy(redir,"");
6499 }
6500
6501 if (masterparam.redirtype2 == 3) {
6502 strncpy(redir,masterparam.lastredirpath2, MAXLINE);
6503 }
6504 strip_string(redir);
6505
6506 /* remove trailing slash */
6507 if (strlen(redir) > 0) {
6508 if (redir[strlen(redir)-1] == '/') {
6509 redir[strlen(redir)-1] = '\0';
6510 }
6511 }
6512 /* add leading slash */
6513 if (redir[0] != '/') {
6514 strcpy(tmp,"/");
6515 strcat(tmp, redir);
6516 strncpy(redir, tmp, MAXLINE);
6517 }
6518 /* update changes in copy */
6519 if (masterparam.redirtype2 == 3) {
6520 g_free(masterparam.lastredirpath2);
6521 masterparam.lastredirpath2 = g_strdup(redir);
6522 }
6523 returncode = masterparam.redirtype2;
6524 }
6525
6526 /* remove dialog window */
6527 gtk_widget_destroy(dialog);
6528
6529 /* now "redir" contains the string where we want to go */
6530 strncpy(ret, redir, MAXLINE);
6531
6532 return returncode;
6533 }
6534
6535
6536 /* prompt for a new device string in setup
6537 Centers automatically above the toplevel-widow
6538 */
6539
show_add_manual_device(gchar * newdev)6540 gint show_add_manual_device(gchar *newdev) {
6541 GtkWidget *dialog;
6542 GtkWidget *button1;
6543 GtkWidget *button2, *entry;
6544 GtkWidget *box1,*box2,*box3;
6545 GtkWidget *f1;
6546 GtkWidget *b1_sep, *lbl;
6547 gint xpos, ypos;
6548 gint xsize, ysize;
6549 GdkCursor *cursor;
6550 GtkRequisition rq;
6551
6552 /* if another dialog is running, ignore */
6553 if (dialog_done == 999) {
6554 return -1;
6555 }
6556
6557 dodebug(8, "show_add_manual_device\n");
6558
6559 /* mark our dialog as running */
6560 dialog_done = 999;
6561
6562 /* create new window and position it relative to the main window */
6563 dialog = my_gtk_dialog_new();
6564 set_xcdr_title(dialog, NULL, -1);
6565 /* gtk_widget_set_usize(dialog,tbf(400),0); */
6566 /* make sure our window is always on top */
6567 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
6568 cddb_window = dialog;
6569
6570 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
6571 GTK_SIGNAL_FUNC (dialog_delete_event), (gpointer) dialog);
6572
6573 /* create layout for dialog */
6574 box1 = gtk_vbox_new(FALSE,5);
6575 gtk_container_set_border_width (GTK_CONTAINER (box1), 5);
6576 gtk_container_add(GTK_CONTAINER(dialog),box1);
6577 gtk_widget_show(box1);
6578
6579 f1 = gtk_frame_new(_("Manually add writer or reader devices"));
6580 set_font_and_color_frame(f1,BOLDFONT,NULL);
6581 gtk_box_pack_start(GTK_BOX(box1),f1,TRUE,TRUE,0);
6582 gtk_widget_show(f1);
6583
6584 box2 = gtk_vbox_new(FALSE,0);
6585 gtk_container_set_border_width (GTK_CONTAINER (box2), 5);
6586 gtk_container_add(GTK_CONTAINER(f1),box2);
6587 gtk_widget_show(box2);
6588
6589 lbl = gtk_label_new(_("Please enter a valid cdrecord device specification:"));
6590 gtk_box_pack_start(GTK_BOX(box2),lbl,FALSE,TRUE,5);
6591 gtk_widget_show(lbl);
6592
6593 b1_sep = gtk_hseparator_new();
6594 gtk_box_pack_start(GTK_BOX(box2),b1_sep,FALSE,TRUE,5);
6595 gtk_widget_show(b1_sep);
6596
6597 lbl = gtk_label_new(_("This can be any device string as described in the\ncdrecord documentation:\n\n For example \"/dev/hdc\" on Linux 2.5.45 or greater, or\n \"REMOTE:rscsi@hostname\" to scan for network enabled devices."));
6598 gtk_box_pack_start(GTK_BOX(box2),lbl,FALSE,TRUE,5);
6599 gtk_widget_show(lbl);
6600
6601
6602 entry = gtk_entry_new();
6603 gtk_box_pack_start(GTK_BOX(box2),entry,TRUE,TRUE,10);
6604 gtk_signal_connect(GTK_OBJECT(entry), "activate",
6605 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(0));
6606 gtk_widget_show(entry);
6607
6608 box3 = gtk_hbox_new(FALSE,0);
6609 gtk_box_pack_start(GTK_BOX(box1),box3,FALSE,TRUE,10);
6610 gtk_widget_show(box3);
6611
6612 button1 = gtk_button_new_with_label(T_OK);
6613 cddb_info_okbutton = button1;
6614 gtk_box_pack_start(GTK_BOX(box3),button1,TRUE,TRUE,10);
6615 gtk_widget_show(button1);
6616 GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
6617 gtk_widget_grab_default (button1);
6618 gtk_signal_connect(GTK_OBJECT(button1),"clicked",
6619 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(0));
6620
6621 button2 = gtk_button_new_with_label(T_CANCEL);
6622 gtk_box_pack_start(GTK_BOX(box3),button2,TRUE,TRUE,10);
6623 gtk_widget_show(button2);
6624 GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
6625 gtk_signal_connect(GTK_OBJECT(button2),"clicked",
6626 GTK_SIGNAL_FUNC(dialog_btn_press), GINT_TO_POINTER(-1));
6627
6628
6629 /* grab cursor and change to watch */
6630 gtk_grab_add(dialog);
6631 cursor = gdk_cursor_new(GDK_WATCH);
6632 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,cursor);
6633
6634 /* only center window when toplevel visible */
6635 if ( GTK_WIDGET_VISIBLE(toplevel)) {
6636 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
6637 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
6638 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
6639 gtk_widget_size_request(dialog,&rq);
6640 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
6641 }
6642
6643 gtk_widget_show(dialog);
6644
6645
6646 /* now wait until button is pressed */
6647 while (dialog_done == 999) {
6648 wait_and_process_events();
6649 }
6650
6651 gtk_grab_remove(GTK_WIDGET(dialog));
6652 gdk_window_set_cursor(GTK_WIDGET(toplevel)->window,NULL);
6653 gdk_cursor_destroy (cursor);
6654
6655
6656 strncpy(newdev, gtk_entry_get_text(GTK_ENTRY(entry)), MAXLINE);
6657
6658 /* remove dialog window */
6659 gtk_widget_destroy(dialog);
6660
6661 return dialog_done;
6662 }
6663
6664
6665 /* A version of the dialog that requests the user to wait - will
6666 * be removed by call */
6667
show_dialog_wait(gchar * icon_file,gchar * ttext)6668 GtkWidget *show_dialog_wait(gchar *icon_file, gchar *ttext) {
6669 GtkWidget *dialog;
6670 GtkWidget *box1;
6671 GtkWidget *b1_t,*pix,*lab;
6672 gint xpos, ypos;
6673 gint xsize, ysize;
6674 GdkCursor *cursor;
6675 /* GtkStyle *style; */
6676 GtkRequisition rq;
6677 #if GTK_MAJOR_VERSION < 2
6678 GdkPixbuf *im;
6679 GdkPixmap *pixmap;
6680 GdkBitmap *mask;
6681 gchar tmp[MAXLINE];
6682 #else
6683 gchar *ico;
6684 #endif
6685
6686 /* if another dialog is running, ignore */
6687 if (dialog_done3 == 999) {
6688 return NULL;
6689 }
6690
6691 dodebug(8, "displaying show_dialog_wait: %s\n", ttext);
6692
6693 /* mark our dialog as running */
6694 dialog_done3 = 999;
6695
6696 /* create new window and position it relative to the main window */
6697 dialog = my_gtk_dialog_new();
6698 set_xcdr_title(dialog, NULL, -1);
6699 /* make sure our window is always on top */
6700 gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(toplevel));
6701
6702 gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
6703 GTK_SIGNAL_FUNC (dialog_delete_event3), (gpointer) dialog);
6704
6705 /* create layout for dialog */
6706 box1 = gtk_vbox_new(FALSE,0);
6707 gtk_container_add(GTK_CONTAINER(dialog),box1);
6708 gtk_widget_show(box1);
6709
6710 b1_t = gtk_table_new(1,10, TRUE);
6711 gtk_container_border_width(GTK_CONTAINER(b1_t),10);
6712
6713 gtk_box_pack_start(GTK_BOX(box1),b1_t,FALSE,TRUE,10);
6714
6715 /* realize table to be able to put a pixmap in it */
6716 gtk_widget_realize(b1_t);
6717 gtk_widget_show(b1_t);
6718
6719
6720 /* style = gtk_widget_get_style(b1_t);
6721 pixmap = gdk_pixmap_create_from_xpm_d(b1_t->window, &mask,
6722 &style->bg[GTK_STATE_NORMAL],(gchar **)icon_xpm);
6723 */
6724
6725 #if GTK_MAJOR_VERSION < 2
6726 g_snprintf(tmp,MAXLINE,"%s/%s", sharedir,icon_file);
6727 dodebug(9, "dialog: trying to load %s\n", tmp);
6728
6729 im=gdk_pixbuf_new_from_file(tmp);
6730 if (im) {
6731 gdk_pixbuf_render_pixmap_and_mask(im, &pixmap, &mask, 128);
6732 pix = gtk_pixmap_new(pixmap,mask);
6733 gtk_table_attach_defaults(GTK_TABLE(b1_t), pix, 0,2,0,1);
6734 gtk_widget_show(pix);
6735 gdk_pixbuf_unref(im);
6736 }
6737 #else
6738 ico = lookup_stock_icon(icon_file);
6739 if (ico) {
6740 pix = gtk_image_new_from_stock(ico, GTK_ICON_SIZE_DIALOG);
6741 gtk_table_attach_defaults(GTK_TABLE(b1_t), pix, 0,2,0,1);
6742 gtk_widget_show(pix);
6743 }
6744 #endif
6745
6746 lab = gtk_label_new(ttext);
6747 gtk_table_attach_defaults(GTK_TABLE(b1_t), lab, 2,10,0,1);
6748 gtk_widget_show(lab);
6749
6750
6751 /* grab cursor and change to watch */
6752 cursor = gdk_cursor_new(GDK_WATCH);
6753 gdk_window_set_cursor(GTK_WIDGET(dialog)->window,cursor);
6754 gdk_cursor_destroy (cursor);
6755 dodebug(9, "showdialog_wait: set cursor\n");
6756
6757 /* only center window when toplevel visible */
6758 if ( GTK_WIDGET_VISIBLE(toplevel)) {
6759 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
6760 gdk_window_get_origin(GTK_WIDGET(toplevel)->window,&xpos,&ypos);
6761 gdk_window_get_size(GTK_WIDGET(toplevel)->window,&xsize,&ysize);
6762 gtk_widget_size_request(dialog,&rq);
6763 gtk_widget_set_uposition(GTK_WIDGET(dialog),xpos+xsize/2-rq.width/2,ypos+ysize/2-rq.height/2);
6764 } else {
6765 /* otherwise center in screen */
6766 gtk_window_position(GTK_WINDOW(dialog),GTK_WIN_POS_NONE);
6767 xsize = gdk_screen_width();
6768 ysize = gdk_screen_height();
6769 gtk_widget_size_request(dialog,&rq);
6770 gtk_widget_set_uposition(GTK_WIDGET(dialog),xsize/2-rq.width/2,ysize/2-rq.height/2);
6771
6772 }
6773
6774 gtk_widget_show(dialog);
6775
6776 return (dialog);
6777 }
6778
6779
6780 /* remove the wait dialog now */
6781
show_dialog_wait_remove(GtkWidget * dialog)6782 void show_dialog_wait_remove(GtkWidget *dialog) {
6783
6784 gdk_window_set_cursor(GTK_WIDGET(dialog)->window,NULL);
6785 dialog_done3 = 0;
6786
6787 /* remove dialog window */
6788 gtk_widget_destroy(dialog);
6789 }
6790