Sets our main struct and passes it to the parent class
Finishes an operation started with g_dbus_connection_new(). Since 2.26
Synchronously sets up a D-Bus connection for exchanging D-Bus messages with the end represented by stream. If stream is a GSocketConnection, then the corresponding GSocket will be put into non-blocking mode. The D-Bus connection will interact with stream from a worker thread. As a result, the caller should not interact with stream after this method has been called, except by calling g_object_unref() on it. If observer is not NULL it may be used to control the authentication process. This is a synchronous failable constructor. See g_dbus_connection_new() for the asynchronous version. Since 2.26
Synchronously connects and sets up a D-Bus client connection for exchanging D-Bus messages with an endpoint specified by address which must be in the D-Bus address format. This constructor can only be used to initiate client-side connections - use g_dbus_connection_new_sync() if you need to act as the server. In particular, flags cannot contain the G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER or G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS flags. This is a synchronous failable constructor. See g_dbus_connection_new_for_address() for the asynchronous version. If observer is not NULL it may be used to control the authentication process. Since 2.26
Adds a message filter. Filters are handlers that are run on all incoming and outgoing messages, prior to standard dispatch. Filters are run in the order that they were added. The same handler can be added as a filter more than once, in which case it will be run more than once. Filters added during a filter callback won't be run on the message being processed. Filter functions are allowed to modify and even drop messages. Note that filters are run in a dedicated message handling thread so they can't block and, generally, can't do anything but signal a worker thread. Also note that filters are rarely needed - use API such as g_dbus_connection_send_message_with_reply(), g_dbus_connection_signal_subscribe() or g_dbus_connection_call() instead. If a filter consumes an incoming message the message is not dispatched anywhere else - not even the standard dispatch machinery (that API such as g_dbus_connection_signal_subscribe() and g_dbus_connection_send_message_with_reply() relies on) will see the message. Similary, if a filter consumes an outgoing message, the message will not be sent to the other peer. Since 2.26
Emitted when the connection is closed. The cause of this event can be If g_dbus_connection_close() is called. In this case remote_peer_vanished is set to FALSE and error is NULL. If the remote peer closes the connection. In this case remote_peer_vanished is set to TRUE and error is set. If the remote peer sends invalid or malformed data. In this case remote_peer_vanished is set to FALSE and error is set. Upon receiving this signal, you should give up your reference to connection. You are guaranteed that this signal is emitted only once. TRUE if connection is closed because the remote peer closed its end of the connection. Since 2.26 [1] This is so that g_bus_get() and g_bus_get_sync() can safely return the same GDBusConnection when called from any thread.
Asynchronously invokes the method_name method on the interface_name D-Bus interface on the remote object at object_path owned by bus_name. If connection 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 reply_type is non-NULL then the reply will be checked for having this type and an error will be raised if it does not match. Said another way, if you give a reply_type then any non-NULL return value will be of this type. If the parameters GVariant is floating, it is consumed. This allows Since 2.26
Finishes an operation started with g_dbus_connection_call(). Since 2.26
Synchronously invokes the method_name method on the interface_name D-Bus interface on the remote object at object_path owned by bus_name. If connection 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 reply_type is non-NULL then the reply will be checked for having this type and an error will be raised if it does not match. Said another way, if you give a reply_type then any non-NULL return value will be of this type. If the parameters GVariant is floating, it is consumed. Since 2.26
Like g_dbus_connection_call() but also takes a GUnixFDList object. This method is only available on UNIX. Since 2.30
Finishes an operation started with g_dbus_connection_call_with_unix_fd_list(). Since 2.30
Like g_dbus_connection_call_sync() but also takes and returns GUnixFDList objects. This method is only available on UNIX. Since 2.30
Closes connection. Note that this never causes the process to exit (this might only happen if the other end of a shared message bus connection disconnects, see "exit-on-close"). Once the connection is closed, operations such as sending a message will return with the error G_IO_ERROR_CLOSED. Closing a connection will not automatically flush the connection so queued messages may be lost. Use g_dbus_connection_flush() if you need such guarantees. If connection is already closed, this method fails with G_IO_ERROR_CLOSED. When connection has been closed, the "closed" signal is emitted in the thread-default main loop of the thread that connection was constructed in. This is an asynchronous method. When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call g_dbus_connection_close_finish() to get the result of the operation. See g_dbus_connection_close_sync() for the synchronous version. Since 2.26
Finishes an operation started with g_dbus_connection_close(). Since 2.26
Synchronously closees connection. The calling thread is blocked until this is done. See g_dbus_connection_close() for the asynchronous version of this method and more details about what it does. Since 2.26
Emits a signal. If the parameters GVariant is floating, it is consumed. This can only fail if parameters is not compatible with the D-Bus protocol. Since 2.26
Exports action_group on connection at object_path. The implemented D-Bus API should be considered private. It is subject to change in the future. A given object path can only have one action group exported on it. If this constraint is violated, the export will fail and 0 will be returned (with error set accordingly). You can unexport the action group using g_dbus_connection_unexport_action_group() with the return value of this function. The thread default main context is taken at the time of this call. All incoming action activations and state change requests are reported from this context. Any changes on the action group that cause it to emit signals must also come from this same context. Since incoming action activations and state change requests are rather likely to cause changes on the action group, this effectively limits a given action group to being exported from only one main context. Since 2.32
Exports menu on connection at object_path. The implemented D-Bus API should be considered private. It is subject to change in the future. An object path can only have one menu model exported on it. If this constraint is violated, the export will fail and 0 will be returned (with error set accordingly). You can unexport the menu model using g_dbus_connection_unexport_menu_model() with the return value of this function. Since 2.32
Asynchronously flushes connection, that is, writes all queued outgoing message to the transport and then flushes the transport (using g_output_stream_flush_async()). This is useful in programs that wants to emit a D-Bus signal and then exit immediately. Without flushing the connection, there is no guarantee that the message has been sent to the networking buffers in the OS kernel. This is an asynchronous method. When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call g_dbus_connection_flush_finish() to get the result of the operation. See g_dbus_connection_flush_sync() for the synchronous version. Since 2.26
Finishes an operation started with g_dbus_connection_flush(). Since 2.26
Synchronously flushes connection. The calling thread is blocked until this is done. See g_dbus_connection_flush() for the asynchronous version of this method and more details about what it does. Since 2.26
Gets the capabilities negotiated with the remote peer Since 2.26
Get the main Gtk struct
Gets whether the process is terminated when connection is closed by the remote peer. See "exit-on-close" for more details. Since 2.26
The GUID of the peer performing the role of server when authenticating. See "guid" for more details. Since 2.26
Retrieves the last serial number assigned to a GDBusMessage on the current thread. This includes messages sent via both low-level API such as g_dbus_connection_send_message() as well as high-level API such as g_dbus_connection_emit_signal(), g_dbus_connection_call() or g_dbus_proxy_call(). Since 2.34
Gets the credentials of the authenticated peer. This will always return NULL unless connection acted as a server (e.g. G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER was passed) when set up and the client passed credentials as part of the authentication process. In a message bus setup, the message bus is always the server and each application is a client. So this method will always return NULL for message bus clients. Since 2.26
Gets the underlying stream used for IO. While the GDBusConnection is active, it will interact with this stream from a worker thread, so it is not safe to interact with the stream directly. Since 2.26
the main Gtk struct as a void*
Gets the unique name of connection as assigned by the message bus. This can also be used to figure out if connection is a message bus connection. Since 2.26
Gets whether connection is closed. Since 2.26
Registers callbacks for exported objects at object_path with the D-Bus interface that is described in interface_info. Calls to functions in vtable (and user_data_free_func) will happen in the thread-default main loop of the thread you are calling this method from. Note that all GVariant values passed to functions in vtable will match the signature given in interface_info - if a remote caller passes incorrect values, the org.freedesktop.DBus.Error.InvalidArgs is returned to the remote caller. Additionally, if the remote caller attempts to invoke methods or access properties not mentioned in interface_info the org.freedesktop.DBus.Error.UnknownMethod resp. org.freedesktop.DBus.Error.InvalidArgs errors are returned to the caller. It is considered a programming error if the GDBusInterfaceGetPropertyFunc function in vtable returns a GVariant of incorrect type. If an existing callback is already registered at object_path and interface_name, then error is set to G_IO_ERROR_EXISTS. GDBus automatically implements the standard D-Bus interfaces org.freedesktop.DBus.Properties, org.freedesktop.DBus.Introspectable and org.freedesktop.Peer, so you don't have to implement those for the objects you export. You can implement org.freedesktop.DBus.Properties yourself, e.g. to handle getting and setting of properties asynchronously. Note that the reference count on interface_info will be incremented by 1 (unless allocated statically, e.g. if the reference count is -1, see g_dbus_interface_info_ref()) for as long as the object is exported. Also note that vtable will be copied. See Example 6, “D-Bus server example” for an example of how to use this method. Since 2.26
Registers a whole subtree of “dynamic” objects. The enumerate and introspection functions in vtable are used to convey, to remote callers, what nodes exist in the subtree rooted by object_path. When handling remote calls into any node in the subtree, first the enumerate function is used to check if the node exists. If the node exists or the G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is set the introspection function is used to check if the node supports the requested method. If so, the dispatch function is used to determine where to dispatch the call. The collected GDBusInterfaceVTable and gpointer will be used to call into the interface vtable for processing the request. All calls into user-provided code will be invoked in the thread-default main loop of the thread you are calling this method from. If an existing subtree is already registered at object_path or then error is set to G_IO_ERROR_EXISTS. Note that it is valid to register regular objects (using g_dbus_connection_register_object()) in a subtree registered with g_dbus_connection_register_subtree() - if so, the subtree handler is tried as the last resort. One way to think about a subtree handler is to consider it a “fallback handler” for object paths not registered via g_dbus_connection_register_object() or other bindings. Note that vtable will be copied so you cannot change it after registration. See Example 7, “D-Bus subtree example” for an example of how to use this method. Since 2.26
Removes a filter. Since 2.26
Asynchronously sends message to the peer represented by connection. Unless flags contain the G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number will be assigned by connection and set on message via g_dbus_message_set_serial(). If out_serial is not NULL, then the serial number used will be written to this location prior to submitting the message to the underlying transport. If connection is closed then the operation will fail with G_IO_ERROR_CLOSED. If message is not well-formed, the operation fails with G_IO_ERROR_INVALID_ARGUMENT. See Example 6, “D-Bus server example” and Example 8, “D-Bus UNIX File Descriptor example” for an example of how to use this low-level API to send and receive UNIX file descriptors. Note that message must be unlocked, unless flags contain the G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag. Since 2.26
Asynchronously sends message to the peer represented by connection. Unless flags contain the G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number will be assigned by connection and set on message via g_dbus_message_set_serial(). If out_serial is not NULL, then the serial number used will be written to this location prior to submitting the message to the underlying transport. If connection 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 message is not well-formed, the operation fails with G_IO_ERROR_INVALID_ARGUMENT. This is an asynchronous method. When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call g_dbus_connection_send_message_with_reply_finish() to get the result of the operation. See g_dbus_connection_send_message_with_reply_sync() for the synchronous version. Note that message must be unlocked, unless flags contain the G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag. See Example 6, “D-Bus server example” and Example 8, “D-Bus UNIX File Descriptor example” for an example of how to use this low-level API to send and receive UNIX file descriptors. Since 2.26
Finishes an operation started with g_dbus_connection_send_message_with_reply(). Note that error is only set if a local in-process error occurred. That is to say that the returned GDBusMessage object may be of type G_DBUS_MESSAGE_TYPE_ERROR. Use g_dbus_message_to_gerror() to transcode this to a GError. See Example 6, “D-Bus server example” and Example 8, “D-Bus UNIX File Descriptor example” for an example of how to use this low-level API to send and receive UNIX file descriptors. Since 2.26
Synchronously sends message to the peer represented by connection and blocks the calling thread until a reply is received or the timeout is reached. See g_dbus_connection_send_message_with_reply() for the asynchronous version of this method. Unless flags contain the G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number will be assigned by connection and set on message via g_dbus_message_set_serial(). If out_serial is not NULL, then the serial number used will be written to this location prior to submitting the message to the underlying transport. If connection 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 message is not well-formed, the operation fails with G_IO_ERROR_INVALID_ARGUMENT. Note that error is only set if a local in-process error occurred. That is to say that the returned GDBusMessage object may be of type G_DBUS_MESSAGE_TYPE_ERROR. Use g_dbus_message_to_gerror() to transcode this to a GError. See Example 6, “D-Bus server example” and Example 8, “D-Bus UNIX File Descriptor example” for an example of how to use this low-level API to send and receive UNIX file descriptors. Note that message must be unlocked, unless flags contain the G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag. Since 2.26
Sets whether the process should be terminated when connection is closed by the remote peer. See "exit-on-close" for more details. Note that this function should be used with care. Most modern UNIX desktops tie the notion of a user session the session bus, and expect all of a users applications to quit when their bus connection goes away. If you are setting exit_on_close to FALSE for the shared session bus connection, you should make sure that your application exits when the user session ends. Since 2.26
Subscribes to signals on connection and invokes callback with a whenever the signal is received. Note that callback will be invoked in the thread-default main loop of the thread you are calling this method from. If connection is not a message bus connection, sender must be NULL. If sender is a well-known name note that callback is invoked with the unique name for the owner of sender, not the well-known name as one would expect. This is because the message bus rewrites the name. As such, to avoid certain race conditions, users should be tracking the name owner of the well-known name and use that when processing the received signal. If one of G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE or G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH are given, arg0 is interpreted as part of a namespace or path. The first argument of a signal is matched against that part as specified by D-Bus. Since 2.26
Unsubscribes from signals. Since 2.26
If connection was created with G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING, this method starts processing messages. Does nothing on if connection wasn't created with this flag or if the method has already been called. Since 2.26
Reverses the effect of a previous call to g_dbus_connection_export_action_group(). It is an error to call this function with an ID that wasn't returned from g_dbus_connection_export_action_group() or to call it with the same ID more than once. Since 2.32
Reverses the effect of a previous call to g_dbus_connection_export_menu_model(). It is an error to call this function with an ID that wasn't returned from g_dbus_connection_export_menu_model() or to call it with the same ID more than once. Since 2.32
Unregisters an object. Since 2.26
Unregisters a subtree. Since 2.26
Asynchronously connects to the message bus specified by bus_type. When the operation is finished, callback will be invoked. You can then call g_bus_get_finish() to get the result of the operation. This is a asynchronous failable function. See g_bus_get_sync() for the synchronous version. Since 2.26
Finishes an operation started with g_bus_get(). The returned object is a singleton, that is, shared with other callers of g_bus_get() and g_bus_get_sync() for bus_type. In the event that you need a private message bus connection, use g_dbus_address_get_for_bus_sync() and g_dbus_connection_new_for_address(). Note that the returned GDBusConnection object will (usually) have the "exit-on-close" property set to TRUE. Since 2.26
Synchronously connects to the message bus specified by bus_type. Note that the returned object may shared with other callers, e.g. if two separate parts of a process calls this function with the same bus_type, they will share the same object. This is a synchronous failable function. See g_bus_get() and g_bus_get_finish() for the asynchronous version. The returned object is a singleton, that is, shared with other callers of g_bus_get() and g_bus_get_sync() for bus_type. In the event that you need a private message bus connection, use g_dbus_address_get_for_bus_sync() and g_dbus_connection_new_for_address(). Note that the returned GDBusConnection object will (usually) have the "exit-on-close" property set to TRUE. Since 2.26
Asynchronously sets up a D-Bus connection for exchanging D-Bus messages with the end represented by stream. If stream is a GSocketConnection, then the corresponding GSocket will be put into non-blocking mode. The D-Bus connection will interact with stream from a worker thread. As a result, the caller should not interact with stream after this method has been called, except by calling g_object_unref() on it. If observer is not NULL it may be used to control the authentication process. When the operation is finished, callback will be invoked. You can then call g_dbus_connection_new_finish() to get the result of the operation. This is a asynchronous failable constructor. See g_dbus_connection_new_sync() for the synchronous version. Since 2.26
Asynchronously connects and sets up a D-Bus client connection for exchanging D-Bus messages with an endpoint specified by address which must be in the D-Bus address format. This constructor can only be used to initiate client-side connections - use g_dbus_connection_new() if you need to act as the server. In particular, flags cannot contain the G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER or G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS flags. When the operation is finished, callback will be invoked. You can then call g_dbus_connection_new_finish() to get the result of the operation. If observer is not NULL it may be used to control the authentication process. This is a asynchronous failable constructor. See g_dbus_connection_new_for_address_sync() for the synchronous version. Since 2.26
These functions support exporting a GMenuModel on D-Bus. The D-Bus interface that is used is a private implementation detail.
the main Gtk struct
the main Gtk struct
Get the main Gtk struct
the main Gtk struct as a void*
Gets a D Object from the objects table of associations.
The notify signal is emitted on an object when one of its properties has been changed. Note that getting this signal doesn't guarantee that the value of the property has actually changed, it may also be emitted when the setter for the property is called to reinstate the previous value.
Installs a new property. This is usually done in the class initializer. Note that it is possible to redefine a property in a derived class, by installing a property with the same name. This can be useful at times, e.g. to change the range of allowed values or the default value.
Installs new properties from an array of GParamSpecs. This is usually done in the class initializer. The property id of each property is the index of each GParamSpec in the pspecs array. The property id of 0 is treated specially by GObject and it should not be used to store a GParamSpec. This function should be used if you plan to use a static array of GParamSpecs and g_object_notify_by_pspec(). For instance, this Since 2.26
Looks up the GParamSpec for a property of a class.
Get an array of GParamSpec* for all properties of a class.
Registers property_id as referring to a property with the name name in a parent class or in an interface implemented by oclass. This allows this class to override a property implementation in a parent class or to provide the implementation of a property from an interface. Note Internally, overriding is implemented by creating a property of type GParamSpecOverride; generally operations that query the properties of the object class, such as g_object_class_find_property() or g_object_class_list_properties() will return the overridden property. However, in one case, the construct_properties argument of the constructor virtual function, the GParamSpecOverride is passed instead, so that the param_id field of the GParamSpec will be correct. For virtually all uses, this makes no difference. If you need to get the overridden property, you can call g_param_spec_get_redirect_target(). Since 2.4
Add a property to an interface; this is only useful for interfaces that are added to GObject-derived types. Adding a property to an interface forces all objects classes with that interface to have a compatible property. The compatible property could be a newly created GParamSpec, but normally g_object_class_override_property() will be used so that the object class only needs to provide an implementation and inherits the property description, default value, bounds, and so forth from the interface property. This function is meant to be called from the interface's default vtable initialization function (the class_init member of GTypeInfo.) It must not be called after after class_init has been called for any object types implementing this interface. Since 2.4
Find the GParamSpec with the given name for an interface. Generally, the interface vtable passed in as g_iface will be the default vtable from g_type_default_interface_ref(), or, if you know the interface has already been loaded, g_type_default_interface_peek(). Since 2.4
Lists the properties of an interface.Generally, the interface vtable passed in as g_iface will be the default vtable from g_type_default_interface_ref(), or, if you know the interface has already been loaded, g_type_default_interface_peek(). Since 2.4
Increases the reference count of object.
Decreases the reference count of object. When its reference count drops to 0, the object is finalized (i.e. its memory is freed).
Increase the reference count of object, and possibly remove the floating reference, if object has a floating reference. In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one. Since 2.10
Clears a reference to a GObject. object_ptr must not be NULL. If the reference is NULL then this function does nothing. Otherwise, the reference count of the object is decreased and the pointer is set to NULL. This function is threadsafe and modifies the pointer atomically, using memory barriers where needed. A macro is also included that allows this function to be used without pointer casts. Since 2.28
Checks whether object has a floating reference. Since 2.10
This function is intended for GObject implementations to re-enforce a floating object reference. Doing this is seldom required: all GInitiallyUnowneds are created with a floating reference which usually just needs to be sunken by calling g_object_ref_sink(). Since 2.10
Adds a weak reference callback to an object. Weak references are used for notification when an object is finalized. They are called "weak references" because they allow you to safely hold a pointer to an object without calling g_object_ref() (g_object_ref() adds a strong reference, that is, forces the object to stay alive). Note that the weak references created by this method are not thread-safe: they cannot safely be used in one thread if the object's last g_object_unref() might happen in another thread. Use GWeakRef if thread-safety is required.
Removes a weak reference callback to an object.
Adds a weak reference from weak_pointer to object to indicate that the pointer located at weak_pointer_location is only valid during the lifetime of object. When the object is finalized, weak_pointer will be set to NULL. Note that as with g_object_weak_ref(), the weak references created by this method are not thread-safe: they cannot safely be used in one thread if the object's last g_object_unref() might happen in another thread. Use GWeakRef if thread-safety is required.
Removes a weak reference from object that was previously added using g_object_add_weak_pointer(). The weak_pointer_location has to match the one used with g_object_add_weak_pointer().
Increases the reference count of the object by one and sets a callback to be called when all other references to the object are dropped, or when this is already the last reference to the object and another reference is established. This functionality is intended for binding object to a proxy object managed by another memory manager. This is done with two paired references: the strong reference added by g_object_add_toggle_ref() and a reverse reference to the proxy object which is either a strong reference or weak reference. The setup is that when there are no other references to object, only a weak reference is held in the reverse direction from object to the proxy object, but when there are other references held to object, a strong reference is held. The notify callback is called when the reference from object to the proxy object should be toggled from strong to weak (is_last_ref true) or weak to strong (is_last_ref false). Since a (normal) reference must be held to the object before calling g_object_add_toggle_ref(), the initial state of the reverse link is always strong. Multiple toggle references may be added to the same gobject, however if there are multiple toggle references to an object, none of them will ever be notified until all but one are removed. For this reason, you should only ever use a toggle reference if there is important state in the proxy object. Since 2.8
Removes a reference added with g_object_add_toggle_ref(). The reference count of the object is decreased by one. Since 2.8
Emits a "notify" signal for the property property_name on object. When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.
Emits a "notify" signal for the property specified by pspec on object. This function omits the property name lookup, hence it is faster than g_object_notify(). One way to avoid using g_object_notify() from within the class that registered the properties, and using g_object_notify_by_pspec() instead, is to store the GParamSpec used with Since 2.26
Increases the freeze count on object. If the freeze count is non-zero, the emission of "notify" signals on object is stopped. The signals are queued until the freeze count is decreased to zero. Duplicate notifications are squashed so that at most one "notify" signal is emitted for each property modified while the object is frozen. This is necessary for accessors that modify multiple properties to prevent premature notification while the object is still being modified.
Reverts the effect of a previous call to g_object_freeze_notify(). The freeze count is decreased on object and when it reaches zero, queued "notify" signals are emitted. Duplicate notifications for each property are squashed so that at most one "notify" signal is emitted for each property. It is an error to call this function when the freeze count is zero.
Gets a named field from the objects table of associations (see g_object_set_data()).
Each object carries around a table of associations from strings to pointers. This function lets you set an association. If the object already had an association with that name, the old association will be destroyed.
Like g_object_set_data() except it adds notification for when the association is destroyed, either by setting it to a different value or when the object is destroyed. Note that the destroy callback is not called if data is NULL.
Remove a specified datum from the object's data associations, without invoking the association's destroy handler.
This is a variant of g_object_get_data() which returns a 'duplicate' of the value. dup_func defines the meaning of 'duplicate' in this context, it could e.g. take a reference on a ref-counted object. If the key is not set on the object then dup_func will be called with a NULL argument. Note that dup_func is called while user data of object is locked. This function can be useful to avoid races when multiple threads are using object data on the same key on the same object. Since 2.34
Compares the user data for the key key on object with oldval, and if they are the same, replaces oldval with newval. This is like a typical atomic compare-and-exchange operation, for user data on an object. If the previous value was replaced then ownership of the old value (oldval) is passed to the caller, including the registered destroy notify for it (passed out in old_destroy). Its up to the caller to free this as he wishes, which may or may not include using old_destroy as sometimes replacement should not destroy the object in the normal way. Return: TRUE if the existing value for key was replaced by newval, FALSE otherwise. Since 2.34
This function gets back user data pointers stored via g_object_set_qdata().
This sets an opaque, named pointer on an object. The name is specified through a GQuark (retrived e.g. via g_quark_from_static_string()), and the pointer can be gotten back from the object with g_object_get_qdata() until the object is finalized. Setting a previously set user data pointer, overrides (frees) the old pointer set, using NULL as pointer essentially removes the data stored.
This function works like g_object_set_qdata(), but in addition, a void (*destroy) (gpointer) function may be specified which is called with data as argument when the object is finalized, or the data is being overwritten by a call to g_object_set_qdata() with the same quark.
This function gets back user data pointers stored via g_object_set_qdata() and removes the data from object without invoking its destroy() function (if any was set). Usually, calling this function is only required to update
This is a variant of g_object_get_qdata() which returns a 'duplicate' of the value. dup_func defines the meaning of 'duplicate' in this context, it could e.g. take a reference on a ref-counted object. If the quark is not set on the object then dup_func will be called with a NULL argument. Note that dup_func is called while user data of object is locked. This function can be useful to avoid races when multiple threads are using object data on the same key on the same object. Since 2.34
Compares the user data for the key quark on object with oldval, and if they are the same, replaces oldval with newval. This is like a typical atomic compare-and-exchange operation, for user data on an object. If the previous value was replaced then ownership of the old value (oldval) is passed to the caller, including the registered destroy notify for it (passed out in old_destroy). Its up to the caller to free this as he wishes, which may or may not include using old_destroy as sometimes replacement should not destroy the object in the normal way. Return: TRUE if the existing value for quark was replaced by newval, FALSE otherwise. Since 2.34
Sets a property on an object.
Gets a property of an object. value must have been initialized to the expected type of the property (or a type to which the expected type can be transformed) using g_value_init(). In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling g_value_unset(). Note that g_object_get_property() is really intended for language bindings, g_object_get() is much more convenient for C programming.
Sets properties on an object.
Gets properties of an object. In general, a copy is made of the property contents and the caller is responsible for freeing the memory in the appropriate manner for the type, for instance by calling g_free() or g_object_unref(). See g_object_get().
This function essentially limits the life time of the closure to the life time of the object. That is, when the object is finalized, the closure is invalidated by calling g_closure_invalidate() on it, in order to prevent invocations of the closure with a finalized (nonexisting) object. Also, g_object_ref() and g_object_unref() are added as marshal guards to the closure, to ensure that an extra reference count is held on object during invocation of the closure. Usually, this function will be called on closures that use this object as closure data.
Releases all references to other objects. This can be used to break reference cycles. This functions should only be called from object system implementations.
Get the main Gtk struct
the main Gtk struct as a void*
Initializes the object implementing the interface. The object must be initialized before any real use after initial construction, either with this function or g_async_initable_init_async(). Implementations may also support cancellation. If cancellable is not NULL, then initialization can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If cancellable is not NULL and the object doesn't support cancellable initialization the error G_IO_ERROR_NOT_SUPPORTED will be returned. If the object is not initialized, or initialization returns with an error, then all operations on the object except g_object_ref() and g_object_unref() are considered to be invalid, and have undefined behaviour. See the ??? section introduction for more details. Implementations of this method must be idempotent, i.e. multiple calls to this function with the same argument should return the same results. Only the first call initializes the object, further calls return the result of the first call. This is so that it's safe to implement the singleton pattern in the GObject constructor function. Since 2.22
Helper function for constructing GInitable object. This is similar to g_object_new_valist() but also initializes the object and returns NULL, setting an error on failure. Since 2.22
Helper function for constructing GInitable object. This is similar to g_object_newv() but also initializes the object and returns NULL, setting an error on failure. Since 2.22
Get the main Gtk struct
the main Gtk struct as a void*
Starts asynchronous initialization of the object implementing the interface. This must be done before any real use of the object after initial construction. If the object also implements GInitable you can optionally call g_initable_init() instead. When the initialization is finished, callback will be called. You can then call g_async_initable_init_finish() to get the result of the initialization. Implementations may also support cancellation. If cancellable is not NULL, then initialization can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If cancellable is not NULL, and the object doesn't support cancellable initialization, the error G_IO_ERROR_NOT_SUPPORTED will be returned. As with GInitable, if the object is not initialized, or initialization Since 2.22
Finishes asynchronous initialization and returns the result. See g_async_initable_init_async(). Since 2.22
Finishes the async construction for the various g_async_initable_new calls, returning the created object or NULL on error. Since 2.22
Helper function for constructing GAsyncInitable object. This is similar to g_object_new_valist() but also initializes the object asynchronously. When the initialization is finished, callback will be called. You can then call g_async_initable_new_finish() to get the new object and check for any errors. Since 2.22
Helper function for constructing GAsyncInitable object. This is similar to g_object_newv() but also initializes the object asynchronously. When the initialization is finished, callback will be called. You can then call g_async_initable_new_finish() to get the new object and check for any errors. Since 2.22
The GDBusConnection type is used for D-Bus connections to remote peers such as a message buses. It is a low-level API that offers a lot of flexibility. For instance, it lets you establish a connection over any transport that can by represented as an GIOStream.
This class is rarely used directly in D-Bus clients. If you are writing an D-Bus client, it is often easier to use the g_bus_own_name(), g_bus_watch_name() or g_dbus_proxy_new_for_bus() APIs.
As an exception to the usual GLib rule that a particular object must not be used by two threads at the same time, GDBusConnection's methods may be called from any thread[1].
Most of the ways to obtain a GDBusConnection automatically initialize it (i.e. connect to D-Bus): for instance, g_dbus_connection_new() and g_bus_get(), and the synchronous versions of those methods, give you an initialized connection. Language bindings for GIO should use g_initable_new() or g_async_initable_new_async(), which also initialize the connection.
If you construct an uninitialized GDBusConnection, such as via g_object_new(), you must initialize it via g_initable_init() or g_async_initable_init_async() before using its methods or properties. Calling methods or accessing properties on a GDBusConnection that has not completed initialization successfully is considered to be invalid, and leads to undefined behaviour. In particular, if initialization fails with a GError, the only valid thing you can do with that GDBusConnection is to free it with g_object_unref().