← Back to branch summary

~mfisch/brasero/update-to-3.8.0

« back to all changes in this revision

Viewing changes to src/burn-task-item.c

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/burn-task-item.c
1
 
/*
2
 
 * brasero
3
 
 * Copyright (C) Philippe Rouquier 2007-2008 <bonfire-app@wanadoo.fr>
4
 
 * 
5
 
 * Brasero 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.sero is distributed in the hope that it will be useful,
9
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11
 
 * See the GNU General Public License for more details.
12
 
 * 
13
 
 * You should have received a copy of the GNU General Public License
14
 
 * along with brasero.  If not, write to:
15
 
 *      The Free Software Foundation, Inc.,
16
 
 *      51 Franklin Street, Fifth Floor
17
 
 *      Boston, MA  02110-1301, USA.
18
 
 */
19
 
 
20
 
#ifdef HAVE_CONFIG_H
21
 
#  include <config.h>
22
 
#endif
23
 
 
24
 
#include <glib-object.h>
25
 
 
26
 
#include "burn-basics.h"
27
 
#include "burn-task-ctx.h"
28
 
#include "burn-task-item.h"
29
 
 
30
 
GType
31
 
brasero_task_item_get_type (void)
32
 
{
33
 
        static GType type = 0;
34
 
        
35
 
        if (type == 0) {
36
 
                static const GTypeInfo info = {
37
 
                        sizeof (BraseroTaskItemIFace),
38
 
                        NULL,   /* base_init */
39
 
                        NULL,   /* base_finalize */
40
 
                        NULL,   /* class_init */
41
 
                        NULL,   /* class_finalize */
42
 
                        NULL,   /* class_data */
43
 
                        0,
44
 
                        0,      /* n_preallocs */
45
 
                        NULL    /* instance_init */
46
 
                };
47
 
                type = g_type_register_static (G_TYPE_INTERFACE,
48
 
                                               "BraseroTaskItem",
49
 
                                               &info,
50
 
                                               0);
51
 
        }
52
 
        return type;
53
 
}
54
 
 
55
 
BraseroBurnResult
56
 
brasero_task_item_link (BraseroTaskItem *input, BraseroTaskItem *output)
57
 
{
58
 
        BraseroTaskItemIFace *klass;
59
 
 
60
 
        g_return_val_if_fail (BRASERO_IS_TASK_ITEM (input), BRASERO_BURN_ERR);
61
 
        g_return_val_if_fail (BRASERO_IS_TASK_ITEM (output), BRASERO_BURN_ERR);
62
 
 
63
 
        klass = BRASERO_TASK_ITEM_GET_CLASS (input);
64
 
        if (klass->link)
65
 
                return klass->link (input, output);
66
 
 
67
 
        klass = BRASERO_TASK_ITEM_GET_CLASS (output);
68
 
        if (klass->link)
69
 
                return klass->link (input, output);
70
 
 
71
 
        return BRASERO_BURN_NOT_SUPPORTED;
72
 
}
73
 
 
74
 
BraseroTaskItem *
75
 
brasero_task_item_previous (BraseroTaskItem *item)
76
 
{
77
 
        BraseroTaskItemIFace *klass;
78
 
 
79
 
        g_return_val_if_fail (BRASERO_IS_TASK_ITEM (item), NULL);
80
 
 
81
 
        klass = BRASERO_TASK_ITEM_GET_CLASS (item);
82
 
        if (klass->previous)
83
 
                return klass->previous (item);
84
 
 
85
 
        return NULL;
86
 
}
87
 
 
88
 
BraseroTaskItem *
89
 
brasero_task_item_next (BraseroTaskItem *item)
90
 
{
91
 
        BraseroTaskItemIFace *klass;
92
 
 
93
 
        g_return_val_if_fail (BRASERO_IS_TASK_ITEM (item), NULL);
94
 
 
95
 
        klass = BRASERO_TASK_ITEM_GET_CLASS (item);
96
 
        if (klass->next)
97
 
                return klass->next (item);
98
 
 
99
 
        return NULL;
100
 
}
101
 
 
102
 
gboolean
103
 
brasero_task_item_is_active (BraseroTaskItem *item)
104
 
{
105
 
        BraseroTaskItemIFace *klass;
106
 
 
107
 
        g_return_val_if_fail (BRASERO_IS_TASK_ITEM (item), FALSE);
108
 
 
109
 
        klass = BRASERO_TASK_ITEM_GET_CLASS (item);
110
 
        if (klass->is_active)
111
 
                return klass->is_active (item);
112
 
 
113
 
        return FALSE;
114
 
}
115
 
 
116
 
BraseroBurnResult
117
 
brasero_task_item_activate (BraseroTaskItem *item,
118
 
                            BraseroTaskCtx *ctx,
119
 
                            GError **error)
120
 
{
121
 
        BraseroTaskItemIFace *klass;
122
 
 
123
 
        g_return_val_if_fail (BRASERO_IS_TASK_ITEM (item), BRASERO_BURN_ERR);
124
 
 
125
 
        klass = BRASERO_TASK_ITEM_GET_CLASS (item);
126
 
        if (klass->activate)
127
 
                return klass->activate (item, ctx, error);
128
 
 
129
 
        return BRASERO_BURN_NOT_SUPPORTED;
130
 
}
131
 
 
132
 
BraseroBurnResult
133
 
brasero_task_item_start (BraseroTaskItem *item,
134
 
                         GError **error)
135
 
{
136
 
        BraseroTaskItemIFace *klass;
137
 
 
138
 
        g_return_val_if_fail (BRASERO_IS_TASK_ITEM (item), BRASERO_BURN_ERR);
139
 
 
140
 
        klass = BRASERO_TASK_ITEM_GET_CLASS (item);
141
 
        if (klass->start)
142
 
                return klass->start (item, error);
143
 
 
144
 
        return BRASERO_BURN_NOT_SUPPORTED;
145
 
}
146
 
 
147
 
BraseroBurnResult
148
 
brasero_task_item_clock_tick (BraseroTaskItem *item,
149
 
                              BraseroTaskCtx *ctx,
150
 
                              GError **error)
151
 
{
152
 
        BraseroTaskItemIFace *klass;
153
 
 
154
 
        g_return_val_if_fail (BRASERO_IS_TASK_ITEM (item), BRASERO_BURN_ERR);
155
 
 
156
 
        klass = BRASERO_TASK_ITEM_GET_CLASS (item);
157
 
        if (klass->clock_tick)
158
 
                return klass->clock_tick (item, ctx, error);
159
 
 
160
 
        return BRASERO_BURN_NOT_SUPPORTED;
161
 
}
162
 
 
163
 
BraseroBurnResult
164
 
brasero_task_item_stop (BraseroTaskItem *item,
165
 
                        BraseroTaskCtx *ctx,
166
 
                        GError **error)
167
 
{
168
 
        BraseroTaskItemIFace *klass;
169
 
 
170
 
        g_return_val_if_fail (BRASERO_IS_TASK_ITEM (item), BRASERO_BURN_ERR);
171
 
 
172
 
        klass = BRASERO_TASK_ITEM_GET_CLASS (item);
173
 
        if (klass->stop)
174
 
                return klass->stop (item, ctx, error);
175
 
 
176
 
        return BRASERO_BURN_NOT_SUPPORTED;
177
 
}