← Back to branch summary

~ubuntu-branches/ubuntu/maverick/brasero/maverick

« back to all changes in this revision

Viewing changes to src/brasero-player-bacon.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2010-01-04 17:45:17 UTC
  • mfrom: (1.1.36 upstream)
  • Revision ID: james.westby@ubuntu.com-20100104174517-vz0avr4o1vdfusrf
Tags: 2.29.4-0ubuntu1
* New upstream release:
  - Bug fixes
  - Fixes for Video DVD
  - Updated translations.
* Add 001_nautilus_lazy_init.patch: Do not call brasero_*_start() at
  nautilus startup, they are very expensive; lazily initialize those
  instead.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/brasero-player-bacon.c
43
43
#include "brasero-player-bacon.h"
44
44
#include "brasero-setting.h"
45
45
 
46
 
static void brasero_player_bacon_class_init(BraseroPlayerBaconClass *klass);
47
 
static void brasero_player_bacon_init(BraseroPlayerBacon *sp);
48
 
static void brasero_player_bacon_finalize(GObject *object);
49
 
static void brasero_player_bacon_destroy (GtkObject *object);
50
 
 
51
 
static void brasero_player_bacon_set_property (GObject *obj,
52
 
                                               guint prop_id,
53
 
                                               const GValue *value,
54
 
                                               GParamSpec *pspec);
55
 
static void brasero_player_bacon_get_property (GObject *obj,
56
 
                                               guint prop_id,
57
 
                                               GValue *value,
58
 
                                               GParamSpec *pspec);
59
 
 
60
 
static void brasero_player_bacon_realize (GtkWidget *widget);
61
 
static void brasero_player_bacon_unrealize (GtkWidget *widget);
62
 
static void brasero_player_bacon_map (GtkWidget *widget);
63
 
static void brasero_player_bacon_unmap (GtkWidget *widget);
64
 
 
65
 
static gboolean brasero_player_bacon_expose (GtkWidget *widget,
66
 
                                             GdkEventExpose *event);
67
 
static void brasero_player_bacon_size_request (GtkWidget *widget,
68
 
                                               GtkRequisition *requisition);
69
 
static void brasero_player_bacon_size_allocate (GtkWidget *widget,
70
 
                                                GtkAllocation *allocation);
71
 
 
72
 
static gboolean brasero_player_bacon_bus_messages (GstBus *bus,
73
 
                                                   GstMessage *msg,
74
 
                                                   BraseroPlayerBacon *bacon);
75
46
 
76
47
struct BraseroPlayerBaconPrivate {
77
48
        GstElement *pipe;
78
49
        GstState state;
79
50
 
80
51
        GstXOverlay *xoverlay;
 
52
        XID xid;
81
53
 
82
54
        gchar *uri;
83
55
        gint64 end;
93
65
        EOF_SIGNAL,
94
66
        LAST_SIGNAL
95
67
} BraseroPlayerBaconSignalType;
 
68
 
96
69
static guint brasero_player_bacon_signals [LAST_SIGNAL] = { 0 };
97
70
 
98
 
#define GCONF_PLAYER_VOLUME     "/apps/brasero/display/volume"
99
 
 
100
 
static GObjectClass *parent_class = NULL;
101
 
 
102
 
GType
103
 
brasero_player_bacon_get_type (void)
104
 
{
105
 
        static GType type = 0;
106
 
 
107
 
        if(type == 0) {
108
 
                static const GTypeInfo our_info = {
109
 
                        sizeof (BraseroPlayerBaconClass),
110
 
                        NULL,
111
 
                        NULL,
112
 
                        (GClassInitFunc)brasero_player_bacon_class_init,
113
 
                        NULL,
114
 
                        NULL,
115
 
                        sizeof (BraseroPlayerBacon),
116
 
                        0,
117
 
                        (GInstanceInitFunc)brasero_player_bacon_init,
118
 
                };
119
 
 
120
 
                type = g_type_register_static (GTK_TYPE_WIDGET, 
121
 
                                               "BraseroPlayerBacon",
122
 
                                               &our_info,
123
 
                                               0);
124
 
        }
125
 
 
126
 
        return type;
127
 
}
128
 
 
129
 
static void
130
 
brasero_player_bacon_class_init (BraseroPlayerBaconClass *klass)
131
 
{
132
 
        GObjectClass *object_class = G_OBJECT_CLASS(klass);
133
 
        GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (klass);
134
 
        GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
135
 
 
136
 
        parent_class = g_type_class_peek_parent(klass);
137
 
 
138
 
        object_class->finalize = brasero_player_bacon_finalize;
139
 
        object_class->set_property = brasero_player_bacon_set_property;
140
 
        object_class->get_property = brasero_player_bacon_get_property;
141
 
        gtk_object_class->destroy = brasero_player_bacon_destroy;
142
 
 
143
 
        widget_class->expose_event = brasero_player_bacon_expose;
144
 
        widget_class->map = brasero_player_bacon_map;
145
 
        widget_class->unmap = brasero_player_bacon_unmap;
146
 
        widget_class->realize = brasero_player_bacon_realize;
147
 
        widget_class->unrealize = brasero_player_bacon_unrealize;
148
 
        widget_class->size_request = brasero_player_bacon_size_request;
149
 
        widget_class->size_allocate = brasero_player_bacon_size_allocate;
150
 
 
151
 
        brasero_player_bacon_signals [STATE_CHANGED_SIGNAL] = 
152
 
                        g_signal_new ("state-change",
153
 
                                      G_TYPE_FROM_CLASS (klass),
154
 
                                      G_SIGNAL_RUN_LAST,
155
 
                                      G_STRUCT_OFFSET (BraseroPlayerBaconClass, state_changed),
156
 
                                      NULL, NULL,
157
 
                                      g_cclosure_marshal_VOID__INT,
158
 
                                      G_TYPE_NONE, 1, G_TYPE_INT);
159
 
 
160
 
        brasero_player_bacon_signals [EOF_SIGNAL] = 
161
 
                        g_signal_new ("eof",
162
 
                                      G_TYPE_FROM_CLASS (klass),
163
 
                                      G_SIGNAL_RUN_LAST,
164
 
                                      G_STRUCT_OFFSET (BraseroPlayerBaconClass, eof),
165
 
                                      NULL, NULL,
166
 
                                      g_cclosure_marshal_VOID__VOID,
167
 
                                      G_TYPE_NONE, 0);
168
 
 
169
 
        g_object_class_install_property (object_class,
170
 
                                         PROP_URI,
171
 
                                         g_param_spec_string ("uri",
172
 
                                                              "The uri of the media",
173
 
                                                              "The uri of the media",
174
 
                                                              NULL,
175
 
                                                              G_PARAM_READWRITE));
176
 
}
 
71
G_DEFINE_TYPE (BraseroPlayerBacon, brasero_player_bacon, GTK_TYPE_WIDGET)
177
72
 
178
73
static void
179
74
brasero_player_bacon_set_property (GObject *obj,
219
114
static void
220
115
brasero_player_bacon_realize (GtkWidget *widget)
221
116
{
 
117
        GdkWindow *window;
 
118
        gint attributes_mask;
222
119
        GtkAllocation allocation;
223
 
        GdkWindow *window;
224
120
        GdkWindowAttr attributes;
225
121
        BraseroPlayerBacon *bacon;
226
 
        gint attributes_mask;
227
122
 
228
123
        bacon = BRASERO_PLAYER_BACON (widget);
229
124
 
230
125
        attributes.window_type = GDK_WINDOW_CHILD;
 
126
 
231
127
        gtk_widget_get_allocation (widget, &allocation);
232
 
        attributes.x = allocation.x;
233
 
        attributes.y = allocation.y;
 
128
        attributes.x = 0;
 
129
        attributes.y = 0;
234
130
        attributes.width = allocation.width;
235
131
        attributes.height = allocation.height;
236
132
        attributes.wclass = GDK_INPUT_OUTPUT;
237
133
        attributes.visual = gtk_widget_get_visual (widget);
238
134
        attributes.colormap = gtk_widget_get_colormap (widget);
239
135
        attributes.event_mask = gtk_widget_get_events (widget);
240
 
        attributes.event_mask |= GDK_EXPOSURE_MASK;
 
136
        attributes.event_mask |= GDK_EXPOSURE_MASK|GDK_BUTTON_PRESS_MASK;
241
137
        attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_COLORMAP;
242
138
 
243
139
        gtk_widget_set_window (widget, gdk_window_new (gtk_widget_get_parent_window (widget),
245
141
                                                       attributes_mask));
246
142
        window = gtk_widget_get_window (widget);
247
143
        gdk_window_set_user_data (window, widget);
248
 
 
 
144
        gdk_window_show (gtk_widget_get_window (widget));
249
145
        gtk_widget_set_style (widget, gtk_style_attach (gtk_widget_get_style (widget), window));
250
146
        //gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
251
 
        
 
147
 
252
148
        GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
253
149
}
254
150
 
255
 
static void
256
 
brasero_player_bacon_unrealize (GtkWidget *widget)
257
 
{
258
 
        BraseroPlayerBacon *bacon;
259
 
 
260
 
        bacon = BRASERO_PLAYER_BACON (widget);
261
 
 
262
 
        if (GTK_WIDGET_CLASS (parent_class)->unrealize)
263
 
                GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
264
 
}
265
 
 
266
 
static void
267
 
brasero_player_bacon_map (GtkWidget *widget)
268
 
{
269
 
        g_return_if_fail (widget != NULL);
270
 
        gdk_window_show (gtk_widget_get_window (widget));
271
 
 
272
 
        GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
273
 
}
274
 
 
275
 
static void
276
 
brasero_player_bacon_unmap (GtkWidget *widget)
277
 
{
278
 
        g_return_if_fail (widget != NULL);
279
 
        gdk_window_hide (gtk_widget_get_window (widget));
280
 
 
281
 
        GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
282
 
}
283
 
 
284
151
static gboolean
285
152
brasero_player_bacon_expose (GtkWidget *widget, GdkEventExpose *event)
286
153
{
287
154
        BraseroPlayerBacon *bacon;
288
 
        GdkWindow * window;
 
155
        GdkWindow *window;
289
156
 
290
157
        if (event && event->count > 0)
291
158
                return TRUE;
293
160
        g_return_val_if_fail (widget != NULL, FALSE);
294
161
        bacon = BRASERO_PLAYER_BACON (widget);
295
162
 
 
163
        window = gtk_widget_get_window (widget);
 
164
        if (window)
 
165
                bacon->priv->xid = gdk_x11_drawable_get_xid (GDK_DRAWABLE (window));
 
166
 
296
167
        if (bacon->priv->xoverlay
297
168
        &&  GST_IS_X_OVERLAY (bacon->priv->xoverlay)
298
169
        &&  bacon->priv->state >= GST_STATE_PAUSED) {
299
170
                gst_x_overlay_expose (bacon->priv->xoverlay);
300
171
        }
301
 
        else if ((window = gtk_widget_get_window (widget)))
 
172
        else if (window)
302
173
                gdk_window_clear (window);
303
174
 
304
175
        return TRUE;
316
187
        requisition->width = PLAYER_BACON_WIDTH;
317
188
        requisition->height = PLAYER_BACON_HEIGHT;
318
189
 
319
 
        if (GTK_WIDGET_CLASS (parent_class)->size_request)
320
 
                GTK_WIDGET_CLASS (parent_class)->size_request (widget, requisition);
 
190
        if (GTK_WIDGET_CLASS (brasero_player_bacon_parent_class)->size_request)
 
191
                GTK_WIDGET_CLASS (brasero_player_bacon_parent_class)->size_request (widget, requisition);
321
192
}
322
193
 
323
194
static void
356
227
                                        (gint) screen_height);
357
228
                gtk_widget_set_allocation (widget, allocation);
358
229
        }
359
 
        else if (GTK_WIDGET_CLASS (parent_class)->size_allocate)
360
 
                GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation);
361
 
}
362
 
 
363
 
static void
364
 
brasero_player_bacon_destroy (GtkObject *obj)
365
 
{
366
 
        BraseroPlayerBacon *cobj;
367
 
 
368
 
        cobj = BRASERO_PLAYER_BACON (obj);
369
 
 
370
 
        /* save volume */
371
 
        if (cobj->priv->pipe) {
372
 
                gdouble volume;
373
 
 
374
 
                g_object_get (cobj->priv->pipe,
375
 
                              "volume", &volume,
376
 
                              NULL);
377
 
                brasero_setting_set_value (brasero_setting_get_default (),
378
 
                                           BRASERO_SETTING_PLAYER_VOLUME,
379
 
                                           GINT_TO_POINTER ((gint)(volume * 100)));
380
 
        }
381
 
 
382
 
        if (cobj->priv->xoverlay
383
 
        &&  GST_IS_X_OVERLAY (cobj->priv->xoverlay)) {
384
 
                cobj->priv->xoverlay = NULL;
385
 
        }
386
 
 
387
 
        if (cobj->priv->pipe) {
388
 
                gst_element_set_state (cobj->priv->pipe, GST_STATE_NULL);
389
 
                gst_object_unref (GST_OBJECT (cobj->priv->pipe));
390
 
                cobj->priv->pipe = NULL;
391
 
        }
392
 
 
393
 
        if (cobj->priv->uri) {
394
 
                g_free (cobj->priv->uri);
395
 
                cobj->priv->uri = NULL;
396
 
        }
397
 
 
398
 
        if (GTK_OBJECT_CLASS (parent_class)->destroy)
399
 
                GTK_OBJECT_CLASS (parent_class)->destroy (obj);
400
 
}
401
 
 
402
 
static void
403
 
brasero_player_bacon_finalize (GObject *object)
404
 
{
405
 
        BraseroPlayerBacon *cobj;
406
 
 
407
 
        cobj = BRASERO_PLAYER_BACON (object);
408
 
 
409
 
        g_free (cobj->priv);
410
 
        G_OBJECT_CLASS (parent_class)->finalize (object);
411
 
}
412
 
 
413
 
GtkWidget *
414
 
brasero_player_bacon_new (void)
415
 
{
416
 
        BraseroPlayerBacon *obj;
417
 
        
418
 
        obj = BRASERO_PLAYER_BACON (g_object_new (BRASERO_TYPE_PLAYER_BACON, NULL));
419
 
        
420
 
        return GTK_WIDGET (obj);
 
230
        else if (GTK_WIDGET_CLASS (brasero_player_bacon_parent_class)->size_allocate)
 
231
                GTK_WIDGET_CLASS (brasero_player_bacon_parent_class)->size_allocate (widget, allocation);
421
232
}
422
233
 
423
234
static GstBusSyncReply
426
237
                                           BraseroPlayerBacon *bacon)
427
238
{
428
239
        const GstStructure *structure;
429
 
        XID window;
430
240
 
431
241
        structure = gst_message_get_structure (message);
432
242
        if (!structure)
436
246
                return GST_BUS_PASS;
437
247
        }
438
248
 
439
 
        window = GDK_WINDOW_XWINDOW (gtk_widget_get_window (GTK_WIDGET (bacon)));
 
249
        /* NOTE: apparently GDK does not like to be asked to retrieve the XID
 
250
         * in a thread so we do it in the callback of the expose event. */
440
251
        bacon->priv->xoverlay = GST_X_OVERLAY (GST_MESSAGE_SRC (message));
441
 
        gst_x_overlay_set_xwindow_id (bacon->priv->xoverlay, window);
 
252
        gst_x_overlay_set_xwindow_id (bacon->priv->xoverlay, bacon->priv->xid);
442
253
 
443
254
        return GST_BUS_DROP;
444
255
}
447
258
brasero_player_bacon_clear_pipe (BraseroPlayerBacon *bacon)
448
259
{
449
260
        bacon->priv->xoverlay = NULL;
 
261
 
450
262
        bacon->priv->state = GST_STATE_NULL;
451
263
 
452
264
        if (bacon->priv->pipe) {
745
557
        obj->priv = g_new0 (BraseroPlayerBaconPrivate, 1);
746
558
        brasero_player_bacon_setup_pipe (obj);
747
559
}
 
560
 
 
561
static void
 
562
brasero_player_bacon_destroy (GtkObject *obj)
 
563
{
 
564
        BraseroPlayerBacon *cobj;
 
565
 
 
566
        cobj = BRASERO_PLAYER_BACON (obj);
 
567
 
 
568
        /* save volume */
 
569
        if (cobj->priv->pipe) {
 
570
                gdouble volume;
 
571
 
 
572
                g_object_get (cobj->priv->pipe,
 
573
                              "volume", &volume,
 
574
                              NULL);
 
575
                brasero_setting_set_value (brasero_setting_get_default (),
 
576
                                           BRASERO_SETTING_PLAYER_VOLUME,
 
577
                                           GINT_TO_POINTER ((gint)(volume * 100)));
 
578
        }
 
579
 
 
580
        if (cobj->priv->xoverlay
 
581
        &&  GST_IS_X_OVERLAY (cobj->priv->xoverlay))
 
582
                cobj->priv->xoverlay = NULL;
 
583
 
 
584
        if (cobj->priv->pipe) {
 
585
                gst_element_set_state (cobj->priv->pipe, GST_STATE_NULL);
 
586
                gst_object_unref (GST_OBJECT (cobj->priv->pipe));
 
587
                cobj->priv->pipe = NULL;
 
588
        }
 
589
 
 
590
        if (cobj->priv->uri) {
 
591
                g_free (cobj->priv->uri);
 
592
                cobj->priv->uri = NULL;
 
593
        }
 
594
 
 
595
        if (GTK_OBJECT_CLASS (brasero_player_bacon_parent_class)->destroy)
 
596
                GTK_OBJECT_CLASS (brasero_player_bacon_parent_class)->destroy (obj);
 
597
}
 
598
 
 
599
static void
 
600
brasero_player_bacon_finalize (GObject *object)
 
601
{
 
602
        BraseroPlayerBacon *cobj;
 
603
 
 
604
        cobj = BRASERO_PLAYER_BACON (object);
 
605
 
 
606
        g_free (cobj->priv);
 
607
        G_OBJECT_CLASS (brasero_player_bacon_parent_class)->finalize (object);
 
608
}
 
609
 
 
610
static void
 
611
brasero_player_bacon_class_init (BraseroPlayerBaconClass *klass)
 
612
{
 
613
        GObjectClass *object_class = G_OBJECT_CLASS(klass);
 
614
        GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (klass);
 
615
        GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 
616
 
 
617
        object_class->finalize = brasero_player_bacon_finalize;
 
618
        object_class->set_property = brasero_player_bacon_set_property;
 
619
        object_class->get_property = brasero_player_bacon_get_property;
 
620
        gtk_object_class->destroy = brasero_player_bacon_destroy;
 
621
 
 
622
        widget_class->expose_event = brasero_player_bacon_expose;
 
623
        widget_class->realize = brasero_player_bacon_realize;
 
624
        widget_class->size_request = brasero_player_bacon_size_request;
 
625
        widget_class->size_allocate = brasero_player_bacon_size_allocate;
 
626
 
 
627
        brasero_player_bacon_signals [STATE_CHANGED_SIGNAL] = 
 
628
                        g_signal_new ("state-change",
 
629
                                      G_TYPE_FROM_CLASS (klass),
 
630
                                      G_SIGNAL_RUN_LAST,
 
631
                                      G_STRUCT_OFFSET (BraseroPlayerBaconClass, state_changed),
 
632
                                      NULL, NULL,
 
633
                                      g_cclosure_marshal_VOID__INT,
 
634
                                      G_TYPE_NONE, 1, G_TYPE_INT);
 
635
 
 
636
        brasero_player_bacon_signals [EOF_SIGNAL] = 
 
637
                        g_signal_new ("eof",
 
638
                                      G_TYPE_FROM_CLASS (klass),
 
639
                                      G_SIGNAL_RUN_LAST,
 
640
                                      G_STRUCT_OFFSET (BraseroPlayerBaconClass, eof),
 
641
                                      NULL, NULL,
 
642
                                      g_cclosure_marshal_VOID__VOID,
 
643
                                      G_TYPE_NONE, 0);
 
644
 
 
645
        g_object_class_install_property (object_class,
 
646
                                         PROP_URI,
 
647
                                         g_param_spec_string ("uri",
 
648
                                                              "The uri of the media",
 
649
                                                              "The uri of the media",
 
650
                                                              NULL,
 
651
                                                              G_PARAM_READWRITE));
 
652
}
 
653
 
 
654
GtkWidget *
 
655
brasero_player_bacon_new (void)
 
656
{
 
657
        BraseroPlayerBacon *obj;
 
658
        
 
659
        obj = BRASERO_PLAYER_BACON (g_object_new (BRASERO_TYPE_PLAYER_BACON, NULL));
 
660
        
 
661
        return GTK_WIDGET (obj);
 
662
}