This introduces some minor API breakage. Nothing major.
camel-string-utils.h \
camel-text-index.h \
camel-trie.h \
- camel-types.h \
camel-url-scanner.h \
camel-url.h \
camel-utf8.h \
* Returns: the cloned address
**/
CamelAddress *
-camel_address_new_clone (const CamelAddress *addr)
+camel_address_new_clone (CamelAddress *addr)
{
CamelAddress *new = CAMEL_ADDRESS(camel_object_new(CAMEL_OBJECT_GET_TYPE(addr)));
* Returns: the number of addresses concatenated
**/
gint
-camel_address_cat (CamelAddress *dest, const CamelAddress *source)
+camel_address_cat (CamelAddress *dest, CamelAddress *source)
{
g_return_val_if_fail(CAMEL_IS_ADDRESS(dest), -1);
g_return_val_if_fail(CAMEL_IS_ADDRESS(source), -1);
* Returns: the number of addresses copied
**/
gint
-camel_address_copy (CamelAddress *dest, const CamelAddress *source)
+camel_address_copy (CamelAddress *dest, CamelAddress *source)
{
g_return_val_if_fail(CAMEL_IS_ADDRESS(dest), -1);
g_return_val_if_fail(CAMEL_IS_ADDRESS(source), -1);
#ifndef CAMEL_ADDRESS_H
#define CAMEL_ADDRESS_H
-#include <glib.h>
#include <camel/camel-object.h>
#define CAMEL_ADDRESS(obj) CAMEL_CHECK_CAST (obj, camel_address_get_type (), CamelAddress)
G_BEGIN_DECLS
+typedef struct _CamelAddress CamelAddress;
typedef struct _CamelAddressClass CamelAddressClass;
+typedef struct _CamelAddressPrivate CamelAddressPrivate;
struct _CamelAddress {
CamelObject parent;
GPtrArray *addresses;
- struct _CamelAddressPrivate *priv;
+ CamelAddressPrivate *priv;
};
struct _CamelAddressClass {
CamelObjectClass parent_class;
- gint (*decode) (CamelAddress *, const gchar *raw);
- gchar *(*encode) (CamelAddress *);
-
- gint (*unformat) (CamelAddress *, const gchar *raw);
- gchar *(*format) (CamelAddress *);
-
- gint (*cat) (CamelAddress *, const CamelAddress *);
-
- void (*remove) (CamelAddress *, gint index);
+ gint (*decode) (CamelAddress *addr,
+ const gchar *raw);
+ gchar * (*encode) (CamelAddress *addr);
+ gint (*unformat) (CamelAddress *addr,
+ const gchar *raw);
+ gchar * (*format) (CamelAddress *addr);
+ gint (*cat) (CamelAddress *dest,
+ CamelAddress *source);
+ void (*remove) (CamelAddress *addr,
+ gint index);
};
-CamelType camel_address_get_type (void);
-CamelAddress *camel_address_new (void);
-CamelAddress *camel_address_new_clone (const CamelAddress *addr);
-gint camel_address_length (CamelAddress *addr);
-
-gint camel_address_decode (CamelAddress *addr, const gchar *raw);
-gchar *camel_address_encode (CamelAddress *addr);
-gint camel_address_unformat (CamelAddress *addr, const gchar *raw);
-gchar *camel_address_format (CamelAddress *addr);
-
-gint camel_address_cat (CamelAddress *dest, const CamelAddress *source);
-gint camel_address_copy (CamelAddress *dest, const CamelAddress *source);
-
-void camel_address_remove (CamelAddress *addr, gint index);
+CamelType camel_address_get_type (void);
+CamelAddress * camel_address_new (void);
+CamelAddress * camel_address_new_clone (CamelAddress *addr);
+gint camel_address_length (CamelAddress *addr);
+gint camel_address_decode (CamelAddress *addr,
+ const gchar *raw);
+gchar * camel_address_encode (CamelAddress *addr);
+gint camel_address_unformat (CamelAddress *addr,
+ const gchar *raw);
+gchar * camel_address_format (CamelAddress *addr);
+gint camel_address_cat (CamelAddress *dest,
+ CamelAddress *source);
+gint camel_address_copy (CamelAddress *dest,
+ CamelAddress *source);
+void camel_address_remove (CamelAddress *addr,
+ gint index);
G_END_DECLS
#include <camel/camel-object.h>
#include <camel/camel-list-utils.h>
-#include <glib.h>
#include <stdio.h>
#include <sys/types.h>
typedef struct _CamelBlock CamelBlock;
typedef struct _CamelBlockFile CamelBlockFile;
typedef struct _CamelBlockFileClass CamelBlockFileClass;
+typedef struct _CamelBlockFilePrivate CamelBlockFilePrivate;
#define CAMEL_BLOCK_FILE_SYNC (1<<0)
struct _CamelBlockFile {
CamelObject parent;
-
- struct _CamelBlockFilePrivate *priv;
+ CamelBlockFilePrivate *priv;
gchar version[8];
gchar *path;
gint (*init_root)(CamelBlockFile *);
};
-CamelType camel_block_file_get_type(void);
-
-CamelBlockFile *camel_block_file_new(const gchar *path, gint flags, const gchar version[8], gsize block_size);
-gint camel_block_file_rename(CamelBlockFile *bs, const gchar *path);
-gint camel_block_file_delete(CamelBlockFile *kf);
-
-CamelBlock *camel_block_file_new_block(CamelBlockFile *bs);
-gint camel_block_file_free_block(CamelBlockFile *bs, camel_block_t id);
-CamelBlock *camel_block_file_get_block(CamelBlockFile *bs, camel_block_t id);
-void camel_block_file_detach_block(CamelBlockFile *bs, CamelBlock *bl);
-void camel_block_file_attach_block(CamelBlockFile *bs, CamelBlock *bl);
-void camel_block_file_touch_block(CamelBlockFile *bs, CamelBlock *bl);
-void camel_block_file_unref_block(CamelBlockFile *bs, CamelBlock *bl);
-gint camel_block_file_sync_block(CamelBlockFile *bs, CamelBlock *bl);
-gint camel_block_file_sync(CamelBlockFile *bs);
+CamelType camel_block_file_get_type (void);
+CamelBlockFile *camel_block_file_new (const gchar *path,
+ gint flags,
+ const gchar version[8],
+ gsize block_size);
+gint camel_block_file_rename (CamelBlockFile *bs,
+ const gchar *path);
+gint camel_block_file_delete (CamelBlockFile *kf);
+CamelBlock * camel_block_file_new_block (CamelBlockFile *bs);
+gint camel_block_file_free_block (CamelBlockFile *bs,
+ camel_block_t id);
+CamelBlock *camel_block_file_get_block (CamelBlockFile *bs,
+ camel_block_t id);
+void camel_block_file_detach_block (CamelBlockFile *bs,
+ CamelBlock *bl);
+void camel_block_file_attach_block (CamelBlockFile *bs,
+ CamelBlock *bl);
+void camel_block_file_touch_block (CamelBlockFile *bs,
+ CamelBlock *bl);
+void camel_block_file_unref_block (CamelBlockFile *bs,
+ CamelBlock *bl);
+gint camel_block_file_sync_block (CamelBlockFile *bs,
+ CamelBlock *bl);
+gint camel_block_file_sync (CamelBlockFile *bs);
/* ********************************************************************** */
typedef struct _CamelKeyFile CamelKeyFile;
typedef struct _CamelKeyFileClass CamelKeyFileClass;
+typedef struct _CamelKeyFilePrivate CamelKeyFilePrivate;
struct _CamelKeyFile {
CamelObject parent;
-
- struct _CamelKeyFilePrivate *priv;
+ CamelKeyFilePrivate *priv;
FILE *fp;
gchar *path;
typedef struct _CamelCertDB CamelCertDB;
typedef struct _CamelCertDBClass CamelCertDBClass;
+typedef struct _CamelCertDBPrivate CamelCertDBPrivate;
enum {
CAMEL_CERTDB_DIRTY = (1 << 0)
} CamelCert;
struct _CamelCertDB {
- CamelObject parent_object;
- struct _CamelCertDBPrivate *priv;
+ CamelObject parent;
+ CamelCertDBPrivate *priv;
gchar *filename;
guint32 version;
CamelTransferEncoding encoding;
gint parts, i;
- dw = camel_medium_get_content_object((CamelMedium *)part);
+ dw = camel_medium_get_content ((CamelMedium *)part);
if (!dw)
return;
gint
camel_cipher_canonical_to_stream(CamelMimePart *part, guint32 flags, CamelStream *ostream)
{
- CamelStreamFilter *filter;
+ CamelStream *filter;
CamelMimeFilter *canon;
gint res = -1;
if (flags & (CAMEL_MIME_FILTER_CANON_FROM|CAMEL_MIME_FILTER_CANON_STRIP))
cc_prepare_sign(part);
- filter = camel_stream_filter_new_with_stream(ostream);
+ filter = camel_stream_filter_new (ostream);
canon = camel_mime_filter_canon_new(flags);
- camel_stream_filter_add(filter, canon);
+ camel_stream_filter_add (CAMEL_STREAM_FILTER (filter), canon);
camel_object_unref(canon);
if (camel_data_wrapper_write_to_stream((CamelDataWrapper *)part, (CamelStream *)filter) != -1
#define CAMEL_CIPHER_CONTEXT_H
#include <camel/camel-list-utils.h>
+#include <camel/camel-mime-part.h>
#include <camel/camel-session.h>
#include <camel/camel-exception.h>
+#include <camel/camel-stream.h>
#define CAMEL_CIPHER_CONTEXT_TYPE (camel_cipher_context_get_type ())
#define CAMEL_CIPHER_CONTEXT(obj) (CAMEL_CHECK_CAST((obj), CAMEL_CIPHER_CONTEXT_TYPE, CamelCipherContext))
G_BEGIN_DECLS
-struct _CamelStream;
-struct _CamelMimePart;
-
typedef struct _CamelCipherValidity CamelCipherValidity;
typedef struct _CamelCipherCertInfo CamelCipherCertInfo;
+typedef struct _CamelCipherContext CamelCipherContext;
+typedef struct _CamelCipherContextClass CamelCipherContextClass;
+typedef struct _CamelCipherContextPrivate CamelCipherContextPrivate;
+
typedef enum {
CAMEL_CIPHER_HASH_DEFAULT,
CAMEL_CIPHER_HASH_MD2,
} encrypt;
};
-typedef struct _CamelCipherContext {
- CamelObject parent_object;
-
- struct _CamelCipherContextPrivate *priv;
+struct _CamelCipherContext {
+ CamelObject parent;
+ CamelCipherContextPrivate *priv;
CamelSession *session;
const gchar *sign_protocol;
const gchar *encrypt_protocol;
const gchar *key_protocol;
-} CamelCipherContext;
+};
-typedef struct _CamelCipherContextClass {
+struct _CamelCipherContextClass {
CamelObjectClass parent_class;
- CamelCipherHash (*id_to_hash)(CamelCipherContext *context, const gchar *id);
- const gchar * (*hash_to_id)(CamelCipherContext *context, CamelCipherHash hash);
-
- gint (*sign) (CamelCipherContext *context, const gchar *userid, CamelCipherHash hash,
- struct _CamelMimePart *ipart, struct _CamelMimePart *opart, CamelException *ex);
-
- CamelCipherValidity * (*verify) (CamelCipherContext *context, struct _CamelMimePart *ipart, CamelException *ex);
-
- gint (*encrypt) (CamelCipherContext *context, const gchar *userid,
- GPtrArray *recipients, struct _CamelMimePart *ipart, struct _CamelMimePart *opart,
- CamelException *ex);
-
- CamelCipherValidity *(*decrypt) (CamelCipherContext *context, struct _CamelMimePart *ipart, struct _CamelMimePart *opart,
- CamelException *ex);
-
- gint (*import_keys) (CamelCipherContext *context, struct _CamelStream *istream,
- CamelException *ex);
-
- gint (*export_keys) (CamelCipherContext *context, GPtrArray *keys,
- struct _CamelStream *ostream, CamelException *ex);
-} CamelCipherContextClass;
+ CamelCipherHash (*id_to_hash) (CamelCipherContext *context,
+ const gchar *id);
+ const gchar * (*hash_to_id) (CamelCipherContext *context,
+ CamelCipherHash hash);
+ gint (*sign) (CamelCipherContext *context,
+ const gchar *userid,
+ CamelCipherHash hash,
+ CamelMimePart *ipart,
+ CamelMimePart *opart,
+ CamelException *ex);
+ CamelCipherValidity *
+ (*verify) (CamelCipherContext *context,
+ CamelMimePart *ipart,
+ CamelException *ex);
+ gint (*encrypt) (CamelCipherContext *context,
+ const gchar *userid,
+ GPtrArray *recipients,
+ CamelMimePart *ipart,
+ CamelMimePart *opart,
+ CamelException *ex);
+ CamelCipherValidity *
+ (*decrypt) (CamelCipherContext *context,
+ CamelMimePart *ipart,
+ CamelMimePart *opart,
+ CamelException *ex);
+ gint (*import_keys) (CamelCipherContext *context,
+ CamelStream *istream,
+ CamelException *ex);
+ gint (*export_keys) (CamelCipherContext *context,
+ GPtrArray *keys,
+ CamelStream *ostream,
+ CamelException *ex);
+};
CamelType camel_cipher_context_get_type (void);
/* cipher routines */
gint camel_cipher_sign (CamelCipherContext *context, const gchar *userid, CamelCipherHash hash,
- struct _CamelMimePart *ipart, struct _CamelMimePart *opart, CamelException *ex);
-CamelCipherValidity *camel_cipher_verify (CamelCipherContext *context, struct _CamelMimePart *ipart, CamelException *ex);
+ CamelMimePart *ipart, CamelMimePart *opart, CamelException *ex);
+CamelCipherValidity *camel_cipher_verify (CamelCipherContext *context, CamelMimePart *ipart, CamelException *ex);
gint camel_cipher_encrypt (CamelCipherContext *context, const gchar *userid,
- GPtrArray *recipients, struct _CamelMimePart *ipart, struct _CamelMimePart *opart,
+ GPtrArray *recipients, CamelMimePart *ipart, CamelMimePart *opart,
CamelException *ex);
-CamelCipherValidity *camel_cipher_decrypt (CamelCipherContext *context, struct _CamelMimePart *ipart, struct _CamelMimePart *opart,
+CamelCipherValidity *camel_cipher_decrypt (CamelCipherContext *context, CamelMimePart *ipart, CamelMimePart *opart,
CamelException *ex);
/* key/certificate routines */
-gint camel_cipher_import_keys (CamelCipherContext *context, struct _CamelStream *istream,
+gint camel_cipher_import_keys (CamelCipherContext *context, CamelStream *istream,
CamelException *ex);
gint camel_cipher_export_keys (CamelCipherContext *context, GPtrArray *keys,
- struct _CamelStream *ostream, CamelException *ex);
+ CamelStream *ostream, CamelException *ex);
/* CamelCipherValidity utility functions */
CamelCipherValidity *camel_cipher_validity_new (void);
/**
* camel_data_cache_new:
* @path: Base path of cache, subdirectories will be created here.
- * @flags: Open flags, none defined.
* @ex:
*
* Create a new data cache.
* be written to.
**/
CamelDataCache *
-camel_data_cache_new(const gchar *path, guint32 flags, CamelException *ex)
+camel_data_cache_new(const gchar *path, CamelException *ex)
{
CamelDataCache *cdc;
cdc = (CamelDataCache *)camel_object_new(CAMEL_DATA_CACHE_TYPE);
cdc->path = g_strdup(path);
- cdc->flags = flags;
cdc->expire_age = -1;
cdc->expire_access = -1;
return ret;
}
-/**
- * camel_data_cache_rename:
- * @cache:
- * @old:
- * @new:
- * @ex:
- *
- * Rename a cache path. All cache items accessed from the old path
- * are accessible using the new path.
- *
- * CURRENTLY UNIMPLEMENTED
- *
- * Returns: -1 on error.
- **/
-gint camel_data_cache_rename(CamelDataCache *cache,
- const gchar *old, const gchar *new, CamelException *ex)
-{
- /* blah dont care yet */
- return -1;
-}
-
-/**
- * camel_data_cache_clear:
- * @cache:
- * @path: Path to clear, or NULL to clear all items in all paths.
- * @ex:
- *
- * Clear all items in a given cache path or all items in the cache.
- *
- * CURRENTLY_UNIMPLEMENTED
- *
- * Returns: -1 on error.
- **/
-gint
-camel_data_cache_clear(CamelDataCache *cache, const gchar *path, CamelException *ex)
-{
- /* nor for this? */
- return -1;
-}
#ifndef CAMEL_DATA_CACHE_H
#define CAMEL_DATA_CACHE_H
-#include <glib.h>
-
#include <camel/camel-stream.h>
#include <camel/camel-exception.h>
typedef struct _CamelDataCache CamelDataCache;
typedef struct _CamelDataCacheClass CamelDataCacheClass;
+typedef struct _CamelDataCachePrivate CamelDataCachePrivate;
struct _CamelDataCache {
- CamelObject parent_object;
-
- struct _CamelDataCachePrivate *priv;
+ CamelObject parent;
+ CamelDataCachePrivate *priv;
gchar *path;
- guint32 flags;
time_t expire_age;
time_t expire_access;
struct _CamelDataCacheClass {
CamelObjectClass parent_class;
-
- /* None are virtual yet */
-#if 0
- /* Virtual methods */
- CamelStream *(*add)(CamelDataCache *cmc, const gchar *path, const gchar *key, CamelException *ex);
- CamelStream *(*get)(CamelDataCache *cmc, const gchar *path, const gchar *key, CamelException *ex);
- gint (*close)(CamelDataCache *cmc, CamelStream *stream, CamelException *ex);
- gint (*remove)(CamelDataCache *cmc, const gchar *path, const gchar *key, CamelException *ex);
-
- gint (*clear)(CamelDataCache *cmc, const gchar *path, CamelException *ex);
-#endif
};
-/* public methods */
-CamelDataCache *camel_data_cache_new(const gchar *path, guint32 flags, CamelException *ex);
-
-void camel_data_cache_set_expire_age(CamelDataCache *cdc, time_t when);
-void camel_data_cache_set_expire_access(CamelDataCache *cdc, time_t when);
-
-gint camel_data_cache_rename(CamelDataCache *cache,
- const gchar *old, const gchar *new, CamelException *ex);
-
-CamelStream *camel_data_cache_add(CamelDataCache *cdc,
- const gchar *path, const gchar *key, CamelException *ex);
-CamelStream *camel_data_cache_get(CamelDataCache *cdc,
- const gchar *path, const gchar *key, CamelException *ex);
-gint camel_data_cache_remove(CamelDataCache *cdc,
- const gchar *path, const gchar *key, CamelException *ex);
-
-gint camel_data_cache_clear(CamelDataCache *cache,
- const gchar *path, CamelException *ex);
-
-gchar * camel_data_cache_get_filename(CamelDataCache *cdc,
- const gchar *path, const gchar *key, CamelException *ex);
-
-/* Standard Camel function */
-CamelType camel_data_cache_get_type (void);
+CamelType camel_data_cache_get_type (void);
+CamelDataCache *camel_data_cache_new (const gchar *path,
+ CamelException *ex);
+void camel_data_cache_set_expire_age (CamelDataCache *cdc,
+ time_t when);
+void camel_data_cache_set_expire_access
+ (CamelDataCache *cdc,
+ time_t when);
+CamelStream * camel_data_cache_add (CamelDataCache *cdc,
+ const gchar *path,
+ const gchar *key,
+ CamelException *ex);
+CamelStream * camel_data_cache_get (CamelDataCache *cdc,
+ const gchar *path,
+ const gchar *key,
+ CamelException *ex);
+gint camel_data_cache_remove (CamelDataCache *cdc,
+ const gchar *path,
+ const gchar *key,
+ CamelException *ex);
+gchar * camel_data_cache_get_filename (CamelDataCache *cdc,
+ const gchar *path,
+ const gchar *key,
+ CamelException *ex);
G_END_DECLS
CamelStream *fstream;
gssize ret;
- fstream = (CamelStream *) camel_stream_filter_new_with_stream (stream);
+ fstream = (CamelStream *) camel_stream_filter_new (stream);
switch (data_wrapper->encoding) {
case CAMEL_TRANSFER_ENCODING_BASE64:
- filter = (CamelMimeFilter *) camel_mime_filter_basic_new_type (CAMEL_MIME_FILTER_BASIC_BASE64_DEC);
+ filter = (CamelMimeFilter *) camel_mime_filter_basic_new (CAMEL_MIME_FILTER_BASIC_BASE64_DEC);
camel_stream_filter_add (CAMEL_STREAM_FILTER (fstream), filter);
camel_object_unref (filter);
break;
case CAMEL_TRANSFER_ENCODING_QUOTEDPRINTABLE:
- filter = (CamelMimeFilter *) camel_mime_filter_basic_new_type (CAMEL_MIME_FILTER_BASIC_QP_DEC);
+ filter = (CamelMimeFilter *) camel_mime_filter_basic_new (CAMEL_MIME_FILTER_BASIC_QP_DEC);
camel_stream_filter_add (CAMEL_STREAM_FILTER (fstream), filter);
camel_object_unref (filter);
break;
case CAMEL_TRANSFER_ENCODING_UUENCODE:
- filter = (CamelMimeFilter *) camel_mime_filter_basic_new_type (CAMEL_MIME_FILTER_BASIC_UU_DEC);
+ filter = (CamelMimeFilter *) camel_mime_filter_basic_new (CAMEL_MIME_FILTER_BASIC_UU_DEC);
camel_stream_filter_add (CAMEL_STREAM_FILTER (fstream), filter);
camel_object_unref (filter);
break;
#ifndef CAMEL_DATA_WRAPPER_H
#define CAMEL_DATA_WRAPPER_H
-#include <glib.h>
#include <sys/types.h>
-#include <camel/camel-object.h>
+
#include <camel/camel-mime-utils.h>
+#include <camel/camel-stream.h>
#define CAMEL_DATA_WRAPPER_TYPE (camel_data_wrapper_get_type ())
#define CAMEL_DATA_WRAPPER(obj) (CAMEL_CHECK_CAST((obj), CAMEL_DATA_WRAPPER_TYPE, CamelDataWrapper))
G_BEGIN_DECLS
+typedef struct _CamelDataWrapper CamelDataWrapper;
+typedef struct _CamelDataWrapperClass CamelDataWrapperClass;
+typedef struct _CamelDataWrapperPrivate CamelDataWrapperPrivate;
+
struct _CamelDataWrapper {
- CamelObject parent_object;
- struct _CamelDataWrapperPrivate *priv;
+ CamelObject parent;
+ CamelDataWrapperPrivate *priv;
CamelTransferEncoding encoding;
guint offline:1;
};
-typedef struct {
+struct _CamelDataWrapperClass {
CamelObjectClass parent_class;
- /* Virtual methods */
- void (*set_mime_type) (CamelDataWrapper *data_wrapper,
- const gchar *mime_type);
- gchar * (*get_mime_type) (CamelDataWrapper *data_wrapper);
- CamelContentType * (*get_mime_type_field) (CamelDataWrapper *data_wrapper);
- void (*set_mime_type_field) (CamelDataWrapper *data_wrapper,
- CamelContentType *mime_type_field);
-
- gssize (*write_to_stream) (CamelDataWrapper *data_wrapper,
- CamelStream *stream);
-
- gssize (*decode_to_stream) (CamelDataWrapper *data_wrapper,
- CamelStream *stream);
-
- gint (*construct_from_stream) (CamelDataWrapper *data_wrapper,
- CamelStream *);
-
- gboolean (*is_offline) (CamelDataWrapper *data_wrapper);
-} CamelDataWrapperClass;
-
-/* Standard Camel function */
-CamelType camel_data_wrapper_get_type (void);
-
-/* public methods */
-CamelDataWrapper *camel_data_wrapper_new(void);
-gssize camel_data_wrapper_write_to_stream (CamelDataWrapper *data_wrapper,
- CamelStream *stream);
-gssize camel_data_wrapper_decode_to_stream (CamelDataWrapper *data_wrapper,
- CamelStream *stream);
-
-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 *camel_data_wrapper_get_mime_type_field (CamelDataWrapper *data_wrapper);
-void camel_data_wrapper_set_mime_type_field (CamelDataWrapper *data_wrapper,
- CamelContentType *mime_type);
-
-gint camel_data_wrapper_construct_from_stream (CamelDataWrapper *data_wrapper,
- CamelStream *stream);
+ void (*set_mime_type) (CamelDataWrapper *data_wrapper,
+ const gchar *mime_type);
+ gchar * (*get_mime_type) (CamelDataWrapper *data_wrapper);
+ CamelContentType *
+ (*get_mime_type_field) (CamelDataWrapper *data_wrapper);
+ void (*set_mime_type_field) (CamelDataWrapper *data_wrapper,
+ CamelContentType *mime_type_field);
+ gssize (*write_to_stream) (CamelDataWrapper *data_wrapper,
+ CamelStream *stream);
+ gssize (*decode_to_stream) (CamelDataWrapper *data_wrapper,
+ CamelStream *stream);
+ gint (*construct_from_stream)(CamelDataWrapper *data_wrapper,
+ CamelStream *);
+ gboolean (*is_offline) (CamelDataWrapper *data_wrapper);
+};
-gboolean camel_data_wrapper_is_offline (CamelDataWrapper *data_wrapper);
+CamelType camel_data_wrapper_get_type (void);
+CamelDataWrapper *
+ camel_data_wrapper_new (void);
+gssize camel_data_wrapper_write_to_stream
+ (CamelDataWrapper *data_wrapper,
+ CamelStream *stream);
+gssize camel_data_wrapper_decode_to_stream
+ (CamelDataWrapper *data_wrapper,
+ CamelStream *stream);
+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 *
+ camel_data_wrapper_get_mime_type_field
+ (CamelDataWrapper *data_wrapper);
+void camel_data_wrapper_set_mime_type_field
+ (CamelDataWrapper *data_wrapper,
+ CamelContentType *mime_type);
+gint camel_data_wrapper_construct_from_stream
+ (CamelDataWrapper *data_wrapper,
+ CamelStream *stream);
+gboolean camel_data_wrapper_is_offline (CamelDataWrapper *data_wrapper);
G_END_DECLS
#ifndef CAMEL_DB_H
#define CAMEL_DB_H
+
#include <sqlite3.h>
#include <glib.h>
#ifndef CAMEL_DISCO_DIARY_H
#define CAMEL_DISCO_DIARY_H
-#include "camel-object.h"
#include <stdarg.h>
#include <stdio.h>
+#include <camel/camel-disco-store.h>
+
#define CAMEL_DISCO_DIARY_TYPE (camel_disco_diary_get_type ())
#define CAMEL_DISCO_DIARY(obj) (CAMEL_CHECK_CAST((obj), CAMEL_DISCO_DIARY_TYPE, CamelDiscoDiary))
#define CAMEL_DISCO_DIARY_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_DISCO_DIARY_TYPE, CamelDiscoDiaryClass))
G_BEGIN_DECLS
+typedef struct _CamelDiscoDiary CamelDiscoDiary;
+typedef struct _CamelDiscoDiaryClass CamelDiscoDiaryClass;
+
typedef enum {
CAMEL_DISCO_DIARY_END = 0,
} CamelDiscoDiaryArgType;
struct _CamelDiscoDiary {
- CamelObject parent_object;
+ CamelObject parent;
CamelDiscoStore *store;
FILE *file;
GHashTable *folders, *uidmap;
};
-typedef struct {
+struct _CamelDiscoDiaryClass {
CamelObjectClass parent_class;
+};
-} CamelDiscoDiaryClass;
-
-/* public methods */
-CamelDiscoDiary *camel_disco_diary_new (CamelDiscoStore *store,
- const gchar *filename,
- CamelException *ex);
-
-gboolean camel_disco_diary_empty (CamelDiscoDiary *diary);
-
-void camel_disco_diary_log (CamelDiscoDiary *diary,
- CamelDiscoDiaryAction action,
- ...);
-void camel_disco_diary_replay (CamelDiscoDiary *diary,
- CamelException *ex);
+CamelType camel_disco_diary_get_type (void);
+CamelDiscoDiary *
+ camel_disco_diary_new (CamelDiscoStore *store,
+ const gchar *filename,
+ CamelException *ex);
+gboolean camel_disco_diary_empty (CamelDiscoDiary *diary);
+void camel_disco_diary_log (CamelDiscoDiary *diary,
+ CamelDiscoDiaryAction action,
+ ...);
+void camel_disco_diary_replay (CamelDiscoDiary *diary,
+ CamelException *ex);
/* Temporary->Permanent UID map stuff */
-void camel_disco_diary_uidmap_add (CamelDiscoDiary *diary,
- const gchar *old_uid,
- const gchar *new_uid);
-const gchar *camel_disco_diary_uidmap_lookup (CamelDiscoDiary *diary,
- const gchar *uid);
-
-/* Standard Camel function */
-CamelType camel_disco_diary_get_type (void);
+void camel_disco_diary_uidmap_add (CamelDiscoDiary *diary,
+ const gchar *old_uid,
+ const gchar *new_uid);
+const gchar * camel_disco_diary_uidmap_lookup (CamelDiscoDiary *diary,
+ const gchar *uid);
G_END_DECLS
#ifndef CAMEL_DISCO_FOLDER_H
#define CAMEL_DISCO_FOLDER_H
-#include "camel-folder.h"
+#include <camel/camel-folder.h>
#define CAMEL_DISCO_FOLDER_TYPE (camel_disco_folder_get_type ())
#define CAMEL_DISCO_FOLDER(obj) (CAMEL_CHECK_CAST((obj), CAMEL_DISCO_FOLDER_TYPE, CamelDiscoFolder))
G_BEGIN_DECLS
+typedef struct _CamelDiscoFolder CamelDiscoFolder;
+typedef struct _CamelDiscoFolderClass CamelDiscoFolderClass;
+
enum {
CAMEL_DISCO_FOLDER_ARG_OFFLINE_SYNC = CAMEL_FOLDER_ARG_LAST,
CAMEL_DISCO_FOLDER_ARG_LAST = CAMEL_FOLDER_ARG_LAST + 0x100
};
struct _CamelDiscoFolder {
- CamelFolder parent_object;
+ CamelFolder parent;
guint offline_sync:1;
};
-typedef struct {
+struct _CamelDiscoFolderClass {
CamelFolderClass parent_class;
- void (*refresh_info_online) (CamelFolder *folder, CamelException *ex);
-
- void (*sync_online) (CamelFolder *folder, CamelException *ex);
- void (*sync_offline) (CamelFolder *folder, CamelException *ex);
- void (*sync_resyncing) (CamelFolder *folder, CamelException *ex);
-
- void (*expunge_uids_online) (CamelFolder *folder, GPtrArray *uids,
- CamelException *ex);
- void (*expunge_uids_offline) (CamelFolder *folder, GPtrArray *uids,
- CamelException *ex);
- void (*expunge_uids_resyncing) (CamelFolder *folder, GPtrArray *uids,
- CamelException *ex);
-
- void (*append_online) (CamelFolder *folder,
- CamelMimeMessage *message,
- const CamelMessageInfo *info,
- gchar **appended_uid,
- CamelException *ex);
- void (*append_offline) (CamelFolder *folder,
- CamelMimeMessage *message,
- const CamelMessageInfo *info,
- gchar **appended_uid,
- CamelException *ex);
- void (*append_resyncing) (CamelFolder *folder,
- CamelMimeMessage *message,
- const CamelMessageInfo *info,
- gchar **appended_uid,
- CamelException *ex);
-
- void (*transfer_online) (CamelFolder *source, GPtrArray *uids,
- CamelFolder *destination,
- GPtrArray **transferred_uids,
- gboolean delete_originals,
- CamelException *ex);
- void (*transfer_offline) (CamelFolder *source, GPtrArray *uids,
- CamelFolder *destination,
- GPtrArray **transferred_uids,
- gboolean delete_originals,
- CamelException *ex);
- void (*transfer_resyncing) (CamelFolder *source, GPtrArray *uids,
- CamelFolder *destination,
- GPtrArray **transferred_uids,
- gboolean delete_originals,
- CamelException *ex);
-
- void (*cache_message) (CamelDiscoFolder *disco_folder,
- const gchar *uid, CamelException *ex);
- void (*prepare_for_offline) (CamelDiscoFolder *disco_folder,
- const gchar *expression,
- CamelException *ex);
-
- void (*update_uid) (CamelFolder *folder, const gchar *old_uid,
- const gchar *new_uid);
-} CamelDiscoFolderClass;
-
-/* public methods */
-void camel_disco_folder_expunge_uids (CamelFolder *folder, GPtrArray *uids,
- CamelException *ex);
-
-void camel_disco_folder_cache_message (CamelDiscoFolder *disco_folder,
- const gchar *uid,
- CamelException *ex);
-void camel_disco_folder_prepare_for_offline (CamelDiscoFolder *disco_folder,
- const gchar *expression,
- CamelException *ex);
-
-/* Standard Camel function */
-CamelType camel_disco_folder_get_type (void);
+ void (*refresh_info_online) (CamelFolder *folder,
+ CamelException *ex);
+ void (*sync_online) (CamelFolder *folder,
+ CamelException *ex);
+ void (*sync_offline) (CamelFolder *folder,
+ CamelException *ex);
+ void (*sync_resyncing) (CamelFolder *folder,
+ CamelException *ex);
+ void (*expunge_uids_online) (CamelFolder *folder,
+ GPtrArray *uids,
+ CamelException *ex);
+ void (*expunge_uids_offline) (CamelFolder *folder,
+ GPtrArray *uids,
+ CamelException *ex);
+ void (*expunge_uids_resyncing)
+ (CamelFolder *folder,
+ GPtrArray *uids,
+ CamelException *ex);
+ void (*append_online) (CamelFolder *folder,
+ CamelMimeMessage *message,
+ const CamelMessageInfo *info,
+ gchar **appended_uid,
+ CamelException *ex);
+ void (*append_offline) (CamelFolder *folder,
+ CamelMimeMessage *message,
+ const CamelMessageInfo *info,
+ gchar **appended_uid,
+ CamelException *ex);
+ void (*append_resyncing) (CamelFolder *folder,
+ CamelMimeMessage *message,
+ const CamelMessageInfo *info,
+ gchar **appended_uid,
+ CamelException *ex);
+ void (*transfer_online) (CamelFolder *source,
+ GPtrArray *uids,
+ CamelFolder *destination,
+ GPtrArray **transferred_uids,
+ gboolean delete_originals,
+ CamelException *ex);
+ void (*transfer_offline) (CamelFolder *source,
+ GPtrArray *uids,
+ CamelFolder *destination,
+ GPtrArray **transferred_uids,
+ gboolean delete_originals,
+ CamelException *ex);
+ void (*transfer_resyncing) (CamelFolder *source,
+ GPtrArray *uids,
+ CamelFolder *destination,
+ GPtrArray **transferred_uids,
+ gboolean delete_originals,
+ CamelException *ex);
+ void (*cache_message) (CamelDiscoFolder *disco_folder,
+ const gchar *uid,
+ CamelException *ex);
+ void (*prepare_for_offline) (CamelDiscoFolder *disco_folder,
+ const gchar *expression,
+ CamelException *ex);
+ void (*update_uid) (CamelFolder *folder,
+ const gchar *old_uid,
+ const gchar *new_uid);
+};
+
+CamelType camel_disco_folder_get_type (void);
+void camel_disco_folder_expunge_uids (CamelFolder *folder,
+ GPtrArray *uids,
+ CamelException *ex);
+void camel_disco_folder_cache_message(CamelDiscoFolder *disco_folder,
+ const gchar *uid,
+ CamelException *ex);
+void camel_disco_folder_prepare_for_offline
+ (CamelDiscoFolder *disco_folder,
+ const gchar *expression,
+ CamelException *ex);
G_END_DECLS
G_BEGIN_DECLS
+struct _CamelDiscoDiary;
+
+typedef struct _CamelDiscoStore CamelDiscoStore;
+typedef struct _CamelDiscoStoreClass CamelDiscoStoreClass;
+
enum {
CAMEL_DISCO_STORE_ARG_FIRST = CAMEL_STORE_ARG_FIRST + 100
};
} CamelDiscoStoreStatus;
struct _CamelDiscoStore {
- CamelStore parent_object;
+ CamelStore parent;
CamelDiscoStoreStatus status;
- CamelDiscoDiary *diary;
+ struct _CamelDiscoDiary *diary;
};
-typedef struct {
+struct _CamelDiscoStoreClass {
CamelStoreClass parent_class;
void (*set_status) (CamelDiscoStore *,
const gchar *top,
guint32 flags,
CamelException *ex);
-
-} CamelDiscoStoreClass;
+};
/* Standard Camel function */
CamelType camel_disco_store_get_type (void);
#ifndef CAMEL_EXCEPTION_H
#define CAMEL_EXCEPTION_H
-#include <camel/camel-types.h>
+#include <glib.h>
G_BEGIN_DECLS
+typedef struct _CamelException CamelException;
+
typedef enum {
#include "camel-exception-list.def"
#include "camel-mime-message.h"
#include "camel-private.h"
#include "camel-service.h"
+#include "camel-session.h"
#include "camel-stream-fs.h"
#include "camel-stream-mem.h"
static ESExpResult *do_move (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *);
static ESExpResult *do_stop (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *);
static ESExpResult *do_label (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *);
-static ESExpResult *do_colour (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *);
+static ESExpResult *do_color (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *);
static ESExpResult *do_score (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *);
static ESExpResult *do_adjust_score(struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *);
static ESExpResult *set_flag (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *);
{ "move-to", (ESExpFunc *) do_move, 0 },
{ "stop", (ESExpFunc *) do_stop, 0 },
{ "set-label", (ESExpFunc *) do_label, 0 },
- { "set-colour", (ESExpFunc *) do_colour, 0 },
+ { "set-color", (ESExpFunc *) do_color, 0 },
{ "set-score", (ESExpFunc *) do_score, 0 },
{ "adjust-score", (ESExpFunc *) do_adjust_score, 0 },
{ "set-system-flag", (ESExpFunc *) set_flag, 0 },
}
static ESExpResult *
-do_colour (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
+do_color (struct _ESExp *f, gint argc, struct _ESExpResult **argv, CamelFilterDriver *driver)
{
struct _CamelFilterDriverPrivate *p = _PRIVATE (driver);
- d(fprintf (stderr, "setting colour tag\n"));
+ d(fprintf (stderr, "setting color tag\n"));
if (argc > 0 && argv[0]->type == ESEXP_RES_STRING) {
if (p->source && p->uid && camel_folder_has_summary_capability (p->source))
- camel_folder_set_message_user_tag (p->source, p->uid, "colour", argv[0]->value.string);
+ camel_folder_set_message_user_tag (p->source, p->uid, "color", argv[0]->value.string);
else
- camel_message_info_set_user_tag(p->info, "colour", argv[0]->value.string);
- camel_filter_driver_log (driver, FILTER_LOG_ACTION, "Set colour to %s", argv[0]->value.string);
+ camel_message_info_set_user_tag(p->info, "color", argv[0]->value.string);
+ camel_filter_driver_log (driver, FILTER_LOG_ACTION, "Set color to %s", argv[0]->value.string);
}
return NULL;
#ifndef CAMEL_FILTER_DRIVER_H
#define CAMEL_FILTER_DRIVER_H
-#include <glib.h>
-#include <camel/camel-object.h>
-#include <camel/camel-session.h>
#include <camel/camel-folder.h>
#include <camel/camel-uid-cache.h>
G_BEGIN_DECLS
+struct _CamelSession;
+
+typedef struct _CamelFilterDriver CamelFilterDriver;
typedef struct _CamelFilterDriverClass CamelFilterDriverClass;
+typedef struct _CamelFilterDriverPrivate CamelFilterDriverPrivate;
struct _CamelFilterDriver {
CamelObject parent;
-
- struct _CamelFilterDriverPrivate *priv;
+ CamelFilterDriverPrivate *priv;
};
struct _CamelFilterDriverClass {
typedef void (CamelFilterSystemBeepFunc) (CamelFilterDriver *driver, gpointer data);
CamelType camel_filter_driver_get_type (void);
-CamelFilterDriver *camel_filter_driver_new (CamelSession *);
+CamelFilterDriver *camel_filter_driver_new (struct _CamelSession *);
/* modifiers */
void camel_filter_driver_set_logfile (CamelFilterDriver *d, FILE *logfile);
#ifndef CAMEL_FILTER_SEARCH_H
#define CAMEL_FILTER_SEARCH_H
-#include <glib.h>
#include <camel/camel-mime-message.h>
#include <camel/camel-folder-summary.h>
G_BEGIN_DECLS
+struct _CamelSession;
+
enum {
CAMEL_SEARCH_ERROR = -1,
CAMEL_SEARCH_NOMATCH = 0,
typedef CamelMimeMessage * (*CamelFilterSearchGetMessageFunc) (gpointer data, CamelException *ex);
-gint camel_filter_search_match (CamelSession *session,
+gint camel_filter_search_match (struct _CamelSession *session,
CamelFilterSearchGetMessageFunc get_message, gpointer data,
CamelMessageInfo *info, const gchar *source,
const gchar *expression, CamelException *ex);
gint truth = FALSE;
gint parts, i;
- containee = camel_medium_get_content_object (CAMEL_MEDIUM (object));
+ containee = camel_medium_get_content (CAMEL_MEDIUM (object));
if (containee == NULL)
return FALSE;
#include <libedataserver/e-sexp.h>
#include <camel/camel-folder.h>
-#include <camel/camel-object.h>
#include <camel/camel-index.h>
#define CAMEL_FOLDER_SEARCH_TYPE (camel_folder_search_get_type ())
G_BEGIN_DECLS
+typedef struct _CamelFolderSearch CamelFolderSearch;
typedef struct _CamelFolderSearchClass CamelFolderSearchClass;
+typedef struct _CamelFolderSearchPrivate CamelFolderSearchPrivate;
struct _CamelFolderSearch {
CamelObject parent;
-
- struct _CamelFolderSearchPrivate *priv;
+ CamelFolderSearchPrivate *priv;
ESExp *sexp; /* s-exp evaluator */
gchar *last_search; /* last searched expression */
if (p->index) {
if (p->filter_index == NULL)
- p->filter_index = camel_mime_filter_index_new_index(p->index);
+ p->filter_index = camel_mime_filter_index_new (p->index);
camel_index_delete_name(p->index, camel_message_info_uid(info));
name = camel_index_add_name(p->index, camel_message_info_uid(info));
- camel_mime_filter_index_set_name(p->filter_index, name);
+ camel_mime_filter_index_set_name (
+ CAMEL_MIME_FILTER_INDEX (p->filter_index), name);
}
/* always scan the content info, even if we dont save it */
if (name && p->index) {
camel_index_write_name(p->index, name);
camel_object_unref((CamelObject *)name);
- camel_mime_filter_index_set_name(p->filter_index, NULL);
+ camel_mime_filter_index_set_name (
+ CAMEL_MIME_FILTER_INDEX (p->filter_index), NULL);
}
CAMEL_SUMMARY_UNLOCK(s, filter_lock);
if (p->index) {
if (p->filter_index == NULL)
- p->filter_index = camel_mime_filter_index_new_index(p->index);
+ p->filter_index = camel_mime_filter_index_new (p->index);
camel_index_delete_name(p->index, camel_message_info_uid(info));
name = camel_index_add_name(p->index, camel_message_info_uid(info));
- camel_mime_filter_index_set_name(p->filter_index, name);
+ camel_mime_filter_index_set_name (
+ CAMEL_MIME_FILTER_INDEX (p->filter_index), name);
if (p->filter_stream == NULL) {
CamelStream *null = camel_stream_null_new();
- p->filter_stream = camel_stream_filter_new_with_stream(null);
+ p->filter_stream = camel_stream_filter_new (null);
camel_object_unref((CamelObject *)null);
}
}
if (name) {
camel_index_write_name(p->index, name);
camel_object_unref((CamelObject *)name);
- camel_mime_filter_index_set_name(p->filter_index, NULL);
+ camel_mime_filter_index_set_name (
+ CAMEL_MIME_FILTER_INDEX (p->filter_index), NULL);
}
CAMEL_SUMMARY_UNLOCK(s, filter_lock);
CamelContentType *ct;
gint enc_id = -1, chr_id = -1, html_id = -1, idx_id = -1;
struct _CamelFolderSummaryPrivate *p = _PRIVATE(s);
- CamelMimeFilterCharset *mfc;
+ CamelMimeFilter *mfc;
CamelMessageContentInfo *part;
const gchar *calendar_header;
if (!g_ascii_strcasecmp(encoding, "base64")) {
d(printf(" decoding base64\n"));
if (p->filter_64 == NULL)
- p->filter_64 = camel_mime_filter_basic_new_type(CAMEL_MIME_FILTER_BASIC_BASE64_DEC);
+ p->filter_64 = camel_mime_filter_basic_new (CAMEL_MIME_FILTER_BASIC_BASE64_DEC);
else
camel_mime_filter_reset((CamelMimeFilter *)p->filter_64);
enc_id = camel_mime_parser_filter_add(mp, (CamelMimeFilter *)p->filter_64);
} else if (!g_ascii_strcasecmp(encoding, "quoted-printable")) {
d(printf(" decoding quoted-printable\n"));
if (p->filter_qp == NULL)
- p->filter_qp = camel_mime_filter_basic_new_type(CAMEL_MIME_FILTER_BASIC_QP_DEC);
+ p->filter_qp = camel_mime_filter_basic_new (CAMEL_MIME_FILTER_BASIC_QP_DEC);
else
camel_mime_filter_reset((CamelMimeFilter *)p->filter_qp);
enc_id = camel_mime_parser_filter_add(mp, (CamelMimeFilter *)p->filter_qp);
} else if (!g_ascii_strcasecmp (encoding, "x-uuencode")) {
d(printf(" decoding x-uuencode\n"));
if (p->filter_uu == NULL)
- p->filter_uu = camel_mime_filter_basic_new_type(CAMEL_MIME_FILTER_BASIC_UU_DEC);
+ p->filter_uu = camel_mime_filter_basic_new (CAMEL_MIME_FILTER_BASIC_UU_DEC);
else
camel_mime_filter_reset((CamelMimeFilter *)p->filter_uu);
enc_id = camel_mime_parser_filter_add(mp, (CamelMimeFilter *)p->filter_uu);
d(printf(" Adding conversion filter from %s to UTF-8\n", charset));
mfc = g_hash_table_lookup(p->filter_charset, charset);
if (mfc == NULL) {
- mfc = camel_mime_filter_charset_new_convert(charset, "UTF-8");
+ mfc = camel_mime_filter_charset_new (charset, "UTF-8");
if (mfc)
g_hash_table_insert(p->filter_charset, g_strdup(charset), mfc);
} else {
if (s->build_content)
info = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->content_info_new_from_message(s, object);
- containee = camel_medium_get_content_object(CAMEL_MEDIUM(object));
+ containee = camel_medium_get_content (CAMEL_MEDIUM(object));
if (containee == NULL)
return info;
- /* TODO: I find it odd that get_part and get_content_object do not
+ /* TODO: I find it odd that get_part and get_content do not
add a reference, probably need fixing for multithreading */
/* check for attachments */
p->filter_html = camel_mime_filter_html_new();
else
camel_mime_filter_reset((CamelMimeFilter *)p->filter_html);
- html_id = camel_stream_filter_add(p->filter_stream, (CamelMimeFilter *)p->filter_html);
+ html_id = camel_stream_filter_add (
+ CAMEL_STREAM_FILTER (p->filter_stream),
+ (CamelMimeFilter *)p->filter_html);
}
- idx_id = camel_stream_filter_add(p->filter_stream, (CamelMimeFilter *)p->filter_index);
+ idx_id = camel_stream_filter_add (
+ CAMEL_STREAM_FILTER (p->filter_stream),
+ (CamelMimeFilter *)p->filter_index);
- camel_data_wrapper_decode_to_stream(containee, (CamelStream *)p->filter_stream);
- camel_stream_flush((CamelStream *)p->filter_stream);
+ camel_data_wrapper_decode_to_stream(containee, p->filter_stream);
+ camel_stream_flush(p->filter_stream);
- camel_stream_filter_remove(p->filter_stream, idx_id);
- camel_stream_filter_remove(p->filter_stream, html_id);
+ camel_stream_filter_remove (
+ CAMEL_STREAM_FILTER (p->filter_stream), idx_id);
+ camel_stream_filter_remove (
+ CAMEL_STREAM_FILTER (p->filter_stream), html_id);
}
return info;
#include <stdio.h>
#include <time.h>
+
+#include <camel/camel-mime-message.h>
#include <camel/camel-mime-parser.h>
-#include <camel/camel-object.h>
#include <camel/camel-index.h>
#define CAMEL_FOLDER_SUMMARY_TYPE camel_folder_summary_get_type ()
G_BEGIN_DECLS
struct _CamelFolder;
+struct _CamelStore;
-/*typedef struct _CamelFolderSummary CamelFolderSummary;*/
+typedef struct _CamelFolderSummary CamelFolderSummary;
typedef struct _CamelFolderSummaryClass CamelFolderSummaryClass;
+typedef struct _CamelFolderSummaryPrivate CamelFolderSummaryPrivate;
typedef struct _CamelMessageInfo CamelMessageInfo;
typedef struct _CamelMessageInfoBase CamelMessageInfoBase;
typedef struct _CamelFolderMetaSummary CamelFolderMetaSummary;
+typedef struct _CamelMessageContentInfo CamelMessageContentInfo;
+
/* A tree of message content info structures
describe the content structure of the message (if it has any) */
struct _CamelMessageContentInfo {
- struct _CamelMessageContentInfo *next;
+ CamelMessageContentInfo *next;
- struct _CamelMessageContentInfo *childs;
- struct _CamelMessageContentInfo *parent;
+ CamelMessageContentInfo *childs;
+ CamelMessageContentInfo *parent;
CamelContentType *type;
gchar *id;
struct _CamelFolderSummary {
CamelObject parent;
-
- struct _CamelFolderSummaryPrivate *priv;
+ CamelFolderSummaryPrivate *priv;
/* header info */
guint32 version; /* version of file loaded/loading */
gchar *summary_path;
gboolean build_content; /* do we try and parse/index the content, or not? */
-#if 0 /* Deprecated */
- GPtrArray *messages; /* CamelMessageInfo's */
- GHashTable *messages_uid; /* CamelMessageInfo's by uid */
-#endif
-
/* New members to replace the above depreacted members */
GPtrArray *uids;
GHashTable *loaded_infos;
/* only load the header */
gint camel_folder_summary_header_load(CamelFolderSummary *summary);
-gint camel_folder_summary_header_load_from_db (CamelFolderSummary *s, CamelStore *store, const gchar *folder_name, CamelException *ex);
+gint camel_folder_summary_header_load_from_db (CamelFolderSummary *s, struct _CamelStore *store, const gchar *folder_name, CamelException *ex);
gint camel_folder_summary_header_save_to_db (CamelFolderSummary *s, CamelException *ex);
/* set the dirty bit on the summary */
#ifndef CAMEL_FOLDER_H
#define CAMEL_FOLDER_H
-#include <glib.h>
-#include <camel/camel-object.h>
#include <camel/camel-folder-summary.h>
#define CAMEL_FOLDER_TYPE (camel_folder_get_type ())
G_BEGIN_DECLS
+struct _CamelStore;
+
typedef struct _CamelFolderChangeInfo CamelFolderChangeInfo;
+typedef struct _CamelFolderChangeInfoPrivate CamelFolderChangeInfoPrivate;
+
+typedef struct _CamelFolder CamelFolder;
+typedef struct _CamelFolderClass CamelFolderClass;
+typedef struct _CamelFolderPrivate CamelFolderPrivate;
enum {
CAMEL_FOLDER_ARG_FIRST = CAMEL_ARG_FIRST + 0x1000,
GPtrArray *uid_changed;
GPtrArray *uid_recent;
- struct _CamelFolderChangeInfoPrivate *priv;
+ CamelFolderChangeInfoPrivate *priv;
};
typedef struct _CamelFolderQuotaInfo CamelFolderQuotaInfo;
};
struct _CamelFolder {
- CamelObject parent_object;
-
- struct _CamelFolderPrivate *priv;
+ CamelObject parent;
+ CamelFolderPrivate *priv;
/* get these via the :get() method, they might not be set otherwise */
gchar *name;
gchar *full_name;
gchar *description;
- CamelStore *parent_store;
+ struct _CamelStore *parent_store;
CamelFolderSummary *summary;
guint32 folder_flags;
#define CAMEL_FOLDER_IS_JUNK (1<<5)
#define CAMEL_FOLDER_FILTER_JUNK (1<<6)
-typedef struct {
+struct _CamelFolderClass {
CamelObjectClass parent_class;
- /* Virtual methods */
- void (*refresh_info) (CamelFolder *folder, CamelException *ex);
-
- void (*sync) (CamelFolder *folder, gboolean expunge,
- CamelException *ex);
-
- const gchar * (*get_name) (CamelFolder *folder);
- const gchar * (*get_full_name) (CamelFolder *folder);
-
- CamelStore * (*get_parent_store) (CamelFolder *folder);
-
- void (*expunge) (CamelFolder *folder,
- CamelException *ex);
-
- gint (*get_message_count) (CamelFolder *folder);
-
- void (*append_message) (CamelFolder *folder,
- CamelMimeMessage *message,
- const CamelMessageInfo *info,
- gchar **appended_uid,
- CamelException *ex);
-
- guint32 (*get_permanent_flags) (CamelFolder *folder);
- guint32 (*get_message_flags) (CamelFolder *folder,
- const gchar *uid);
- gboolean (*set_message_flags) (CamelFolder *folder,
- const gchar *uid,
- guint32 flags, guint32 set);
-
- gboolean (*get_message_user_flag) (CamelFolder *folder,
- const gchar *uid,
- const gchar *name);
- void (*set_message_user_flag) (CamelFolder *folder,
- const gchar *uid,
- const gchar *name,
- gboolean value);
-
- const gchar * (*get_message_user_tag) (CamelFolder *folder,
- const gchar *uid,
- const gchar *name);
- void (*set_message_user_tag) (CamelFolder *folder,
- const gchar *uid,
- const gchar *name,
- const gchar *value);
-
- CamelMimeMessage * (*get_message) (CamelFolder *folder,
- const gchar *uid,
- CamelException *ex);
-
- GPtrArray * (*get_uids) (CamelFolder *folder);
- void (*free_uids) (CamelFolder *folder,
- GPtrArray *array);
-
- gint (* cmp_uids) (CamelFolder *folder, const gchar *uid1, const gchar *uid2);
- void (* sort_uids) (CamelFolder *folder, GPtrArray *uids);
-
- GPtrArray * (*get_summary) (CamelFolder *folder);
- void (*free_summary) (CamelFolder *folder,
- GPtrArray *summary);
-
- gboolean (*has_search_capability) (CamelFolder *folder);
-
- GPtrArray * (*search_by_expression) (CamelFolder *, const gchar *, CamelException *);
- GPtrArray * (*search_by_uids) (CamelFolder *, const gchar *, GPtrArray *uids, CamelException *);
-
- void (*search_free) (CamelFolder *folder, GPtrArray *result);
-
- CamelMessageInfo * (*get_message_info) (CamelFolder *, const gchar *uid);
- void (*ref_message_info) (CamelFolder *, CamelMessageInfo *);
- void (*free_message_info) (CamelFolder *, CamelMessageInfo *);
-
- void (*transfer_messages_to) (CamelFolder *source,
- GPtrArray *uids,
- CamelFolder *destination,
- GPtrArray **transferred_uids,
- gboolean delete_originals,
- CamelException *ex);
-
- void (*delete) (CamelFolder *folder);
- void (*rename) (CamelFolder *folder, const gchar *newname);
-
- void (*freeze) (CamelFolder *folder);
- void (*thaw) (CamelFolder *folder);
- gboolean (*is_frozen) (CamelFolder *folder);
-
- CamelFolderQuotaInfo * (*get_quota_info) (CamelFolder *folder);
- guint32 (*count_by_expression) (CamelFolder *, const gchar *, CamelException *);
- void (*sync_message) (CamelFolder *folder,
- const gchar *uid,
- CamelException *ex);
- GPtrArray * (*get_uncached_uids)(CamelFolder *, GPtrArray * uids, CamelException *);
- gchar * (*get_filename) (CamelFolder *, const gchar *uid, CamelException *);
-} CamelFolderClass;
-
-/* Standard Camel function */
-CamelType camel_folder_get_type (void);
-
-/* public methods */
-void camel_folder_construct (CamelFolder *folder,
- CamelStore *parent_store,
- const gchar *full_name,
- const gchar *name);
-
-void camel_folder_refresh_info (CamelFolder *folder,
- CamelException *ex);
-void camel_folder_sync (CamelFolder *folder,
- gboolean expunge,
- CamelException *ex);
-void camel_folder_set_lock_async (CamelFolder *folder,
- gboolean skip_folder_lock);
-
-CamelStore * camel_folder_get_parent_store (CamelFolder *folder);
+ void (*refresh_info) (CamelFolder *folder,
+ CamelException *ex);
+ void (*sync) (CamelFolder *folder,
+ gboolean expunge,
+ CamelException *ex);
+ const gchar * (*get_name) (CamelFolder *folder);
+ const gchar * (*get_full_name) (CamelFolder *folder);
+ struct _CamelStore *
+ (*get_parent_store) (CamelFolder *folder);
+ void (*expunge) (CamelFolder *folder,
+ CamelException *ex);
+ gint (*get_message_count) (CamelFolder *folder);
+ void (*append_message) (CamelFolder *folder,
+ CamelMimeMessage *message,
+ const CamelMessageInfo *info,
+ gchar **appended_uid,
+ CamelException *ex);
+ guint32 (*get_permanent_flags) (CamelFolder *folder);
+ guint32 (*get_message_flags) (CamelFolder *folder,
+ const gchar *uid);
+ gboolean (*set_message_flags) (CamelFolder *folder,
+ const gchar *uid,
+ guint32 flags, guint32 set);
+ gboolean (*get_message_user_flag)(CamelFolder *folder,
+ const gchar *uid,
+ const gchar *name);
+ void (*set_message_user_flag)(CamelFolder *folder,
+ const gchar *uid,
+ const gchar *name,
+ gboolean value);
+ const gchar * (*get_message_user_tag) (CamelFolder *folder,
+ const gchar *uid,
+ const gchar *name);
+ void (*set_message_user_tag) (CamelFolder *folder,
+ const gchar *uid,
+ const gchar *name,
+ const gchar *value);
+ CamelMimeMessage *
+ (*get_message) (CamelFolder *folder,
+ const gchar *uid,
+ CamelException *ex);
+ GPtrArray * (*get_uids) (CamelFolder *folder);
+ void (*free_uids) (CamelFolder *folder,
+ GPtrArray *array);
+ gint (*cmp_uids) (CamelFolder *folder,
+ const gchar *uid1,
+ const gchar *uid2);
+ void (*sort_uids) (CamelFolder *folder,
+ GPtrArray *uids);
+ GPtrArray * (*get_summary) (CamelFolder *folder);
+ void (*free_summary) (CamelFolder *folder,
+ GPtrArray *summary);
+ gboolean (*has_search_capability)(CamelFolder *folder);
+ GPtrArray * (*search_by_expression) (CamelFolder *folder,
+ const gchar *expression,
+ CamelException *ex);
+ GPtrArray * (*search_by_uids) (CamelFolder *folder,
+ const gchar *expression,
+ GPtrArray *uids,
+ CamelException *ex);
+ void (*search_free) (CamelFolder *folder,
+ GPtrArray *result);
+ CamelMessageInfo *
+ (*get_message_info) (CamelFolder *folder,
+ const gchar *uid);
+ void (*ref_message_info) (CamelFolder *folder,
+ CamelMessageInfo *info);
+ void (*free_message_info) (CamelFolder *folder,
+ CamelMessageInfo *info);
+ void (*transfer_messages_to) (CamelFolder *source,
+ GPtrArray *uids,
+ CamelFolder *destination,
+ GPtrArray **transferred_uids,
+ gboolean delete_originals,
+ CamelException *ex);
+ void (*delete) (CamelFolder *folder);
+ void (*rename) (CamelFolder *folder,
+ const gchar *newname);
+ void (*freeze) (CamelFolder *folder);
+ void (*thaw) (CamelFolder *folder);
+ gboolean (*is_frozen) (CamelFolder *folder);
+ CamelFolderQuotaInfo *
+ (*get_quota_info) (CamelFolder *folder);
+ guint32 (*count_by_expression) (CamelFolder *folder,
+ const gchar *expression,
+ CamelException *ex);
+ void (*sync_message) (CamelFolder *folder,
+ const gchar *uid,
+ CamelException *ex);
+ GPtrArray * (*get_uncached_uids) (CamelFolder *folder,
+ GPtrArray * uids,
+ CamelException *ex);
+ gchar * (*get_filename) (CamelFolder *folder,
+ const gchar *uid,
+ CamelException *ex);
+};
+
+CamelType camel_folder_get_type (void);
+void camel_folder_construct (CamelFolder *folder,
+ struct _CamelStore *parent_store,
+ const gchar *full_name,
+ const gchar *name);
+void camel_folder_refresh_info (CamelFolder *folder,
+ CamelException *ex);
+void camel_folder_sync (CamelFolder *folder,
+ gboolean expunge,
+ CamelException *ex);
+void camel_folder_set_lock_async (CamelFolder *folder,
+ gboolean skip_folder_lock);
+
+struct _CamelStore *
+ camel_folder_get_parent_store (CamelFolder *folder);
/* delete operations */
-void camel_folder_expunge (CamelFolder *folder,
- CamelException *ex);
+void camel_folder_expunge (CamelFolder *folder,
+ CamelException *ex);
/* folder name operations */
-const gchar * camel_folder_get_name (CamelFolder *folder);
-const gchar * camel_folder_get_full_name (CamelFolder *folder);
+const gchar * camel_folder_get_name (CamelFolder *folder);
+const gchar * camel_folder_get_full_name (CamelFolder *folder);
/* various properties accessors */
-guint32 camel_folder_get_permanent_flags (CamelFolder *folder);
+guint32 camel_folder_get_permanent_flags(CamelFolder *folder);
#ifndef CAMEL_DISABLE_DEPRECATED
-guint32 camel_folder_get_message_flags (CamelFolder *folder,
- const gchar *uid);
-
-gboolean camel_folder_set_message_flags (CamelFolder *folder,
- const gchar *uid,
- guint32 flags,
- guint32 set);
-
-gboolean camel_folder_get_message_user_flag (CamelFolder *folder,
- const gchar *uid,
- const gchar *name);
-
-void camel_folder_set_message_user_flag (CamelFolder *folder,
- const gchar *uid,
- const gchar *name,
- gboolean value);
-
-const gchar * camel_folder_get_message_user_tag (CamelFolder *folder,
- const gchar *uid,
- const gchar *name);
-
-void camel_folder_set_message_user_tag (CamelFolder *folder,
- const gchar *uid,
- const gchar *name,
- const gchar *value);
+guint32 camel_folder_get_message_flags (CamelFolder *folder,
+ const gchar *uid);
+
+gboolean camel_folder_set_message_flags (CamelFolder *folder,
+ const gchar *uid,
+ guint32 flags,
+ guint32 set);
+
+gboolean camel_folder_get_message_user_flag
+ (CamelFolder *folder,
+ const gchar *uid,
+ const gchar *name);
+
+void camel_folder_set_message_user_flag
+ (CamelFolder *folder,
+ const gchar *uid,
+ const gchar *name,
+ gboolean value);
+
+const gchar * camel_folder_get_message_user_tag
+ (CamelFolder *folder,
+ const gchar *uid,
+ const gchar *name);
+
+void camel_folder_set_message_user_tag
+ (CamelFolder *folder,
+ const gchar *uid,
+ const gchar *name,
+ const gchar *value);
#endif /* CAMEL_DISABLE_DEPRECATED */
/* message manipulation */
-void camel_folder_append_message (CamelFolder *folder,
- CamelMimeMessage *message,
- const CamelMessageInfo *info,
- gchar **appended_uid,
- CamelException *ex);
+void camel_folder_append_message (CamelFolder *folder,
+ CamelMimeMessage *message,
+ const CamelMessageInfo *info,
+ gchar **appended_uid,
+ CamelException *ex);
/* summary related operations */
-gboolean camel_folder_has_summary_capability (CamelFolder *folder);
+gboolean camel_folder_has_summary_capability
+ (CamelFolder *folder);
-gint camel_folder_get_message_count (CamelFolder *folder);
+gint camel_folder_get_message_count (CamelFolder *folder);
#ifndef CAMEL_DISABLE_DEPRECATED
-gint camel_folder_get_unread_message_count (CamelFolder *folder);
+gint camel_folder_get_unread_message_count
+ (CamelFolder *folder);
#endif
-gint camel_folder_get_deleted_message_count (CamelFolder *folder);
+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);
+GPtrArray * camel_folder_get_summary (CamelFolder *folder);
+void camel_folder_free_summary (CamelFolder *folder,
+ GPtrArray *array);
/* uid based access operations */
-CamelMimeMessage * camel_folder_get_message (CamelFolder *folder,
- const gchar *uid,
- CamelException *ex);
-void camel_folder_sync_message (CamelFolder *folder,
- const gchar *uid,
- CamelException *ex);
+CamelMimeMessage *
+ camel_folder_get_message (CamelFolder *folder,
+ const gchar *uid,
+ CamelException *ex);
+void camel_folder_sync_message (CamelFolder *folder,
+ const gchar *uid,
+ CamelException *ex);
#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 *,
- GPtrArray * uids,
- CamelException *);
-gint camel_folder_cmp_uids (CamelFolder *folder, const gchar *uid1, const gchar *uid2);
-void camel_folder_sort_uids (CamelFolder *folder,
- GPtrArray *uids);
+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,
+ CamelException *ex);
+gint camel_folder_cmp_uids (CamelFolder *folder,
+ const gchar *uid1,
+ const gchar *uid2);
+void camel_folder_sort_uids (CamelFolder *folder,
+ GPtrArray *uids);
/* search api */
-gboolean camel_folder_has_search_capability (CamelFolder *folder);
-GPtrArray * camel_folder_search_by_expression (CamelFolder *folder, const gchar *expr, CamelException *ex);
-GPtrArray * camel_folder_search_by_uids (CamelFolder *folder, const gchar *expr, GPtrArray *uids, CamelException *ex);
-void camel_folder_search_free (CamelFolder *folder, GPtrArray *result);
-guint32 camel_folder_count_by_expression (CamelFolder *folder, const gchar *expression, CamelException *ex);
+gboolean camel_folder_has_search_capability
+ (CamelFolder *folder);
+GPtrArray * camel_folder_search_by_expression
+ (CamelFolder *folder,
+ const gchar *expr,
+ CamelException *ex);
+GPtrArray * camel_folder_search_by_uids (CamelFolder *folder,
+ const gchar *expr,
+ GPtrArray *uids,
+ CamelException *ex);
+void camel_folder_search_free (CamelFolder *folder,
+ GPtrArray *result);
+guint32 camel_folder_count_by_expression(CamelFolder *folder,
+ const gchar *expression,
+ CamelException *ex);
/* summary info */
-CamelMessageInfo *camel_folder_get_message_info (CamelFolder *folder, const gchar *uid);
-void camel_folder_free_message_info (CamelFolder *folder, CamelMessageInfo *info);
+CamelMessageInfo *
+ camel_folder_get_message_info (CamelFolder *folder,
+ const gchar *uid);
+void camel_folder_free_message_info (CamelFolder *folder,
+ CamelMessageInfo *info);
#ifndef CAMEL_DISABLE_DEPRECATED
-void camel_folder_ref_message_info (CamelFolder *folder, CamelMessageInfo *info);
+void camel_folder_ref_message_info (CamelFolder *folder,
+ CamelMessageInfo *info);
#endif
-void camel_folder_transfer_messages_to (CamelFolder *source,
- GPtrArray *uids,
- CamelFolder *dest,
- GPtrArray **transferred_uids,
- gboolean delete_originals,
- CamelException *ex);
+void camel_folder_transfer_messages_to
+ (CamelFolder *source,
+ GPtrArray *uids,
+ CamelFolder *dest,
+ GPtrArray **transferred_uids,
+ gboolean delete_originals,
+ CamelException *ex);
-void camel_folder_delete (CamelFolder *folder);
-void camel_folder_rename (CamelFolder *folder, const gchar *new);
+void camel_folder_delete (CamelFolder *folder);
+void camel_folder_rename (CamelFolder *folder,
+ const gchar *new);
/* stop/restart getting events */
-void camel_folder_freeze (CamelFolder *folder);
-void camel_folder_thaw (CamelFolder *folder);
-gboolean camel_folder_is_frozen (CamelFolder *folder);
+void camel_folder_freeze (CamelFolder *folder);
+void camel_folder_thaw (CamelFolder *folder);
+gboolean camel_folder_is_frozen (CamelFolder *folder);
/* quota support */
-CamelFolderQuotaInfo *camel_folder_get_quota_info (CamelFolder *folder);
+CamelFolderQuotaInfo *
+ camel_folder_get_quota_info (CamelFolder *folder);
-CamelFolderQuotaInfo *camel_folder_quota_info_new (const gchar *name, guint64 used, guint64 total);
-CamelFolderQuotaInfo *camel_folder_quota_info_clone (const CamelFolderQuotaInfo *info);
-void camel_folder_quota_info_free (CamelFolderQuotaInfo *info);
+CamelFolderQuotaInfo *
+ camel_folder_quota_info_new (const gchar *name,
+ guint64 used,
+ guint64 total);
+CamelFolderQuotaInfo *
+ camel_folder_quota_info_clone (const CamelFolderQuotaInfo *info);
+void camel_folder_quota_info_free (CamelFolderQuotaInfo *info);
/* For use by subclasses (for free_{uids,summary,subfolder_names}) */
-void camel_folder_free_nop (CamelFolder *folder, GPtrArray *array);
-void camel_folder_free_shallow (CamelFolder *folder, GPtrArray *array);
-void camel_folder_free_deep (CamelFolder *folder, GPtrArray *array);
+void camel_folder_free_nop (CamelFolder *folder,
+ GPtrArray *array);
+void camel_folder_free_shallow (CamelFolder *folder,
+ GPtrArray *array);
+void camel_folder_free_deep (CamelFolder *folder,
+ GPtrArray *array);
-gchar * camel_folder_get_filename (CamelFolder *folder, const gchar *uid, CamelException *ex);
+gchar * camel_folder_get_filename (CamelFolder *folder,
+ const gchar *uid,
+ CamelException *ex);
/* update functions for change info */
-CamelFolderChangeInfo * camel_folder_change_info_new (void);
-void camel_folder_change_info_clear (CamelFolderChangeInfo *info);
-void camel_folder_change_info_free (CamelFolderChangeInfo *info);
-gboolean camel_folder_change_info_changed (CamelFolderChangeInfo *info);
+CamelFolderChangeInfo *
+ camel_folder_change_info_new (void);
+void camel_folder_change_info_clear (CamelFolderChangeInfo *info);
+void camel_folder_change_info_free (CamelFolderChangeInfo *info);
+gboolean camel_folder_change_info_changed(CamelFolderChangeInfo *info);
/* for building diff's automatically */
-void camel_folder_change_info_add_source (CamelFolderChangeInfo *info, const gchar *uid);
-void camel_folder_change_info_add_source_list(CamelFolderChangeInfo *info, const GPtrArray *list);
-void camel_folder_change_info_add_update (CamelFolderChangeInfo *info, const gchar *uid);
-void camel_folder_change_info_add_update_list(CamelFolderChangeInfo *info, const GPtrArray *list);
-void camel_folder_change_info_build_diff (CamelFolderChangeInfo *info);
+void camel_folder_change_info_add_source
+ (CamelFolderChangeInfo *info,
+ const gchar *uid);
+void camel_folder_change_info_add_source_list
+ (CamelFolderChangeInfo *info,
+ const GPtrArray *list);
+void camel_folder_change_info_add_update
+ (CamelFolderChangeInfo *info,
+ const gchar *uid);
+void camel_folder_change_info_add_update_list
+ (CamelFolderChangeInfo *info,
+ const GPtrArray *list);
+void camel_folder_change_info_build_diff
+ (CamelFolderChangeInfo *info);
/* for manipulating diff's directly */
-void camel_folder_change_info_cat (CamelFolderChangeInfo *info, CamelFolderChangeInfo *src);
-void camel_folder_change_info_add_uid (CamelFolderChangeInfo *info, const gchar *uid);
-void camel_folder_change_info_remove_uid (CamelFolderChangeInfo *info, const gchar *uid);
-void camel_folder_change_info_change_uid (CamelFolderChangeInfo *info, const gchar *uid);
-void camel_folder_change_info_recent_uid (CamelFolderChangeInfo *info, const gchar *uid);
+void camel_folder_change_info_cat (CamelFolderChangeInfo *info,
+ CamelFolderChangeInfo *src);
+void camel_folder_change_info_add_uid(CamelFolderChangeInfo *info,
+ const gchar *uid);
+void camel_folder_change_info_remove_uid
+ (CamelFolderChangeInfo *info,
+ const gchar *uid);
+void camel_folder_change_info_change_uid
+ (CamelFolderChangeInfo *info,
+ const gchar *uid);
+void camel_folder_change_info_recent_uid
+ (CamelFolderChangeInfo *info,
+ const gchar *uid);
G_END_DECLS
gpg->diagflushed = FALSE;
if ((charset = camel_iconv_locale_charset ()) && g_ascii_strcasecmp (charset, "UTF-8") != 0) {
- CamelMimeFilterCharset *filter;
- CamelStreamFilter *fstream;
+ CamelMimeFilter *filter;
+ CamelStream *fstream;
gpg->utf8 = FALSE;
- if ((filter = camel_mime_filter_charset_new_convert (charset, "UTF-8"))) {
- fstream = camel_stream_filter_new_with_stream (stream);
- camel_stream_filter_add (fstream, (CamelMimeFilter *) filter);
+ if ((filter = camel_mime_filter_charset_new (charset, "UTF-8"))) {
+ fstream = camel_stream_filter_new (stream);
+ camel_stream_filter_add (
+ CAMEL_STREAM_FILTER (fstream),
+ (CamelMimeFilter *) filter);
camel_object_unref (filter);
camel_object_unref (stream);
camel_data_wrapper_set_mime_type_field(dw, ct);
camel_content_type_unref(ct);
- camel_medium_set_content_object((CamelMedium *)sigpart, dw);
+ camel_medium_set_content ((CamelMedium *)sigpart, dw);
camel_object_unref(dw);
camel_mime_part_set_description(sigpart, "This is a digitally signed message part");
camel_stream_reset(istream);
camel_object_ref(istream);
- camel_medium_set_content_object((CamelMedium *)opart, (CamelDataWrapper *)mps);
+ camel_medium_set_content ((CamelMedium *)opart, (CamelDataWrapper *)mps);
fail:
camel_object_unref(ostream);
CamelMimePart *sigpart;
CamelStream *istream = NULL, *canon_stream;
CamelMultipart *mps;
- CamelStreamFilter *filter;
+ CamelStream *filter;
CamelMimeFilter *canon;
- mps = (CamelMultipart *)camel_medium_get_content_object((CamelMedium *)ipart);
+ mps = (CamelMultipart *)camel_medium_get_content ((CamelMedium *)ipart);
ct = ((CamelDataWrapper *)mps)->mime_type;
/* Inline signature (using our fake mime type) or PGP/Mime signature */
} else if (camel_content_type_is(ct, "application", "x-inlinepgp-signed")) {
/* Inline Signed */
CamelDataWrapper *content;
- content = camel_medium_get_content_object ((CamelMedium *) ipart);
+ content = camel_medium_get_content ((CamelMedium *) ipart);
istream = camel_stream_mem_new();
camel_data_wrapper_decode_to_stream (content, istream);
camel_stream_reset(istream);
canon_stream = camel_stream_mem_new ();
/* strip trailing white-spaces */
- filter = camel_stream_filter_new_with_stream (canon_stream);
+ filter = camel_stream_filter_new (canon_stream);
canon = camel_mime_filter_canon_new (CAMEL_MIME_FILTER_CANON_CRLF | CAMEL_MIME_FILTER_CANON_STRIP);
- camel_stream_filter_add (filter, canon);
+ camel_stream_filter_add (CAMEL_STREAM_FILTER (filter), canon);
camel_object_unref (canon);
camel_stream_write_to_stream (istream, (CamelStream *)filter);
camel_data_wrapper_set_mime_type_field(dw, ct);
camel_content_type_unref(ct);
- camel_medium_set_content_object((CamelMedium *)encpart, dw);
+ camel_medium_set_content ((CamelMedium *)encpart, dw);
camel_object_unref(dw);
camel_mime_part_set_description(encpart, _("This is a digitally encrypted message part"));
camel_data_wrapper_set_mime_type(dw, context->encrypt_protocol);
camel_data_wrapper_construct_from_stream(dw, vstream);
camel_object_unref(vstream);
- camel_medium_set_content_object((CamelMedium *)verpart, dw);
+ camel_medium_set_content ((CamelMedium *)verpart, dw);
camel_object_unref(dw);
mpe = camel_multipart_encrypted_new();
camel_multipart_add_part((CamelMultipart *)mpe, encpart);
camel_object_unref(encpart);
- camel_medium_set_content_object((CamelMedium *)opart, (CamelDataWrapper *)mpe);
+ camel_medium_set_content ((CamelMedium *)opart, (CamelDataWrapper *)mpe);
fail:
gpg_ctx_free(gpg);
fail1:
return NULL;
}
- content = camel_medium_get_content_object((CamelMedium *)ipart);
+ content = camel_medium_get_content ((CamelMedium *)ipart);
if (!content) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
ct = camel_mime_part_get_content_type((CamelMimePart *)content);
/* Encrypted part (using our fake mime type) or PGP/Mime multipart */
if (camel_content_type_is(ct, "multipart", "encrypted")) {
- mp = (CamelMultipart *) camel_medium_get_content_object ((CamelMedium *) ipart);
+ mp = (CamelMultipart *) camel_medium_get_content ((CamelMedium *) ipart);
if (!(encrypted = camel_multipart_get_part (mp, CAMEL_MULTIPART_ENCRYPTED_CONTENT))) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Failed to decrypt MIME part: protocol error"));
return NULL;
}
- content = camel_medium_get_content_object ((CamelMedium *) encrypted);
+ content = camel_medium_get_content ((CamelMedium *) encrypted);
} else if (camel_content_type_is(ct, "application", "x-inlinepgp-encrypted")) {
- content = camel_medium_get_content_object ((CamelMedium *) ipart);
+ content = camel_medium_get_content ((CamelMedium *) ipart);
} else {
/* Invalid Mimetype */
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
/* Multipart encrypted - parse a full mime part */
rv = camel_data_wrapper_construct_from_stream ((CamelDataWrapper *)opart, ostream);
- dw = camel_medium_get_content_object ((CamelMedium *)opart);
+ dw = camel_medium_get_content ((CamelMedium *)opart);
if (!camel_data_wrapper_decode_to_stream (dw, null)) {
/* nothing had been decoded from the stream, it doesn't
contain any header, like Content-Type or such, thus
dw = camel_data_wrapper_new ();
rv = camel_data_wrapper_construct_from_stream(dw, ostream);
camel_data_wrapper_set_mime_type(dw, "application/octet-stream");
- camel_medium_set_content_object((CamelMedium *)opart, dw);
+ camel_medium_set_content ((CamelMedium *)opart, dw);
camel_object_unref(dw);
/* Set mime/type of this new part to application/octet-stream to force type snooping */
camel_mime_part_set_content_type(opart, "application/octet-stream");
#define CAMEL_GPG_CONTEXT_H
#include <camel/camel-cipher-context.h>
+#include <camel/camel-session.h>
#define CAMEL_GPG_CONTEXT_TYPE (camel_gpg_context_get_type ())
#define CAMEL_GPG_CONTEXT(obj) (CAMEL_CHECK_CAST((obj), CAMEL_GPG_CONTEXT_TYPE, CamelGpgContext))
typedef struct _CamelGpgContextClass CamelGpgContextClass;
struct _CamelGpgContext {
- CamelCipherContext parent_object;
+ CamelCipherContext parent;
gboolean always_trust;
};
};
-CamelType camel_gpg_context_get_type (void);
-
-CamelCipherContext *camel_gpg_context_new (CamelSession *session);
-
-void camel_gpg_context_set_always_trust (CamelGpgContext *ctx, gboolean trust);
+CamelType camel_gpg_context_get_type (void);
+CamelCipherContext *
+ camel_gpg_context_new (CamelSession *session);
+void camel_gpg_context_set_always_trust
+ (CamelGpgContext *context,
+ gboolean always_trust);
G_END_DECLS
/* Parser definitions, see below object code for details */
-typedef struct _CamelHTMLParserPrivate CamelHTMLParserPrivate;
-
struct _CamelHTMLParserPrivate {
gchar *inbuf,
*inptr,
G_BEGIN_DECLS
-typedef struct _CamelHTMLParserClass CamelHTMLParserClass;
typedef struct _CamelHTMLParser CamelHTMLParser;
+typedef struct _CamelHTMLParserClass CamelHTMLParserClass;
+typedef struct _CamelHTMLParserPrivate CamelHTMLParserPrivate;
/* Parser/tokeniser states */
typedef enum _camel_html_parser_t {
struct _CamelHTMLParser {
CamelObject parent;
-
- struct _CamelHTMLParserPrivate *priv;
+ CamelHTMLParserPrivate *priv;
};
struct _CamelHTMLParserClass {
/*CAMEL_HTTP_METHOD_CONNECT*/
} CamelHttpMethod;
+typedef struct _CamelHttpStream CamelHttpStream;
typedef struct _CamelHttpStreamClass CamelHttpStreamClass;
struct _CamelHttpStream {
- CamelStream parent_object;
+ CamelStream parent;
CamelMimeParser *parser;
struct _CamelHttpStreamClass {
CamelStreamClass parent_class;
-
- /* Virtual methods */
};
-/* Standard Camel function */
-CamelType camel_http_stream_get_type (void);
-
-/* public methods */
-CamelStream *camel_http_stream_new (CamelHttpMethod method, struct _CamelSession *session, CamelURL *url);
-
-void camel_http_stream_set_user_agent (CamelHttpStream *http_stream, const gchar *user_agent);
-
-void camel_http_stream_set_proxy (CamelHttpStream *http_stream, const gchar *proxy_url);
-void camel_http_stream_set_proxy_authrealm (CamelHttpStream *http_stream, const gchar *proxy_authrealm);
-void camel_http_stream_set_proxy_authpass (CamelHttpStream *http_stream, const gchar *proxy_authpass);
-
-CamelContentType *camel_http_stream_get_content_type (CamelHttpStream *http_stream);
+CamelType camel_http_stream_get_type (void);
+CamelStream * camel_http_stream_new (CamelHttpMethod method,
+ struct _CamelSession *session,
+ CamelURL *url);
+void camel_http_stream_set_user_agent(CamelHttpStream *http_stream,
+ const gchar *user_agent);
+void camel_http_stream_set_proxy (CamelHttpStream *http_stream,
+ const gchar *proxy_url);
+void camel_http_stream_set_proxy_authrealm
+ (CamelHttpStream *http_stream,
+ const gchar *proxy_authrealm);
+void camel_http_stream_set_proxy_authpass
+ (CamelHttpStream *http_stream,
+ const gchar *proxy_authpass);
+CamelContentType *
+ camel_http_stream_get_content_type
+ (CamelHttpStream *http_stream);
G_END_DECLS
const gchar *path = "/home/notzed/evolution/local/Inbox/mbox/cur";
struct dirent *d;
CamelStream *null, *filter, *stream;
- CamelMimeFilterIndex *filter_index;
+ CamelMimeFilter *filter_index;
gchar *name;
CamelIndexName *idn;
}
null = camel_stream_null_new();
- filter = (CamelStream *)camel_stream_filter_new_with_stream(null);
+ filter = camel_stream_filter_new (null);
camel_object_unref((CamelObject *)null);
- filter_index = camel_mime_filter_index_new_index(idx);
+ filter_index = camel_mime_filter_index_new (idx);
camel_stream_filter_add((CamelStreamFilter *)filter, (CamelMimeFilter *)filter_index);
while ((d = readdir(dir))) {
printf("indexing '%s'\n", d->d_name);
idn = camel_index_add_name(idx, d->d_name);
- camel_mime_filter_index_set_name(filter_index, idn);
+ camel_mime_filter_index_set_name (
+ CAMEL_MIME_FILTER_INDEX (filter_index), idn);
name = g_strdup_printf("%s/%s", path, d->d_name);
stream = camel_stream_fs_new_with_name(name, O_RDONLY, 0);
camel_stream_write_to_stream(stream, filter);
camel_index_write_name(idx, idn);
camel_object_unref((CamelObject *)idn);
- camel_mime_filter_index_set_name(filter_index, NULL);
+ camel_mime_filter_index_set_name (
+ CAMEL_MIME_FILTER_INDEX (filter_index), NULL);
}
closedir(dir);
}
void
-camel_index_set_normalise(CamelIndex *idx, CamelIndexNorm func, gpointer data)
+camel_index_set_normalize(CamelIndex *idx, CamelIndexNorm func, gpointer data)
{
g_return_if_fail (CAMEL_IS_INDEX (idx));
- idx->normalise = func;
- idx->normalise_data = data;
+ idx->normalize = func;
+ idx->normalize_data = data;
}
gint
if ((idx->state & CAMEL_INDEX_DELETED) != 0)
return NULL;
- if (idx->normalise)
- b = idx->normalise(idx, word, idx->normalise_data);
+ if (idx->normalize)
+ b = idx->normalize(idx, word, idx->normalize_data);
ret = CI_CLASS(idx)->find(idx, b);
{
gchar *b = (gchar *)word;
- if (idn->index->normalise)
- b = idn->index->normalise(idn->index, word, idn->index->normalise_data);
+ if (idn->index->normalize)
+ b = idn->index->normalize(idn->index, word, idn->index->normalize_data);
CIN_CLASS(idn)->add_word(idn, b);
#define CAMEL_INDEX_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_index_get_type (), CamelIndexClass)
#define CAMEL_IS_INDEX(obj) CAMEL_CHECK_TYPE (obj, camel_index_get_type ())
-G_BEGIN_DECLS
-
-typedef struct _CamelIndex CamelIndex;
-typedef struct _CamelIndexClass CamelIndexClass;
-
#define CAMEL_INDEX_NAME(obj) CAMEL_CHECK_CAST (obj, camel_index_name_get_type (), CamelIndexName)
#define CAMEL_INDEX_NAME_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_index_name_get_type (), CamelIndexNameClass)
#define CAMEL_IS_INDEX_NAME(obj) CAMEL_CHECK_TYPE (obj, camel_index_name_get_type ())
-typedef struct _CamelIndexName CamelIndexName;
-typedef struct _CamelIndexNameClass CamelIndexNameClass;
-
#define CAMEL_INDEX_CURSOR(obj) CAMEL_CHECK_CAST (obj, camel_index_cursor_get_type (), CamelIndexCursor)
#define CAMEL_INDEX_CURSOR_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_index_cursor_get_type (), CamelIndexCursorClass)
#define CAMEL_IS_INDEX_CURSOR(obj) CAMEL_CHECK_TYPE (obj, camel_index_cursor_get_type ())
-typedef struct _CamelIndexCursor CamelIndexCursor;
+G_BEGIN_DECLS
+
+typedef struct _CamelIndex CamelIndex;
+typedef struct _CamelIndexClass CamelIndexClass;
+typedef struct _CamelIndexPrivate CamelIndexPrivate;
+
+typedef struct _CamelIndexName CamelIndexName;
+typedef struct _CamelIndexNameClass CamelIndexNameClass;
+typedef struct _CamelIndexNamePrivate CamelIndexNamePrivate;
+
+typedef struct _CamelIndexCursor CamelIndexCursor;
typedef struct _CamelIndexCursorClass CamelIndexCursorClass;
+typedef struct _CamelIndexCursorPrivate CamelIndexCursorPrivate;
-typedef gchar * (*CamelIndexNorm)(CamelIndex *idx, const gchar *word, gpointer data);
+typedef gchar * (*CamelIndexNorm)(CamelIndex *index, const gchar *word, gpointer data);
/* ********************************************************************** */
struct _CamelIndexCursor {
CamelObject parent;
-
- struct _CamelIndexCursorPrivate *priv;
+ CamelIndexCursorPrivate *priv;
CamelIndex *index;
};
CamelType camel_index_cursor_get_type(void);
-CamelIndexCursor *camel_index_cursor_new(CamelIndex *idx, const gchar *name);
+CamelIndexCursor *camel_index_cursor_new(CamelIndex *index, const gchar *name);
const gchar *camel_index_cursor_next(CamelIndexCursor *idc);
void camel_index_cursor_reset(CamelIndexCursor *idc);
struct _CamelIndexName {
CamelObject parent;
-
- struct _CamelIndexNamePrivate *priv;
+ CamelIndexNamePrivate *priv;
CamelIndex *index;
CamelType camel_index_name_get_type (void);
-CamelIndexName *camel_index_name_new(CamelIndex *idx, const gchar *name);
+CamelIndexName *camel_index_name_new(CamelIndex *index, const gchar *name);
void camel_index_name_add_word(CamelIndexName *name, const gchar *word);
gsize camel_index_name_add_buffer(CamelIndexName *name, const gchar *buffer, gsize len);
struct _CamelIndex {
CamelObject parent;
-
- struct _CamelIndexPrivate *priv;
+ CamelIndexPrivate *priv;
gchar *path;
guint32 version;
guint32 flags; /* open flags */
guint32 state;
- CamelIndexNorm normalise;
- gpointer normalise_data;
+ CamelIndexNorm normalize;
+ gpointer normalize_data;
};
struct _CamelIndexClass {
CamelObjectClass parent_class;
- gint (*sync)(CamelIndex *idx);
- gint (*compress)(CamelIndex *idx);
- gint (*delete)(CamelIndex *idx);
-
- gint (*rename)(CamelIndex *idx, const gchar *path);
-
- gint (*has_name)(CamelIndex *idx, const gchar *name);
- CamelIndexName * (*add_name)(CamelIndex *idx, const gchar *name);
- gint (*write_name)(CamelIndex *idx, CamelIndexName *idn);
- CamelIndexCursor * (*find_name)(CamelIndex *idx, const gchar *name);
- void (*delete_name)(CamelIndex *idx, const gchar *name);
- CamelIndexCursor * (*find)(CamelIndex *idx, const gchar *word);
-
- CamelIndexCursor * (*words)(CamelIndex *idx);
- CamelIndexCursor * (*names)(CamelIndex *idx);
+ gint (*sync) (CamelIndex *index);
+ gint (*compress) (CamelIndex *index);
+ gint (*delete) (CamelIndex *index);
+ gint (*rename) (CamelIndex *index,
+ const gchar *path);
+ gint (*has_name) (CamelIndex *index,
+ const gchar *name);
+ CamelIndexName *(*add_name) (CamelIndex *index,
+ const gchar *name);
+ gint (*write_name) (CamelIndex *index,
+ CamelIndexName *idn);
+ CamelIndexCursor *
+ (*find_name) (CamelIndex *index,
+ const gchar *name);
+ void (*delete_name) (CamelIndex *index,
+ const gchar *name);
+ CamelIndexCursor *
+ (*find) (CamelIndex *index,
+ const gchar *word);
+ CamelIndexCursor *
+ (*words) (CamelIndex *index);
+ CamelIndexCursor *
+ (*names) (CamelIndex *index);
};
/* flags, stored in 'state', set with set_state */
#define CAMEL_INDEX_DELETED (1<<0)
-CamelType camel_index_get_type (void);
-
-CamelIndex *camel_index_new(const gchar *path, gint flags);
-void camel_index_construct(CamelIndex *, const gchar *path, gint flags);
-gint camel_index_rename(CamelIndex *, const gchar *path);
-
-void camel_index_set_normalise(CamelIndex *idx, CamelIndexNorm func, gpointer data);
-
-gint camel_index_sync(CamelIndex *idx);
-gint camel_index_compress(CamelIndex *idx);
-gint camel_index_delete(CamelIndex *idx);
-
-gint camel_index_has_name(CamelIndex *idx, const gchar *name);
-CamelIndexName *camel_index_add_name(CamelIndex *idx, const gchar *name);
-gint camel_index_write_name(CamelIndex *idx, CamelIndexName *idn);
-CamelIndexCursor *camel_index_find_name(CamelIndex *idx, const gchar *name);
-void camel_index_delete_name(CamelIndex *idx, const gchar *name);
-CamelIndexCursor *camel_index_find(CamelIndex *idx, const gchar *word);
-
-CamelIndexCursor *camel_index_words(CamelIndex *idx);
-CamelIndexCursor *camel_index_names(CamelIndex *idx);
+CamelType camel_index_get_type (void);
+CamelIndex * camel_index_new (const gchar *path,
+ gint flags);
+void camel_index_construct (CamelIndex *index,
+ const gchar *path,
+ gint flags);
+gint camel_index_rename (CamelIndex *index,
+ const gchar *path);
+void camel_index_set_normalize (CamelIndex *index,
+ CamelIndexNorm func,
+ gpointer data);
+gint camel_index_sync (CamelIndex *index);
+gint camel_index_compress (CamelIndex *index);
+gint camel_index_delete (CamelIndex *index);
+gint camel_index_has_name (CamelIndex *index,
+ const gchar *name);
+CamelIndexName *camel_index_add_name (CamelIndex *index,
+ const gchar *name);
+gint camel_index_write_name (CamelIndex *index,
+ CamelIndexName *idn);
+CamelIndexCursor *
+ camel_index_find_name (CamelIndex *index,
+ const gchar *name);
+void camel_index_delete_name (CamelIndex *index,
+ const gchar *name);
+CamelIndexCursor *
+ camel_index_find (CamelIndex *index,
+ const gchar *word);
+CamelIndexCursor *
+ camel_index_words (CamelIndex *index);
+CamelIndexCursor *
+ camel_index_names (CamelIndex *index);
G_END_DECLS
static gchar * internet_encode (CamelAddress *);
static gint internet_unformat (CamelAddress *, const gchar *raw);
static gchar * internet_format (CamelAddress *);
-static gint internet_cat (CamelAddress *dest, const CamelAddress *source);
+static gint internet_cat (CamelAddress *dest, CamelAddress *source);
static void internet_remove (CamelAddress *, gint index);
static void camel_internet_address_class_init (CamelInternetAddressClass *klass);
}
static gint
-internet_cat (CamelAddress *dest, const CamelAddress *source)
+internet_cat (CamelAddress *dest, CamelAddress *source)
{
gint i;
* Returns: %TRUE if such an address exists, or %FALSE otherwise
**/
gboolean
-camel_internet_address_get (const CamelInternetAddress *addr, gint index, const gchar **namep, const gchar **addressp)
+camel_internet_address_get (CamelInternetAddress *addr, gint index, const gchar **namep, const gchar **addressp)
{
struct _address *a;
G_BEGIN_DECLS
+typedef struct _CamelInternetAddress CamelInternetAddress;
typedef struct _CamelInternetAddressClass CamelInternetAddressClass;
+typedef struct _CamelInternetAddressPrivate CamelInternetAddressPrivate;
struct _CamelInternetAddress {
CamelAddress parent;
-
- struct _CamelInternetAddressPrivate *priv;
+ CamelInternetAddressPrivate *priv;
};
struct _CamelInternetAddressClass {
CamelAddressClass parent_class;
};
-CamelType camel_internet_address_get_type (void);
-CamelInternetAddress *camel_internet_address_new (void);
-
-gint camel_internet_address_add (CamelInternetAddress *addr, const gchar *name, const gchar *address);
-gboolean camel_internet_address_get (const CamelInternetAddress *addr, gint index, const gchar **namep, const gchar **addressp);
-
-gint camel_internet_address_find_name(CamelInternetAddress *addr, const gchar *name, const gchar **addressp);
-gint camel_internet_address_find_address(CamelInternetAddress *addr, const gchar *address, const gchar **namep);
+CamelType camel_internet_address_get_type (void);
+CamelInternetAddress *
+ camel_internet_address_new (void);
+gint camel_internet_address_add (CamelInternetAddress *addr,
+ const gchar *name,
+ const gchar *address);
+gboolean camel_internet_address_get (CamelInternetAddress *addr,
+ gint index,
+ const gchar **namep,
+ const gchar **addressp);
+gint camel_internet_address_find_name(CamelInternetAddress *addr,
+ const gchar *name,
+ const gchar **addressp);
+gint camel_internet_address_find_address
+ (CamelInternetAddress *addr,
+ const gchar *address,
+ const gchar **namep);
/* utility functions, for network/display formatting */
-gchar * camel_internet_address_encode_address(gint *len, const gchar *name, const gchar *addr);
-gchar * camel_internet_address_format_address(const gchar *name, const gchar *addr);
+gchar * camel_internet_address_encode_address
+ (gint *len,
+ const gchar *name,
+ const gchar *addr);
+gchar * camel_internet_address_format_address
+ (const gchar *name,
+ const gchar *addr);
G_END_DECLS
static GArray *get_headers (CamelMedium *medium);
static void free_headers (CamelMedium *medium, GArray *headers);
-static CamelDataWrapper *get_content_object (CamelMedium *medium);
-static void set_content_object (CamelMedium *medium,
+static CamelDataWrapper *get_content (CamelMedium *medium);
+static void set_content (CamelMedium *medium,
CamelDataWrapper *content);
static void
camel_medium_class->get_headers = get_headers;
camel_medium_class->free_headers = free_headers;
- camel_medium_class->set_content_object = set_content_object;
- camel_medium_class->get_content_object = get_content_object;
+ camel_medium_class->set_content = set_content;
+ camel_medium_class->get_content = get_content;
}
static void
}
static CamelDataWrapper *
-get_content_object(CamelMedium *medium)
+get_content (CamelMedium *medium)
{
return medium->content;
}
/**
- * camel_medium_get_content_object:
+ * camel_medium_get_content:
* @medium: a #CamelMedium object
*
* Gets a data wrapper that represents the content of the medium,
* Returns: a #CamelDataWrapper containing @medium's content. Can return NULL.
**/
CamelDataWrapper *
-camel_medium_get_content_object (CamelMedium *medium)
+camel_medium_get_content (CamelMedium *medium)
{
g_return_val_if_fail (CAMEL_IS_MEDIUM (medium), NULL);
- return CM_CLASS (medium)->get_content_object (medium);
+ return CM_CLASS (medium)->get_content (medium);
}
static void
-set_content_object (CamelMedium *medium, CamelDataWrapper *content)
+set_content (CamelMedium *medium, CamelDataWrapper *content)
{
if (medium->content)
camel_object_unref (medium->content);
}
/**
- * camel_medium_set_content_object:
+ * camel_medium_set_content:
* @medium: a #CamelMedium object
* @content: a #CamelDataWrapper object
*
* Sets the content of @medium to be @content.
**/
void
-camel_medium_set_content_object (CamelMedium *medium,
+camel_medium_set_content (CamelMedium *medium,
CamelDataWrapper *content)
{
g_return_if_fail (CAMEL_IS_MEDIUM (medium));
g_return_if_fail (CAMEL_IS_DATA_WRAPPER (content));
- CM_CLASS (medium)->set_content_object (medium, content);
+ CM_CLASS (medium)->set_content (medium, content);
}
G_BEGIN_DECLS
+typedef struct _CamelMedium CamelMedium;
+typedef struct _CamelMediumClass CamelMediumClass;
+
typedef struct {
const gchar *name;
const gchar *value;
} CamelMediumHeader;
struct _CamelMedium {
- CamelDataWrapper parent_object;
+ CamelDataWrapper parent;
/* The content of the medium, as opposed to our parent
* CamelDataWrapper, which wraps both the headers and the
CamelDataWrapper *content;
};
-typedef struct {
+struct _CamelMediumClass {
CamelDataWrapperClass parent_class;
- /* Virtual methods */
- void (*add_header) (CamelMedium *medium, const gchar *name, gconstpointer value);
- void (*set_header) (CamelMedium *medium, const gchar *name, gconstpointer value);
- void (*remove_header) (CamelMedium *medium, const gchar *name);
- gconstpointer (*get_header) (CamelMedium *medium, const gchar *name);
-
- GArray * (*get_headers) (CamelMedium *medium);
- void (*free_headers) (CamelMedium *medium, GArray *headers);
-
- CamelDataWrapper * (*get_content_object) (CamelMedium *medium);
- void (*set_content_object) (CamelMedium *medium, CamelDataWrapper *content);
-} CamelMediumClass;
-
-/* Standard Camel function */
-CamelType camel_medium_get_type (void);
-
-/* Header get/set interface */
-void camel_medium_add_header (CamelMedium *medium, const gchar *name, gconstpointer value);
-void camel_medium_set_header (CamelMedium *medium, const gchar *name, gconstpointer value);
-void camel_medium_remove_header (CamelMedium *medium, const gchar *name);
-gconstpointer camel_medium_get_header (CamelMedium *medium, const gchar *name);
-
-GArray *camel_medium_get_headers (CamelMedium *medium);
-void camel_medium_free_headers (CamelMedium *medium, GArray *headers);
+ void (*add_header) (CamelMedium *medium,
+ const gchar *name,
+ gconstpointer value);
+ void (*set_header) (CamelMedium *medium,
+ const gchar *name,
+ gconstpointer value);
+ void (*remove_header) (CamelMedium *medium,
+ const gchar *name);
+ gconstpointer (*get_header) (CamelMedium *medium,
+ const gchar *name);
+ GArray * (*get_headers) (CamelMedium *medium);
+ void (*free_headers) (CamelMedium *medium,
+ GArray *headers);
+ CamelDataWrapper *
+ (*get_content) (CamelMedium *medium);
+ void (*set_content) (CamelMedium *medium,
+ CamelDataWrapper *content);
+};
-/* accessor methods */
-CamelDataWrapper *camel_medium_get_content_object (CamelMedium *medium);
-void camel_medium_set_content_object (CamelMedium *medium,
- CamelDataWrapper *content);
+CamelType camel_medium_get_type (void);
+void camel_medium_add_header (CamelMedium *medium,
+ const gchar *name,
+ gconstpointer value);
+void camel_medium_set_header (CamelMedium *medium,
+ const gchar *name,
+ gconstpointer value);
+void camel_medium_remove_header (CamelMedium *medium,
+ const gchar *name);
+gconstpointer camel_medium_get_header (CamelMedium *medium,
+ const gchar *name);
+GArray * camel_medium_get_headers (CamelMedium *medium);
+void camel_medium_free_headers (CamelMedium *medium,
+ GArray *headers);
+CamelDataWrapper *
+ camel_medium_get_content (CamelMedium *medium);
+void camel_medium_set_content (CamelMedium *medium,
+ CamelDataWrapper *content);
G_END_DECLS
/**
* camel_mime_filter_basic_new:
- *
- * Create a new #CamelMimeFilterBasic object.
- *
- * Returns: a new #CamelMimeFilterBasic object
- **/
-CamelMimeFilterBasic *
-camel_mime_filter_basic_new (void)
-{
- CamelMimeFilterBasic *new = CAMEL_MIME_FILTER_BASIC ( camel_object_new (camel_mime_filter_basic_get_type ()));
- return new;
-}
-
-/**
- * camel_mime_filter_basic_new_type:
* @type: a #CamelMimeFilterBasicType type
*
* Create a new #CamelMimeFilterBasic object of type @type.
*
* Returns: a new #CamelMimeFilterBasic object
**/
-CamelMimeFilterBasic *
-camel_mime_filter_basic_new_type(CamelMimeFilterBasicType type)
+CamelMimeFilter *
+camel_mime_filter_basic_new (CamelMimeFilterBasicType type)
{
- CamelMimeFilterBasic *new;
+ CamelMimeFilter *new;
switch (type) {
case CAMEL_MIME_FILTER_BASIC_BASE64_ENC:
case CAMEL_MIME_FILTER_BASIC_QP_DEC:
case CAMEL_MIME_FILTER_BASIC_UU_ENC:
case CAMEL_MIME_FILTER_BASIC_UU_DEC:
- new = camel_mime_filter_basic_new();
- new->type = type;
+ new = camel_mime_filter_basic_new (type);
break;
default:
g_warning ("Invalid type of CamelMimeFilterBasic requested: %u", type);
new = NULL;
break;
}
- camel_mime_filter_reset((CamelMimeFilter *)new);
+ camel_mime_filter_reset (new);
return new;
}
G_BEGIN_DECLS
+typedef struct _CamelMimeFilterBasic CamelMimeFilterBasic;
typedef struct _CamelMimeFilterBasicClass CamelMimeFilterBasicClass;
+typedef struct _CamelMimeFilterBasicPrivate CamelMimeFilterBasicPrivate;
typedef enum {
CAMEL_MIME_FILTER_BASIC_BASE64_ENC = 1,
struct _CamelMimeFilterBasic {
CamelMimeFilter parent;
-
- struct _CamelMimeFilterBasicPrivate *priv;
+ CamelMimeFilterBasicPrivate *priv;
CamelMimeFilterBasicType type;
CamelMimeFilterClass parent_class;
};
-CamelType camel_mime_filter_basic_get_type (void);
-CamelMimeFilterBasic *camel_mime_filter_basic_new (void);
-CamelMimeFilterBasic *camel_mime_filter_basic_new_type (CamelMimeFilterBasicType type);
+CamelType camel_mime_filter_basic_get_type(void);
+CamelMimeFilter *
+ camel_mime_filter_basic_new (CamelMimeFilterBasicType type);
G_END_DECLS
*
* Returns: a new #CamelMimeFilterBestenc object
**/
-CamelMimeFilterBestenc *
+CamelMimeFilter *
camel_mime_filter_bestenc_new (guint flags)
{
CamelMimeFilterBestenc *new = (CamelMimeFilterBestenc *)camel_object_new(camel_mime_filter_bestenc_get_type());
new->flags = flags;
- return new;
+ return CAMEL_MIME_FILTER (new);
}
/**
G_BEGIN_DECLS
+typedef struct _CamelMimeFilterBestenc CamelMimeFilterBestenc;
typedef struct _CamelMimeFilterBestencClass CamelMimeFilterBestencClass;
typedef enum _CamelBestencRequired {
CamelMimeFilterClass parent_class;
};
-CamelType camel_mime_filter_bestenc_get_type (void);
-CamelMimeFilterBestenc *camel_mime_filter_bestenc_new (guint flags);
-
-CamelTransferEncoding camel_mime_filter_bestenc_get_best_encoding(CamelMimeFilterBestenc *filter, CamelBestencEncoding required);
-const gchar * camel_mime_filter_bestenc_get_best_charset(CamelMimeFilterBestenc *filter);
-void camel_mime_filter_bestenc_set_flags(CamelMimeFilterBestenc *filter, guint flags);
+CamelType camel_mime_filter_bestenc_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_bestenc_new (guint flags);
+CamelTransferEncoding
+ camel_mime_filter_bestenc_get_best_encoding
+ (CamelMimeFilterBestenc *filter,
+ CamelBestencEncoding required);
+const gchar * camel_mime_filter_bestenc_get_best_charset
+ (CamelMimeFilterBestenc *filter);
+void camel_mime_filter_bestenc_set_flags
+ (CamelMimeFilterBestenc *filter,
+ guint flags);
G_END_DECLS
CamelMimeFilterClass parent_class;
};
-CamelType camel_mime_filter_canon_get_type (void);
+CamelType camel_mime_filter_canon_get_type(void);
-CamelMimeFilter *camel_mime_filter_canon_new(guint32 flags);
+CamelMimeFilter *
+ camel_mime_filter_canon_new (guint32 flags);
G_END_DECLS
}
/**
- * camel_mime_filter_charset_new:
- *
- * Create a new #CamelMimeFilterCharset object.
- *
- * Returns: a new #CamelMimeFilterCharset object
- **/
-CamelMimeFilterCharset *
-camel_mime_filter_charset_new (void)
-{
- return CAMEL_MIME_FILTER_CHARSET (camel_object_new (camel_mime_filter_charset_get_type ()));
-}
-
-/**
* camel_mime_filter_charset_new_convert:
* @from_charset: charset to convert from
* @to_charset: charset to convert to
*
* Returns: a new #CamelMimeFilterCharset object
**/
-CamelMimeFilterCharset *
-camel_mime_filter_charset_new_convert (const gchar *from_charset, const gchar *to_charset)
+CamelMimeFilter *
+camel_mime_filter_charset_new (const gchar *from_charset,
+ const gchar *to_charset)
{
CamelMimeFilterCharset *new;
new->to = g_strdup (to_charset);
}
- return new;
+ return CAMEL_MIME_FILTER (new);
}
G_BEGIN_DECLS
+typedef struct _CamelMimeFilterCharset CamelMimeFilterCharset;
typedef struct _CamelMimeFilterCharsetClass CamelMimeFilterCharsetClass;
struct _CamelMimeFilterCharset {
CamelMimeFilterClass parent_class;
};
-CamelType camel_mime_filter_charset_get_type (void);
-CamelMimeFilterCharset *camel_mime_filter_charset_new (void);
-
-CamelMimeFilterCharset *camel_mime_filter_charset_new_convert (const gchar *from_charset, const gchar *to_charset);
+CamelType camel_mime_filter_charset_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_charset_new (const gchar *from_charset,
+ const gchar *to_charset);
G_END_DECLS
G_BEGIN_DECLS
+typedef struct _CamelMimeFilterCRLF CamelMimeFilterCRLF;
typedef struct _CamelMimeFilterCRLFClass CamelMimeFilterCRLFClass;
typedef enum {
CamelMimeFilterClass parent_class;
};
-CamelType camel_mime_filter_crlf_get_type (void);
-
-CamelMimeFilter *camel_mime_filter_crlf_new (CamelMimeFilterCRLFDirection direction, CamelMimeFilterCRLFMode mode);
+CamelType camel_mime_filter_crlf_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_crlf_new (CamelMimeFilterCRLFDirection direction,
+ CamelMimeFilterCRLFMode mode);
G_END_DECLS
typedef gchar * (*EnrichedParamParser) (const gchar *inptr, gint inlen);
-static gchar *param_parse_colour (const gchar *inptr, gint inlen);
+static gchar *param_parse_color (const gchar *inptr, gint inlen);
static gchar *param_parse_font (const gchar *inptr, gint inlen);
static gchar *param_parse_lang (const gchar *inptr, gint inlen);
{ "np", "<hr>", FALSE, NULL },
{ "fontfamily", "<font face=\"%s\">", TRUE, param_parse_font },
{ "/fontfamily", "</font>", FALSE, NULL },
- { "color", "<font color=\"%s\">", TRUE, param_parse_colour },
+ { "color", "<font color=\"%s\">", TRUE, param_parse_color },
{ "/color", "</font>", FALSE, NULL },
{ "lang", "<span lang=\"%s\">", TRUE, param_parse_lang },
{ "/lang", "</span>", FALSE, NULL },
return strstr (tag, "%s") != NULL;
}
-static const gchar *valid_colours[] = {
+static const gchar *valid_colors[] = {
"red", "green", "blue", "yellow", "cyan", "magenta", "black", "white"
};
static gchar *
-param_parse_colour (const gchar *inptr, gint inlen)
+param_parse_color (const gchar *inptr, gint inlen)
{
const gchar *inend, *end;
guint32 rgb = 0;
guint v;
gint i;
- for (i = 0; i < G_N_ELEMENTS (valid_colours); i++) {
- if (!g_ascii_strncasecmp (inptr, valid_colours[i], inlen))
- return g_strdup (valid_colours[i]);
+ for (i = 0; i < G_N_ELEMENTS (valid_colors); i++) {
+ if (!g_ascii_strncasecmp (inptr, valid_colors[i], inlen))
+ return g_strdup (valid_colors[i]);
}
/* check for numeric r/g/b in the format: ####,####,#### */
if (inptr[4] != ',' || inptr[9] != ',') {
/* okay, mailer must have used a string name that
* rfc1896 did not specify? do some simple scanning
- * action, a colour name MUST be [a-zA-Z] */
+ * action, a color name MUST be [a-zA-Z] */
end = inptr;
inend = inptr + inlen;
while (end < inend && ((*end >= 'a' && *end <= 'z') || (*end >= 'A' && *end <= 'Z')))
invalid_format:
- /* default colour? */
+ /* default color? */
return g_strdup ("black");
}
typedef struct _CamelMimeFilterEnrichedClass CamelMimeFilterEnrichedClass;
struct _CamelMimeFilterEnriched {
- CamelMimeFilter parent_object;
+ CamelMimeFilter parent;
guint32 flags;
gint nofill;
struct _CamelMimeFilterEnrichedClass {
CamelMimeFilterClass parent_class;
-
};
-CamelType camel_mime_filter_enriched_get_type (void);
-
-CamelMimeFilter *camel_mime_filter_enriched_new (guint32 flags);
-gchar *camel_enriched_to_html(const gchar *in, guint32 flags);
+CamelType camel_mime_filter_enriched_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_enriched_new (guint32 flags);
+gchar * camel_enriched_to_html (const gchar *in,
+ guint32 flags);
G_END_DECLS
*
* Returns: a new #CamelMimeFilterFrom object
**/
-CamelMimeFilterFrom *
+CamelMimeFilter*
camel_mime_filter_from_new (void)
{
- CamelMimeFilterFrom *new = CAMEL_MIME_FILTER_FROM ( camel_object_new (camel_mime_filter_from_get_type ()));
- return new;
+ return (CamelMimeFilter *) camel_object_new (camel_mime_filter_from_get_type ());
}
#if 0
CamelMimeFilterClass parent_class;
};
-CamelType camel_mime_filter_from_get_type (void);
-CamelMimeFilterFrom *camel_mime_filter_from_new (void);
+CamelType camel_mime_filter_from_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_from_new (void);
G_END_DECLS
} CamelMimeFilterGZipMode;
struct _CamelMimeFilterGZip {
- CamelMimeFilter parent_object;
+ CamelMimeFilter parent;
struct _CamelMimeFilterGZipPrivate *priv;
struct _CamelMimeFilterGZipClass {
CamelMimeFilterClass parent_class;
-
};
-CamelType camel_mime_filter_gzip_get_type (void);
-
-CamelMimeFilter *camel_mime_filter_gzip_new (CamelMimeFilterGZipMode mode, gint level);
+CamelType camel_mime_filter_gzip_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_gzip_new (CamelMimeFilterGZipMode mode,
+ gint level);
G_END_DECLS
*
* Returns: a new #CamelMimeFilterHTML object
**/
-CamelMimeFilterHTML *
+CamelMimeFilter *
camel_mime_filter_html_new (void)
{
- CamelMimeFilterHTML *new = CAMEL_MIME_FILTER_HTML ( camel_object_new (camel_mime_filter_html_get_type ()));
- return new;
+ return (CamelMimeFilter *) camel_object_new (camel_mime_filter_html_get_type ());
}
G_BEGIN_DECLS
-typedef struct _CamelMimeFilterHTMLClass CamelMimeFilterHTMLClass;
typedef struct _CamelMimeFilterHTML CamelMimeFilterHTML;
+typedef struct _CamelMimeFilterHTMLClass CamelMimeFilterHTMLClass;
+typedef struct _CamelMimeFilterHTMLPrivate CamelMimeFilterHTMLPrivate;
struct _CamelMimeFilterHTML {
CamelMimeFilter parent;
-
- struct _CamelMimeFilterHTMLPrivate *priv;
+ CamelMimeFilterHTMLPrivate *priv;
};
struct _CamelMimeFilterHTMLClass {
CamelMimeFilterClass parent_class;
};
-CamelType camel_mime_filter_html_get_type (void);
-CamelMimeFilterHTML *camel_mime_filter_html_new (void);
+CamelType camel_mime_filter_html_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_html_new (void);
G_END_DECLS
/**
* camel_mime_filter_index_new:
- *
- * Create a new #CamelMimeFilterIndex object
- *
- * Returns: a new #CamelMimeFilterIndex object
- **/
-CamelMimeFilterIndex *
-camel_mime_filter_index_new (void)
-{
- CamelMimeFilterIndex *new = CAMEL_MIME_FILTER_INDEX ( camel_object_new (camel_mime_filter_index_get_type ()));
- return new;
-}
-
-/**
- * camel_mime_filter_index_new_index:
* @index: a #CamelIndex object
*
* Create a new #CamelMimeFilterIndex based on @index.
*
* Returns: a new #CamelMimeFilterIndex object
**/
-CamelMimeFilterIndex *
-camel_mime_filter_index_new_index (CamelIndex *index)
+CamelMimeFilter *
+camel_mime_filter_index_new (CamelIndex *index)
{
- CamelMimeFilterIndex *new = camel_mime_filter_index_new();
+ CamelMimeFilterIndex *new;
+
+ new = CAMEL_MIME_FILTER_INDEX (camel_object_new (camel_mime_filter_index_get_type ()));
if (new) {
new->index = index;
if (index)
camel_object_ref (index);
}
- return new;
+ return CAMEL_MIME_FILTER (new);
}
/* Set the match name for any indexed words */
#ifndef CAMEL_MIME_FILTER_INDEX_H
#define CAMEL_MIME_FILTER_INDEX_H
+#include <camel/camel-index.h>
#include <camel/camel-mime-filter.h>
#define CAMEL_MIME_FILTER_INDEX(obj) CAMEL_CHECK_CAST (obj, camel_mime_filter_index_get_type (), CamelMimeFilterIndex)
G_BEGIN_DECLS
+typedef struct _CamelMimeFilterIndex CamelMimeFilterIndex;
typedef struct _CamelMimeFilterIndexClass CamelMimeFilterIndexClass;
+typedef struct _CamelMimeFilterIndexPrivate CamelMimeFilterIndexPrivate;
struct _CamelMimeFilterIndex {
CamelMimeFilter parent;
+ CamelMimeFilterIndexPrivate *priv;
- struct _CamelMimeFilterIndexPrivate *priv;
-
- struct _CamelIndex *index;
- struct _CamelIndexName *name;
+ CamelIndex *index;
+ CamelIndexName *name;
};
struct _CamelMimeFilterIndexClass {
CamelMimeFilterClass parent_class;
};
-CamelType camel_mime_filter_index_get_type (void);
-CamelMimeFilterIndex *camel_mime_filter_index_new (void);
-
-CamelMimeFilterIndex *camel_mime_filter_index_new_index(struct _CamelIndex *index);
+CamelType 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, struct _CamelIndexName *name);
-void camel_mime_filter_index_set_index (CamelMimeFilterIndex *filter, struct _CamelIndex *index);
+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
CAMEL_MIME_FILTER_LINEWRAP_WORD = (1<<1), /* indents on word boundary */
};
+typedef struct _CamelMimeFilterLinewrap CamelMimeFilterLinewrap;
typedef struct _CamelMimeFilterLinewrapClass CamelMimeFilterLinewrapClass;
struct _CamelMimeFilterLinewrap {
CamelMimeFilterClass parent_class;
};
-CamelType camel_mime_filter_linewrap_get_type (void);
-
-CamelMimeFilter *camel_mime_filter_linewrap_new (guint preferred_len, guint max_len, gchar indent_char, guint32 flags);
+CamelType camel_mime_filter_linewrap_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_linewrap_new (guint preferred_len,
+ guint max_len,
+ gchar indent_char,
+ guint32 flags);
G_END_DECLS
G_BEGIN_DECLS
-typedef struct _CamelMimeFilterPgp {
+typedef struct _CamelMimeFilterPgp CamelMimeFilterPgp;
+typedef struct _CamelMimeFilterPgpClass CamelMimeFilterPgpClass;
+
+struct _CamelMimeFilterPgp {
CamelMimeFilter filter;
gint state;
-} CamelMimeFilterPgp;
+};
-typedef struct _CamelMimeFilterPgpClass {
+struct _CamelMimeFilterPgpClass {
CamelMimeFilterClass parent_class;
-} CamelMimeFilterPgpClass;
-
-CamelType camel_mime_filter_pgp_get_type (void);
+};
-CamelMimeFilter *camel_mime_filter_pgp_new(void);
+CamelType camel_mime_filter_pgp_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_pgp_new (void);
G_END_DECLS
G_BEGIN_DECLS
-typedef struct _CamelMimeFilterProgressClass CamelMimeFilterProgressClass;
typedef struct _CamelMimeFilterProgress CamelMimeFilterProgress;
+typedef struct _CamelMimeFilterProgressClass CamelMimeFilterProgressClass;
/**
* CamelMimeFilterProgress:
struct _CamelMimeFilterProgressClass {
CamelMimeFilterClass parent_class;
-
};
-CamelType camel_mime_filter_progress_get_type (void);
-
-CamelMimeFilter *camel_mime_filter_progress_new (CamelOperation *operation, gsize total);
+CamelType camel_mime_filter_progress_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_progress_new (CamelOperation *operation,
+ gsize total);
G_END_DECLS
/**
* camel_mime_filter_save_new:
- *
- * Create a new #CamelMimeFilterSave filter object.
- *
- * Returns: a new #CamelMimeFilterSave object
- **/
-CamelMimeFilter *
-camel_mime_filter_save_new (void)
-{
- CamelMimeFilterSave *save = CAMEL_MIME_FILTER_SAVE (camel_object_new (CAMEL_MIME_FILTER_SAVE_TYPE));
-
- save->stream = camel_stream_mem_new ();
-
- return (CamelMimeFilter *) save;
-}
-
-/**
- * camel_mime_filter_save_new_with_stream:
* @stream: a #CamelStream object
*
* Create a new #CamelMimeFilterSave filter object that will save a
* Returns: a new #CamelMimeFilterSave object
**/
CamelMimeFilter *
-camel_mime_filter_save_new_with_stream (CamelStream *stream)
+camel_mime_filter_save_new (CamelStream *stream)
{
CamelMimeFilterSave *save = CAMEL_MIME_FILTER_SAVE (camel_object_new (CAMEL_MIME_FILTER_SAVE_TYPE));
G_BEGIN_DECLS
+typedef struct _CamelMimeFilterSave CamelMimeFilterSave;
typedef struct _CamelMimeFilterSaveClass CamelMimeFilterSaveClass;
struct _CamelMimeFilterSave {
CamelMimeFilterClass parent_class;
};
-CamelType camel_mime_filter_save_get_type (void);
-
-CamelMimeFilter *camel_mime_filter_save_new (void);
-CamelMimeFilter *camel_mime_filter_save_new_with_stream (CamelStream *stream);
+CamelType camel_mime_filter_save_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_save_new (CamelStream *stream);
G_END_DECLS
filter->scanner = camel_url_scanner_new ();
filter->flags = 0;
- filter->colour = 0;
+ filter->color = 0;
filter->column = 0;
filter->pre_open = FALSE;
}
if (html->flags & CAMEL_MIME_FILTER_TOHTML_MARK_CITATION) {
if ((depth = citation_depth (start)) > 0) {
- /* FIXME: we could easily support multiple colour depths here */
+ /* FIXME: we could easily support multiple color depths here */
outptr = check_size (filter, outptr, &outend, 25);
- outptr += sprintf(outptr, "<font color=\"#%06x\">", (html->colour & 0xffffff));
+ outptr += sprintf(outptr, "<font color=\"#%06x\">", (html->color & 0xffffff));
}
#if FOOLISHLY_UNMUNGE_FROM
else if (*start == '>') {
/**
* camel_mime_filter_tohtml_new:
* @flags: bitwise flags defining the behaviour
- * @colour: colour to use when highlighting quoted text
+ * @color: color to use when highlighting quoted text
*
* Create a new #CamelMimeFilterToHTML object to convert plain text
* into HTML.
* Returns: a new #CamelMimeFilterToHTML object
**/
CamelMimeFilter *
-camel_mime_filter_tohtml_new (guint32 flags, guint32 colour)
+camel_mime_filter_tohtml_new (guint32 flags, guint32 color)
{
CamelMimeFilterToHTML *new;
gint i;
new = CAMEL_MIME_FILTER_TOHTML (camel_object_new (camel_mime_filter_tohtml_get_type ()));
new->flags = flags;
- new->colour = colour;
+ new->color = color;
for (i = 0; i < G_N_ELEMENTS (patterns); i++) {
if (patterns[i].mask & flags)
* camel_text_to_html:
* @in: input text
* @flags: bitwise flags defining the html conversion behaviour
- * @colour: colour to use when syntax highlighting
+ * @color: color to use when syntax highlighting
*
* Convert @in from plain text into HTML.
*
* of @in
**/
gchar *
-camel_text_to_html (const gchar *in, guint32 flags, guint32 colour)
+camel_text_to_html (const gchar *in, guint32 flags, guint32 color)
{
CamelMimeFilter *filter;
gsize outlen, outpre;
g_return_val_if_fail (in != NULL, NULL);
- filter = camel_mime_filter_tohtml_new (flags, colour);
+ filter = camel_mime_filter_tohtml_new (flags, color);
camel_mime_filter_complete (filter, (gchar *) in, strlen (in), 0,
&outbuf, &outlen, &outpre);
G_BEGIN_DECLS
-typedef struct _CamelMimeFilterToHTMLClass CamelMimeFilterToHTMLClass;
typedef struct _CamelMimeFilterToHTML CamelMimeFilterToHTML;
+typedef struct _CamelMimeFilterToHTMLClass CamelMimeFilterToHTMLClass;
struct _CamelMimeFilterToHTML {
CamelMimeFilter parent;
struct _CamelUrlScanner *scanner;
guint32 flags;
- guint32 colour;
+ guint32 color;
guint32 column : 31;
guint32 pre_open : 1;
CamelMimeFilterClass parent_class;
};
-CamelType camel_mime_filter_tohtml_get_type (void);
-
-CamelMimeFilter *camel_mime_filter_tohtml_new (guint32 flags, guint32 colour);
+CamelType camel_mime_filter_tohtml_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_tohtml_new (guint32 flags,
+ guint32 color);
/* utility functions to replace e_text_to_html */
-gchar *camel_text_to_html (const gchar *in, guint32 flags, guint32 colour);
+gchar * camel_text_to_html (const gchar *in,
+ guint32 flags,
+ guint32 color);
G_END_DECLS
G_BEGIN_DECLS
-typedef struct _CamelMimeFilterWindowsClass CamelMimeFilterWindowsClass;
typedef struct _CamelMimeFilterWindows CamelMimeFilterWindows;
+typedef struct _CamelMimeFilterWindowsClass CamelMimeFilterWindowsClass;
struct _CamelMimeFilterWindows {
CamelMimeFilter parent;
struct _CamelMimeFilterWindowsClass {
CamelMimeFilterClass parent_class;
-
};
-CamelType camel_mime_filter_windows_get_type (void);
-
-CamelMimeFilter *camel_mime_filter_windows_new (const gchar *claimed_charset);
-
-gboolean camel_mime_filter_windows_is_windows_charset (CamelMimeFilterWindows *filter);
-const gchar *camel_mime_filter_windows_real_charset (CamelMimeFilterWindows *filter);
+CamelType camel_mime_filter_windows_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_windows_new
+ (const gchar *claimed_charset);
+gboolean camel_mime_filter_windows_is_windows_charset
+ (CamelMimeFilterWindows *filter);
+const gchar * camel_mime_filter_windows_real_charset
+ (CamelMimeFilterWindows *filter);
G_END_DECLS
#define CAMEL_MIME_YENCODE_CRC_FINAL(crc) (~crc)
struct _CamelMimeFilterYenc {
- CamelMimeFilter parent_object;
+ CamelMimeFilter parent;
CamelMimeFilterYencDirection direction;
struct _CamelMimeFilterYencClass {
CamelMimeFilterClass parent_class;
-
};
-CamelType camel_mime_filter_yenc_get_type (void);
-
-CamelMimeFilter *camel_mime_filter_yenc_new (CamelMimeFilterYencDirection direction);
-
-void camel_mime_filter_yenc_set_state (CamelMimeFilterYenc *yenc, gint state);
-void camel_mime_filter_yenc_set_crc (CamelMimeFilterYenc *yenc, guint32 crc);
-
-/*int camel_mime_filter_yenc_get_part (CamelMimeFilterYenc *yenc);*/
-guint32 camel_mime_filter_yenc_get_pcrc (CamelMimeFilterYenc *yenc);
-guint32 camel_mime_filter_yenc_get_crc (CamelMimeFilterYenc *yenc);
-
-gsize camel_ydecode_step (const guchar *in, gsize inlen, guchar *out,
- gint *state, guint32 *pcrc, guint32 *crc);
-gsize camel_yencode_step (const guchar *in, gsize inlen, guchar *out,
- gint *state, guint32 *pcrc, guint32 *crc);
-gsize camel_yencode_close (const guchar *in, gsize inlen, guchar *out,
- gint *state, guint32 *pcrc, guint32 *crc);
+CamelType camel_mime_filter_yenc_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_yenc_new (CamelMimeFilterYencDirection direction);
+void camel_mime_filter_yenc_set_state(CamelMimeFilterYenc *yenc,
+ gint state);
+void camel_mime_filter_yenc_set_crc (CamelMimeFilterYenc *yenc,
+ guint32 crc);
+guint32 camel_mime_filter_yenc_get_pcrc (CamelMimeFilterYenc *yenc);
+guint32 camel_mime_filter_yenc_get_crc (CamelMimeFilterYenc *yenc);
+
+gsize camel_ydecode_step (const guchar *in,
+ gsize inlen,
+ guchar *out,
+ gint *state,
+ guint32 *pcrc,
+ guint32 *crc);
+gsize camel_yencode_step (const guchar *in,
+ gsize inlen,
+ guchar *out,
+ gint *state,
+ guint32 *pcrc,
+ guint32 *crc);
+gsize camel_yencode_close (const guchar *in,
+ gsize inlen,
+ guchar *out,
+ gint *state,
+ guint32 *pcrc,
+ guint32 *crc);
G_END_DECLS
G_BEGIN_DECLS
+typedef struct _CamelMimeFilter CamelMimeFilter;
typedef struct _CamelMimeFilterClass CamelMimeFilterClass;
+typedef struct _CamelMimeFilterPrivate CamelMimeFilterPrivate;
struct _CamelMimeFilter {
CamelObject parent;
-
- struct _CamelMimeFilterPrivate *priv;
+ CamelMimeFilterPrivate *priv;
gchar *outreal; /* real malloc'd buffer */
gchar *outbuf; /* first 'writable' position allowed (outreal + outpre) */
struct _CamelMimeFilterClass {
CamelObjectClass parent_class;
- /* virtual functions */
- void (*filter)(CamelMimeFilter *f,
- const gchar *in, gsize len, gsize prespace,
- gchar **out, gsize *outlen, gsize *outprespace);
- void (*complete)(CamelMimeFilter *f,
- const gchar *in, gsize len, gsize prespace,
- gchar **out, gsize *outlen, gsize *outprespace);
- void (*reset)(CamelMimeFilter *f);
+ void (*filter) (CamelMimeFilter *filter,
+ const gchar *in,
+ gsize len,
+ gsize prespace,
+ gchar **out,
+ gsize *outlen,
+ gsize *outprespace);
+ void (*complete) (CamelMimeFilter *filter,
+ const gchar *in,
+ gsize len,
+ gsize prespace,
+ gchar **out,
+ gsize *outlen,
+ gsize *outprespace);
+ void (*reset) (CamelMimeFilter *filter);
};
-CamelType camel_mime_filter_get_type (void);
-CamelMimeFilter *camel_mime_filter_new (void);
-
-void camel_mime_filter_filter(CamelMimeFilter *filter,
- const gchar *in, gsize len, gsize prespace,
- gchar **out, gsize *outlen, gsize *outprespace);
-
-void camel_mime_filter_complete(CamelMimeFilter *filter,
- const gchar *in, gsize len, gsize prespace,
- gchar **out, gsize *outlen, gsize *outprespace);
-
-void camel_mime_filter_reset(CamelMimeFilter *filter);
+CamelType camel_mime_filter_get_type (void);
+CamelMimeFilter *
+ camel_mime_filter_new (void);
+void camel_mime_filter_filter (CamelMimeFilter *filter,
+ const gchar *in,
+ gsize len,
+ gsize prespace,
+ gchar **out,
+ gsize *outlen,
+ gsize *outprespace);
+void camel_mime_filter_complete (CamelMimeFilter *filter,
+ const gchar *in,
+ gsize len,
+ gsize prespace,
+ gchar **out,
+ gsize *outlen,
+ gsize *outprespace);
+void camel_mime_filter_reset (CamelMimeFilter *filter);
/* sets/returns number of bytes backed up on the input */
-void camel_mime_filter_backup(CamelMimeFilter *filter, const gchar *data, gsize length);
+void camel_mime_filter_backup (CamelMimeFilter *filter,
+ const gchar *data,
+ gsize length);
/* ensure this much size available for filter output */
-void camel_mime_filter_set_size(CamelMimeFilter *filter, gsize size, gint keep);
+void camel_mime_filter_set_size (CamelMimeFilter *filter,
+ gsize size,
+ gint keep);
G_END_DECLS
* Set the Reply-To of a message.
**/
void
-camel_mime_message_set_reply_to (CamelMimeMessage *msg, const CamelInternetAddress *reply_to)
+camel_mime_message_set_reply_to (CamelMimeMessage *msg, CamelInternetAddress *reply_to)
{
gchar *addr;
*
* Returns: the Reply-Toa ddress of the message
**/
-const CamelInternetAddress *
+CamelInternetAddress *
camel_mime_message_get_reply_to (CamelMimeMessage *mime_message)
{
g_assert (mime_message);
* Set the from address of a message.
**/
void
-camel_mime_message_set_from (CamelMimeMessage *msg, const CamelInternetAddress *from)
+camel_mime_message_set_from (CamelMimeMessage *msg, CamelInternetAddress *from)
{
gchar *addr;
*
* Returns: the from address of the message
**/
-const CamelInternetAddress *
+CamelInternetAddress *
camel_mime_message_get_from (CamelMimeMessage *mime_message)
{
g_assert (mime_message);
* Set the recipients of a message.
**/
void
-camel_mime_message_set_recipients(CamelMimeMessage *mime_message, const gchar *type, const CamelInternetAddress *r)
+camel_mime_message_set_recipients(CamelMimeMessage *mime_message, const gchar *type, CamelInternetAddress *r)
{
gchar *text;
CamelInternetAddress *addr;
}
/* note this does copy, and not append (cat) */
- camel_address_copy ((CamelAddress *)addr, (const CamelAddress *)r);
+ camel_address_copy ((CamelAddress *)addr, (CamelAddress *)r);
/* and sync our headers */
text = camel_address_encode (CAMEL_ADDRESS (addr));
*
* Returns: the requested recipients
**/
-const CamelInternetAddress *
+CamelInternetAddress *
camel_mime_message_get_recipients (CamelMimeMessage *mime_message, const gchar *type)
{
g_assert(mime_message);
if (callback (msg, part, data) == FALSE)
return FALSE;
- containee = camel_medium_get_content_object (CAMEL_MEDIUM (part));
+ containee = camel_medium_get_content (CAMEL_MEDIUM (part));
if (containee == NULL)
return go;
static CamelTransferEncoding
find_best_encoding (CamelMimePart *part, CamelBestencRequired required, CamelBestencEncoding enctype, gchar **charsetp)
{
- CamelMimeFilterCharset *charenc = NULL;
+ CamelMimeFilter *charenc = NULL;
CamelTransferEncoding encoding;
- CamelMimeFilterBestenc *bestenc;
+ CamelMimeFilter *bestenc;
guint flags, callerflags;
CamelDataWrapper *content;
- CamelStreamFilter *filter;
+ CamelStream *filter;
const gchar *charsetin = NULL;
gchar *charset = NULL;
CamelStream *null;
d(printf("starting to check part\n"));
- content = camel_medium_get_content_object ((CamelMedium *)part);
+ content = camel_medium_get_content ((CamelMedium *)part);
if (content == NULL) {
/* charset might not be right here, but it'll get the right stuff
if it is ever set */
/* first a null stream, so any filtering is thrown away; we only want the sideeffects */
null = (CamelStream *)camel_stream_null_new ();
- filter = camel_stream_filter_new_with_stream (null);
+ filter = camel_stream_filter_new (null);
/* if we're looking for the best charset, then we need to convert to UTF-8 */
if (istext && (required & CAMEL_BESTENC_GET_CHARSET) != 0
&& (charsetin = camel_content_type_param (content->mime_type, "charset"))) {
- charenc = camel_mime_filter_charset_new_convert (charsetin, "UTF-8");
+ charenc = camel_mime_filter_charset_new (charsetin, "UTF-8");
if (charenc != NULL)
- idc = camel_stream_filter_add (filter, (CamelMimeFilter *)charenc);
+ idc = camel_stream_filter_add (
+ CAMEL_STREAM_FILTER (filter), charenc);
charsetin = NULL;
}
bestenc = camel_mime_filter_bestenc_new (flags);
- idb = camel_stream_filter_add (filter, (CamelMimeFilter *)bestenc);
+ idb = camel_stream_filter_add (
+ CAMEL_STREAM_FILTER (filter), bestenc);
d(printf("writing to checking stream\n"));
camel_data_wrapper_decode_to_stream (content, (CamelStream *)filter);
- camel_stream_filter_remove (filter, idb);
+ camel_stream_filter_remove (
+ CAMEL_STREAM_FILTER (filter), idb);
if (idc != -1) {
- camel_stream_filter_remove (filter, idc);
+ camel_stream_filter_remove (CAMEL_STREAM_FILTER (filter), idc);
camel_object_unref (charenc);
charenc = NULL;
}
if (istext && (required & CAMEL_BESTENC_GET_CHARSET) != 0) {
- charsetin = camel_mime_filter_bestenc_get_best_charset (bestenc);
+ charsetin = camel_mime_filter_bestenc_get_best_charset (
+ CAMEL_MIME_FILTER_BESTENC (bestenc));
d(printf("best charset = %s\n", charsetin ? charsetin : "(null)"));
charset = g_strdup (charsetin);
a charset conversion filter as well, and then re-add the bestenc to filter the
result to find the best encoding to use as well */
- charenc = camel_mime_filter_charset_new_convert (charsetin, charset);
+ charenc = camel_mime_filter_charset_new (charsetin, charset);
if (charenc != NULL) {
/* otherwise, try another pass, converting to the real charset */
camel_mime_filter_reset ((CamelMimeFilter *)bestenc);
- camel_mime_filter_bestenc_set_flags (bestenc, CAMEL_BESTENC_GET_ENCODING |
- CAMEL_BESTENC_LF_IS_CRLF | callerflags);
+ camel_mime_filter_bestenc_set_flags (
+ CAMEL_MIME_FILTER_BESTENC (bestenc),
+ CAMEL_BESTENC_GET_ENCODING |
+ CAMEL_BESTENC_LF_IS_CRLF | callerflags);
- camel_stream_filter_add (filter, (CamelMimeFilter *)charenc);
- camel_stream_filter_add (filter, (CamelMimeFilter *)bestenc);
+ camel_stream_filter_add (
+ CAMEL_STREAM_FILTER (filter), charenc);
+ camel_stream_filter_add (
+ CAMEL_STREAM_FILTER (filter), bestenc);
/* and write it to the new stream */
camel_data_wrapper_write_to_stream (content, (CamelStream *)filter);
}
}
- encoding = camel_mime_filter_bestenc_get_best_encoding (bestenc, enctype);
+ encoding = camel_mime_filter_bestenc_get_best_encoding (
+ CAMEL_MIME_FILTER_BESTENC (bestenc), enctype);
camel_object_unref (filter);
camel_object_unref (bestenc);
CamelDataWrapper *wrapper;
gchar *charset;
- wrapper = camel_medium_get_content_object (CAMEL_MEDIUM (part));
+ wrapper = camel_medium_get_content (CAMEL_MEDIUM (part));
if (!wrapper)
return FALSE;
printf("%sclass: %s\n", s, ((CamelObject *)part)->klass->name);
printf("%smime-type: %s\n", s, camel_content_type_format(((CamelDataWrapper *)part)->mime_type));
- containee = camel_medium_get_content_object((CamelMedium *)part);
+ containee = camel_medium_get_content ((CamelMedium *)part);
if (containee == NULL)
return;
#include <camel/camel-internet-address.h>
#include <camel/camel-mime-filter-bestenc.h>
+#define CAMEL_MIME_MESSAGE_TYPE (camel_mime_message_get_type ())
+#define CAMEL_MIME_MESSAGE(obj) (CAMEL_CHECK_CAST((obj), CAMEL_MIME_MESSAGE_TYPE, CamelMimeMessage))
+#define CAMEL_MIME_MESSAGE_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_MIME_MESSAGE_TYPE, CamelMimeMessageClass))
+#define CAMEL_IS_MIME_MESSAGE(o) (CAMEL_CHECK_TYPE((o), CAMEL_MIME_MESSAGE_TYPE))
+
#define CAMEL_RECIPIENT_TYPE_TO "To"
#define CAMEL_RECIPIENT_TYPE_CC "Cc"
#define CAMEL_RECIPIENT_TYPE_BCC "Bcc"
#define CAMEL_RECIPIENT_TYPE_RESENT_CC "Resent-Cc"
#define CAMEL_RECIPIENT_TYPE_RESENT_BCC "Resent-Bcc"
-#define CAMEL_MIME_MESSAGE_TYPE (camel_mime_message_get_type ())
-#define CAMEL_MIME_MESSAGE(obj) (CAMEL_CHECK_CAST((obj), CAMEL_MIME_MESSAGE_TYPE, CamelMimeMessage))
-#define CAMEL_MIME_MESSAGE_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_MIME_MESSAGE_TYPE, CamelMimeMessageClass))
-#define CAMEL_IS_MIME_MESSAGE(o) (CAMEL_CHECK_TYPE((o), CAMEL_MIME_MESSAGE_TYPE))
-
/* specify local time */
#define CAMEL_MESSAGE_DATE_CURRENT (~0)
G_BEGIN_DECLS
-struct _CamelMimeMessage
-{
- CamelMimePart parent_object;
+typedef struct _CamelMimeMessage CamelMimeMessage;
+typedef struct _CamelMimeMessageClass CamelMimeMessageClass;
+
+struct _CamelMimeMessage {
+ CamelMimePart parent;
/* header fields */
time_t date;
GHashTable *recipients; /* hash table of CamelInternetAddress's */
};
-typedef struct {
+struct _CamelMimeMessageClass {
CamelMimePartClass parent_class;
-
- /* Virtual methods */
-
-} CamelMimeMessageClass;
+};
/* Standard Camel function */
CamelType camel_mime_message_get_type (void);
const gchar *message_id);
const gchar *camel_mime_message_get_message_id (CamelMimeMessage *message);
void camel_mime_message_set_reply_to (CamelMimeMessage *message,
- const CamelInternetAddress *reply_to);
-const CamelInternetAddress *camel_mime_message_get_reply_to (CamelMimeMessage *message);
+ CamelInternetAddress *reply_to);
+CamelInternetAddress * camel_mime_message_get_reply_to (CamelMimeMessage *message);
void camel_mime_message_set_subject (CamelMimeMessage *message,
const gchar *subject);
const gchar *camel_mime_message_get_subject (CamelMimeMessage *message);
void camel_mime_message_set_from (CamelMimeMessage *message,
- const CamelInternetAddress *from);
-const CamelInternetAddress *camel_mime_message_get_from (CamelMimeMessage *message);
+ CamelInternetAddress *from);
+CamelInternetAddress * camel_mime_message_get_from (CamelMimeMessage *message);
-const CamelInternetAddress *camel_mime_message_get_recipients (CamelMimeMessage *message,
+CamelInternetAddress * camel_mime_message_get_recipients (CamelMimeMessage *message,
const gchar *type);
void camel_mime_message_set_recipients (CamelMimeMessage *message,
const gchar *type,
- const CamelInternetAddress *recipients);
+ CamelInternetAddress *recipients);
void camel_mime_message_set_source (CamelMimeMessage *message,
const gchar *identity);
G_BEGIN_DECLS
+typedef struct _CamelMimeParser CamelMimeParser;
typedef struct _CamelMimeParserClass CamelMimeParserClass;
+typedef struct _CamelMimeParserPrivate CamelMimeParserPrivate;
/* NOTE: if you add more states, you may need to bump the
start of the END tags to 16 or 32, etc - so they are
struct _CamelMimeParser {
CamelObject parent;
-
- struct _CamelMimeParserPrivate *priv;
+ CamelMimeParserPrivate *priv;
};
struct _CamelMimeParserClass {
/* would you believe you have to set this BEFORE you set the content object??? oh my god !!!! */
camel_data_wrapper_set_mime_type_field (content, camel_mime_part_get_content_type (dw));
- camel_medium_set_content_object ((CamelMedium *)dw, content);
+ camel_medium_set_content ((CamelMedium *)dw, content);
camel_object_unref (content);
}
CamelDataWrapper *dw;
gboolean got_plain = FALSE;
- dw = camel_medium_get_content_object((CamelMedium *)msg);
+ dw = camel_medium_get_content ((CamelMedium *)msg);
if (camel_content_type_is (dw->mime_type, "multipart", "*")) {
gint i, nparts;
- CamelMultipart *mp = (CamelMultipart *)camel_medium_get_content_object((CamelMedium *)msg);
+ CamelMultipart *mp = (CamelMultipart *)camel_medium_get_content ((CamelMedium *)msg);
if (!CAMEL_IS_MULTIPART(mp))
g_assert (0);
G_BEGIN_DECLS
-void camel_mime_part_construct_content_from_parser(CamelMimePart *, CamelMimeParser *mp);
-gboolean camel_mime_message_build_preview (CamelMimePart *msg, CamelMessageInfo *info);
+void camel_mime_part_construct_content_from_parser
+ (CamelMimePart *mime_part,
+ CamelMimeParser *mp);
+gboolean camel_mime_message_build_preview(CamelMimePart *mime_part,
+ CamelMessageInfo *info);
G_END_DECLS
static GArray *get_headers (CamelMedium *medium);
static void free_headers (CamelMedium *medium, GArray *headers);
-static void set_content_object (CamelMedium *medium, CamelDataWrapper *content);
+static void set_content (CamelMedium *medium, CamelDataWrapper *content);
/* from camel mime parser */
static gint construct_from_parser (CamelMimePart *mime_part, CamelMimeParser *mp);
camel_medium_class->remove_header = remove_header;
camel_medium_class->get_headers = get_headers;
camel_medium_class->free_headers = free_headers;
- camel_medium_class->set_content_object = set_content_object;
+ camel_medium_class->set_content = set_content;
camel_data_wrapper_class->write_to_stream = write_to_stream;
camel_data_wrapper_class->construct_from_stream= construct_from_stream;
/* **** Content-MD5: */
/**
- * camel_mime_part_set_content_MD5:
+ * camel_mime_part_set_content_md5:
* @mime_part: a #CamelMimePart object
* @md5sum: the md5sum of the MIME part
*
* Set the content-md5 field of the MIME part.
**/
void
-camel_mime_part_set_content_MD5 (CamelMimePart *mime_part, const gchar *md5)
+camel_mime_part_set_content_md5 (CamelMimePart *mime_part, const gchar *md5)
{
camel_medium_set_header (CAMEL_MEDIUM (mime_part), "Content-MD5", md5);
}
/**
- * camel_mime_part_get_content_MD5:
+ * camel_mime_part_get_content_md5:
* @mime_part: a #CamelMimePart object
*
* Get the content-md5 field of the MIME part.
* Returns: the content-md5 field of the MIME part
**/
const gchar *
-camel_mime_part_get_content_MD5 (CamelMimePart *mime_part)
+camel_mime_part_get_content_md5 (CamelMimePart *mime_part)
{
return mime_part->content_MD5;
}
}
static void
-set_content_object (CamelMedium *medium, CamelDataWrapper *content)
+set_content (CamelMedium *medium, CamelDataWrapper *content)
{
CamelDataWrapper *mime_part = CAMEL_DATA_WRAPPER (medium);
CamelContentType *content_type;
- parent_class->set_content_object (medium, content);
+ parent_class->set_content (medium, content);
content_type = camel_data_wrapper_get_mime_type_field (content);
if (mime_part->mime_type != content_type) {
return -1;
total += count;
- content = camel_medium_get_content_object(medium);
+ content = camel_medium_get_content (medium);
if (content) {
CamelMimeFilter *filter = NULL;
- CamelStreamFilter *filter_stream = NULL;
+ CamelStream *filter_stream = NULL;
CamelMimeFilter *charenc = NULL;
const gchar *content_charset = NULL;
const gchar *part_charset = NULL;
if (mp->encoding != content->encoding) {
switch (mp->encoding) {
case CAMEL_TRANSFER_ENCODING_BASE64:
- filter = (CamelMimeFilter *) camel_mime_filter_basic_new_type (CAMEL_MIME_FILTER_BASIC_BASE64_ENC);
+ filter = camel_mime_filter_basic_new (CAMEL_MIME_FILTER_BASIC_BASE64_ENC);
break;
case CAMEL_TRANSFER_ENCODING_QUOTEDPRINTABLE:
- filter = (CamelMimeFilter *) camel_mime_filter_basic_new_type (CAMEL_MIME_FILTER_BASIC_QP_ENC);
+ filter = camel_mime_filter_basic_new (CAMEL_MIME_FILTER_BASIC_QP_ENC);
break;
case CAMEL_TRANSFER_ENCODING_UUENCODE:
filename = camel_mime_part_get_filename (mp);
if (count == -1)
return -1;
total += count;
- filter = (CamelMimeFilter *) camel_mime_filter_basic_new_type (CAMEL_MIME_FILTER_BASIC_UU_ENC);
+ filter = camel_mime_filter_basic_new (CAMEL_MIME_FILTER_BASIC_UU_ENC);
break;
default:
/* content is encoded but the part doesn't want to be... */
}
if (content_charset && part_charset && part_charset != content_charset)
- charenc = (CamelMimeFilter *) camel_mime_filter_charset_new_convert (content_charset, part_charset);
+ charenc = camel_mime_filter_charset_new (content_charset, part_charset);
if (filter || charenc) {
- filter_stream = camel_stream_filter_new_with_stream(stream);
+ filter_stream = camel_stream_filter_new (stream);
/* if we have a character encoder, add that always */
if (charenc) {
- camel_stream_filter_add(filter_stream, charenc);
+ camel_stream_filter_add (
+ CAMEL_STREAM_FILTER (filter_stream), charenc);
camel_object_unref (charenc);
}
CamelMimeFilter *crlf = camel_mime_filter_crlf_new(CAMEL_MIME_FILTER_CRLF_ENCODE,
CAMEL_MIME_FILTER_CRLF_MODE_CRLF_ONLY);
- camel_stream_filter_add(filter_stream, crlf);
+ camel_stream_filter_add (
+ CAMEL_STREAM_FILTER (filter_stream), crlf);
camel_object_unref (crlf);
}
if (filter) {
- camel_stream_filter_add(filter_stream, filter);
+ camel_stream_filter_add (
+ CAMEL_STREAM_FILTER (filter_stream), filter);
camel_object_unref (filter);
}
stream = camel_stream_mem_new_with_buffer (data, length);
camel_data_wrapper_construct_from_stream (dw, stream);
camel_object_unref (stream);
- camel_medium_set_content_object (medium, dw);
+ camel_medium_set_content (medium, dw);
camel_object_unref (dw);
} else {
if (medium->content)
g_return_val_if_fail (CAMEL_IS_MIME_PART (mime_part), 0);
- dw = camel_medium_get_content_object (CAMEL_MEDIUM (mime_part));
+ dw = camel_medium_get_content (CAMEL_MEDIUM (mime_part));
null = (CamelStreamNull *) camel_stream_null_new ();
camel_data_wrapper_decode_to_stream (dw, (CamelStream *) null);
G_BEGIN_DECLS
+typedef struct _CamelMimePart CamelMimePart;
+typedef struct _CamelMimePartClass CamelMimePartClass;
+
/* Do not change these values directly, you would regret it one day */
struct _CamelMimePart {
- CamelMedium parent_object;
+ CamelMedium parent;
struct _camel_header_raw *headers; /* mime headers */
CamelTransferEncoding encoding;
};
-typedef struct _CamelMimePartClass {
+struct _CamelMimePartClass {
CamelMediumClass parent_class;
- /* Virtual methods */
- gint (*construct_from_parser) (CamelMimePart *, CamelMimeParser *);
-} CamelMimePartClass;
+ gint (*construct_from_parser)(CamelMimePart *mime_part,
+ CamelMimeParser *parser);
+};
/* Standard Camel function */
CamelType camel_mime_part_get_type (void);
void camel_mime_part_set_content_id (CamelMimePart *mime_part, const gchar *contentid);
const gchar *camel_mime_part_get_content_id (CamelMimePart *mime_part);
-void camel_mime_part_set_content_MD5 (CamelMimePart *mime_part, const gchar *md5sum);
-const gchar *camel_mime_part_get_content_MD5 (CamelMimePart *mime_part);
+void camel_mime_part_set_content_md5 (CamelMimePart *mime_part, const gchar *md5sum);
+const gchar *camel_mime_part_get_content_md5 (CamelMimePart *mime_part);
void camel_mime_part_set_content_location (CamelMimePart *mime_part, const gchar *location);
const gchar *camel_mime_part_get_content_location (CamelMimePart *mime_part);
};
struct _CamelMultipartEncrypted {
- CamelMultipart parent_object;
+ CamelMultipart parent;
CamelMimePart *version;
CamelMimePart *content;
/* first, prepare our parts */
sub = camel_seekable_substream_new((CamelSeekableStream *)((CamelDataWrapper *)mps)->stream, mps->start1, mps->end1);
- constream = (CamelStream *)camel_stream_filter_new_with_stream(sub);
+ constream = camel_stream_filter_new (sub);
camel_object_unref((CamelObject *)sub);
/* Note: see rfc2015 or rfc3156, section 5 */
struct _CamelMultipartSigned
{
- CamelMultipart parent_object;
+ CamelMultipart parent;
/* these are the client visible parts, decoded forms of our data wrapper content */
CamelMimePart *content;
struct _CamelMimeParser;
-struct _CamelMultipart
-{
- CamelDataWrapper parent_object;
+typedef struct _CamelMultipart CamelMultipart;
+typedef struct _CamelMultipartClass CamelMultipartClass;
+
+struct _CamelMultipart {
+ CamelDataWrapper parent;
GList *parts;
gchar *preface;
gchar *postface;
};
-typedef struct {
+struct _CamelMultipartClass {
CamelDataWrapperClass parent_class;
/* Virtual methods */
gint (*construct_from_parser)(CamelMultipart *, struct _CamelMimeParser *);
/*int (*construct_from_stream)(CamelMultipart *, CamelStream *);*/
+};
-} CamelMultipartClass;
-
-/* Standard Camel function */
CamelType camel_multipart_get_type (void);
/* public methods */
static gint nntp_decode (CamelAddress *, const gchar *raw);
static gchar * nntp_encode (CamelAddress *);
-static gint nntp_cat (CamelAddress *dest, const CamelAddress *source);
+static gint nntp_cat (CamelAddress *dest, CamelAddress *source);
static void nntp_remove (CamelAddress *, gint index);
static void camel_nntp_address_class_init (CamelNNTPAddressClass *klass);
}
static gint
-nntp_cat (CamelAddress *dest, const CamelAddress *source)
+nntp_cat (CamelAddress *dest, CamelAddress *source)
{
gint i;
* Returns: TRUE if such an address exists, or FALSE otherwise.
**/
gboolean
-camel_nntp_address_get (const CamelNNTPAddress *a, gint index, const gchar **namep)
+camel_nntp_address_get (CamelNNTPAddress *a, gint index, const gchar **namep)
{
g_assert(CAMEL_IS_NNTP_ADDRESS(a));
typedef struct _CamelNNTPAddress CamelNNTPAddress;
typedef struct _CamelNNTPAddressClass CamelNNTPAddressClass;
+typedef struct _CamelNNTPAddressPrivate CamelNNTPAddressPrivate;
struct _CamelNNTPAddress {
CamelAddress parent;
-
- struct _CamelNNTPAddressPrivate *priv;
+ CamelNNTPAddressPrivate *priv;
};
struct _CamelNNTPAddressClass {
CamelAddressClass parent_class;
};
-CamelType camel_nntp_address_get_type (void);
-CamelNNTPAddress *camel_nntp_address_new (void);
-
-gint camel_nntp_address_add (CamelNNTPAddress *a, const gchar *name);
-gboolean camel_nntp_address_get (const CamelNNTPAddress *a, gint index, const gchar **namep);
+CamelType camel_nntp_address_get_type (void);
+CamelNNTPAddress *
+ camel_nntp_address_new (void);
+gint camel_nntp_address_add (CamelNNTPAddress *a,
+ const gchar *name);
+gboolean camel_nntp_address_get (CamelNNTPAddress *a,
+ gint index,
+ const gchar **namep);
G_END_DECLS
#include <pthread.h>
#include <camel/camel-arg.h>
-#include <camel/camel-types.h> /* this is a @##$@#SF stupid header */
+#include <camel/camel-exception.h>
/* turn on so that camel_object_class_dump_tree() dumps object instances as well */
#define CAMEL_OBJECT_TRACK_INSTANCES
/* root-class fields follow, type system above */
/* get/set interface */
- gint (*setv)(struct _CamelObject *, struct _CamelException *ex, CamelArgV *args);
- gint (*getv)(struct _CamelObject *, struct _CamelException *ex, CamelArgGetV *args);
+ gint (*setv)(struct _CamelObject *, CamelException *ex, CamelArgV *args);
+ gint (*getv)(struct _CamelObject *, CamelException *ex, CamelArgGetV *args);
/* we only free 1 at a time, and only pointer types, obviously */
void (*free)(struct _CamelObject *, guint32 tag, gpointer ptr);
void camel_object_trigger_event(gpointer obj, const gchar *name, gpointer event_data);
/* get/set methods */
-gint camel_object_set(gpointer obj, struct _CamelException *ex, ...);
-gint camel_object_setv(gpointer obj, struct _CamelException *ex, CamelArgV *);
-gint camel_object_get(gpointer obj, struct _CamelException *ex, ...);
-gint camel_object_getv(gpointer obj, struct _CamelException *ex, CamelArgGetV *);
+gint camel_object_set(gpointer obj, CamelException *ex, ...);
+gint camel_object_setv(gpointer obj, CamelException *ex, CamelArgV *);
+gint camel_object_get(gpointer obj, CamelException *ex, ...);
+gint camel_object_getv(gpointer obj, CamelException *ex, CamelArgGetV *);
/* reads/writes the state from/to the CAMEL_OBJECT_STATE_FILE */
gint camel_object_state_read(gpointer vo);
};
struct _CamelOfflineFolder {
- CamelFolder parent_object;
+ CamelFolder parent;
guint sync_offline:1;
};
#include <stdio.h>
#include <stdarg.h>
-#include <glib.h>
-
#include <camel/camel-list-utils.h>
#include <camel/camel-object.h>
struct _CamelFolder;
struct _CamelOfflineJournal {
- CamelObject parent_object;
+ CamelObject parent;
struct _CamelFolder *folder;
gchar *filename;
};
struct _CamelOfflineStore {
- CamelStore parent_object;
+ CamelStore parent;
gint state;
};
}
/**
- * camel_operation_cancel_block:
- * @cc: operation context
- *
- * Block cancellation for this operation. If @cc is NULL, then the
- * current thread is blocked.
- **/
-void
-camel_operation_cancel_block (CamelOperation *cc)
-{
- if (cc == NULL)
- cc = co_getcc();
-
- if (cc) {
- LOCK();
- cc->blocked++;
- UNLOCK();
- }
-}
-
-/**
- * camel_operation_cancel_unblock:
- * @cc: operation context
- *
- * Unblock cancellation, when the unblock count reaches the block
- * count, then this operation can be cancelled. If @cc is NULL, then
- * the current thread is unblocked.
- **/
-void
-camel_operation_cancel_unblock (CamelOperation *cc)
-{
- if (cc == NULL)
- cc = co_getcc();
-
- if (cc) {
- LOCK();
- cc->blocked--;
- UNLOCK();
- }
-}
-
-/**
* camel_operation_cancel:
* @cc: operation context
*
}
/**
- * camel_operation_progress_count:
- * @cc: operation context
- * @sofar:
- *
- **/
-void
-camel_operation_progress_count (CamelOperation *cc, gint sofar)
-{
- camel_operation_progress(cc, sofar);
-}
-
-/**
* camel_operation_end:
* @cc: operation context
*
void camel_operation_unregister (CamelOperation *cc);
/* called internally by camel, for the current thread */
-void camel_operation_cancel_block(CamelOperation *cc);
-void camel_operation_cancel_unblock(CamelOperation *cc);
gint camel_operation_cancel_check(CamelOperation *cc);
gint camel_operation_cancel_fd(CamelOperation *cc);
#ifdef HAVE_NSS
void camel_operation_start(CamelOperation *cc, const gchar *what, ...);
void camel_operation_start_transient(CamelOperation *cc, const gchar *what, ...);
void camel_operation_progress(CamelOperation *cc, gint pc);
-void camel_operation_progress_count(CamelOperation *cc, gint sofar);
void camel_operation_end(CamelOperation *cc);
G_END_DECLS
#define CAMEL_PARTITION_TABLE_H
#include <camel/camel-object.h>
-#include <glib.h>
#include "camel-block-file.h"
#include "camel-list-utils.h"
typedef struct _CamelPartitionTable CamelPartitionTable;
typedef struct _CamelPartitionTableClass CamelPartitionTableClass;
+typedef struct _CamelPartitionTablePrivate CamelPartitionTablePrivate;
struct _CamelPartitionKey {
camel_hash_t hashid;
struct _CamelPartitionTable {
CamelObject parent;
-
- struct _CamelPartitionTablePrivate *priv;
+ CamelPartitionTablePrivate *priv;
CamelBlockFile *blocks;
camel_block_t rootid;
CamelObjectClass parent;
};
-CamelType camel_partition_table_get_type(void);
-
-CamelPartitionTable *camel_partition_table_new(struct _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);
-void camel_partition_table_remove(CamelPartitionTable *cpi, const gchar *key);
+CamelType camel_partition_table_get_type (void);
+CamelPartitionTable *
+ camel_partition_table_new (struct _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);
+void camel_partition_table_remove (CamelPartitionTable *cpi,
+ const gchar *key);
/* ********************************************************************** */
typedef struct _CamelKeyTable CamelKeyTable;
typedef struct _CamelKeyTableClass CamelKeyTableClass;
+typedef struct _CamelKeyTablePrivate CamelKeyTablePrivate;
struct _CamelKeyRootBlock {
camel_block_t first;
struct _CamelKeyTable {
CamelObject parent;
-
- struct _CamelKeyTablePrivate *priv;
+ CamelKeyTablePrivate *priv;
CamelBlockFile *blocks;
CamelObjectClass parent;
};
-CamelType camel_key_table_get_type(void);
-
-CamelKeyTable * camel_key_table_new(CamelBlockFile *bs, camel_block_t root);
-gint camel_key_table_sync(CamelKeyTable *ki);
-camel_key_t camel_key_table_add(CamelKeyTable *ki, const gchar *key, camel_block_t data, guint flags);
-void camel_key_table_set_data(CamelKeyTable *ki, camel_key_t keyid, camel_block_t data);
-void camel_key_table_set_flags(CamelKeyTable *ki, camel_key_t keyid, guint flags, guint set);
-camel_block_t camel_key_table_lookup(CamelKeyTable *ki, camel_key_t keyid, gchar **key, guint *flags);
-camel_key_t camel_key_table_next(CamelKeyTable *ki, camel_key_t next, gchar **keyp, guint *flagsp, camel_block_t *datap);
+CamelType camel_key_table_get_type (void);
+CamelKeyTable * camel_key_table_new (CamelBlockFile *bs,
+ camel_block_t root);
+gint camel_key_table_sync (CamelKeyTable *ki);
+camel_key_t camel_key_table_add (CamelKeyTable *ki,
+ const gchar *key,
+ camel_block_t data,
+ guint flags);
+void camel_key_table_set_data (CamelKeyTable *ki,
+ camel_key_t keyid,
+ camel_block_t data);
+void camel_key_table_set_flags (CamelKeyTable *ki,
+ camel_key_t keyid,
+ guint flags,
+ guint set);
+camel_block_t camel_key_table_lookup (CamelKeyTable *ki,
+ camel_key_t keyid,
+ gchar **key,
+ guint *flags);
+camel_key_t camel_key_table_next (CamelKeyTable *ki,
+ camel_key_t next,
+ gchar **keyp,
+ guint *flagsp,
+ camel_block_t *datap);
G_END_DECLS
struct _CamelFolderSummaryPrivate {
GHashTable *filter_charset; /* CamelMimeFilterCharset's indexed by source charset */
- struct _CamelMimeFilterIndex *filter_index;
- struct _CamelMimeFilterBasic *filter_64;
- struct _CamelMimeFilterBasic *filter_qp;
- struct _CamelMimeFilterBasic *filter_uu;
- struct _CamelMimeFilterSave *filter_save;
- struct _CamelMimeFilterHTML *filter_html;
-
- struct _CamelStreamFilter *filter_stream;
+ struct _CamelMimeFilter *filter_index;
+ struct _CamelMimeFilter *filter_64;
+ struct _CamelMimeFilter *filter_qp;
+ struct _CamelMimeFilter *filter_uu;
+ struct _CamelMimeFilter *filter_save;
+ struct _CamelMimeFilter *filter_html;
+
+ struct _CamelStream *filter_stream;
struct _CamelIndex *index;
#ifndef CAMEL_PROVIDER_H
#define CAMEL_PROVIDER_H
-#include <camel/camel-types.h>
#include <camel/camel-object.h>
#include <camel/camel-exception.h>
#include <camel/camel-url.h>
guint loaded:1;
};
-void camel_provider_init(void);
-
-void camel_provider_load(const gchar *path, CamelException *ex);
-void camel_provider_register(CamelProvider *provider);
-GList *camel_provider_list(gboolean load);
-CamelProvider *camel_provider_get(const gchar *url_string, CamelException *ex);
+void camel_provider_init (void);
+void camel_provider_load (const gchar *path,
+ CamelException *ex);
+void camel_provider_register (CamelProvider *provider);
+GList * camel_provider_list (gboolean load);
+CamelProvider * camel_provider_get (const gchar *url_string,
+ CamelException *ex);
/* This is defined by each module, not by camel-provider.c. */
-void camel_provider_module_init(void);
+void camel_provider_module_init (void);
-gint camel_provider_auto_detect (CamelProvider *provider, CamelURL *url,
- GHashTable **auto_detected, CamelException *ex);
+gint camel_provider_auto_detect (CamelProvider *provider,
+ CamelURL *url,
+ GHashTable **auto_detected,
+ CamelException *ex);
G_END_DECLS
G_BEGIN_DECLS
+typedef struct _CamelSaslAnonymous CamelSaslAnonymous;
+typedef struct _CamelSaslAnonymousClass CamelSaslAnonymousClass;
+
typedef enum {
CAMEL_SASL_ANON_TRACE_EMAIL,
CAMEL_SASL_ANON_TRACE_OPAQUE,
CAMEL_SASL_ANON_TRACE_EMPTY
} CamelSaslAnonTraceType;
-typedef struct _CamelSaslAnonymous {
- CamelSasl parent_object;
+struct _CamelSaslAnonymous {
+ CamelSasl parent;
gchar *trace_info;
CamelSaslAnonTraceType type;
-} CamelSaslAnonymous;
+};
-typedef struct _CamelSaslAnonymousClass {
+struct _CamelSaslAnonymousClass {
CamelSaslClass parent_class;
+};
-} CamelSaslAnonymousClass;
-
-/* Standard Camel function */
CamelType camel_sasl_anonymous_get_type (void);
/* public methods */
G_BEGIN_DECLS
-typedef struct _CamelSaslCramMd5 {
- CamelSasl parent_object;
+typedef struct _CamelSaslCramMd5 CamelSaslCramMd5;
+typedef struct _CamelSaslCramMd5Class CamelSaslCramMd5Class;
-} CamelSaslCramMd5;
+struct _CamelSaslCramMd5 {
+ CamelSasl parent;
+};
-typedef struct _CamelSaslCramMd5Class {
+struct _CamelSaslCramMd5Class {
CamelSaslClass parent_class;
+};
-} CamelSaslCramMd5Class;
-
-/* Standard Camel function */
CamelType camel_sasl_cram_md5_get_type (void);
extern CamelServiceAuthType camel_sasl_cram_md5_authtype;
G_BEGIN_DECLS
-typedef struct _CamelSaslDigestMd5 {
- CamelSasl parent_object;
- struct _CamelSaslDigestMd5Private *priv;
+typedef struct _CamelSaslDigestMd5 CamelSaslDigestMd5;
+typedef struct _CamelSaslDigestMd5Class CamelSaslDigestMd5Class;
+typedef struct _CamelSaslDigestMd5Private CamelSaslDigestMd5Private;
-} CamelSaslDigestMd5;
+struct _CamelSaslDigestMd5 {
+ CamelSasl parent;
+ CamelSaslDigestMd5Private *priv;
+};
-typedef struct _CamelSaslDigestMd5Class {
+struct _CamelSaslDigestMd5Class {
CamelSaslClass parent_class;
+};
-} CamelSaslDigestMd5Class;
-
-/* Standard Camel function */
CamelType camel_sasl_digest_md5_get_type (void);
extern CamelServiceAuthType camel_sasl_digest_md5_authtype;
typedef struct _CamelSaslGssapi CamelSaslGssapi;
typedef struct _CamelSaslGssapiClass CamelSaslGssapiClass;
+typedef struct _CamelSaslGssapiPrivate CamelSaslGssapiPrivate;
struct _CamelSaslGssapi {
- CamelSasl parent_object;
-
- struct _CamelSaslGssapiPrivate *priv;
-
+ CamelSasl parent;
+ CamelSaslGssapiPrivate *priv;
};
struct _CamelSaslGssapiClass {
CamelSaslClass parent_class;
-
};
-/* Standard Camel function */
CamelType camel_sasl_gssapi_get_type (void);
extern CamelServiceAuthType camel_sasl_gssapi_authtype;
G_BEGIN_DECLS
-typedef struct _CamelSaslLogin {
- CamelSasl parent_object;
+typedef struct _CamelSaslLogin CamelSaslLogin;
+typedef struct _CamelSaslLoginClass CamelSaslLoginClass;
+typedef struct _CamelSaslLoginPrivate CamelSaslLoginPrivate;
- struct _CamelSaslLoginPrivate *priv;
+struct _CamelSaslLogin {
+ CamelSasl parent;
+ CamelSaslLoginPrivate *priv;
+};
-} CamelSaslLogin;
-
-typedef struct _CamelSaslLoginClass {
+struct _CamelSaslLoginClass {
CamelSaslClass parent_class;
+};
-} CamelSaslLoginClass;
-
-/* Standard Camel function */
CamelType camel_sasl_login_get_type (void);
extern CamelServiceAuthType camel_sasl_login_authtype;
G_BEGIN_DECLS
-typedef struct _CamelSaslNTLM {
- CamelSasl parent_object;
+typedef struct _CamelSaslNTLM CamelSaslNTLM;
+typedef struct _CamelSaslNTLMClass CamelSaslNTLMClass;
-} CamelSaslNTLM;
+struct _CamelSaslNTLM {
+ CamelSasl parent;
+};
-typedef struct _CamelSaslNTLMClass {
+struct _CamelSaslNTLMClass {
CamelSaslClass parent_class;
+};
-} CamelSaslNTLMClass;
-
-/* Standard Camel function */
CamelType camel_sasl_ntlm_get_type (void);
extern CamelServiceAuthType camel_sasl_ntlm_authtype;
G_BEGIN_DECLS
-typedef struct _CamelSaslPlain {
- CamelSasl parent_object;
+typedef struct _CamelSaslPlain CamelSaslPlain;
+typedef struct _CamelSaslPlainClass CamelSaslPlainClass;
-} CamelSaslPlain;
+struct _CamelSaslPlain {
+ CamelSasl parent;
+};
-typedef struct _CamelSaslPlainClass {
+struct _CamelSaslPlainClass {
CamelSaslClass parent_class;
+};
-} CamelSaslPlainClass;
-
-/* Standard Camel function */
CamelType camel_sasl_plain_get_type (void);
extern CamelServiceAuthType camel_sasl_plain_authtype;
#include "camel-sasl-popb4smtp.h"
#include "camel-service.h"
#include "camel-session.h"
+#include "camel-store.h"
CamelServiceAuthType camel_sasl_popb4smtp_authtype = {
N_("POP before SMTP"),
G_BEGIN_DECLS
-typedef struct _CamelSaslPOPB4SMTP {
- CamelSasl parent_object;
+typedef struct _CamelSaslPOPB4SMTP CamelSaslPOPB4SMTP;
+typedef struct _CamelSaslPOPB4SMTPClass CamelSaslPOPB4SMTPClass;
-} CamelSaslPOPB4SMTP;
+struct _CamelSaslPOPB4SMTP {
+ CamelSasl parent;
+};
-typedef struct _CamelSaslPOPB4SMTPClass {
+struct _CamelSaslPOPB4SMTPClass {
CamelSaslClass parent_class;
+};
-} CamelSaslPOPB4SMTPClass;
-
-/* Standard Camel function */
CamelType camel_sasl_popb4smtp_get_type (void);
extern CamelServiceAuthType camel_sasl_popb4smtp_authtype;
#ifndef CAMEL_SASL_H
#define CAMEL_SASL_H
-#include <glib.h>
#include <camel/camel-object.h>
#include <camel/camel-exception.h>
#include <camel/camel-service.h>
G_BEGIN_DECLS
-typedef struct _CamelSasl {
- CamelObject parent_object;
+typedef struct _CamelSasl CamelSasl;
+typedef struct _CamelSaslClass CamelSaslClass;
+
+struct _CamelSasl {
+ CamelObject parent;
gchar *service_name;
gchar *mech; /* mechanism */
CamelService *service;
gboolean authenticated;
-} CamelSasl;
+};
-typedef struct _CamelSaslClass {
+struct _CamelSaslClass {
CamelObjectClass parent_class;
- GByteArray * (*challenge) (CamelSasl *sasl, GByteArray *token, CamelException *ex);
-
-} CamelSaslClass;
-
-/* Standard Camel function */
-CamelType camel_sasl_get_type (void);
-
-/* public methods */
-GByteArray *camel_sasl_challenge (CamelSasl *sasl, GByteArray *token, CamelException *ex);
-gchar *camel_sasl_challenge_base64 (CamelSasl *sasl, const gchar *token, CamelException *ex);
-
-gboolean camel_sasl_authenticated (CamelSasl *sasl);
-
-/* utility functions */
-CamelSasl *camel_sasl_new (const gchar *service_name, const gchar *mechanism, CamelService *service);
-
-GList *camel_sasl_authtype_list (gboolean include_plain);
-CamelServiceAuthType *camel_sasl_authtype (const gchar *mechanism);
+ GByteArray * (*challenge) (CamelSasl *sasl,
+ GByteArray *token,
+ CamelException *ex);
+};
+
+CamelType camel_sasl_get_type (void);
+GByteArray * camel_sasl_challenge (CamelSasl *sasl,
+ GByteArray *token,
+ CamelException *ex);
+gchar * camel_sasl_challenge_base64 (CamelSasl *sasl,
+ const gchar *token,
+ CamelException *ex);
+gboolean camel_sasl_authenticated (CamelSasl *sasl);
+CamelSasl * camel_sasl_new (const gchar *service_name,
+ const gchar *mechanism,
+ CamelService *service);
+
+GList * camel_sasl_authtype_list (gboolean include_plain);
+CamelServiceAuthType *
+ camel_sasl_authtype (const gchar *mechanism);
G_END_DECLS
gint truth = FALSE;
gint parts, i;
- containee = camel_medium_get_content_object (CAMEL_MEDIUM (object));
+ containee = camel_medium_get_content (CAMEL_MEDIUM (object));
if (containee == NULL)
return FALSE;
#ifndef CAMEL_SEARCH_SQL_SEXP_H
#define CAMEL_SEARCH_SQL_SEXP_H
+#include <glib.h>
+
G_BEGIN_DECLS
/* FIXME: Weird naming, since, I want both parsers to be there for some time.*/
#ifndef CAMEL_SEARCH_SQL_H
#define CAMEL_SEARCH_SQL_H
+#include <glib.h>
+
G_BEGIN_DECLS
gchar * camel_sexp_to_sql (const gchar *sexp);
G_BEGIN_DECLS
+typedef struct _CamelSeekableStream CamelSeekableStream;
+typedef struct _CamelSeekableStreamClass CamelSeekableStreamClass;
+
typedef enum {
CAMEL_STREAM_SET = SEEK_SET,
CAMEL_STREAM_CUR = SEEK_CUR,
#define CAMEL_STREAM_UNBOUND (~0)
struct _CamelSeekableStream {
- CamelStream parent_object;
+ CamelStream parent;
off_t position; /* current postion in the stream */
off_t bound_start; /* first valid position */
off_t bound_end; /* first invalid position */
};
-typedef struct {
+struct _CamelSeekableStreamClass {
CamelStreamClass parent_class;
- /* Virtual methods */
- off_t (*seek) (CamelSeekableStream *stream, off_t offset,
- CamelStreamSeekPolicy policy);
- off_t (*tell) (CamelSeekableStream *stream);
- gint (*set_bounds) (CamelSeekableStream *stream,
- off_t start, off_t end);
-} CamelSeekableStreamClass;
-
-/* Standard Camel function */
-CamelType camel_seekable_stream_get_type (void);
-
-/* public methods */
-off_t camel_seekable_stream_seek (CamelSeekableStream *stream, off_t offset,
- CamelStreamSeekPolicy policy);
-off_t camel_seekable_stream_tell (CamelSeekableStream *stream);
-gint camel_seekable_stream_set_bounds (CamelSeekableStream *stream, off_t start, off_t end);
+ off_t (*seek) (CamelSeekableStream *stream,
+ off_t offset,
+ CamelStreamSeekPolicy policy);
+ off_t (*tell) (CamelSeekableStream *stream);
+ gint (*set_bounds) (CamelSeekableStream *stream,
+ off_t start,
+ off_t end);
+};
+
+CamelType camel_seekable_stream_get_type (void);
+off_t camel_seekable_stream_seek (CamelSeekableStream *stream,
+ off_t offset,
+ CamelStreamSeekPolicy policy);
+off_t camel_seekable_stream_tell (CamelSeekableStream *stream);
+gint camel_seekable_stream_set_bounds(CamelSeekableStream *stream,
+ off_t start,
+ off_t end);
G_END_DECLS
G_BEGIN_DECLS
+typedef struct _CamelSeekableSubstream CamelSeekableSubstream;
+typedef struct _CamelSeekableSubstreamClass CamelSeekableSubstreamClass;
+
struct _CamelSeekableSubstream {
- CamelSeekableStream parent_object;
+ CamelSeekableStream parent;
/* --**-- Private fields --**-- */
CamelSeekableStream *parent_stream;
};
-typedef struct {
+struct _CamelSeekableSubstreamClass {
CamelSeekableStreamClass parent_class;
+};
-} CamelSeekableSubstreamClass;
-
-/* Standard Camel function */
CamelType camel_seekable_substream_get_type (void);
/* public methods */
G_BEGIN_DECLS
+struct _CamelSession;
+
+typedef struct _CamelService CamelService;
+typedef struct _CamelServiceClass CamelServiceClass;
+
enum {
CAMEL_SERVICE_ARG_FIRST = CAMEL_ARG_FIRST + 100,
CAMEL_SERVICE_ARG_USERNAME,
} CamelServiceConnectionStatus;
struct _CamelService {
- CamelObject parent_object;
+ CamelObject parent;
struct _CamelServicePrivate *priv;
- CamelSession *session;
+ struct _CamelSession *session;
CamelProvider *provider;
CamelServiceConnectionStatus status;
CamelOperation *connect_op;
CamelURL *url;
};
-typedef struct {
+struct _CamelServiceClass {
CamelObjectClass parent_class;
- void (*construct) (CamelService *service,
- CamelSession *session,
- CamelProvider *provider,
- CamelURL *url,
- CamelException *ex);
-
- gboolean (*connect) (CamelService *service,
- CamelException *ex);
- gboolean (*disconnect) (CamelService *service,
- gboolean clean,
- CamelException *ex);
- void (*cancel_connect) (CamelService *service);
-
- GList * (*query_auth_types) (CamelService *service,
- CamelException *ex);
-
- gchar * (*get_name) (CamelService *service,
- gboolean brief);
- gchar * (*get_path) (CamelService *service);
-
-} CamelServiceClass;
+ void (*construct) (CamelService *service,
+ struct _CamelSession *session,
+ CamelProvider *provider,
+ CamelURL *url,
+ CamelException *ex);
+ gboolean (*connect) (CamelService *service,
+ CamelException *ex);
+ gboolean (*disconnect) (CamelService *service,
+ gboolean clean,
+ CamelException *ex);
+ void (*cancel_connect) (CamelService *service);
+ GList * (*query_auth_types) (CamelService *service,
+ CamelException *ex);
+ gchar * (*get_name) (CamelService *service,
+ gboolean brief);
+ gchar * (*get_path) (CamelService *service);
+};
/* query_auth_types returns a GList of these */
typedef struct {
gboolean need_password; /* needs a password to authenticate */
} CamelServiceAuthType;
-/* public methods */
-void camel_service_construct (CamelService *service,
- CamelSession *session,
- CamelProvider *provider,
- CamelURL *url,
- CamelException *ex);
-gboolean camel_service_connect (CamelService *service,
- CamelException *ex);
-gboolean camel_service_disconnect (CamelService *service,
- gboolean clean,
- CamelException *ex);
-void camel_service_cancel_connect (CamelService *service);
-gchar * camel_service_get_url (CamelService *service);
-gchar * camel_service_get_name (CamelService *service,
- gboolean brief);
-gchar * camel_service_get_path (CamelService *service);
-CamelSession * camel_service_get_session (CamelService *service);
-CamelProvider * camel_service_get_provider (CamelService *service);
-GList * camel_service_query_auth_types (CamelService *service,
- CamelException *ex);
-
-/* Standard Camel function */
-CamelType camel_service_get_type (void);
+CamelType camel_service_get_type (void);
+void camel_service_construct (CamelService *service,
+ struct _CamelSession *session,
+ CamelProvider *provider,
+ CamelURL *url,
+ CamelException *ex);
+gboolean camel_service_connect (CamelService *service,
+ CamelException *ex);
+gboolean camel_service_disconnect (CamelService *service,
+ gboolean clean,
+ CamelException *ex);
+void camel_service_cancel_connect (CamelService *service);
+gchar * camel_service_get_url (CamelService *service);
+gchar * camel_service_get_name (CamelService *service,
+ gboolean brief);
+gchar * camel_service_get_path (CamelService *service);
+struct _CamelSession *
+ camel_service_get_session (CamelService *service);
+CamelProvider * camel_service_get_provider (CamelService *service);
+GList * camel_service_query_auth_types (CamelService *service,
+ CamelException *ex);
G_END_DECLS
#include "camel-exception.h"
#include "camel-file-utils.h"
+#include "camel-filter-driver.h"
#include "camel-private.h"
#include "camel-session.h"
#include "camel-store.h"
#ifndef CAMEL_SESSION_H
#define CAMEL_SESSION_H
+#include <camel/camel-filter-driver.h>
+#include <camel/camel-junk-plugin.h>
#include <camel/camel-msgport.h>
-#include <camel/camel-object.h>
#include <camel/camel-provider.h>
-#include <camel/camel-junk-plugin.h>
+#include <camel/camel-service.h>
#define CAMEL_SESSION_TYPE (camel_session_get_type ())
#define CAMEL_SESSION(obj) (CAMEL_CHECK_CAST((obj), CAMEL_SESSION_TYPE, CamelSession))
G_BEGIN_DECLS
+typedef struct _CamelSession CamelSession;
+typedef struct _CamelSessionClass CamelSessionClass;
+typedef struct _CamelSessionPrivate CamelSessionPrivate;
+
typedef gboolean (*CamelTimeoutCallback) (gpointer data);
typedef enum {
CAMEL_SESSION_ALERT_INFO,
CAMEL_SESSION_PASSPHRASE = 1 << 4
};
-struct _CamelSession
-{
- CamelObject parent_object;
- struct _CamelSessionPrivate *priv;
+struct _CamelSession {
+ CamelObject parent;
+ CamelSessionPrivate *priv;
gchar *storage_path;
CamelJunkPlugin *junk_plugin;
typedef struct _CamelSessionThreadOps CamelSessionThreadOps;
typedef struct _CamelSessionThreadMsg CamelSessionThreadMsg;
-typedef struct {
+struct _CamelSessionClass {
CamelObjectClass parent_class;
CamelService * (*get_service) (CamelSession *session,
gboolean (*lookup_addressbook)(CamelSession *session,
const gchar *name);
void (*forward_to) (CamelSession *session,
- struct _CamelFolder *folder,
- struct _CamelMimeMessage *message,
+ CamelFolder *folder,
+ CamelMimeMessage *message,
const gchar *address,
CamelException *ex);
-} CamelSessionClass;
-
-/* public methods */
+};
-/* Standard Camel function */
CamelType camel_session_get_type (void);
void camel_session_construct (CamelSession *session,
gboolean check_junk);
struct _CamelSessionThreadOps {
- void (*receive)(CamelSession *session, struct _CamelSessionThreadMsg *m);
- void (*free)(CamelSession *session, struct _CamelSessionThreadMsg *m);
+ void (*receive)(CamelSession *session, CamelSessionThreadMsg *m);
+ void (*free)(CamelSession *session, CamelSessionThreadMsg *m);
};
struct _CamelSessionThreadMsg {
CamelException ex;
CamelSessionThreadOps *ops;
- struct _CamelOperation *op;
+ CamelOperation *op;
CamelSession *session;
gpointer data; /* free for implementation to define, not used by camel, do not use in client code */
const gchar *name);
void camel_session_forward_to (CamelSession *session,
- struct _CamelFolder *folder,
- struct _CamelMimeMessage *message,
+ CamelFolder *folder,
+ CamelMimeMessage *message,
const gchar *address,
CamelException *ex);
/* FIXME: stream this to the decoder incrementally */
istream = (CamelStreamMem *)camel_stream_mem_new();
- camel_data_wrapper_decode_to_stream(camel_medium_get_content_object((CamelMedium *)part), (CamelStream *)istream);
+ camel_data_wrapper_decode_to_stream(camel_medium_get_content ((CamelMedium *)part), (CamelStream *)istream);
camel_stream_reset((CamelStream *)istream);
dec = NSS_CMSDecoder_Start(NULL,
camel_data_wrapper_set_mime_type_field(dw, ct);
camel_content_type_unref(ct);
- camel_medium_set_content_object((CamelMedium *)sigpart, dw);
+ camel_medium_set_content ((CamelMedium *)sigpart, dw);
camel_mime_part_set_filename(sigpart, "smime.p7s");
camel_mime_part_set_disposition(sigpart, "attachment");
camel_stream_reset(istream);
camel_object_ref(istream);
- camel_medium_set_content_object((CamelMedium *)opart, (CamelDataWrapper *)mps);
+ camel_medium_set_content ((CamelMedium *)opart, (CamelDataWrapper *)mps);
} else {
ct = camel_content_type_new("application", "x-pkcs7-mime");
camel_content_type_set_param(ct, "name", "smime.p7m");
camel_data_wrapper_set_mime_type_field(dw, ct);
camel_content_type_unref(ct);
- camel_medium_set_content_object((CamelMedium *)opart, dw);
+ camel_medium_set_content ((CamelMedium *)opart, dw);
camel_mime_part_set_filename(opart, "smime.p7m");
camel_mime_part_set_description(opart, "S/MIME Signed Message");
CamelMimePart *sigpart;
CamelDataWrapper *dw;
- dw = camel_medium_get_content_object((CamelMedium *)ipart);
+ dw = camel_medium_get_content ((CamelMedium *)ipart);
ct = dw->mime_type;
/* FIXME: we should stream this to the decoder */
NULL, NULL, /* password callback */
NULL, NULL); /* decrypt key callback */
- camel_data_wrapper_decode_to_stream(camel_medium_get_content_object((CamelMedium *)sigpart), (CamelStream *)mem);
+ camel_data_wrapper_decode_to_stream(camel_medium_get_content ((CamelMedium *)sigpart), (CamelStream *)mem);
(void)NSS_CMSDecoder_Update(dec, (gchar *) mem->buffer->data, mem->buffer->len);
cmsg = NSS_CMSDecoder_Finish(dec);
if (cmsg == NULL) {
camel_data_wrapper_set_mime_type_field(dw, ct);
camel_content_type_unref(ct);
- camel_medium_set_content_object((CamelMedium *)opart, dw);
+ camel_medium_set_content ((CamelMedium *)opart, dw);
camel_object_unref(dw);
camel_mime_part_set_disposition(opart, "attachment");
/* FIXME: stream this to the decoder incrementally */
istream = (CamelStreamMem *)camel_stream_mem_new();
- camel_data_wrapper_decode_to_stream(camel_medium_get_content_object((CamelMedium *)ipart), (CamelStream *)istream);
+ camel_data_wrapper_decode_to_stream(camel_medium_get_content ((CamelMedium *)ipart), (CamelStream *)istream);
camel_stream_reset((CamelStream *)istream);
dec = NSS_CMSDecoder_Start(NULL,
typedef struct _CamelSMIMEContext CamelSMIMEContext;
typedef struct _CamelSMIMEContextClass CamelSMIMEContextClass;
+typedef struct _CamelSMIMEContextPrivate CamelSMIMEContextPrivate;
struct _CamelSMIMEContext {
- CamelCipherContext cipher;
-
- struct _CamelSMIMEContextPrivate *priv;
+ CamelCipherContext parent;
+ CamelSMIMEContextPrivate *priv;
};
struct _CamelSMIMEContextClass {
- CamelCipherContextClass cipher_class;
+ CamelCipherContextClass parent_class;
};
CamelType camel_smime_context_get_type(void);
#include <stdio.h>
-#include <glib.h>
-
#include <camel/camel-mime-parser.h>
#include <camel/camel-object.h>
#include <camel/camel-url.h>
G_BEGIN_DECLS
-typedef struct _CamelStoreSummary CamelStoreSummary;
+typedef struct _CamelStoreSummary CamelStoreSummary;
typedef struct _CamelStoreSummaryClass CamelStoreSummaryClass;
+typedef struct _CamelStoreSummaryPrivate CamelStoreSummaryPrivate;
typedef struct _CamelStoreInfo CamelStoreInfo;
struct _CamelStoreSummary {
CamelObject parent;
-
- struct _CamelStoreSummaryPrivate *priv;
+ CamelStoreSummaryPrivate *priv;
/* header info */
guint32 version; /* version of base part of file */
/* for mode_t */
#include <sys/types.h>
-#include <camel/camel-object.h>
+#include <camel/camel-folder.h>
#include <camel/camel-service.h>
+#define CAMEL_STORE_TYPE (camel_store_get_type ())
+#define CAMEL_STORE(obj) (CAMEL_CHECK_CAST((obj), CAMEL_STORE_TYPE, CamelStore))
+#define CAMEL_STORE_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_STORE_TYPE, CamelStoreClass))
+#define CAMEL_IS_STORE(o) (CAMEL_CHECK_TYPE((o), CAMEL_STORE_TYPE))
+
G_BEGIN_DECLS
enum {
struct _CamelFolderInfo *new;
} CamelRenameInfo;
-#define CAMEL_STORE_TYPE (camel_store_get_type ())
-#define CAMEL_STORE(obj) (CAMEL_CHECK_CAST((obj), CAMEL_STORE_TYPE, CamelStore))
-#define CAMEL_STORE_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_STORE_TYPE, CamelStoreClass))
-#define CAMEL_IS_STORE(o) (CAMEL_CHECK_TYPE((o), CAMEL_STORE_TYPE))
-
/* Flags for store flags */
#define CAMEL_STORE_SUBSCRIPTIONS (1 << 0)
#define CAMEL_STORE_VTRASH (1 << 1)
struct _CamelDB;
+typedef struct _CamelStore CamelStore;
+typedef struct _CamelStoreClass CamelStoreClass;
+typedef struct _CamelStorePrivate CamelStorePrivate;
+
struct _CamelStore {
- CamelService parent_object;
- struct _CamelStorePrivate *priv;
+ CamelService parent;
+ CamelStorePrivate *priv;
CamelObjectBag *folders;
struct _CamelDB *cdb_r;
**/
#define CAMEL_STORE_FOLDER_INFO_SUBSCRIPTION_LIST (1 << 4)
-typedef struct {
+struct _CamelStoreClass {
CamelServiceClass parent_class;
- GHashFunc hash_folder_name;
- GCompareFunc compare_folder_name;
-
- CamelFolder * (*get_folder) (CamelStore *store,
- const gchar *folder_name,
- guint32 flags,
- CamelException *ex);
-
- CamelFolder * (*get_inbox) (CamelStore *store, CamelException *ex);
- CamelFolder * (*get_trash) (CamelStore *store, CamelException *ex);
- CamelFolder * (*get_junk) (CamelStore *store, CamelException *ex);
-
- CamelFolderInfo *(*create_folder) (CamelStore *store,
- const gchar *parent_name,
- const gchar *folder_name,
- CamelException *ex);
- void (*delete_folder) (CamelStore *store,
- const gchar *folder_name,
- CamelException *ex);
- void (*rename_folder) (CamelStore *store,
- const gchar *old_name,
- const gchar *new_name,
- CamelException *ex);
-
- void (*sync) (CamelStore *store, gint expunge, CamelException *ex);
-
- CamelFolderInfo *(*get_folder_info) (CamelStore *store,
- const gchar *top,
- guint32 flags,
- CamelException *ex);
- void (*free_folder_info) (CamelStore *store,
- CamelFolderInfo *fi);
-
- gboolean (*folder_subscribed) (CamelStore *store,
- const gchar *folder_name);
- void (*subscribe_folder) (CamelStore *store,
- const gchar *folder_name,
- CamelException *ex);
- void (*unsubscribe_folder) (CamelStore *store,
- const gchar *folder_name,
- CamelException *ex);
- void (*noop) (CamelStore *store,
- CamelException *ex);
-
- gboolean (*can_refresh_folder) (CamelStore *store,
- CamelFolderInfo *info,
- CamelException *ex);
-
-} CamelStoreClass;
-
-/* Standard Camel function */
-CamelType camel_store_get_type (void);
-
-/* public methods */
-CamelFolder * camel_store_get_folder (CamelStore *store,
+ GHashFunc hash_folder_name;
+ GCompareFunc compare_folder_name;
+
+ CamelFolder * (*get_folder) (CamelStore *store,
const gchar *folder_name,
guint32 flags,
CamelException *ex);
-CamelFolder * camel_store_get_inbox (CamelStore *store,
+ CamelFolder * (*get_inbox) (CamelStore *store,
+ CamelException *ex);
+ CamelFolder * (*get_trash) (CamelStore *store,
+ CamelException *ex);
+ CamelFolder * (*get_junk) (CamelStore *store,
CamelException *ex);
-CamelFolder * camel_store_get_trash (CamelStore *store,
+ CamelFolderInfo *
+ (*create_folder) (CamelStore *store,
+ const gchar *parent_name,
+ const gchar *folder_name,
+ CamelException *ex);
+ void (*delete_folder) (CamelStore *store,
+ const gchar *folder_name,
+ CamelException *ex);
+ void (*rename_folder) (CamelStore *store,
+ const gchar *old_name,
+ const gchar *new_name,
+ CamelException *ex);
+ void (*sync) (CamelStore *store,
+ gint expunge,
CamelException *ex);
-CamelFolder * camel_store_get_junk (CamelStore *store,
+ CamelFolderInfo *
+ (*get_folder_info) (CamelStore *store,
+ const gchar *top,
+ guint32 flags,
+ CamelException *ex);
+ void (*free_folder_info) (CamelStore *store,
+ CamelFolderInfo *fi);
+ gboolean (*folder_subscribed) (CamelStore *store,
+ const gchar *folder_name);
+ void (*subscribe_folder) (CamelStore *store,
+ const gchar *folder_name,
+ CamelException *ex);
+ void (*unsubscribe_folder) (CamelStore *store,
+ const gchar *folder_name,
CamelException *ex);
+ void (*noop) (CamelStore *store,
+ CamelException *ex);
+ gboolean (*can_refresh_folder) (CamelStore *store,
+ CamelFolderInfo *info,
+ CamelException *ex);
+};
-CamelFolderInfo *camel_store_create_folder (CamelStore *store,
+CamelType camel_store_get_type (void);
+CamelFolder * camel_store_get_folder (CamelStore *store,
+ const gchar *folder_name,
+ guint32 flags,
+ CamelException *ex);
+CamelFolder * camel_store_get_inbox (CamelStore *store,
+ CamelException *ex);
+CamelFolder * camel_store_get_trash (CamelStore *store,
+ CamelException *ex);
+CamelFolder * camel_store_get_junk (CamelStore *store,
+ CamelException *ex);
+CamelFolderInfo *
+ camel_store_create_folder (CamelStore *store,
const gchar *parent_name,
const gchar *folder_name,
CamelException *ex);
-void camel_store_delete_folder (CamelStore *store,
+void camel_store_delete_folder (CamelStore *store,
const gchar *folder_name,
CamelException *ex);
-void camel_store_rename_folder (CamelStore *store,
+void camel_store_rename_folder (CamelStore *store,
const gchar *old_namein,
const gchar *new_name,
CamelException *ex);
-
-void camel_store_sync (CamelStore *store, gint expunge, CamelException *ex);
-
-CamelFolderInfo *camel_store_get_folder_info (CamelStore *store,
+void camel_store_sync (CamelStore *store,
+ gint expunge,
+ CamelException *ex);
+CamelFolderInfo *
+ camel_store_get_folder_info (CamelStore *store,
const gchar *top,
guint32 flags,
CamelException *ex);
-void camel_store_free_folder_info (CamelStore *store,
+void camel_store_free_folder_info (CamelStore *store,
CamelFolderInfo *fi);
-
-void camel_store_free_folder_info_full (CamelStore *store,
- CamelFolderInfo *fi);
-void camel_store_free_folder_info_nop (CamelStore *store,
- CamelFolderInfo *fi);
-
-CamelFolderInfo *camel_folder_info_new (void);
-void camel_folder_info_free (CamelFolderInfo *fi);
+void camel_store_free_folder_info_full
+ (CamelStore *store,
+ CamelFolderInfo *fi);
+void camel_store_free_folder_info_nop(CamelStore *store,
+ CamelFolderInfo *fi);
+CamelFolderInfo *
+ camel_folder_info_new (void);
+void camel_folder_info_free (CamelFolderInfo *fi);
#ifndef CAMEL_DISABLE_DEPRECATED
-CamelFolderInfo *camel_folder_info_build (GPtrArray *folders,
- const gchar *namespace,
- gchar separator,
- gboolean short_names);
+CamelFolderInfo *camel_folder_info_build (GPtrArray *folders,
+ const gchar *namespace,
+ gchar separator,
+ gboolean short_names);
#endif /* CAMEL_DISABLE_DEPRECATED */
-CamelFolderInfo *camel_folder_info_clone (CamelFolderInfo *fi);
-
-gboolean camel_store_supports_subscriptions (CamelStore *store);
-
-gboolean camel_store_folder_subscribed (CamelStore *store,
- const gchar *folder_name);
-void camel_store_subscribe_folder (CamelStore *store,
- const gchar *folder_name,
- CamelException *ex);
-void camel_store_unsubscribe_folder (CamelStore *store,
- const gchar *folder_name,
- CamelException *ex);
-
-void camel_store_noop (CamelStore *store,
- CamelException *ex);
-
-gint camel_store_folder_uri_equal (CamelStore *store,
- const gchar *uri0,
- const gchar *uri1);
-
-gboolean camel_store_can_refresh_folder (CamelStore *store,
- CamelFolderInfo *info,
- CamelException *ex);
+CamelFolderInfo *
+ camel_folder_info_clone (CamelFolderInfo *fi);
+gboolean camel_store_supports_subscriptions
+ (CamelStore *store);
+gboolean camel_store_folder_subscribed (CamelStore *store,
+ const gchar *folder_name);
+void camel_store_subscribe_folder (CamelStore *store,
+ const gchar *folder_name,
+ CamelException *ex);
+void camel_store_unsubscribe_folder (CamelStore *store,
+ const gchar *folder_name,
+ CamelException *ex);
+void camel_store_noop (CamelStore *store,
+ CamelException *ex);
+gint camel_store_folder_uri_equal (CamelStore *store,
+ const gchar *uri0,
+ const gchar *uri1);
+gboolean camel_store_can_refresh_folder (CamelStore *store,
+ CamelFolderInfo *info,
+ CamelException *ex);
G_END_DECLS
G_BEGIN_DECLS
+typedef struct _CamelStreamBuffer CamelStreamBuffer;
+typedef struct _CamelStreamBufferClass CamelStreamBufferClass;
+
typedef enum {
CAMEL_STREAM_BUFFER_BUFFER = 0,
CAMEL_STREAM_BUFFER_NONE,
CAMEL_STREAM_BUFFER_MODE = 0x80
} CamelStreamBufferMode;
-struct _CamelStreamBuffer
-{
- CamelStream parent_object;
+struct _CamelStreamBuffer {
+ CamelStream parent;
/* these are all of course, private */
CamelStream *stream;
guint flags; /* internal flags */
};
-typedef struct {
+struct _CamelStreamBufferClass {
CamelStreamClass parent_class;
- /* Virtual methods */
- void (*init) (CamelStreamBuffer *stream_buffer, CamelStream *stream,
- CamelStreamBufferMode mode);
- void (*init_vbuf) (CamelStreamBuffer *stream_buffer,
- CamelStream *stream, CamelStreamBufferMode mode,
- gchar *buf, guint32 size);
-
-} CamelStreamBufferClass;
-
-/* Standard Camel function */
-CamelType camel_stream_buffer_get_type (void);
-
-/* public methods */
-CamelStream *camel_stream_buffer_new (CamelStream *stream,
- CamelStreamBufferMode mode);
-CamelStream *camel_stream_buffer_new_with_vbuf (CamelStream *stream,
- CamelStreamBufferMode mode,
- gchar *buf, guint32 size);
-
-/* unimplemented
- CamelStream *camel_stream_buffer_set_vbuf (CamelStreamBuffer *b, CamelStreamBufferMode mode, gchar *buf, guint32 size); */
-
-/* read a line of characters */
-gint camel_stream_buffer_gets (CamelStreamBuffer *sbf, gchar *buf, guint max);
+ void (*init) (CamelStreamBuffer *stream_buffer,
+ CamelStream *stream,
+ CamelStreamBufferMode mode);
+ void (*init_vbuf) (CamelStreamBuffer *stream_buffer,
+ CamelStream *stream,
+ CamelStreamBufferMode mode,
+ gchar *buf,
+ guint32 size);
+};
-gchar *camel_stream_buffer_read_line (CamelStreamBuffer *sbf);
+CamelType camel_stream_buffer_get_type (void);
+CamelStream * camel_stream_buffer_new (CamelStream *stream,
+ CamelStreamBufferMode mode);
+CamelStream * camel_stream_buffer_new_with_vbuf
+ (CamelStream *stream,
+ CamelStreamBufferMode mode,
+ gchar *buf,
+ guint32 size);
+gint camel_stream_buffer_gets (CamelStreamBuffer *sbf,
+ gchar *buf,
+ guint max);
+gchar * camel_stream_buffer_read_line (CamelStreamBuffer *sbf);
G_END_DECLS
*
* Returns: a new #CamelStreamFilter object.
**/
-CamelStreamFilter *
-camel_stream_filter_new_with_stream(CamelStream *stream)
+CamelStream *
+camel_stream_filter_new (CamelStream *stream)
{
CamelStreamFilter *new = CAMEL_STREAM_FILTER ( camel_object_new (camel_stream_filter_get_type ()));
new->source = stream;
camel_object_ref ((CamelObject *)stream);
- return new;
+ return CAMEL_STREAM (new);
}
/**
G_BEGIN_DECLS
+typedef struct _CamelStreamFilter CamelStreamFilter;
typedef struct _CamelStreamFilterClass CamelStreamFilterClass;
+typedef struct _CamelStreamFilterPrivate CamelStreamFilterPrivate;
struct _CamelStreamFilter {
CamelStream parent;
CamelStream *source;
- struct _CamelStreamFilterPrivate *priv;
+ CamelStreamFilterPrivate *priv;
};
struct _CamelStreamFilterClass {
CamelStreamClass parent_class;
};
-CamelType camel_stream_filter_get_type (void);
-
-CamelStreamFilter *camel_stream_filter_new_with_stream (CamelStream *stream);
-
-gint camel_stream_filter_add (CamelStreamFilter *stream, CamelMimeFilter *filter);
-void camel_stream_filter_remove (CamelStreamFilter *stream, gint id);
+CamelType camel_stream_filter_get_type (void);
+CamelStream * camel_stream_filter_new (CamelStream *stream);
+gint camel_stream_filter_add (CamelStreamFilter *stream,
+ CamelMimeFilter *filter);
+void camel_stream_filter_remove (CamelStreamFilter *stream,
+ gint id);
G_END_DECLS
G_BEGIN_DECLS
+typedef struct _CamelStreamFs CamelStreamFs;
+typedef struct _CamelStreamFsClass CamelStreamFsClass;
+
struct _CamelStreamFs {
- CamelSeekableStream parent_object;
+ CamelSeekableStream parent;
gint fd; /* file descriptor on the underlying file */
};
-typedef struct {
+struct _CamelStreamFsClass {
CamelSeekableStreamClass parent_class;
+};
-} CamelStreamFsClass;
-
-/* Standard Camel function */
-CamelType camel_stream_fs_get_type (void);
-
-/* public methods */
-CamelStream * camel_stream_fs_new_with_name (const gchar *name, gint flags, mode_t mode);
-CamelStream * camel_stream_fs_new_with_name_and_bounds (const gchar *name, gint flags, mode_t mode,
- off_t start, off_t end);
-
-CamelStream * camel_stream_fs_new_with_fd (gint fd);
-CamelStream * camel_stream_fs_new_with_fd_and_bounds (gint fd, off_t start, off_t end);
+CamelType camel_stream_fs_get_type (void);
+CamelStream * camel_stream_fs_new_with_name (const gchar *name,
+ gint flags,
+ mode_t mode);
+CamelStream * camel_stream_fs_new_with_name_and_bounds
+ (const gchar *name,
+ gint flags,
+ mode_t mode,
+ off_t start,
+ off_t end);
+CamelStream * camel_stream_fs_new_with_fd (gint fd);
+CamelStream * camel_stream_fs_new_with_fd_and_bounds
+ (gint fd,
+ off_t start,
+ off_t end);
G_END_DECLS
G_BEGIN_DECLS
+typedef struct _CamelStreamMem CamelStreamMem;
typedef struct _CamelStreamMemClass CamelStreamMemClass;
struct _CamelStreamMem {
- CamelSeekableStream parent_object;
+ CamelSeekableStream parent;
guint owner:1; /* do we own the buffer? */
guint secure:1; /* do we clear the buffer on finalise (if we own it) */
struct _CamelStreamMemClass {
CamelSeekableStreamClass parent_class;
-
- /* Virtual methods */
};
-/* Standard Camel function */
-CamelType camel_stream_mem_get_type (void);
-
-/* public methods */
-CamelStream *camel_stream_mem_new(void);
-CamelStream *camel_stream_mem_new_with_byte_array(GByteArray *buffer);
-CamelStream *camel_stream_mem_new_with_buffer(const gchar *buffer, gsize len);
-
-/* 'secure' data, currently just clears memory on finalise */
-void camel_stream_mem_set_secure(CamelStreamMem *mem);
-
-/* these are really only here for implementing classes */
-void camel_stream_mem_set_byte_array(CamelStreamMem *mem, GByteArray *buffer);
-void camel_stream_mem_set_buffer(CamelStreamMem *mem, const gchar *buffer, gsize len);
+CamelType camel_stream_mem_get_type (void);
+CamelStream * camel_stream_mem_new (void);
+CamelStream * camel_stream_mem_new_with_byte_array
+ (GByteArray *buffer);
+CamelStream * camel_stream_mem_new_with_buffer(const gchar *buffer,
+ gsize len);
+void camel_stream_mem_set_secure (CamelStreamMem *mem);
+void camel_stream_mem_set_byte_array (CamelStreamMem *mem,
+ GByteArray *buffer);
+void camel_stream_mem_set_buffer (CamelStreamMem *mem,
+ const gchar *buffer,
+ gsize len);
G_END_DECLS
G_BEGIN_DECLS
+typedef struct _CamelStreamNull CamelStreamNull;
typedef struct _CamelStreamNullClass CamelStreamNullClass;
struct _CamelStreamNull {
G_BEGIN_DECLS
-typedef struct _CamelStreamProcessClass CamelStreamProcessClass;
typedef struct _CamelStreamProcess CamelStreamProcess;
+typedef struct _CamelStreamProcessClass CamelStreamProcessClass;
struct _CamelStreamProcess {
CamelStream parent;
CamelStreamClass parent_class;
};
-CamelType camel_stream_process_get_type (void);
-CamelStream *camel_stream_process_new (void);
-gint camel_stream_process_connect(CamelStreamProcess *, const gchar *, const gchar **);
+CamelType 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);
G_END_DECLS
G_BEGIN_DECLS
typedef struct _CamelStreamVFS CamelStreamVFS;
+typedef struct _CamelStreamVFSClass CamelStreamVFSClass;
struct _CamelStreamVFS {
- CamelStream parent_object;
+ CamelStream parent;
GObject *stream;
};
-typedef struct {
+struct _CamelStreamVFSClass {
CamelStreamClass parent_class;
+};
-} CamelStreamVFSClass;
-
-/* Standard Camel function */
CamelType camel_stream_vfs_get_type (void);
/**
G_BEGIN_DECLS
-struct _CamelStream
-{
- CamelObject parent_object;
+typedef struct _CamelStream CamelStream;
+typedef struct _CamelStreamClass CamelStreamClass;
+
+struct _CamelStream {
+ CamelObject parent;
gboolean eos;
};
-typedef struct {
+struct _CamelStreamClass {
CamelObjectClass parent_class;
- /* Virtual methods */
-
- gssize (*read) (CamelStream *stream, gchar *buffer, gsize n);
- gssize (*write) (CamelStream *stream, const gchar *buffer, gsize n);
- gint (*close) (CamelStream *stream);
- gint (*flush) (CamelStream *stream);
- gboolean (*eos) (CamelStream *stream);
- gint (*reset) (CamelStream *stream);
-
-} CamelStreamClass;
-
-/* Standard Camel function */
-CamelType camel_stream_get_type (void);
+ gssize (*read) (CamelStream *stream,
+ gchar *buffer,
+ gsize n);
+ gssize (*write) (CamelStream *stream,
+ const gchar *buffer,
+ gsize n);
+ gint (*close) (CamelStream *stream);
+ gint (*flush) (CamelStream *stream);
+ gboolean (*eos) (CamelStream *stream);
+ gint (*reset) (CamelStream *stream);
+};
-/* public methods */
-gssize camel_stream_read (CamelStream *stream, gchar *buffer, gsize n);
-gssize camel_stream_write (CamelStream *stream, const gchar *buffer, gsize n);
-gint camel_stream_flush (CamelStream *stream);
-gint camel_stream_close (CamelStream *stream);
-gboolean camel_stream_eos (CamelStream *stream);
-gint camel_stream_reset (CamelStream *stream);
+CamelType camel_stream_get_type (void);
+gssize camel_stream_read (CamelStream *stream,
+ gchar *buffer,
+ gsize n);
+gssize camel_stream_write (CamelStream *stream,
+ const gchar *buffer,
+ gsize n);
+gint camel_stream_flush (CamelStream *stream);
+gint camel_stream_close (CamelStream *stream);
+gboolean camel_stream_eos (CamelStream *stream);
+gint camel_stream_reset (CamelStream *stream);
/* utility macros and funcs */
-gssize camel_stream_write_string (CamelStream *stream, const gchar *string);
-gssize camel_stream_printf (CamelStream *stream, const gchar *fmt, ... ) G_GNUC_PRINTF (2, 3);
-gssize camel_stream_vprintf (CamelStream *stream, const gchar *fmt, va_list ap);
+gssize camel_stream_write_string (CamelStream *stream,
+ const gchar *string);
+gssize camel_stream_printf (CamelStream *stream,
+ const gchar *fmt,
+ ... ) G_GNUC_PRINTF (2, 3);
+gssize camel_stream_vprintf (CamelStream *stream,
+ const gchar *fmt,
+ va_list ap);
/* Write a whole stream to another stream, until eof or error on
- * either stream.
- */
-gssize camel_stream_write_to_stream (CamelStream *stream, CamelStream *output_stream);
+ * either stream. */
+gssize camel_stream_write_to_stream (CamelStream *stream,
+ CamelStream *output_stream);
G_END_DECLS
G_BEGIN_DECLS
-struct _CamelTcpStreamRaw
-{
- CamelTcpStream parent_object;
+typedef struct _CamelTcpStreamRaw CamelTcpStreamRaw;
+typedef struct _CamelTcpStreamRawClass CamelTcpStreamRawClass;
+
+struct _CamelTcpStreamRaw {
+ CamelTcpStream parent;
gint sockfd;
#ifdef G_OS_WIN32
#endif
};
-typedef struct {
+struct _CamelTcpStreamRawClass {
CamelTcpStreamClass parent_class;
+};
- /* virtual functions */
-
-} CamelTcpStreamRawClass;
-
-/* Standard Camel function */
CamelType camel_tcp_stream_raw_get_type (void);
/* public methods */
struct _CamelSession;
-struct _CamelTcpStreamSSL {
- CamelTcpStream parent_object;
+typedef struct _CamelTcpStreamSSL CamelTcpStreamSSL;
+typedef struct _CamelTcpStreamSSLClass CamelTcpStreamSSLClass;
+typedef struct _CamelTcpStreamSSLPrivate CamelTcpStreamSSLPrivate;
- struct _CamelTcpStreamSSLPrivate *priv;
+struct _CamelTcpStreamSSL {
+ CamelTcpStream parent;
+ CamelTcpStreamSSLPrivate *priv;
};
-typedef struct {
+struct _CamelTcpStreamSSLClass {
CamelTcpStreamClass parent_class;
+};
- /* virtual functions */
-
-} CamelTcpStreamSSLClass;
-
-/* Standard Camel function */
CamelType camel_tcp_stream_ssl_get_type (void);
/* public methods */
#ifndef CAMEL_TCP_STREAM_H
#define CAMEL_TCP_STREAM_H
-#include <glib.h>
-
#ifndef G_OS_WIN32
#include <sys/types.h>
#include <sys/socket.h>
G_BEGIN_DECLS
+typedef struct _CamelTcpStream CamelTcpStream;
+typedef struct _CamelTcpStreamClass CamelTcpStreamClass;
+
typedef enum {
CAMEL_SOCKOPT_NONBLOCKING, /* nonblocking io */
CAMEL_SOCKOPT_LINGER, /* linger on close if data present */
} CamelSockOptData;
struct _CamelTcpStream {
- CamelStream parent_object;
-
+ CamelStream parent;
};
-typedef struct {
+struct _CamelTcpStreamClass {
CamelStreamClass parent_class;
- /* Virtual methods */
- gint (*connect) (CamelTcpStream *stream, struct addrinfo *host);
- gint (*getsockopt) (CamelTcpStream *stream, CamelSockOptData *data);
- gint (*setsockopt) (CamelTcpStream *stream, const CamelSockOptData *data);
-
- struct sockaddr * (*get_local_address) (CamelTcpStream *stream, socklen_t *len);
- struct sockaddr * (*get_remote_address) (CamelTcpStream *stream, socklen_t *len);
-} CamelTcpStreamClass;
-
-/* Standard Camel function */
-CamelType camel_tcp_stream_get_type (void);
-
-/* public methods */
-gint camel_tcp_stream_connect (CamelTcpStream *stream, struct addrinfo *host);
-gint camel_tcp_stream_getsockopt (CamelTcpStream *stream, CamelSockOptData *data);
-gint camel_tcp_stream_setsockopt (CamelTcpStream *stream, const CamelSockOptData *data);
+ gint (*connect) (CamelTcpStream *stream,
+ struct addrinfo *host);
+ gint (*getsockopt) (CamelTcpStream *stream,
+ CamelSockOptData *data);
+ gint (*setsockopt) (CamelTcpStream *stream,
+ const CamelSockOptData *data);
+ struct sockaddr *
+ (*get_local_address) (CamelTcpStream *stream,
+ socklen_t *len);
+ struct sockaddr *
+ (*get_remote_address) (CamelTcpStream *stream,
+ socklen_t *len);
+};
-struct sockaddr *camel_tcp_stream_get_local_address (CamelTcpStream *stream, socklen_t *len);
-struct sockaddr *camel_tcp_stream_get_remote_address (CamelTcpStream *stream, socklen_t *len);
+CamelType camel_tcp_stream_get_type (void);
+gint camel_tcp_stream_connect (CamelTcpStream *stream,
+ struct addrinfo *host);
+gint camel_tcp_stream_getsockopt (CamelTcpStream *stream,
+ CamelSockOptData *data);
+gint camel_tcp_stream_setsockopt (CamelTcpStream *stream,
+ const CamelSockOptData *data);
+struct sockaddr *
+ camel_tcp_stream_get_local_address
+ (CamelTcpStream *stream,
+ socklen_t *len);
+struct sockaddr *
+ camel_tcp_stream_get_remote_address
+ (CamelTcpStream *stream,
+ socklen_t *len);
G_END_DECLS
/* ********************************************************************** */
-/* "private" data, shared between index/cursor/name classes */
-typedef struct _CamelTextIndexNamePrivate CamelTextIndexNamePrivate;
-
struct _CamelTextIndexNamePrivate {
GString *buffer;
camel_key_t nameid;
/* ****************************** */
-typedef struct _CamelTextIndexCursorPrivate CamelTextIndexCursorPrivate;
-
struct _CamelTextIndexCursorPrivate {
camel_block_t first;
camel_block_t next;
CamelTextIndexCursor *camel_text_index_cursor_new(CamelTextIndex *idx, camel_block_t data);
/* ****************************** */
-typedef struct _CamelTextIndexKeyCursorPrivate CamelTextIndexKeyCursorPrivate;
struct _CamelTextIndexKeyCursorPrivate {
CamelKeyTable *table;
}
static gchar *
-text_index_normalise(CamelIndex *idx, const gchar *in, gpointer data)
+text_index_normalize(CamelIndex *idx, const gchar *in, gpointer data)
{
gchar *word;
CamelBlock *bl;
camel_index_construct((CamelIndex *)idx, path, flags);
- camel_index_set_normalise((CamelIndex *)idx, text_index_normalise, NULL);
+ camel_index_set_normalize((CamelIndex *)idx, text_index_normalize, NULL);
p->blocks = camel_block_file_new(idx->parent.path, flags, CAMEL_TEXT_INDEX_VERSION, CAMEL_BLOCK_SIZE);
link = alloca(strlen(idx->parent.path)+7);
G_BEGIN_DECLS
-typedef struct _CamelTextIndex CamelTextIndex;
+typedef struct _CamelTextIndex CamelTextIndex;
typedef struct _CamelTextIndexClass CamelTextIndexClass;
+typedef struct _CamelTextIndexPrivate CamelTextIndexPrivate;
-typedef struct _CamelTextIndexName CamelTextIndexName;
+typedef struct _CamelTextIndexName CamelTextIndexName;
typedef struct _CamelTextIndexNameClass CamelTextIndexNameClass;
+typedef struct _CamelTextIndexNamePrivate CamelTextIndexNamePrivate;
-typedef struct _CamelTextIndexCursor CamelTextIndexCursor;
+typedef struct _CamelTextIndexCursor CamelTextIndexCursor;
typedef struct _CamelTextIndexCursorClass CamelTextIndexCursorClass;
+typedef struct _CamelTextIndexCursorPrivate CamelTextIndexCursorPrivate;
-typedef struct _CamelTextIndexKeyCursor CamelTextIndexKeyCursor;
+typedef struct _CamelTextIndexKeyCursor CamelTextIndexKeyCursor;
typedef struct _CamelTextIndexKeyCursorClass CamelTextIndexKeyCursorClass;
+typedef struct _CamelTextIndexKeyCursorPrivate CamelTextIndexKeyCursorPrivate;
typedef void (*CamelTextIndexFunc)(CamelTextIndex *idx, const gchar *word, gchar *buffer);
struct _CamelTextIndexCursor {
CamelIndexCursor parent;
-
- struct _CamelTextIndexCursorPrivate *priv;
+ CamelTextIndexCursorPrivate *priv;
};
struct _CamelTextIndexCursorClass {
- CamelIndexCursorClass parent;
+ CamelIndexCursorClass parent_class;
};
CamelType camel_text_index_cursor_get_type(void);
struct _CamelTextIndexKeyCursor {
CamelIndexCursor parent;
-
- struct _CamelTextIndexKeyCursorPrivate *priv;
+ CamelTextIndexKeyCursorPrivate *priv;
};
struct _CamelTextIndexKeyCursorClass {
- CamelIndexCursorClass parent;
+ CamelIndexCursorClass parent_class;
};
CamelType camel_text_index_key_cursor_get_type(void);
struct _CamelTextIndexName {
CamelIndexName parent;
-
- struct _CamelTextIndexNamePrivate *priv;
+ CamelTextIndexNamePrivate *priv;
};
struct _CamelTextIndexNameClass {
- CamelIndexNameClass parent;
+ CamelIndexNameClass parent_class;
};
CamelType camel_text_index_name_get_type(void);
struct _CamelTextIndex {
CamelIndex parent;
-
- struct _CamelTextIndexPrivate *priv;
+ CamelTextIndexPrivate *priv;
};
struct _CamelTextIndexClass {
CamelIndexClass parent_class;
};
-CamelType camel_text_index_get_type (void);
-CamelTextIndex *camel_text_index_new(const gchar *path, gint flags);
+CamelType camel_text_index_get_type (void);
+CamelTextIndex *camel_text_index_new (const gchar *path,
+ gint flags);
/* static utility functions */
-gint camel_text_index_check(const gchar *path);
-gint camel_text_index_rename(const gchar *old, const gchar *new);
-gint camel_text_index_remove(const gchar *old);
-
-void camel_text_index_dump(CamelTextIndex *idx);
-void camel_text_index_info(CamelTextIndex *idx);
-void camel_text_index_validate(CamelTextIndex *idx);
+gint camel_text_index_check (const gchar *path);
+gint camel_text_index_rename (const gchar *old,
+ const gchar *new);
+gint camel_text_index_remove (const gchar *old);
+
+void camel_text_index_dump (CamelTextIndex *idx);
+void camel_text_index_info (CamelTextIndex *idx);
+void camel_text_index_validate (CamelTextIndex *idx);
G_END_DECLS
#ifndef CAMEL_TRANSPORT_H
#define CAMEL_TRANSPORT_H
-#include <glib.h>
+#include <camel/camel-address.h>
+#include <camel/camel-mime-message.h>
#include <camel/camel-service.h>
#define CAMEL_TRANSPORT_TYPE (camel_transport_get_type ())
G_BEGIN_DECLS
+typedef struct _CamelTransport CamelTransport;
+typedef struct _CamelTransportClass CamelTransportClass;
+typedef struct _CamelTransportPrivate CamelTransportPrivate;
+
enum {
CAMEL_TRANSPORT_ARG_FIRST = CAMEL_SERVICE_ARG_FIRST + 100
};
-struct _CamelTransport
-{
- CamelService parent_object;
-
- struct _CamelTransportPrivate *priv;
+struct _CamelTransport {
+ CamelService parent;
+ CamelTransportPrivate *priv;
};
-typedef struct {
+struct _CamelTransportClass {
CamelServiceClass parent_class;
gboolean (*send_to) (CamelTransport *transport,
CamelMimeMessage *message,
CamelAddress *from, CamelAddress *recipients,
CamelException *ex);
-} CamelTransportClass;
+};
/* public methods */
gboolean camel_transport_send_to (CamelTransport *transport,
+++ /dev/null
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-
-/*
- * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU Lesser General Public
- * License as published by the Free Software Foundation.
- *
- * This program 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 program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
- * USA
- */
-
-#if !defined (__CAMEL_H_INSIDE__) && !defined (CAMEL_COMPILATION)
-#error "Only <camel/camel.h> can be included directly."
-#endif
-
-#ifndef CAMEL_TYPES_H
-#define CAMEL_TYPES_H
-
-#include <glib.h>
-
-G_BEGIN_DECLS
-
-typedef struct _CamelAddress CamelAddress;
-typedef struct _CamelDiscoDiary CamelDiscoDiary;
-typedef struct _CamelDiscoFolder CamelDiscoFolder;
-typedef struct _CamelDiscoStore CamelDiscoStore;
-typedef struct _CamelDataWrapper CamelDataWrapper;
-typedef struct _CamelException CamelException;
-typedef struct _CamelFilterDriver CamelFilterDriver;
-typedef struct _CamelFolder CamelFolder;
-typedef struct _CamelFolderSearch CamelFolderSearch;
-typedef struct _CamelFolderSummary CamelFolderSummary;
-typedef struct _CamelInternetAddress CamelInternetAddress;
-typedef struct _CamelMedium CamelMedium;
-typedef struct _CamelMessageContentInfo CamelMessageContentInfo;
-typedef struct _CamelMimeFilter CamelMimeFilter;
-typedef struct _CamelMimeFilterBasic CamelMimeFilterBasic;
-typedef struct _CamelMimeFilterBestenc CamelMimeFilterBestenc;
-typedef struct _CamelMimeFilterCharset CamelMimeFilterCharset;
-typedef struct _CamelMimeFilterChomp CamelMimeFilterChomp;
-typedef struct _CamelMimeFilterIndex CamelMimeFilterIndex;
-typedef struct _CamelMimeFilterLinewrap CamelMimeFilterLinewrap;
-typedef struct _CamelMimeFilterSave CamelMimeFilterSave;
-typedef struct _CamelMimeFilterCRLF CamelMimeFilterCRLF;
-typedef struct _CamelMimeMessage CamelMimeMessage;
-typedef struct _CamelMimeParser CamelMimeParser;
-typedef struct _CamelMimePart CamelMimePart;
-typedef struct _CamelMultipart CamelMultipart;
-typedef struct _CamelNewsAddress CamelNewsAddress;
-typedef struct _CamelSeekableStream CamelSeekableStream;
-typedef struct _CamelSeekableSubstream CamelSeekableSubstream;
-typedef struct _CamelService CamelService;
-typedef struct _CamelSession CamelSession;
-typedef struct _CamelSimpleDataWrapper CamelSimpleDataWrapper;
-typedef struct _CamelStore CamelStore;
-typedef struct _CamelStream CamelStream;
-typedef struct _CamelStreamNull CamelStreamNull;
-typedef struct _CamelStreamBuffer CamelStreamBuffer;
-typedef struct _CamelStreamDataWrapper CamelStreamDataWrapper;
-typedef struct _CamelStreamFilter CamelStreamFilter;
-typedef struct _CamelStreamFs CamelStreamFs;
-typedef struct _CamelStreamMem CamelStreamMem;
-typedef struct _CamelTcpStream CamelTcpStream;
-typedef struct _CamelTcpStreamRaw CamelTcpStreamRaw;
-typedef struct _CamelTcpStreamSSL CamelTcpStreamSSL;
-typedef struct _CamelHttpStream CamelHttpStream;
-typedef struct _CamelTransport CamelTransport;
-
-G_END_DECLS
-
-#endif /* CAMEL_TYPES_H */
#define CAMEL_URL_H
#include <glib.h>
-#include <camel/camel-types.h>
+
+#include <camel/camel-exception.h>
G_BEGIN_DECLS
#ifndef CAMEL_VEE_FOLDER_H
#define CAMEL_VEE_FOLDER_H
-#include <glib.h>
#include <camel/camel-folder.h>
+#include <camel/camel-folder-search.h>
+#include <camel/camel-store.h>
#include <camel/camel-vee-summary.h>
#define CAMEL_VEE_FOLDER(obj) CAMEL_CHECK_CAST (obj, camel_vee_folder_get_type (), CamelVeeFolder)
G_BEGIN_DECLS
-typedef struct _CamelVeeFolder CamelVeeFolder;
+typedef struct _CamelVeeFolder CamelVeeFolder;
typedef struct _CamelVeeFolderClass CamelVeeFolderClass;
+typedef struct _CamelVeeFolderPrivate CamelVeeFolderPrivate;
struct _CamelVeeFolder {
CamelFolder parent;
-
- struct _CamelVeeFolderPrivate *priv;
+ CamelVeeFolderPrivate *priv;
gchar *expression; /* query expression */
#include "camel-db.h"
#include "camel-exception.h"
#include "camel-private.h"
+#include "camel-session.h"
#include "camel-vee-folder.h"
#include "camel-vee-store.h"
#ifndef CAMEL_VEE_STORE_H
#define CAMEL_VEE_STORE_H
-#include <glib.h>
#include <camel/camel-store.h>
#define CAMEL_VEE_STORE(obj) CAMEL_CHECK_CAST (obj, camel_vee_store_get_type (), CamelVeeStore)
G_BEGIN_DECLS
-typedef struct _CamelVeeStore CamelVeeStore;
+typedef struct _CamelVeeStore CamelVeeStore;
typedef struct _CamelVeeStoreClass CamelVeeStoreClass;
/* open mode for folder, vee folder auto-update */
CamelStoreClass parent_class;
};
-CamelType camel_vee_store_get_type (void);
-CamelVeeStore *camel_vee_store_new (void);
+CamelType camel_vee_store_get_type (void);
+CamelVeeStore * camel_vee_store_new (void);
G_END_DECLS
struct _CamelVeeSummaryClass {
CamelFolderSummaryClass parent_class;
-
};
-CamelType camel_vee_summary_get_type (void);
-CamelFolderSummary *camel_vee_summary_new(struct _CamelFolder *parent);
-
-CamelVeeMessageInfo * camel_vee_summary_add(CamelVeeSummary *s, CamelFolderSummary *summary, const gchar *uid, const gchar hash[8]);
-GPtrArray * camel_vee_summary_get_ids (CamelVeeSummary *summary, gchar hash[8]);
-void camel_vee_summary_load_check_unread_vfolder (CamelVeeSummary *vs);
+CamelType camel_vee_summary_get_type (void);
+CamelFolderSummary *
+ camel_vee_summary_new (struct _CamelFolder *parent);
+CamelVeeMessageInfo *
+ camel_vee_summary_add (CamelVeeSummary *s,
+ CamelFolderSummary *summary,
+ const gchar *uid,
+ const gchar hash[8]);
+GPtrArray * camel_vee_summary_get_ids (CamelVeeSummary *summary,
+ gchar hash[8]);
+void camel_vee_summary_load_check_unread_vfolder
+ (CamelVeeSummary *vs);
G_END_DECLS
G_BEGIN_DECLS
-typedef struct _CamelVTrashFolder CamelVTrashFolder;
+typedef struct _CamelVTrashFolder CamelVTrashFolder;
typedef struct _CamelVTrashFolderClass CamelVTrashFolderClass;
-#define CAMEL_VTRASH_NAME ".#evolution/Trash"
-#define CAMEL_VJUNK_NAME ".#evolution/Junk"
+#define CAMEL_VTRASH_NAME ".#evolution/Trash"
+#define CAMEL_VJUNK_NAME ".#evolution/Junk"
typedef enum {
CAMEL_VTRASH_FOLDER_TRASH,
struct _CamelVTrashFolderClass {
CamelVeeFolderClass parent_class;
-
};
-CamelType camel_vtrash_folder_get_type (void);
-
-CamelFolder *camel_vtrash_folder_new (CamelStore *parent_store, camel_vtrash_folder_t type);
+CamelType camel_vtrash_folder_get_type (void);
+CamelFolder * camel_vtrash_folder_new (CamelStore *parent_store,
+ camel_vtrash_folder_t type);
G_END_DECLS
#include <camel/camel-text-index.h>
#include <camel/camel-transport.h>
#include <camel/camel-trie.h>
-#include <camel/camel-types.h>
#include <camel/camel-uid-cache.h>
#include <camel/camel-url.h>
#include <camel/camel-url-scanner.h>
#undef __CAMEL_H_INSIDE__
-#include <glib.h>
-
G_BEGIN_DECLS
gint camel_init (const gchar *certdb_dir, gboolean nss_init);
g_free(state_file);
camel_object_state_read(folder);
- gw_folder->cache = camel_data_cache_new (folder_dir,0 ,ex);
+ gw_folder->cache = camel_data_cache_new (folder_dir ,ex);
if (!gw_folder->cache) {
camel_object_unref (folder);
return NULL;
part = camel_mime_part_new ();
camel_data_wrapper_set_mime_type_field(CAMEL_DATA_WRAPPER (temp_msg), ct);
camel_content_type_unref(ct);
- camel_medium_set_content_object ( CAMEL_MEDIUM (part),CAMEL_DATA_WRAPPER(temp_msg));
+ camel_medium_set_content ( CAMEL_MEDIUM (part),CAMEL_DATA_WRAPPER(temp_msg));
camel_multipart_add_part (multipart,part);
camel_object_unref (temp_msg);
if (e_gw_item_get_security (item))
camel_medium_add_header ( CAMEL_MEDIUM (msg), "Security", e_gw_item_get_security(item));
- camel_medium_set_content_object(CAMEL_MEDIUM (msg), CAMEL_DATA_WRAPPER(multipart));
+ camel_medium_set_content (CAMEL_MEDIUM (msg), CAMEL_DATA_WRAPPER(multipart));
camel_object_unref (multipart);
end:
typedef struct _CamelGroupwiseFolder CamelGroupwiseFolder;
typedef struct _CamelGroupwiseFolderClass CamelGroupwiseFolderClass;
struct _CamelGroupwiseFolder {
- CamelOfflineFolder parent_object;
+ CamelOfflineFolder parent;
struct _CamelGroupwiseFolderPrivate *priv;
};
struct _CamelGroupwiseJournal {
- CamelOfflineJournal parent_object;
+ CamelOfflineJournal parent;
};
typedef struct _CamelGroupwiseStorePrivate CamelGroupwiseStorePrivate;
struct _CamelGroupwiseStore {
- CamelOfflineStore parent_object;
+ CamelOfflineStore parent;
struct _CamelGroupwiseStoreSummary *summary;
camel_folder_summary_clear_db (summary);
/*camel_folder_summary_save (summary);*/
- if (uncache)
- camel_data_cache_clear (((CamelGroupwiseFolder *) summary->folder)->cache, "cache", NULL);
-
if (camel_folder_change_info_changed (changes))
camel_object_trigger_event (summary->folder, "folder_changed", changes);
camel_folder_change_info_free (changes);
G_BEGIN_DECLS
typedef struct {
- CamelTransport parent_object;
+ CamelTransport parent;
gboolean connected;
} CamelGroupwiseTransport;
recipient_list = g_slist_reverse (recipient_list);
/** Get the mime parts from CamelMimemessge **/
- mp = (CamelMultipart *)camel_medium_get_content_object (CAMEL_MEDIUM (message));
+ mp = (CamelMultipart *)camel_medium_get_content (CAMEL_MEDIUM (message));
if (!mp) {
g_warning ("ERROR: Could not get content object");
camel_operation_end (NULL);
CamelDataWrapper *dw = NULL;
CamelContentType *type;
- dw = camel_medium_get_content_object (CAMEL_MEDIUM (message));
+ dw = camel_medium_get_content (CAMEL_MEDIUM (message));
type = camel_mime_part_get_content_type((CamelMimePart *)message);
if (camel_content_type_is (type, "text", "plain")) {
charset = camel_content_type_param (type, "charset");
if (charset && g_ascii_strcasecmp (charset, "US-ASCII") && g_ascii_strcasecmp (charset, "UTF-8")) {
- filter = (CamelMimeFilter *) camel_mime_filter_charset_new_convert (charset, "UTF-8");
- filtered_stream = (CamelStream *) camel_stream_filter_new_with_stream ((CamelStream *) content);
+ filter = camel_mime_filter_charset_new (charset, "UTF-8");
+ filtered_stream = camel_stream_filter_new ((CamelStream *) content);
camel_stream_filter_add ((CamelStreamFilter *) filtered_stream, filter);
camel_object_unref (filter);
} else {
continue;
type = camel_mime_part_get_content_type(part);
- dw = camel_medium_get_content_object (CAMEL_MEDIUM (part));
+ dw = camel_medium_get_content (CAMEL_MEDIUM (part));
if (CAMEL_IS_MULTIPART (dw)) {
- do_multipart (cnc, item, (CamelMultipart *) camel_medium_get_content_object ((CamelMedium *) part), attach_list);
+ do_multipart (cnc, item, (CamelMultipart *) camel_medium_get_content ((CamelMedium *) part), attach_list);
continue;
}
temp_part = camel_multipart_get_part ((CamelMultipart *)dw, 1);
if (temp_part) {
is_alternative = TRUE;
- temp_dw = camel_medium_get_content_object (CAMEL_MEDIUM (temp_part));
+ temp_dw = camel_medium_get_content (CAMEL_MEDIUM (temp_part));
camel_data_wrapper_write_to_stream(temp_dw, (CamelStream *)temp_content);
filename = camel_mime_part_get_filename (temp_part);
disposition = camel_mime_part_get_disposition (temp_part);
charset = camel_content_type_param (type, "charset");
if (charset && g_ascii_strcasecmp (charset, "US-ASCII") && g_ascii_strcasecmp (charset, "UTF-8")) {
- filter = (CamelMimeFilter *) camel_mime_filter_charset_new_convert (charset, "UTF-8");
- filtered_stream = (CamelStream *) camel_stream_filter_new_with_stream ((CamelStream *) content);
+ filter = camel_mime_filter_charset_new (charset, "UTF-8");
+ filtered_stream = camel_stream_filter_new ((CamelStream *) content);
camel_stream_filter_add ((CamelStreamFilter *) filtered_stream, filter);
camel_object_unref (filter);
} else {
CamelImapResponse *response, *response2;
CamelStream *memstream;
CamelMimeFilter *crlf_filter;
- CamelStreamFilter *streamfilter;
+ CamelStream *streamfilter;
GByteArray *ba;
gchar *flagstr, *end;
guint32 flags = 0;
ba = g_byte_array_new ();
camel_stream_mem_set_byte_array (CAMEL_STREAM_MEM (memstream), ba);
- streamfilter = camel_stream_filter_new_with_stream (memstream);
+ streamfilter = camel_stream_filter_new (memstream);
crlf_filter = camel_mime_filter_crlf_new (CAMEL_MIME_FILTER_CRLF_ENCODE,
CAMEL_MIME_FILTER_CRLF_MODE_CRLF_ONLY);
- camel_stream_filter_add (streamfilter, crlf_filter);
+ camel_stream_filter_add (
+ CAMEL_STREAM_FILTER (streamfilter), crlf_filter);
camel_data_wrapper_write_to_stream (CAMEL_DATA_WRAPPER (message),
CAMEL_STREAM (streamfilter));
camel_object_unref (CAMEL_OBJECT (streamfilter));
camel_data_wrapper_set_mime_type_field(content, camel_mime_part_get_content_type(part));
}
- camel_medium_set_content_object (CAMEL_MEDIUM (part), content);
+ camel_medium_set_content (CAMEL_MEDIUM (part), content);
camel_object_unref(content);
camel_multipart_add_part (body_mp, part);
}
camel_data_wrapper_set_mime_type_field(content, camel_mime_part_get_content_type((CamelMimePart *)msg));
- camel_medium_set_content_object (CAMEL_MEDIUM (msg), content);
+ camel_medium_set_content (CAMEL_MEDIUM (msg), content);
camel_object_unref (CAMEL_OBJECT (content));
return msg;
typedef struct _CamelImapFolderPrivate CamelImapFolderPrivate;
struct _CamelImapFolder {
- CamelOfflineFolder parent_object;
+ CamelOfflineFolder parent;
CamelImapFolderPrivate *priv;
};
struct _CamelIMAPJournal {
- CamelOfflineJournal parent_object;
+ CamelOfflineJournal parent;
GHashTable *folders;
GHashTable *uidmap;
typedef struct _CamelImapMessageCacheClass CamelImapMessageCacheClass;
struct _CamelImapMessageCache {
- CamelObject parent_object;
+ CamelObject parent;
gchar *path;
/* parts contains two sorts of objects.
camel_folder_search_construct (new);
- is->cache = camel_data_cache_new(cachedir, 0, NULL);
+ is->cache = camel_data_cache_new(cachedir, NULL);
if (is->cache) {
/* Expire entries after 14 days of inactivity */
camel_data_cache_set_expire_access(is->cache, 60*60*24*14);
}
/* imap needs to treat inbox case insensitive */
-/* we'll assume the names are normalised already */
+/* we'll assume the names are normalized already */
static guint folder_hash(gconstpointer ap)
{
const gchar *a = ap;
#define IMAP_FETCH_MINIMAL_HEADERS 3
struct _CamelImapStore {
- CamelOfflineStore parent_object;
+ CamelOfflineStore parent;
CamelStream *istream;
CamelStream *ostream;
typedef struct _CamelImapWrapperPrivate CamelImapWrapperPrivate;
struct _CamelImapWrapper {
- CamelDataWrapper parent_object;
+ CamelDataWrapper parent;
CamelImapWrapperPrivate *priv;
typedef gboolean (* CamelIMAP4ReconnectFunc) (CamelIMAP4Engine *engine, CamelException *ex);
struct _CamelIMAP4Engine {
- CamelObject parent_object;
+ CamelObject parent;
CamelIMAP4ReconnectFunc reconnect;
gboolean reconnecting;
};
struct _CamelIMAP4Folder {
- CamelOfflineFolder parent_object;
+ CamelOfflineFolder parent;
CamelFolderSearch *search;
};
struct _CamelIMAP4Journal {
- CamelOfflineJournal parent_object;
+ CamelOfflineJournal parent;
GPtrArray *failed;
};
struct _CamelIMAP4Engine;
struct _CamelIMAP4Search {
- CamelFolderSearch parent_object;
+ CamelFolderSearch parent;
struct _CamelIMAP4Engine *engine;
struct _CamelIMAP4Engine;
struct _CamelIMAP4Store {
- CamelOfflineStore parent_object;
+ CamelOfflineStore parent;
struct _CamelIMAP4StoreSummary *summary;
struct _CamelIMAP4Engine *engine;
};
struct _CamelIMAP4Stream {
- CamelStream parent_object;
+ CamelStream parent;
CamelStream *stream;
};
struct _CamelIMAP4Summary {
- CamelFolderSummary parent_object;
+ CamelFolderSummary parent;
guint32 version;
return NULL;
}
- ifolder->cache = camel_data_cache_new (folder_dir, 0, ex);
+ ifolder->cache = camel_data_cache_new (folder_dir, ex);
if (!ifolder->cache) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
_("Could not create cache for %s"),
#define CAMEL_IS_IMAPX_FOLDER(o) (CAMEL_CHECK_TYPE((o), CAMEL_IMAPX_FOLDER_TYPE))
typedef struct _CamelIMAPXFolder {
- CamelOfflineFolder parent_object;
+ CamelOfflineFolder parent;
gchar *raw_name;
CamelDataCache *cache;
return;
}
- filter = (CamelStream *)camel_stream_filter_new_with_stream(stream);
+ filter = camel_stream_filter_new (stream);
camel_object_unref(stream);
canon = camel_mime_filter_canon_new(CAMEL_MIME_FILTER_CANON_CRLF);
camel_stream_filter_add((CamelStreamFilter *)filter, canon);
}
/* imap needs to treat inbox case insensitive */
-/* we'll assume the names are normalised already */
+/* we'll assume the names are normalized already */
static guint
folder_hash(gconstpointer ap)
{
#define IMAPX_USE_IDLE (1 << 7)
typedef struct {
- CamelOfflineStore parent_object;
+ CamelOfflineStore parent;
struct _CamelIMAPXServer *server;
typedef struct _CamelLocalFolderPrivate CamelLocalFolderPrivate;
struct _CamelLocalFolder {
- CamelFolder parent_object;
+ CamelFolder parent;
CamelLocalFolderPrivate *priv;
guint32 flags; /* open mode flags */
G_BEGIN_DECLS
typedef struct {
- CamelStore parent_object;
+ CamelStore parent;
gchar *toplevel_dir;
} CamelLocalStore;
G_BEGIN_DECLS
typedef struct {
- CamelLocalFolder parent_object;
+ CamelLocalFolder parent;
} CamelMaildirFolder;
G_BEGIN_DECLS
typedef struct {
- CamelLocalStore parent_object;
+ CamelLocalStore parent;
} CamelMaildirStore;
goto fail_write;
/* and write the content to the filtering stream, that translates '\nFrom' into '\n>From' */
- filter_stream = (CamelStream *) camel_stream_filter_new_with_stream(output_stream);
+ filter_stream = camel_stream_filter_new (output_stream);
filter_from = (CamelMimeFilter *) camel_mime_filter_from_new();
camel_stream_filter_add((CamelStreamFilter *) filter_stream, filter_from);
camel_object_unref (filter_from);
G_BEGIN_DECLS
typedef struct {
- CamelLocalFolder parent_object;
+ CamelLocalFolder parent;
gint lockfd; /* for when we have a lock on the folder */
} CamelMboxFolder;
G_BEGIN_DECLS
typedef struct {
- CamelLocalStore parent_object;
+ CamelLocalStore parent;
} CamelMboxStore;
G_BEGIN_DECLS
typedef struct {
- CamelLocalFolder parent_object;
+ CamelLocalFolder parent;
} CamelMhFolder;
};
typedef struct {
- CamelLocalStore parent_object;
+ CamelLocalStore parent;
guint32 flags;
} CamelMhStore;
} camel_spool_store_t;
typedef struct {
- CamelMboxStore parent_object;
+ CamelMboxStore parent;
camel_spool_store_t type;
} CamelSpoolStore;
{
CamelNNTPStore *nntp_store = (CamelNNTPStore *) folder->parent_store;
CamelStream *stream = (CamelStream*)nntp_store->stream;
- CamelStreamFilter *filtered_stream;
+ CamelStream *filtered_stream;
CamelMimeFilter *crlffilter;
gint ret;
guint u;
/* setup stream filtering */
crlffilter = camel_mime_filter_crlf_new (CAMEL_MIME_FILTER_CRLF_ENCODE, CAMEL_MIME_FILTER_CRLF_MODE_CRLF_DOTS);
- filtered_stream = camel_stream_filter_new_with_stream (stream);
- camel_stream_filter_add (filtered_stream, crlffilter);
+ filtered_stream = camel_stream_filter_new (stream);
+ camel_stream_filter_add (
+ CAMEL_STREAM_FILTER (filtered_stream), crlffilter);
camel_object_unref (crlffilter);
/* remove mail 'To', 'CC', and 'BCC' headers */
/* setup store-wide cache */
if (nntp_store->cache == NULL) {
- nntp_store->cache = camel_data_cache_new (nntp_store->storage_path, 0, ex);
+ nntp_store->cache = camel_data_cache_new (nntp_store->storage_path, ex);
if (nntp_store->cache == NULL)
return FALSE;
nntp_store->folder_hierarchy_relative = FALSE;
/* setup store-wide cache */
- nntp_store->cache = camel_data_cache_new(nntp_store->storage_path, 0, ex);
+ nntp_store->cache = camel_data_cache_new(nntp_store->storage_path, ex);
if (nntp_store->cache == NULL)
return;
};
struct _CamelNNTPStore {
- CamelDiscoStore parent_object;
+ CamelDiscoStore parent;
CamelNNTPStorePrivate *priv;
/* TODO; somehow work out the limit and use that for proper progress reporting
We need a pointer to the folder perhaps? */
- camel_operation_progress_count(NULL, fi->id);
+ camel_operation_progress (NULL, fi->id);
checksum = g_checksum_new (G_CHECKSUM_MD5);
mp = camel_mime_parser_new();
} CamelPOP3FolderInfo;
typedef struct {
- CamelFolder parent_object;
+ CamelFolder parent;
GPtrArray *uids;
GHashTable *uids_uid; /* messageinfo by uid */
root = camel_session_get_storage_path (session, service, ex);
if (root) {
- store->cache = camel_data_cache_new(root, 0, ex);
+ store->cache = camel_data_cache_new(root, ex);
g_free(root);
if (store->cache) {
/* Default cache expiry - 1 week or not visited in a day */
G_BEGIN_DECLS
typedef struct {
- CamelStore parent_object;
+ CamelStore parent;
CamelPOP3Engine *engine; /* pop processing engine */
struct _camel_header_raw *header, *savedbcc, *n, *tail;
const gchar *from_addr, *addr, **argv;
gint i, len, fd[2], nullfd, wstat;
- CamelStreamFilter *filter;
+ CamelStream *filter;
CamelMimeFilter *crlf;
sigset_t mask, omask;
CamelStream *out;
out = camel_stream_fs_new_with_fd (fd[1]);
/* workaround for lame sendmail implementations that can't handle CRLF eoln sequences */
- filter = camel_stream_filter_new_with_stream (out);
+ filter = camel_stream_filter_new (out);
crlf = camel_mime_filter_crlf_new (CAMEL_MIME_FILTER_CRLF_DECODE, CAMEL_MIME_FILTER_CRLF_MODE_CRLF_ONLY);
- camel_stream_filter_add (filter, crlf);
+ camel_stream_filter_add (CAMEL_STREAM_FILTER (filter), crlf);
camel_object_unref (crlf);
camel_object_unref (out);
G_BEGIN_DECLS
typedef struct {
- CamelTransport parent_object;
+ CamelTransport parent;
} CamelSendmailTransport;
CamelException *ex)
{
CamelSmtpTransport *smtp_transport = CAMEL_SMTP_TRANSPORT (transport);
- const CamelInternetAddress *cia;
+ CamelInternetAddress *cia;
gboolean has_8bit_parts;
const gchar *addr;
gint i, len;
{
struct _camel_header_raw *header, *savedbcc, *n, *tail;
CamelBestencEncoding enctype = CAMEL_BESTENC_8BIT;
- CamelStreamFilter *filtered_stream;
+ CamelStream *filtered_stream;
gchar *cmdbuf, *respbuf = NULL;
CamelMimeFilter *filter;
CamelStreamNull *null;
null = CAMEL_STREAM_NULL (camel_stream_null_new ());
camel_data_wrapper_write_to_stream (CAMEL_DATA_WRAPPER (message), CAMEL_STREAM (null));
- filtered_stream = camel_stream_filter_new_with_stream (transport->ostream);
+ filtered_stream = camel_stream_filter_new (transport->ostream);
/* setup progress reporting for message sending... */
filter = camel_mime_filter_progress_new (NULL, null->written);
- camel_stream_filter_add (filtered_stream, filter);
+ camel_stream_filter_add (CAMEL_STREAM_FILTER (filtered_stream), filter);
camel_object_unref (filter);
camel_object_unref (null);
/* setup LF->CRLF conversion */
filter = camel_mime_filter_crlf_new (CAMEL_MIME_FILTER_CRLF_ENCODE, CAMEL_MIME_FILTER_CRLF_MODE_CRLF_DOTS);
- camel_stream_filter_add (filtered_stream, filter);
+ camel_stream_filter_add (CAMEL_STREAM_FILTER (filtered_stream), filter);
camel_object_unref (filter);
/* write the message */
G_BEGIN_DECLS
typedef struct {
- CamelTransport parent_object;
+ CamelTransport parent;
CamelStream *istream, *ostream;
content = g_strdup_printf("Test message %08x contents\n\n", id+i);
push("comparing content '%s': '%s'", res->pdata[0], content);
- test_message_compare_content(camel_medium_get_content_object((CamelMedium *)msg), content, strlen(content));
+ test_message_compare_content(camel_medium_get_content ((CamelMedium *)msg), content, strlen(content));
test_free(content);
pull();
camel_data_wrapper_set_mime_type (dw, type);
camel_data_wrapper_construct_from_stream(dw, (CamelStream *)content);
- camel_medium_set_content_object((CamelMedium *)part, dw);
+ camel_medium_set_content ((CamelMedium *)part, dw);
check_unref(content, 2);
check_unref(dw, 2);
printf("msg2:\n");
test_message_dump_structure(msg2);
- content = camel_medium_get_content_object ((CamelMedium *) msg);
+ content = camel_medium_get_content ((CamelMedium *) msg);
}
check_unref(msg2, 1);
printf("%s encoding: %s\n", s, camel_transfer_encoding_to_string(((CamelDataWrapper *)part)->encoding));
printf("%s part encoding: %s\n", s, camel_transfer_encoding_to_string(part->encoding));
- containee = camel_medium_get_content_object (CAMEL_MEDIUM (part));
+ containee = camel_medium_get_content (CAMEL_MEDIUM (part));
if (containee == NULL)
return;
#define CAMEL_TEST_IS_SESSION(o) (CAMEL_CHECK_TYPE((o), CAMEL_TEST_SESSION_TYPE))
typedef struct _CamelTestSession {
- CamelSession parent_object;
+ CamelSession parent;
} CamelTestSession;
pull();
push("compare original content");
- test_message_compare_content(camel_medium_get_content_object((CamelMedium *)msg), text, len);
+ test_message_compare_content(camel_medium_get_content ((CamelMedium *)msg), text, len);
pull();
push("save message to test1.msg");
pull();
push("compare read with original content");
- test_message_compare_content(camel_medium_get_content_object((CamelMedium *)msg2), text, len);
+ test_message_compare_content(camel_medium_get_content ((CamelMedium *)msg2), text, len);
check_unref(msg2, 1);
pull();
pull();
push("compare read with original content");
- test_message_compare_content(camel_medium_get_content_object((CamelMedium *)msg2), text, len);
+ test_message_compare_content(camel_medium_get_content ((CamelMedium *)msg2), text, len);
check_unref(msg2, 1);
pull();
camel_multipart_set_boundary(mp, "_=,.XYZ_Kangaroo_Meat_is_!_ABADF00D");
check(strcmp(camel_multipart_get_boundary(mp), "_=,.XYZ_Kangaroo_Meat_is_!_ABADF00D") == 0);
- camel_medium_set_content_object((CamelMedium *)msg, (CamelDataWrapper *)mp);
+ camel_medium_set_content ((CamelMedium *)msg, (CamelDataWrapper *)mp);
check(camel_multipart_get_number(mp) == 0);
check(camel_multipart_get_part(mp, 0) == NULL);
check(camel_multipart_get_part(mp, 1) == NULL);
pull();
push("compre content of multipart");
- mp2 = (CamelMultipart *)camel_medium_get_content_object((CamelMedium *)msg2);
+ mp2 = (CamelMultipart *)camel_medium_get_content ((CamelMedium *)msg2);
check(mp2 != NULL);
check(CAMEL_IS_MULTIPART(mp2));
check(camel_multipart_get_number(mp2) == 3);
check_msg(mp2->postface == NULL || strlen(mp2->postface) == 0, "postface: '%s'", mp2->postface);
camel_test_fatal();
- test_message_compare_content(camel_medium_get_content_object(CAMEL_MEDIUM(camel_multipart_get_part(mp2, 0))),
+ test_message_compare_content(camel_medium_get_content (CAMEL_MEDIUM(camel_multipart_get_part(mp2, 0))),
"content part 1", strlen("content part 1"));
- test_message_compare_content(camel_medium_get_content_object(CAMEL_MEDIUM(camel_multipart_get_part(mp2, 1))),
+ test_message_compare_content(camel_medium_get_content (CAMEL_MEDIUM(camel_multipart_get_part(mp2, 1))),
"content part 3", strlen("content part 3"));
- test_message_compare_content(camel_medium_get_content_object(CAMEL_MEDIUM(camel_multipart_get_part(mp2, 2))),
+ test_message_compare_content(camel_medium_get_content (CAMEL_MEDIUM(camel_multipart_get_part(mp2, 2))),
"content part 2", strlen("content part 2"));
pull();
msg3 = test_message_read_file("test3-2.msg");
push("comparing again");
- mp2 = (CamelMultipart *)camel_medium_get_content_object((CamelMedium *)msg3);
+ mp2 = (CamelMultipart *)camel_medium_get_content ((CamelMedium *)msg3);
check(mp2 != NULL);
check(CAMEL_IS_MULTIPART(mp2));
check(camel_multipart_get_number(mp2) == 3);
check_msg(mp2->postface == NULL || strlen(mp2->postface) == 0, "postface: '%s'", mp2->postface);
- test_message_compare_content(camel_medium_get_content_object(CAMEL_MEDIUM(camel_multipart_get_part(mp2, 0))),
+ test_message_compare_content(camel_medium_get_content (CAMEL_MEDIUM(camel_multipart_get_part(mp2, 0))),
"content part 1", strlen("content part 1"));
- test_message_compare_content(camel_medium_get_content_object(CAMEL_MEDIUM(camel_multipart_get_part(mp2, 1))),
+ test_message_compare_content(camel_medium_get_content (CAMEL_MEDIUM(camel_multipart_get_part(mp2, 1))),
"content part 3", strlen("content part 3"));
- test_message_compare_content(camel_medium_get_content_object(CAMEL_MEDIUM(camel_multipart_get_part(mp2, 2))),
+ test_message_compare_content(camel_medium_get_content (CAMEL_MEDIUM(camel_multipart_get_part(mp2, 2))),
"content part 2", strlen("content part 2"));
pull();
pull();
test_message_write_file(msg, "test3-3.msg");
msg2 = test_message_read_file("test3-3.msg");
- mp2 = (CamelMultipart *)camel_medium_get_content_object((CamelMedium *)msg2);
+ mp2 = (CamelMultipart *)camel_medium_get_content ((CamelMedium *)msg2);
check(mp2 != NULL);
check(CAMEL_IS_MULTIPART(mp2));
check(camel_multipart_get_number(mp2) == 3);
check(strcmp(camel_multipart_get_boundary(mp2), "_=,.XYZ_Kangaroo_Meat_is_!_ABADF00D") == 0);
check(mp2->preface && strcmp(mp2->preface, "pre-text\nLines.") == 0);
check(mp2->postface && strcmp(mp2->postface, "post-text, no lines.\nOne line.\n") == 0);
- test_message_compare_content(camel_medium_get_content_object(CAMEL_MEDIUM(camel_multipart_get_part(mp2, 0))),
+ test_message_compare_content(camel_medium_get_content (CAMEL_MEDIUM(camel_multipart_get_part(mp2, 0))),
"content part 1", strlen("content part 1"));
- test_message_compare_content(camel_medium_get_content_object(CAMEL_MEDIUM(camel_multipart_get_part(mp2, 1))),
+ test_message_compare_content(camel_medium_get_content (CAMEL_MEDIUM(camel_multipart_get_part(mp2, 1))),
"content part 3", strlen("content part 3"));
- test_message_compare_content(camel_medium_get_content_object(CAMEL_MEDIUM(camel_multipart_get_part(mp2, 2))),
+ test_message_compare_content(camel_medium_get_content (CAMEL_MEDIUM(camel_multipart_get_part(mp2, 2))),
"content part 2", strlen("content part 2"));
pull();
check_unref(msg2, 1);
conpart = camel_mime_part_new();
dw = camel_data_wrapper_new();
camel_data_wrapper_construct_from_stream(dw, stream1);
- camel_medium_set_content_object((CamelMedium *)conpart, dw);
+ camel_medium_set_content ((CamelMedium *)conpart, dw);
camel_object_unref(stream1);
camel_object_unref(dw);
dw = camel_data_wrapper_new();
camel_stream_reset(stream1);
camel_data_wrapper_construct_from_stream(dw, stream1);
- camel_medium_set_content_object((CamelMedium *)conpart, dw);
+ camel_medium_set_content ((CamelMedium *)conpart, dw);
camel_object_unref(stream1);
camel_object_unref(dw);
</para>
-@parent_object:
+@parent:
@priv:
@filename:
@version:
</para>
-@parent_object:
+@parent:
@priv:
@session:
@sign_protocol:
</para>
-@parent_object:
+@parent:
@priv:
@path:
-@flags:
@expire_age:
@expire_access:
</para>
@path:
-@flags:
@ex:
@Returns:
@when:
-<!-- ##### FUNCTION camel_data_cache_rename ##### -->
-<para>
-
-</para>
-
-@cache:
-@old:
-@new:
-@ex:
-@Returns:
-
-
<!-- ##### FUNCTION camel_data_cache_add ##### -->
<para>
@Returns:
-<!-- ##### FUNCTION camel_data_cache_clear ##### -->
-<para>
-
-</para>
-
-@cache:
-@path:
-@ex:
-@Returns:
-
-
<!-- ##### FUNCTION camel_data_cache_get_filename ##### -->
<para>
</para>
-@parent_object:
+@parent:
@priv:
@encoding:
@mime_type:
</para>
-@parent_object:
+@parent:
@store:
@file:
@folders:
</para>
-@parent_object:
+@parent:
@offline_sync:
<!-- ##### FUNCTION camel_disco_folder_expunge_uids ##### -->
</para>
-@parent_object:
+@parent:
@status:
@diary:
@content_info_chunks:
@summary_path:
@build_content:
-@messages:
-@messages_uid:
@uids:
@loaded_infos:
@folder:
</para>
-@parent_object:
+@parent:
@priv:
@name:
@full_name:
</para>
-@Param1:
+@folder:
@uids:
-@Param3:
+@ex:
@Returns:
</para>
-@parent_object:
+@parent:
@always_trust:
<!-- ##### FUNCTION camel_gpg_context_new ##### -->
</para>
-@ctx:
-@trust:
+@context:
+@always_trust:
</para>
-@parent_object:
+@parent:
@priv:
@search:
@journal:
</para>
-@parent_object:
+@parent:
<!-- ##### STRUCT CamelGroupwiseJournalEntry ##### -->
<para>
</para>
-@parent_object:
+@parent:
@summary:
@root_container:
@priv:
</para>
-@parent_object:
+@parent:
@connected:
</para>
-@parent_object:
+@parent:
@parser:
@content_type:
@headers:
</para>
-@parent_object:
+@parent:
@priv:
@search:
@cache:
</para>
-@parent_object:
+@parent:
@folders:
@uidmap:
@rp_in_progress:
</para>
-@parent_object:
+@parent:
@path:
@parts:
@cached:
</para>
-@parent_object:
+@parent:
@istream:
@ostream:
@summary:
</para>
-@parent_object:
+@parent:
@priv:
@folder:
@uid:
</para>
-@parent_object:
+@parent:
@reconnect:
@reconnecting:
@session:
</para>
-@parent_object:
+@parent:
@search:
@journal:
@cache:
</para>
-@parent_object:
+@parent:
@failed:
<!-- ##### STRUCT CamelIMAP4JournalEntry ##### -->
</para>
-@parent_object:
+@parent:
@engine:
@lastuid:
@validity:
</para>
-@parent_object:
+@parent:
@summary:
@engine:
@storage_path:
</para>
-@parent_object:
+@parent:
@stream:
@disconnected:
@have_unget:
</para>
-@parent_object:
+@parent:
@version:
@exists:
@recent:
@version:
@flags:
@state:
-@normalise:
-@normalise_data:
+@normalize:
+@normalize_data:
<!-- ##### USER_FUNCTION CamelIndexNorm ##### -->
<para>
</para>
-@idx:
+@index:
@word:
@data:
@Returns:
</para>
-@idx:
+@index:
@name:
@Returns:
</para>
-@idx:
+@index:
@name:
@Returns:
</para>
-@Param1:
+@index:
@path:
@flags:
</para>
-@Param1:
+@index:
@path:
@Returns:
-<!-- ##### FUNCTION camel_index_set_normalise ##### -->
-<para>
-
-</para>
-
-@idx:
-@func:
-@data:
-
-
<!-- ##### FUNCTION camel_index_sync ##### -->
<para>
</para>
-@idx:
+@index:
@Returns:
</para>
-@idx:
+@index:
@Returns:
</para>
-@idx:
+@index:
@Returns:
</para>
-@idx:
+@index:
@name:
@Returns:
</para>
-@idx:
+@index:
@name:
@Returns:
</para>
-@idx:
+@index:
@idn:
@Returns:
</para>
-@idx:
+@index:
@name:
@Returns:
</para>
-@idx:
+@index:
@name:
</para>
-@idx:
+@index:
@word:
@Returns:
</para>
-@idx:
+@index:
@Returns:
</para>
-@idx:
+@index:
@Returns:
</para>
-@parent_object:
+@parent:
@priv:
@flags:
@locked:
</para>
-@parent_object:
+@parent:
@toplevel_dir:
<!-- ##### FUNCTION camel_local_store_get_toplevel_dir ##### -->
</para>
-@parent_object:
+@parent:
<!-- ##### FUNCTION camel_maildir_folder_new ##### -->
<para>
</para>
-@parent_object:
+@parent:
</para>
-@parent_object:
+@parent:
@lockfd:
<!-- ##### FUNCTION camel_mbox_folder_new ##### -->
</para>
-@parent_object:
+@parent:
</para>
-@parent_object:
+@parent:
@content:
<!-- ##### STRUCT CamelMediumHeader ##### -->
@headers:
-<!-- ##### FUNCTION camel_medium_get_content_object ##### -->
-<para>
-
-</para>
-
-@medium:
-@Returns:
-
-
-<!-- ##### FUNCTION camel_medium_set_content_object ##### -->
-<para>
-
-</para>
-
-@medium:
-@content:
-
-
</para>
-@parent_object:
+@parent:
<!-- ##### FUNCTION camel_mh_folder_new ##### -->
<para>
</para>
-@parent_object:
+@parent:
@flags:
</para>
-@Returns:
-
-
-<!-- ##### FUNCTION camel_mime_filter_basic_new_type ##### -->
-<para>
-
-</para>
-
@type:
@Returns:
</para>
-@Returns:
-
-
-<!-- ##### FUNCTION camel_mime_filter_charset_new_convert ##### -->
-<para>
-
-</para>
-
@from_charset:
@to_charset:
@Returns:
</para>
-@parent_object:
+@parent:
@flags:
@nofill:
</para>
-@parent_object:
+@parent:
@priv:
@mode:
@level:
</para>
-@Returns:
-
-
-<!-- ##### FUNCTION camel_mime_filter_index_new_index ##### -->
-<para>
-
-</para>
-
@index:
@Returns:
</para>
-@Returns:
-
-
-<!-- ##### FUNCTION camel_mime_filter_save_new_with_stream ##### -->
-<para>
-
-</para>
-
@stream:
@Returns:
@parent:
@scanner:
@flags:
-@colour:
+@color:
@column:
@pre_open:
</para>
@flags:
-@colour:
+@color:
@Returns:
@in:
@flags:
-@colour:
+@color:
@Returns:
</para>
-@parent_object:
+@parent:
@direction:
@part:
@state:
</para>
-@parent_object:
+@parent:
@date:
@date_offset:
@date_received:
</para>
-@parent_object:
+@parent:
@headers:
@description:
@disposition:
@Returns:
-<!-- ##### FUNCTION camel_mime_part_set_content_MD5 ##### -->
-<para>
-
-</para>
-
-@mime_part:
-@md5sum:
-
-
-<!-- ##### FUNCTION camel_mime_part_get_content_MD5 ##### -->
-<para>
-
-</para>
-
-@mime_part:
-@Returns:
-
-
<!-- ##### FUNCTION camel_mime_part_set_content_location ##### -->
<para>
</para>
-@Param1:
+@mime_part:
@mp:
</para>
-@msg:
+@mime_part:
@info:
@Returns:
</para>
-@parent_object:
+@parent:
@version:
@content:
@decrypted:
</para>
-@parent_object:
+@parent:
@content:
@signature:
@contentraw:
</para>
-@parent_object:
+@parent:
@parts:
@preface:
@postface:
</para>
-@parent_object:
+@parent:
@priv:
@extensions:
@posting_allowed:
</para>
-@parent_object:
+@parent:
@sync_offline:
<!-- ##### FUNCTION camel_offline_folder_downsync ##### -->
</para>
-@parent_object:
+@parent:
@folder:
@filename:
@queue:
</para>
-@parent_object:
+@parent:
@state:
<!-- ##### FUNCTION camel_offline_store_set_network_state ##### -->
@cc:
-<!-- ##### FUNCTION camel_operation_cancel_block ##### -->
-<para>
-
-</para>
-
-@cc:
-
-
-<!-- ##### FUNCTION camel_operation_cancel_unblock ##### -->
-<para>
-
-</para>
-
-@cc:
-
-
<!-- ##### FUNCTION camel_operation_cancel_check ##### -->
<para>
@pc:
-<!-- ##### FUNCTION camel_operation_progress_count ##### -->
-<para>
-
-</para>
-
-@cc:
-@sofar:
-
-
<!-- ##### FUNCTION camel_operation_end ##### -->
<para>
</para>
-@parent_object:
+@parent:
@uids:
@uids_uid:
@uids_id:
</para>
-@parent_object:
+@parent:
@engine:
@cache:
@delete_after:
</para>
-@parent_object:
+@parent:
@trace_info:
@type:
</para>
-@parent_object:
+@parent:
<!-- ##### VARIABLE camel_sasl_cram_md5_authtype ##### -->
<para>
</para>
-@parent_object:
+@parent:
@priv:
<!-- ##### VARIABLE camel_sasl_digest_md5_authtype ##### -->
</para>
-@parent_object:
+@parent:
@priv:
<!-- ##### VARIABLE camel_sasl_gssapi_authtype ##### -->
</para>
-@parent_object:
+@parent:
@priv:
<!-- ##### VARIABLE camel_sasl_login_authtype ##### -->
</para>
-@parent_object:
+@parent:
<!-- ##### VARIABLE camel_sasl_ntlm_authtype ##### -->
<para>
</para>
-@parent_object:
+@parent:
<!-- ##### VARIABLE camel_sasl_plain_authtype ##### -->
<para>
</para>
-@parent_object:
+@parent:
<!-- ##### VARIABLE camel_sasl_popb4smtp_authtype ##### -->
<para>
</para>
-@parent_object:
+@parent:
@service_name:
@mech:
@service:
</para>
-@parent_object:
+@parent:
@position:
@bound_start:
@bound_end:
</para>
-@parent_object:
+@parent:
@parent_stream:
<!-- ##### FUNCTION camel_seekable_substream_new ##### -->
</para>
-@parent_object:
+@parent:
</para>
-@parent_object:
+@parent:
@priv:
@session:
@provider:
</para>
-@parent_object:
+@parent:
@priv:
@storage_path:
@junk_plugin:
</para>
-@cipher:
+@parent:
@priv:
<!-- ##### ENUM camel_smime_sign_t ##### -->
</para>
-@parent_object:
+@parent:
@istream:
@ostream:
@flags:
</para>
-@parent_object:
+@parent:
@type:
<!-- ##### ENUM camel_spool_store_t ##### -->
</para>
-@parent_object:
+@parent:
@priv:
@folders:
@cdb_r:
</para>
-@parent_object:
+@parent:
@stream:
@buf:
@ptr:
@source:
@priv:
-<!-- ##### FUNCTION camel_stream_filter_new_with_stream ##### -->
-<para>
-
-</para>
-
-@stream:
-@Returns:
-
-
<!-- ##### FUNCTION camel_stream_filter_add ##### -->
<para>
</para>
-@parent_object:
+@parent:
@fd:
<!-- ##### FUNCTION camel_stream_fs_new_with_name ##### -->
</para>
-@parent_object:
+@parent:
@owner:
@secure:
@buffer:
</para>
-@Param1:
-@Param2:
-@Param3:
+@stream:
+@command:
+@env:
@Returns:
</para>
-@parent_object:
+@parent:
@stream:
<!-- ##### ENUM CamelStreamVFSOpenMethod ##### -->
</para>
-@parent_object:
+@parent:
@eos:
<!-- ##### FUNCTION camel_stream_read ##### -->
</para>
-@parent_object:
+@parent:
@sockfd:
@is_nonblocking:
</para>
-@parent_object:
+@parent:
@priv:
<!-- ##### MACRO CAMEL_TCP_STREAM_SSL_ENABLE_SSL2 ##### -->
</para>
-@parent_object:
+@parent:
<!-- ##### ENUM CamelSockOpt ##### -->
<para>
</para>
-@parent_object:
+@parent:
@priv:
<!-- ##### FUNCTION camel_transport_send_to ##### -->
@Returns:
+<!-- ##### FUNCTION camel_data_cache_clear ##### -->
+<para>
+
+</para>
+
+@cache:
+@path:
+@ex:
+@Returns:
+
+<!-- ##### FUNCTION camel_data_cache_rename ##### -->
+<para>
+
+</para>
+
+@cache:
+@old:
+@new:
+@ex:
+@Returns:
+
<!-- ##### FUNCTION camel_digest_folder_new ##### -->
<para>
@Returns:
+<!-- ##### FUNCTION camel_index_set_normalise ##### -->
+<para>
+
+</para>
+
+@idx:
+@func:
+@data:
+
<!-- ##### FUNCTION camel_interface_cast ##### -->
<para>
@buf:
@len:
+<!-- ##### FUNCTION camel_medium_get_content_object ##### -->
+<para>
+
+</para>
+
+@medium:
+@Returns:
+
+<!-- ##### FUNCTION camel_medium_set_content_object ##### -->
+<para>
+
+</para>
+
+@medium:
+@content:
+
+<!-- ##### FUNCTION camel_mime_filter_basic_new_type ##### -->
+<para>
+
+</para>
+
+@type:
+@Returns:
+
+<!-- ##### FUNCTION camel_mime_filter_charset_new_convert ##### -->
+<para>
+
+</para>
+
+@from_charset:
+@to_charset:
+@Returns:
+
+<!-- ##### FUNCTION camel_mime_filter_index_new_index ##### -->
+<para>
+
+</para>
+
+@index:
+@Returns:
+
+<!-- ##### FUNCTION camel_mime_filter_save_new_with_stream ##### -->
+<para>
+
+</para>
+
+@stream:
+@Returns:
+
+<!-- ##### FUNCTION camel_mime_part_get_content_MD5 ##### -->
+<para>
+
+</para>
+
+@mime_part:
+@Returns:
+
+<!-- ##### FUNCTION camel_mime_part_set_content_MD5 ##### -->
+<para>
+
+</para>
+
+@mime_part:
+@md5sum:
+
<!-- ##### FUNCTION camel_mkdir ##### -->
<para>
@name:
@Returns:
+<!-- ##### FUNCTION camel_operation_cancel_block ##### -->
+<para>
+
+</para>
+
+@cc:
+
+<!-- ##### FUNCTION camel_operation_cancel_unblock ##### -->
+<para>
+
+</para>
+
+@cc:
+
+<!-- ##### FUNCTION camel_operation_progress_count ##### -->
+<para>
+
+</para>
+
+@cc:
+@sofar:
+
<!-- ##### FUNCTION camel_partition_table_get_type ##### -->
<para>
@type:
@words:
+<!-- ##### FUNCTION camel_stream_filter_new_with_stream ##### -->
+<para>
+
+</para>
+
+@stream:
+@Returns:
+
<!-- ##### FUNCTION camel_stream_vfs_new_with_handle ##### -->
<para>
</para>
-@parent_object:
+@parent:
<!-- ##### FUNCTION camel_test_session_new ##### -->
<para>
projects / platform / upstream / evolution-data-server.git / commitdiff