CC address of the associated message.
Received date of the associated message.
Sent Date of the associated message.
Flag, whether the info is changed and requires save to disk. Compare with CamelMessageInfo:folder-flagged
Bit-or of #CamelMessageFlags.
Flag, whether the info is changed and requires save to the destination store/server. This is different from the CamelMessageInfo:dirty, which takes care of the local information only.
The 'folder-flagged-stamp' is a stamp of the 'folder-flagged' flag. This stamp
changes whenever anything would mark the mi 'folder-flagged', regardless the mi
being already 'folder-flagged'. It can be used to recognize changes
on the 'folder-flagged' flag during the time.
From address of the associated message.
Headers of the associated message. Can be %NULL.
Encoded Message-ID of the associated message as a guint64 number, partial MD5 sum. The value can be cast to #CamelSummaryMessageID.
Mailing list address of the associated message.
Body preview of the associated message. Can be %NULL.
Encoded In-Reply-To and References headers of the associated message as an array of guint64 numbers, partial MD5 sums. Each value can be cast to #CamelSummaryMessageID.
Size of the associated message.
Subject of the associated message.
The #CamelFolderSummary to which the message info belongs, or %NULL. It can be set only during construction of the object.
To address of the associated message.
A unique ID of the message in its folder.
User flags for the associated message. Can be %NULL. Unlike user-tags, which can contain various values, the user-flags can only be set or not.
User-defined headers of the associated message. Can be %NULL.
User tags for the associated message. Can be %NULL. Unlike user-flags, which can be set or not, the user-tags can contain various values.
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
Clones the mi as a new #CamelMessageInfo and eventually assigns
a new #CamelFolderSummary to it. If it's not set, then the same
summary as the one with mi is used.
parent #CamelFolderSummary object, or %NULL, to set on the clone
Dumps the mesasge info mi to stdout. This is meand for debugging
purposes only.
Duplicates array of headers for the mi.
Duplicates encoded In-Reply-To and References headers of the associated message as an array of guint64 numbers, partial MD5 sums. Each value can be cast to #CamelSummaryMessageID.
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().
Freezes all the notifications until the camel_message_info_thaw_notifications() is called. This function can be called multiple times, where the last thaw will do the notifications.
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.
Gets a named field from the objects table of associations (see g_object_set_data()).
name of the key for that association
The folder flagged flag is used to mark the message infor as being changed and this change should be propagated to the remote store (server). This is different from the 'dirty' flag, which is set for local changes only. It can happen that the 'folder-flagged' flag is set, but the 'dirty' flag not.
This is only a convenient wrapper around CAMEL_MESSAGE_FOLDER_FLAGGED flag, for better readiness of the code.
The 'folder-flagged-stamp' is a stamp of the 'folder-flagged' flag. This stamp
changes whenever anything would mark the mi as 'folder-flagged', regardless
the mi being already 'folder-flagged'. It can be used to recognize changes
on the 'folder-flagged' flag during the time.
Encoded Message-ID of the associated message as a guint64 number, partial MD5 sum. The value can be cast to #CamelSummaryMessageID.
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
Gets encoded In-Reply-To and References headers of the associated message as an array of guint64 numbers, partial MD5 sums. Each value can be cast to #CamelSummaryMessageID.
Get the UID of the #mi.
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
Checks whether object has a [floating][floating-ref] reference.
Load content of mi from the data stored in record. The bdata_ptr points
to the current position of the record->bdata, where the read can continue.
Use helper functions camel_util_bdata_get_number() and camel_util_bdata_get_string()
to read data from it and also move forward the *bdata_ptr.
After successful load of the mi, the 'dirty' flag is unset.
a #CamelMIRecord to load the mi from
a backend specific data (bdata) pointer
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.
Get the UID of the #mi, duplicated on the Camel's string pool. This is good for thread safety, though the UID should not change once set.
Acquires a property lock, which is used to ensure thread safety when properties are changing. Release the lock with camel_message_info_property_unlock().
Note: Make sure the CamelFolderSummary lock is held before this lock,
if there will be called any 'set' function on the mi, to avoid deadlock
when the summary would be set as dirty while another thread might try
to read values from the mi, waiting for the property lock and holding
the summary lock at the same time.
Releases a property lock, previously acquired with camel_message_info_property_lock().
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().
Releases all references to other objects. This can be used to break reference cycles.
This function should only be called from object system implementations.
Save the mi content to the message info record record. It can populate all
but the record->bdata value, which is set fro mthe bdata_str. Use helper functions
camel_util_bdata_put_number() and camel_util_bdata_put_string() to put data into the bdata_str.
a #CamelMIRecord to populate
a #GString with a string to save as backend specific data (bdata)
Marks the mi to abort any notifications, which means that it
will not influence 'dirty' and 'folder-flagged' flags in
the set/take functions, neither it will emit any GObject::notify
signals on change, nor associated folder's "changed" signal.
a state to set
Sets CC from the associated message.
This property is considered static, in a meaning that it should
not change during the life-time of the mi, the same as it doesn't
change in the associated message.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is not emitted
folder's "changed" signal for this mi.
a CC to set
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
Sets received date (the Received header) of the associated message.
This property is considered static, in a meaning that it should
not change during the life-time of the mi, the same as it doesn't
change in the associated message.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is not emitted
folder's "changed" signal for this mi.
a received date to set
Sets sent date (the Date header) of the associated message.
This property is considered static, in a meaning that it should
not change during the life-time of the mi, the same as it doesn't
change in the associated message.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is not emitted
folder's "changed" signal for this mi.
a sent date to set
Marks the mi as dirty, which means a save to the local summary
is required.
a dirty state to set
Change the state of the flags on the mi. Both mask and set are bit-or
of #CamelMessageFlags.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is also emitted
folder's "changed" signal for this mi, if necessary. In case
the CAMEL_MESSAGE_FOLDER_FLAGGED flag would be set and the mi is
not aborting notifications, the 'folder-flagged-stamp' changes too.
mask of flags to change
state the flags should be changed to
Changes the folder-flagged flag to the folder_flagged value. See
camel_message_info_get_folder_flagged() for more information about
the use of this flag.
This is only a convenient wrapper around CAMEL_MESSAGE_FOLDER_FLAGGED flag, for better readiness of the code.
a value to set to
Sets From from the associated message.
This property is considered static, in a meaning that it should
not change during the life-time of the mi, the same as it doesn't
change in the associated message.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is not emitted
folder's "changed" signal for this mi.
a From to set
Sets encoded Message-ID of the associated message as a guint64 number, partial MD5 sum. The value can be cast to #CamelSummaryMessageID.
This property is considered static, in a meaning that it should
not change during the life-time of the mi, the same as it doesn't
change in the associated message.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is not emitted
folder's "changed" signal for this mi.
a message id to set
Sets mesage list address from the associated message.
This property is considered static, in a meaning that it should
not change during the life-time of the mi, the same as it doesn't
change in the associated message.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is not emitted
folder's "changed" signal for this mi.
a message list address to set
Set preview as the body preview of the associated message. Use %NULL or an empty
string to unset the value.
If the mi changed, the 'dirty' flag is set automatically, unless the mi is
aborting notifications. There is not emitted folder's "changed" signal for this mi.
message body preview, or %NULL
Sets a property on an object.
the name of the property to set
the value
Sets size of the associated message.
This property is considered static, in a meaning that it should
not change during the life-time of the mi, the same as it doesn't
change in the associated message.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is not emitted
folder's "changed" signal for this mi.
a size to set
Sets Subject from the associated message.
This property is considered static, in a meaning that it should
not change during the life-time of the mi, the same as it doesn't
change in the associated message.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is not emitted
folder's "changed" signal for this mi.
a Subject to set
Sets To from the associated message.
This property is considered static, in a meaning that it should
not change during the life-time of the mi, the same as it doesn't
change in the associated message.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is not emitted
folder's "changed" signal for this mi.
a To to set
Changes UID of the mi to uid. If it changes, the 'dirty' flag
of the mi is set too, unless the mi is aborting notifications. This change
does not influence the 'folder-flagged' flag.
a UID to set
Change state of the flag named name. Unlike user tags, user flags
can only be set or unset, while the user tags can contain certain values.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is also emitted
folder's "changed" signal for this mi, if necessary.
user flag name
state to set for the flag
Set value for a single user-defined message header of the associated message.
When the value is %NULL, the header name is removed from the user-defined
headers.
If the mi changed, the 'dirty' flag is set automatically, unless the mi is
aborting notifications. There is not emitted folder's "changed" signal for this mi.
header name
header value, or %NULL
Set user tag name to value, or remove it, if value is %NULL.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is also emitted
folder's "changed" signal for this mi, if necessary.
user tag name
user tag value, or %NULL to remove the user tag
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
Takes headers of the associated message.
This property is considered static, in a meaning that it should
not change during the life-time of the mi, the same as it doesn't
change in the associated message.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is not emitted
folder's "changed" signal for this mi.
Note that it's not safe to use the headers after the call to this function,
because it can be freed due to no change.
headers to set, as #CamelNameValueArray, or %NULL
Takes encoded In-Reply-To and References headers of the associated message as an array of guint64 numbers, partial MD5 sums. Each value can be cast to #CamelSummaryMessageID.
This property is considered static, in a meaning that it should
not change during the life-time of the mi, the same as it doesn't
change in the associated message.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is not emitted
folder's "changed" signal for this mi.
Note that it's not safe to use the references after the call to this function,
because it can be freed due to no change.
a references to set
Takes all the user_flags, which replaces any current user flags on the mi.
The passed-in user_flags is consumed by the mi, which becomes an owner
of it. The caller should not change user_flags afterwards.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is also emitted
folder's "changed" signal for this mi, if necessary.
Note that it's not safe to use the user_flags after the call to this function,
because it can be freed due to no change.
user flags to set
Takes user-defined message headers of the associated message.
If the mi changed, the 'dirty' flag is set automatically, unless the mi is
aborting notifications. There is not emitted folder's "changed" signal for this mi.
Note that it's not safe to use the headers after the call to this function,
because it can be freed due to no change.
headers to set, as #CamelNameValueArray, or %NULL
Takes all the user_tags, which replaces any current user tags on the mi.
The passed-in user_tags is consumed by the mi, which becomes an owner
of it. The caller should not change user_tags afterwards.
If the mi changed, the 'dirty' flag and the 'folder-flagged' flag are
set automatically, unless the mi is aborting notifications. There is also emitted
folder's "changed" signal for this mi, if necessary.
Note that it's not safe to use the user_tags after the call to this function,
because it can be freed due to no change.
user tags to set
Reverses the call of the camel_message_info_freeze_notifications(). If this is the last freeze, then the associated folder is also notified about the change, if any happened during the freeze.
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
Create a new #CamelMessageInfo object, optionally for given summary.
parent #CamelFolderSummary object, or %NULL
Create a new #CamelMessageInfo pre-populated with info from
headers.
a #CamelFolderSummary object or %NULL
a #CamelNameValueArray
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
Flag, whether the info is currently aborting notifications. It is used to avoid unnecessary 'folder-flagged' and 'dirty' flags changes and also to avoid associated folder's "changed" signal. f