← Back to branch summary

~kaozilon/totem/test

« back to all changes in this revision

Viewing changes to src/plugins/brasero-disc-recorder/totem-disc-recorder.c

  • Committer: Bazaar Package Importer
  • Author(s): Sjoerd Simons, Josselin Mouette, Sjoerd Simons, Emilio Pozuelo Monfort
  • Date: 2009-04-19 17:28:51 UTC
  • mfrom: (1.2.52 upstream) (5.1.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090419172851-epoqimnq62akn294
Tags: 2.26.1-1
http://bugs.debian.org/523582
http://bugs.debian.org/523052
[ Josselin Mouette ]
* totem-plugins depends on python-gdbm. Closes: #523582.

[ Sjoerd Simons ]
* New upstream release (2.26.1)
* debian/patches/02_flv.patch: Dropped, fixed upstream
* debian/patches/04_tracker_build.patch: Dropped, fixed upstream
* debian/patches/01_fake_keypresses.patch: Updated and simplified
* debian/patches/70_bbc_plugin.patch: Updated
* debian/patches/90_autotools.patch: Updated

[ Emilio Pozuelo Monfort ]
* Recommend gnome-codec-install rather than gnome-app-install.
  Closes: #523052.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/brasero-disc-recorder/totem-disc-recorder.c
 
1
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
 
2
/*
 
3
 * Copyright (C) Philippe Rouquier 2008 <bonfire-app@wanadoo.fr>
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License as published by
 
7
 * the Free Software Foundation; either version 2 of the License, or
 
8
 * (at your option) any later version.
 
9
 * 
 
10
 * This program is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 * GNU Library General Public License for more details.
 
14
 * 
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with this program; if not, write to the Free Software
 
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor Boston, MA 02110-1301,  USA
 
18
 */
 
19
 
 
20
#include "config.h"
 
21
 
 
22
#include <unistd.h>
 
23
 
 
24
#include <glib.h>
 
25
#include <glib-object.h>
 
26
#include <glib/gi18n-lib.h>
 
27
#include <glib/gstdio.h>
 
28
#include <gmodule.h>
 
29
#include <gdk/gdkx.h>
 
30
 
 
31
#include <libxml/xmlerror.h>
 
32
#include <libxml/xmlwriter.h>
 
33
#include <libxml/parser.h>
 
34
#include <libxml/xmlstring.h>
 
35
#include <libxml/xmlsave.h>
 
36
 
 
37
#include "totem-plugin.h"
 
38
#include "totem-interface.h"
 
39
 
 
40
#define TOTEM_TYPE_DISC_RECORDER_PLUGIN         (totem_disc_recorder_plugin_get_type ())
 
41
#define TOTEM_DISC_RECORDER_PLUGIN(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), TOTEM_TYPE_DISC_RECORDER_PLUGIN, TotemDiscRecorderPlugin))
 
42
#define TOTEM_DISC_RECORDER_PLUGIN_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), TOTEM_TYPE_DISC_RECORDER_PLUGIN, TotemDiscRecorderPluginClass))
 
43
#define TOTEM_IS_DISC_RECORDER_PLUGIN(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), TOTEM_TYPE_DISC_RECORDER_PLUGIN))
 
44
#define TOTEM_IS_DISC_RECORDER_PLUGIN_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), TOTEM_TYPE_DISC_RECORDER_PLUGIN))
 
45
#define TOTEM_DISC_RECORDER_PLUGIN_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TOTEM_TYPE_DISC_RECORDER_PLUGIN, TotemDiscRecorderPluginClass))
 
46
 
 
47
typedef struct TotemDiscRecorderPluginPrivate         TotemDiscRecorderPluginPrivate;
 
48
 
 
49
typedef struct
 
50
{
 
51
        TotemPlugin parent;
 
52
 
 
53
        TotemObject *totem;
 
54
 
 
55
        GtkActionGroup *action_group;
 
56
        guint ui_merge_id;
 
57
 
 
58
        gboolean enabled;
 
59
} TotemDiscRecorderPlugin;
 
60
 
 
61
typedef struct
 
62
{
 
63
        TotemPluginClass parent_class;
 
64
} TotemDiscRecorderPluginClass;
 
65
 
 
66
G_MODULE_EXPORT GType register_totem_plugin (GTypeModule *module);
 
67
GType totem_disc_recorder_plugin_get_type (void) G_GNUC_CONST;
 
68
 
 
69
TOTEM_PLUGIN_REGISTER (TotemDiscRecorderPlugin, totem_disc_recorder_plugin)
 
70
 
 
71
static void totem_disc_recorder_plugin_burn (GtkAction *action,
 
72
                                             TotemDiscRecorderPlugin *pi);
 
73
static void totem_disc_recorder_plugin_copy (GtkAction *action,
 
74
                                             TotemDiscRecorderPlugin *pi);
 
75
 
 
76
static GtkActionEntry totem_disc_recorder_plugin_actions [] = {
 
77
        { "VideoBurnToDisc", "media-optical-video-new", N_("_Create Video Disc..."), NULL,
 
78
                N_("Create a video DVD or a (S)VCD from the currently opened movie"),
 
79
                G_CALLBACK (totem_disc_recorder_plugin_burn) },
 
80
        { "VideoDVDCopy", "media-optical-copy", N_("Copy Vide_o DVD..."), NULL,
 
81
                N_("Copy the currently playing video DVD"),
 
82
                G_CALLBACK (totem_disc_recorder_plugin_copy) },
 
83
        { "VideoVCDCopy", "media-optical-copy", N_("Copy Vide_o (S)VCD..."), NULL,
 
84
                N_("Copy the currently playing (S)VCD"),
 
85
                G_CALLBACK (totem_disc_recorder_plugin_copy) },
 
86
};
 
87
 
 
88
static gboolean
 
89
totem_disc_recorder_plugin_start_burning (TotemDiscRecorderPlugin *pi,
 
90
                                          const char *path,
 
91
                                          gboolean copy)
 
92
{
 
93
        GtkWindow *main_window;
 
94
        GPtrArray *array;
 
95
        char **args, *xid_str;
 
96
        GError *error = NULL;
 
97
        gboolean ret;
 
98
 
 
99
        array = g_ptr_array_new ();
 
100
        g_ptr_array_add (array, "brasero");
 
101
        if (copy != FALSE)
 
102
                g_ptr_array_add (array, "-c");
 
103
        else
 
104
                g_ptr_array_add (array, "-r");
 
105
        g_ptr_array_add (array, (gpointer) path);
 
106
 
 
107
        main_window = totem_get_main_window (pi->totem);
 
108
        if (main_window && GTK_WIDGET (main_window)->window) {
 
109
                int xid;
 
110
                xid = gdk_x11_drawable_get_xid (GDK_DRAWABLE (GTK_WIDGET (main_window)->window));
 
111
                xid_str = g_strdup_printf ("%d", xid);
 
112
                g_ptr_array_add (array, "-x");
 
113
                g_ptr_array_add (array, xid_str);
 
114
        } else {
 
115
                xid_str = NULL;
 
116
        }
 
117
 
 
118
        g_ptr_array_add (array, NULL);
 
119
        args = (char **) g_ptr_array_free (array, FALSE);
 
120
 
 
121
        ret = TRUE;
 
122
        if (!g_spawn_async (NULL, args, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, &error)) {
 
123
                if (copy != FALSE) {
 
124
                        totem_interface_error (_("The video disc could not be duplicated."),
 
125
                                               error->message,
 
126
                                               totem_get_main_window (pi->totem));
 
127
                } else {
 
128
                        totem_interface_error (_("The movie could not be recorded."),
 
129
                                               error->message,
 
130
                                               totem_get_main_window (pi->totem));
 
131
                }
 
132
                ret = FALSE;
 
133
                g_error_free (error);
 
134
        }
 
135
 
 
136
        g_free (xid_str);
 
137
        g_free (args);
 
138
 
 
139
        return ret;
 
140
}
 
141
 
 
142
static char*
 
143
totem_disc_recorder_plugin_write_video_project (TotemDiscRecorderPlugin *pi,
 
144
                                                char **error)
 
145
{
 
146
        xmlTextWriter *project;
 
147
        xmlDocPtr doc = NULL;
 
148
        xmlSaveCtxt *save;
 
149
        xmlChar *escaped;
 
150
        gint success;
 
151
        char *title, *path, *uri;
 
152
        int fd;
 
153
 
 
154
        /* get a temporary path */
 
155
        path = g_build_filename (g_get_tmp_dir (), "brasero-tmp-project-XXXXXX",  NULL);
 
156
        fd = g_mkstemp (path);
 
157
        if (!fd) {
 
158
                g_free (path);
 
159
 
 
160
                *error = g_strdup (_("Unable to write a project."));
 
161
                return NULL;
 
162
        }
 
163
 
 
164
        project = xmlNewTextWriterDoc (&doc, 0);
 
165
        if (!project) {
 
166
                g_remove (path);
 
167
                g_free (path);
 
168
                close (fd);
 
169
 
 
170
                *error = g_strdup (_("Unable to write a project."));
 
171
                return NULL;
 
172
        }
 
173
 
 
174
        xmlTextWriterSetIndent (project, 1);
 
175
        xmlTextWriterSetIndentString (project, (xmlChar *) "\t");
 
176
 
 
177
        success = xmlTextWriterStartDocument (project,
 
178
                                              NULL,
 
179
                                              "UTF8",
 
180
                                              NULL);
 
181
        if (success < 0)
 
182
                goto error;
 
183
 
 
184
        success = xmlTextWriterStartElement (project, (xmlChar *) "braseroproject");
 
185
        if (success < 0)
 
186
                goto error;
 
187
 
 
188
        /* write the name of the version */
 
189
        success = xmlTextWriterWriteElement (project,
 
190
                                             (xmlChar *) "version",
 
191
                                             (xmlChar *) "0.2");
 
192
        if (success < 0)
 
193
                goto error;
 
194
 
 
195
        title = totem_get_short_title (pi->totem);
 
196
        if (title) {
 
197
                success = xmlTextWriterWriteElement (project,
 
198
                                                     (xmlChar *) "label",
 
199
                                                     (xmlChar *) title);
 
200
                g_free (title);
 
201
 
 
202
                if (success < 0)
 
203
                        goto error;
 
204
        }
 
205
 
 
206
        success = xmlTextWriterStartElement (project, (xmlChar *) "track");
 
207
        if (success < 0)
 
208
                goto error;
 
209
 
 
210
        success = xmlTextWriterStartElement (project, (xmlChar *) "video");
 
211
        if (success < 0)
 
212
                goto error;
 
213
 
 
214
        uri = totem_get_current_mrl (pi->totem);
 
215
        escaped = (unsigned char *) g_uri_escape_string (uri, NULL, FALSE);
 
216
        g_free (uri);
 
217
 
 
218
        success = xmlTextWriterWriteElement (project,
 
219
                                             (xmlChar *) "uri",
 
220
                                             escaped);
 
221
        g_free (escaped);
 
222
        if (success == -1)
 
223
                goto error;
 
224
 
 
225
        /* start of the song always 0 */
 
226
        success = xmlTextWriterWriteElement (project,
 
227
                                             (xmlChar *) "start",
 
228
                                             (xmlChar *) "0");
 
229
        if (success == -1)
 
230
                goto error;
 
231
 
 
232
        success = xmlTextWriterEndElement (project); /* video */
 
233
        if (success < 0)
 
234
                goto error;
 
235
 
 
236
        success = xmlTextWriterEndElement (project); /* track */
 
237
        if (success < 0)
 
238
                goto error;
 
239
 
 
240
        success = xmlTextWriterEndElement (project); /* braseroproject */
 
241
        if (success < 0)
 
242
                goto error;
 
243
 
 
244
        xmlTextWriterEndDocument (project);
 
245
        xmlFreeTextWriter (project);
 
246
 
 
247
        save = xmlSaveToFd (fd, "UTF8", XML_SAVE_FORMAT);
 
248
        xmlSaveDoc (save, doc);
 
249
        xmlSaveClose (save);
 
250
 
 
251
        xmlFreeDoc (doc);
 
252
        close (fd);
 
253
 
 
254
        return path;
 
255
 
 
256
error:
 
257
 
 
258
        /* cleanup */
 
259
        xmlTextWriterEndDocument (project);
 
260
        xmlFreeTextWriter (project);
 
261
 
 
262
        g_remove (path);
 
263
        g_free (path);
 
264
        close (fd);
 
265
 
 
266
        *error = g_strdup (_("Unable to write a project."));
 
267
        return NULL;
 
268
}
 
269
 
 
270
static void
 
271
totem_disc_recorder_plugin_burn (GtkAction *action,
 
272
                                 TotemDiscRecorderPlugin *pi)
 
273
{
 
274
        char *path;
 
275
        char *error = NULL;
 
276
 
 
277
        path = totem_disc_recorder_plugin_write_video_project (pi, &error);
 
278
        if (!path) {
 
279
                totem_interface_error (_("The movie could not be recorded."),
 
280
                                       error,
 
281
                                       totem_get_main_window (pi->totem));
 
282
                g_free (error);
 
283
                return;
 
284
        }
 
285
 
 
286
        if (!totem_disc_recorder_plugin_start_burning (pi, path, FALSE))
 
287
                g_remove (path);
 
288
 
 
289
        g_free (path);
 
290
}
 
291
 
 
292
static void
 
293
totem_disc_recorder_plugin_copy (GtkAction *action,
 
294
                                 TotemDiscRecorderPlugin *pi)
 
295
{
 
296
        char *mrl;
 
297
 
 
298
        mrl = totem_get_current_mrl (pi->totem);
 
299
        if (!g_str_has_prefix (mrl, "dvd:") && !g_str_has_prefix (mrl, "vcd:")) {
 
300
                g_free (mrl);
 
301
                g_assert_not_reached ();
 
302
                return;
 
303
        }
 
304
 
 
305
        totem_disc_recorder_plugin_start_burning (pi, mrl + 6, TRUE);
 
306
}
 
307
 
 
308
static void
 
309
totem_disc_recorder_file_closed (TotemObject *totem,
 
310
                                 TotemDiscRecorderPlugin *pi)
 
311
{
 
312
        GtkAction *action;
 
313
 
 
314
        action = gtk_action_group_get_action (pi->action_group, "VideoBurnToDisc");
 
315
        gtk_action_set_visible (action, FALSE);
 
316
        action = gtk_action_group_get_action (pi->action_group, "VideoDVDCopy");
 
317
        gtk_action_set_visible (action, FALSE);
 
318
        action = gtk_action_group_get_action (pi->action_group, "VideoVCDCopy");
 
319
        gtk_action_set_visible (action, FALSE);
 
320
}
 
321
 
 
322
static void
 
323
totem_disc_recorder_file_opened (TotemObject *totem,
 
324
                                 const char *mrl,
 
325
                                 TotemDiscRecorderPlugin *pi)
 
326
{
 
327
        GtkAction *action;
 
328
 
 
329
        /* Check if that stream is supported by brasero */
 
330
        if (g_str_has_prefix (mrl, "file:")) {
 
331
                /* If the file is supported we can always burn, even if there
 
332
                 * aren't any burner since we can still create an image. */
 
333
                action = gtk_action_group_get_action (pi->action_group, "VideoBurnToDisc");
 
334
                gtk_action_set_visible (action, TRUE);
 
335
                action = gtk_action_group_get_action (pi->action_group, "VideoDVDCopy");
 
336
                gtk_action_set_visible (action, FALSE);
 
337
                action = gtk_action_group_get_action (pi->action_group, "VideoVCDCopy");
 
338
                gtk_action_set_visible (action, FALSE);
 
339
        }
 
340
        else if (g_str_has_prefix (mrl, "dvd:")) {
 
341
                action = gtk_action_group_get_action (pi->action_group, "VideoBurnToDisc");
 
342
                gtk_action_set_visible (action, FALSE);
 
343
                action = gtk_action_group_get_action (pi->action_group, "VideoDVDCopy");
 
344
                gtk_action_set_visible (action, TRUE);
 
345
                action = gtk_action_group_get_action (pi->action_group, "VideoVCDCopy");
 
346
                gtk_action_set_visible (action, FALSE);
 
347
        }
 
348
        else if (g_str_has_prefix (mrl, "vcd:")) {
 
349
                action = gtk_action_group_get_action (pi->action_group, "VideoBurnToDisc");
 
350
                gtk_action_set_visible (action, FALSE);
 
351
                action = gtk_action_group_get_action (pi->action_group, "VideoDVDCopy");
 
352
                gtk_action_set_visible (action, FALSE);
 
353
                action = gtk_action_group_get_action (pi->action_group, "VideoVCDCopy");
 
354
                gtk_action_set_visible (action, TRUE);
 
355
        }
 
356
        else {
 
357
                action = gtk_action_group_get_action (pi->action_group, "VideoBurnToDisc");
 
358
                gtk_action_set_visible (action, FALSE);
 
359
                action = gtk_action_group_get_action (pi->action_group, "VideoDVDCopy");
 
360
                gtk_action_set_visible (action, FALSE);
 
361
                action = gtk_action_group_get_action (pi->action_group, "VideoVCDCopy");
 
362
                gtk_action_set_visible (action, FALSE);
 
363
        }
 
364
}
 
365
 
 
366
static gboolean
 
367
impl_activate (TotemPlugin *plugin, TotemObject *totem, GError **error)
 
368
{
 
369
        TotemDiscRecorderPlugin *pi = TOTEM_DISC_RECORDER_PLUGIN (plugin);
 
370
        GtkUIManager *uimanager = NULL;
 
371
        GtkAction *action;
 
372
        char *path;
 
373
 
 
374
        /* make sure brasero is in the path */
 
375
        path = g_find_program_in_path ("brasero");
 
376
        if (!path)
 
377
                return FALSE;
 
378
        g_free (path);
 
379
 
 
380
        //FIXME this shouldn't be necessary
 
381
#if 0
 
382
        /* Set up to use brasero icons */
 
383
        path = g_build_path (G_DIR_SEPARATOR_S, LIBBRASERO_MEDIA_INSTALL, "/share/brasero/icons", NULL);
 
384
        gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), path);
 
385
        g_free (path);
 
386
#endif
 
387
 
 
388
        pi->totem = totem;
 
389
 
 
390
        g_signal_connect (totem,
 
391
                          "file-opened",
 
392
                          G_CALLBACK (totem_disc_recorder_file_opened),
 
393
                          plugin);
 
394
        g_signal_connect (totem,
 
395
                          "file-closed",
 
396
                          G_CALLBACK (totem_disc_recorder_file_closed),
 
397
                          plugin);
 
398
 
 
399
        /* add UI */
 
400
        pi->action_group = gtk_action_group_new ("DiscRecorderActions");
 
401
        gtk_action_group_set_translation_domain (pi->action_group, GETTEXT_PACKAGE);
 
402
        gtk_action_group_add_actions (pi->action_group,
 
403
                                      totem_disc_recorder_plugin_actions,
 
404
                                      G_N_ELEMENTS (totem_disc_recorder_plugin_actions),
 
405
                                      pi);
 
406
 
 
407
        uimanager = totem_get_ui_manager (totem);
 
408
        gtk_ui_manager_insert_action_group (uimanager, pi->action_group, -1);
 
409
        g_object_unref (pi->action_group);
 
410
 
 
411
        pi->ui_merge_id = gtk_ui_manager_new_merge_id (uimanager);
 
412
 
 
413
        gtk_ui_manager_add_ui (uimanager,
 
414
                               pi->ui_merge_id,
 
415
                               "/ui/tmw-menubar/movie/burn-placeholder",
 
416
                               "VideoBurnToDisc",
 
417
                               "VideoBurnToDisc",
 
418
                               GTK_UI_MANAGER_MENUITEM,
 
419
                               TRUE);
 
420
        gtk_ui_manager_add_ui (uimanager,
 
421
                               pi->ui_merge_id,
 
422
                               "/ui/totem-main-popup/burn-placeholder",
 
423
                               "VideoBurnToDisc",
 
424
                               "VideoBurnToDisc",
 
425
                               GTK_UI_MANAGER_MENUITEM,
 
426
                               TRUE);
 
427
 
 
428
        gtk_ui_manager_add_ui (uimanager,
 
429
                               pi->ui_merge_id,
 
430
                               "/ui/tmw-menubar/movie/burn-placeholder",
 
431
                               "VideoDVDCopy",
 
432
                               "VideoDVDCopy",
 
433
                               GTK_UI_MANAGER_MENUITEM,
 
434
                               TRUE);
 
435
        gtk_ui_manager_add_ui (uimanager,
 
436
                               pi->ui_merge_id,
 
437
                               "/ui/totem-main-popup/burn-placeholder",
 
438
                               "VideoDVDCopy",
 
439
                               "VideoDVDCopy",
 
440
                               GTK_UI_MANAGER_MENUITEM,
 
441
                               TRUE);
 
442
 
 
443
        gtk_ui_manager_add_ui (uimanager,
 
444
                               pi->ui_merge_id,
 
445
                               "/ui/tmw-menubar/movie/burn-placeholder",
 
446
                               "VideoVCDCopy",
 
447
                               "VideoVCDCopy",
 
448
                               GTK_UI_MANAGER_MENUITEM,
 
449
                               TRUE);
 
450
        gtk_ui_manager_add_ui (uimanager,
 
451
                               pi->ui_merge_id,
 
452
                               "/ui/totem-main-popup/burn-placeholder",
 
453
                               "VideoVCDCopy",
 
454
                               "VideoVCDCopy",
 
455
                               GTK_UI_MANAGER_MENUITEM,
 
456
                               TRUE);
 
457
 
 
458
        if (!totem_is_paused (totem) && !totem_is_playing (totem)) {
 
459
                action = gtk_action_group_get_action (pi->action_group, "VideoBurnToDisc");
 
460
                gtk_action_set_visible (action, FALSE);
 
461
                action = gtk_action_group_get_action (pi->action_group, "VideoDVDCopy");
 
462
                gtk_action_set_visible (action, FALSE);
 
463
                action = gtk_action_group_get_action (pi->action_group, "VideoVCDCopy");
 
464
                gtk_action_set_visible (action, FALSE); }
 
465
        else {
 
466
                char *mrl;
 
467
 
 
468
                mrl = totem_get_current_mrl (totem);
 
469
                totem_disc_recorder_file_opened (totem, mrl, pi);
 
470
                g_free (mrl);
 
471
        }
 
472
 
 
473
        return TRUE;
 
474
}
 
475
 
 
476
static void
 
477
impl_deactivate (TotemPlugin *plugin, TotemObject *totem)
 
478
{
 
479
        TotemDiscRecorderPlugin *pi = TOTEM_DISC_RECORDER_PLUGIN (plugin);
 
480
        GtkUIManager *uimanager = NULL;
 
481
 
 
482
        pi->enabled = FALSE;
 
483
 
 
484
        g_signal_handlers_disconnect_by_func (totem, totem_disc_recorder_file_opened, plugin);
 
485
        g_signal_handlers_disconnect_by_func (totem, totem_disc_recorder_file_closed, plugin);
 
486
 
 
487
        uimanager = totem_get_ui_manager (totem);
 
488
        gtk_ui_manager_remove_ui (uimanager, pi->ui_merge_id);
 
489
        gtk_ui_manager_remove_action_group (uimanager, pi->action_group);
 
490
 
 
491
        pi->totem = NULL;
 
492
}
 
493
 
 
494
static void
 
495
totem_disc_recorder_plugin_finalize (GObject *object)
 
496
{
 
497
        G_OBJECT_CLASS (totem_disc_recorder_plugin_parent_class)->finalize (object);
 
498
}
 
499
 
 
500
static void
 
501
totem_disc_recorder_plugin_class_init (TotemDiscRecorderPluginClass *klass)
 
502
{
 
503
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
504
        TotemPluginClass *plugin_class = TOTEM_PLUGIN_CLASS (klass);
 
505
 
 
506
        object_class->finalize = totem_disc_recorder_plugin_finalize;
 
507
 
 
508
        plugin_class->activate = impl_activate;
 
509
        plugin_class->deactivate = impl_deactivate;
 
510
}
 
511
 
 
512
static void
 
513
totem_disc_recorder_plugin_init (TotemDiscRecorderPlugin *pi)
 
514
{
 
515
}
 
516