Class ServerSideSource

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.

This function is the language bindings friendly version of g_object_bind_property_full(), using #GClosures instead of function pointers.

Call this function immediately after creating a new #CamelService with camel_session_add_service().

This function is primarily intended for use by #ESourceExtension when emitting a #GObject::notify signal on one of its properties.

When the operation is finished, callback will be called. You can then call e_source_delete_password_finish() to get the result of the operation.

Note the boolean return value indicates whether the delete operation itself completed successfully, not whether a password was found and deleted. If no password was found, the function will still return %TRUE. If an error occurs, the function sets error and returns %FALSE.

Note the boolean return value indicates whether the delete operation itself completed successfully, not whether a password was found and deleted. If no password was found, the function will still return %TRUE. If an error occurs, the function sets error and returns %FALSE.

The returned string should be freed with g_free() when no longer needed.

The returned string should be freed with g_free() when no longer needed.

The returned string should be freed with g_free() when no longer needed.

This is necessary for accessors that modify multiple properties to prevent premature notification while the object is still being modified.

An application should try to honor this setting if at all possible, even if it does not provide a way to change the setting through its user interface. Disabled data sources should generally be hidden.

This function does not take into account source's ancestors in the #ESource hierarchy, each of which have their own enabled state. If any of source's ancestors are disabled, then source itself should be treated as disabled. Use e_source_registry_check_enabled() to easily check for this.

If you just want to test for the existence of an extension within source without creating it, use e_source_has_extension().

Extension instances are owned by their #ESource and should not be referenced directly. Instead, reference the #ESource instance and use this function to fetch the extension instance as needed.

When the operation is finished, callback will be called. You can then call e_source_get_last_credentials_required_arguments_finish() to get the result of the operation.

If an error occurs, the function sets error and returns %FALSE.

If an error occurs, the function sets error and returns %FALSE. The result gchar values should be freed with g_free() when no longer needed.

When the operation is finished, callback will be called. You can then call e_source_get_oauth2_access_token_finish() to get the result of the operation.

Free the returned access token with g_free() when finished with it. If an error occurred, the function will set error and return %FALSE.

Free the returned access token with g_free() when finished with it. If an error occurs, the function will set error and return %FALSE.

The value can be:

• an empty #GValue initialized by %G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
• a #GValue initialized with the expected type of the property
• a #GValue initialized with a type to which the expected type of the property can be transformed

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.

Generally this is only %TRUE if source has an #ESourceCollection extension, which means there is an #ECollectionBackend in the D-Bus service that can handle create requests. If source does not have this capability, calls to e_source_remote_create() will fail.

Generally this is only %TRUE if source is a child of an #ESource which has an #ESourceCollection extension, which means there is an #ECollectionBackend in the D-Bus service that can handle delete requests. If source does not have this capability, calls to e_source_remote_delete() will fail.

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.

When the operation is finished, callback will be called. You can then call e_source_invoke_authenticate_finish() to get the result of the operation.

If an error occurs, the function sets error and returns %FALSE.

If an error occurs, the function sets error and returns %FALSE.

When the operation is finished, callback will be called. You can then call e_source_invoke_credentials_required_finish() to get the result of the operation.

If an error occurs, the function sets error and returns %FALSE.

The %E_SOURCE_CREDENTIALS_REASON_REQUIRED is used for the first credentials prompt, when the client can return credentials as stored from the previous success login.

The %E_SOURCE_CREDENTIALS_REASON_REJECTED is used when the previously used credentials had been rejected by the server. That usually means that the user should be asked to provide/correct the credentials.

The %E_SOURCE_CREDENTIALS_REASON_SSL_FAILED is used when a secured connection failed due to some server-side certificate issues.

The %E_SOURCE_CREDENTIALS_REASON_ERROR is used when the server returned an error. It is not possible to connect to it at the moment usually.

If an error occurs, the function sets error and returns %FALSE.

If you don't know what network protocol is being used on the socket, you should use none as the URI protocol. In this case, the resolver might still return a generic proxy type (such as SOCKS), but would not return protocol-specific proxy types (such as http).

direct:// is used when no proxy is needed. Direct connection should not be attempted unless it is part of the returned array of proxies.

When the operation is finished, callback will be called. You can then call e_source_lookup_password_finish() to get the result of the operation.

Note the boolean return value indicates whether the lookup operation itself completed successfully, not whether a password was found. If no password was found, the function will set out_password to %NULL but still return %TRUE. If an error occurs, the function sets error and returns %FALSE.

Note the boolean return value indicates whether the lookup operation itself completed successfully, not whether a password was found. If no password was found, the function will set out_password to %NULL but still return %TRUE. If an error occurs, the function sets error and returns %FALSE.

If the signature file is executable, it will be executed and its output captured as the email signature content. If the signature file is not executable, the email signature content is read directly from the file.

When the operation is finished, callback will be called. You can then call e_source_mail_signature_load_finish() to get the result of the operation.

If the signature file is executable, it will be executed and its output captured as the email signature content. If the signature file is not executable, the email signature content is read directly from the file.

When the operation is finished, callback will be called. You can then call e_source_mail_signature_replace_finish() to get the result of the operation.

When the operation is finished, callback will be called. You can then call e_source_mail_signature_symlink_finish() to get the result of the operation.

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.

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]);