Asynchronously attempts to authenticate service using mechanism and,
if necessary, service's #CamelService:password property. The function
makes only ONE attempt at authentication and does not loop.
Generally this function should only be called from a #CamelSession subclass in order to implement its own authentication loop.
When the operation is finished, callback will be called. You can
then call camel_service_authenticate_finish() to get the result of
the operation.
a SASL mechanism name, or %NULL
the I/O priority of the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_service_authenticate().
If the authentication attempt completed and the server accepted the credentials, the function returns #CAMEL_AUTHENTICATION_ACCEPTED.
If the authentication attempt completed but the server rejected the credentials, the function returns #CAMEL_AUTHENTICATION_REJECTED.
If the authentication attempt failed to complete due to a network
communication issue or some other mishap, the function sets error
and returns #CAMEL_AUTHENTICATION_ERROR.
a #GAsyncResult
Attempts to authenticate service using mechanism and, if necessary,
service's #CamelService:password property. The function makes only
ONE attempt at authentication and does not loop.
If the authentication attempt completed and the server accepted the credentials, the function returns #CAMEL_AUTHENTICATION_ACCEPTED.
If the authentication attempt completed but the server rejected the credentials, the function returns #CAMEL_AUTHENTICATION_REJECTED.
If the authentication attempt failed to complete due to a network
communication issue or some other mishap, the function sets error
and returns #CAMEL_AUTHENTICATION_ERROR.
Generally this function should only be called from a #CamelSession subclass in order to implement its own authentication loop.
a SASL mechanism name, or %NULL
optional #GCancellable object, or %NULL
Creates a binding between source_property on source and target_property
on target.
Whenever the source_property is changed the target_property is
updated using the same value. For instance:
g_object_bind_property (action, "active", widget, "sensitive", 0);
Will result in the "sensitive" property of the widget #GObject instance to be updated with the same value of the "active" property of the action #GObject instance.
If flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
if target_property on target changes then the source_property on source
will be updated as well.
The binding will automatically be removed when either the source or the
target instances are finalized. To remove the binding without affecting the
source and the target you can just call g_object_unref() on the returned
#GBinding instance.
Removing the binding by calling g_object_unref() on it must only be done if
the binding, source and target are only used from a single thread and it
is clear that both source and target outlive the binding. Especially it
is not safe to rely on this if the binding, source or target can be
finalized from different threads. Keep another reference to the binding and
use g_binding_unbind() instead to be on the safe side.
A #GObject can have multiple bindings.
the property on source to bind
the target #GObject
the property on target to bind
flags to pass to #GBinding
Creates a binding between source_property on source and target_property
on target, allowing you to set the transformation functions to be used by
the binding.
This function is the language bindings friendly version of g_object_bind_property_full(), using #GClosures instead of function pointers.
the property on source to bind
the target #GObject
the property on target to bind
flags to pass to #GBinding
a #GClosure wrapping the transformation function from the source to the target, or %NULL to use the default
a #GClosure wrapping the transformation function from the target to the source, or %NULL to use the default
Returns if this folder (param info) should be checked for new mail or not. It should not look into sub infos (info->child) or next infos, it should return value only for the actual folder info. Default behavior is that all Inbox folders are intended to be refreshed.
a #CamelFolderInfo
Finishes the operation started with camel_service_connect().
a #GAsyncResult
Connects service to a remote server using the information in its
#CamelService:settings instance.
If a connect operation is already in progress when this function is called, its results will be reflected in this connect operation.
optional #GCancellable object, or %NULL
Asynchronously creates a new folder as a child of an existing folder.
parent_name can be %NULL to create a new top-level folder.
When the operation is finished, callback will be called. You can then
call camel_store_create_folder_finish() to get the result of the operation.
name of the new folder's parent, or %NULL
name of the folder to create
the I/O priority of the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_store_create_folder(). The returned #CamelFolderInfo struct should be freed with camel_folder_info_free().
a #GAsyncResult
Creates a new folder as a child of an existing folder.
parent_name can be %NULL to create a new top-level folder.
The returned #CamelFolderInfo struct should be freed with
camel_folder_info_free().
name of the new folder's parent, or %NULL
name of the folder to create
optional #GCancellable object, or %NULL
Deletes local data for the given folder_name. The folder should
be part of the opened folders.
It doesn't delete the folder in the store (server) as such. Use camel_store_delete_folder(), or its synchronous variant, if you want to do that instead.
a folder full name to delete from the cache
Asynchronously deletes the folder described by folder_name. The
folder must be empty.
When the operation is finished, callback will be called. You can then
call camel_store_delete_folder_finish() to get the result of the operation.
name of the folder to delete
the I/O priority of the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_store_delete_folder().
a #GAsyncResult
Deletes the folder described by folder_name. The folder must be empty.
name of the folder to delete
optional #GCancellable object, or %NULL
If a disconnect operation is already in progress when this function is called, its results will be reflected in this disconnect operation.
If any connect operations are in progress when this function is called, they will be cancelled.
When the operation is finished, callback will be called. You can
then call camel_service_disconnect_finish() to get the result of the
operation.
whether or not to try to disconnect cleanly
the I/O priority of the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_service_disconnect().
a #GAsyncResult
Disconnect from the service. If clean is %FALSE, it should not
try to do any synchronizing or other cleanup of the connection.
If a disconnect operation is already in progress when this function is called, its results will be reflected in this disconnect operation.
If any connect operations are in progress when this function is called, they will be cancelled.
whether or not to try to disconnect cleanly
optional #GCancellable object, or %NULL
Thread-safe variation of camel_service_get_display_name().
Use this function when accessing service from multiple threads.
The returned string should be freed with g_free() when no longer needed.
Thread-safe variation of camel_service_get_password().
Use this function when accessing service from multiple threads.
The returned string should be freed with g_free() when no longer needed.
Emits the #CamelStore::folder-created signal from an idle source on the main loop. The idle source's priority is #G_PRIORITY_HIGH_IDLE.
This function is only intended for Camel providers.
information about the created folder
Emits the #CamelStore::folder-deleted signal from an idle source on the main loop. The idle source's priority is #G_PRIORITY_HIGH_IDLE.
This function is only intended for Camel providers.
information about the deleted folder
Emits the #CamelStore::folder-info-stale signal from an idle source on the main loop. The idle source's priority is #G_PRIORITY_LOW.
See the #CamelStore::folder-info-stale documentation for details on when to use this signal.
This function is only intended for Camel providers.
Emits the #CamelStore::folder-renamed signal from an idle source on the main loop. The idle source's priority is #G_PRIORITY_HIGH_IDLE.
This function is only intended for Camel providers.
the old name of the folder
information about the renamed folder
This function is intended for #GObject implementations to re-enforce a [floating][floating-ref] 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().
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
#GObject::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.
Returns whether there can be done automatic save of folder changes. Default is TRUE. The descendants can overwrite it with CamelStoreClass::get_can_auto_save_changes().
Returns the connection status for service.
Gets a named field from the objects table of associations (see g_object_set_data()).
name of the key for that association
Returns the display name for service, or %NULL if service has not
been given a display name. The display name is intended for use in
a user interface and should generally be given a user-defined name.
Compare this with camel_service_get_name(), which returns a built-in description of the type of service (IMAP, SMTP, etc.).
Asynchronously gets a specific folder object from store by name.
When the operation is finished, callback will be called. You can then
call camel_store_get_folder_finish() to get the result of the operation.
name of the folder to get
folder flags (create, save body index, etc)
the I/O priority of the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_store_get_folder().
a #GAsyncResult
Asynchronously fetches information about the folder structure of store,
starting with top. For details of the behavior, see
camel_store_get_folder_info_sync().
When the operation is finished, callback will be called. You can
then call camel_store_get_folder_info_finish() to get the result of
the operation.
the name of the folder to start from
various CAMEL_STORE_FOLDER_INFO_* flags to control behavior
the I/O priority of the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_store_get_folder_info(). The returned #CamelFolderInfo tree should be freed with camel_folder_info_free().
a #GAsyncResult
This fetches information about the folder structure of store,
starting with top, and returns a tree of #CamelFolderInfo
structures. If flags includes %CAMEL_STORE_FOLDER_INFO_SUBSCRIBED,
only subscribed folders will be listed. If the store doesn't support
subscriptions, then it will list all folders. If flags includes
%CAMEL_STORE_FOLDER_INFO_RECURSIVE, the returned tree will include
all levels of hierarchy below top. If not, it will only include
the immediate subfolders of top. If flags includes
%CAMEL_STORE_FOLDER_INFO_FAST, the unread_message_count fields of
some or all of the structures may be set to -1, if the store cannot
determine that information quickly. If flags includes
%CAMEL_STORE_FOLDER_INFO_NO_VIRTUAL, don't include special virtual
folders (such as vTrash or vJunk).
The returned #CamelFolderInfo tree should be freed with camel_folder_info_free().
The CAMEL_STORE_FOLDER_INFO_FAST flag should be considered deprecated; most backends will behave the same whether it is supplied or not. The only guaranteed way to get updated folder counts is to both open the folder and invoke camel_folder_refresh_info() it.
the name of the folder to start from
various CAMEL_STORE_FOLDER_INFO_* flags to control behavior
optional #GCancellable object, or %NULL
Gets a specific folder object from store by name.
name of the folder to get
folder flags (create, save body index, etc)
optional #GCancellable object, or %NULL
Asynchronously gets the folder in store into which new mail is delivered.
When the operation is finished, callback will be called. You can
then call camel_store_get_inbox_folder_finish() to get the result of
the operation.
the I/O priority of the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_store_get_inbox_folder().
a #GAsyncResult
Gets the folder in store into which new mail is delivered.
optional #GCancellable object, or %NULL
Asynchronously gets the folder in store into which junk is delivered.
When the operation is finished, callback will be called. You can
then call camel_store_get_junk_folder_finish() to get the result of
the operation.
the I/O priority of the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_store_get_junk_folder().
a #GAsyncResult
Gets the folder in store into which junk is delivered.
optional #GCancellable object, or %NULL
This gets the name of the service in a "friendly" (suitable for
humans) form. If brief is %TRUE, this should be a brief description
such as for use in the folder tree. If brief is %FALSE, it should
be a more complete and mostly unambiguous description.
whether or not to use a briefer form
Returns %TRUE if store is online.
Returns the password for service. Some SASL mechanisms use this
when attempting to authenticate.
Gets a property of an object.
The value can be:
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.
the name of the property to get
return location for the property value
This function gets back user data pointers stored via g_object_set_qdata().
A #GQuark, naming the user data pointer
Returns the name of the file in which persistent property values for
object are stored. The file is used by camel_object_state_write()
and camel_object_state_read() to save and restore object state.
Asynchronously gets the folder in store into which trash is delivered.
When the operation is finished, callback will be called. You can
then call camel_store_get_trash_folder_finish() to get the result of
the operation.
the I/O priority of the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_store_get_trash_folder().
a #GAsyncResult
Gets the folder in store into which trash is delivered.
optional #GCancellable object, or %NULL
Gets the unique identifier string associated with the service.
Returns the base directory under which to store cache data
for service. The directory is formed by appending the directory
returned by camel_session_get_user_cache_dir() with the service's
#CamelService:uid value.
Returns the base directory under which to store user-specific data
for service. The directory is formed by appending the directory
returned by camel_session_get_user_data_dir() with the service's
#CamelService:uid value.
Gets n_properties properties for an object.
Obtained properties will be set to values. All properties must be valid.
Warnings will be emitted and undefined behaviour may result if invalid
properties are passed in.
the names of each property to get
the values of each property to get
Initializes the object implementing the interface.
This method is intended for language bindings. If writing in C, g_initable_new() should typically be used instead.
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 [introduction][ginitable] for more details.
Callers should not assume that a class which implements #GInitable can be initialized multiple times, unless the class explicitly documents itself as supporting this. Generally, a class’ implementation of init() can assume (and assert) that it will only be called once. Previously, this documentation recommended all #GInitable implementations should be idempotent; that recommendation was relaxed in GLib 2.54.
If a class explicitly supports being initialized multiple times, it is recommended that the method is idempotent: multiple calls with the same arguments should return the same results. Only the first call initializes the object; further calls return the result of the first call.
One reason why a class might need to support idempotent initialization is if it is designed to be used via the singleton pattern, with a #GObjectClass.constructor that sometimes returns an existing instance. In this pattern, a caller would expect to be able to call g_initable_init() on the result of g_object_new(), regardless of whether it is in fact a new instance.
optional #GCancellable object, %NULL to ignore.
Runs initial setup for the store asynchronously.
When the operation is finished, callback will be called. You can then
call camel_store_initial_setup_finish() to get the result of the operation.
The store advertises support of this function by including
CAMEL_STORE_SUPPORTS_INITIAL_SETUP in CamelStore::flags.
the I/O priority of the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_store_initial_setup().
The save_setup result, if not %NULL, should be freed using
g_hash_table_destroy(). It's not an error to have it %NULL,
it only means the store doesn't have anything to save.
a #GAsyncResult
Runs initial setup for the store. It's meant to preset some
values the first time the account connects to the server after
it had been created. The function should return %TRUE even if
it didn't populate anything. The default implementation does
just that.
The save_setup result, if not %NULL, should be freed using
g_hash_table_destroy(). It's not an error to have it %NULL,
it only means the store doesn't have anything to save.
Both the key and the value in the hash are newly allocated
UTF-8 strings, owned by the hash table.
The store advertises support of this function by including
CAMEL_STORE_SUPPORTS_INITIAL_SETUP in CamelStore::flags.
optional #GCancellable object, or %NULL
Checks whether object has a [floating][floating-ref] reference.
Checks the state of the current CamelDB used for the store and eventually
runs maintenance routines on it.
Performs any necessary file migrations for service. This should be
called after installing or configuring the service's #CamelSettings,
since it requires building a URL string for service.
Returns a new #CamelURL representing service.
Free the returned #CamelURL with camel_url_free().
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.
Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.
the name of a property installed on the class of object.
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 g_object_class_install_property() inside a static array, e.g.:
enum
{
PROP_0,
PROP_FOO,
PROP_LAST
};
static GParamSpec *properties[PROP_LAST];
static void
my_object_class_init (MyObjectClass *klass)
{
properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
0, 100,
50,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class,
PROP_FOO,
properties[PROP_FOO]);
}
and then notify a change on the "foo" property with:
g_object_notify_by_pspec (self, properties[PROP_FOO]);
the #GParamSpec of a property installed on the class of object.
Downloads messages for offline, when setup to do so and when the host is reachable.
optional #GCancellable object, or %NULL
Asynchronously obtains a list of authentication types supported by
service.
When the operation is finished, callback will be called. You can
then call camel_service_query_auth_types_finish() to get the result
of the operation.
the I/O priority of the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_service_query_auth_types(). Free the returned list with g_list_free().
a #GAsyncResult
Obtains a list of authentication types supported by service.
Free the returned list with g_list_free().
optional #GCancellable object, or %NULL
Adds task to a queue of waiting tasks with the same source object.
Queued tasks execute one at a time in the order they were added. When
task reaches the front of the queue, it will be dispatched by invoking
task_func in a separate thread. If task is cancelled while queued,
it will complete immediately with an appropriate error.
This is primarily intended for use by #CamelStore, #CamelTransport and #CamelFolder to achieve ordered invocation of synchronous class methods.
a #GTask
function to call when task is dispatched
Returns the #GProxyResolver for service. If an application needs to
override this, it should do so prior to calling functions on service
that may require a network connection.
The returned #GProxyResolver is referenced for thread-safety and must be unreferenced with g_object_unref() when finished with it.
Increase the reference count of object, and possibly remove the
[floating][floating-ref] 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 GLib 2.56, the type of object will be propagated to the return type
under the same conditions as for g_object_ref().
Asynchronously renames the folder described by old_name to new_name.
When the operation is finished, callback will be called. You can then
call camel_store_rename_folder_finish() to get the result of the operation.
the current name of the folder
the new name of the folder
the I/O priority of the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_store_rename_folder().
a #GAsyncResult
Renames the folder described by old_name to new_name.
the current name of the folder
the new name of the folder
optional #GCancellable object, or %NULL
Check whether the store requires synchronization for offline usage.
This is not blocking, it only checks settings on the store and its
currently opened folders.
Returns %TRUE if the store requires synchronization for offline usage
Releases all references to other objects. This can be used to break reference cycles.
This function should only be called from object system implementations.
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.
Internally, the key is converted to a #GQuark using g_quark_from_string().
This means a copy of key is kept permanently (even after object has been
finalized) — so it is recommended to only use a small, bounded set of values
for key in your program, to avoid the #GQuark storage growing unbounded.
name of the key
data to associate with that key
Assigns a UTF-8 display name to service. The display name is intended
for use in a user interface and should generally be given a user-defined
name.
Compare this with camel_service_get_name(), which returns a built-in description of the type of service (IMAP, SMTP, etc.).
a valid UTF-8 string, or %NULL
Sets flags for the store, a bit-or of #CamelStoreFlags.
bit-or of #CamelStoreFlags
An asynchronous variant of camel_offline_store_set_online_sync().
Call camel_offline_store_set_online_finish() from within the callback.
%TRUE for online, %FALSE for offline
the I/O priority for the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_offline_store_set_online().
a #GAsyncResult
Sets the online/offline state of store according to online.
%TRUE for online, %FALSE for offline
optional #GCancellable object, or %NULL
Sets the password for service. Use this function to cache the password
in memory after obtaining it through camel_session_get_password(). Some
SASL mechanisms use this when attempting to authenticate.
the password for service
Sets permissions for the store, a bit-or of #CamelStorePermissionFlags
permissions of the store, a bit-or of #CamelStorePermissionFlags
Sets a property on an object.
the name of the property to set
the value
Sets the #GProxyResolver for service. If an application needs to
override this, it should do so prior to calling functions on service
that may require a network connection.
a #GProxyResolver, or %NULL for the default
Associates a new #CamelSettings instance with the service.
The settings instance must match the settings type defined in
#CamelServiceClass. If settings is %NULL, a new #CamelSettings
instance of the appropriate type is created with all properties
set to defaults.
Sets the name of the file in which persistent property values for
object are stored. The file is used by camel_object_state_write()
and camel_object_state_read() to save and restore object state.
path to a local file
Read persistent object state from #CamelObject:state-filename.
Write persistent object state #CamelObject:state-filename.
Remove a specified datum from the object's data associations, without invoking the association's destroy handler.
name of the key
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
user data pointers with a destroy notifier, for example:
void
object_add_to_user_list (GObject *object,
const gchar *new_string)
{
// the quark, naming the object data
GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
// retrieve the old string list
GList *list = g_object_steal_qdata (object, quark_string_list);
// prepend new string
list = g_list_prepend (list, g_strdup (new_string));
// this changed 'list', so we need to set it again
g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
}
static void
free_string_list (gpointer data)
{
GList *node, *list = data;
for (node = list; node; node = node->next)
g_free (node->data);
g_list_free (list);
}
Using g_object_get_qdata() in the above example, instead of g_object_steal_qdata() would have left the destroy function set, and thus the partial string list would have been freed upon g_object_set_qdata_full().
A #GQuark, naming the user data pointer
Synchronizes any changes that have been made to store and its folders
with the real store asynchronously.
When the operation is finished, callback will be called. You can then
call camel_store_synchronize_finish() to get the result of the operation.
whether to expunge after synchronizing
the I/O priority of the request
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with camel_store_synchronize().
a #GAsyncResult
Synchronizes any changes that have been made to store and its folders
with the real store.
whether to expunge after synchronizing
optional #GCancellable object, or %NULL
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 #GObject::notify signal is emitted for each property, in the reverse order in which they have been queued.
It is an error to call this function when the freeze count is zero.
Decreases the reference count of object. When its reference count
drops to 0, the object is finalized (i.e. its memory is freed).
If the pointer to the #GObject may be reused in future (for example, if it is an instance variable of another object), it is recommended to clear the pointer to %NULL rather than retain a dangling pointer to a potentially invalid #GObject instance. Use g_clear_object() for this.
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.
#GClosure to watch
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().
any interface vtable for the interface, or the default vtable for the interface
name of a property to look up.
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.
If pspec is a floating reference, it will be consumed.
any interface vtable for the interface, or the default vtable for the interface.
the #GParamSpec for the new property
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().
any interface vtable for the interface, or the default vtable for the interface
Creates a new instance of a #GObject subtype and sets its properties.
Construction parameters (see %G_PARAM_CONSTRUCT, %G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values.
the type id of the #GObject subtype to instantiate
an array of #GParameter
The file in which to store persistent property values for this instance.