source: appstream-generator/build/girepo/gio/DBusObjectManagerT.d @ 4841

Last change on this file since 4841 was 4841, checked in by Juanma, 2 years ago

Initial release

File size: 10.3 KB
Line 
1/*
2 * Licensed under the GNU Lesser General Public License Version 3
3 *
4 * This library is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published by
6 * the Free Software Foundation, either version 3 of the license, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18// generated automatically - do not change
19
20
21module gio.DBusObjectManagerT;
22
23public  import gi.gio;
24public  import gi.giotypes;
25public  import gio.DBusInterface;
26public  import gio.DBusInterfaceIF;
27public  import gio.DBusObject;
28public  import gio.DBusObjectIF;
29public  import glib.ListG;
30public  import glib.Str;
31public  import gobject.ObjectG;
32public  import gobject.Signals;
33public  import std.algorithm;
34
35
36/**
37 * The #GDBusObjectManager type is the base type for service- and
38 * client-side implementations of the standardized
39 * [org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
40 * interface.
41 *
42 * See #GDBusObjectManagerClient for the client-side implementation
43 * and #GDBusObjectManagerServer for the service-side implementation.
44 */
45public template DBusObjectManagerT(TStruct)
46{
47        /** Get the main Gtk struct */
48        public GDBusObjectManager* getDBusObjectManagerStruct()
49        {
50                return cast(GDBusObjectManager*)getStruct();
51        }
52
53
54        /**
55         * Gets the interface proxy for @interface_name at @object_path, if
56         * any.
57         *
58         * Params:
59         *     objectPath = Object path to lookup.
60         *     interfaceName = D-Bus interface name to lookup.
61         *
62         * Returns: A #GDBusInterface instance or %NULL. Free
63         *     with g_object_unref().
64         *
65         * Since: 2.30
66         */
67        public DBusInterfaceIF getInterface(string objectPath, string interfaceName)
68        {
69                auto p = g_dbus_object_manager_get_interface(getDBusObjectManagerStruct(), Str.toStringz(objectPath), Str.toStringz(interfaceName));
70               
71                if(p is null)
72                {
73                        return null;
74                }
75               
76                return ObjectG.getDObject!(DBusInterface, DBusInterfaceIF)(cast(GDBusInterface*) p, true);
77        }
78
79        /**
80         * Gets the #GDBusObjectProxy at @object_path, if any.
81         *
82         * Params:
83         *     objectPath = Object path to lookup.
84         *
85         * Returns: A #GDBusObject or %NULL. Free with
86         *     g_object_unref().
87         *
88         * Since: 2.30
89         */
90        public DBusObjectIF getObject(string objectPath)
91        {
92                auto p = g_dbus_object_manager_get_object(getDBusObjectManagerStruct(), Str.toStringz(objectPath));
93               
94                if(p is null)
95                {
96                        return null;
97                }
98               
99                return ObjectG.getDObject!(DBusObject, DBusObjectIF)(cast(GDBusObject*) p, true);
100        }
101
102        /**
103         * Gets the object path that @manager is for.
104         *
105         * Returns: A string owned by @manager. Do not free.
106         *
107         * Since: 2.30
108         */
109        public string getObjectPath()
110        {
111                return Str.toString(g_dbus_object_manager_get_object_path(getDBusObjectManagerStruct()));
112        }
113
114        /**
115         * Gets all #GDBusObject objects known to @manager.
116         *
117         * Returns: A list of
118         *     #GDBusObject objects. The returned list should be freed with
119         *     g_list_free() after each element has been freed with
120         *     g_object_unref().
121         *
122         * Since: 2.30
123         */
124        public ListG getObjects()
125        {
126                auto p = g_dbus_object_manager_get_objects(getDBusObjectManagerStruct());
127               
128                if(p is null)
129                {
130                        return null;
131                }
132               
133                return new ListG(cast(GList*) p, true);
134        }
135
136        protected class OnInterfaceAddedDelegateWrapper
137        {
138                static OnInterfaceAddedDelegateWrapper[] listeners;
139                void delegate(DBusObjectIF, DBusInterfaceIF, DBusObjectManagerIF) dlg;
140                gulong handlerId;
141               
142                this(void delegate(DBusObjectIF, DBusInterfaceIF, DBusObjectManagerIF) dlg)
143                {
144                        this.dlg = dlg;
145                        this.listeners ~= this;
146                }
147               
148                void remove(OnInterfaceAddedDelegateWrapper source)
149                {
150                        foreach(index, wrapper; listeners)
151                        {
152                                if (wrapper.handlerId == source.handlerId)
153                                {
154                                        listeners[index] = null;
155                                        listeners = std.algorithm.remove(listeners, index);
156                                        break;
157                                }
158                        }
159                }
160        }
161
162        /**
163         * Emitted when @interface is added to @object.
164         *
165         * This signal exists purely as a convenience to avoid having to
166         * connect signals to all objects managed by @manager.
167         *
168         * Params:
169         *     object = The #GDBusObject on which an interface was added.
170         *     iface = The #GDBusInterface that was added.
171         *
172         * Since: 2.30
173         */
174        gulong addOnInterfaceAdded(void delegate(DBusObjectIF, DBusInterfaceIF, DBusObjectManagerIF) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
175        {
176                auto wrapper = new OnInterfaceAddedDelegateWrapper(dlg);
177                wrapper.handlerId = Signals.connectData(
178                        this,
179                        "interface-added",
180                        cast(GCallback)&callBackInterfaceAdded,
181                        cast(void*)wrapper,
182                        cast(GClosureNotify)&callBackInterfaceAddedDestroy,
183                        connectFlags);
184                return wrapper.handlerId;
185        }
186       
187        extern(C) static void callBackInterfaceAdded(GDBusObjectManager* dbusobjectmanagerStruct, GDBusObject* object, GDBusInterface* iface, OnInterfaceAddedDelegateWrapper wrapper)
188        {
189                wrapper.dlg(ObjectG.getDObject!(DBusObject, DBusObjectIF)(object), ObjectG.getDObject!(DBusInterface, DBusInterfaceIF)(iface), wrapper.outer);
190        }
191       
192        extern(C) static void callBackInterfaceAddedDestroy(OnInterfaceAddedDelegateWrapper wrapper, GClosure* closure)
193        {
194                wrapper.remove(wrapper);
195        }
196
197        protected class OnInterfaceRemovedDelegateWrapper
198        {
199                static OnInterfaceRemovedDelegateWrapper[] listeners;
200                void delegate(DBusObjectIF, DBusInterfaceIF, DBusObjectManagerIF) dlg;
201                gulong handlerId;
202               
203                this(void delegate(DBusObjectIF, DBusInterfaceIF, DBusObjectManagerIF) dlg)
204                {
205                        this.dlg = dlg;
206                        this.listeners ~= this;
207                }
208               
209                void remove(OnInterfaceRemovedDelegateWrapper source)
210                {
211                        foreach(index, wrapper; listeners)
212                        {
213                                if (wrapper.handlerId == source.handlerId)
214                                {
215                                        listeners[index] = null;
216                                        listeners = std.algorithm.remove(listeners, index);
217                                        break;
218                                }
219                        }
220                }
221        }
222
223        /**
224         * Emitted when @interface has been removed from @object.
225         *
226         * This signal exists purely as a convenience to avoid having to
227         * connect signals to all objects managed by @manager.
228         *
229         * Params:
230         *     object = The #GDBusObject on which an interface was removed.
231         *     iface = The #GDBusInterface that was removed.
232         *
233         * Since: 2.30
234         */
235        gulong addOnInterfaceRemoved(void delegate(DBusObjectIF, DBusInterfaceIF, DBusObjectManagerIF) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
236        {
237                auto wrapper = new OnInterfaceRemovedDelegateWrapper(dlg);
238                wrapper.handlerId = Signals.connectData(
239                        this,
240                        "interface-removed",
241                        cast(GCallback)&callBackInterfaceRemoved,
242                        cast(void*)wrapper,
243                        cast(GClosureNotify)&callBackInterfaceRemovedDestroy,
244                        connectFlags);
245                return wrapper.handlerId;
246        }
247       
248        extern(C) static void callBackInterfaceRemoved(GDBusObjectManager* dbusobjectmanagerStruct, GDBusObject* object, GDBusInterface* iface, OnInterfaceRemovedDelegateWrapper wrapper)
249        {
250                wrapper.dlg(ObjectG.getDObject!(DBusObject, DBusObjectIF)(object), ObjectG.getDObject!(DBusInterface, DBusInterfaceIF)(iface), wrapper.outer);
251        }
252       
253        extern(C) static void callBackInterfaceRemovedDestroy(OnInterfaceRemovedDelegateWrapper wrapper, GClosure* closure)
254        {
255                wrapper.remove(wrapper);
256        }
257
258        protected class OnObjectAddedDelegateWrapper
259        {
260                static OnObjectAddedDelegateWrapper[] listeners;
261                void delegate(DBusObjectIF, DBusObjectManagerIF) dlg;
262                gulong handlerId;
263               
264                this(void delegate(DBusObjectIF, DBusObjectManagerIF) dlg)
265                {
266                        this.dlg = dlg;
267                        this.listeners ~= this;
268                }
269               
270                void remove(OnObjectAddedDelegateWrapper source)
271                {
272                        foreach(index, wrapper; listeners)
273                        {
274                                if (wrapper.handlerId == source.handlerId)
275                                {
276                                        listeners[index] = null;
277                                        listeners = std.algorithm.remove(listeners, index);
278                                        break;
279                                }
280                        }
281                }
282        }
283
284        /**
285         * Emitted when @object is added to @manager.
286         *
287         * Params:
288         *     object = The #GDBusObject that was added.
289         *
290         * Since: 2.30
291         */
292        gulong addOnObjectAdded(void delegate(DBusObjectIF, DBusObjectManagerIF) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
293        {
294                auto wrapper = new OnObjectAddedDelegateWrapper(dlg);
295                wrapper.handlerId = Signals.connectData(
296                        this,
297                        "object-added",
298                        cast(GCallback)&callBackObjectAdded,
299                        cast(void*)wrapper,
300                        cast(GClosureNotify)&callBackObjectAddedDestroy,
301                        connectFlags);
302                return wrapper.handlerId;
303        }
304       
305        extern(C) static void callBackObjectAdded(GDBusObjectManager* dbusobjectmanagerStruct, GDBusObject* object, OnObjectAddedDelegateWrapper wrapper)
306        {
307                wrapper.dlg(ObjectG.getDObject!(DBusObject, DBusObjectIF)(object), wrapper.outer);
308        }
309       
310        extern(C) static void callBackObjectAddedDestroy(OnObjectAddedDelegateWrapper wrapper, GClosure* closure)
311        {
312                wrapper.remove(wrapper);
313        }
314
315        protected class OnObjectRemovedDelegateWrapper
316        {
317                static OnObjectRemovedDelegateWrapper[] listeners;
318                void delegate(DBusObjectIF, DBusObjectManagerIF) dlg;
319                gulong handlerId;
320               
321                this(void delegate(DBusObjectIF, DBusObjectManagerIF) dlg)
322                {
323                        this.dlg = dlg;
324                        this.listeners ~= this;
325                }
326               
327                void remove(OnObjectRemovedDelegateWrapper source)
328                {
329                        foreach(index, wrapper; listeners)
330                        {
331                                if (wrapper.handlerId == source.handlerId)
332                                {
333                                        listeners[index] = null;
334                                        listeners = std.algorithm.remove(listeners, index);
335                                        break;
336                                }
337                        }
338                }
339        }
340
341        /**
342         * Emitted when @object is removed from @manager.
343         *
344         * Params:
345         *     object = The #GDBusObject that was removed.
346         *
347         * Since: 2.30
348         */
349        gulong addOnObjectRemoved(void delegate(DBusObjectIF, DBusObjectManagerIF) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
350        {
351                auto wrapper = new OnObjectRemovedDelegateWrapper(dlg);
352                wrapper.handlerId = Signals.connectData(
353                        this,
354                        "object-removed",
355                        cast(GCallback)&callBackObjectRemoved,
356                        cast(void*)wrapper,
357                        cast(GClosureNotify)&callBackObjectRemovedDestroy,
358                        connectFlags);
359                return wrapper.handlerId;
360        }
361       
362        extern(C) static void callBackObjectRemoved(GDBusObjectManager* dbusobjectmanagerStruct, GDBusObject* object, OnObjectRemovedDelegateWrapper wrapper)
363        {
364                wrapper.dlg(ObjectG.getDObject!(DBusObject, DBusObjectIF)(object), wrapper.outer);
365        }
366       
367        extern(C) static void callBackObjectRemovedDestroy(OnObjectRemovedDelegateWrapper wrapper, GClosure* closure)
368        {
369                wrapper.remove(wrapper);
370        }
371}
Note: See TracBrowser for help on using the repository browser.