root/trunk/src/gio/DBusProxy.d

/*
 * This file is part of gtkD.
 *
 * gtkD is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version, with
 * some exceptions, please read the COPYING file.
 *
 * gtkD is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with gtkD; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
 */
 
// generated automatically - do not change
// find conversion definition on APILookup.txt
// implement new conversion functionalities on the wrap.utils pakage

/*
 * Conversion parameters:
 * inFile  = GDBusProxy.html
 * outPack = gio
 * outFile = DBusProxy
 * strct   = GDBusProxy
 * realStrct=
 * ctorStrct=
 * clss    = DBusProxy
 * interf  = 
 * class Code: Yes
 * interface Code: No
 * template for:
 * extend  = GObject
 * implements:
 * prefixes:
 *  - g_dbus_proxy_
 * omit structs:
 * omit prefixes:
 * omit code:
 *  - g_dbus_proxy_new_finish
 *  - g_dbus_proxy_new_for_bus_finish
 * omit signals:
 * imports:
 *  - glib.Str
 *  - glib.ErrorG
 *  - glib.GException
 *  - glib.Variant
 *  - gio.AsyncResultIF
 *  - gio.Cancellable
 *  - gio.DBusConnection
 * structWrap:
 *  - GAsyncResult* -> AsyncResultIF
 *  - GCancellable* -> Cancellable
 *  - GDBusConnection* -> DBusConnection
 *  - GVariant* -> Variant
 * module aliases:
 * local aliases:
 * overrides:
 */

module gio.DBusProxy;

public  import gtkc.giotypes;

private import gtkc.gio;
private import glib.ConstructionException;

private import gobject.Signals;
public  import gtkc.gdktypes;

private import glib.Str;
private import glib.ErrorG;
private import glib.GException;
private import glib.Variant;
private import gio.AsyncResultIF;
private import gio.Cancellable;
private import gio.DBusConnection;



private import gobject.ObjectG;

/**
 * Description
 * GDBusProxy is a base class used for proxies to access a D-Bus
 * interface on a remote object. A GDBusProxy can be constructed for
 * both well-known and unique names.
 * By default, GDBusProxy will cache all properties (and listen to
 * changes) of the remote object, and proxy all signals that gets
 * emitted. This behaviour can be changed by passing suitable
 * GDBusProxyFlags when the proxy is created. If the proxy is for a
 * well-known name, the property cache is flushed when the name owner
 * vanishes and reloaded when a name owner appears.
 * If a GDBusProxy is used for a well-known name, the owner of the
 * name is tracked and can be read from
 * "g-name-owner". Connect to the "notify" signal to
 * get notified of changes. Additionally, only signals and property
 * changes emitted from the current name owner are considered and
 * calls are always sent to the current name owner. This avoids a
 * number of race conditions when the name is lost by one owner and
 * claimed by another. However, if no name owner currently exists,
 * then calls will be sent to the well-known name which may result in
 * the message bus launching an owner (unless
 * G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START is set).
 * The generic "g-properties-changed" and "g-signal"
 * signals are not very convenient to work with. Therefore, the recommended
 * way of working with proxies is to subclass GDBusProxy, and have
 * more natural properties and signals in your derived class.
 * See Example 19, “GDBusProxy subclass example” for an example.
 * $(DDOC_COMMENT example)
 */
public class DBusProxy : ObjectG
{
    
    /** the main Gtk struct */
    protected GDBusProxy* gDBusProxy;
    
    
    public GDBusProxy* getDBusProxyStruct()
    {
        return gDBusProxy;
    }
    
    
    /** the main Gtk struct as a void* */
    protected override void* getStruct()
    {
        return cast(void*)gDBusProxy;
    }
    
    /**
     * Sets our main struct and passes it to the parent class
     */
    public this (GDBusProxy* gDBusProxy)
    {
        if(gDBusProxy is null)
        {
            this = null;
            return;
        }
        //Check if there already is a D object for this gtk struct
        void* ptr = getDObject(cast(GObject*)gDBusProxy);
        if( ptr !is null )
        {
            this = cast(DBusProxy)ptr;
            return;
        }
        super(cast(GObject*)gDBusProxy);
        this.gDBusProxy = gDBusProxy;
    }
    
    protected override void setStruct(GObject* obj)
    {
        super.setStruct(obj);
        gDBusProxy = cast(GDBusProxy*)obj;
    }
    
    /**
     * Finishes creating a GDBusProxy.
     * Since 2.26
     * Params:
     *     res    = A GAsyncResult obtained from the GAsyncReadyCallback
     *              function passed to g_dbus_proxy_new().
     *     forBus = If true finish an address.
     * Throws: GException on failure.
     * Throws: ConstructionException GTK+ fails to create the object.
     */
    public this (AsyncResultIF res, bool forBus = false)
    {
        // GDBusProxy * g_dbus_proxy_new_finish (GAsyncResult *res,  GError **error);
        GError* err = null;
        GDBusProxy* p;
        
        if ( forBus )
        {
            p = g_dbus_proxy_new_for_bus_finish((res is null) ? null : res.getAsyncResultTStruct(), &err);
        }
        else
        {
            p = g_dbus_proxy_new_finish((res is null) ? null : res.getAsyncResultTStruct(), &err);
        }
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            throw new ConstructionException("null returned by g_dbus_proxy_new_finish((res is null) ? null : res.getAsyncResultTStruct(), &err)");
        }
        this(cast(GDBusProxy*) p);
    }
    
    /**
     */
    int[string] connectedSignals;
    
    void delegate(Variant, GStrv, DBusProxy)[] onGPropertiesChangedListeners;
    /**
     * Emitted when one or more D-Bus properties on proxy changes. The
     * local cache has already been updated when this signal fires. Note
     * that both changed_properties and invalidated_properties are
     * guaranteed to never be NULL (either may be empty though).
     * This signal corresponds to the
     * PropertiesChanged D-Bus signal on the
     * org.freedesktop.DBus.Properties interface.
     * Since 2.26
     */
    void addOnGPropertiesChanged(void delegate(Variant, GStrv, DBusProxy) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
    {
        if ( !("g-properties-changed" in connectedSignals) )
        {
            Signals.connectData(
            getStruct(),
            "g-properties-changed",
            cast(GCallback)&callBackGPropertiesChanged,
            cast(void*)this,
            null,
            connectFlags);
            connectedSignals["g-properties-changed"] = 1;
        }
        onGPropertiesChangedListeners ~= dlg;
    }
    extern(C) static void callBackGPropertiesChanged(GDBusProxy* proxyStruct, GVariant* changedProperties, GStrv invalidatedProperties, DBusProxy dBusProxy)
    {
        foreach ( void delegate(Variant, GStrv, DBusProxy) dlg ; dBusProxy.onGPropertiesChangedListeners )
        {
            dlg(new Variant(changedProperties), invalidatedProperties, dBusProxy);
        }
    }
    
    void delegate(string, string, Variant, DBusProxy)[] onGSignalListeners;
    /**
     * Emitted when a signal from the remote object and interface that proxy is for, has been received.
     * Since 2.26
     */
    void addOnGSignal(void delegate(string, string, Variant, DBusProxy) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
    {
        if ( !("g-signal" in connectedSignals) )
        {
            Signals.connectData(
            getStruct(),
            "g-signal",
            cast(GCallback)&callBackGSignal,
            cast(void*)this,
            null,
            connectFlags);
            connectedSignals["g-signal"] = 1;
        }
        onGSignalListeners ~= dlg;
    }
    extern(C) static void callBackGSignal(GDBusProxy* proxyStruct, gchar* senderName, gchar* signalName, GVariant* parameters, DBusProxy dBusProxy)
    {
        foreach ( void delegate(string, string, Variant, DBusProxy) dlg ; dBusProxy.onGSignalListeners )
        {
            dlg(Str.toString(senderName), Str.toString(signalName), new Variant(parameters), dBusProxy);
        }
    }
    
    
    /**
     * Creates a proxy for accessing interface_name on the remote object
     * at object_path owned by name at connection and asynchronously
     * loads D-Bus properties unless the
     * G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used. Connect to
     * the "g-properties-changed" signal to get notified about
     * property changes.
     * If the G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up
     * match rules for signals. Connect to the "g-signal" signal
     * to handle signals from the remote object.
     * If name is a well-known name and the
     * G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START flag isn't set and no name
     * owner currently exists, the message bus will be requested to launch
     * a name owner for the name.
     * This is a failable asynchronous constructor - when the proxy is
     * ready, callback will be invoked and you can use
     * g_dbus_proxy_new_finish() to get the result.
     * See g_dbus_proxy_new_sync() and for a synchronous version of this constructor.
     * See Example 10, “GDBusProxy for a well-known-name” for an example of how GDBusProxy can be used.
     * Since 2.26
     * Params:
     * connection = A GDBusConnection.
     * flags = Flags used when constructing the proxy.
     * info = A GDBusInterfaceInfo specifying the minimal interface that proxy conforms to or NULL. [allow-none]
     * name = A bus name (well-known or unique) or NULL if connection is not a message bus connection. [allow-none]
     * objectPath = An object path.
     * interfaceName = A D-Bus interface name.
     * cancellable = A GCancellable or NULL.
     * callback = Callback function to invoke when the proxy is ready.
     * userData = User data to pass to callback.
     */
    public static void newDBusProxy(DBusConnection connection, GDBusProxyFlags flags, GDBusInterfaceInfo* info, string name, string objectPath, string interfaceName, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
    {
        // void g_dbus_proxy_new (GDBusConnection *connection,  GDBusProxyFlags flags,  GDBusInterfaceInfo *info,  const gchar *name,  const gchar *object_path,  const gchar *interface_name,  GCancellable *cancellable,  GAsyncReadyCallback callback,  gpointer user_data);
        g_dbus_proxy_new((connection is null) ? null : connection.getDBusConnectionStruct(), flags, info, Str.toStringz(name), Str.toStringz(objectPath), Str.toStringz(interfaceName), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
    }
    
    /**
     * Creates a proxy for accessing interface_name on the remote object
     * at object_path owned by name at connection and synchronously
     * loads D-Bus properties unless the
     * G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used.
     * If the G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up
     * match rules for signals. Connect to the "g-signal" signal
     * to handle signals from the remote object.
     * If name is a well-known name and the
     * G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START flag isn't set and no name
     * owner currently exists, the message bus will be requested to launch
     * a name owner for the name.
     * This is a synchronous failable constructor. See g_dbus_proxy_new()
     * and g_dbus_proxy_new_finish() for the asynchronous version.
     * See Example 10, “GDBusProxy for a well-known-name” for an example of how GDBusProxy can be used.
     * Since 2.26
     * Params:
     * connection = A GDBusConnection.
     * flags = Flags used when constructing the proxy.
     * info = A GDBusInterfaceInfo specifying the minimal interface that proxy conforms to or NULL. [allow-none]
     * name = A bus name (well-known or unique) or NULL if connection is not a message bus connection. [allow-none]
     * objectPath = An object path.
     * interfaceName = A D-Bus interface name.
     * cancellable = A GCancellable or NULL. [allow-none]
     * Throws: GException on failure.
     * Throws: ConstructionException GTK+ fails to create the object.
     */
    public this (DBusConnection connection, GDBusProxyFlags flags, GDBusInterfaceInfo* info, string name, string objectPath, string interfaceName, Cancellable cancellable)
    {
        // GDBusProxy * g_dbus_proxy_new_sync (GDBusConnection *connection,  GDBusProxyFlags flags,  GDBusInterfaceInfo *info,  const gchar *name,  const gchar *object_path,  const gchar *interface_name,  GCancellable *cancellable,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_proxy_new_sync((connection is null) ? null : connection.getDBusConnectionStruct(), flags, info, Str.toStringz(name), Str.toStringz(objectPath), Str.toStringz(interfaceName), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            throw new ConstructionException("null returned by g_dbus_proxy_new_sync((connection is null) ? null : connection.getDBusConnectionStruct(), flags, info, Str.toStringz(name), Str.toStringz(objectPath), Str.toStringz(interfaceName), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err)");
        }
        this(cast(GDBusProxy*) p);
    }
    
    /**
     * Like g_dbus_proxy_new() but takes a GBusType instead of a GDBusConnection.
     * See Example 10, “GDBusProxy for a well-known-name” for an example of how GDBusProxy can be used.
     * Since 2.26
     * Params:
     * busType = A GBusType.
     * flags = Flags used when constructing the proxy.
     * info = A GDBusInterfaceInfo specifying the minimal interface that proxy conforms to or NULL. [allow-none]
     * name = A bus name (well-known or unique).
     * objectPath = An object path.
     * interfaceName = A D-Bus interface name.
     * cancellable = A GCancellable or NULL.
     * callback = Callback function to invoke when the proxy is ready.
     * userData = User data to pass to callback.
     */
    public static void newForBus(GBusType busType, GDBusProxyFlags flags, GDBusInterfaceInfo* info, string name, string objectPath, string interfaceName, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
    {
        // void g_dbus_proxy_new_for_bus (GBusType bus_type,  GDBusProxyFlags flags,  GDBusInterfaceInfo *info,  const gchar *name,  const gchar *object_path,  const gchar *interface_name,  GCancellable *cancellable,  GAsyncReadyCallback callback,  gpointer user_data);
        g_dbus_proxy_new_for_bus(busType, flags, info, Str.toStringz(name), Str.toStringz(objectPath), Str.toStringz(interfaceName), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
    }
    
    /**
     * Like g_dbus_proxy_new_sync() but takes a GBusType instead of a GDBusConnection.
     * See Example 10, “GDBusProxy for a well-known-name” for an example of how GDBusProxy can be used.
     * Since 2.26
     * Params:
     * busType = A GBusType.
     * flags = Flags used when constructing the proxy.
     * info = A GDBusInterfaceInfo specifying the minimal interface
     * that proxy conforms to or NULL. [allow-none]
     * name = A bus name (well-known or unique).
     * objectPath = An object path.
     * interfaceName = A D-Bus interface name.
     * cancellable = A GCancellable or NULL.
     * Throws: GException on failure.
     * Throws: ConstructionException GTK+ fails to create the object.
     */
    public this (GBusType busType, GDBusProxyFlags flags, GDBusInterfaceInfo* info, string name, string objectPath, string interfaceName, Cancellable cancellable)
    {
        // GDBusProxy * g_dbus_proxy_new_for_bus_sync (GBusType bus_type,  GDBusProxyFlags flags,  GDBusInterfaceInfo *info,  const gchar *name,  const gchar *object_path,  const gchar *interface_name,  GCancellable *cancellable,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_proxy_new_for_bus_sync(busType, flags, info, Str.toStringz(name), Str.toStringz(objectPath), Str.toStringz(interfaceName), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            throw new ConstructionException("null returned by g_dbus_proxy_new_for_bus_sync(busType, flags, info, Str.toStringz(name), Str.toStringz(objectPath), Str.toStringz(interfaceName), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err)");
        }
        this(cast(GDBusProxy*) p);
    }
    
    /**
     * Gets the flags that proxy was constructed with.
     * Since 2.26
     * Returns: Flags from the GDBusProxyFlags enumeration.
     */
    public GDBusProxyFlags getFlags()
    {
        // GDBusProxyFlags g_dbus_proxy_get_flags (GDBusProxy *proxy);
        return g_dbus_proxy_get_flags(gDBusProxy);
    }
    
    /**
     * Gets the connection proxy is for.
     * Since 2.26
     * Returns: A GDBusConnection owned by proxy. Do not free. [transfer none]
     */
    public DBusConnection getConnection()
    {
        // GDBusConnection * g_dbus_proxy_get_connection (GDBusProxy *proxy);
        auto p = g_dbus_proxy_get_connection(gDBusProxy);
        if(p is null)
        {
            return null;
        }
        return new DBusConnection(cast(GDBusConnection*) p);
    }
    
    /**
     * Gets the name that proxy was constructed for.
     * Since 2.26
     * Returns: A string owned by proxy. Do not free.
     */
    public string getName()
    {
        // const gchar * g_dbus_proxy_get_name (GDBusProxy *proxy);
        return Str.toString(g_dbus_proxy_get_name(gDBusProxy));
    }
    
    /**
     * The unique name that owns the name that proxy is for or NULL if
     * no-one currently owns that name. You may connect to the
     * "notify" signal to track changes to the
     * "g-name-owner" property.
     * Since 2.26
     * Returns: The name owner or NULL if no name owner exists. Free with g_free().
     */
    public string getNameOwner()
    {
        // gchar * g_dbus_proxy_get_name_owner (GDBusProxy *proxy);
        return Str.toString(g_dbus_proxy_get_name_owner(gDBusProxy));
    }
    
    /**
     * Gets the object path proxy is for.
     * Since 2.26
     * Returns: A string owned by proxy. Do not free.
     */
    public string getObjectPath()
    {
        // const gchar * g_dbus_proxy_get_object_path (GDBusProxy *proxy);
        return Str.toString(g_dbus_proxy_get_object_path(gDBusProxy));
    }
    
    /**
     * Gets the D-Bus interface name proxy is for.
     * Since 2.26
     * Returns: A string owned by proxy. Do not free.
     */
    public string getInterfaceName()
    {
        // const gchar * g_dbus_proxy_get_interface_name (GDBusProxy *proxy);
        return Str.toString(g_dbus_proxy_get_interface_name(gDBusProxy));
    }
    
    /**
     * Gets the timeout to use if -1 (specifying default timeout) is
     * passed as timeout_msec in the g_dbus_proxy_call() and
     * g_dbus_proxy_call_sync() functions.
     * See the "g-default-timeout" property for more details.
     * Since 2.26
     * Returns: Timeout to use for proxy.
     */
    public int getDefaultTimeout()
    {
        // gint g_dbus_proxy_get_default_timeout (GDBusProxy *proxy);
        return g_dbus_proxy_get_default_timeout(gDBusProxy);
    }
    
    /**
     * Sets the timeout to use if -1 (specifying default timeout) is
     * passed as timeout_msec in the g_dbus_proxy_call() and
     * g_dbus_proxy_call_sync() functions.
     * See the "g-default-timeout" property for more details.
     * Since 2.26
     * Params:
     * timeoutMsec = Timeout in milliseconds.
     */
    public void setDefaultTimeout(int timeoutMsec)
    {
        // void g_dbus_proxy_set_default_timeout (GDBusProxy *proxy,  gint timeout_msec);
        g_dbus_proxy_set_default_timeout(gDBusProxy, timeoutMsec);
    }
    
    /**
     * Looks up the value for a property from the cache. This call does no
     * blocking IO.
     * If proxy has an expected interface (see
     * "g-interface-info"), then property_name (for existence)
     * is checked against it.
     * Since 2.26
     * Params:
     * propertyName = Property name.
     * Returns: A reference to the GVariant instance that holds the value for property_name or NULL if the value is not in the cache. The returned reference must be freed with g_variant_unref().
     */
    public Variant getCachedProperty(string propertyName)
    {
        // GVariant * g_dbus_proxy_get_cached_property (GDBusProxy *proxy,  const gchar *property_name);
        auto p = g_dbus_proxy_get_cached_property(gDBusProxy, Str.toStringz(propertyName));
        if(p is null)
        {
            return null;
        }
        return new Variant(cast(GVariant*) p);
    }
    
    /**
     * If value is not NULL, sets the cached value for the property with
     * name property_name to the value in value.
     * If value is NULL, then the cached value is removed from the
     * property cache.
     * If proxy has an expected interface (see
     * "g-interface-info"), then property_name (for existence)
     * and value (for the type) is checked against it.
     * If the value GVariant is floating, it is consumed. This allows
     * convenient 'inline' use of g_variant_new(), e.g.
     * $(DDOC_COMMENT example)
     * Normally you will not need to use this method since proxy is
     * tracking changes using the
     * org.freedesktop.DBus.Properties.PropertiesChanged
     * D-Bus signal. However, for performance reasons an object may decide
     * to not use this signal for some properties and instead use a
     * proprietary out-of-band mechanism to transmit changes.
     * As a concrete example, consider an object with a property
     * ChatroomParticipants which is an array of
     * strings. Instead of transmitting the same (long) array every time
     * the property changes, it is more efficient to only transmit the
     * delta using e.g. signals ChatroomParticipantJoined(String
     * name) and ChatroomParticipantParted(String
     * name).
     * Since 2.26
     * Params:
     * propertyName = Property name.
     * value = Value for the property or NULL to remove it from the cache. [allow-none]
     */
    public void setCachedProperty(string propertyName, Variant value)
    {
        // void g_dbus_proxy_set_cached_property (GDBusProxy *proxy,  const gchar *property_name,  GVariant *value);
        g_dbus_proxy_set_cached_property(gDBusProxy, Str.toStringz(propertyName), (value is null) ? null : value.getVariantStruct());
    }
    
    /**
     * Gets the names of all cached properties on proxy.
     * Since 2.26
     * Returns: A NULL-terminated array of strings or NULL if proxy has no cached properties. Free the returned array with g_strfreev().
     */
    public string[] getCachedPropertyNames()
    {
        // gchar ** g_dbus_proxy_get_cached_property_names  (GDBusProxy *proxy);
        return Str.toStringArray(g_dbus_proxy_get_cached_property_names(gDBusProxy));
    }
    
    /**
     * Ensure that interactions with proxy conform to the given
     * interface. For example, when completing a method call, if the type
     * signature of the message isn't what's expected, the given GError
     * is set. Signals that have a type signature mismatch are simply
     * dropped.
     * See the "g-interface-info" property for more details.
     * Since 2.26
     * Params:
     * info = Minimum interface this proxy conforms to or NULL to unset. [allow-none]
     */
    public void setInterfaceInfo(GDBusInterfaceInfo* info)
    {
        // void g_dbus_proxy_set_interface_info (GDBusProxy *proxy,  GDBusInterfaceInfo *info);
        g_dbus_proxy_set_interface_info(gDBusProxy, info);
    }
    
    /**
     * Returns the GDBusInterfaceInfo, if any, specifying the minimal
     * interface that proxy conforms to.
     * See the "g-interface-info" property for more details.
     * Since 2.26
     * Returns: A GDBusInterfaceInfo or NULL. Do not unref the returned object, it is owned by proxy.
     */
    public GDBusInterfaceInfo* getInterfaceInfo()
    {
        // GDBusInterfaceInfo * g_dbus_proxy_get_interface_info (GDBusProxy *proxy);
        return g_dbus_proxy_get_interface_info(gDBusProxy);
    }
    
    /**
     * Asynchronously invokes the method_name method on proxy.
     * If method_name contains any dots, then name is split into interface and
     * method name parts. This allows using proxy for invoking methods on
     * other interfaces.
     * If the GDBusConnection associated with proxy is closed then
     * the operation will fail with G_IO_ERROR_CLOSED. If
     * cancellable is canceled, the operation will fail with
     * G_IO_ERROR_CANCELLED. If parameters contains a value not
     * compatible with the D-Bus protocol, the operation fails with
     * G_IO_ERROR_INVALID_ARGUMENT.
     * If the parameters GVariant is floating, it is consumed. This allows
     * Since 2.26
     * Params:
     * methodName = Name of method to invoke.
     * parameters = A GVariant tuple with parameters for the signal or NULL if not passing parameters. [allow-none]
     * flags = Flags from the GDBusCallFlags enumeration.
     * timeoutMsec = The timeout in milliseconds (with G_MAXINT meaning
     * "infinite") or -1 to use the proxy default timeout.
     * cancellable = A GCancellable or NULL.
     * callback = A GAsyncReadyCallback to call when the request is satisfied or NULL if you don't
     * care about the result of the method invocation.
     * userData = The data to pass to callback.
     */
    public void call(string methodName, Variant parameters, GDBusCallFlags flags, int timeoutMsec, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
    {
        // void g_dbus_proxy_call (GDBusProxy *proxy,  const gchar *method_name,  GVariant *parameters,  GDBusCallFlags flags,  gint timeout_msec,  GCancellable *cancellable,  GAsyncReadyCallback callback,  gpointer user_data);
        g_dbus_proxy_call(gDBusProxy, Str.toStringz(methodName), (parameters is null) ? null : parameters.getVariantStruct(), flags, timeoutMsec, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
    }
    
    /**
     * Finishes an operation started with g_dbus_proxy_call().
     * Since 2.26
     * Params:
     * res = A GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_proxy_call().
     * Returns: NULL if error is set. Otherwise a GVariant tuple with return values. Free with g_variant_unref().
     * Throws: GException on failure.
     */
    public Variant callFinish(AsyncResultIF res)
    {
        // GVariant * g_dbus_proxy_call_finish (GDBusProxy *proxy,  GAsyncResult *res,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_proxy_call_finish(gDBusProxy, (res is null) ? null : res.getAsyncResultTStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            return null;
        }
        return new Variant(cast(GVariant*) p);
    }
    
    /**
     * Synchronously invokes the method_name method on proxy.
     * If method_name contains any dots, then name is split into interface and
     * method name parts. This allows using proxy for invoking methods on
     * other interfaces.
     * If the GDBusConnection associated with proxy is disconnected then
     * the operation will fail with G_IO_ERROR_CLOSED. If
     * cancellable is canceled, the operation will fail with
     * G_IO_ERROR_CANCELLED. If parameters contains a value not
     * compatible with the D-Bus protocol, the operation fails with
     * G_IO_ERROR_INVALID_ARGUMENT.
     * If the parameters GVariant is floating, it is consumed. This allows
     * Since 2.26
     * Params:
     * methodName = Name of method to invoke.
     * parameters = A GVariant tuple with parameters for the signal
     * or NULL if not passing parameters. [allow-none]
     * flags = Flags from the GDBusCallFlags enumeration.
     * timeoutMsec = The timeout in milliseconds (with G_MAXINT meaning
     * "infinite") or -1 to use the proxy default timeout.
     * cancellable = A GCancellable or NULL.
     * Returns: NULL if error is set. Otherwise a GVariant tuple with return values. Free with g_variant_unref().
     * Throws: GException on failure.
     */
    public Variant callSync(string methodName, Variant parameters, GDBusCallFlags flags, int timeoutMsec, Cancellable cancellable)
    {
        // GVariant * g_dbus_proxy_call_sync (GDBusProxy *proxy,  const gchar *method_name,  GVariant *parameters,  GDBusCallFlags flags,  gint timeout_msec,  GCancellable *cancellable,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_proxy_call_sync(gDBusProxy, Str.toStringz(methodName), (parameters is null) ? null : parameters.getVariantStruct(), flags, timeoutMsec, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            return null;
        }
        return new Variant(cast(GVariant*) p);
    }
}