1 /* interface.c
2 * Copyright (C) 2004, 2005 Sylvain Cresto <scresto@gmail.com>
3 *
4 * This file is part of graveman!
5 *
6 * graveman! is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2, or
9 * (at your option) any later version.
10 *
11 * graveman! is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with program; see the file COPYING. If not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
19 * MA 02111-1307, USA.
20 *
21 * URL: http://www.nongnu.org/graveman/
22 *
23 */
24
25 /* definition des fenetres */
26
27 #include "graveman.h"
28 /* drag and drop */
29
30 enum {
31 TARGET_URI_LIST,
32 TARGET_STRING
33 };
34
35 GtkTargetEntry Gdndaudio[] = { {"text/uri-list", 0, TARGET_URI_LIST } };
36 GtkTargetEntry Gdnddata[] = { {"text/uri-list", 0, TARGET_URI_LIST } };
37
38 /* liste des medias */
39 GSList *Gmedialist = NULL;
40
41 static Tmyentry Gtypecdaudio[] = {
42 { "1260", N_("21 min"), FALSE, 0 },
43 { "1380", N_("23 min"), FALSE, 0 },
44 { "4440", N_("74 min"), FALSE, 0 },
45 { "4800", N_("80 min"), TRUE, 0 },
46 { "5400", N_("90 min"), FALSE, 0 },
47 { "5940", N_("99 min"), FALSE, 0 },
48 { "6000", N_("100 min"), FALSE, 0 },
49 { NULL }
50 };
51
52 static Tmyentry Gtypecddata[] = {
53 { "180", N_("180 mb"), FALSE, 0 },
54 { "202", N_("202 mb"), FALSE, 0 },
55 { "650", N_("650 mb"), FALSE, 0 },
56 { "700", N_("700 mb"), TRUE, 0 },
57 { "790", N_("790 mb"), FALSE ,0 },
58 { "869", N_("869 mb"), FALSE, 0 },
59 { "878", N_("878 mb"), FALSE, 0 },
60 { NULL }
61 };
62
63 static Tmyentry Gtypedvddata[] = {
64 { "4482", N_("4.7 gb"), TRUE, 0 },
65 { "8964", N_("9.4 gb"), FALSE, 0 },
66 { NULL }
67 };
68
69 Tmyentry Gtypeicosize[] = {
70 { "16", N_("16x16 px"), FALSE, 0 },
71 { "24", N_("24x24 px"), FALSE, 0 },
72 { "32", N_("32x32 px"), FALSE, 0 },
73 { "48", N_("48x48 px"), FALSE, 0 },
74 { NULL }
75 };
76
77 /*
78 static Tmyentry Gtypeunit[] = {
79 { "kb", N_("kb"), TRUE },
80 { "mb", N_("mb"), FALSE },
81 { "gb", N_("gb"), FALSE },
82 };*/
83
84 static Tmyentry Gmodburn[] = {
85 { "dao", N_("Disk At Once - DAO (default)"), TRUE, 0 },
86 { "", N_("Track At Once - TAO"), FALSE, 0 },
87 { "raw96r", N_("RAW writing - raw96r"), FALSE, 0 },
88 { "raw96", N_("RAW writing - raw96"), FALSE, 0 },
89 { "raw96p", N_("RAW writing - raw96p"), FALSE, 0 },
90 { NULL }
91 };
92
93 static Tmyentry Gisolevel[] = {
94 { "1", N_("ISO 9660 level 1"), FALSE, 0 },
95 { "2", N_("ISO 9660 level 2 (default)"), TRUE, 0 },
96 { "3", N_("ISO 9660 level 3"), FALSE, 0 },
97 { "4", N_("ISO 9660 version 2"), FALSE, 1 },
98 { NULL }
99 };
100
101 static Tmyentry Gformatcd[] = {
102 { "data", N_("CD-Rom Mode 1 (default)"), TRUE, 0 },
103 { "mode2", N_("CD-Rom Mode 2"), FALSE, 0 },
104 { "xa1", N_("CD-Rom XA Mode 1"), FALSE, 0 },
105 { "xa2", N_("CD-Rom XA Mode 2"), FALSE, 0 },
106 { NULL }
107 };
108
remplire_combo_vitesse(GtkComboBox * Acombo,Tdriveinfo * Adrive,gchar * Aselvalue)109 void remplire_combo_vitesse(GtkComboBox *Acombo, Tdriveinfo *Adrive, gchar *Aselvalue)
110 {
111 GtkListStore *Ldata = GTK_LIST_STORE(gtk_combo_box_get_model(Acombo));
112 const gchar *Lname = glade_get_widget_name(GTK_WIDGET(Acombo));
113 gchar *Llabel, *Lident;
114 gint i;
115 gint passe = 0;
116 GtkTreeIter Liter;
117 gint Lmaxspeed = MAX_SPEED;
118 gboolean Lselok = FALSE;
119 gboolean Lisdvd = FALSE;
120
121 if (Adrive) {
122 if (strstr(Lname, "dvd")) Lisdvd = TRUE;
123 Lmaxspeed = Lisdvd ? Adrive->vitessedvd : Adrive->vitesse;
124 }
125
126 gtk_list_store_clear(Ldata);
127
128 for (i=1; 1; i++) {
129 if (!Lisdvd) {
130 passe = ! passe;
131 if (passe) continue;
132 }
133 Llabel = g_strdup_printf("%dx", i);
134 Lident = g_strdup_printf("%d", i);
135 gtk_list_store_append(Ldata, &Liter);
136 gtk_list_store_set(Ldata, &Liter, 0, Lident, 1, Llabel, -1);
137
138 if (Aselvalue && *Aselvalue && Lselok == FALSE) {
139 if (!strcmp(Lident, Aselvalue)) {
140 gtk_combo_box_set_active_iter(Acombo, &Liter);
141 Lselok = TRUE;
142 }
143 }
144
145 g_free(Llabel); g_free(Lident);
146
147 if (i >= Lmaxspeed) break;
148 }
149
150 gtk_list_store_append(Ldata, &Liter);
151 gtk_list_store_set(Ldata, &Liter, 0, "0", 1, _("Full speed"), -1);
152
153 if (Lselok == FALSE) gtk_combo_box_set_active_iter(Acombo, &Liter);
154 }
155
remplirecombo_full(GtkComboBox * Acombo,gchar * Abasename,Tmyentry * Aentry,gboolean Adoinit,gchar * Aselvalue,gint Afiltre)156 void remplirecombo_full (GtkComboBox *Acombo, gchar *Abasename, Tmyentry *Aentry, gboolean Adoinit, gchar *Aselvalue, gint Afiltre)
157 {
158 GtkListStore *Ldata;
159 gchar *Lident;
160 Tmyentry *Lcurentry;
161 GtkTreeIter Liter;
162 gboolean Lselok = FALSE;
163
164 if (Adoinit == FALSE) {
165 Ldata = GTK_LIST_STORE(gtk_combo_box_get_model(Acombo));
166 } else {
167 GtkCellRenderer *Lcellrender;
168
169 Ldata = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
170 gtk_combo_box_set_model(Acombo, GTK_TREE_MODEL(Ldata));
171
172 gtk_cell_layout_clear(GTK_CELL_LAYOUT(Acombo));
173 Lcellrender = GTK_CELL_RENDERER(gtk_cell_renderer_text_new());
174 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(Acombo), Lcellrender, TRUE);
175 gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(Acombo), Lcellrender,
176 "text", 1, NULL);
177 }
178
179 gtk_list_store_clear(Ldata);
180
181 for (Lcurentry = Aentry; Lcurentry->label; Lcurentry++) {
182 if (Afiltre > -1 && Lcurentry->filtre > Afiltre) continue;
183
184 Lident = g_strdup_printf("%s%s", Abasename, Lcurentry->basecode);
185 gtk_list_store_append(Ldata, &Liter);
186 gtk_list_store_set(Ldata, &Liter, 0, Lident, 1, _(Lcurentry->label), -1);
187
188 if (!Aselvalue || !*Aselvalue) {
189 if (Lcurentry->defaut == TRUE) {
190 gtk_combo_box_set_active_iter(Acombo, &Liter);
191 Lselok = TRUE;
192 }
193 } else {
194 if (!strcmp(Aselvalue, Lident)) {
195 gtk_combo_box_set_active_iter(Acombo, &Liter);
196 Lselok = TRUE;
197 }
198 }
199 g_free(Lident);
200 }
201
202 /* si pas de selection alors on met le premier par defaut */
203 if (Lselok == FALSE) gtk_combo_box_set_active(Acombo, 0);
204 }
205
remplirecombograveur(GtkComboBox * Acombo,gint Aquoi,gchar * Aselvalue)206 void remplirecombograveur(GtkComboBox *Acombo, gint Aquoi, gchar *Aselvalue)
207 {
208 GtkListStore *Ldata = GTK_LIST_STORE(gtk_combo_box_get_model(Acombo));
209 GtkTreeIter Liter;
210 GSList *Lcur;
211 Tdriveinfo *Ldrive;
212 gint i;
213 gboolean Lselok = FALSE;
214 gchar *Lcurdrive;
215
216 if (GTK_IS_LIST_STORE(Ldata)) {
217 gtk_list_store_clear(Ldata);
218 }
219 for (Lcur = Glistdrives, i=0; Lcur; Lcur = g_slist_next(Lcur), i++) {
220 Ldrive = (Tdriveinfo *)Lcur->data;
221 if ((Aquoi & TYPE_ALLWRITER) && (! DRIVE_WRITER(Ldrive))) continue;
222 if ((Aquoi & TYPE_DVDWRITER) && (! DRIVE_DVDWRITER(Ldrive))) continue;
223
224 gtk_list_store_append(Ldata, &Liter);
225
226 Lcurdrive =g_slist_nth_data(Ldrive->dev, Ldrive->actuperiph);
227
228 gtk_list_store_set(Ldata, &Liter, 0, Ldrive, 1,
229 DRIVE_ICONE(Ldrive), 2, Ldrive->name, 3, i, -1);
230
231 if (Aselvalue && *Aselvalue && Lselok==FALSE) {
232 if (!strcmp(Aselvalue, Lcurdrive)) {
233 gtk_combo_box_set_active_iter(Acombo, &Liter);
234 Lselok = TRUE;
235 }
236 }
237 }
238
239 if (Aquoi & TYPE_ISO) {
240 gtk_list_store_append(Ldata, &Liter);
241 gtk_list_store_set(Ldata, &Liter, 0, NULL, 1, get_image("ISOsmallIcon"), 2, _("ISO file..."), 3, -1, -1);
242
243 if (Aselvalue && Lselok==FALSE && !strcmp(Aselvalue, "iso")) {
244 gtk_combo_box_set_active_iter(Acombo, &Liter);
245 Lselok = TRUE;
246 }
247 }
248
249 /* si pas de selection alors on met le premier par defaut */
250 if (Lselok == FALSE) gtk_combo_box_set_active(Acombo, 0);
251 }
252
remplirelistegraveur(GtkTreeView * Aliste)253 void remplirelistegraveur(GtkTreeView *Aliste)
254 {
255 GtkListStore *Ldata = GTK_LIST_STORE(gtk_tree_view_get_model(Aliste));
256 GtkTreeIter Liter;
257 gint i;
258 gchar Llabeldevice[50];
259 GSList *Lcur;
260 Tdriveinfo *Ldrive;
261
262 gtk_list_store_clear(Ldata);
263
264 for (Lcur = Glistdrives, i=0; Lcur; Lcur = g_slist_next(Lcur), i++) {
265 Ldrive = (Tdriveinfo *)Lcur->data;
266
267 gtk_list_store_append(Ldata, &Liter);
268
269 put_devicelabel(Ldrive, Llabeldevice, sizeof(Llabeldevice)-1);
270 gtk_list_store_set(Ldata, &Liter, 0, i, 1, DRIVE_ICONE(Ldrive), 2,
271 (gchar *)g_slist_nth_data(Ldrive->dev, Ldrive->actuperiph), 3,
272 Llabeldevice, 4, Ldrive->name, -1);
273 }
274 }
275
276 #if 0
277 void remplirelistemedia(GtkTreeView *Aliste)
278 {
279 GtkListStore *Ldata = GTK_LIST_STORE(gtk_tree_view_get_model(Aliste));
280 GtkTreeIter Liter;
281 GSList *Lcur;
282 Tmediaentry *Lcurmedia;
283
284 gtk_list_store_clear(Ldata);
285
286 for (Lcur = Gmedialist; Lcur; Lcur = g_slist_next(Lcur)) {
287 Lcurmedia = (Tmediaentry *)Lcur->data;
288 gtk_list_store_append(Ldata, &Liter);
289 gtk_list_store_set(Ldata, &Liter, 0, Lcurmedia->labeldata, 1, Lcurmedia->labelaudio, -1);
290 }
291 }
292 #endif
293 /* menu popup sur les lecteurs/graveurs */
create_gtkpopupmenudevices(GtkWidget * Aliste,Tgrave * Ag)294 GtkMenu *create_gtkpopupmenudevices(GtkWidget *Aliste, Tgrave *Ag)
295 {
296 GtkMenu *Lmenu = GTK_MENU(sc_grave_get_widget(Ag, "popupdevices"));
297 GtkWidget *Litem;
298 GtkTreePath *Lpath = NULL;
299
300 /* on cherche l'object selectionne, on est pas sur qu'il y en ai un car
301 * il n'y a pas forcement de peripheriques de detect� */
302 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Aliste), &Lpath, NULL);
303
304 Litem = GTK_WIDGET(sc_grave_get_widget(Ag, "popupdevices_edit"));
305 gtk_widget_set_sensitive(Litem, Lpath ? TRUE : FALSE);
306 Litem = GTK_WIDGET(sc_grave_get_widget(Ag, "popupdevices_remove"));
307 gtk_widget_set_sensitive(Litem, Lpath ? TRUE : FALSE);
308
309 if (Lpath) gtk_tree_path_free(Lpath);
310
311 return Lmenu;
312 }
313
314 /* menu popup sur les character sets */
create_gtkpopupmenucharset(GtkWidget * Aliste,Tgrave * Ag)315 GtkMenu *create_gtkpopupmenucharset(GtkWidget *Aliste, Tgrave *Ag)
316 {
317 GtkMenu *Lmenu = GTK_MENU(sc_grave_get_widget(Ag, "popupcharset"));
318 GtkWidget *Litem;
319 GtkTreePath *Lpath = NULL;
320
321 /* on cherche l'object selectionne, on est pas sur qu'il y en ai un car
322 * il n'y a pas forcement de peripheriques de detect� */
323 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Aliste), &Lpath, NULL);
324
325 Litem = GTK_WIDGET(sc_grave_get_widget(Ag, "popupcharset_edit"));
326 gtk_widget_set_sensitive(Litem, Lpath ? TRUE : FALSE);
327 Litem = GTK_WIDGET(sc_grave_get_widget(Ag, "popupcharset_remove"));
328 gtk_widget_set_sensitive(Litem, Lpath ? TRUE : FALSE);
329
330 if (Lpath) gtk_tree_path_free(Lpath);
331
332 return Lmenu;
333 }
334
335 /* menu popup sur le formatage d'un dvd */
create_gtkpopupmenuformatdvd(Tgrave * Ag)336 GtkMenu *create_gtkpopupmenuformatdvd(Tgrave *Ag)
337 {
338 GtkMenu *Lmenu = GTK_MENU(sc_grave_get_widget(Ag, "popupformatdvd"));
339
340 return Lmenu;
341 }
342
343 /* menu popup sur les pistes audio */
create_gtkpopupmenuaudio(GtkWidget * Aliste,Tgrave * Ag)344 GtkMenu *create_gtkpopupmenuaudio(GtkWidget *Aliste, Tgrave *Ag)
345 {
346 GtkMenu *Lmenu = GTK_MENU(sc_grave_get_widget(Ag, "popupaudio"));
347 GtkWidget *Litem;
348 GtkTreePath *Lpath = NULL;
349
350 /* on cherche l'object selectionne, on est pas sur qu'il y en ai un car
351 * on est en SELECTION_MULTIPLE */
352 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Aliste), &Lpath, NULL);
353
354 Litem = GTK_WIDGET(sc_grave_get_widget(Ag, "popupaudio_removetrack"));
355 if (Lpath) {
356 gtk_widget_set_sensitive(Litem, TRUE);
357 } else {
358 gtk_widget_set_sensitive(Litem, FALSE);
359 }
360
361 if (Lpath) gtk_tree_path_free(Lpath);
362
363 return Lmenu;
364 }
365
366 /* creation popup "affichage" */
create_gtkpopupmenudisplay(GtkWidget * Aliste,Tgrave * Ag)367 GtkMenu *create_gtkpopupmenudisplay(GtkWidget *Aliste, Tgrave *Ag)
368 {
369 GtkMenu *Lmenu = GTK_MENU(sc_grave_get_widget(Ag, "popupdisplay"));
370 gboolean Ldispsb = conf_get_boolean("statusbar");
371 GtkWidget *Litem, *Litem2;
372
373
374 Litem = sc_grave_get_widget(Ag, "popupdisp_showstatusbar");
375 Litem2 = sc_grave_get_widget(Ag, "popupdisp_hidestatusbar");
376 if (Ldispsb) {
377 gtk_widget_hide(Litem);
378 gtk_widget_show(Litem2);
379 } else {
380 gtk_widget_show(Litem);
381 gtk_widget_hide(Litem2);
382 }
383
384 Litem = sc_grave_get_widgetv(Ag, "popupdisp_iconsize_%s", conf_get_string("iconsize"));
385 if (GTK_IS_WIDGET(Litem)) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(Litem), TRUE);
386
387 return Lmenu;
388 }
389
390 /* creation popup "cd/dvd data" */
create_gtkpopupmenudata(GtkWidget * Aliste,Tgrave * Ag)391 GtkMenu *create_gtkpopupmenudata(GtkWidget *Aliste, Tgrave *Ag)
392 {
393 GtkMenu *Lmenu = GTK_MENU(sc_grave_get_widget(Ag, "popupdata"));
394 GtkTreeModel *Lmodel = gtk_tree_view_get_model(GTK_TREE_VIEW(Aliste));
395 GtkWidget *Litem, *Litem2, *Lsep;
396 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(Aliste));
397 GtkTreeIter Liter;
398 gint type, Lcolid = 0;
399 GtkSortType Lorder;
400 gint Lnumsel = gtk_tree_selection_count_selected_rows(Lselection);
401 gboolean Lonlyone = TRUE;
402 const gchar *Llistename = glade_get_widget_name(Aliste);
403 GtkTreePath *Lpath = NULL;
404
405 /* on cherche l'object selectionne, il peu y en avoir plusieur
406 * car on est en SELECTION_MULTIPLE */
407
408 /* focus sur le premier element si pas de focus */
409 if (!Lnumsel) {
410 if (!gtk_tree_model_get_iter_first(Lmodel, &Liter)) return NULL;
411
412 gtk_tree_selection_select_iter(Lselection, &Liter);
413 gtk_widget_grab_focus(Aliste);
414 } else {
415 /* si plusieurs elements de selectionne alors on pointe sur celui etant
416 * sous le curseur */
417 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Aliste), &Lpath, NULL);
418 if (!Lpath) {
419 gtk_widget_grab_focus(Aliste);
420 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Aliste), &Lpath, NULL);
421 if (!Lpath) return NULL;
422 }
423 gtk_tree_model_get_iter(Lmodel, &Liter, Lpath);
424 gtk_tree_path_free(Lpath);
425
426 Lonlyone = (Lnumsel == 1 ? TRUE : FALSE);
427 }
428
429
430 /* type nous permet de savoir le type de ligne selectionne (CD, DIR, FILE...) */
431 gtk_tree_model_get(Lmodel, &Liter, 0, &type, -1);
432
433 /* RENOMMER LE CD */
434 Litem = sc_grave_get_widget(Ag, "popupdata_renamecd");
435 Litem2 = sc_grave_get_widget(Ag, "popupdata_renamedvd");
436 if (!strcmp(Llistename, "LISTEDVDDATA")) {
437 if (type == TYPE_CD && Lonlyone) {
438 gtk_widget_show(Litem2);
439 } else {
440 gtk_widget_hide(Litem2);
441 }
442 gtk_widget_hide(Litem);
443 } else {
444 if (type == TYPE_CD && Lonlyone) {
445 gtk_widget_show(Litem);
446 } else {
447 gtk_widget_hide(Litem);
448 }
449 gtk_widget_hide(Litem2);
450 }
451
452 /* EXPAND */
453 Litem = sc_grave_get_widget(Ag, "popupdata_expand");
454 if (type != TYPE_FILE && Lonlyone) {
455 gtk_widget_show (Litem);
456 } else {
457 gtk_widget_hide(Litem);
458 }
459
460 /* RENOMMER L'ELEMENT SELECTIONNE */
461 Litem = sc_grave_get_widget(Ag, "popupdata_renamedirectory");
462 if (type == TYPE_DIR && Lonlyone) {
463 gtk_widget_show (Litem);
464 } else {
465 gtk_widget_hide (Litem);
466 }
467 Litem = sc_grave_get_widget(Ag, "popupdata_renamefile");
468 if (type == TYPE_FILE && Lonlyone) {
469 gtk_widget_show (Litem);
470 } else {
471 gtk_widget_hide (Litem);
472 }
473
474 /* CREER UN REPERTOIRE */
475 Litem = sc_grave_get_widget(Ag, "popupdata_createdirectory");
476 if (type != TYPE_FILE && Lonlyone) {
477 gtk_widget_show (Litem);
478 } else {
479 gtk_widget_hide (Litem);
480 }
481
482 /* AJOUTER DES FICHIERS */
483 /* AJOUTER DES REPERTOIRES */
484 Lsep = sc_grave_get_widget(Ag, "popupdata_sep1");
485 Litem = sc_grave_get_widget(Ag, "popupdata_addfile");
486 Litem2 = sc_grave_get_widget(Ag, "popupdata_adddirectory");
487 if (type != TYPE_FILE && Lonlyone) {
488 gtk_widget_show (Lsep);
489 gtk_widget_show (Litem);
490 gtk_widget_show (Litem2);
491 } else {
492 gtk_widget_hide (Lsep);
493 gtk_widget_hide (Litem);
494 gtk_widget_hide (Litem2);
495 }
496
497 /* SUPPRIMER DE LA LISTE */
498 Lsep = sc_grave_get_widget(Ag, "popupdata_sep2");
499 Litem = sc_grave_get_widget(Ag, "popupdata_remove");
500 if (type != TYPE_CD) {
501 gtk_widget_hide (Lsep);
502 gtk_widget_set_sensitive(Litem, TRUE);
503 gtk_widget_show (Litem);
504
505 /* suppresion des fichiers */
506 } else {
507 gtk_widget_hide (Lsep);
508 if (Lonlyone) {
509 gtk_widget_hide (Litem);
510 } else {
511 /* si plusieurs elements de selectionne mais que le focus
512 * est sur le CD alors on affiche quand meme l'action "suppresion
513 * des fichiers" dans le popup en la grisant pour que le popup
514 * ne soit pas entierement vide */
515 gtk_widget_set_sensitive(Litem, FALSE);
516 gtk_widget_show (Litem);
517 }
518 }
519
520 /* IMAGE DE BOOT */
521 /* Lsep = sc_grave_get_widget(Ag, "popupdata_sep3");
522 Litem = sc_grave_get_widget(Ag, "popupdata_imageboot");
523 if (type == TYPE_FILE) {
524 gtk_widget_show (Lsep);
525 gtk_widget_show (Litem);
526
527 } else {
528 gtk_widget_hide (Lsep);
529 gtk_widget_hide (Litem);
530 }*/
531
532 /* TRIER */
533 if (!gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(Lmodel), &Lcolid, &Lorder)) Lcolid=0;
534
535 if (Lcolid == 2) {
536 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(sc_grave_get_widget(Ag, "popupdata_sort_name")), TRUE);
537 } else if (Lcolid == 3) {
538 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(sc_grave_get_widget(Ag, "popupdata_sort_size")), TRUE);
539 } else if (Lcolid == 4) {
540 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(sc_grave_get_widget(Ag, "popupdata_sort_location")), TRUE);
541 } else {
542 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(sc_grave_get_widget(Ag, "popupdata_sort_none")), TRUE);
543 }
544
545 return Lmenu;
546 }
547
prepare_popups(Tgrave * Ag)548 void prepare_popups(Tgrave *Ag)
549 {
550 /* popup cd audio */
551 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupaudio_addtrack")),
552 "activate", G_CALLBACK(gtk_audio_addtrack), Ag);
553 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupaudio_removetrack")),
554 "activate", G_CALLBACK(gtk_audio_removetrack), Ag);
555 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupaudio_append")),
556 "activate", G_CALLBACK(menu_load), Ag);
557
558 /* popup cd data */
559 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdata_renamecd")),
560 "activate", G_CALLBACK(callbacks_data_renameitem), Ag);
561 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdata_renamedvd")),
562 "activate", G_CALLBACK(callbacks_data_renameitem), Ag);
563
564 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdata_expand")),
565 "activate", G_CALLBACK(gtk_data_expandelement), Ag);
566 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdata_renamefile")),
567 "activate", G_CALLBACK(callbacks_data_renameitem), Ag);
568 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdata_renamedirectory")),
569 "activate", G_CALLBACK(callbacks_data_renameitem), Ag);
570 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdata_createdirectory")),
571 "activate", G_CALLBACK(gtk_data_creerrepertoire), Ag);
572 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdata_addfile")),
573 "activate", G_CALLBACK(gtk_data_addfile), Ag);
574 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdata_adddirectory")),
575 "activate", G_CALLBACK(gtk_data_adddirectory), Ag);
576
577 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdata_remove")),
578 "activate", G_CALLBACK(gtk_data_removefiles), Ag);
579
580 /* tris */
581 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdata_sort_none")),
582 "activate", G_CALLBACK(callbacks_data_asksort), Ag);
583 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdata_sort_name")),
584 "activate", G_CALLBACK(callbacks_data_asksort), Ag);
585 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdata_sort_size")),
586 "activate", G_CALLBACK(callbacks_data_asksort), Ag);
587
588
589 #if 0
590 sc_grave_get_widget(Ag, "popupdata_sep3");
591 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdata_imageboot")),
592 "activate", G_CALLBACK(gtk_def_imageboot), Ahash);
593 #endif
594
595 /* popup affichage */
596 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdisp_iconsize_48")),
597 "activate", G_CALLBACK(gtk_display_updatesize), Ag);
598 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdisp_iconsize_32")),
599 "activate", G_CALLBACK(gtk_display_updatesize), Ag);
600 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdisp_iconsize_24")),
601 "activate", G_CALLBACK(gtk_display_updatesize), Ag);
602 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdisp_iconsize_16")),
603 "activate", G_CALLBACK(gtk_display_updatesize), Ag);
604
605 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdisp_showstatusbar")),
606 "activate", G_CALLBACK(gtk_display_switchstatusbar), Ag);
607 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupdisp_hidestatusbar")),
608 "activate", G_CALLBACK(gtk_display_switchstatusbar), Ag);
609
610 /* popup formater un dvd */
611 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupform_format")),
612 "activate", G_CALLBACK(gtk_confirm_dvdoperation), Ag);
613 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupform_blank")),
614 "activate", G_CALLBACK(gtk_confirm_dvdoperation), Ag);
615 g_signal_connect(G_OBJECT(sc_grave_get_widget(Ag, "popupform_blankfull")),
616 "activate", G_CALLBACK(gtk_confirm_dvdoperation), Ag);
617 }
618
619 /* fenetre principal */
manage_main_window(guint64 * Aaudiolen,guint64 * Aaudiomaxlen,guint64 * Adatasize,guint64 * Adatamaxsize,guint64 * Advddatasize,guint64 * Advddatamaxsize)620 Tgrave *manage_main_window (guint64 *Aaudiolen, guint64 *Aaudiomaxlen,
621 guint64 *Adatasize, guint64 *Adatamaxsize, guint64 *Advddatasize, guint64 *Advddatamaxsize)
622 {
623 Tgrave *Lg = sc_grave_load("window_main.glade");
624 GtkWidget *Lwindow;
625 GtkNotebook *Lbodycdaudio, *Lbodycddata, *Lbodycdcopy, *Lbodycdother, *Lbodydvddata;
626 GtkHBox *Lmainbody;
627 GtkComboBox *Lcombo;
628 GtkTreeView *Ltreeaudio, *Ltreedata, *Ltopmenu, *Ltreedvddata;
629
630 g_assert(Lg);
631
632 Lmainbody = GTK_HBOX(sc_grave_get_widget(Lg, "mainbody"));
633 Lwindow = GTK_WIDGET(sc_grave_get_widget(Lg, "topwindow"));
634
635 sc_tooltips(Lwindow, conf_get_boolean("tooltips"));
636 image_prepare_main_window(Lg);
637
638 sc_grave_set_data(Lg, Lwindow, "window");
639 sc_grave_set_data(Lg, Aaudiolen, "audiolen");
640 sc_grave_set_data(Lg, Aaudiomaxlen, "audiomaxlen");
641 sc_grave_set_data(Lg, Adatasize, "datasize");
642 sc_grave_set_data(Lg, Adatamaxsize, "datamaxsize");
643 sc_grave_set_data(Lg, Advddatasize, "dvddatasize");
644 sc_grave_set_data(Lg, Advddatamaxsize, "dvddatamaxsize");
645
646 /* onglets page de droite */
647 Lbodycdaudio = GTK_NOTEBOOK(sc_grave_get_widget(Lg, "bodycdaudio"));
648 gtk_widget_reparent(GTK_WIDGET(Lbodycdaudio), GTK_WIDGET(Lmainbody));
649 Lbodycddata = GTK_NOTEBOOK(sc_grave_get_widget(Lg, "bodycddata"));
650 gtk_widget_reparent(GTK_WIDGET(Lbodycddata), GTK_WIDGET(Lmainbody));
651 Lbodydvddata = GTK_NOTEBOOK(sc_grave_get_widget(Lg, "bodydvddata"));
652 gtk_widget_reparent(GTK_WIDGET(Lbodydvddata), GTK_WIDGET(Lmainbody));
653 Lbodycdcopy = GTK_NOTEBOOK(sc_grave_get_widget(Lg, "bodycdcopy"));
654 gtk_widget_reparent(GTK_WIDGET(Lbodycdcopy), GTK_WIDGET(Lmainbody));
655 Lbodycdother = GTK_NOTEBOOK(sc_grave_get_widget(Lg, "bodycdother"));
656 gtk_widget_reparent(GTK_WIDGET(Lbodycdother), GTK_WIDGET(Lmainbody));
657 sc_grave_replace_data(Lg, Lbodycdaudio, "_lstclicked");
658
659 /* mise a jour des label lorsque l'on change d'onglet dans la partie "graver un cd de donnee" */
660 g_signal_connect(G_OBJECT(Lbodycddata), "switch-page", G_CALLBACK(switchpage), Lg);
661 /* mise a jour des label lorsque l'on change d'onglet dans la partie "graver un dvd de donnee" */
662 g_signal_connect(G_OBJECT(Lbodydvddata), "switch-page", G_CALLBACK(switchpage), Lg);
663
664 /* bouttons barre de gauche */
665 Ltopmenu = GTK_TREE_VIEW(sc_grave_get_widget(Lg, "topmenu"));
666
667 manage_interface(Lg, MENU_NEW + COMBO_UPDATE);
668 update_status_bar_display(Lg);
669
670 g_signal_connect(G_OBJECT(Ltopmenu), "button-press-event", G_CALLBACK(gtk_do_eventbuttonpress), Lg);
671 g_signal_connect(G_OBJECT(Ltopmenu), "popup-menu", G_CALLBACK(key_popupmenu_display), Lg);
672
673
674 /* signaux sur le menu */
675 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "menustartnew")), "activate",
676 G_CALLBACK(menu_start_new), Lg);
677 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "menuload")), "activate",
678 G_CALLBACK(menu_load), Lg);
679
680 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "menucdaudio")), "activate",
681 G_CALLBACK(menu_active_panel), Lg);
682 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "menucddata")), "activate",
683 G_CALLBACK(menu_active_panel), Lg);
684 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "menudvddata")), "activate",
685 G_CALLBACK(menu_active_panel), Lg);
686 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "menucdcopy")), "activate",
687 G_CALLBACK(menu_active_panel), Lg);
688 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "menucdother")), "activate",
689 G_CALLBACK(menu_active_panel), Lg);
690 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "menuproperties")), "activate",
691 G_CALLBACK(menu_active_proprietes), Lg);
692 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "menuquit")), "activate",
693 G_CALLBACK(menu_quit), Lg);
694 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "menuabout")), "activate",
695 G_CALLBACK(on_about), Lg);
696
697 prepare_combobox_vitesse(GTK_COMBO_BOX(sc_grave_get_widget(Lg, "dstaudiospeed")));
698 prepare_combobox_vitesse(GTK_COMBO_BOX(sc_grave_get_widget(Lg, "dstcopyspeed")));
699 prepare_combobox_vitesse(GTK_COMBO_BOX(sc_grave_get_widget(Lg, "dstdataspeed")));
700 prepare_combobox_vitesse(GTK_COMBO_BOX(sc_grave_get_widget(Lg, "dstdvddataspeed")));
701
702 /* tous les combo contenant la liste des lecteurs */
703 prepare_combobox_graveur(Lg, "dstaudio");
704
705 prepare_combobox_graveur(Lg, "dstdata");
706 prepare_disable_when_iso(Lg, "dstdatacombo", "nbrcddata", "datamulti", "datanotfix", "datasimul", NULL);
707
708 prepare_combobox_graveur(Lg, "dstdvddata");
709 prepare_disable_when_iso(Lg, "dstdvddatacombo", "nbrdvddata", "dvddatanotfix", "dvddatasimul", NULL);
710
711 prepare_combobox_graveur(Lg, "srccopy");
712 prepare_combobox_graveur(Lg, "dstcopy");
713
714 prepare_combobox_graveur(Lg, "dstother");
715 prepare_disable_when(Lg, "dstothercombo_notcdrw", "btnerasecdrwother1", NULL);
716 prepare_disable_when(Lg, "dstothercombo_notdvdrw", "btnformatdvdrwother1", NULL);
717
718 /* checkbox continuer un cd multi session, on ne permet dans ce cas pas de faire
719 * plusieurs copie a la suite */
720 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "datamulti")), "toggled", G_CALLBACK(change_datamulti), Lg);
721
722
723 /* on rempli les autres combo */
724 remplirecombo(GTK_COMBO_BOX(sc_grave_get_widget(Lg, "dataformat")), "", Gformatcd,
725 TRUE, conf_get_string("dataformat"));
726 remplirecombo(GTK_COMBO_BOX(sc_grave_get_widget(Lg, "datamodburn")), "", Gmodburn,
727 TRUE, conf_get_string("datamodburn"));
728 Lcombo = GTK_COMBO_BOX(sc_grave_get_widget(Lg, "listeremplidata"));
729 remplirecombo(Lcombo, "", Gtypecddata, TRUE, conf_get_string("listeremplidata"));
730 g_signal_connect(G_OBJECT(Lcombo), "changed", G_CALLBACK(change_remplissage), Lg);
731
732 Lcombo = GTK_COMBO_BOX(sc_grave_get_widget(Lg, "listeremplidvddata"));
733 remplirecombo(Lcombo, "", Gtypedvddata, TRUE, conf_get_string("listeremplidvddata"));
734 g_signal_connect(G_OBJECT(Lcombo), "changed", G_CALLBACK(change_remplissage), Lg);
735
736 Lcombo = GTK_COMBO_BOX(sc_grave_get_widget(Lg, "listerempliaudio"));
737 remplirecombo(Lcombo, "", Gtypecdaudio, TRUE, conf_get_string("listerempliaudio"));
738 g_signal_connect(G_OBJECT(Lcombo), "changed", G_CALLBACK(change_remplissage), Lg);
739
740 /* boutons "page suivante" */
741 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnnextaudio1")), "clicked", G_CALLBACK(gonextpage), Lbodycdaudio);
742 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnnextdata1")), "clicked", G_CALLBACK(gonextpage), Lbodycddata);
743 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnnextdata2")), "clicked", G_CALLBACK(gonextpage), Lbodycddata);
744 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnnextdvddata1")), "clicked", G_CALLBACK(gonextpage), Lbodydvddata);
745 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnnextdvddata2")), "clicked", G_CALLBACK(gonextpage), Lbodydvddata);
746
747 /* boutons "graver" */
748 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnburnaudio2")), "clicked", G_CALLBACK(confirm_burn), Lg);
749 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnburndata2")), "clicked", G_CALLBACK(confirm_burn), Lg);
750 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnburndata3")), "clicked", G_CALLBACK(confirm_burn), Lg);
751 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnburndvddata2")), "clicked", G_CALLBACK(confirm_burn), Lg);
752 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnburndvddata3")), "clicked", G_CALLBACK(confirm_burn), Lg);
753 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnburncopy1")), "clicked", G_CALLBACK(confirm_burn), Lg);
754
755 /* boutons de la page "autres operations" */
756 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnerasecdrwother1")), "clicked", G_CALLBACK(confirm_erasecdrw), Lg);
757 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnformatdvdrwother1")), "clicked", G_CALLBACK(popup_formatdvdrw), Lg);
758 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnfixcdother1")), "clicked", G_CALLBACK(confirm_fixcd), Lg);
759
760 update_combo_graveur(Lg);
761
762 /* menu popup sur les listes */
763 Ltreeaudio = GTK_TREE_VIEW(sc_grave_get_widget(Lg, "LISTEAUDIO"));
764
765 prepare_popups(Lg);
766 prepare_listeaudio(Ltreeaudio);
767
768 g_signal_connect(G_OBJECT(Ltreeaudio), "button-press-event", G_CALLBACK(gtk_do_eventbuttonpress), Lg);
769 g_signal_connect(G_OBJECT(Ltreeaudio), "popup-menu", G_CALLBACK(key_popupmenu_addaudio), Lg);
770 g_signal_connect(G_OBJECT(Ltreeaudio), "key-release-event", G_CALLBACK(gtk_do_eventkeyrelease), Lg);
771 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnaddtrack")), "clicked", G_CALLBACK(gtk_audio_addtrack), Lg);
772
773 Ltreedata = GTK_TREE_VIEW(sc_grave_get_widget(Lg, "LISTEDATA"));
774 prepare_listedata(Ltreedata, _("New CD"));
775 g_signal_connect(G_OBJECT(Ltreedata), "button-press-event", G_CALLBACK(gtk_do_eventbuttonpress), Lg);
776 g_signal_connect(G_OBJECT(Ltreedata), "popup-menu", G_CALLBACK(key_popupmenu_addfile), Lg);
777 g_signal_connect(G_OBJECT(Ltreedata), "key-release-event", G_CALLBACK(gtk_do_eventkeyrelease), Lg);
778 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnaddfile")), "clicked", G_CALLBACK(gtk_data_addfile), Lg);
779 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btnadddirectory")), "clicked",
780 G_CALLBACK(gtk_data_adddirectory), Lg);
781
782 Ltreedvddata = GTK_TREE_VIEW(sc_grave_get_widget(Lg, "LISTEDVDDATA"));
783 prepare_listedata(Ltreedvddata, _("New DVD"));
784 g_signal_connect(G_OBJECT(Ltreedvddata), "button-press-event", G_CALLBACK(gtk_do_eventbuttonpress), Lg);
785 g_signal_connect(G_OBJECT(Ltreedvddata), "popup-menu", G_CALLBACK(key_popupmenu_addfile), Lg);
786 g_signal_connect(G_OBJECT(Ltreedvddata), "key-release-event", G_CALLBACK(gtk_do_eventkeyrelease), Lg);
787 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btndvdaddfile")), "clicked", G_CALLBACK(gtk_data_addfile), Lg);
788 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "btndvdadddirectory")), "clicked",
789 G_CALLBACK(gtk_data_adddirectory), Lg);
790
791
792 /* drag and drop */
793 /* audio */
794 gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (Ltreeaudio),
795 GDK_BUTTON1_MASK, Gdndaudio, G_N_ELEMENTS (Gdndaudio), GDK_ACTION_MOVE|GDK_ACTION_COPY);
796 gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (Ltreeaudio),
797 Gdndaudio, G_N_ELEMENTS (Gdndaudio), GDK_ACTION_MOVE|GDK_ACTION_COPY);
798 g_signal_connect(G_OBJECT(Ltreeaudio), "drag-data-received", G_CALLBACK(audio_dnd_data_received), Lg);
799
800 /* cd data */
801 gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (Ltreedata),
802 GDK_BUTTON1_MASK, Gdnddata, G_N_ELEMENTS (Gdnddata), GDK_ACTION_MOVE|GDK_ACTION_COPY|GDK_ACTION_LINK);
803 gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (Ltreedata),
804 Gdnddata, G_N_ELEMENTS (Gdnddata), GDK_ACTION_MOVE|GDK_ACTION_COPY|GDK_ACTION_LINK);
805 g_signal_connect(G_OBJECT(Ltreedata), "drag-data-received", G_CALLBACK(data_dnd_data_received),
806 Lg);
807 /* dvd data */
808 gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (Ltreedvddata),
809 GDK_BUTTON1_MASK, Gdnddata, G_N_ELEMENTS (Gdnddata), GDK_ACTION_MOVE|GDK_ACTION_COPY);
810 gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (Ltreedvddata),
811 Gdnddata, G_N_ELEMENTS (Gdnddata), GDK_ACTION_MOVE|GDK_ACTION_COPY);
812 g_signal_connect(G_OBJECT(Ltreedvddata), "drag-data-received", G_CALLBACK(data_dnd_data_received),
813 Lg);
814
815 /* evenement fermer la fenetre */
816 g_signal_connect(G_OBJECT(Lwindow), "delete-event", G_CALLBACK(delete_event_quit), Lg);
817
818 /* on restaure la taille et la position que la fenetre avait lors de la derniere utilisation */
819 restore_main_window_pos(Lwindow);
820
821 /* on restaure les dernieres valeurs utilisees pour certains champs */
822 restore_last_used_values(Lg);
823
824 gtk_widget_show(Lwindow);
825
826 return Lg;
827 }
828
829 /* mise a jour des listes contenant les lecteurs */
update_combo_graveur(Tgrave * Ag)830 void update_combo_graveur(Tgrave *Ag)
831 {
832 GtkComboBox *Lsrccopycombo = GTK_COMBO_BOX(sc_grave_get_widget(Ag, "srccopycombo"));
833 GtkComboBox *Ldstcopycombo = GTK_COMBO_BOX(sc_grave_get_widget(Ag, "dstcopycombo"));
834 GtkComboBox *Ldstdatacombo = GTK_COMBO_BOX(sc_grave_get_widget(Ag, "dstdatacombo"));
835 GtkComboBox *Ldstdvddatacombo = GTK_COMBO_BOX(sc_grave_get_widget(Ag, "dstdvddatacombo"));
836 GtkComboBox *Ldstaudiocombo = GTK_COMBO_BOX(sc_grave_get_widget(Ag, "dstaudiocombo"));
837 GtkComboBox *Ldstothercombo = GTK_COMBO_BOX(sc_grave_get_widget(Ag, "dstothercombo"));
838 GtkButton *Lbtnburnaudio2 = GTK_BUTTON(sc_grave_get_widget(Ag, "btnburnaudio2"));
839 GtkButton *Lbtnburncopy1 = GTK_BUTTON(sc_grave_get_widget(Ag, "btnburncopy1"));
840 GtkButton *Lbtnfixcdother1 = GTK_BUTTON(sc_grave_get_widget(Ag, "btnfixcdother1"));
841 GtkButton *Lbtnerasecdrwother1 = GTK_BUTTON(sc_grave_get_widget(Ag, "btnerasecdrwother1"));
842 gboolean Lreadcd, Lwritecdr, Lwritecdrw, Lreaddvd, Lwritedvd;
843 matos_get_current_matos(&Lreadcd, &Lwritecdr, &Lwritecdrw, &Lreaddvd, &Lwritedvd);
844
845 remplirecombograveur(Lsrccopycombo, TYPE_ALL + TYPE_ISO, conf_get_string("srccopycombo"));
846
847 remplirecombograveur(Ldstcopycombo, TYPE_ALLWRITER + TYPE_ISO, conf_get_string("dstcopycombo"));
848
849 remplirecombograveur(Ldstdatacombo, TYPE_ALLWRITER + TYPE_ISO, conf_get_string("dstdatacombo"));
850
851 remplirecombograveur(Ldstdvddatacombo, TYPE_DVDWRITER + TYPE_ISO, conf_get_string("dstdvddatacombo"));
852
853 remplirecombograveur(Ldstaudiocombo, TYPE_ALLWRITER, conf_get_string("dstaudiocombo"));
854
855 remplirecombograveur(Ldstothercombo, TYPE_ALLWRITER, conf_get_string("dstothercombo"));
856
857 gtk_widget_set_sensitive(GTK_WIDGET(Lbtnburncopy1), Lreadcd);
858 gtk_widget_set_sensitive(GTK_WIDGET(Lbtnburnaudio2), Lwritecdr);
859 gtk_widget_set_sensitive(GTK_WIDGET(Lbtnfixcdother1), Lwritecdr);
860 gtk_widget_set_sensitive(GTK_WIDGET(Lbtnerasecdrwother1), Lwritecdrw);
861 /*if (Lwritedvd == FALSE) { et l'image iso ?!
862 gtk_widget_set_sensitive(GTK_WIDGET(Lbtnburndvddata2), FALSE);
863 gtk_widget_set_sensitive(GTK_WIDGET(Lbtnburndvddata3), FALSE);
864 }*/
865 }
866
create_isoselection(GtkWindow * AParent,GtkFileChooserAction AType)867 GtkWidget* create_isoselection (GtkWindow *AParent, GtkFileChooserAction AType)
868 {
869 GtkWidget *Lfileselection;
870
871 GtkFileFilter *filterall, *filteriso;
872
873 /* filtres pour la selection de fichiers */
874 filterall = gtk_file_filter_new ();
875 gtk_file_filter_set_name (filterall, _("All files (*.*)"));
876 gtk_file_filter_add_pattern(filterall, "*");
877 filteriso = gtk_file_filter_new ();
878 gtk_file_filter_set_name (filteriso, _("Iso images only (*.iso)"));
879 gtk_file_filter_add_pattern(filteriso, "*.iso");
880
881 Lfileselection = gtk_file_chooser_dialog_new(AType == GTK_FILE_CHOOSER_ACTION_OPEN ?
882 _("Select iso image source") : _("Select iso image destination"),
883 AParent, AType, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
884 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
885 NULL);
886
887 gtk_dialog_set_default_response (GTK_DIALOG (Lfileselection), GTK_RESPONSE_ACCEPT);
888 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (Lfileselection), filteriso);
889 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (Lfileselection), filterall);
890
891 return Lfileselection;
892 }
893
create_addfileselection(GtkWindow * AParent)894 GtkWidget* create_addfileselection (GtkWindow *AParent)
895 {
896 GtkWidget *Lfileselection;
897
898 GtkFileFilter *filterall;
899
900 /* filtres pour la selection de fichiers */
901 filterall = gtk_file_filter_new ();
902 gtk_file_filter_set_name (filterall, _("All files (*.*)"));
903 gtk_file_filter_add_pattern(filterall, "*");
904
905 Lfileselection = gtk_file_chooser_dialog_new(_("Select files to add"),
906 AParent, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
907 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
908
909 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(Lfileselection), TRUE);
910 gtk_dialog_set_default_response (GTK_DIALOG (Lfileselection), GTK_RESPONSE_ACCEPT);
911 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (Lfileselection), filterall);
912
913 return Lfileselection;
914 }
915
create_addpisteselection(GtkWindow * AParent)916 GtkWidget* create_addpisteselection (GtkWindow *AParent)
917 {
918 GtkWidget *Lfileselection;
919 GtkFileFilter *filterall, *filterwav, *filteraudio;
920 gchar Ltxt[_BUF_SIZE];
921 #ifdef ENABLE_MP3
922 GtkFileFilter *filtermp3;
923 #endif
924 #ifdef ENABLE_OGG
925 GtkFileFilter *filterogg;
926 #endif
927 #ifdef ENABLE_FLAC
928 GtkFileFilter *filterflac;
929 #endif
930
931 /* filtres pour la selection de fichiers */
932 filterall = gtk_file_filter_new ();
933 gtk_file_filter_set_name (filterall, _("All files (*.*)"));
934 gtk_file_filter_add_pattern(filterall, "*");
935
936 filteraudio = gtk_file_filter_new ();
937
938 g_strlcpy(Ltxt, _("All audio files ("), sizeof(Ltxt)-1);
939 if (GsupportFlac) strncat(Ltxt, "*.flac", sizeof(Ltxt)-strlen(Ltxt)-1);
940 if (GsupportMp3) strncat(Ltxt, "*.mp3", sizeof(Ltxt)-strlen(Ltxt)-1);
941 if (GsupportOgg) strncat(Ltxt, "*.ogg", sizeof(Ltxt)-strlen(Ltxt)-1);
942 strncat(Ltxt, "*.wav)", sizeof(Ltxt)-strlen(Ltxt)-1);
943
944 gtk_file_filter_set_name (filteraudio, Ltxt);
945
946 #ifdef ENABLE_FLAC
947 if (GsupportFlac) {
948 gtk_file_filter_add_pattern(filteraudio, "*.flac");
949 filterflac = gtk_file_filter_new ();
950 gtk_file_filter_set_name (filterflac, _("Flac files (*.flac)"));
951 gtk_file_filter_add_pattern(filterflac, "*.flac");
952 }
953 #endif
954 #ifdef ENABLE_MP3
955 if (GsupportMp3) {
956 gtk_file_filter_add_pattern(filteraudio, "*.mp3");
957 filtermp3 = gtk_file_filter_new ();
958 gtk_file_filter_set_name (filtermp3, _("Mp3 files (*.mp3)"));
959 gtk_file_filter_add_pattern(filtermp3, "*.mp3");
960 }
961 #endif
962 #ifdef ENABLE_OGG
963 if (GsupportOgg) {
964 gtk_file_filter_add_pattern(filteraudio, "*.ogg");
965 filterogg = gtk_file_filter_new ();
966 gtk_file_filter_set_name (filterogg, _("Ogg files (*.ogg)"));
967 gtk_file_filter_add_pattern(filterogg, "*.ogg");
968 }
969 #endif
970 gtk_file_filter_add_pattern(filteraudio, "*.wav");
971
972 filterwav = gtk_file_filter_new ();
973 gtk_file_filter_set_name (filterwav, _("Wav files (*.wav)"));
974 gtk_file_filter_add_pattern(filterwav, "*.wav");
975
976 Lfileselection = gtk_file_chooser_dialog_new(_("Select audio files to add"),
977 AParent, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
978 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
979
980 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(Lfileselection), TRUE);
981 gtk_dialog_set_default_response (GTK_DIALOG (Lfileselection), GTK_RESPONSE_ACCEPT);
982 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (Lfileselection), filteraudio);
983 #ifdef ENABLE_FLAC
984 if (GsupportFlac) {
985 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (Lfileselection), filterflac);
986 }
987 #endif
988 #ifdef ENABLE_MP3
989 if (GsupportMp3) {
990 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (Lfileselection), filtermp3);
991 }
992 #endif
993 #ifdef ENABLE_OGG
994 if (GsupportOgg) {
995 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (Lfileselection), filterogg);
996 }
997 #endif
998 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (Lfileselection), filterwav);
999 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (Lfileselection), filterall);
1000
1001 return Lfileselection;
1002 }
1003
create_adddirselection(GtkWindow * AParent)1004 GtkWidget* create_adddirselection (GtkWindow *AParent)
1005 {
1006 GtkWidget *Lfileselection;
1007 GtkFileFilter *Lfilterall;
1008
1009 /* filtres pour la selection de fichiers */
1010 Lfilterall = gtk_file_filter_new ();
1011 gtk_file_filter_set_name (Lfilterall, _("All files (*.*)"));
1012 gtk_file_filter_add_pattern(Lfilterall, "*");
1013 Lfileselection = gtk_file_chooser_dialog_new(_("Select directories to add"),
1014 AParent, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1015 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
1016
1017 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(Lfileselection), TRUE);
1018 gtk_dialog_set_default_response (GTK_DIALOG (Lfileselection), GTK_RESPONSE_ACCEPT);
1019 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (Lfileselection), Lfilterall);
1020
1021 return Lfileselection;
1022 }
1023
1024 /* boite de dialogue "edition media" */
1025 #if 0
1026 GHashTable *addmediaformat(GHashTable *Aparent)
1027 {
1028 gchar *Ltemplate = PACKAGE_DATA_DIR "/" PACKAGE "/dialog_media.glade";
1029 GladeXML *Lxml = glade_xml_new(Ltemplate, NULL,NULL);
1030 GtkWidget *Ldialog;
1031 GHashTable *Lhash = _hash();
1032 gulong Lsize = 0;
1033 GtkComboBox *Lcombo;
1034
1035 if (!Lxml) {
1036 g_error("Cannot load '%s': %s\n", Ltemplate, g_strerror(errno));
1037 }
1038 Ldialog = glade_to_hash(Lxml, Lhash, "dialog_media");
1039
1040 g_hash_table_insert(Lhash, "fullsize", &Lsize);
1041
1042 g_signal_connect(G_OBJECT(glade_to_hash(Lxml, Lhash, "mediadata")), "value-changed",
1043 G_CALLBACK(update_media_fields), Lhash);
1044
1045 Lcombo = GTK_COMBO_BOX(glade_to_hash(Lxml, Lhash, "mediadataunit"));
1046 remplirecombo(Lcombo, "", Gtypeunit, TRUE);
1047 g_signal_connect(G_OBJECT(Lcombo), "changed", G_CALLBACK(update_media_unit), Lhash);
1048
1049 glade_to_hash(Lxml, Lhash, "labelmediadata");
1050 glade_to_hash(Lxml, Lhash, "labelmediaaudio");
1051
1052 return Lhash;
1053 }
1054 #endif
1055
1056 /* boite de dialogue "editer un peripherique" */
create_dialog_edit_device(GtkWidget * Aparent,Tdriveinfo * Adrive)1057 Tgrave *create_dialog_edit_device(GtkWidget *Aparent, Tdriveinfo *Adrive)
1058 {
1059 Tgrave *Lg = sc_grave_load("dialog_device.glade");
1060 GtkWidget *Ldialog;
1061 GtkComboBox *Lcombobox;
1062
1063 g_assert(Lg);
1064
1065 Ldialog = sc_grave_get_widget(Lg, "dialog_device");
1066 gtk_window_set_transient_for(GTK_WINDOW(Ldialog), GTK_WINDOW(Aparent));
1067 sc_grave_ref_wtd(Lg, "dialog_device", "window");
1068 gtk_dialog_set_default_response(GTK_DIALOG(Ldialog), GTK_RESPONSE_OK);
1069
1070 gtk_entry_set_text(GTK_ENTRY(sc_grave_get_widget(Lg, "devicename")), Adrive->name);
1071 Lcombobox = GTK_COMBO_BOX(sc_grave_get_widget(Lg, "devicebus"));
1072
1073 manage_combobox_devicebus(Lcombobox, Adrive);
1074
1075 return Lg;
1076 }
1077
1078 /* boite de dialogue "ajouter un peripherique" */
create_dialog_add_device(GtkWidget * Aparent)1079 Tgrave *create_dialog_add_device(GtkWidget *Aparent)
1080 {
1081 Tgrave *Lg = sc_grave_load("dialog_add_device.glade");
1082 GtkWidget *Ldialog;
1083
1084 g_assert(Lg);
1085
1086 Ldialog = sc_grave_get_widget(Lg, "dialog_add_device");
1087 gtk_window_set_transient_for(GTK_WINDOW(Ldialog), GTK_WINDOW(Aparent));
1088 sc_grave_ref_wtd(Lg, "dialog_add_device", "window");
1089
1090 gtk_dialog_set_default_response(GTK_DIALOG(Ldialog), GTK_RESPONSE_OK);
1091
1092 gtk_entry_set_text(GTK_ENTRY(sc_grave_get_widget(Lg, "devicename")), _("New device"));
1093
1094 return Lg;
1095 }
1096
1097
1098 /* boite de dialogue "a propos de ..." */
about_graveman(void)1099 void about_graveman (void)
1100 {
1101 Tgrave *Lg = sc_grave_load("dialog_about.glade");
1102 GtkWidget *Ldialog;
1103 GtkLabel *Llabelversion;
1104 gchar *Ltmp;
1105
1106 g_assert(Lg);
1107
1108 Llabelversion = GTK_LABEL(sc_grave_get_widget(Lg, "version"));
1109
1110 Ltmp = g_strdup_printf(_("version %s - http://www.nongnu.org/graveman"), VERSION);
1111 gtk_label_set_label(Llabelversion, Ltmp);
1112 g_free(Ltmp);
1113
1114 Ldialog = sc_grave_get_widget(Lg, "dialog_about");
1115 gtk_dialog_run(GTK_DIALOG(Ldialog));
1116 gtk_widget_destroy(Ldialog);
1117
1118 sc_grave_destroy(Lg);
1119 }
1120
hide_some_progressbar(Tgrave * Ag)1121 void hide_some_progressbar(Tgrave *Ag)
1122 {
1123 GtkWidget *Lpbfifo = sc_grave_get_widget(Ag, "pb_fifo");
1124 GtkWidget *Lpbbuffer = sc_grave_get_widget(Ag, "pb_buffer");
1125 GtkWidget *Llfifo = sc_grave_get_widget(Ag, "l_fifo");
1126 GtkWidget *Llbuffer = sc_grave_get_widget(Ag, "l_buffer");
1127
1128 gtk_widget_hide(Lpbfifo);
1129 gtk_widget_hide(Llfifo);
1130 gtk_widget_hide(Lpbbuffer);
1131 gtk_widget_hide(Llbuffer);
1132 }
1133
1134 /* fenetre gravure d'un cd en cours */
show_graverwindow(Tgrave * Ag,gchar * Aaction,gchar * Atitle)1135 void show_graverwindow (Tgrave *Ag, gchar *Aaction, gchar *Atitle)
1136 {
1137 Tgrave *Lburng = sc_grave_load("window_burn.glade");
1138 GtkWidget *Lwindowburn;
1139 GtkLabel *Ltitle;
1140 GtkProgressBar *Lpbtotal, *Lpbstep, *Lpbfifo, *Lpbbuffer;
1141 gint Ltotaldone = 0;
1142 gint Lpid = 0, Lpid2 = 0;
1143 gboolean Labort = FALSE;
1144 gboolean Lbackvalue = FALSE;
1145 gint Lcont = 1;
1146 GtkWidget *Lstatusbox = NULL;
1147 GtkWidget *Lparent = GTK_WIDGET(sc_grave_get_widget(Ag, "topwindow"));
1148 GError *Lerror = NULL;
1149 Tmng *Lmnglogo = gtk_mng_read_file(get_animation("Working"));
1150 GtkMngView *Lmngview = GTK_MNG_VIEW(gtk_mng_view_new());
1151
1152 g_assert(Lburng);
1153 g_assert(Lmnglogo);
1154
1155 Lwindowburn = sc_grave_get_widget(Lburng, "window_burn");
1156 gtk_window_set_transient_for(GTK_WINDOW(Lwindowburn), GTK_WINDOW(Lparent));
1157
1158 /* on insere le logo anim� mng */
1159
1160 gtk_table_attach(GTK_TABLE(sc_grave_get_widget(Lburng, "tableburn")),
1161 GTK_WIDGET(Lmngview), 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
1162 gtk_mng_view_load(Lmngview, Lmnglogo);
1163 gtk_widget_show(GTK_WIDGET(Lmngview));
1164 gtk_mng_free(Lmnglogo);
1165
1166 /* barres de progression */
1167 Lpbtotal = GTK_PROGRESS_BAR(sc_grave_get_widget(Lburng, "pb_total"));
1168 Lpbstep = GTK_PROGRESS_BAR(sc_grave_get_widget(Lburng, "pb_step"));
1169
1170 /* pour la conversion des fichiers audio et la pulse bar */
1171 Lpbfifo = GTK_PROGRESS_BAR(sc_grave_get_widget(Lburng, "pb_fifo"));
1172
1173 Lpbbuffer = GTK_PROGRESS_BAR(sc_grave_get_widget(Lburng, "pb_buffer"));
1174 Ltitle = GTK_LABEL(sc_grave_get_widget(Lburng, "gravetitle"));
1175
1176 if (Atitle && *Atitle) {
1177 gtk_label_set_text(Ltitle, Atitle);
1178 }
1179
1180 /* on attache les variables utilisees lors de l'operation */
1181 sc_grave_set_data(Ag, Lwindowburn, "window_burn");
1182 sc_grave_set_data(Ag, Ltitle, "gravetitle");
1183 sc_grave_set_data(Ag, Lpbtotal, "pb_total");
1184 sc_grave_set_data(Ag, Lpbstep, "pb_step");
1185 sc_grave_set_data(Ag, Lpbstep, "progress");
1186 sc_grave_set_data(Ag, Lpbfifo, "pb_fifo");
1187 sc_grave_set_data(Ag, Lpbbuffer, "pb_buffer");
1188
1189 sc_grave_set_data(Ag, &Ltotaldone, "totaldone");
1190 sc_grave_set_data(Ag, &Labort, "gabort"); /* operation annulee par l'utilisateur ? */
1191 sc_grave_set_data(Ag, &Lpid, "pid");
1192 sc_grave_set_data(Ag, &Lcont, "cont");
1193 sc_grave_set_data(Ag, &Lpid2, "pid2");
1194
1195 /* bouton annuler l'operation */
1196 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lburng, "btncancelburn")), "clicked", G_CALLBACK(abort_gravure), Ag);
1197 g_signal_connect(G_OBJECT(Lwindowburn), "delete_event", GTK_SIGNAL_FUNC(on_deleteevent_gravure), Ag);
1198
1199 /* lancement de l'operation en elle meme */
1200 if (g_str_has_prefix(Aaction, "btnburncopy")) {
1201 Lbackvalue = burn_copy(Ag, &Lerror);
1202 } else if (g_str_has_prefix(Aaction, "btnburnaudio")) {
1203 Lbackvalue = burn_audio(Ag, &Lerror);
1204 } else if (g_str_has_prefix(Aaction, "btnburndata")) {
1205 Lbackvalue = burn_data(Ag, &Lerror);
1206 } else if (g_str_has_prefix(Aaction, "btnburndvddata")) {
1207 hide_some_progressbar(Lburng);
1208 Lbackvalue = burn_dvddata(Ag, &Lerror);
1209 }
1210
1211 if (Labort) {
1212 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwindowburn),
1213 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
1214 _("Operation aborted by user !"));
1215 } else {
1216
1217 /* pour plus de beaute on s'assure que les barres de progression aient les bonnes
1218 * valeurs :-) */
1219 gtk_progress_bar_set_fraction(Lpbtotal, 1);
1220 gtk_progress_bar_set_fraction(Lpbstep, 1);
1221 gtk_progress_bar_set_fraction(Lpbfifo, 0);
1222 gtk_progress_bar_set_fraction(Lpbbuffer, 0);
1223 gtk_progress_bar_set_text(Lpbtotal, "100%");
1224 gtk_progress_bar_set_text(Lpbstep, "100%");
1225 gtk_progress_bar_set_text(Lpbfifo, "0%");
1226 gtk_progress_bar_set_text(Lpbbuffer, "0%");
1227
1228 if (Lbackvalue == FALSE) {
1229 gtk_label_set_text(Ltitle, _("Operation failed"));
1230
1231 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwindowburn),
1232 GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
1233 Lerror ? Lerror->message : _("Operation failed"));
1234 } else {
1235 gtk_label_set_text(Ltitle, _("Operation successful."));
1236
1237 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwindowburn),
1238 GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
1239 _("Operation successful"));
1240 }
1241 }
1242
1243 if (Lstatusbox) {
1244 gtk_mng_view_stop_animation(Lmngview);
1245 gtk_dialog_run(GTK_DIALOG(Lstatusbox));
1246 gtk_widget_destroy(Lstatusbox);
1247 }
1248
1249 gtk_widget_destroy(Lwindowburn);
1250 sc_grave_destroy(Lburng);
1251 if (Lerror) g_error_free(Lerror);
1252 }
1253
1254 /* fenetre "operation en cours" */
create_window_encours(GtkWidget * Aparent)1255 Tgrave *create_window_encours(GtkWidget *Aparent)
1256 {
1257 Tgrave *Lg = sc_grave_load("window_inprogress.glade");
1258
1259 g_assert(Lg);
1260
1261 gtk_image_set_from_pixbuf(GTK_IMAGE(sc_grave_get_widget(Lg, "imgburning")), get_image("BurnIcon"));
1262
1263 if (GTK_IS_WIDGET(Aparent)) {
1264 gtk_window_set_transient_for(GTK_WINDOW(sc_grave_get_widget(Lg, "window_inprogress")), GTK_WINDOW(Aparent));
1265 }
1266
1267 return Lg;
1268 }
1269
prepare_combobox_vitesse(GtkComboBox * Acombobox)1270 void prepare_combobox_vitesse(GtkComboBox *Acombobox)
1271 {
1272 if (GTK_IS_WIDGET(Acombobox)) {
1273 GtkListStore *Lmodel = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
1274 GtkCellRenderer *Lcellrender = GTK_CELL_RENDERER(gtk_cell_renderer_text_new());
1275 gtk_combo_box_set_model(Acombobox, GTK_TREE_MODEL(Lmodel));
1276
1277 gtk_cell_layout_clear(GTK_CELL_LAYOUT(Acombobox));
1278 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(Acombobox), Lcellrender, TRUE);
1279 gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(Acombobox), Lcellrender,
1280 "text", 1, NULL);
1281 }
1282 }
1283
1284 /* objets a cacher lorsque l'on selectionne une image iso en tant que source ou destination */
prepare_disable_when_iso(Tgrave * Ag,gchar * Abasename,const gchar * Afirst,...)1285 void prepare_disable_when_iso(Tgrave *Ag, gchar *Abasename, const gchar *Afirst, ...)
1286 {
1287 va_list Largs;
1288 gchar *Lbuf = (gchar *) Afirst;
1289 gint Lnbr = 0;
1290 gchar *Lname = g_strdup_printf("%s_isotodisabled%d", Abasename, Lnbr++);
1291 gchar *Lcur;
1292
1293 sc_grave_ref_wtd(Ag, Lbuf, Lname);
1294
1295 va_start(Largs, Afirst);
1296 while (*Lbuf++) {
1297 if (!(Lcur = va_arg(Largs, gchar *))) break;
1298
1299 Lname = g_strdup_printf("%s_isotodisabled%d", Abasename, Lnbr++);
1300 sc_grave_ref_wtd(Ag, Lcur, Lname);
1301 }
1302
1303 va_end(Largs);
1304 }
1305
1306 /* objets a cacher lorsque l'on selectionne une image iso en tant que source ou destination */
prepare_disable_when(Tgrave * Ag,gchar * Abasename,const gchar * Afirst,...)1307 void prepare_disable_when(Tgrave *Ag, gchar *Abasename, const gchar *Afirst, ...)
1308 {
1309 va_list Largs;
1310 gchar *Lbuf = (gchar *) Afirst;
1311 gint Lnbr = 0;
1312 gchar *Lname = g_strdup_printf("%stodisabled%d", Abasename, Lnbr++);
1313 gchar *Lcur;
1314
1315 sc_grave_ref_wtd(Ag, Lbuf, Lname);
1316
1317 va_start(Largs, Afirst);
1318 while (*Lbuf++) {
1319 if (!(Lcur = va_arg(Largs, gchar *))) break;
1320
1321 Lname = g_strdup_printf("%stodisabled%d", Abasename, Lnbr++);
1322 sc_grave_ref_wtd(Ag, Lcur, Lname);
1323 }
1324
1325 va_end(Largs);
1326 }
1327
gtk_toggle_top_menu(GtkTreeView * Atopmenu,gpointer Adata)1328 void gtk_toggle_top_menu(GtkTreeView *Atopmenu, gpointer Adata)
1329 {
1330 Tgrave *Lg = (Tgrave *)Adata;
1331 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(Atopmenu);
1332 GtkTreeIter Liter;
1333 gchar *Lident;
1334 GtkNotebook *Llstclick = sc_grave_get_data(Lg, "_lstclicked"); /* dernier element ayant eu le focus */
1335 GtkNotebook *Lnewclick;
1336 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(Atopmenu);
1337
1338 if (!gtk_tree_selection_get_selected(Lselection, &Ltreemodel, &Liter)) return;
1339
1340 gtk_tree_model_get(Ltreemodel, &Liter, 0, &Lident, -1);
1341 Lnewclick = GTK_NOTEBOOK(sc_grave_get_widget(Lg, Lident));
1342 if (GTK_IS_NOTEBOOK(Lnewclick)) {
1343 if (GTK_IS_NOTEBOOK(Llstclick)) {
1344 gtk_widget_hide(GTK_WIDGET(Llstclick));
1345 }
1346 sc_grave_replace_data(Lg, Lnewclick, "_lstclicked");
1347
1348 gtk_widget_show(GTK_WIDGET(Lnewclick));
1349
1350 /* pointeur sur la liste courante pour plus de simplicite */
1351 if (!strcmp(Lident, "bodycddata")) {
1352 sc_grave_replace_data(Lg, sc_grave_get_widget(Lg, "LISTEDATA"), "_current_list");
1353 } else if (!strcmp(Lident, "bodydvddata")) {
1354 sc_grave_replace_data(Lg, sc_grave_get_widget(Lg, "LISTEDVDDATA"), "_current_list");
1355 } else if (!strcmp(Lident, "bodycdaudio")) {
1356 sc_grave_replace_data(Lg, sc_grave_get_widget(Lg, "LISTEAUDIO"), "_current_list");
1357 }
1358 }
1359 g_free(Lident);
1360 }
1361
1362 /* status bar */
update_status_bar_display(Tgrave * Ag)1363 void update_status_bar_display(Tgrave *Ag)
1364 {
1365 gboolean Ldispsb = conf_get_boolean("statusbar");
1366 GtkWidget *Ldisp = sc_grave_get_widget(Ag, "statusbar");
1367
1368 if (Ldispsb) {
1369 gtk_widget_show(Ldisp);
1370 } else {
1371 gtk_widget_hide(Ldisp);
1372 }
1373 }
1374
1375 /* mise a jour interface */
manage_interface(Tgrave * Ag,gint Aaction)1376 void manage_interface(Tgrave *Ag, gint Aaction)
1377 {
1378 GtkListStore *Lmodel;
1379 GtkTreeView *Ltopmenu = GTK_TREE_VIEW(sc_grave_get_widget(Ag, "topmenu"));
1380 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(Ltopmenu);
1381 GtkTreeIter Liter;
1382 GtkCellRenderer *Lcellrender;
1383 GtkTreeViewColumn *Lcell;
1384
1385 if (Aaction & MENU_NEW) {
1386 Lmodel = gtk_list_store_new(3, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING);
1387 gtk_tree_selection_set_mode(Lselection, GTK_SELECTION_BROWSE);
1388 gtk_tree_view_set_model(Ltopmenu, GTK_TREE_MODEL(Lmodel));
1389
1390 /* creation colonnes */
1391 Lcellrender = gtk_cell_renderer_pixbuf_new();
1392 Lcell = gtk_tree_view_column_new_with_attributes("", Lcellrender, "pixbuf", 1, NULL);
1393 gtk_tree_view_append_column(GTK_TREE_VIEW(Ltopmenu), Lcell);
1394
1395 Lcellrender = gtk_cell_renderer_pixbuf_new();
1396 Lcellrender = gtk_cell_renderer_text_new();
1397 Lcell = gtk_tree_view_column_new_with_attributes("", Lcellrender, "text", 2, NULL);
1398 gtk_tree_view_append_column(GTK_TREE_VIEW(Ltopmenu), Lcell);
1399 Lcellrender = gtk_cell_renderer_pixbuf_new();
1400
1401 g_signal_connect(G_OBJECT(Ltopmenu), "cursor-changed", G_CALLBACK(gtk_toggle_top_menu), Ag);
1402 } else {
1403 Lmodel = GTK_LIST_STORE(gtk_tree_view_get_model(Ltopmenu));
1404 gtk_list_store_clear(Lmodel);
1405 }
1406
1407 /* les icones en elles meme */
1408 prepare_menu_images(Ag);
1409
1410 gtk_list_store_append(Lmodel, &Liter);
1411 gtk_list_store_set(Lmodel, &Liter, 0, "bodycdaudio", 1, get_image("Menu-Audio-"), 2, _("Audio CD"), -1);
1412 gtk_tree_selection_select_iter(Lselection, &Liter);
1413 gtk_toggle_top_menu(Ltopmenu, Ag);
1414
1415 gtk_list_store_append(Lmodel, &Liter);
1416 gtk_list_store_set(Lmodel, &Liter, 0, "bodycddata", 1, get_image("Menu-Data-"), 2, _("Data CD"), -1);
1417
1418 gtk_list_store_append(Lmodel, &Liter);
1419 gtk_list_store_set(Lmodel, &Liter, 0, "bodydvddata", 1, get_image("Menu-Dvd-"), 2, _("Data DVD"), -1);
1420
1421 gtk_list_store_append(Lmodel, &Liter);
1422 gtk_list_store_set(Lmodel, &Liter, 0, "bodycdcopy", 1, get_image("Menu-Copy-"), 2, _("Duplicate CD"), -1);
1423
1424 gtk_list_store_append(Lmodel, &Liter);
1425 gtk_list_store_set(Lmodel, &Liter, 0, "bodycdother", 1, get_image("Menu-Other-"), 2, _("Other operations"), -1);
1426
1427 gtk_tree_view_columns_autosize(Ltopmenu);
1428
1429 /* mise a jour combo "iso level" */
1430 if (Aaction & COMBO_UPDATE) {
1431 remplirecombo_full(GTK_COMBO_BOX(sc_grave_get_widget(Ag, "dataisolevel")), "", Gisolevel,
1432 TRUE, conf_get_string("dataisolevel"), conf_get_int("mkisofs_support_isov2"));
1433 }
1434 }
1435
1436
1437 /* preparation du combo contenant la liste du peripherique a utiliser */
prepare_combobox_graveur(Tgrave * Ag,gchar * Abasename)1438 void prepare_combobox_graveur(Tgrave *Ag, gchar *Abasename)
1439 {
1440 GtkComboBox *Lcombobox = GTK_COMBO_BOX(sc_grave_get_widgetv(Ag, "%scombo", Abasename));
1441 if (GTK_IS_COMBO_BOX(Lcombobox)) {
1442 GtkListStore *Lmodel = gtk_list_store_new(4, G_TYPE_POINTER, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT);
1443 GtkCellRenderer *Lcellrender;
1444 GtkWidget *Lbtniso = sc_grave_get_widgetv(Ag, "%sbtn", Abasename);
1445
1446 gtk_combo_box_set_model(Lcombobox, GTK_TREE_MODEL(Lmodel));
1447 Lcellrender = GTK_CELL_RENDERER(gtk_cell_renderer_pixbuf_new());
1448 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(Lcombobox), Lcellrender, TRUE);
1449 gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(Lcombobox), Lcellrender,
1450 "pixbuf", 1, NULL);
1451 Lcellrender = GTK_CELL_RENDERER(gtk_cell_renderer_text_new());
1452 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(Lcombobox), Lcellrender, TRUE);
1453 gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(Lcombobox), Lcellrender,
1454 "text", 2, NULL);
1455
1456 g_signal_connect(G_OBJECT(Lcombobox), "changed", G_CALLBACK(on_selectgraveur), Ag);
1457 /* il y a peutetre un champ "image iso" associe a ce combo graveur */
1458
1459 if (GTK_IS_BUTTON(Lbtniso)) {
1460 g_signal_connect(G_OBJECT(Lbtniso), "clicked", G_CALLBACK(gtk_file_sel), Ag);
1461 }
1462 }
1463 }
1464
manage_combobox_devicebus(GtkComboBox * Acombobox,Tdriveinfo * Adrive)1465 void manage_combobox_devicebus(GtkComboBox *Acombobox, Tdriveinfo *Adrive)
1466 {
1467 GtkListStore *Lmodel = gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING);
1468 GtkCellRenderer *Lcellrender = GTK_CELL_RENDERER(gtk_cell_renderer_text_new());
1469 GtkTreeIter Liter;
1470 GSList *Lcur;
1471 gint i;
1472
1473 gtk_combo_box_set_model(Acombobox, GTK_TREE_MODEL(Lmodel));
1474
1475 gtk_cell_layout_clear(GTK_CELL_LAYOUT(Acombobox));
1476 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(Acombobox), Lcellrender, TRUE);
1477 gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(Acombobox), Lcellrender,
1478 "text", 1, NULL);
1479
1480 for(Lcur = Adrive->dev, i=0; Lcur; Lcur = g_slist_next(Lcur), i++) {
1481 gtk_list_store_append(Lmodel, &Liter);
1482 gtk_list_store_set(Lmodel, &Liter, 0, i, 1, (gchar *)Lcur->data, -1);
1483 if (i==Adrive->actuperiph) gtk_combo_box_set_active_iter(Acombobox, &Liter);
1484 }
1485 }
1486
1487 #if 0
1488 void prepare_properties_mediatreeview(GtkTreeView *Atreeview)
1489 {
1490 GtkListStore *Lmodel = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
1491 GtkCellRenderer *Lcellrender;
1492 GtkTreeViewColumn *Lcell;
1493
1494 gtk_tree_view_set_model(Atreeview, GTK_TREE_MODEL(Lmodel));
1495
1496 /* creation colonnes */
1497 Lcellrender = gtk_cell_renderer_text_new();
1498 Lcell = gtk_tree_view_column_new_with_attributes(("Label for Audio media"), Lcellrender, "text", 0, NULL);
1499 gtk_tree_view_append_column(GTK_TREE_VIEW(Atreeview), Lcell);
1500
1501 Lcellrender = gtk_cell_renderer_text_new();
1502 Lcell = gtk_tree_view_column_new_with_attributes(("Label for Data media"), Lcellrender, "text", 1, NULL);
1503 gtk_tree_view_append_column(GTK_TREE_VIEW(Atreeview), Lcell);
1504 }
1505 #endif
1506
prepare_properties_devicestreeview(GtkTreeView * Atreeview)1507 void prepare_properties_devicestreeview(GtkTreeView *Atreeview)
1508 {
1509 GtkListStore *Lmodel = gtk_list_store_new(5, G_TYPE_INT, GDK_TYPE_PIXBUF, G_TYPE_STRING,
1510 G_TYPE_STRING, G_TYPE_STRING);
1511 GtkCellRenderer *Lcellrender;
1512 GtkTreeViewColumn *Lcell;
1513
1514 gtk_tree_view_set_model(Atreeview, GTK_TREE_MODEL(Lmodel));
1515
1516 /* creation colonnes */
1517 Lcellrender = gtk_cell_renderer_pixbuf_new();
1518 Lcell = gtk_tree_view_column_new_with_attributes("", Lcellrender, "pixbuf", 1, NULL);
1519 gtk_tree_view_column_set_resizable(Lcell, TRUE);
1520 gtk_tree_view_append_column(GTK_TREE_VIEW(Atreeview), Lcell);
1521
1522 Lcellrender = gtk_cell_renderer_text_new();
1523 Lcell = gtk_tree_view_column_new_with_attributes(_("Location"), Lcellrender, "text", 2, NULL);
1524 gtk_tree_view_column_set_resizable(Lcell, TRUE);
1525 gtk_tree_view_append_column(GTK_TREE_VIEW(Atreeview), Lcell);
1526
1527 Lcellrender = gtk_cell_renderer_text_new();
1528 Lcell = gtk_tree_view_column_new_with_attributes(_("Type"), Lcellrender, "text", 3, NULL);
1529 gtk_tree_view_column_set_resizable(Lcell, TRUE);
1530 gtk_tree_view_append_column(GTK_TREE_VIEW(Atreeview), Lcell);
1531
1532 Lcellrender = gtk_cell_renderer_text_new();
1533 Lcell = gtk_tree_view_column_new_with_attributes(_("Name"), Lcellrender, "text", 4, NULL);
1534 gtk_tree_view_column_set_resizable(Lcell, TRUE);
1535 gtk_tree_view_append_column(GTK_TREE_VIEW(Atreeview), Lcell);
1536
1537 }
1538
prepare_listeaudio(GtkTreeView * Atreeaudio)1539 void prepare_listeaudio(GtkTreeView *Atreeaudio)
1540 {
1541 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(Atreeaudio));
1542 GtkListStore *Lmodel = gtk_list_store_new(7, G_TYPE_INT, GDK_TYPE_PIXBUF, G_TYPE_STRING,
1543 G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT);
1544 GtkCellRenderer *Lcellrender;
1545 GtkTreeViewColumn *Lcell;
1546
1547 gtk_tree_selection_set_mode(Lselection, GTK_SELECTION_MULTIPLE);
1548
1549 /* creation colonnes */
1550 Lcellrender = gtk_cell_renderer_pixbuf_new();
1551 Lcell = gtk_tree_view_column_new_with_attributes("", Lcellrender, "pixbuf", 1, NULL);
1552 gtk_tree_view_column_set_resizable(Lcell, TRUE);
1553 gtk_tree_view_append_column(GTK_TREE_VIEW(Atreeaudio), Lcell);
1554
1555 Lcellrender = gtk_cell_renderer_text_new();
1556 Lcell = gtk_tree_view_column_new_with_attributes(_("Track"), Lcellrender, "text", 2, NULL);
1557 gtk_tree_view_column_set_resizable(Lcell, TRUE);
1558 gtk_tree_view_column_set_sort_column_id (Lcell, 2);
1559 gtk_tree_view_append_column(GTK_TREE_VIEW(Atreeaudio), Lcell);
1560
1561 Lcellrender = gtk_cell_renderer_text_new();
1562 Lcell = gtk_tree_view_column_new_with_attributes(_("Length"), Lcellrender, "text", 3, NULL);
1563 gtk_tree_view_column_set_resizable(Lcell, TRUE);
1564 gtk_tree_view_column_set_sort_column_id (Lcell, 3);
1565 gtk_tree_view_append_column(GTK_TREE_VIEW(Atreeaudio), Lcell);
1566
1567 Lcellrender = gtk_cell_renderer_text_new();
1568 Lcell = gtk_tree_view_column_new_with_attributes(_("Location"), Lcellrender, "text", 4, NULL);
1569 gtk_tree_view_column_set_sort_column_id (Lcell, 4);
1570 gtk_tree_view_append_column(GTK_TREE_VIEW(Atreeaudio), Lcell);
1571
1572 gtk_tree_view_set_model(Atreeaudio, GTK_TREE_MODEL(Lmodel));
1573 }
1574
prepare_listedata(GtkTreeView * Atreedata,gchar * Atitle)1575 void prepare_listedata(GtkTreeView *Atreedata, gchar *Atitle)
1576 {
1577 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(Atreedata));
1578 GtkTreeStore *Lmodel = gtk_tree_store_new(7, G_TYPE_INT, GDK_TYPE_PIXBUF, G_TYPE_STRING,
1579 G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT);
1580 GtkTreeIter Liter;
1581 GtkCellRenderer *Lcellrender;
1582 GtkTreeViewColumn *Lcell;
1583
1584 // gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(Lmodel), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, NULL, NULL);
1585
1586 gtk_tree_selection_set_mode(Lselection, GTK_SELECTION_MULTIPLE);
1587 gtk_tree_view_set_enable_search(Atreedata, TRUE);
1588 gtk_tree_view_set_model(Atreedata, GTK_TREE_MODEL(Lmodel));
1589
1590 /* creation colonnes */
1591 Lcellrender = gtk_cell_renderer_pixbuf_new();
1592 Lcell = gtk_tree_view_column_new_with_attributes("", Lcellrender, "pixbuf", 1, NULL);
1593 gtk_tree_view_column_set_resizable(Lcell, TRUE);
1594 gtk_tree_view_append_column(Atreedata, Lcell);
1595
1596 Lcellrender = gtk_cell_renderer_text_new();
1597 Lcell = gtk_tree_view_column_new_with_attributes(_("Name"), Lcellrender, "text", 2, NULL);
1598
1599 gtk_tree_view_column_set_sort_column_id (Lcell, 2);
1600 gtk_tree_view_column_set_resizable(Lcell, TRUE);
1601 gtk_tree_view_append_column(Atreedata, Lcell);
1602
1603 Lcellrender = gtk_cell_renderer_text_new();
1604 Lcell = gtk_tree_view_column_new_with_attributes(_("Size"), Lcellrender, "text", 3, NULL);
1605 gtk_tree_view_column_set_sort_column_id (Lcell, 3);
1606 gtk_tree_view_column_set_resizable(Lcell, TRUE);
1607 gtk_tree_view_append_column(Atreedata, Lcell);
1608
1609 Lcellrender = gtk_cell_renderer_text_new();
1610 Lcell = gtk_tree_view_column_new_with_attributes(_("Location"), Lcellrender, "text", 4, NULL);
1611 gtk_tree_view_column_set_sort_column_id (Lcell, 4);
1612 gtk_tree_view_append_column(Atreedata, Lcell);
1613
1614 /* icone de base dans la liste des fichiers */
1615 gtk_tree_store_append(GTK_TREE_STORE(Lmodel), &Liter, NULL);
1616 gtk_tree_store_set(Lmodel, &Liter, 0, TYPE_CD, 1, get_image("CDsmallIcon"), 2, Atitle, 3, "", 4, "", 5, "", 6, 0, -1);
1617 }
1618
1619 /* fenetre de confirmation avec une checkbox */
create_dialog_confirm_operation(GtkWidget * Aparent,gchar * Alabel,gchar * Acheckboxlbl,gboolean Acheckboxstatus)1620 Tgrave *create_dialog_confirm_operation (GtkWidget *Aparent,
1621 gchar *Alabel, gchar *Acheckboxlbl, gboolean Acheckboxstatus)
1622 {
1623 Tgrave *Lg = sc_grave_load("dialog_confirm_operation.glade");
1624 GtkWidget *Ldialog;
1625 GtkToggleButton *Ltoggleoption;
1626
1627 g_assert(Lg);
1628
1629 Ldialog = sc_grave_get_widget(Lg, "dialog_confirm_operation");
1630 gtk_window_set_transient_for(GTK_WINDOW(Ldialog), GTK_WINDOW(Aparent));
1631 sc_grave_set_data(Lg, Ldialog, "window");
1632
1633 /* titre */
1634 gtk_label_set_text(GTK_LABEL(sc_grave_get_widget(Lg, "label")), Alabel);
1635
1636 /* effacer les cdrw en mode fast ? */
1637 Ltoggleoption = GTK_TOGGLE_BUTTON(sc_grave_get_widget(Lg, "checkbox"));
1638 if (Acheckboxlbl) {
1639 gtk_toggle_button_set_active(Ltoggleoption, Acheckboxstatus);
1640 gtk_button_set_label(GTK_BUTTON(Ltoggleoption), Acheckboxlbl);
1641 } else {
1642 gtk_widget_hide(GTK_WIDGET(Ltoggleoption));
1643 }
1644
1645 return Lg;
1646 }
1647
1648 /* fenetre selection d'une operation sur un dvd */
create_dialog_select_dvdoperation(GtkWidget * Aparent,gint Atypedvd)1649 Tgrave *create_dialog_select_dvdoperation (GtkWidget *Aparent, gint Atypedvd)
1650 {
1651 Tgrave *Lg = sc_grave_load("dialog_select_operation.glade");
1652 GtkWidget *Ldialog;
1653
1654 g_assert(Lg);
1655
1656 Ldialog = sc_grave_get_widget(Lg, "dialog_select_operation");
1657 gtk_window_set_transient_for(GTK_WINDOW(Ldialog), GTK_WINDOW(Aparent));
1658 sc_grave_set_data(Lg, Ldialog, "window");
1659
1660 /* commencer une session ou merger ? */
1661 if (Atypedvd & _MEDIA_BLANK) {
1662 /* si le dvd est vide alors c'est forcement pour la commencer, on cache
1663 * donc la case a cocher "merger" */
1664 gtk_widget_hide(sc_grave_get_widget(Lg, "burnmerge"));
1665 }
1666 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sc_grave_get_widget(Lg, "burninitial")), TRUE);
1667
1668 return Lg;
1669 }
1670
1671 /* premiere utilisation de graveman, bienvenue ! */
welcome_to_graveman(void)1672 void welcome_to_graveman(void)
1673 {
1674 Tgrave *Lg = sc_grave_load("dialog_welcome.glade");
1675 GtkWidget *Ldialog;
1676
1677 g_assert(Lg);
1678
1679 Ldialog = sc_grave_get_widget(Lg, "dialog_welcome");
1680
1681 gtk_dialog_run(GTK_DIALOG(Ldialog));
1682 gtk_widget_destroy(Ldialog);
1683 sc_grave_destroy(Lg);
1684 }
1685
1686 /* mise a jour d'une bar indicant le remplissage, passage en rouge si le cd est plein */
switch_pbar_status(GtkProgressBar * Apbar,guint64 Amaxlen,guint64 Acurlen,Ttypemajpbar Aupdatetext)1687 void switch_pbar_status(GtkProgressBar *Apbar, guint64 Amaxlen, guint64 Acurlen, Ttypemajpbar Aupdatetext) {
1688 gdouble Lpremp = (1.0/Amaxlen)*Acurlen;
1689 if (Lpremp>1) {
1690 GdkColor Lcolor;
1691 gdk_color_parse ("red", &Lcolor);
1692 Lpremp = 1;
1693 gtk_widget_modify_bg (GTK_WIDGET(Apbar), GTK_STATE_NORMAL, &Lcolor);
1694 gtk_widget_modify_bg (GTK_WIDGET(Apbar), GTK_STATE_ACTIVE, &Lcolor);
1695 gtk_widget_modify_bg (GTK_WIDGET(Apbar), GTK_STATE_PRELIGHT, &Lcolor);
1696 gtk_widget_modify_bg (GTK_WIDGET(Apbar), GTK_STATE_SELECTED, &Lcolor);
1697 } else {
1698 gtk_widget_modify_bg (GTK_WIDGET(Apbar), GTK_STATE_NORMAL, NULL);
1699 gtk_widget_modify_bg (GTK_WIDGET(Apbar), GTK_STATE_ACTIVE, NULL);
1700 gtk_widget_modify_bg (GTK_WIDGET(Apbar), GTK_STATE_PRELIGHT, NULL);
1701 gtk_widget_modify_bg (GTK_WIDGET(Apbar), GTK_STATE_SELECTED, NULL);
1702 }
1703 gtk_progress_bar_set_fraction(Apbar, Lpremp);
1704
1705 if (Aupdatetext != PB_NONE) {
1706 gchar *Ltmp = Aupdatetext == PB_UPDATE_AUDIO ? format_length(Acurlen) : format_size(Acurlen);
1707 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(Apbar), Ltmp);
1708 g_free(Ltmp);
1709 }
1710 }
1711
1712 /* effacer un cd reinscriptible */
show_erasecdrwwindow(Tgrave * Ag)1713 void show_erasecdrwwindow(Tgrave *Ag)
1714 {
1715 GtkWidget *Lwindow1 = sc_grave_get_data(Ag, "window");
1716 Tgrave *Lerasecdg = create_window_encours(Lwindow1);
1717 gint Lcont = 2;
1718 gint Lpid;
1719 gboolean Loperationstatus = FALSE;
1720 gboolean Labort = FALSE;
1721 GtkWidget *Lwin;
1722 GError *Lerror = NULL;
1723 GtkWidget *Lstatusbox = NULL;
1724
1725 Lwin = sc_grave_get_widget(Lerasecdg, "window_inprogress");
1726 gtk_label_set_text(GTK_LABEL(sc_grave_get_widget(Lerasecdg, "labelava")), _("Erasing CD-RW in progress, please wait..."));
1727
1728
1729 sc_grave_set_data(Ag, &Lcont, "cont");
1730 sc_grave_set_data(Ag, &Lpid, "pid");
1731 sc_grave_set_data(Ag, &Labort, "gabort");
1732 sc_grave_set_data(Ag, &Lerror, "gerror");
1733 sc_grave_set_data(Ag, sc_grave_get_widget(Lerasecdg, "progress"), "progress");
1734 sc_grave_set_data(Ag, &Loperationstatus, "operationstatus");
1735
1736 /* bouton annuler */
1737 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lerasecdg, "cancelbtn")), "clicked", G_CALLBACK(abort_encours), Ag);
1738 g_signal_connect(G_OBJECT(Lwin), "delete-event", G_CALLBACK(delete_event_encours), Ag);
1739
1740 gtk_widget_show(Lwin);
1741 g_timeout_add(500, encours_callback, Ag);
1742
1743 /* operation en elle meme */
1744 perform_erase_cdrw(Ag, &Lerror);
1745
1746 if (Labort) {
1747 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwin),
1748 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
1749 _("Operation aborted by user !"));
1750 } else if (Lerror) {
1751 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwin),
1752 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
1753 Lerror->message);
1754 } else {
1755 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwin),
1756 GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
1757 _("Operation successful"));
1758 }
1759 gtk_dialog_run(GTK_DIALOG(Lstatusbox));
1760 gtk_widget_destroy(Lstatusbox);
1761
1762 gtk_widget_destroy(Lwin);
1763 sc_grave_destroy(Lerasecdg);
1764
1765 if (Lerror) g_error_free(Lerror);
1766 }
1767
1768 /* cloturer un cd */
show_fixcdwindow(Tgrave * Ag)1769 void show_fixcdwindow(Tgrave *Ag)
1770 {
1771 GtkWidget *Lwindow1 = sc_grave_get_data(Ag, "window");
1772 Tgrave *Lfixcdg = create_window_encours(Lwindow1);
1773 gint Lcont = 2;
1774 gint Lpid;
1775 gboolean Loperationstatus = FALSE;
1776 gboolean Labort = FALSE;
1777 GtkWidget *Lwin;
1778 GError *Lerror = NULL;
1779 GtkWidget *Lstatusbox = NULL;
1780
1781 Lwin = sc_grave_get_widget(Lfixcdg, "window_inprogress");
1782 gtk_label_set_text(GTK_LABEL(sc_grave_get_widget(Lfixcdg, "labelava")), _("Fixating CD-R in progress, please wait..."));
1783
1784 sc_grave_set_data(Ag, &Lcont, "cont");
1785 sc_grave_set_data(Ag, &Lpid, "pid");
1786 sc_grave_set_data(Ag, &Labort, "gabort");
1787 sc_grave_set_data(Ag, &Lerror, "gerror");
1788 sc_grave_set_data(Ag, sc_grave_get_widget(Lfixcdg, "progress"), "progress");
1789 sc_grave_set_data(Ag, &Loperationstatus, "operationstatus");
1790
1791 /* bouton annuler */
1792 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lfixcdg, "cancelbtn")), "clicked", G_CALLBACK(abort_encours), Ag);
1793 g_signal_connect(G_OBJECT(Lwin), "delete-event", G_CALLBACK(delete_event_encours), Ag);
1794
1795 gtk_widget_show(Lwin);
1796 g_timeout_add(500, encours_callback, Ag);
1797
1798 /* operation en elle meme */
1799 perform_fix_cd(Ag, &Lerror);
1800
1801 if (Labort) {
1802 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwin),
1803 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
1804 _("Operation aborted by user !"));
1805 } else if (Lerror) {
1806 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwin),
1807 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
1808 Lerror->message);
1809 } else {
1810 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwin),
1811 GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
1812 _("Operation successful"));
1813 }
1814 gtk_dialog_run(GTK_DIALOG(Lstatusbox));
1815 gtk_widget_destroy(Lstatusbox);
1816
1817 gtk_widget_destroy(Lwin);
1818 sc_grave_destroy(Lfixcdg);
1819
1820 if (Lerror) g_error_free(Lerror);
1821 }
1822
1823 /* formater un dvd */
show_dvdformatwindow(Tgrave * Ag,gchar * Atitle,Ttypeformatdvd Aoperation)1824 void show_dvdformatwindow(Tgrave *Ag, gchar *Atitle, Ttypeformatdvd Aoperation)
1825 {
1826 GtkWidget *Lwindow1 = sc_grave_get_widget(Ag, "window");
1827 Tgrave *Lformatdvdg = create_window_encours(Lwindow1);
1828 gint Lcont = 2;
1829 gint Lpid;
1830 gboolean Loperationstatus = FALSE;
1831 gboolean Labort = FALSE;
1832 GtkLabel *Llabel;
1833 GtkWidget *Lwin;
1834 GError *Lerror = NULL;
1835 GtkWidget *Lstatusbox = NULL;
1836
1837 Lwin = sc_grave_get_widget(Lformatdvdg, "window_inprogress");
1838 Llabel = GTK_LABEL(sc_grave_get_widget(Lformatdvdg, "labelava"));
1839 gtk_label_set_text(Llabel, Atitle);
1840
1841
1842 sc_grave_set_data(Ag, &Lcont, "cont");
1843 sc_grave_set_data(Ag, &Lpid, "pid");
1844 sc_grave_set_data(Ag, &Labort, "gabort");
1845 sc_grave_set_data(Ag, &Lerror, "gerror");
1846 sc_grave_set_data(Ag, sc_grave_get_widget(Lformatdvdg, "progress"), "progress");
1847 sc_grave_set_data(Ag, &Loperationstatus, "operationstatus");
1848
1849 /* bouton annuler */
1850 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lformatdvdg, "cancelbtn")), "clicked", G_CALLBACK(abort_encours), Ag);
1851 g_signal_connect(G_OBJECT(Lwin), "delete-event", G_CALLBACK(delete_event_encours), Ag);
1852
1853 gtk_widget_show(Lwin);
1854
1855 /* operation en elle meme */
1856 perform_format_dvd(Ag, Aoperation, &Lerror);
1857
1858 if (Labort) {
1859 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwin),
1860 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
1861 _("Operation aborted by user !"));
1862 } else if (Lerror) {
1863 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwin),
1864 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
1865 Lerror->message);
1866 } else {
1867 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwin),
1868 GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
1869 _("Operation successful"));
1870 }
1871 gtk_dialog_run(GTK_DIALOG(Lstatusbox));
1872 gtk_widget_destroy(Lstatusbox);
1873
1874 gtk_widget_destroy(Lwin);
1875
1876 sc_grave_destroy(Lformatdvdg);
1877
1878 if (Lerror) g_error_free(Lerror);
1879 }
1880
1881 /* expand or callapse GtkTreeView */
expand_list_icons(GtkTreeView * Aliste,gboolean Aetat)1882 gboolean expand_list_icons(GtkTreeView *Aliste, gboolean Aetat)
1883 {
1884 GtkTreePath *Lpath = NULL;
1885
1886 gtk_tree_view_get_cursor(Aliste, &Lpath, NULL);
1887 if (!Lpath) return FALSE;
1888
1889 if (Aetat) {
1890 gtk_tree_view_expand_row(Aliste, Lpath, TRUE);
1891 } else {
1892 gtk_tree_view_collapse_row(Aliste, Lpath);
1893 }
1894 gtk_tree_path_free(Lpath);
1895
1896 return TRUE;
1897 }
1898 /*
1899 * vim:et:ts=8:sts=2:sw=2
1900 */
1901