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