← Back to branch summary

~mfisch/brasero/update-to-3.8.0

« back to all changes in this revision

Viewing changes to libbrasero-burn/brasero-track-data.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Ancell
  • Date: 2009-06-03 10:36:30 UTC
  • mfrom: (1.1.23 upstream)
  • Revision ID: james.westby@ubuntu.com-20090603103630-2r72408gk45sc0ws
Tags: 2.27.2-0ubuntu1
https://launchpad.net/bugs/380850
https://launchpad.net/bugs/360671
* New upstream release (LP: #380850)
  - Split burning backend into a new library called libbrasero-burn
  - Split some utilities into a new library called libbrasero-utils
  - Use Brasero as a single instance application using libunique
  - Data spanning
  - Memleak fixes
  - Bug Fixes
  - String fixes
  - Use autogenerated Changelog via git
  - Translation Updates
  - Fixes (LP: #360671)
* Bump GTK+ requirement and add libunique requirement

Show diffs side-by-side

added added

removed removed

Lines of Context:
libbrasero-burn/brasero-track-data.c
 
1
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
 
2
/*
 
3
 * Libbrasero-burn
 
4
 * Copyright (C) Philippe Rouquier 2005-2009 <bonfire-app@wanadoo.fr>
 
5
 *
 
6
 * Libbrasero-burn 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 of the License, or
 
9
 * (at your option) any later version.
 
10
 *
 
11
 * The Libbrasero-burn authors hereby grant permission for non-GPL compatible
 
12
 * GStreamer plugins to be used and distributed together with GStreamer
 
13
 * and Libbrasero-burn. This permission is above and beyond the permissions granted
 
14
 * by the GPL license by which Libbrasero-burn is covered. If you modify this code
 
15
 * you may extend this exception to your version of the code, but you are not
 
16
 * obligated to do so. If you do not wish to do so, delete this exception
 
17
 * statement from your version.
 
18
 * 
 
19
 * Libbrasero-burn is distributed in the hope that it will be useful,
 
20
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
21
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
22
 * GNU Library General Public License for more details.
 
23
 * 
 
24
 * You should have received a copy of the GNU General Public License
 
25
 * along with this program; if not, write to:
 
26
 *      The Free Software Foundation, Inc.,
 
27
 *      51 Franklin Street, Fifth Floor
 
28
 *      Boston, MA  02110-1301, USA.
 
29
 */
 
30
 
 
31
#ifdef HAVE_CONFIG_H
 
32
#  include <config.h>
 
33
#endif
 
34
 
 
35
#include <glib.h>
 
36
#include <glib/gstdio.h>
 
37
#include <glib/gi18n-lib.h>
 
38
 
 
39
#include "brasero-track-data.h"
 
40
#include "burn-mkisofs-base.h"
 
41
 
 
42
typedef struct _BraseroTrackDataPrivate BraseroTrackDataPrivate;
 
43
struct _BraseroTrackDataPrivate
 
44
{
 
45
        BraseroImageFS fs_type;
 
46
        GSList *grafts;
 
47
        GSList *excluded;
 
48
 
 
49
        guint file_num;
 
50
        guint64 data_blocks;
 
51
};
 
52
 
 
53
#define BRASERO_TRACK_DATA_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), BRASERO_TYPE_TRACK_DATA, BraseroTrackDataPrivate))
 
54
 
 
55
G_DEFINE_TYPE (BraseroTrackData, brasero_track_data, BRASERO_TYPE_TRACK);
 
56
 
 
57
 
 
58
void
 
59
brasero_graft_point_free (BraseroGraftPt *graft)
 
60
{
 
61
        if (graft->uri)
 
62
                g_free (graft->uri);
 
63
 
 
64
        g_free (graft->path);
 
65
        g_free (graft);
 
66
}
 
67
 
 
68
BraseroGraftPt *
 
69
brasero_graft_point_copy (BraseroGraftPt *graft)
 
70
{
 
71
        BraseroGraftPt *newgraft;
 
72
 
 
73
        g_return_val_if_fail (graft != NULL, NULL);
 
74
 
 
75
        newgraft = g_new0 (BraseroGraftPt, 1);
 
76
        newgraft->path = g_strdup (graft->path);
 
77
        if (graft->uri)
 
78
                newgraft->uri = g_strdup (graft->uri);
 
79
 
 
80
        return newgraft;
 
81
}
 
82
 
 
83
BraseroBurnResult
 
84
brasero_track_data_set_source_real (BraseroTrackData *track,
 
85
                                    GSList *grafts,
 
86
                                    GSList *unreadable)
 
87
{
 
88
        BraseroTrackDataPrivate *priv;
 
89
 
 
90
        g_return_val_if_fail (BRASERO_IS_TRACK_DATA (track), BRASERO_BURN_NOT_SUPPORTED);
 
91
 
 
92
        priv = BRASERO_TRACK_DATA_PRIVATE (track);
 
93
 
 
94
        if (priv->grafts) {
 
95
                g_slist_foreach (priv->grafts, (GFunc) brasero_graft_point_free, NULL);
 
96
                g_slist_free (priv->grafts);
 
97
        }
 
98
 
 
99
        if (priv->excluded) {
 
100
                g_slist_foreach (priv->excluded, (GFunc) g_free, NULL);
 
101
                g_slist_free (priv->excluded);
 
102
        }
 
103
 
 
104
        priv->grafts = grafts;
 
105
        priv->excluded = unreadable;
 
106
        brasero_track_changed (BRASERO_TRACK (track));
 
107
 
 
108
        return BRASERO_BURN_OK;
 
109
}
 
110
 
 
111
BraseroBurnResult
 
112
brasero_track_data_set_source (BraseroTrackData *track,
 
113
                               GSList *grafts,
 
114
                               GSList *unreadable)
 
115
{
 
116
        BraseroTrackDataClass *klass;
 
117
 
 
118
        g_return_val_if_fail (BRASERO_IS_TRACK_DATA (track), BRASERO_BURN_ERR);
 
119
 
 
120
        klass = BRASERO_TRACK_DATA_GET_CLASS (track);
 
121
        return klass->set_source (track, grafts, unreadable);
 
122
}
 
123
 
 
124
static BraseroBurnResult
 
125
brasero_track_data_add_fs_real (BraseroTrackData *track,
 
126
                                BraseroImageFS fstype)
 
127
{
 
128
        BraseroTrackDataPrivate *priv;
 
129
 
 
130
        priv = BRASERO_TRACK_DATA_PRIVATE (track);
 
131
        priv->fs_type |= fstype;
 
132
        return BRASERO_BURN_OK;
 
133
}
 
134
 
 
135
BraseroBurnResult
 
136
brasero_track_data_add_fs (BraseroTrackData *track,
 
137
                           BraseroImageFS fstype)
 
138
{
 
139
        BraseroTrackDataClass *klass;
 
140
        BraseroImageFS fs_before;
 
141
        BraseroBurnResult result;
 
142
 
 
143
        g_return_val_if_fail (BRASERO_IS_TRACK_DATA (track), BRASERO_BURN_NOT_SUPPORTED);
 
144
 
 
145
        fs_before = brasero_track_data_get_fs (track);
 
146
        klass = BRASERO_TRACK_DATA_GET_CLASS (track);
 
147
        if (!klass->add_fs)
 
148
                return BRASERO_BURN_NOT_SUPPORTED;
 
149
 
 
150
        result = klass->add_fs (track, fstype);
 
151
        if (result != BRASERO_BURN_OK)
 
152
                return result;
 
153
 
 
154
        if (fs_before != brasero_track_data_get_fs (track))
 
155
                brasero_track_changed (BRASERO_TRACK (track));
 
156
 
 
157
        return BRASERO_BURN_OK;
 
158
}
 
159
 
 
160
static BraseroBurnResult
 
161
brasero_track_data_rm_fs_real (BraseroTrackData *track,
 
162
                               BraseroImageFS fstype)
 
163
{
 
164
        BraseroTrackDataPrivate *priv;
 
165
 
 
166
        priv = BRASERO_TRACK_DATA_PRIVATE (track);
 
167
        priv->fs_type &= ~(fstype);
 
168
        return BRASERO_BURN_OK;
 
169
}
 
170
 
 
171
BraseroBurnResult
 
172
brasero_track_data_rm_fs (BraseroTrackData *track,
 
173
                          BraseroImageFS fstype)
 
174
{
 
175
        BraseroTrackDataClass *klass;
 
176
        BraseroImageFS fs_before;
 
177
        BraseroBurnResult result;
 
178
 
 
179
        g_return_val_if_fail (BRASERO_IS_TRACK_DATA (track), BRASERO_BURN_NOT_SUPPORTED);
 
180
 
 
181
        fs_before = brasero_track_data_get_fs (track);
 
182
        klass = BRASERO_TRACK_DATA_GET_CLASS (track);
 
183
        if (!klass->rm_fs);
 
184
                return BRASERO_BURN_NOT_SUPPORTED;
 
185
 
 
186
        result = klass->rm_fs (track, fstype);
 
187
        if (result != BRASERO_BURN_OK)
 
188
                return result;
 
189
 
 
190
        if (fs_before != brasero_track_data_get_fs (track))
 
191
                brasero_track_changed (BRASERO_TRACK (track));
 
192
 
 
193
        return BRASERO_BURN_OK;
 
194
}
 
195
 
 
196
BraseroBurnResult
 
197
brasero_track_data_set_data_blocks (BraseroTrackData *track,
 
198
                                    goffset blocks)
 
199
{
 
200
        BraseroTrackDataPrivate *priv;
 
201
 
 
202
        g_return_val_if_fail (BRASERO_IS_TRACK_DATA (track), BRASERO_BURN_NOT_SUPPORTED);
 
203
 
 
204
        priv = BRASERO_TRACK_DATA_PRIVATE (track);
 
205
        priv->data_blocks = blocks;
 
206
 
 
207
        return BRASERO_BURN_OK;
 
208
}
 
209
 
 
210
BraseroBurnResult
 
211
brasero_track_data_set_file_num (BraseroTrackData *track,
 
212
                                 guint64 number)
 
213
{
 
214
        BraseroTrackDataPrivate *priv;
 
215
 
 
216
        g_return_val_if_fail (BRASERO_IS_TRACK_DATA (track), BRASERO_BURN_NOT_SUPPORTED);
 
217
 
 
218
        priv = BRASERO_TRACK_DATA_PRIVATE (track);
 
219
 
 
220
        priv->file_num = number;
 
221
        return BRASERO_BURN_OK;
 
222
}
 
223
 
 
224
BraseroImageFS
 
225
brasero_track_data_get_fs (BraseroTrackData *track)
 
226
{
 
227
        BraseroTrackDataClass *klass;
 
228
 
 
229
        g_return_val_if_fail (BRASERO_IS_TRACK_DATA (track), BRASERO_IMAGE_FS_NONE);
 
230
 
 
231
        klass = BRASERO_TRACK_DATA_GET_CLASS (track);
 
232
        return klass->get_fs (track);
 
233
}
 
234
 
 
235
BraseroImageFS
 
236
brasero_track_data_get_fs_real (BraseroTrackData *track)
 
237
{
 
238
        BraseroTrackDataPrivate *priv;
 
239
 
 
240
        priv = BRASERO_TRACK_DATA_PRIVATE (track);
 
241
        return priv->fs_type;
 
242
}
 
243
 
 
244
GSList *
 
245
brasero_track_data_get_grafts (BraseroTrackData *track)
 
246
{
 
247
        BraseroTrackDataClass *klass;
 
248
 
 
249
        g_return_val_if_fail (BRASERO_IS_TRACK_DATA (track), NULL);
 
250
 
 
251
        klass = BRASERO_TRACK_DATA_GET_CLASS (track);
 
252
        return klass->get_grafts (track);
 
253
}
 
254
 
 
255
static GSList *
 
256
brasero_track_data_get_grafts_real (BraseroTrackData *track)
 
257
{
 
258
        BraseroTrackDataPrivate *priv;
 
259
 
 
260
        priv = BRASERO_TRACK_DATA_PRIVATE (track);
 
261
        return priv->grafts;
 
262
}
 
263
 
 
264
GSList *
 
265
brasero_track_data_get_excluded (BraseroTrackData *track,
 
266
                                 gboolean copy)
 
267
{
 
268
        BraseroTrackDataClass *klass;
 
269
        GSList *retval = NULL;
 
270
        GSList *excluded;
 
271
        GSList *iter;
 
272
 
 
273
        g_return_val_if_fail (BRASERO_IS_TRACK_DATA (track), NULL);
 
274
 
 
275
        klass = BRASERO_TRACK_DATA_GET_CLASS (track);
 
276
        excluded = klass->get_excluded (track);
 
277
        if (!copy)
 
278
                return excluded;
 
279
 
 
280
        for (iter = excluded; iter; iter = iter->next) {
 
281
                gchar *uri;
 
282
 
 
283
                uri = iter->data;
 
284
                retval = g_slist_prepend (retval, g_strdup (uri));
 
285
        }
 
286
 
 
287
        return retval;
 
288
}
 
289
 
 
290
static GSList *
 
291
brasero_track_data_get_excluded_real (BraseroTrackData *track)
 
292
{
 
293
        BraseroTrackDataPrivate *priv;
 
294
 
 
295
        priv = BRASERO_TRACK_DATA_PRIVATE (track);
 
296
        return priv->excluded;
 
297
}
 
298
 
 
299
BraseroBurnResult
 
300
brasero_track_data_get_paths (BraseroTrackData *track,
 
301
                              gboolean use_joliet,
 
302
                              const gchar *grafts_path,
 
303
                              const gchar *excluded_path,
 
304
                              const gchar *emptydir,
 
305
                              const gchar *videodir,
 
306
                              GError **error)
 
307
{
 
308
        GSList *grafts;
 
309
        GSList *excluded;
 
310
        BraseroBurnResult result;
 
311
        BraseroTrackDataClass *klass;
 
312
 
 
313
        g_return_val_if_fail (BRASERO_IS_TRACK_DATA (track), BRASERO_BURN_NOT_SUPPORTED);
 
314
 
 
315
        klass = BRASERO_TRACK_DATA_GET_CLASS (track);
 
316
        grafts = klass->get_grafts (track);
 
317
        excluded = klass->get_excluded (track);
 
318
 
 
319
        result = brasero_mkisofs_base_write_to_files (grafts,
 
320
                                                      excluded,
 
321
                                                      use_joliet,
 
322
                                                      emptydir,
 
323
                                                      videodir,
 
324
                                                      grafts_path,
 
325
                                                      excluded_path,
 
326
                                                      error);
 
327
        return result;
 
328
}
 
329
 
 
330
BraseroBurnResult
 
331
brasero_track_data_get_file_num (BraseroTrackData *track,
 
332
                                 guint64 *file_num)
 
333
{
 
334
        BraseroTrackDataClass *klass;
 
335
 
 
336
        g_return_val_if_fail (BRASERO_IS_TRACK_DATA (track), 0);
 
337
 
 
338
        klass = BRASERO_TRACK_DATA_GET_CLASS (track);
 
339
        if (file_num)
 
340
                *file_num = klass->get_file_num (track);
 
341
 
 
342
        return BRASERO_BURN_OK;
 
343
}
 
344
 
 
345
static guint64
 
346
brasero_track_data_get_file_num_real (BraseroTrackData *track)
 
347
{
 
348
        BraseroTrackDataPrivate *priv;
 
349
 
 
350
        priv = BRASERO_TRACK_DATA_PRIVATE (track);
 
351
        return priv->file_num;
 
352
}
 
353
 
 
354
static BraseroBurnResult
 
355
brasero_track_data_get_size (BraseroTrack *track,
 
356
                             goffset *blocks,
 
357
                             goffset *block_size)
 
358
{
 
359
        BraseroTrackDataPrivate *priv;
 
360
 
 
361
        priv = BRASERO_TRACK_DATA_PRIVATE (track);
 
362
 
 
363
        if (*block_size)
 
364
                *block_size = 2048;
 
365
 
 
366
        if (*blocks)
 
367
                *blocks = priv->data_blocks;
 
368
 
 
369
        return BRASERO_BURN_OK;
 
370
}
 
371
 
 
372
static BraseroTrackDataType
 
373
brasero_track_data_get_track_type (BraseroTrack *track,
 
374
                                   BraseroTrackType *type)
 
375
{
 
376
        BraseroTrackDataPrivate *priv;
 
377
 
 
378
        priv = BRASERO_TRACK_DATA_PRIVATE (track);
 
379
 
 
380
        if (!type)
 
381
                return BRASERO_TRACK_TYPE_DATA;
 
382
 
 
383
        brasero_track_type_set_has_data (type);
 
384
        brasero_track_type_set_data_fs (type, priv->fs_type);
 
385
 
 
386
        return BRASERO_TRACK_TYPE_DATA;
 
387
}
 
388
 
 
389
static BraseroBurnResult
 
390
brasero_track_data_get_status (BraseroTrack *track,
 
391
                               BraseroStatus *status)
 
392
{
 
393
        BraseroTrackDataPrivate *priv;
 
394
 
 
395
        priv = BRASERO_TRACK_DATA_PRIVATE (track);
 
396
 
 
397
        if (!priv->grafts) {
 
398
                if (status)
 
399
                        brasero_status_set_error (status,
 
400
                                                  g_error_new (BRASERO_BURN_ERROR,
 
401
                                                               BRASERO_BURN_ERROR_EMPTY,
 
402
                                                               _("The project is empty")));
 
403
                return BRASERO_BURN_ERR;
 
404
        }
 
405
 
 
406
        return BRASERO_BURN_OK;
 
407
}
 
408
 
 
409
static void
 
410
brasero_track_data_init (BraseroTrackData *object)
 
411
{ }
 
412
 
 
413
static void
 
414
brasero_track_data_finalize (GObject *object)
 
415
{
 
416
        G_OBJECT_CLASS (brasero_track_data_parent_class)->finalize (object);
 
417
}
 
418
 
 
419
static void
 
420
brasero_track_data_class_init (BraseroTrackDataClass *klass)
 
421
{
 
422
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
423
        BraseroTrackClass *track_class = BRASERO_TRACK_CLASS (klass);
 
424
        BraseroTrackDataClass *track_data_class = BRASERO_TRACK_DATA_CLASS (klass);
 
425
 
 
426
        g_type_class_add_private (klass, sizeof (BraseroTrackDataPrivate));
 
427
 
 
428
        object_class->finalize = brasero_track_data_finalize;
 
429
 
 
430
        track_class->get_type = brasero_track_data_get_track_type;
 
431
        track_class->get_status = brasero_track_data_get_status;
 
432
        track_class->get_size = brasero_track_data_get_size;
 
433
 
 
434
        track_data_class->set_source = brasero_track_data_set_source_real;
 
435
        track_data_class->add_fs = brasero_track_data_add_fs_real;
 
436
        track_data_class->rm_fs = brasero_track_data_rm_fs_real;
 
437
 
 
438
        track_data_class->get_fs = brasero_track_data_get_fs_real;
 
439
        track_data_class->get_grafts = brasero_track_data_get_grafts_real;
 
440
        track_data_class->get_excluded = brasero_track_data_get_excluded_real;
 
441
        track_data_class->get_file_num = brasero_track_data_get_file_num_real;
 
442
}
 
443
 
 
444
BraseroTrackData *
 
445
brasero_track_data_new (void)
 
446
{
 
447
        return g_object_new (BRASERO_TYPE_TRACK_DATA, NULL);
 
448
}