← Back to branch summary

~ubuntu-branches/ubuntu/trusty/evince/trusty-proposed

« back to all changes in this revision

Viewing changes to backend/ev-link-action.c

Tags: upstream-0.5.3
Import upstream version 0.5.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
backend/ev-link-action.c
 
1
/* this file is part of evince, a gnome document viewer
 
2
 *
 
3
 *  Copyright (C) 2006 Carlos Garcia Campos <carlosgc@gnome.org>
 
4
 *  Copyright (C) 2005 Red Hat, Inc.
 
5
 *
 
6
 * Evince is free software; you can redistribute it and/or modify it
 
7
 * under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; either version 2 of the License, or
 
9
 * (at your option) any later version.
 
10
 *
 
11
 * Evince is distributed in the hope that it will be useful, but
 
12
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
 * General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
 
19
 */
 
20
 
 
21
#include "ev-link-action.h"
 
22
 
 
23
enum {
 
24
        PROP_0,
 
25
        PROP_TYPE,
 
26
        PROP_DEST,
 
27
        PROP_URI,
 
28
        PROP_FILENAME,
 
29
        PROP_PARAMS,
 
30
        PROP_NAME
 
31
};
 
32
 
 
33
struct _EvLinkAction {
 
34
        GObject base_instance;
 
35
 
 
36
        EvLinkActionPrivate *priv;
 
37
};
 
38
 
 
39
struct _EvLinkActionClass {
 
40
        GObjectClass base_class;
 
41
};
 
42
 
 
43
struct _EvLinkActionPrivate {
 
44
        EvLinkActionType  type;
 
45
        EvLinkDest       *dest;
 
46
        gchar            *uri;
 
47
        gchar            *filename;
 
48
        gchar            *params;
 
49
        gchar            *name;
 
50
};
 
51
 
 
52
G_DEFINE_TYPE (EvLinkAction, ev_link_action, G_TYPE_OBJECT)
 
53
 
 
54
#define EV_LINK_ACTION_GET_PRIVATE(object) \
 
55
        (G_TYPE_INSTANCE_GET_PRIVATE ((object), EV_TYPE_LINK_ACTION, EvLinkActionPrivate))
 
56
 
 
57
GType
 
58
ev_link_action_type_get_type (void)
 
59
{
 
60
        static GType type = 0;
 
61
 
 
62
        if (G_UNLIKELY (type == 0)) {
 
63
                static const GEnumValue values[] = {
 
64
                        { EV_LINK_ACTION_TYPE_GOTO_DEST, "EV_LINK_ACTION_TYPE_GOTO_DEST", "goto-dest" },
 
65
                        { EV_LINK_ACTION_TYPE_GOTO_REMOTE, "EV_LINK_ACTION_TYPE_GOTO_REMOTE", "goto-remote" },
 
66
                        { EV_LINK_ACTION_TYPE_LAUNCH, "EV_LINK_ACTION_TYPE_LAUNCH", "launch" },
 
67
                        { EV_LINK_ACTION_TYPE_EXTERNAL_URI, "EV_LINK_ACTION_TYPE_EXTERNAL_URI", "external-uri"},
 
68
                        { EV_LINK_ACTION_TYPE_NAMED, "EV_LINK_ACTION_TYPE_NAMED", "named"},
 
69
                        { 0, NULL, NULL }
 
70
                };
 
71
 
 
72
                type = g_enum_register_static ("EvLinkActionType", values);
 
73
        }
 
74
 
 
75
        return type;
 
76
}
 
77
 
 
78
EvLinkActionType
 
79
ev_link_action_get_action_type (EvLinkAction *self)
 
80
{
 
81
        g_return_val_if_fail (EV_IS_LINK_ACTION (self), 0);
 
82
 
 
83
        return self->priv->type;
 
84
}
 
85
 
 
86
EvLinkDest *
 
87
ev_link_action_get_dest (EvLinkAction *self)
 
88
{
 
89
        g_return_val_if_fail (EV_IS_LINK_ACTION (self), NULL);
 
90
 
 
91
        return self->priv->dest;
 
92
}
 
93
 
 
94
const gchar *
 
95
ev_link_action_get_uri (EvLinkAction *self)
 
96
{
 
97
        g_return_val_if_fail (EV_IS_LINK_ACTION (self), NULL);
 
98
 
 
99
        return self->priv->uri;
 
100
}
 
101
 
 
102
const gchar *
 
103
ev_link_action_get_filename (EvLinkAction *self)
 
104
{
 
105
        g_return_val_if_fail (EV_IS_LINK_ACTION (self), NULL);
 
106
 
 
107
        return self->priv->filename;
 
108
}
 
109
 
 
110
const gchar *
 
111
ev_link_action_get_params (EvLinkAction *self)
 
112
{
 
113
        g_return_val_if_fail (EV_IS_LINK_ACTION (self), NULL);
 
114
 
 
115
        return self->priv->params;
 
116
}
 
117
 
 
118
const gchar *
 
119
ev_link_action_get_name (EvLinkAction *self)
 
120
{
 
121
        g_return_val_if_fail (EV_IS_LINK_ACTION (self), NULL);
 
122
 
 
123
        return self->priv->name;
 
124
}
 
125
 
 
126
static void
 
127
ev_link_action_get_property (GObject    *object,
 
128
                             guint       prop_id,
 
129
                             GValue     *value,
 
130
                             GParamSpec *param_spec)
 
131
{
 
132
        EvLinkAction *self;
 
133
 
 
134
        self = EV_LINK_ACTION (object);
 
135
 
 
136
        switch (prop_id) {
 
137
                case PROP_TYPE:
 
138
                        g_value_set_enum (value, self->priv->type);
 
139
                        break;
 
140
                case PROP_DEST:
 
141
                        g_value_set_pointer (value, self->priv->dest);
 
142
                        break;
 
143
                case PROP_URI:
 
144
                        g_value_set_string (value, self->priv->uri);
 
145
                        break;
 
146
                case PROP_FILENAME:
 
147
                        g_value_set_string (value, self->priv->filename);
 
148
                        break;
 
149
                case PROP_PARAMS:
 
150
                        g_value_set_string (value, self->priv->params);
 
151
                        break;
 
152
                case PROP_NAME:
 
153
                        g_value_set_string (value, self->priv->name);
 
154
                        break;
 
155
                default:
 
156
                        G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
 
157
                                                           prop_id,
 
158
                                                           param_spec);
 
159
                        break;
 
160
        }
 
161
}
 
162
 
 
163
static void
 
164
ev_link_action_set_property (GObject      *object,
 
165
                             guint         prop_id,
 
166
                             const GValue *value,
 
167
                             GParamSpec   *param_spec)
 
168
{
 
169
        EvLinkAction *self = EV_LINK_ACTION (object);
 
170
 
 
171
        switch (prop_id) {
 
172
                case PROP_TYPE:
 
173
                        self->priv->type = g_value_get_enum (value);
 
174
                        break;
 
175
                case PROP_DEST:
 
176
                        self->priv->dest = g_value_get_pointer (value);
 
177
                        break;
 
178
                case PROP_URI:
 
179
                        g_free (self->priv->uri);
 
180
                        self->priv->uri = g_value_dup_string (value);
 
181
                        break;
 
182
                case PROP_FILENAME:
 
183
                        g_free (self->priv->filename);
 
184
                        self->priv->filename = g_value_dup_string (value);
 
185
                        break;
 
186
                case PROP_PARAMS:
 
187
                        g_free (self->priv->params);
 
188
                        self->priv->params = g_value_dup_string (value);
 
189
                        break;
 
190
                case PROP_NAME:
 
191
                        g_free (self->priv->name);
 
192
                        self->priv->name = g_value_dup_string (value);
 
193
                        break;
 
194
                default:
 
195
                        G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
 
196
                                                           prop_id,
 
197
                                                           param_spec);
 
198
                        break;
 
199
        }
 
200
}
 
201
 
 
202
static void
 
203
ev_link_action_finalize (GObject *object)
 
204
{
 
205
        EvLinkActionPrivate *priv;
 
206
 
 
207
        priv = EV_LINK_ACTION (object)->priv;
 
208
 
 
209
        if (priv->dest) {
 
210
                g_object_unref (priv->dest);
 
211
                priv->dest = NULL;
 
212
        }
 
213
 
 
214
        if (priv->uri) {
 
215
                g_free (priv->uri);
 
216
                priv->uri = NULL;
 
217
        }
 
218
 
 
219
        if (priv->filename) {
 
220
                g_free (priv->filename);
 
221
                priv->filename = NULL;
 
222
        }
 
223
 
 
224
        if (priv->params) {
 
225
                g_free (priv->params);
 
226
                priv->params = NULL;
 
227
        }
 
228
 
 
229
        if (priv->name) {
 
230
                g_free (priv->name);
 
231
                priv->name = NULL;
 
232
        }
 
233
 
 
234
        G_OBJECT_CLASS (ev_link_action_parent_class)->finalize (object);
 
235
}
 
236
 
 
237
static void
 
238
ev_link_action_init (EvLinkAction *ev_link_action)
 
239
{
 
240
        ev_link_action->priv = EV_LINK_ACTION_GET_PRIVATE (ev_link_action);
 
241
 
 
242
        ev_link_action->priv->dest = NULL;
 
243
        ev_link_action->priv->uri = NULL;
 
244
        ev_link_action->priv->filename = NULL;
 
245
        ev_link_action->priv->params = NULL;
 
246
        ev_link_action->priv->name = NULL;
 
247
}
 
248
 
 
249
static void
 
250
ev_link_action_class_init (EvLinkActionClass *ev_link_action_class)
 
251
{
 
252
        GObjectClass *g_object_class;
 
253
 
 
254
        g_object_class = G_OBJECT_CLASS (ev_link_action_class);
 
255
 
 
256
        g_object_class->set_property = ev_link_action_set_property;
 
257
        g_object_class->get_property = ev_link_action_get_property;
 
258
 
 
259
        g_object_class->finalize = ev_link_action_finalize;
 
260
 
 
261
        g_type_class_add_private (g_object_class, sizeof (EvLinkActionPrivate));
 
262
 
 
263
        g_object_class_install_property (g_object_class,
 
264
                                         PROP_TYPE,
 
265
                                         g_param_spec_enum  ("type",
 
266
                                                             "Action Type",
 
267
                                                             "The link action type",
 
268
                                                             EV_TYPE_LINK_ACTION_TYPE,
 
269
                                                             EV_LINK_ACTION_TYPE_GOTO_DEST,
 
270
                                                             G_PARAM_READWRITE |
 
271
                                                             G_PARAM_CONSTRUCT_ONLY));
 
272
        g_object_class_install_property (g_object_class,
 
273
                                         PROP_DEST,
 
274
                                         g_param_spec_pointer ("dest",
 
275
                                                               "Action destination",
 
276
                                                               "The link action destination",
 
277
                                                               G_PARAM_READWRITE |
 
278
                                                               G_PARAM_CONSTRUCT_ONLY));
 
279
        g_object_class_install_property (g_object_class,
 
280
                                         PROP_URI,
 
281
                                         g_param_spec_string ("uri",
 
282
                                                              "Link Action URI",
 
283
                                                              "The link action URI",
 
284
                                                              NULL,
 
285
                                                              G_PARAM_READWRITE |
 
286
                                                              G_PARAM_CONSTRUCT_ONLY));
 
287
        g_object_class_install_property (g_object_class,
 
288
                                         PROP_FILENAME,
 
289
                                         g_param_spec_string ("filename",
 
290
                                                              "Filename",
 
291
                                                              "The link action filename",
 
292
                                                              NULL,
 
293
                                                              G_PARAM_READWRITE |
 
294
                                                              G_PARAM_CONSTRUCT_ONLY));
 
295
        g_object_class_install_property (g_object_class,
 
296
                                         PROP_PARAMS,
 
297
                                         g_param_spec_string ("params",
 
298
                                                              "Params",
 
299
                                                              "The link action params",
 
300
                                                              NULL,
 
301
                                                              G_PARAM_READWRITE |
 
302
                                                              G_PARAM_CONSTRUCT_ONLY));
 
303
        g_object_class_install_property (g_object_class,
 
304
                                         PROP_NAME,
 
305
                                         g_param_spec_string ("name",
 
306
                                                              "Name",
 
307
                                                              "The link action name",
 
308
                                                              NULL,
 
309
                                                              G_PARAM_READWRITE |
 
310
                                                              G_PARAM_CONSTRUCT_ONLY));
 
311
}
 
312
 
 
313
EvLinkAction *
 
314
ev_link_action_new_dest (EvLinkDest *dest)
 
315
{
 
316
        return EV_LINK_ACTION (g_object_new (EV_TYPE_LINK_ACTION,
 
317
                                             "dest", dest,
 
318
                                             "type", EV_LINK_ACTION_TYPE_GOTO_DEST,
 
319
                                             NULL));
 
320
}
 
321
 
 
322
EvLinkAction *
 
323
ev_link_action_new_remote (EvLinkDest  *dest,
 
324
                           const gchar *filename)
 
325
{
 
326
        return EV_LINK_ACTION (g_object_new (EV_TYPE_LINK_ACTION,
 
327
                                             "dest", dest,
 
328
                                             "filename", filename,
 
329
                                             "type", EV_LINK_ACTION_TYPE_GOTO_REMOTE,
 
330
                                             NULL));
 
331
}
 
332
 
 
333
EvLinkAction *
 
334
ev_link_action_new_external_uri (const gchar *uri)
 
335
{
 
336
        return EV_LINK_ACTION (g_object_new (EV_TYPE_LINK_ACTION,
 
337
                                             "uri", uri,
 
338
                                             "type", EV_LINK_ACTION_TYPE_EXTERNAL_URI,
 
339
                                             NULL));
 
340
}
 
341
 
 
342
EvLinkAction *
 
343
ev_link_action_new_launch (const gchar *filename,
 
344
                           const gchar *params)
 
345
{
 
346
        return EV_LINK_ACTION (g_object_new (EV_TYPE_LINK_ACTION,
 
347
                                             "filename", filename,
 
348
                                             "params", params,
 
349
                                             "type", EV_LINK_ACTION_TYPE_LAUNCH,
 
350
                                             NULL));
 
351
}
 
352
 
 
353
EvLinkAction *
 
354
ev_link_action_new_named (const gchar *name)
 
355
{
 
356
        return EV_LINK_ACTION (g_object_new (EV_TYPE_LINK_ACTION,
 
357
                                             "name", name,
 
358
                                             "type", EV_LINK_ACTION_TYPE_NAMED,
 
359
                                             NULL));
 
360
}