1 /* callbacks.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 #include "graveman.h"
26
27 /* affichage boite de dialogue au sujet de ... */
on_about(GtkMenuItem * Amenuitem,gpointer Adata)28 void on_about (GtkMenuItem *Amenuitem, gpointer Adata)
29 {
30 about_graveman();
31 }
32
33
on_closeabout(GtkWidget * Awidget,GdkEventButton * Aevent,gpointer Adata)34 gboolean on_closeabout (GtkWidget *Awidget, GdkEventButton *Aevent, gpointer Adata)
35 {
36 return FALSE;
37 }
38
39 /* callback appele pour l'ajout d'une piste audio */
_add_a_piste(gchar * Anom,GtkListStore * Aliststore,Tgrave * Ag)40 void _add_a_piste(gchar *Anom, GtkListStore *Aliststore, Tgrave *Ag)
41 {
42 guint32 *Laudiolen = (guint32 *)sc_grave_get_data(Ag, "audiolen");
43 GtkTreeIter Liter;
44 gchar *LTitle = NULL, *LAlbum = NULL, *LArtist = NULL;
45 guint32 Llennbr = 0;
46 gchar *Lfullnameutf8 = NULL, *Lnameutf8 = NULL, *Llengthutf8 = NULL;
47 gchar *Lname;
48 gboolean Lstatus = FALSE;
49
50 /* on reconnai le type fichier grace a son extension */
51
52 #ifdef ENABLE_MP3
53 if (GsupportMp3 && sc_str_has_casesuffix(Anom, MP3)) {
54 Lstatus = getMp3Info(Anom, <itle, &LAlbum, &LArtist, &Llennbr, NULL);
55 } else
56 #endif
57 #ifdef ENABLE_OGG
58 if (GsupportOgg && sc_str_has_casesuffix(Anom, OGG)) {
59 Lstatus = getOggInfo(Anom, <itle, &LAlbum, &LArtist, &Llennbr, NULL);
60 } else
61 #endif
62 #ifdef ENABLE_FLAC
63 if (GsupportFlac && sc_str_has_casesuffix(Anom, FLAC)) {
64 Lstatus = getFlacInfo(Anom, &Llennbr, NULL);
65 } else
66 #endif
67 if (sc_str_has_casesuffix(Anom, WAV)) {
68 Lstatus = getWavInfo(Anom, &Llennbr, NULL);
69 }
70 if (Lstatus == FALSE) {
71 /* erreur format inconnue ou incorecte */
72 gchar *Ltmp;
73 GtkWidget *Lerrdiag;
74
75 Lnameutf8 = _UTF8(Anom);
76 Ltmp = g_strdup_printf(_("Cannot add track '%s', this is an unknown or invalid audio file."),
77 Lnameutf8);
78 g_free(Lnameutf8);
79
80 Lerrdiag = gtk_message_dialog_new(NULL,
81 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_CANCEL, Ltmp);
82 gtk_dialog_run(GTK_DIALOG(Lerrdiag));
83 gtk_widget_destroy(Lerrdiag);
84
85 g_free(Ltmp);
86
87 return;
88 }
89
90 if ((!LTitle && !LAlbum && !LArtist) ||
91 (LTitle && LAlbum && LArtist && !*LTitle && !*LAlbum && !*LArtist)) {
92 gchar *slash = strrchr(Anom, '/');
93 Lname = g_strdup(slash ? ++slash : Anom);
94 Lnameutf8 = _UTF8(Lname);
95 } else {
96 Lname = NULL;
97 Lnameutf8 = g_strdup_printf("%s - %s - %s", LArtist, LAlbum, LTitle);
98 }
99 *(Laudiolen)=*(Laudiolen) + Llennbr;
100 gtk_list_store_append(Aliststore, &Liter);
101 Llengthutf8 = format_length(Llennbr);
102 Lfullnameutf8 = _UTF8(Anom);
103
104 gtk_list_store_set(Aliststore, &Liter, 0, TYPE_MP3, 1, get_image("AudioIcon"), 2, Lnameutf8, 3,
105 Llengthutf8, 4, Lfullnameutf8, 5, Anom, 6, Llennbr, -1);
106 g_free(Lfullnameutf8); g_free(Llengthutf8); g_free(Lnameutf8); g_free(Lname);
107
108 g_free(LArtist);
109 g_free(LAlbum); g_free(LTitle);
110 }
111
112 /* callback appele pour l'ajout de chaques fichiers */
_add_a_file(gchar * Anom,GtkTreeStore * ATreeStore,GtkTreeIter * Aparent,Tgrave * Ag,guint64 * Adatasize,GtkTreeIter * Aiter)113 gint _add_a_file(gchar *Anom, GtkTreeStore *ATreeStore, GtkTreeIter *Aparent, Tgrave *Ag, guint64 *Adatasize, GtkTreeIter *Aiter)
114 {
115 GtkTreeIter Liter;
116 gchar *LOnlyName;
117 struct stat Lfi;
118 GDir *Lgdir;
119 const gchar *Ldirname;
120 gchar *Lfullname;
121 gchar *Lonlynameutf8, *Lnomutf8;
122 gchar *Lformatsizeutf8;
123 gboolean Lret;
124
125 if ((LOnlyName=strrchr(Anom, '/'))) {
126 LOnlyName++;
127 } else {
128 LOnlyName = Anom;
129 }
130
131 if (stat(Anom, &Lfi) == -1) {
132 _WARN("erreur lecture fichier '%s' err [%d]", Anom, errno);
133 return errno;
134 }
135
136 gtk_tree_store_append(ATreeStore, &Liter, Aparent);
137
138 if (S_ISDIR(Lfi.st_mode)) {
139 /* si c'est un repertoire alors on lis tout son contenu et on ajoute
140 * les fichiers qu'il contient */
141
142 Lonlynameutf8 = _UTF8(LOnlyName);
143 Lnomutf8 = _UTF8(Anom);
144 gtk_tree_store_set(ATreeStore, &Liter, 0, TYPE_DIR, 1, get_image("DirIcon"), 2, Lonlynameutf8, 3, "", 4, Lnomutf8, 5, LOnlyName, 6, 0, -1);
145 g_free(Lnomutf8);
146 g_free(Lonlynameutf8);
147
148 Lgdir = g_dir_open(Anom, 0, NULL);
149 if (!Lgdir) {
150 _WARN("erreur ouverture repertoire '%s'", Anom);
151 return errno;
152 }
153
154 while ((Ldirname = g_dir_read_name(Lgdir))) {
155 if (!strcmp(Ldirname, ".") || !strcmp(Ldirname, "..")) continue;
156
157 Lfullname = g_strdup_printf("%s/%s", Anom, Ldirname);
158 Lret = _add_a_file(Lfullname, ATreeStore, &Liter, Ag, Adatasize, NULL);
159 g_free(Lfullname);
160
161 if (Lret == ELOOP || Lret == EMLINK) break;
162 }
163
164 g_dir_close(Lgdir);
165
166 } else {
167 Lonlynameutf8 = _UTF8(LOnlyName);
168 Lnomutf8 = _UTF8(Anom);
169 Lformatsizeutf8 = format_size(Lfi.st_size);
170 gtk_tree_store_set(ATreeStore, &Liter, 0, TYPE_FILE, 1, get_image("FileIcon"), 2, Lonlynameutf8,
171 3, Lformatsizeutf8, 4, Lnomutf8, 5, Anom, 6, Lfi.st_size, -1);
172 g_free(Lformatsizeutf8);
173 g_free(Lnomutf8);
174 g_free(Lonlynameutf8);
175
176 *(Adatasize)=*(Adatasize) + Lfi.st_size;
177 }
178
179 if (Aiter) *Aiter = Liter;
180
181 return Lret;
182 }
183
184 /* creer un repertoire */
gtk_data_creerrepertoire(GtkWidget * btn,gpointer Adata)185 void gtk_data_creerrepertoire(GtkWidget *btn, gpointer Adata)
186 {
187 Tgrave *Lg = (Tgrave *)Adata;
188 GtkTreeView *Lliste = GTK_TREE_VIEW(sc_grave_get_data(Lg, "_current_list"));
189 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(Lliste);
190 GtkTreeIter Liter, Lparent;
191 GtkWidget *Lboite, *Lentry;
192 GtkTreePath *Lpath = NULL;
193 const gchar *Lname;
194
195 /* on recupere l'element selectionne */
196 gtk_tree_view_get_cursor(Lliste, &Lpath, NULL);
197 if (!Lpath) return;
198 gtk_tree_model_get_iter(Ltreemodel, &Lparent, Lpath);
199 gtk_tree_path_free(Lpath);
200
201 Lboite= gtk_dialog_new_with_buttons(_("Enter the new directory name"), NULL, GTK_DIALOG_MODAL,
202 GTK_STOCK_OK,GTK_RESPONSE_OK, GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL, NULL);
203
204 Lentry = gtk_entry_new();
205
206 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Lboite)->vbox), Lentry, TRUE, FALSE, 0);
207 gtk_widget_show_all(GTK_DIALOG(Lboite)->vbox);
208
209 if (gtk_dialog_run(GTK_DIALOG(Lboite)) == GTK_RESPONSE_OK) {
210 /* creation d'un repertoire */
211 Lname = gtk_entry_get_text(GTK_ENTRY(Lentry));
212 if (!Lname || !*Lname) return;
213
214 gtk_tree_store_prepend(GTK_TREE_STORE(Ltreemodel), &Liter, &Lparent);
215 gtk_tree_store_set(GTK_TREE_STORE(Ltreemodel), &Liter, 0, TYPE_DIR, 1, get_image("DirIcon"), 2, Lname, 3, "", 4, "", 5, 0, -1);
216
217 /* on developpe pour qu'il soit visible */
218 if ((Lpath = gtk_tree_model_get_path(Ltreemodel, &Liter))) {
219 gtk_tree_view_expand_to_path(Lliste, Lpath);
220 gtk_tree_path_free(Lpath);
221 }
222 }
223 gtk_widget_destroy(Lboite);
224 }
225
226 /* developper tout le contenu de l'arbre */
gtk_data_expandelement(GtkWidget * Abtn,gpointer Adata)227 void gtk_data_expandelement(GtkWidget *Abtn, gpointer Adata)
228 {
229 Tgrave *Lg = (Tgrave *)Adata;
230 GtkTreeView *Llist = GTK_TREE_VIEW(sc_grave_get_data(Lg, "_current_list"));
231
232 if (!GTK_IS_TREE_VIEW(Llist)) return;
233
234 expand_list_icons(Llist, TRUE);
235 }
236
callback_simpledialog_eventkeyrelease(GtkWidget * Aentry,GdkEventKey * Aevent,gpointer Adata)237 gboolean callback_simpledialog_eventkeyrelease(GtkWidget *Aentry, GdkEventKey *Aevent, gpointer Adata)
238 {
239 GtkDialog *Ldialog = GTK_DIALOG(Adata);
240
241 if (!Aevent) return FALSE;
242 if (Aevent->keyval == GDK_Return) {
243 gtk_dialog_response(Ldialog, GTK_RESPONSE_OK);
244 return TRUE;
245 }
246
247 return FALSE;
248 }
249
250 /* renommer un element (fichier ou repertoire) */
callbacks_data_renameitem(GtkWidget * Abtn,gpointer Adata)251 void callbacks_data_renameitem(GtkWidget *Abtn, gpointer Adata)
252 {
253 Tgrave *Lg = (Tgrave *)Adata;
254 GtkTreeView *Lliste = GTK_TREE_VIEW(sc_grave_get_data(Lg, "_current_list"));
255 GtkWidget *Lboite, *Lentry;
256 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(Lliste);
257 GtkTreePath *Lpath = NULL;
258 gchar *Ltitle;
259 gchar *Lname;
260 const gchar *Lselname;
261 GtkTreeIter Liter;
262
263 /* on recupere le nom de l'element selectionne */
264 gtk_tree_view_get_cursor(Lliste, &Lpath, NULL);
265 if (!Lpath) return;
266 gtk_tree_model_get_iter(Ltreemodel, &Liter, Lpath);
267 gtk_tree_path_free(Lpath);
268
269 gtk_tree_model_get(Ltreemodel, &Liter, 2, &Lname, -1);
270
271 Ltitle = g_strdup_printf(Ltitle, _("Enter the new name for %s"), Lname);
272
273 Lboite = gtk_dialog_new_with_buttons(Ltitle, NULL, GTK_DIALOG_MODAL,
274 GTK_STOCK_OK,GTK_RESPONSE_OK, GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL, NULL);
275 g_free(Ltitle);
276 gtk_dialog_set_default_response(GTK_DIALOG(Lboite), GTK_RESPONSE_OK);
277
278 Lentry = gtk_entry_new();
279 gtk_entry_set_text(GTK_ENTRY(Lentry), Lname);
280 g_free(Lname);
281 g_signal_connect(G_OBJECT(Lentry), "key-release-event", G_CALLBACK(callback_simpledialog_eventkeyrelease), Lboite);
282
283 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Lboite)->vbox), Lentry, TRUE, FALSE, 0);
284 gtk_widget_show_all(GTK_DIALOG(Lboite)->vbox);
285
286 if (gtk_dialog_run(GTK_DIALOG(Lboite)) == GTK_RESPONSE_OK) {
287 Lselname = gtk_entry_get_text(GTK_ENTRY(Lentry));
288 if (Lselname && *Lselname) {
289
290 /* on definie le nouveau nom dans la liste */
291 gtk_tree_store_set(GTK_TREE_STORE(Ltreemodel), &Liter, 2, Lselname, -1);
292 }
293 }
294
295 gtk_widget_destroy(Lboite);
296 }
297
298 /* retourne l'element selectionne ou bien le premier si aucun n'est
299 * selectionne */
get_parent_iter(GtkTreeView * Aliste,GtkTreeIter * Aiter,gint * Anb,gboolean * Aisroot)300 void get_parent_iter(GtkTreeView *Aliste, GtkTreeIter *Aiter, gint *Anb, gboolean *Aisroot)
301 {
302 GtkTreeModel *LTreeData = gtk_tree_view_get_model(GTK_TREE_VIEW(Aliste));
303 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(Aliste));
304 GList *Lfiles = NULL;
305
306 *(Aisroot) = 0;
307 *(Anb) = 0;
308 gtk_tree_model_get_iter_from_string(LTreeData, Aiter, "0");
309
310 if (Lselection) {
311 if (!gtk_tree_selection_iter_is_selected(Lselection, Aiter)) {
312 *(Anb) = gtk_tree_selection_count_selected_rows(Lselection);
313 Lfiles = gtk_tree_selection_get_selected_rows(Lselection, <reeData);
314 } else {
315 *(Aisroot)=1;
316 }
317 }
318
319 if (Lfiles) {
320 gtk_tree_model_get_iter(LTreeData, Aiter, (GtkTreePath*)(Lfiles->data));
321 g_list_free(Lfiles);
322 }
323 }
324
325 /* enlever des pistes a graver */
gtk_audio_removetrack(GtkWidget * Abtn,gpointer Adata)326 void gtk_audio_removetrack(GtkWidget *Abtn, gpointer Adata)
327 {
328 Tgrave *Lg = (Tgrave *)Adata;
329 GtkTreeView *Lliste = GTK_TREE_VIEW(sc_grave_get_widget(Lg, "LISTEAUDIO"));
330 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(Lliste));
331 GtkProgressBar *Lcontenance = GTK_PROGRESS_BAR(sc_grave_get_widget(Lg, "audiolenbar"));
332 guint32 *Laudiolen = (guint32 *)sc_grave_get_data(Lg, "audiolen");
333 guint32 *Laudiomaxlen = (guint32 *)sc_grave_get_data(Lg, "audiomaxlen");
334 GtkTreeIter Liter;
335 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(Lliste);
336 guint32 Llennbr = 0;
337 GList *Ltracks = gtk_tree_selection_get_selected_rows(Lselection, &Ltreemodel);
338 GList *Lrefs = NULL, *Lnode = NULL;
339 gpointer Lproxy = g_object_newv(G_TYPE_OBJECT, 0, NULL);
340
341 for (Lnode = Ltracks; Lnode; Lnode = Lnode->next) {
342 Lrefs = g_list_append(Lrefs, gtk_tree_row_reference_new_proxy(Lproxy, Ltreemodel, Lnode->data));
343 gtk_tree_path_free(Lnode->data);
344 }
345 g_list_free(Ltracks);
346
347 for (Lnode = Lrefs; Lnode; Lnode = Lnode->next) {
348 GtkTreePath *Lpath = gtk_tree_row_reference_get_path(Lnode->data);
349 gtk_tree_model_get_iter(Ltreemodel, &Liter, Lpath);
350
351 gtk_tree_model_get(Ltreemodel, &Liter, 6, &Llennbr, -1);
352 gtk_list_store_remove(GTK_LIST_STORE(Ltreemodel), &Liter);
353
354 *Laudiolen-=Llennbr;
355 g_assert((*Laudiolen) >= 0);
356
357 gtk_tree_row_reference_deleted(Lproxy, Lpath);
358 gtk_tree_path_free(Lpath);
359 gtk_tree_row_reference_free(Lnode->data);
360 }
361
362 g_list_free(Lrefs);
363 g_object_unref(Lproxy);
364
365 switch_pbar_status(Lcontenance, *Laudiomaxlen, *Laudiolen, PB_UPDATE_AUDIO);
366 }
367
368 /* parcourir tous les fils d'un element et recuperer leur taille que l'on enleve de "cursize" */
369 void remove_children_size(GtkTreeModel *Atreedata, GtkTreeIter *Aiter, guint64 *Acursize, Tgrave *Ag);
remove_children_size(GtkTreeModel * Atreedata,GtkTreeIter * Aiter,guint64 * Acursize,Tgrave * Ag)370 void remove_children_size(GtkTreeModel *Atreedata, GtkTreeIter *Aiter, guint64 *Acursize, Tgrave *Ag)
371 {
372 GtkTreeIter Lcuriter;
373 guint64 Lsizenbr = 0;
374 int Ltype;
375
376 if (gtk_tree_model_iter_children(Atreedata, &Lcuriter, Aiter)) {
377 do {
378 gtk_tree_model_get(Atreedata, &Lcuriter, 0, &Ltype, 6, &Lsizenbr, -1);
379 *Acursize-=Lsizenbr;
380 #if 0
381 if (Ltype == TYPE_IMAGEBOOT) {
382 g_hash_table_replace(Lg, "file_imageboot", gtk_tree_iter_copy(&Lnewiter));
383 }
384 #endif
385
386 remove_children_size(Atreedata, &Lcuriter, Acursize, Ag);
387 } while (gtk_tree_model_iter_next(Atreedata, &Lcuriter));
388 }
389 }
390
391 /* clique sur le popup pour la mise a jour de la taille des icones utilisees */
gtk_display_updatesize(GtkWidget * Abtn,gpointer Adata)392 void gtk_display_updatesize(GtkWidget *Abtn, gpointer Adata)
393 {
394 const gchar *Lname = glade_get_widget_name(Abtn);
395 Tgrave *Lg = (Tgrave *) Adata;
396 gchar *Lsize = strrchr(Lname, '_');
397
398 g_assert(Lsize);
399
400 conf_store_value("iconsize", ++Lsize);
401
402 manage_interface(Lg, MENU_UPDATE);
403 }
404
405 /* clique sur le popup pour l'affichage ou non de la status bar */
gtk_display_switchstatusbar(GtkWidget * Abtn,gpointer Adata)406 void gtk_display_switchstatusbar(GtkWidget *Abtn, gpointer Adata)
407 {
408 Tgrave *Lg = (Tgrave *) Adata;
409 gboolean Ldispsb = conf_get_boolean("statusbar");
410
411 conf_store_value("statusbar", Ldispsb ? "0" : "1");
412
413 update_status_bar_display(Lg);
414 }
415
416 /* enlever des fichiers a graver */
gtk_data_removefiles(GtkWidget * Abtn,gpointer Adata)417 void gtk_data_removefiles(GtkWidget *Abtn, gpointer Adata)
418 {
419 GtkTreeModel *Ltreedata;
420 GtkTreeSelection *Lselection;
421 GList *Lfiles;
422 GList *Lrefs;
423 GList *Lnode;
424 gint Ltype;
425 guint32 Lsizenbr = 0;
426 GtkTreeIter Liter;
427 gpointer Lproxy;
428 Tgrave *Lg = (Tgrave *)Adata;
429 GtkTreeView *Lliste = GTK_TREE_VIEW(sc_grave_get_data(Lg, "_current_list"));
430 GtkProgressBar *Lcontenance;
431 guint64 *Ldatasize;
432 guint64 *Ldatamaxsize;
433
434 _REMPLISSAGE_VALUE(Lg, Lliste, Ldatasize, Ldatamaxsize, Lcontenance);
435
436 /* image de boot */
437 #if 0
438 GtkTreeIter *Literboot = sc_grave_get_data(Lg, "file_imageboot");
439 #endif
440 Ltreedata = gtk_tree_view_get_model(GTK_TREE_VIEW(Lliste));
441 Lselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(Lliste));
442 Lfiles = gtk_tree_selection_get_selected_rows(Lselection, &Ltreedata);
443 Lrefs = NULL;
444 Lnode = NULL;
445 Lproxy = g_object_newv(G_TYPE_OBJECT, 0, NULL);
446
447 for (Lnode = Lfiles; Lnode; Lnode = Lnode->next) {
448 Lrefs = g_list_append(Lrefs, gtk_tree_row_reference_new_proxy(Lproxy, Ltreedata, Lnode->data));
449 gtk_tree_path_free(Lnode->data); /* Free unneeded tree path */
450 }
451 g_list_free(Lfiles); /* Emptied list */
452
453 for (Lnode = Lrefs; Lnode; Lnode = Lnode->next) {
454 GtkTreePath *Lpath = gtk_tree_row_reference_get_path(Lnode->data);
455
456 if (Lpath) {
457 gtk_tree_model_get_iter(Ltreedata, &Liter, Lpath);
458
459 gtk_tree_model_get(Ltreedata, &Liter, 0, &Ltype, 6, &Lsizenbr, -1);
460
461 /* on enleve pas l'element racine */
462 if (Ltype != TYPE_CD) {
463 *Ldatasize-=Lsizenbr;
464 g_assert((*Ldatasize) >= 0);
465
466 /* on enleve la taille des eventuels enfants */
467 remove_children_size(Ltreedata, &Liter, Ldatasize, Lg);
468
469 gtk_tree_store_remove(GTK_TREE_STORE(Ltreedata), &Liter);
470 gtk_tree_row_reference_deleted(Lproxy, Lpath);
471 gtk_tree_path_free(Lpath);
472 }
473 }
474 gtk_tree_row_reference_free(Lnode->data); /* No longer needed */
475 }
476 g_list_free(Lrefs);
477
478 g_object_unref(Lproxy);
479
480 switch_pbar_status(Lcontenance, *Ldatamaxsize, *Ldatasize, PB_UPDATE_DATA);
481
482 /* on selectionne l'icone CD */
483 if (gtk_tree_model_get_iter_first(Ltreedata, &Liter)) {
484 gtk_tree_selection_select_iter(Lselection, &Liter);
485 gtk_widget_grab_focus(GTK_WIDGET(Lliste));
486 }
487 }
488
489 /* ajouter des pistes a graver */
gtk_audio_addtrack(GtkWidget * Abtn,gpointer Adata)490 void gtk_audio_addtrack(GtkWidget *Abtn, gpointer Adata)
491 {
492 Tgrave *Lg = (Tgrave *)Adata;
493 GtkWidget *Lwindow1 = GTK_WIDGET(sc_grave_get_widget(Lg, "topwindow"));
494 GtkTreeView *Lliste = GTK_TREE_VIEW(sc_grave_get_widget(Lg, "LISTEAUDIO"));
495 guint32 *Laudiolen = (guint32 *)sc_grave_get_data(Lg, "audiolen");
496 guint32 *Laudiomaxlen = (guint32 *)sc_grave_get_data(Lg, "audiomaxlen");
497 GtkProgressBar *Lcontenance = GTK_PROGRESS_BAR(sc_grave_get_widget(Lg, "audiolenbar"));
498 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(Lliste);
499 GtkWidget *Lpistesel = create_addpisteselection(NULL);
500 GSList *Lfiles, *Lcur;
501
502 use_last_dir(GTK_FILE_CHOOSER(Lpistesel));
503 if (gtk_dialog_run(GTK_DIALOG(Lpistesel))==GTK_RESPONSE_ACCEPT) {
504 save_last_dir(GTK_FILE_CHOOSER(Lpistesel));
505
506 Lfiles = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(Lpistesel));
507
508 set_cursor(Lwindow1, GDK_WATCH);
509 for (Lcur = Lfiles; Lcur && Lcur->data; Lcur = Lcur->next) {
510 _add_a_piste((gchar *) Lcur->data, GTK_LIST_STORE(Ltreemodel), Lg);
511 }
512 unset_cursor(Lwindow1);
513
514 g_slist_free(Lfiles);
515 }
516
517 gtk_widget_destroy(Lpistesel);
518
519 switch_pbar_status(Lcontenance, *Laudiomaxlen, *Laudiolen, PB_UPDATE_AUDIO);
520 }
521
522 /* ajouter des repertoires a graver */
gtk_data_adddirectory(GtkWidget * Abtn,gpointer Adata)523 void gtk_data_adddirectory(GtkWidget *Abtn, gpointer Adata)
524 {
525 Tgrave *Lg = (Tgrave *)Adata;
526 GtkWidget *Lwindow1 = GTK_WIDGET(sc_grave_get_widget(Lg, "topwindow"));
527 GtkTreeView *Lliste = GTK_TREE_VIEW(sc_grave_get_data(Lg, "_current_list"));
528 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(Lliste));
529 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(GTK_TREE_VIEW(Lliste));
530 GtkWidget *Lfilesel = create_adddirselection(NULL);
531 GtkTreeIter Liter;
532 GSList *Lfiles, *Lcur;
533 GtkProgressBar *Lcontenance;
534 guint64 *Ldatasize;
535 guint64 *Ldatamaxsize;
536 gint Lnumsel = gtk_tree_selection_count_selected_rows(Lselection);
537 gint Ltype;
538 GtkTreePath *Lpath = NULL;
539
540 _REMPLISSAGE_VALUE(Lg, Lliste, Ldatasize, Ldatamaxsize, Lcontenance);
541
542 /* focus sur le premier element si pas de focus */
543 if (!Lnumsel) {
544 if (!gtk_tree_model_get_iter_first(Ltreemodel, &Liter)) return;
545
546 gtk_tree_selection_select_iter(Lselection, &Liter);
547 gtk_widget_grab_focus(GTK_WIDGET(Lliste));
548 } else {
549 /* si plusieurs elements de selectionne alors on pointe sur celui etant
550 * sous le curseur */
551 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Lliste), &Lpath, NULL);
552 if (!Lpath) return;
553 gtk_tree_model_get_iter(Ltreemodel, &Liter, Lpath);
554 gtk_tree_model_get(Ltreemodel, &Liter, 0, &Ltype, -1);
555 if (Ltype == TYPE_FILE) {
556 gtk_tree_path_up(Lpath);
557 gtk_tree_model_get_iter(Ltreemodel, &Liter, Lpath);
558 }
559 gtk_tree_path_free(Lpath);
560 }
561
562 use_last_dir(GTK_FILE_CHOOSER(Lfilesel));
563 if (gtk_dialog_run(GTK_DIALOG(Lfilesel))==GTK_RESPONSE_ACCEPT) {
564 set_cursor(Lwindow1, GDK_WATCH);
565 save_last_dir(GTK_FILE_CHOOSER(Lfilesel));
566
567 Lfiles = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(Lfilesel));
568
569 for (Lcur = Lfiles; Lcur && Lcur->data; Lcur = Lcur->next) {
570 _add_a_file((gchar *) Lcur->data, (GtkTreeStore *)Ltreemodel, &Liter, Lg, Ldatasize, NULL);
571
572 }
573 g_slist_free(Lfiles);
574
575 if ((Lpath = gtk_tree_model_get_path(Ltreemodel, &Liter))) {
576 gtk_tree_view_expand_row(Lliste, Lpath, TRUE);
577 gtk_tree_path_free(Lpath);
578 }
579 unset_cursor(Lwindow1);
580 }
581 gtk_widget_destroy(Lfilesel);
582
583 switch_pbar_status(Lcontenance, *Ldatamaxsize, *Ldatasize, PB_UPDATE_DATA);
584 }
585
586
587 /* ajouter des fichiers a graver */
gtk_data_addfile(GtkWidget * Abtn,gpointer Adata)588 void gtk_data_addfile(GtkWidget *Abtn, gpointer Adata)
589 {
590 Tgrave *Lg = (Tgrave *)Adata;
591 GtkTreeView *Lliste = GTK_TREE_VIEW(sc_grave_get_data(Lg, "_current_list"));
592 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(Lliste));
593 guint64 *Ldatasize;
594 guint64 *Ldatamaxsize;
595 GtkProgressBar *Lcontenance;
596 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(GTK_TREE_VIEW(Lliste));
597 GtkWidget *Lfilesel = create_addfileselection(NULL);
598 GtkTreeIter Liter;
599 GSList *Lfiles, *Lcur;
600 gint Ltype;
601 gint Lnumsel = gtk_tree_selection_count_selected_rows(Lselection);
602 GtkTreePath *Lpath = NULL;
603
604 _REMPLISSAGE_VALUE(Lg, Lliste, Ldatasize, Ldatamaxsize, Lcontenance);
605
606 /* focus sur le premier element si pas de focus */
607 if (!Lnumsel) {
608 if (!gtk_tree_model_get_iter_first(Ltreemodel, &Liter)) return;
609
610 gtk_tree_selection_select_iter(Lselection, &Liter);
611 gtk_widget_grab_focus(GTK_WIDGET(Lliste));
612 } else {
613 /* si plusieurs elements de selectionne alors on pointe sur celui etant
614 * sous le curseur */
615 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Lliste), &Lpath, NULL);
616 if (!Lpath) return;
617 gtk_tree_model_get_iter(Ltreemodel, &Liter, Lpath);
618 gtk_tree_model_get(Ltreemodel, &Liter, 0, &Ltype, -1);
619 if (Ltype == TYPE_FILE) {
620 gtk_tree_path_up(Lpath);
621 gtk_tree_model_get_iter(Ltreemodel, &Liter, Lpath);
622 }
623 gtk_tree_path_free(Lpath);
624 }
625
626 use_last_dir(GTK_FILE_CHOOSER(Lfilesel));
627 if (gtk_dialog_run(GTK_DIALOG(Lfilesel))==GTK_RESPONSE_ACCEPT) {
628 save_last_dir(GTK_FILE_CHOOSER(Lfilesel));
629
630 Lfiles = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(Lfilesel));
631 for (Lcur = Lfiles; Lcur && Lcur->data; Lcur = Lcur->next) {
632 _add_a_file((gchar *) Lcur->data, GTK_TREE_STORE(Ltreemodel), &Liter, Lg, Ldatasize, NULL);
633
634 }
635 g_slist_free(Lfiles);
636
637 if ((Lpath = gtk_tree_model_get_path(Ltreemodel, &Liter))) {
638 gtk_tree_view_expand_row(Lliste, Lpath, TRUE);
639 gtk_tree_path_free(Lpath);
640 }
641 }
642 gtk_widget_destroy(Lfilesel);
643
644 switch_pbar_status(Lcontenance, *Ldatamaxsize, *Ldatasize, PB_UPDATE_DATA);
645 }
646
647 /* l'utilisateur veut editer un device */
gtk_devices_edit(GtkWidget * Abtn,gpointer Adata)648 void gtk_devices_edit(GtkWidget *Abtn, gpointer Adata)
649 {
650 Tgrave *Lg = (Tgrave *) Adata;
651 GtkWidget *Lparent = GTK_WIDGET(sc_grave_get_data(Lg, "window"));
652 GtkTreeView *Lliste = GTK_TREE_VIEW(sc_grave_get_widget(Lg, "periphdata"));
653 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(Lliste));
654 GtkTreeIter Liter;
655 GtkTreeModel *Ltreemodel;
656
657 if (gtk_tree_selection_get_selected(Lselection, &Ltreemodel, &Liter)) {
658 Tgrave *Ldialoghash;
659 GtkWidget *Lwineditdevice;
660 Tdriveinfo *Ldrive;
661 gint Lnum;
662 gint Lbus;
663
664 gtk_tree_model_get(Ltreemodel, &Liter, 0, &Lnum, -1);
665 Ldrive = (Tdriveinfo *)g_slist_nth_data(Glistdrives, Lnum);
666 Ldialoghash = create_dialog_edit_device(Lparent, Ldrive);
667 Lwineditdevice = sc_grave_get_data(Ldialoghash, "window");
668
669 if (gtk_dialog_run(GTK_DIALOG(Lwineditdevice)) != GTK_RESPONSE_CANCEL) {
670 GtkEntry *Ldevicename = GTK_ENTRY(sc_grave_get_widget(Ldialoghash, "devicename"));
671
672 Lbus = get_combo_intvalue(sc_grave_get_widget(Ldialoghash, "devicebus"));
673 Ldrive->actuperiph = Lbus;
674
675 /* on remplace le nom dans la liste des lecteurs */
676 g_free(Ldrive->name);
677 Ldrive->name = g_strdup(gtk_entry_get_text(Ldevicename));
678 /* ainsi que dans la liste affich�e */
679 gtk_list_store_set(GTK_LIST_STORE(Ltreemodel), &Liter, 2, (gchar *)g_slist_nth_data(Ldrive->dev, Ldrive->actuperiph),
680 4, Ldrive->name, -1);
681 }
682 gtk_widget_destroy(Lwineditdevice);
683 sc_grave_destroy(Ldialoghash);
684 }
685
686 }
687
688 /* l'utilisateur a cliquer sur supprimer un device */
gtk_devices_remove(GtkWidget * Abtn,gpointer Adata)689 void gtk_devices_remove(GtkWidget *Abtn, gpointer Adata)
690 {
691 Tgrave *Lg = (Tgrave *)Adata;
692 GtkWidget *Lwindow1 = GTK_WIDGET(sc_grave_get_widget(Lg, "topwindow"));
693 GtkWidget *Lconfirm;
694 gint Lrep;
695
696 /* confirmation debut de l'operation */
697 Lconfirm = gtk_message_dialog_new(GTK_WINDOW(Lwindow1),
698 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
699 GTK_BUTTONS_YES_NO,
700 _("Do you really want to remove this device ?"));
701 Lrep = gtk_dialog_run(GTK_DIALOG(Lconfirm));
702 gtk_widget_destroy(Lconfirm);
703
704 if (Lrep == GTK_RESPONSE_YES) {
705 /* oui on supprime un device */
706 GtkTreeView *Lliste = GTK_TREE_VIEW(sc_grave_get_widget(Lg, "periphdata"));
707 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(Lliste));
708 GtkTreeIter Liter;
709 GtkTreeModel *Ltreemodel;
710 gint Lnum;
711
712 if (gtk_tree_selection_get_selected(Lselection, &Ltreemodel, &Liter)) {
713 gtk_tree_model_get(Ltreemodel, &Liter, 0, &Lnum, -1);
714
715 _DEB("ON SUPRIMME LE LEC = %d\n", Lnum);
716 Glistdrives = g_slist_remove(Glistdrives, g_slist_nth_data(Glistdrives, Lnum));
717 gtk_list_store_remove(GTK_LIST_STORE(Ltreemodel), &Liter);
718 }
719 }
720
721 }
722
723 /* ajouter manuelement un device */
gtk_devices_add(GtkWidget * Abtn,gpointer Adata)724 void gtk_devices_add(GtkWidget *Abtn, gpointer Adata)
725 {
726 Tgrave *Lg = (Tgrave *) Adata;
727 GtkWidget *Lparent = GTK_WIDGET(sc_grave_get_data(Lg, "window"));
728 GtkTreeView *Lliste = GTK_TREE_VIEW(sc_grave_get_widget(Lg, "periphdata"));
729 Tgrave *Ldialoghash = create_dialog_add_device(Lparent);
730 GtkWidget *Lwinadddevice = sc_grave_get_data(Ldialoghash, "window");
731 GtkWidget *Lmessage;
732
733 while (1) {
734 if (gtk_dialog_run(GTK_DIALOG(Lwinadddevice)) != GTK_RESPONSE_CANCEL) {
735 GtkEntry *Ldevicebus = GTK_ENTRY(sc_grave_get_widget(Ldialoghash, "devicebus"));
736 GtkEntry *Ldevicename = GTK_ENTRY(sc_grave_get_widget(Ldialoghash, "devicename"));
737 gchar *Lbus = (gchar *)gtk_entry_get_text(Ldevicebus);
738 Tdriveinfo *Ldrive = g_malloc0(sizeof(Tdriveinfo));
739
740 proc_init_cdrominfo(NULL);
741 matos_maj_drive_info(Ldrive, Lbus, NULL);
742 proc_free_cdrominfo();
743
744 if (Ldrive->type == 0) {
745 Lmessage = gtk_message_dialog_new(GTK_WINDOW(Lparent),
746 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
747 _("Cannot add this drive !"));
748 } else {
749 Lmessage = gtk_message_dialog_new(GTK_WINDOW(Lparent),
750 GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
751 _("Drive succesfully added !"));
752 }
753
754 gtk_dialog_run(GTK_DIALOG(Lmessage));
755 gtk_widget_destroy(Lmessage);
756
757 if (Ldrive->type > 0) {
758 /* on complate la structure drive avant de l'ajouter */
759 Ldrive->manual = TRUE;
760 Ldrive->actuperiph = 0;
761 Ldrive->name = g_strdup(gtk_entry_get_text(Ldevicename));
762 Ldrive->dev = g_slist_append(Ldrive->dev, g_strdup(Lbus));
763 Ldrive->bus = g_slist_append(Ldrive->bus, g_strdup("MANU"));
764
765 Glistdrives = g_slist_append(Glistdrives, Ldrive);
766
767 /* mise a jour de la liste des peripheriques */
768 remplirelistegraveur(Lliste);
769 break;
770 }
771 g_free(Ldrive);
772 } else {
773 break;
774 }
775 }
776 gtk_widget_destroy(Lwinadddevice);
777 sc_grave_destroy(Ldialoghash);
778 }
779
780
781 /* selection d'une image iso */
gtk_file_sel(GtkWidget * Abtn,gpointer Adata)782 void gtk_file_sel(GtkWidget *Abtn, gpointer Adata)
783 {
784 Tgrave *Lg = (Tgrave *)Adata;
785 const gchar *Lname = glade_get_widget_name(Abtn);
786 GtkWidget *Ltextdest = (GtkWidget *) sc_grave_get_widgetv(Lg, "%svalue", Lname);
787 gint Lresp;
788 GtkWidget *Lfilesel;
789 GtkFileChooserAction Ldialogtype = !strncmp(Lname, "src", 3) ?
790 GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE;
791 _DEB("=>%s\n", Lname);
792 if (!strncmp(Lname, "dir", 3)) {
793 Ldialogtype = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
794 }
795 Lfilesel = create_isoselection(NULL, Ldialogtype);
796 use_last_dir(GTK_FILE_CHOOSER(Lfilesel));
797 Lresp=gtk_dialog_run(GTK_DIALOG(Lfilesel));
798 gtk_widget_hide (Lfilesel);
799 while (gtk_events_pending())
800 gtk_main_iteration();
801
802 if (Lresp == GTK_RESPONSE_ACCEPT) {
803 gchar *Lfilenamebrut = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER ( Lfilesel));
804 gchar *Lfilename = _FILENAME(Lfilenamebrut);
805 save_last_dir(GTK_FILE_CHOOSER(Lfilesel));
806 gtk_entry_set_text(GTK_ENTRY(Ltextdest), Lfilename);
807 g_free(Lfilename);
808 g_free(Lfilenamebrut);
809 }
810
811 gtk_widget_destroy(Lfilesel);
812 }
813
814 /* lors de la selection d'un lecteur / graveur */
on_selectgraveur(GtkWidget * Acombo,gpointer Adata)815 void on_selectgraveur(GtkWidget *Acombo, gpointer Adata)
816 {
817 Tgrave *Lg = (Tgrave *)Adata;
818 GtkWidget *Lpanel;
819 GtkWidget *Lvitesse, *Lobj;
820 GtkTreeModel *Lmodel = gtk_combo_box_get_model(GTK_COMBO_BOX(Acombo));
821 GtkTreeIter Liter;
822 gboolean Lisimgiso = FALSE;
823 const gchar *Lname = glade_get_widget_name(Acombo);
824 gchar *Laskname, *Lspeedname;
825 gchar *Llecteur = NULL;
826 guint Lident = 0;
827 gint i;
828 Tdriveinfo *Ldrive;
829
830 if (g_str_has_suffix(Lname, "combo")==FALSE) return;
831
832 if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(Acombo), &Liter)) return;
833
834 gtk_tree_model_get(Lmodel, &Liter, 0, &Ldrive, 3, &Lident, -1);
835
836 Lisimgiso = !Ldrive;
837
838 Lspeedname = g_strdup(Lname);
839 _SWAP_COMBO(Lspeedname, "speed");
840 Lvitesse = (GtkWidget *)sc_grave_get_widget(Lg, Lspeedname);
841
842 Laskname = g_strdup(Lname);
843 _SWAP_COMBO(Laskname, "table");
844 Lpanel = (GtkWidget *)sc_grave_get_widget(Lg, Laskname);
845 g_free(Laskname);
846
847 /* on cache ou montre la zone de saisie du nom de l'image iso */
848 if (GTK_IS_WIDGET(Lpanel)) {
849
850 if (Lisimgiso) {
851 /* on montre le champ de selection de l'image iso */
852 gtk_widget_show(Lpanel);
853 } else {
854 /* on le cache */
855 gtk_widget_hide(Lpanel);
856 }
857 if (GTK_IS_WIDGET(Lvitesse)) {
858 /* selection de la vitesse non active lorsque l'on a selectionne une image iso .. */
859 gtk_widget_set_sensitive(Lvitesse, Lisimgiso ? FALSE : TRUE);
860 }
861 }
862 if (!Lisimgiso && GTK_IS_WIDGET(Lvitesse)) {
863 remplire_combo_vitesse(GTK_COMBO_BOX(Lvitesse), Ldrive, conf_get_string(Lspeedname));
864 }
865
866 for (i=0; ((Lobj = sc_grave_get_datav(Lg, "%s_isotodisabled%d", Lname, i)) && GTK_IS_WIDGET(Lobj)); i++) {
867 /* disable si image iso, enable sinon */
868 gtk_widget_set_sensitive (Lobj, !Lisimgiso);
869 }
870
871 for (i=0; ((Lobj = sc_grave_get_datav(Lg, "%s_notcdrwtodisabled%d", Lname, i)) && GTK_IS_WIDGET(Lobj)); i++) {
872 /* disable si lecteur non cdrw */
873 gtk_widget_set_sensitive (Lobj, DRIVE_WRITER(Ldrive));
874 }
875
876 for (i=0; ((Lobj = sc_grave_get_datav(Lg, "%s_notdvdrwtodisabled%d", Lname, i)) && GTK_IS_WIDGET(Lobj)); i++) {
877 /* disable si lecteur non dvdrw */
878 gtk_widget_set_sensitive (Lobj, DRIVE_DVDWRITER(Ldrive));
879 }
880
881 g_free(Lspeedname);
882 g_free(Llecteur);
883 }
884
885 /* confirmer l'annulation de la gravure */
abort_gravure(GtkWidget * Abtn,gpointer Adata)886 gboolean abort_gravure(GtkWidget *Abtn, gpointer Adata)
887 {
888 Tgrave *Lg = (Tgrave *) Adata;
889 gboolean *Labort = (gboolean *)sc_grave_get_data(Lg, "gabort");
890 GtkWidget *Lwindow = GTK_WIDGET(sc_grave_get_widget(Lg, "window_burn"));
891 gint Lret;
892 GtkWidget *Lconfirm;
893
894 g_assert(Labort);
895
896 Lconfirm = gtk_message_dialog_new(GTK_WINDOW(Lwindow),
897 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
898 GTK_BUTTONS_YES_NO, _("Do you really want to abort operation ?"));
899
900 Lret = gtk_dialog_run(GTK_DIALOG(Lconfirm));
901
902 if (Lret == GTK_RESPONSE_YES) {
903 gint *Lpid = (gint *)sc_grave_get_data(Lg, "pid");
904 if (*Lpid) {
905 /* on envoi un TERM au process (cdrecord...) pour qu'il s'arrete ! */
906 _DEB("kill de %d\n", *Lpid);
907 kill(*Lpid, SIGINT);
908 }
909 *Labort = TRUE;
910 }
911
912 gtk_widget_destroy(Lconfirm);
913
914 return Lret == GTK_RESPONSE_YES ? TRUE : FALSE;
915 }
916
on_deleteevent_gravure(GtkWidget * Awidget,GdkEvent * Aevent,gpointer Adata)917 gboolean on_deleteevent_gravure(GtkWidget *Awidget, GdkEvent *Aevent, gpointer Adata)
918 {
919
920 abort_gravure(NULL, Adata);
921
922 return TRUE;
923 }
924
925 /* confirmer la cloture d'un cd */
confirm_fixcd(GtkWidget * Abtn,gpointer Adata)926 void confirm_fixcd(GtkWidget *Abtn, gpointer Adata)
927 {
928 Tgrave *Lg = (Tgrave *)Adata;
929 GtkWidget *Lwindow1 = GTK_WIDGET(sc_grave_get_widget(Lg, "topwindow"));
930 GtkWidget *Lconfirm;
931 gint Lrep;
932 GSList *Llmediarequis = g_slist_append(NULL, GINT_TO_POINTER(_MEDIA_CDR + _MEDIA_NOBLANK + _MEDIA_APPENDABLE));
933 gboolean Lstatus;
934
935 Lstatus = waiting_for_user(_MEDIA_TITLE_BLANKORAPPENDABLE, Lg, Llmediarequis, NULL, matos_get_drive_info(Lg, "dstothercombo"));
936 g_slist_free(Llmediarequis);
937
938 if (Lstatus==FALSE) return;
939
940 /* confirmation debut de l'operation */
941 Lconfirm = gtk_message_dialog_new(GTK_WINDOW(Lwindow1),
942 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
943 GTK_BUTTONS_YES_NO,
944 _("Do you really want to fix the CD-R ?"));
945 Lrep = gtk_dialog_run(GTK_DIALOG(Lconfirm));
946
947 gtk_widget_destroy(Lconfirm);
948
949 if (Lrep == GTK_RESPONSE_YES) {
950 /* ok go ! */
951 show_fixcdwindow(Lg);
952 }
953 }
954
955 /* affichage du popup "formater un dvdrw" */
popup_formatdvdrw(GtkWidget * Abtn,gpointer Adata)956 void popup_formatdvdrw(GtkWidget *Abtn, gpointer Adata)
957 {
958 GtkMenu *Lpopupm = create_gtkpopupmenuformatdvd(Adata);
959 gtk_menu_popup(Lpopupm, NULL, NULL, NULL, Abtn, 0, 0);
960
961 }
962
963 /* confirmation d'une operation de formatage sur un dvd */
gtk_confirm_dvdoperation(GtkWidget * Abtn,gpointer Adata)964 void gtk_confirm_dvdoperation(GtkWidget *Abtn, gpointer Adata)
965 {
966 const gchar *Lname = glade_get_widget_name(Abtn);
967 gchar *s, *Ltitle, *Lmessage;
968 GtkWidget *Lconfirm;
969 Tgrave *Lg = (Tgrave *)Adata;
970 GtkWidget *Lwindow1 = GTK_WIDGET(sc_grave_get_widget(Lg, "topwindow"));
971 gint Lrep;
972 Ttypeformatdvd Lcode;
973
974 g_assert(Lname);
975 if (!(s = strrchr(Lname, '_')) || !*(++s)) return;
976
977 if (!strcmp(s, "format")) {
978 Ltitle = _("Formatting DVD...");
979 Lmessage = _("Do you really want to format this media ?");
980 Lcode = DVD_FORMAT;
981 } else if (!strcmp(s, "blank")) {
982 Ltitle = _("Blanking DVD...");
983 Lmessage = _("Do you really want to fast blanking this DVD-RW ?\nBe carreful you could only write in DAO mode after a fast blanking.");
984 Lcode = DVD_BLANK;
985 } else if (!strcmp(s, "blankfull")) {
986 Ltitle = _("Full blanking DVD...");
987 Lmessage = _("Do you really want to blank this DVD-RW ?\nThis could take 1 hour with an 1x media.");
988 Lcode = DVD_FULLBLANK;
989 } else {
990 return;
991 }
992
993 Lconfirm = gtk_message_dialog_new(GTK_WINDOW(Lwindow1),
994 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
995 GTK_BUTTONS_YES_NO, Lmessage);
996
997 Lrep = gtk_dialog_run(GTK_DIALOG(Lconfirm));
998 gtk_widget_destroy(Lconfirm);
999 if (Lrep == GTK_RESPONSE_YES) {
1000 show_dvdformatwindow(Lg, Ltitle, Lcode);
1001 }
1002 }
1003
1004 /* confirmer l'effacement d'un cdrw */
confirm_erasecdrw(GtkWidget * Abtn,gpointer Adata)1005 void confirm_erasecdrw(GtkWidget *Abtn, gpointer Adata)
1006 {
1007 Tgrave *Lg = (Tgrave *)Adata;
1008 GtkWidget *Lwindow1 = GTK_WIDGET(sc_grave_get_widget(Lg, "topwindow"));
1009 Tgrave *Ldialoghash;
1010 GtkWidget *Lconfirm;
1011 GSList *Llmediarequis = g_slist_append(NULL, GINT_TO_POINTER(_MEDIA_CDRW + _MEDIA_NOBLANK));
1012 gboolean Lstatus;
1013 Lstatus = waiting_for_user(_MEDIA_TITLE_BLANKORAPPENDABLE, Lg, Llmediarequis, NULL, matos_get_drive_info(Lg, "dstothercombo"));
1014 g_slist_free(Llmediarequis);
1015
1016 if (Lstatus==FALSE) return;
1017
1018 Ldialoghash = create_dialog_confirm_operation(Lwindow1, _("Do you really want to erase the CD-RW ?"),
1019 _("_Fast blank disk when erasing CD-RW"), conf_get_boolean("fastblank"));
1020 Lconfirm = sc_grave_get_data(Ldialoghash, "window");
1021
1022 /* confirmation debut de l'operation */
1023 if (gtk_dialog_run(GTK_DIALOG(Lconfirm)) == GTK_RESPONSE_YES) {
1024 gboolean Lusefastblank = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sc_grave_get_widget(Ldialoghash, "checkbox")));
1025 gtk_widget_destroy(Lconfirm);
1026
1027 sc_grave_set_data(Lg, &Lusefastblank, "usefastblank");
1028 show_erasecdrwwindow(Lg);
1029 sc_grave_del_data(Lg, "usefastblank");
1030 } else {
1031 gtk_widget_destroy(Lconfirm);
1032 }
1033 sc_grave_destroy(Ldialoghash);
1034
1035 }
1036
1037 /* confirmer la debut de la gravure */
confirm_burn(GtkWidget * Abtn,gpointer Adata)1038 void confirm_burn (GtkWidget *Abtn, gpointer Adata)
1039 {
1040 Tgrave *Lg = (Tgrave *)Adata;
1041 Tgrave *Ldialoghash;
1042 GtkWidget *Lconfirm;
1043 gint Lrep;
1044 gboolean Luseautoblank = FALSE;
1045 gchar *Ltypeburn = NULL;
1046 const gchar *Lname;
1047 gchar *Ltxt = NULL;
1048 gchar *Ltitle = NULL;
1049 GtkWidget *Lwindow1 = GTK_WIDGET(sc_grave_get_widget(Lg, "topwindow"));
1050 GSList *Llmediarequis1 = NULL;
1051 GSList *Llmediarequis2 = NULL;
1052 gint Lmediatitle1 = _MEDIA_NONE, Lmediatitle2 = _MEDIA_NONE;
1053 gint Lmediadetect1 = _MEDIA_NONE, Lmediadetect2 = _MEDIA_NONE;
1054 Tdriveinfo *Ldevicename1 = NULL, *Ldevicename2 = NULL;
1055 gboolean Lwritercdrw;
1056 gboolean Liso = FALSE;
1057 Ttypeoperation Loperation = WRITE_CD;
1058
1059 Lname = gtk_widget_get_name(Abtn);
1060
1061 if (!Lname) return;
1062 if (g_str_has_prefix(Lname, "btnburnaudio")) {
1063 GtkTreeIter Liter;
1064 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(
1065 GTK_TREE_VIEW(sc_grave_get_widget(Lg, "LISTEAUDIO")));
1066
1067 /* gravure cd audio, on verifie d'abord qu'il y ai au
1068 * moins une piste dans la liste .. */
1069 if (!gtk_tree_model_get_iter_first(Ltreemodel, &Liter)) {
1070 Lconfirm = gtk_message_dialog_new(GTK_WINDOW(Lwindow1),
1071 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING,
1072 GTK_BUTTONS_CANCEL,
1073 _("You must add at least one track to write !"));
1074 gtk_dialog_run(GTK_DIALOG(Lconfirm));
1075 gtk_widget_destroy(Lconfirm);
1076 return;
1077 }
1078 Ltxt = _("Do you really want to create an audio cd ?");
1079 Ltitle = _("Writing audio cd in progress...");
1080 Ldevicename1 = matos_get_drive_info(Lg, "dstaudiocombo");
1081 Llmediarequis1 = manage_mediarequis(NULL,
1082 _MEDIA_CDR + _MEDIA_BLANK, _MEDIA_CDR + _MEDIA_APPENDABLE,
1083 _MEDIA_CDRW + _MEDIA_BLANK, _MEDIA_CDRW + _MEDIA_APPENDABLE,
1084 _MEDIA_CDRW + _MEDIA_NOBLANK, -1);
1085 Lmediatitle1 = _MEDIA_TITLE_BLANKORAPPENDABLE;
1086 } else if (g_str_has_prefix(Lname, "btnburndata") || g_str_has_prefix(Lname, "btnburndvddata")) {
1087 GtkTreeIter Liter;
1088 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(GTK_TREE_VIEW(sc_grave_get_data(Lg, "_current_list")));
1089 /* gravure cd de donnee, on verifie qu'il y ai au
1090 * moins un fichier/repertoire dans la liste */
1091 if (g_str_has_prefix(Lname, "btnburndvddata")) {
1092 Loperation = WRITE_DVD;
1093 }
1094
1095 if (!gtk_tree_model_get_iter_first(Ltreemodel, &Liter) ||
1096 !gtk_tree_model_iter_has_child(Ltreemodel, &Liter)) {
1097
1098 Lconfirm = gtk_message_dialog_new(GTK_WINDOW(Lwindow1),
1099 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING,
1100 GTK_BUTTONS_CANCEL,
1101 _("You must add at least one file to write !"));
1102 gtk_dialog_run(GTK_DIALOG(Lconfirm));
1103 gtk_widget_destroy(Lconfirm);
1104 return;
1105 }
1106
1107 if (Loperation == WRITE_CD) {
1108 Ldevicename1 = matos_get_drive_info(Lg, "dstdatacombo");
1109 Liso = !Ldevicename1;
1110 if (Liso) {
1111 Ltxt = _("Do you really want to create an iso image ?");
1112 } else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sc_grave_get_widget(Lg, "datamulti")))) {
1113 Loperation = WRITE_CD_MULTI;
1114 Ltxt = _("Do you really want to start or continue a multi session data cd ?");
1115 } else {
1116 Ltxt = _("Do you really want to create a data cd ?");
1117 }
1118 if (!Liso) {
1119 Ltitle = _("Writing data cd in progress...");
1120 Llmediarequis1 = manage_mediarequis(NULL,
1121 _MEDIA_CDR + _MEDIA_BLANK, _MEDIA_CDR + _MEDIA_APPENDABLE,
1122 _MEDIA_CDRW + _MEDIA_BLANK, _MEDIA_CDRW + _MEDIA_APPENDABLE,
1123 _MEDIA_CDRW + _MEDIA_NOBLANK, -1);
1124 Lmediatitle1 = _MEDIA_TITLE_BLANKORAPPENDABLE;
1125 } else {
1126 Ltitle = _("Writing iso image in progress...");
1127 }
1128 } else {
1129 Ldevicename1 = matos_get_drive_info(Lg, "dstdvddatacombo");
1130 Liso = !Ldevicename1;
1131 if (!Liso) {
1132 Ltxt = _("Do you really want to create a data dvd ?");
1133 Ltitle = _("Writing data dvd in progress...");
1134
1135 Llmediarequis1 = manage_mediarequis(NULL,
1136 _MEDIA_DVDR_P + _MEDIA_BLANK, _MEDIA_DVDR_P + _MEDIA_APPENDABLE,
1137 _MEDIA_DVDR_M + _MEDIA_BLANK, _MEDIA_DVDR_M + _MEDIA_APPENDABLE,
1138 _MEDIA_DVD_RAM, _MEDIA_DVDP_RW, _MEDIA_DVDM_RW, -1);
1139 Lmediatitle1 = _MEDIA_TITLE_DVDRew;
1140 } else {
1141 /* creation image iso */
1142 Loperation = WRITE_CD;
1143 Ltxt = _("Do you really want to create an iso image ?");
1144 }
1145 }
1146 } else {
1147 /* copie de cd */
1148
1149 Ltxt = _("Do you really want to start the copy ?");
1150 Ltitle = _("Copying in progress...");
1151 Ldevicename1 = matos_get_drive_info(Lg, "srccopycombo");
1152 Liso = !Ldevicename1;
1153 if (!Liso) {
1154 Llmediarequis1 = manage_mediarequis(NULL, _MEDIA_CD + _MEDIA_NOBLANK, -1);
1155 Lmediatitle1 = _MEDIA_CD;
1156 }
1157 Ldevicename2 = matos_get_drive_info(Lg, "dstcopycombo");
1158
1159 if (Ldevicename2) {
1160 Llmediarequis2 = manage_mediarequis(NULL,
1161 _MEDIA_CDR + _MEDIA_BLANK, _MEDIA_CDR + _MEDIA_APPENDABLE,
1162 _MEDIA_CDRW + _MEDIA_BLANK, _MEDIA_CDRW + _MEDIA_APPENDABLE,
1163 _MEDIA_CDRW + _MEDIA_NOBLANK, -1);
1164
1165 Lmediatitle2 = _MEDIA_TITLE_BLANKORAPPENDABLE;
1166 }
1167 }
1168
1169 /* attente que l'utilisateur ai bien insere un cd */
1170 if (waiting_for_user(Lmediatitle1, Lg, Llmediarequis1, &Lmediadetect1, Ldevicename1)==FALSE) return;
1171 if (waiting_for_user(Lmediatitle2, Lg, Llmediarequis2, &Lmediadetect2, Ldevicename2)==FALSE) return;
1172
1173 /* confirmation debut de l'operation */
1174 if (Loperation != WRITE_DVD) {
1175 /* on affiche l'option "effacer le CDRW que lorsque c'est un graveur qui le permet */
1176 Lwritercdrw = Ldevicename1 && DRIVE_CDRW_WRITER(Ldevicename1) ? TRUE : FALSE;
1177 Ldialoghash = create_dialog_confirm_operation(Lwindow1, Ltxt,
1178 Lwritercdrw == TRUE &&
1179 ((Lmediadetect1 & _MEDIA_CDRW) && (Lmediadetect1 & _MEDIA_NOBLANK)) ?
1180 _("Blank CD-RW before writing") : NULL, conf_get_boolean("autoblank"));
1181 } else {
1182 /* confirmation gravure dvd */
1183 Ldialoghash = create_dialog_select_dvdoperation(Lwindow1, Lmediadetect1);
1184 }
1185 Lconfirm = sc_grave_get_data(Ldialoghash, "window");
1186
1187 Lrep = gtk_dialog_run(GTK_DIALOG(Lconfirm));
1188
1189 if (Lrep == GTK_RESPONSE_YES) {
1190 /* ok go ! */
1191 if (Loperation != WRITE_DVD) {
1192 GtkCheckButton *Labcheck = GTK_CHECK_BUTTON(sc_grave_get_widget(Ldialoghash, "checkbox"));
1193
1194 g_assert(GTK_IS_WIDGET(Labcheck));
1195 if (Lwritercdrw == TRUE) {
1196 Luseautoblank = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Labcheck));
1197 }
1198 sc_grave_set_data(Lg, &Luseautoblank, "useautoblank");
1199 } else {
1200 GtkRadioButton *Labradio = GTK_RADIO_BUTTON(sc_grave_get_widget(Ldialoghash, "burninitial"));
1201 Ltypeburn = g_strdup(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Labradio)) ? "-Z" : "-M");
1202 sc_grave_set_data(Lg, Ltypeburn, "typeburn");
1203 }
1204
1205 gtk_widget_destroy(Lconfirm);
1206
1207 sc_grave_set_data(Lg, Llmediarequis1, "mediarequis1");
1208 sc_grave_set_data(Lg, &Lmediatitle1, "mediatitle1");
1209 sc_grave_set_data(Lg, Llmediarequis2, "mediarequis2");
1210 sc_grave_set_data(Lg, &Lmediatitle2, "mediatitle2");
1211 sc_grave_set_data(Lg, Ltxt, "medialabel");
1212 show_graverwindow(Lg, (gchar *)Lname, Ltitle);
1213 sc_grave_del_data(Lg, "medialabel");
1214 sc_grave_del_data(Lg, "mediatitle2");
1215 sc_grave_del_data(Lg, "mediarequis2");
1216 sc_grave_del_data(Lg, "mediatitle1");
1217 sc_grave_del_data(Lg, "mediarequis1");
1218
1219 if (Loperation != WRITE_DVD) {
1220 sc_grave_del_data(Lg, "useautoblank");
1221 } else {
1222 sc_grave_del_data(Lg, "typeburn");
1223 g_free(Ltypeburn);
1224 }
1225 } else {
1226 gtk_widget_destroy(Lconfirm);
1227 }
1228
1229 g_slist_free(Llmediarequis2);
1230 g_slist_free(Llmediarequis1);
1231
1232 sc_grave_destroy(Ldialoghash);
1233 }
1234
1235 /* popup ajouter des fichiers */
view_popupmenu_addfile(GtkWidget * Aliste,GdkEventButton * Aevent,gpointer Adata)1236 void view_popupmenu_addfile(GtkWidget *Aliste, GdkEventButton *Aevent, gpointer Adata) {
1237 GtkMenu *Lpopupm = create_gtkpopupmenudata(Aliste, Adata);
1238 gtk_menu_popup(Lpopupm, NULL, NULL, NULL, Aliste, Aevent->button, Aevent->time);
1239 }
key_popupmenu_addfile(GtkWidget * Aliste,gpointer Adata)1240 void key_popupmenu_addfile(GtkWidget *Aliste, gpointer Adata) {
1241 GtkMenu *Lpopupm = create_gtkpopupmenudata(Aliste, Adata);
1242 gtk_menu_popup(Lpopupm, NULL, NULL, NULL, Aliste, 0, 0);
1243 }
1244
1245 /* popup affichage */
view_popupmenu_display(GtkWidget * Aliste,GdkEventButton * Aevent,gpointer Adata)1246 void view_popupmenu_display(GtkWidget *Aliste, GdkEventButton *Aevent, gpointer Adata) {
1247 GtkMenu *Lpopupm = create_gtkpopupmenudisplay(Aliste, Adata);
1248 gtk_menu_popup(Lpopupm, NULL, NULL, NULL, Aliste, Aevent->button, Aevent->time);
1249 }
key_popupmenu_display(GtkWidget * Aliste,gpointer Adata)1250 void key_popupmenu_display(GtkWidget *Aliste, gpointer Adata) {
1251 GtkMenu *Lpopupm = create_gtkpopupmenudisplay(Aliste, Adata);
1252 gtk_menu_popup(Lpopupm, NULL, NULL, NULL, Aliste, 0, 0);
1253 }
1254
1255 /* popup ajouter des pistes audio */
view_popupmenu_addaudio(GtkWidget * Aliste,GdkEventButton * Aevent,gpointer Adata)1256 void view_popupmenu_addaudio(GtkWidget *Aliste, GdkEventButton *Aevent, gpointer Adata) {
1257 GtkMenu *Lpopupm = create_gtkpopupmenuaudio(Aliste, Adata);
1258 gtk_menu_popup(Lpopupm, NULL, NULL, NULL, Aliste, Aevent->button, Aevent->time);
1259 }
key_popupmenu_addaudio(GtkWidget * Aliste,gpointer Adata)1260 void key_popupmenu_addaudio(GtkWidget *Aliste, gpointer Adata) {
1261 GtkMenu *Lpopupm = create_gtkpopupmenuaudio(Aliste, Adata);
1262 gtk_menu_popup(Lpopupm, NULL, NULL, NULL, Aliste, 0, 0);
1263 }
1264
1265
1266 /* popup gestion des peripheriques */
view_popupmenu_devices(GtkWidget * Aliste,GdkEventButton * Aevent,gpointer Adata)1267 void view_popupmenu_devices(GtkWidget *Aliste, GdkEventButton *Aevent, gpointer Adata) {
1268 GtkMenu *Lpopupm = create_gtkpopupmenudevices(Aliste, Adata);
1269 gtk_menu_popup(Lpopupm, NULL, NULL, NULL, Aliste, Aevent->button, Aevent->time);
1270 }
key_popupmenu_devices(GtkWidget * Aliste,gpointer Adata)1271 void key_popupmenu_devices(GtkWidget *Aliste, gpointer Adata) {
1272 GtkMenu *Lpopupm = create_gtkpopupmenudevices(Aliste, Adata);
1273 gtk_menu_popup(Lpopupm, NULL, NULL, NULL, Aliste, 0, 0);
1274 }
1275
1276 /* popup gestion des charsets */
view_popupmenu_charset(GtkWidget * Aliste,GdkEventButton * Aevent,gpointer Adata)1277 void view_popupmenu_charset(GtkWidget *Aliste, GdkEventButton *Aevent, gpointer Adata) {
1278 GtkMenu *Lpopupm = create_gtkpopupmenucharset(Aliste, Adata);
1279 gtk_menu_popup(Lpopupm, NULL, NULL, NULL, Aliste, Aevent->button, Aevent->time);
1280 }
key_popupmenu_charset(GtkWidget * Aliste,gpointer Adata)1281 void key_popupmenu_charset(GtkWidget *Aliste, gpointer Adata) {
1282 GtkMenu *Lpopupm = create_gtkpopupmenucharset(Aliste, Adata);
1283 gtk_menu_popup(Lpopupm, NULL, NULL, NULL, Aliste, 0, 0);
1284 }
1285
1286 /* appuis sur une touche, gestion de la suppresion des elements dans les treeview */
gtk_do_eventkeyrelease(GtkWidget * Aliste,GdkEventKey * Aevent,gpointer Adata)1287 gboolean gtk_do_eventkeyrelease(GtkWidget *Aliste, GdkEventKey *Aevent, gpointer Adata)
1288 {
1289 Tgrave *Lg = (Tgrave *) Adata;
1290 const gchar *Lname = glade_get_widget_name(Aliste);
1291 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(Aliste));
1292
1293 if (!Aevent) return FALSE;
1294
1295 /* appuis sur la touche supprimer */
1296 if (Aevent->keyval == GDK_Delete) {
1297 if (!gtk_tree_selection_count_selected_rows(Lselection)) return TRUE;
1298
1299 if (!strcmp(Lname, "periphdata")) {
1300 gtk_devices_remove(NULL, Lg);
1301 return TRUE;
1302 } else if (!strcmp(Lname, "charsetdata")) {
1303 gtk_charset_remove(NULL, Lg);
1304 return TRUE;
1305 } else if (!strcmp(Lname, "LISTEAUDIO")) {
1306 gtk_audio_removetrack(NULL, Lg);
1307 return TRUE;
1308 } else if (!strcmp(Lname, "LISTEDATA")) {
1309 gtk_data_removefiles(NULL, Lg);
1310 return TRUE;
1311 } else if (!strcmp(Lname, "LISTEDVDDATA")) {
1312 gtk_data_removefiles(NULL, Lg);
1313 return TRUE;
1314 }
1315 } else if (Aevent->keyval == GDK_Insert) {
1316 /* appuis sur la touche insert */
1317 if (!strcmp(Lname, "periphdata")) {
1318 gtk_devices_add(NULL, Lg);
1319 return TRUE;
1320 } else if (!strcmp(Lname, "charsetdata")) {
1321 gtk_charset_add(NULL, Lg);
1322 return TRUE;
1323 } else if (!strcmp(Lname, "LISTEAUDIO")) {
1324 gtk_audio_addtrack(NULL, Lg);
1325 return TRUE;
1326 } else if (!strcmp(Lname, "LISTEDATA")) {
1327 gtk_data_addfile(NULL, Lg);
1328 return TRUE;
1329 } else if (!strcmp(Lname, "LISTEDVDDATA")) {
1330 gtk_data_addfile(NULL, Lg);
1331 return TRUE;
1332 }
1333
1334 } else if (Aevent->keyval == GDK_F2) {
1335 /* appuis sur F2, renommer un element */
1336 if (!strcmp(Lname, "LISTEDATA") || !strcmp(Lname, "LISTEDVDDATA")) {
1337 callbacks_data_renameitem(NULL, Lg);
1338 }
1339 } else if ((Aevent->keyval >= GDK_exclam && Aevent->keyval <= GDK_EuroSign) ||
1340 (Aevent->keyval >= GDK_KP_0 && Aevent->keyval <= GDK_KP_9)) {
1341 guint Lkey = Aevent->keyval >=GDK_KP_0 ? Aevent->keyval - 0xFF80 : Aevent->keyval;
1342
1343 callbacks_try_to_select(Lkey, GTK_TREE_VIEW(Aliste), Lg);
1344 }
1345
1346 return FALSE;
1347 }
1348
1349 /* clique sur la souris, gestion des popups */
gtk_do_eventbuttonpress(GtkWidget * Aliste,GdkEventButton * Aevent,gpointer Adata)1350 gboolean gtk_do_eventbuttonpress(GtkWidget *Aliste, GdkEventButton *Aevent, gpointer Adata)
1351 {
1352 if (!Aevent) return FALSE;
1353
1354 if (Aevent->type == GDK_BUTTON_PRESS) {
1355 if (Aevent->button == 3) {
1356 const gchar *Lname = glade_get_widget_name(Aliste);
1357 if (!strcmp(Lname, "LISTEDATA")) {
1358 view_popupmenu_addfile(Aliste, Aevent, Adata);
1359 } else if (!strcmp(Lname, "LISTEDVDDATA")) {
1360 view_popupmenu_addfile(Aliste, Aevent, Adata);
1361 } else if (!strcmp(Lname, "LISTEAUDIO")) {
1362 view_popupmenu_addaudio(Aliste, Aevent, Adata);
1363 } else if (!strcmp(Lname, "periphdata")) {
1364 view_popupmenu_devices(Aliste, Aevent, Adata);
1365 } else if (!strcmp(Lname, "charsetdata")) {
1366 view_popupmenu_charset(Aliste, Aevent, Adata);
1367 } else if (!strcmp(Lname, "topmenu")) {
1368 view_popupmenu_display(Aliste, Aevent, Adata);
1369 }
1370 return TRUE;
1371 }
1372 } else if (Aevent->type == GDK_2BUTTON_PRESS) {
1373 if (Aevent->button == 1) {
1374 const gchar *Lname = glade_get_widget_name(Aliste);
1375 /* double clique sur la fenetre des lecteurs, on edite le lecteur */
1376 if (!strcmp(Lname, "periphdata")) {
1377 gtk_devices_edit(NULL, Adata);
1378 } else if (!strcmp(Lname, "charsetdata")) {
1379 gtk_charset_edit(NULL, Adata);
1380 }
1381 return TRUE;
1382 }
1383 }
1384 return FALSE;
1385 }
1386
1387 /* callback lorsque l'on selectionne un fichier pour activer/desactiver
1388 * le bouton "ajouter des fichiers" */
on_select_files(GtkTreeSelection * Aselection,GtkTreeModel * Amodel,GtkTreePath * Apath,gboolean Apath_currently_selected,gpointer Adata)1389 gboolean on_select_files (GtkTreeSelection *Aselection, GtkTreeModel *Amodel,
1390 GtkTreePath *Apath, gboolean Apath_currently_selected,
1391 gpointer Adata)
1392 {
1393 GtkTreeIter Liter;
1394 GtkWidget *Lbtn = (GtkWidget *) Adata;
1395 gboolean Ltodisable;
1396
1397 if (Lbtn && !Apath_currently_selected && gtk_tree_model_get_iter(Amodel, &Liter, Apath)) {
1398 gint Ltype;
1399
1400 gtk_tree_model_get(Amodel, &Liter, 0, &Ltype, -1);
1401
1402 Ltodisable = (Ltype != TYPE_FILE);
1403
1404 gtk_widget_set_sensitive(GTK_WIDGET(Lbtn), Ltodisable);
1405 }
1406 return TRUE;
1407 }
1408
1409 /* passage a l'onglet suivante */
gonextpage(GtkWidget * Antn,GtkNotebook * Anotebook)1410 void gonextpage(GtkWidget *Antn, GtkNotebook *Anotebook)
1411 {
1412 gtk_notebook_next_page(Anotebook);
1413 }
1414
1415 /* callback pour verifier la longueur des textes buffer */
text_buffer_callback(GtkTextBuffer * Aobj,gpointer Adata)1416 void text_buffer_callback(GtkTextBuffer *Aobj, gpointer Adata)
1417 {
1418 GtkTextIter Lstart_iter;
1419 GtkTextIter Lend_iter;
1420 gchar *Ltext;
1421 gint Lmax_len;
1422
1423 Lmax_len = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (Aobj), "max-length"));
1424 if (Lmax_len == 0) return;
1425
1426 gtk_text_buffer_get_bounds (Aobj, &Lstart_iter, &Lend_iter);
1427 Ltext = gtk_text_buffer_get_text (Aobj, &Lstart_iter, &Lend_iter, FALSE);
1428
1429 if (strlen(Ltext)>Lmax_len) {
1430 gtk_text_buffer_get_iter_at_offset (Aobj, &Lstart_iter, Lmax_len);
1431 gtk_text_buffer_delete (Aobj, &Lstart_iter, &Lend_iter);
1432 }
1433
1434 g_free(Ltext);
1435 }
1436
1437 /* clique sur le menu, on active un onglet */
menu_active_panel(GtkWidget * Amenuitem,gpointer Adata)1438 void menu_active_panel(GtkWidget *Amenuitem, gpointer Adata)
1439 {
1440 Tgrave *Lg = (Tgrave *)Adata;
1441 GtkTreeView *Ltopmenu = GTK_TREE_VIEW(sc_grave_get_widget(Lg, "topmenu"));
1442 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(Ltopmenu);
1443 GtkTreeModel *Lmodel = gtk_tree_view_get_model(Ltopmenu);
1444 GtkTreeIter Liter;
1445 const gchar *Lname = glade_get_widget_name(Amenuitem);
1446 gchar *Lrequest = g_strdup_printf("body%s", Lname+strlen("menu"));
1447 gchar *Lcuritem;
1448 gchar Lcont = gtk_tree_model_get_iter_first(Lmodel, &Liter);
1449 while (Lcont == TRUE) {
1450 gtk_tree_model_get(Lmodel, &Liter, 0, &Lcuritem, -1);
1451
1452 if (!strcmp(Lcuritem, Lrequest)) {
1453 gtk_tree_selection_select_iter(Lselection, &Liter);
1454 gtk_toggle_top_menu(Ltopmenu, Lg);
1455
1456 g_free(Lcuritem);
1457 break;
1458 }
1459 g_free(Lcuritem);
1460
1461 Lcont = gtk_tree_model_iter_next(Lmodel, &Liter);
1462 }
1463 }
1464
1465 /* changement d'onglet */
switchpage(GtkNotebook * Anotebook,GtkNotebookPage * Anotebookpage,guint Apagenum,gpointer Adata)1466 void switchpage(GtkNotebook *Anotebook, GtkNotebookPage *Anotebookpage, guint Apagenum, gpointer Adata)
1467 {
1468 Tgrave *Lg = (Tgrave *)Adata;
1469 GtkWidget *Ldatavoli;
1470 GtkTreeModel *Ltreemodel;
1471 GtkTreeIter Liter;
1472 gchar *Lnom;
1473
1474 if (Apagenum != 0 && Apagenum != 2) return;
1475 if (!strcmp(glade_get_widget_name(GTK_WIDGET(Anotebook)), "bodycddata")) {
1476 Ldatavoli = sc_grave_get_widget(Lg, "datavoli");
1477 Ltreemodel = gtk_tree_view_get_model(GTK_TREE_VIEW(sc_grave_get_widget(Lg, "LISTEDATA")));
1478 } else {
1479 Ldatavoli = sc_grave_get_widget(Lg, "dvddatavoli");
1480 Ltreemodel = gtk_tree_view_get_model(GTK_TREE_VIEW(sc_grave_get_widget(Lg, "LISTEDVDDATA")));
1481 }
1482
1483
1484
1485 /* il devrait normalement toujours y avoir une entree dans la liste, au moins le nom du cd ! */
1486 if (!gtk_tree_model_get_iter_first(Ltreemodel, &Liter)) return;
1487 if (Apagenum == 2) {
1488 /* mise a jour du champ "Nom du volume" */
1489 gtk_tree_model_get(Ltreemodel, &Liter, 2, &Lnom, -1);
1490 gtk_entry_set_text(GTK_ENTRY(Ldatavoli), Lnom);
1491 g_free(Lnom);
1492 } else if (Apagenum == 0) {
1493 /* mise a jour de l'entre contenant le nom du volume */
1494 gtk_tree_store_set(GTK_TREE_STORE(Ltreemodel), &Liter, 2, gtk_entry_get_text(GTK_ENTRY(Ldatavoli)), -1);
1495 }
1496 }
1497
1498 /* activer la boite de dialogue proprietes */
menu_active_proprietes(GtkWidget * Amenuitem,gpointer Adata)1499 void menu_active_proprietes(GtkWidget *Amenuitem, gpointer Adata)
1500 {
1501 Tgrave *Lg = (Tgrave *) Adata;
1502 GtkWidget *Lparent = GTK_WIDGET(sc_grave_get_widget(Lg, "topwindow"));
1503 Tgrave *Ldialoghash = create_dialog_proprietes(Lparent);
1504 GtkWidget *Lwinproprietes = sc_grave_get_data(Ldialoghash, "window");
1505 GError *Aerror = NULL;
1506 GtkWidget *Lptr;
1507 TProgRequis *Lcurentry;
1508 gchar Ltmp[256];
1509 gboolean Lval;
1510
1511 sc_tooltips(Lwinproprietes, conf_get_boolean("tooltips"));
1512
1513 gtk_dialog_run(GTK_DIALOG(Lwinproprietes));
1514
1515 /* recuperation des valeurs a sauver */
1516 Lptr = sc_grave_get_widget(Ldialoghash, "dirtmpvalue");
1517 conf_store_value("tmpdir", (gchar *)gtk_entry_get_text(GTK_ENTRY(Lptr)));
1518 Lptr = sc_grave_get_widget(Ldialoghash, "overburn");
1519 conf_store_value("overburn", _BOOLEAN_CONF(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Lptr))));
1520 Lptr = sc_grave_get_widget(Ldialoghash, "fastblank");
1521 conf_store_value("fastblank", _BOOLEAN_CONF(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Lptr))));
1522 Lptr = sc_grave_get_widget(Ldialoghash, "autoblank");
1523 conf_store_value("autoblank", _BOOLEAN_CONF(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Lptr))));
1524 Lptr = sc_grave_get_widget(Ldialoghash, "eject");
1525 conf_store_value("eject", _BOOLEAN_CONF(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Lptr))));
1526 Lptr = sc_grave_get_widget(Ldialoghash, "statusbar");
1527 conf_store_value("statusbar", _BOOLEAN_CONF(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Lptr))));
1528 Lptr = sc_grave_get_widget(Ldialoghash, "iconsizelist");
1529 conf_store_value("iconsize", get_combo_value((Lptr)));
1530 Lptr = sc_grave_get_widget(Ldialoghash, "saveconfig");
1531 conf_store_value("saveconfig", _BOOLEAN_CONF(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Lptr))));
1532 Lptr = sc_grave_get_widget(Ldialoghash, "inputcharset");
1533 conf_store_value("charsetdata", get_combo_value_pos(Lptr, 2));
1534 Lptr = sc_grave_get_widget(Ldialoghash, "themelist");
1535 conf_store_value("theme", get_combo_value_pos(Lptr, 3));
1536
1537 /* tooltips ! */
1538 Lptr = sc_grave_get_widget(Ldialoghash, "tooltips");
1539 Lval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Lptr));
1540 conf_store_value("tooltips", _BOOLEAN_CONF(Lval));
1541 sc_tooltips(Lparent, Lval);
1542
1543 #if 0
1544 Lptr = sc_grave_get_widget(Ldialoghash, "extended");
1545 conf_store_value("extended", _BOOLEAN_CONF(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Lptr))));
1546 #endif
1547
1548
1549 /* on sauve les parametres utilisateurs a passer aux programmes externes */
1550 for (Lcurentry = Glisteprogrequis; Lcurentry->entry; Lcurentry++) {
1551 if (Lcurentry->type != CONF_PROG) continue;
1552 g_snprintf(Ltmp, sizeof(Ltmp)-1, "%spara", Lcurentry->entry);
1553
1554 Lptr = sc_grave_get_widget(Ldialoghash, Ltmp);
1555 if (!GTK_IS_WIDGET(Lptr)) continue;
1556
1557 conf_store_value(Ltmp, (gchar *)gtk_entry_get_text(GTK_ENTRY(Lptr)));
1558 }
1559
1560 /* sauvegarde configuration */
1561 write_conf(&Aerror);
1562
1563 /* mise a jour des listes contenant les lecteurs */
1564 update_combo_graveur(Lg);
1565 update_status_bar_display(Lg);
1566 manage_interface(Lg, MENU_UPDATE + COMBO_UPDATE );
1567
1568 gtk_widget_destroy(Lwinproprietes);
1569
1570 sc_grave_destroy(Ldialoghash);
1571 }
1572
encours_callback(gpointer Adata)1573 gboolean encours_callback(gpointer Adata)
1574 {
1575 Tgrave *Lg = (Tgrave *)Adata;
1576 GtkProgressBar *Lprog = GTK_PROGRESS_BAR(sc_grave_get_data(Lg, "progress"));
1577 gint *Lcont = (gint *)sc_grave_get_data(Lg, "cont");
1578
1579 gtk_progress_bar_pulse(Lprog);
1580
1581 if ((*Lcont) == 1) (*Lcont) = 0;
1582
1583 return (*Lcont) > 0 ? TRUE : FALSE;
1584 }
1585
1586 /* chercher (a nouveau) les programmes */
chercheprog(GtkWidget * Aobj,gpointer Adata)1587 void chercheprog(GtkWidget *Aobj, gpointer Adata)
1588 {
1589 Tgrave *Lg = (Tgrave *)Adata;
1590 GtkWidget *Lstatusbox;
1591 GtkWidget *Lwindow1 = sc_grave_get_data(Lg, "window");
1592
1593 /* mise a jour de la configuration */
1594 manage_config(Lg, SEARCH_PROG, NULL);
1595 clean_config();
1596
1597 maj_proprietes_prog(Lg);
1598
1599 /* boite de dialoge operation terminee */
1600 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwindow1), GTK_DIALOG_MODAL,
1601 GTK_MESSAGE_INFO, GTK_BUTTONS_OK, _("configuration updated."));
1602 gtk_dialog_run(GTK_DIALOG(Lstatusbox));
1603 gtk_widget_destroy(Lstatusbox);
1604 }
1605
1606
1607 /* chercher (a nouveau) les lecteurs */
cherchelecteur(GtkWidget * Aobj,gpointer Adata)1608 void cherchelecteur(GtkWidget *Aobj, gpointer Adata)
1609 {
1610 Tgrave *Lparenthash = (Tgrave *)Adata;
1611 GtkWidget *Lwindow1 = sc_grave_get_data(Lparenthash, "window");
1612 Tgrave *Lg = create_window_encours(Lwindow1);
1613 GtkWidget *Lstatusbox;
1614 GtkWidget *Lwin;
1615 GtkTreeView *Ldata;
1616 gboolean Labort = FALSE;
1617 gint Lcont = 2;
1618 gchar *Ltxt;
1619 GSList *Lcur, *Lnext;
1620 Tdriveinfo *Ldrive;
1621 guint Ltimeout;
1622
1623 Lwin = sc_grave_get_widget(Lg, "window_inprogress");
1624
1625 sc_grave_set_data(Lg, &Lcont, "cont");
1626 sc_grave_set_data(Lg, &Labort, "gabort");
1627 sc_grave_ref_wtd(Lg, "progress", "progress");
1628
1629 /* bouton annuler */
1630 g_signal_connect(G_OBJECT(sc_grave_get_widget(Lg, "cancelbtn")), "clicked", G_CALLBACK(abort_encours), (GtkWidget *)Lg);
1631
1632 gtk_widget_show(Lwin);
1633 Ltimeout = g_timeout_add(500, encours_callback, Lg);
1634
1635 proc_init_cdrominfo(NULL);
1636 cdrecord_scan_for_drives(Lg, NULL);
1637
1638 if (Labort == FALSE) {
1639 for (Lcur = Glistdrives; Lcur; Lcur = Lcur ? g_slist_next(Lcur) : Lnext) {
1640 Ldrive = (Tdriveinfo *)Lcur->data;
1641 if (g_slist_length(Ldrive->dev)>0) {
1642 Ltxt = g_strdup_printf(_("Scanning drive \"%s\"..."), Ldrive->name);
1643 gtk_label_set_text(GTK_LABEL(sc_grave_get_widget(Lg, "labelava")), Ltxt); g_free(Ltxt);
1644 while(gtk_events_pending()) gtk_main_iteration();
1645
1646 matos_maj_drive_info(Ldrive, NULL, NULL);
1647
1648 /* on n'ajoute que les lecteurs/graveurs */
1649 if (Ldrive->type == 0) {
1650 _DEB("le type == %d = %s\n", Ldrive->type, Ldrive->name);
1651 Lnext = g_slist_next(Lcur);
1652 Glistdrives = g_slist_delete_link(Glistdrives, Lcur);
1653 Lcur = NULL;
1654 }
1655 }
1656 }
1657 }
1658 proc_free_cdrominfo();
1659
1660 /* on attend la fin d'execution de la popup d'attente */
1661 g_source_remove(Ltimeout);
1662
1663 gtk_widget_destroy(Lwin);
1664 if (GTK_IS_WIDGET(Aobj) && Labort == FALSE) {
1665 Ldata = GTK_TREE_VIEW(sc_grave_get_widget(Lparenthash, "periphdata"));
1666 remplirelistegraveur(Ldata);
1667
1668 /* boite de dialoge operation terminee */
1669 Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lwindow1), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
1670 _("configuration updated."));
1671 gtk_dialog_run(GTK_DIALOG(Lstatusbox));
1672 gtk_widget_destroy(Lstatusbox);
1673 }
1674
1675 sc_grave_destroy(Lg);
1676 }
1677
abort_encours(GtkWidget * Abtn,gpointer Adata)1678 void abort_encours(GtkWidget *Abtn, gpointer Adata)
1679 {
1680 Tgrave *Lg = (Tgrave *)Adata;
1681 gint *Lcont = (gint *)sc_grave_get_data(Lg, "cont");
1682 gboolean *Labort = (gboolean *)sc_grave_get_data(Lg, "gabort");
1683 gint *Lpid = (gint *)sc_grave_get_data(Lg, "pid");
1684 printf(" on va kill !\n");
1685 if (Lpid && *Lpid) {
1686 /* on envoi un TERM au process (cdrecord...) pour qu'il s'arrete ! */
1687 _DEB("kill de %d\n", *Lpid);
1688 kill(*Lpid, SIGINT);
1689 }
1690
1691 (*Labort) = TRUE;
1692 (*Lcont) = 1; /* on passe Lcont de 2 a 1 */
1693 }
delete_event_encours(GtkWidget * Awidget,GdkEvent * Aevent,gpointer Adata)1694 void delete_event_encours(GtkWidget *Awidget, GdkEvent *Aevent, gpointer Adata)
1695 {
1696 abort_encours(NULL, Adata);
1697 }
1698
1699 /* on quitte l'application .. */
menu_quit(GtkWidget * Aobj1,gpointer Adata)1700 void menu_quit(GtkWidget *Aobj1, gpointer Adata)
1701 {
1702 Tgrave *Lg = (Tgrave *)Adata;
1703 gint Loperation = UPDATE_SIZE + WRITE_CONFIG;
1704
1705 if (conf_get_boolean("saveconfig")==TRUE) {
1706 Loperation+=UPDATE_SAVEONEXIT_VALUE;
1707 }
1708
1709 /* on sauve la position et taille de la fenetre */
1710 manage_config(Lg, Loperation, NULL);
1711
1712 gtk_main_quit();
1713 }
1714
delete_event_quit(GtkWidget * Awidget,GdkEvent * Aevent,gpointer Adata)1715 void delete_event_quit(GtkWidget *Awidget, GdkEvent *Aevent, gpointer Adata)
1716 {
1717 menu_quit(Awidget, Adata);
1718 }
1719
1720 #if 0
1721 void on_addmediaformat(GtkWidget *Abtn, gpointer Adata)
1722 {
1723 Tgrave *Lmediahash = addmediaformat(Adata);
1724 GtkDialog *Ldialog = GTK_DIALOG(sc_grave_get_widget(Lmediahash, "dialog_media"));
1725
1726 gtk_dialog_run(Ldialog);
1727 gtk_widget_destroy(GTK_WIDGET(Ldialog));
1728
1729 sc_grave_destroy(Lmediahash);
1730 }
1731 #endif
1732
1733 /* mise a jour type cdr destination, on mets donc a jour la barre de remplissage */
change_remplissage(GtkWidget * Acombo,gpointer Adata)1734 void change_remplissage(GtkWidget *Acombo, gpointer Adata)
1735 {
1736 Tgrave *Lg = (Tgrave *)Adata;
1737 const gchar *Lname = glade_get_widget_name(Acombo);
1738 gchar *Lvalue = get_combo_value(Acombo);
1739 GtkProgressBar *Lcontenance;
1740 guint64 *Lmaxlen;
1741 guint64 *Llen;
1742
1743 if (!strcmp(Lname, "listeremplidata")) { /* cd data */
1744 Lcontenance = GTK_PROGRESS_BAR(sc_grave_get_widget(Lg, "datasizebar"));
1745 Lmaxlen = (guint64 *)sc_grave_get_data(Lg, "datamaxsize");
1746 Llen = (guint64 *)sc_grave_get_data(Lg, "datasize");
1747 (*Lmaxlen) = (unsigned long long)strtoul(Lvalue, NULL, 10) * 1024 * 1024;
1748 } else if (!strcmp(Lname, "listeremplidvddata")) { /* dvd data */
1749 Lcontenance = GTK_PROGRESS_BAR(sc_grave_get_widget(Lg, "dvddatasizebar"));
1750 Lmaxlen = (guint64 *)sc_grave_get_data(Lg, "dvddatamaxsize");
1751 Llen = (guint64 *)sc_grave_get_data(Lg, "dvddatasize");
1752 (*Lmaxlen) = (unsigned long long)strtoul(Lvalue, NULL, 10) * 1024 * 1024;
1753
1754 } else { /* cd audio */
1755 Lcontenance = GTK_PROGRESS_BAR(sc_grave_get_widget(Lg, "audiolenbar"));
1756 Lmaxlen = (guint64 *)sc_grave_get_data(Lg, "audiomaxlen");
1757 Llen = (guint64 *)sc_grave_get_data(Lg, "audiolen");
1758 (*Lmaxlen) = (unsigned long long)strtoul(Lvalue, NULL, 10);
1759 }
1760
1761 switch_pbar_status(Lcontenance, *Lmaxlen, *Llen, PB_NONE);
1762 }
1763
1764 /* gestion drag and drop */
audio_dnd_data_received(GtkWidget * Aliste,GdkDragContext * Acontext,gint Ax,gint Ay,GtkSelectionData * Aseldata,guint Ainfo,guint Atime,gpointer Adata)1765 void audio_dnd_data_received (GtkWidget *Aliste, GdkDragContext *Acontext, gint Ax, gint Ay, GtkSelectionData *Aseldata, guint Ainfo, guint Atime, gpointer Adata)
1766 {
1767 Tgrave *Lg = (Tgrave *)Adata;
1768 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(GTK_TREE_VIEW(Aliste));
1769 guint64 *Laudiolen = (guint64 *)sc_grave_get_data(Lg, "audiolen");
1770 guint64 *Laudiomaxlen = (guint64 *)sc_grave_get_data(Lg, "audiomaxlen");
1771 GtkProgressBar *Lcontenance = GTK_PROGRESS_BAR(sc_grave_get_widget(Lg, "audiolenbar"));
1772
1773 if ((Aseldata->length >= 0) && (Aseldata->format == 8))
1774 {
1775 gchar *Lunfic;
1776 gint i;
1777 gchar **Lallname = g_strsplit(Aseldata->data, "\r\n", 0);
1778 gchar *Lfilename = NULL;
1779
1780 for (i=0; ((Lallname[i])); i++) {
1781 if ((!(Lunfic = g_strchomp(Lallname[i]))) || !*Lunfic) continue;
1782
1783 /* on ne gere que les fichiers locaux pour le moment, et c'est deja �a !! */
1784 if (g_ascii_strncasecmp(Lunfic, "file://", 7) || (
1785 ! (
1786 #ifdef ENABLE_MP3
1787 (GsupportMp3 && sc_str_has_casesuffix(Lunfic, MP3)) ||
1788 #endif
1789 #ifdef ENABLE_OGG
1790 (GsupportOgg && sc_str_has_casesuffix(Lunfic, OGG)) ||
1791 #endif
1792 #ifdef ENABLE_FLAC
1793 (GsupportFlac && sc_str_has_casesuffix(Lunfic, FLAC)) ||
1794 #endif
1795 sc_str_has_casesuffix(Lunfic, WAV)))) continue;
1796
1797 if (!(Lfilename = g_filename_from_uri(Lunfic, NULL, NULL))) continue;
1798 _add_a_piste(Lfilename, GTK_LIST_STORE(Ltreemodel), Lg);
1799 g_free(Lfilename);
1800 }
1801
1802 g_strfreev(Lallname);
1803
1804 /* mise a jour barre de remplissage */
1805 switch_pbar_status(Lcontenance, *Laudiomaxlen, *Laudiolen, PB_UPDATE_AUDIO);
1806
1807 gtk_drag_finish (Acontext, TRUE, FALSE, Atime);
1808 return;
1809 } else {
1810 GtkTreePath *Lpathsrc = NULL;
1811 GtkTreePath *Lpathdst = NULL;
1812 GtkTreeIter Litersrc;
1813 GtkTreeIter Literdst;
1814 gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(Aliste), Ax, Ay, &Lpathdst, NULL);
1815 if (Lpathdst) {
1816 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Aliste), &Lpathsrc, NULL);
1817 if (Lpathsrc) {
1818 gtk_tree_model_get_iter(Ltreemodel, &Litersrc, Lpathsrc);
1819 gtk_tree_model_get_iter(Ltreemodel, &Literdst, Lpathdst);
1820 gtk_list_store_move_after(GTK_LIST_STORE(Ltreemodel), &Litersrc, &Literdst);
1821 gtk_tree_path_free(Lpathsrc);
1822 gtk_drag_finish (Acontext, TRUE, FALSE, Atime);
1823 }
1824 gtk_tree_path_free(Lpathdst);
1825 }
1826 }
1827 gtk_drag_finish (Acontext, FALSE, FALSE, Atime);
1828 }
1829
data_dnd_data_received(GtkWidget * Aliste,GdkDragContext * Acontext,gint Ax,gint Ay,GtkSelectionData * Aseldata,guint Ainfo,guint Atime,gpointer Adata)1830 void data_dnd_data_received (GtkWidget *Aliste, GdkDragContext *Acontext, gint Ax, gint Ay, GtkSelectionData *Aseldata, guint Ainfo, guint Atime, gpointer Adata)
1831 {
1832 Tgrave *Lg = (Tgrave *)Adata;
1833 guint64 *Ldatasize;
1834 guint64 *Ldatamaxsize;
1835 GtkProgressBar *Lcontenance;
1836 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(GTK_TREE_VIEW(Aliste));
1837
1838 _REMPLISSAGE_VALUE(Lg, Aliste, Ldatasize, Ldatamaxsize, Lcontenance);
1839
1840 if ((Aseldata->length >= 0) && (Aseldata->format == 8))
1841 {
1842 gchar *Lunfic;
1843 gint i;
1844 gchar **Lallname = g_strsplit(Aseldata->data, "\n", 0);
1845 gchar *Lfilename = NULL;
1846 GtkTreeIter Liter, Lfirstiter;
1847 GtkTreePath *Lpath = NULL;
1848
1849 gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(Aliste), Ax, Ay, &Lpath, NULL);
1850 if (!Lpath) {
1851 if (!gtk_tree_model_get_iter_first(Ltreemodel, &Liter)) {
1852 gtk_drag_finish (Acontext, FALSE, FALSE, Atime);
1853 return;
1854 }
1855 } else {
1856 gtk_tree_model_get_iter(Ltreemodel, &Liter, Lpath);
1857 gtk_tree_path_free(Lpath);
1858 }
1859
1860 for (i=0; ((Lallname[i])); i++) {
1861 if ((!(Lunfic = g_strchomp(Lallname[i]))) || !*Lunfic) continue;
1862 if (g_ascii_strncasecmp(Lunfic, "file://", 7)) continue;
1863 if (!(Lfilename = g_filename_from_uri(Lunfic, NULL, NULL))) continue;
1864
1865 _add_a_file(Lfilename, GTK_TREE_STORE(Ltreemodel), &Liter, Lg, Ldatasize,
1866 i == 0 ? &Lfirstiter : NULL);
1867
1868 g_free(Lfilename);
1869 }
1870
1871 g_strfreev(Lallname);
1872
1873 /* expand element ajoute */
1874 if ((Lpath = gtk_tree_model_get_path(Ltreemodel, &Lfirstiter))) {
1875 gtk_tree_view_expand_to_path(GTK_TREE_VIEW(Aliste), Lpath);
1876 gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(Aliste), Lpath, NULL, FALSE, 0, 0);
1877 gtk_tree_view_set_cursor(GTK_TREE_VIEW(Aliste), Lpath, NULL, TRUE);
1878 gtk_tree_path_free(Lpath);
1879 }
1880
1881 /* mise a jour barre de remplissage */
1882 switch_pbar_status(Lcontenance, *Ldatamaxsize, *Ldatasize, PB_UPDATE_DATA);
1883
1884 gtk_drag_finish (Acontext, TRUE, FALSE, Atime);
1885 return;
1886 } else {
1887 GtkTreePath *Lpathsrc = NULL;
1888 GtkTreePath *Lpathdst = NULL;
1889 GtkTreeIter Litersrc, Literdst, Liternew;
1890 gint Ltype;
1891 gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(Aliste), Ax, Ay, &Lpathdst, NULL);
1892 if (Lpathdst) {
1893 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Aliste), &Lpathsrc, NULL);
1894 if (Lpathsrc) {
1895 if (gtk_tree_path_is_descendant(Lpathdst, Lpathsrc)) {
1896
1897 gtk_tree_path_free(Lpathsrc);
1898 gtk_tree_path_free(Lpathdst);
1899 gtk_drag_finish (Acontext, FALSE, FALSE, Atime);
1900 return;
1901 }
1902
1903 gtk_tree_model_get_iter(Ltreemodel, &Litersrc, Lpathsrc);
1904 gtk_tree_model_get_iter(Ltreemodel, &Literdst, Lpathdst);
1905
1906 gtk_tree_model_get(Ltreemodel, &Literdst, 0, &Ltype, -1);
1907
1908 /* on ne deplace pas le CD root */
1909 if (Ltype == TYPE_CD) return;
1910
1911 if (Ltype == TYPE_FILE) {
1912 gtk_tree_store_insert_after(GTK_TREE_STORE(Ltreemodel), &Liternew, NULL, &Literdst);
1913 } else {
1914 gtk_tree_store_insert_after(GTK_TREE_STORE(Ltreemodel), &Liternew, &Literdst, NULL);
1915 }
1916
1917 /* copie recursive de l'element et des enfants */
1918 sc_line_data_copy(Ltreemodel, &Litersrc, &Liternew);
1919
1920 gtk_tree_path_free(Lpathsrc);
1921 gtk_tree_path_free(Lpathdst);
1922 gtk_drag_finish (Acontext, TRUE, TRUE, Atime);
1923
1924 return;
1925 }
1926 gtk_tree_path_free(Lpathdst);
1927 }
1928 }
1929
1930 gtk_drag_finish (Acontext, FALSE, FALSE, Atime);
1931 }
1932
1933 #if 0
1934 void update_media_unit_range(gchar *Aunit)
1935 {
1936 // gtk_spin_button_set_range
1937
1938 }
1939
1940 void update_media_unit(GtkWidget *Acombo, gpointer Adata)
1941 {
1942 Tgrave *Lg = (Tgrave *)Adata;
1943 GtkWidget *Ldataentry = GTK_WIDGET(g_hash_table_lookup(Lg, "mediadata"));
1944
1945 gtk_widget_grab_focus(Ldataentry);
1946 }
1947
1948 /* mise a jour des champs dans la fenetre "configuration des medias" */
1949 gboolean update_media_fields(GtkWidget *Awidget, gpointer Adata)
1950 {
1951 Tgrave *Lg = (Tgrave *)Adata;
1952 const gchar *Lname = glade_get_widget_name(GTK_WIDGET(Awidget));
1953 gulong Lnewsize;
1954 gulong Lasksize;
1955 gulong *Lsize = (gulong *)g_hash_table_lookup(Lg, "fullsize");
1956 GtkComboBox *Lmediadataunit = GTK_COMBO_BOX(g_hash_table_lookup(Lg, "mediadataunit"));
1957 gchar *Lcharunit = get_combo_value(GTK_WIDGET(Lmediadataunit));
1958
1959 // printf("l'unite est => %s\n", Lcharunit);
1960 Lasksize = (gulong) gtk_spin_button_get_value(GTK_SPIN_BUTTON(Awidget));
1961
1962 // printf("oui [%c]\n", *Lcharunit);
1963 /* mise a jour depuis la taille */
1964 // printf("asjsize avant => %ld\n", Lasksize);
1965 if (*Lcharunit == 'g') {
1966 Lasksize*=1024 * 1024 * 1024;
1967 } else if (*Lcharunit == 'm') {
1968 Lasksize*=1024 * 1024;
1969 } else {
1970 // printf("oui kb\n");
1971 Lasksize*= 1024;
1972 }
1973
1974 gtk_spin_button_set_value(Lmediaaudio, Lasksize );
1975 *Lsize = Lasksize;
1976 //printf("la taille est donc de = %ld\n", *Lsize);
1977
1978 g_free(Lcharunit);
1979 }
1980
1981 return FALSE;
1982 }
1983 #endif
1984
1985 /* charger un fichier, importer une playlist */
menu_load(GtkMenuItem * Amenuitem,gpointer Adata)1986 void menu_load(GtkMenuItem *Amenuitem, gpointer Adata)
1987 {
1988 Tgrave *Lg = (Tgrave *)Adata;
1989 GtkFileFilter *filterm3u, *filterpts, *filterall;
1990 GtkWidget *Lparent = sc_grave_get_widget(Lg, "topwindow");
1991 guint32 *Laudiolen = (guint32 *)sc_grave_get_data(Lg, "audiolen");
1992 guint32 *Laudiomaxlen = (guint32 *)sc_grave_get_data(Lg, "audiomaxlen");
1993 GtkProgressBar *Lcontenance = GTK_PROGRESS_BAR(sc_grave_get_widget(Lg, "audiolenbar"));
1994 GError *Lerror = NULL;
1995 GtkWidget *Lfileselection;
1996 gint Lresp;
1997 gboolean LnewPl = (strcmp(glade_get_widget_name(GTK_WIDGET(Amenuitem)), "popupaudio_append"));
1998
1999 /* filtres pour la selection de fichiers */
2000 filterall = gtk_file_filter_new ();
2001 gtk_file_filter_set_name (filterall, _("All playlists files (*.m3u *.pts)"));
2002 gtk_file_filter_add_pattern(filterall, "*.m3u");
2003 gtk_file_filter_add_pattern(filterall, "*.pts");
2004 filterm3u = gtk_file_filter_new ();
2005 gtk_file_filter_set_name (filterm3u, _("M3u and m3u extended playlists only (*.m3u)"));
2006 gtk_file_filter_add_pattern(filterm3u, "*.m3u");
2007 filterpts = gtk_file_filter_new ();
2008 gtk_file_filter_set_name (filterpts, _("Pts playlists only (*.pts)"));
2009 gtk_file_filter_add_pattern(filterpts, "*.pts");
2010
2011 Lfileselection = gtk_file_chooser_dialog_new(LnewPl ? _("Import audio play list") : _("Append audio play list"),
2012 GTK_WINDOW(Lparent), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
2013 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
2014
2015 gtk_dialog_set_default_response (GTK_DIALOG (Lfileselection), GTK_RESPONSE_ACCEPT);
2016 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (Lfileselection), filterall);
2017 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (Lfileselection), filterm3u);
2018 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (Lfileselection), filterpts);
2019
2020 use_last_dir(GTK_FILE_CHOOSER(Lfileselection));
2021 Lresp=gtk_dialog_run(GTK_DIALOG(Lfileselection));
2022
2023 gtk_widget_hide (Lfileselection);
2024
2025 if (Lresp == GTK_RESPONSE_ACCEPT) {
2026 gchar *Lfilenamebrut = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (Lfileselection));
2027 gchar *Lfilename = _FILENAME(Lfilenamebrut);
2028
2029 save_last_dir(GTK_FILE_CHOOSER(Lfileselection));
2030
2031 if (sc_str_has_casesuffix(Lfilename, M3U)) {
2032 m3u_import(Lfilename, Lg, LnewPl, &Lerror);
2033 } else if (sc_str_has_casesuffix(Lfilename, PLS)) {
2034 pls_import(Lfilename, Lg, LnewPl, &Lerror);
2035 }
2036
2037 g_free(Lfilename);
2038 g_free(Lfilenamebrut);
2039
2040 if (Lerror) {
2041 /* erreur */
2042 GtkWidget *Lstatusbox = gtk_message_dialog_new(GTK_WINDOW(Lparent),
2043 GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
2044 Lerror->message);
2045 gtk_dialog_run(GTK_DIALOG(Lstatusbox));
2046
2047 gtk_widget_destroy(Lstatusbox);
2048 g_error_free(Lerror);
2049 } else {
2050 /* on active le panel "cd audio" si on n'y est pas */
2051 menu_active_panel(sc_grave_get_widget(Lg, "menucdaudio"), Lg);
2052 }
2053 }
2054
2055 gtk_widget_destroy(Lfileselection);
2056 switch_pbar_status(Lcontenance, *Laudiomaxlen, *Laudiolen, PB_UPDATE_AUDIO);
2057 }
2058
2059 /* debuter un nouveau projet */
menu_start_new(GtkMenuItem * Amenuitem,gpointer Adata)2060 void menu_start_new(GtkMenuItem *Amenuitem, gpointer Adata)
2061 {
2062 Tgrave *Lg = (Tgrave *)Adata;
2063 GtkTreeView *Ltopmenu = GTK_TREE_VIEW(sc_grave_get_widget(Lg, "topmenu"));
2064 gchar *Lname;
2065 GtkTreeIter Liter;
2066 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(Ltopmenu);
2067 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(Ltopmenu);
2068
2069 if (!gtk_tree_selection_get_selected(Lselection, &Ltreemodel, &Liter)) return;
2070 gtk_tree_model_get(Ltreemodel, &Liter, 0, &Lname, -1);
2071
2072 if (!strcmp(Lname, "bodycdaudio")) {
2073 /* on est sur l'onglet cd audio, on vide la liste */
2074 clear_list_audio(Lg);
2075 } else if (!strcmp(Lname, "bodycddata") || !strcmp(Lname, "bodydvddata")) {
2076 /* on est sur l'onglet cd data, on vide la liste */
2077 GtkTreeView *Lliste = GTK_TREE_VIEW(sc_grave_get_data(Lg, "_current_list"));
2078 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(GTK_TREE_VIEW(Lliste));
2079 GtkProgressBar *Lcontenance;
2080 guint64 *Ldatasize;
2081 guint64 *Ldatamaxsize;
2082 GtkTreeIter Liter;
2083
2084 _REMPLISSAGE_VALUE(Lg, Lliste, Ldatasize, Ldatamaxsize, Lcontenance);
2085 (*Ldatasize) = 0;
2086
2087 gtk_tree_store_clear(GTK_TREE_STORE(Ltreemodel));
2088 /* icone de base dans la liste des fichiers */
2089 gtk_tree_store_append(GTK_TREE_STORE(Ltreemodel), &Liter, NULL);
2090 gtk_tree_store_set(GTK_TREE_STORE(Ltreemodel), &Liter, 0, TYPE_CD, 1, get_image("CDsmallIcon"), 2,
2091 !strcmp(Lname, "bodycddata") ? _("New CD") : _("New DVD"), 3, "", 4, "", 5, 0, -1);
2092 gtk_tree_view_columns_autosize(Lliste);
2093 switch_pbar_status(Lcontenance, *Ldatamaxsize, *Ldatasize, PB_UPDATE_DATA);
2094 }
2095
2096 g_free(Lname);
2097 }
2098
2099 /* lorsque l'on coche/decoche "continuer un cd multi session" */
change_datamulti(GtkWidget * Amulti,gpointer Adata)2100 void change_datamulti(GtkWidget *Amulti, gpointer Adata)
2101 {
2102 Tgrave *Lg = (Tgrave *)Adata;
2103 gboolean Lact = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Amulti));
2104 GtkSpinButton *Lspin = GTK_SPIN_BUTTON(sc_grave_get_widget(Lg, "nbrcddata"));
2105
2106 if (Lact) gtk_spin_button_set_value(Lspin, 1);
2107 gtk_widget_set_sensitive(GTK_WIDGET(Lspin), ! Lact);
2108 }
2109
2110 /* select items begining with key user has pressed */
callbacks_try_to_select(guint Akey,GtkTreeView * Aliste,Tgrave * Ag)2111 gboolean callbacks_try_to_select(guint Akey, GtkTreeView *Aliste, Tgrave *Ag)
2112 {
2113 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(GTK_TREE_VIEW(Aliste));
2114 GtkTreePath *Lpath = NULL;
2115 gchar *Lname;
2116 GtkTreeIter Liter;
2117 gboolean Ltrouve = FALSE;
2118 gboolean Lfirstiteration = TRUE;
2119 gboolean Lskip = FALSE;
2120
2121 gtk_tree_view_get_cursor(Aliste, &Lpath, NULL);
2122 if (!Lpath) return FALSE;
2123
2124 while (1) {
2125 while (1) {
2126 if (Lskip == FALSE) {
2127 gtk_tree_path_next(Lpath);
2128 } else {
2129 Lskip = FALSE;
2130 }
2131 if (!gtk_tree_model_get_iter(Ltreemodel, &Liter, Lpath)) break;
2132
2133 gtk_tree_model_get(Ltreemodel, &Liter, 2, &Lname, -1);
2134 if (!Lname) continue;
2135
2136 if (*(tools_next_no_char(Lname, (gchar ) GDK_space)) == Akey) {
2137 Ltrouve = TRUE;
2138 break;
2139 }
2140 }
2141
2142 if (Lfirstiteration == FALSE || Ltrouve == TRUE) {
2143 break;
2144 } else {
2145 Lfirstiteration = FALSE;
2146 while (gtk_tree_path_prev(Lpath)) ;
2147 Lskip = TRUE;
2148 }
2149 }
2150
2151 if (Ltrouve) {
2152 gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(Aliste), Lpath, NULL, FALSE, 0, 0);
2153 gtk_tree_view_set_cursor(GTK_TREE_VIEW(Aliste), Lpath, NULL, TRUE);
2154 }
2155
2156 gtk_tree_path_free(Lpath);
2157
2158 return Ltrouve;
2159 }
2160
2161 /* gestion des tris */
callbacks_data_asksort(GtkWidget * Abtn,gpointer Adata)2162 void callbacks_data_asksort(GtkWidget *Abtn, gpointer Adata)
2163 {
2164 Tgrave *Lg = (Tgrave *)Adata;
2165 GtkTreeView *Lliste = GTK_TREE_VIEW(sc_grave_get_data(Lg, "_current_list"));
2166 GtkTreeModel *Ltreemodel = gtk_tree_view_get_model(GTK_TREE_VIEW(Lliste));
2167 GtkTreeSortable *Lsort = NULL;
2168 /* gint Lcolid;
2169 GtkSortType Lorder;*/
2170 const gchar *Lname;
2171
2172 if (!GTK_IS_WIDGET(Abtn) || !GTK_IS_WIDGET(Lliste)) return;
2173 Lsort = GTK_TREE_SORTABLE(Ltreemodel);
2174
2175 if ((!(Lname = gtk_widget_get_name(Abtn))) || strlen(Lname)<10) return;
2176
2177 /* if (!gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(Lmodel), &Lcolid, &Lorder)) return;*/
2178 if (strstr(Lname, "_name")) {
2179 gtk_tree_sortable_set_sort_column_id(Lsort, 2, GTK_SORT_ASCENDING);
2180 } else if (strstr(Lname, "_size")) {
2181 gtk_tree_sortable_set_sort_column_id(Lsort, 3, GTK_SORT_ASCENDING);
2182 } else {
2183 gtk_tree_sortable_set_sort_column_id(Lsort, 0, GTK_SORT_ASCENDING);
2184 }
2185
2186 }
2187
2188 /* definir/enlever l'image de boot */
2189 #if 0
2190 void gtk_def_imageboot(GtkWidget *Abtn, gpointer Adata)
2191 {
2192 Tgrave *Lg = (Tgrave *)Adata;
2193 GtkTreeView *Lliste = GTK_TREE_VIEW(g_hash_table_lookup(Lg, "LISTEDATA"));
2194 GtkTreeModel *Ltreemodel;
2195 GtkTreeSelection *Lselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(Lliste));
2196 GtkTreeIter *Liter = g_hash_table_lookup(Lg, "file_imageboot");
2197 GtkTreeIter Lnewiter;
2198
2199 if (!gtk_tree_selection_get_selected(Lselection, &Ltreemodel, &Lnewiter)) return;
2200
2201 if (Liter) {
2202 gtk_tree_store_set(GTK_TREE_STORE(Ltreemodel), Liter, 1, GFileIcone, -1);
2203 gtk_tree_iter_free(Liter);
2204 }
2205
2206 gtk_tree_store_set(GTK_TREE_STORE(Ltreemodel), &Lnewiter, 0, TYPE_IMAGEBOOT, 1, GFileImage, -1);
2207
2208 g_hash_table_replace(Lg, "file_imageboot", gtk_tree_iter_copy(&Lnewiter));
2209 }
2210 #endif
2211
2212 /*
2213 * vim:et:ts=8:sts=2:sw=2
2214 */
2215