← Back to branch summary

~mfisch/brasero/update-to-3.8.0

« back to all changes in this revision

Viewing changes to src/brasero-video-tree-model.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Ancell
  • Date: 2009-07-14 14:13:00 UTC
  • mfrom: (1.1.25 upstream)
  • Revision ID: james.westby@ubuntu.com-20090714141300-e08q13sp48b2xzwd
Tags: 2.27.4-0ubuntu1
https://launchpad.net/bugs/399112
* New upstream release: (LP: #399112)
  - Hal support removed, now relies on GIO only for drives/media probing
  - New layout for size reporting in data/audio/video project
  - Lot's of bug fixes
  - Fixed some memleaks
  - Bump libbrasero-media version to reflect changes (important to packagers)
  - Fix #582261 – brasero shows 0% done, while continues burning disc
  - Fix #582513 – Bogus VIDEO_TS directory error if AUDIO_TS directory present
  - Fix #573805 – "Increase compatibility with Windows systems"?
  - Fix #585190 – remove 0 from 03 % status
  - Fix #586744 – Use AS_HELP_STRING for configure switches
  - Fix #584793 – Poor language in warning dialog when attempting to burn an audio CD onto a CDRW
  - Fix #580617 – Brasero floods .xsession-errors log with "Unknown (or already deleted) monitored directory" warnings
  - Fix #563501 – Brasero burning window shouldn't try to show drive speed while is converting audio files
  - Fix #485719 – Burn dialog CD icon
  - Fix #585481 – Deep hierarchy warning
  - Fix #554070 – The need of a "replace all" and "replace non" button
  - Fix #582461 – Brasero hangs at normalizing tracks
  - Fix #587284 – nautilus hangs every time
  - Fix #574093 – Caret visible in instructions for project creation
  - Fix #581742 – port from HAL to DeviceKit-disks
  - Fix #573801 – Bad error message when burning empty burn:///
  - Fix #573486 – Various i18n and string issues for good
  - Fix #587399 – License clarification
  - Fix #587554 – Unclear meaning of text
  - Fix #582979 – brasero should not include Categories in mime handler .desktop files
  - Fix #586040 – duplicated command listed in open-with dialog
  - Fixes for #573486 – Various i18n and string issues
* debian/control.in:
  - Add in missing comma in brasero suggests

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/brasero-video-tree-model.c
29
29
 
30
30
#include <gtk/gtk.h>
31
31
 
32
 
#include "burn-basics.h"
 
32
#include "brasero-session-cfg.h"
 
33
#include "brasero-tags.h"
 
34
#include "brasero-track-stream-cfg.h"
 
35
 
33
36
#include "brasero-utils.h"
34
 
#include "brasero-video-project.h"
35
37
#include "brasero-video-tree-model.h"
36
38
 
37
39
#include "eggtreemultidnd.h"
39
41
typedef struct _BraseroVideoTreeModelPrivate BraseroVideoTreeModelPrivate;
40
42
struct _BraseroVideoTreeModelPrivate
41
43
{
 
44
        BraseroSessionCfg *session;
 
45
 
 
46
        GSList *gaps;
 
47
 
42
48
        guint stamp;
43
49
        GtkIconTheme *theme;
44
50
};
56
62
 
57
63
G_DEFINE_TYPE_WITH_CODE (BraseroVideoTreeModel,
58
64
                         brasero_video_tree_model,
59
 
                         BRASERO_TYPE_VIDEO_PROJECT,
 
65
                         G_TYPE_OBJECT,
60
66
                         G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
61
67
                                                brasero_video_tree_model_iface_init)
62
68
                         G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_DEST,
66
72
                         G_IMPLEMENT_INTERFACE (EGG_TYPE_TREE_MULTI_DRAG_SOURCE,
67
73
                                                brasero_video_tree_model_multi_drag_source_iface_init));
68
74
 
 
75
enum {
 
76
        BRASERO_STREAM_ROW_NORMAL       = 0,
 
77
        BRASERO_STREAM_ROW_GAP          = 1,
 
78
};
69
79
 
70
80
/**
71
81
 * This is mainly a list so the following functions are not implemented.
118
128
{
119
129
        BraseroVideoTreeModelPrivate *priv;
120
130
        BraseroVideoTreeModel *self;
121
 
        BraseroVideoFile *file;
 
131
        BraseroStatus *status;
 
132
        BraseroTrack *track;
 
133
        const gchar *string;
122
134
        GdkPixbuf *pixbuf;
 
135
        GValue *value_tag;
 
136
        GSList *tracks;
123
137
        gchar *text;
124
138
 
125
139
        self = BRASERO_VIDEO_TREE_MODEL (model);
129
143
        g_return_if_fail (priv->stamp == iter->stamp);
130
144
        g_return_if_fail (iter->user_data != NULL);
131
145
 
132
 
        file = iter->user_data;
 
146
        track = iter->user_data;
 
147
        if (!BRASERO_IS_TRACK_STREAM (track))
 
148
                return;
 
149
 
 
150
        if (GPOINTER_TO_INT (iter->user_data2) == BRASERO_STREAM_ROW_GAP) {
 
151
                switch (column) {
 
152
                case BRASERO_VIDEO_TREE_MODEL_NAME:
 
153
                        text = g_strdup_printf ("<i><b>%s</b></i>", _("Pause"));
 
154
                        g_value_init (value, G_TYPE_STRING);
 
155
                        g_value_set_string (value, text);
 
156
                        g_free (text);
 
157
                        break;
 
158
                case BRASERO_VIDEO_TREE_MODEL_ICON_NAME:
 
159
                        g_value_init (value, G_TYPE_STRING);
 
160
                        g_value_set_string (value, GTK_STOCK_MEDIA_PAUSE);
 
161
                        break;
 
162
                case BRASERO_VIDEO_TREE_MODEL_EDITABLE:
 
163
                case BRASERO_VIDEO_TREE_MODEL_SELECTABLE:
 
164
                        g_value_init (value, G_TYPE_BOOLEAN);
 
165
                        g_value_set_boolean (value, FALSE);
 
166
                        break;
 
167
                case BRASERO_VIDEO_TREE_MODEL_IS_GAP:
 
168
                        g_value_init (value, G_TYPE_BOOLEAN);
 
169
                        g_value_set_boolean (value, TRUE);
 
170
                        break;
 
171
 
 
172
                case BRASERO_VIDEO_TREE_MODEL_SIZE:
 
173
                        g_value_init (value, G_TYPE_STRING);
 
174
                        text = brasero_units_get_time_string (brasero_track_stream_get_gap (BRASERO_TRACK_STREAM (track)), TRUE, FALSE);
 
175
                        g_value_set_string (value, text);
 
176
                        g_free (text);
 
177
                        break;
 
178
 
 
179
                case BRASERO_VIDEO_TREE_MODEL_INDEX:
 
180
                case BRASERO_VIDEO_TREE_MODEL_ARTIST:
 
181
                        g_value_init (value, G_TYPE_STRING);
 
182
                        g_value_set_string (value, NULL);
 
183
                        break;
 
184
 
 
185
                case BRASERO_VIDEO_TREE_MODEL_THUMBNAIL:
 
186
                case BRASERO_VIDEO_TREE_MODEL_INDEX_NUM:
 
187
                default:
 
188
                        g_value_init (value, G_TYPE_INVALID);
 
189
                        break;
 
190
                }
 
191
 
 
192
                return;
 
193
        }
133
194
 
134
195
        switch (column) {
135
196
        case BRASERO_VIDEO_TREE_MODEL_NAME:
136
197
                g_value_init (value, G_TYPE_STRING);
137
198
 
138
 
                if (file->info && file->info->title)
139
 
                        g_value_set_string (value, file->info->title);
 
199
                string = brasero_track_tag_lookup_string (track, BRASERO_TRACK_STREAM_TITLE_TAG);
 
200
                if (string)
 
201
                        g_value_set_string (value, string);
140
202
                else {
 
203
                        gchar *uri;
141
204
                        gchar *name;
142
205
                        gchar *path;
143
206
                        gchar *unescaped;
144
207
 
145
 
                        unescaped = g_uri_unescape_string (file->uri, NULL);
 
208
                        uri = brasero_track_stream_get_source (BRASERO_TRACK_STREAM (track), TRUE);
 
209
                        unescaped = g_uri_unescape_string (uri, NULL);
 
210
                        g_free (uri);
 
211
 
146
212
                        path = g_filename_from_uri (unescaped, NULL, NULL);
147
213
                        g_free (unescaped);
148
214
 
155
221
 
156
222
                return;
157
223
 
158
 
        case BRASERO_VIDEO_TREE_MODEL_MIME_ICON:
 
224
        case BRASERO_VIDEO_TREE_MODEL_ARTIST:
 
225
                g_value_init (value, G_TYPE_STRING);
 
226
 
 
227
                string = brasero_track_tag_lookup_string (track, BRASERO_TRACK_STREAM_ARTIST_TAG);
 
228
                if (string)
 
229
                        g_value_set_string (value, string);
 
230
 
 
231
                return;
 
232
 
 
233
        case BRASERO_VIDEO_TREE_MODEL_ICON_NAME:
 
234
                status = brasero_status_new ();
 
235
                brasero_track_get_status (track, status);
 
236
                g_value_init (value, G_TYPE_STRING);
 
237
 
 
238
                value_tag = NULL;
 
239
                if (brasero_status_get_result (status) == BRASERO_BURN_NOT_READY)
 
240
                        g_value_set_string (value, "image-loading");
 
241
                else if (brasero_track_tag_lookup (track, BRASERO_TRACK_STREAM_MIME_TAG, &value_tag) == BRASERO_BURN_OK)
 
242
                        g_value_set_string (value, g_value_get_string (value_tag));
 
243
                else
 
244
                        g_value_set_string (value, "image-missing");
 
245
 
 
246
                brasero_status_free (status);
 
247
                return;
 
248
 
 
249
        case BRASERO_VIDEO_TREE_MODEL_THUMBNAIL:
159
250
                g_value_init (value, GDK_TYPE_PIXBUF);
160
251
 
161
 
                if (file->snapshot) {
162
 
                        pixbuf = file->snapshot;
163
 
                        g_object_ref (file->snapshot);
164
 
                }
165
 
                else if (file->is_loading) {
 
252
                status = brasero_status_new ();
 
253
                brasero_track_get_status (track, status);
 
254
 
 
255
                if (brasero_status_get_result (status) == BRASERO_BURN_NOT_READY)
166
256
                        pixbuf = gtk_icon_theme_load_icon (priv->theme,
167
257
                                                           "image-loading",
168
258
                                                           48,
169
259
                                                           0,
170
260
                                                           NULL);
171
 
                }
172
261
                else {
173
 
                        pixbuf = gtk_icon_theme_load_icon (priv->theme,
174
 
                                                           "image-missing",
175
 
                                                           48,
176
 
                                                           0,
177
 
                                                           NULL);
 
262
                        value_tag = NULL;
 
263
                        brasero_track_tag_lookup (track,
 
264
                                                  BRASERO_TRACK_STREAM_THUMBNAIL_TAG,
 
265
                                                  &value_tag);
 
266
 
 
267
                        if (value_tag)
 
268
                                pixbuf = g_value_dup_object (value_tag);
 
269
                        else
 
270
                                pixbuf = gtk_icon_theme_load_icon (priv->theme,
 
271
                                                                   "image-missing",
 
272
                                                                   48,
 
273
                                                                   0,
 
274
                                                                   NULL);
178
275
                }
179
276
 
180
277
                g_value_set_object (value, pixbuf);
181
278
                g_object_unref (pixbuf);
182
279
 
 
280
                brasero_status_free (status);
183
281
                return;
184
282
 
185
283
        case BRASERO_VIDEO_TREE_MODEL_SIZE:
 
284
                status = brasero_status_new ();
 
285
                brasero_track_get_status (track, status);
 
286
 
186
287
                g_value_init (value, G_TYPE_STRING);
187
288
 
188
 
                if (!file->is_loading) {
189
 
                        text = brasero_units_get_time_string (file->end - file->start, TRUE, FALSE);
 
289
                if (brasero_status_get_result (status) == BRASERO_BURN_OK) {
 
290
                        guint64 len = 0;
 
291
 
 
292
                        brasero_track_stream_get_length (BRASERO_TRACK_STREAM (track), &len);
 
293
                        len -= brasero_track_stream_get_gap (BRASERO_TRACK_STREAM (track));
 
294
                        text = brasero_units_get_time_string (len, TRUE, FALSE);
190
295
                        g_value_set_string (value, text);
191
296
                        g_free (text);
192
297
                }
193
298
                else
194
299
                        g_value_set_string (value, _("(loading ...)"));
195
300
 
 
301
                brasero_status_free (status);
196
302
                return;
197
303
 
198
304
        case BRASERO_VIDEO_TREE_MODEL_EDITABLE:
199
305
                g_value_init (value, G_TYPE_BOOLEAN);
200
 
                g_value_set_boolean (value, file->editable);
201
 
 
 
306
                /* This can be used for gap lines */
 
307
                g_value_set_boolean (value, TRUE);
 
308
                //g_value_set_boolean (value, file->editable);
 
309
                return;
 
310
 
 
311
        case BRASERO_VIDEO_TREE_MODEL_SELECTABLE:
 
312
                g_value_init (value, G_TYPE_BOOLEAN);
 
313
                /* This can be used for gap lines */
 
314
                g_value_set_boolean (value, TRUE);
 
315
                //g_value_set_boolean (value, file->editable);
 
316
                return;
 
317
 
 
318
        case BRASERO_VIDEO_TREE_MODEL_IS_GAP:
 
319
                g_value_init (value, G_TYPE_BOOLEAN);
 
320
                g_value_set_boolean (value, FALSE);
 
321
                return;
 
322
 
 
323
        case BRASERO_VIDEO_TREE_MODEL_INDEX:
 
324
                tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (priv->session));
 
325
                g_value_init (value, G_TYPE_STRING);
 
326
                text = g_strdup_printf ("%02i", g_slist_index (tracks, track) + 1);
 
327
                g_value_set_string (value, text);
 
328
                g_free (text);
 
329
                return;
 
330
 
 
331
        case BRASERO_VIDEO_TREE_MODEL_INDEX_NUM:
 
332
                tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (priv->session));
 
333
                g_value_init (value, G_TYPE_UINT);
 
334
                g_value_set_uint (value, g_slist_index (tracks, track) + 1);
202
335
                return;
203
336
 
204
337
        default:
205
 
                return;
 
338
                break;
206
339
        }
207
 
 
208
 
        return;
209
340
}
210
341
 
211
342
GtkTreePath *
212
 
brasero_video_tree_model_file_to_path (BraseroVideoTreeModel *self,
213
 
                                       BraseroVideoFile *file)
 
343
brasero_video_tree_model_track_to_path (BraseroVideoTreeModel *self,
 
344
                                        BraseroTrack *track_arg)
214
345
{
215
346
        BraseroVideoTreeModelPrivate *priv;
216
 
        GtkTreePath *path;
217
 
        guint nth;
 
347
        GSList *tracks;
 
348
        gint nth = 0;
 
349
 
 
350
        if (!BRASERO_IS_TRACK_STREAM (track_arg))
 
351
                return NULL;
218
352
 
219
353
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (self);
220
354
 
221
 
        path = gtk_tree_path_new ();
222
 
        nth = brasero_video_project_get_item_index (BRASERO_VIDEO_PROJECT (self), file);
223
 
        gtk_tree_path_prepend_index (path, nth);
224
 
 
225
 
        return path;
 
355
        tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (priv->session));
 
356
        for (; tracks; tracks = tracks->next) {
 
357
                BraseroTrackStream *track;
 
358
 
 
359
                track = tracks->data;
 
360
                if (track == BRASERO_TRACK_STREAM (track_arg))
 
361
                        break;
 
362
 
 
363
                nth ++;
 
364
 
 
365
                if (brasero_track_stream_get_gap (track) > 0)
 
366
                        nth ++;
 
367
 
 
368
        }
 
369
 
 
370
        return gtk_tree_path_new_from_indices (nth, -1);
226
371
}
227
372
 
228
373
static GtkTreePath *
230
375
                                   GtkTreeIter *iter)
231
376
{
232
377
        BraseroVideoTreeModelPrivate *priv;
233
 
        BraseroVideoFile *file;
234
 
        GtkTreePath *path;
235
 
        guint nth;
 
378
        GSList *tracks;
 
379
        gint nth = 0;
236
380
 
237
381
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (model);
238
382
 
240
384
        g_return_val_if_fail (priv->stamp == iter->stamp, NULL);
241
385
        g_return_val_if_fail (iter->user_data != NULL, NULL);
242
386
 
243
 
        file = iter->user_data;
 
387
        tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (priv->session));
 
388
        for (; tracks; tracks = tracks->next) {
 
389
                BraseroTrackStream *track;
 
390
 
 
391
                track = tracks->data;
 
392
                if (GPOINTER_TO_INT (iter->user_data2) == BRASERO_STREAM_ROW_NORMAL
 
393
                &&  track == iter->user_data)
 
394
                        break;
 
395
 
 
396
                nth ++;
 
397
 
 
398
                if (brasero_track_stream_get_gap (track) > 0) {
 
399
                        if (GPOINTER_TO_INT (iter->user_data2) == BRASERO_STREAM_ROW_GAP
 
400
                        &&  track == iter->user_data)
 
401
                                break;
 
402
 
 
403
                        nth ++;
 
404
                }
 
405
        }
244
406
 
245
407
        /* NOTE: there is only one single file without a name: root */
246
 
        path = gtk_tree_path_new ();
247
 
        nth = brasero_video_project_get_item_index (BRASERO_VIDEO_PROJECT (model), file);
248
 
        gtk_tree_path_prepend_index (path, nth);
249
 
 
250
 
        return path;
 
408
        return gtk_tree_path_new_from_indices (nth, -1);
251
409
}
252
410
 
253
 
BraseroVideoFile *
254
 
brasero_video_tree_model_path_to_file (BraseroVideoTreeModel *self,
255
 
                                       GtkTreePath *path)
 
411
BraseroTrack *
 
412
brasero_video_tree_model_path_to_track (BraseroVideoTreeModel *self,
 
413
                                        GtkTreePath *path)
256
414
{
257
415
        BraseroVideoTreeModelPrivate *priv;
258
416
        const gint *indices;
 
417
        GSList *tracks;
259
418
        guint depth;
 
419
        gint index;
260
420
 
261
421
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (self);
262
422
 
268
428
        if (depth > 2)
269
429
                return NULL;
270
430
 
271
 
        return brasero_video_project_get_nth_item (BRASERO_VIDEO_PROJECT (self), indices  [0]);
 
431
        /* Whether it is a GAP or a NORMAL row is of no importance */
 
432
        tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (priv->session));
 
433
        index = indices [0];
 
434
        for (; tracks; tracks = tracks->next) {
 
435
                BraseroTrackStream *track;
 
436
 
 
437
                track = tracks->data;
 
438
                if (index <= 0)
 
439
                        return BRASERO_TRACK (track);
 
440
 
 
441
                index --;
 
442
 
 
443
                if (index <= 0)
 
444
                        return BRASERO_TRACK (track);
 
445
 
 
446
                if (brasero_track_stream_get_gap (track) > 0)
 
447
                        index --;
 
448
        }
 
449
 
 
450
        return NULL;
272
451
}
273
452
 
274
453
static gboolean
277
456
                                   GtkTreePath *path)
278
457
{
279
458
        BraseroVideoTreeModelPrivate *priv;
280
 
        BraseroVideoFile *file;
281
459
        const gint *indices;
 
460
        GSList *tracks;
282
461
        guint depth;
 
462
        gint index;
283
463
 
284
464
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (model);
285
465
 
286
466
        depth = gtk_tree_path_get_depth (path);
 
467
 
 
468
        /* NOTE: it can happen that paths are depth 2 when there is DND but then
 
469
         * only the first index is relevant. */
287
470
        if (depth > 2)
288
471
                return FALSE;
289
472
 
 
473
        /* Whether it is a GAP or a NORMAL row is of no importance */
290
474
        indices = gtk_tree_path_get_indices (path);
291
 
        file = brasero_video_project_get_nth_item (BRASERO_VIDEO_PROJECT (model),
292
 
                                                   indices [0]);
293
 
        if (!file)
294
 
                return FALSE;
295
 
 
296
 
        iter->user_data = file;
297
 
        iter->stamp = priv->stamp;
298
 
 
299
 
        return TRUE;
 
475
        index = indices [0];
 
476
        tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (priv->session));
 
477
        for (; tracks; tracks = tracks->next) {
 
478
                BraseroTrackStream *track;
 
479
 
 
480
                track = tracks->data;
 
481
                if (index <= 0) {
 
482
                        iter->stamp = priv->stamp;
 
483
                        iter->user_data2 = GINT_TO_POINTER (BRASERO_STREAM_ROW_NORMAL);
 
484
                        iter->user_data = track;
 
485
                        return TRUE;
 
486
                }
 
487
                index --;
 
488
 
 
489
                if (brasero_track_stream_get_gap (track) > 0) {
 
490
                        if (index <= 0) {
 
491
                                iter->stamp = priv->stamp;
 
492
                                iter->user_data2 = GINT_TO_POINTER (BRASERO_STREAM_ROW_GAP);
 
493
                                iter->user_data = track;
 
494
                                return TRUE;
 
495
                        }
 
496
                        index --;
 
497
                }
 
498
        }
 
499
 
 
500
        return FALSE;
 
501
}
 
502
 
 
503
static BraseroTrack *
 
504
brasero_video_tree_model_track_next (BraseroVideoTreeModel *model,
 
505
                                     BraseroTrack *track)
 
506
{
 
507
        BraseroVideoTreeModelPrivate *priv;
 
508
        GSList *tracks;
 
509
        GSList *node;
 
510
 
 
511
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (model);
 
512
 
 
513
        tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (priv->session));
 
514
        node = g_slist_find (tracks, track);
 
515
        if (!node || !node->next)
 
516
                return NULL;
 
517
 
 
518
        return node->next->data;
 
519
}
 
520
 
 
521
static BraseroTrack *
 
522
brasero_video_tree_model_track_previous (BraseroVideoTreeModel *model,
 
523
                                         BraseroTrack *track)
 
524
{
 
525
        BraseroVideoTreeModelPrivate *priv;
 
526
        GSList *tracks;
 
527
 
 
528
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (model);
 
529
 
 
530
        tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (priv->session));
 
531
        while (tracks && tracks->next) {
 
532
                if (tracks->next->data == track)
 
533
                        return tracks->data;
 
534
 
 
535
                tracks = tracks->next;
 
536
        }
 
537
 
 
538
        return NULL;
300
539
}
301
540
 
302
541
static gboolean
304
543
                                    GtkTreeIter *iter)
305
544
{
306
545
        BraseroVideoTreeModelPrivate *priv;
307
 
        BraseroVideoFile *file;
 
546
        BraseroTrackStream *track;
 
547
        GSList *tracks;
 
548
        GSList *node;
308
549
 
309
550
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (model);
310
551
 
312
553
        g_return_val_if_fail (priv->stamp == iter->stamp, FALSE);
313
554
        g_return_val_if_fail (iter->user_data != NULL, FALSE);
314
555
 
315
 
        file = iter->user_data;
316
 
        if (!file || !file->next)
317
 
                return FALSE;
318
 
 
319
 
        iter->user_data = file->next;
 
556
        track = BRASERO_TRACK_STREAM (iter->user_data);
 
557
        if (!track)
 
558
                return FALSE;
 
559
 
 
560
        if (GPOINTER_TO_INT (iter->user_data2) == BRASERO_STREAM_ROW_NORMAL
 
561
        &&  brasero_track_stream_get_gap (track) > 0) {
 
562
                iter->user_data2 = GINT_TO_POINTER (BRASERO_STREAM_ROW_GAP);
 
563
                return TRUE;
 
564
        }
 
565
 
 
566
        tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (priv->session));
 
567
        node = g_slist_find (tracks, track);
 
568
        if (!node || !node->next)
 
569
                return FALSE;
 
570
 
 
571
        iter->user_data2 = GINT_TO_POINTER (BRASERO_STREAM_ROW_NORMAL);
 
572
        iter->user_data = node->next->data;
320
573
        return TRUE;
321
574
}
322
575
 
328
581
        case BRASERO_VIDEO_TREE_MODEL_NAME:
329
582
                return G_TYPE_STRING;
330
583
 
331
 
        case BRASERO_VIDEO_TREE_MODEL_MIME_ICON:
 
584
        case BRASERO_VIDEO_TREE_MODEL_ARTIST:
 
585
                return G_TYPE_STRING;
 
586
 
 
587
        case BRASERO_VIDEO_TREE_MODEL_THUMBNAIL:
332
588
                return GDK_TYPE_PIXBUF;
333
589
 
 
590
        case BRASERO_VIDEO_TREE_MODEL_ICON_NAME:
 
591
                return G_TYPE_STRING;
 
592
 
334
593
        case BRASERO_VIDEO_TREE_MODEL_SIZE:
335
594
                return G_TYPE_STRING;
336
595
 
337
596
        case BRASERO_VIDEO_TREE_MODEL_EDITABLE:
338
597
                return G_TYPE_BOOLEAN;
339
598
 
 
599
        case BRASERO_VIDEO_TREE_MODEL_SELECTABLE:
 
600
                return G_TYPE_BOOLEAN;
 
601
 
 
602
        case BRASERO_VIDEO_TREE_MODEL_INDEX:
 
603
                return G_TYPE_STRING;
 
604
 
 
605
        case BRASERO_VIDEO_TREE_MODEL_INDEX_NUM:
 
606
                return G_TYPE_UINT;
 
607
 
 
608
        case BRASERO_VIDEO_TREE_MODEL_IS_GAP:
 
609
                return G_TYPE_STRING;
 
610
 
340
611
        default:
341
612
                break;
342
613
        }
398
669
        return TRUE;
399
670
}
400
671
 
 
672
void
 
673
brasero_video_tree_model_move_before (BraseroVideoTreeModel *self,
 
674
                                      GtkTreeIter *iter,
 
675
                                      GtkTreePath *dest_before)
 
676
{
 
677
        BraseroTrack *track;
 
678
        GtkTreeIter sibling;
 
679
        BraseroTrack *track_sibling;
 
680
        BraseroVideoTreeModelPrivate *priv;
 
681
 
 
682
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (self);
 
683
 
 
684
        track = BRASERO_TRACK (iter->user_data);
 
685
        if (!dest_before || !brasero_video_tree_model_get_iter (GTK_TREE_MODEL (self), &sibling, dest_before)) {
 
686
                if (GPOINTER_TO_INT (iter->user_data2) == BRASERO_STREAM_ROW_GAP) {
 
687
                        guint64 gap;
 
688
                        GSList *tracks;
 
689
 
 
690
                        gap = brasero_track_stream_get_gap (BRASERO_TRACK_STREAM (track));
 
691
                        brasero_track_stream_set_boundaries (BRASERO_TRACK_STREAM (track),
 
692
                                                             -1,
 
693
                                                             -1,
 
694
                                                             0);
 
695
                        brasero_track_changed (track);
 
696
 
 
697
                        /* Get last track */
 
698
                        tracks = brasero_burn_session_get_tracks (BRASERO_BURN_SESSION (priv->session));
 
699
                        tracks = g_slist_last (tracks);
 
700
                        track_sibling = tracks->data;
 
701
 
 
702
                        gap += brasero_track_stream_get_gap (BRASERO_TRACK_STREAM (track_sibling));
 
703
                        brasero_track_stream_set_boundaries (BRASERO_TRACK_STREAM (track_sibling),
 
704
                                                             -1,
 
705
                                                             -1,
 
706
                                                             gap);
 
707
                        brasero_track_changed (track_sibling);
 
708
                        return;
 
709
                }
 
710
 
 
711
                brasero_burn_session_move_track (BRASERO_BURN_SESSION (priv->session),
 
712
                                                 track,
 
713
                                                 NULL);
 
714
                return;
 
715
        }
 
716
 
 
717
        track_sibling = BRASERO_TRACK (sibling.user_data);
 
718
 
 
719
        if (GPOINTER_TO_INT (iter->user_data2) == BRASERO_STREAM_ROW_GAP) {
 
720
                guint64 gap;
 
721
                BraseroTrack *previous_sibling;
 
722
 
 
723
                /* Merge the gaps or add it */
 
724
                gap = brasero_track_stream_get_gap (BRASERO_TRACK_STREAM (track));
 
725
                brasero_track_stream_set_boundaries (BRASERO_TRACK_STREAM (track),
 
726
                                                     -1,
 
727
                                                     -1,
 
728
                                                     0);
 
729
                brasero_track_changed (track);
 
730
 
 
731
                if (GPOINTER_TO_INT (sibling.user_data2) == BRASERO_STREAM_ROW_GAP) {
 
732
                        gap += brasero_track_stream_get_gap (BRASERO_TRACK_STREAM (track_sibling));
 
733
                        brasero_track_stream_set_boundaries (BRASERO_TRACK_STREAM (track_sibling),
 
734
                                                             -1,
 
735
                                                             -1,
 
736
                                                             gap);
 
737
                        brasero_track_changed (track_sibling);
 
738
                        return;
 
739
                }
 
740
 
 
741
                /* get the track before track_sibling */
 
742
                previous_sibling = brasero_video_tree_model_track_previous (self, track_sibling);
 
743
                if (previous_sibling)
 
744
                        track_sibling = previous_sibling;
 
745
 
 
746
                gap += brasero_track_stream_get_gap (BRASERO_TRACK_STREAM (track_sibling));
 
747
                brasero_track_stream_set_boundaries (BRASERO_TRACK_STREAM (track_sibling),
 
748
                                                     -1,
 
749
                                                     -1,
 
750
                                                     gap);
 
751
                brasero_track_changed (track_sibling);
 
752
                return;
 
753
        }
 
754
 
 
755
        if (GPOINTER_TO_INT (sibling.user_data2) == BRASERO_STREAM_ROW_GAP) {
 
756
                guint64 gap;
 
757
 
 
758
                /* merge */
 
759
                gap = brasero_track_stream_get_gap (BRASERO_TRACK_STREAM (track_sibling));
 
760
                brasero_track_stream_set_boundaries (BRASERO_TRACK_STREAM (track_sibling),
 
761
                                                     -1,
 
762
                                                     -1,
 
763
                                                     0);
 
764
                brasero_track_changed (track_sibling);
 
765
 
 
766
                gap += brasero_track_stream_get_gap (BRASERO_TRACK_STREAM (track));
 
767
                brasero_track_stream_set_boundaries (BRASERO_TRACK_STREAM (track),
 
768
                                                     -1,
 
769
                                                     -1,
 
770
                                                     gap);
 
771
                brasero_track_changed (track);
 
772
 
 
773
                /* Track sibling is now the next track of current track_sibling */
 
774
                track_sibling = brasero_video_tree_model_track_next (self, track_sibling);
 
775
        }
 
776
 
 
777
        brasero_burn_session_move_track (BRASERO_BURN_SESSION (priv->session),
 
778
                                         track,
 
779
                                         track_sibling);
 
780
}
 
781
 
401
782
static gboolean
402
783
brasero_video_tree_model_drag_data_received (GtkTreeDragDest *drag_dest,
403
784
                                             GtkTreePath *dest_path,
404
785
                                             GtkSelectionData *selection_data)
405
786
{
406
 
        BraseroVideoFile *file;
407
 
        BraseroVideoFile *sibling;
408
 
        BraseroVideoTreeModel *self;
 
787
        BraseroTrack *sibling;
 
788
        BraseroVideoTreeModelPrivate *priv;
409
789
 
410
 
        self = BRASERO_VIDEO_TREE_MODEL (drag_dest);
 
790
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (drag_dest);
411
791
 
412
792
        /* The new row(s) must be before dest_path but after our sibling */
413
 
        sibling = brasero_video_tree_model_path_to_file (BRASERO_VIDEO_TREE_MODEL (drag_dest), dest_path);
 
793
        sibling = brasero_video_tree_model_path_to_track (BRASERO_VIDEO_TREE_MODEL (drag_dest), dest_path);
414
794
                
415
795
        /* Received data: see where it comes from:
416
796
         * - from us, then that's a simple move
428
808
                for (iter = context->references; iter; iter = iter->next) {
429
809
                        GtkTreeRowReference *reference;
430
810
                        GtkTreePath *treepath;
 
811
                        GtkTreeIter tree_iter;
431
812
 
432
813
                        reference = iter->data;
433
814
                        treepath = gtk_tree_row_reference_get_path (reference);
434
 
 
435
 
                        file = brasero_video_tree_model_path_to_file (BRASERO_VIDEO_TREE_MODEL (drag_dest), treepath);
 
815
                        gtk_tree_model_get_iter (GTK_TREE_MODEL (drag_dest),
 
816
                                                 &tree_iter,
 
817
                                                 treepath);
436
818
                        gtk_tree_path_free (treepath);
437
819
 
438
 
                        brasero_video_project_move (BRASERO_VIDEO_PROJECT (self), file, sibling);
 
820
                        brasero_video_tree_model_move_before (BRASERO_VIDEO_TREE_MODEL (drag_dest),
 
821
                                                              &tree_iter,
 
822
                                                              dest_path);
439
823
                }
440
824
        }
441
825
        else if (selection_data->target == gdk_atom_intern ("text/uri-list", TRUE)) {
451
835
                        return TRUE;
452
836
 
453
837
                for (i = 0; uris [i]; i ++) {
 
838
                        BraseroTrackStreamCfg *track;
 
839
 
454
840
                        /* Add the URIs to the project */
455
 
                        brasero_video_project_add_uri (BRASERO_VIDEO_PROJECT (self),
456
 
                                                       uris [i],
457
 
                                                       NULL,
458
 
                                                       sibling,
459
 
                                                       -1,
460
 
                                                       -1);
 
841
                        track = brasero_track_stream_cfg_new ();
 
842
                        brasero_track_stream_set_source (BRASERO_TRACK_STREAM (track), uris [i]);
 
843
                        brasero_burn_session_add_track (BRASERO_BURN_SESSION (priv->session),
 
844
                                                        BRASERO_TRACK (track),
 
845
                                                        sibling);
461
846
                }
462
847
                g_strfreev (uris);
463
848
        }
484
869
}
485
870
 
486
871
static void
487
 
brasero_video_tree_model_clear (BraseroVideoTreeModel *self,
488
 
                                guint num_files)
 
872
brasero_video_tree_model_reindex (BraseroVideoTreeModel *model,
 
873
                                  BraseroBurnSession *session,
 
874
                                  BraseroTrack *track_arg,
 
875
                                  GtkTreeIter *iter,
 
876
                                  GtkTreePath *path)
489
877
{
490
 
        GtkTreePath *treepath;
 
878
        GSList *tracks;
491
879
        BraseroVideoTreeModelPrivate *priv;
492
880
 
493
 
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (self);
494
 
 
495
 
        /* NOTE: no need to move to the next row since previous one was deleted */
496
 
        treepath = gtk_tree_path_new_first ();
497
 
        while (num_files > 0) {
498
 
                num_files --;
499
 
                gtk_tree_model_row_deleted (GTK_TREE_MODEL (self), treepath);
 
881
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (model);
 
882
 
 
883
        /* tracks (including) after sibling need to be reindexed */
 
884
        tracks = brasero_burn_session_get_tracks (session);
 
885
        tracks = g_slist_find (tracks, track_arg);
 
886
        if (!tracks)
 
887
                return;
 
888
 
 
889
        tracks = tracks->next;
 
890
        for (; tracks; tracks = tracks->next) {
 
891
                BraseroTrack *track;
 
892
 
 
893
                track = tracks->data;
 
894
 
 
895
                iter->stamp = priv->stamp;
 
896
                iter->user_data = track;
 
897
                iter->user_data2 = GINT_TO_POINTER (BRASERO_STREAM_ROW_NORMAL);
 
898
 
 
899
                gtk_tree_path_next (path);
 
900
                gtk_tree_model_row_changed (GTK_TREE_MODEL (model),
 
901
                                            path,
 
902
                                            iter);
 
903
 
 
904
                /* skip gap rows */
 
905
                if (brasero_track_stream_get_gap (BRASERO_TRACK_STREAM (track)) > 0)
 
906
                        gtk_tree_path_next (path);
500
907
        }
501
 
        gtk_tree_path_free (treepath);
502
908
}
503
909
 
504
910
static void
505
 
brasero_video_tree_model_reset (BraseroVideoProject *project,
506
 
                                guint num_files)
507
 
{
508
 
        brasero_video_tree_model_clear (BRASERO_VIDEO_TREE_MODEL (project), num_files);
509
 
 
510
 
        /* chain up this function except if we invalidated the file */
511
 
        if (BRASERO_VIDEO_PROJECT_CLASS (brasero_video_tree_model_parent_class)->reset)
512
 
                BRASERO_VIDEO_PROJECT_CLASS (brasero_video_tree_model_parent_class)->reset (project, num_files);
513
 
}
514
 
 
515
 
static gboolean
516
 
brasero_video_tree_model_file_added (BraseroVideoProject *project,
517
 
                                     BraseroVideoFile *file)
 
911
brasero_video_tree_model_track_added (BraseroBurnSession *session,
 
912
                                      BraseroTrack *track,
 
913
                                      BraseroVideoTreeModel *model)
518
914
{
519
915
        BraseroVideoTreeModelPrivate *priv;
520
916
        GtkTreePath *path;
521
917
        GtkTreeIter iter;
522
918
 
523
 
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (project);
 
919
        if (!BRASERO_IS_TRACK_STREAM (track))
 
920
                return;
 
921
 
 
922
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (model);
524
923
 
525
924
        iter.stamp = priv->stamp;
526
 
        iter.user_data = file;
 
925
        iter.user_data = track;
 
926
        iter.user_data2 = GINT_TO_POINTER (BRASERO_STREAM_ROW_NORMAL);
527
927
 
528
 
        path = brasero_video_tree_model_file_to_path (BRASERO_VIDEO_TREE_MODEL (project), file);
 
928
        path = brasero_video_tree_model_track_to_path (model, track);
529
929
 
530
930
        /* if the file is reloading (because of a file system change or because
531
931
         * it was a file that was a tmp folder) then no need to signal an added
532
932
         * signal but a changed one */
533
 
        if (file->is_reloading) {
534
 
                gtk_tree_model_row_changed (GTK_TREE_MODEL (project),
535
 
                                            path,
536
 
                                            &iter);
537
 
                gtk_tree_path_free (path);
538
 
                goto end;
539
 
        }
540
 
 
541
 
        /* Add the row itself */
542
 
        gtk_tree_model_row_inserted (GTK_TREE_MODEL (project),
 
933
        gtk_tree_model_row_inserted (GTK_TREE_MODEL (model),
543
934
                                     path,
544
935
                                     &iter);
 
936
 
 
937
        if (brasero_track_stream_get_gap (BRASERO_TRACK_STREAM (track)) > 0) {
 
938
                priv->gaps = g_slist_prepend (priv->gaps, track);
 
939
 
 
940
                iter.user_data2 = GINT_TO_POINTER (BRASERO_STREAM_ROW_GAP);
 
941
                gtk_tree_path_next (path);
 
942
                gtk_tree_model_row_inserted (GTK_TREE_MODEL (model),
 
943
                                             path,
 
944
                                             &iter);
 
945
        }
 
946
 
 
947
        /* tracks (including) after sibling need to be reindexed */
 
948
        brasero_video_tree_model_reindex (model, session, track, &iter, path);
545
949
        gtk_tree_path_free (path);
546
 
 
547
 
end:
548
 
        /* chain up this function */
549
 
        if (BRASERO_VIDEO_PROJECT_CLASS (brasero_video_tree_model_parent_class)->node_added)
550
 
                return BRASERO_VIDEO_PROJECT_CLASS (brasero_video_tree_model_parent_class)->node_added (project,
551
 
                                                                                                        file);
552
 
 
553
 
        return TRUE;
554
950
}
555
951
 
556
952
static void
557
 
brasero_video_tree_model_file_removed (BraseroVideoProject *project,
558
 
                                       BraseroVideoFile *file)
 
953
brasero_video_tree_model_track_removed (BraseroBurnSession *session,
 
954
                                        BraseroTrack *track,
 
955
                                        guint former_location,
 
956
                                        BraseroVideoTreeModel *model)
559
957
{
560
958
        BraseroVideoTreeModelPrivate *priv;
561
 
        BraseroVideoFile *next;
562
959
        GtkTreePath *path;
563
 
 
564
 
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (project);
 
960
        GtkTreeIter iter;
 
961
 
 
962
        if (!BRASERO_IS_TRACK_STREAM (track))
 
963
                return;
 
964
 
 
965
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (model);
565
966
 
566
967
        /* remove the file. */
567
 
        next = file->next;
568
 
        path = brasero_video_tree_model_file_to_path (BRASERO_VIDEO_TREE_MODEL (project), next);
569
 
        gtk_tree_model_row_deleted (GTK_TREE_MODEL (project), path);
 
968
        path = gtk_tree_path_new_from_indices (former_location, -1);
 
969
        gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
 
970
 
 
971
        if (brasero_track_stream_get_gap (BRASERO_TRACK_STREAM (track)) > 0) {
 
972
                priv->gaps = g_slist_remove (priv->gaps, track);
 
973
                gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
 
974
        }
 
975
 
 
976
        /* tracks (including) after former_location need to be reindexed */
 
977
        brasero_video_tree_model_reindex (model, session, track, &iter, path);
570
978
        gtk_tree_path_free (path);
571
 
 
572
 
        /* chain up this function */
573
 
        if (BRASERO_VIDEO_PROJECT_CLASS (brasero_video_tree_model_parent_class)->node_removed)
574
 
                BRASERO_VIDEO_PROJECT_CLASS (brasero_video_tree_model_parent_class)->node_removed (project,
575
 
                                                                                                   file);
576
979
}
577
980
 
578
981
static void
579
 
brasero_video_tree_model_file_changed (BraseroVideoProject *project,
580
 
                                       BraseroVideoFile *file)
 
982
brasero_video_tree_model_track_changed (BraseroBurnSession *session,
 
983
                                        BraseroTrack *track,
 
984
                                        BraseroVideoTreeModel *model)
581
985
{
582
986
        BraseroVideoTreeModelPrivate *priv;
 
987
        GValue *value = NULL;
583
988
        GtkTreePath *path;
584
989
        GtkTreeIter iter;
585
990
 
586
 
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (project);
 
991
        if (!BRASERO_IS_TRACK_STREAM (track))
 
992
                return;
 
993
 
 
994
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (model);
 
995
 
 
996
        /* scale the thumbnail */
 
997
        brasero_track_tag_lookup (BRASERO_TRACK (track),
 
998
                                  BRASERO_TRACK_STREAM_THUMBNAIL_TAG,
 
999
                                  &value);
 
1000
        if (value) {
 
1001
                GdkPixbuf *scaled;
 
1002
                GdkPixbuf *snapshot;
 
1003
 
 
1004
                snapshot = g_value_get_object (value);
 
1005
                scaled = gdk_pixbuf_scale_simple (snapshot,
 
1006
                                                  48 * gdk_pixbuf_get_width (snapshot) / gdk_pixbuf_get_height (snapshot),
 
1007
                                                  48,
 
1008
                                                  GDK_INTERP_BILINEAR);
 
1009
 
 
1010
                value = g_new0 (GValue, 1);
 
1011
                g_value_init (value, GDK_TYPE_PIXBUF);
 
1012
                g_value_set_object (value, scaled);
 
1013
                brasero_track_tag_add (track,
 
1014
                                       BRASERO_TRACK_STREAM_THUMBNAIL_TAG,
 
1015
                                       value);
 
1016
        }
587
1017
 
588
1018
        /* Get the iter for the file */
589
1019
        iter.stamp = priv->stamp;
590
 
        iter.user_data = file;
 
1020
        iter.user_data2 = GINT_TO_POINTER (BRASERO_STREAM_ROW_NORMAL);
 
1021
        iter.user_data = track;
591
1022
 
592
 
        path = brasero_video_tree_model_file_to_path (BRASERO_VIDEO_TREE_MODEL (project), file);
593
 
        gtk_tree_model_row_changed (GTK_TREE_MODEL (project),
 
1023
        path = brasero_video_tree_model_track_to_path (model, track);
 
1024
        gtk_tree_model_row_changed (GTK_TREE_MODEL (model),
594
1025
                                    path,
595
1026
                                    &iter);
 
1027
 
 
1028
        /* Get the iter for a possible gap row.
 
1029
         * The problem is to know whether one was added, removed or simply
 
1030
         * changed. */
 
1031
        gtk_tree_path_next (path);
 
1032
        if (brasero_track_stream_get_gap (BRASERO_TRACK_STREAM (track)) > 0) {
 
1033
                iter.user_data2 = GINT_TO_POINTER (BRASERO_STREAM_ROW_GAP);
 
1034
                if (!g_slist_find (priv->gaps, track)) {
 
1035
                        priv->gaps = g_slist_prepend (priv->gaps,  track);
 
1036
                        gtk_tree_model_row_inserted (GTK_TREE_MODEL (model),
 
1037
                                                     path,
 
1038
                                                     &iter);
 
1039
                }
 
1040
                else
 
1041
                        gtk_tree_model_row_changed (GTK_TREE_MODEL (model),
 
1042
                                                    path,
 
1043
                                                    &iter);
 
1044
        }
 
1045
        else if (g_slist_find (priv->gaps, track)) {
 
1046
                priv->gaps = g_slist_remove (priv->gaps, track);
 
1047
                gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);              
 
1048
        }
 
1049
 
596
1050
        gtk_tree_path_free (path);
597
 
 
598
 
        /* chain up this function */
599
 
        if (BRASERO_VIDEO_PROJECT_CLASS (brasero_video_tree_model_parent_class)->node_changed)
600
 
                BRASERO_VIDEO_PROJECT_CLASS (brasero_video_tree_model_parent_class)->node_changed (project, file);
 
1051
}
 
1052
 
 
1053
void
 
1054
brasero_video_tree_model_set_session (BraseroVideoTreeModel *model,
 
1055
                                      BraseroSessionCfg *session)
 
1056
{
 
1057
        BraseroVideoTreeModelPrivate *priv;
 
1058
 
 
1059
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (model);
 
1060
        if (priv->session) {
 
1061
                g_signal_handlers_disconnect_by_func (priv->session,
 
1062
                                                      brasero_video_tree_model_track_added,
 
1063
                                                      model);
 
1064
                g_signal_handlers_disconnect_by_func (priv->session,
 
1065
                                                      brasero_video_tree_model_track_removed,
 
1066
                                                      model);
 
1067
                g_signal_handlers_disconnect_by_func (priv->session,
 
1068
                                                      brasero_video_tree_model_track_changed,
 
1069
                                                      model);
 
1070
                g_object_unref (priv->session);
 
1071
                priv->session = NULL;
 
1072
        }
 
1073
 
 
1074
        if (!session)
 
1075
                return;
 
1076
 
 
1077
        priv->session = g_object_ref (session);
 
1078
        g_signal_connect (session,
 
1079
                          "track-added",
 
1080
                          G_CALLBACK (brasero_video_tree_model_track_added),
 
1081
                          model);
 
1082
        g_signal_connect (session,
 
1083
                          "track-removed",
 
1084
                          G_CALLBACK (brasero_video_tree_model_track_removed),
 
1085
                          model);
 
1086
        g_signal_connect (session,
 
1087
                          "track-changed",
 
1088
                          G_CALLBACK (brasero_video_tree_model_track_changed),
 
1089
                          model);
 
1090
}
 
1091
 
 
1092
BraseroSessionCfg *
 
1093
brasero_video_tree_model_get_session (BraseroVideoTreeModel *model)
 
1094
{
 
1095
        BraseroVideoTreeModelPrivate *priv;
 
1096
 
 
1097
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (model);
 
1098
        return priv->session;
601
1099
}
602
1100
 
603
1101
static void
621
1119
 
622
1120
        priv = BRASERO_VIDEO_TREE_MODEL_PRIVATE (object);
623
1121
 
624
 
        if (priv->theme) {
625
 
                g_object_unref (priv->theme);
626
 
                priv->theme = NULL;
 
1122
        if (priv->session) {
 
1123
                g_signal_handlers_disconnect_by_func (priv->session,
 
1124
                                                      brasero_video_tree_model_track_added,
 
1125
                                                      object);
 
1126
                g_signal_handlers_disconnect_by_func (priv->session,
 
1127
                                                      brasero_video_tree_model_track_removed,
 
1128
                                                      object);
 
1129
                g_signal_handlers_disconnect_by_func (priv->session,
 
1130
                                                      brasero_video_tree_model_track_changed,
 
1131
                                                      object);
 
1132
                g_object_unref (priv->session);
 
1133
                priv->session = NULL;
 
1134
        }
 
1135
 
 
1136
        if (priv->gaps) {
 
1137
                g_slist_free (priv->gaps);
 
1138
                priv->gaps = NULL;
627
1139
        }
628
1140
 
629
1141
        G_OBJECT_CLASS (brasero_video_tree_model_parent_class)->finalize (object);
703
1215
brasero_video_tree_model_class_init (BraseroVideoTreeModelClass *klass)
704
1216
{
705
1217
        GObjectClass* object_class = G_OBJECT_CLASS (klass);
706
 
        BraseroVideoProjectClass *video_class = BRASERO_VIDEO_PROJECT_CLASS (klass);
707
1218
 
708
1219
        g_type_class_add_private (klass, sizeof (BraseroVideoTreeModelPrivate));
709
1220
 
710
1221
        object_class->finalize = brasero_video_tree_model_finalize;
711
 
 
712
 
        video_class->reset = brasero_video_tree_model_reset;
713
 
        video_class->node_added = brasero_video_tree_model_file_added;
714
 
        video_class->node_removed = brasero_video_tree_model_file_removed;
715
 
        video_class->node_changed = brasero_video_tree_model_file_changed;
716
1222
}
717
1223
 
718
1224
BraseroVideoTreeModel *