← Back to branch summary

~nathandyer/birdie/manual-import

« back to all changes in this revision

Viewing changes to build/src/Utils/System.c

  • Committer: Nathan Dyer
  • Date: 2016-02-06 20:22:09 UTC
  • Revision ID: mail@nathandyer.me-20160206202209-qwhtqwi1j8feglds
Updated to git master

Show diffs side-by-side

added added

removed removed

Lines of Context:
build/src/Utils/System.c
1
 
/* System.c generated by valac 0.30.0, the Vala compiler
2
 
 * generated from System.vala, do not modify */
3
 
 
4
 
/* -*- Mode: vala; indent-tabs-mode: nil; tab-width: 4 -*-*/
5
 
/*-
6
 
 * Copyright (c) 2013-2016 Birdie Developers (http://birdieapp.github.io)
7
 
 *
8
 
 * This software is licensed under the GNU General Public License
9
 
 * (version 3 or later). See the COPYING file in this distribution.
10
 
 *
11
 
 * You should have received a copy of the GNU Library General Public
12
 
 * License along with this software; if not, write to the
13
 
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
14
 
 * Boston, MA 02111-1307, USA.
15
 
 *
16
 
 * Authored by: Ivo Nunes <ivoavnunes@gmail.com>
17
 
 *              Vasco Nunes <vascomfnunes@gmail.com>
18
 
 *              Nathan Dyer <mail@nathandyer.me>
19
 
 */
20
 
 
21
 
#include <glib.h>
22
 
#include <glib-object.h>
23
 
#include <stdlib.h>
24
 
#include <string.h>
25
 
#include <gio/gio.h>
26
 
 
27
 
 
28
 
#define BIRDIE_UTILS_TYPE_CINNA (birdie_utils_cinna_get_type ())
29
 
#define BIRDIE_UTILS_CINNA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BIRDIE_UTILS_TYPE_CINNA, BirdieUtilscinna))
30
 
#define BIRDIE_UTILS_IS_CINNA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BIRDIE_UTILS_TYPE_CINNA))
31
 
#define BIRDIE_UTILS_CINNA_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), BIRDIE_UTILS_TYPE_CINNA, BirdieUtilscinnaIface))
32
 
 
33
 
typedef struct _BirdieUtilscinna BirdieUtilscinna;
34
 
typedef struct _BirdieUtilscinnaIface BirdieUtilscinnaIface;
35
 
 
36
 
#define BIRDIE_UTILS_TYPE_CINNA_PROXY (birdie_utils_cinna_proxy_get_type ())
37
 
typedef GDBusProxy BirdieUtilscinnaProxy;
38
 
typedef GDBusProxyClass BirdieUtilscinnaProxyClass;
39
 
#define _g_free0(var) (var = (g_free (var), NULL))
40
 
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
41
 
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
42
 
 
43
 
#define BIRDIE_UTILS_TYPE_GNOME_SHELL (birdie_utils_gnome_shell_get_type ())
44
 
#define BIRDIE_UTILS_GNOME_SHELL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BIRDIE_UTILS_TYPE_GNOME_SHELL, BirdieUtilsGnomeShell))
45
 
#define BIRDIE_UTILS_IS_GNOME_SHELL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BIRDIE_UTILS_TYPE_GNOME_SHELL))
46
 
#define BIRDIE_UTILS_GNOME_SHELL_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), BIRDIE_UTILS_TYPE_GNOME_SHELL, BirdieUtilsGnomeShellIface))
47
 
 
48
 
typedef struct _BirdieUtilsGnomeShell BirdieUtilsGnomeShell;
49
 
typedef struct _BirdieUtilsGnomeShellIface BirdieUtilsGnomeShellIface;
50
 
 
51
 
#define BIRDIE_UTILS_TYPE_GNOME_SHELL_PROXY (birdie_utils_gnome_shell_proxy_get_type ())
52
 
typedef GDBusProxy BirdieUtilsGnomeShellProxy;
53
 
typedef GDBusProxyClass BirdieUtilsGnomeShellProxyClass;
54
 
 
55
 
struct _BirdieUtilscinnaIface {
56
 
        GTypeInterface parent_iface;
57
 
        gchar* (*get_CinnamonVersion) (BirdieUtilscinna* self);
58
 
};
59
 
 
60
 
struct _BirdieUtilsGnomeShellIface {
61
 
        GTypeInterface parent_iface;
62
 
        gchar* (*get_ShellVersion) (BirdieUtilsGnomeShell* self);
63
 
};
64
 
 
65
 
 
66
 
 
67
 
GType birdie_utils_cinna_get_type (void) G_GNUC_CONST;
68
 
GType birdie_utils_cinna_proxy_get_type (void) G_GNUC_CONST;
69
 
guint birdie_utils_cinna_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
70
 
gchar* birdie_utils_cinna_get_CinnamonVersion (BirdieUtilscinna* self);
71
 
static void birdie_utils_cinna_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters);
72
 
static gchar* birdie_utils_cinna_dbus_proxy_get_CinnamonVersion (BirdieUtilscinna* self);
73
 
static void birdie_utils_cinna_proxy_birdie_utils_cinna_interface_init (BirdieUtilscinnaIface* iface);
74
 
static void birdie_utils_cinna_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data);
75
 
static GVariant* birdie_utils_cinna_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data);
76
 
static GVariant* _dbus_birdie_utils_cinna_get_CinnamonVersion (BirdieUtilscinna* self);
77
 
static gboolean birdie_utils_cinna_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data);
78
 
static void _birdie_utils_cinna_unregister_object (gpointer user_data);
79
 
gboolean birdie_utils_is_cinnamon (void);
80
 
GType birdie_utils_gnome_shell_get_type (void) G_GNUC_CONST;
81
 
GType birdie_utils_gnome_shell_proxy_get_type (void) G_GNUC_CONST;
82
 
guint birdie_utils_gnome_shell_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
83
 
gchar* birdie_utils_gnome_shell_get_ShellVersion (BirdieUtilsGnomeShell* self);
84
 
static void birdie_utils_gnome_shell_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters);
85
 
static gchar* birdie_utils_gnome_shell_dbus_proxy_get_ShellVersion (BirdieUtilsGnomeShell* self);
86
 
static void birdie_utils_gnome_shell_proxy_birdie_utils_gnome_shell_interface_init (BirdieUtilsGnomeShellIface* iface);
87
 
static void birdie_utils_gnome_shell_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data);
88
 
static GVariant* birdie_utils_gnome_shell_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data);
89
 
static GVariant* _dbus_birdie_utils_gnome_shell_get_ShellVersion (BirdieUtilsGnomeShell* self);
90
 
static gboolean birdie_utils_gnome_shell_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data);
91
 
static void _birdie_utils_gnome_shell_unregister_object (gpointer user_data);
92
 
gboolean birdie_utils_is_gnome (void);
93
 
 
94
 
static const GDBusMethodInfo * const _birdie_utils_cinna_dbus_method_info[] = {NULL};
95
 
static const GDBusSignalInfo * const _birdie_utils_cinna_dbus_signal_info[] = {NULL};
96
 
static const GDBusPropertyInfo _birdie_utils_cinna_dbus_property_info_CinnamonVersion = {-1, "CinnamonVersion", "s", G_DBUS_PROPERTY_INFO_FLAGS_READABLE};
97
 
static const GDBusPropertyInfo * const _birdie_utils_cinna_dbus_property_info[] = {&_birdie_utils_cinna_dbus_property_info_CinnamonVersion, NULL};
98
 
static const GDBusInterfaceInfo _birdie_utils_cinna_dbus_interface_info = {-1, "org.Cinnamon", (GDBusMethodInfo **) (&_birdie_utils_cinna_dbus_method_info), (GDBusSignalInfo **) (&_birdie_utils_cinna_dbus_signal_info), (GDBusPropertyInfo **) (&_birdie_utils_cinna_dbus_property_info)};
99
 
static const GDBusInterfaceVTable _birdie_utils_cinna_dbus_interface_vtable = {birdie_utils_cinna_dbus_interface_method_call, birdie_utils_cinna_dbus_interface_get_property, birdie_utils_cinna_dbus_interface_set_property};
100
 
static const GDBusMethodInfo * const _birdie_utils_gnome_shell_dbus_method_info[] = {NULL};
101
 
static const GDBusSignalInfo * const _birdie_utils_gnome_shell_dbus_signal_info[] = {NULL};
102
 
static const GDBusPropertyInfo _birdie_utils_gnome_shell_dbus_property_info_ShellVersion = {-1, "ShellVersion", "s", G_DBUS_PROPERTY_INFO_FLAGS_READABLE};
103
 
static const GDBusPropertyInfo * const _birdie_utils_gnome_shell_dbus_property_info[] = {&_birdie_utils_gnome_shell_dbus_property_info_ShellVersion, NULL};
104
 
static const GDBusInterfaceInfo _birdie_utils_gnome_shell_dbus_interface_info = {-1, "org.gnome.Shell", (GDBusMethodInfo **) (&_birdie_utils_gnome_shell_dbus_method_info), (GDBusSignalInfo **) (&_birdie_utils_gnome_shell_dbus_signal_info), (GDBusPropertyInfo **) (&_birdie_utils_gnome_shell_dbus_property_info)};
105
 
static const GDBusInterfaceVTable _birdie_utils_gnome_shell_dbus_interface_vtable = {birdie_utils_gnome_shell_dbus_interface_method_call, birdie_utils_gnome_shell_dbus_interface_get_property, birdie_utils_gnome_shell_dbus_interface_set_property};
106
 
 
107
 
gchar* birdie_utils_cinna_get_CinnamonVersion (BirdieUtilscinna* self) {
108
 
        g_return_val_if_fail (self != NULL, NULL);
109
 
        return BIRDIE_UTILS_CINNA_GET_INTERFACE (self)->get_CinnamonVersion (self);
110
 
}
111
 
 
112
 
 
113
 
static void birdie_utils_cinna_base_init (BirdieUtilscinnaIface * iface) {
114
 
        static gboolean initialized = FALSE;
115
 
        if (!initialized) {
116
 
                initialized = TRUE;
117
 
        }
118
 
}
119
 
 
120
 
 
121
 
GType birdie_utils_cinna_get_type (void) {
122
 
        static volatile gsize birdie_utils_cinna_type_id__volatile = 0;
123
 
        if (g_once_init_enter (&birdie_utils_cinna_type_id__volatile)) {
124
 
                static const GTypeInfo g_define_type_info = { sizeof (BirdieUtilscinnaIface), (GBaseInitFunc) birdie_utils_cinna_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
125
 
                GType birdie_utils_cinna_type_id;
126
 
                birdie_utils_cinna_type_id = g_type_register_static (G_TYPE_INTERFACE, "BirdieUtilscinna", &g_define_type_info, 0);
127
 
                g_type_interface_add_prerequisite (birdie_utils_cinna_type_id, G_TYPE_OBJECT);
128
 
                g_type_set_qdata (birdie_utils_cinna_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) birdie_utils_cinna_proxy_get_type);
129
 
                g_type_set_qdata (birdie_utils_cinna_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.Cinnamon");
130
 
                g_type_set_qdata (birdie_utils_cinna_type_id, g_quark_from_static_string ("vala-dbus-interface-info"), (void*) (&_birdie_utils_cinna_dbus_interface_info));
131
 
                g_type_set_qdata (birdie_utils_cinna_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) birdie_utils_cinna_register_object);
132
 
                g_once_init_leave (&birdie_utils_cinna_type_id__volatile, birdie_utils_cinna_type_id);
133
 
        }
134
 
        return birdie_utils_cinna_type_id__volatile;
135
 
}
136
 
 
137
 
 
138
 
G_DEFINE_TYPE_EXTENDED (BirdieUtilscinnaProxy, birdie_utils_cinna_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (BIRDIE_UTILS_TYPE_CINNA, birdie_utils_cinna_proxy_birdie_utils_cinna_interface_init) )
139
 
static void birdie_utils_cinna_proxy_class_init (BirdieUtilscinnaProxyClass* klass) {
140
 
        G_DBUS_PROXY_CLASS (klass)->g_signal = birdie_utils_cinna_proxy_g_signal;
141
 
}
142
 
 
143
 
 
144
 
static void birdie_utils_cinna_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters) {
145
 
}
146
 
 
147
 
 
148
 
static void birdie_utils_cinna_proxy_init (BirdieUtilscinnaProxy* self) {
149
 
}
150
 
 
151
 
 
152
 
static gchar* birdie_utils_cinna_dbus_proxy_get_CinnamonVersion (BirdieUtilscinna* self) {
153
 
        GVariant *_inner_reply;
154
 
        gchar* _result;
155
 
        _inner_reply = g_dbus_proxy_get_cached_property ((GDBusProxy *) self, "CinnamonVersion");
156
 
        if (!_inner_reply) {
157
 
                GVariant *_arguments;
158
 
                GVariant *_reply;
159
 
                GVariantBuilder _arguments_builder;
160
 
                g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
161
 
                g_variant_builder_add_value (&_arguments_builder, g_variant_new_string ("org.Cinnamon"));
162
 
                g_variant_builder_add_value (&_arguments_builder, g_variant_new_string ("CinnamonVersion"));
163
 
                _arguments = g_variant_builder_end (&_arguments_builder);
164
 
                _reply = g_dbus_proxy_call_sync ((GDBusProxy *) self, "org.freedesktop.DBus.Properties.Get", _arguments, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL);
165
 
                if (!_reply) {
166
 
                        return NULL;
167
 
                }
168
 
                g_variant_get (_reply, "(v)", &_inner_reply);
169
 
                g_variant_unref (_reply);
170
 
        }
171
 
        _result = g_variant_dup_string (_inner_reply, NULL);
172
 
        g_variant_unref (_inner_reply);
173
 
        return _result;
174
 
}
175
 
 
176
 
 
177
 
static void birdie_utils_cinna_proxy_birdie_utils_cinna_interface_init (BirdieUtilscinnaIface* iface) {
178
 
        iface->get_CinnamonVersion = birdie_utils_cinna_dbus_proxy_get_CinnamonVersion;
179
 
}
180
 
 
181
 
 
182
 
static void birdie_utils_cinna_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data) {
183
 
        gpointer* data;
184
 
        gpointer object;
185
 
        data = user_data;
186
 
        object = data[0];
187
 
        g_object_unref (invocation);
188
 
}
189
 
 
190
 
 
191
 
static GVariant* _dbus_birdie_utils_cinna_get_CinnamonVersion (BirdieUtilscinna* self) {
192
 
        gchar* result;
193
 
        GVariant* _reply;
194
 
        result = birdie_utils_cinna_get_CinnamonVersion (self);
195
 
        _reply = g_variant_new_string (result);
196
 
        _g_free0 (result);
197
 
        return _reply;
198
 
}
199
 
 
200
 
 
201
 
static GVariant* birdie_utils_cinna_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data) {
202
 
        gpointer* data;
203
 
        gpointer object;
204
 
        data = user_data;
205
 
        object = data[0];
206
 
        if (strcmp (property_name, "CinnamonVersion") == 0) {
207
 
                return _dbus_birdie_utils_cinna_get_CinnamonVersion (object);
208
 
        }
209
 
        return NULL;
210
 
}
211
 
 
212
 
 
213
 
static gboolean birdie_utils_cinna_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data) {
214
 
        gpointer* data;
215
 
        gpointer object;
216
 
        data = user_data;
217
 
        object = data[0];
218
 
        return FALSE;
219
 
}
220
 
 
221
 
 
222
 
guint birdie_utils_cinna_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
223
 
        guint result;
224
 
        gpointer *data;
225
 
        data = g_new (gpointer, 3);
226
 
        data[0] = g_object_ref (object);
227
 
        data[1] = g_object_ref (connection);
228
 
        data[2] = g_strdup (path);
229
 
        result = g_dbus_connection_register_object (connection, path, (GDBusInterfaceInfo *) (&_birdie_utils_cinna_dbus_interface_info), &_birdie_utils_cinna_dbus_interface_vtable, data, _birdie_utils_cinna_unregister_object, error);
230
 
        if (!result) {
231
 
                return 0;
232
 
        }
233
 
        return result;
234
 
}
235
 
 
236
 
 
237
 
static void _birdie_utils_cinna_unregister_object (gpointer user_data) {
238
 
        gpointer* data;
239
 
        data = user_data;
240
 
        g_object_unref (data[0]);
241
 
        g_object_unref (data[1]);
242
 
        g_free (data[2]);
243
 
        g_free (data);
244
 
}
245
 
 
246
 
 
247
 
gboolean birdie_utils_is_cinnamon (void) {
248
 
        gboolean result = FALSE;
249
 
        gchar* cv = NULL;
250
 
        const gchar* _tmp4_ = NULL;
251
 
        GError * _inner_error_ = NULL;
252
 
        {
253
 
                BirdieUtilscinna* c = NULL;
254
 
                BirdieUtilscinna* _tmp0_ = NULL;
255
 
                BirdieUtilscinna* _tmp1_ = NULL;
256
 
                gchar* _tmp2_ = NULL;
257
 
                gchar* _tmp3_ = NULL;
258
 
                _tmp0_ = g_initable_new (BIRDIE_UTILS_TYPE_CINNA_PROXY, NULL, &_inner_error_, "g-flags", 0, "g-name", "org.Cinnamon", "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", "/org/Cinnamon", "g-interface-name", "org.Cinnamon", "g-interface-info", g_type_get_qdata (BIRDIE_UTILS_TYPE_CINNA, g_quark_from_static_string ("vala-dbus-interface-info")), NULL);
259
 
                c = (BirdieUtilscinna*) _tmp0_;
260
 
                if (G_UNLIKELY (_inner_error_ != NULL)) {
261
 
                        goto __catch109_g_error;
262
 
                }
263
 
                _tmp1_ = c;
264
 
                _tmp2_ = birdie_utils_cinna_get_CinnamonVersion (_tmp1_);
265
 
                _tmp3_ = _tmp2_;
266
 
                _g_free0 (cv);
267
 
                cv = _tmp3_;
268
 
                _g_object_unref0 (c);
269
 
        }
270
 
        goto __finally109;
271
 
        __catch109_g_error:
272
 
        {
273
 
                GError* e = NULL;
274
 
                e = _inner_error_;
275
 
                _inner_error_ = NULL;
276
 
                result = FALSE;
277
 
                _g_error_free0 (e);
278
 
                _g_free0 (cv);
279
 
                return result;
280
 
        }
281
 
        __finally109:
282
 
        if (G_UNLIKELY (_inner_error_ != NULL)) {
283
 
                _g_free0 (cv);
284
 
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
285
 
                g_clear_error (&_inner_error_);
286
 
                return FALSE;
287
 
        }
288
 
        _tmp4_ = cv;
289
 
        if (_tmp4_ == NULL) {
290
 
                result = FALSE;
291
 
                _g_free0 (cv);
292
 
                return result;
293
 
        } else {
294
 
                result = TRUE;
295
 
                _g_free0 (cv);
296
 
                return result;
297
 
        }
298
 
        _g_free0 (cv);
299
 
}
300
 
 
301
 
 
302
 
gchar* birdie_utils_gnome_shell_get_ShellVersion (BirdieUtilsGnomeShell* self) {
303
 
        g_return_val_if_fail (self != NULL, NULL);
304
 
        return BIRDIE_UTILS_GNOME_SHELL_GET_INTERFACE (self)->get_ShellVersion (self);
305
 
}
306
 
 
307
 
 
308
 
static void birdie_utils_gnome_shell_base_init (BirdieUtilsGnomeShellIface * iface) {
309
 
        static gboolean initialized = FALSE;
310
 
        if (!initialized) {
311
 
                initialized = TRUE;
312
 
        }
313
 
}
314
 
 
315
 
 
316
 
GType birdie_utils_gnome_shell_get_type (void) {
317
 
        static volatile gsize birdie_utils_gnome_shell_type_id__volatile = 0;
318
 
        if (g_once_init_enter (&birdie_utils_gnome_shell_type_id__volatile)) {
319
 
                static const GTypeInfo g_define_type_info = { sizeof (BirdieUtilsGnomeShellIface), (GBaseInitFunc) birdie_utils_gnome_shell_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
320
 
                GType birdie_utils_gnome_shell_type_id;
321
 
                birdie_utils_gnome_shell_type_id = g_type_register_static (G_TYPE_INTERFACE, "BirdieUtilsGnomeShell", &g_define_type_info, 0);
322
 
                g_type_interface_add_prerequisite (birdie_utils_gnome_shell_type_id, G_TYPE_OBJECT);
323
 
                g_type_set_qdata (birdie_utils_gnome_shell_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) birdie_utils_gnome_shell_proxy_get_type);
324
 
                g_type_set_qdata (birdie_utils_gnome_shell_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.gnome.Shell");
325
 
                g_type_set_qdata (birdie_utils_gnome_shell_type_id, g_quark_from_static_string ("vala-dbus-interface-info"), (void*) (&_birdie_utils_gnome_shell_dbus_interface_info));
326
 
                g_type_set_qdata (birdie_utils_gnome_shell_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) birdie_utils_gnome_shell_register_object);
327
 
                g_once_init_leave (&birdie_utils_gnome_shell_type_id__volatile, birdie_utils_gnome_shell_type_id);
328
 
        }
329
 
        return birdie_utils_gnome_shell_type_id__volatile;
330
 
}
331
 
 
332
 
 
333
 
G_DEFINE_TYPE_EXTENDED (BirdieUtilsGnomeShellProxy, birdie_utils_gnome_shell_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (BIRDIE_UTILS_TYPE_GNOME_SHELL, birdie_utils_gnome_shell_proxy_birdie_utils_gnome_shell_interface_init) )
334
 
static void birdie_utils_gnome_shell_proxy_class_init (BirdieUtilsGnomeShellProxyClass* klass) {
335
 
        G_DBUS_PROXY_CLASS (klass)->g_signal = birdie_utils_gnome_shell_proxy_g_signal;
336
 
}
337
 
 
338
 
 
339
 
static void birdie_utils_gnome_shell_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters) {
340
 
}
341
 
 
342
 
 
343
 
static void birdie_utils_gnome_shell_proxy_init (BirdieUtilsGnomeShellProxy* self) {
344
 
}
345
 
 
346
 
 
347
 
static gchar* birdie_utils_gnome_shell_dbus_proxy_get_ShellVersion (BirdieUtilsGnomeShell* self) {
348
 
        GVariant *_inner_reply;
349
 
        gchar* _result;
350
 
        _inner_reply = g_dbus_proxy_get_cached_property ((GDBusProxy *) self, "ShellVersion");
351
 
        if (!_inner_reply) {
352
 
                GVariant *_arguments;
353
 
                GVariant *_reply;
354
 
                GVariantBuilder _arguments_builder;
355
 
                g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
356
 
                g_variant_builder_add_value (&_arguments_builder, g_variant_new_string ("org.gnome.Shell"));
357
 
                g_variant_builder_add_value (&_arguments_builder, g_variant_new_string ("ShellVersion"));
358
 
                _arguments = g_variant_builder_end (&_arguments_builder);
359
 
                _reply = g_dbus_proxy_call_sync ((GDBusProxy *) self, "org.freedesktop.DBus.Properties.Get", _arguments, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL);
360
 
                if (!_reply) {
361
 
                        return NULL;
362
 
                }
363
 
                g_variant_get (_reply, "(v)", &_inner_reply);
364
 
                g_variant_unref (_reply);
365
 
        }
366
 
        _result = g_variant_dup_string (_inner_reply, NULL);
367
 
        g_variant_unref (_inner_reply);
368
 
        return _result;
369
 
}
370
 
 
371
 
 
372
 
static void birdie_utils_gnome_shell_proxy_birdie_utils_gnome_shell_interface_init (BirdieUtilsGnomeShellIface* iface) {
373
 
        iface->get_ShellVersion = birdie_utils_gnome_shell_dbus_proxy_get_ShellVersion;
374
 
}
375
 
 
376
 
 
377
 
static void birdie_utils_gnome_shell_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data) {
378
 
        gpointer* data;
379
 
        gpointer object;
380
 
        data = user_data;
381
 
        object = data[0];
382
 
        g_object_unref (invocation);
383
 
}
384
 
 
385
 
 
386
 
static GVariant* _dbus_birdie_utils_gnome_shell_get_ShellVersion (BirdieUtilsGnomeShell* self) {
387
 
        gchar* result;
388
 
        GVariant* _reply;
389
 
        result = birdie_utils_gnome_shell_get_ShellVersion (self);
390
 
        _reply = g_variant_new_string (result);
391
 
        _g_free0 (result);
392
 
        return _reply;
393
 
}
394
 
 
395
 
 
396
 
static GVariant* birdie_utils_gnome_shell_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data) {
397
 
        gpointer* data;
398
 
        gpointer object;
399
 
        data = user_data;
400
 
        object = data[0];
401
 
        if (strcmp (property_name, "ShellVersion") == 0) {
402
 
                return _dbus_birdie_utils_gnome_shell_get_ShellVersion (object);
403
 
        }
404
 
        return NULL;
405
 
}
406
 
 
407
 
 
408
 
static gboolean birdie_utils_gnome_shell_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data) {
409
 
        gpointer* data;
410
 
        gpointer object;
411
 
        data = user_data;
412
 
        object = data[0];
413
 
        return FALSE;
414
 
}
415
 
 
416
 
 
417
 
guint birdie_utils_gnome_shell_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
418
 
        guint result;
419
 
        gpointer *data;
420
 
        data = g_new (gpointer, 3);
421
 
        data[0] = g_object_ref (object);
422
 
        data[1] = g_object_ref (connection);
423
 
        data[2] = g_strdup (path);
424
 
        result = g_dbus_connection_register_object (connection, path, (GDBusInterfaceInfo *) (&_birdie_utils_gnome_shell_dbus_interface_info), &_birdie_utils_gnome_shell_dbus_interface_vtable, data, _birdie_utils_gnome_shell_unregister_object, error);
425
 
        if (!result) {
426
 
                return 0;
427
 
        }
428
 
        return result;
429
 
}
430
 
 
431
 
 
432
 
static void _birdie_utils_gnome_shell_unregister_object (gpointer user_data) {
433
 
        gpointer* data;
434
 
        data = user_data;
435
 
        g_object_unref (data[0]);
436
 
        g_object_unref (data[1]);
437
 
        g_free (data[2]);
438
 
        g_free (data);
439
 
}
440
 
 
441
 
 
442
 
gboolean birdie_utils_is_gnome (void) {
443
 
        gboolean result = FALSE;
444
 
        gchar* gsv = NULL;
445
 
        const gchar* _tmp4_ = NULL;
446
 
        GError * _inner_error_ = NULL;
447
 
        gsv = NULL;
448
 
        {
449
 
                BirdieUtilsGnomeShell* gs = NULL;
450
 
                BirdieUtilsGnomeShell* _tmp0_ = NULL;
451
 
                BirdieUtilsGnomeShell* _tmp1_ = NULL;
452
 
                gchar* _tmp2_ = NULL;
453
 
                gchar* _tmp3_ = NULL;
454
 
                _tmp0_ = g_initable_new (BIRDIE_UTILS_TYPE_GNOME_SHELL_PROXY, NULL, &_inner_error_, "g-flags", 0, "g-name", "org.gnome.Shell", "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", "/org/gnome/Shell", "g-interface-name", "org.gnome.Shell", "g-interface-info", g_type_get_qdata (BIRDIE_UTILS_TYPE_GNOME_SHELL, g_quark_from_static_string ("vala-dbus-interface-info")), NULL);
455
 
                gs = (BirdieUtilsGnomeShell*) _tmp0_;
456
 
                if (G_UNLIKELY (_inner_error_ != NULL)) {
457
 
                        goto __catch110_g_error;
458
 
                }
459
 
                _tmp1_ = gs;
460
 
                _tmp2_ = birdie_utils_gnome_shell_get_ShellVersion (_tmp1_);
461
 
                _tmp3_ = _tmp2_;
462
 
                _g_free0 (gsv);
463
 
                gsv = _tmp3_;
464
 
                _g_object_unref0 (gs);
465
 
        }
466
 
        goto __finally110;
467
 
        __catch110_g_error:
468
 
        {
469
 
                GError* e = NULL;
470
 
                e = _inner_error_;
471
 
                _inner_error_ = NULL;
472
 
                result = FALSE;
473
 
                _g_error_free0 (e);
474
 
                _g_free0 (gsv);
475
 
                return result;
476
 
        }
477
 
        __finally110:
478
 
        if (G_UNLIKELY (_inner_error_ != NULL)) {
479
 
                _g_free0 (gsv);
480
 
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
481
 
                g_clear_error (&_inner_error_);
482
 
                return FALSE;
483
 
        }
484
 
        _tmp4_ = gsv;
485
 
        if (_tmp4_ == NULL) {
486
 
                result = FALSE;
487
 
                _g_free0 (gsv);
488
 
                return result;
489
 
        } else {
490
 
                result = TRUE;
491
 
                _g_free0 (gsv);
492
 
                return result;
493
 
        }
494
 
        _g_free0 (gsv);
495
 
}
496
 
 
497
 
 
498