← Back to branch summary

~ubuntu-branches/ubuntu/trusty/indicator-sound/trusty

« back to all changes in this revision

Viewing changes to src/transport-menu-item.c

  • Committer: Package Import Robot
  • Author(s): Automatic PS uploader, Mathieu Trudel-Lapierre, Automatic PS uploader
  • Date: 2012-11-21 11:47:58 UTC
  • mfrom: (28.51.54)
  • Revision ID: package-import@ubuntu.com-20121121114758-fvo8tle5qvg5xbkr
Tags: 12.10.2daily12.11.21.1-0ubuntu1
https://launchpad.net/bugs/1075753
https://launchpad.net/bugs/1064255
https://launchpad.net/bugs/1024705
[ Mathieu Trudel-Lapierre ]
* debian/control:
  - add gnome-common to Build-Depends for use by dh_autoreconf.
  - update style for constency: use trailing commas at the end of dep lists.
  - Add Vcs-Bzr, Vcs-Browser fields with comment for uploaders.
* debian/rules:
  - override dh_autoreconf to use autogen.sh for the reconfiguration process.
  - add export DPKG_GENSYMBOLS_CHECK_LEVEL=4.
  - enable quilt with the dh sequencer to make sure patches get applied.
* debian/compat: bump to compat level 9.
* debian/source/format: migrate back to source format 1.0 for consistency
  with the rest of the indicator stack.
* Automatic snapshot from revision 337 (bootstrap):
  - Add 'check-news' to AM_INIT_AUTOMAKE. (LP: #1075753)
  - Remove the determine_key function. (LP: #1064255)
  - Use the file path directly if it's an absolute path. (LP: #1024705)

[ Automatic PS uploader ]
* Automatic snapshot from revision 339

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/transport-menu-item.c
1
 
/* transport-menu-item.c generated by valac 0.16.1, the Vala compiler
2
 
 * generated from transport-menu-item.vala, do not modify */
3
 
 
4
 
/*
5
 
Copyright 2010 Canonical Ltd.
6
 
 
7
 
Authors:
8
 
    Conor Curran <conor.curran@canonical.com>
9
 
 
10
 
This program is free software: you can redistribute it and/or modify it 
11
 
under the terms of the GNU General Public License version 3, as published 
12
 
by the Free Software Foundation.
13
 
 
14
 
This program is distributed in the hope that it will be useful, but 
15
 
WITHOUT ANY WARRANTY; without even the implied warranties of 
16
 
MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
17
 
PURPOSE.  See the GNU General Public License for more details.
18
 
 
19
 
You should have received a copy of the GNU General Public License along 
20
 
with this program.  If not, see <http://www.gnu.org/licenses/>.
21
 
*/
22
 
 
23
 
#include <glib.h>
24
 
#include <glib-object.h>
25
 
#include <libdbusmenu-glib/client.h>
26
 
#include <libdbusmenu-glib/dbusmenu-glib.h>
27
 
#include <libdbusmenu-glib/enum-types.h>
28
 
#include <libdbusmenu-glib/menuitem-proxy.h>
29
 
#include <libdbusmenu-glib/menuitem.h>
30
 
#include <libdbusmenu-glib/server.h>
31
 
#include <libdbusmenu-glib/types.h>
32
 
#include <common-defs.h>
33
 
#include <gee.h>
34
 
#include <stdlib.h>
35
 
#include <string.h>
36
 
#include <gio/gio.h>
37
 
 
38
 
 
39
 
#define TYPE_PLAYER_ITEM (player_item_get_type ())
40
 
#define PLAYER_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PLAYER_ITEM, PlayerItem))
41
 
#define PLAYER_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PLAYER_ITEM, PlayerItemClass))
42
 
#define IS_PLAYER_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PLAYER_ITEM))
43
 
#define IS_PLAYER_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PLAYER_ITEM))
44
 
#define PLAYER_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PLAYER_ITEM, PlayerItemClass))
45
 
 
46
 
typedef struct _PlayerItem PlayerItem;
47
 
typedef struct _PlayerItemClass PlayerItemClass;
48
 
typedef struct _PlayerItemPrivate PlayerItemPrivate;
49
 
 
50
 
#define TYPE_TRANSPORT_MENUITEM (transport_menuitem_get_type ())
51
 
#define TRANSPORT_MENUITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRANSPORT_MENUITEM, TransportMenuitem))
52
 
#define TRANSPORT_MENUITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRANSPORT_MENUITEM, TransportMenuitemClass))
53
 
#define IS_TRANSPORT_MENUITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRANSPORT_MENUITEM))
54
 
#define IS_TRANSPORT_MENUITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRANSPORT_MENUITEM))
55
 
#define TRANSPORT_MENUITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRANSPORT_MENUITEM, TransportMenuitemClass))
56
 
 
57
 
typedef struct _TransportMenuitem TransportMenuitem;
58
 
typedef struct _TransportMenuitemClass TransportMenuitemClass;
59
 
typedef struct _TransportMenuitemPrivate TransportMenuitemPrivate;
60
 
 
61
 
#define TYPE_PLAYER_CONTROLLER (player_controller_get_type ())
62
 
#define PLAYER_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PLAYER_CONTROLLER, PlayerController))
63
 
#define PLAYER_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PLAYER_CONTROLLER, PlayerControllerClass))
64
 
#define IS_PLAYER_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PLAYER_CONTROLLER))
65
 
#define IS_PLAYER_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PLAYER_CONTROLLER))
66
 
#define PLAYER_CONTROLLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PLAYER_CONTROLLER, PlayerControllerClass))
67
 
 
68
 
typedef struct _PlayerController PlayerController;
69
 
typedef struct _PlayerControllerClass PlayerControllerClass;
70
 
typedef struct _PlayerControllerPrivate PlayerControllerPrivate;
71
 
 
72
 
#define TYPE_MPRIS2_CONTROLLER (mpris2_controller_get_type ())
73
 
#define MPRIS2_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MPRIS2_CONTROLLER, Mpris2Controller))
74
 
#define MPRIS2_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MPRIS2_CONTROLLER, Mpris2ControllerClass))
75
 
#define IS_MPRIS2_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MPRIS2_CONTROLLER))
76
 
#define IS_MPRIS2_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MPRIS2_CONTROLLER))
77
 
#define MPRIS2_CONTROLLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MPRIS2_CONTROLLER, Mpris2ControllerClass))
78
 
 
79
 
typedef struct _Mpris2Controller Mpris2Controller;
80
 
typedef struct _Mpris2ControllerClass Mpris2ControllerClass;
81
 
#define _g_variant_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_unref (var), NULL)))
82
 
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
83
 
 
84
 
#define PLAYER_CONTROLLER_TYPE_STATE (player_controller_state_get_type ())
85
 
 
86
 
struct _PlayerItem {
87
 
        DbusmenuMenuitem parent_instance;
88
 
        PlayerItemPrivate * priv;
89
 
};
90
 
 
91
 
struct _PlayerItemClass {
92
 
        DbusmenuMenuitemClass parent_class;
93
 
};
94
 
 
95
 
struct _TransportMenuitem {
96
 
        PlayerItem parent_instance;
97
 
        TransportMenuitemPrivate * priv;
98
 
};
99
 
 
100
 
struct _TransportMenuitemClass {
101
 
        PlayerItemClass parent_class;
102
 
};
103
 
 
104
 
struct _TransportMenuitemPrivate {
105
 
        TransportAction cached_action;
106
 
};
107
 
 
108
 
struct _PlayerController {
109
 
        GObject parent_instance;
110
 
        PlayerControllerPrivate * priv;
111
 
        gint current_state;
112
 
        DbusmenuMenuitem* root_menu;
113
 
        GeeArrayList* custom_items;
114
 
        Mpris2Controller* mpris_bridge;
115
 
        gboolean* use_playlists;
116
 
};
117
 
 
118
 
struct _PlayerControllerClass {
119
 
        GObjectClass parent_class;
120
 
};
121
 
 
122
 
typedef enum  {
123
 
        PLAYER_CONTROLLER_STATE_OFFLINE,
124
 
        PLAYER_CONTROLLER_STATE_INSTANTIATING,
125
 
        PLAYER_CONTROLLER_STATE_READY,
126
 
        PLAYER_CONTROLLER_STATE_CONNECTED,
127
 
        PLAYER_CONTROLLER_STATE_DISCONNECTED
128
 
} PlayerControllerstate;
129
 
 
130
 
 
131
 
static gpointer transport_menuitem_parent_class = NULL;
132
 
 
133
 
GType player_item_get_type (void) G_GNUC_CONST;
134
 
GType transport_menuitem_get_type (void) G_GNUC_CONST;
135
 
#define TRANSPORT_MENUITEM_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_TRANSPORT_MENUITEM, TransportMenuitemPrivate))
136
 
enum  {
137
 
        TRANSPORT_MENUITEM_DUMMY_PROPERTY
138
 
};
139
 
GType player_controller_get_type (void) G_GNUC_CONST;
140
 
TransportMenuitem* transport_menuitem_new (PlayerController* parent);
141
 
TransportMenuitem* transport_menuitem_construct (GType object_type, PlayerController* parent);
142
 
void transport_menuitem_handle_cached_action (TransportMenuitem* self);
143
 
static gboolean transport_menuitem_send_cached_action (TransportMenuitem* self);
144
 
static gboolean _transport_menuitem_send_cached_action_gsource_func (gpointer self);
145
 
PlayerController* player_item_get_owner (PlayerItem* self);
146
 
GType mpris2_controller_get_type (void) G_GNUC_CONST;
147
 
void mpris2_controller_transport_update (Mpris2Controller* self, TransportAction command);
148
 
void transport_menuitem_change_play_state (TransportMenuitem* self, TransportState update);
149
 
static void transport_menuitem_real_handle_event (DbusmenuMenuitem* base, const gchar* name, GVariant* input_value, guint timestamp);
150
 
static gboolean transport_menuitem_get_running (TransportMenuitem* self);
151
 
void player_controller_instantiate (PlayerController* self);
152
 
GeeHashSet* transport_menuitem_attributes_format (void);
153
 
GType player_controller_state_get_type (void) G_GNUC_CONST;
154
 
static GObject * transport_menuitem_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);
155
 
GAppInfo* player_controller_get_app_info (PlayerController* self);
156
 
static void transport_menuitem_finalize (GObject* obj);
157
 
static void _vala_transport_menuitem_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
158
 
 
159
 
 
160
 
TransportMenuitem* transport_menuitem_construct (GType object_type, PlayerController* parent) {
161
 
        TransportMenuitem * self = NULL;
162
 
        PlayerController* _tmp0_;
163
 
        g_return_val_if_fail (parent != NULL, NULL);
164
 
        _tmp0_ = parent;
165
 
        self = (TransportMenuitem*) g_object_new (object_type, "item-type", DBUSMENU_TRANSPORT_MENUITEM_TYPE, "owner", _tmp0_, NULL);
166
 
        return self;
167
 
}
168
 
 
169
 
 
170
 
TransportMenuitem* transport_menuitem_new (PlayerController* parent) {
171
 
        return transport_menuitem_construct (TYPE_TRANSPORT_MENUITEM, parent);
172
 
}
173
 
 
174
 
 
175
 
/**
176
 
  Please remove this timeout when the default player can handle mpris commands
177
 
  immediately once it raises its dbus interface
178
 
  **/
179
 
static gboolean _transport_menuitem_send_cached_action_gsource_func (gpointer self) {
180
 
        gboolean result;
181
 
        result = transport_menuitem_send_cached_action (self);
182
 
        return result;
183
 
}
184
 
 
185
 
 
186
 
void transport_menuitem_handle_cached_action (TransportMenuitem* self) {
187
 
        TransportAction _tmp0_;
188
 
        g_return_if_fail (self != NULL);
189
 
        _tmp0_ = self->priv->cached_action;
190
 
        if (_tmp0_ != TRANSPORT_ACTION_NO_ACTION) {
191
 
                g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, (guint) 1, _transport_menuitem_send_cached_action_gsource_func, g_object_ref (self), g_object_unref);
192
 
        }
193
 
}
194
 
 
195
 
 
196
 
static gboolean transport_menuitem_send_cached_action (TransportMenuitem* self) {
197
 
        gboolean result = FALSE;
198
 
        PlayerController* _tmp0_;
199
 
        PlayerController* _tmp1_;
200
 
        Mpris2Controller* _tmp2_;
201
 
        TransportAction _tmp3_;
202
 
        g_return_val_if_fail (self != NULL, FALSE);
203
 
        _tmp0_ = player_item_get_owner ((PlayerItem*) self);
204
 
        _tmp1_ = _tmp0_;
205
 
        _tmp2_ = _tmp1_->mpris_bridge;
206
 
        _tmp3_ = self->priv->cached_action;
207
 
        mpris2_controller_transport_update (_tmp2_, _tmp3_);
208
 
        self->priv->cached_action = TRANSPORT_ACTION_NO_ACTION;
209
 
        result = FALSE;
210
 
        return result;
211
 
}
212
 
 
213
 
 
214
 
void transport_menuitem_change_play_state (TransportMenuitem* self, TransportState update) {
215
 
        TransportState _tmp0_;
216
 
        gint temp;
217
 
        g_return_if_fail (self != NULL);
218
 
        _tmp0_ = update;
219
 
        temp = (gint) _tmp0_;
220
 
        dbusmenu_menuitem_property_set_int ((DbusmenuMenuitem*) self, DBUSMENU_TRANSPORT_MENUITEM_PLAY_STATE, temp);
221
 
}
222
 
 
223
 
 
224
 
static gpointer _g_variant_ref0 (gpointer self) {
225
 
        return self ? g_variant_ref (self) : NULL;
226
 
}
227
 
 
228
 
 
229
 
static void transport_menuitem_real_handle_event (DbusmenuMenuitem* base, const gchar* name, GVariant* input_value, guint timestamp) {
230
 
        TransportMenuitem * self;
231
 
        GVariant* _tmp0_;
232
 
        GVariant* _tmp1_;
233
 
        GVariant* v;
234
 
        GVariant* _tmp2_;
235
 
        const GVariantType* _tmp3_;
236
 
        gboolean _tmp4_ = FALSE;
237
 
        GVariant* _tmp7_;
238
 
        gint32 _tmp8_ = 0;
239
 
        gint32 input;
240
 
        gboolean _tmp9_;
241
 
        gboolean _tmp10_;
242
 
        self = (TransportMenuitem*) base;
243
 
        g_return_if_fail (name != NULL);
244
 
        g_return_if_fail (input_value != NULL);
245
 
        _tmp0_ = input_value;
246
 
        _tmp1_ = _g_variant_ref0 (_tmp0_);
247
 
        v = _tmp1_;
248
 
        _tmp2_ = input_value;
249
 
        _tmp3_ = G_VARIANT_TYPE_VARIANT;
250
 
        _tmp4_ = g_variant_is_of_type (_tmp2_, _tmp3_);
251
 
        if (_tmp4_) {
252
 
                GVariant* _tmp5_;
253
 
                GVariant* _tmp6_ = NULL;
254
 
                _tmp5_ = input_value;
255
 
                _tmp6_ = g_variant_get_variant (_tmp5_);
256
 
                _g_variant_unref0 (v);
257
 
                v = _tmp6_;
258
 
        }
259
 
        _tmp7_ = v;
260
 
        _tmp8_ = g_variant_get_int32 (_tmp7_);
261
 
        input = _tmp8_;
262
 
        _tmp9_ = transport_menuitem_get_running (self);
263
 
        _tmp10_ = _tmp9_;
264
 
        if (_tmp10_ == TRUE) {
265
 
                PlayerController* _tmp11_;
266
 
                PlayerController* _tmp12_;
267
 
                Mpris2Controller* _tmp13_;
268
 
                gint32 _tmp14_;
269
 
                _tmp11_ = player_item_get_owner ((PlayerItem*) self);
270
 
                _tmp12_ = _tmp11_;
271
 
                _tmp13_ = _tmp12_->mpris_bridge;
272
 
                _tmp14_ = input;
273
 
                mpris2_controller_transport_update (_tmp13_, (TransportAction) _tmp14_);
274
 
        } else {
275
 
                gint32 _tmp15_;
276
 
                PlayerController* _tmp16_;
277
 
                PlayerController* _tmp17_;
278
 
                _tmp15_ = input;
279
 
                self->priv->cached_action = (TransportAction) _tmp15_;
280
 
                _tmp16_ = player_item_get_owner ((PlayerItem*) self);
281
 
                _tmp17_ = _tmp16_;
282
 
                player_controller_instantiate (_tmp17_);
283
 
                dbusmenu_menuitem_property_set_int ((DbusmenuMenuitem*) self, DBUSMENU_TRANSPORT_MENUITEM_PLAY_STATE, (gint) TRANSPORT_STATE_LAUNCHING);
284
 
        }
285
 
        _g_variant_unref0 (v);
286
 
}
287
 
 
288
 
 
289
 
GeeHashSet* transport_menuitem_attributes_format (void) {
290
 
        GeeHashSet* result = NULL;
291
 
        GeeHashSet* _tmp0_;
292
 
        GeeHashSet* attrs;
293
 
        _tmp0_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL);
294
 
        attrs = _tmp0_;
295
 
        gee_abstract_collection_add ((GeeAbstractCollection*) attrs, DBUSMENU_TRANSPORT_MENUITEM_PLAY_STATE);
296
 
        result = attrs;
297
 
        return result;
298
 
}
299
 
 
300
 
 
301
 
static gboolean transport_menuitem_get_running (TransportMenuitem* self) {
302
 
        gboolean result;
303
 
        PlayerController* _tmp0_;
304
 
        PlayerController* _tmp1_;
305
 
        gint _tmp2_;
306
 
        g_return_val_if_fail (self != NULL, FALSE);
307
 
        _tmp0_ = player_item_get_owner ((PlayerItem*) self);
308
 
        _tmp1_ = _tmp0_;
309
 
        _tmp2_ = _tmp1_->current_state;
310
 
        result = _tmp2_ == ((gint) PLAYER_CONTROLLER_STATE_CONNECTED);
311
 
        return result;
312
 
}
313
 
 
314
 
 
315
 
static GObject * transport_menuitem_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
316
 
        GObject * obj;
317
 
        GObjectClass * parent_class;
318
 
        TransportMenuitem * self;
319
 
        PlayerController* _tmp0_;
320
 
        PlayerController* _tmp1_;
321
 
        GAppInfo* _tmp2_;
322
 
        GAppInfo* _tmp3_;
323
 
        const gchar* _tmp4_ = NULL;
324
 
        parent_class = G_OBJECT_CLASS (transport_menuitem_parent_class);
325
 
        obj = parent_class->constructor (type, n_construct_properties, construct_properties);
326
 
        self = TRANSPORT_MENUITEM (obj);
327
 
        dbusmenu_menuitem_property_set_int ((DbusmenuMenuitem*) self, DBUSMENU_TRANSPORT_MENUITEM_PLAY_STATE, (gint) TRANSPORT_STATE_PAUSED);
328
 
        _tmp0_ = player_item_get_owner ((PlayerItem*) self);
329
 
        _tmp1_ = _tmp0_;
330
 
        _tmp2_ = player_controller_get_app_info (_tmp1_);
331
 
        _tmp3_ = _tmp2_;
332
 
        _tmp4_ = g_app_info_get_name (_tmp3_);
333
 
        dbusmenu_menuitem_property_set ((DbusmenuMenuitem*) self, DBUSMENU_MENUITEM_PROP_LABEL, _tmp4_);
334
 
        self->priv->cached_action = TRANSPORT_ACTION_NO_ACTION;
335
 
        return obj;
336
 
}
337
 
 
338
 
 
339
 
static void transport_menuitem_class_init (TransportMenuitemClass * klass) {
340
 
        transport_menuitem_parent_class = g_type_class_peek_parent (klass);
341
 
        g_type_class_add_private (klass, sizeof (TransportMenuitemPrivate));
342
 
        DBUSMENU_MENUITEM_CLASS (klass)->handle_event = transport_menuitem_real_handle_event;
343
 
        G_OBJECT_CLASS (klass)->get_property = _vala_transport_menuitem_get_property;
344
 
        G_OBJECT_CLASS (klass)->constructor = transport_menuitem_constructor;
345
 
        G_OBJECT_CLASS (klass)->finalize = transport_menuitem_finalize;
346
 
}
347
 
 
348
 
 
349
 
static void transport_menuitem_instance_init (TransportMenuitem * self) {
350
 
        self->priv = TRANSPORT_MENUITEM_GET_PRIVATE (self);
351
 
}
352
 
 
353
 
 
354
 
static void transport_menuitem_finalize (GObject* obj) {
355
 
        TransportMenuitem * self;
356
 
        self = TRANSPORT_MENUITEM (obj);
357
 
        G_OBJECT_CLASS (transport_menuitem_parent_class)->finalize (obj);
358
 
}
359
 
 
360
 
 
361
 
GType transport_menuitem_get_type (void) {
362
 
        static volatile gsize transport_menuitem_type_id__volatile = 0;
363
 
        if (g_once_init_enter (&transport_menuitem_type_id__volatile)) {
364
 
                static const GTypeInfo g_define_type_info = { sizeof (TransportMenuitemClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) transport_menuitem_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TransportMenuitem), 0, (GInstanceInitFunc) transport_menuitem_instance_init, NULL };
365
 
                GType transport_menuitem_type_id;
366
 
                transport_menuitem_type_id = g_type_register_static (TYPE_PLAYER_ITEM, "TransportMenuitem", &g_define_type_info, 0);
367
 
                g_once_init_leave (&transport_menuitem_type_id__volatile, transport_menuitem_type_id);
368
 
        }
369
 
        return transport_menuitem_type_id__volatile;
370
 
}
371
 
 
372
 
 
373
 
static void _vala_transport_menuitem_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
374
 
        TransportMenuitem * self;
375
 
        self = TRANSPORT_MENUITEM (object);
376
 
        switch (property_id) {
377
 
                default:
378
 
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
379
 
                break;
380
 
        }
381
 
}
382
 
 
383
 
 
384