7¤0ìþå2>°£m0 Ã0 Ã0 ÃÀ€§±‘Râ¹bUÌîB©_GØîªíZ¡Û†Û†¹FÑÆŠ:âÿ÷™.ÒqÁƒ•Kà  FY<mü@À  ˜ ‹ÄÑ`,ˆCÂ( £(ˆâ ˆ£ ÆT Õ äcšå2† (time_t time, gint week_start_day, const ICalTimezone *zone); /* Returns the start of the day containing the given time_t, using the given * timezone. */ time_t time_day_begin_with_zone(time_t time, const ICalTimezone *zone); /* Returns the end of the day containing the given time_t, using the given * timezone. (The end of the day is the start of the next day.) */ time_t time_day_end_with_zone (time_t time, const ICalTimezone *zone); void time_to_gdate_with_zone (GDate *date, time_t time, const ICalTimezone *zone); /************************************************************************** * struct tm manipulation **************************************************************************/ struct tm e_cal_util_icaltime_to_tm (const ICalTime *itt); struct tm e_cal_util_icaltime_to_tm_with_zone (const ICalTime *itt, const Ir); /* Returns the number of leap years since year 1 up to (but not including) the * specified year. Year is the normal year, e.g. 2001. */ gint time_leap_years_up_to (gint year); /* Convert to or from an ISO 8601 representation of a time, in UTC, * e.g. "20010708T183000Z". */ gchar * isodate_from_time_t (time_t t); time_t time_from_isodate (const gchar *str); /************************************************************************** * time_t manipulation functions. * * NOTE: these use the Unix timezone functions like mktime() and localtime() * and so should not be used in Evolution. New Evolution code should use * ICalTime values rather than time_t values wherever possible. **************************************************************************/ /* Add or subtract a number of days, weeks or months. */ time_t time_add_day (time_t time, gint days); time_t time_add_week (time_t time, gint weeks); /* Returns the beginning or end of the day. */ time_t time_day_begin (timeL_CLIENT_VIEW_FLAGS_NONE = 0, E_CAL_CLIENT_VIEW_FLAGS_NOTIFY_INITIAL = (1 << 0) } ECalClientViewFlags; /** * ECalClientView: * * Contains only private data that should be read and manipulated using the * functions below. * * Since: 3.2 **/ struct _ECalClientView { /*< private >*/ GObject object; ECalClientViewPrivate *priv; }; /** * ECalClientViewClass: * @objects_added: A signal emitted when new objects are added into the view * @objects_modified: A signal emitted when some objects are modified in the view * @objects_removed: A signal emitted when some objects are removed from the view * @progress: A signal emitted when the backend notifies about the progress * @complete: A signal emitted when the backend finished initial view population * * Base class structure for the #ECalClientView class **/ struct _ECalClientViewClass { /*< private >*/ GObjectClass parent_class; /*< public >*/ /* Signals */ void (*objects_added) (ECalClientView *client_view, const GSList *objects); /* const GSList *rdate_list); /* ECalComponentPeriod * */ gboolean e_cal_component_has_rdates (ECalComponent *comp); GSList * e_cal_component_get_rrules (ECalComponent *comp); /* ICalRecurrence * */ GSList * e_cal_component_get_rrule_properties /* ICalProperty * */ (ECalComponent *comp); void e_cal_component_set_rrules (ECalComponent *comp, const GSList *recur_list); /* ICalRecurrence * */ gboolean e_cal_component_has_rrules (ECalComponent *comp); gboolean e_cal_component_has_recurrences (ECalComponent *comp); gboolean e_cal_component_has_simple_recurrence (ECalComponent *comp); gboolean e_cal_component_is_instance (ECalComponent *comp); gint e_cal_component_get_sequence (ECalComponent *comp); void e_cal_component_set_sequence (ECalComponent *comp, gint sequence); ICalPropertyStatus e_cal_component_get_status (ECalComponent *comp); void e_cal_component_set_status (ECalComponent *comp, ICalPropertyStatus status); ECalComponentText * e_cal_component_get_summary (ECalCgger, const ICalTime *absolute_time); ECalComponentAlarmTriggerKind e_cal_component_alarm_trigger_get_kind (const ECalComponentAlarmTrigger *trigger); void e_cal_component_alarm_trigger_set_kind (ECalComponentAlarmTrigger *trigger, ECalComponentAlarmTriggerKind kind); ICalDuration * e_cal_component_alarm_trigger_get_duration (const ECalComponentAlarmTrigger *trigger); void e_cal_component_alarm_trigger_set_duration (ECalComponentAlarmTrigger *trigger, const ICalDuration *duration); ICalTime * e_cal_component_alarm_trigger_get_absolute_time (const ECalComponentAlarmTrigger *trigger); void e_cal_component_alarm_trigger_set_absolute_time (ECalComponentAlarmTrigger *trigger, const ICalTime *absolute_time); ECalComponentParameterBag * e_cal_component_alarm_trigger_get_parameter_bag (const ECalComponentAlarmTrigger *trigger); G_END_DECLS #endif /* E_CAL_COMPONENT_ALARM_TRIGGER_H */ /* Evolution calendar - iCalendar component object * *const gchar *value, const gchar *member, ICalParameterCutype cutype, ICalParameterRole role, ICalParameterPartstat partstat, gboolean rsvp, const gchar *delegatedfrom, const gchar *delegatedto, const gchar *sentby, const gchar *cn, const gchar *language); ECalComponentAttendee * e_cal_component_attendee_new_from_property (const ICalProperty *property); ECalComponentAttendee * e_cal_component_attendee_copy (const ECalComponentAttendee *attendee); void e_cal_component_attendee_free (gpointer attendee); /* ECalComponentAttendee * */ void e_cal_component_attendee_set_from_property (ECalComponentAttendee *attendee, const ICalProperty *property); ICalProperty * e_cal_component_attendee_get_as_property (const ECalComponentAttendee *attendee); void e_cal_component_attendee_fill_property (const ECalComponentAttendee *attendee, ICalProperty *property); const gchar * e_cal_component_attendee_get_value omponent *comp, gchar **inout_category, gpointer user_data); void e_cal_util_foreach_category (ICalComponent *comp, ECalUtilForeachCategoryFunc func, gpointer user_data); void e_cal_util_diff_categories (ICalComponent *old_comp, ICalComponent *new_comp, GHashTable **out_added, /* const gchar *category ~> 1 */ GHashTable **out_removed); /* const gchar *category ~> 1 */ const gchar * e_cal_util_strip_mailto (const gchar *address); gboolean e_cal_util_email_addresses_equal(const gchar *email1, const gchar *email2); gboolean e_cal_util_get_default_name_and_address (ESourceRegistry *registry, gchar **out_name, gchar **out_address); const gchar * e_cal_util_get_organizer_email (const ECalComponentOrganizer *organizer); const gchar * e_cal_util_get_attendee_email (const ECalComponentAttendee *attendee); const gchar * e_cal_util_get_property_email (ICalProperty *prop); G_END_DECLS #endif /* E_CAL_UTIL_H */ /* * e-timezone-cache.h * * Flag indicating that the backend supports bulk removals. * * Since: 3.6 */ #define E_CAL_STATIC_CAPABILITY_BULK_REMOVES "bulk-removes" /** * E_CAL_STATIC_CAPABILITY_REMOVE_ONLY_THIS: * * FIXME: Document me. * * Since: 3.2 **/ #define E_CAL_STATIC_CAPABILITY_REMOVE_ONLY_THIS "remove-only-this" #define E_CAL_STATIC_CAPABILITY_ONE_ALARM_ONLY "one-alarm-only" #define E_CAL_STATIC_CAPABILITY_ORGANIZER_MUST_ATTEND "organizer-must-attend" #define E_CAL_STATIC_CAPABILITY_ORGANIZER_NOT_EMAIL_ADDRESS "organizer-not-email-address" #define E_CAL_STATIC_CAPABILITY_REMOVE_ALARMS "remove-alarms" /** * E_CAL_STATIC_CAPABILITY_CREATE_MESSAGES: * * Since: 2.26 **/ #define E_CAL_STATIC_CAPABILITY_CREATE_MESSAGES "create-messages" #define E_CAL_STATIC_CAPABILITY_SAVE_SCHEDULES "save-schedules" #define E_CAL_STATIC_CAPABILITY_NO_CONV_TO_ASSIGN_TASK "no-conv-to-assign-task" #define E_CAL_STATIC_CAPABILITY_NO_CONV_TO_RECUR "no-conv-to-recur" #define E_CAL_STATIC_CAPABILITY_NO_GEN_OPTIONS "no-general-option* * Resolve timezone by its ID provided as @tzid. The returned object, * if not %NULL, is owned by the callback implementation and should * not be freed. * * Returns: (transfer none) (nullable): an #ICalTimezone object for @tzid, * or %NULL, on error or if not found. * * Since: 3.34 **/ typedef ICalTimezone * (* ECalRecurResolveTimezoneCb) (const gchar *tzid, gpointer user_data, GCancellable *cancellable, GError **error); /** * ECalRecurInstanceCb: * @icomp: an #ICalComponent * @instance_start: start time of an instance * @instance_end: end time of an instance * @user_data: user data used for this callback in e_cal_recur_generate_instances_sync() * @cancellable: optional #GCancellable object, or %NULL * @error: return location for a #GError, or %NULL * * Callback used by e_cal_recur_generate_instances_sync(), called * for each instance of a (recurring) component within given time range. * * Returns: %TRUE, to continue recurrence generation, %FALSE to stop * *RangeKind kind, const ECalComponentDateTime *datetime); ECalComponentRange * e_cal_component_range_new_take (ECalComponentRangeKind kind, ECalComponentDateTime *datetime); ECalComponentRange * e_cal_component_range_copy (const ECalComponentRange *range); void e_cal_component_range_free (gpointer range); /* ECalComponentRange * */ ECalComponentRangeKind e_cal_component_range_get_kind (const ECalComponentRange *range); void e_cal_component_range_set_kind (ECalComponentRange *range, ECalComponentRangeKind kind); ECalComponentDateTime * e_cal_component_range_get_datetime (const ECalComponentRange *range); void e_cal_component_range_set_datetime (ECalComponentRange *range, const ECalComponentDateTime *datetime); void e_cal_component_range_take_datetime (ECalComponentRange *range, ECalComponentDateTime *datetime); G_END_DECLS #endif /* E_CAL_COMPONENT_RANGE_H */ /* * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com) * Copyright (C) 2019 Red Ha%NULL or the recurrence description prefixed * with text like "The meeting recurs", forming something like "The meeting recurs every 2 weeks..." * @E_CAL_RECUR_DESCRIBE_RECURRENCE_FLAG_FALLBACK: returns %NULL only if the component doesn't recur, * otherwise returns either the recurrence description or at least text like "The meeting recurs" * * Influences behaviour of e_cal_recur_describe_recurrence(). * * Since: 3.30 **/ typedef enum { /*< flags >*/ E_CAL_RECUR_DESCRIBE_RECURRENCE_FLAG_NONE = 0, E_CAL_RECUR_DESCRIBE_RECURRENCE_FLAG_PREFIXED = (1 << 0), E_CAL_RECUR_DESCRIBE_RECURRENCE_FLAG_FALLBACK = (1 << 1) } ECalRecurDescribeRecurrenceFlags; /** * ECalOperationFlags: * @E_CAL_OPERATION_FLAG_NONE: no operation flags defined * @E_CAL_OPERATION_FLAG_CONFLICT_FAIL: conflict resolution mode, to fail and do not * do any changes, when a conflict is detected * @E_CAL_OPERATION_FLAG_CONFLICT_USE_NEWER: conflict resolution mode, to use newer * of the local and the server side data, whene: camel-1.2 Libs: -L${libdir} -lecal-2.0 Cflags: -I${privincludedir} prefix=/usr libdir=/usr/lib includedir=/usr/include datarootdir=/usr/share datadir=/usr/share privincludedir=/usr/include/evolution-data-server Name: libebook-contacts Description: Client library for Evolution Data Server contacts and vCard structures Version: 3.52.4 Requires: libedataserver-1.2 Requires.private: camel-1.2 Libs: -L${libdir} -lebook-contacts-1.2 Cflags: -I${privincludedir} /* This file is generated by glib-mkenums, do not modify it. This code is licensed under the same license as the containing project. Note that it links to GLib, so must comply with the LGPL linking clauses. */ #ifndef E_CAL_ENUMTYPES_H #define E_CAL_ENUMTYPES_H #include G_BEGIN_DECLS /* Enumerations from "e-cal-enums.h" */ #define E_TYPE_CAL_CLIENT_SOURCE_TYPE (e_cal_client_source_type_get_type()) GType e_cal_client_source_type_get_type (void) G_GNUC_CONST; #define E_TYPE_CAL_OBJ_MOD_TYPE (e_cal_obj_mod_type_get_type()) GType e_cal_oURL_HIDDEN_PATH = CAMEL_URL_PART_PATH << CAMEL_URL_PART_HIDDEN, CAMEL_URL_FRAGMENT_IS_PATH = 1 << 30, /* url uses fragment for folder name path, not path */ CAMEL_URL_PATH_IS_ABSOLUTE = 1u << 31, } CamelProviderURLFlags; #define CAMEL_PROVIDER_IS_STORE_AND_TRANSPORT(provider) \ ((provider != NULL) && \ (provider->object_types[CAMEL_PROVIDER_STORE] != G_TYPE_INVALID) && \ (provider->object_types[CAMEL_PROVIDER_TRANSPORT] != G_TYPE_INVALID)) /* Generic extra config stuff */ typedef struct { CamelProviderConfType type; const gchar *name, *depname; const gchar *text, *value; } CamelProviderConfEntry; /** * CamelProviderPortEntry: * @port: port number * @desc: human description of the port * @is_ssl: a boolean whether the port is used together with TLS/SSL * * Since: 3.2 **/ typedef struct { gint port; const gchar *desc; gboolean is_ssl; } CamelProviderPortEntry; /** * CamelProviderAutoDetectFunc: * @url: a #CamelURL * @auto_detected: (out) (element-type utf8 utf8) (nullable): output * include #include #define CAMEL_PROVIDER(obj) ((CamelProvider *)(obj)) #define CAMEL_TYPE_PROVIDER \ (camel_provider_get_type ()) /** * EDS_CAMEL_PROVIDER_DIR: * * This environment variable configures where the camel * provider modules are loaded from. */ #define EDS_CAMEL_PROVIDER_DIR "EDS_CAMEL_PROVIDER_DIR" G_BEGIN_DECLS extern gchar *camel_provider_type_name[CAMEL_NUM_PROVIDER_TYPES]; /* Flags for url_flags. "ALLOW" means the config dialog will let the * user configure it. "NEED" implies "ALLOW" but means the user must * configure it. Service code can assume that any url part for which * it has set the NEED flag will be set when the service is * created. "HIDE" also implies "ALLOW", but the setting will be * hidden/no widgets created for it. */ #define CAMEL_URL_PART_USER (1 << 0) #define CAMEL_URL_PART_AUTH (1 << 1) #define CAMEL_URL_PART_PASSWORD (1 << 2) #define CAMEL_URL_PART_HOST (1 << 3) #define CAMEL_URL_PART_PORT (1 << 4) #defiruct _CamelMsgPort CamelMsgPort; /** * CamelMsg: * @reply_port: a #CamelMsgPort this #CamelMsg belongs to * * Since: 2.24 **/ struct _CamelMsg { CamelMsgPort *reply_port; /*< private >*/ gint flags; }; CamelMsgPort * camel_msgport_new (void); void camel_msgport_destroy (CamelMsgPort *msgport); gint camel_msgport_fd (CamelMsgPort *msgport); void camel_msgport_push (CamelMsgPort *msgport, CamelMsg *msg); CamelMsg * camel_msgport_pop (CamelMsgPort *msgport); CamelMsg * camel_msgport_try_pop (CamelMsgPort *msgport); CamelMsg * camel_msgport_timeout_pop (CamelMsgPort *msgport, guint64 timeout); void camel_msgport_reply (CamelMsg *msg); struct PRFileDesc * camel_msgport_prfd (CamelMsgPort *msgport); G_END_DECLS #endif /* CAMEL_MSGPORT_H */ /* * camel-async-closure.h * truct _CamelSaslXOAuth2YahooPrivate CamelSaslXOAuth2YahooPrivate; struct _CamelSaslXOAuth2Yahoo { CamelSaslXOAuth2 parent; CamelSaslXOAuth2YahooPrivate *priv; }; struct _CamelSaslXOAuth2YahooClass { CamelSaslXOAuth2Class parent_class; }; GType camel_sasl_xoauth2_yahoo_get_type (void) G_GNUC_CONST; G_END_DECLS #endif /* CAMEL_SASL_XOAUTH2_YAHOO_H */ INE_STORE(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), CAMEL_TYPE_OFFLINE_STORE)) #define CAMEL_IS_OFFLINE_STORE_CLASS(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), CAMEL_TYPE_OFFLINE_STORE)) #define CAMEL_OFFLINE_STORE_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), CAMEL_TYPE_OFFLINE_STORE, CamelOfflineStoreClass)) G_BEGIN_DECLS typedef struct _CamelOfflineStore CamelOfflineStore; typedef struct _CamelOfflineStoreClass CamelOfflineStoreClass; typedef struct _CamelOfflineStorePrivate CamelOfflineStorePrivate; struct _CamelOfflineStore { CamelStore parent; CamelOfflineStorePrivate *priv; }; struct _CamelOfflineStoreClass { CamelStoreClass parent_class; GPtrArray * (*dup_downsync_folders) (CamelOfflineStore *store); /* Padding for future expansion */ gpointer reserved[19]; }; GType camel_offline_store_get_type (void); gboolean camel_offline_store_get_online (CamelOfflineStore *store); gboolean camel_offline_store_set_online_sync (CamelOfflineStore *store, gboolean online, (CamelFolderSummary *summary, CamelMessageInfo *info); /* Peek from mem only */ CamelMessageInfo * camel_folder_summary_peek_loaded (CamelFolderSummary *summary, const gchar *uid); /* Get only the uids of dirty/changed things to sync to server/db */ GPtrArray * camel_folder_summary_get_changed (CamelFolderSummary *summary); /* reload the summary at any required point if required */ void camel_folder_summary_prepare_fetch_all (CamelFolderSummary *summary, GError **error); /* summary locking */ void camel_folder_summary_lock (CamelFolderSummary *summary); void camel_folder_summary_unlock (CamelFolderSummary *summary); CamelMessageFlags camel_system_flag (const gchar *name); gboolean camel_system_flag_get (CamelMessageFlags flags, const gchar *name); CamelMessageInfo * camel_message_info_new_from_headers (CamelFolderSummary *summary, const CamelNameValueArray *headers); CamelMessageInfo * camel_message_info_new_from_message S_TYPE \ ((cls), CAMEL_TYPE_VEE_STORE)) #define CAMEL_VEE_STORE_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), CAMEL_TYPE_VEE_STORE, CamelVeeStoreClass)) G_BEGIN_DECLS typedef struct _CamelVeeStore CamelVeeStore; typedef struct _CamelVeeStorePrivate CamelVeeStorePrivate; typedef struct _CamelVeeStoreClass CamelVeeStoreClass; struct _CamelVeeStore { CamelStore parent; CamelVeeStorePrivate *priv; }; struct _CamelVeeStoreClass { CamelStoreClass parent_class; /* Padding for future expansion */ gpointer reserved[20]; }; GType camel_vee_store_get_type (void); CamelVeeStore * camel_vee_store_new (void); CamelVeeDataCache * camel_vee_store_get_vee_data_cache (CamelVeeStore *vstore); struct _CamelVeeFolder *camel_vee_store_get_unmatched_folder (CamelVeeStore *vstore); gboolean camel_vee_store_get_unmatched_enabled (CamelVeeStore *vstore); void camel_vee_store_set_unmatched_enabled (CamelVeeStore *vstore, gboolean is_enabled); void camel_vee_store_note_subfolder_used (Cbase_stream); GIOStream * camel_stream_ref_base_stream (CamelStream *stream); void camel_stream_set_base_stream (CamelStream *stream, GIOStream *base_stream); gssize camel_stream_read (CamelStream *stream, gchar *buffer, gsize n, GCancellable *cancellable, GError **error); gssize camel_stream_write (CamelStream *stream, const gchar *buffer, gsize n, GCancellable *cancellable, GError **error); gint camel_stream_flush (CamelStream *stream, GCancellable *cancellable, GError **error); gint camel_stream_close (CamelStream *stream, GCancellable *cancellable, GError **error); gboolean camel_stream_eos (CamelStream *stream); /* utility macros and funcs */ gssize camel_stream_write_string (CamelStream *stream, const gchar *string, GCancellable *cancellable, GError **error); /* Write a whole stream to another stream, until eof or error on * either stream. */ gssize camel_stream_write_to_streamel-sasl-xoauth2-outlook.h> #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #AMEL_IS_MULTIPART_ENCRYPTED_CLASS(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), CAMEL_TYPE_MULTIPART_ENCRYPTED)) #define CAMEL_MULTIPART_ENCRYPTED_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), CAMEL_TYPE_MULTIPART_ENCRYPTED, CamelMultipartEncryptedClass)) G_BEGIN_DECLS typedef struct _CamelMultipartEncrypted CamelMultipartEncrypted; typedef struct _CamelMultipartEncryptedClass CamelMultipartEncryptedClass; typedef struct _CamelMultipartEncryptedPrivate CamelMultipartEncryptedPrivate; /* 'handy' enums for getting the internal parts of the multipart */ enum { CAMEL_MULTIPART_ENCRYPTED_VERSION, CAMEL_MULTIPART_ENCRYPTED_CONTENT }; struct _CamelMultipartEncrypted { CamelMultipart parent; CamelMultipartEncryptedPrivate *priv; }; struct _CamelMultipartEncryptedClass { CamelMultipartClass parent_class; /* Padding for future expansion */ gpointer reserved[20]; }; GType camel_multipart_encrypted_get_type (void) G_GNUC_CONST; CamelMultipartEncrypted * camel_multipart_encrypted_new (void); G_Epe (void) G_GNUC_CONST; #define CAMEL_TYPE_STORE_GET_FOLDER_INFO_FLAGS (camel_store_get_folder_info_flags_get_type()) GType camel_store_get_folder_info_flags_get_type (void) G_GNUC_CONST; #define CAMEL_TYPE_STORE_PERMISSION_FLAGS (camel_store_permission_flags_get_type()) GType camel_store_permission_flags_get_type (void) G_GNUC_CONST; #define CAMEL_TYPE_TRANSFER_ENCODING (camel_transfer_encoding_get_type()) GType camel_transfer_encoding_get_type (void) G_GNUC_CONST; #define CAMEL_TYPE_THREE_STATE (camel_three_state_get_type()) GType camel_three_state_get_type (void) G_GNUC_CONST; #define CAMEL_TYPE_COMPARE_TYPE (camel_compare_type_get_type()) GType camel_compare_type_get_type (void) G_GNUC_CONST; #define CAMEL_TYPE_TIME_UNIT (camel_time_unit_get_type()) GType camel_time_unit_get_type (void) G_GNUC_CONST; #define CAMEL_TYPE_GPG_TRUST (camel_gpg_trust_get_type()) GType camel_gpg_trust_get_type (void) G_GNUC_CONST; /* Enumerations from "camel-folder.h" */ #define CAMEL_TYPE_FOLDER_ERROR (camel_folder_error_get_IME_PART_UTILS_H #include #include G_BEGIN_DECLS gboolean camel_mime_part_construct_content_from_parser (CamelMimePart *mime_part, CamelMimeParser *mp, GCancellable *cancellable, GError **error); typedef struct _CamelMessageContentInfo CamelMessageContentInfo; /** * CamelMessageContentInfoTraverseCallback: * @ci: a #CamelMessageContentInfo * @depth: the current depth * @user_data: data passed to camel_message_content_info_traverse() * * This is the callback signature for camel_message_content_info_traverse(). * * Returns: %TRUE to continue processing or %FALSE to stop it. * * Since: 3.36 **/ typedef gboolean (*CamelMessageContentInfoTraverseCallback) (CamelMessageContentInfo *ci, gint depth, gpointer user_data); /* A tree of message content info structures * describe the content structure of the message (if it has any) */ struct _CamelMessageContentInfo { CamelMessageContentInfo *next; RL; /* if this changes, remember to change camel_url_copy */ struct _CamelURL { gchar *protocol; gchar *user; gchar *authmech; gchar *host; gint port; gchar *path; GData *params; gchar *query; gchar *fragment; }; typedef enum { CAMEL_URL_HIDE_PARAMS = 1 << 0, CAMEL_URL_HIDE_AUTH = 1 << 1 } CamelURLFlags; #define CAMEL_URL_HIDE_ALL \ (CAMEL_URL_HIDE_PARAMS | CAMEL_URL_HIDE_AUTH) GType camel_url_get_type (void) G_GNUC_CONST; CamelURL * camel_url_new_with_base (CamelURL *base, const gchar *url_string); CamelURL * camel_url_new (const gchar *url_string, GError **error); gchar * camel_url_to_string (CamelURL *url, CamelURLFlags flags); guint camel_url_hash (const CamelURL *u); gboolean camel_url_equal (const CamelURL *u, const CamelURL *u2); CamelURL * camel_url_copy (CamelURL *in); void camel_url_free (CamelURL *url); gchar * camel_url_encode (const gchar *part, const gchar *escape_extra); void camel_url_decode (gchar *part); gchae CAMEL_IS_SESSION_CLASS(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), CAMEL_TYPE_SESSION)) #define CAMEL_SESSION_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), CAMEL_TYPE_SESSION, CamelSessionClass)) G_BEGIN_DECLS #define CAMEL_SESSION_BOOK_UID_ANY "*any" #define CAMEL_SESSION_BOOK_UID_COMPLETION "*completion" typedef struct _CamelSession CamelSession; typedef struct _CamelSessionClass CamelSessionClass; typedef struct _CamelSessionPrivate CamelSessionPrivate; enum { CAMEL_SESSION_PASSWORD_REPROMPT = 1 << 0, CAMEL_SESSION_PASSWORD_SECRET = 1 << 2, CAMEL_SESSION_PASSWORD_STATIC = 1 << 3, CAMEL_SESSION_PASSPHRASE = 1 << 4 }; struct _CamelSession { GObject parent; CamelSessionPrivate *priv; }; /** * CamelSessionCallback: * @session: a #CamelSession * @cancellable: a #CamelOperation cast as a #GCancellable * @user_data: data passed to camel_session_submit_job() * @error: return location for a #GError * * This is the callback signature for jobs submitted to the CamelSession * via camel_LASS \ ((obj), CAMEL_TYPE_TEXT_INDEX_NAME, CamelTextIndexNameClass)) #define CAMEL_TYPE_TEXT_INDEX_CURSOR \ (camel_text_index_cursor_get_type ()) #define CAMEL_TEXT_INDEX_CURSOR(obj) \ (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), CAMEL_TYPE_TEXT_INDEX_CURSOR, CamelTextIndexCursor)) #define CAMEL_TEXT_INDEX_CURSOR_CLASS(cls) \ (G_TYPE_CHECK_CLASS_CAST \ ((cls), CAMEL_TYPE_TEXT_INDEX_CURSOR, CamelTextIndexCursorClass)) #define CAMEL_IS_TEXT_INDEX_CURSOR(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), CAMEL_TYPE_TEXT_INDEX_CURSOR)) #define CAMEL_IS_TEXT_INDEX_CURSOR_CLASS(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), CAMEL_TYPE_TEXT_INDEX_CURSOR)) #define CAMEL_TEXT_INDEX_CURSOR_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), CAMEL_TYPE_TEXT_INDEX_CURSOR, CamelTextIndexCursorClass)) #define CAMEL_TYPE_TEXT_INDEX_KEY_CURSOR \ (camel_text_index_key_cursor_get_type ()) #define CAMEL_TEXT_INDEX_KEY_CURSOR(obj) \ (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), CAMEL_TYPE_TEXT_INDEX_KEY_CURSOR, CamelTextIndexKeyCursor)r to process */ CAMEL_FILTER_STATUS_END /* end of message */ }; typedef CamelFolder * (*CamelFilterGetFolderFunc) (CamelFilterDriver *driver, const gchar *uri, gpointer user_data, GError **error); /* report status */ typedef void (*CamelFilterStatusFunc) (CamelFilterDriver *driver, enum camel_filter_status_t status, gint pc, const gchar *desc, gpointer user_data); typedef void (*CamelFilterShellFunc) (CamelFilterDriver *driver, gint argc, gchar **argv, gpointer user_data); typedef void (*CamelFilterPlaySoundFunc) (CamelFilterDriver *driver, const gchar *filename, gpointer user_data); typedef void (*CamelFilterSystemBeepFunc) (CamelFilterDriver *driver, gpointer user_data); GType camel_filter_driver_get_type (void); CamelFilterDriver *camel_filter_driver_new (struct _CamelSession *session); /* modifiers */ void camel_filter_driver_set_logfile (CamelFilterDriver *d, FILE *logfile); void camel_filter_driver_set_status_func (CamelFilterDriver *d, CamelFiSExpIFunc: * @sexp: a #CamelSExp * @argc: count of arguments * @argv: (in) (array length=argc): array of values of the arguments * @user_data: user data as passed to camel_sexp_add_ifunction() * * Callback type for function symbols used with camel_sexp_add_ifunction(). * * Returns: Result of the function call, allocated by camel_sexp_result_new(). * * Since: 3.4 **/ typedef CamelSExpResult * (*CamelSExpIFunc) (CamelSExp *sexp, gint argc, CamelSExpTerm **argv, gpointer user_data); /** * CamelSExpTermType: * @CAMEL_SEXP_TERM_INT: integer literal * @CAMEL_SEXP_TERM_BOOL: boolean literal * @CAMEL_SEXP_TERM_STRING: string literal * @CAMEL_SEXP_TERM_TIME: time_t literal (number of seconds past the epoch) * @CAMEL_SEXP_TERM_FUNC: normal function, arguments are evaluated before calling * @CAMEL_SEXP_TERM_IFUNC: immediate function, raw terms are arguments * @CAMEL_SEXP_TERM_VAR: variable reference * * Defines type of a #CamelSExpTerm and partly also #CamelSExpSymbol * * void (*folder_deleted) (CamelStore *store, CamelFolderInfo *folder_info); void (*folder_opened) (CamelStore *store, CamelFolder *folder); void (*folder_renamed) (CamelStore *store, const gchar *old_name, CamelFolderInfo *folder_info); void (*folder_info_stale) (CamelStore *store); /* Padding for future expansion */ gpointer reserved_signals[20]; }; GType camel_store_get_type (void); GQuark camel_store_error_quark (void) G_GNUC_CONST; CamelDB * camel_store_get_db (CamelStore *store); CamelObjectBag *camel_store_get_folders_bag (CamelStore *store); GPtrArray * camel_store_dup_opened_folders (CamelStore *store); guint32 camel_store_get_flags (CamelStore *store); void camel_store_set_flags (CamelStore *store, guint32 flags); guint32 camel_store_get_permissions (CamelStore *store); void camel_store_set_permissions (CamelStore *store, guint32 permissions); void camel_store_folder_created (CamelStore *store, CamelFolderInfo *folder_info); voidL_TYPE_FOLDER_INFO)) /** * CAMEL_STORE_ERROR: * * Since: 2.32 **/ #define CAMEL_STORE_ERROR \ (camel_store_error_quark ()) /** * CAMEL_STORE_SETUP * @CAMEL_STORE_SETUP_ARCHIVE_FOLDER: Name of an Archive folder key * @CAMEL_STORE_SETUP_DRAFTS_FOLDER: Name of a Drafts folder key * @CAMEL_STORE_SETUP_SENT_FOLDER: Name of a Sent folder key * @CAMEL_STORE_SETUP_TEMPLATES_FOLDER: Name of a Templates folder key * * Key names to a hash table with values to preset for the account used * as in the camel_store_initial_setup_sync() function. * * The key name consists of up to four parts: Source:Extension:Property[:Type] * Source can be 'Collection', 'Account', 'Submission', 'Transport', 'Backend'. * Extension is any extension name; it's up to the key creator to make sure * the extension belongs to that particular Source. * Property is a property name in the Extension. * Type is an optional letter describing the type of the value; if not set, then * string is used. Available values are: 'b' for booled_count: count of junk and not deleted messages * @bdata: custom data of the #CamelFolderSummary descendants * * Values to store/load for single folder's #CamelFolderSummary structure. * * Since: 2.24 **/ typedef struct _CamelFIRecord { gchar *folder_name; guint32 version; guint32 flags; guint32 nextuid; gint64 timestamp; guint32 saved_count; guint32 unread_count; guint32 deleted_count; guint32 junk_count; guint32 visible_count; guint32 jnd_count; /* Junked not deleted */ gchar *bdata; } CamelFIRecord; /** * CamelDBKnownColumnNames: * @CAMEL_DB_COLUMN_UNKNOWN: unknown column name * @CAMEL_DB_COLUMN_ATTACHMENT: attachment * @CAMEL_DB_COLUMN_BDATA: bdata * @CAMEL_DB_COLUMN_CINFO: cinfo * @CAMEL_DB_COLUMN_DELETED: deleted * @CAMEL_DB_COLUMN_DELETED_COUNT: deleted_count * @CAMEL_DB_COLUMN_DRECEIVED: dreceived * @CAMEL_DB_COLUMN_DSENT: dsent * @CAMEL_DB_COLUMN_FLAGS: flags * @CAMEL_DB_COLUMN_FOLDER_NAME: folder_name * @CAMEL_DB_COLUMN_FOLLOWUP_COMPLETED_ON: followup_completed_on * _TRUST_UNKNOWN, CAMEL_CERT_TRUST_NEVER, CAMEL_CERT_TRUST_MARGINAL, CAMEL_CERT_TRUST_FULLY, CAMEL_CERT_TRUST_ULTIMATE, CAMEL_CERT_TRUST_TEMPORARY } CamelCertTrust; typedef struct { volatile gint refcount; gchar *issuer; gchar *subject; gchar *hostname; gchar *fingerprint; CamelCertTrust trust; GBytes *rawcert; /* loaded on demand, with camel_cert_load_cert_file() */ } CamelCert; struct _CamelCertDB { GObject parent; CamelCertDBPrivate *priv; }; struct _CamelCertDBClass { GObjectClass parent_class; gint (*header_load) (CamelCertDB *certdb, FILE *istream); gint (*header_save) (CamelCertDB *certdb, FILE *ostream); CamelCert * (*cert_load) (CamelCertDB *certdb, FILE *istream); gint (*cert_save) (CamelCertDB *certdb, CamelCert *cert, FILE *ostream); /* Padding for future expansion */ gpointer reserved[20]; }; GType camel_cert_get_type (void) G_GNUC_CONST; CamelCert * camel_cert_new (void); CamelCert * camel_cert_ref (CamelCert *cert); voierviceAuthType; GType camel_service_get_type (void); GQuark camel_service_error_quark (void) G_GNUC_CONST; void camel_service_migrate_files (CamelService *service); CamelURL * camel_service_new_camel_url (CamelService *service); CamelServiceConnectionStatus camel_service_get_connection_status (CamelService *service); const gchar * camel_service_get_display_name (CamelService *service); gchar * camel_service_dup_display_name (CamelService *service); void camel_service_set_display_name (CamelService *service, const gchar *display_name); const gchar * camel_service_get_password (CamelService *service); gchar * camel_service_dup_password (CamelService *service); void camel_service_set_password (CamelService *service, const gchar *password); const gchar * camel_service_get_user_data_dir (CamelService *service); const gchar * camel_service_get_user_cache_dir (CamelService *service); gchar * camel_service_get_name (CamelService *service, gboolean brief); CamelProvider * etails. * * You should have received a copy of the GNU Lesser General Public License * along with this library. If not, see . * * Authors: Bertrand Guiheneuf */ #if !defined (__CAMEL_H_INSIDE__) && !defined (CAMEL_COMPILATION) #error "Only can be included directly." #endif #ifndef CAMEL_UID_CACHE_H #define CAMEL_UID_CACHE_H #include #include #include G_BEGIN_DECLS typedef struct { gchar *filename; GHashTable *uids; guint level; gsize expired; gsize size; gint fd; } CamelUIDCache; CamelUIDCache *camel_uid_cache_new (const gchar *filename); gboolean camel_uid_cache_save (CamelUIDCache *cache); void camel_uid_cache_destroy (CamelUIDCache *cache); GPtrArray *camel_uid_cache_get_new_uids (CamelUIDCache *cache, GPtrArray *uids); void camel_uid_cache_save_uid (CamelUIDCache *cache, const gchar *uid); void camel_uid_cache_free_uids (GPtrArray *uids); G_END_DECLS #endif /* CAMEL_UID_CACHE_H */t or a #CamelMultipart * @user_data: user data for the function * * A custom function to generate preview text for the content * of the @part. The @part can be either a #CamelMimePart or * a #CamelMultipart, depending in which context it is called. * * The preview is supposed to be up to %CAMEL_MAX_PREVIEW_LENGTH * characters long, in a plain text format. * * Returns: (nullable) (transfer full): valid UTF-8 encoded preview * text for the @part, or %NULL, when cannot handle the @part * * Since: 3.52 **/ typedef gchar * (* CamelGeneratePreviewFunc) (gpointer part, gpointer user_data); typedef struct _CamelMimePart CamelMimePart; typedef struct _CamelMimePartClass CamelMimePartClass; typedef struct _CamelMimePartPrivate CamelMimePartPrivate; struct _CamelMimePart { CamelMedium parent; CamelMimePartPrivate *priv; }; struct _CamelMimePartClass { CamelMediumClass parent_class; /* Synchronous I/O Methods */ gboolean (*construct_from_parser_sync) (CamelMimePart *mime_part, ndef CAMEL_LOCK_H #define CAMEL_LOCK_H #include /* for .lock locking, retry, delay and stale counts */ #define CAMEL_LOCK_DOT_RETRY (5) /* number of times to retry lock */ #define CAMEL_LOCK_DOT_DELAY (2) /* delay between locking retries */ #define CAMEL_LOCK_DOT_STALE (60) /* seconds before a lock becomes stale */ /* for locking folders, retry/interretry delay */ #define CAMEL_LOCK_RETRY (5) /* number of times to retry lock */ #define CAMEL_LOCK_DELAY (2) /* delay between locking retries */ G_BEGIN_DECLS typedef enum { CAMEL_LOCK_READ, CAMEL_LOCK_WRITE } CamelLockType; /* specific locking strategies */ gint camel_lock_dot (const gchar *path, GError **error); gint camel_lock_fcntl (gint fd, CamelLockType type, GError **error); gint camel_lock_flock (gint fd, CamelLockType type, GError **error); void camel_unlock_dot (const gchar *path); void camel_unlock_fcntl (gint fd); void camel_unlock_flock (gint fd); /* lock a folder in a standard way */ gint camel_lock_folder (const gchar *path, gint EE_SUBFOLDER_DATA, CamelVeeSubfolderDataClass)) #define CAMEL_TYPE_VEE_MESSAGE_INFO_DATA \ (camel_vee_message_info_data_get_type ()) #define CAMEL_VEE_MESSAGE_INFO_DATA(obj) \ (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), CAMEL_TYPE_VEE_MESSAGE_INFO_DATA, CamelVeeMessageInfoData)) #define CAMEL_VEE_MESSAGE_INFO_DATA_CLASS(cls) \ (G_TYPE_CHECK_CLASS_CAST \ ((cls), CAMEL_TYPE_VEE_MESSAGE_INFO_DATA, CamelVeeMessageInfoDataClass)) #define CAMEL_IS_VEE_MESSAGE_INFO_DATA(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), CAMEL_TYPE_VEE_MESSAGE_INFO_DATA)) #define CAMEL_IS_VEE_MESSAGE_INFO_DATA_CLASS(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), CAMEL_TYPE_VEE_MESSAGE_INFO_DATA)) #define CAMEL_VEE_MESSAGE_INFO_DATA_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), CAMEL_TYPE_VEE_MESSAGE_INFO_DATA, CamelVeeMessageInfoDataClass)) #define CAMEL_TYPE_VEE_DATA_CACHE \ (camel_vee_data_cache_get_type ()) #define CAMEL_VEE_DATA_CACHE(obj) \ (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), CAMEL_TYPE_VEE_DATA_CACHE, CamelVeeDataCachelude #include #define CAMEL_UTILS_MAX_USER_HEADERS 3 G_BEGIN_DECLS gint64 camel_util_bdata_get_number (/* const */ gchar **bdata_ptr, gint64 default_value); void camel_util_bdata_put_number (GString *bdata_str, gint64 value); gchar * camel_util_bdata_get_string (/* const */ gchar **bdata_ptr, const gchar *default_value); void camel_util_bdata_put_string (GString *bdata_str, const gchar *value); time_t camel_time_value_apply (time_t src_time, CamelTimeUnit unit, gint value); GWeakRef * camel_utils_weak_ref_new (gpointer object); void camel_utils_weak_ref_free (GWeakRef *weak_ref); gboolean camel_util_fill_message_info_user_headers (CamelMessageInfo *info, const CamelNameValueArray *headers); gchar * camel_util_encode_user_header_setting (const gchar *display_name, const gchar *header_name); void camel_util_decode_user_header_setting (const gchar *setting_value, error); gssize (*decode_to_output_stream_sync) (CamelDataWrapper *data_wrapper, GOutputStream *output_stream, GCancellable *cancellable, GError **error); gboolean (*construct_from_input_stream_sync) (CamelDataWrapper *data_wrapper, GInputStream *input_stream, GCancellable *cancellable, GError **error); /* Padding for future expansion */ gpointer reserved[20]; }; GType camel_data_wrapper_get_type (void); CamelDataWrapper * camel_data_wrapper_new (void); GByteArray * camel_data_wrapper_get_byte_array (CamelDataWrapper *data_wrapper); CamelTransferEncoding camel_data_wrapper_get_encoding (CamelDataWrapper *data_wrapper); void camel_data_wrapper_set_encoding (CamelDataWrapper *data_wrapper, CamelTransferEncoding encoding); void camel_data_wrapper_set_mime_type (CamelDataWrapper *data_wrapper, const gchar *mime_type); gchar * camel_data_wrapper_get_mime_type (CamelDataWrapper *data_wrapper); CamelContentType * cr_has_summary_capability (CamelFolder *folder); gint camel_folder_get_message_count (CamelFolder *folder); #ifndef CAMEL_DISABLE_DEPRECATED gint camel_folder_get_unread_message_count (CamelFolder *folder); #endif gint camel_folder_get_deleted_message_count (CamelFolder *folder); GPtrArray * camel_folder_get_summary (CamelFolder *folder); void camel_folder_free_summary (CamelFolder *folder, GPtrArray *array); #define camel_folder_delete_message(folder, uid) \ (camel_folder_set_message_flags ( \ folder, uid, \ CAMEL_MESSAGE_DELETED | CAMEL_MESSAGE_SEEN, \ CAMEL_MESSAGE_DELETED | CAMEL_MESSAGE_SEEN)) GPtrArray * camel_folder_get_uids (CamelFolder *folder); void camel_folder_free_uids (CamelFolder *folder, GPtrArray *array); GPtrArray * camel_folder_get_uncached_uids (CamelFolder *folder, GPtrArray *uids, GError **error); gint camel_folder_cmp_uids (CamelFolder *folder, const gchar *uid1, const gchar *uid2); void camel_folder_sort_uids GPtrArray *result); CamelMessageInfo * (*get_message_info) (CamelFolder *folder, const gchar *uid); void (*delete_) (CamelFolder *folder); void (*rename) (CamelFolder *folder, const gchar *new_name); void (*freeze) (CamelFolder *folder); void (*thaw) (CamelFolder *folder); gboolean (*is_frozen) (CamelFolder *folder); guint32 (*count_by_expression) (CamelFolder *folder, const gchar *expression, GCancellable *cancellable, GError **error); GPtrArray * (*get_uncached_uids) (CamelFolder *folder, GPtrArray *uids, GError **error); gchar * (*get_filename) (CamelFolder *folder, const gchar *uid, GError **error); CamelMimeMessage * (*get_message_cached) (CamelFolder *folder, const gchar *message_uid, GCancellable *cancellable); /* Synchronous I/O Methods */ gboolean (*append_message_sync) (CamelFolder *folder, CamelMimeMessage *message, CamelMessageInfo *info, gchar **appended_uid, ); /* (compare-date time_t time_t) * Compares only date portion of the two time_t values and returns an integer * value < 0 when the first date is before the second, 0 when they are the same * and value > 0 when the first is after the second date. */ CamelSExpResult * (*compare_date) (CamelSExp *sexp, gint argc, CamelSExpResult **argv, CamelFolderSearch *search); /* (addressbook-contains "book_uid" "header-name") * Checks whether at least one address from header "header-name" * is in the address book "book_uid". Not all headers are supported. */ CamelSExpResult * (*addressbook_contains) (CamelSExp *sexp, gint argc, CamelSExpResult **argv, CamelFolderSearch *search); /* Padding for future expansion */ gpointer reserved[17]; }; GType camel_folder_search_get_type (void) G_GNUC_CONST; CamelFolderSearch * camel_folder_search_new (void); void camel_folder_search_set_only_cached_messages (CamelFolderSearch *search, gboolean only_calFilterInputStream, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelFilterOutputStream, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelFolderChangeInfo, camel_folder_change_info_free) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelFolder, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelFolderSearch, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelFolderSummary, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelFolderThread, camel_folder_thread_messages_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelGpgContext, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelGpgKeyInfo, camel_gpg_key_info_free) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelHTMLParser, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelIndex, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelIndexName, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelIndexCursor, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelInternetAddress, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelLocalSettings, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(CamelMedium,NETWORK_SETTINGS_INTERFACE(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), CAMEL_TYPE_NETWORK_SETTINGS)) #define CAMEL_NETWORK_SETTINGS_GET_INTERFACE(obj) \ (G_TYPE_INSTANCE_GET_INTERFACE \ ((obj), CAMEL_TYPE_NETWORK_SETTINGS, CamelNetworkSettingsInterface)) G_BEGIN_DECLS /** * CamelNetworkSettings: * * Since: 3.2 **/ typedef struct _CamelNetworkSettings CamelNetworkSettings; typedef struct _CamelNetworkSettingsInterface CamelNetworkSettingsInterface; struct _CamelNetworkSettingsInterface { GTypeInterface parent_interface; /* Padding for future expansion */ gpointer reserved[20]; }; GType camel_network_settings_get_type (void) G_GNUC_CONST; const gchar * camel_network_settings_get_auth_mechanism (CamelNetworkSettings *settings); gchar * camel_network_settings_dup_auth_mechanism (CamelNetworkSettings *settings); void camel_network_settings_set_auth_mechanism (CamelNetworkSettings *settings, const gchar *auth_mechanism); const gchar * camel_network_settings_get_host (ror); gboolean (*encrypt_sync) (CamelCipherContext *context, const gchar *userid, GPtrArray *recipients, CamelMimePart *ipart, CamelMimePart *opart, GCancellable *cancellable, GError **error); CamelCipherValidity * (*decrypt_sync) (CamelCipherContext *context, CamelMimePart *ipart, CamelMimePart *opart, GCancellable *cancellable, GError **error); /* Padding for future expansion */ gpointer reserved[20]; }; GType camel_cipher_context_get_type (void); CamelCipherContext * camel_cipher_context_new (CamelSession *session); CamelSession * camel_cipher_context_get_session (CamelCipherContext *context); /* cipher context util routines */ CamelCipherHash camel_cipher_context_id_to_hash (CamelCipherContext *context, const gchar *id); const gchar * camel_cipher_context_hash_to_id (CamelCipherContext *context, CamelCipherHash hash); /* FIXME: * There are some inconsistencies here, the api's should probably handle Cncluded directly." #endif #ifndef CAMEL_CIPHER_CONTEXT_H #define CAMEL_CIPHER_CONTEXT_H #include #include /* Standard GObject macros */ #define CAMEL_TYPE_CIPHER_CONTEXT \ (camel_cipher_context_get_type ()) #define CAMEL_CIPHER_CONTEXT(obj) \ (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), CAMEL_TYPE_CIPHER_CONTEXT, CamelCipherContext)) #define CAMEL_CIPHER_CONTEXT_CLASS(cls) \ (G_TYPE_CHECK_CLASS_CAST \ ((cls), CAMEL_TYPE_CIPHER_CONTEXT, CamelCipherContextClass)) #define CAMEL_IS_CIPHER_CONTEXT(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), CAMEL_TYPE_CIPHER_CONTEXT)) #define CAMEL_IS_CIPHER_CONTEXT_CLASS(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), CAMEL_TYPE_CIPHER_CONTEXT)) #define CAMEL_CIPHER_CONTEXT_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), CAMEL_TYPE_CIPHER_CONTEXT, CamelCipherContextClass)) /** * CAMEL_CIPHER_CERT_INFO_PROPERTY_PHOTO_FILENAME: * * Name of the photo-filename property which can be stored * on a #CamelCipherCertInfo. * 24 /*< skip >*/ } CamelStoreInfoFlags; /** * CAMEL_STORE_INFO_FOLDER_TYPE_MASK: (value 64512) * The folder store info type mask value. **/ #define CAMEL_STORE_INFO_FOLDER_TYPE_MASK (0x3F << CAMEL_STORE_INFO_FOLDER_TYPE_BIT) /** * CamelFetchHeadersType: * @CAMEL_FETCH_HEADERS_BASIC: * Fetch only basic headers (Date, From, To, Subject, etc.). * @CAMEL_FETCH_HEADERS_BASIC_AND_MAILING_LIST: * Fetch all basic headers and mailing list headers. * @CAMEL_FETCH_HEADERS_ALL: * Fetch all available message headers. * * Describes what headers to fetch when downloading message summaries. * * Since: 3.2 **/ typedef enum { CAMEL_FETCH_HEADERS_BASIC, CAMEL_FETCH_HEADERS_BASIC_AND_MAILING_LIST, CAMEL_FETCH_HEADERS_ALL } CamelFetchHeadersType; /** * CamelJunkStatus: * @CAMEL_JUNK_STATUS_ERROR: * An error occurred while invoking the junk filter. * @CAMEL_JUNK_STATUS_INCONCLUSIVE: * The junk filter could not determine whether the message is junk. * @CAMEL_JUNK_STATUS_MESSAGE_IS_JUNCATION_ACCEPTED, CAMEL_AUTHENTICATION_REJECTED } CamelAuthenticationResult; typedef enum { /*< flags >*/ CAMEL_FOLDER_HAS_SUMMARY_CAPABILITY = 1 << 0, CAMEL_FOLDER_FILTER_RECENT = 1 << 2, CAMEL_FOLDER_HAS_BEEN_DELETED = 1 << 3, CAMEL_FOLDER_IS_TRASH = 1 << 4, CAMEL_FOLDER_IS_JUNK = 1 << 5, CAMEL_FOLDER_FILTER_JUNK = 1 << 6 } CamelFolderFlags; /** * CAMEL_FOLDER_TYPE_BIT: (value 10) * The folder type bitshift value. **/ #define CAMEL_FOLDER_TYPE_BIT (10) /** * CamelFolderInfoFlags: * @CAMEL_FOLDER_NOSELECT: * The folder cannot contain messages. * @CAMEL_FOLDER_NOINFERIORS: * The folder cannot have child folders. * @CAMEL_FOLDER_CHILDREN: * The folder has children (not yet fully implemented). * @CAMEL_FOLDER_NOCHILDREN: * The folder does not have children (not yet fully implemented). * @CAMEL_FOLDER_SUBSCRIBED: * The folder is subscribed. * @CAMEL_FOLDER_VIRTUAL: * The folder is virtual. Messages cannot be copied or moved to * virtual folders since they are only ; gsize camel_quoted_encode_close (guchar *in, gsize len, guchar *out, gint *state, gint *save); /* camel ctype type functions for rfc822/rfc2047/other, which are non-locale specific */ enum { CAMEL_MIME_IS_CTRL = 1 << 0, CAMEL_MIME_IS_LWSP = 1 << 1, CAMEL_MIME_IS_TSPECIAL = 1 << 2, CAMEL_MIME_IS_SPECIAL = 1 << 3, CAMEL_MIME_IS_SPACE = 1 << 4, CAMEL_MIME_IS_DSPECIAL = 1 << 5, CAMEL_MIME_IS_QPSAFE = 1 << 6, CAMEL_MIME_IS_ESAFE = 1 << 7, /* encoded word safe */ CAMEL_MIME_IS_PSAFE = 1 << 8, /* encoded word in phrase safe */ CAMEL_MIME_IS_ATTRCHAR = 1 << 9 /* attribute-char safe (rfc2184) */ }; extern gushort camel_mime_special_table[256]; #define camel_mime_is_ctrl(x) ((camel_mime_special_table[(guchar)(x)] & CAMEL_MIME_IS_CTRL) != 0) #define camel_mime_is_lwsp(x) ((camel_mime_special_table[(guchar)(x)] & CAMEL_MIME_IS_LWSP) != 0) #define camel_mime_is_tspecial(x) ((camel_mime_special_table[(guchar)(x)] & CAMEL_MIME_IS_TSPECIAL) != 0) #define camel_mime_is_type(x, t) ((camst gchar *charset); CamelHeaderAddress *camel_header_mailbox_decode (const gchar *in, const gchar *charset); /* for mailing */ gchar *camel_header_address_list_encode (CamelHeaderAddress *addrlist); /* for display */ gchar *camel_header_address_list_format (CamelHeaderAddress *addrlist); /* structured header prameters */ struct _camel_header_param *camel_header_param_list_decode (const gchar *in); gchar *camel_header_param (struct _camel_header_param *params, const gchar *name); struct _camel_header_param *camel_header_set_param (struct _camel_header_param **paramsp, const gchar *name, const gchar *value); void camel_header_param_list_format_append (GString *out, struct _camel_header_param *params); gchar *camel_header_param_list_format (struct _camel_header_param *params); void camel_header_param_list_free (struct _camel_header_param *params); /* Content-Type header */ GType camel_content_type_get_type (void) G_GNUC_CONST; CamelContentType *camel_content_type_new (const gchar *type, const gchar *subtype); .gnu.org/licenses/>. * * Authors: Jeffrey Stedfast */ #if !defined (__CAMEL_H_INSIDE__) && !defined (CAMEL_COMPILATION) #error "Only can be included directly." #endif #ifndef CAMEL_MIME_FILTER_PROGRESS_H #define CAMEL_MIME_FILTER_PROGRESS_H #include #include /* Standard GObject macros */ #define CAMEL_TYPE_MIME_FILTER_PROGRESS \ (camel_mime_filter_progress_get_type ()) #define CAMEL_MIME_FILTER_PROGRESS(obj) \ (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), CAMEL_TYPE_MIME_FILTER_PROGRESS, CamelMimeFilterProgress)) #define CAMEL_MIME_FILTER_PROGRESS_CLASS(cls) \ (G_TYPE_CHECK_CLASS_CAST \ ((cls), CAMEL_TYPE_MIME_FILTER_PROGRESS, CamelMimeFilterProgressClass)) #define CAMEL_IS_MIME_FILTER_PROGRESS(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), CAMEL_TYPE_MIME_FILTER_PROGRESS)) #define CAMEL_IS_MIME_FILTER_PROGRESS_CLASS(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), CAMEL_TYPE_MIME_FILTER_PROGRESS)) #define CAMEL_MIME_FILTER_PROGRESS_GETPartitionMapBlock { camel_block_t next; guint32 used; struct _CamelPartitionMap partition[(CAMEL_BLOCK_SIZE - 8) / sizeof (struct _CamelPartitionMap)]; }; struct _CamelPartitionTable { GObject parent; CamelPartitionTablePrivate *priv; }; struct _CamelPartitionTableClass { GObjectClass parent; /* Padding for future expansion */ gpointer reserved[20]; }; GType camel_partition_table_get_type (void); CamelPartitionTable * camel_partition_table_new (CamelBlockFile *bs, camel_block_t root); gint camel_partition_table_sync (CamelPartitionTable *cpi); gint camel_partition_table_add (CamelPartitionTable *cpi, const gchar *key, camel_key_t keyid); camel_key_t camel_partition_table_lookup (CamelPartitionTable *cpi, const gchar *key); gboolean camel_partition_table_remove (CamelPartitionTable *cpi, const gchar *key); /* ********************************************************************** */ /* CamelKeyTable - index of keyid to key and flag and data mapping */ typed ((obj), CAMEL_TYPE_STREAM_PROCESS)) #define CAMEL_IS_STREAM_PROCESS_CLASS(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), CAMEL_TYPE_STREAM_PROCESS)) #define CAMEL_STREAM_PROCESS_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), CAMEL_TYPE_STREAM_PROCSS, CamelStreamProcessClass)) G_BEGIN_DECLS typedef struct _CamelStreamProcess CamelStreamProcess; typedef struct _CamelStreamProcessClass CamelStreamProcessClass; typedef struct _CamelStreamProcessPrivate CamelStreamProcessPrivate; struct _CamelStreamProcess { CamelStream parent; CamelStreamProcessPrivate *priv; }; struct _CamelStreamProcessClass { CamelStreamClass parent_class; /* Padding for future expansion */ gpointer reserved[20]; }; GType camel_stream_process_get_type (void); CamelStream * camel_stream_process_new (void); gint camel_stream_process_connect (CamelStreamProcess *stream, const gchar *command, const gchar **env, GError **error); G_END_DECLS #endif /* CAMEL_STREAM_PROCESS_H */ /* * camel-subscribable.h * ellable); void (*set_expression) (CamelVeeFolder *vfolder, const gchar *expression); /* Called for a folder-changed event on a source folder */ void (*folder_changed) (CamelVeeFolder *vfolder, CamelFolder *subfolder, CamelFolderChangeInfo *changes); /* Padding for future expansion */ gpointer reserved[20]; }; #define CAMEL_UNMATCHED_NAME "UNMATCHED" GType camel_vee_folder_get_type (void); CamelFolder * camel_vee_folder_new (CamelStore *parent_store, const gchar *full, guint32 flags); void camel_vee_folder_construct (CamelVeeFolder *vf, guint32 flags); guint32 camel_vee_folder_get_flags (CamelVeeFolder *vf); CamelFolder * camel_vee_folder_get_location (CamelVeeFolder *vf, const CamelVeeMessageInfo *vinfo, gchar **realuid); CamelFolder * camel_vee_folder_get_vee_uid_folder (CamelVeeFolder *vfolder, const gchar *vee_message_uid); void camel_vee_folder_set_auto_update (CamelVeeFolder *vfolder, gboolean auto_update);el_message_info_get_uid (const CamelMessageInfo *mi); const gchar * camel_message_info_pooldup_uid (const CamelMessageInfo *mi); gboolean camel_message_info_set_uid (CamelMessageInfo *mi, const gchar *uid); guint32 camel_message_info_get_flags (const CamelMessageInfo *mi); gboolean camel_message_info_set_flags (CamelMessageInfo *mi, guint32 mask, guint32 set); gboolean camel_message_info_get_user_flag (const CamelMessageInfo *mi, const gchar *name); gboolean camel_message_info_set_user_flag (CamelMessageInfo *mi, const gchar *name, gboolean state); const CamelNamedFlags * camel_message_info_get_user_flags (const CamelMessageInfo *mi); CamelNamedFlags * camel_message_info_dup_user_flags (const CamelMessageInfo *mi); gboolean camel_message_info_take_user_flags (CamelMessageInfo *mi, CamelNamedFlags *user_flags); const gchar * camel_message_info_get_user_tag (const CamelMessageInfo *mi, const gchar *name); gchar * camel take_references) (CamelMessageInfo *mi, GArray *references); const CamelNameValueArray * (* get_headers) (const CamelMessageInfo *mi); gboolean (* take_headers)(CamelMessageInfo *mi, CamelNameValueArray *headers); const gchar * (* get_user_header) (const CamelMessageInfo *mi, const gchar *name); gboolean (* set_user_header) (CamelMessageInfo *mi, const gchar *name, const gchar *value); const CamelNameValueArray * (* get_user_headers) (const CamelMessageInfo *mi); gboolean (* take_user_headers) (CamelMessageInfo *mi, CamelNameValueArray *headers); const gchar * (* get_preview) (const CamelMessageInfo *mi); gboolean (* set_preview) (CamelMessageInfo *mi, const gchar *preview); /* Padding for future expansion */ gpointer reserved[14]; }; GType camel_message_info_get_type (void); CamelMessageInfo * camel_message_info_new (struct _CamelFolderSummary *summary); CamelMessageInfo * camel_message_info_clone MMARY)) #define CAMEL_VEE_SUMMARY_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), CAMEL_TYPE_VEE_SUMMARY, CamelVeeSummaryClass)) G_BEGIN_DECLS struct _CamelVeeMessageInfoData; struct _CamelVeeFolder; struct _CamelFolder; typedef struct _CamelVeeSummary CamelVeeSummary; typedef struct _CamelVeeSummaryClass CamelVeeSummaryClass; typedef struct _CamelVeeSummaryPrivate CamelVeeSummaryPrivate; struct _CamelVeeSummary { CamelFolderSummary parent; CamelVeeSummaryPrivate *priv; }; struct _CamelVeeSummaryClass { CamelFolderSummaryClass parent_class; /* Padding for future expansion */ gpointer reserved[20]; }; GType camel_vee_summary_get_type (void); CamelFolderSummary * camel_vee_summary_new (CamelFolder *parent); CamelVeeMessageInfo * camel_vee_summary_add (CamelVeeSummary *summary, struct _CamelVeeMessageInfoData *mi_data); void camel_vee_summary_remove (CamelVeeSummary *summary, const gchar *vuid, CamelFolder *subfolder); void camel_vee_summary_replace_flags (CamelTRASH_FOLDER)) #define CAMEL_VTRASH_FOLDER_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), CAMEL_TYPE_VTRASH_FOLDER, CamelVTrashFolderClass)) #define CAMEL_VTRASH_NAME ".#evolution/Trash" #define CAMEL_VJUNK_NAME ".#evolution/Junk" G_BEGIN_DECLS typedef struct _CamelVTrashFolder CamelVTrashFolder; typedef struct _CamelVTrashFolderClass CamelVTrashFolderClass; typedef struct _CamelVTrashFolderPrivate CamelVTrashFolderPrivate; typedef enum { CAMEL_VTRASH_FOLDER_TRASH, CAMEL_VTRASH_FOLDER_JUNK, CAMEL_VTRASH_FOLDER_LAST } CamelVTrashFolderType; struct _CamelVTrashFolder { CamelVeeFolder parent; CamelVTrashFolderPrivate *priv; }; struct _CamelVTrashFolderClass { CamelVeeFolderClass parent_class; /* Padding for future expansion */ gpointer reserved[20]; }; GType camel_vtrash_folder_get_type (void); CamelFolder * camel_vtrash_folder_new (CamelStore *parent_store, CamelVTrashFolderType type); CamelVTrashFolderType camel_vtrash_folder_get_folder_type (CamelVTrashFolder *vtrash_ect.h> #include G_BEGIN_DECLS /** * CamelNameValueArray: * * Since: 3.24 **/ struct _CamelNameValueArray; typedef struct _CamelNameValueArray CamelNameValueArray; #define CAMEL_TYPE_NAME_VALUE_ARRAY (camel_name_value_array_get_type ()) GType camel_name_value_array_get_type (void) G_GNUC_CONST; CamelNameValueArray * camel_name_value_array_new (void); CamelNameValueArray * camel_name_value_array_new_sized (guint reserve_size); CamelNameValueArray * camel_name_value_array_copy (const CamelNameValueArray *array); void camel_name_value_array_free (CamelNameValueArray *array); guint camel_name_value_array_get_length (const CamelNameValueArray *array); gboolean camel_name_value_array_get (const CamelNameValueArray *array, guint index, const gchar **out_name, const gchar **out_value); const gchar * camel_name_value_array_get_named (const CamelNameValueArray *array, CamelCompareType compare_type, const gchar *name); coracket */ CAMEL_MIME_PARSER_STATE_HEADER_END, /* dummy value */ CAMEL_MIME_PARSER_STATE_BODY_END, /* end of message */ CAMEL_MIME_PARSER_STATE_MULTIPART_END, /* end of multipart */ CAMEL_MIME_PARSER_STATE_MESSAGE_END /* end of message */ } CamelMimeParserState; struct _CamelMimeParser { GObject parent; CamelMimeParserPrivate *priv; }; struct _CamelMimeParserClass { GObjectClass parent_class; void (*message) (CamelMimeParser *parser, gpointer headers); void (*part) (CamelMimeParser *parser); void (*content) (CamelMimeParser *parser); /* Padding for future expansion */ gpointer reserved[20]; }; GType camel_mime_parser_get_type (void); CamelMimeParser *camel_mime_parser_new (void); /* quick-fix for parser not erroring, we can find out if it had an error afterwards */ gint camel_mime_parser_errno (CamelMimeParser *parser); gint camel_mime_parser_init_with_fd (CamelMimeParser *m, gint fd); gint camel_mime_parser_init_with_stream (CamelMimeParser *m, CamelStream *stream, GErrorSEARCH_TYPE_ADDRESS_ENCODED, CAMEL_SEARCH_TYPE_MLIST /* its a mailing list pseudo-header */ } camel_search_t; /* builds a regex that represents a string search */ gint camel_search_build_match_regex (regex_t *pattern, camel_search_flags_t type, gint argc, CamelSExpResult **argv, GError **error); gboolean camel_search_message_body_contains (CamelDataWrapper *object, regex_t *pattern); gboolean camel_search_header_match (const gchar *value, const gchar *match, camel_search_match_t how, camel_search_t type, const gchar *default_charset); gboolean camel_search_camel_header_soundex (const gchar *header, const gchar *match); /* TODO: replace with a real search function */ const gchar * camel_ustrstrcase (const gchar *haystack, const gchar *needle); /* Some crappy utility functions for handling multiple search words */ typedef enum _camel_search_word_t { CAMEL_SEARCH_WORD_SIMPLE = 1, CAMEL_SEARCH_WORD_COMPLEX = 2, CAME_INDEX_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), CAMEL_TYPE_MIME_FILTER_INDEX, CamelMimeFilterIndexClass)) G_BEGIN_DECLS typedef struct _CamelMimeFilterIndex CamelMimeFilterIndex; typedef struct _CamelMimeFilterIndexClass CamelMimeFilterIndexClass; typedef struct _CamelMimeFilterIndexPrivate CamelMimeFilterIndexPrivate; struct _CamelMimeFilterIndex { CamelMimeFilter parent; CamelMimeFilterIndexPrivate *priv; }; struct _CamelMimeFilterIndexClass { CamelMimeFilterClass parent_class; /* Padding for future expansion */ gpointer reserved[20]; }; GType camel_mime_filter_index_get_type (void); CamelMimeFilter * camel_mime_filter_index_new (CamelIndex *index); /* Set the match name for any indexed words */ void camel_mime_filter_index_set_name (CamelMimeFilterIndex *filter, CamelIndexName *name); void camel_mime_filter_index_set_index (CamelMimeFilterIndex *filter, CamelIndex *index); G_END_DECLS #endif /* CAMEL_MIME_FILTER_INDEX_H */ /* * camel-junk-filter.h * fined (__CAMEL_H_INSIDE__) && !defined (CAMEL_COMPILATION) #error "Only can be included directly." #endif #ifndef CAMEL_SASL_DIGEST_MD5_H #define CAMEL_SASL_DIGEST_MD5_H #include #include /* Standard GObject macros */ #define CAMEL_TYPE_SASL_DIGEST_MD5 \ (camel_sasl_digest_md5_get_type ()) #define CAMEL_SASL_DIGEST_MD5(obj) \ (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), CAMEL_TYPE_SASL_DIGEST_MD5, CamelSaslDigestMd5)) #define CAMEL_SASL_DIGEST_MD5_CLASS(cls) \ (G_TYPE_CHECK_CLASS_CAST \ ((cls), CAMEL_TYPE_SASL_DIGEST_MD5, CamelSaslDigestMd5Class)) #define CAMEL_IS_SASL_DIGEST_MD5(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), CAMEL_TYPE_SASL_DIGEST_MD5)) #define CAMEL_IS_SASL_DIGEST_MD5_CLASS(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), CAMEL_TYPE_SASL_DIGEST_MD5)) #define CAMEL_SASL_DIGEST_MD5_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), CAMEL_TYPE_SASL_DIGEST_MD5, CamelSaslDigestMd5Class)) G_BEGIN_DECLS typedef struct _CamelSaslDigestMd5 CamelS_sync(), * or e_oauth2_service_refresh_and_store_token_sync() * @uid: an #ESource UID to return * * Returns: (transfer full) (nullable): an #ESource with UID @uid, or %NULL, if not found. * Dereference the returned non-NULL #ESource with g_object_unref(), when no longer needed. * * Since: 3.28 **/ typedef ESource * (* EOAuth2ServiceRefSourceFunc) (gpointer user_data, const gchar *uid); typedef struct _EOAuth2Service EOAuth2Service; typedef struct _EOAuth2ServiceInterface EOAuth2ServiceInterface; /** * EOAuth2Service: * * Contains only private data that should be read and manipulated using the * functions below. * * Since: 3.28 **/ struct _EOAuth2ServiceInterface { GTypeInterface parent_interface; gboolean (* can_process) (EOAuth2Service *service, ESource *source); gboolean (* guess_can_process) (EOAuth2Service *service, const gchar *protocol, const gchar *hostname); guint32 (* get_flags) (EOAuth2Service *service); const gchar * (* get_name) SERVICE, EOAuth2ServiceInterface)) /* Secret key names, saved by the code; not the names returned by the OAuth2 server */ #define E_OAUTH2_SECRET_REFRESH_TOKEN "refresh_token" #define E_OAUTH2_SECRET_ACCESS_TOKEN "access_token" #define E_OAUTH2_SECRET_EXPIRES_AFTER "expires_after" G_BEGIN_DECLS /** * EOAuth2ServiceFlags: * @E_OAUTH2_SERVICE_FLAG_NONE: No flag set * @E_OAUTH2_SERVICE_FLAG_EXTRACT_REQUIRES_PAGE_CONTENT: the service requires also page * content to be passed to e_oauth2_service_extract_authorization_code() * * Flags of the OAuth2 service. * * Since: 3.28 **/ typedef enum { E_OAUTH2_SERVICE_FLAG_NONE = 0, E_OAUTH2_SERVICE_FLAG_EXTRACT_REQUIRES_PAGE_CONTENT = (1 << 1) } EOAuth2ServiceFlags; /** * EOAuth2ServiceNavigationPolicy: * @E_OAUTH2_SERVICE_NAVIGATION_POLICY_DENY: Deny navigation to the given web resource * @E_OAUTH2_SERVICE_NAVIGATION_POLICY_ALLOW: Allow navigation to the given web resource * @E_OAUTH2_SERVICE_NAVIGATION_POLICY_ABORT: Abort authentication processing" property is a comma-separated list of capabilities * supported by the backend. The preferred method of retrieving and working * with capabilities is e_client_get_capabilities() and * e_client_check_capability(). * * Since: 3.2 **/ #define CLIENT_BACKEND_PROPERTY_CAPABILITIES "capabilities" /** * CLIENT_BACKEND_PROPERTY_REVISION: * * The current overall revision string, this can be used as * a quick check to see if data has changed at all since the * last time the revision was observed. * * Since: 3.4 **/ #define CLIENT_BACKEND_PROPERTY_REVISION "revision" /** * E_CLIENT_ERROR: * * Error domain for #EClient operations. Errors in this domain will be * from the #EClientError enumeration. See #GError for more information * on error domains. * * Since: 3.2 **/ #define E_CLIENT_ERROR e_client_error_quark () G_BEGIN_DECLS /** * EClientError: * @E_CLIENT_ERROR_INVALID_ARG: Invalid argument was used * @E_CLIENT_ERROR_BUSY: The client is busy * @E_CLIENT_ERROR_SOURCE_NOT_LOADED: Th_ESourceCamelPrivate ESourceCamelPrivate; /** * ESourceCamel: * * Contains only private data that should be read and manipulated using the * functions below. * * Since: 3.6 **/ struct _ESourceCamel { /*< private >*/ ESourceExtension parent; ESourceCamelPrivate *priv; }; struct _ESourceCamelClass { ESourceExtensionClass parent_class; /* Same idea as in CamelServiceClass. */ GType settings_type; }; GType e_source_camel_get_type (void) G_GNUC_CONST; void e_source_camel_register_types (void); GType e_source_camel_generate_subtype (const gchar *protocol, GType settings_type); CamelSettings * e_source_camel_get_settings (ESourceCamel *extension); const gchar * e_source_camel_get_type_name (const gchar *protocol); const gchar * e_source_camel_get_extension_name (const gchar *protocol); void e_source_camel_configure_service (ESource *source, CamelService *service); G_END_DECLS #endif /* E_SOURCE_CAMEL_H */ /* * Copyright (C) 2015 Red Hat, Inc. (www.redhat.com) * Copt_enabled (ESourceRefresh *extension); void e_source_refresh_set_enabled (ESourceRefresh *extension, gboolean enabled); gboolean e_source_refresh_get_enabled_on_metered_network (ESourceRefresh *extension); void e_source_refresh_set_enabled_on_metered_network (ESourceRefresh *extension, gboolean enabled); guint e_source_refresh_get_interval_minutes (ESourceRefresh *extension); void e_source_refresh_set_interval_minutes (ESourceRefresh *extension, guint interval_minutes); guint e_source_refresh_add_timeout (ESource *source, GMainContext *context, ESourceRefreshFunc callback, gpointer user_data, GDestroyNotify notify); void e_source_refresh_force_timeout (ESource *source); gboolean e_source_refresh_remove_timeout (ESource *source, guint refresh_timeout_id); guint e_source_refresh_remove_timeouts_by_data (ESource *source, gpointer user_data); G_END_DECLS #endif /* E_SOURCE_REFRESH_H */ /* * e-source-smime.h * (ESourceMailSubmission *extension); void e_source_mail_submission_set_sent_folder (ESourceMailSubmission *extension, const gchar *sent_folder); gboolean e_source_mail_submission_get_use_sent_folder (ESourceMailSubmission *extension); void e_source_mail_submission_set_use_sent_folder (ESourceMailSubmission *extension, gboolean use_sent_folder); const gchar * e_source_mail_submission_get_transport_uid (ESourceMailSubmission *extension); gchar * e_source_mail_submission_dup_transport_uid (ESourceMailSubmission *extension); void e_source_mail_submission_set_transport_uid (ESourceMailSubmission *extension, const gchar *transport_uid); gboolean e_source_mail_submission_get_replies_to_origin_folder (ESourceMailSubmission *extension); void e_source_mail_submission_set_replies_to_origin_folder (ESourceMailSubmission *extension, gboolean replies_to_origin_folder); G_END_DECLS #endif /* E_SOURCE_MAIL_SUBMISSION_H */ /* * Copyright (C) 2015 Red Halgorithm (ESourceOpenPGP *extension, const gchar *signing_algorithm); gboolean e_source_openpgp_get_sign_by_default (ESourceOpenPGP *extension); void e_source_openpgp_set_sign_by_default (ESourceOpenPGP *extension, gboolean sign_by_default); gboolean e_source_openpgp_get_encrypt_by_default (ESourceOpenPGP *extension); void e_source_openpgp_set_encrypt_by_default (ESourceOpenPGP *extension, gboolean encrypt_by_default); gboolean e_source_openpgp_get_prefer_inline (ESourceOpenPGP *extension); void e_source_openpgp_set_prefer_inline (ESourceOpenPGP *extension, gboolean prefer_inline); gboolean e_source_openpgp_get_locate_keys(ESourceOpenPGP *extension); void e_source_openpgp_set_locate_keys(ESourceOpenPGP *extension, gboolean locate_keys); gboolean e_source_openpgp_get_send_public_key (ESourceOpenPGP *extension); void e_source_openpgp_set_send_public_key (ESourceOpenPGP *extension, gboolean send_public_key); gboo\ (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), E_TYPE_LIST_ITERATOR, EListIterator)) #define E_LIST_ITERATOR_CLASS(cls) \ (G_TYPE_CHECK_CLASS_CAST \ ((cls), E_TYPE_LIST_ITERATOR, EListIteratorClass)) #define E_IS_LIST_ITERATOR(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), E_TYPE_LIST_ITERATOR)) #define E_IS_LIST_ITERATOR_CLASS(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), E_TYPE_LIST_ITERATOR)) #define E_LIST_ITERATOR_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), E_TYPE_LIST_ITERATOR, EListIteratorClass)) G_BEGIN_DECLS typedef struct _EListIterator EListIterator; typedef struct _EListIteratorClass EListIteratorClass; struct _EListIterator { EIterator parent; EList *list; GList *iterator; }; struct _EListIteratorClass { EIteratorClass parent_class; }; GType e_list_iterator_get_type (void) G_GNUC_CONST; EIterator * e_list_iterator_new (EList *list); G_END_DECLS #endif /* E_LIST_ITERATOR_H */ #endif /* __GI_SCANNER__ */ #endif /* EDS_DISABLE_DEPRECATED */ /* * e-source-autocomplete.h * PROMPT_FLAG_REMEMBER_MASK = 0xf, E_CREDENTIALS_PROMPT_FLAG_SECRET = 1 << 8, /* whether hide password letters in the UI */ E_CREDENTIALS_PROMPT_FLAG_REPROMPT = 1 << 9, /* automatically set when username and password is provided */ E_CREDENTIALS_PROMPT_FLAG_ONLINE = 1 << 10, /* only ask if we're online */ E_CREDENTIALS_PROMPT_FLAG_DISABLE_REMEMBER = 1 << 11, /* disable the 'remember password' checkbox */ E_CREDENTIALS_PROMPT_FLAG_PASSPHRASE = 1 << 12 /* We are asking a passphrase */ } ECredentialsPromptFlags; ECredentials * e_credentials_new (void); ECredentials * e_credentials_new_strv (const gchar * const *strv); ECredentials * e_credentials_new_args (const gchar *key, ...) G_GNUC_NULL_TERMINATED; ECredentials * e_credentials_new_clone (const ECredentials *credentials); void e_credentials_free ( ECredentials *credentials); gchar ** e_credentials_to_strv (const ECredentials *credentials); void e_credentials_set ( ECredentials *credentials, const gchar *key, const gchar *value); gchar * e_crd e_source_proxy_set_method (ESourceProxy *extension, EProxyMethod method); const gchar * e_source_proxy_get_autoconfig_url (ESourceProxy *extension); gchar * e_source_proxy_dup_autoconfig_url (ESourceProxy *extension); void e_source_proxy_set_autoconfig_url (ESourceProxy *extension, const gchar *autoconfig_url); const gchar * const * e_source_proxy_get_ignore_hosts (ESourceProxy *extension); gchar ** e_source_proxy_dup_ignore_hosts (ESourceProxy *extension); void e_source_proxy_set_ignore_hosts (ESourceProxy *extension, const gchar * const *ignore_hosts); const gchar * e_source_proxy_get_ftp_host (ESourceProxy *extension); gchar * e_source_proxy_dup_ftp_host (ESourceProxy *extension); void e_source_proxy_set_ftp_host (ESourceProxy *extension, const gchar *ftp_host); guint16 e_source_proxy_get_ftp_port (ESourceProxy *extension); void e_source_proxy_set_ftp_port (ESourceProxy *extension, guint16 ftp_port); const gchar * e_source_proxy_get_http_host_set_authentication (ESourceLDAP *extension, ESourceLDAPAuthentication authentication); gboolean e_source_ldap_get_can_browse (ESourceLDAP *extension); void e_source_ldap_set_can_browse (ESourceLDAP *extension, gboolean can_browse); const gchar * e_source_ldap_get_filter (ESourceLDAP *extension); gchar * e_source_ldap_dup_filter (ESourceLDAP *extension); void e_source_ldap_set_filter (ESourceLDAP *extension, const gchar *filter); guint e_source_ldap_get_limit (ESourceLDAP *extension); void e_source_ldap_set_limit (ESourceLDAP *extension, guint limit); const gchar * e_source_ldap_get_root_dn (ESourceLDAP *extension); gchar * e_source_ldap_dup_root_dn (ESourceLDAP *extension); void e_source_ldap_set_root_dn (ESourceLDAP *extension, const gchar *root_dn); ESourceLDAPScope e_source_ldap_get_scope (ESourceLDAP *extension); void e_source_ldap_set_scope (ESourceLDAP *extension, ESourceLDAPScope scope); ESourceLDAPSecurity e_source_ldap_get_security (ESoines what connection security should be used for LDAP sources. * * Since: 3.18 **/ typedef enum { E_SOURCE_LDAP_SECURITY_NONE, E_SOURCE_LDAP_SECURITY_LDAPS, E_SOURCE_LDAP_SECURITY_STARTTLS } ESourceLDAPSecurity; /** * ESourceWeatherUnits: * @E_SOURCE_WEATHER_UNITS_FAHRENHEIT: * Fahrenheit units * @E_SOURCE_WEATHER_UNITS_CENTIGRADE: * Centigrade units * @E_SOURCE_WEATHER_UNITS_KELVIN: * Kelvin units * * Units to be used in an #ESourceWeather extension. * * Since: 3.18 **/ typedef enum { E_SOURCE_WEATHER_UNITS_FAHRENHEIT = 0, E_SOURCE_WEATHER_UNITS_CENTIGRADE, E_SOURCE_WEATHER_UNITS_KELVIN } ESourceWeatherUnits; /** * ESourceMailCompositionReplyStyle: * @E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_DEFAULT: * Use default reply style. * @E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_QUOTED: * Use quoted reply style. * @E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_DO_NOT_QUOTE: * Do not quote anything in replies. * @E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_ATTACH: * Attach original message in* Ask the user before responding to an MDN request. * * Policy for responding to Message Disposition Notification requests * (i.e. a Disposition-Notification-To header) when receiving messages. * See RFC 2298 for more information about MDN requests. * * Since: 3.6 **/ typedef enum { E_MDN_RESPONSE_POLICY_NEVER, E_MDN_RESPONSE_POLICY_ALWAYS, E_MDN_RESPONSE_POLICY_ASK } EMdnResponsePolicy; /** * EProxyMethod: * @E_PROXY_METHOD_DEFAULT: * Use the default #GProxyResolver (see g_proxy_resolver_get_default()). * @E_PROXY_METHOD_MANUAL: * Use the FTP/HTTP/HTTPS/SOCKS settings defined in #ESourceProxy. * @E_PROXY_METHOD_AUTO: * Use the autoconfiguration URL defined in #ESourceProxy. * @E_PROXY_METHOD_NONE: * Direct connection; do not use a network proxy. * * Network proxy configuration methods. * * Since: 3.12 **/ typedef enum { E_PROXY_METHOD_DEFAULT, E_PROXY_METHOD_MANUAL, E_PROXY_METHOD_AUTO, E_PROXY_METHOD_NONE } EProxyMethod; /** * ESourceAuthenticationResult: * @E_SOURCrkMonitorClass)) #define E_IS_NETWORK_MONITOR(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), E_TYPE_NETWORK_MONITOR)) #define E_IS_NETWORK_MONITOR_CLASS(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), E_TYPE_NETWORK_MONITOR)) #define E_NETWORK_MONITOR_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), E_TYPE_NETWORK_MONITOR, ENetworkMonitorClass)) G_BEGIN_DECLS typedef struct _ENetworkMonitor ENetworkMonitor; typedef struct _ENetworkMonitorClass ENetworkMonitorClass; typedef struct _ENetworkMonitorPrivate ENetworkMonitorPrivate; /** * E_NETWORK_MONITOR_ALWAYS_ONLINE_NAME: (value "always-online") * * A special name, which can be used as a GIO name in the call * to e_network_monitor_set_gio_name(), which is used to report * the network as always reachable. * * Since: 3.22 **/ #define E_NETWORK_MONITOR_ALWAYS_ONLINE_NAME "always-online" /** * ENetworkMonitor: * * Contains only private data that should be read and manipulated using * the functions below. Implements #GNetworkMonitorInterface. * ize max, const gchar *fmt, const struct tm *tm); gchar ** e_util_slist_to_strv (const GSList *strings); GSList * e_util_strv_to_slist (const gchar * const *strv); void e_util_free_nullable_object_slist (GSList *objects); void e_util_safe_free_string (gchar *str); void e_queue_transfer (GQueue *src_queue, GQueue *dst_queue); GWeakRef * e_weak_ref_new (gpointer object); void e_weak_ref_free (GWeakRef *weak_ref); gboolean e_file_recursive_delete_sync (GFile *file, GCancellable *cancellable, GError **error); void e_file_recursive_delete (GFile *file, gint io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean e_file_recursive_delete_finish (GFile *file, GAsyncResult *result, GError **error); GBinding * e_binding_bind_property (gpointer source, const gchar *source_property, gpointer target, const gchar *target_property, GBindingFlags flags); guint32 flags, /* bit-or of EWebDAVListFlags */ GSList **out_resources, /* EWebDAVResource * */ GCancellable *cancellable, GError **error); gboolean e_webdav_session_update_properties_sync (EWebDAVSession *webdav, const gchar *uri, const GSList *changes, /* EWebDAVPropertyChange * */ GCancellable *cancellable, GError **error); gboolean e_webdav_session_lock_resource_sync (EWebDAVSession *webdav, const gchar *uri, EWebDAVLockScope lock_scope, gint32 lock_timeout, const gchar *owner, gchar **out_lock_token, GCancellable *cancellable, GError **error); gboolean e_webdav_session_acl_sync (EWebDAVSession *webdav, const gchar *uri, const EXmlDocument *xml, GCancellable *cancellable, GError **error); gboolean e_webdav_session_get_supported_privilege_set_sync (EWebDAVSession *webdav, const gchar *uri, GNode **out_privileges, /* EWebDAVPrivilege * */ const gchar *prefix, GError **inout_error); gchar * e_webdav_session_ensure_full_uri (EWebDAVSession *webdav, const GUri *request_uri, const gchar *href); gboolean e_webdav_session_options_sync (EWebDAVSession *webdav, const gchar *uri, GHashTable **out_capabilities, GHashTable **out_allows, GCancellable *cancellable, GError **error); gboolean e_webdav_session_post_sync (EWebDAVSession *webdav, const gchar *uri, const gchar *data, gsize data_length, const gchar *in_content_type, SoupMessageHeaders *in_headers, gchar **out_content_type, SoupMessageHeaders **out_headers, GByteArray **out_content, GCancellable *cancellable, GError **error); gboolean e_webdav_session_propfind_sync (EWebDAVSession *webdav, const gchar *uri, const gchar *depth, const EXmlDocument *xml, EWebDAVPropstatTraverseFunc func, gpointer func_user_daename, xmlDoc *doc); xmlNode * e_xml_get_child_by_name (const xmlNode *parent, const xmlChar *child_name); xmlDoc * e_xml_parse_data (gconstpointer data, gsize length); xmlXPathContext * e_xml_new_xpath_context_with_namespaces (xmlDoc *doc, ...) G_GNUC_NULL_TERMINATED; void e_xml_xpath_context_register_namespaces (xmlXPathContext *xpath_ctx, const gchar *prefix, const gchar *href, ...) G_GNUC_NULL_TERMINATED; xmlXPathObject * e_xml_xpath_eval (xmlXPathContext *xpath_ctx, const gchar *format, ...) G_GNUC_PRINTF (2, 3); gchar * e_xml_xpath_eval_as_string (xmlXPathContext *xpath_ctx, const gchar *format, ...) G_GNUC_PRINTF (2, 3); gboolean e_xml_xpath_eval_exists (xmlXPathContext *xpath_ctx, const gchar *format, ...) G_GNUC_PRINTF (2, 3); gboolean e_xml_is_element_name (xmlNode *node, const gchar *ns_href, const gchar *name); xmlNode * e_xml_find_sibling (xmlNode *sibling, E_EXTENSION, ESourceExtensionClass)) G_BEGIN_DECLS typedef struct _ESourceExtension ESourceExtension; typedef struct _ESourceExtensionClass ESourceExtensionClass; typedef struct _ESourceExtensionPrivate ESourceExtensionPrivate; /** * ESourceExtension: * * Contains only private data that should be read and manipulated using the * functions below. * * Since: 3.6 **/ struct _ESourceExtension { /*< private >*/ GObject parent; ESourceExtensionPrivate *priv; }; struct _ESourceExtensionClass { GObjectClass parent_class; const gchar *name; }; GType e_source_extension_get_type (void) G_GNUC_CONST; ESource * e_source_extension_ref_source (ESourceExtension *extension); void e_source_extension_property_lock (ESourceExtension *extension); void e_source_extension_property_unlock (ESourceExtension *extension); #ifndef EDS_DISABLE_DEPRECATED ESource * e_source_extension_get_source (ESourceExtension *extension); #endif /* EDS_DISABLE_DEPRECATED */ G_END_DECLS #endif /* E_SOURCE_EXTENSION_H #define E_OAUTH2_SERVICE_GOOGLE_CLASS(cls) \ (G_TYPE_CHECK_CLASS_CAST \ ((cls), E_TYPE_OAUTH2_SERVICE_GOOGLE, EOAuth2ServiceGoogleClass)) #define E_IS_OAUTH2_SERVICE_GOOGLE(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), E_TYPE_OAUTH2_SERVICE_GOOGLE)) #define E_IS_OAUTH2_SERVICE_GOOGLE_CLASS(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), E_TYPE_OAUTH2_SERVICE_GOOGLE)) #define E_OAUTH2_SERVICE_GOOGLE_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), E_TYPE_OAUTH2_SERVICE_GOOGLE, EOAuth2ServiceGoogleClass)) G_BEGIN_DECLS typedef struct _EOAuth2ServiceGoogle EOAuth2ServiceGoogle; typedef struct _EOAuth2ServiceGoogleClass EOAuth2ServiceGoogleClass; struct _EOAuth2ServiceGoogle { EOAuth2ServiceBase parent; }; struct _EOAuth2ServiceGoogleClass { EOAuth2ServiceBaseClass parent_class; }; GType e_oauth2_service_google_get_type (void) G_GNUC_CONST; G_END_DECLS #endif /* E_OAUTH2_SERVICE_GOOGLE_H */ /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ /* * Copyright (C) 2017 Red Hamanipulated using the * functions below. **/ struct _ESourceRegistryWatcher { /*< private >*/ GObject parent; ESourceRegistryWatcherPrivate *priv; }; struct _ESourceRegistryWatcherClass { GObjectClass parent_class; /* Signals */ gboolean (* filter) (ESourceRegistryWatcher *watcher, ESource *source); void (* appeared) (ESourceRegistryWatcher *watcher, ESource *source); void (* disappeared) (ESourceRegistryWatcher *watcher, ESource *source); }; GType e_source_registry_watcher_get_type (void) G_GNUC_CONST; ESourceRegistryWatcher * e_source_registry_watcher_new (ESourceRegistry *registry, const gchar *extension_name); ESourceRegistry * e_source_registry_watcher_get_registry (ESourceRegistryWatcher *watcher); const gchar * e_source_registry_watcher_get_extension_name (ESourceRegistryWatcher *watcher); void e_source_registry_watcher_reclaim (ESourceRegistryWatcher *watcher); G_END_DECLS #endif /* E_SOURCE_REGISTRY_WATCHER_H */ /* * e-source-collection.h * essage_simple_sync (ESoupSession *session, SoupMessage *message, GCancellable *cancellable, GError **error); GByteArray * e_soup_session_util_get_message_bytes (SoupMessage *message); const gchar * e_soup_session_util_status_to_string (guint status_code, const gchar *reason_phrase); GUri * e_soup_session_util_normalize_uri_path (GUri *uri); void e_soup_session_util_set_message_request_body (SoupMessage *message, const gchar *content_type, GInputStream *input_stream, gssize length); void e_soup_session_util_set_message_request_body_from_data (SoupMessage *message, gboolean create_copy, const gchar *content_type, gconstpointer data, gssize length, GDestroyNotify free_func); GInputStream * e_soup_session_util_ref_message_request_body (SoupMessage *message, gssize *out_length); gboolean e_soup_session_util_get_force_http1_supported (void); G_END_DECLS #endif /* E_SOUP_SESSION_H *boolean e_secret_store_delete_sync (const gchar *uid, GCancellable *cancellable, GError **error); G_END_DECLS #endif /* E_SECRET_STORE_H */ /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ /* * SPDX-FileCopyrightText: (C) 2020 Red Hat (www.redhat.com) * SPDX-License-Identifier: LGPL-2.1-or-later */ #if !defined (__LIBEDATASERVER_H_INSIDE__) && !defined (LIBEDATASERVER_COMPILATION) #error "Only should be included directly." #endif #ifndef E_JSON_UTILS_H #define E_JSON_UTILS_H #ifndef __GI_SCANNER__ #include G_BEGIN_DECLS JsonArray * e_json_get_array_member (JsonObject *object, const gchar *member_name); void e_json_begin_array_member (JsonBuilder *builder, const gchar *member_name); void e_json_end_array_member (JsonBuilder *builder); gboolean e_json_get_boolean_member (JsonObject *object, const gchar *member_name, gboolean default_value); void e_json_add_booleancellable, GError **error); gboolean e_gdata_session_tasklists_update_sync (EGDataSession *self, const gchar *tasklist_id, JsonBuilder *tasklist, JsonObject **out_updated_tasklist, GCancellable *cancellable, GError **error); /** * EGDataTaskStatus: * @E_GDATA_TASK_STATUS_UNKNOWN: unknown status * @E_GDATA_TASK_STATUS_NEEDS_ACTION: the task needs action * @E_GDATA_TASK_STATUS_COMPLETED: the task is completed * * Holds status of a task. * * Since: 3.46 **/ typedef enum { E_GDATA_TASK_STATUS_UNKNOWN, E_GDATA_TASK_STATUS_NEEDS_ACTION, E_GDATA_TASK_STATUS_COMPLETED } EGDataTaskStatus; const gchar * e_gdata_task_get_id (JsonObject *task); void e_gdata_task_add_id (JsonBuilder *builder, const gchar *value); const gchar * e_gdata_task_get_etag (JsonObject *task); const gchar * e_gdata_task_get_title (JsonObject *task); void e_gdata_task_add_title (JsonBuilder *builder, const gchar *value); gint64 e_gdata_task_get_updated (JsonS_CALENDAR_AUTO_SCHEDULE = E_WEBDAV_RESOURCE_SUPPORTS_LAST << 1, E_WEBDAV_DISCOVER_SUPPORTS_SUBSCRIBED_ICALENDAR = E_WEBDAV_DISCOVER_SUPPORTS_CALENDAR_AUTO_SCHEDULE << 1 } EWebDAVDiscoverSupports; typedef struct _EWebDAVDiscoveredSource { gchar *href; guint32 supports; gchar *display_name; gchar *description; gchar *color; guint order; } EWebDAVDiscoveredSource; void e_webdav_discover_free_discovered_sources (GSList *discovered_sources); void e_webdav_discover_sources (ESource *source, const gchar *url_use_path, guint32 only_supports, const ENamedParameters *credentials, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean e_webdav_discover_sources_finish (ESource *source, GAsyncResult *result, gchar **out_certificate_pem, GTlsCertificateFlags *out_certificate_errors, GSList **out_discovered_sources, GSList **out_calendar_user_addresses, GError **error); gbo-source-enumtypes.h> #include #ifndef E_COLLATOR_H #define E_COLLATOR_H /** * E_COLLATOR_ERROR: * * An error domain for collation errors * * Since: 3.12 */ #define E_COLLATOR_ERROR (e_collator_error_quark ()) #define E_TYPE_COLLATOR (e_collator_get_type ()) G_BEGIN_DECLS /** * ECollatorError: * @E_COLLATOR_ERROR_OPEN: An error occured trying to open a collator and access collation data. * @E_COLLATOR_ERROR_CONVERSION: An error occurred converting character encodings * @E_COLLATOR_ERROR_INVALID_LOCALE: A malformed locale name was given to e_collator_new() * * Errors from the #E_COLLATOR_ERROR domain. */ typedef enum { E_COLLATOR_ERROR_OPEN, E_COLLATOR_ERROR_CONVERSION, E_COLLATOR_ERROR_INVALID_LOCALE } ECollatorError; /** * ECollator: * * An opaque object used for locale specific string comparisons * and sort ordering. * * Since: 3.12 */ typedef struct _ECollator ECollator; GType e_collator_get_type (void); GQuark d a copy of the GNU Lesser General Public License * along with this library. If not, see . * */ #if !defined (__LIBEDATASERVER_H_INSIDE__) && !defined (LIBEDATASERVER_COMPILATION) #error "Only should be included directly." #endif #ifndef E_SOURCE_CREDENTIALS_PROVIDER_IMPL_H #define E_SOURCE_CREDENTIALS_PROVIDER_IMPL_H #include #include #include #include #include /* Standard GObject macros */ #define E_TYPE_SOURCE_CREDENTIALS_PROVIDER_IMPL \ (e_source_credentials_provider_impl_get_type ()) #define E_SOURCE_CREDENTIALS_PROVIDER_IMPL(obj) \ (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), E_TYPE_SOURCE_CREDENTIALS_PROVIDER_IMPL, ESourceCredentialsProviderImpl)) #define E_SOURCE_CREDENTIALS_PROVIDER_IMPL_CLASS(cls) \ (G_TYPE_CHECK_CLASS_CAST \ ((cls), E_TYPE_SOURCE_CREDENTIALS_PROVIDER_IMPL, ESourceCredentialsProviderImplClass))ourceSecurity, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(ESourceSelectable, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(ESourceSMIME, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(ESourceTaskList, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(ESourceUoa, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(ESourceWeather, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(ESourceWebdav, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(EWebDAVDiscoveredSource, e_webdav_discovered_source_free) G_DEFINE_AUTOPTR_CLEANUP_FUNC(EWebDAVSession, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(EWebDAVResource, e_webdav_resource_free) G_DEFINE_AUTOPTR_CLEANUP_FUNC(EWebDAVPropertyChange, e_webdav_property_change_free) G_DEFINE_AUTOPTR_CLEANUP_FUNC(EWebDAVPrivilege, e_webdav_privilege_free) G_DEFINE_AUTOPTR_CLEANUP_FUNC(EWebDAVAccessControlEntry, e_webdav_access_control_entry_free) G_DEFINE_AUTOPTR_CLEANUP_FUNC(EXmlDocument, g_object_unref) #endif /* G_DEFINE_AUTOPTR_CLEANUP_FUNC */ #endif /* !__GI_SCANNER__ */ #endif /* __E_DATASEsource_invoke_authenticate() automatically, if the * corresponding ESource contain a WebDAV extension and the key * is not part of the credentials already. * * Since: 3.16 **/ #define E_SOURCE_CREDENTIAL_SSL_TRUST "ssl-trust" G_BEGIN_DECLS typedef struct _ESource ESource; typedef struct _ESourceClass ESourceClass; typedef struct _ESourcePrivate ESourcePrivate; /** * ESource: * * Contains only private data that should be read and manipulated using the * functions below. * * Since: 3.6 **/ struct _ESource { /*< private >*/ GObject parent; ESourcePrivate *priv; }; struct _ESourceClass { GObjectClass parent_class; /* Signals */ void (*changed) (ESource *source); void (*credentials_required) (ESource *source, ESourceCredentialsReason reason, const gchar *certificate_pem, GTlsCertificateFlags certificate_errors, const GError *op_error); void (* authenticate) (ESource *source, const ENamedParameters *credentials); /* Methods */ gboolean (*remove_syncon); void e_source_authentication_set_remember_password (ESourceAuthentication *extension, gboolean remember_password); const gchar * e_source_authentication_get_user (ESourceAuthentication *extension); gchar * e_source_authentication_dup_user (ESourceAuthentication *extension); void e_source_authentication_set_user (ESourceAuthentication *extension, const gchar *user); const gchar * e_source_authentication_get_credential_name (ESourceAuthentication *extension); gchar * e_source_authentication_dup_credential_name (ESourceAuthentication *extension); void e_source_authentication_set_credential_name (ESourceAuthentication *extension, const gchar *credential_name); gboolean e_source_authentication_get_is_external (ESourceAuthentication *extension); void e_source_authentication_set_is_external (ESourceAuthentication *extension, gboolean is_external); G_END_DECLS #endif /* E_SOURCE_AUTHENTICATION_H */ /* * e-source-mail-transport.h * * included directly." #endif #ifndef E_SOURCE_MAIL_IDENTITY_H #define E_SOURCE_MAIL_IDENTITY_H #include /* Standard GObject macros */ #define E_TYPE_SOURCE_MAIL_IDENTITY \ (e_source_mail_identity_get_type ()) #define E_SOURCE_MAIL_IDENTITY(obj) \ (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), E_TYPE_SOURCE_MAIL_IDENTITY, ESourceMailIdentity)) #define E_SOURCE_MAIL_IDENTITY_CLASS(cls) \ (G_TYPE_CHECK_CLASS_CAST \ ((cls), E_TYPE_SOURCE_MAIL_IDENTITY, ESourceMailIdentityClass)) #define E_IS_SOURCE_MAIL_IDENTITY(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), E_TYPE_SOURCE_MAIL_IDENTITY)) #define E_IS_SOURCE_MAIL_IDENTITY_CLASS(cls) \ (G_TYPE_CHECK_CLASS_TYPE \ ((cls), E_TYPE_SOURCE_MAIL_IDENTITY)) #define E_SOURCE_MAIL_IDENTITY_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS \ ((obj), E_TYPE_SOURCE_MAIL_IDENTITY, ESourceMailIdentityClass)) /** * E_SOURCE_EXTENSION_MAIL_IDENTITY: * * Pass this extension name to e_source_get_extension() to access * #ESourceMailIdentity. Thiswith this library. If not, see . * * Authors: Michael Zucchi * Jacob Berkman */ #if !defined (__LIBEDATASERVER_H_INSIDE__) && !defined (LIBEDATASERVER_COMPILATION) #error "Only should be included directly." #endif #ifndef E_MEMORY_H #define E_MEMORY_H #include G_BEGIN_DECLS /* memchunks - allocate/free fixed-size blocks of memory */ /* this is like gmemchunk, only faster and less overhead (only 4 bytes for every atomcount allocations) */ typedef struct _EMemChunk EMemChunk; EMemChunk * e_memchunk_new (gint atomcount, gint atomsize); gpointer e_memchunk_alloc (EMemChunk *memchunk); gpointer e_memchunk_alloc0 (EMemChunk *memchunk); void e_memchunk_free (EMemChunk *memchunk, gpointer mem); void e_memchunk_empty (EMemChunk *memchunk); void e_memchunk_clean (EMemChunk *memchunk); void e_memchunk_destroy (EMemChunk *memchunk); G_END_DECLS #endif /* E_MEMORY_H */ N_ALARMS: * * Pass this extension name to e_source_get_extension() to access * #ESourceAlarms. This is also used as a group name in key files. * * Since: 3.6 **/ #define E_SOURCE_EXTENSION_ALARMS "Alarms" G_BEGIN_DECLS typedef struct _ESourceAlarms ESourceAlarms; typedef struct _ESourceAlarmsClass ESourceAlarmsClass; typedef struct _ESourceAlarmsPrivate ESourceAlarmsPrivate; /** * ESourceAlarms: * * Contains only private data that should be read and manipulated using the * functions below. * * Since: 3.6 **/ struct _ESourceAlarms { /*< private >*/ ESourceExtension parent; ESourceAlarmsPrivate *priv; }; struct _ESourceAlarmsClass { ESourceExtensionClass parent_class; }; GType e_source_alarms_get_type (void) G_GNUC_CONST; gboolean e_source_alarms_get_include_me (ESourceAlarms *extension); void e_source_alarms_set_include_me (ESourceAlarms *extension, gboolean include_me); const gchar * e_source_alarms_get_last_notified (ESourceAlarms *extension); gchar * e_source_alarms_du licensed under the same license as the containing project. Note that it links to GLib, so must comply with the LGPL linking clauses. */ #ifndef E_SOURCE_ENUMTYPES_H #define E_SOURCE_ENUMTYPES_H #include G_BEGIN_DECLS /* Enumerations from "e-source-enums.h" */ #define E_TYPE_MDN_RESPONSE_POLICY (e_mdn_response_policy_get_type()) GType e_mdn_response_policy_get_type (void) G_GNUC_CONST; #define E_TYPE_PROXY_METHOD (e_proxy_method_get_type()) GType e_proxy_method_get_type (void) G_GNUC_CONST; #define E_TYPE_SOURCE_AUTHENTICATION_RESULT (e_source_authentication_result_get_type()) GType e_source_authentication_result_get_type (void) G_GNUC_CONST; #define E_TYPE_TRUST_PROMPT_RESPONSE (e_trust_prompt_response_get_type()) GType e_trust_prompt_response_get_type (void) G_GNUC_CONST; #define E_TYPE_SOURCE_CONNECTION_STATUS (e_source_connection_status_get_type()) GType e_source_connection_status_get_type (void) G_GNUC_CONST; #define E_TYPE_SOURCE_CREDENTIALS_REASON (e_source_credentials_reason_get_ty gchar **out_uid, GError **error); gboolean e_cal_client_create_object_sync (ECalClient *client, ICalComponent *icalcomp, ECalOperationFlags opflags, gchar **out_uid, GCancellable *cancellable, GError **error); void e_cal_client_create_objects (ECalClient *client, GSList *icalcomps, /* ICalComponent * */ ECalOperationFlags opflags, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean e_cal_client_create_objects_finish (ECalClient *client, GAsyncResult *result, GSList **out_uids, /* gchar * */ GError **error); gboolean e_cal_client_create_objects_sync (ECalClient *client, GSList *icalcomps, /* ICalComponent * */ ECalOperationFlags opflags, GSList **out_uids, /* gchar * */ GCancellable *cancellable, GError **error); void e_cal_client_modify_object (ECalClient *client, ICalComponent *icalcomp, ECalObjModType mod, xists * @E_CAL_CLIENT_ERROR_INVALID_RANGE: Invalid range * * Since: 3.2 **/ typedef enum { E_CAL_CLIENT_ERROR_NO_SUCH_CALENDAR, E_CAL_CLIENT_ERROR_OBJECT_NOT_FOUND, E_CAL_CLIENT_ERROR_INVALID_OBJECT, E_CAL_CLIENT_ERROR_UNKNOWN_USER, E_CAL_CLIENT_ERROR_OBJECT_ID_ALREADY_EXISTS, E_CAL_CLIENT_ERROR_INVALID_RANGE } ECalClientError; GQuark e_cal_client_error_quark (void) G_GNUC_CONST; const gchar * e_cal_client_error_to_string (ECalClientError code); GError * e_cal_client_error_create (ECalClientError code, const gchar *custom_msg); GError * e_cal_client_error_create_fmt (ECalClientError code, const gchar *format, ...) G_GNUC_PRINTF (2, 3); typedef struct _ECalClient ECalClient; typedef struct _ECalClientClass ECalClientClass; typedef struct _ECalClientPrivate ECalClientPrivate; /** * ECalClient: * * Contains only private data that should be read and manipulated using the * functions below. * * Since: 3.2 **/ struct _ECalClient { /*< private >*/ EClient parent; ECalClirror); void (* cal_client_connect) (EReminderWatcher *watcher, ESource *source, ECalClientSourceType source_type, guint32 wait_for_connected_seconds, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); EClient * (* cal_client_connect_finish) (EReminderWatcher *watcher, GAsyncResult *result, GError **error); /* Padding for future expansion */ gpointer reserved[7]; }; GType e_reminder_watcher_get_type (void) G_GNUC_CONST; EReminderWatcher * e_reminder_watcher_new (ESourceRegistry *registry); ESourceRegistry * e_reminder_watcher_get_registry (EReminderWatcher *watcher); ECalClient * e_reminder_watcher_ref_opened_client (EReminderWatcher *watcher, const gchar *source_uid); void e_reminder_watcher_set_default_zone (EReminderWatcher *watcher, const ICalTimezone *zone); ICalTimezone * e_reminder_watcher_dup_default_zone (EReminderWatcher *watcher); gboolean e_reminder_watcher_get_timers_enabled (EPONENT_PERIOD_H */ /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ /* * Copyright (C) 2018 Red Hat, Inc. (www.redhat.com) * * This library is free software: you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation. * * This library is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License * for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this library. If not, see . */ #if !defined (__LIBECAL_H_INSIDE__) && !defined (LIBECAL_COMPILATION) #error "Only should be included directly." #endif #ifndef E_REMINDER_WATCHER_H #define E_REMINDER_WATCHER_H #include #include */ GObject parent; ECalComponentPrivate *priv; }; struct _ECalComponentClass { /*< private >*/ GObjectClass parent_class; }; GType e_cal_component_get_type (void); ECalComponent * e_cal_component_new (void); ECalComponent * e_cal_component_new_vtype (ECalComponentVType vtype); ECalComponent * e_cal_component_new_from_string (const gchar *calobj); ECalComponent * e_cal_component_new_from_icalcomponent (ICalComponent *icalcomp); ECalComponent * e_cal_component_clone (ECalComponent *comp); void e_cal_component_set_new_vtype (ECalComponent *comp, ECalComponentVType type); ECalComponentVType e_cane E_CAL_COMPONENT_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* Standard GObject macros */ #define E_TYPE_CAL_COMPONENT \ (e_cal_component_get_type ()) #define E_CAL_COMPONENT(obj) \ (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), E_TYPE_CAL_COMPONENT, ECalComponent)) #define E_CAL_COMPONENT_CLASS(cls) \ (G_TYPE_CHECK_CLASS_CAST \ ((cls), E_TYPE_CAL_COMPONENT, ECalComponentClass)) #define E_IS_CAL_COc: * @parameter: an #ICalParameter * @user_data: user data for the callback * * A function used to filter which parameters should be added to the bag, * when filling it with e_cal_component_parameter_bag_new_from_property() * and e_cal_component_parameter_bag_set_from_property(). * * Returns: %TRUE, to add the parameter to the bag; %FALSE, to not add it to the bag * * Since: 3.34 **/ typedef gboolean (* ECalComponentParameterBagFilterFunc) (ICalParameter *parameter, gpointer user_data); GType e_cal_component_parameter_bag_get_type (void); ECalComponentParameterBag * e_cal_component_parameter_bag_new (void); ECalComponentParameterBag * e_cal_component_parameter_bag_new_from_property (const ICalProperty *property, ECalComponentParameterBagFilterFunc func, gpointer user_data); ECalComponentParameterBag * e_cal_component_parameter_bag_copy (const ECalComponentParameterBag *bag); void e_cal_component_parameter_bag_free (gpointer bag); /* .h> /* Standard GObject macros */ #define E_TYPE_TIMEZONE_CACHE \ (e_timezone_cache_get_type ()) #define E_TIMEZONE_CACHE(obj) \ (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), E_TYPE_TIMEZONE_CACHE, ETimezoneCache)) #define E_IS_TIMEZONE_CACHE(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), E_TYPE_TIMEZONE_CACHE)) #define E_TIMEZONE_CACHE_GET_INTERFACE(obj) \ (G_TYPE_INSTANCE_GET_INTERFACE \ ((obj), E_TYPE_TIMEZONE_CACHE, ETimezoneCacheInterface)) G_BEGIN_DECLS /** * ETimezoneCache: * * Since: 3.8 **/ typedef struct _ETimezoneCache ETimezoneCache; typedef struct _ETimezoneCacheInterface ETimezoneCacheInterface; /** * ETimezoneCacheInterface: * @impl_add_timezone: a method to add timezone to the cache * @impl_get_timezone: a method to get timezone from the cache, identified by its timezone id * @impl_list_timezones: a method to get list of all stored timezones * @impl_timezone_added: a signal emitted when a timezone is added to the cache * * Since: 3.8 **/ struct _ETimezoneCacheInterface { /*< priv time_t end, ECalComponentAlarmAction *omit, GSList **comp_alarms, ECalRecurResolveTimezoneCb resolve_tzid, gpointer user_data, ICalTimezone *default_timezone); ECalComponentAlarms * e_cal_util_generate_alarms_for_uid_sync (struct _ECalClient *client, const gchar *uid, time_t start, time_t end, ECalComponentAlarmAction *omit, ECalRecurResolveTimezoneCb resolve_tzid, gpointer user_data, ICalTimezone *default_timezone, gint def_reminder_before_start_seconds, GCancellable *cancellable, GError **error); const gchar * e_cal_util_priority_to_string (gint priority); gint e_cal_util_priority_from_string (const gchar *string); gchar * e_cal_util_seconds_to_string (gint64 seconds); void e_cal_util_add_timezones_from_component (ICalComponent *vcal_comp, ICalComponent *icalcomp); gboolean e_cal_util_property_has_parameter (ICalProperty *prop, ICalParameterKind param_kind); gboo*error); time_t e_cal_recur_obtain_enddate (ICalRecurrence *ir, ICalProperty *prop, ICalTimezone *zone, gboolean convert_end_date); gboolean e_cal_recur_ensure_end_dates (ECalComponent *comp, gboolean refresh, ECalRecurResolveTimezoneCb tz_cb, gpointer tz_cb_data, GCancellable *cancellable, GError **error); const gchar * e_cal_recur_get_localized_nth (gint nth); /** * ECalRecurFormatDateTimeFunc: * @itt: an #ICalTime to format to string * @buffer: a buffer to fill with the result * @buffer_size: the @buffer size, in bytes, not counting the NUL-terminator character * * Format the date/time value from @itt into @buffer, whose size cannot * exceed @buffer_size letters. * * Since: 3.38 **/ typedef void (* ECalRecurFormatDateTimeFunc) (ICalTime *itt, gchar *buffer, gint buffer_size); gchar * e_cal_recur_describe_recurrence_ex (ICalComponent *icalcomp, GDateWeekday week_start_day, guint32 flags, ponentAlarm *alarm, ECalComponentAlarmTrigger *trigger); gboolean e_cal_component_alarm_has_attendees (const ECalComponentAlarm *alarm); GSList * e_cal_component_alarm_get_attendees /* ECalComponentAttendee * */ (const ECalComponentAlarm *alarm); void e_cal_component_alarm_set_attendees (ECalComponentAlarm *alarm, const GSList *attendees); /* ECalComponentAttendee * */ void e_cal_component_alarm_take_attendees (ECalComponentAlarm *alarm, GSList *attendees); /* ECalComponentAttendee * */ gboolean e_cal_component_alarm_has_attachments (const ECalComponentAlarm *alarm); GSList * e_cal_component_alarm_get_attachments /* ICalAttach * */ (const ECalComponentAlarm *alarm); void e_cal_component_alarm_set_attachments (ECalComponentAlarm *alarm, const GSList *attachments); /* ICalAttach * */ void e_cal_component_alarm_take_attachments (ECalComponentAlarm *alarm, GSList *attachments); /* ICalAttach * */ ECalComponentPropertyBag * e__CAL_COMPONENT_ORGANIZER_H #define E_CAL_COMPONENT_ORGANIZER_H #include #include #include G_BEGIN_DECLS /** * ECalComponentOrganizer: * * Describes an organizer. Use the functions below to work with it. **/ typedef struct _ECalComponentOrganizer ECalComponentOrganizer; GType e_cal_component_organizer_get_type (void); ECalComponentOrganizer * e_cal_component_organizer_new (void); ECalComponentOrganizer * e_cal_component_organizer_new_full (const gchar *value, const gchar *sentby, const gchar *cn, const gchar *language); ECalComponentOrganizer * e_cal_component_organizer_new_from_property (const ICalProperty *property); ECalComponentOrganizer * e_cal_component_organizer_copy (const ECalComponentOrganizer *organizer); void e_cal_component_organizer_free (gpointer organizer); /* ECalComponentOrganizer * */ void e_cal_component_organizer_set_from_property (ECalComrms, const ECalComponentAlarmInstance *instance); G_END_DECLS #endif /* E_CAL_COMPONENT_ALARMS_H */ /* * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com) * * This library is free software: you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation. * * This library is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License * for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this library. If not, see . * * Authors: Federico Mena-Quintero * JP Rosevear */