← Back to branch summary

~ubuntu-branches/ubuntu/vivid/brasero/vivid-proposed

« back to all changes in this revision

Viewing changes to src/brasero-player.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Biebl, Laurent Bigonville, Michael Biebl
  • Date: 2011-10-13 20:13:30 UTC
  • mfrom: (1.4.5 experimental)
  • mto: (1.4.7 experimental)
  • mto: This revision was merged to the branch mainline in revision 96.
  • Revision ID: james.westby@ubuntu.com-20111013201330-r1rg6r6uof0cwpsp
Tags: 3.0.0-4
[ Laurent Bigonville ]
* debian/control.in: Update Vcs-* fields

[ Michael Biebl ]
* Upload to unstable.
* debian/patches/02_gcc-format-security.patch
  - Fix format string vulnerabilities.
* debian/watch:
  - Switch to .xz tarballs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/brasero-player.c
53
53
G_DEFINE_TYPE (BraseroPlayer, brasero_player, GTK_TYPE_ALIGNMENT);
54
54
 
55
55
struct BraseroPlayerPrivate {
56
 
        GtkWidget *hbox;
57
 
        GtkWidget *vbox;
58
 
 
59
56
        GtkWidget *notebook;
 
57
 
60
58
        GtkWidget *bacon;
61
 
        GtkWidget *controls;
 
59
 
 
60
        GtkWidget *spinner;
 
61
 
 
62
        GtkWidget *play_image;
62
63
 
63
64
        gint image_width;
64
65
        gint image_height;
65
66
        GdkPixbuf *pixbuf;
66
67
 
67
 
 
68
68
        GtkWidget *image_display;
69
 
        GtkWidget *image_event;
70
 
        GtkWidget *image_zoom_in;
71
 
        GtkWidget *image_zoom_out;
 
69
 
 
70
        GtkWidget *zoom_in;
 
71
        GtkWidget *zoom_out;
72
72
 
73
73
        gint video_width;
74
74
        gint video_height;
75
 
        GtkWidget *video_zoom_in;
76
 
        GtkWidget *video_zoom_out;
77
 
 
78
 
        GtkWidget *button;
79
 
        GtkWidget *progress;
80
 
 
81
 
        GtkWidget *header;
82
 
        GtkWidget *size;
83
 
        guint update_scale_id;
84
75
 
85
76
        BraseroPlayerBaconState state;
86
77
 
90
81
        gint64 start;
91
82
        gint64 end;
92
83
        gint64 length;
 
84
 
 
85
        int is_video:1;
93
86
};
94
87
 
95
88
typedef enum {
103
96
static GObjectClass *parent_class = NULL;
104
97
 
105
98
static void
106
 
brasero_player_destroy_controls (BraseroPlayer *player)
107
 
{
108
 
        if (!player->priv->controls)
109
 
                return;
110
 
 
111
 
        gtk_box_set_child_packing (GTK_BOX (player->priv->hbox),
112
 
                                   gtk_widget_get_parent (player->priv->notebook),
113
 
                                   FALSE,
114
 
                                   FALSE,
115
 
                                   0,
116
 
                                   GTK_PACK_START);
117
 
 
118
 
        gtk_widget_destroy (player->priv->controls);
119
 
        player->priv->controls = NULL;
120
 
        player->priv->progress = NULL;
121
 
        player->priv->header = NULL;
122
 
        player->priv->button = NULL;
123
 
        player->priv->size = NULL;
124
 
        player->priv->video_zoom_in = NULL;
125
 
        player->priv->video_zoom_out = NULL;
126
 
        player->priv->image_zoom_in = NULL;
127
 
        player->priv->image_zoom_out = NULL;
128
 
}
129
 
 
130
 
static void
131
99
brasero_player_no_multimedia_stream (BraseroPlayer *player)
132
100
{
133
 
        if (player->priv->update_scale_id) {
134
 
                g_source_remove (player->priv->update_scale_id);
135
 
                player->priv->update_scale_id = 0;
136
 
        }
137
 
 
138
 
        gtk_alignment_set_padding (GTK_ALIGNMENT (player), 0, 0, 0, 0);
139
 
        
140
 
        gtk_widget_hide (player->priv->notebook);
 
101
        gtk_spinner_stop (GTK_SPINNER (player->priv->spinner));
 
102
        gtk_widget_set_has_tooltip (GTK_WIDGET (player), FALSE);
 
103
        gtk_notebook_set_current_page (GTK_NOTEBOOK (player->priv->notebook), 2);
141
104
 
142
105
        player->priv->length = 0;
143
106
        player->priv->start = 0;
147
110
static void
148
111
brasero_player_video_zoom_out (BraseroPlayer *player)
149
112
{
150
 
        GtkWidget *parent;
151
 
        gint width, height;
152
 
        GtkAllocation player_allocation, bacon_allocation;
153
 
 
154
 
        gtk_widget_set_sensitive (GTK_WIDGET (player->priv->video_zoom_in), TRUE);
155
 
 
156
 
        gtk_widget_get_allocation (GTK_WIDGET (player->priv->bacon), &bacon_allocation);
157
 
        width = bacon_allocation.width;
158
 
        height = bacon_allocation.height;
159
 
 
160
 
        width -= PLAYER_BACON_WIDTH / 3;
161
 
        height -= PLAYER_BACON_HEIGHT / 3;
162
 
 
163
 
        gtk_widget_get_allocation (GTK_WIDGET (player), &player_allocation);
164
 
        parent = gtk_widget_get_parent (player->priv->controls);
165
 
        if (width < player_allocation.width / 2 &&
166
 
            gtk_widget_get_parent (player->priv->controls) == player->priv->vbox) {
167
 
                g_object_ref (player->priv->controls);
168
 
                gtk_container_remove (GTK_CONTAINER (player->priv->vbox),
169
 
                                      player->priv->controls);
170
 
 
171
 
                gtk_box_pack_start (GTK_BOX (player->priv->hbox),
172
 
                                    player->priv->controls,
173
 
                                    TRUE,
174
 
                                    TRUE,
175
 
                                    0);
176
 
                g_object_unref (player->priv->controls);
177
 
 
178
 
                gtk_box_set_child_packing (GTK_BOX (player->priv->hbox),
179
 
                                           gtk_widget_get_parent (player->priv->notebook),
180
 
                                           FALSE,
181
 
                                           FALSE,
182
 
                                           0,
183
 
                                           GTK_PACK_START);
184
 
        }
185
 
 
186
 
        if (width <= PLAYER_BACON_WIDTH ||
187
 
            height <= PLAYER_BACON_HEIGHT) {
188
 
                width = PLAYER_BACON_WIDTH;
189
 
                height = PLAYER_BACON_HEIGHT;
190
 
                gtk_widget_set_sensitive (GTK_WIDGET (player->priv->video_zoom_out), FALSE);
191
 
        }
192
 
 
193
 
        player->priv->video_width = width;
194
 
        player->priv->video_height = height;
 
113
        player->priv->video_width -= PLAYER_BACON_WIDTH / 3;
 
114
        player->priv->video_height -= PLAYER_BACON_HEIGHT / 3;
 
115
 
 
116
        if (player->priv->video_width <= PLAYER_BACON_WIDTH ||
 
117
            player->priv->video_height <= PLAYER_BACON_HEIGHT) {
 
118
                player->priv->video_width = PLAYER_BACON_WIDTH;
 
119
                player->priv->video_height = PLAYER_BACON_HEIGHT;
 
120
        }
195
121
 
196
122
        gtk_widget_set_size_request (GTK_WIDGET (player->priv->bacon),
197
 
                                     width,
198
 
                                     height);
199
 
}
200
 
 
201
 
static void
202
 
brasero_player_video_zoom_out_button_cb (GtkButton *button,
203
 
                                         BraseroPlayer *player)
204
 
{
205
 
        brasero_player_video_zoom_out (player);
 
123
                                     player->priv->video_width,
 
124
                                     player->priv->video_height);
206
125
}
207
126
 
208
127
static void
209
128
brasero_player_video_zoom_in (BraseroPlayer *player)
210
129
{
211
 
        GtkAllocation player_allocation, bacon_allocation;
212
 
        gint width, height;
213
 
 
214
 
        gtk_widget_set_sensitive (GTK_WIDGET (player->priv->video_zoom_out), TRUE);
215
 
 
216
 
        gtk_widget_get_allocation (player->priv->bacon, &bacon_allocation);
217
 
        width = bacon_allocation.width;
218
 
        height = bacon_allocation.height;
219
 
 
220
 
        width += PLAYER_BACON_WIDTH / 3;
221
 
        height += PLAYER_BACON_HEIGHT / 3;
222
 
 
223
 
        gtk_widget_get_allocation (GTK_WIDGET (player), &player_allocation);
224
 
        if (width >= (player_allocation.width / 2) &&
225
 
            gtk_widget_get_parent (player->priv->controls) == player->priv->hbox) {
226
 
                g_object_ref (player->priv->controls);
227
 
                gtk_container_remove (GTK_CONTAINER (player->priv->hbox),
228
 
                                      player->priv->controls);
229
 
 
230
 
                gtk_box_pack_start (GTK_BOX (player->priv->vbox),
231
 
                                    player->priv->controls,
232
 
                                    TRUE,
233
 
                                    TRUE,
234
 
                                    0);
235
 
                g_object_unref (player->priv->controls);
236
 
 
237
 
                gtk_box_set_child_packing (GTK_BOX (player->priv->hbox),
238
 
                                           gtk_widget_get_parent (player->priv->notebook),
239
 
                                           TRUE,
240
 
                                           TRUE,
241
 
                                           0,
242
 
                                           GTK_PACK_START);
243
 
        }
244
 
 
245
 
        if (width >= PLAYER_BACON_WIDTH * 3 ||
246
 
            height >= PLAYER_BACON_HEIGHT * 3) {
247
 
                width = PLAYER_BACON_WIDTH * 3;
248
 
                height = PLAYER_BACON_HEIGHT * 3;
249
 
                gtk_widget_set_sensitive (GTK_WIDGET (player->priv->video_zoom_in), FALSE);
250
 
        }
251
 
 
252
 
        player->priv->video_width = width;
253
 
        player->priv->video_height = height;
 
130
        player->priv->video_width += PLAYER_BACON_WIDTH / 3;
 
131
        player->priv->video_height += PLAYER_BACON_HEIGHT / 3;
 
132
 
 
133
        if (player->priv->video_width >= PLAYER_BACON_WIDTH * 3 ||
 
134
            player->priv->video_height >= PLAYER_BACON_HEIGHT * 3) {
 
135
                player->priv->video_width = PLAYER_BACON_WIDTH * 3;
 
136
                player->priv->video_height = PLAYER_BACON_HEIGHT * 3;
 
137
        }
254
138
 
255
139
        gtk_widget_set_size_request (GTK_WIDGET (player->priv->bacon),
256
 
                                     width,
257
 
                                     height);
258
 
}
259
 
 
260
 
static void
261
 
brasero_player_video_zoom_in_button_cb (GtkButton *button,
262
 
                                        BraseroPlayer *player)
263
 
{
264
 
        brasero_player_video_zoom_in (player);
265
 
}
266
 
 
267
 
static gboolean
268
 
brasero_player_video_scroll (BraseroPlayerBacon *bacon,
269
 
                             GdkEventScroll *event,
270
 
                             BraseroPlayer *player)
271
 
{
272
 
        if (event->direction == GDK_SCROLL_UP)
273
 
                brasero_player_video_zoom_in (player);
274
 
        else
275
 
                brasero_player_video_zoom_out (player);
276
 
 
277
 
        return TRUE;
278
 
}
279
 
 
280
 
static void
281
 
brasero_player_update_position (BraseroPlayer *player)
282
 
{
283
 
        gdouble value;
284
 
        GtkAdjustment *adjustment;
285
 
        gchar *pos_string, *len_string, *result;
286
 
 
287
 
        if (!player->priv->progress || !player->priv->size)
288
 
                return;
289
 
 
290
 
        adjustment = gtk_range_get_adjustment (GTK_RANGE (player->priv->progress));
291
 
        len_string = brasero_units_get_time_string (player->priv->end - player->priv->start, FALSE, FALSE);
292
 
 
293
 
        value = gtk_range_get_value (GTK_RANGE (player->priv->progress));
294
 
        pos_string = brasero_units_get_time_string (value, FALSE, FALSE);
295
 
 
296
 
        /**
297
 
         * Translators: this is the position being played in the stream. The 
298
 
         * first %s is the position and the second %s is the whole length of
299
 
         * the stream. I chose to make that translatable in case some languages
300
 
         * don't allow the "/" */
301
 
        result = g_strdup_printf (_("%s / %s"), pos_string, len_string);
302
 
        g_free (len_string);
303
 
        g_free (pos_string);
304
 
 
305
 
        gtk_label_set_text (GTK_LABEL (player->priv->size), result);
306
 
        g_free (result);
307
 
}
308
 
 
309
 
static void
310
 
brasero_player_range_value_changed (GtkRange *range,
311
 
                                    BraseroPlayer *player)
312
 
{
313
 
        if (player->priv->state >= BACON_STATE_PAUSED && !player->priv->update_scale_id) {
314
 
                gdouble pos;
315
 
 
316
 
                /* user changed the value tell the player/pipeline */
317
 
                pos = gtk_range_get_value (GTK_RANGE (player->priv->progress));
318
 
                brasero_player_bacon_set_pos (BRASERO_PLAYER_BACON (player->priv->bacon), (gint64) pos + player->priv->start);
319
 
        }
320
 
 
321
 
        brasero_player_update_position (player);
322
 
}
323
 
 
324
 
static void
325
 
brasero_player_set_length (BraseroPlayer *player)
326
 
{
327
 
        if (player->priv->progress && player->priv->end - player->priv->start != 0)
328
 
                gtk_range_set_range (GTK_RANGE (player->priv->progress),
329
 
                                     0.0,
330
 
                                     (gdouble) player->priv->end - player->priv->start);
331
 
 
332
 
        brasero_player_update_position (player);
333
 
}
334
 
 
335
 
static gboolean
336
 
brasero_player_update_progress_cb (BraseroPlayer *player)
337
 
{
338
 
        gint64 pos;
339
 
 
340
 
        if (brasero_player_bacon_get_pos (BRASERO_PLAYER_BACON (player->priv->bacon), &pos) == TRUE) {
341
 
                gtk_range_set_value (GTK_RANGE (player->priv->progress), (gdouble) pos - player->priv->start);
342
 
 
343
 
                /* This is done on purpose with videos it wouldn't redraw automatically 
344
 
                 * I don't know why */
345
 
                gtk_widget_queue_draw (GTK_WIDGET (player->priv->progress));
346
 
        }
347
 
 
348
 
        return TRUE;
349
 
}
350
 
 
351
 
static gboolean
352
 
brasero_player_range_button_pressed_cb (GtkWidget *widget,
353
 
                                        GdkEvent *event,
354
 
                                        BraseroPlayer *player)
355
 
{
356
 
        /* stop the automatic update of progress bar position */
357
 
        if (player->priv->update_scale_id) {
358
 
                g_source_remove (player->priv->update_scale_id);
359
 
                player->priv->update_scale_id = 0;
360
 
        }
361
 
 
362
 
        return FALSE;
363
 
}
364
 
 
365
 
static gboolean
366
 
brasero_player_range_button_released_cb (GtkWidget *widget,
367
 
                                         GdkEvent *event,
368
 
                                         BraseroPlayer *player)
369
 
{
370
 
        /* restart the automatic update of progress bar */
371
 
        if (player->priv->state == BACON_STATE_PLAYING && !player->priv->update_scale_id)
372
 
                player->priv->update_scale_id = g_timeout_add (500,
373
 
                                                               (GSourceFunc) brasero_player_update_progress_cb,
374
 
                                                               player);
375
 
 
376
 
        return FALSE;
377
 
}
378
 
 
379
 
static void
380
 
brasero_player_button_clicked_cb (GtkButton *button,
381
 
                                  BraseroPlayer *player)
382
 
{
383
 
        if (player->priv->state == BACON_STATE_READY) {
384
 
                gtk_notebook_set_current_page (GTK_NOTEBOOK (player->priv->notebook), 2);
385
 
                brasero_player_bacon_set_uri (BRASERO_PLAYER_BACON (player->priv->bacon), player->priv->uri);
386
 
                brasero_player_bacon_play (BRASERO_PLAYER_BACON (player->priv->bacon));
387
 
        }
388
 
        else if (player->priv->state == BACON_STATE_PAUSED)
389
 
                brasero_player_bacon_play (BRASERO_PLAYER_BACON (player->priv->bacon));
390
 
        else if (player->priv->state == BACON_STATE_PLAYING)
391
 
                brasero_player_bacon_stop (BRASERO_PLAYER_BACON (player->priv->bacon));
392
 
}
393
 
 
394
 
static void
395
 
brasero_player_volume_changed_cb (GtkScaleButton *button,
396
 
                                  gdouble volume,
397
 
                                  BraseroPlayer *player)
398
 
{
399
 
        brasero_player_bacon_set_volume (BRASERO_PLAYER_BACON (player->priv->bacon),
400
 
                                         volume);
401
 
}
402
 
 
403
 
static void
404
 
brasero_player_create_controls_stream (BraseroPlayer *player,
405
 
                                       gboolean video)
406
 
{
407
 
        GtkAllocation allocation;
408
 
        GtkWidget *box = NULL;
409
 
        GtkWidget *header_box;
410
 
        GtkWidget *alignment;
411
 
        GtkWidget *volume;
412
 
        GtkWidget *image;
413
 
        
414
 
        if (player->priv->controls)
415
 
                brasero_player_destroy_controls (player);
416
 
 
417
 
        player->priv->controls = gtk_vbox_new (FALSE, 4);
418
 
 
419
 
        /* first line title */
420
 
        header_box = gtk_hbox_new (FALSE, 12);
421
 
        gtk_box_pack_start (GTK_BOX (player->priv->controls),
422
 
                            header_box,
423
 
                            FALSE,
424
 
                            FALSE,
425
 
                            0);
426
 
        
427
 
        player->priv->header = gtk_label_new (_("No file"));
428
 
        gtk_label_set_use_markup (GTK_LABEL (player->priv->header), TRUE);
429
 
        gtk_label_set_justify (GTK_LABEL (player->priv->header), GTK_JUSTIFY_LEFT);
430
 
        gtk_misc_set_alignment (GTK_MISC (player->priv->header), 0.0, 0.5);
431
 
        gtk_box_pack_start (GTK_BOX (header_box),
432
 
                            player->priv->header,
433
 
                            TRUE,
434
 
                            TRUE,
435
 
                            0);
436
 
 
437
 
        player->priv->size = gtk_label_new (NULL);
438
 
        gtk_widget_get_allocation (GTK_WIDGET (player), &allocation);
439
 
        if (allocation.width > allocation.height) {
440
 
                gtk_label_set_justify (GTK_LABEL (player->priv->size), GTK_JUSTIFY_RIGHT);
441
 
                gtk_misc_set_alignment (GTK_MISC (player->priv->size), 1.0, 0.0);
442
 
 
443
 
                gtk_box_pack_start (GTK_BOX (header_box),
444
 
                                    player->priv->size,
445
 
                                    FALSE,
446
 
                                    FALSE,
447
 
                                    0);
448
 
        }
449
 
        else {
450
 
                gtk_label_set_justify (GTK_LABEL (player->priv->size), GTK_JUSTIFY_LEFT);
451
 
                gtk_misc_set_alignment (GTK_MISC (player->priv->size), 0.0, 0.0);
452
 
 
453
 
                gtk_box_pack_start (GTK_BOX (player->priv->controls),
454
 
                                    player->priv->size,
455
 
                                    FALSE,
456
 
                                    FALSE,
457
 
                                    0);
458
 
        }
459
 
        
460
 
        /* second line : play, progress, volume button */
461
 
        box = gtk_hbox_new (FALSE, 12);
462
 
        gtk_box_pack_start (GTK_BOX (player->priv->controls),
463
 
                            box,
464
 
                            FALSE,
465
 
                            FALSE,
466
 
                            0);
467
 
 
468
 
        alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
469
 
        player->priv->button = gtk_toggle_button_new ();
470
 
        gtk_widget_set_tooltip_text (player->priv->button, _("Start and stop playing"));
471
 
        gtk_container_add (GTK_CONTAINER (alignment), player->priv->button);
472
 
        gtk_box_pack_start (GTK_BOX (box),
473
 
                            alignment,
474
 
                            FALSE,
475
 
                            FALSE,
476
 
                            0);
477
 
 
478
 
        image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_BUTTON);
479
 
        gtk_container_add (GTK_CONTAINER (player->priv->button), image);
480
 
        g_signal_connect (G_OBJECT (player->priv->button), "clicked",
481
 
                          G_CALLBACK (brasero_player_button_clicked_cb),
482
 
                          player);
483
 
 
484
 
        player->priv->progress = gtk_hscale_new_with_range (0, 1, 500000000);
485
 
        gtk_scale_set_digits (GTK_SCALE (player->priv->progress), 0);
486
 
        gtk_scale_set_draw_value (GTK_SCALE (player->priv->progress), FALSE);
487
 
        gtk_widget_set_size_request (player->priv->progress, 80, -1);
488
 
        gtk_range_set_update_policy (GTK_RANGE (player->priv->progress), GTK_UPDATE_CONTINUOUS);
489
 
        gtk_box_pack_start (GTK_BOX (box),
490
 
                          player->priv->progress,
491
 
                          TRUE,
492
 
                          TRUE,
493
 
                          0);
494
 
 
495
 
        g_signal_connect (G_OBJECT (player->priv->progress),
496
 
                          "button-press-event",
497
 
                          G_CALLBACK (brasero_player_range_button_pressed_cb), player);
498
 
        g_signal_connect (G_OBJECT (player->priv->progress),
499
 
                          "button-release-event",
500
 
                          G_CALLBACK (brasero_player_range_button_released_cb), player);
501
 
        g_signal_connect (G_OBJECT (player->priv->progress),
502
 
                          "value-changed",
503
 
                          G_CALLBACK (brasero_player_range_value_changed),
504
 
                          player);
505
 
 
506
 
        volume = gtk_volume_button_new ();
507
 
        gtk_widget_show (volume);
508
 
        gtk_box_pack_start (GTK_BOX (box),
509
 
                            volume,
510
 
                            FALSE,
511
 
                            FALSE,
512
 
                            0);
513
 
 
514
 
        if (player->priv->bacon)
515
 
                gtk_scale_button_set_value (GTK_SCALE_BUTTON (volume),
516
 
                                            brasero_player_bacon_get_volume (BRASERO_PLAYER_BACON (player->priv->bacon)));
517
 
 
518
 
        g_signal_connect (volume,
519
 
                          "value-changed",
520
 
                          G_CALLBACK (brasero_player_volume_changed_cb),
521
 
                          player);
522
 
 
523
 
        /* zoom in/out, only if video */
524
 
        if (video) {
525
 
                GtkWidget *image;
526
 
                GtkWidget *zoom;
527
 
                GtkWidget *hbox;
528
 
 
529
 
                box = gtk_hbox_new (FALSE, 12);
530
 
                gtk_box_pack_start (GTK_BOX (player->priv->controls),
531
 
                                    box,
532
 
                                    FALSE,
533
 
                                    FALSE,
534
 
                                    0);
535
 
 
536
 
                hbox = gtk_hbox_new (FALSE, 0);
537
 
                alignment = gtk_alignment_new (1.0, 0.0, 0.0, 0.0);
538
 
 
539
 
                gtk_container_add (GTK_CONTAINER (alignment), hbox);
540
 
                gtk_box_pack_start (GTK_BOX (box),
541
 
                                    alignment,
542
 
                                    TRUE,
543
 
                                    TRUE,
544
 
                                    0);
545
 
                
546
 
                image = gtk_image_new_from_stock (GTK_STOCK_ZOOM_OUT, GTK_ICON_SIZE_BUTTON);
547
 
                zoom = gtk_button_new ();
548
 
                gtk_button_set_image (GTK_BUTTON (zoom), image);
549
 
                gtk_button_set_relief (GTK_BUTTON (zoom), GTK_RELIEF_NONE);
550
 
                gtk_button_set_focus_on_click (GTK_BUTTON (zoom), FALSE);
551
 
                g_signal_connect (zoom,
552
 
                                  "clicked",
553
 
                                  G_CALLBACK (brasero_player_video_zoom_out_button_cb),
554
 
                                  player);
555
 
                gtk_box_pack_start (GTK_BOX (hbox),
556
 
                                    zoom,
557
 
                                    FALSE,
558
 
                                    FALSE,
559
 
                                    0);
560
 
                player->priv->video_zoom_out = zoom;
561
 
 
562
 
                image = gtk_image_new_from_stock (GTK_STOCK_ZOOM_IN, GTK_ICON_SIZE_BUTTON);
563
 
                zoom = gtk_button_new ();
564
 
                gtk_button_set_image (GTK_BUTTON (zoom), image);
565
 
                gtk_button_set_relief (GTK_BUTTON (zoom), GTK_RELIEF_NONE);
566
 
                gtk_button_set_focus_on_click (GTK_BUTTON (zoom), FALSE);
567
 
                g_signal_connect (zoom,
568
 
                                  "clicked",
569
 
                                  G_CALLBACK (brasero_player_video_zoom_in_button_cb),
570
 
                                  player);
571
 
                gtk_box_pack_start (GTK_BOX (hbox),
572
 
                                    zoom,
573
 
                                    FALSE,
574
 
                                    FALSE,
575
 
                                    0);
576
 
                player->priv->video_zoom_in = zoom;
577
 
 
578
 
                if (player->priv->video_height <= PLAYER_BACON_HEIGHT
579
 
                ||  player->priv->video_width  <= PLAYER_BACON_WIDTH)
580
 
                        gtk_widget_set_sensitive (player->priv->video_zoom_out, FALSE);
581
 
                else
582
 
                        gtk_widget_set_sensitive (player->priv->video_zoom_out, TRUE);
583
 
 
584
 
                if (player->priv->video_height >= PLAYER_BACON_HEIGHT * 3
585
 
                ||  player->priv->video_width  >= PLAYER_BACON_WIDTH * 3)
586
 
                        gtk_widget_set_sensitive (player->priv->video_zoom_in, FALSE);
587
 
                else
588
 
                        gtk_widget_set_sensitive (player->priv->video_zoom_in, TRUE);
589
 
 
590
 
                if (player->priv->video_width >= (allocation.width / 2)) {
591
 
                        gtk_box_pack_start (GTK_BOX (player->priv->vbox),
592
 
                                            player->priv->controls,
593
 
                                            TRUE,
594
 
                                            TRUE,
595
 
                                            0);
596
 
                        gtk_box_set_child_packing (GTK_BOX (player->priv->hbox),
597
 
                                                   gtk_widget_get_parent (player->priv->notebook),
598
 
                                                   TRUE,
599
 
                                                   TRUE,
600
 
                                                   0,
601
 
                                                   GTK_PACK_START);
602
 
                }
603
 
                else if (player->priv->video_width < (allocation.width / 2))
604
 
                        gtk_box_pack_start (GTK_BOX (player->priv->hbox),
605
 
                                            player->priv->controls,
606
 
                                            TRUE,
607
 
                                            TRUE,
608
 
                                            0);
609
 
        }
610
 
        else
611
 
                gtk_box_pack_end (GTK_BOX (player->priv->hbox),
612
 
                                  player->priv->controls,
613
 
                                  TRUE,
614
 
                                  TRUE,
615
 
                                  0);
616
 
 
617
 
        gtk_widget_show_all (player->priv->controls);
618
 
        gtk_alignment_set_padding (GTK_ALIGNMENT (player), 12, 0, 0, 0);
 
140
                                     player->priv->video_width,
 
141
                                     player->priv->video_height);
619
142
}
620
143
 
621
144
static gboolean
657
180
static void
658
181
brasero_player_image_zoom_in (BraseroPlayer *player)
659
182
{
660
 
        gtk_widget_set_sensitive (player->priv->image_zoom_out, TRUE);
661
 
 
662
183
        player->priv->image_width += PLAYER_BACON_WIDTH / 3;
663
184
        player->priv->image_height += PLAYER_BACON_HEIGHT / 3;
664
185
 
665
186
        if (player->priv->image_width >= PLAYER_BACON_WIDTH * 3 ||
666
187
            player->priv->image_height >= PLAYER_BACON_HEIGHT * 3) {
667
 
                gtk_widget_set_sensitive (player->priv->image_zoom_in, FALSE);
668
188
                player->priv->image_width = PLAYER_BACON_WIDTH * 3;
669
189
                player->priv->image_height = PLAYER_BACON_HEIGHT * 3;
670
190
        }
671
191
 
672
 
        brasero_player_scale_image (player);
673
 
}
674
 
 
675
 
static void
676
 
brasero_player_image_zoom_in_button_cb (GtkButton *button,
677
 
                                        BraseroPlayer *player)
678
 
{
679
 
        brasero_player_image_zoom_in (player);
 
192
        if (player->priv->pixbuf)
 
193
                brasero_player_scale_image (player);
680
194
}
681
195
 
682
196
static void
684
198
{
685
199
        gint min_height, min_width;
686
200
 
687
 
        gtk_widget_set_sensitive (player->priv->image_zoom_in, TRUE);
688
 
 
689
 
        min_width = MIN (PLAYER_BACON_WIDTH, gdk_pixbuf_get_width (player->priv->pixbuf));
690
 
        min_height = MIN (PLAYER_BACON_HEIGHT, gdk_pixbuf_get_height (player->priv->pixbuf));
 
201
        if (player->priv->pixbuf) {
 
202
                min_width = MIN (PLAYER_BACON_WIDTH, gdk_pixbuf_get_width (player->priv->pixbuf));
 
203
                min_height = MIN (PLAYER_BACON_HEIGHT, gdk_pixbuf_get_height (player->priv->pixbuf));
 
204
        }
 
205
        else {
 
206
                min_width = PLAYER_BACON_WIDTH;
 
207
                min_height = PLAYER_BACON_HEIGHT;
 
208
        }
691
209
 
692
210
        player->priv->image_width -= PLAYER_BACON_WIDTH / 3;
693
211
        player->priv->image_height -= PLAYER_BACON_HEIGHT / 3;
695
213
        /* the image itself */
696
214
        if (player->priv->image_width <= min_width ||
697
215
            player->priv->image_height <= min_height) {
698
 
                gtk_widget_set_sensitive (player->priv->image_zoom_out, FALSE);
699
216
                player->priv->image_width = min_width;
700
217
                player->priv->image_height = min_height;
701
218
        }
702
219
 
703
 
        brasero_player_scale_image (player);
704
 
}
705
 
 
706
 
static void
707
 
brasero_player_image_zoom_out_button_cb (GtkButton *button,
708
 
                                         BraseroPlayer *player)
 
220
        if (player->priv->pixbuf)
 
221
                brasero_player_scale_image (player);
 
222
}
 
223
 
 
224
static void
 
225
brasero_player_zoom_in_cb (GtkButton *button,
 
226
                           BraseroPlayer *player)
 
227
{
 
228
        brasero_player_image_zoom_in (player);
 
229
        brasero_player_video_zoom_in (player);
 
230
}
 
231
 
 
232
static void
 
233
brasero_player_zoom_out_cb (GtkButton *button,
 
234
                            BraseroPlayer *player)
709
235
{
710
236
        brasero_player_image_zoom_out (player);
711
 
}
712
 
 
713
 
static gboolean
714
 
brasero_player_image_scroll (BraseroPlayerBacon *bacon,
715
 
                             GdkEventScroll *event,
716
 
                             BraseroPlayer *player)
717
 
{
718
 
        if (event->direction == GDK_SCROLL_UP)
719
 
                brasero_player_image_zoom_in (player);
720
 
        else
721
 
                brasero_player_image_zoom_out (player);
722
 
 
723
 
        return TRUE;
724
 
}
725
 
 
726
 
static void
727
 
brasero_player_create_controls_image (BraseroPlayer *player)
728
 
{
729
 
        GtkWidget *box, *zoom;
730
 
        GtkWidget *image;
731
 
        GtkAllocation allocation;
732
 
 
733
 
        if (player->priv->image_display)
734
 
                gtk_widget_set_sensitive (player->priv->image_display, TRUE);
735
 
 
736
 
        player->priv->controls = gtk_vbox_new (FALSE, 4);
737
 
 
738
 
        gtk_widget_get_allocation (GTK_WIDGET (player), &allocation);
739
 
        if (allocation.width > allocation.height)
740
 
                gtk_box_pack_end (GTK_BOX (player->priv->hbox),
741
 
                                  player->priv->controls,
742
 
                                  TRUE,
743
 
                                  TRUE,
744
 
                                  0);
745
 
        else
746
 
                gtk_box_pack_end (GTK_BOX (player->priv->vbox),
747
 
                                  player->priv->controls,
748
 
                                  TRUE,
749
 
                                  TRUE,
750
 
                                  0);
751
 
 
752
 
        player->priv->header = gtk_label_new (NULL);
753
 
        gtk_misc_set_alignment (GTK_MISC (player->priv->header), 0.0, 0.5);
754
 
        gtk_box_pack_start (GTK_BOX (player->priv->controls),
755
 
                            player->priv->header,
756
 
                            FALSE,
757
 
                            FALSE,
758
 
                            0);
759
 
 
760
 
        player->priv->size = gtk_label_new (NULL);
761
 
        gtk_misc_set_alignment (GTK_MISC (player->priv->size), 0.0, 0.5);
762
 
        gtk_box_pack_start (GTK_BOX (player->priv->controls),
763
 
                            player->priv->size,
764
 
                            FALSE,
765
 
                            FALSE,
766
 
                            0);
767
 
 
768
 
        box = gtk_hbox_new (FALSE, 0);
769
 
        gtk_box_pack_start (GTK_BOX (player->priv->controls),
770
 
                            box,
771
 
                            FALSE,
772
 
                            FALSE,
773
 
                            0);
774
 
 
775
 
        image = gtk_image_new_from_stock (GTK_STOCK_ZOOM_OUT, GTK_ICON_SIZE_BUTTON);
776
 
        zoom = gtk_button_new ();
777
 
        gtk_button_set_image (GTK_BUTTON (zoom), image);
778
 
        gtk_button_set_relief (GTK_BUTTON (zoom), GTK_RELIEF_NONE);
779
 
        gtk_button_set_focus_on_click (GTK_BUTTON (zoom), FALSE);
780
 
        g_signal_connect (zoom,
781
 
                          "clicked",
782
 
                          G_CALLBACK (brasero_player_image_zoom_out_button_cb),
783
 
                          player);
784
 
        gtk_box_pack_start (GTK_BOX (box),
785
 
                            zoom,
786
 
                            FALSE,
787
 
                            FALSE,
788
 
                            0);
789
 
        player->priv->image_zoom_out = zoom;
790
 
 
791
 
        image = gtk_image_new_from_stock (GTK_STOCK_ZOOM_IN, GTK_ICON_SIZE_BUTTON);
792
 
        zoom = gtk_button_new ();
793
 
        gtk_button_set_image (GTK_BUTTON (zoom), image);
794
 
        gtk_button_set_relief (GTK_BUTTON (zoom), GTK_RELIEF_NONE);
795
 
        gtk_button_set_focus_on_click (GTK_BUTTON (zoom), FALSE);
796
 
        g_signal_connect (zoom,
797
 
                          "clicked",
798
 
                          G_CALLBACK (brasero_player_image_zoom_in_button_cb),
799
 
                          player);
800
 
        gtk_box_pack_start (GTK_BOX (box),
801
 
                            zoom,
802
 
                            FALSE,
803
 
                            FALSE,
804
 
                            0);
805
 
        player->priv->image_zoom_in = zoom;
806
 
 
807
 
        gtk_widget_show_all (player->priv->controls);
808
 
        gtk_alignment_set_padding (GTK_ALIGNMENT (player), 12, 0, 0, 0);
 
237
        brasero_player_video_zoom_out (player);
 
238
}
 
239
 
 
240
static gboolean
 
241
brasero_bacon_scroll (BraseroPlayerBacon *bacon,
 
242
                      GdkEventScroll *event,
 
243
                      BraseroPlayer *player)
 
244
{
 
245
        switch (gtk_notebook_get_current_page (GTK_NOTEBOOK (player->priv->notebook))) {
 
246
        case 1:
 
247
        case 4:
 
248
                if (event->direction == GDK_SCROLL_UP)
 
249
                        brasero_player_bacon_forward (bacon, GST_SECOND);
 
250
                else
 
251
                        brasero_player_bacon_backward (bacon, GST_SECOND);
 
252
                break;
 
253
 
 
254
        case 0:
 
255
        case 2:
 
256
        case 3:
 
257
        default:
 
258
                if (event->direction == GDK_SCROLL_UP) {
 
259
                        brasero_player_image_zoom_in (player);
 
260
                        brasero_player_video_zoom_in (player);
 
261
                }
 
262
                else {
 
263
                        brasero_player_image_zoom_out (player);
 
264
                        brasero_player_video_zoom_out (player);
 
265
                }
 
266
                break;
 
267
        }
 
268
 
 
269
        return TRUE;
 
270
}
 
271
 
 
272
static gboolean
 
273
brasero_bacon_button_release (BraseroPlayerBacon *bacon,
 
274
                              GdkEventButton *event,
 
275
                              BraseroPlayer *player)
 
276
{
 
277
        if (event->button != 1)
 
278
                return FALSE;
 
279
 
 
280
        if (player->priv->state == BACON_STATE_READY) {
 
281
                /* This will probably never happen as we display a play button */
 
282
                gtk_image_set_from_stock (GTK_IMAGE (player->priv->play_image), GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_DIALOG);
 
283
                gtk_notebook_set_current_page (GTK_NOTEBOOK (player->priv->notebook), 1);
 
284
                brasero_player_bacon_set_uri (BRASERO_PLAYER_BACON (player->priv->bacon), player->priv->uri);
 
285
                brasero_player_bacon_play (BRASERO_PLAYER_BACON (player->priv->bacon));
 
286
        }
 
287
        else if (player->priv->state == BACON_STATE_PAUSED) {
 
288
                gtk_image_set_from_stock (GTK_IMAGE (player->priv->play_image), GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_DIALOG);
 
289
                gtk_notebook_set_current_page (GTK_NOTEBOOK (player->priv->notebook), 1);
 
290
                brasero_player_bacon_play (BRASERO_PLAYER_BACON (player->priv->bacon));
 
291
        }
 
292
        else if (player->priv->state == BACON_STATE_PLAYING) {
 
293
                gtk_image_set_from_stock (GTK_IMAGE (player->priv->play_image), GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_DIALOG);
 
294
                gtk_notebook_set_current_page (GTK_NOTEBOOK (player->priv->notebook), 4);
 
295
                brasero_player_bacon_stop (BRASERO_PLAYER_BACON (player->priv->bacon));
 
296
        }
 
297
 
 
298
        return TRUE;
 
299
}
 
300
 
 
301
static gboolean
 
302
brasero_player_button_release (GtkWidget *widget,
 
303
                               GdkEventButton *event,
 
304
                               BraseroPlayer *player)
 
305
{
 
306
        if (event->button != 1)
 
307
                return FALSE;
 
308
 
 
309
        if (gtk_notebook_get_current_page (GTK_NOTEBOOK (player->priv->notebook)) == 4) {
 
310
                if (player->priv->state == BACON_STATE_READY) {
 
311
                        gtk_image_set_from_stock (GTK_IMAGE (player->priv->play_image), GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_DIALOG);
 
312
                        if (player->priv->is_video)
 
313
                                gtk_notebook_set_current_page (GTK_NOTEBOOK (player->priv->notebook), 1);
 
314
 
 
315
                        brasero_player_bacon_set_uri (BRASERO_PLAYER_BACON (player->priv->bacon), player->priv->uri);
 
316
                        brasero_player_bacon_play (BRASERO_PLAYER_BACON (player->priv->bacon));
 
317
                }
 
318
                else if (player->priv->state == BACON_STATE_PAUSED) {
 
319
                        gtk_image_set_from_stock (GTK_IMAGE (player->priv->play_image), GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_DIALOG);
 
320
                        if (player->priv->is_video)
 
321
                                gtk_notebook_set_current_page (GTK_NOTEBOOK (player->priv->notebook), 1);
 
322
 
 
323
                        brasero_player_bacon_play (BRASERO_PLAYER_BACON (player->priv->bacon));
 
324
                }
 
325
                else if (player->priv->state == BACON_STATE_PLAYING) {
 
326
                        gtk_image_set_from_stock (GTK_IMAGE (player->priv->play_image), GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_DIALOG);
 
327
                        brasero_player_bacon_stop (BRASERO_PLAYER_BACON (player->priv->bacon));
 
328
                }
 
329
        }
 
330
 
 
331
        return TRUE;
 
332
}
 
333
 
 
334
static gboolean
 
335
brasero_player_scroll (GtkWidget *widget,
 
336
                       GdkEventScroll *event,
 
337
                       BraseroPlayer *player)
 
338
{
 
339
        switch (gtk_notebook_get_current_page (GTK_NOTEBOOK (player->priv->notebook))) {
 
340
        case 1:
 
341
        case 4:
 
342
                if (event->direction == GDK_SCROLL_UP)
 
343
                        brasero_player_bacon_forward (BRASERO_PLAYER_BACON (player->priv->bacon), GST_SECOND);
 
344
                else
 
345
                        brasero_player_bacon_backward (BRASERO_PLAYER_BACON (player->priv->bacon), GST_SECOND);
 
346
                break;
 
347
 
 
348
        case 0:
 
349
        case 2:
 
350
        case 3:
 
351
        default:
 
352
                if (event->direction == GDK_SCROLL_UP) {
 
353
                        brasero_player_image_zoom_in (player);
 
354
                        brasero_player_video_zoom_in (player);
 
355
                }
 
356
                else {
 
357
                        brasero_player_image_zoom_out (player);
 
358
                        brasero_player_video_zoom_out (player);
 
359
                }
 
360
                break;
 
361
        }
 
362
 
 
363
        return TRUE;
809
364
}
810
365
 
811
366
static void
812
367
brasero_player_image (BraseroPlayer *player)
813
368
{
814
369
        GError *error = NULL;
815
 
        gint width, height;
816
 
        gchar *string;
817
370
        gchar *path;
818
 
        gchar *name;
819
371
 
820
372
        if (player->priv->pixbuf) {
821
373
                g_object_unref (player->priv->pixbuf);
834
386
                }
835
387
 
836
388
                brasero_player_no_multimedia_stream (player);
837
 
 
838
389
                g_free (path);
839
390
                return;
840
391
        }
841
 
 
842
 
        height = gdk_pixbuf_get_height (player->priv->pixbuf);
843
 
        width = gdk_pixbuf_get_width (player->priv->pixbuf);
844
 
 
 
392
        
845
393
        brasero_player_scale_image (player);
846
394
 
847
 
        /* display information about the image */
848
 
        brasero_player_create_controls_image (player);
849
 
 
850
 
        if (player->priv->image_height <= MIN (PLAYER_BACON_HEIGHT, gdk_pixbuf_get_height (player->priv->pixbuf))
851
 
        ||  player->priv->image_width  <= MIN (PLAYER_BACON_WIDTH, gdk_pixbuf_get_width (player->priv->pixbuf)))
852
 
                gtk_widget_set_sensitive (player->priv->image_zoom_out, FALSE);
853
 
        else
854
 
                gtk_widget_set_sensitive (player->priv->image_zoom_out, TRUE);
855
 
 
856
 
        if (player->priv->image_height >= PLAYER_BACON_HEIGHT * 3
857
 
        ||  player->priv->image_width  >= PLAYER_BACON_WIDTH * 3)
858
 
                gtk_widget_set_sensitive (player->priv->image_zoom_in, FALSE);
859
 
        else
860
 
                gtk_widget_set_sensitive (player->priv->image_zoom_in, TRUE);
861
 
 
862
 
        BRASERO_GET_BASENAME_FOR_DISPLAY (path, name);
863
 
        g_free (path);
864
 
 
865
 
        string = g_strdup_printf ("<span weight=\"bold\">%s</span>\t %s",
866
 
                                  _("Name:"),
867
 
                                  name);
868
 
        g_free (name);
869
 
 
870
 
        gtk_label_set_markup (GTK_LABEL (player->priv->header), string);
871
 
        g_free (string);
872
 
 
873
 
        string = g_strdup_printf (_("<span weight=\"bold\">Size:</span>\t<i><span size=\"smaller\"> %i \303\227 %i pixels</span></i>"), width, height);
874
 
        gtk_label_set_markup (GTK_LABEL (player->priv->size), string);
875
 
        g_free (string);
876
 
 
877
 
        gtk_widget_hide (player->priv->bacon);
878
 
        gtk_widget_show (player->priv->image_event);
879
395
        gtk_widget_show (player->priv->notebook);
880
 
        gtk_alignment_set_padding (GTK_ALIGNMENT (player), 12, 0, 0, 0);
881
 
 
 
396
        gtk_notebook_set_current_page (GTK_NOTEBOOK (player->priv->notebook), 0);
882
397
        g_signal_emit (player,
883
398
                       brasero_player_signals [READY_SIGNAL],
884
399
                       0);
885
400
}
886
401
 
887
402
static void
888
 
brasero_player_update_info_real (BraseroPlayer *player,
889
 
                                 const gchar *artist,
890
 
                                 const gchar *title)
 
403
brasero_player_update_tooltip (BraseroPlayer *player,
 
404
                               GFileInfo *info)
891
405
{
892
 
        gchar *header;
893
 
 
894
 
        brasero_player_set_length (player);
895
 
        if (artist && title) {
896
 
                header = g_markup_printf_escaped (_("<span weight=\"bold\">%s</span>\nby <span size=\"smaller\"><i>%s</i></span>"),
897
 
                                                  title,
898
 
                                                  artist);
899
 
                gtk_label_set_ellipsize (GTK_LABEL (player->priv->header),
900
 
                                         PANGO_ELLIPSIZE_END);
901
 
 
902
 
        }
903
 
        else if (title) {
904
 
                header = g_markup_printf_escaped ("<span weight=\"bold\">%s</span>\n", title);
905
 
                gtk_label_set_ellipsize (GTK_LABEL (player->priv->header),
906
 
                                         PANGO_ELLIPSIZE_END);
907
 
        }
 
406
        gchar *string;
 
407
        gchar *len_string;
 
408
        const gchar *title;
 
409
        const gchar *artist;
 
410
 
 
411
        /* Update the tooltip */
 
412
        len_string = brasero_units_get_time_string (g_file_info_get_attribute_uint64 (info, BRASERO_IO_LEN), TRUE, FALSE);
 
413
        title = g_file_info_get_attribute_string (info, BRASERO_IO_TITLE);
 
414
        artist = g_file_info_get_attribute_string (info, BRASERO_IO_ARTIST);
 
415
        if (artist) {
 
416
                gchar *artist_string;
 
417
 
 
418
                /* Translators: %s is the name of the artist */
 
419
                artist_string = g_strdup_printf (_("by %s"), artist);
 
420
                string = g_markup_printf_escaped ("<span weight=\"bold\">%s</span>"
 
421
                                                  "\n<i><span size=\"smaller\">%s</span></i>"
 
422
                                                  "\n%s",
 
423
                                                  title,
 
424
                                                  artist_string,
 
425
                                                  len_string);
 
426
                g_free (artist_string);
 
427
        }
 
428
        else if (title)
 
429
                string = g_markup_printf_escaped ("<span weight=\"bold\">%s</span>"
 
430
                                                  "\n%s",
 
431
                                                  title,
 
432
                                                  len_string);
908
433
        else {
909
434
                gchar *name;
 
435
                gchar *unescaped_uri;
910
436
 
911
 
                BRASERO_GET_BASENAME_FOR_DISPLAY (player->priv->uri, name);
912
 
                header = g_markup_printf_escaped ("<span weight=\"bold\">%s</span>\n", name);
 
437
                unescaped_uri = g_uri_unescape_string (player->priv->uri, NULL);
 
438
                name = g_path_get_basename (unescaped_uri);
 
439
                g_free (unescaped_uri);
 
440
                string = g_markup_printf_escaped ("<span weight=\"bold\">%s</span>"
 
441
                                                  "\n%s",
 
442
                                                  name,
 
443
                                                  len_string);
913
444
                g_free (name);
914
 
                gtk_label_set_ellipsize (GTK_LABEL (player->priv->header),
915
 
                                         PANGO_ELLIPSIZE_END);
916
445
        }
917
446
 
918
 
        gtk_label_set_markup (GTK_LABEL (player->priv->header), header);
919
 
        g_free (header);
 
447
        g_free (len_string);
 
448
 
 
449
        gtk_widget_set_tooltip_markup (GTK_WIDGET (player), string);
 
450
        g_free (string);
920
451
}
921
452
 
922
453
static void
929
460
        BraseroPlayer *player = BRASERO_PLAYER (obj);
930
461
        const gchar *mime;
931
462
 
 
463
        gtk_spinner_stop (GTK_SPINNER (player->priv->spinner));
 
464
 
932
465
        if (player->priv->pixbuf) {
933
466
                gtk_image_set_from_pixbuf (GTK_IMAGE (player->priv->image_display), NULL);
934
467
                g_object_unref (player->priv->pixbuf);
935
468
                player->priv->pixbuf = NULL;
936
469
        }
937
470
 
938
 
        if (player->priv->controls)
939
 
                brasero_player_destroy_controls (player);
940
 
 
941
471
        if (error) {
942
472
                brasero_player_no_multimedia_stream (player);
943
473
                g_signal_emit (player,
958
488
                        return;
959
489
                }
960
490
 
961
 
                /* video */
962
 
                brasero_player_create_controls_stream (player, TRUE);
963
 
                gtk_range_set_value (GTK_RANGE (player->priv->progress), 0.0);
964
 
                if (g_file_info_get_attribute_boolean (info,BRASERO_IO_IS_SEEKABLE))
965
 
                        gtk_widget_set_sensitive (player->priv->progress, TRUE);
966
 
                else
967
 
                        gtk_widget_set_sensitive (player->priv->progress, FALSE);
 
491
                /* video: display play button first */
 
492
                player->priv->is_video = TRUE;
 
493
                gtk_image_set_from_stock (GTK_IMAGE (player->priv->play_image), GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_DIALOG);
 
494
                gtk_notebook_set_current_page (GTK_NOTEBOOK (player->priv->notebook), 4);
968
495
 
969
 
                gtk_widget_show (player->priv->bacon);
970
 
                gtk_widget_hide (player->priv->image_event);
971
 
                gtk_widget_show (player->priv->notebook);
 
496
                brasero_player_update_tooltip (player, info);
972
497
        }
973
498
        else if (g_file_info_get_attribute_boolean (info, BRASERO_IO_HAS_AUDIO)) {
974
499
                if (g_file_info_get_attribute_uint64 (info, BRASERO_IO_LEN) <= 0) {
979
504
                        return;
980
505
                }
981
506
 
982
 
                /* audio */
983
 
                brasero_player_create_controls_stream (player, FALSE);
984
 
                gtk_widget_hide (player->priv->notebook);
985
 
                gtk_range_set_value (GTK_RANGE (player->priv->progress), 0.0);
 
507
                /* Audio */
 
508
                player->priv->is_video = FALSE;
 
509
                gtk_image_set_from_stock (GTK_IMAGE (player->priv->play_image), GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_DIALOG);
 
510
                gtk_notebook_set_current_page (GTK_NOTEBOOK (player->priv->notebook), 4);
986
511
 
987
 
                if (g_file_info_get_attribute_boolean (info, BRASERO_IO_IS_SEEKABLE))
988
 
                        gtk_widget_set_sensitive (player->priv->progress, TRUE);
989
 
                else
990
 
                        gtk_widget_set_sensitive (player->priv->progress, FALSE);
 
512
                brasero_player_update_tooltip (player, info);
991
513
        }
992
514
        else if (mime && !strncmp ("image/", mime, 6)) {
 
515
                gchar *size_string;
 
516
                gchar *string;
 
517
                gchar *path;
 
518
                gchar *name;
 
519
                gint height;
 
520
                gint width;
 
521
 
993
522
                /* Only do that if the image is < 20 M otherwise that's crap
994
523
                 * FIXME: maybe a sort of error message here? or use thumbnail? */
995
524
                if (g_file_info_get_size (info) > 100000000LL) {
997
526
                        g_signal_emit (player,
998
527
                                       brasero_player_signals [ERROR_SIGNAL],
999
528
                                       0);
 
529
                        return;
1000
530
                }
1001
 
                else
1002
 
                        brasero_player_image (player);
1003
 
 
 
531
 
 
532
                brasero_player_image (player);
 
533
 
 
534
                path = g_filename_from_uri (player->priv->uri, NULL, NULL);
 
535
                BRASERO_GET_BASENAME_FOR_DISPLAY (path, name);
 
536
                g_free (path);
 
537
 
 
538
                height = gdk_pixbuf_get_height (player->priv->pixbuf);
 
539
                width = gdk_pixbuf_get_width (player->priv->pixbuf);
 
540
                size_string = g_strdup_printf (_("%i \303\227 %i pixels"), width, height);
 
541
 
 
542
                string = g_strdup_printf ("<span weight=\"bold\">%s</span>\n"
 
543
                                          "<i><span size=\"smaller\">%s</span></i>",
 
544
                                          name,
 
545
                                          size_string);
 
546
                g_free (name);
 
547
                g_free (size_string);
 
548
 
 
549
                gtk_widget_set_tooltip_markup (GTK_WIDGET (player), string);
 
550
                g_free (string);
1004
551
                return;
1005
552
        }
1006
553
        else {
1016
563
 
1017
564
        player->priv->length = g_file_info_get_attribute_uint64 (info, BRASERO_IO_LEN);
1018
565
 
1019
 
        /* only reached for audio/video */
1020
 
        brasero_player_update_info_real (player,
1021
 
                                         g_file_info_get_attribute_string (info, BRASERO_IO_ARTIST),
1022
 
                                         g_file_info_get_attribute_string (info, BRASERO_IO_TITLE));
1023
 
 
1024
566
        player->priv->state = BACON_STATE_READY;
1025
567
        g_signal_emit (player,
1026
568
                       brasero_player_signals [READY_SIGNAL],
1043
585
                                  NULL);
1044
586
}
1045
587
 
1046
 
const gchar *
1047
 
brasero_player_get_uri (BraseroPlayer *player)
1048
 
{
1049
 
        return player->priv->uri;
1050
 
}
1051
 
 
1052
588
void
1053
589
brasero_player_set_boundaries (BraseroPlayer *player, 
1054
590
                               gint64 start,
1064
600
        else
1065
601
                player->priv->end = end;
1066
602
 
1067
 
        if (player->priv->progress) {
1068
 
                brasero_player_set_length (player);
1069
 
                gtk_range_set_value (GTK_RANGE (player->priv->progress), 0);
1070
 
        }
1071
 
 
1072
603
        if (player->priv->bacon)
1073
604
                brasero_player_bacon_set_boundaries (BRASERO_PLAYER_BACON (player->priv->bacon),
1074
605
                                                     player->priv->start,
1079
610
brasero_player_set_uri (BraseroPlayer *player,
1080
611
                        const gchar *uri)
1081
612
{
1082
 
        gchar *name;
1083
 
 
1084
613
        /* avoid reloading everything if it's the same uri */
1085
 
        if (uri && player->priv->uri
1086
 
        && !strcmp (uri, player->priv->uri)) {
 
614
        if (!g_strcmp0 (uri, player->priv->uri)) {
1087
615
                /* if it's not loaded yet just return */
1088
 
                if (!player->priv->controls)
1089
 
                        return;
1090
 
 
1091
 
                if (player->priv->progress) {
1092
 
                        brasero_player_bacon_set_uri (BRASERO_PLAYER_BACON (player->priv->bacon), uri);
1093
 
                        brasero_player_set_boundaries (player, -1, -1);
1094
 
 
1095
 
                        /* the existence of progress is the surest way to know
1096
 
                         * if that uri was successfully loaded */
 
616
                /* the existence of progress is the surest way to know
 
617
                 * if that uri was successfully loaded */
 
618
                if (uri)
1097
619
                        g_signal_emit (player,
1098
620
                                       brasero_player_signals [READY_SIGNAL],
1099
621
                                       0);
1100
 
                }
1101
 
 
 
622
                else
 
623
                        g_signal_emit (player,
 
624
                                       brasero_player_signals [ERROR_SIGNAL],
 
625
                                       0);
1102
626
                return;
1103
627
        }
1104
628
 
1115
639
 
1116
640
        /* That stops the pipeline from playing */
1117
641
        brasero_player_bacon_set_uri (BRASERO_PLAYER_BACON (player->priv->bacon), NULL);
1118
 
 
1119
642
        if (!uri) {
1120
643
                brasero_player_no_multimedia_stream (player);
1121
 
                brasero_player_destroy_controls (player);
1122
644
                return;
1123
645
        }
1124
646
 
1125
 
        if (player->priv->controls) {
1126
 
                if (player->priv->header) {
1127
 
                        gchar *song_uri;
1128
 
 
1129
 
                        BRASERO_GET_BASENAME_FOR_DISPLAY (uri, name);
1130
 
                        song_uri = g_markup_printf_escaped (_("<span weight=\"bold\">Loading information</span>\nabout <span size=\"smaller\"><i>%s</i></span>"),
1131
 
                                                          name);
1132
 
                        g_free (name);
1133
 
 
1134
 
                        gtk_label_set_markup (GTK_LABEL (player->priv->header), song_uri);
1135
 
                        g_free (song_uri);
1136
 
                }
1137
 
 
1138
 
                /* grey out the rest of the control while it's loading */
1139
 
                if (player->priv->progress) {
1140
 
                        gtk_widget_set_sensitive (player->priv->progress, FALSE);
1141
 
                        gtk_range_set_value (GTK_RANGE (player->priv->progress), 0);
1142
 
                }
1143
 
 
1144
 
                if (player->priv->size)
1145
 
                        gtk_label_set_text (GTK_LABEL (player->priv->size), NULL);
1146
 
 
1147
 
                if (player->priv->button) {
1148
 
                        gtk_widget_set_sensitive (player->priv->button, FALSE);
1149
 
                        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (player->priv->button), FALSE);
1150
 
                }
1151
 
                
1152
 
                if (player->priv->image_zoom_in)
1153
 
                        gtk_widget_set_sensitive (player->priv->image_zoom_in, FALSE);
1154
 
 
1155
 
                if (player->priv->image_zoom_out)
1156
 
                        gtk_widget_set_sensitive (player->priv->image_zoom_out, FALSE);
1157
 
 
1158
 
                if (player->priv->video_zoom_in)
1159
 
                        gtk_widget_set_sensitive (player->priv->video_zoom_in, FALSE);
1160
 
 
1161
 
                if (player->priv->video_zoom_out)
1162
 
                        gtk_widget_set_sensitive (player->priv->video_zoom_out, FALSE);
1163
 
 
1164
 
                if (player->priv->image_display)
1165
 
                        gtk_widget_set_sensitive (player->priv->image_display, FALSE);
1166
 
        }
 
647
        gtk_widget_set_has_tooltip (GTK_WIDGET (player), FALSE);
 
648
        gtk_notebook_set_current_page (GTK_NOTEBOOK (player->priv->notebook), 3);
 
649
        gtk_spinner_start (GTK_SPINNER (player->priv->spinner));
1167
650
 
1168
651
        brasero_player_retrieve_metadata (player);
1169
652
}
1171
654
static void
1172
655
brasero_player_eof_cb (BraseroPlayerBacon *bacon, BraseroPlayer *player)
1173
656
{
1174
 
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (player->priv->button), FALSE);
1175
 
 
1176
 
        if (player->priv->update_scale_id) {
1177
 
                g_source_remove (player->priv->update_scale_id);
1178
 
                player->priv->update_scale_id = 0;
1179
 
        }
1180
 
 
1181
 
        gtk_range_set_value (GTK_RANGE (player->priv->progress), 0.0);
1182
657
        brasero_player_bacon_stop (BRASERO_PLAYER_BACON (player->priv->bacon));
1183
658
        brasero_player_bacon_set_pos (BRASERO_PLAYER_BACON (player->priv->bacon), player->priv->start);
1184
659
        player->priv->state = BACON_STATE_PAUSED;
 
660
        gtk_image_set_from_stock (GTK_IMAGE (player->priv->play_image), GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_DIALOG);
1185
661
}
1186
662
 
1187
663
static void
1197
673
                brasero_player_no_multimedia_stream (player);
1198
674
                break;
1199
675
 
1200
 
        case BACON_STATE_PAUSED:
1201
 
                gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (player->priv->button), FALSE); 
1202
 
                if (player->priv->update_scale_id) {
1203
 
                        g_source_remove (player->priv->update_scale_id);
1204
 
                        player->priv->update_scale_id = 0;
1205
 
                }
1206
 
                break;
1207
 
 
1208
 
        case BACON_STATE_PLAYING:
1209
 
                if (player->priv->state == BACON_STATE_READY) {
1210
 
                        gdouble pos;
1211
 
 
1212
 
                        pos = gtk_range_get_value (GTK_RANGE (player->priv->progress));
1213
 
                        brasero_player_bacon_set_pos (BRASERO_PLAYER_BACON (player->priv->bacon), pos + player->priv->start);
1214
 
 
1215
 
                        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (player->priv->button), TRUE);
1216
 
 
1217
 
                        if (!player->priv->update_scale_id)
1218
 
                        player->priv->update_scale_id = g_timeout_add (500,
1219
 
                                                                       (GSourceFunc) brasero_player_update_progress_cb,
1220
 
                                                                       player);
1221
 
                }
1222
 
 
1223
 
                break;
1224
 
 
1225
676
        default:
1226
677
                break;
1227
678
        }
1229
680
        player->priv->state = state;
1230
681
}
1231
682
 
1232
 
gint64
1233
 
brasero_player_get_length (BraseroPlayer *self)
1234
 
{
1235
 
        if (!self->priv->bacon)
1236
 
                return -1;
1237
 
 
1238
 
        return self->priv->end - self->priv->start;
1239
 
}
1240
 
 
1241
 
gint64
1242
 
brasero_player_get_pos (BraseroPlayer *self)
1243
 
{
1244
 
        gdouble pos;
1245
 
 
1246
 
        if (!self->priv->bacon)
1247
 
                return -1;
1248
 
 
1249
 
        pos = gtk_range_get_value (GTK_RANGE (self->priv->progress));
1250
 
 
1251
 
        return pos;
1252
 
}
1253
 
 
1254
 
static void
1255
 
brasero_player_size_allocate (GtkWidget *widget,
1256
 
                              GtkAllocation *allocation)
1257
 
{
1258
 
        BraseroPlayer *player;
1259
 
        GtkWidget *parent;
1260
 
 
1261
 
        player = BRASERO_PLAYER (widget);
1262
 
        if (!player->priv->controls) {
1263
 
                GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation);
1264
 
                return;
1265
 
        }
1266
 
 
1267
 
        if (!player->priv->pixbuf) {
1268
 
                GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation);
1269
 
                return;
1270
 
        }
1271
 
 
1272
 
        parent = gtk_widget_get_parent (player->priv->controls);
1273
 
 
1274
 
        g_object_ref (player->priv->controls);
1275
 
 
1276
 
        if (allocation->width > allocation->height) {
1277
 
                if (parent != player->priv->hbox) {
1278
 
                        gtk_container_remove (GTK_CONTAINER (player->priv->vbox), player->priv->controls);
1279
 
                        gtk_box_pack_end (GTK_BOX (player->priv->hbox),
1280
 
                                          player->priv->controls,
1281
 
                                          TRUE,
1282
 
                                          TRUE,
1283
 
                                          0);
1284
 
                }
1285
 
        }
1286
 
        else {
1287
 
                if (parent != player->priv->vbox) {
1288
 
                        gtk_container_remove (GTK_CONTAINER (player->priv->hbox), player->priv->controls);
1289
 
                        gtk_box_pack_end (GTK_BOX (player->priv->vbox),
1290
 
                                          player->priv->controls,
1291
 
                                          TRUE,
1292
 
                                          TRUE,
1293
 
                                          0);
1294
 
                }
1295
 
        }
1296
 
 
1297
 
        g_object_unref (player->priv->controls);
1298
 
        gtk_widget_show (player->priv->controls);
1299
 
 
1300
 
        GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation);
1301
 
}
1302
 
 
1303
 
static void
1304
 
brasero_player_destroy (GtkObject *obj)
 
683
static void
 
684
brasero_player_destroy (GtkWidget *obj)
1305
685
{
1306
686
        BraseroPlayer *player;
1307
687
 
1317
697
                                   BRASERO_SETTING_VIDEO_SIZE_WIDTH,
1318
698
                                   GINT_TO_POINTER (player->priv->video_width));
1319
699
        brasero_setting_set_value (brasero_setting_get_default (),
1320
 
                                   BRASERO_SETTING_VIDEO_SIZE_WIDTH,
1321
 
                                   GINT_TO_POINTER (player->priv->video_width));
 
700
                                   BRASERO_SETTING_VIDEO_SIZE_HEIGHT,
 
701
                                   GINT_TO_POINTER (player->priv->video_height));
1322
702
 
1323
703
        if (player->priv->pixbuf) {
1324
704
                g_object_unref (player->priv->pixbuf);
1325
705
                player->priv->pixbuf = NULL;
1326
706
        }
1327
707
 
1328
 
        if (player->priv->update_scale_id) {
1329
 
                g_source_remove (player->priv->update_scale_id);
1330
 
                player->priv->update_scale_id = 0;
1331
 
        }
1332
 
 
1333
708
        if (player->priv->uri) {
1334
709
                g_free (player->priv->uri);
1335
710
                player->priv->uri = NULL;
1341
716
                player->priv->meta_task = 0;
1342
717
        }
1343
718
 
1344
 
        if (GTK_OBJECT_CLASS (parent_class)->destroy)
1345
 
                GTK_OBJECT_CLASS (parent_class)->destroy (obj);
 
719
        if (GTK_WIDGET_CLASS (parent_class)->destroy)
 
720
                GTK_WIDGET_CLASS (parent_class)->destroy (obj);
1346
721
}
1347
722
 
1348
723
static void
1360
735
brasero_player_class_init (BraseroPlayerClass *klass)
1361
736
{
1362
737
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
1363
 
        GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (klass);
1364
 
        GtkWidgetClass *gtk_widget_class = GTK_WIDGET_CLASS (klass);
 
738
        GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
1365
739
 
1366
740
        parent_class = g_type_class_peek_parent (klass);
1367
741
        object_class->finalize = brasero_player_finalize;
1368
742
 
1369
 
        gtk_object_class->destroy = brasero_player_destroy;
1370
 
 
1371
 
        gtk_widget_class->size_allocate = brasero_player_size_allocate;
 
743
        widget_class->destroy = brasero_player_destroy;
1372
744
 
1373
745
        brasero_player_signals [ERROR_SIGNAL] = 
1374
746
                        g_signal_new ("error",
1389
761
}
1390
762
 
1391
763
static void
 
764
brasero_player_volume_changed_cb (GtkScaleButton *button,
 
765
                                  gdouble volume,
 
766
                                  BraseroPlayer *player)
 
767
{
 
768
        brasero_player_bacon_set_volume (BRASERO_PLAYER_BACON (player->priv->bacon), volume);
 
769
}
 
770
 
 
771
static void
1392
772
brasero_player_init (BraseroPlayer *obj)
1393
773
{
1394
 
        GtkWidget *alignment;
 
774
        GtkWidget *volume;
 
775
        GtkWidget *image;
 
776
        GtkWidget *label;
1395
777
        GtkWidget *event;
 
778
        GtkWidget *zoom;
 
779
        GtkWidget *hbox;
 
780
        GtkWidget *vbox;
1396
781
        gpointer value;
 
782
        gchar *string;
1397
783
 
1398
784
        obj->priv = g_new0 (BraseroPlayerPrivate, 1);
1399
785
 
1400
 
        obj->priv->vbox = gtk_vbox_new (FALSE, 0);
1401
 
        gtk_widget_show (obj->priv->vbox);
1402
 
        gtk_container_set_border_width (GTK_CONTAINER (obj->priv->vbox), 0);
1403
 
        gtk_container_add (GTK_CONTAINER (obj), obj->priv->vbox);
1404
 
 
1405
 
        obj->priv->hbox = gtk_hbox_new (FALSE, 0);
1406
 
        gtk_widget_show (obj->priv->hbox);
1407
 
        gtk_box_pack_start (GTK_BOX (obj->priv->vbox),
1408
 
                            obj->priv->hbox,
1409
 
                            TRUE,
1410
 
                            TRUE,
1411
 
                            0);
1412
 
 
1413
 
        alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
1414
 
        gtk_widget_show (alignment);
1415
 
        gtk_box_pack_start (GTK_BOX (obj->priv->hbox),
1416
 
                            alignment,
1417
 
                            FALSE,
1418
 
                            FALSE,
1419
 
                            0);
1420
 
 
1421
 
        obj->priv->notebook = gtk_notebook_new ();
1422
 
        gtk_container_set_border_width (GTK_CONTAINER (obj->priv->notebook), 6);
1423
 
        gtk_container_add (GTK_CONTAINER (alignment), obj->priv->notebook);
1424
 
        gtk_notebook_set_show_tabs (GTK_NOTEBOOK (obj->priv->notebook), FALSE);
1425
 
        gtk_notebook_set_show_border (GTK_NOTEBOOK (obj->priv->notebook), FALSE);
1426
 
 
 
786
        gtk_alignment_set (GTK_ALIGNMENT (obj), 0.5, 0.5, 0.0, 0.0);
 
787
 
 
788
        vbox = gtk_vbox_new (FALSE, 2);
 
789
        gtk_widget_show (vbox);
 
790
        gtk_container_add (GTK_CONTAINER (obj), vbox);
 
791
        
 
792
        /* The notebook and all views */
1427
793
        event = gtk_event_box_new ();
1428
 
        obj->priv->image_event = event;
 
794
        gtk_box_pack_start (GTK_BOX (vbox), event, FALSE, FALSE, 0);
1429
795
        gtk_event_box_set_above_child (GTK_EVENT_BOX (event), TRUE);
1430
796
        gtk_event_box_set_visible_window (GTK_EVENT_BOX (event), FALSE);
1431
 
        gtk_notebook_append_page (GTK_NOTEBOOK (obj->priv->notebook),
1432
 
                                  event,
1433
 
                                  NULL);
 
797
        g_signal_connect (event,
 
798
                          "button-release-event",
 
799
                          G_CALLBACK (brasero_player_button_release),
 
800
                          obj);
1434
801
        g_signal_connect (event,
1435
802
                          "scroll-event",
1436
 
                          G_CALLBACK (brasero_player_image_scroll),
 
803
                          G_CALLBACK (brasero_player_scroll),
1437
804
                          obj);
1438
805
        gtk_widget_show (event);
1439
806
 
 
807
        obj->priv->notebook = gtk_notebook_new ();
 
808
        gtk_widget_show (obj->priv->notebook);
 
809
        gtk_container_add (GTK_CONTAINER (event), obj->priv->notebook);
 
810
        gtk_notebook_set_show_tabs (GTK_NOTEBOOK (obj->priv->notebook), FALSE);
 
811
 
 
812
        /* Images */
1440
813
        obj->priv->image_display = gtk_image_new ();
1441
814
        gtk_widget_show (obj->priv->image_display);
1442
 
        gtk_misc_set_alignment (GTK_MISC (obj->priv->image_display), 1.0, 0.0);
1443
 
        gtk_container_add (GTK_CONTAINER (event), obj->priv->image_display);
 
815
        gtk_misc_set_alignment (GTK_MISC (obj->priv->image_display), 0.5, 0.5);
 
816
        gtk_notebook_append_page (GTK_NOTEBOOK (obj->priv->notebook),
 
817
                                  obj->priv->image_display,
 
818
                                  NULL);
1444
819
 
 
820
        /* Video */
1445
821
        obj->priv->bacon = brasero_player_bacon_new ();
1446
822
        gtk_widget_show (obj->priv->bacon);
1447
823
        g_signal_connect (obj->priv->bacon,
 
824
                          "button-release-event",
 
825
                          G_CALLBACK (brasero_bacon_button_release),
 
826
                          obj);
 
827
        g_signal_connect (obj->priv->bacon,
 
828
                          "scroll-event",
 
829
                          G_CALLBACK (brasero_bacon_scroll),
 
830
                          obj);
 
831
        g_signal_connect (obj->priv->bacon,
1448
832
                          "state-change",
1449
833
                          G_CALLBACK (brasero_player_state_changed_cb),
1450
834
                          obj);
1452
836
                          "eof",
1453
837
                          G_CALLBACK (brasero_player_eof_cb),
1454
838
                          obj);
1455
 
        g_signal_connect (obj->priv->bacon,
1456
 
                          "scroll-event",
1457
 
                          G_CALLBACK (brasero_player_video_scroll),
1458
 
                          obj);
1459
839
 
1460
840
        gtk_notebook_append_page (GTK_NOTEBOOK (obj->priv->notebook),
1461
841
                                  obj->priv->bacon,
1462
842
                                  NULL);
1463
843
 
 
844
        /* No Preview view */
 
845
        string = g_strdup_printf ("<span color='grey'><big><b>%s</b></big></span>", _("No preview"));
 
846
        label = gtk_label_new (string);
 
847
        g_free (string);
 
848
 
 
849
        gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
 
850
        gtk_widget_show (label);
 
851
        gtk_notebook_append_page (GTK_NOTEBOOK (obj->priv->notebook),
 
852
                                  label,
 
853
                                  NULL);
 
854
        gtk_notebook_set_current_page (GTK_NOTEBOOK (obj->priv->notebook), 2);
 
855
 
 
856
        /* Loading view */
 
857
        obj->priv->spinner = gtk_spinner_new ();
 
858
        gtk_widget_show (obj->priv->spinner);
 
859
        gtk_notebook_append_page (GTK_NOTEBOOK (obj->priv->notebook),
 
860
                                  obj->priv->spinner,
 
861
                                  NULL);
 
862
 
 
863
        /* Music */
 
864
        image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_DIALOG);
 
865
        gtk_widget_show (image);
 
866
        gtk_notebook_append_page (GTK_NOTEBOOK (obj->priv->notebook),
 
867
                                  image,
 
868
                                  NULL);
 
869
        obj->priv->play_image = image;
 
870
 
 
871
        /* Set the saved sizes */
1464
872
        brasero_setting_get_value (brasero_setting_get_default (),
1465
873
                                   BRASERO_SETTING_IMAGE_SIZE_WIDTH,
1466
874
                                   &value);
1500
908
        gtk_widget_set_size_request (obj->priv->bacon,
1501
909
                                     obj->priv->video_width,
1502
910
                                     obj->priv->video_height);
 
911
 
 
912
        /* A few controls */
 
913
        hbox = gtk_hbox_new (FALSE, 0);
 
914
        gtk_widget_show (hbox);
 
915
        gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 
916
 
 
917
        image = gtk_image_new_from_stock (GTK_STOCK_ZOOM_OUT, GTK_ICON_SIZE_BUTTON);
 
918
        zoom = gtk_button_new ();
 
919
        gtk_widget_show (zoom);
 
920
        gtk_widget_show (image);
 
921
        gtk_button_set_image (GTK_BUTTON (zoom), image);
 
922
        gtk_button_set_relief (GTK_BUTTON (zoom), GTK_RELIEF_NONE);
 
923
        gtk_button_set_focus_on_click (GTK_BUTTON (zoom), FALSE);
 
924
        g_signal_connect (zoom,
 
925
                          "clicked",
 
926
                          G_CALLBACK (brasero_player_zoom_out_cb),
 
927
                          obj);
 
928
        gtk_box_pack_start (GTK_BOX (hbox),
 
929
                            zoom,
 
930
                            FALSE,
 
931
                            FALSE,
 
932
                            0);
 
933
        obj->priv->zoom_out = zoom;
 
934
 
 
935
        image = gtk_image_new_from_stock (GTK_STOCK_ZOOM_IN, GTK_ICON_SIZE_BUTTON);
 
936
        zoom = gtk_button_new ();
 
937
        gtk_widget_show (zoom);
 
938
        gtk_widget_show (image);
 
939
        gtk_button_set_image (GTK_BUTTON (zoom), image);
 
940
        gtk_button_set_relief (GTK_BUTTON (zoom), GTK_RELIEF_NONE);
 
941
        gtk_button_set_focus_on_click (GTK_BUTTON (zoom), FALSE);
 
942
        g_signal_connect (zoom,
 
943
                          "clicked",
 
944
                          G_CALLBACK (brasero_player_zoom_in_cb),
 
945
                          obj);
 
946
        gtk_box_pack_start (GTK_BOX (hbox),
 
947
                            zoom,
 
948
                            FALSE,
 
949
                            FALSE,
 
950
                            0);
 
951
        obj->priv->zoom_in = zoom;
 
952
 
 
953
        volume = gtk_volume_button_new ();
 
954
        gtk_widget_show (volume);
 
955
        gtk_box_pack_end (GTK_BOX (hbox),
 
956
                          volume,
 
957
                          FALSE,
 
958
                          FALSE,
 
959
                          0);
 
960
 
 
961
        gtk_scale_button_set_value (GTK_SCALE_BUTTON (volume),
 
962
                                    brasero_player_bacon_get_volume (BRASERO_PLAYER_BACON (obj->priv->bacon)));
 
963
 
 
964
        g_signal_connect (volume,
 
965
                          "value-changed",
 
966
                          G_CALLBACK (brasero_player_volume_changed_cb),
 
967
                          obj);
1503
968
}
1504
969
 
1505
970
GtkWidget *
1510
975
        obj = BRASERO_PLAYER (g_object_new (BRASERO_TYPE_PLAYER, NULL));
1511
976
 
1512
977
        return GTK_WIDGET (obj);
 
978
 
1513
979
}