← Back to branch summary

~mfisch/brasero/update-to-3.8.0

« back to all changes in this revision

Viewing changes to src/brasero-image-option-dialog.c

  • Committer: Bazaar Package Importer
  • Author(s): Pedro Fragoso
  • Date: 2008-11-18 11:30:50 UTC
  • mto: (1.4.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: james.westby@ubuntu.com-20081118113050-yhrskmatlel0gzfm
Tags: upstream-0.8.3
Import upstream version 0.8.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/brasero-image-option-dialog.c
41
41
 
42
42
#include <gconf/gconf-client.h>
43
43
 
 
44
#include "burn-basics.h"
 
45
#include "burn-drive.h"
 
46
 
44
47
#include "brasero-utils.h"
45
 
#include "burn-basics.h"
46
 
#include "burn-plugin-manager.h"
47
48
#include "brasero-image-option-dialog.h"
48
 
#include "brasero-image-type-chooser.h"
49
 
#include "brasero-dest-selection.h"
50
 
#include "burn-drive.h"
51
 
#include "brasero-io.h"
 
49
#include "brasero-src-image.h"
 
50
#include "brasero-burn-options.h"
52
51
 
53
 
#define BRASERO_KEY_ISO_DIRECTORY               "/apps/brasero/display/iso_folder"
54
 
G_DEFINE_TYPE (BraseroImageOptionDialog, brasero_image_option_dialog, GTK_TYPE_DIALOG);
 
52
G_DEFINE_TYPE (BraseroImageOptionDialog, brasero_image_option_dialog, BRASERO_TYPE_BURN_OPTIONS);
55
53
 
56
54
struct _BraseroImageOptionDialogPrivate {
57
 
        BraseroBurnSession *session;
58
 
        BraseroTrack *track;
59
 
 
60
 
        BraseroBurnCaps *caps;
61
 
 
62
 
        BraseroIO *io;
63
 
        BraseroIOJobBase *info_type;
64
 
 
65
 
        GtkWidget *selection;
66
 
        GtkWidget *format;
67
55
        GtkWidget *file;
68
 
        GtkWidget *button;
69
56
};
70
57
typedef struct _BraseroImageOptionDialogPrivate BraseroImageOptionDialogPrivate;
71
58
 
73
60
 
74
61
static GtkDialogClass *parent_class = NULL;
75
62
 
76
 
static const gchar *mimes [] = { "application/x-cd-image",
77
 
                                 "application/x-cue",
78
 
                                 "application/x-toc",
79
 
                                 "application/x-cdrdao-toc" };
80
 
 
81
 
static void
82
 
brasero_image_option_dialog_set_track (BraseroImageOptionDialog *dialog,
83
 
                                       BraseroImageFormat format,
84
 
                                       const gchar *image,
85
 
                                       const gchar *toc)
86
 
{
87
 
        BraseroImageOptionDialogPrivate *priv;
88
 
 
89
 
        priv = BRASERO_IMAGE_OPTION_DIALOG_PRIVATE (dialog);
90
 
 
91
 
        /* add a track every time to send a signal */
92
 
        if (priv->track) {
93
 
                gchar *uri = NULL;
94
 
                BraseroTrackType type = { 0, };
95
 
 
96
 
                /* make sure something actually changed */
97
 
                brasero_track_get_type (priv->track, &type);
98
 
 
99
 
                if (image)
100
 
                        uri = brasero_track_get_image_source (priv->track, TRUE);
101
 
                else if (toc)
102
 
                        uri = brasero_track_get_toc_source (priv->track, TRUE);
103
 
 
104
 
                if (!toc && !image && !uri)
105
 
                        return;
106
 
 
107
 
                if((format == type.subtype.img_format)
108
 
                &&  uri && (image || toc)
109
 
                && !strcmp (uri, image?image:toc)) {
110
 
                        g_free (uri);
111
 
                        return;
112
 
                }
113
 
 
114
 
                g_free (uri);
115
 
 
116
 
                brasero_burn_session_clear_current_track (priv->session);
117
 
                brasero_track_unref (priv->track);
118
 
        }
119
 
 
120
 
        /* set image type before adding so that signal has the right type */
121
 
        priv->track = brasero_track_new (BRASERO_TRACK_TYPE_IMAGE);
122
 
        brasero_track_set_image_source (priv->track,
123
 
                                        image,
124
 
                                        toc,
125
 
                                        format);
126
 
        brasero_burn_session_add_track (priv->session, priv->track);
127
 
}
128
 
 
129
 
static void
130
 
brasero_image_option_dialog_image_info_cb (GObject *object,
131
 
                                           GError *error,
132
 
                                           const gchar *uri,
133
 
                                           GFileInfo *info,
134
 
                                           gpointer null_data)
135
 
{
136
 
        BraseroImageOptionDialog *dialog = BRASERO_IMAGE_OPTION_DIALOG (object);
137
 
        BraseroImageOptionDialogPrivate *priv;
138
 
 
139
 
        priv = BRASERO_IMAGE_OPTION_DIALOG_PRIVATE (dialog);
140
 
 
141
 
        if (error) {
142
 
                brasero_image_option_dialog_set_track (dialog,
143
 
                                                       BRASERO_IMAGE_FORMAT_NONE,
144
 
                                                       NULL,
145
 
                                                       NULL);
146
 
                return;
147
 
        }
148
 
 
149
 
        if (!strcmp (g_file_info_get_content_type (info), "application/x-toc")
150
 
        ||  !strcmp (g_file_info_get_content_type (info), "application/x-cdrdao-toc")
151
 
        ||  !strcmp (g_file_info_get_content_type (info), "application/x-cue")) {
152
 
                BraseroImageFormat format;
153
 
                gchar *path;
154
 
 
155
 
                path = g_filename_from_uri (uri, NULL, NULL);
156
 
                format = brasero_image_format_identify_cuesheet (path);
157
 
                g_free (path);
158
 
 
159
 
                if (format != BRASERO_IMAGE_FORMAT_NONE)
160
 
                        brasero_image_option_dialog_set_track (dialog,
161
 
                                                               format,
162
 
                                                               NULL,
163
 
                                                               uri);
164
 
                else if (g_str_has_suffix (path, ".toc"))
165
 
                        brasero_image_option_dialog_set_track (dialog,
166
 
                                                               BRASERO_IMAGE_FORMAT_CLONE,
167
 
                                                               NULL,
168
 
                                                               uri);
169
 
                else
170
 
                        brasero_image_option_dialog_set_track (dialog,
171
 
                                                               BRASERO_IMAGE_FORMAT_NONE,
172
 
                                                               NULL,
173
 
                                                               uri);
174
 
        }
175
 
        else if (!strcmp (g_file_info_get_content_type (info), "application/octet-stream")) {
176
 
                /* that could be an image, so here is the deal:
177
 
                 * if we can find the type through the extension, fine.
178
 
                 * if not default to CLONE */
179
 
                if (g_str_has_suffix (uri, ".bin"))
180
 
                        brasero_image_option_dialog_set_track (dialog,
181
 
                                                               BRASERO_IMAGE_FORMAT_CDRDAO,
182
 
                                                               uri,
183
 
                                                               NULL);
184
 
                else if (g_str_has_suffix (uri, ".raw"))
185
 
                        brasero_image_option_dialog_set_track (dialog,
186
 
                                                               BRASERO_IMAGE_FORMAT_CLONE,
187
 
                                                               uri,
188
 
                                                               NULL);
189
 
                else
190
 
                        brasero_image_option_dialog_set_track (dialog,
191
 
                                                               BRASERO_IMAGE_FORMAT_BIN,
192
 
                                                               uri,
193
 
                                                               NULL);
194
 
        }
195
 
        else if (!strcmp (g_file_info_get_content_type (info), "application/x-cd-image"))
196
 
                brasero_image_option_dialog_set_track (dialog,
197
 
                                                       BRASERO_IMAGE_FORMAT_BIN,
198
 
                                                       uri,
199
 
                                                       NULL);
200
 
        else
201
 
                brasero_image_option_dialog_set_track (dialog,
202
 
                                                       BRASERO_IMAGE_FORMAT_NONE,
203
 
                                                       NULL,
204
 
                                                       uri);
205
 
}
206
 
 
207
 
static void
208
 
brasero_image_option_dialog_get_format (BraseroImageOptionDialog *dialog,
209
 
                                        gchar *uri)
210
 
{
211
 
        BraseroImageOptionDialogPrivate *priv;
212
 
 
213
 
        priv = BRASERO_IMAGE_OPTION_DIALOG_PRIVATE (dialog);
214
 
 
215
 
        if (!uri) {
216
 
                brasero_image_option_dialog_set_track (dialog,
217
 
                                                       BRASERO_IMAGE_FORMAT_NONE,
218
 
                                                       NULL,
219
 
                                                       NULL);
220
 
                return;
221
 
        }
222
 
 
223
 
        if (!priv->io)
224
 
                priv->io = brasero_io_get_default ();
225
 
 
226
 
        if (!priv->info_type)
227
 
                priv->info_type = brasero_io_register (G_OBJECT (dialog),
228
 
                                                       brasero_image_option_dialog_image_info_cb,
229
 
                                                       NULL,
230
 
                                                       NULL);
231
 
 
232
 
        brasero_io_get_file_info (priv->io,
233
 
                                  uri,
234
 
                                  priv->info_type,
235
 
                                  BRASERO_IO_INFO_MIME,
236
 
                                  NULL);
237
 
}
238
 
 
239
 
static void
240
 
brasero_image_option_dialog_changed (BraseroImageOptionDialog *dialog)
241
 
{
242
 
        gchar *uri;
243
 
        BraseroImageFormat format;
244
 
        BraseroImageOptionDialogPrivate *priv;
245
 
 
246
 
        priv = BRASERO_IMAGE_OPTION_DIALOG_PRIVATE (dialog);
247
 
 
248
 
        uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (priv->file));
249
 
        brasero_image_type_chooser_get_format (BRASERO_IMAGE_TYPE_CHOOSER (priv->format), &format);
250
 
 
251
 
        switch (format) {
252
 
        case BRASERO_IMAGE_FORMAT_NONE:
253
 
                brasero_image_option_dialog_get_format (dialog, uri);
254
 
                break;
255
 
        case BRASERO_IMAGE_FORMAT_BIN:
256
 
                brasero_image_option_dialog_set_track (dialog,
257
 
                                                       format,
258
 
                                                       uri,
259
 
                                                       NULL);
260
 
                break;
261
 
        case BRASERO_IMAGE_FORMAT_CUE:
262
 
                brasero_image_option_dialog_set_track (dialog,
263
 
                                                       format,
264
 
                                                       NULL,
265
 
                                                       uri);
266
 
                break;
267
 
        case BRASERO_IMAGE_FORMAT_CDRDAO:
268
 
                brasero_image_option_dialog_set_track (dialog,
269
 
                                                       format,
270
 
                                                       NULL,
271
 
                                                       uri);
272
 
                break;
273
 
        case BRASERO_IMAGE_FORMAT_CLONE:
274
 
                brasero_image_option_dialog_set_track (dialog,
275
 
                                                       format,
276
 
                                                       NULL,
277
 
                                                       uri);
278
 
                break;
279
 
        default:
280
 
                break;
281
 
        }
282
 
        g_free (uri);   
283
 
}
284
 
 
285
 
static void
286
 
brasero_image_option_dialog_format_changed (BraseroImageTypeChooser *format,
287
 
                                            BraseroImageOptionDialog *dialog)
288
 
{
289
 
        brasero_image_option_dialog_changed (dialog);
290
 
}
291
 
 
292
 
static void
293
 
brasero_image_option_dialog_file_changed (GtkFileChooser *chooser,
294
 
                                          BraseroImageOptionDialog *dialog)
295
 
{
296
 
        brasero_image_option_dialog_changed (dialog);
297
 
}
298
 
 
299
 
static void
300
 
brasero_image_option_dialog_set_formats (BraseroImageOptionDialog *dialog)
301
 
{
302
 
        BraseroImageOptionDialogPrivate *priv;
303
 
        BraseroImageFormat formats;
304
 
        BraseroImageFormat format;
305
 
        BraseroTrackType output;
306
 
        BraseroTrackType input;
307
 
        BraseroMedium *medium;
308
 
        BraseroDrive *drive;
309
 
 
310
 
        priv = BRASERO_IMAGE_OPTION_DIALOG_PRIVATE (dialog);
311
 
 
312
 
        if (!priv->format)
313
 
                return;
314
 
 
315
 
        /* get the available image types */
316
 
        output.type = BRASERO_TRACK_TYPE_DISC;
317
 
        drive = brasero_burn_session_get_burner (priv->session);
318
 
        medium = brasero_drive_get_medium (drive);
319
 
        output.subtype.media = brasero_medium_get_status (medium);
320
 
 
321
 
        input.type = BRASERO_TRACK_TYPE_IMAGE;
322
 
        formats = BRASERO_IMAGE_FORMAT_NONE;
323
 
        format = BRASERO_IMAGE_FORMAT_CDRDAO;
324
 
 
325
 
        for (; format != BRASERO_IMAGE_FORMAT_NONE; format >>= 1) {
326
 
                BraseroBurnResult result;
327
 
 
328
 
                input.subtype.img_format = format;
329
 
                result = brasero_burn_caps_is_input_supported (priv->caps,
330
 
                                                               priv->session,
331
 
                                                               &input,
332
 
                                                               FALSE);
333
 
                if (result == BRASERO_BURN_OK)
334
 
                        formats |= format;
335
 
        }
336
 
 
337
 
        brasero_image_type_chooser_set_formats (BRASERO_IMAGE_TYPE_CHOOSER (priv->format),
338
 
                                                formats);
339
 
}
340
 
 
341
63
void
342
64
brasero_image_option_dialog_set_image_uri (BraseroImageOptionDialog *dialog,
343
65
                                           const gchar *uri)
346
68
 
347
69
        priv = BRASERO_IMAGE_OPTION_DIALOG_PRIVATE (dialog);
348
70
 
349
 
        brasero_image_option_dialog_set_formats (dialog);
350
 
        if (uri)
351
 
                gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (priv->file), uri);
352
 
        else
353
 
                brasero_image_option_dialog_set_track (dialog,
354
 
                                                       BRASERO_IMAGE_FORMAT_NONE,
355
 
                                                       NULL,
356
 
                                                       NULL);
357
 
}
358
 
 
359
 
static void
360
 
brasero_image_option_dialog_image_info_error (BraseroImageOptionDialog *dialog)
361
 
{
362
 
        GtkWidget *message;
363
 
        GtkWidget *toplevel;
364
 
 
365
 
        toplevel = gtk_widget_get_toplevel (GTK_WIDGET (dialog));
366
 
        message = gtk_message_dialog_new (GTK_WINDOW (toplevel),
367
 
                                          GTK_DIALOG_DESTROY_WITH_PARENT |
368
 
                                          GTK_DIALOG_MODAL,
369
 
                                          GTK_MESSAGE_ERROR,
370
 
                                          GTK_BUTTONS_CLOSE,
371
 
                                          _("This image can't be burnt:"));
372
 
 
373
 
        gtk_window_set_title (GTK_WINDOW (message), _("Invalid Image"));
374
 
 
375
 
        gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message),
376
 
                                                  _("it doesn't appear to be a valid image or a valid cue file."));
377
 
 
378
 
        gtk_dialog_run (GTK_DIALOG (message));
379
 
        gtk_widget_destroy (message);
380
 
}
381
 
 
382
 
static void
383
 
brasero_image_option_dialog_image_empty (BraseroImageOptionDialog *dialog)
384
 
{
385
 
        GtkWidget *message;
386
 
        GtkWidget *toplevel;
387
 
 
388
 
        toplevel = gtk_widget_get_toplevel (GTK_WIDGET (dialog));
389
 
        message = gtk_message_dialog_new (GTK_WINDOW (toplevel),
390
 
                                          GTK_DIALOG_DESTROY_WITH_PARENT |
391
 
                                          GTK_DIALOG_MODAL,
392
 
                                          GTK_MESSAGE_ERROR,
393
 
                                          GTK_BUTTONS_CLOSE,
394
 
                                          _("There is no specified image:"));
395
 
 
396
 
        gtk_window_set_title (GTK_WINDOW (message), _("No Image"));
397
 
 
398
 
        gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message),
399
 
                                                  _("Please, choose an image and retry."));
400
 
 
401
 
        gtk_dialog_run (GTK_DIALOG (message));
402
 
        gtk_widget_destroy (message);
403
 
}
404
 
 
405
 
BraseroBurnSession *
406
 
brasero_image_option_dialog_get_session (BraseroImageOptionDialog *dialog)
407
 
{
408
 
        gchar *uri = NULL;
409
 
        gchar *groups [] = { "brasero",
410
 
                              NULL };
411
 
        GtkRecentData recent_data = { NULL,
412
 
                                      NULL,
413
 
                                      NULL,
414
 
                                      "brasero",
415
 
                                      "brasero -p %u",
416
 
                                      groups,
417
 
                                      FALSE };
418
 
        BraseroImageOptionDialogPrivate *priv;
419
 
        BraseroTrackType type;
420
 
        gchar *image;
421
 
 
422
 
        priv = BRASERO_IMAGE_OPTION_DIALOG_PRIVATE (dialog);
423
 
 
424
 
        /* check that all could be set for the session */
425
 
        image = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (priv->file));
426
 
        if (!image) {
427
 
                brasero_image_option_dialog_image_empty (dialog);
428
 
                return NULL;
429
 
        }
430
 
        g_free (image);
431
 
 
432
 
        brasero_track_get_type (priv->track, &type);
433
 
        if (type.type == BRASERO_TRACK_TYPE_NONE
434
 
        ||  type.subtype.img_format == BRASERO_IMAGE_FORMAT_NONE) {
435
 
                brasero_image_option_dialog_image_info_error (dialog);
436
 
                return NULL;
437
 
        }
438
 
 
439
 
        /* Add it to recent file manager */
440
 
        switch (type.subtype.img_format) {
441
 
        case BRASERO_IMAGE_FORMAT_BIN:
442
 
                recent_data.mime_type = (gchar *) mimes [0];
443
 
                uri = brasero_track_get_image_source (priv->track, TRUE);
444
 
                break;
445
 
 
446
 
        case BRASERO_IMAGE_FORMAT_CUE:
447
 
                recent_data.mime_type = (gchar *) mimes [1];
448
 
                uri = brasero_track_get_toc_source (priv->track, TRUE);
449
 
                break;
450
 
 
451
 
        case BRASERO_IMAGE_FORMAT_CLONE:
452
 
                recent_data.mime_type = (gchar *) mimes [2];
453
 
                uri = brasero_track_get_toc_source (priv->track, TRUE);
454
 
                break;
455
 
 
456
 
        case BRASERO_IMAGE_FORMAT_CDRDAO:
457
 
                recent_data.mime_type = (gchar *) mimes [3];
458
 
                uri = brasero_track_get_toc_source (priv->track, TRUE);
459
 
                break;
460
 
 
461
 
        default:
462
 
                break;
463
 
        }
464
 
 
465
 
        if (uri) {
466
 
                GtkRecentManager *recent;
467
 
 
468
 
                recent = gtk_recent_manager_get_default ();
469
 
                gtk_recent_manager_add_full (recent,
470
 
                                             uri,
471
 
                                             &recent_data);
472
 
                g_free (uri);
473
 
        }
474
 
 
475
 
        g_object_ref (priv->session);
476
 
        return priv->session;
477
 
}
478
 
 
479
 
static void
480
 
brasero_image_option_dialog_valid_media_cb (BraseroDestSelection *selection,
481
 
                                            gboolean valid,
482
 
                                            BraseroImageOptionDialog *self)
483
 
{
484
 
        BraseroImageOptionDialogPrivate *priv;
485
 
 
486
 
        priv = BRASERO_IMAGE_OPTION_DIALOG_PRIVATE (self);
487
 
 
488
 
        brasero_image_option_dialog_set_formats (self);
489
 
        gtk_widget_set_sensitive (priv->button, valid);
490
 
}
491
 
 
492
 
static void     
493
 
brasero_image_option_dialog_file_chooser_destroy (GtkWidget *file,
494
 
                                                  BraseroImageOptionDialog *self)
495
 
{
496
 
        BraseroImageOptionDialogPrivate *priv;
497
 
        GConfClient *client;
498
 
        gchar *uri;
499
 
 
500
 
        priv = BRASERO_IMAGE_OPTION_DIALOG_PRIVATE (self);
501
 
 
502
 
        uri = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (priv->file));
503
 
        if (uri) {
504
 
                client = gconf_client_get_default ();
505
 
                gconf_client_set_string (client, BRASERO_KEY_ISO_DIRECTORY, uri, NULL);
506
 
                g_object_unref (client);
507
 
                g_free (uri);
508
 
        }
 
71
        brasero_src_image_set_uri (BRASERO_SRC_IMAGE (priv->file), uri);
509
72
}
510
73
 
511
74
static void
512
75
brasero_image_option_dialog_init (BraseroImageOptionDialog *obj)
513
76
{
514
 
        gchar *uri;
515
 
        GtkWidget *label;
516
 
        GtkWidget *button;
517
 
        GtkWidget *options;
518
 
        GConfClient *client;
519
 
        GtkWidget *box, *box1;
520
 
        GtkFileFilter *filter;
 
77
        gchar *string;
 
78
        BraseroBurnSession *session;
521
79
        BraseroImageOptionDialogPrivate *priv;
522
80
 
523
81
        priv = BRASERO_IMAGE_OPTION_DIALOG_PRIVATE (obj);
524
82
 
525
 
        gtk_dialog_set_has_separator (GTK_DIALOG (obj), FALSE);
526
 
 
527
 
        button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
528
 
        gtk_widget_show (button);
529
 
        gtk_dialog_add_action_widget (GTK_DIALOG (obj),
530
 
                                      button,
531
 
                                      GTK_RESPONSE_CANCEL);
532
 
 
533
 
        priv->button = brasero_utils_make_button (_("_Burn"),
534
 
                                                  NULL,
535
 
                                                  "media-optical-burn",
536
 
                                                  GTK_ICON_SIZE_BUTTON);
537
 
        gtk_widget_show (priv->button);
538
 
        gtk_dialog_add_action_widget (GTK_DIALOG (obj),
539
 
                                      priv->button,
540
 
                                      GTK_RESPONSE_OK);
541
 
 
542
 
        priv->caps = brasero_burn_caps_get_default ();
543
 
 
544
 
        priv->session = brasero_burn_session_new ();
545
 
        brasero_burn_session_add_flag (priv->session,
546
 
                                       BRASERO_BURN_FLAG_EJECT|
547
 
                                       BRASERO_BURN_FLAG_NOGRACE|
548
 
                                       BRASERO_BURN_FLAG_BURNPROOF|
549
 
                                       BRASERO_BURN_FLAG_CHECK_SIZE|
550
 
                                       BRASERO_BURN_FLAG_DONT_CLEAN_OUTPUT|
551
 
                                       BRASERO_BURN_FLAG_FAST_BLANK);
552
 
 
553
 
        /* first box */
554
 
        priv->selection = brasero_dest_selection_new (priv->session);
555
 
        g_signal_connect (priv->selection,
556
 
                          "valid-media",
557
 
                          G_CALLBACK (brasero_image_option_dialog_valid_media_cb),
558
 
                          obj);
559
 
 
560
 
        options = brasero_utils_pack_properties (_("<b>Select a disc to write to</b>"),
561
 
                                                 priv->selection,
562
 
                                                 NULL);
563
 
 
564
 
        gtk_widget_show (options);
565
 
        gtk_box_pack_start (GTK_BOX (GTK_DIALOG (obj)->vbox),
566
 
                            options,
567
 
                            FALSE,
568
 
                            FALSE,
569
 
                            6);
570
 
 
571
 
        brasero_drive_selection_set_type_shown (BRASERO_DRIVE_SELECTION (priv->selection),
572
 
                                                BRASERO_MEDIA_TYPE_WRITABLE);
 
83
        brasero_burn_options_set_type_shown (BRASERO_BURN_OPTIONS (obj),
 
84
                                             BRASERO_MEDIA_TYPE_WRITABLE);
573
85
 
574
86
        /* Image properties */
575
 
        box1 = gtk_table_new (2, 2, FALSE);
576
 
        gtk_table_set_col_spacings (GTK_TABLE (box1), 6);
577
 
        gtk_widget_show (box1);
578
 
 
579
 
        label = gtk_label_new (_("Path:"));
580
 
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
581
 
        gtk_table_attach (GTK_TABLE (box1),
582
 
                          label,
583
 
                          0,
584
 
                          1,
585
 
                          0,
586
 
                          1,
587
 
                          GTK_FILL,
588
 
                          GTK_FILL,
589
 
                          0,
590
 
                          0);
591
 
 
592
 
        priv->file = gtk_file_chooser_button_new (_("Open an image"), GTK_FILE_CHOOSER_ACTION_OPEN);
593
 
        gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (priv->file), FALSE);
594
 
 
595
 
        client = gconf_client_get_default ();
596
 
        uri = gconf_client_get_string (client, BRASERO_KEY_ISO_DIRECTORY, NULL);
597
 
        g_object_unref (client);
598
 
        if (uri) {
599
 
                if (!gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (priv->file), uri))
600
 
                        gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (priv->file), g_get_home_dir ());
601
 
 
602
 
                g_free (uri);
603
 
        }
604
 
        else
605
 
                gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (priv->file), g_get_home_dir ());
606
 
 
607
 
        g_signal_connect (priv->file,
608
 
                          "destroy",
609
 
                          G_CALLBACK (brasero_image_option_dialog_file_chooser_destroy),
610
 
                          obj);
611
 
 
612
 
        filter = gtk_file_filter_new ();
613
 
        gtk_file_filter_set_name (filter, _("All files"));
614
 
        gtk_file_filter_add_pattern (filter, "*");
615
 
        gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (priv->file), filter);
616
 
 
617
 
        filter = gtk_file_filter_new ();
618
 
        gtk_file_filter_set_name (filter, _("Image files only"));
619
 
        gtk_file_filter_add_mime_type (filter, mimes [0]);
620
 
        gtk_file_filter_add_mime_type (filter, mimes [1]);
621
 
        gtk_file_filter_add_mime_type (filter, mimes [2]);
622
 
        gtk_file_filter_add_mime_type (filter, mimes [3]);
623
 
        gtk_file_filter_add_mime_type (filter, "image/*");
624
 
        gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (priv->file), filter);
625
 
        gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (priv->file), filter);
626
 
 
627
 
        gtk_table_attach (GTK_TABLE (box1),
628
 
                          priv->file,
629
 
                          1,
630
 
                          2,
631
 
                          0,
632
 
                          1,
633
 
                          GTK_EXPAND|GTK_FILL,
634
 
                          GTK_EXPAND|GTK_FILL,
635
 
                          0,
636
 
                          0);
637
 
        g_signal_connect (priv->file,
638
 
                          "selection-changed",
639
 
                          G_CALLBACK (brasero_image_option_dialog_file_changed),
640
 
                          obj);
641
 
 
642
 
        label = gtk_label_new (_("Image type:"));
643
 
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
644
 
        gtk_widget_show (label);
645
 
        gtk_table_attach (GTK_TABLE (box1),
646
 
                          label,
647
 
                          0,
648
 
                          1,
649
 
                          1,
650
 
                          2,
651
 
                          GTK_FILL,
652
 
                          GTK_FILL,
653
 
                          0,
654
 
                          0);
655
 
 
656
 
        priv->format = brasero_image_type_chooser_new ();
657
 
        gtk_table_attach (GTK_TABLE (box1),
658
 
                          priv->format,
659
 
                          1,
660
 
                          2,
661
 
                          1,
662
 
                          2,
663
 
                          GTK_EXPAND|GTK_FILL,
664
 
                          GTK_EXPAND|GTK_FILL,
665
 
                          0,
666
 
                          0);
667
 
        g_signal_connect (priv->format,
668
 
                          "changed",
669
 
                          G_CALLBACK (brasero_image_option_dialog_format_changed),
670
 
                          obj);
671
 
 
672
 
        box = brasero_utils_pack_properties (_("<b>Image</b>"),
673
 
                                             box1,
674
 
                                             NULL);
675
 
 
676
 
        gtk_box_pack_end (GTK_BOX (GTK_DIALOG (obj)->vbox),
677
 
                          box,
678
 
                          TRUE,
679
 
                          FALSE,
680
 
                          6);
681
 
 
682
 
        gtk_widget_show_all (box);
683
 
        brasero_image_option_dialog_set_formats (obj);
 
87
        session = brasero_burn_options_get_session (BRASERO_BURN_OPTIONS (obj));
 
88
        priv->file = brasero_src_image_new (session);
 
89
        g_object_unref (session);
 
90
 
 
91
        gtk_widget_show (priv->file);
 
92
 
 
93
        /* pack everything */
 
94
        string = g_strdup_printf ("<b>%s</b>", _("Select an image to write"));
 
95
        brasero_burn_options_add_source (BRASERO_BURN_OPTIONS (obj), 
 
96
                                         string,
 
97
                                         priv->file,
 
98
                                         NULL);
 
99
        g_free (string);
684
100
}
685
101
 
686
102
static void
687
103
brasero_image_option_dialog_finalize (GObject *object)
688
104
{
689
 
        BraseroImageOptionDialogPrivate *priv;
690
 
 
691
 
        priv = BRASERO_IMAGE_OPTION_DIALOG_PRIVATE (object);
692
 
 
693
 
        if (priv->io) {
694
 
                brasero_io_cancel_by_base (priv->io, priv->info_type);
695
 
 
696
 
                g_free (priv->info_type);
697
 
                priv->info_type = NULL;
698
 
 
699
 
                g_object_unref (priv->io);
700
 
                priv->io = NULL;
701
 
        }
702
 
 
703
 
        if (priv->track) {
704
 
                brasero_track_unref (priv->track);
705
 
                priv->track = NULL;
706
 
        }
707
 
 
708
 
        if (priv->session) {
709
 
                g_object_unref (priv->session);
710
 
                priv->session = NULL;
711
 
        }
712
 
 
713
 
        if (priv->caps) {
714
 
                g_object_unref (priv->caps);
715
 
                priv->caps = NULL;
716
 
        }
717
 
 
718
105
        G_OBJECT_CLASS (parent_class)->finalize (object);
719
106
}
720
107