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

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

Initial release

File size: 22.2 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.DBusObjectManagerClient;
22
23private import gi.gio;
24public  import gi.giotypes;
25private import gio.AsyncInitableIF;
26private import gio.AsyncInitableT;
27private import gio.Cancellable;
28private import gio.DBusConnection;
29private import gio.DBusObjectManagerIF;
30private import gio.DBusObjectManagerT;
31private import gio.DBusObjectProxy;
32private import gio.DBusProxy;
33private import gio.InitableIF;
34private import gio.InitableT;
35private import glib.ConstructionException;
36private import glib.ErrorG;
37private import glib.GException;
38private import glib.Str;
39private import glib.Variant;
40private import gobject.ObjectG;
41private import gobject.Signals;
42private import std.algorithm;
43
44
45/**
46 * #GDBusObjectManagerClient is used to create, monitor and delete object
47 * proxies for remote objects exported by a #GDBusObjectManagerServer (or any
48 * code implementing the
49 * [org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
50 * interface).
51 *
52 * Once an instance of this type has been created, you can connect to
53 * the #GDBusObjectManager::object-added and
54 * #GDBusObjectManager::object-removed signals and inspect the
55 * #GDBusObjectProxy objects returned by
56 * g_dbus_object_manager_get_objects().
57 *
58 * If the name for a #GDBusObjectManagerClient is not owned by anyone at
59 * object construction time, the default behavior is to request the
60 * message bus to launch an owner for the name. This behavior can be
61 * disabled using the %G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START
62 * flag. It's also worth noting that this only works if the name of
63 * interest is activatable in the first place. E.g. in some cases it
64 * is not possible to launch an owner for the requested name. In this
65 * case, #GDBusObjectManagerClient object construction still succeeds but
66 * there will be no object proxies
67 * (e.g. g_dbus_object_manager_get_objects() returns the empty list) and
68 * the #GDBusObjectManagerClient:name-owner property is %NULL.
69 *
70 * The owner of the requested name can come and go (for example
71 * consider a system service being restarted) – #GDBusObjectManagerClient
72 * handles this case too; simply connect to the #GObject::notify
73 * signal to watch for changes on the #GDBusObjectManagerClient:name-owner
74 * property. When the name owner vanishes, the behavior is that
75 * #GDBusObjectManagerClient:name-owner is set to %NULL (this includes
76 * emission of the #GObject::notify signal) and then
77 * #GDBusObjectManager::object-removed signals are synthesized
78 * for all currently existing object proxies. Since
79 * #GDBusObjectManagerClient:name-owner is %NULL when this happens, you can
80 * use this information to disambiguate a synthesized signal from a
81 * genuine signal caused by object removal on the remote
82 * #GDBusObjectManager. Similarly, when a new name owner appears,
83 * #GDBusObjectManager::object-added signals are synthesized
84 * while #GDBusObjectManagerClient:name-owner is still %NULL. Only when all
85 * object proxies have been added, the #GDBusObjectManagerClient:name-owner
86 * is set to the new name owner (this includes emission of the
87 * #GObject::notify signal).  Furthermore, you are guaranteed that
88 * #GDBusObjectManagerClient:name-owner will alternate between a name owner
89 * (e.g. `:1.42`) and %NULL even in the case where
90 * the name of interest is atomically replaced
91 *
92 * Ultimately, #GDBusObjectManagerClient is used to obtain #GDBusProxy
93 * instances. All signals (including the
94 * org.freedesktop.DBus.Properties::PropertiesChanged signal)
95 * delivered to #GDBusProxy instances are guaranteed to originate
96 * from the name owner. This guarantee along with the behavior
97 * described above, means that certain race conditions including the
98 * "half the proxy is from the old owner and the other half is from
99 * the new owner" problem cannot happen.
100 *
101 * To avoid having the application connect to signals on the returned
102 * #GDBusObjectProxy and #GDBusProxy objects, the
103 * #GDBusObject::interface-added,
104 * #GDBusObject::interface-removed,
105 * #GDBusProxy::g-properties-changed and
106 * #GDBusProxy::g-signal signals
107 * are also emitted on the #GDBusObjectManagerClient instance managing these
108 * objects. The signals emitted are
109 * #GDBusObjectManager::interface-added,
110 * #GDBusObjectManager::interface-removed,
111 * #GDBusObjectManagerClient::interface-proxy-properties-changed and
112 * #GDBusObjectManagerClient::interface-proxy-signal.
113 *
114 * Note that all callbacks and signals are emitted in the
115 * [thread-default main context][g-main-context-push-thread-default]
116 * that the #GDBusObjectManagerClient object was constructed
117 * in. Additionally, the #GDBusObjectProxy and #GDBusProxy objects
118 * originating from the #GDBusObjectManagerClient object will be created in
119 * the same context and, consequently, will deliver signals in the
120 * same main loop.
121 *
122 * Since: 2.30
123 */
124public class DBusObjectManagerClient : ObjectG, AsyncInitableIF, DBusObjectManagerIF, InitableIF
125{
126        /** the main Gtk struct */
127        protected GDBusObjectManagerClient* gDBusObjectManagerClient;
128
129        /** Get the main Gtk struct */
130        public GDBusObjectManagerClient* getDBusObjectManagerClientStruct()
131        {
132                return gDBusObjectManagerClient;
133        }
134
135        /** the main Gtk struct as a void* */
136        protected override void* getStruct()
137        {
138                return cast(void*)gDBusObjectManagerClient;
139        }
140
141        protected override void setStruct(GObject* obj)
142        {
143                gDBusObjectManagerClient = cast(GDBusObjectManagerClient*)obj;
144                super.setStruct(obj);
145        }
146
147        /**
148         * Sets our main struct and passes it to the parent class.
149         */
150        public this (GDBusObjectManagerClient* gDBusObjectManagerClient, bool ownedRef = false)
151        {
152                this.gDBusObjectManagerClient = gDBusObjectManagerClient;
153                super(cast(GObject*)gDBusObjectManagerClient, ownedRef);
154        }
155
156        // add the AsyncInitable capabilities
157        mixin AsyncInitableT!(GDBusObjectManagerClient);
158
159        // add the DBusObjectManager capabilities
160        mixin DBusObjectManagerT!(GDBusObjectManagerClient);
161
162        // add the Initable capabilities
163        mixin InitableT!(GDBusObjectManagerClient);
164
165        /**
166         * Finishes an operation started with g_dbus_object_manager_client_new().
167         *
168         * Params:
169         *     res    = A GAsyncResult obtained from the GAsyncReadyCallback passed to the DBusObjectManager constructor.
170         *     forBus = If true finish an address.
171         *
172         * Throws: GException on failure.
173         * Throws: ConstructionException GTK+ fails to create the object.
174         *
175         * Since: 2.30
176         */
177        public this (AsyncResultIF res, bool forBus = false)
178        {
179                GError* err = null;
180                GDBusObjectManager* p;
181               
182                if ( forBus )
183                {
184                        p = g_dbus_object_manager_client_new_for_bus_finish((res is null) ? null : res.getAsyncResultStruct(), &err);
185                }
186                else
187                {
188                        p = g_dbus_object_manager_client_new_finish((res is null) ? null : res.getAsyncResultStruct(), &err);
189                }
190               
191                if (err !is null)
192                {
193                        throw new GException( new ErrorG(err) );
194                }
195               
196                if(p is null)
197                {
198                        throw new ConstructionException("null returned by g_dbus_object_manager_client_new_finish((res is null) ? null : res.getAsyncResultStruct(), &err)");
199                }
200                this(cast(GDBusObjectManagerClient*) p, true);
201        }
202
203        /**
204         */
205
206        /** */
207        public static GType getType()
208        {
209                return g_dbus_object_manager_client_get_type();
210        }
211
212        /**
213         * Like g_dbus_object_manager_client_new_sync() but takes a #GBusType instead
214         * of a #GDBusConnection.
215         *
216         * This is a synchronous failable constructor - the calling thread is
217         * blocked until a reply is received. See g_dbus_object_manager_client_new_for_bus()
218         * for the asynchronous version.
219         *
220         * Params:
221         *     busType = A #GBusType.
222         *     flags = Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
223         *     name = The owner of the control object (unique or well-known name).
224         *     objectPath = The object path of the control object.
225         *     getProxyTypeFunc = A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
226         *     getProxyTypeUserData = User data to pass to @get_proxy_type_func.
227         *     getProxyTypeDestroyNotify = Free function for @get_proxy_type_user_data or %NULL.
228         *     cancellable = A #GCancellable or %NULL
229         *
230         * Returns: A
231         *     #GDBusObjectManagerClient object or %NULL if @error is set. Free
232         *     with g_object_unref().
233         *
234         * Since: 2.30
235         *
236         * Throws: GException on failure.
237         * Throws: ConstructionException GTK+ fails to create the object.
238         */
239        public this(GBusType busType, GDBusObjectManagerClientFlags flags, string name, string objectPath, GDBusProxyTypeFunc getProxyTypeFunc, void* getProxyTypeUserData, GDestroyNotify getProxyTypeDestroyNotify, Cancellable cancellable)
240        {
241                GError* err = null;
242               
243                auto p = g_dbus_object_manager_client_new_for_bus_sync(busType, flags, Str.toStringz(name), Str.toStringz(objectPath), getProxyTypeFunc, getProxyTypeUserData, getProxyTypeDestroyNotify, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
244               
245                if (err !is null)
246                {
247                        throw new GException( new ErrorG(err) );
248                }
249               
250                if(p is null)
251                {
252                        throw new ConstructionException("null returned by new_for_bus_sync");
253                }
254               
255                this(cast(GDBusObjectManagerClient*) p, true);
256        }
257
258        /**
259         * Creates a new #GDBusObjectManagerClient object.
260         *
261         * This is a synchronous failable constructor - the calling thread is
262         * blocked until a reply is received. See g_dbus_object_manager_client_new()
263         * for the asynchronous version.
264         *
265         * Params:
266         *     connection = A #GDBusConnection.
267         *     flags = Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
268         *     name = The owner of the control object (unique or well-known name), or %NULL when not using a message bus connection.
269         *     objectPath = The object path of the control object.
270         *     getProxyTypeFunc = A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
271         *     getProxyTypeUserData = User data to pass to @get_proxy_type_func.
272         *     getProxyTypeDestroyNotify = Free function for @get_proxy_type_user_data or %NULL.
273         *     cancellable = A #GCancellable or %NULL
274         *
275         * Returns: A
276         *     #GDBusObjectManagerClient object or %NULL if @error is set. Free
277         *     with g_object_unref().
278         *
279         * Since: 2.30
280         *
281         * Throws: GException on failure.
282         * Throws: ConstructionException GTK+ fails to create the object.
283         */
284        public this(DBusConnection connection, GDBusObjectManagerClientFlags flags, string name, string objectPath, GDBusProxyTypeFunc getProxyTypeFunc, void* getProxyTypeUserData, GDestroyNotify getProxyTypeDestroyNotify, Cancellable cancellable)
285        {
286                GError* err = null;
287               
288                auto p = g_dbus_object_manager_client_new_sync((connection is null) ? null : connection.getDBusConnectionStruct(), flags, Str.toStringz(name), Str.toStringz(objectPath), getProxyTypeFunc, getProxyTypeUserData, getProxyTypeDestroyNotify, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
289               
290                if (err !is null)
291                {
292                        throw new GException( new ErrorG(err) );
293                }
294               
295                if(p is null)
296                {
297                        throw new ConstructionException("null returned by new_sync");
298                }
299               
300                this(cast(GDBusObjectManagerClient*) p, true);
301        }
302
303        /**
304         * Asynchronously creates a new #GDBusObjectManagerClient object.
305         *
306         * This is an asynchronous failable constructor. When the result is
307         * ready, @callback will be invoked in the
308         * [thread-default main context][g-main-context-push-thread-default]
309         * of the thread you are calling this method from. You can
310         * then call g_dbus_object_manager_client_new_finish() to get the result. See
311         * g_dbus_object_manager_client_new_sync() for the synchronous version.
312         *
313         * Params:
314         *     connection = A #GDBusConnection.
315         *     flags = Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
316         *     name = The owner of the control object (unique or well-known name).
317         *     objectPath = The object path of the control object.
318         *     getProxyTypeFunc = A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
319         *     getProxyTypeUserData = User data to pass to @get_proxy_type_func.
320         *     getProxyTypeDestroyNotify = Free function for @get_proxy_type_user_data or %NULL.
321         *     cancellable = A #GCancellable or %NULL
322         *     callback = A #GAsyncReadyCallback to call when the request is satisfied.
323         *     userData = The data to pass to @callback.
324         *
325         * Since: 2.30
326         */
327        public static void newObjectManagerClient(DBusConnection connection, GDBusObjectManagerClientFlags flags, string name, string objectPath, GDBusProxyTypeFunc getProxyTypeFunc, void* getProxyTypeUserData, GDestroyNotify getProxyTypeDestroyNotify, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
328        {
329                g_dbus_object_manager_client_new((connection is null) ? null : connection.getDBusConnectionStruct(), flags, Str.toStringz(name), Str.toStringz(objectPath), getProxyTypeFunc, getProxyTypeUserData, getProxyTypeDestroyNotify, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
330        }
331
332        /**
333         * Like g_dbus_object_manager_client_new() but takes a #GBusType instead of a
334         * #GDBusConnection.
335         *
336         * This is an asynchronous failable constructor. When the result is
337         * ready, @callback will be invoked in the
338         * [thread-default main loop][g-main-context-push-thread-default]
339         * of the thread you are calling this method from. You can
340         * then call g_dbus_object_manager_client_new_for_bus_finish() to get the result. See
341         * g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.
342         *
343         * Params:
344         *     busType = A #GBusType.
345         *     flags = Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
346         *     name = The owner of the control object (unique or well-known name).
347         *     objectPath = The object path of the control object.
348         *     getProxyTypeFunc = A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
349         *     getProxyTypeUserData = User data to pass to @get_proxy_type_func.
350         *     getProxyTypeDestroyNotify = Free function for @get_proxy_type_user_data or %NULL.
351         *     cancellable = A #GCancellable or %NULL
352         *     callback = A #GAsyncReadyCallback to call when the request is satisfied.
353         *     userData = The data to pass to @callback.
354         *
355         * Since: 2.30
356         */
357        public static void newForBus(GBusType busType, GDBusObjectManagerClientFlags flags, string name, string objectPath, GDBusProxyTypeFunc getProxyTypeFunc, void* getProxyTypeUserData, GDestroyNotify getProxyTypeDestroyNotify, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
358        {
359                g_dbus_object_manager_client_new_for_bus(busType, flags, Str.toStringz(name), Str.toStringz(objectPath), getProxyTypeFunc, getProxyTypeUserData, getProxyTypeDestroyNotify, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
360        }
361
362        /**
363         * Gets the #GDBusConnection used by @manager.
364         *
365         * Returns: A #GDBusConnection object. Do not free,
366         *     the object belongs to @manager.
367         *
368         * Since: 2.30
369         */
370        public DBusConnection getConnection()
371        {
372                auto p = g_dbus_object_manager_client_get_connection(gDBusObjectManagerClient);
373               
374                if(p is null)
375                {
376                        return null;
377                }
378               
379                return ObjectG.getDObject!(DBusConnection)(cast(GDBusConnection*) p);
380        }
381
382        /**
383         * Gets the flags that @manager was constructed with.
384         *
385         * Returns: Zero of more flags from the #GDBusObjectManagerClientFlags
386         *     enumeration.
387         *
388         * Since: 2.30
389         */
390        public GDBusObjectManagerClientFlags getFlags()
391        {
392                return g_dbus_object_manager_client_get_flags(gDBusObjectManagerClient);
393        }
394
395        /**
396         * Gets the name that @manager is for, or %NULL if not a message bus
397         * connection.
398         *
399         * Returns: A unique or well-known name. Do not free, the string
400         *     belongs to @manager.
401         *
402         * Since: 2.30
403         */
404        public string getName()
405        {
406                return Str.toString(g_dbus_object_manager_client_get_name(gDBusObjectManagerClient));
407        }
408
409        /**
410         * The unique name that owns the name that @manager is for or %NULL if
411         * no-one currently owns that name. You can connect to the
412         * #GObject::notify signal to track changes to the
413         * #GDBusObjectManagerClient:name-owner property.
414         *
415         * Returns: The name owner or %NULL if no name owner
416         *     exists. Free with g_free().
417         *
418         * Since: 2.30
419         */
420        public string getNameOwner()
421        {
422                auto retStr = g_dbus_object_manager_client_get_name_owner(gDBusObjectManagerClient);
423               
424                scope(exit) Str.freeString(retStr);
425                return Str.toString(retStr);
426        }
427
428        protected class OnInterfaceProxyPropertiesChangedDelegateWrapper
429        {
430                static OnInterfaceProxyPropertiesChangedDelegateWrapper[] listeners;
431                void delegate(DBusObjectProxy, DBusProxy, Variant, string[], DBusObjectManagerClient) dlg;
432                gulong handlerId;
433               
434                this(void delegate(DBusObjectProxy, DBusProxy, Variant, string[], DBusObjectManagerClient) dlg)
435                {
436                        this.dlg = dlg;
437                        this.listeners ~= this;
438                }
439               
440                void remove(OnInterfaceProxyPropertiesChangedDelegateWrapper source)
441                {
442                        foreach(index, wrapper; listeners)
443                        {
444                                if (wrapper.handlerId == source.handlerId)
445                                {
446                                        listeners[index] = null;
447                                        listeners = std.algorithm.remove(listeners, index);
448                                        break;
449                                }
450                        }
451                }
452        }
453
454        /**
455         * Emitted when one or more D-Bus properties on proxy changes. The
456         * local cache has already been updated when this signal fires. Note
457         * that both @changed_properties and @invalidated_properties are
458         * guaranteed to never be %NULL (either may be empty though).
459         *
460         * This signal exists purely as a convenience to avoid having to
461         * connect signals to all interface proxies managed by @manager.
462         *
463         * This signal is emitted in the
464         * [thread-default main context][g-main-context-push-thread-default]
465         * that @manager was constructed in.
466         *
467         * Params:
468         *     objectProxy = The #GDBusObjectProxy on which an interface has properties that are changing.
469         *     interfaceProxy = The #GDBusProxy that has properties that are changing.
470         *     changedProperties = A #GVariant containing the properties that changed.
471         *     invalidatedProperties = A %NULL terminated array of properties that was invalidated.
472         *
473         * Since: 2.30
474         */
475        gulong addOnInterfaceProxyPropertiesChanged(void delegate(DBusObjectProxy, DBusProxy, Variant, string[], DBusObjectManagerClient) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
476        {
477                auto wrapper = new OnInterfaceProxyPropertiesChangedDelegateWrapper(dlg);
478                wrapper.handlerId = Signals.connectData(
479                        this,
480                        "interface-proxy-properties-changed",
481                        cast(GCallback)&callBackInterfaceProxyPropertiesChanged,
482                        cast(void*)wrapper,
483                        cast(GClosureNotify)&callBackInterfaceProxyPropertiesChangedDestroy,
484                        connectFlags);
485                return wrapper.handlerId;
486        }
487       
488        extern(C) static void callBackInterfaceProxyPropertiesChanged(GDBusObjectManagerClient* dbusobjectmanagerclientStruct, GDBusObjectProxy* objectProxy, GDBusProxy* interfaceProxy, GVariant* changedProperties, char** invalidatedProperties, OnInterfaceProxyPropertiesChangedDelegateWrapper wrapper)
489        {
490                wrapper.dlg(ObjectG.getDObject!(DBusObjectProxy)(objectProxy), ObjectG.getDObject!(DBusProxy)(interfaceProxy), new Variant(changedProperties), Str.toStringArray(invalidatedProperties), wrapper.outer);
491        }
492       
493        extern(C) static void callBackInterfaceProxyPropertiesChangedDestroy(OnInterfaceProxyPropertiesChangedDelegateWrapper wrapper, GClosure* closure)
494        {
495                wrapper.remove(wrapper);
496        }
497
498        protected class OnInterfaceProxySignalDelegateWrapper
499        {
500                static OnInterfaceProxySignalDelegateWrapper[] listeners;
501                void delegate(DBusObjectProxy, DBusProxy, string, string, Variant, DBusObjectManagerClient) dlg;
502                gulong handlerId;
503               
504                this(void delegate(DBusObjectProxy, DBusProxy, string, string, Variant, DBusObjectManagerClient) dlg)
505                {
506                        this.dlg = dlg;
507                        this.listeners ~= this;
508                }
509               
510                void remove(OnInterfaceProxySignalDelegateWrapper source)
511                {
512                        foreach(index, wrapper; listeners)
513                        {
514                                if (wrapper.handlerId == source.handlerId)
515                                {
516                                        listeners[index] = null;
517                                        listeners = std.algorithm.remove(listeners, index);
518                                        break;
519                                }
520                        }
521                }
522        }
523
524        /**
525         * Emitted when a D-Bus signal is received on @interface_proxy.
526         *
527         * This signal exists purely as a convenience to avoid having to
528         * connect signals to all interface proxies managed by @manager.
529         *
530         * This signal is emitted in the
531         * [thread-default main context][g-main-context-push-thread-default]
532         * that @manager was constructed in.
533         *
534         * Params:
535         *     objectProxy = The #GDBusObjectProxy on which an interface is emitting a D-Bus signal.
536         *     interfaceProxy = The #GDBusProxy that is emitting a D-Bus signal.
537         *     senderName = The sender of the signal or NULL if the connection is not a bus connection.
538         *     signalName = The signal name.
539         *     parameters = A #GVariant tuple with parameters for the signal.
540         *
541         * Since: 2.30
542         */
543        gulong addOnInterfaceProxySignal(void delegate(DBusObjectProxy, DBusProxy, string, string, Variant, DBusObjectManagerClient) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
544        {
545                auto wrapper = new OnInterfaceProxySignalDelegateWrapper(dlg);
546                wrapper.handlerId = Signals.connectData(
547                        this,
548                        "interface-proxy-signal",
549                        cast(GCallback)&callBackInterfaceProxySignal,
550                        cast(void*)wrapper,
551                        cast(GClosureNotify)&callBackInterfaceProxySignalDestroy,
552                        connectFlags);
553                return wrapper.handlerId;
554        }
555       
556        extern(C) static void callBackInterfaceProxySignal(GDBusObjectManagerClient* dbusobjectmanagerclientStruct, GDBusObjectProxy* objectProxy, GDBusProxy* interfaceProxy, char* senderName, char* signalName, GVariant* parameters, OnInterfaceProxySignalDelegateWrapper wrapper)
557        {
558                wrapper.dlg(ObjectG.getDObject!(DBusObjectProxy)(objectProxy), ObjectG.getDObject!(DBusProxy)(interfaceProxy), Str.toString(senderName), Str.toString(signalName), new Variant(parameters), wrapper.outer);
559        }
560       
561        extern(C) static void callBackInterfaceProxySignalDestroy(OnInterfaceProxySignalDelegateWrapper wrapper, GClosure* closure)
562        {
563                wrapper.remove(wrapper);
564        }
565}
Note: See TracBrowser for help on using the repository browser.