~ubuntu-branches/ubuntu/oneiric/avant-window-navigator/oneiric

« back to all changes in this revision

Viewing changes to applets/taskmanager/dock-manager-api.c

  • Committer: Bazaar Package Importer
  • Author(s): Julien Lavergne
  • Date: 2010-02-18 00:22:52 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20100218002252-fe6vniq3o8ct3cdz
Tags: 0.3.9.1~bzr603-0ubuntu1
* New upstream snapshot. 
 - Switch to main trunk branch.
* debian/control:
 - Add Conflicts on awn-manager for awn-settings (LP: #507822)
 - Remove build-depends on python-elementtree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* dock-manager-api.c generated by valac, the Vala compiler
 
2
 * generated from dock-manager-api.vala, do not modify */
 
3
 
 
4
/*
 
5
 * Copyright (C) 2010 Michal Hruby <michal.mhr@gmail.com>
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or modify
 
8
 * it under the terms of the GNU General Public License as published by
 
9
 * the Free Software Foundation; either version 2 of the License, or
 
10
 * (at your option) any later version.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU General Public License
 
18
 * along with this program; if not, write to the Free Software
 
19
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA.
 
20
 *
 
21
 * Authored by Michal Hruby <michal.mhr@gmail.com>
 
22
 */
 
23
 
 
24
#include <glib.h>
 
25
#include <glib-object.h>
 
26
#include <stdlib.h>
 
27
#include <string.h>
 
28
#include <dbus/dbus-glib-lowlevel.h>
 
29
#include <dbus/dbus-glib.h>
 
30
#include "task-manager.h"
 
31
#include "task-icon.h"
 
32
#include "task-window.h"
 
33
#include "task-launcher.h"
 
34
#include <gtk/gtk.h>
 
35
#include "task-item.h"
 
36
#include <libawn/libawn.h>
 
37
#include <float.h>
 
38
#include <math.h>
 
39
#include <dbus/dbus.h>
 
40
 
 
41
 
 
42
#define TYPE_DOCK_MANAGER_DBUS_INTERFACE (dock_manager_dbus_interface_get_type ())
 
43
#define DOCK_MANAGER_DBUS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_DOCK_MANAGER_DBUS_INTERFACE, DockManagerDBusInterface))
 
44
#define IS_DOCK_MANAGER_DBUS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_DOCK_MANAGER_DBUS_INTERFACE))
 
45
#define DOCK_MANAGER_DBUS_INTERFACE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_DOCK_MANAGER_DBUS_INTERFACE, DockManagerDBusInterfaceIface))
 
46
 
 
47
typedef struct _DockManagerDBusInterface DockManagerDBusInterface;
 
48
typedef struct _DockManagerDBusInterfaceIface DockManagerDBusInterfaceIface;
 
49
#define _g_free0(var) (var = (g_free (var), NULL))
 
50
typedef struct _DockManagerDBusInterfaceDBusProxy DockManagerDBusInterfaceDBusProxy;
 
51
typedef DBusGProxyClass DockManagerDBusInterfaceDBusProxyClass;
 
52
 
 
53
#define TYPE_DOCK_ITEM_DBUS_INTERFACE (dock_item_dbus_interface_get_type ())
 
54
#define DOCK_ITEM_DBUS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_DOCK_ITEM_DBUS_INTERFACE, DockItemDBusInterface))
 
55
#define IS_DOCK_ITEM_DBUS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_DOCK_ITEM_DBUS_INTERFACE))
 
56
#define DOCK_ITEM_DBUS_INTERFACE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_DOCK_ITEM_DBUS_INTERFACE, DockItemDBusInterfaceIface))
 
57
 
 
58
typedef struct _DockItemDBusInterface DockItemDBusInterface;
 
59
typedef struct _DockItemDBusInterfaceIface DockItemDBusInterfaceIface;
 
60
#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))
 
61
typedef struct _DockItemDBusInterfaceDBusProxy DockItemDBusInterfaceDBusProxy;
 
62
typedef DBusGProxyClass DockItemDBusInterfaceDBusProxyClass;
 
63
 
 
64
#define TYPE_TASK_MANAGER_DISPATCHER (task_manager_dispatcher_get_type ())
 
65
#define TASK_MANAGER_DISPATCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TASK_MANAGER_DISPATCHER, TaskManagerDispatcher))
 
66
#define TASK_MANAGER_DISPATCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TASK_MANAGER_DISPATCHER, TaskManagerDispatcherClass))
 
67
#define IS_TASK_MANAGER_DISPATCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TASK_MANAGER_DISPATCHER))
 
68
#define IS_TASK_MANAGER_DISPATCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TASK_MANAGER_DISPATCHER))
 
69
#define TASK_MANAGER_DISPATCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TASK_MANAGER_DISPATCHER, TaskManagerDispatcherClass))
 
70
 
 
71
typedef struct _TaskManagerDispatcher TaskManagerDispatcher;
 
72
typedef struct _TaskManagerDispatcherClass TaskManagerDispatcherClass;
 
73
typedef struct _TaskManagerDispatcherPrivate TaskManagerDispatcherPrivate;
 
74
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
75
#define _dbus_g_connection_unref0(var) ((var == NULL) ? NULL : (var = (dbus_g_connection_unref (var), NULL)))
 
76
 
 
77
#define TYPE_TASK_ICON_DISPATCHER (task_icon_dispatcher_get_type ())
 
78
#define TASK_ICON_DISPATCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TASK_ICON_DISPATCHER, TaskIconDispatcher))
 
79
#define TASK_ICON_DISPATCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TASK_ICON_DISPATCHER, TaskIconDispatcherClass))
 
80
#define IS_TASK_ICON_DISPATCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TASK_ICON_DISPATCHER))
 
81
#define IS_TASK_ICON_DISPATCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TASK_ICON_DISPATCHER))
 
82
#define TASK_ICON_DISPATCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TASK_ICON_DISPATCHER, TaskIconDispatcherClass))
 
83
 
 
84
typedef struct _TaskIconDispatcher TaskIconDispatcher;
 
85
typedef struct _TaskIconDispatcherClass TaskIconDispatcherClass;
 
86
#define _g_slist_free0(var) ((var == NULL) ? NULL : (var = (g_slist_free (var), NULL)))
 
87
typedef struct _TaskIconDispatcherPrivate TaskIconDispatcherPrivate;
 
88
typedef struct _Block1Data Block1Data;
 
89
typedef struct _DBusObjectVTable _DBusObjectVTable;
 
90
 
 
91
struct _DockManagerDBusInterfaceIface {
 
92
        GTypeInterface parent_iface;
 
93
        char** (*get_capabilities) (DockManagerDBusInterface* self, int* result_length1, GError** error);
 
94
        char** (*get_items) (DockManagerDBusInterface* self, int* result_length1, GError** error);
 
95
        char** (*get_items_by_name) (DockManagerDBusInterface* self, const char* name, int* result_length1, GError** error);
 
96
        char** (*get_items_by_desktop_file) (DockManagerDBusInterface* self, const char* desktop_file, int* result_length1, GError** error);
 
97
        char** (*get_items_by_pid) (DockManagerDBusInterface* self, gint pid, int* result_length1, GError** error);
 
98
        char* (*get_item_by_xid) (DockManagerDBusInterface* self, gint64 xid, GError** error);
 
99
        void (*awn_set_visibility) (DockManagerDBusInterface* self, const char* win_name, gboolean visible, GError** error);
 
100
        char* (*awn_register_proxy_item) (DockManagerDBusInterface* self, const char* desktop_file, const char* uri, GError** error);
 
101
};
 
102
 
 
103
struct _DockManagerDBusInterfaceDBusProxy {
 
104
        DBusGProxy parent_instance;
 
105
        gboolean disposed;
 
106
};
 
107
 
 
108
struct _DockItemDBusInterfaceIface {
 
109
        GTypeInterface parent_iface;
 
110
        gint (*add_menu_item) (DockItemDBusInterface* self, GHashTable* menu_hints, GError** error);
 
111
        void (*remove_menu_item) (DockItemDBusInterface* self, gint id, GError** error);
 
112
        void (*update_dock_item) (DockItemDBusInterface* self, GHashTable* hints, GError** error);
 
113
        char* (*get_desktop_file) (DockItemDBusInterface* self);
 
114
        char* (*get_uri) (DockItemDBusInterface* self);
 
115
};
 
116
 
 
117
struct _DockItemDBusInterfaceDBusProxy {
 
118
        DBusGProxy parent_instance;
 
119
        gboolean disposed;
 
120
};
 
121
 
 
122
struct _TaskManagerDispatcher {
 
123
        GObject parent_instance;
 
124
        TaskManagerDispatcherPrivate * priv;
 
125
};
 
126
 
 
127
struct _TaskManagerDispatcherClass {
 
128
        GObjectClass parent_class;
 
129
};
 
130
 
 
131
struct _TaskManagerDispatcherPrivate {
 
132
        TaskManager* _manager;
 
133
};
 
134
 
 
135
struct _TaskIconDispatcher {
 
136
        GObject parent_instance;
 
137
        TaskIconDispatcherPrivate * priv;
 
138
};
 
139
 
 
140
struct _TaskIconDispatcherClass {
 
141
        GObjectClass parent_class;
 
142
};
 
143
 
 
144
struct _TaskIconDispatcherPrivate {
 
145
        TaskIcon* icon;
 
146
        char* _object_path;
 
147
};
 
148
 
 
149
struct _Block1Data {
 
150
        int _ref_count_;
 
151
        TaskIconDispatcher * self;
 
152
        gint id;
 
153
};
 
154
 
 
155
struct _DBusObjectVTable {
 
156
        void (*register_object) (DBusConnection*, const char*, void*);
 
157
};
 
158
 
 
159
 
 
160
static gpointer task_manager_dispatcher_parent_class = NULL;
 
161
static DockManagerDBusInterfaceIface* task_manager_dispatcher_dock_manager_dbus_interface_parent_iface = NULL;
 
162
static gint task_icon_dispatcher_counter;
 
163
static gint task_icon_dispatcher_counter = 1;
 
164
static gpointer task_icon_dispatcher_parent_class = NULL;
 
165
static DockItemDBusInterfaceIface* task_icon_dispatcher_dock_item_dbus_interface_parent_iface = NULL;
 
166
 
 
167
GType dock_manager_dbus_interface_get_type (void);
 
168
char** dock_manager_dbus_interface_get_capabilities (DockManagerDBusInterface* self, int* result_length1, GError** error);
 
169
char** dock_manager_dbus_interface_get_items (DockManagerDBusInterface* self, int* result_length1, GError** error);
 
170
char** dock_manager_dbus_interface_get_items_by_name (DockManagerDBusInterface* self, const char* name, int* result_length1, GError** error);
 
171
char** dock_manager_dbus_interface_get_items_by_desktop_file (DockManagerDBusInterface* self, const char* desktop_file, int* result_length1, GError** error);
 
172
char** dock_manager_dbus_interface_get_items_by_pid (DockManagerDBusInterface* self, gint pid, int* result_length1, GError** error);
 
173
char* dock_manager_dbus_interface_get_item_by_xid (DockManagerDBusInterface* self, gint64 xid, GError** error);
 
174
void dock_manager_dbus_interface_awn_set_visibility (DockManagerDBusInterface* self, const char* win_name, gboolean visible, GError** error);
 
175
char* dock_manager_dbus_interface_awn_register_proxy_item (DockManagerDBusInterface* self, const char* desktop_file, const char* uri, GError** error);
 
176
void dock_manager_dbus_interface_dbus_register_object (DBusConnection* connection, const char* path, void* object);
 
177
void _dock_manager_dbus_interface_dbus_unregister (DBusConnection* connection, void* _user_data_);
 
178
DBusHandlerResult dock_manager_dbus_interface_dbus_message (DBusConnection* connection, DBusMessage* message, void* object);
 
179
static DBusHandlerResult _dbus_dock_manager_dbus_interface_introspect (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
180
static DBusHandlerResult _dbus_dock_manager_dbus_interface_property_get_all (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
181
static DBusHandlerResult _dbus_dock_manager_dbus_interface_get_capabilities (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
182
static DBusHandlerResult _dbus_dock_manager_dbus_interface_get_items (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
183
static DBusHandlerResult _dbus_dock_manager_dbus_interface_get_items_by_name (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
184
static DBusHandlerResult _dbus_dock_manager_dbus_interface_get_items_by_desktop_file (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
185
static DBusHandlerResult _dbus_dock_manager_dbus_interface_get_items_by_pid (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
186
static DBusHandlerResult _dbus_dock_manager_dbus_interface_get_item_by_xid (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
187
static DBusHandlerResult _dbus_dock_manager_dbus_interface_awn_set_visibility (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
188
static DBusHandlerResult _dbus_dock_manager_dbus_interface_awn_register_proxy_item (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
189
static void _dbus_dock_manager_dbus_interface_item_added (GObject* _sender, const char* path, DBusConnection* _connection);
 
190
static void _dbus_dock_manager_dbus_interface_item_removed (GObject* _sender, const char* path, DBusConnection* _connection);
 
191
GType dock_manager_dbus_interface_dbus_proxy_get_type (void);
 
192
DockManagerDBusInterface* dock_manager_dbus_interface_dbus_proxy_new (DBusGConnection* connection, const char* name, const char* path);
 
193
static void _dbus_handle_dock_manager_dbus_interface_item_added (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
194
static void _dbus_handle_dock_manager_dbus_interface_item_removed (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
195
DBusHandlerResult dock_manager_dbus_interface_dbus_proxy_filter (DBusConnection* connection, DBusMessage* message, void* user_data);
 
196
enum  {
 
197
        DOCK_MANAGER_DBUS_INTERFACE_DBUS_PROXY_DUMMY_PROPERTY
 
198
};
 
199
static char** dock_manager_dbus_interface_dbus_proxy_get_capabilities (DockManagerDBusInterface* self, int* result_length1, GError** error);
 
200
static char** dock_manager_dbus_interface_dbus_proxy_get_items (DockManagerDBusInterface* self, int* result_length1, GError** error);
 
201
static char** dock_manager_dbus_interface_dbus_proxy_get_items_by_name (DockManagerDBusInterface* self, const char* name, int* result_length1, GError** error);
 
202
static char** dock_manager_dbus_interface_dbus_proxy_get_items_by_desktop_file (DockManagerDBusInterface* self, const char* desktop_file, int* result_length1, GError** error);
 
203
static char** dock_manager_dbus_interface_dbus_proxy_get_items_by_pid (DockManagerDBusInterface* self, gint pid, int* result_length1, GError** error);
 
204
static char* dock_manager_dbus_interface_dbus_proxy_get_item_by_xid (DockManagerDBusInterface* self, gint64 xid, GError** error);
 
205
static void dock_manager_dbus_interface_dbus_proxy_awn_set_visibility (DockManagerDBusInterface* self, const char* win_name, gboolean visible, GError** error);
 
206
static char* dock_manager_dbus_interface_dbus_proxy_awn_register_proxy_item (DockManagerDBusInterface* self, const char* desktop_file, const char* uri, GError** error);
 
207
static void dock_manager_dbus_interface_dbus_proxy_dock_manager_dbus_interface__interface_init (DockManagerDBusInterfaceIface* iface);
 
208
static void dock_manager_dbus_interface_dbus_proxy_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 
209
static void dock_manager_dbus_interface_dbus_proxy_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 
210
GType dock_item_dbus_interface_get_type (void);
 
211
gint dock_item_dbus_interface_add_menu_item (DockItemDBusInterface* self, GHashTable* menu_hints, GError** error);
 
212
void dock_item_dbus_interface_remove_menu_item (DockItemDBusInterface* self, gint id, GError** error);
 
213
void dock_item_dbus_interface_update_dock_item (DockItemDBusInterface* self, GHashTable* hints, GError** error);
 
214
char* dock_item_dbus_interface_get_desktop_file (DockItemDBusInterface* self);
 
215
char* dock_item_dbus_interface_get_uri (DockItemDBusInterface* self);
 
216
void dock_item_dbus_interface_dbus_register_object (DBusConnection* connection, const char* path, void* object);
 
217
void _dock_item_dbus_interface_dbus_unregister (DBusConnection* connection, void* _user_data_);
 
218
DBusHandlerResult dock_item_dbus_interface_dbus_message (DBusConnection* connection, DBusMessage* message, void* object);
 
219
static DBusHandlerResult _dbus_dock_item_dbus_interface_introspect (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
220
static DBusHandlerResult _dbus_dock_item_dbus_interface_property_get (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
221
static DBusHandlerResult _dbus_dock_item_dbus_interface_property_get_all (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
222
static DBusHandlerResult _dbus_dock_item_dbus_interface_add_menu_item (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
223
static DBusHandlerResult _dbus_dock_item_dbus_interface_remove_menu_item (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
224
static DBusHandlerResult _dbus_dock_item_dbus_interface_update_dock_item (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
225
static void _dbus_dock_item_dbus_interface_menu_item_activated (GObject* _sender, gint id, DBusConnection* _connection);
 
226
GType dock_item_dbus_interface_dbus_proxy_get_type (void);
 
227
DockItemDBusInterface* dock_item_dbus_interface_dbus_proxy_new (DBusGConnection* connection, const char* name, const char* path);
 
228
static void _dbus_handle_dock_item_dbus_interface_menu_item_activated (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message);
 
229
DBusHandlerResult dock_item_dbus_interface_dbus_proxy_filter (DBusConnection* connection, DBusMessage* message, void* user_data);
 
230
enum  {
 
231
        DOCK_ITEM_DBUS_INTERFACE_DBUS_PROXY_DUMMY_PROPERTY,
 
232
        DOCK_ITEM_DBUS_INTERFACE_DBUS_PROXY_DESKTOP_FILE,
 
233
        DOCK_ITEM_DBUS_INTERFACE_DBUS_PROXY_URI
 
234
};
 
235
static gint dock_item_dbus_interface_dbus_proxy_add_menu_item (DockItemDBusInterface* self, GHashTable* menu_hints, GError** error);
 
236
static void dock_item_dbus_interface_dbus_proxy_remove_menu_item (DockItemDBusInterface* self, gint id, GError** error);
 
237
static void dock_item_dbus_interface_dbus_proxy_update_dock_item (DockItemDBusInterface* self, GHashTable* hints, GError** error);
 
238
static char* dock_item_dbus_interface_dbus_proxy_get_desktop_file (DockItemDBusInterface* self);
 
239
static char* dock_item_dbus_interface_dbus_proxy_get_uri (DockItemDBusInterface* self);
 
240
static void dock_item_dbus_interface_dbus_proxy_dock_item_dbus_interface__interface_init (DockItemDBusInterfaceIface* iface);
 
241
static void dock_item_dbus_interface_dbus_proxy_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 
242
static void dock_item_dbus_interface_dbus_proxy_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 
243
GType task_manager_dispatcher_get_type (void);
 
244
#define TASK_MANAGER_DISPATCHER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_TASK_MANAGER_DISPATCHER, TaskManagerDispatcherPrivate))
 
245
enum  {
 
246
        TASK_MANAGER_DISPATCHER_DUMMY_PROPERTY,
 
247
        TASK_MANAGER_DISPATCHER_MANAGER
 
248
};
 
249
TaskManagerDispatcher* task_manager_dispatcher_new (TaskManager* manager);
 
250
TaskManagerDispatcher* task_manager_dispatcher_construct (GType object_type, TaskManager* manager);
 
251
GType task_icon_dispatcher_get_type (void);
 
252
const char* task_icon_dispatcher_get_object_path (TaskIconDispatcher* self);
 
253
static char** task_manager_dispatcher_list_to_object_path_array (GSList* list, int* result_length1);
 
254
static char** task_manager_dispatcher_real_get_capabilities (DockManagerDBusInterface* base, int* result_length1, GError** error);
 
255
TaskManager* task_manager_dispatcher_get_manager (TaskManagerDispatcher* self);
 
256
static char** task_manager_dispatcher_real_get_items (DockManagerDBusInterface* base, int* result_length1, GError** error);
 
257
static char** task_manager_dispatcher_real_get_items_by_name (DockManagerDBusInterface* base, const char* name, int* result_length1, GError** error);
 
258
static char** task_manager_dispatcher_real_get_items_by_desktop_file (DockManagerDBusInterface* base, const char* desktop_file, int* result_length1, GError** error);
 
259
static char** task_manager_dispatcher_real_get_items_by_pid (DockManagerDBusInterface* base, gint pid, int* result_length1, GError** error);
 
260
static char* task_manager_dispatcher_real_get_item_by_xid (DockManagerDBusInterface* base, gint64 xid, GError** error);
 
261
static void task_manager_dispatcher_real_awn_set_visibility (DockManagerDBusInterface* base, const char* win_name, gboolean visible, GError** error);
 
262
static char* task_manager_dispatcher_real_awn_register_proxy_item (DockManagerDBusInterface* base, const char* desktop_file, const char* uri, GError** error);
 
263
static void task_manager_dispatcher_set_manager (TaskManagerDispatcher* self, TaskManager* value);
 
264
void task_manager_dispatcher_dbus_register_object (DBusConnection* connection, const char* path, void* object);
 
265
void _task_manager_dispatcher_dbus_unregister (DBusConnection* connection, void* _user_data_);
 
266
DBusHandlerResult task_manager_dispatcher_dbus_message (DBusConnection* connection, DBusMessage* message, void* object);
 
267
static DBusHandlerResult _dbus_task_manager_dispatcher_introspect (TaskManagerDispatcher* self, DBusConnection* connection, DBusMessage* message);
 
268
static void task_manager_dispatcher_finalize (GObject* obj);
 
269
static void task_manager_dispatcher_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 
270
static void task_manager_dispatcher_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 
271
#define TASK_ICON_DISPATCHER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_TASK_ICON_DISPATCHER, TaskIconDispatcherPrivate))
 
272
enum  {
 
273
        TASK_ICON_DISPATCHER_DUMMY_PROPERTY,
 
274
        TASK_ICON_DISPATCHER_OBJECT_PATH,
 
275
        TASK_ICON_DISPATCHER_DESKTOP_FILE,
 
276
        TASK_ICON_DISPATCHER_URI
 
277
};
 
278
void task_icon_dispatcher_set_object_path (TaskIconDispatcher* self, const char* value);
 
279
TaskIconDispatcher* task_icon_dispatcher_new (TaskIcon* icon);
 
280
TaskIconDispatcher* task_icon_dispatcher_construct (GType object_type, TaskIcon* icon);
 
281
static void _lambda0_ (GtkMenuItem* w, Block1Data* _data1_);
 
282
static void __lambda0__gtk_menu_item_activate (GtkMenuItem* _sender, gpointer self);
 
283
static Block1Data* block1_data_ref (Block1Data* _data1_);
 
284
static void block1_data_unref (Block1Data* _data1_);
 
285
static gint task_icon_dispatcher_real_add_menu_item (DockItemDBusInterface* base, GHashTable* menu_hints, GError** error);
 
286
static void task_icon_dispatcher_real_remove_menu_item (DockItemDBusInterface* base, gint id, GError** error);
 
287
static void task_icon_dispatcher_real_update_dock_item (DockItemDBusInterface* base, GHashTable* hints, GError** error);
 
288
void task_icon_dispatcher_dbus_register_object (DBusConnection* connection, const char* path, void* object);
 
289
void _task_icon_dispatcher_dbus_unregister (DBusConnection* connection, void* _user_data_);
 
290
DBusHandlerResult task_icon_dispatcher_dbus_message (DBusConnection* connection, DBusMessage* message, void* object);
 
291
static DBusHandlerResult _dbus_task_icon_dispatcher_introspect (TaskIconDispatcher* self, DBusConnection* connection, DBusMessage* message);
 
292
static void task_icon_dispatcher_finalize (GObject* obj);
 
293
static void task_icon_dispatcher_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 
294
static void task_icon_dispatcher_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 
295
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
296
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
297
static int _vala_strcmp0 (const char * str1, const char * str2);
 
298
static void _vala_dbus_register_object (DBusConnection* connection, const char* path, void* object);
 
299
static void _vala_dbus_unregister_object (gpointer connection, GObject* object);
 
300
 
 
301
static const DBusObjectPathVTable _dock_manager_dbus_interface_dbus_path_vtable = {_dock_manager_dbus_interface_dbus_unregister, dock_manager_dbus_interface_dbus_message};
 
302
static const _DBusObjectVTable _dock_manager_dbus_interface_dbus_vtable = {dock_manager_dbus_interface_dbus_register_object};
 
303
static const DBusObjectPathVTable _dock_item_dbus_interface_dbus_path_vtable = {_dock_item_dbus_interface_dbus_unregister, dock_item_dbus_interface_dbus_message};
 
304
static const _DBusObjectVTable _dock_item_dbus_interface_dbus_vtable = {dock_item_dbus_interface_dbus_register_object};
 
305
static const DBusObjectPathVTable _task_manager_dispatcher_dbus_path_vtable = {_task_manager_dispatcher_dbus_unregister, task_manager_dispatcher_dbus_message};
 
306
static const _DBusObjectVTable _task_manager_dispatcher_dbus_vtable = {task_manager_dispatcher_dbus_register_object};
 
307
static const DBusObjectPathVTable _task_icon_dispatcher_dbus_path_vtable = {_task_icon_dispatcher_dbus_unregister, task_icon_dispatcher_dbus_message};
 
308
static const _DBusObjectVTable _task_icon_dispatcher_dbus_vtable = {task_icon_dispatcher_dbus_register_object};
 
309
 
 
310
static void g_cclosure_user_marshal_VOID__BOXED (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 
311
 
 
312
char** dock_manager_dbus_interface_get_capabilities (DockManagerDBusInterface* self, int* result_length1, GError** error) {
 
313
        return DOCK_MANAGER_DBUS_INTERFACE_GET_INTERFACE (self)->get_capabilities (self, result_length1, error);
 
314
}
 
315
 
 
316
 
 
317
char** dock_manager_dbus_interface_get_items (DockManagerDBusInterface* self, int* result_length1, GError** error) {
 
318
        return DOCK_MANAGER_DBUS_INTERFACE_GET_INTERFACE (self)->get_items (self, result_length1, error);
 
319
}
 
320
 
 
321
 
 
322
char** dock_manager_dbus_interface_get_items_by_name (DockManagerDBusInterface* self, const char* name, int* result_length1, GError** error) {
 
323
        return DOCK_MANAGER_DBUS_INTERFACE_GET_INTERFACE (self)->get_items_by_name (self, name, result_length1, error);
 
324
}
 
325
 
 
326
 
 
327
char** dock_manager_dbus_interface_get_items_by_desktop_file (DockManagerDBusInterface* self, const char* desktop_file, int* result_length1, GError** error) {
 
328
        return DOCK_MANAGER_DBUS_INTERFACE_GET_INTERFACE (self)->get_items_by_desktop_file (self, desktop_file, result_length1, error);
 
329
}
 
330
 
 
331
 
 
332
char** dock_manager_dbus_interface_get_items_by_pid (DockManagerDBusInterface* self, gint pid, int* result_length1, GError** error) {
 
333
        return DOCK_MANAGER_DBUS_INTERFACE_GET_INTERFACE (self)->get_items_by_pid (self, pid, result_length1, error);
 
334
}
 
335
 
 
336
 
 
337
char* dock_manager_dbus_interface_get_item_by_xid (DockManagerDBusInterface* self, gint64 xid, GError** error) {
 
338
        return DOCK_MANAGER_DBUS_INTERFACE_GET_INTERFACE (self)->get_item_by_xid (self, xid, error);
 
339
}
 
340
 
 
341
 
 
342
void dock_manager_dbus_interface_awn_set_visibility (DockManagerDBusInterface* self, const char* win_name, gboolean visible, GError** error) {
 
343
        DOCK_MANAGER_DBUS_INTERFACE_GET_INTERFACE (self)->awn_set_visibility (self, win_name, visible, error);
 
344
}
 
345
 
 
346
 
 
347
char* dock_manager_dbus_interface_awn_register_proxy_item (DockManagerDBusInterface* self, const char* desktop_file, const char* uri, GError** error) {
 
348
        return DOCK_MANAGER_DBUS_INTERFACE_GET_INTERFACE (self)->awn_register_proxy_item (self, desktop_file, uri, error);
 
349
}
 
350
 
 
351
 
 
352
void _dock_manager_dbus_interface_dbus_unregister (DBusConnection* connection, void* _user_data_) {
 
353
}
 
354
 
 
355
 
 
356
static DBusHandlerResult _dbus_dock_manager_dbus_interface_introspect (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
357
        DBusMessage* reply;
 
358
        DBusMessageIter iter;
 
359
        GString* xml_data;
 
360
        char** children;
 
361
        int i;
 
362
        reply = dbus_message_new_method_return (message);
 
363
        dbus_message_iter_init_append (reply, &iter);
 
364
        xml_data = g_string_new ("<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" \"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n");
 
365
        g_string_append (xml_data, "<node>\n<interface name=\"org.freedesktop.DBus.Introspectable\">\n  <method name=\"Introspect\">\n    <arg name=\"data\" direction=\"out\" type=\"s\"/>\n  </method>\n</interface>\n<interface name=\"org.freedesktop.DBus.Properties\">\n  <method name=\"Get\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n    <arg name=\"value\" direction=\"out\" type=\"v\"/>\n  </method>\n  <method name=\"Set\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n    <arg name=\"value\" direction=\"in\" type=\"v\"/>\n  </method>\n  <method name=\"GetAll\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"props\" direction=\"out\" type=\"a{sv}\"/>\n  </method>\n</interface>\n<interface name=\"org.freedesktop.DockManager\">\n  <method name=\"GetCapabilities\">\n    <arg name=\"result\" type=\"as\" direction=\"out\"/>\n  </method>\n  <method name=\"GetItems\">\n    <arg name=\"result\" type=\"ao\" direction=\"out\"/>\n  </method>\n  <method name=\"GetItemsByName\">\n    <arg name=\"name\" type=\"s\" direction=\"in\"/>\n    <arg name=\"result\" type=\"ao\" direction=\"out\"/>\n  </method>\n  <method name=\"GetItemsByDesktopFile\">\n    <arg name=\"desktop_file\" type=\"s\" direction=\"in\"/>\n    <arg name=\"result\" type=\"ao\" direction=\"out\"/>\n  </method>\n  <method name=\"GetItemsByPid\">\n    <arg name=\"pid\" type=\"i\" direction=\"in\"/>\n    <arg name=\"result\" type=\"ao\" direction=\"out\"/>\n  </method>\n  <method name=\"GetItemByXid\">\n    <arg name=\"xid\" type=\"x\" direction=\"in\"/>\n    <arg name=\"result\" type=\"o\" direction=\"out\"/>\n  </method>\n  <method name=\"AwnSetVisibility\">\n    <arg name=\"win_name\" type=\"s\" direction=\"in\"/>\n    <arg name=\"visible\" type=\"b\" direction=\"in\"/>\n  </method>\n  <method name=\"AwnRegisterProxyItem\">\n    <arg name=\"desktop_file\" type=\"s\" direction=\"in\"/>\n    <arg name=\"uri\" type=\"s\" direction=\"in\"/>\n    <arg name=\"result\" type=\"o\" direction=\"out\"/>\n  </method>\n  <signal name=\"ItemAdded\">\n    <arg name=\"path\" type=\"o\"/>\n  </signal>\n  <signal name=\"ItemRemoved\">\n    <arg name=\"path\" type=\"o\"/>\n  </signal>\n</interface>\n");
 
366
        dbus_connection_list_registered (connection, g_object_get_data ((GObject *) self, "dbus_object_path"), &children);
 
367
        for (i = 0; children[i]; i++) {
 
368
                g_string_append_printf (xml_data, "<node name=\"%s\"/>\n", children[i]);
 
369
        }
 
370
        dbus_free_string_array (children);
 
371
        g_string_append (xml_data, "</node>\n");
 
372
        dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &xml_data->str);
 
373
        g_string_free (xml_data, TRUE);
 
374
        if (reply) {
 
375
                dbus_connection_send (connection, reply, NULL);
 
376
                dbus_message_unref (reply);
 
377
                return DBUS_HANDLER_RESULT_HANDLED;
 
378
        } else {
 
379
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
380
        }
 
381
}
 
382
 
 
383
 
 
384
static DBusHandlerResult _dbus_dock_manager_dbus_interface_property_get_all (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
385
        DBusMessage* reply;
 
386
        DBusMessageIter iter, reply_iter, subiter;
 
387
        char* interface_name;
 
388
        const char* _tmp0_;
 
389
        if (strcmp (dbus_message_get_signature (message), "s")) {
 
390
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
391
        }
 
392
        dbus_message_iter_init (message, &iter);
 
393
        reply = dbus_message_new_method_return (message);
 
394
        dbus_message_iter_init_append (reply, &reply_iter);
 
395
        dbus_message_iter_get_basic (&iter, &_tmp0_);
 
396
        dbus_message_iter_next (&iter);
 
397
        interface_name = g_strdup (_tmp0_);
 
398
        if (strcmp (interface_name, "org.freedesktop.DockManager") == 0) {
 
399
                dbus_message_iter_open_container (&reply_iter, DBUS_TYPE_ARRAY, "{sv}", &subiter);
 
400
                dbus_message_iter_close_container (&reply_iter, &subiter);
 
401
        } else {
 
402
                dbus_message_unref (reply);
 
403
                reply = NULL;
 
404
        }
 
405
        g_free (interface_name);
 
406
        if (reply) {
 
407
                dbus_connection_send (connection, reply, NULL);
 
408
                dbus_message_unref (reply);
 
409
                return DBUS_HANDLER_RESULT_HANDLED;
 
410
        } else {
 
411
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
412
        }
 
413
}
 
414
 
 
415
 
 
416
static DBusHandlerResult _dbus_dock_manager_dbus_interface_get_capabilities (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
417
        DBusMessageIter iter;
 
418
        GError* error;
 
419
        char** result;
 
420
        int result_length1;
 
421
        DBusMessage* reply;
 
422
        char** _tmp1_;
 
423
        DBusMessageIter _tmp2_;
 
424
        int _tmp3_;
 
425
        error = NULL;
 
426
        if (strcmp (dbus_message_get_signature (message), "")) {
 
427
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
428
        }
 
429
        dbus_message_iter_init (message, &iter);
 
430
        result_length1 = 0;
 
431
        result = dock_manager_dbus_interface_get_capabilities (self, &result_length1, &error);
 
432
        if (error) {
 
433
                if (error->domain == DBUS_GERROR) {
 
434
                        switch (error->code) {
 
435
                                case DBUS_GERROR_FAILED:
 
436
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
437
                                break;
 
438
                                case DBUS_GERROR_NO_MEMORY:
 
439
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
440
                                break;
 
441
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
442
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
443
                                break;
 
444
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
445
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
446
                                break;
 
447
                                case DBUS_GERROR_NO_REPLY:
 
448
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
449
                                break;
 
450
                                case DBUS_GERROR_IO_ERROR:
 
451
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
452
                                break;
 
453
                                case DBUS_GERROR_BAD_ADDRESS:
 
454
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
455
                                break;
 
456
                                case DBUS_GERROR_NOT_SUPPORTED:
 
457
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
458
                                break;
 
459
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
460
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
461
                                break;
 
462
                                case DBUS_GERROR_ACCESS_DENIED:
 
463
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
464
                                break;
 
465
                                case DBUS_GERROR_AUTH_FAILED:
 
466
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
467
                                break;
 
468
                                case DBUS_GERROR_NO_SERVER:
 
469
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
470
                                break;
 
471
                                case DBUS_GERROR_TIMEOUT:
 
472
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
473
                                break;
 
474
                                case DBUS_GERROR_NO_NETWORK:
 
475
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
476
                                break;
 
477
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
478
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
479
                                break;
 
480
                                case DBUS_GERROR_DISCONNECTED:
 
481
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
482
                                break;
 
483
                                case DBUS_GERROR_INVALID_ARGS:
 
484
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
485
                                break;
 
486
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
487
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
488
                                break;
 
489
                                case DBUS_GERROR_FILE_EXISTS:
 
490
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
491
                                break;
 
492
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
493
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
494
                                break;
 
495
                                case DBUS_GERROR_TIMED_OUT:
 
496
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
497
                                break;
 
498
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
499
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
500
                                break;
 
501
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
502
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
503
                                break;
 
504
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
505
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
506
                                break;
 
507
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
508
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
509
                                break;
 
510
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
511
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
512
                                break;
 
513
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
514
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
515
                                break;
 
516
                                case DBUS_GERROR_SPAWN_FAILED:
 
517
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
518
                                break;
 
519
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
520
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
521
                                break;
 
522
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
523
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
524
                                break;
 
525
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
526
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
527
                                break;
 
528
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
529
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
530
                                break;
 
531
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
532
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
533
                                break;
 
534
                        }
 
535
                }
 
536
                dbus_connection_send (connection, reply, NULL);
 
537
                dbus_message_unref (reply);
 
538
                return DBUS_HANDLER_RESULT_HANDLED;
 
539
        }
 
540
        reply = dbus_message_new_method_return (message);
 
541
        dbus_message_iter_init_append (reply, &iter);
 
542
        _tmp1_ = result;
 
543
        dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &_tmp2_);
 
544
        for (_tmp3_ = 0; _tmp3_ < result_length1; _tmp3_++) {
 
545
                const char* _tmp4_;
 
546
                _tmp4_ = *_tmp1_;
 
547
                dbus_message_iter_append_basic (&_tmp2_, DBUS_TYPE_STRING, &_tmp4_);
 
548
                _tmp1_++;
 
549
        }
 
550
        dbus_message_iter_close_container (&iter, &_tmp2_);
 
551
        result = (_vala_array_free (result,  result_length1, (GDestroyNotify) g_free), NULL);
 
552
        if (reply) {
 
553
                dbus_connection_send (connection, reply, NULL);
 
554
                dbus_message_unref (reply);
 
555
                return DBUS_HANDLER_RESULT_HANDLED;
 
556
        } else {
 
557
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
558
        }
 
559
}
 
560
 
 
561
 
 
562
static DBusHandlerResult _dbus_dock_manager_dbus_interface_get_items (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
563
        DBusMessageIter iter;
 
564
        GError* error;
 
565
        char** result;
 
566
        int result_length1;
 
567
        DBusMessage* reply;
 
568
        char** _tmp5_;
 
569
        DBusMessageIter _tmp6_;
 
570
        int _tmp7_;
 
571
        error = NULL;
 
572
        if (strcmp (dbus_message_get_signature (message), "")) {
 
573
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
574
        }
 
575
        dbus_message_iter_init (message, &iter);
 
576
        result_length1 = 0;
 
577
        result = dock_manager_dbus_interface_get_items (self, &result_length1, &error);
 
578
        if (error) {
 
579
                if (error->domain == DBUS_GERROR) {
 
580
                        switch (error->code) {
 
581
                                case DBUS_GERROR_FAILED:
 
582
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
583
                                break;
 
584
                                case DBUS_GERROR_NO_MEMORY:
 
585
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
586
                                break;
 
587
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
588
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
589
                                break;
 
590
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
591
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
592
                                break;
 
593
                                case DBUS_GERROR_NO_REPLY:
 
594
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
595
                                break;
 
596
                                case DBUS_GERROR_IO_ERROR:
 
597
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
598
                                break;
 
599
                                case DBUS_GERROR_BAD_ADDRESS:
 
600
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
601
                                break;
 
602
                                case DBUS_GERROR_NOT_SUPPORTED:
 
603
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
604
                                break;
 
605
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
606
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
607
                                break;
 
608
                                case DBUS_GERROR_ACCESS_DENIED:
 
609
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
610
                                break;
 
611
                                case DBUS_GERROR_AUTH_FAILED:
 
612
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
613
                                break;
 
614
                                case DBUS_GERROR_NO_SERVER:
 
615
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
616
                                break;
 
617
                                case DBUS_GERROR_TIMEOUT:
 
618
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
619
                                break;
 
620
                                case DBUS_GERROR_NO_NETWORK:
 
621
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
622
                                break;
 
623
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
624
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
625
                                break;
 
626
                                case DBUS_GERROR_DISCONNECTED:
 
627
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
628
                                break;
 
629
                                case DBUS_GERROR_INVALID_ARGS:
 
630
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
631
                                break;
 
632
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
633
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
634
                                break;
 
635
                                case DBUS_GERROR_FILE_EXISTS:
 
636
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
637
                                break;
 
638
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
639
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
640
                                break;
 
641
                                case DBUS_GERROR_TIMED_OUT:
 
642
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
643
                                break;
 
644
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
645
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
646
                                break;
 
647
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
648
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
649
                                break;
 
650
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
651
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
652
                                break;
 
653
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
654
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
655
                                break;
 
656
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
657
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
658
                                break;
 
659
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
660
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
661
                                break;
 
662
                                case DBUS_GERROR_SPAWN_FAILED:
 
663
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
664
                                break;
 
665
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
666
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
667
                                break;
 
668
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
669
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
670
                                break;
 
671
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
672
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
673
                                break;
 
674
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
675
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
676
                                break;
 
677
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
678
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
679
                                break;
 
680
                        }
 
681
                }
 
682
                dbus_connection_send (connection, reply, NULL);
 
683
                dbus_message_unref (reply);
 
684
                return DBUS_HANDLER_RESULT_HANDLED;
 
685
        }
 
686
        reply = dbus_message_new_method_return (message);
 
687
        dbus_message_iter_init_append (reply, &iter);
 
688
        _tmp5_ = result;
 
689
        dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "o", &_tmp6_);
 
690
        for (_tmp7_ = 0; _tmp7_ < result_length1; _tmp7_++) {
 
691
                const char* _tmp8_;
 
692
                _tmp8_ = *_tmp5_;
 
693
                dbus_message_iter_append_basic (&_tmp6_, DBUS_TYPE_OBJECT_PATH, &_tmp8_);
 
694
                _tmp5_++;
 
695
        }
 
696
        dbus_message_iter_close_container (&iter, &_tmp6_);
 
697
        result = (_vala_array_free (result,  result_length1, (GDestroyNotify) g_free), NULL);
 
698
        if (reply) {
 
699
                dbus_connection_send (connection, reply, NULL);
 
700
                dbus_message_unref (reply);
 
701
                return DBUS_HANDLER_RESULT_HANDLED;
 
702
        } else {
 
703
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
704
        }
 
705
}
 
706
 
 
707
 
 
708
static DBusHandlerResult _dbus_dock_manager_dbus_interface_get_items_by_name (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
709
        DBusMessageIter iter;
 
710
        GError* error;
 
711
        char* name = NULL;
 
712
        const char* _tmp9_;
 
713
        char** result;
 
714
        int result_length1;
 
715
        DBusMessage* reply;
 
716
        char** _tmp10_;
 
717
        DBusMessageIter _tmp11_;
 
718
        int _tmp12_;
 
719
        error = NULL;
 
720
        if (strcmp (dbus_message_get_signature (message), "s")) {
 
721
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
722
        }
 
723
        dbus_message_iter_init (message, &iter);
 
724
        dbus_message_iter_get_basic (&iter, &_tmp9_);
 
725
        dbus_message_iter_next (&iter);
 
726
        name = g_strdup (_tmp9_);
 
727
        result_length1 = 0;
 
728
        result = dock_manager_dbus_interface_get_items_by_name (self, name, &result_length1, &error);
 
729
        if (error) {
 
730
                if (error->domain == DBUS_GERROR) {
 
731
                        switch (error->code) {
 
732
                                case DBUS_GERROR_FAILED:
 
733
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
734
                                break;
 
735
                                case DBUS_GERROR_NO_MEMORY:
 
736
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
737
                                break;
 
738
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
739
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
740
                                break;
 
741
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
742
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
743
                                break;
 
744
                                case DBUS_GERROR_NO_REPLY:
 
745
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
746
                                break;
 
747
                                case DBUS_GERROR_IO_ERROR:
 
748
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
749
                                break;
 
750
                                case DBUS_GERROR_BAD_ADDRESS:
 
751
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
752
                                break;
 
753
                                case DBUS_GERROR_NOT_SUPPORTED:
 
754
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
755
                                break;
 
756
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
757
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
758
                                break;
 
759
                                case DBUS_GERROR_ACCESS_DENIED:
 
760
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
761
                                break;
 
762
                                case DBUS_GERROR_AUTH_FAILED:
 
763
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
764
                                break;
 
765
                                case DBUS_GERROR_NO_SERVER:
 
766
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
767
                                break;
 
768
                                case DBUS_GERROR_TIMEOUT:
 
769
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
770
                                break;
 
771
                                case DBUS_GERROR_NO_NETWORK:
 
772
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
773
                                break;
 
774
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
775
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
776
                                break;
 
777
                                case DBUS_GERROR_DISCONNECTED:
 
778
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
779
                                break;
 
780
                                case DBUS_GERROR_INVALID_ARGS:
 
781
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
782
                                break;
 
783
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
784
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
785
                                break;
 
786
                                case DBUS_GERROR_FILE_EXISTS:
 
787
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
788
                                break;
 
789
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
790
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
791
                                break;
 
792
                                case DBUS_GERROR_TIMED_OUT:
 
793
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
794
                                break;
 
795
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
796
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
797
                                break;
 
798
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
799
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
800
                                break;
 
801
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
802
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
803
                                break;
 
804
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
805
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
806
                                break;
 
807
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
808
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
809
                                break;
 
810
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
811
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
812
                                break;
 
813
                                case DBUS_GERROR_SPAWN_FAILED:
 
814
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
815
                                break;
 
816
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
817
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
818
                                break;
 
819
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
820
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
821
                                break;
 
822
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
823
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
824
                                break;
 
825
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
826
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
827
                                break;
 
828
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
829
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
830
                                break;
 
831
                        }
 
832
                }
 
833
                dbus_connection_send (connection, reply, NULL);
 
834
                dbus_message_unref (reply);
 
835
                return DBUS_HANDLER_RESULT_HANDLED;
 
836
        }
 
837
        reply = dbus_message_new_method_return (message);
 
838
        dbus_message_iter_init_append (reply, &iter);
 
839
        _g_free0 (name);
 
840
        _tmp10_ = result;
 
841
        dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "o", &_tmp11_);
 
842
        for (_tmp12_ = 0; _tmp12_ < result_length1; _tmp12_++) {
 
843
                const char* _tmp13_;
 
844
                _tmp13_ = *_tmp10_;
 
845
                dbus_message_iter_append_basic (&_tmp11_, DBUS_TYPE_OBJECT_PATH, &_tmp13_);
 
846
                _tmp10_++;
 
847
        }
 
848
        dbus_message_iter_close_container (&iter, &_tmp11_);
 
849
        result = (_vala_array_free (result,  result_length1, (GDestroyNotify) g_free), NULL);
 
850
        if (reply) {
 
851
                dbus_connection_send (connection, reply, NULL);
 
852
                dbus_message_unref (reply);
 
853
                return DBUS_HANDLER_RESULT_HANDLED;
 
854
        } else {
 
855
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
856
        }
 
857
}
 
858
 
 
859
 
 
860
static DBusHandlerResult _dbus_dock_manager_dbus_interface_get_items_by_desktop_file (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
861
        DBusMessageIter iter;
 
862
        GError* error;
 
863
        char* desktop_file = NULL;
 
864
        const char* _tmp14_;
 
865
        char** result;
 
866
        int result_length1;
 
867
        DBusMessage* reply;
 
868
        char** _tmp15_;
 
869
        DBusMessageIter _tmp16_;
 
870
        int _tmp17_;
 
871
        error = NULL;
 
872
        if (strcmp (dbus_message_get_signature (message), "s")) {
 
873
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
874
        }
 
875
        dbus_message_iter_init (message, &iter);
 
876
        dbus_message_iter_get_basic (&iter, &_tmp14_);
 
877
        dbus_message_iter_next (&iter);
 
878
        desktop_file = g_strdup (_tmp14_);
 
879
        result_length1 = 0;
 
880
        result = dock_manager_dbus_interface_get_items_by_desktop_file (self, desktop_file, &result_length1, &error);
 
881
        if (error) {
 
882
                if (error->domain == DBUS_GERROR) {
 
883
                        switch (error->code) {
 
884
                                case DBUS_GERROR_FAILED:
 
885
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
886
                                break;
 
887
                                case DBUS_GERROR_NO_MEMORY:
 
888
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
889
                                break;
 
890
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
891
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
892
                                break;
 
893
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
894
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
895
                                break;
 
896
                                case DBUS_GERROR_NO_REPLY:
 
897
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
898
                                break;
 
899
                                case DBUS_GERROR_IO_ERROR:
 
900
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
901
                                break;
 
902
                                case DBUS_GERROR_BAD_ADDRESS:
 
903
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
904
                                break;
 
905
                                case DBUS_GERROR_NOT_SUPPORTED:
 
906
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
907
                                break;
 
908
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
909
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
910
                                break;
 
911
                                case DBUS_GERROR_ACCESS_DENIED:
 
912
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
913
                                break;
 
914
                                case DBUS_GERROR_AUTH_FAILED:
 
915
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
916
                                break;
 
917
                                case DBUS_GERROR_NO_SERVER:
 
918
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
919
                                break;
 
920
                                case DBUS_GERROR_TIMEOUT:
 
921
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
922
                                break;
 
923
                                case DBUS_GERROR_NO_NETWORK:
 
924
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
925
                                break;
 
926
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
927
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
928
                                break;
 
929
                                case DBUS_GERROR_DISCONNECTED:
 
930
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
931
                                break;
 
932
                                case DBUS_GERROR_INVALID_ARGS:
 
933
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
934
                                break;
 
935
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
936
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
937
                                break;
 
938
                                case DBUS_GERROR_FILE_EXISTS:
 
939
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
940
                                break;
 
941
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
942
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
943
                                break;
 
944
                                case DBUS_GERROR_TIMED_OUT:
 
945
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
946
                                break;
 
947
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
948
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
949
                                break;
 
950
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
951
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
952
                                break;
 
953
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
954
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
955
                                break;
 
956
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
957
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
958
                                break;
 
959
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
960
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
961
                                break;
 
962
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
963
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
964
                                break;
 
965
                                case DBUS_GERROR_SPAWN_FAILED:
 
966
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
967
                                break;
 
968
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
969
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
970
                                break;
 
971
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
972
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
973
                                break;
 
974
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
975
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
976
                                break;
 
977
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
978
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
979
                                break;
 
980
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
981
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
982
                                break;
 
983
                        }
 
984
                }
 
985
                dbus_connection_send (connection, reply, NULL);
 
986
                dbus_message_unref (reply);
 
987
                return DBUS_HANDLER_RESULT_HANDLED;
 
988
        }
 
989
        reply = dbus_message_new_method_return (message);
 
990
        dbus_message_iter_init_append (reply, &iter);
 
991
        _g_free0 (desktop_file);
 
992
        _tmp15_ = result;
 
993
        dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "o", &_tmp16_);
 
994
        for (_tmp17_ = 0; _tmp17_ < result_length1; _tmp17_++) {
 
995
                const char* _tmp18_;
 
996
                _tmp18_ = *_tmp15_;
 
997
                dbus_message_iter_append_basic (&_tmp16_, DBUS_TYPE_OBJECT_PATH, &_tmp18_);
 
998
                _tmp15_++;
 
999
        }
 
1000
        dbus_message_iter_close_container (&iter, &_tmp16_);
 
1001
        result = (_vala_array_free (result,  result_length1, (GDestroyNotify) g_free), NULL);
 
1002
        if (reply) {
 
1003
                dbus_connection_send (connection, reply, NULL);
 
1004
                dbus_message_unref (reply);
 
1005
                return DBUS_HANDLER_RESULT_HANDLED;
 
1006
        } else {
 
1007
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
1008
        }
 
1009
}
 
1010
 
 
1011
 
 
1012
static DBusHandlerResult _dbus_dock_manager_dbus_interface_get_items_by_pid (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
1013
        DBusMessageIter iter;
 
1014
        GError* error;
 
1015
        gint pid = 0;
 
1016
        dbus_int32_t _tmp19_;
 
1017
        char** result;
 
1018
        int result_length1;
 
1019
        DBusMessage* reply;
 
1020
        char** _tmp20_;
 
1021
        DBusMessageIter _tmp21_;
 
1022
        int _tmp22_;
 
1023
        error = NULL;
 
1024
        if (strcmp (dbus_message_get_signature (message), "i")) {
 
1025
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
1026
        }
 
1027
        dbus_message_iter_init (message, &iter);
 
1028
        dbus_message_iter_get_basic (&iter, &_tmp19_);
 
1029
        dbus_message_iter_next (&iter);
 
1030
        pid = _tmp19_;
 
1031
        result_length1 = 0;
 
1032
        result = dock_manager_dbus_interface_get_items_by_pid (self, pid, &result_length1, &error);
 
1033
        if (error) {
 
1034
                if (error->domain == DBUS_GERROR) {
 
1035
                        switch (error->code) {
 
1036
                                case DBUS_GERROR_FAILED:
 
1037
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
1038
                                break;
 
1039
                                case DBUS_GERROR_NO_MEMORY:
 
1040
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
1041
                                break;
 
1042
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
1043
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
1044
                                break;
 
1045
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
1046
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
1047
                                break;
 
1048
                                case DBUS_GERROR_NO_REPLY:
 
1049
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
1050
                                break;
 
1051
                                case DBUS_GERROR_IO_ERROR:
 
1052
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
1053
                                break;
 
1054
                                case DBUS_GERROR_BAD_ADDRESS:
 
1055
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
1056
                                break;
 
1057
                                case DBUS_GERROR_NOT_SUPPORTED:
 
1058
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
1059
                                break;
 
1060
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
1061
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
1062
                                break;
 
1063
                                case DBUS_GERROR_ACCESS_DENIED:
 
1064
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
1065
                                break;
 
1066
                                case DBUS_GERROR_AUTH_FAILED:
 
1067
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
1068
                                break;
 
1069
                                case DBUS_GERROR_NO_SERVER:
 
1070
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
1071
                                break;
 
1072
                                case DBUS_GERROR_TIMEOUT:
 
1073
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
1074
                                break;
 
1075
                                case DBUS_GERROR_NO_NETWORK:
 
1076
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
1077
                                break;
 
1078
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
1079
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
1080
                                break;
 
1081
                                case DBUS_GERROR_DISCONNECTED:
 
1082
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
1083
                                break;
 
1084
                                case DBUS_GERROR_INVALID_ARGS:
 
1085
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
1086
                                break;
 
1087
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
1088
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
1089
                                break;
 
1090
                                case DBUS_GERROR_FILE_EXISTS:
 
1091
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
1092
                                break;
 
1093
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
1094
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
1095
                                break;
 
1096
                                case DBUS_GERROR_TIMED_OUT:
 
1097
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
1098
                                break;
 
1099
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
1100
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
1101
                                break;
 
1102
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
1103
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
1104
                                break;
 
1105
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
1106
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
1107
                                break;
 
1108
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
1109
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
1110
                                break;
 
1111
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
1112
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
1113
                                break;
 
1114
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
1115
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
1116
                                break;
 
1117
                                case DBUS_GERROR_SPAWN_FAILED:
 
1118
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
1119
                                break;
 
1120
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
1121
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
1122
                                break;
 
1123
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
1124
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
1125
                                break;
 
1126
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
1127
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
1128
                                break;
 
1129
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
1130
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
1131
                                break;
 
1132
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
1133
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
1134
                                break;
 
1135
                        }
 
1136
                }
 
1137
                dbus_connection_send (connection, reply, NULL);
 
1138
                dbus_message_unref (reply);
 
1139
                return DBUS_HANDLER_RESULT_HANDLED;
 
1140
        }
 
1141
        reply = dbus_message_new_method_return (message);
 
1142
        dbus_message_iter_init_append (reply, &iter);
 
1143
        _tmp20_ = result;
 
1144
        dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "o", &_tmp21_);
 
1145
        for (_tmp22_ = 0; _tmp22_ < result_length1; _tmp22_++) {
 
1146
                const char* _tmp23_;
 
1147
                _tmp23_ = *_tmp20_;
 
1148
                dbus_message_iter_append_basic (&_tmp21_, DBUS_TYPE_OBJECT_PATH, &_tmp23_);
 
1149
                _tmp20_++;
 
1150
        }
 
1151
        dbus_message_iter_close_container (&iter, &_tmp21_);
 
1152
        result = (_vala_array_free (result,  result_length1, (GDestroyNotify) g_free), NULL);
 
1153
        if (reply) {
 
1154
                dbus_connection_send (connection, reply, NULL);
 
1155
                dbus_message_unref (reply);
 
1156
                return DBUS_HANDLER_RESULT_HANDLED;
 
1157
        } else {
 
1158
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
1159
        }
 
1160
}
 
1161
 
 
1162
 
 
1163
static DBusHandlerResult _dbus_dock_manager_dbus_interface_get_item_by_xid (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
1164
        DBusMessageIter iter;
 
1165
        GError* error;
 
1166
        gint64 xid = 0LL;
 
1167
        dbus_int64_t _tmp24_;
 
1168
        char* result;
 
1169
        DBusMessage* reply;
 
1170
        const char* _tmp25_;
 
1171
        error = NULL;
 
1172
        if (strcmp (dbus_message_get_signature (message), "x")) {
 
1173
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
1174
        }
 
1175
        dbus_message_iter_init (message, &iter);
 
1176
        dbus_message_iter_get_basic (&iter, &_tmp24_);
 
1177
        dbus_message_iter_next (&iter);
 
1178
        xid = _tmp24_;
 
1179
        result = dock_manager_dbus_interface_get_item_by_xid (self, xid, &error);
 
1180
        if (error) {
 
1181
                if (error->domain == DBUS_GERROR) {
 
1182
                        switch (error->code) {
 
1183
                                case DBUS_GERROR_FAILED:
 
1184
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
1185
                                break;
 
1186
                                case DBUS_GERROR_NO_MEMORY:
 
1187
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
1188
                                break;
 
1189
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
1190
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
1191
                                break;
 
1192
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
1193
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
1194
                                break;
 
1195
                                case DBUS_GERROR_NO_REPLY:
 
1196
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
1197
                                break;
 
1198
                                case DBUS_GERROR_IO_ERROR:
 
1199
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
1200
                                break;
 
1201
                                case DBUS_GERROR_BAD_ADDRESS:
 
1202
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
1203
                                break;
 
1204
                                case DBUS_GERROR_NOT_SUPPORTED:
 
1205
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
1206
                                break;
 
1207
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
1208
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
1209
                                break;
 
1210
                                case DBUS_GERROR_ACCESS_DENIED:
 
1211
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
1212
                                break;
 
1213
                                case DBUS_GERROR_AUTH_FAILED:
 
1214
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
1215
                                break;
 
1216
                                case DBUS_GERROR_NO_SERVER:
 
1217
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
1218
                                break;
 
1219
                                case DBUS_GERROR_TIMEOUT:
 
1220
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
1221
                                break;
 
1222
                                case DBUS_GERROR_NO_NETWORK:
 
1223
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
1224
                                break;
 
1225
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
1226
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
1227
                                break;
 
1228
                                case DBUS_GERROR_DISCONNECTED:
 
1229
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
1230
                                break;
 
1231
                                case DBUS_GERROR_INVALID_ARGS:
 
1232
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
1233
                                break;
 
1234
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
1235
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
1236
                                break;
 
1237
                                case DBUS_GERROR_FILE_EXISTS:
 
1238
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
1239
                                break;
 
1240
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
1241
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
1242
                                break;
 
1243
                                case DBUS_GERROR_TIMED_OUT:
 
1244
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
1245
                                break;
 
1246
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
1247
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
1248
                                break;
 
1249
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
1250
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
1251
                                break;
 
1252
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
1253
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
1254
                                break;
 
1255
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
1256
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
1257
                                break;
 
1258
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
1259
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
1260
                                break;
 
1261
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
1262
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
1263
                                break;
 
1264
                                case DBUS_GERROR_SPAWN_FAILED:
 
1265
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
1266
                                break;
 
1267
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
1268
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
1269
                                break;
 
1270
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
1271
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
1272
                                break;
 
1273
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
1274
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
1275
                                break;
 
1276
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
1277
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
1278
                                break;
 
1279
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
1280
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
1281
                                break;
 
1282
                        }
 
1283
                }
 
1284
                dbus_connection_send (connection, reply, NULL);
 
1285
                dbus_message_unref (reply);
 
1286
                return DBUS_HANDLER_RESULT_HANDLED;
 
1287
        }
 
1288
        reply = dbus_message_new_method_return (message);
 
1289
        dbus_message_iter_init_append (reply, &iter);
 
1290
        _tmp25_ = result;
 
1291
        dbus_message_iter_append_basic (&iter, DBUS_TYPE_OBJECT_PATH, &_tmp25_);
 
1292
        _g_free0 (result);
 
1293
        if (reply) {
 
1294
                dbus_connection_send (connection, reply, NULL);
 
1295
                dbus_message_unref (reply);
 
1296
                return DBUS_HANDLER_RESULT_HANDLED;
 
1297
        } else {
 
1298
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
1299
        }
 
1300
}
 
1301
 
 
1302
 
 
1303
static DBusHandlerResult _dbus_dock_manager_dbus_interface_awn_set_visibility (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
1304
        DBusMessageIter iter;
 
1305
        GError* error;
 
1306
        char* win_name = NULL;
 
1307
        const char* _tmp26_;
 
1308
        gboolean visible = FALSE;
 
1309
        dbus_bool_t _tmp27_;
 
1310
        DBusMessage* reply;
 
1311
        error = NULL;
 
1312
        if (strcmp (dbus_message_get_signature (message), "sb")) {
 
1313
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
1314
        }
 
1315
        dbus_message_iter_init (message, &iter);
 
1316
        dbus_message_iter_get_basic (&iter, &_tmp26_);
 
1317
        dbus_message_iter_next (&iter);
 
1318
        win_name = g_strdup (_tmp26_);
 
1319
        dbus_message_iter_get_basic (&iter, &_tmp27_);
 
1320
        dbus_message_iter_next (&iter);
 
1321
        visible = _tmp27_;
 
1322
        dock_manager_dbus_interface_awn_set_visibility (self, win_name, visible, &error);
 
1323
        if (error) {
 
1324
                if (error->domain == DBUS_GERROR) {
 
1325
                        switch (error->code) {
 
1326
                                case DBUS_GERROR_FAILED:
 
1327
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
1328
                                break;
 
1329
                                case DBUS_GERROR_NO_MEMORY:
 
1330
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
1331
                                break;
 
1332
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
1333
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
1334
                                break;
 
1335
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
1336
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
1337
                                break;
 
1338
                                case DBUS_GERROR_NO_REPLY:
 
1339
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
1340
                                break;
 
1341
                                case DBUS_GERROR_IO_ERROR:
 
1342
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
1343
                                break;
 
1344
                                case DBUS_GERROR_BAD_ADDRESS:
 
1345
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
1346
                                break;
 
1347
                                case DBUS_GERROR_NOT_SUPPORTED:
 
1348
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
1349
                                break;
 
1350
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
1351
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
1352
                                break;
 
1353
                                case DBUS_GERROR_ACCESS_DENIED:
 
1354
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
1355
                                break;
 
1356
                                case DBUS_GERROR_AUTH_FAILED:
 
1357
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
1358
                                break;
 
1359
                                case DBUS_GERROR_NO_SERVER:
 
1360
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
1361
                                break;
 
1362
                                case DBUS_GERROR_TIMEOUT:
 
1363
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
1364
                                break;
 
1365
                                case DBUS_GERROR_NO_NETWORK:
 
1366
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
1367
                                break;
 
1368
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
1369
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
1370
                                break;
 
1371
                                case DBUS_GERROR_DISCONNECTED:
 
1372
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
1373
                                break;
 
1374
                                case DBUS_GERROR_INVALID_ARGS:
 
1375
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
1376
                                break;
 
1377
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
1378
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
1379
                                break;
 
1380
                                case DBUS_GERROR_FILE_EXISTS:
 
1381
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
1382
                                break;
 
1383
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
1384
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
1385
                                break;
 
1386
                                case DBUS_GERROR_TIMED_OUT:
 
1387
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
1388
                                break;
 
1389
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
1390
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
1391
                                break;
 
1392
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
1393
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
1394
                                break;
 
1395
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
1396
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
1397
                                break;
 
1398
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
1399
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
1400
                                break;
 
1401
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
1402
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
1403
                                break;
 
1404
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
1405
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
1406
                                break;
 
1407
                                case DBUS_GERROR_SPAWN_FAILED:
 
1408
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
1409
                                break;
 
1410
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
1411
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
1412
                                break;
 
1413
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
1414
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
1415
                                break;
 
1416
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
1417
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
1418
                                break;
 
1419
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
1420
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
1421
                                break;
 
1422
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
1423
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
1424
                                break;
 
1425
                        }
 
1426
                }
 
1427
                dbus_connection_send (connection, reply, NULL);
 
1428
                dbus_message_unref (reply);
 
1429
                return DBUS_HANDLER_RESULT_HANDLED;
 
1430
        }
 
1431
        reply = dbus_message_new_method_return (message);
 
1432
        dbus_message_iter_init_append (reply, &iter);
 
1433
        _g_free0 (win_name);
 
1434
        if (reply) {
 
1435
                dbus_connection_send (connection, reply, NULL);
 
1436
                dbus_message_unref (reply);
 
1437
                return DBUS_HANDLER_RESULT_HANDLED;
 
1438
        } else {
 
1439
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
1440
        }
 
1441
}
 
1442
 
 
1443
 
 
1444
static DBusHandlerResult _dbus_dock_manager_dbus_interface_awn_register_proxy_item (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
1445
        DBusMessageIter iter;
 
1446
        GError* error;
 
1447
        char* desktop_file = NULL;
 
1448
        const char* _tmp28_;
 
1449
        char* uri = NULL;
 
1450
        const char* _tmp29_;
 
1451
        char* result;
 
1452
        DBusMessage* reply;
 
1453
        const char* _tmp30_;
 
1454
        error = NULL;
 
1455
        if (strcmp (dbus_message_get_signature (message), "ss")) {
 
1456
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
1457
        }
 
1458
        dbus_message_iter_init (message, &iter);
 
1459
        dbus_message_iter_get_basic (&iter, &_tmp28_);
 
1460
        dbus_message_iter_next (&iter);
 
1461
        desktop_file = g_strdup (_tmp28_);
 
1462
        dbus_message_iter_get_basic (&iter, &_tmp29_);
 
1463
        dbus_message_iter_next (&iter);
 
1464
        uri = g_strdup (_tmp29_);
 
1465
        result = dock_manager_dbus_interface_awn_register_proxy_item (self, desktop_file, uri, &error);
 
1466
        if (error) {
 
1467
                if (error->domain == DBUS_GERROR) {
 
1468
                        switch (error->code) {
 
1469
                                case DBUS_GERROR_FAILED:
 
1470
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
1471
                                break;
 
1472
                                case DBUS_GERROR_NO_MEMORY:
 
1473
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
1474
                                break;
 
1475
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
1476
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
1477
                                break;
 
1478
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
1479
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
1480
                                break;
 
1481
                                case DBUS_GERROR_NO_REPLY:
 
1482
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
1483
                                break;
 
1484
                                case DBUS_GERROR_IO_ERROR:
 
1485
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
1486
                                break;
 
1487
                                case DBUS_GERROR_BAD_ADDRESS:
 
1488
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
1489
                                break;
 
1490
                                case DBUS_GERROR_NOT_SUPPORTED:
 
1491
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
1492
                                break;
 
1493
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
1494
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
1495
                                break;
 
1496
                                case DBUS_GERROR_ACCESS_DENIED:
 
1497
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
1498
                                break;
 
1499
                                case DBUS_GERROR_AUTH_FAILED:
 
1500
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
1501
                                break;
 
1502
                                case DBUS_GERROR_NO_SERVER:
 
1503
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
1504
                                break;
 
1505
                                case DBUS_GERROR_TIMEOUT:
 
1506
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
1507
                                break;
 
1508
                                case DBUS_GERROR_NO_NETWORK:
 
1509
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
1510
                                break;
 
1511
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
1512
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
1513
                                break;
 
1514
                                case DBUS_GERROR_DISCONNECTED:
 
1515
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
1516
                                break;
 
1517
                                case DBUS_GERROR_INVALID_ARGS:
 
1518
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
1519
                                break;
 
1520
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
1521
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
1522
                                break;
 
1523
                                case DBUS_GERROR_FILE_EXISTS:
 
1524
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
1525
                                break;
 
1526
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
1527
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
1528
                                break;
 
1529
                                case DBUS_GERROR_TIMED_OUT:
 
1530
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
1531
                                break;
 
1532
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
1533
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
1534
                                break;
 
1535
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
1536
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
1537
                                break;
 
1538
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
1539
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
1540
                                break;
 
1541
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
1542
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
1543
                                break;
 
1544
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
1545
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
1546
                                break;
 
1547
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
1548
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
1549
                                break;
 
1550
                                case DBUS_GERROR_SPAWN_FAILED:
 
1551
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
1552
                                break;
 
1553
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
1554
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
1555
                                break;
 
1556
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
1557
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
1558
                                break;
 
1559
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
1560
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
1561
                                break;
 
1562
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
1563
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
1564
                                break;
 
1565
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
1566
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
1567
                                break;
 
1568
                        }
 
1569
                }
 
1570
                dbus_connection_send (connection, reply, NULL);
 
1571
                dbus_message_unref (reply);
 
1572
                return DBUS_HANDLER_RESULT_HANDLED;
 
1573
        }
 
1574
        reply = dbus_message_new_method_return (message);
 
1575
        dbus_message_iter_init_append (reply, &iter);
 
1576
        _g_free0 (desktop_file);
 
1577
        _g_free0 (uri);
 
1578
        _tmp30_ = result;
 
1579
        dbus_message_iter_append_basic (&iter, DBUS_TYPE_OBJECT_PATH, &_tmp30_);
 
1580
        _g_free0 (result);
 
1581
        if (reply) {
 
1582
                dbus_connection_send (connection, reply, NULL);
 
1583
                dbus_message_unref (reply);
 
1584
                return DBUS_HANDLER_RESULT_HANDLED;
 
1585
        } else {
 
1586
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
1587
        }
 
1588
}
 
1589
 
 
1590
 
 
1591
DBusHandlerResult dock_manager_dbus_interface_dbus_message (DBusConnection* connection, DBusMessage* message, void* object) {
 
1592
        DBusHandlerResult result;
 
1593
        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
1594
        if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
 
1595
                result = _dbus_dock_manager_dbus_interface_introspect (object, connection, message);
 
1596
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Properties", "GetAll")) {
 
1597
                result = _dbus_dock_manager_dbus_interface_property_get_all (object, connection, message);
 
1598
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DockManager", "GetCapabilities")) {
 
1599
                result = _dbus_dock_manager_dbus_interface_get_capabilities (object, connection, message);
 
1600
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DockManager", "GetItems")) {
 
1601
                result = _dbus_dock_manager_dbus_interface_get_items (object, connection, message);
 
1602
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DockManager", "GetItemsByName")) {
 
1603
                result = _dbus_dock_manager_dbus_interface_get_items_by_name (object, connection, message);
 
1604
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DockManager", "GetItemsByDesktopFile")) {
 
1605
                result = _dbus_dock_manager_dbus_interface_get_items_by_desktop_file (object, connection, message);
 
1606
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DockManager", "GetItemsByPid")) {
 
1607
                result = _dbus_dock_manager_dbus_interface_get_items_by_pid (object, connection, message);
 
1608
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DockManager", "GetItemByXid")) {
 
1609
                result = _dbus_dock_manager_dbus_interface_get_item_by_xid (object, connection, message);
 
1610
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DockManager", "AwnSetVisibility")) {
 
1611
                result = _dbus_dock_manager_dbus_interface_awn_set_visibility (object, connection, message);
 
1612
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DockManager", "AwnRegisterProxyItem")) {
 
1613
                result = _dbus_dock_manager_dbus_interface_awn_register_proxy_item (object, connection, message);
 
1614
        }
 
1615
        if (result == DBUS_HANDLER_RESULT_HANDLED) {
 
1616
                return result;
 
1617
        } else {
 
1618
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
1619
        }
 
1620
}
 
1621
 
 
1622
 
 
1623
static void _dbus_dock_manager_dbus_interface_item_added (GObject* _sender, const char* path, DBusConnection* _connection) {
 
1624
        const char * _path;
 
1625
        DBusMessage *_message;
 
1626
        DBusMessageIter _iter;
 
1627
        const char* _tmp31_;
 
1628
        _path = g_object_get_data (_sender, "dbus_object_path");
 
1629
        _message = dbus_message_new_signal (_path, "org.freedesktop.DockManager", "ItemAdded");
 
1630
        dbus_message_iter_init_append (_message, &_iter);
 
1631
        _tmp31_ = path;
 
1632
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_OBJECT_PATH, &_tmp31_);
 
1633
        dbus_connection_send (_connection, _message, NULL);
 
1634
        dbus_message_unref (_message);
 
1635
}
 
1636
 
 
1637
 
 
1638
static void _dbus_dock_manager_dbus_interface_item_removed (GObject* _sender, const char* path, DBusConnection* _connection) {
 
1639
        const char * _path;
 
1640
        DBusMessage *_message;
 
1641
        DBusMessageIter _iter;
 
1642
        const char* _tmp32_;
 
1643
        _path = g_object_get_data (_sender, "dbus_object_path");
 
1644
        _message = dbus_message_new_signal (_path, "org.freedesktop.DockManager", "ItemRemoved");
 
1645
        dbus_message_iter_init_append (_message, &_iter);
 
1646
        _tmp32_ = path;
 
1647
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_OBJECT_PATH, &_tmp32_);
 
1648
        dbus_connection_send (_connection, _message, NULL);
 
1649
        dbus_message_unref (_message);
 
1650
}
 
1651
 
 
1652
 
 
1653
void dock_manager_dbus_interface_dbus_register_object (DBusConnection* connection, const char* path, void* object) {
 
1654
        if (!g_object_get_data (object, "dbus_object_path")) {
 
1655
                g_object_set_data (object, "dbus_object_path", g_strdup (path));
 
1656
                dbus_connection_register_object_path (connection, path, &_dock_manager_dbus_interface_dbus_path_vtable, object);
 
1657
                g_object_weak_ref (object, _vala_dbus_unregister_object, connection);
 
1658
        }
 
1659
        g_signal_connect (object, "item-added", (GCallback) _dbus_dock_manager_dbus_interface_item_added, connection);
 
1660
        g_signal_connect (object, "item-removed", (GCallback) _dbus_dock_manager_dbus_interface_item_removed, connection);
 
1661
}
 
1662
 
 
1663
 
 
1664
static void dock_manager_dbus_interface_base_init (DockManagerDBusInterfaceIface * iface) {
 
1665
        static gboolean initialized = FALSE;
 
1666
        if (!initialized) {
 
1667
                initialized = TRUE;
 
1668
                g_signal_new ("item_added", TYPE_DOCK_MANAGER_DBUS_INTERFACE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__BOXED, G_TYPE_NONE, 1, DBUS_TYPE_G_OBJECT_PATH);
 
1669
                g_signal_new ("item_removed", TYPE_DOCK_MANAGER_DBUS_INTERFACE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__BOXED, G_TYPE_NONE, 1, DBUS_TYPE_G_OBJECT_PATH);
 
1670
                g_type_set_qdata (TYPE_DOCK_MANAGER_DBUS_INTERFACE, g_quark_from_static_string ("DBusObjectVTable"), (void*) (&_dock_manager_dbus_interface_dbus_vtable));
 
1671
        }
 
1672
}
 
1673
 
 
1674
 
 
1675
GType dock_manager_dbus_interface_get_type (void) {
 
1676
        static GType dock_manager_dbus_interface_type_id = 0;
 
1677
        if (dock_manager_dbus_interface_type_id == 0) {
 
1678
                static const GTypeInfo g_define_type_info = { sizeof (DockManagerDBusInterfaceIface), (GBaseInitFunc) dock_manager_dbus_interface_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
 
1679
                dock_manager_dbus_interface_type_id = g_type_register_static (G_TYPE_INTERFACE, "DockManagerDBusInterface", &g_define_type_info, 0);
 
1680
                g_type_interface_add_prerequisite (dock_manager_dbus_interface_type_id, G_TYPE_OBJECT);
 
1681
                g_type_set_qdata (dock_manager_dbus_interface_type_id, g_quark_from_string ("ValaDBusInterfaceProxyType"), &dock_manager_dbus_interface_dbus_proxy_get_type);
 
1682
        }
 
1683
        return dock_manager_dbus_interface_type_id;
 
1684
}
 
1685
 
 
1686
 
 
1687
G_DEFINE_TYPE_EXTENDED (DockManagerDBusInterfaceDBusProxy, dock_manager_dbus_interface_dbus_proxy, DBUS_TYPE_G_PROXY, 0, G_IMPLEMENT_INTERFACE (TYPE_DOCK_MANAGER_DBUS_INTERFACE, dock_manager_dbus_interface_dbus_proxy_dock_manager_dbus_interface__interface_init) );
 
1688
DockManagerDBusInterface* dock_manager_dbus_interface_dbus_proxy_new (DBusGConnection* connection, const char* name, const char* path) {
 
1689
        DockManagerDBusInterface* self;
 
1690
        self = g_object_new (dock_manager_dbus_interface_dbus_proxy_get_type (), "connection", connection, "name", name, "path", path, "interface", "org.freedesktop.DockManager", NULL);
 
1691
        return self;
 
1692
}
 
1693
 
 
1694
 
 
1695
static GObject* dock_manager_dbus_interface_dbus_proxy_construct (GType gtype, guint n_properties, GObjectConstructParam* properties) {
 
1696
        GObject* self;
 
1697
        DBusGConnection *connection;
 
1698
        char* path;
 
1699
        char* filter;
 
1700
        self = G_OBJECT_CLASS (dock_manager_dbus_interface_dbus_proxy_parent_class)->constructor (gtype, n_properties, properties);
 
1701
        g_object_get (self, "connection", &connection, NULL);
 
1702
        g_object_get (self, "path", &path, NULL);
 
1703
        dbus_connection_add_filter (dbus_g_connection_get_connection (connection), dock_manager_dbus_interface_dbus_proxy_filter, self, NULL);
 
1704
        filter = g_strdup_printf ("type='signal',path='%s'", path);
 
1705
        dbus_bus_add_match (dbus_g_connection_get_connection (connection), filter, NULL);
 
1706
        dbus_g_connection_unref (connection);
 
1707
        g_free (path);
 
1708
        g_free (filter);
 
1709
        return self;
 
1710
}
 
1711
 
 
1712
 
 
1713
static void _dbus_handle_dock_manager_dbus_interface_item_added (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
1714
        DBusMessageIter iter;
 
1715
        const char* path = NULL;
 
1716
        const char* _tmp33_;
 
1717
        DBusMessage* reply;
 
1718
        if (strcmp (dbus_message_get_signature (message), "o")) {
 
1719
                return;
 
1720
        }
 
1721
        dbus_message_iter_init (message, &iter);
 
1722
        dbus_message_iter_get_basic (&iter, &_tmp33_);
 
1723
        dbus_message_iter_next (&iter);
 
1724
        path = g_strdup (_tmp33_);
 
1725
        g_signal_emit_by_name (self, "item-added", path);
 
1726
}
 
1727
 
 
1728
 
 
1729
static void _dbus_handle_dock_manager_dbus_interface_item_removed (DockManagerDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
1730
        DBusMessageIter iter;
 
1731
        const char* path = NULL;
 
1732
        const char* _tmp34_;
 
1733
        DBusMessage* reply;
 
1734
        if (strcmp (dbus_message_get_signature (message), "o")) {
 
1735
                return;
 
1736
        }
 
1737
        dbus_message_iter_init (message, &iter);
 
1738
        dbus_message_iter_get_basic (&iter, &_tmp34_);
 
1739
        dbus_message_iter_next (&iter);
 
1740
        path = g_strdup (_tmp34_);
 
1741
        g_signal_emit_by_name (self, "item-removed", path);
 
1742
}
 
1743
 
 
1744
 
 
1745
DBusHandlerResult dock_manager_dbus_interface_dbus_proxy_filter (DBusConnection* connection, DBusMessage* message, void* user_data) {
 
1746
        if (dbus_message_has_path (message, dbus_g_proxy_get_path (user_data))) {
 
1747
                if (dbus_message_is_signal (message, "org.freedesktop.DockManager", "ItemAdded")) {
 
1748
                        _dbus_handle_dock_manager_dbus_interface_item_added (user_data, connection, message);
 
1749
                } else if (dbus_message_is_signal (message, "org.freedesktop.DockManager", "ItemRemoved")) {
 
1750
                        _dbus_handle_dock_manager_dbus_interface_item_removed (user_data, connection, message);
 
1751
                }
 
1752
        }
 
1753
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
1754
}
 
1755
 
 
1756
 
 
1757
static void dock_manager_dbus_interface_dbus_proxy_dispose (GObject* self) {
 
1758
        DBusGConnection *connection;
 
1759
        if (((DockManagerDBusInterfaceDBusProxy*) self)->disposed) {
 
1760
                return;
 
1761
        }
 
1762
        ((DockManagerDBusInterfaceDBusProxy*) self)->disposed = TRUE;
 
1763
        g_object_get (self, "connection", &connection, NULL);
 
1764
        dbus_connection_remove_filter (dbus_g_connection_get_connection (connection), dock_manager_dbus_interface_dbus_proxy_filter, self);
 
1765
        G_OBJECT_CLASS (dock_manager_dbus_interface_dbus_proxy_parent_class)->dispose (self);
 
1766
}
 
1767
 
 
1768
 
 
1769
static void dock_manager_dbus_interface_dbus_proxy_class_init (DockManagerDBusInterfaceDBusProxyClass* klass) {
 
1770
        G_OBJECT_CLASS (klass)->constructor = dock_manager_dbus_interface_dbus_proxy_construct;
 
1771
        G_OBJECT_CLASS (klass)->dispose = dock_manager_dbus_interface_dbus_proxy_dispose;
 
1772
        G_OBJECT_CLASS (klass)->get_property = dock_manager_dbus_interface_dbus_proxy_get_property;
 
1773
        G_OBJECT_CLASS (klass)->set_property = dock_manager_dbus_interface_dbus_proxy_set_property;
 
1774
}
 
1775
 
 
1776
 
 
1777
static void dock_manager_dbus_interface_dbus_proxy_init (DockManagerDBusInterfaceDBusProxy* self) {
 
1778
}
 
1779
 
 
1780
 
 
1781
static char** dock_manager_dbus_interface_dbus_proxy_get_capabilities (DockManagerDBusInterface* self, int* result_length1, GError** error) {
 
1782
        DBusError _dbus_error;
 
1783
        DBusGConnection *_connection;
 
1784
        DBusMessage *_message, *_reply;
 
1785
        DBusMessageIter _iter;
 
1786
        char** _result;
 
1787
        int _result_length1;
 
1788
        char** _tmp35_;
 
1789
        int _tmp35__length;
 
1790
        int _tmp35__size;
 
1791
        int _tmp35__length1;
 
1792
        DBusMessageIter _tmp36_;
 
1793
        if (((DockManagerDBusInterfaceDBusProxy*) self)->disposed) {
 
1794
                g_set_error_literal (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "Connection is closed");
 
1795
                return NULL;
 
1796
        }
 
1797
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.DockManager", "GetCapabilities");
 
1798
        dbus_message_iter_init_append (_message, &_iter);
 
1799
        g_object_get (self, "connection", &_connection, NULL);
 
1800
        dbus_error_init (&_dbus_error);
 
1801
        _reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);
 
1802
        dbus_g_connection_unref (_connection);
 
1803
        dbus_message_unref (_message);
 
1804
        if (dbus_error_is_set (&_dbus_error)) {
 
1805
                GQuark _edomain;
 
1806
                gint _ecode;
 
1807
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
1808
                        const char* _tmp38_;
 
1809
                        _edomain = DBUS_GERROR;
 
1810
                        _tmp38_ = _dbus_error.name + 27;
 
1811
                        if (strcmp (_tmp38_, "Failed") == 0) {
 
1812
                                _ecode = DBUS_GERROR_FAILED;
 
1813
                        } else if (strcmp (_tmp38_, "NoMemory") == 0) {
 
1814
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
1815
                        } else if (strcmp (_tmp38_, "ServiceUnknown") == 0) {
 
1816
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
1817
                        } else if (strcmp (_tmp38_, "NameHasNoOwner") == 0) {
 
1818
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
1819
                        } else if (strcmp (_tmp38_, "NoReply") == 0) {
 
1820
                                _ecode = DBUS_GERROR_NO_REPLY;
 
1821
                        } else if (strcmp (_tmp38_, "IOError") == 0) {
 
1822
                                _ecode = DBUS_GERROR_IO_ERROR;
 
1823
                        } else if (strcmp (_tmp38_, "BadAddress") == 0) {
 
1824
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
1825
                        } else if (strcmp (_tmp38_, "NotSupported") == 0) {
 
1826
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
1827
                        } else if (strcmp (_tmp38_, "LimitsExceeded") == 0) {
 
1828
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
1829
                        } else if (strcmp (_tmp38_, "AccessDenied") == 0) {
 
1830
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
1831
                        } else if (strcmp (_tmp38_, "AuthFailed") == 0) {
 
1832
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
1833
                        } else if (strcmp (_tmp38_, "NoServer") == 0) {
 
1834
                                _ecode = DBUS_GERROR_NO_SERVER;
 
1835
                        } else if (strcmp (_tmp38_, "Timeout") == 0) {
 
1836
                                _ecode = DBUS_GERROR_TIMEOUT;
 
1837
                        } else if (strcmp (_tmp38_, "NoNetwork") == 0) {
 
1838
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
1839
                        } else if (strcmp (_tmp38_, "AddressInUse") == 0) {
 
1840
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
1841
                        } else if (strcmp (_tmp38_, "Disconnected") == 0) {
 
1842
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
1843
                        } else if (strcmp (_tmp38_, "InvalidArgs") == 0) {
 
1844
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
1845
                        } else if (strcmp (_tmp38_, "FileNotFound") == 0) {
 
1846
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
1847
                        } else if (strcmp (_tmp38_, "FileExists") == 0) {
 
1848
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
1849
                        } else if (strcmp (_tmp38_, "UnknownMethod") == 0) {
 
1850
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
1851
                        } else if (strcmp (_tmp38_, "TimedOut") == 0) {
 
1852
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
1853
                        } else if (strcmp (_tmp38_, "MatchRuleNotFound") == 0) {
 
1854
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
1855
                        } else if (strcmp (_tmp38_, "MatchRuleInvalid") == 0) {
 
1856
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
1857
                        } else if (strcmp (_tmp38_, "Spawn.ExecFailed") == 0) {
 
1858
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
1859
                        } else if (strcmp (_tmp38_, "Spawn.ForkFailed") == 0) {
 
1860
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
1861
                        } else if (strcmp (_tmp38_, "Spawn.ChildExited") == 0) {
 
1862
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
1863
                        } else if (strcmp (_tmp38_, "Spawn.ChildSignaled") == 0) {
 
1864
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
1865
                        } else if (strcmp (_tmp38_, "Spawn.Failed") == 0) {
 
1866
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
1867
                        } else if (strcmp (_tmp38_, "UnixProcessIdUnknown") == 0) {
 
1868
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
1869
                        } else if (strcmp (_tmp38_, "InvalidSignature") == 0) {
 
1870
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
1871
                        } else if (strcmp (_tmp38_, "InvalidFileContent") == 0) {
 
1872
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
1873
                        } else if (strcmp (_tmp38_, "SELinuxSecurityContextUnknown") == 0) {
 
1874
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
1875
                        } else if (strcmp (_tmp38_, "RemoteException") == 0) {
 
1876
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
1877
                        }
 
1878
                }
 
1879
                g_set_error_literal (error, _edomain, _ecode, _dbus_error.message);
 
1880
                dbus_error_free (&_dbus_error);
 
1881
                return NULL;
 
1882
        }
 
1883
        if (strcmp (dbus_message_get_signature (_reply), "as")) {
 
1884
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "as", dbus_message_get_signature (_reply));
 
1885
                dbus_message_unref (_reply);
 
1886
                return NULL;
 
1887
        }
 
1888
        dbus_message_iter_init (_reply, &_iter);
 
1889
        _result_length1 = 0;
 
1890
        _tmp35_ = g_new (char*, 5);
 
1891
        _tmp35__length = 0;
 
1892
        _tmp35__size = 4;
 
1893
        _tmp35__length1 = 0;
 
1894
        dbus_message_iter_recurse (&_iter, &_tmp36_);
 
1895
        for (; dbus_message_iter_get_arg_type (&_tmp36_); _tmp35__length1++) {
 
1896
                const char* _tmp37_;
 
1897
                if (_tmp35__size == _tmp35__length) {
 
1898
                        _tmp35__size = 2 * _tmp35__size;
 
1899
                        _tmp35_ = g_renew (char*, _tmp35_, _tmp35__size + 1);
 
1900
                }
 
1901
                dbus_message_iter_get_basic (&_tmp36_, &_tmp37_);
 
1902
                dbus_message_iter_next (&_tmp36_);
 
1903
                _tmp35_[_tmp35__length++] = g_strdup (_tmp37_);
 
1904
        }
 
1905
        _result_length1 = _tmp35__length1;
 
1906
        _tmp35_[_tmp35__length] = NULL;
 
1907
        dbus_message_iter_next (&_iter);
 
1908
        _result = _tmp35_;
 
1909
        *result_length1 = _result_length1;
 
1910
        dbus_message_unref (_reply);
 
1911
        return _result;
 
1912
}
 
1913
 
 
1914
 
 
1915
static char** dock_manager_dbus_interface_dbus_proxy_get_items (DockManagerDBusInterface* self, int* result_length1, GError** error) {
 
1916
        DBusError _dbus_error;
 
1917
        DBusGConnection *_connection;
 
1918
        DBusMessage *_message, *_reply;
 
1919
        DBusMessageIter _iter;
 
1920
        char** _result;
 
1921
        int _result_length1;
 
1922
        char** _tmp39_;
 
1923
        int _tmp39__length;
 
1924
        int _tmp39__size;
 
1925
        int _tmp39__length1;
 
1926
        DBusMessageIter _tmp40_;
 
1927
        if (((DockManagerDBusInterfaceDBusProxy*) self)->disposed) {
 
1928
                g_set_error_literal (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "Connection is closed");
 
1929
                return NULL;
 
1930
        }
 
1931
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.DockManager", "GetItems");
 
1932
        dbus_message_iter_init_append (_message, &_iter);
 
1933
        g_object_get (self, "connection", &_connection, NULL);
 
1934
        dbus_error_init (&_dbus_error);
 
1935
        _reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);
 
1936
        dbus_g_connection_unref (_connection);
 
1937
        dbus_message_unref (_message);
 
1938
        if (dbus_error_is_set (&_dbus_error)) {
 
1939
                GQuark _edomain;
 
1940
                gint _ecode;
 
1941
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
1942
                        const char* _tmp42_;
 
1943
                        _edomain = DBUS_GERROR;
 
1944
                        _tmp42_ = _dbus_error.name + 27;
 
1945
                        if (strcmp (_tmp42_, "Failed") == 0) {
 
1946
                                _ecode = DBUS_GERROR_FAILED;
 
1947
                        } else if (strcmp (_tmp42_, "NoMemory") == 0) {
 
1948
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
1949
                        } else if (strcmp (_tmp42_, "ServiceUnknown") == 0) {
 
1950
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
1951
                        } else if (strcmp (_tmp42_, "NameHasNoOwner") == 0) {
 
1952
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
1953
                        } else if (strcmp (_tmp42_, "NoReply") == 0) {
 
1954
                                _ecode = DBUS_GERROR_NO_REPLY;
 
1955
                        } else if (strcmp (_tmp42_, "IOError") == 0) {
 
1956
                                _ecode = DBUS_GERROR_IO_ERROR;
 
1957
                        } else if (strcmp (_tmp42_, "BadAddress") == 0) {
 
1958
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
1959
                        } else if (strcmp (_tmp42_, "NotSupported") == 0) {
 
1960
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
1961
                        } else if (strcmp (_tmp42_, "LimitsExceeded") == 0) {
 
1962
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
1963
                        } else if (strcmp (_tmp42_, "AccessDenied") == 0) {
 
1964
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
1965
                        } else if (strcmp (_tmp42_, "AuthFailed") == 0) {
 
1966
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
1967
                        } else if (strcmp (_tmp42_, "NoServer") == 0) {
 
1968
                                _ecode = DBUS_GERROR_NO_SERVER;
 
1969
                        } else if (strcmp (_tmp42_, "Timeout") == 0) {
 
1970
                                _ecode = DBUS_GERROR_TIMEOUT;
 
1971
                        } else if (strcmp (_tmp42_, "NoNetwork") == 0) {
 
1972
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
1973
                        } else if (strcmp (_tmp42_, "AddressInUse") == 0) {
 
1974
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
1975
                        } else if (strcmp (_tmp42_, "Disconnected") == 0) {
 
1976
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
1977
                        } else if (strcmp (_tmp42_, "InvalidArgs") == 0) {
 
1978
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
1979
                        } else if (strcmp (_tmp42_, "FileNotFound") == 0) {
 
1980
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
1981
                        } else if (strcmp (_tmp42_, "FileExists") == 0) {
 
1982
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
1983
                        } else if (strcmp (_tmp42_, "UnknownMethod") == 0) {
 
1984
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
1985
                        } else if (strcmp (_tmp42_, "TimedOut") == 0) {
 
1986
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
1987
                        } else if (strcmp (_tmp42_, "MatchRuleNotFound") == 0) {
 
1988
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
1989
                        } else if (strcmp (_tmp42_, "MatchRuleInvalid") == 0) {
 
1990
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
1991
                        } else if (strcmp (_tmp42_, "Spawn.ExecFailed") == 0) {
 
1992
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
1993
                        } else if (strcmp (_tmp42_, "Spawn.ForkFailed") == 0) {
 
1994
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
1995
                        } else if (strcmp (_tmp42_, "Spawn.ChildExited") == 0) {
 
1996
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
1997
                        } else if (strcmp (_tmp42_, "Spawn.ChildSignaled") == 0) {
 
1998
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
1999
                        } else if (strcmp (_tmp42_, "Spawn.Failed") == 0) {
 
2000
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
2001
                        } else if (strcmp (_tmp42_, "UnixProcessIdUnknown") == 0) {
 
2002
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
2003
                        } else if (strcmp (_tmp42_, "InvalidSignature") == 0) {
 
2004
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
2005
                        } else if (strcmp (_tmp42_, "InvalidFileContent") == 0) {
 
2006
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
2007
                        } else if (strcmp (_tmp42_, "SELinuxSecurityContextUnknown") == 0) {
 
2008
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
2009
                        } else if (strcmp (_tmp42_, "RemoteException") == 0) {
 
2010
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
2011
                        }
 
2012
                }
 
2013
                g_set_error_literal (error, _edomain, _ecode, _dbus_error.message);
 
2014
                dbus_error_free (&_dbus_error);
 
2015
                return NULL;
 
2016
        }
 
2017
        if (strcmp (dbus_message_get_signature (_reply), "ao")) {
 
2018
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "ao", dbus_message_get_signature (_reply));
 
2019
                dbus_message_unref (_reply);
 
2020
                return NULL;
 
2021
        }
 
2022
        dbus_message_iter_init (_reply, &_iter);
 
2023
        _result_length1 = 0;
 
2024
        _tmp39_ = g_new (char*, 5);
 
2025
        _tmp39__length = 0;
 
2026
        _tmp39__size = 4;
 
2027
        _tmp39__length1 = 0;
 
2028
        dbus_message_iter_recurse (&_iter, &_tmp40_);
 
2029
        for (; dbus_message_iter_get_arg_type (&_tmp40_); _tmp39__length1++) {
 
2030
                const char* _tmp41_;
 
2031
                if (_tmp39__size == _tmp39__length) {
 
2032
                        _tmp39__size = 2 * _tmp39__size;
 
2033
                        _tmp39_ = g_renew (char*, _tmp39_, _tmp39__size + 1);
 
2034
                }
 
2035
                dbus_message_iter_get_basic (&_tmp40_, &_tmp41_);
 
2036
                dbus_message_iter_next (&_tmp40_);
 
2037
                _tmp39_[_tmp39__length++] = g_strdup (_tmp41_);
 
2038
        }
 
2039
        _result_length1 = _tmp39__length1;
 
2040
        _tmp39_[_tmp39__length] = NULL;
 
2041
        dbus_message_iter_next (&_iter);
 
2042
        _result = _tmp39_;
 
2043
        *result_length1 = _result_length1;
 
2044
        dbus_message_unref (_reply);
 
2045
        return _result;
 
2046
}
 
2047
 
 
2048
 
 
2049
static char** dock_manager_dbus_interface_dbus_proxy_get_items_by_name (DockManagerDBusInterface* self, const char* name, int* result_length1, GError** error) {
 
2050
        DBusError _dbus_error;
 
2051
        DBusGConnection *_connection;
 
2052
        DBusMessage *_message, *_reply;
 
2053
        DBusMessageIter _iter;
 
2054
        const char* _tmp43_;
 
2055
        char** _result;
 
2056
        int _result_length1;
 
2057
        char** _tmp44_;
 
2058
        int _tmp44__length;
 
2059
        int _tmp44__size;
 
2060
        int _tmp44__length1;
 
2061
        DBusMessageIter _tmp45_;
 
2062
        if (((DockManagerDBusInterfaceDBusProxy*) self)->disposed) {
 
2063
                g_set_error_literal (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "Connection is closed");
 
2064
                return NULL;
 
2065
        }
 
2066
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.DockManager", "GetItemsByName");
 
2067
        dbus_message_iter_init_append (_message, &_iter);
 
2068
        _tmp43_ = name;
 
2069
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_STRING, &_tmp43_);
 
2070
        g_object_get (self, "connection", &_connection, NULL);
 
2071
        dbus_error_init (&_dbus_error);
 
2072
        _reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);
 
2073
        dbus_g_connection_unref (_connection);
 
2074
        dbus_message_unref (_message);
 
2075
        if (dbus_error_is_set (&_dbus_error)) {
 
2076
                GQuark _edomain;
 
2077
                gint _ecode;
 
2078
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
2079
                        const char* _tmp47_;
 
2080
                        _edomain = DBUS_GERROR;
 
2081
                        _tmp47_ = _dbus_error.name + 27;
 
2082
                        if (strcmp (_tmp47_, "Failed") == 0) {
 
2083
                                _ecode = DBUS_GERROR_FAILED;
 
2084
                        } else if (strcmp (_tmp47_, "NoMemory") == 0) {
 
2085
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
2086
                        } else if (strcmp (_tmp47_, "ServiceUnknown") == 0) {
 
2087
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
2088
                        } else if (strcmp (_tmp47_, "NameHasNoOwner") == 0) {
 
2089
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
2090
                        } else if (strcmp (_tmp47_, "NoReply") == 0) {
 
2091
                                _ecode = DBUS_GERROR_NO_REPLY;
 
2092
                        } else if (strcmp (_tmp47_, "IOError") == 0) {
 
2093
                                _ecode = DBUS_GERROR_IO_ERROR;
 
2094
                        } else if (strcmp (_tmp47_, "BadAddress") == 0) {
 
2095
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
2096
                        } else if (strcmp (_tmp47_, "NotSupported") == 0) {
 
2097
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
2098
                        } else if (strcmp (_tmp47_, "LimitsExceeded") == 0) {
 
2099
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
2100
                        } else if (strcmp (_tmp47_, "AccessDenied") == 0) {
 
2101
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
2102
                        } else if (strcmp (_tmp47_, "AuthFailed") == 0) {
 
2103
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
2104
                        } else if (strcmp (_tmp47_, "NoServer") == 0) {
 
2105
                                _ecode = DBUS_GERROR_NO_SERVER;
 
2106
                        } else if (strcmp (_tmp47_, "Timeout") == 0) {
 
2107
                                _ecode = DBUS_GERROR_TIMEOUT;
 
2108
                        } else if (strcmp (_tmp47_, "NoNetwork") == 0) {
 
2109
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
2110
                        } else if (strcmp (_tmp47_, "AddressInUse") == 0) {
 
2111
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
2112
                        } else if (strcmp (_tmp47_, "Disconnected") == 0) {
 
2113
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
2114
                        } else if (strcmp (_tmp47_, "InvalidArgs") == 0) {
 
2115
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
2116
                        } else if (strcmp (_tmp47_, "FileNotFound") == 0) {
 
2117
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
2118
                        } else if (strcmp (_tmp47_, "FileExists") == 0) {
 
2119
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
2120
                        } else if (strcmp (_tmp47_, "UnknownMethod") == 0) {
 
2121
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
2122
                        } else if (strcmp (_tmp47_, "TimedOut") == 0) {
 
2123
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
2124
                        } else if (strcmp (_tmp47_, "MatchRuleNotFound") == 0) {
 
2125
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
2126
                        } else if (strcmp (_tmp47_, "MatchRuleInvalid") == 0) {
 
2127
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
2128
                        } else if (strcmp (_tmp47_, "Spawn.ExecFailed") == 0) {
 
2129
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
2130
                        } else if (strcmp (_tmp47_, "Spawn.ForkFailed") == 0) {
 
2131
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
2132
                        } else if (strcmp (_tmp47_, "Spawn.ChildExited") == 0) {
 
2133
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
2134
                        } else if (strcmp (_tmp47_, "Spawn.ChildSignaled") == 0) {
 
2135
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
2136
                        } else if (strcmp (_tmp47_, "Spawn.Failed") == 0) {
 
2137
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
2138
                        } else if (strcmp (_tmp47_, "UnixProcessIdUnknown") == 0) {
 
2139
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
2140
                        } else if (strcmp (_tmp47_, "InvalidSignature") == 0) {
 
2141
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
2142
                        } else if (strcmp (_tmp47_, "InvalidFileContent") == 0) {
 
2143
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
2144
                        } else if (strcmp (_tmp47_, "SELinuxSecurityContextUnknown") == 0) {
 
2145
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
2146
                        } else if (strcmp (_tmp47_, "RemoteException") == 0) {
 
2147
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
2148
                        }
 
2149
                }
 
2150
                g_set_error_literal (error, _edomain, _ecode, _dbus_error.message);
 
2151
                dbus_error_free (&_dbus_error);
 
2152
                return NULL;
 
2153
        }
 
2154
        if (strcmp (dbus_message_get_signature (_reply), "ao")) {
 
2155
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "ao", dbus_message_get_signature (_reply));
 
2156
                dbus_message_unref (_reply);
 
2157
                return NULL;
 
2158
        }
 
2159
        dbus_message_iter_init (_reply, &_iter);
 
2160
        _result_length1 = 0;
 
2161
        _tmp44_ = g_new (char*, 5);
 
2162
        _tmp44__length = 0;
 
2163
        _tmp44__size = 4;
 
2164
        _tmp44__length1 = 0;
 
2165
        dbus_message_iter_recurse (&_iter, &_tmp45_);
 
2166
        for (; dbus_message_iter_get_arg_type (&_tmp45_); _tmp44__length1++) {
 
2167
                const char* _tmp46_;
 
2168
                if (_tmp44__size == _tmp44__length) {
 
2169
                        _tmp44__size = 2 * _tmp44__size;
 
2170
                        _tmp44_ = g_renew (char*, _tmp44_, _tmp44__size + 1);
 
2171
                }
 
2172
                dbus_message_iter_get_basic (&_tmp45_, &_tmp46_);
 
2173
                dbus_message_iter_next (&_tmp45_);
 
2174
                _tmp44_[_tmp44__length++] = g_strdup (_tmp46_);
 
2175
        }
 
2176
        _result_length1 = _tmp44__length1;
 
2177
        _tmp44_[_tmp44__length] = NULL;
 
2178
        dbus_message_iter_next (&_iter);
 
2179
        _result = _tmp44_;
 
2180
        *result_length1 = _result_length1;
 
2181
        dbus_message_unref (_reply);
 
2182
        return _result;
 
2183
}
 
2184
 
 
2185
 
 
2186
static char** dock_manager_dbus_interface_dbus_proxy_get_items_by_desktop_file (DockManagerDBusInterface* self, const char* desktop_file, int* result_length1, GError** error) {
 
2187
        DBusError _dbus_error;
 
2188
        DBusGConnection *_connection;
 
2189
        DBusMessage *_message, *_reply;
 
2190
        DBusMessageIter _iter;
 
2191
        const char* _tmp48_;
 
2192
        char** _result;
 
2193
        int _result_length1;
 
2194
        char** _tmp49_;
 
2195
        int _tmp49__length;
 
2196
        int _tmp49__size;
 
2197
        int _tmp49__length1;
 
2198
        DBusMessageIter _tmp50_;
 
2199
        if (((DockManagerDBusInterfaceDBusProxy*) self)->disposed) {
 
2200
                g_set_error_literal (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "Connection is closed");
 
2201
                return NULL;
 
2202
        }
 
2203
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.DockManager", "GetItemsByDesktopFile");
 
2204
        dbus_message_iter_init_append (_message, &_iter);
 
2205
        _tmp48_ = desktop_file;
 
2206
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_STRING, &_tmp48_);
 
2207
        g_object_get (self, "connection", &_connection, NULL);
 
2208
        dbus_error_init (&_dbus_error);
 
2209
        _reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);
 
2210
        dbus_g_connection_unref (_connection);
 
2211
        dbus_message_unref (_message);
 
2212
        if (dbus_error_is_set (&_dbus_error)) {
 
2213
                GQuark _edomain;
 
2214
                gint _ecode;
 
2215
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
2216
                        const char* _tmp52_;
 
2217
                        _edomain = DBUS_GERROR;
 
2218
                        _tmp52_ = _dbus_error.name + 27;
 
2219
                        if (strcmp (_tmp52_, "Failed") == 0) {
 
2220
                                _ecode = DBUS_GERROR_FAILED;
 
2221
                        } else if (strcmp (_tmp52_, "NoMemory") == 0) {
 
2222
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
2223
                        } else if (strcmp (_tmp52_, "ServiceUnknown") == 0) {
 
2224
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
2225
                        } else if (strcmp (_tmp52_, "NameHasNoOwner") == 0) {
 
2226
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
2227
                        } else if (strcmp (_tmp52_, "NoReply") == 0) {
 
2228
                                _ecode = DBUS_GERROR_NO_REPLY;
 
2229
                        } else if (strcmp (_tmp52_, "IOError") == 0) {
 
2230
                                _ecode = DBUS_GERROR_IO_ERROR;
 
2231
                        } else if (strcmp (_tmp52_, "BadAddress") == 0) {
 
2232
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
2233
                        } else if (strcmp (_tmp52_, "NotSupported") == 0) {
 
2234
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
2235
                        } else if (strcmp (_tmp52_, "LimitsExceeded") == 0) {
 
2236
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
2237
                        } else if (strcmp (_tmp52_, "AccessDenied") == 0) {
 
2238
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
2239
                        } else if (strcmp (_tmp52_, "AuthFailed") == 0) {
 
2240
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
2241
                        } else if (strcmp (_tmp52_, "NoServer") == 0) {
 
2242
                                _ecode = DBUS_GERROR_NO_SERVER;
 
2243
                        } else if (strcmp (_tmp52_, "Timeout") == 0) {
 
2244
                                _ecode = DBUS_GERROR_TIMEOUT;
 
2245
                        } else if (strcmp (_tmp52_, "NoNetwork") == 0) {
 
2246
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
2247
                        } else if (strcmp (_tmp52_, "AddressInUse") == 0) {
 
2248
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
2249
                        } else if (strcmp (_tmp52_, "Disconnected") == 0) {
 
2250
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
2251
                        } else if (strcmp (_tmp52_, "InvalidArgs") == 0) {
 
2252
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
2253
                        } else if (strcmp (_tmp52_, "FileNotFound") == 0) {
 
2254
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
2255
                        } else if (strcmp (_tmp52_, "FileExists") == 0) {
 
2256
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
2257
                        } else if (strcmp (_tmp52_, "UnknownMethod") == 0) {
 
2258
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
2259
                        } else if (strcmp (_tmp52_, "TimedOut") == 0) {
 
2260
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
2261
                        } else if (strcmp (_tmp52_, "MatchRuleNotFound") == 0) {
 
2262
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
2263
                        } else if (strcmp (_tmp52_, "MatchRuleInvalid") == 0) {
 
2264
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
2265
                        } else if (strcmp (_tmp52_, "Spawn.ExecFailed") == 0) {
 
2266
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
2267
                        } else if (strcmp (_tmp52_, "Spawn.ForkFailed") == 0) {
 
2268
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
2269
                        } else if (strcmp (_tmp52_, "Spawn.ChildExited") == 0) {
 
2270
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
2271
                        } else if (strcmp (_tmp52_, "Spawn.ChildSignaled") == 0) {
 
2272
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
2273
                        } else if (strcmp (_tmp52_, "Spawn.Failed") == 0) {
 
2274
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
2275
                        } else if (strcmp (_tmp52_, "UnixProcessIdUnknown") == 0) {
 
2276
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
2277
                        } else if (strcmp (_tmp52_, "InvalidSignature") == 0) {
 
2278
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
2279
                        } else if (strcmp (_tmp52_, "InvalidFileContent") == 0) {
 
2280
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
2281
                        } else if (strcmp (_tmp52_, "SELinuxSecurityContextUnknown") == 0) {
 
2282
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
2283
                        } else if (strcmp (_tmp52_, "RemoteException") == 0) {
 
2284
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
2285
                        }
 
2286
                }
 
2287
                g_set_error_literal (error, _edomain, _ecode, _dbus_error.message);
 
2288
                dbus_error_free (&_dbus_error);
 
2289
                return NULL;
 
2290
        }
 
2291
        if (strcmp (dbus_message_get_signature (_reply), "ao")) {
 
2292
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "ao", dbus_message_get_signature (_reply));
 
2293
                dbus_message_unref (_reply);
 
2294
                return NULL;
 
2295
        }
 
2296
        dbus_message_iter_init (_reply, &_iter);
 
2297
        _result_length1 = 0;
 
2298
        _tmp49_ = g_new (char*, 5);
 
2299
        _tmp49__length = 0;
 
2300
        _tmp49__size = 4;
 
2301
        _tmp49__length1 = 0;
 
2302
        dbus_message_iter_recurse (&_iter, &_tmp50_);
 
2303
        for (; dbus_message_iter_get_arg_type (&_tmp50_); _tmp49__length1++) {
 
2304
                const char* _tmp51_;
 
2305
                if (_tmp49__size == _tmp49__length) {
 
2306
                        _tmp49__size = 2 * _tmp49__size;
 
2307
                        _tmp49_ = g_renew (char*, _tmp49_, _tmp49__size + 1);
 
2308
                }
 
2309
                dbus_message_iter_get_basic (&_tmp50_, &_tmp51_);
 
2310
                dbus_message_iter_next (&_tmp50_);
 
2311
                _tmp49_[_tmp49__length++] = g_strdup (_tmp51_);
 
2312
        }
 
2313
        _result_length1 = _tmp49__length1;
 
2314
        _tmp49_[_tmp49__length] = NULL;
 
2315
        dbus_message_iter_next (&_iter);
 
2316
        _result = _tmp49_;
 
2317
        *result_length1 = _result_length1;
 
2318
        dbus_message_unref (_reply);
 
2319
        return _result;
 
2320
}
 
2321
 
 
2322
 
 
2323
static char** dock_manager_dbus_interface_dbus_proxy_get_items_by_pid (DockManagerDBusInterface* self, gint pid, int* result_length1, GError** error) {
 
2324
        DBusError _dbus_error;
 
2325
        DBusGConnection *_connection;
 
2326
        DBusMessage *_message, *_reply;
 
2327
        DBusMessageIter _iter;
 
2328
        dbus_int32_t _tmp53_;
 
2329
        char** _result;
 
2330
        int _result_length1;
 
2331
        char** _tmp54_;
 
2332
        int _tmp54__length;
 
2333
        int _tmp54__size;
 
2334
        int _tmp54__length1;
 
2335
        DBusMessageIter _tmp55_;
 
2336
        if (((DockManagerDBusInterfaceDBusProxy*) self)->disposed) {
 
2337
                g_set_error_literal (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "Connection is closed");
 
2338
                return NULL;
 
2339
        }
 
2340
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.DockManager", "GetItemsByPid");
 
2341
        dbus_message_iter_init_append (_message, &_iter);
 
2342
        _tmp53_ = pid;
 
2343
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_INT32, &_tmp53_);
 
2344
        g_object_get (self, "connection", &_connection, NULL);
 
2345
        dbus_error_init (&_dbus_error);
 
2346
        _reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);
 
2347
        dbus_g_connection_unref (_connection);
 
2348
        dbus_message_unref (_message);
 
2349
        if (dbus_error_is_set (&_dbus_error)) {
 
2350
                GQuark _edomain;
 
2351
                gint _ecode;
 
2352
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
2353
                        const char* _tmp57_;
 
2354
                        _edomain = DBUS_GERROR;
 
2355
                        _tmp57_ = _dbus_error.name + 27;
 
2356
                        if (strcmp (_tmp57_, "Failed") == 0) {
 
2357
                                _ecode = DBUS_GERROR_FAILED;
 
2358
                        } else if (strcmp (_tmp57_, "NoMemory") == 0) {
 
2359
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
2360
                        } else if (strcmp (_tmp57_, "ServiceUnknown") == 0) {
 
2361
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
2362
                        } else if (strcmp (_tmp57_, "NameHasNoOwner") == 0) {
 
2363
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
2364
                        } else if (strcmp (_tmp57_, "NoReply") == 0) {
 
2365
                                _ecode = DBUS_GERROR_NO_REPLY;
 
2366
                        } else if (strcmp (_tmp57_, "IOError") == 0) {
 
2367
                                _ecode = DBUS_GERROR_IO_ERROR;
 
2368
                        } else if (strcmp (_tmp57_, "BadAddress") == 0) {
 
2369
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
2370
                        } else if (strcmp (_tmp57_, "NotSupported") == 0) {
 
2371
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
2372
                        } else if (strcmp (_tmp57_, "LimitsExceeded") == 0) {
 
2373
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
2374
                        } else if (strcmp (_tmp57_, "AccessDenied") == 0) {
 
2375
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
2376
                        } else if (strcmp (_tmp57_, "AuthFailed") == 0) {
 
2377
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
2378
                        } else if (strcmp (_tmp57_, "NoServer") == 0) {
 
2379
                                _ecode = DBUS_GERROR_NO_SERVER;
 
2380
                        } else if (strcmp (_tmp57_, "Timeout") == 0) {
 
2381
                                _ecode = DBUS_GERROR_TIMEOUT;
 
2382
                        } else if (strcmp (_tmp57_, "NoNetwork") == 0) {
 
2383
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
2384
                        } else if (strcmp (_tmp57_, "AddressInUse") == 0) {
 
2385
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
2386
                        } else if (strcmp (_tmp57_, "Disconnected") == 0) {
 
2387
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
2388
                        } else if (strcmp (_tmp57_, "InvalidArgs") == 0) {
 
2389
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
2390
                        } else if (strcmp (_tmp57_, "FileNotFound") == 0) {
 
2391
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
2392
                        } else if (strcmp (_tmp57_, "FileExists") == 0) {
 
2393
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
2394
                        } else if (strcmp (_tmp57_, "UnknownMethod") == 0) {
 
2395
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
2396
                        } else if (strcmp (_tmp57_, "TimedOut") == 0) {
 
2397
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
2398
                        } else if (strcmp (_tmp57_, "MatchRuleNotFound") == 0) {
 
2399
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
2400
                        } else if (strcmp (_tmp57_, "MatchRuleInvalid") == 0) {
 
2401
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
2402
                        } else if (strcmp (_tmp57_, "Spawn.ExecFailed") == 0) {
 
2403
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
2404
                        } else if (strcmp (_tmp57_, "Spawn.ForkFailed") == 0) {
 
2405
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
2406
                        } else if (strcmp (_tmp57_, "Spawn.ChildExited") == 0) {
 
2407
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
2408
                        } else if (strcmp (_tmp57_, "Spawn.ChildSignaled") == 0) {
 
2409
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
2410
                        } else if (strcmp (_tmp57_, "Spawn.Failed") == 0) {
 
2411
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
2412
                        } else if (strcmp (_tmp57_, "UnixProcessIdUnknown") == 0) {
 
2413
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
2414
                        } else if (strcmp (_tmp57_, "InvalidSignature") == 0) {
 
2415
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
2416
                        } else if (strcmp (_tmp57_, "InvalidFileContent") == 0) {
 
2417
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
2418
                        } else if (strcmp (_tmp57_, "SELinuxSecurityContextUnknown") == 0) {
 
2419
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
2420
                        } else if (strcmp (_tmp57_, "RemoteException") == 0) {
 
2421
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
2422
                        }
 
2423
                }
 
2424
                g_set_error_literal (error, _edomain, _ecode, _dbus_error.message);
 
2425
                dbus_error_free (&_dbus_error);
 
2426
                return NULL;
 
2427
        }
 
2428
        if (strcmp (dbus_message_get_signature (_reply), "ao")) {
 
2429
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "ao", dbus_message_get_signature (_reply));
 
2430
                dbus_message_unref (_reply);
 
2431
                return NULL;
 
2432
        }
 
2433
        dbus_message_iter_init (_reply, &_iter);
 
2434
        _result_length1 = 0;
 
2435
        _tmp54_ = g_new (char*, 5);
 
2436
        _tmp54__length = 0;
 
2437
        _tmp54__size = 4;
 
2438
        _tmp54__length1 = 0;
 
2439
        dbus_message_iter_recurse (&_iter, &_tmp55_);
 
2440
        for (; dbus_message_iter_get_arg_type (&_tmp55_); _tmp54__length1++) {
 
2441
                const char* _tmp56_;
 
2442
                if (_tmp54__size == _tmp54__length) {
 
2443
                        _tmp54__size = 2 * _tmp54__size;
 
2444
                        _tmp54_ = g_renew (char*, _tmp54_, _tmp54__size + 1);
 
2445
                }
 
2446
                dbus_message_iter_get_basic (&_tmp55_, &_tmp56_);
 
2447
                dbus_message_iter_next (&_tmp55_);
 
2448
                _tmp54_[_tmp54__length++] = g_strdup (_tmp56_);
 
2449
        }
 
2450
        _result_length1 = _tmp54__length1;
 
2451
        _tmp54_[_tmp54__length] = NULL;
 
2452
        dbus_message_iter_next (&_iter);
 
2453
        _result = _tmp54_;
 
2454
        *result_length1 = _result_length1;
 
2455
        dbus_message_unref (_reply);
 
2456
        return _result;
 
2457
}
 
2458
 
 
2459
 
 
2460
static char* dock_manager_dbus_interface_dbus_proxy_get_item_by_xid (DockManagerDBusInterface* self, gint64 xid, GError** error) {
 
2461
        DBusError _dbus_error;
 
2462
        DBusGConnection *_connection;
 
2463
        DBusMessage *_message, *_reply;
 
2464
        DBusMessageIter _iter;
 
2465
        dbus_int64_t _tmp58_;
 
2466
        char* _result;
 
2467
        const char* _tmp59_;
 
2468
        if (((DockManagerDBusInterfaceDBusProxy*) self)->disposed) {
 
2469
                g_set_error_literal (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "Connection is closed");
 
2470
                return NULL;
 
2471
        }
 
2472
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.DockManager", "GetItemByXid");
 
2473
        dbus_message_iter_init_append (_message, &_iter);
 
2474
        _tmp58_ = xid;
 
2475
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_INT64, &_tmp58_);
 
2476
        g_object_get (self, "connection", &_connection, NULL);
 
2477
        dbus_error_init (&_dbus_error);
 
2478
        _reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);
 
2479
        dbus_g_connection_unref (_connection);
 
2480
        dbus_message_unref (_message);
 
2481
        if (dbus_error_is_set (&_dbus_error)) {
 
2482
                GQuark _edomain;
 
2483
                gint _ecode;
 
2484
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
2485
                        const char* _tmp60_;
 
2486
                        _edomain = DBUS_GERROR;
 
2487
                        _tmp60_ = _dbus_error.name + 27;
 
2488
                        if (strcmp (_tmp60_, "Failed") == 0) {
 
2489
                                _ecode = DBUS_GERROR_FAILED;
 
2490
                        } else if (strcmp (_tmp60_, "NoMemory") == 0) {
 
2491
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
2492
                        } else if (strcmp (_tmp60_, "ServiceUnknown") == 0) {
 
2493
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
2494
                        } else if (strcmp (_tmp60_, "NameHasNoOwner") == 0) {
 
2495
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
2496
                        } else if (strcmp (_tmp60_, "NoReply") == 0) {
 
2497
                                _ecode = DBUS_GERROR_NO_REPLY;
 
2498
                        } else if (strcmp (_tmp60_, "IOError") == 0) {
 
2499
                                _ecode = DBUS_GERROR_IO_ERROR;
 
2500
                        } else if (strcmp (_tmp60_, "BadAddress") == 0) {
 
2501
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
2502
                        } else if (strcmp (_tmp60_, "NotSupported") == 0) {
 
2503
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
2504
                        } else if (strcmp (_tmp60_, "LimitsExceeded") == 0) {
 
2505
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
2506
                        } else if (strcmp (_tmp60_, "AccessDenied") == 0) {
 
2507
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
2508
                        } else if (strcmp (_tmp60_, "AuthFailed") == 0) {
 
2509
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
2510
                        } else if (strcmp (_tmp60_, "NoServer") == 0) {
 
2511
                                _ecode = DBUS_GERROR_NO_SERVER;
 
2512
                        } else if (strcmp (_tmp60_, "Timeout") == 0) {
 
2513
                                _ecode = DBUS_GERROR_TIMEOUT;
 
2514
                        } else if (strcmp (_tmp60_, "NoNetwork") == 0) {
 
2515
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
2516
                        } else if (strcmp (_tmp60_, "AddressInUse") == 0) {
 
2517
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
2518
                        } else if (strcmp (_tmp60_, "Disconnected") == 0) {
 
2519
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
2520
                        } else if (strcmp (_tmp60_, "InvalidArgs") == 0) {
 
2521
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
2522
                        } else if (strcmp (_tmp60_, "FileNotFound") == 0) {
 
2523
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
2524
                        } else if (strcmp (_tmp60_, "FileExists") == 0) {
 
2525
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
2526
                        } else if (strcmp (_tmp60_, "UnknownMethod") == 0) {
 
2527
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
2528
                        } else if (strcmp (_tmp60_, "TimedOut") == 0) {
 
2529
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
2530
                        } else if (strcmp (_tmp60_, "MatchRuleNotFound") == 0) {
 
2531
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
2532
                        } else if (strcmp (_tmp60_, "MatchRuleInvalid") == 0) {
 
2533
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
2534
                        } else if (strcmp (_tmp60_, "Spawn.ExecFailed") == 0) {
 
2535
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
2536
                        } else if (strcmp (_tmp60_, "Spawn.ForkFailed") == 0) {
 
2537
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
2538
                        } else if (strcmp (_tmp60_, "Spawn.ChildExited") == 0) {
 
2539
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
2540
                        } else if (strcmp (_tmp60_, "Spawn.ChildSignaled") == 0) {
 
2541
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
2542
                        } else if (strcmp (_tmp60_, "Spawn.Failed") == 0) {
 
2543
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
2544
                        } else if (strcmp (_tmp60_, "UnixProcessIdUnknown") == 0) {
 
2545
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
2546
                        } else if (strcmp (_tmp60_, "InvalidSignature") == 0) {
 
2547
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
2548
                        } else if (strcmp (_tmp60_, "InvalidFileContent") == 0) {
 
2549
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
2550
                        } else if (strcmp (_tmp60_, "SELinuxSecurityContextUnknown") == 0) {
 
2551
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
2552
                        } else if (strcmp (_tmp60_, "RemoteException") == 0) {
 
2553
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
2554
                        }
 
2555
                }
 
2556
                g_set_error_literal (error, _edomain, _ecode, _dbus_error.message);
 
2557
                dbus_error_free (&_dbus_error);
 
2558
                return NULL;
 
2559
        }
 
2560
        if (strcmp (dbus_message_get_signature (_reply), "o")) {
 
2561
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "o", dbus_message_get_signature (_reply));
 
2562
                dbus_message_unref (_reply);
 
2563
                return NULL;
 
2564
        }
 
2565
        dbus_message_iter_init (_reply, &_iter);
 
2566
        dbus_message_iter_get_basic (&_iter, &_tmp59_);
 
2567
        dbus_message_iter_next (&_iter);
 
2568
        _result = g_strdup (_tmp59_);
 
2569
        dbus_message_unref (_reply);
 
2570
        return _result;
 
2571
}
 
2572
 
 
2573
 
 
2574
static void dock_manager_dbus_interface_dbus_proxy_awn_set_visibility (DockManagerDBusInterface* self, const char* win_name, gboolean visible, GError** error) {
 
2575
        DBusError _dbus_error;
 
2576
        DBusGConnection *_connection;
 
2577
        DBusMessage *_message, *_reply;
 
2578
        DBusMessageIter _iter;
 
2579
        const char* _tmp61_;
 
2580
        dbus_bool_t _tmp62_;
 
2581
        if (((DockManagerDBusInterfaceDBusProxy*) self)->disposed) {
 
2582
                g_set_error_literal (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "Connection is closed");
 
2583
                return;
 
2584
        }
 
2585
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.DockManager", "AwnSetVisibility");
 
2586
        dbus_message_iter_init_append (_message, &_iter);
 
2587
        _tmp61_ = win_name;
 
2588
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_STRING, &_tmp61_);
 
2589
        _tmp62_ = visible;
 
2590
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_BOOLEAN, &_tmp62_);
 
2591
        g_object_get (self, "connection", &_connection, NULL);
 
2592
        dbus_error_init (&_dbus_error);
 
2593
        _reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);
 
2594
        dbus_g_connection_unref (_connection);
 
2595
        dbus_message_unref (_message);
 
2596
        if (dbus_error_is_set (&_dbus_error)) {
 
2597
                GQuark _edomain;
 
2598
                gint _ecode;
 
2599
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
2600
                        const char* _tmp63_;
 
2601
                        _edomain = DBUS_GERROR;
 
2602
                        _tmp63_ = _dbus_error.name + 27;
 
2603
                        if (strcmp (_tmp63_, "Failed") == 0) {
 
2604
                                _ecode = DBUS_GERROR_FAILED;
 
2605
                        } else if (strcmp (_tmp63_, "NoMemory") == 0) {
 
2606
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
2607
                        } else if (strcmp (_tmp63_, "ServiceUnknown") == 0) {
 
2608
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
2609
                        } else if (strcmp (_tmp63_, "NameHasNoOwner") == 0) {
 
2610
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
2611
                        } else if (strcmp (_tmp63_, "NoReply") == 0) {
 
2612
                                _ecode = DBUS_GERROR_NO_REPLY;
 
2613
                        } else if (strcmp (_tmp63_, "IOError") == 0) {
 
2614
                                _ecode = DBUS_GERROR_IO_ERROR;
 
2615
                        } else if (strcmp (_tmp63_, "BadAddress") == 0) {
 
2616
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
2617
                        } else if (strcmp (_tmp63_, "NotSupported") == 0) {
 
2618
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
2619
                        } else if (strcmp (_tmp63_, "LimitsExceeded") == 0) {
 
2620
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
2621
                        } else if (strcmp (_tmp63_, "AccessDenied") == 0) {
 
2622
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
2623
                        } else if (strcmp (_tmp63_, "AuthFailed") == 0) {
 
2624
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
2625
                        } else if (strcmp (_tmp63_, "NoServer") == 0) {
 
2626
                                _ecode = DBUS_GERROR_NO_SERVER;
 
2627
                        } else if (strcmp (_tmp63_, "Timeout") == 0) {
 
2628
                                _ecode = DBUS_GERROR_TIMEOUT;
 
2629
                        } else if (strcmp (_tmp63_, "NoNetwork") == 0) {
 
2630
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
2631
                        } else if (strcmp (_tmp63_, "AddressInUse") == 0) {
 
2632
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
2633
                        } else if (strcmp (_tmp63_, "Disconnected") == 0) {
 
2634
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
2635
                        } else if (strcmp (_tmp63_, "InvalidArgs") == 0) {
 
2636
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
2637
                        } else if (strcmp (_tmp63_, "FileNotFound") == 0) {
 
2638
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
2639
                        } else if (strcmp (_tmp63_, "FileExists") == 0) {
 
2640
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
2641
                        } else if (strcmp (_tmp63_, "UnknownMethod") == 0) {
 
2642
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
2643
                        } else if (strcmp (_tmp63_, "TimedOut") == 0) {
 
2644
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
2645
                        } else if (strcmp (_tmp63_, "MatchRuleNotFound") == 0) {
 
2646
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
2647
                        } else if (strcmp (_tmp63_, "MatchRuleInvalid") == 0) {
 
2648
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
2649
                        } else if (strcmp (_tmp63_, "Spawn.ExecFailed") == 0) {
 
2650
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
2651
                        } else if (strcmp (_tmp63_, "Spawn.ForkFailed") == 0) {
 
2652
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
2653
                        } else if (strcmp (_tmp63_, "Spawn.ChildExited") == 0) {
 
2654
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
2655
                        } else if (strcmp (_tmp63_, "Spawn.ChildSignaled") == 0) {
 
2656
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
2657
                        } else if (strcmp (_tmp63_, "Spawn.Failed") == 0) {
 
2658
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
2659
                        } else if (strcmp (_tmp63_, "UnixProcessIdUnknown") == 0) {
 
2660
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
2661
                        } else if (strcmp (_tmp63_, "InvalidSignature") == 0) {
 
2662
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
2663
                        } else if (strcmp (_tmp63_, "InvalidFileContent") == 0) {
 
2664
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
2665
                        } else if (strcmp (_tmp63_, "SELinuxSecurityContextUnknown") == 0) {
 
2666
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
2667
                        } else if (strcmp (_tmp63_, "RemoteException") == 0) {
 
2668
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
2669
                        }
 
2670
                }
 
2671
                g_set_error_literal (error, _edomain, _ecode, _dbus_error.message);
 
2672
                dbus_error_free (&_dbus_error);
 
2673
                return;
 
2674
        }
 
2675
        if (strcmp (dbus_message_get_signature (_reply), "")) {
 
2676
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "", dbus_message_get_signature (_reply));
 
2677
                dbus_message_unref (_reply);
 
2678
                return;
 
2679
        }
 
2680
        dbus_message_iter_init (_reply, &_iter);
 
2681
        dbus_message_unref (_reply);
 
2682
}
 
2683
 
 
2684
 
 
2685
static char* dock_manager_dbus_interface_dbus_proxy_awn_register_proxy_item (DockManagerDBusInterface* self, const char* desktop_file, const char* uri, GError** error) {
 
2686
        DBusError _dbus_error;
 
2687
        DBusGConnection *_connection;
 
2688
        DBusMessage *_message, *_reply;
 
2689
        DBusMessageIter _iter;
 
2690
        const char* _tmp64_;
 
2691
        const char* _tmp65_;
 
2692
        char* _result;
 
2693
        const char* _tmp66_;
 
2694
        if (((DockManagerDBusInterfaceDBusProxy*) self)->disposed) {
 
2695
                g_set_error_literal (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "Connection is closed");
 
2696
                return NULL;
 
2697
        }
 
2698
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.DockManager", "AwnRegisterProxyItem");
 
2699
        dbus_message_iter_init_append (_message, &_iter);
 
2700
        _tmp64_ = desktop_file;
 
2701
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_STRING, &_tmp64_);
 
2702
        _tmp65_ = uri;
 
2703
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_STRING, &_tmp65_);
 
2704
        g_object_get (self, "connection", &_connection, NULL);
 
2705
        dbus_error_init (&_dbus_error);
 
2706
        _reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);
 
2707
        dbus_g_connection_unref (_connection);
 
2708
        dbus_message_unref (_message);
 
2709
        if (dbus_error_is_set (&_dbus_error)) {
 
2710
                GQuark _edomain;
 
2711
                gint _ecode;
 
2712
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
2713
                        const char* _tmp67_;
 
2714
                        _edomain = DBUS_GERROR;
 
2715
                        _tmp67_ = _dbus_error.name + 27;
 
2716
                        if (strcmp (_tmp67_, "Failed") == 0) {
 
2717
                                _ecode = DBUS_GERROR_FAILED;
 
2718
                        } else if (strcmp (_tmp67_, "NoMemory") == 0) {
 
2719
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
2720
                        } else if (strcmp (_tmp67_, "ServiceUnknown") == 0) {
 
2721
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
2722
                        } else if (strcmp (_tmp67_, "NameHasNoOwner") == 0) {
 
2723
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
2724
                        } else if (strcmp (_tmp67_, "NoReply") == 0) {
 
2725
                                _ecode = DBUS_GERROR_NO_REPLY;
 
2726
                        } else if (strcmp (_tmp67_, "IOError") == 0) {
 
2727
                                _ecode = DBUS_GERROR_IO_ERROR;
 
2728
                        } else if (strcmp (_tmp67_, "BadAddress") == 0) {
 
2729
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
2730
                        } else if (strcmp (_tmp67_, "NotSupported") == 0) {
 
2731
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
2732
                        } else if (strcmp (_tmp67_, "LimitsExceeded") == 0) {
 
2733
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
2734
                        } else if (strcmp (_tmp67_, "AccessDenied") == 0) {
 
2735
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
2736
                        } else if (strcmp (_tmp67_, "AuthFailed") == 0) {
 
2737
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
2738
                        } else if (strcmp (_tmp67_, "NoServer") == 0) {
 
2739
                                _ecode = DBUS_GERROR_NO_SERVER;
 
2740
                        } else if (strcmp (_tmp67_, "Timeout") == 0) {
 
2741
                                _ecode = DBUS_GERROR_TIMEOUT;
 
2742
                        } else if (strcmp (_tmp67_, "NoNetwork") == 0) {
 
2743
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
2744
                        } else if (strcmp (_tmp67_, "AddressInUse") == 0) {
 
2745
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
2746
                        } else if (strcmp (_tmp67_, "Disconnected") == 0) {
 
2747
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
2748
                        } else if (strcmp (_tmp67_, "InvalidArgs") == 0) {
 
2749
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
2750
                        } else if (strcmp (_tmp67_, "FileNotFound") == 0) {
 
2751
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
2752
                        } else if (strcmp (_tmp67_, "FileExists") == 0) {
 
2753
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
2754
                        } else if (strcmp (_tmp67_, "UnknownMethod") == 0) {
 
2755
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
2756
                        } else if (strcmp (_tmp67_, "TimedOut") == 0) {
 
2757
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
2758
                        } else if (strcmp (_tmp67_, "MatchRuleNotFound") == 0) {
 
2759
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
2760
                        } else if (strcmp (_tmp67_, "MatchRuleInvalid") == 0) {
 
2761
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
2762
                        } else if (strcmp (_tmp67_, "Spawn.ExecFailed") == 0) {
 
2763
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
2764
                        } else if (strcmp (_tmp67_, "Spawn.ForkFailed") == 0) {
 
2765
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
2766
                        } else if (strcmp (_tmp67_, "Spawn.ChildExited") == 0) {
 
2767
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
2768
                        } else if (strcmp (_tmp67_, "Spawn.ChildSignaled") == 0) {
 
2769
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
2770
                        } else if (strcmp (_tmp67_, "Spawn.Failed") == 0) {
 
2771
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
2772
                        } else if (strcmp (_tmp67_, "UnixProcessIdUnknown") == 0) {
 
2773
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
2774
                        } else if (strcmp (_tmp67_, "InvalidSignature") == 0) {
 
2775
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
2776
                        } else if (strcmp (_tmp67_, "InvalidFileContent") == 0) {
 
2777
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
2778
                        } else if (strcmp (_tmp67_, "SELinuxSecurityContextUnknown") == 0) {
 
2779
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
2780
                        } else if (strcmp (_tmp67_, "RemoteException") == 0) {
 
2781
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
2782
                        }
 
2783
                }
 
2784
                g_set_error_literal (error, _edomain, _ecode, _dbus_error.message);
 
2785
                dbus_error_free (&_dbus_error);
 
2786
                return NULL;
 
2787
        }
 
2788
        if (strcmp (dbus_message_get_signature (_reply), "o")) {
 
2789
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "o", dbus_message_get_signature (_reply));
 
2790
                dbus_message_unref (_reply);
 
2791
                return NULL;
 
2792
        }
 
2793
        dbus_message_iter_init (_reply, &_iter);
 
2794
        dbus_message_iter_get_basic (&_iter, &_tmp66_);
 
2795
        dbus_message_iter_next (&_iter);
 
2796
        _result = g_strdup (_tmp66_);
 
2797
        dbus_message_unref (_reply);
 
2798
        return _result;
 
2799
}
 
2800
 
 
2801
 
 
2802
static void dock_manager_dbus_interface_dbus_proxy_dock_manager_dbus_interface__interface_init (DockManagerDBusInterfaceIface* iface) {
 
2803
        iface->get_capabilities = dock_manager_dbus_interface_dbus_proxy_get_capabilities;
 
2804
        iface->get_items = dock_manager_dbus_interface_dbus_proxy_get_items;
 
2805
        iface->get_items_by_name = dock_manager_dbus_interface_dbus_proxy_get_items_by_name;
 
2806
        iface->get_items_by_desktop_file = dock_manager_dbus_interface_dbus_proxy_get_items_by_desktop_file;
 
2807
        iface->get_items_by_pid = dock_manager_dbus_interface_dbus_proxy_get_items_by_pid;
 
2808
        iface->get_item_by_xid = dock_manager_dbus_interface_dbus_proxy_get_item_by_xid;
 
2809
        iface->awn_set_visibility = dock_manager_dbus_interface_dbus_proxy_awn_set_visibility;
 
2810
        iface->awn_register_proxy_item = dock_manager_dbus_interface_dbus_proxy_awn_register_proxy_item;
 
2811
}
 
2812
 
 
2813
 
 
2814
static void dock_manager_dbus_interface_dbus_proxy_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
2815
}
 
2816
 
 
2817
 
 
2818
static void dock_manager_dbus_interface_dbus_proxy_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 
2819
}
 
2820
 
 
2821
 
 
2822
gint dock_item_dbus_interface_add_menu_item (DockItemDBusInterface* self, GHashTable* menu_hints, GError** error) {
 
2823
        return DOCK_ITEM_DBUS_INTERFACE_GET_INTERFACE (self)->add_menu_item (self, menu_hints, error);
 
2824
}
 
2825
 
 
2826
 
 
2827
void dock_item_dbus_interface_remove_menu_item (DockItemDBusInterface* self, gint id, GError** error) {
 
2828
        DOCK_ITEM_DBUS_INTERFACE_GET_INTERFACE (self)->remove_menu_item (self, id, error);
 
2829
}
 
2830
 
 
2831
 
 
2832
void dock_item_dbus_interface_update_dock_item (DockItemDBusInterface* self, GHashTable* hints, GError** error) {
 
2833
        DOCK_ITEM_DBUS_INTERFACE_GET_INTERFACE (self)->update_dock_item (self, hints, error);
 
2834
}
 
2835
 
 
2836
 
 
2837
char* dock_item_dbus_interface_get_desktop_file (DockItemDBusInterface* self) {
 
2838
        return DOCK_ITEM_DBUS_INTERFACE_GET_INTERFACE (self)->get_desktop_file (self);
 
2839
}
 
2840
 
 
2841
 
 
2842
char* dock_item_dbus_interface_get_uri (DockItemDBusInterface* self) {
 
2843
        return DOCK_ITEM_DBUS_INTERFACE_GET_INTERFACE (self)->get_uri (self);
 
2844
}
 
2845
 
 
2846
 
 
2847
void _dock_item_dbus_interface_dbus_unregister (DBusConnection* connection, void* _user_data_) {
 
2848
}
 
2849
 
 
2850
 
 
2851
static DBusHandlerResult _dbus_dock_item_dbus_interface_introspect (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
2852
        DBusMessage* reply;
 
2853
        DBusMessageIter iter;
 
2854
        GString* xml_data;
 
2855
        char** children;
 
2856
        int i;
 
2857
        reply = dbus_message_new_method_return (message);
 
2858
        dbus_message_iter_init_append (reply, &iter);
 
2859
        xml_data = g_string_new ("<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" \"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n");
 
2860
        g_string_append (xml_data, "<node>\n<interface name=\"org.freedesktop.DBus.Introspectable\">\n  <method name=\"Introspect\">\n    <arg name=\"data\" direction=\"out\" type=\"s\"/>\n  </method>\n</interface>\n<interface name=\"org.freedesktop.DBus.Properties\">\n  <method name=\"Get\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n    <arg name=\"value\" direction=\"out\" type=\"v\"/>\n  </method>\n  <method name=\"Set\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n    <arg name=\"value\" direction=\"in\" type=\"v\"/>\n  </method>\n  <method name=\"GetAll\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"props\" direction=\"out\" type=\"a{sv}\"/>\n  </method>\n</interface>\n<interface name=\"org.freedesktop.DockItem\">\n  <method name=\"AddMenuItem\">\n    <arg name=\"menu_hints\" type=\"a{sv}\" direction=\"in\"/>\n    <arg name=\"result\" type=\"i\" direction=\"out\"/>\n  </method>\n  <method name=\"RemoveMenuItem\">\n    <arg name=\"id\" type=\"i\" direction=\"in\"/>\n  </method>\n  <method name=\"UpdateDockItem\">\n    <arg name=\"hints\" type=\"a{sv}\" direction=\"in\"/>\n  </method>\n  <property name=\"DesktopFile\" type=\"s\" access=\"read\"/>\n  <property name=\"Uri\" type=\"s\" access=\"read\"/>\n  <signal name=\"MenuItemActivated\">\n    <arg name=\"id\" type=\"i\"/>\n  </signal>\n</interface>\n");
 
2861
        dbus_connection_list_registered (connection, g_object_get_data ((GObject *) self, "dbus_object_path"), &children);
 
2862
        for (i = 0; children[i]; i++) {
 
2863
                g_string_append_printf (xml_data, "<node name=\"%s\"/>\n", children[i]);
 
2864
        }
 
2865
        dbus_free_string_array (children);
 
2866
        g_string_append (xml_data, "</node>\n");
 
2867
        dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &xml_data->str);
 
2868
        g_string_free (xml_data, TRUE);
 
2869
        if (reply) {
 
2870
                dbus_connection_send (connection, reply, NULL);
 
2871
                dbus_message_unref (reply);
 
2872
                return DBUS_HANDLER_RESULT_HANDLED;
 
2873
        } else {
 
2874
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
2875
        }
 
2876
}
 
2877
 
 
2878
 
 
2879
static DBusHandlerResult _dbus_dock_item_dbus_interface_property_get (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
2880
        DBusMessage* reply;
 
2881
        DBusMessageIter iter, reply_iter, subiter;
 
2882
        char* interface_name;
 
2883
        const char* _tmp68_;
 
2884
        char* property_name;
 
2885
        const char* _tmp69_;
 
2886
        if (strcmp (dbus_message_get_signature (message), "ss")) {
 
2887
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
2888
        }
 
2889
        dbus_message_iter_init (message, &iter);
 
2890
        reply = dbus_message_new_method_return (message);
 
2891
        dbus_message_iter_init_append (reply, &reply_iter);
 
2892
        dbus_message_iter_get_basic (&iter, &_tmp68_);
 
2893
        dbus_message_iter_next (&iter);
 
2894
        interface_name = g_strdup (_tmp68_);
 
2895
        dbus_message_iter_get_basic (&iter, &_tmp69_);
 
2896
        dbus_message_iter_next (&iter);
 
2897
        property_name = g_strdup (_tmp69_);
 
2898
        if ((strcmp (interface_name, "org.freedesktop.DockItem") == 0) && (strcmp (property_name, "DesktopFile") == 0)) {
 
2899
                char* result;
 
2900
                const char* _tmp70_;
 
2901
                dbus_message_iter_open_container (&reply_iter, DBUS_TYPE_VARIANT, "s", &subiter);
 
2902
                result = dock_item_dbus_interface_get_desktop_file (self);
 
2903
                _tmp70_ = result;
 
2904
                dbus_message_iter_append_basic (&subiter, DBUS_TYPE_STRING, &_tmp70_);
 
2905
                _g_free0 (result);
 
2906
                dbus_message_iter_close_container (&reply_iter, &subiter);
 
2907
        } else if ((strcmp (interface_name, "org.freedesktop.DockItem") == 0) && (strcmp (property_name, "Uri") == 0)) {
 
2908
                char* result;
 
2909
                const char* _tmp71_;
 
2910
                dbus_message_iter_open_container (&reply_iter, DBUS_TYPE_VARIANT, "s", &subiter);
 
2911
                result = dock_item_dbus_interface_get_uri (self);
 
2912
                _tmp71_ = result;
 
2913
                dbus_message_iter_append_basic (&subiter, DBUS_TYPE_STRING, &_tmp71_);
 
2914
                _g_free0 (result);
 
2915
                dbus_message_iter_close_container (&reply_iter, &subiter);
 
2916
        } else {
 
2917
                dbus_message_unref (reply);
 
2918
                reply = NULL;
 
2919
        }
 
2920
        g_free (interface_name);
 
2921
        g_free (property_name);
 
2922
        if (reply) {
 
2923
                dbus_connection_send (connection, reply, NULL);
 
2924
                dbus_message_unref (reply);
 
2925
                return DBUS_HANDLER_RESULT_HANDLED;
 
2926
        } else {
 
2927
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
2928
        }
 
2929
}
 
2930
 
 
2931
 
 
2932
static DBusHandlerResult _dbus_dock_item_dbus_interface_property_get_all (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
2933
        DBusMessage* reply;
 
2934
        DBusMessageIter iter, reply_iter, subiter, entry_iter, value_iter;
 
2935
        char* interface_name;
 
2936
        const char* _tmp72_;
 
2937
        const char* property_name;
 
2938
        if (strcmp (dbus_message_get_signature (message), "s")) {
 
2939
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
2940
        }
 
2941
        dbus_message_iter_init (message, &iter);
 
2942
        reply = dbus_message_new_method_return (message);
 
2943
        dbus_message_iter_init_append (reply, &reply_iter);
 
2944
        dbus_message_iter_get_basic (&iter, &_tmp72_);
 
2945
        dbus_message_iter_next (&iter);
 
2946
        interface_name = g_strdup (_tmp72_);
 
2947
        if (strcmp (interface_name, "org.freedesktop.DockItem") == 0) {
 
2948
                dbus_message_iter_open_container (&reply_iter, DBUS_TYPE_ARRAY, "{sv}", &subiter);
 
2949
                {
 
2950
                        char* result;
 
2951
                        const char* _tmp73_;
 
2952
                        dbus_message_iter_open_container (&subiter, DBUS_TYPE_DICT_ENTRY, NULL, &entry_iter);
 
2953
                        property_name = "DesktopFile";
 
2954
                        dbus_message_iter_append_basic (&entry_iter, DBUS_TYPE_STRING, &property_name);
 
2955
                        dbus_message_iter_open_container (&entry_iter, DBUS_TYPE_VARIANT, "s", &value_iter);
 
2956
                        result = dock_item_dbus_interface_get_desktop_file (self);
 
2957
                        _tmp73_ = result;
 
2958
                        dbus_message_iter_append_basic (&value_iter, DBUS_TYPE_STRING, &_tmp73_);
 
2959
                        _g_free0 (result);
 
2960
                        dbus_message_iter_close_container (&entry_iter, &value_iter);
 
2961
                        dbus_message_iter_close_container (&subiter, &entry_iter);
 
2962
                }
 
2963
                {
 
2964
                        char* result;
 
2965
                        const char* _tmp74_;
 
2966
                        dbus_message_iter_open_container (&subiter, DBUS_TYPE_DICT_ENTRY, NULL, &entry_iter);
 
2967
                        property_name = "Uri";
 
2968
                        dbus_message_iter_append_basic (&entry_iter, DBUS_TYPE_STRING, &property_name);
 
2969
                        dbus_message_iter_open_container (&entry_iter, DBUS_TYPE_VARIANT, "s", &value_iter);
 
2970
                        result = dock_item_dbus_interface_get_uri (self);
 
2971
                        _tmp74_ = result;
 
2972
                        dbus_message_iter_append_basic (&value_iter, DBUS_TYPE_STRING, &_tmp74_);
 
2973
                        _g_free0 (result);
 
2974
                        dbus_message_iter_close_container (&entry_iter, &value_iter);
 
2975
                        dbus_message_iter_close_container (&subiter, &entry_iter);
 
2976
                }
 
2977
                dbus_message_iter_close_container (&reply_iter, &subiter);
 
2978
        } else {
 
2979
                dbus_message_unref (reply);
 
2980
                reply = NULL;
 
2981
        }
 
2982
        g_free (interface_name);
 
2983
        if (reply) {
 
2984
                dbus_connection_send (connection, reply, NULL);
 
2985
                dbus_message_unref (reply);
 
2986
                return DBUS_HANDLER_RESULT_HANDLED;
 
2987
        } else {
 
2988
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
2989
        }
 
2990
}
 
2991
 
 
2992
 
 
2993
static DBusHandlerResult _dbus_dock_item_dbus_interface_add_menu_item (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
2994
        DBusMessageIter iter;
 
2995
        GError* error;
 
2996
        GHashTable* menu_hints = NULL;
 
2997
        GHashTable* _tmp75_;
 
2998
        DBusMessageIter _tmp76_;
 
2999
        DBusMessageIter _tmp77_;
 
3000
        gint result;
 
3001
        DBusMessage* reply;
 
3002
        dbus_int32_t _tmp93_;
 
3003
        error = NULL;
 
3004
        if (strcmp (dbus_message_get_signature (message), "a{sv}")) {
 
3005
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
3006
        }
 
3007
        dbus_message_iter_init (message, &iter);
 
3008
        _tmp75_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 
3009
        dbus_message_iter_recurse (&iter, &_tmp76_);
 
3010
        while (dbus_message_iter_get_arg_type (&_tmp76_)) {
 
3011
                char* _key;
 
3012
                GValue* _value;
 
3013
                const char* _tmp78_;
 
3014
                GValue _tmp79_ = {0};
 
3015
                DBusMessageIter _tmp80_;
 
3016
                dbus_message_iter_recurse (&_tmp76_, &_tmp77_);
 
3017
                dbus_message_iter_get_basic (&_tmp77_, &_tmp78_);
 
3018
                dbus_message_iter_next (&_tmp77_);
 
3019
                _key = g_strdup (_tmp78_);
 
3020
                dbus_message_iter_recurse (&_tmp77_, &_tmp80_);
 
3021
                if (dbus_message_iter_get_arg_type (&_tmp80_) == DBUS_TYPE_BYTE) {
 
3022
                        guint8 _tmp81_;
 
3023
                        dbus_message_iter_get_basic (&_tmp80_, &_tmp81_);
 
3024
                        g_value_init (&_tmp79_, G_TYPE_UCHAR);
 
3025
                        g_value_set_uchar (&_tmp79_, _tmp81_);
 
3026
                } else if (dbus_message_iter_get_arg_type (&_tmp80_) == DBUS_TYPE_BOOLEAN) {
 
3027
                        dbus_bool_t _tmp82_;
 
3028
                        dbus_message_iter_get_basic (&_tmp80_, &_tmp82_);
 
3029
                        g_value_init (&_tmp79_, G_TYPE_BOOLEAN);
 
3030
                        g_value_set_boolean (&_tmp79_, _tmp82_);
 
3031
                } else if (dbus_message_iter_get_arg_type (&_tmp80_) == DBUS_TYPE_INT16) {
 
3032
                        dbus_int16_t _tmp83_;
 
3033
                        dbus_message_iter_get_basic (&_tmp80_, &_tmp83_);
 
3034
                        g_value_init (&_tmp79_, G_TYPE_INT);
 
3035
                        g_value_set_int (&_tmp79_, _tmp83_);
 
3036
                } else if (dbus_message_iter_get_arg_type (&_tmp80_) == DBUS_TYPE_UINT16) {
 
3037
                        dbus_uint16_t _tmp84_;
 
3038
                        dbus_message_iter_get_basic (&_tmp80_, &_tmp84_);
 
3039
                        g_value_init (&_tmp79_, G_TYPE_UINT);
 
3040
                        g_value_set_uint (&_tmp79_, _tmp84_);
 
3041
                } else if (dbus_message_iter_get_arg_type (&_tmp80_) == DBUS_TYPE_INT32) {
 
3042
                        dbus_int32_t _tmp85_;
 
3043
                        dbus_message_iter_get_basic (&_tmp80_, &_tmp85_);
 
3044
                        g_value_init (&_tmp79_, G_TYPE_INT);
 
3045
                        g_value_set_int (&_tmp79_, _tmp85_);
 
3046
                } else if (dbus_message_iter_get_arg_type (&_tmp80_) == DBUS_TYPE_UINT32) {
 
3047
                        dbus_uint32_t _tmp86_;
 
3048
                        dbus_message_iter_get_basic (&_tmp80_, &_tmp86_);
 
3049
                        g_value_init (&_tmp79_, G_TYPE_UINT);
 
3050
                        g_value_set_uint (&_tmp79_, _tmp86_);
 
3051
                } else if (dbus_message_iter_get_arg_type (&_tmp80_) == DBUS_TYPE_INT64) {
 
3052
                        dbus_int64_t _tmp87_;
 
3053
                        dbus_message_iter_get_basic (&_tmp80_, &_tmp87_);
 
3054
                        g_value_init (&_tmp79_, G_TYPE_INT64);
 
3055
                        g_value_set_int64 (&_tmp79_, _tmp87_);
 
3056
                } else if (dbus_message_iter_get_arg_type (&_tmp80_) == DBUS_TYPE_UINT64) {
 
3057
                        dbus_uint64_t _tmp88_;
 
3058
                        dbus_message_iter_get_basic (&_tmp80_, &_tmp88_);
 
3059
                        g_value_init (&_tmp79_, G_TYPE_UINT64);
 
3060
                        g_value_set_uint64 (&_tmp79_, _tmp88_);
 
3061
                } else if (dbus_message_iter_get_arg_type (&_tmp80_) == DBUS_TYPE_DOUBLE) {
 
3062
                        double _tmp89_;
 
3063
                        dbus_message_iter_get_basic (&_tmp80_, &_tmp89_);
 
3064
                        g_value_init (&_tmp79_, G_TYPE_DOUBLE);
 
3065
                        g_value_set_double (&_tmp79_, _tmp89_);
 
3066
                } else if (dbus_message_iter_get_arg_type (&_tmp80_) == DBUS_TYPE_STRING) {
 
3067
                        const char* _tmp90_;
 
3068
                        dbus_message_iter_get_basic (&_tmp80_, &_tmp90_);
 
3069
                        g_value_init (&_tmp79_, G_TYPE_STRING);
 
3070
                        g_value_take_string (&_tmp79_, g_strdup (_tmp90_));
 
3071
                } else if (dbus_message_iter_get_arg_type (&_tmp80_) == DBUS_TYPE_OBJECT_PATH) {
 
3072
                        const char* _tmp91_;
 
3073
                        dbus_message_iter_get_basic (&_tmp80_, &_tmp91_);
 
3074
                        g_value_init (&_tmp79_, G_TYPE_STRING);
 
3075
                        g_value_take_string (&_tmp79_, g_strdup (_tmp91_));
 
3076
                } else if (dbus_message_iter_get_arg_type (&_tmp80_) == DBUS_TYPE_SIGNATURE) {
 
3077
                        const char* _tmp92_;
 
3078
                        dbus_message_iter_get_basic (&_tmp80_, &_tmp92_);
 
3079
                        g_value_init (&_tmp79_, G_TYPE_STRING);
 
3080
                        g_value_take_string (&_tmp79_, g_strdup (_tmp92_));
 
3081
                }
 
3082
                dbus_message_iter_next (&_tmp77_);
 
3083
                _value = g_memdup (&_tmp79_, sizeof (GValue));
 
3084
                g_hash_table_insert (_tmp75_, _key, _value);
 
3085
                dbus_message_iter_next (&_tmp76_);
 
3086
        }
 
3087
        dbus_message_iter_next (&iter);
 
3088
        menu_hints = _tmp75_;
 
3089
        result = dock_item_dbus_interface_add_menu_item (self, menu_hints, &error);
 
3090
        if (error) {
 
3091
                if (error->domain == DBUS_GERROR) {
 
3092
                        switch (error->code) {
 
3093
                                case DBUS_GERROR_FAILED:
 
3094
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
3095
                                break;
 
3096
                                case DBUS_GERROR_NO_MEMORY:
 
3097
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
3098
                                break;
 
3099
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
3100
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
3101
                                break;
 
3102
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
3103
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
3104
                                break;
 
3105
                                case DBUS_GERROR_NO_REPLY:
 
3106
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
3107
                                break;
 
3108
                                case DBUS_GERROR_IO_ERROR:
 
3109
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
3110
                                break;
 
3111
                                case DBUS_GERROR_BAD_ADDRESS:
 
3112
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
3113
                                break;
 
3114
                                case DBUS_GERROR_NOT_SUPPORTED:
 
3115
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
3116
                                break;
 
3117
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
3118
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
3119
                                break;
 
3120
                                case DBUS_GERROR_ACCESS_DENIED:
 
3121
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
3122
                                break;
 
3123
                                case DBUS_GERROR_AUTH_FAILED:
 
3124
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
3125
                                break;
 
3126
                                case DBUS_GERROR_NO_SERVER:
 
3127
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
3128
                                break;
 
3129
                                case DBUS_GERROR_TIMEOUT:
 
3130
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
3131
                                break;
 
3132
                                case DBUS_GERROR_NO_NETWORK:
 
3133
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
3134
                                break;
 
3135
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
3136
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
3137
                                break;
 
3138
                                case DBUS_GERROR_DISCONNECTED:
 
3139
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
3140
                                break;
 
3141
                                case DBUS_GERROR_INVALID_ARGS:
 
3142
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
3143
                                break;
 
3144
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
3145
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
3146
                                break;
 
3147
                                case DBUS_GERROR_FILE_EXISTS:
 
3148
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
3149
                                break;
 
3150
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
3151
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
3152
                                break;
 
3153
                                case DBUS_GERROR_TIMED_OUT:
 
3154
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
3155
                                break;
 
3156
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
3157
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
3158
                                break;
 
3159
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
3160
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
3161
                                break;
 
3162
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
3163
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
3164
                                break;
 
3165
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
3166
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
3167
                                break;
 
3168
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
3169
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
3170
                                break;
 
3171
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
3172
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
3173
                                break;
 
3174
                                case DBUS_GERROR_SPAWN_FAILED:
 
3175
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
3176
                                break;
 
3177
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
3178
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
3179
                                break;
 
3180
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
3181
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
3182
                                break;
 
3183
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
3184
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
3185
                                break;
 
3186
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
3187
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
3188
                                break;
 
3189
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
3190
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
3191
                                break;
 
3192
                        }
 
3193
                }
 
3194
                dbus_connection_send (connection, reply, NULL);
 
3195
                dbus_message_unref (reply);
 
3196
                return DBUS_HANDLER_RESULT_HANDLED;
 
3197
        }
 
3198
        reply = dbus_message_new_method_return (message);
 
3199
        dbus_message_iter_init_append (reply, &iter);
 
3200
        _g_hash_table_unref0 (menu_hints);
 
3201
        _tmp93_ = result;
 
3202
        dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &_tmp93_);
 
3203
        if (reply) {
 
3204
                dbus_connection_send (connection, reply, NULL);
 
3205
                dbus_message_unref (reply);
 
3206
                return DBUS_HANDLER_RESULT_HANDLED;
 
3207
        } else {
 
3208
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
3209
        }
 
3210
}
 
3211
 
 
3212
 
 
3213
static DBusHandlerResult _dbus_dock_item_dbus_interface_remove_menu_item (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
3214
        DBusMessageIter iter;
 
3215
        GError* error;
 
3216
        gint id = 0;
 
3217
        dbus_int32_t _tmp94_;
 
3218
        DBusMessage* reply;
 
3219
        error = NULL;
 
3220
        if (strcmp (dbus_message_get_signature (message), "i")) {
 
3221
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
3222
        }
 
3223
        dbus_message_iter_init (message, &iter);
 
3224
        dbus_message_iter_get_basic (&iter, &_tmp94_);
 
3225
        dbus_message_iter_next (&iter);
 
3226
        id = _tmp94_;
 
3227
        dock_item_dbus_interface_remove_menu_item (self, id, &error);
 
3228
        if (error) {
 
3229
                if (error->domain == DBUS_GERROR) {
 
3230
                        switch (error->code) {
 
3231
                                case DBUS_GERROR_FAILED:
 
3232
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
3233
                                break;
 
3234
                                case DBUS_GERROR_NO_MEMORY:
 
3235
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
3236
                                break;
 
3237
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
3238
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
3239
                                break;
 
3240
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
3241
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
3242
                                break;
 
3243
                                case DBUS_GERROR_NO_REPLY:
 
3244
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
3245
                                break;
 
3246
                                case DBUS_GERROR_IO_ERROR:
 
3247
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
3248
                                break;
 
3249
                                case DBUS_GERROR_BAD_ADDRESS:
 
3250
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
3251
                                break;
 
3252
                                case DBUS_GERROR_NOT_SUPPORTED:
 
3253
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
3254
                                break;
 
3255
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
3256
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
3257
                                break;
 
3258
                                case DBUS_GERROR_ACCESS_DENIED:
 
3259
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
3260
                                break;
 
3261
                                case DBUS_GERROR_AUTH_FAILED:
 
3262
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
3263
                                break;
 
3264
                                case DBUS_GERROR_NO_SERVER:
 
3265
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
3266
                                break;
 
3267
                                case DBUS_GERROR_TIMEOUT:
 
3268
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
3269
                                break;
 
3270
                                case DBUS_GERROR_NO_NETWORK:
 
3271
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
3272
                                break;
 
3273
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
3274
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
3275
                                break;
 
3276
                                case DBUS_GERROR_DISCONNECTED:
 
3277
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
3278
                                break;
 
3279
                                case DBUS_GERROR_INVALID_ARGS:
 
3280
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
3281
                                break;
 
3282
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
3283
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
3284
                                break;
 
3285
                                case DBUS_GERROR_FILE_EXISTS:
 
3286
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
3287
                                break;
 
3288
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
3289
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
3290
                                break;
 
3291
                                case DBUS_GERROR_TIMED_OUT:
 
3292
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
3293
                                break;
 
3294
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
3295
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
3296
                                break;
 
3297
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
3298
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
3299
                                break;
 
3300
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
3301
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
3302
                                break;
 
3303
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
3304
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
3305
                                break;
 
3306
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
3307
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
3308
                                break;
 
3309
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
3310
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
3311
                                break;
 
3312
                                case DBUS_GERROR_SPAWN_FAILED:
 
3313
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
3314
                                break;
 
3315
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
3316
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
3317
                                break;
 
3318
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
3319
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
3320
                                break;
 
3321
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
3322
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
3323
                                break;
 
3324
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
3325
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
3326
                                break;
 
3327
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
3328
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
3329
                                break;
 
3330
                        }
 
3331
                }
 
3332
                dbus_connection_send (connection, reply, NULL);
 
3333
                dbus_message_unref (reply);
 
3334
                return DBUS_HANDLER_RESULT_HANDLED;
 
3335
        }
 
3336
        reply = dbus_message_new_method_return (message);
 
3337
        dbus_message_iter_init_append (reply, &iter);
 
3338
        if (reply) {
 
3339
                dbus_connection_send (connection, reply, NULL);
 
3340
                dbus_message_unref (reply);
 
3341
                return DBUS_HANDLER_RESULT_HANDLED;
 
3342
        } else {
 
3343
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
3344
        }
 
3345
}
 
3346
 
 
3347
 
 
3348
static DBusHandlerResult _dbus_dock_item_dbus_interface_update_dock_item (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
3349
        DBusMessageIter iter;
 
3350
        GError* error;
 
3351
        GHashTable* hints = NULL;
 
3352
        GHashTable* _tmp95_;
 
3353
        DBusMessageIter _tmp96_;
 
3354
        DBusMessageIter _tmp97_;
 
3355
        DBusMessage* reply;
 
3356
        error = NULL;
 
3357
        if (strcmp (dbus_message_get_signature (message), "a{sv}")) {
 
3358
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
3359
        }
 
3360
        dbus_message_iter_init (message, &iter);
 
3361
        _tmp95_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 
3362
        dbus_message_iter_recurse (&iter, &_tmp96_);
 
3363
        while (dbus_message_iter_get_arg_type (&_tmp96_)) {
 
3364
                char* _key;
 
3365
                GValue* _value;
 
3366
                const char* _tmp98_;
 
3367
                GValue _tmp99_ = {0};
 
3368
                DBusMessageIter _tmp100_;
 
3369
                dbus_message_iter_recurse (&_tmp96_, &_tmp97_);
 
3370
                dbus_message_iter_get_basic (&_tmp97_, &_tmp98_);
 
3371
                dbus_message_iter_next (&_tmp97_);
 
3372
                _key = g_strdup (_tmp98_);
 
3373
                dbus_message_iter_recurse (&_tmp97_, &_tmp100_);
 
3374
                if (dbus_message_iter_get_arg_type (&_tmp100_) == DBUS_TYPE_BYTE) {
 
3375
                        guint8 _tmp101_;
 
3376
                        dbus_message_iter_get_basic (&_tmp100_, &_tmp101_);
 
3377
                        g_value_init (&_tmp99_, G_TYPE_UCHAR);
 
3378
                        g_value_set_uchar (&_tmp99_, _tmp101_);
 
3379
                } else if (dbus_message_iter_get_arg_type (&_tmp100_) == DBUS_TYPE_BOOLEAN) {
 
3380
                        dbus_bool_t _tmp102_;
 
3381
                        dbus_message_iter_get_basic (&_tmp100_, &_tmp102_);
 
3382
                        g_value_init (&_tmp99_, G_TYPE_BOOLEAN);
 
3383
                        g_value_set_boolean (&_tmp99_, _tmp102_);
 
3384
                } else if (dbus_message_iter_get_arg_type (&_tmp100_) == DBUS_TYPE_INT16) {
 
3385
                        dbus_int16_t _tmp103_;
 
3386
                        dbus_message_iter_get_basic (&_tmp100_, &_tmp103_);
 
3387
                        g_value_init (&_tmp99_, G_TYPE_INT);
 
3388
                        g_value_set_int (&_tmp99_, _tmp103_);
 
3389
                } else if (dbus_message_iter_get_arg_type (&_tmp100_) == DBUS_TYPE_UINT16) {
 
3390
                        dbus_uint16_t _tmp104_;
 
3391
                        dbus_message_iter_get_basic (&_tmp100_, &_tmp104_);
 
3392
                        g_value_init (&_tmp99_, G_TYPE_UINT);
 
3393
                        g_value_set_uint (&_tmp99_, _tmp104_);
 
3394
                } else if (dbus_message_iter_get_arg_type (&_tmp100_) == DBUS_TYPE_INT32) {
 
3395
                        dbus_int32_t _tmp105_;
 
3396
                        dbus_message_iter_get_basic (&_tmp100_, &_tmp105_);
 
3397
                        g_value_init (&_tmp99_, G_TYPE_INT);
 
3398
                        g_value_set_int (&_tmp99_, _tmp105_);
 
3399
                } else if (dbus_message_iter_get_arg_type (&_tmp100_) == DBUS_TYPE_UINT32) {
 
3400
                        dbus_uint32_t _tmp106_;
 
3401
                        dbus_message_iter_get_basic (&_tmp100_, &_tmp106_);
 
3402
                        g_value_init (&_tmp99_, G_TYPE_UINT);
 
3403
                        g_value_set_uint (&_tmp99_, _tmp106_);
 
3404
                } else if (dbus_message_iter_get_arg_type (&_tmp100_) == DBUS_TYPE_INT64) {
 
3405
                        dbus_int64_t _tmp107_;
 
3406
                        dbus_message_iter_get_basic (&_tmp100_, &_tmp107_);
 
3407
                        g_value_init (&_tmp99_, G_TYPE_INT64);
 
3408
                        g_value_set_int64 (&_tmp99_, _tmp107_);
 
3409
                } else if (dbus_message_iter_get_arg_type (&_tmp100_) == DBUS_TYPE_UINT64) {
 
3410
                        dbus_uint64_t _tmp108_;
 
3411
                        dbus_message_iter_get_basic (&_tmp100_, &_tmp108_);
 
3412
                        g_value_init (&_tmp99_, G_TYPE_UINT64);
 
3413
                        g_value_set_uint64 (&_tmp99_, _tmp108_);
 
3414
                } else if (dbus_message_iter_get_arg_type (&_tmp100_) == DBUS_TYPE_DOUBLE) {
 
3415
                        double _tmp109_;
 
3416
                        dbus_message_iter_get_basic (&_tmp100_, &_tmp109_);
 
3417
                        g_value_init (&_tmp99_, G_TYPE_DOUBLE);
 
3418
                        g_value_set_double (&_tmp99_, _tmp109_);
 
3419
                } else if (dbus_message_iter_get_arg_type (&_tmp100_) == DBUS_TYPE_STRING) {
 
3420
                        const char* _tmp110_;
 
3421
                        dbus_message_iter_get_basic (&_tmp100_, &_tmp110_);
 
3422
                        g_value_init (&_tmp99_, G_TYPE_STRING);
 
3423
                        g_value_take_string (&_tmp99_, g_strdup (_tmp110_));
 
3424
                } else if (dbus_message_iter_get_arg_type (&_tmp100_) == DBUS_TYPE_OBJECT_PATH) {
 
3425
                        const char* _tmp111_;
 
3426
                        dbus_message_iter_get_basic (&_tmp100_, &_tmp111_);
 
3427
                        g_value_init (&_tmp99_, G_TYPE_STRING);
 
3428
                        g_value_take_string (&_tmp99_, g_strdup (_tmp111_));
 
3429
                } else if (dbus_message_iter_get_arg_type (&_tmp100_) == DBUS_TYPE_SIGNATURE) {
 
3430
                        const char* _tmp112_;
 
3431
                        dbus_message_iter_get_basic (&_tmp100_, &_tmp112_);
 
3432
                        g_value_init (&_tmp99_, G_TYPE_STRING);
 
3433
                        g_value_take_string (&_tmp99_, g_strdup (_tmp112_));
 
3434
                }
 
3435
                dbus_message_iter_next (&_tmp97_);
 
3436
                _value = g_memdup (&_tmp99_, sizeof (GValue));
 
3437
                g_hash_table_insert (_tmp95_, _key, _value);
 
3438
                dbus_message_iter_next (&_tmp96_);
 
3439
        }
 
3440
        dbus_message_iter_next (&iter);
 
3441
        hints = _tmp95_;
 
3442
        dock_item_dbus_interface_update_dock_item (self, hints, &error);
 
3443
        if (error) {
 
3444
                if (error->domain == DBUS_GERROR) {
 
3445
                        switch (error->code) {
 
3446
                                case DBUS_GERROR_FAILED:
 
3447
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
3448
                                break;
 
3449
                                case DBUS_GERROR_NO_MEMORY:
 
3450
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
3451
                                break;
 
3452
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
3453
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
3454
                                break;
 
3455
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
3456
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
3457
                                break;
 
3458
                                case DBUS_GERROR_NO_REPLY:
 
3459
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
3460
                                break;
 
3461
                                case DBUS_GERROR_IO_ERROR:
 
3462
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
3463
                                break;
 
3464
                                case DBUS_GERROR_BAD_ADDRESS:
 
3465
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
3466
                                break;
 
3467
                                case DBUS_GERROR_NOT_SUPPORTED:
 
3468
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
3469
                                break;
 
3470
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
3471
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
3472
                                break;
 
3473
                                case DBUS_GERROR_ACCESS_DENIED:
 
3474
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
3475
                                break;
 
3476
                                case DBUS_GERROR_AUTH_FAILED:
 
3477
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
3478
                                break;
 
3479
                                case DBUS_GERROR_NO_SERVER:
 
3480
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
3481
                                break;
 
3482
                                case DBUS_GERROR_TIMEOUT:
 
3483
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
3484
                                break;
 
3485
                                case DBUS_GERROR_NO_NETWORK:
 
3486
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
3487
                                break;
 
3488
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
3489
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
3490
                                break;
 
3491
                                case DBUS_GERROR_DISCONNECTED:
 
3492
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
3493
                                break;
 
3494
                                case DBUS_GERROR_INVALID_ARGS:
 
3495
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
3496
                                break;
 
3497
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
3498
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
3499
                                break;
 
3500
                                case DBUS_GERROR_FILE_EXISTS:
 
3501
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
3502
                                break;
 
3503
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
3504
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
3505
                                break;
 
3506
                                case DBUS_GERROR_TIMED_OUT:
 
3507
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
3508
                                break;
 
3509
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
3510
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
3511
                                break;
 
3512
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
3513
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
3514
                                break;
 
3515
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
3516
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
3517
                                break;
 
3518
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
3519
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
3520
                                break;
 
3521
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
3522
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
3523
                                break;
 
3524
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
3525
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
3526
                                break;
 
3527
                                case DBUS_GERROR_SPAWN_FAILED:
 
3528
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
3529
                                break;
 
3530
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
3531
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
3532
                                break;
 
3533
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
3534
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
3535
                                break;
 
3536
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
3537
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
3538
                                break;
 
3539
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
3540
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
3541
                                break;
 
3542
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
3543
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
3544
                                break;
 
3545
                        }
 
3546
                }
 
3547
                dbus_connection_send (connection, reply, NULL);
 
3548
                dbus_message_unref (reply);
 
3549
                return DBUS_HANDLER_RESULT_HANDLED;
 
3550
        }
 
3551
        reply = dbus_message_new_method_return (message);
 
3552
        dbus_message_iter_init_append (reply, &iter);
 
3553
        _g_hash_table_unref0 (hints);
 
3554
        if (reply) {
 
3555
                dbus_connection_send (connection, reply, NULL);
 
3556
                dbus_message_unref (reply);
 
3557
                return DBUS_HANDLER_RESULT_HANDLED;
 
3558
        } else {
 
3559
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
3560
        }
 
3561
}
 
3562
 
 
3563
 
 
3564
DBusHandlerResult dock_item_dbus_interface_dbus_message (DBusConnection* connection, DBusMessage* message, void* object) {
 
3565
        DBusHandlerResult result;
 
3566
        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
3567
        if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
 
3568
                result = _dbus_dock_item_dbus_interface_introspect (object, connection, message);
 
3569
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Properties", "Get")) {
 
3570
                result = _dbus_dock_item_dbus_interface_property_get (object, connection, message);
 
3571
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Properties", "GetAll")) {
 
3572
                result = _dbus_dock_item_dbus_interface_property_get_all (object, connection, message);
 
3573
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DockItem", "AddMenuItem")) {
 
3574
                result = _dbus_dock_item_dbus_interface_add_menu_item (object, connection, message);
 
3575
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DockItem", "RemoveMenuItem")) {
 
3576
                result = _dbus_dock_item_dbus_interface_remove_menu_item (object, connection, message);
 
3577
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DockItem", "UpdateDockItem")) {
 
3578
                result = _dbus_dock_item_dbus_interface_update_dock_item (object, connection, message);
 
3579
        }
 
3580
        if (result == DBUS_HANDLER_RESULT_HANDLED) {
 
3581
                return result;
 
3582
        } else {
 
3583
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
3584
        }
 
3585
}
 
3586
 
 
3587
 
 
3588
static void _dbus_dock_item_dbus_interface_menu_item_activated (GObject* _sender, gint id, DBusConnection* _connection) {
 
3589
        const char * _path;
 
3590
        DBusMessage *_message;
 
3591
        DBusMessageIter _iter;
 
3592
        dbus_int32_t _tmp113_;
 
3593
        _path = g_object_get_data (_sender, "dbus_object_path");
 
3594
        _message = dbus_message_new_signal (_path, "org.freedesktop.DockItem", "MenuItemActivated");
 
3595
        dbus_message_iter_init_append (_message, &_iter);
 
3596
        _tmp113_ = id;
 
3597
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_INT32, &_tmp113_);
 
3598
        dbus_connection_send (_connection, _message, NULL);
 
3599
        dbus_message_unref (_message);
 
3600
}
 
3601
 
 
3602
 
 
3603
void dock_item_dbus_interface_dbus_register_object (DBusConnection* connection, const char* path, void* object) {
 
3604
        if (!g_object_get_data (object, "dbus_object_path")) {
 
3605
                g_object_set_data (object, "dbus_object_path", g_strdup (path));
 
3606
                dbus_connection_register_object_path (connection, path, &_dock_item_dbus_interface_dbus_path_vtable, object);
 
3607
                g_object_weak_ref (object, _vala_dbus_unregister_object, connection);
 
3608
        }
 
3609
        g_signal_connect (object, "menu-item-activated", (GCallback) _dbus_dock_item_dbus_interface_menu_item_activated, connection);
 
3610
}
 
3611
 
 
3612
 
 
3613
static void dock_item_dbus_interface_base_init (DockItemDBusInterfaceIface * iface) {
 
3614
        static gboolean initialized = FALSE;
 
3615
        if (!initialized) {
 
3616
                initialized = TRUE;
 
3617
                g_object_interface_install_property (iface, g_param_spec_string ("desktop-file", "desktop-file", "desktop-file", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
 
3618
                g_object_interface_install_property (iface, g_param_spec_string ("uri", "uri", "uri", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
 
3619
                g_signal_new ("menu_item_activated", TYPE_DOCK_ITEM_DBUS_INTERFACE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
 
3620
                g_type_set_qdata (TYPE_DOCK_ITEM_DBUS_INTERFACE, g_quark_from_static_string ("DBusObjectVTable"), (void*) (&_dock_item_dbus_interface_dbus_vtable));
 
3621
        }
 
3622
}
 
3623
 
 
3624
 
 
3625
GType dock_item_dbus_interface_get_type (void) {
 
3626
        static GType dock_item_dbus_interface_type_id = 0;
 
3627
        if (dock_item_dbus_interface_type_id == 0) {
 
3628
                static const GTypeInfo g_define_type_info = { sizeof (DockItemDBusInterfaceIface), (GBaseInitFunc) dock_item_dbus_interface_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
 
3629
                dock_item_dbus_interface_type_id = g_type_register_static (G_TYPE_INTERFACE, "DockItemDBusInterface", &g_define_type_info, 0);
 
3630
                g_type_interface_add_prerequisite (dock_item_dbus_interface_type_id, G_TYPE_OBJECT);
 
3631
                g_type_set_qdata (dock_item_dbus_interface_type_id, g_quark_from_string ("ValaDBusInterfaceProxyType"), &dock_item_dbus_interface_dbus_proxy_get_type);
 
3632
        }
 
3633
        return dock_item_dbus_interface_type_id;
 
3634
}
 
3635
 
 
3636
 
 
3637
G_DEFINE_TYPE_EXTENDED (DockItemDBusInterfaceDBusProxy, dock_item_dbus_interface_dbus_proxy, DBUS_TYPE_G_PROXY, 0, G_IMPLEMENT_INTERFACE (TYPE_DOCK_ITEM_DBUS_INTERFACE, dock_item_dbus_interface_dbus_proxy_dock_item_dbus_interface__interface_init) );
 
3638
DockItemDBusInterface* dock_item_dbus_interface_dbus_proxy_new (DBusGConnection* connection, const char* name, const char* path) {
 
3639
        DockItemDBusInterface* self;
 
3640
        self = g_object_new (dock_item_dbus_interface_dbus_proxy_get_type (), "connection", connection, "name", name, "path", path, "interface", "org.freedesktop.DockItem", NULL);
 
3641
        return self;
 
3642
}
 
3643
 
 
3644
 
 
3645
static GObject* dock_item_dbus_interface_dbus_proxy_construct (GType gtype, guint n_properties, GObjectConstructParam* properties) {
 
3646
        GObject* self;
 
3647
        DBusGConnection *connection;
 
3648
        char* path;
 
3649
        char* filter;
 
3650
        self = G_OBJECT_CLASS (dock_item_dbus_interface_dbus_proxy_parent_class)->constructor (gtype, n_properties, properties);
 
3651
        g_object_get (self, "connection", &connection, NULL);
 
3652
        g_object_get (self, "path", &path, NULL);
 
3653
        dbus_connection_add_filter (dbus_g_connection_get_connection (connection), dock_item_dbus_interface_dbus_proxy_filter, self, NULL);
 
3654
        filter = g_strdup_printf ("type='signal',path='%s'", path);
 
3655
        dbus_bus_add_match (dbus_g_connection_get_connection (connection), filter, NULL);
 
3656
        dbus_g_connection_unref (connection);
 
3657
        g_free (path);
 
3658
        g_free (filter);
 
3659
        return self;
 
3660
}
 
3661
 
 
3662
 
 
3663
static void _dbus_handle_dock_item_dbus_interface_menu_item_activated (DockItemDBusInterface* self, DBusConnection* connection, DBusMessage* message) {
 
3664
        DBusMessageIter iter;
 
3665
        gint id = 0;
 
3666
        dbus_int32_t _tmp114_;
 
3667
        DBusMessage* reply;
 
3668
        if (strcmp (dbus_message_get_signature (message), "i")) {
 
3669
                return;
 
3670
        }
 
3671
        dbus_message_iter_init (message, &iter);
 
3672
        dbus_message_iter_get_basic (&iter, &_tmp114_);
 
3673
        dbus_message_iter_next (&iter);
 
3674
        id = _tmp114_;
 
3675
        g_signal_emit_by_name (self, "menu-item-activated", id);
 
3676
}
 
3677
 
 
3678
 
 
3679
DBusHandlerResult dock_item_dbus_interface_dbus_proxy_filter (DBusConnection* connection, DBusMessage* message, void* user_data) {
 
3680
        if (dbus_message_has_path (message, dbus_g_proxy_get_path (user_data))) {
 
3681
                if (dbus_message_is_signal (message, "org.freedesktop.DockItem", "MenuItemActivated")) {
 
3682
                        _dbus_handle_dock_item_dbus_interface_menu_item_activated (user_data, connection, message);
 
3683
                }
 
3684
        }
 
3685
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
3686
}
 
3687
 
 
3688
 
 
3689
static void dock_item_dbus_interface_dbus_proxy_dispose (GObject* self) {
 
3690
        DBusGConnection *connection;
 
3691
        if (((DockItemDBusInterfaceDBusProxy*) self)->disposed) {
 
3692
                return;
 
3693
        }
 
3694
        ((DockItemDBusInterfaceDBusProxy*) self)->disposed = TRUE;
 
3695
        g_object_get (self, "connection", &connection, NULL);
 
3696
        dbus_connection_remove_filter (dbus_g_connection_get_connection (connection), dock_item_dbus_interface_dbus_proxy_filter, self);
 
3697
        G_OBJECT_CLASS (dock_item_dbus_interface_dbus_proxy_parent_class)->dispose (self);
 
3698
}
 
3699
 
 
3700
 
 
3701
static void dock_item_dbus_interface_dbus_proxy_class_init (DockItemDBusInterfaceDBusProxyClass* klass) {
 
3702
        G_OBJECT_CLASS (klass)->constructor = dock_item_dbus_interface_dbus_proxy_construct;
 
3703
        G_OBJECT_CLASS (klass)->dispose = dock_item_dbus_interface_dbus_proxy_dispose;
 
3704
        G_OBJECT_CLASS (klass)->get_property = dock_item_dbus_interface_dbus_proxy_get_property;
 
3705
        G_OBJECT_CLASS (klass)->set_property = dock_item_dbus_interface_dbus_proxy_set_property;
 
3706
        g_object_class_override_property (G_OBJECT_CLASS (klass), DOCK_ITEM_DBUS_INTERFACE_DBUS_PROXY_DESKTOP_FILE, "desktop-file");
 
3707
        g_object_class_override_property (G_OBJECT_CLASS (klass), DOCK_ITEM_DBUS_INTERFACE_DBUS_PROXY_URI, "uri");
 
3708
}
 
3709
 
 
3710
 
 
3711
static void dock_item_dbus_interface_dbus_proxy_init (DockItemDBusInterfaceDBusProxy* self) {
 
3712
}
 
3713
 
 
3714
 
 
3715
static gint dock_item_dbus_interface_dbus_proxy_add_menu_item (DockItemDBusInterface* self, GHashTable* menu_hints, GError** error) {
 
3716
        DBusError _dbus_error;
 
3717
        DBusGConnection *_connection;
 
3718
        DBusMessage *_message, *_reply;
 
3719
        DBusMessageIter _iter;
 
3720
        DBusMessageIter _tmp115_, _tmp116_;
 
3721
        GHashTableIter _tmp117_;
 
3722
        gpointer _tmp118_, _tmp119_;
 
3723
        gint _result;
 
3724
        dbus_int32_t _tmp130_;
 
3725
        if (((DockItemDBusInterfaceDBusProxy*) self)->disposed) {
 
3726
                g_set_error_literal (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "Connection is closed");
 
3727
                return 0;
 
3728
        }
 
3729
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.DockItem", "AddMenuItem");
 
3730
        dbus_message_iter_init_append (_message, &_iter);
 
3731
        dbus_message_iter_open_container (&_iter, DBUS_TYPE_ARRAY, "{sv}", &_tmp115_);
 
3732
        g_hash_table_iter_init (&_tmp117_, menu_hints);
 
3733
        while (g_hash_table_iter_next (&_tmp117_, &_tmp118_, &_tmp119_)) {
 
3734
                char* _key;
 
3735
                GValue* _value;
 
3736
                const char* _tmp120_;
 
3737
                DBusMessageIter _tmp121_;
 
3738
                dbus_message_iter_open_container (&_tmp115_, DBUS_TYPE_DICT_ENTRY, NULL, &_tmp116_);
 
3739
                _key = (char*) _tmp118_;
 
3740
                _value = (GValue*) _tmp119_;
 
3741
                _tmp120_ = _key;
 
3742
                dbus_message_iter_append_basic (&_tmp116_, DBUS_TYPE_STRING, &_tmp120_);
 
3743
                if (G_VALUE_TYPE (_value) == G_TYPE_UCHAR) {
 
3744
                        guint8 _tmp122_;
 
3745
                        dbus_message_iter_open_container (&_tmp116_, DBUS_TYPE_VARIANT, "y", &_tmp121_);
 
3746
                        _tmp122_ = g_value_get_uchar (_value);
 
3747
                        dbus_message_iter_append_basic (&_tmp121_, DBUS_TYPE_BYTE, &_tmp122_);
 
3748
                        dbus_message_iter_close_container (&_tmp116_, &_tmp121_);
 
3749
                } else if (G_VALUE_TYPE (_value) == G_TYPE_BOOLEAN) {
 
3750
                        dbus_bool_t _tmp123_;
 
3751
                        dbus_message_iter_open_container (&_tmp116_, DBUS_TYPE_VARIANT, "b", &_tmp121_);
 
3752
                        _tmp123_ = g_value_get_boolean (_value);
 
3753
                        dbus_message_iter_append_basic (&_tmp121_, DBUS_TYPE_BOOLEAN, &_tmp123_);
 
3754
                        dbus_message_iter_close_container (&_tmp116_, &_tmp121_);
 
3755
                } else if (G_VALUE_TYPE (_value) == G_TYPE_INT) {
 
3756
                        dbus_int32_t _tmp124_;
 
3757
                        dbus_message_iter_open_container (&_tmp116_, DBUS_TYPE_VARIANT, "i", &_tmp121_);
 
3758
                        _tmp124_ = g_value_get_int (_value);
 
3759
                        dbus_message_iter_append_basic (&_tmp121_, DBUS_TYPE_INT32, &_tmp124_);
 
3760
                        dbus_message_iter_close_container (&_tmp116_, &_tmp121_);
 
3761
                } else if (G_VALUE_TYPE (_value) == G_TYPE_UINT) {
 
3762
                        dbus_uint32_t _tmp125_;
 
3763
                        dbus_message_iter_open_container (&_tmp116_, DBUS_TYPE_VARIANT, "u", &_tmp121_);
 
3764
                        _tmp125_ = g_value_get_uint (_value);
 
3765
                        dbus_message_iter_append_basic (&_tmp121_, DBUS_TYPE_UINT32, &_tmp125_);
 
3766
                        dbus_message_iter_close_container (&_tmp116_, &_tmp121_);
 
3767
                } else if (G_VALUE_TYPE (_value) == G_TYPE_INT64) {
 
3768
                        dbus_int64_t _tmp126_;
 
3769
                        dbus_message_iter_open_container (&_tmp116_, DBUS_TYPE_VARIANT, "x", &_tmp121_);
 
3770
                        _tmp126_ = g_value_get_int64 (_value);
 
3771
                        dbus_message_iter_append_basic (&_tmp121_, DBUS_TYPE_INT64, &_tmp126_);
 
3772
                        dbus_message_iter_close_container (&_tmp116_, &_tmp121_);
 
3773
                } else if (G_VALUE_TYPE (_value) == G_TYPE_UINT64) {
 
3774
                        dbus_uint64_t _tmp127_;
 
3775
                        dbus_message_iter_open_container (&_tmp116_, DBUS_TYPE_VARIANT, "t", &_tmp121_);
 
3776
                        _tmp127_ = g_value_get_uint64 (_value);
 
3777
                        dbus_message_iter_append_basic (&_tmp121_, DBUS_TYPE_UINT64, &_tmp127_);
 
3778
                        dbus_message_iter_close_container (&_tmp116_, &_tmp121_);
 
3779
                } else if (G_VALUE_TYPE (_value) == G_TYPE_DOUBLE) {
 
3780
                        double _tmp128_;
 
3781
                        dbus_message_iter_open_container (&_tmp116_, DBUS_TYPE_VARIANT, "d", &_tmp121_);
 
3782
                        _tmp128_ = g_value_get_double (_value);
 
3783
                        dbus_message_iter_append_basic (&_tmp121_, DBUS_TYPE_DOUBLE, &_tmp128_);
 
3784
                        dbus_message_iter_close_container (&_tmp116_, &_tmp121_);
 
3785
                } else if (G_VALUE_TYPE (_value) == G_TYPE_STRING) {
 
3786
                        const char* _tmp129_;
 
3787
                        dbus_message_iter_open_container (&_tmp116_, DBUS_TYPE_VARIANT, "s", &_tmp121_);
 
3788
                        _tmp129_ = g_value_get_string (_value);
 
3789
                        dbus_message_iter_append_basic (&_tmp121_, DBUS_TYPE_STRING, &_tmp129_);
 
3790
                        dbus_message_iter_close_container (&_tmp116_, &_tmp121_);
 
3791
                }
 
3792
                dbus_message_iter_close_container (&_tmp115_, &_tmp116_);
 
3793
        }
 
3794
        dbus_message_iter_close_container (&_iter, &_tmp115_);
 
3795
        g_object_get (self, "connection", &_connection, NULL);
 
3796
        dbus_error_init (&_dbus_error);
 
3797
        _reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);
 
3798
        dbus_g_connection_unref (_connection);
 
3799
        dbus_message_unref (_message);
 
3800
        if (dbus_error_is_set (&_dbus_error)) {
 
3801
                GQuark _edomain;
 
3802
                gint _ecode;
 
3803
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
3804
                        const char* _tmp131_;
 
3805
                        _edomain = DBUS_GERROR;
 
3806
                        _tmp131_ = _dbus_error.name + 27;
 
3807
                        if (strcmp (_tmp131_, "Failed") == 0) {
 
3808
                                _ecode = DBUS_GERROR_FAILED;
 
3809
                        } else if (strcmp (_tmp131_, "NoMemory") == 0) {
 
3810
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
3811
                        } else if (strcmp (_tmp131_, "ServiceUnknown") == 0) {
 
3812
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
3813
                        } else if (strcmp (_tmp131_, "NameHasNoOwner") == 0) {
 
3814
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
3815
                        } else if (strcmp (_tmp131_, "NoReply") == 0) {
 
3816
                                _ecode = DBUS_GERROR_NO_REPLY;
 
3817
                        } else if (strcmp (_tmp131_, "IOError") == 0) {
 
3818
                                _ecode = DBUS_GERROR_IO_ERROR;
 
3819
                        } else if (strcmp (_tmp131_, "BadAddress") == 0) {
 
3820
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
3821
                        } else if (strcmp (_tmp131_, "NotSupported") == 0) {
 
3822
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
3823
                        } else if (strcmp (_tmp131_, "LimitsExceeded") == 0) {
 
3824
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
3825
                        } else if (strcmp (_tmp131_, "AccessDenied") == 0) {
 
3826
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
3827
                        } else if (strcmp (_tmp131_, "AuthFailed") == 0) {
 
3828
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
3829
                        } else if (strcmp (_tmp131_, "NoServer") == 0) {
 
3830
                                _ecode = DBUS_GERROR_NO_SERVER;
 
3831
                        } else if (strcmp (_tmp131_, "Timeout") == 0) {
 
3832
                                _ecode = DBUS_GERROR_TIMEOUT;
 
3833
                        } else if (strcmp (_tmp131_, "NoNetwork") == 0) {
 
3834
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
3835
                        } else if (strcmp (_tmp131_, "AddressInUse") == 0) {
 
3836
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
3837
                        } else if (strcmp (_tmp131_, "Disconnected") == 0) {
 
3838
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
3839
                        } else if (strcmp (_tmp131_, "InvalidArgs") == 0) {
 
3840
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
3841
                        } else if (strcmp (_tmp131_, "FileNotFound") == 0) {
 
3842
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
3843
                        } else if (strcmp (_tmp131_, "FileExists") == 0) {
 
3844
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
3845
                        } else if (strcmp (_tmp131_, "UnknownMethod") == 0) {
 
3846
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
3847
                        } else if (strcmp (_tmp131_, "TimedOut") == 0) {
 
3848
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
3849
                        } else if (strcmp (_tmp131_, "MatchRuleNotFound") == 0) {
 
3850
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
3851
                        } else if (strcmp (_tmp131_, "MatchRuleInvalid") == 0) {
 
3852
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
3853
                        } else if (strcmp (_tmp131_, "Spawn.ExecFailed") == 0) {
 
3854
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
3855
                        } else if (strcmp (_tmp131_, "Spawn.ForkFailed") == 0) {
 
3856
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
3857
                        } else if (strcmp (_tmp131_, "Spawn.ChildExited") == 0) {
 
3858
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
3859
                        } else if (strcmp (_tmp131_, "Spawn.ChildSignaled") == 0) {
 
3860
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
3861
                        } else if (strcmp (_tmp131_, "Spawn.Failed") == 0) {
 
3862
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
3863
                        } else if (strcmp (_tmp131_, "UnixProcessIdUnknown") == 0) {
 
3864
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
3865
                        } else if (strcmp (_tmp131_, "InvalidSignature") == 0) {
 
3866
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
3867
                        } else if (strcmp (_tmp131_, "InvalidFileContent") == 0) {
 
3868
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
3869
                        } else if (strcmp (_tmp131_, "SELinuxSecurityContextUnknown") == 0) {
 
3870
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
3871
                        } else if (strcmp (_tmp131_, "RemoteException") == 0) {
 
3872
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
3873
                        }
 
3874
                }
 
3875
                g_set_error_literal (error, _edomain, _ecode, _dbus_error.message);
 
3876
                dbus_error_free (&_dbus_error);
 
3877
                return 0;
 
3878
        }
 
3879
        if (strcmp (dbus_message_get_signature (_reply), "i")) {
 
3880
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "i", dbus_message_get_signature (_reply));
 
3881
                dbus_message_unref (_reply);
 
3882
                return 0;
 
3883
        }
 
3884
        dbus_message_iter_init (_reply, &_iter);
 
3885
        dbus_message_iter_get_basic (&_iter, &_tmp130_);
 
3886
        dbus_message_iter_next (&_iter);
 
3887
        _result = _tmp130_;
 
3888
        dbus_message_unref (_reply);
 
3889
        return _result;
 
3890
}
 
3891
 
 
3892
 
 
3893
static void dock_item_dbus_interface_dbus_proxy_remove_menu_item (DockItemDBusInterface* self, gint id, GError** error) {
 
3894
        DBusError _dbus_error;
 
3895
        DBusGConnection *_connection;
 
3896
        DBusMessage *_message, *_reply;
 
3897
        DBusMessageIter _iter;
 
3898
        dbus_int32_t _tmp132_;
 
3899
        if (((DockItemDBusInterfaceDBusProxy*) self)->disposed) {
 
3900
                g_set_error_literal (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "Connection is closed");
 
3901
                return;
 
3902
        }
 
3903
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.DockItem", "RemoveMenuItem");
 
3904
        dbus_message_iter_init_append (_message, &_iter);
 
3905
        _tmp132_ = id;
 
3906
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_INT32, &_tmp132_);
 
3907
        g_object_get (self, "connection", &_connection, NULL);
 
3908
        dbus_error_init (&_dbus_error);
 
3909
        _reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);
 
3910
        dbus_g_connection_unref (_connection);
 
3911
        dbus_message_unref (_message);
 
3912
        if (dbus_error_is_set (&_dbus_error)) {
 
3913
                GQuark _edomain;
 
3914
                gint _ecode;
 
3915
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
3916
                        const char* _tmp133_;
 
3917
                        _edomain = DBUS_GERROR;
 
3918
                        _tmp133_ = _dbus_error.name + 27;
 
3919
                        if (strcmp (_tmp133_, "Failed") == 0) {
 
3920
                                _ecode = DBUS_GERROR_FAILED;
 
3921
                        } else if (strcmp (_tmp133_, "NoMemory") == 0) {
 
3922
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
3923
                        } else if (strcmp (_tmp133_, "ServiceUnknown") == 0) {
 
3924
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
3925
                        } else if (strcmp (_tmp133_, "NameHasNoOwner") == 0) {
 
3926
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
3927
                        } else if (strcmp (_tmp133_, "NoReply") == 0) {
 
3928
                                _ecode = DBUS_GERROR_NO_REPLY;
 
3929
                        } else if (strcmp (_tmp133_, "IOError") == 0) {
 
3930
                                _ecode = DBUS_GERROR_IO_ERROR;
 
3931
                        } else if (strcmp (_tmp133_, "BadAddress") == 0) {
 
3932
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
3933
                        } else if (strcmp (_tmp133_, "NotSupported") == 0) {
 
3934
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
3935
                        } else if (strcmp (_tmp133_, "LimitsExceeded") == 0) {
 
3936
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
3937
                        } else if (strcmp (_tmp133_, "AccessDenied") == 0) {
 
3938
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
3939
                        } else if (strcmp (_tmp133_, "AuthFailed") == 0) {
 
3940
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
3941
                        } else if (strcmp (_tmp133_, "NoServer") == 0) {
 
3942
                                _ecode = DBUS_GERROR_NO_SERVER;
 
3943
                        } else if (strcmp (_tmp133_, "Timeout") == 0) {
 
3944
                                _ecode = DBUS_GERROR_TIMEOUT;
 
3945
                        } else if (strcmp (_tmp133_, "NoNetwork") == 0) {
 
3946
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
3947
                        } else if (strcmp (_tmp133_, "AddressInUse") == 0) {
 
3948
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
3949
                        } else if (strcmp (_tmp133_, "Disconnected") == 0) {
 
3950
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
3951
                        } else if (strcmp (_tmp133_, "InvalidArgs") == 0) {
 
3952
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
3953
                        } else if (strcmp (_tmp133_, "FileNotFound") == 0) {
 
3954
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
3955
                        } else if (strcmp (_tmp133_, "FileExists") == 0) {
 
3956
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
3957
                        } else if (strcmp (_tmp133_, "UnknownMethod") == 0) {
 
3958
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
3959
                        } else if (strcmp (_tmp133_, "TimedOut") == 0) {
 
3960
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
3961
                        } else if (strcmp (_tmp133_, "MatchRuleNotFound") == 0) {
 
3962
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
3963
                        } else if (strcmp (_tmp133_, "MatchRuleInvalid") == 0) {
 
3964
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
3965
                        } else if (strcmp (_tmp133_, "Spawn.ExecFailed") == 0) {
 
3966
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
3967
                        } else if (strcmp (_tmp133_, "Spawn.ForkFailed") == 0) {
 
3968
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
3969
                        } else if (strcmp (_tmp133_, "Spawn.ChildExited") == 0) {
 
3970
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
3971
                        } else if (strcmp (_tmp133_, "Spawn.ChildSignaled") == 0) {
 
3972
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
3973
                        } else if (strcmp (_tmp133_, "Spawn.Failed") == 0) {
 
3974
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
3975
                        } else if (strcmp (_tmp133_, "UnixProcessIdUnknown") == 0) {
 
3976
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
3977
                        } else if (strcmp (_tmp133_, "InvalidSignature") == 0) {
 
3978
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
3979
                        } else if (strcmp (_tmp133_, "InvalidFileContent") == 0) {
 
3980
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
3981
                        } else if (strcmp (_tmp133_, "SELinuxSecurityContextUnknown") == 0) {
 
3982
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
3983
                        } else if (strcmp (_tmp133_, "RemoteException") == 0) {
 
3984
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
3985
                        }
 
3986
                }
 
3987
                g_set_error_literal (error, _edomain, _ecode, _dbus_error.message);
 
3988
                dbus_error_free (&_dbus_error);
 
3989
                return;
 
3990
        }
 
3991
        if (strcmp (dbus_message_get_signature (_reply), "")) {
 
3992
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "", dbus_message_get_signature (_reply));
 
3993
                dbus_message_unref (_reply);
 
3994
                return;
 
3995
        }
 
3996
        dbus_message_iter_init (_reply, &_iter);
 
3997
        dbus_message_unref (_reply);
 
3998
}
 
3999
 
 
4000
 
 
4001
static void dock_item_dbus_interface_dbus_proxy_update_dock_item (DockItemDBusInterface* self, GHashTable* hints, GError** error) {
 
4002
        DBusError _dbus_error;
 
4003
        DBusGConnection *_connection;
 
4004
        DBusMessage *_message, *_reply;
 
4005
        DBusMessageIter _iter;
 
4006
        DBusMessageIter _tmp134_, _tmp135_;
 
4007
        GHashTableIter _tmp136_;
 
4008
        gpointer _tmp137_, _tmp138_;
 
4009
        if (((DockItemDBusInterfaceDBusProxy*) self)->disposed) {
 
4010
                g_set_error_literal (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "Connection is closed");
 
4011
                return;
 
4012
        }
 
4013
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.DockItem", "UpdateDockItem");
 
4014
        dbus_message_iter_init_append (_message, &_iter);
 
4015
        dbus_message_iter_open_container (&_iter, DBUS_TYPE_ARRAY, "{sv}", &_tmp134_);
 
4016
        g_hash_table_iter_init (&_tmp136_, hints);
 
4017
        while (g_hash_table_iter_next (&_tmp136_, &_tmp137_, &_tmp138_)) {
 
4018
                char* _key;
 
4019
                GValue* _value;
 
4020
                const char* _tmp139_;
 
4021
                DBusMessageIter _tmp140_;
 
4022
                dbus_message_iter_open_container (&_tmp134_, DBUS_TYPE_DICT_ENTRY, NULL, &_tmp135_);
 
4023
                _key = (char*) _tmp137_;
 
4024
                _value = (GValue*) _tmp138_;
 
4025
                _tmp139_ = _key;
 
4026
                dbus_message_iter_append_basic (&_tmp135_, DBUS_TYPE_STRING, &_tmp139_);
 
4027
                if (G_VALUE_TYPE (_value) == G_TYPE_UCHAR) {
 
4028
                        guint8 _tmp141_;
 
4029
                        dbus_message_iter_open_container (&_tmp135_, DBUS_TYPE_VARIANT, "y", &_tmp140_);
 
4030
                        _tmp141_ = g_value_get_uchar (_value);
 
4031
                        dbus_message_iter_append_basic (&_tmp140_, DBUS_TYPE_BYTE, &_tmp141_);
 
4032
                        dbus_message_iter_close_container (&_tmp135_, &_tmp140_);
 
4033
                } else if (G_VALUE_TYPE (_value) == G_TYPE_BOOLEAN) {
 
4034
                        dbus_bool_t _tmp142_;
 
4035
                        dbus_message_iter_open_container (&_tmp135_, DBUS_TYPE_VARIANT, "b", &_tmp140_);
 
4036
                        _tmp142_ = g_value_get_boolean (_value);
 
4037
                        dbus_message_iter_append_basic (&_tmp140_, DBUS_TYPE_BOOLEAN, &_tmp142_);
 
4038
                        dbus_message_iter_close_container (&_tmp135_, &_tmp140_);
 
4039
                } else if (G_VALUE_TYPE (_value) == G_TYPE_INT) {
 
4040
                        dbus_int32_t _tmp143_;
 
4041
                        dbus_message_iter_open_container (&_tmp135_, DBUS_TYPE_VARIANT, "i", &_tmp140_);
 
4042
                        _tmp143_ = g_value_get_int (_value);
 
4043
                        dbus_message_iter_append_basic (&_tmp140_, DBUS_TYPE_INT32, &_tmp143_);
 
4044
                        dbus_message_iter_close_container (&_tmp135_, &_tmp140_);
 
4045
                } else if (G_VALUE_TYPE (_value) == G_TYPE_UINT) {
 
4046
                        dbus_uint32_t _tmp144_;
 
4047
                        dbus_message_iter_open_container (&_tmp135_, DBUS_TYPE_VARIANT, "u", &_tmp140_);
 
4048
                        _tmp144_ = g_value_get_uint (_value);
 
4049
                        dbus_message_iter_append_basic (&_tmp140_, DBUS_TYPE_UINT32, &_tmp144_);
 
4050
                        dbus_message_iter_close_container (&_tmp135_, &_tmp140_);
 
4051
                } else if (G_VALUE_TYPE (_value) == G_TYPE_INT64) {
 
4052
                        dbus_int64_t _tmp145_;
 
4053
                        dbus_message_iter_open_container (&_tmp135_, DBUS_TYPE_VARIANT, "x", &_tmp140_);
 
4054
                        _tmp145_ = g_value_get_int64 (_value);
 
4055
                        dbus_message_iter_append_basic (&_tmp140_, DBUS_TYPE_INT64, &_tmp145_);
 
4056
                        dbus_message_iter_close_container (&_tmp135_, &_tmp140_);
 
4057
                } else if (G_VALUE_TYPE (_value) == G_TYPE_UINT64) {
 
4058
                        dbus_uint64_t _tmp146_;
 
4059
                        dbus_message_iter_open_container (&_tmp135_, DBUS_TYPE_VARIANT, "t", &_tmp140_);
 
4060
                        _tmp146_ = g_value_get_uint64 (_value);
 
4061
                        dbus_message_iter_append_basic (&_tmp140_, DBUS_TYPE_UINT64, &_tmp146_);
 
4062
                        dbus_message_iter_close_container (&_tmp135_, &_tmp140_);
 
4063
                } else if (G_VALUE_TYPE (_value) == G_TYPE_DOUBLE) {
 
4064
                        double _tmp147_;
 
4065
                        dbus_message_iter_open_container (&_tmp135_, DBUS_TYPE_VARIANT, "d", &_tmp140_);
 
4066
                        _tmp147_ = g_value_get_double (_value);
 
4067
                        dbus_message_iter_append_basic (&_tmp140_, DBUS_TYPE_DOUBLE, &_tmp147_);
 
4068
                        dbus_message_iter_close_container (&_tmp135_, &_tmp140_);
 
4069
                } else if (G_VALUE_TYPE (_value) == G_TYPE_STRING) {
 
4070
                        const char* _tmp148_;
 
4071
                        dbus_message_iter_open_container (&_tmp135_, DBUS_TYPE_VARIANT, "s", &_tmp140_);
 
4072
                        _tmp148_ = g_value_get_string (_value);
 
4073
                        dbus_message_iter_append_basic (&_tmp140_, DBUS_TYPE_STRING, &_tmp148_);
 
4074
                        dbus_message_iter_close_container (&_tmp135_, &_tmp140_);
 
4075
                }
 
4076
                dbus_message_iter_close_container (&_tmp134_, &_tmp135_);
 
4077
        }
 
4078
        dbus_message_iter_close_container (&_iter, &_tmp134_);
 
4079
        g_object_get (self, "connection", &_connection, NULL);
 
4080
        dbus_error_init (&_dbus_error);
 
4081
        _reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);
 
4082
        dbus_g_connection_unref (_connection);
 
4083
        dbus_message_unref (_message);
 
4084
        if (dbus_error_is_set (&_dbus_error)) {
 
4085
                GQuark _edomain;
 
4086
                gint _ecode;
 
4087
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
4088
                        const char* _tmp149_;
 
4089
                        _edomain = DBUS_GERROR;
 
4090
                        _tmp149_ = _dbus_error.name + 27;
 
4091
                        if (strcmp (_tmp149_, "Failed") == 0) {
 
4092
                                _ecode = DBUS_GERROR_FAILED;
 
4093
                        } else if (strcmp (_tmp149_, "NoMemory") == 0) {
 
4094
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
4095
                        } else if (strcmp (_tmp149_, "ServiceUnknown") == 0) {
 
4096
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
4097
                        } else if (strcmp (_tmp149_, "NameHasNoOwner") == 0) {
 
4098
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
4099
                        } else if (strcmp (_tmp149_, "NoReply") == 0) {
 
4100
                                _ecode = DBUS_GERROR_NO_REPLY;
 
4101
                        } else if (strcmp (_tmp149_, "IOError") == 0) {
 
4102
                                _ecode = DBUS_GERROR_IO_ERROR;
 
4103
                        } else if (strcmp (_tmp149_, "BadAddress") == 0) {
 
4104
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
4105
                        } else if (strcmp (_tmp149_, "NotSupported") == 0) {
 
4106
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
4107
                        } else if (strcmp (_tmp149_, "LimitsExceeded") == 0) {
 
4108
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
4109
                        } else if (strcmp (_tmp149_, "AccessDenied") == 0) {
 
4110
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
4111
                        } else if (strcmp (_tmp149_, "AuthFailed") == 0) {
 
4112
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
4113
                        } else if (strcmp (_tmp149_, "NoServer") == 0) {
 
4114
                                _ecode = DBUS_GERROR_NO_SERVER;
 
4115
                        } else if (strcmp (_tmp149_, "Timeout") == 0) {
 
4116
                                _ecode = DBUS_GERROR_TIMEOUT;
 
4117
                        } else if (strcmp (_tmp149_, "NoNetwork") == 0) {
 
4118
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
4119
                        } else if (strcmp (_tmp149_, "AddressInUse") == 0) {
 
4120
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
4121
                        } else if (strcmp (_tmp149_, "Disconnected") == 0) {
 
4122
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
4123
                        } else if (strcmp (_tmp149_, "InvalidArgs") == 0) {
 
4124
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
4125
                        } else if (strcmp (_tmp149_, "FileNotFound") == 0) {
 
4126
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
4127
                        } else if (strcmp (_tmp149_, "FileExists") == 0) {
 
4128
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
4129
                        } else if (strcmp (_tmp149_, "UnknownMethod") == 0) {
 
4130
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
4131
                        } else if (strcmp (_tmp149_, "TimedOut") == 0) {
 
4132
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
4133
                        } else if (strcmp (_tmp149_, "MatchRuleNotFound") == 0) {
 
4134
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
4135
                        } else if (strcmp (_tmp149_, "MatchRuleInvalid") == 0) {
 
4136
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
4137
                        } else if (strcmp (_tmp149_, "Spawn.ExecFailed") == 0) {
 
4138
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
4139
                        } else if (strcmp (_tmp149_, "Spawn.ForkFailed") == 0) {
 
4140
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
4141
                        } else if (strcmp (_tmp149_, "Spawn.ChildExited") == 0) {
 
4142
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
4143
                        } else if (strcmp (_tmp149_, "Spawn.ChildSignaled") == 0) {
 
4144
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
4145
                        } else if (strcmp (_tmp149_, "Spawn.Failed") == 0) {
 
4146
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
4147
                        } else if (strcmp (_tmp149_, "UnixProcessIdUnknown") == 0) {
 
4148
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
4149
                        } else if (strcmp (_tmp149_, "InvalidSignature") == 0) {
 
4150
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
4151
                        } else if (strcmp (_tmp149_, "InvalidFileContent") == 0) {
 
4152
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
4153
                        } else if (strcmp (_tmp149_, "SELinuxSecurityContextUnknown") == 0) {
 
4154
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
4155
                        } else if (strcmp (_tmp149_, "RemoteException") == 0) {
 
4156
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
4157
                        }
 
4158
                }
 
4159
                g_set_error_literal (error, _edomain, _ecode, _dbus_error.message);
 
4160
                dbus_error_free (&_dbus_error);
 
4161
                return;
 
4162
        }
 
4163
        if (strcmp (dbus_message_get_signature (_reply), "")) {
 
4164
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "", dbus_message_get_signature (_reply));
 
4165
                dbus_message_unref (_reply);
 
4166
                return;
 
4167
        }
 
4168
        dbus_message_iter_init (_reply, &_iter);
 
4169
        dbus_message_unref (_reply);
 
4170
}
 
4171
 
 
4172
 
 
4173
static char* dock_item_dbus_interface_dbus_proxy_get_desktop_file (DockItemDBusInterface* self) {
 
4174
        DBusGConnection *_connection;
 
4175
        DBusMessage *_message, *_reply;
 
4176
        DBusMessageIter _iter, _subiter;
 
4177
        const char* _tmp150_;
 
4178
        const char* _tmp151_;
 
4179
        char* _result;
 
4180
        const char* _tmp152_;
 
4181
        if (((DockItemDBusInterfaceDBusProxy*) self)->disposed) {
 
4182
                return NULL;
 
4183
        }
 
4184
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.DBus.Properties", "Get");
 
4185
        dbus_message_iter_init_append (_message, &_iter);
 
4186
        _tmp150_ = "org.freedesktop.DockItem";
 
4187
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_STRING, &_tmp150_);
 
4188
        _tmp151_ = "DesktopFile";
 
4189
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_STRING, &_tmp151_);
 
4190
        g_object_get (self, "connection", &_connection, NULL);
 
4191
        _reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, NULL);
 
4192
        dbus_g_connection_unref (_connection);
 
4193
        dbus_message_unref (_message);
 
4194
        dbus_message_iter_init (_reply, &_iter);
 
4195
        dbus_message_iter_recurse (&_iter, &_subiter);
 
4196
        dbus_message_iter_get_basic (&_subiter, &_tmp152_);
 
4197
        dbus_message_iter_next (&_subiter);
 
4198
        _result = g_strdup (_tmp152_);
 
4199
        dbus_message_unref (_reply);
 
4200
        return _result;
 
4201
}
 
4202
 
 
4203
 
 
4204
static char* dock_item_dbus_interface_dbus_proxy_get_uri (DockItemDBusInterface* self) {
 
4205
        DBusGConnection *_connection;
 
4206
        DBusMessage *_message, *_reply;
 
4207
        DBusMessageIter _iter, _subiter;
 
4208
        const char* _tmp153_;
 
4209
        const char* _tmp154_;
 
4210
        char* _result;
 
4211
        const char* _tmp155_;
 
4212
        if (((DockItemDBusInterfaceDBusProxy*) self)->disposed) {
 
4213
                return NULL;
 
4214
        }
 
4215
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.DBus.Properties", "Get");
 
4216
        dbus_message_iter_init_append (_message, &_iter);
 
4217
        _tmp153_ = "org.freedesktop.DockItem";
 
4218
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_STRING, &_tmp153_);
 
4219
        _tmp154_ = "Uri";
 
4220
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_STRING, &_tmp154_);
 
4221
        g_object_get (self, "connection", &_connection, NULL);
 
4222
        _reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, NULL);
 
4223
        dbus_g_connection_unref (_connection);
 
4224
        dbus_message_unref (_message);
 
4225
        dbus_message_iter_init (_reply, &_iter);
 
4226
        dbus_message_iter_recurse (&_iter, &_subiter);
 
4227
        dbus_message_iter_get_basic (&_subiter, &_tmp155_);
 
4228
        dbus_message_iter_next (&_subiter);
 
4229
        _result = g_strdup (_tmp155_);
 
4230
        dbus_message_unref (_reply);
 
4231
        return _result;
 
4232
}
 
4233
 
 
4234
 
 
4235
static void dock_item_dbus_interface_dbus_proxy_dock_item_dbus_interface__interface_init (DockItemDBusInterfaceIface* iface) {
 
4236
        iface->add_menu_item = dock_item_dbus_interface_dbus_proxy_add_menu_item;
 
4237
        iface->remove_menu_item = dock_item_dbus_interface_dbus_proxy_remove_menu_item;
 
4238
        iface->update_dock_item = dock_item_dbus_interface_dbus_proxy_update_dock_item;
 
4239
        iface->get_desktop_file = dock_item_dbus_interface_dbus_proxy_get_desktop_file;
 
4240
        iface->get_uri = dock_item_dbus_interface_dbus_proxy_get_uri;
 
4241
}
 
4242
 
 
4243
 
 
4244
static void dock_item_dbus_interface_dbus_proxy_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
4245
}
 
4246
 
 
4247
 
 
4248
static void dock_item_dbus_interface_dbus_proxy_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 
4249
}
 
4250
 
 
4251
 
 
4252
TaskManagerDispatcher* task_manager_dispatcher_construct (GType object_type, TaskManager* manager) {
 
4253
        GError * _inner_error_;
 
4254
        TaskManagerDispatcher * self;
 
4255
        DBusGConnection* conn;
 
4256
        char* obj_path;
 
4257
        g_return_val_if_fail (manager != NULL, NULL);
 
4258
        _inner_error_ = NULL;
 
4259
        self = (TaskManagerDispatcher*) g_object_new (object_type, "manager", manager, NULL);
 
4260
        conn = dbus_g_bus_get (DBUS_BUS_SESSION, &_inner_error_);
 
4261
        if (_inner_error_ != NULL) {
 
4262
                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);
 
4263
                g_clear_error (&_inner_error_);
 
4264
                return NULL;
 
4265
        }
 
4266
        obj_path = g_strdup ("/org/freedesktop/DockManager");
 
4267
        _vala_dbus_register_object (dbus_g_connection_get_connection (conn), obj_path, (GObject*) self);
 
4268
        _dbus_g_connection_unref0 (conn);
 
4269
        _g_free0 (obj_path);
 
4270
        return self;
 
4271
}
 
4272
 
 
4273
 
 
4274
TaskManagerDispatcher* task_manager_dispatcher_new (TaskManager* manager) {
 
4275
        return task_manager_dispatcher_construct (TYPE_TASK_MANAGER_DISPATCHER, manager);
 
4276
}
 
4277
 
 
4278
 
 
4279
static char** task_manager_dispatcher_list_to_object_path_array (GSList* list, int* result_length1) {
 
4280
        char** result;
 
4281
        char** _tmp1_;
 
4282
        gint _result__size;
 
4283
        gint _result__length1;
 
4284
        gint _tmp0_;
 
4285
        char** _result_;
 
4286
        gint i;
 
4287
        char** _tmp5_;
 
4288
        _result_ = (_tmp1_ = g_new0 (char*, (_tmp0_ = g_slist_length (list)) + 1), _result__length1 = _tmp0_, _result__size = _result__length1, _tmp1_);
 
4289
        i = 0;
 
4290
        {
 
4291
                GSList* icon_collection;
 
4292
                GSList* icon_it;
 
4293
                icon_collection = list;
 
4294
                for (icon_it = icon_collection; icon_it != NULL; icon_it = icon_it->next) {
 
4295
                        TaskIcon* icon;
 
4296
                        icon = (TaskIcon*) icon_it->data;
 
4297
                        {
 
4298
                                TaskIconDispatcher* dispatcher;
 
4299
                                GObject* _tmp2_;
 
4300
                                char* _tmp4_;
 
4301
                                char* *_tmp3_;
 
4302
                                dispatcher = NULL;
 
4303
                                dispatcher = (_tmp2_ = task_icon_get_dbus_dispatcher (icon), IS_TASK_ICON_DISPATCHER (_tmp2_) ? ((TaskIconDispatcher*) _tmp2_) : NULL);
 
4304
                                _tmp3_ = &_result_[i++];
 
4305
                                (*_tmp3_) = (_tmp4_ = g_strdup (task_icon_dispatcher_get_object_path (dispatcher)), _g_free0 ((*_tmp3_)), _tmp4_);
 
4306
                        }
 
4307
                }
 
4308
        }
 
4309
        result = (_tmp5_ = _result_, *result_length1 = _result__length1, _tmp5_);
 
4310
        return result;
 
4311
        _result_ = (_vala_array_free (_result_, _result__length1, (GDestroyNotify) g_free), NULL);
 
4312
}
 
4313
 
 
4314
 
 
4315
static char** task_manager_dispatcher_real_get_capabilities (DockManagerDBusInterface* base, int* result_length1, GError** error) {
 
4316
        TaskManagerDispatcher * self;
 
4317
        char** result;
 
4318
        char** _tmp1_;
 
4319
        gint capabilities_size;
 
4320
        gint capabilities_length1;
 
4321
        char** _tmp0_ = NULL;
 
4322
        char** capabilities;
 
4323
        char** _tmp2_;
 
4324
        self = (TaskManagerDispatcher*) base;
 
4325
        capabilities = (_tmp1_ = (_tmp0_ = g_new0 (char*, 2 + 1), _tmp0_[0] = g_strdup ("x-awn-set-visibility"), _tmp0_[1] = g_strdup ("x-awn-register-proxy-item"), _tmp0_), capabilities_length1 = 2, capabilities_size = capabilities_length1, _tmp1_);
 
4326
        result = (_tmp2_ = capabilities, *result_length1 = capabilities_length1, _tmp2_);
 
4327
        return result;
 
4328
        capabilities = (_vala_array_free (capabilities, capabilities_length1, (GDestroyNotify) g_free), NULL);
 
4329
}
 
4330
 
 
4331
 
 
4332
static char** task_manager_dispatcher_real_get_items (DockManagerDBusInterface* base, int* result_length1, GError** error) {
 
4333
        TaskManagerDispatcher * self;
 
4334
        char** result;
 
4335
        gint _tmp0_;
 
4336
        char** _tmp1_;
 
4337
        self = (TaskManagerDispatcher*) base;
 
4338
        result = (_tmp1_ = task_manager_dispatcher_list_to_object_path_array (task_manager_get_icons (self->priv->_manager), &_tmp0_), *result_length1 = _tmp0_, _tmp1_);
 
4339
        return result;
 
4340
}
 
4341
 
 
4342
 
 
4343
static char** task_manager_dispatcher_real_get_items_by_name (DockManagerDBusInterface* base, const char* name, int* result_length1, GError** error) {
 
4344
        TaskManagerDispatcher * self;
 
4345
        char** result;
 
4346
        GSList* icons;
 
4347
        GSList* matches;
 
4348
        gint _tmp1_;
 
4349
        char** _tmp2_;
 
4350
        self = (TaskManagerDispatcher*) base;
 
4351
        g_return_val_if_fail (name != NULL, NULL);
 
4352
        icons = task_manager_get_icons (self->priv->_manager);
 
4353
        matches = NULL;
 
4354
        {
 
4355
                GSList* icon_collection;
 
4356
                GSList* icon_it;
 
4357
                icon_collection = icons;
 
4358
                for (icon_it = icon_collection; icon_it != NULL; icon_it = icon_it->next) {
 
4359
                        TaskIcon* icon;
 
4360
                        icon = (TaskIcon*) icon_it->data;
 
4361
                        {
 
4362
                                {
 
4363
                                        GSList* item_collection;
 
4364
                                        GSList* item_it;
 
4365
                                        item_collection = task_icon_get_items (icon);
 
4366
                                        for (item_it = item_collection; item_it != NULL; item_it = item_it->next) {
 
4367
                                                TaskItem* item;
 
4368
                                                item = (TaskItem*) item_it->data;
 
4369
                                                {
 
4370
                                                        TaskItem* _tmp0_;
 
4371
                                                        TaskWindow* window;
 
4372
                                                        window = (_tmp0_ = item, TASK_IS_WINDOW (_tmp0_) ? ((TaskWindow*) _tmp0_) : NULL);
 
4373
                                                        if (window != NULL) {
 
4374
                                                                if (task_window_matches_wmclass (window, name)) {
 
4375
                                                                        matches = g_slist_append (matches, icon);
 
4376
                                                                        break;
 
4377
                                                                }
 
4378
                                                        }
 
4379
                                                }
 
4380
                                        }
 
4381
                                }
 
4382
                        }
 
4383
                }
 
4384
        }
 
4385
        result = (_tmp2_ = task_manager_dispatcher_list_to_object_path_array (matches, &_tmp1_), *result_length1 = _tmp1_, _tmp2_);
 
4386
        _g_slist_free0 (matches);
 
4387
        return result;
 
4388
        _g_slist_free0 (matches);
 
4389
}
 
4390
 
 
4391
 
 
4392
static char** task_manager_dispatcher_real_get_items_by_desktop_file (DockManagerDBusInterface* base, const char* desktop_file, int* result_length1, GError** error) {
 
4393
        TaskManagerDispatcher * self;
 
4394
        char** result;
 
4395
        GSList* icons;
 
4396
        GSList* matches;
 
4397
        gint _tmp1_;
 
4398
        char** _tmp2_;
 
4399
        self = (TaskManagerDispatcher*) base;
 
4400
        g_return_val_if_fail (desktop_file != NULL, NULL);
 
4401
        icons = task_manager_get_icons (self->priv->_manager);
 
4402
        matches = NULL;
 
4403
        {
 
4404
                GSList* icon_collection;
 
4405
                GSList* icon_it;
 
4406
                icon_collection = icons;
 
4407
                for (icon_it = icon_collection; icon_it != NULL; icon_it = icon_it->next) {
 
4408
                        TaskIcon* icon;
 
4409
                        icon = (TaskIcon*) icon_it->data;
 
4410
                        {
 
4411
                                TaskItem* _tmp0_;
 
4412
                                TaskLauncher* launcher;
 
4413
                                launcher = (_tmp0_ = task_icon_get_launcher (icon), TASK_IS_LAUNCHER (_tmp0_) ? ((TaskLauncher*) _tmp0_) : NULL);
 
4414
                                if (launcher != NULL) {
 
4415
                                        if (g_str_has_suffix (task_launcher_get_desktop_path (launcher), desktop_file)) {
 
4416
                                                matches = g_slist_append (matches, icon);
 
4417
                                        }
 
4418
                                }
 
4419
                        }
 
4420
                }
 
4421
        }
 
4422
        result = (_tmp2_ = task_manager_dispatcher_list_to_object_path_array (matches, &_tmp1_), *result_length1 = _tmp1_, _tmp2_);
 
4423
        _g_slist_free0 (matches);
 
4424
        return result;
 
4425
        _g_slist_free0 (matches);
 
4426
}
 
4427
 
 
4428
 
 
4429
static char** task_manager_dispatcher_real_get_items_by_pid (DockManagerDBusInterface* base, gint pid, int* result_length1, GError** error) {
 
4430
        TaskManagerDispatcher * self;
 
4431
        char** result;
 
4432
        GSList* icons;
 
4433
        GSList* matches;
 
4434
        gint _tmp1_;
 
4435
        char** _tmp2_;
 
4436
        self = (TaskManagerDispatcher*) base;
 
4437
        icons = task_manager_get_icons (self->priv->_manager);
 
4438
        matches = NULL;
 
4439
        {
 
4440
                GSList* icon_collection;
 
4441
                GSList* icon_it;
 
4442
                icon_collection = icons;
 
4443
                for (icon_it = icon_collection; icon_it != NULL; icon_it = icon_it->next) {
 
4444
                        TaskIcon* icon;
 
4445
                        icon = (TaskIcon*) icon_it->data;
 
4446
                        {
 
4447
                                {
 
4448
                                        GSList* item_collection;
 
4449
                                        GSList* item_it;
 
4450
                                        item_collection = task_icon_get_items (icon);
 
4451
                                        for (item_it = item_collection; item_it != NULL; item_it = item_it->next) {
 
4452
                                                TaskItem* item;
 
4453
                                                item = (TaskItem*) item_it->data;
 
4454
                                                {
 
4455
                                                        if (TASK_IS_WINDOW (item)) {
 
4456
                                                                TaskItem* _tmp0_;
 
4457
                                                                TaskWindow* window;
 
4458
                                                                window = (_tmp0_ = item, TASK_IS_WINDOW (_tmp0_) ? ((TaskWindow*) _tmp0_) : NULL);
 
4459
                                                                if (task_window_get_pid (window) == pid) {
 
4460
                                                                        matches = g_slist_append (matches, icon);
 
4461
                                                                        break;
 
4462
                                                                }
 
4463
                                                        }
 
4464
                                                }
 
4465
                                        }
 
4466
                                }
 
4467
                        }
 
4468
                }
 
4469
        }
 
4470
        result = (_tmp2_ = task_manager_dispatcher_list_to_object_path_array (matches, &_tmp1_), *result_length1 = _tmp1_, _tmp2_);
 
4471
        _g_slist_free0 (matches);
 
4472
        return result;
 
4473
        _g_slist_free0 (matches);
 
4474
}
 
4475
 
 
4476
 
 
4477
static char* task_manager_dispatcher_real_get_item_by_xid (DockManagerDBusInterface* base, gint64 xid, GError** error) {
 
4478
        TaskManagerDispatcher * self;
 
4479
        char* result;
 
4480
        TaskIcon* icon;
 
4481
        self = (TaskManagerDispatcher*) base;
 
4482
        icon = task_manager_get_icon_by_xid (self->priv->_manager, xid);
 
4483
        if (icon != NULL) {
 
4484
                TaskIconDispatcher* dispatcher;
 
4485
                GObject* _tmp0_;
 
4486
                dispatcher = NULL;
 
4487
                dispatcher = (_tmp0_ = task_icon_get_dbus_dispatcher (icon), IS_TASK_ICON_DISPATCHER (_tmp0_) ? ((TaskIconDispatcher*) _tmp0_) : NULL);
 
4488
                result = g_strdup (task_icon_dispatcher_get_object_path (dispatcher));
 
4489
                return result;
 
4490
        }
 
4491
        result = NULL;
 
4492
        return result;
 
4493
}
 
4494
 
 
4495
 
 
4496
static void task_manager_dispatcher_real_awn_set_visibility (DockManagerDBusInterface* base, const char* win_name, gboolean visible, GError** error) {
 
4497
        TaskManagerDispatcher * self;
 
4498
        GError * _inner_error_;
 
4499
        GHashTable* hints;
 
4500
        GHashTable* _tmp0_;
 
4501
        GValue* _tmp1_ = NULL;
 
4502
        GValue _tmp3_;
 
4503
        GValue _tmp2_ = {0};
 
4504
        self = (TaskManagerDispatcher*) base;
 
4505
        g_return_if_fail (win_name != NULL);
 
4506
        _inner_error_ = NULL;
 
4507
        hints = NULL;
 
4508
        hints = (_tmp0_ = g_hash_table_new (g_str_hash, g_str_equal), _g_hash_table_unref0 (hints), _tmp0_);
 
4509
        g_hash_table_insert (hints, g_strdup ("visible"), (_tmp1_ = g_new0 (GValue, 1), g_value_init (_tmp1_, G_TYPE_BOOLEAN), g_value_set_boolean (_tmp1_, visible), _tmp1_));
 
4510
        task_manager_update (self->priv->_manager, (_tmp3_ = (g_value_init (&_tmp2_, G_TYPE_STRING), g_value_set_string (&_tmp2_, win_name), _tmp2_), &_tmp3_), hints, &_inner_error_);
 
4511
        if (_inner_error_ != NULL) {
 
4512
                if (_inner_error_->domain == DBUS_GERROR) {
 
4513
                        g_propagate_error (error, _inner_error_);
 
4514
                        _g_hash_table_unref0 (hints);
 
4515
                        return;
 
4516
                } else {
 
4517
                        _g_hash_table_unref0 (hints);
 
4518
                        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);
 
4519
                        g_clear_error (&_inner_error_);
 
4520
                        return;
 
4521
                }
 
4522
        }
 
4523
        _g_hash_table_unref0 (hints);
 
4524
}
 
4525
 
 
4526
 
 
4527
static char* task_manager_dispatcher_real_awn_register_proxy_item (DockManagerDBusInterface* base, const char* desktop_file, const char* uri, GError** error) {
 
4528
        TaskManagerDispatcher * self;
 
4529
        char* result;
 
4530
        self = (TaskManagerDispatcher*) base;
 
4531
        g_return_val_if_fail (desktop_file != NULL, NULL);
 
4532
        g_return_val_if_fail (uri != NULL, NULL);
 
4533
        result = g_strdup ("/not/yet/implemented");
 
4534
        return result;
 
4535
}
 
4536
 
 
4537
 
 
4538
TaskManager* task_manager_dispatcher_get_manager (TaskManagerDispatcher* self) {
 
4539
        TaskManager* result;
 
4540
        g_return_val_if_fail (self != NULL, NULL);
 
4541
        result = self->priv->_manager;
 
4542
        return result;
 
4543
}
 
4544
 
 
4545
 
 
4546
static gpointer _g_object_ref0 (gpointer self) {
 
4547
        return self ? g_object_ref (self) : NULL;
 
4548
}
 
4549
 
 
4550
 
 
4551
static void task_manager_dispatcher_set_manager (TaskManagerDispatcher* self, TaskManager* value) {
 
4552
        TaskManager* _tmp0_;
 
4553
        g_return_if_fail (self != NULL);
 
4554
        self->priv->_manager = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_manager), _tmp0_);
 
4555
        g_object_notify ((GObject *) self, "manager");
 
4556
}
 
4557
 
 
4558
 
 
4559
void _task_manager_dispatcher_dbus_unregister (DBusConnection* connection, void* _user_data_) {
 
4560
}
 
4561
 
 
4562
 
 
4563
static DBusHandlerResult _dbus_task_manager_dispatcher_introspect (TaskManagerDispatcher* self, DBusConnection* connection, DBusMessage* message) {
 
4564
        DBusMessage* reply;
 
4565
        DBusMessageIter iter;
 
4566
        GString* xml_data;
 
4567
        char** children;
 
4568
        int i;
 
4569
        reply = dbus_message_new_method_return (message);
 
4570
        dbus_message_iter_init_append (reply, &iter);
 
4571
        xml_data = g_string_new ("<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" \"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n");
 
4572
        g_string_append (xml_data, "<node>\n<interface name=\"org.freedesktop.DBus.Introspectable\">\n  <method name=\"Introspect\">\n    <arg name=\"data\" direction=\"out\" type=\"s\"/>\n  </method>\n</interface>\n<interface name=\"org.freedesktop.DBus.Properties\">\n  <method name=\"Get\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n    <arg name=\"value\" direction=\"out\" type=\"v\"/>\n  </method>\n  <method name=\"Set\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n    <arg name=\"value\" direction=\"in\" type=\"v\"/>\n  </method>\n  <method name=\"GetAll\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"props\" direction=\"out\" type=\"a{sv}\"/>\n  </method>\n</interface>\n<interface name=\"org.freedesktop.DockManager\">\n  <method name=\"GetCapabilities\">\n    <arg name=\"result\" type=\"as\" direction=\"out\"/>\n  </method>\n  <method name=\"GetItems\">\n    <arg name=\"result\" type=\"ao\" direction=\"out\"/>\n  </method>\n  <method name=\"GetItemsByName\">\n    <arg name=\"name\" type=\"s\" direction=\"in\"/>\n    <arg name=\"result\" type=\"ao\" direction=\"out\"/>\n  </method>\n  <method name=\"GetItemsByDesktopFile\">\n    <arg name=\"desktop_file\" type=\"s\" direction=\"in\"/>\n    <arg name=\"result\" type=\"ao\" direction=\"out\"/>\n  </method>\n  <method name=\"GetItemsByPid\">\n    <arg name=\"pid\" type=\"i\" direction=\"in\"/>\n    <arg name=\"result\" type=\"ao\" direction=\"out\"/>\n  </method>\n  <method name=\"GetItemByXid\">\n    <arg name=\"xid\" type=\"x\" direction=\"in\"/>\n    <arg name=\"result\" type=\"o\" direction=\"out\"/>\n  </method>\n  <method name=\"AwnSetVisibility\">\n    <arg name=\"win_name\" type=\"s\" direction=\"in\"/>\n    <arg name=\"visible\" type=\"b\" direction=\"in\"/>\n  </method>\n  <method name=\"AwnRegisterProxyItem\">\n    <arg name=\"desktop_file\" type=\"s\" direction=\"in\"/>\n    <arg name=\"uri\" type=\"s\" direction=\"in\"/>\n    <arg name=\"result\" type=\"o\" direction=\"out\"/>\n  </method>\n  <signal name=\"ItemAdded\">\n    <arg name=\"path\" type=\"o\"/>\n  </signal>\n  <signal name=\"ItemRemoved\">\n    <arg name=\"path\" type=\"o\"/>\n  </signal>\n</interface>\n");
 
4573
        dbus_connection_list_registered (connection, g_object_get_data ((GObject *) self, "dbus_object_path"), &children);
 
4574
        for (i = 0; children[i]; i++) {
 
4575
                g_string_append_printf (xml_data, "<node name=\"%s\"/>\n", children[i]);
 
4576
        }
 
4577
        dbus_free_string_array (children);
 
4578
        g_string_append (xml_data, "</node>\n");
 
4579
        dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &xml_data->str);
 
4580
        g_string_free (xml_data, TRUE);
 
4581
        if (reply) {
 
4582
                dbus_connection_send (connection, reply, NULL);
 
4583
                dbus_message_unref (reply);
 
4584
                return DBUS_HANDLER_RESULT_HANDLED;
 
4585
        } else {
 
4586
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
4587
        }
 
4588
}
 
4589
 
 
4590
 
 
4591
DBusHandlerResult task_manager_dispatcher_dbus_message (DBusConnection* connection, DBusMessage* message, void* object) {
 
4592
        DBusHandlerResult result;
 
4593
        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
4594
        if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
 
4595
                result = _dbus_task_manager_dispatcher_introspect (object, connection, message);
 
4596
        }
 
4597
        if (result == DBUS_HANDLER_RESULT_HANDLED) {
 
4598
                return result;
 
4599
        } else if (dock_manager_dbus_interface_dbus_message (connection, message, object) == DBUS_HANDLER_RESULT_HANDLED) {
 
4600
                return DBUS_HANDLER_RESULT_HANDLED;
 
4601
        } else {
 
4602
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
4603
        }
 
4604
}
 
4605
 
 
4606
 
 
4607
void task_manager_dispatcher_dbus_register_object (DBusConnection* connection, const char* path, void* object) {
 
4608
        if (!g_object_get_data (object, "dbus_object_path")) {
 
4609
                g_object_set_data (object, "dbus_object_path", g_strdup (path));
 
4610
                dbus_connection_register_object_path (connection, path, &_task_manager_dispatcher_dbus_path_vtable, object);
 
4611
                g_object_weak_ref (object, _vala_dbus_unregister_object, connection);
 
4612
        }
 
4613
        dock_manager_dbus_interface_dbus_register_object (connection, path, object);
 
4614
}
 
4615
 
 
4616
 
 
4617
static void task_manager_dispatcher_class_init (TaskManagerDispatcherClass * klass) {
 
4618
        task_manager_dispatcher_parent_class = g_type_class_peek_parent (klass);
 
4619
        g_type_class_add_private (klass, sizeof (TaskManagerDispatcherPrivate));
 
4620
        G_OBJECT_CLASS (klass)->get_property = task_manager_dispatcher_get_property;
 
4621
        G_OBJECT_CLASS (klass)->set_property = task_manager_dispatcher_set_property;
 
4622
        G_OBJECT_CLASS (klass)->finalize = task_manager_dispatcher_finalize;
 
4623
        g_object_class_install_property (G_OBJECT_CLASS (klass), TASK_MANAGER_DISPATCHER_MANAGER, g_param_spec_object ("manager", "manager", "manager", TASK_TYPE_MANAGER, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 
4624
        g_type_set_qdata (TYPE_TASK_MANAGER_DISPATCHER, g_quark_from_static_string ("DBusObjectVTable"), (void*) (&_task_manager_dispatcher_dbus_vtable));
 
4625
}
 
4626
 
 
4627
 
 
4628
static void task_manager_dispatcher_dock_manager_dbus_interface_interface_init (DockManagerDBusInterfaceIface * iface) {
 
4629
        task_manager_dispatcher_dock_manager_dbus_interface_parent_iface = g_type_interface_peek_parent (iface);
 
4630
        iface->get_capabilities = task_manager_dispatcher_real_get_capabilities;
 
4631
        iface->get_items = task_manager_dispatcher_real_get_items;
 
4632
        iface->get_items_by_name = task_manager_dispatcher_real_get_items_by_name;
 
4633
        iface->get_items_by_desktop_file = task_manager_dispatcher_real_get_items_by_desktop_file;
 
4634
        iface->get_items_by_pid = task_manager_dispatcher_real_get_items_by_pid;
 
4635
        iface->get_item_by_xid = task_manager_dispatcher_real_get_item_by_xid;
 
4636
        iface->awn_set_visibility = task_manager_dispatcher_real_awn_set_visibility;
 
4637
        iface->awn_register_proxy_item = task_manager_dispatcher_real_awn_register_proxy_item;
 
4638
}
 
4639
 
 
4640
 
 
4641
static void task_manager_dispatcher_instance_init (TaskManagerDispatcher * self) {
 
4642
        self->priv = TASK_MANAGER_DISPATCHER_GET_PRIVATE (self);
 
4643
}
 
4644
 
 
4645
 
 
4646
static void task_manager_dispatcher_finalize (GObject* obj) {
 
4647
        TaskManagerDispatcher * self;
 
4648
        self = TASK_MANAGER_DISPATCHER (obj);
 
4649
        _g_object_unref0 (self->priv->_manager);
 
4650
        G_OBJECT_CLASS (task_manager_dispatcher_parent_class)->finalize (obj);
 
4651
}
 
4652
 
 
4653
 
 
4654
GType task_manager_dispatcher_get_type (void) {
 
4655
        static GType task_manager_dispatcher_type_id = 0;
 
4656
        if (task_manager_dispatcher_type_id == 0) {
 
4657
                static const GTypeInfo g_define_type_info = { sizeof (TaskManagerDispatcherClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) task_manager_dispatcher_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TaskManagerDispatcher), 0, (GInstanceInitFunc) task_manager_dispatcher_instance_init, NULL };
 
4658
                static const GInterfaceInfo dock_manager_dbus_interface_info = { (GInterfaceInitFunc) task_manager_dispatcher_dock_manager_dbus_interface_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 
4659
                task_manager_dispatcher_type_id = g_type_register_static (G_TYPE_OBJECT, "TaskManagerDispatcher", &g_define_type_info, 0);
 
4660
                g_type_add_interface_static (task_manager_dispatcher_type_id, TYPE_DOCK_MANAGER_DBUS_INTERFACE, &dock_manager_dbus_interface_info);
 
4661
        }
 
4662
        return task_manager_dispatcher_type_id;
 
4663
}
 
4664
 
 
4665
 
 
4666
static void task_manager_dispatcher_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
4667
        TaskManagerDispatcher * self;
 
4668
        self = TASK_MANAGER_DISPATCHER (object);
 
4669
        switch (property_id) {
 
4670
                case TASK_MANAGER_DISPATCHER_MANAGER:
 
4671
                g_value_set_object (value, task_manager_dispatcher_get_manager (self));
 
4672
                break;
 
4673
                default:
 
4674
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
4675
                break;
 
4676
        }
 
4677
}
 
4678
 
 
4679
 
 
4680
static void task_manager_dispatcher_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 
4681
        TaskManagerDispatcher * self;
 
4682
        self = TASK_MANAGER_DISPATCHER (object);
 
4683
        switch (property_id) {
 
4684
                case TASK_MANAGER_DISPATCHER_MANAGER:
 
4685
                task_manager_dispatcher_set_manager (self, g_value_get_object (value));
 
4686
                break;
 
4687
                default:
 
4688
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
4689
                break;
 
4690
        }
 
4691
}
 
4692
 
 
4693
 
 
4694
TaskIconDispatcher* task_icon_dispatcher_construct (GType object_type, TaskIcon* icon) {
 
4695
        GError * _inner_error_;
 
4696
        TaskIconDispatcher * self;
 
4697
        DBusGConnection* conn;
 
4698
        char* _tmp0_;
 
4699
        g_return_val_if_fail (icon != NULL, NULL);
 
4700
        _inner_error_ = NULL;
 
4701
        self = (TaskIconDispatcher*) g_object_new (object_type, NULL);
 
4702
        self->priv->icon = icon;
 
4703
        conn = dbus_g_bus_get (DBUS_BUS_SESSION, &_inner_error_);
 
4704
        if (_inner_error_ != NULL) {
 
4705
                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);
 
4706
                g_clear_error (&_inner_error_);
 
4707
                return NULL;
 
4708
        }
 
4709
        task_icon_dispatcher_set_object_path (self, _tmp0_ = g_strdup_printf ("/org/freedesktop/DockManager/Item%d", task_icon_dispatcher_counter++));
 
4710
        _g_free0 (_tmp0_);
 
4711
        _vala_dbus_register_object (dbus_g_connection_get_connection (conn), self->priv->_object_path, (GObject*) self);
 
4712
        _dbus_g_connection_unref0 (conn);
 
4713
        return self;
 
4714
}
 
4715
 
 
4716
 
 
4717
TaskIconDispatcher* task_icon_dispatcher_new (TaskIcon* icon) {
 
4718
        return task_icon_dispatcher_construct (TYPE_TASK_ICON_DISPATCHER, icon);
 
4719
}
 
4720
 
 
4721
 
 
4722
static void _lambda0_ (GtkMenuItem* w, Block1Data* _data1_) {
 
4723
        TaskIconDispatcher * self;
 
4724
        self = _data1_->self;
 
4725
        g_return_if_fail (w != NULL);
 
4726
        g_signal_emit_by_name ((DockItemDBusInterface*) self, "menu-item-activated", _data1_->id);
 
4727
}
 
4728
 
 
4729
 
 
4730
static void __lambda0__gtk_menu_item_activate (GtkMenuItem* _sender, gpointer self) {
 
4731
        _lambda0_ (_sender, self);
 
4732
}
 
4733
 
 
4734
 
 
4735
static Block1Data* block1_data_ref (Block1Data* _data1_) {
 
4736
        ++_data1_->_ref_count_;
 
4737
        return _data1_;
 
4738
}
 
4739
 
 
4740
 
 
4741
static void block1_data_unref (Block1Data* _data1_) {
 
4742
        if ((--_data1_->_ref_count_) == 0) {
 
4743
                _g_object_unref0 (_data1_->self);
 
4744
                g_slice_free (Block1Data, _data1_);
 
4745
        }
 
4746
}
 
4747
 
 
4748
 
 
4749
static gint task_icon_dispatcher_real_add_menu_item (DockItemDBusInterface* base, GHashTable* menu_hints, GError** error) {
 
4750
        TaskIconDispatcher * self;
 
4751
        gint result;
 
4752
        GtkImageMenuItem* item;
 
4753
        GtkImage* image;
 
4754
        GHashTableIter _tmp0_ = {0};
 
4755
        GHashTableIter iter;
 
4756
        const char* key;
 
4757
        GValue* value = NULL;
 
4758
        self = (TaskIconDispatcher*) base;
 
4759
        g_return_val_if_fail (menu_hints != NULL, 0);
 
4760
        item = NULL;
 
4761
        image = NULL;
 
4762
        iter = (g_hash_table_iter_init (&_tmp0_, menu_hints), _tmp0_);
 
4763
        key = NULL;
 
4764
        while (TRUE) {
 
4765
                if (!g_hash_table_iter_next (&iter, &key, &value)) {
 
4766
                        break;
 
4767
                }
 
4768
                if (_vala_strcmp0 (key, "label") == 0) {
 
4769
                        GtkImageMenuItem* _tmp1_;
 
4770
                        item = (_tmp1_ = g_object_ref_sink ((GtkImageMenuItem*) gtk_image_menu_item_new_with_label (g_value_get_string (value))), _g_object_unref0 (item), _tmp1_);
 
4771
                } else {
 
4772
                        if (_vala_strcmp0 (key, "icon-name") == 0) {
 
4773
                                GtkImage* _tmp2_;
 
4774
                                image = (_tmp2_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_icon_name (g_value_get_string (value), GTK_ICON_SIZE_MENU)), _g_object_unref0 (image), _tmp2_);
 
4775
                        } else {
 
4776
                                if (_vala_strcmp0 (key, "uri") == 0) {
 
4777
                                }
 
4778
                        }
 
4779
                }
 
4780
        }
 
4781
        if (item != NULL) {
 
4782
                Block1Data* _data1_;
 
4783
                _data1_ = g_slice_new0 (Block1Data);
 
4784
                _data1_->_ref_count_ = 1;
 
4785
                _data1_->self = g_object_ref (self);
 
4786
                if (image != NULL) {
 
4787
                        gtk_image_menu_item_set_image (item, (GtkWidget*) image);
 
4788
                }
 
4789
                _data1_->id = task_icon_add_menu_item (self->priv->icon, (GtkMenuItem*) item);
 
4790
                gtk_widget_show ((GtkWidget*) item);
 
4791
                g_signal_connect_data ((GtkMenuItem*) item, "activate", (GCallback) __lambda0__gtk_menu_item_activate, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0);
 
4792
                result = _data1_->id;
 
4793
                block1_data_unref (_data1_);
 
4794
                _g_object_unref0 (item);
 
4795
                _g_object_unref0 (image);
 
4796
                return result;
 
4797
        }
 
4798
        result = 0;
 
4799
        _g_object_unref0 (item);
 
4800
        _g_object_unref0 (image);
 
4801
        return result;
 
4802
}
 
4803
 
 
4804
 
 
4805
static void task_icon_dispatcher_real_remove_menu_item (DockItemDBusInterface* base, gint id, GError** error) {
 
4806
        TaskIconDispatcher * self;
 
4807
        self = (TaskIconDispatcher*) base;
 
4808
        task_icon_remove_menu_item (self->priv->icon, id);
 
4809
}
 
4810
 
 
4811
 
 
4812
static void task_icon_dispatcher_real_update_dock_item (DockItemDBusInterface* base, GHashTable* hints, GError** error) {
 
4813
        TaskIconDispatcher * self;
 
4814
        GHashTableIter _tmp0_ = {0};
 
4815
        GHashTableIter iter;
 
4816
        const char* key;
 
4817
        GValue* value = NULL;
 
4818
        self = (TaskIconDispatcher*) base;
 
4819
        g_return_if_fail (hints != NULL);
 
4820
        iter = (g_hash_table_iter_init (&_tmp0_, hints), _tmp0_);
 
4821
        key = NULL;
 
4822
        while (TRUE) {
 
4823
                if (!g_hash_table_iter_next (&iter, &key, &value)) {
 
4824
                        break;
 
4825
                }
 
4826
                if (_vala_strcmp0 (key, "message") == 0) {
 
4827
                        GSList* items;
 
4828
                        if (!G_VALUE_HOLDS (value, G_TYPE_STRING)) {
 
4829
                                g_warning ("dock-manager-api.vala:299: Invalid type for property \"%s\"", key);
 
4830
                                continue;
 
4831
                        }
 
4832
                        items = task_icon_get_items (self->priv->icon);
 
4833
                        {
 
4834
                                GSList* item_collection;
 
4835
                                GSList* item_it;
 
4836
                                item_collection = items;
 
4837
                                for (item_it = item_collection; item_it != NULL; item_it = item_it->next) {
 
4838
                                        TaskItem* item;
 
4839
                                        item = (TaskItem*) item_it->data;
 
4840
                                        {
 
4841
                                                const char* text;
 
4842
                                                if (TASK_IS_LAUNCHER (item)) {
 
4843
                                                        continue;
 
4844
                                                }
 
4845
                                                if (item->text_overlay == NULL) {
 
4846
                                                        AwnOverlayText* _tmp1_;
 
4847
                                                        AwnOverlayable* over;
 
4848
                                                        GtkWidget* _tmp2_;
 
4849
                                                        item->text_overlay = (_tmp1_ = g_object_ref_sink (awn_overlay_text_new ()), _g_object_unref0 (item->text_overlay), _tmp1_);
 
4850
                                                        g_object_set (item->text_overlay, "font-sizing", (double) 15, NULL);
 
4851
                                                        over = NULL;
 
4852
                                                        over = (_tmp2_ = task_item_get_image_widget (item), AWN_IS_OVERLAYABLE (_tmp2_) ? ((AwnOverlayable*) _tmp2_) : NULL);
 
4853
                                                        awn_overlayable_add_overlay (over, (AwnOverlay*) item->text_overlay);
 
4854
                                                }
 
4855
                                                text = g_value_get_string (value);
 
4856
                                                g_object_set ((AwnOverlay*) item->text_overlay, "active", strlen (text) > 0, NULL);
 
4857
                                                g_object_set (item->text_overlay, "text", text, NULL);
 
4858
                                                task_item_set_task_icon (item, task_item_get_task_icon (item));
 
4859
                                        }
 
4860
                                }
 
4861
                        }
 
4862
                } else {
 
4863
                        if (_vala_strcmp0 (key, "progress") == 0) {
 
4864
                                GSList* items;
 
4865
                                if (!G_VALUE_HOLDS (value, G_TYPE_INT)) {
 
4866
                                        g_warning ("dock-manager-api.vala:330: Invalid type for property \"%s\"", key);
 
4867
                                        continue;
 
4868
                                }
 
4869
                                items = task_icon_get_items (self->priv->icon);
 
4870
                                {
 
4871
                                        GSList* item_collection;
 
4872
                                        GSList* item_it;
 
4873
                                        item_collection = items;
 
4874
                                        for (item_it = item_collection; item_it != NULL; item_it = item_it->next) {
 
4875
                                                TaskItem* item;
 
4876
                                                item = (TaskItem*) item_it->data;
 
4877
                                                {
 
4878
                                                        gint percent;
 
4879
                                                        if (TASK_IS_LAUNCHER (item)) {
 
4880
                                                                continue;
 
4881
                                                        }
 
4882
                                                        if (item->progress_overlay == NULL) {
 
4883
                                                                AwnOverlayProgressCircle* _tmp3_;
 
4884
                                                                AwnOverlayable* over;
 
4885
                                                                GtkWidget* _tmp4_;
 
4886
                                                                item->progress_overlay = (_tmp3_ = g_object_ref_sink (awn_overlay_progress_circle_new ()), _g_object_unref0 (item->progress_overlay), _tmp3_);
 
4887
                                                                over = NULL;
 
4888
                                                                over = (_tmp4_ = task_item_get_image_widget (item), AWN_IS_OVERLAYABLE (_tmp4_) ? ((AwnOverlayable*) _tmp4_) : NULL);
 
4889
                                                                awn_overlayable_add_overlay (over, (AwnOverlay*) item->progress_overlay);
 
4890
                                                        }
 
4891
                                                        percent = g_value_get_int (value);
 
4892
                                                        g_object_set ((AwnOverlay*) item->progress_overlay, "active", percent != (-1), NULL);
 
4893
                                                        if (percent != (-1)) {
 
4894
                                                                g_object_set ((AwnOverlayProgress*) item->progress_overlay, "percent-complete", (double) percent, NULL);
 
4895
                                                        }
 
4896
                                                        task_item_set_task_icon (item, task_item_get_task_icon (item));
 
4897
                                                }
 
4898
                                        }
 
4899
                                }
 
4900
                        } else {
 
4901
                                if (_vala_strcmp0 (key, "icon-file") == 0) {
 
4902
                                        GSList* items;
 
4903
                                        if (!G_VALUE_HOLDS (value, G_TYPE_STRING)) {
 
4904
                                                g_warning ("dock-manager-api.vala:364: Invalid type for property \"%s\"", key);
 
4905
                                                continue;
 
4906
                                        }
 
4907
                                        items = task_icon_get_items (self->priv->icon);
 
4908
                                        {
 
4909
                                                GSList* item_collection;
 
4910
                                                GSList* item_it;
 
4911
                                                item_collection = items;
 
4912
                                                for (item_it = item_collection; item_it != NULL; item_it = item_it->next) {
 
4913
                                                        TaskItem* item;
 
4914
                                                        item = (TaskItem*) item_it->data;
 
4915
                                                        {
 
4916
                                                                const char* filename;
 
4917
                                                                if (TASK_IS_LAUNCHER (item)) {
 
4918
                                                                        continue;
 
4919
                                                                }
 
4920
                                                                if (item->icon_overlay == NULL) {
 
4921
                                                                        AwnOverlayPixbufFile* _tmp5_;
 
4922
                                                                        AwnOverlayable* over;
 
4923
                                                                        GtkWidget* _tmp6_;
 
4924
                                                                        item->icon_overlay = (_tmp5_ = g_object_ref_sink (awn_overlay_pixbuf_file_new (NULL)), _g_object_unref0 (item->icon_overlay), _tmp5_);
 
4925
                                                                        awn_overlay_set_use_source_op ((AwnOverlay*) item->icon_overlay, TRUE);
 
4926
                                                                        g_object_set ((AwnOverlayPixbuf*) item->icon_overlay, "scale", 1.0, NULL);
 
4927
                                                                        over = NULL;
 
4928
                                                                        over = (_tmp6_ = task_item_get_image_widget (item), AWN_IS_OVERLAYABLE (_tmp6_) ? ((AwnOverlayable*) _tmp6_) : NULL);
 
4929
                                                                        awn_overlayable_add_overlay (over, (AwnOverlay*) item->progress_overlay);
 
4930
                                                                }
 
4931
                                                                filename = g_value_get_string (value);
 
4932
                                                                g_object_set ((AwnOverlay*) item->icon_overlay, "active", strlen (filename) > 0, NULL);
 
4933
                                                                if (strlen (filename) > 0) {
 
4934
                                                                        g_object_set (item->icon_overlay, "file-name", filename, NULL);
 
4935
                                                                }
 
4936
                                                        }
 
4937
                                                }
 
4938
                                        }
 
4939
                                } else {
 
4940
                                        g_debug ("dock-manager-api.vala:395: Unsupported key: \"%s\"", key);
 
4941
                                }
 
4942
                        }
 
4943
                }
 
4944
        }
 
4945
}
 
4946
 
 
4947
 
 
4948
const char* task_icon_dispatcher_get_object_path (TaskIconDispatcher* self) {
 
4949
        const char* result;
 
4950
        g_return_val_if_fail (self != NULL, NULL);
 
4951
        result = self->priv->_object_path;
 
4952
        return result;
 
4953
}
 
4954
 
 
4955
 
 
4956
void task_icon_dispatcher_set_object_path (TaskIconDispatcher* self, const char* value) {
 
4957
        char* _tmp0_;
 
4958
        g_return_if_fail (self != NULL);
 
4959
        self->priv->_object_path = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_object_path), _tmp0_);
 
4960
        g_object_notify ((GObject *) self, "object-path");
 
4961
}
 
4962
 
 
4963
 
 
4964
static char* task_icon_dispatcher_real_get_desktop_file (DockItemDBusInterface* base) {
 
4965
        char* result;
 
4966
        TaskIconDispatcher* self;
 
4967
        char* path;
 
4968
        TaskLauncher* launcher;
 
4969
        TaskItem* _tmp0_;
 
4970
        self = (TaskIconDispatcher*) base;
 
4971
        path = g_strdup ("");
 
4972
        launcher = NULL;
 
4973
        launcher = (_tmp0_ = task_icon_get_launcher (self->priv->icon), TASK_IS_LAUNCHER (_tmp0_) ? ((TaskLauncher*) _tmp0_) : NULL);
 
4974
        if (launcher != NULL) {
 
4975
                char* _tmp1_;
 
4976
                path = (_tmp1_ = g_strdup (task_launcher_get_desktop_path (launcher)), _g_free0 (path), _tmp1_);
 
4977
        }
 
4978
        result = path;
 
4979
        return result;
 
4980
}
 
4981
 
 
4982
 
 
4983
static char* task_icon_dispatcher_real_get_uri (DockItemDBusInterface* base) {
 
4984
        char* result;
 
4985
        TaskIconDispatcher* self;
 
4986
        self = (TaskIconDispatcher*) base;
 
4987
        result = g_strdup ("");
 
4988
        return result;
 
4989
}
 
4990
 
 
4991
 
 
4992
void _task_icon_dispatcher_dbus_unregister (DBusConnection* connection, void* _user_data_) {
 
4993
}
 
4994
 
 
4995
 
 
4996
static DBusHandlerResult _dbus_task_icon_dispatcher_introspect (TaskIconDispatcher* self, DBusConnection* connection, DBusMessage* message) {
 
4997
        DBusMessage* reply;
 
4998
        DBusMessageIter iter;
 
4999
        GString* xml_data;
 
5000
        char** children;
 
5001
        int i;
 
5002
        reply = dbus_message_new_method_return (message);
 
5003
        dbus_message_iter_init_append (reply, &iter);
 
5004
        xml_data = g_string_new ("<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" \"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n");
 
5005
        g_string_append (xml_data, "<node>\n<interface name=\"org.freedesktop.DBus.Introspectable\">\n  <method name=\"Introspect\">\n    <arg name=\"data\" direction=\"out\" type=\"s\"/>\n  </method>\n</interface>\n<interface name=\"org.freedesktop.DBus.Properties\">\n  <method name=\"Get\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n    <arg name=\"value\" direction=\"out\" type=\"v\"/>\n  </method>\n  <method name=\"Set\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n    <arg name=\"value\" direction=\"in\" type=\"v\"/>\n  </method>\n  <method name=\"GetAll\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"props\" direction=\"out\" type=\"a{sv}\"/>\n  </method>\n</interface>\n<interface name=\"org.freedesktop.DockItem\">\n  <method name=\"AddMenuItem\">\n    <arg name=\"menu_hints\" type=\"a{sv}\" direction=\"in\"/>\n    <arg name=\"result\" type=\"i\" direction=\"out\"/>\n  </method>\n  <method name=\"RemoveMenuItem\">\n    <arg name=\"id\" type=\"i\" direction=\"in\"/>\n  </method>\n  <method name=\"UpdateDockItem\">\n    <arg name=\"hints\" type=\"a{sv}\" direction=\"in\"/>\n  </method>\n  <property name=\"DesktopFile\" type=\"s\" access=\"read\"/>\n  <property name=\"Uri\" type=\"s\" access=\"read\"/>\n  <signal name=\"MenuItemActivated\">\n    <arg name=\"id\" type=\"i\"/>\n  </signal>\n</interface>\n");
 
5006
        dbus_connection_list_registered (connection, g_object_get_data ((GObject *) self, "dbus_object_path"), &children);
 
5007
        for (i = 0; children[i]; i++) {
 
5008
                g_string_append_printf (xml_data, "<node name=\"%s\"/>\n", children[i]);
 
5009
        }
 
5010
        dbus_free_string_array (children);
 
5011
        g_string_append (xml_data, "</node>\n");
 
5012
        dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &xml_data->str);
 
5013
        g_string_free (xml_data, TRUE);
 
5014
        if (reply) {
 
5015
                dbus_connection_send (connection, reply, NULL);
 
5016
                dbus_message_unref (reply);
 
5017
                return DBUS_HANDLER_RESULT_HANDLED;
 
5018
        } else {
 
5019
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
5020
        }
 
5021
}
 
5022
 
 
5023
 
 
5024
DBusHandlerResult task_icon_dispatcher_dbus_message (DBusConnection* connection, DBusMessage* message, void* object) {
 
5025
        DBusHandlerResult result;
 
5026
        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
5027
        if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
 
5028
                result = _dbus_task_icon_dispatcher_introspect (object, connection, message);
 
5029
        }
 
5030
        if (result == DBUS_HANDLER_RESULT_HANDLED) {
 
5031
                return result;
 
5032
        } else if (dock_item_dbus_interface_dbus_message (connection, message, object) == DBUS_HANDLER_RESULT_HANDLED) {
 
5033
                return DBUS_HANDLER_RESULT_HANDLED;
 
5034
        } else {
 
5035
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
5036
        }
 
5037
}
 
5038
 
 
5039
 
 
5040
void task_icon_dispatcher_dbus_register_object (DBusConnection* connection, const char* path, void* object) {
 
5041
        if (!g_object_get_data (object, "dbus_object_path")) {
 
5042
                g_object_set_data (object, "dbus_object_path", g_strdup (path));
 
5043
                dbus_connection_register_object_path (connection, path, &_task_icon_dispatcher_dbus_path_vtable, object);
 
5044
                g_object_weak_ref (object, _vala_dbus_unregister_object, connection);
 
5045
        }
 
5046
        dock_item_dbus_interface_dbus_register_object (connection, path, object);
 
5047
}
 
5048
 
 
5049
 
 
5050
static void task_icon_dispatcher_class_init (TaskIconDispatcherClass * klass) {
 
5051
        task_icon_dispatcher_parent_class = g_type_class_peek_parent (klass);
 
5052
        g_type_class_add_private (klass, sizeof (TaskIconDispatcherPrivate));
 
5053
        G_OBJECT_CLASS (klass)->get_property = task_icon_dispatcher_get_property;
 
5054
        G_OBJECT_CLASS (klass)->set_property = task_icon_dispatcher_set_property;
 
5055
        G_OBJECT_CLASS (klass)->finalize = task_icon_dispatcher_finalize;
 
5056
        g_object_class_install_property (G_OBJECT_CLASS (klass), TASK_ICON_DISPATCHER_OBJECT_PATH, g_param_spec_string ("object-path", "object-path", "object-path", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
 
5057
        g_object_class_override_property (G_OBJECT_CLASS (klass), TASK_ICON_DISPATCHER_DESKTOP_FILE, "desktop-file");
 
5058
        g_object_class_override_property (G_OBJECT_CLASS (klass), TASK_ICON_DISPATCHER_URI, "uri");
 
5059
        g_type_set_qdata (TYPE_TASK_ICON_DISPATCHER, g_quark_from_static_string ("DBusObjectVTable"), (void*) (&_task_icon_dispatcher_dbus_vtable));
 
5060
}
 
5061
 
 
5062
 
 
5063
static void task_icon_dispatcher_dock_item_dbus_interface_interface_init (DockItemDBusInterfaceIface * iface) {
 
5064
        task_icon_dispatcher_dock_item_dbus_interface_parent_iface = g_type_interface_peek_parent (iface);
 
5065
        iface->add_menu_item = task_icon_dispatcher_real_add_menu_item;
 
5066
        iface->remove_menu_item = task_icon_dispatcher_real_remove_menu_item;
 
5067
        iface->update_dock_item = task_icon_dispatcher_real_update_dock_item;
 
5068
        iface->get_desktop_file = task_icon_dispatcher_real_get_desktop_file;
 
5069
        iface->get_uri = task_icon_dispatcher_real_get_uri;
 
5070
}
 
5071
 
 
5072
 
 
5073
static void task_icon_dispatcher_instance_init (TaskIconDispatcher * self) {
 
5074
        self->priv = TASK_ICON_DISPATCHER_GET_PRIVATE (self);
 
5075
}
 
5076
 
 
5077
 
 
5078
static void task_icon_dispatcher_finalize (GObject* obj) {
 
5079
        TaskIconDispatcher * self;
 
5080
        self = TASK_ICON_DISPATCHER (obj);
 
5081
        _g_free0 (self->priv->_object_path);
 
5082
        G_OBJECT_CLASS (task_icon_dispatcher_parent_class)->finalize (obj);
 
5083
}
 
5084
 
 
5085
 
 
5086
GType task_icon_dispatcher_get_type (void) {
 
5087
        static GType task_icon_dispatcher_type_id = 0;
 
5088
        if (task_icon_dispatcher_type_id == 0) {
 
5089
                static const GTypeInfo g_define_type_info = { sizeof (TaskIconDispatcherClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) task_icon_dispatcher_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TaskIconDispatcher), 0, (GInstanceInitFunc) task_icon_dispatcher_instance_init, NULL };
 
5090
                static const GInterfaceInfo dock_item_dbus_interface_info = { (GInterfaceInitFunc) task_icon_dispatcher_dock_item_dbus_interface_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 
5091
                task_icon_dispatcher_type_id = g_type_register_static (G_TYPE_OBJECT, "TaskIconDispatcher", &g_define_type_info, 0);
 
5092
                g_type_add_interface_static (task_icon_dispatcher_type_id, TYPE_DOCK_ITEM_DBUS_INTERFACE, &dock_item_dbus_interface_info);
 
5093
        }
 
5094
        return task_icon_dispatcher_type_id;
 
5095
}
 
5096
 
 
5097
 
 
5098
static void task_icon_dispatcher_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
5099
        TaskIconDispatcher * self;
 
5100
        self = TASK_ICON_DISPATCHER (object);
 
5101
        switch (property_id) {
 
5102
                case TASK_ICON_DISPATCHER_OBJECT_PATH:
 
5103
                g_value_set_string (value, task_icon_dispatcher_get_object_path (self));
 
5104
                break;
 
5105
                case TASK_ICON_DISPATCHER_DESKTOP_FILE:
 
5106
                g_value_set_string (value, dock_item_dbus_interface_get_desktop_file ((DockItemDBusInterface*) self));
 
5107
                break;
 
5108
                case TASK_ICON_DISPATCHER_URI:
 
5109
                g_value_set_string (value, dock_item_dbus_interface_get_uri ((DockItemDBusInterface*) self));
 
5110
                break;
 
5111
                default:
 
5112
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
5113
                break;
 
5114
        }
 
5115
}
 
5116
 
 
5117
 
 
5118
static void task_icon_dispatcher_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 
5119
        TaskIconDispatcher * self;
 
5120
        self = TASK_ICON_DISPATCHER (object);
 
5121
        switch (property_id) {
 
5122
                case TASK_ICON_DISPATCHER_OBJECT_PATH:
 
5123
                task_icon_dispatcher_set_object_path (self, g_value_get_string (value));
 
5124
                break;
 
5125
                default:
 
5126
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
5127
                break;
 
5128
        }
 
5129
}
 
5130
 
 
5131
 
 
5132
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
5133
        if ((array != NULL) && (destroy_func != NULL)) {
 
5134
                int i;
 
5135
                for (i = 0; i < array_length; i = i + 1) {
 
5136
                        if (((gpointer*) array)[i] != NULL) {
 
5137
                                destroy_func (((gpointer*) array)[i]);
 
5138
                        }
 
5139
                }
 
5140
        }
 
5141
}
 
5142
 
 
5143
 
 
5144
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
5145
        _vala_array_destroy (array, array_length, destroy_func);
 
5146
        g_free (array);
 
5147
}
 
5148
 
 
5149
 
 
5150
static int _vala_strcmp0 (const char * str1, const char * str2) {
 
5151
        if (str1 == NULL) {
 
5152
                return -(str1 != str2);
 
5153
        }
 
5154
        if (str2 == NULL) {
 
5155
                return str1 != str2;
 
5156
        }
 
5157
        return strcmp (str1, str2);
 
5158
}
 
5159
 
 
5160
 
 
5161
static void _vala_dbus_register_object (DBusConnection* connection, const char* path, void* object) {
 
5162
        const _DBusObjectVTable * vtable;
 
5163
        vtable = g_type_get_qdata (G_TYPE_FROM_INSTANCE (object), g_quark_from_static_string ("DBusObjectVTable"));
 
5164
        if (vtable) {
 
5165
                vtable->register_object (connection, path, object);
 
5166
        } else {
 
5167
                g_warning ("Object does not implement any D-Bus interface");
 
5168
        }
 
5169
}
 
5170
 
 
5171
 
 
5172
static void _vala_dbus_unregister_object (gpointer connection, GObject* object) {
 
5173
        char* path;
 
5174
        path = g_object_steal_data ((GObject*) object, "dbus_object_path");
 
5175
        dbus_connection_unregister_object_path (connection, path);
 
5176
        g_free (path);
 
5177
}
 
5178
 
 
5179
 
 
5180
 
 
5181
static void g_cclosure_user_marshal_VOID__BOXED (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
 
5182
        typedef void (*GMarshalFunc_VOID__BOXED) (gpointer data1, gpointer arg_1, gpointer data2);
 
5183
        register GMarshalFunc_VOID__BOXED callback;
 
5184
        register GCClosure * cc;
 
5185
        register gpointer data1, data2;
 
5186
        cc = (GCClosure *) closure;
 
5187
        g_return_if_fail (n_param_values == 2);
 
5188
        if (G_CCLOSURE_SWAP_DATA (closure)) {
 
5189
                data1 = closure->data;
 
5190
                data2 = param_values->data[0].v_pointer;
 
5191
        } else {
 
5192
                data1 = param_values->data[0].v_pointer;
 
5193
                data2 = closure->data;
 
5194
        }
 
5195
        callback = (GMarshalFunc_VOID__BOXED) (marshal_data ? marshal_data : cc->callback);
 
5196
        callback (data1, g_value_get_boxed (param_values + 1), data2);
 
5197
}
 
5198
 
 
5199
 
 
5200