From 8cb514d6dd9497893a35a089d07a132d51263ee7 Mon Sep 17 00:00:00 2001 From: Peter Williams Date: Thu, 10 Aug 2000 17:30:50 +0000 Subject: Merge with camel-async. svn path=/trunk/; revision=4687 --- camel/.cvsignore | 1 + camel/ChangeLog | 170 +++- camel/Makefile.am | 8 +- camel/camel-address.c | 68 +- camel/camel-address.h | 6 +- camel/camel-data-wrapper.c | 66 +- camel/camel-data-wrapper.h | 10 +- camel/camel-folder-search.c | 94 +- camel/camel-folder-search.h | 6 +- camel/camel-folder-summary.c | 106 +-- camel/camel-folder-summary.h | 6 +- camel/camel-folder.c | 636 ++++++++------ camel/camel-folder.h | 20 +- camel/camel-internet-address.c | 53 +- camel/camel-internet-address.h | 6 +- camel/camel-medium.c | 75 +- camel/camel-medium.h | 10 +- camel/camel-mime-filter-basic.c | 86 +- camel/camel-mime-filter-basic.h | 6 +- camel/camel-mime-filter-charset.c | 48 +- camel/camel-mime-filter-charset.h | 6 +- camel/camel-mime-filter-crlf.c | 28 +- camel/camel-mime-filter-crlf.h | 8 +- camel/camel-mime-filter-from.c | 48 +- camel/camel-mime-filter-from.h | 7 +- camel/camel-mime-filter-index.c | 50 +- camel/camel-mime-filter-index.h | 6 +- camel/camel-mime-filter-save.c | 46 +- camel/camel-mime-filter-save.h | 6 +- camel/camel-mime-filter.c | 97 +-- camel/camel-mime-filter.h | 9 +- camel/camel-mime-message.c | 75 +- camel/camel-mime-message.h | 10 +- camel/camel-mime-parser.c | 84 +- camel/camel-mime-parser.h | 6 +- camel/camel-mime-part-utils.c | 20 +- camel/camel-mime-part.c | 82 +- camel/camel-mime-part.h | 10 +- camel/camel-movemail.c | 8 +- camel/camel-multipart.c | 84 +- camel/camel-multipart.h | 10 +- camel/camel-news-address.c | 51 +- camel/camel-news-address.h | 6 +- camel/camel-object.c | 949 ++++++++++++++++++++- camel/camel-object.h | 138 ++- camel/camel-provider.h | 4 +- camel/camel-seekable-stream.c | 33 +- camel/camel-seekable-stream.h | 10 +- camel/camel-seekable-substream.c | 61 +- camel/camel-seekable-substream.h | 10 +- camel/camel-service.c | 74 +- camel/camel-service.h | 12 +- camel/camel-session.c | 104 ++- camel/camel-session.h | 32 +- camel/camel-store.c | 91 +- camel/camel-store.h | 11 +- camel/camel-stream-buffer.c | 86 +- camel/camel-stream-buffer.h | 10 +- camel/camel-stream-filter.c | 101 +-- camel/camel-stream-filter.h | 6 +- camel/camel-stream-fs.c | 56 +- camel/camel-stream-fs.h | 10 +- camel/camel-stream-mem.c | 52 +- camel/camel-stream-mem.h | 10 +- camel/camel-stream.c | 34 +- camel/camel-stream.h | 10 +- camel/camel-transport.c | 28 +- camel/camel-transport.h | 10 +- camel/camel-types.h | 1 - camel/providers/Makefile.am | 1 + camel/providers/imap/camel-imap-folder.c | 73 +- camel/providers/imap/camel-imap-folder.h | 11 +- camel/providers/imap/camel-imap-store.c | 84 +- camel/providers/imap/camel-imap-store.h | 12 +- camel/providers/imap/camel-imap-stream.c | 52 +- camel/providers/imap/camel-imap-stream.h | 10 +- camel/providers/mbox/camel-mbox-folder.c | 485 ++++++----- camel/providers/mbox/camel-mbox-folder.h | 11 +- camel/providers/mbox/camel-mbox-store.c | 34 +- camel/providers/mbox/camel-mbox-store.h | 11 +- camel/providers/mbox/camel-mbox-summary.c | 494 ++++++----- camel/providers/mbox/camel-mbox-summary.h | 7 +- camel/providers/mh/camel-mh-folder.c | 64 +- camel/providers/mh/camel-mh-folder.h | 11 +- camel/providers/mh/camel-mh-store.c | 44 +- camel/providers/mh/camel-mh-store.h | 11 +- camel/providers/mh/camel-mh-summary.c | 44 +- camel/providers/mh/camel-mh-summary.h | 9 +- camel/providers/nntp/Makefile.am | 5 +- camel/providers/nntp/camel-nntp-folder.c | 52 +- camel/providers/nntp/camel-nntp-folder.h | 11 +- camel/providers/nntp/camel-nntp-provider.c | 7 +- camel/providers/nntp/camel-nntp-store.c | 46 +- camel/providers/nntp/camel-nntp-store.h | 11 +- camel/providers/pop3/camel-pop3-folder.c | 42 +- camel/providers/pop3/camel-pop3-folder.h | 11 +- camel/providers/pop3/camel-pop3-store.c | 38 +- camel/providers/pop3/camel-pop3-store.h | 11 +- .../providers/sendmail/camel-sendmail-transport.c | 30 +- .../providers/sendmail/camel-sendmail-transport.h | 10 +- camel/providers/smtp/camel-smtp-transport.c | 38 +- camel/providers/smtp/camel-smtp-transport.h | 10 +- camel/providers/vee/camel-vee-folder.c | 61 +- camel/providers/vee/camel-vee-folder.h | 7 +- camel/providers/vee/camel-vee-store.c | 50 +- camel/providers/vee/camel-vee-store.h | 7 +- 106 files changed, 3455 insertions(+), 2641 deletions(-) (limited to 'camel') diff --git a/camel/.cvsignore b/camel/.cvsignore index fd6b811c68..521f6065df 100644 --- a/camel/.cvsignore +++ b/camel/.cvsignore @@ -5,3 +5,4 @@ Makefile.in .deps *.lo *.la +temp-test diff --git a/camel/ChangeLog b/camel/ChangeLog index 7152df91ba..ce492be3e7 100644 --- a/camel/ChangeLog +++ b/camel/ChangeLog @@ -61,6 +61,15 @@ (camel_tag_list_size): (camel_tag_list_free): Operations for working with CamelTags. +2000-08-09 Peter Williams + + * camel-store.c (camel_store_get_folder): Connect beforehand, if + necessary. + + * providers/imap/camel-imap-store.c (camel_imap_store_init): Default + the dir_sep to "/" so that certain functions can safely assume that + dir_sep is valid (at least, nonnull). + 2000-08-09 Ettore Perazzoli * providers/nntp/camel-nntp-folder.c @@ -92,35 +101,22 @@ * camel-mime-message.c (process_header): Add another subject g_strstrip that fejj's earlier commit missed. -2000-08-07 Not Zed - - * providers/mh/camel-mh-folder.c (mh_append_message): Only retry - another uid if we had a name clash, otherwise fail. - -2000-08-04 Not Zed - - * camel-url.c (camel_url_set_protocol): - (camel_url_set_host): - (camel_url_set_path): - (camel_url_set_port): Url editing functions. - -2000-08-02 Not Zed - - * providers/mh/camel-mh-summary.c (camel_mh_summary_sync): Expunge - from the end, so the index isn't messed up when you remove a - message. +2000-08-08 Peter Williams - * providers/mh/camel-mh-folder.c (mh_append_message): Fix a bug - where it would never open an output file/uid. + * camel-provider.h: Remove some GTK stuff that I missed. - * providers/mbox/camel-mbox-store.c (rename_folder): - Implementation for mbox as well. + * providers/imap/camel-imap-store.c (imap_noop): Turn this + back on with the new timeout interface in CamelSession. - * camel-store.c (camel_store_rename_folder): New method to rename folders. - (rename_folder): Default implementation. + * camel-session.[ch] (camel_session_register_timeout): New + interface for Camel to register timeouts. Basically the + GTK timeout interface is copied. We do this because Camel isn't + allowed to use GTK anymore. + +2000-08-07 Not Zed - * providers/mh/camel-mh-store.c (delete_folder): Implement this. - (rename_folder): Implement a rename operation. + * providers/mh/camel-mh-folder.c (mh_append_message): Only retry + another uid if we had a name clash, otherwise fail. 2000-08-07 Jeffrey Stedfast @@ -132,6 +128,14 @@ * providers/imap/camel-imap-utils.c (imap_parse_list_response): Check for NIL as a directory separator. +2000-08-07 Peter Williams + + * providers/nntp/Makefile.am: Reorder the INCLUDES to pull + in the camel headers from the local source tree before + the ones in $(includedir). This was causing compile problems + because the installed, Gtk-based camel-object.h was included + before the uninstall Camel-based one. + 2000-08-07 Jeffrey Stedfast * providers/imap/camel-imap-utils.c (imap_translate_sexp): Strip @@ -160,6 +164,18 @@ * providers/imap/camel-imap-store.c (get_folder): Prevent a coredump when get_folder()ing from a store with dir_sep = NULL. +2000-08-04 Peter Williams + + * camel-store.h: Include camel-object.h. Ettore said this wasn't + compiling. + +2000-08-04 Not Zed + + * camel-url.c (camel_url_set_protocol): + (camel_url_set_host): + (camel_url_set_path): + (camel_url_set_port): Url editing functions. + 2000-08-04 Dan Winship * providers/pop3/camel-pop3-folder.c (pop3_set_message_flags): @@ -182,6 +198,24 @@ * providers/nntp/Makefile.am (INCLUDES): Add -I$(top_srcdir) to pull in libibex/ibex.h +2000-08-02 Not Zed + + * providers/mh/camel-mh-summary.c (camel_mh_summary_sync): Expunge + from the end, so the index isn't messed up when you remove a + message. + + * providers/mh/camel-mh-folder.c (mh_append_message): Fix a bug + where it would never open an output file/uid. + + * providers/mbox/camel-mbox-store.c (rename_folder): + Implementation for mbox as well. + + * camel-store.c (camel_store_rename_folder): New method to rename folders. + (rename_folder): Default implementation. + + * providers/mh/camel-mh-store.c (delete_folder): Implement this. + (rename_folder): Implement a rename operation. + 2000-08-02 Dan Winship * providers/MH: Kill this. It doesn't have any code to do anything @@ -540,6 +574,19 @@ (imap_get_message_info): Oops. Fix UID parser to allow 0 and 9 to be in the range of valid UID chars. +2000-07-20 Peter Williams + + * camel-object.c (camel_object_unref): Add a new global mutex + 'refcount' held when refcounting operations occur. + +2000-07-19 Peter Williams + + * camel-object.c (camel_type_lock_up): Correct the recursiveness; + the locklevel is stored as a private, so each thread has its own + idea of the locklevel. Thus one thread can relock, but a different + one will think that it's a level 0 and try to lock the type_system + mutex. + 2000-07-19 Jeffrey Stedfast * providers/imap/camel-imap-folder.c: General cleanup working @@ -578,6 +625,16 @@ (imap_get_subfolder_names): Let the subfolder parser trim the namespace off the folder name. +2000-07-17 Peter Williams + + * camel-object.c (camel_type_lock_up): New function; the + Camel type_system lock is now fakey-recursive, being controlled + by a semaphore that goes up and down and is protected by another + lock. Theoretically all we need is the lock on the semaphore, + but this we catch exceptions "better" (by deadlocking). + (camel_type_lock_down): Corresponding to above. + (all functions): s,G_LOCK,camel_type_lock_up, etc. + 2000-07-17 Jeffrey Stedfast * providers/imap/camel-imap-store.c (imap_disconnect): Send a @@ -617,6 +674,31 @@ * providers/imap/camel-imap-folder.c (camel_imap_folder_new): One last fix to get rid of hard-coded "/" directory separators +2000-07-14 Peter Williams + + * camel-object.c : Implement 'events', which are suspiciously + like signals except without all the marshalling baggage, and + with quasi-thread-safety. + (camel_object_class_declare_event): New func. + (camel_object_hook_event): Ditto. + (camel_object_trigger_event): Ditto. + (obj_class_init): Declare the "finalize" event. + (obj_class_finalize): Free the hashtable of events->preps + (obj_finalize): Free the hashtable of events->hooklists + (camel_object_unref): Trigger the finalize event (ourselves, + to prevent massively unpleasant looping things.) + +2000-07-14 Peter Williams + + * camel-object.c (make_global_classfuncs): Change to return + a CamelObjectClass. Change parents to a GSList and free it + when done. + (camel_object_new): Don't allocate a classfuncs for every object; + merely give it a reference to the global_classfuncs. Convert + parents to a GSList and free it when done. + (camel_object_unref): Don't free the classfuncs. Free the parents + list, which is changed to a GSList. + 2000-07-14 Jeffrey Stedfast * string-utils.c (string_unquote): New convenience function @@ -634,6 +716,30 @@ Deals with the case where the user edits the mbox and makes it bigger, without adding new messages. +2000-07-13 Peter Williams + + * camel-object.c: Rewritten to not be based on GtkObject, + but a tiny threadsafe ripoff thereof. Objects still cannot + be shared across threads, but ref/unref/destroy/new/etc + will work. Signals are not implemented because doing it + robustly would be a major pain in the butt, but class + functions are. There's a small demonstration that it doesn't + crash in ./temp-test.c: build it with ./make-test.sh. + * camel-stream.c, camel-seekable-stream.c, camel-stream-mem.c: + moved over to CamelObject. Proof of concept: two levels of + subclass and class functions, all working without coredumps. + To port to CamelObject: + - s,GTK_,CAMEL_,g in the cast checks + - s,gtk_type_new,camel_object_new,g + - s,GtkType,CamelType,g + - Change get_type function over to camel_type_declare + - instead of hooking to finalize function, it goes into the + type declaration. + - remove signals. + - instead of GTK_OBJECT(so)->klass, CAMEL_OBJECT_GET_CLASS(so) + - s,gtk_type_class,camel_type_get_global_classfuncs,g + - don't chain finalize handlers; it will be done for you + 2000-07-13 Jeffrey Stedfast * providers/imap/camel-imap-folder.c: @@ -834,6 +940,20 @@ * providers/imap/camel-imap-folder.c (imap_append_message): Updated. +2000-07-11 Dan Winship + + * camel-folder.c: Remove exceptions from a number of methods + that work on what ought to be static data: get_parent_folder, + get_parent_store, get_message_count, get_unread_message_count, + get_permanent_flags, get_message_flags, set_message_flags, + get_message_user_flag, set_message_user_flag, get_message_uid, + get_uids, get_summary, get_subfolder_names. Turn + camel_folder_delete_message into a macro. + + * providers/{mbox,pop3,vee}: Update for CamelFolder changes + + * providers/Makefile.am: Disable imap and nntp for now + 2000-07-11 Jeffrey Stedfast * providers/imap/camel-imap-folder.c (imap_search_by_expression): diff --git a/camel/Makefile.am b/camel/Makefile.am index a265d3a027..4d2c29a4ca 100644 --- a/camel/Makefile.am +++ b/camel/Makefile.am @@ -7,10 +7,10 @@ providerdir = $(libdir)/evolution/camel-providers/$(VERSION) lib_LTLIBRARIES = libcamel.la -INCLUDES = -I.. -I$(srcdir)/.. -I$(includedir) \ - -I$(top_srcdir)/intl \ - $(GTK_INCLUDEDIR) \ - $(UNICODE_CFLAGS) \ +INCLUDES = -I.. -I$(srcdir)/.. -I$(includedir) \ + -I$(top_srcdir)/intl \ + $(GLIB_CFLAGS) \ + $(UNICODE_CFLAGS) \ -DCAMEL_PROVIDERDIR=\""$(providerdir)"\" \ -DG_LOG_DOMAIN=\"camel\" diff --git a/camel/camel-address.c b/camel/camel-address.c index 8056c121c8..8f7cea3d67 100644 --- a/camel/camel-address.c +++ b/camel/camel-address.c @@ -23,48 +23,14 @@ static void camel_address_class_init (CamelAddressClass *klass); static void camel_address_init (CamelAddress *obj); -static void camel_address_finalise (GtkObject *obj); +static void camel_address_finalize (CamelObject *obj); static CamelObjectClass *camel_address_parent; -enum SIGNALS { - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = { 0 }; - -guint -camel_address_get_type (void) -{ - static guint type = 0; - - if (!type) { - GtkTypeInfo type_info = { - "CamelAddress", - sizeof (CamelAddress), - sizeof (CamelAddressClass), - (GtkClassInitFunc) camel_address_class_init, - (GtkObjectInitFunc) camel_address_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_object_get_type (), &type_info); - } - - return type; -} - static void camel_address_class_init (CamelAddressClass *klass) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; - - camel_address_parent = gtk_type_class (camel_object_get_type ()); - - object_class->finalize = camel_address_finalise; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); + camel_address_parent = camel_type_get_global_classfuncs (camel_object_get_type ()); } static void @@ -74,11 +40,27 @@ camel_address_init (CamelAddress *obj) } static void -camel_address_finalise (GtkObject *obj) +camel_address_finalize (CamelObject *obj) { camel_address_remove((CamelAddress *)obj, -1); +} - ((GtkObjectClass *)(camel_address_parent))->finalize((GtkObject *)obj); +CamelType +camel_address_get_type (void) +{ + static CamelType type = CAMEL_INVALID_TYPE; + + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_object_get_type (), "CamelAddress", + sizeof (CamelAddress), + sizeof (CamelAddressClass), + (CamelObjectClassInitFunc) camel_address_class_init, + NULL, + (CamelObjectInitFunc) camel_address_init, + (CamelObjectFinalizeFunc) camel_address_finalize); + } + + return type; } /** @@ -91,7 +73,7 @@ camel_address_finalise (GtkObject *obj) CamelAddress * camel_address_new (void) { - CamelAddress *new = CAMEL_ADDRESS ( gtk_type_new (camel_address_get_type ())); + CamelAddress *new = CAMEL_ADDRESS ( camel_object_new (camel_address_get_type ())); return new; } @@ -111,7 +93,7 @@ camel_address_decode (CamelAddress *a, const char *raw) { g_return_val_if_fail(IS_CAMEL_ADDRESS(a), -1); - return ((CamelAddressClass *)((GtkObject *)a)->klass)->decode(a, raw); + return CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (a))->decode(a, raw); } /** @@ -127,7 +109,7 @@ camel_address_encode (CamelAddress *a) { g_return_val_if_fail(IS_CAMEL_ADDRESS(a), NULL); - return ((CamelAddressClass *)((GtkObject *)a)->klass)->encode(a); + return CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (a))->encode(a); } /** @@ -144,8 +126,8 @@ camel_address_remove (CamelAddress *a, int index) if (index == -1) { for (index=a->addresses->len; index>-1; index--) - ((CamelAddressClass *)((GtkObject *)a)->klass)->remove(a, index); + CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (a))->remove(a, index); } else { - ((CamelAddressClass *)((GtkObject *)a)->klass)->remove(a, index); + CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (a))->remove(a, index); } } diff --git a/camel/camel-address.h b/camel/camel-address.h index d035f20e00..a2d6fe34dd 100644 --- a/camel/camel-address.h +++ b/camel/camel-address.h @@ -23,9 +23,9 @@ #include -#define CAMEL_ADDRESS(obj) GTK_CHECK_CAST (obj, camel_address_get_type (), CamelAddress) -#define CAMEL_ADDRESS_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_address_get_type (), CamelAddressClass) -#define IS_CAMEL_ADDRESS(obj) GTK_CHECK_TYPE (obj, camel_address_get_type ()) +#define CAMEL_ADDRESS(obj) CAMEL_CHECK_CAST (obj, camel_address_get_type (), CamelAddress) +#define CAMEL_ADDRESS_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_address_get_type (), CamelAddressClass) +#define IS_CAMEL_ADDRESS(obj) CAMEL_CHECK_TYPE (obj, camel_address_get_type ()) typedef struct _CamelAddressClass CamelAddressClass; diff --git a/camel/camel-data-wrapper.c b/camel/camel-data-wrapper.c index 94c222e9a4..52cf60bd33 100644 --- a/camel/camel-data-wrapper.c +++ b/camel/camel-data-wrapper.c @@ -33,7 +33,7 @@ static CamelObjectClass *parent_class = NULL; /* Returns the class for a CamelDataWrapper */ -#define CDW_CLASS(so) CAMEL_DATA_WRAPPER_CLASS (GTK_OBJECT (so)->klass) +#define CDW_CLASS(so) CAMEL_DATA_WRAPPER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static int construct_from_stream(CamelDataWrapper *, CamelStream *); @@ -42,15 +42,11 @@ static void set_mime_type (CamelDataWrapper *data_wrapper, const gchar *mime_typ static gchar *get_mime_type (CamelDataWrapper *data_wrapper); static GMimeContentField *get_mime_type_field (CamelDataWrapper *data_wrapper); static void set_mime_type_field (CamelDataWrapper *data_wrapper, GMimeContentField *mime_type); -static void finalize (GtkObject *object); static void camel_data_wrapper_class_init (CamelDataWrapperClass *camel_data_wrapper_class) { - GtkObjectClass *gtk_object_class = - GTK_OBJECT_CLASS (camel_data_wrapper_class); - - parent_class = gtk_type_class (camel_object_get_type ()); + parent_class = camel_type_get_global_classfuncs (camel_object_get_type ()); /* virtual method definition */ camel_data_wrapper_class->write_to_stream = write_to_stream; @@ -60,9 +56,6 @@ camel_data_wrapper_class_init (CamelDataWrapperClass *camel_data_wrapper_class) camel_data_wrapper_class->set_mime_type_field = set_mime_type_field; camel_data_wrapper_class->construct_from_stream = construct_from_stream; - - /* virtual method overload */ - gtk_object_class->finalize = finalize; } static void @@ -73,35 +66,8 @@ camel_data_wrapper_init (gpointer object, gpointer klass) camel_data_wrapper->mime_type = gmime_content_field_new (NULL, NULL); } - - -GtkType -camel_data_wrapper_get_type (void) -{ - static GtkType camel_data_wrapper_type = 0; - - if (!camel_data_wrapper_type) { - GtkTypeInfo camel_data_wrapper_info = - { - "CamelDataWrapper", - sizeof (CamelDataWrapper), - sizeof (CamelDataWrapperClass), - (GtkClassInitFunc) camel_data_wrapper_class_init, - (GtkObjectInitFunc) camel_data_wrapper_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_data_wrapper_type = gtk_type_unique (camel_object_get_type (), &camel_data_wrapper_info); - } - - return camel_data_wrapper_type; -} - - static void -finalize (GtkObject *object) +camel_data_wrapper_finalize (CamelObject *object) { CamelDataWrapper *camel_data_wrapper = CAMEL_DATA_WRAPPER (object); @@ -109,9 +75,25 @@ finalize (GtkObject *object) gmime_content_field_unref (camel_data_wrapper->mime_type); if (camel_data_wrapper->stream) - gtk_object_unref (GTK_OBJECT (camel_data_wrapper->stream)); + camel_object_unref (CAMEL_OBJECT (camel_data_wrapper->stream)); +} - GTK_OBJECT_CLASS (parent_class)->finalize (object); +CamelType +camel_data_wrapper_get_type (void) +{ + static CamelType camel_data_wrapper_type = CAMEL_INVALID_TYPE; + + if (camel_data_wrapper_type == CAMEL_INVALID_TYPE) { + camel_data_wrapper_type = camel_type_register (CAMEL_OBJECT_TYPE, "CamelDataWrapper", + sizeof (CamelDataWrapper), + sizeof (CamelDataWrapperClass), + (CamelObjectClassInitFunc) camel_data_wrapper_class_init, + NULL, + (CamelObjectInitFunc) camel_data_wrapper_init, + (CamelObjectFinalizeFunc) camel_data_wrapper_finalize); + } + + return camel_data_wrapper_type; } static int @@ -130,7 +112,7 @@ write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream) CamelDataWrapper * camel_data_wrapper_new(void) { - return (CamelDataWrapper *)gtk_type_new(camel_data_wrapper_get_type()); + return (CamelDataWrapper *)camel_object_new(camel_data_wrapper_get_type()); } /** @@ -160,10 +142,10 @@ static int construct_from_stream (CamelDataWrapper *data_wrapper, CamelStream *stream) { if (data_wrapper->stream) - gtk_object_unref((GtkObject *)data_wrapper->stream); + camel_object_unref((CamelObject *)data_wrapper->stream); data_wrapper->stream = stream; - gtk_object_ref (GTK_OBJECT (stream)); + camel_object_ref (CAMEL_OBJECT (stream)); return 0; } diff --git a/camel/camel-data-wrapper.h b/camel/camel-data-wrapper.h index 8df09fa848..4a3074ae20 100644 --- a/camel/camel-data-wrapper.h +++ b/camel/camel-data-wrapper.h @@ -38,9 +38,9 @@ extern "C" { #include #define CAMEL_DATA_WRAPPER_TYPE (camel_data_wrapper_get_type ()) -#define CAMEL_DATA_WRAPPER(obj) (GTK_CHECK_CAST((obj), CAMEL_DATA_WRAPPER_TYPE, CamelDataWrapper)) -#define CAMEL_DATA_WRAPPER_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_DATA_WRAPPER_TYPE, CamelDataWrapperClass)) -#define CAMEL_IS_DATA_WRAPPER(o) (GTK_CHECK_TYPE((o), CAMEL_DATA_WRAPPER_TYPE)) +#define CAMEL_DATA_WRAPPER(obj) (CAMEL_CHECK_CAST((obj), CAMEL_DATA_WRAPPER_TYPE, CamelDataWrapper)) +#define CAMEL_DATA_WRAPPER_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_DATA_WRAPPER_TYPE, CamelDataWrapperClass)) +#define CAMEL_IS_DATA_WRAPPER(o) (CAMEL_CHECK_TYPE((o), CAMEL_DATA_WRAPPER_TYPE)) struct _CamelDataWrapper { @@ -72,8 +72,8 @@ typedef struct { CamelStream *); } CamelDataWrapperClass; -/* Standard Gtk function */ -GtkType camel_data_wrapper_get_type (void); +/* Standard Camel function */ +CamelType camel_data_wrapper_get_type (void); /* public methods */ CamelDataWrapper * camel_data_wrapper_new(void); diff --git a/camel/camel-folder-search.c b/camel/camel-folder-search.c index 5c6fa111bb..c15b6d7d40 100644 --- a/camel/camel-folder-search.c +++ b/camel/camel-folder-search.c @@ -48,54 +48,19 @@ static ESExpResult *search_dummy(struct _ESExp *f, int argc, struct _ESExpResult static void camel_folder_search_class_init (CamelFolderSearchClass *klass); static void camel_folder_search_init (CamelFolderSearch *obj); -static void camel_folder_search_finalise (GtkObject *obj); +static void camel_folder_search_finalize (CamelObject *obj); static CamelObjectClass *camel_folder_search_parent; -enum SIGNALS { - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = { 0 }; - -guint -camel_folder_search_get_type (void) -{ - static guint type = 0; - - if (!type) { - GtkTypeInfo type_info = { - "CamelFolderSearch", - sizeof (CamelFolderSearch), - sizeof (CamelFolderSearchClass), - (GtkClassInitFunc) camel_folder_search_class_init, - (GtkObjectInitFunc) camel_folder_search_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_object_get_type (), &type_info); - } - - return type; -} - static void camel_folder_search_class_init (CamelFolderSearchClass *klass) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; - - camel_folder_search_parent = gtk_type_class (camel_object_get_type ()); - - object_class->finalize = camel_folder_search_finalise; + camel_folder_search_parent = camel_type_get_global_classfuncs (camel_object_get_type ()); klass->match_all = search_match_all; klass->body_contains = search_body_contains; klass->header_contains = search_header_contains; - klass->user_flag = search_user_flag; klass->user_flag = search_user_tag; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); } static void @@ -109,51 +74,72 @@ camel_folder_search_init (CamelFolderSearch *obj) } static void -camel_folder_search_finalise (GtkObject *obj) +camel_folder_search_finalize (CamelObject *obj) { CamelFolderSearch *search = (CamelFolderSearch *)obj; if (search->sexp) - gtk_object_unref((GtkObject *)search->sexp); + camel_object_unref((CamelObject *)search->sexp); g_free(search->last_search); +} - ((GtkObjectClass *)(camel_folder_search_parent))->finalize((GtkObject *)obj); +CamelType +camel_folder_search_get_type (void) +{ + static CamelType type = CAMEL_INVALID_TYPE; + + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_object_get_type (), "CamelFolderSearch", + sizeof (CamelFolderSearch), + sizeof (CamelFolderSearchClass), + (CamelObjectClassInitFunc) camel_folder_search_class_init, + NULL, + (CamelObjectInitFunc) camel_folder_search_init, + (CamelObjectFinalizeFunc) camel_folder_search_finalize); + } + + return type; } +#ifdef offsetof +#define CAMEL_STRUCT_OFFSET(type, field) ((gint) offsetof (type, field)) +#else +#define CAMEL_STRUCT_OFFSET(type, field) ((gint) ((gchar*) &((type *) 0)->field)) +#endif + struct { char *name; int offset; int flags; /* 0x02 = immediate, 0x01 = always enter */ } builtins[] = { /* these have default implementations in e-sexp */ - { "and", GTK_STRUCT_OFFSET(CamelFolderSearchClass, and), 2 }, - { "or", GTK_STRUCT_OFFSET(CamelFolderSearchClass, or), 2 }, - { "not", GTK_STRUCT_OFFSET(CamelFolderSearchClass, not), 2 }, - { "<", GTK_STRUCT_OFFSET(CamelFolderSearchClass, lt), 2 }, - { ">", GTK_STRUCT_OFFSET(CamelFolderSearchClass, gt), 2 }, - { "=", GTK_STRUCT_OFFSET(CamelFolderSearchClass, eq), 2 }, + { "and", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, and), 2 }, + { "or", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, or), 2 }, + { "not", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, not), 2 }, + { "<", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, lt), 2 }, + { ">", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, gt), 2 }, + { "=", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, eq), 2 }, /* these we have to use our own default if there is none */ /* they should all be defined in the language? so it poarses, or should they not?? */ - { "match-all", GTK_STRUCT_OFFSET(CamelFolderSearchClass, match_all), 3 }, - { "body-contains", GTK_STRUCT_OFFSET(CamelFolderSearchClass, body_contains), 1 }, - { "header-contains", GTK_STRUCT_OFFSET(CamelFolderSearchClass, header_contains), 1 }, - { "user-flag", GTK_STRUCT_OFFSET(CamelFolderSearchClass, user_flag), 1 }, - { "user-tag", GTK_STRUCT_OFFSET(CamelFolderSearchClass, user_flag), 1 }, + { "match-all", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, match_all), 3 }, + { "body-contains", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, body_contains), 1 }, + { "header-contains", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, header_contains), 1 }, + { "user-tag", CAMEL_STRUCT_OFFSET(CamelFolderSearchClass, user_flag), 1 }, }; void camel_folder_search_construct (CamelFolderSearch *search) { int i; - CamelFolderSearchClass *klass = (CamelFolderSearchClass *)GTK_OBJECT(search)->klass; + CamelFolderSearchClass *klass = (CamelFolderSearchClass *)CAMEL_OBJECT_GET_CLASS(search); for (i=0;iklass->type)); + g_warning("Search class doesn't implement '%s' method: %s", builtins[i].name, camel_type_to_name(CAMEL_OBJECT_GET_CLASS(search)->s.type)); func = (void *)search_dummy; } if (func != NULL) { @@ -181,7 +167,7 @@ camel_folder_search_construct (CamelFolderSearch *search) CamelFolderSearch * camel_folder_search_new (void) { - CamelFolderSearch *new = CAMEL_FOLDER_SEARCH ( gtk_type_new (camel_folder_search_get_type ())); + CamelFolderSearch *new = CAMEL_FOLDER_SEARCH ( camel_object_new (camel_folder_search_get_type ())); camel_folder_search_construct(new); return new; diff --git a/camel/camel-folder-search.h b/camel/camel-folder-search.h index 61c8d52a07..d1f165d842 100644 --- a/camel/camel-folder-search.h +++ b/camel/camel-folder-search.h @@ -28,9 +28,9 @@ #include #include -#define CAMEL_FOLDER_SEARCH(obj) GTK_CHECK_CAST (obj, camel_folder_search_get_type (), CamelFolderSearch) -#define CAMEL_FOLDER_SEARCH_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_folder_search_get_type (), CamelFolderSearchClass) -#define IS_CAMEL_FOLDER_SEARCH(obj) GTK_CHECK_TYPE (obj, camel_folder_search_get_type ()) +#define CAMEL_FOLDER_SEARCH(obj) CAMEL_CHECK_CAST (obj, camel_folder_search_get_type (), CamelFolderSearch) +#define CAMEL_FOLDER_SEARCH_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_folder_search_get_type (), CamelFolderSearchClass) +#define IS_CAMEL_FOLDER_SEARCH(obj) CAMEL_CHECK_TYPE (obj, camel_folder_search_get_type ()) typedef struct _CamelFolderSearchClass CamelFolderSearchClass; diff --git a/camel/camel-folder-summary.c b/camel/camel-folder-summary.c index a47d98a46a..6bae5cecec 100644 --- a/camel/camel-folder-summary.c +++ b/camel/camel-folder-summary.c @@ -90,46 +90,14 @@ static CamelMessageContentInfo * summary_build_content_info(CamelFolderSummary * static void camel_folder_summary_class_init (CamelFolderSummaryClass *klass); static void camel_folder_summary_init (CamelFolderSummary *obj); -static void camel_folder_summary_finalise (GtkObject *obj); +static void camel_folder_summary_finalize (CamelObject *obj); static CamelObjectClass *camel_folder_summary_parent; -enum SIGNALS { - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = { 0 }; - -guint -camel_folder_summary_get_type (void) -{ - static guint type = 0; - - if (!type) { - GtkTypeInfo type_info = { - "CamelFolderSummary", - sizeof (CamelFolderSummary), - sizeof (CamelFolderSummaryClass), - (GtkClassInitFunc) camel_folder_summary_class_init, - (GtkObjectInitFunc) camel_folder_summary_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_object_get_type (), &type_info); - } - - return type; -} - static void camel_folder_summary_class_init (CamelFolderSummaryClass *klass) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; - - camel_folder_summary_parent = gtk_type_class (camel_object_get_type ()); - - object_class->finalize = camel_folder_summary_finalise; + camel_folder_summary_parent = camel_type_get_global_classfuncs (camel_object_get_type ()); klass->summary_header_load = summary_header_load; klass->summary_header_save = summary_header_save; @@ -145,8 +113,6 @@ camel_folder_summary_class_init (CamelFolderSummaryClass *klass) klass->content_info_load = content_info_load; klass->content_info_save = content_info_save; klass->content_info_free = content_info_free; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); } static void @@ -172,12 +138,12 @@ camel_folder_summary_init (CamelFolderSummary *s) static void free_o_name(void *key, void *value, void *data) { - gtk_object_unref((GtkObject *)value); + camel_object_unref((CamelObject *)value); g_free(key); } static void -camel_folder_summary_finalise (GtkObject *obj) +camel_folder_summary_finalize (CamelObject *obj) { struct _CamelFolderSummaryPrivate *p; CamelFolderSummary *s = (CamelFolderSummary *)obj; @@ -194,17 +160,33 @@ camel_folder_summary_finalise (GtkObject *obj) g_free(s->summary_path); if (p->filter_index) - gtk_object_unref ((GtkObject *)p->filter_index); + camel_object_unref ((CamelObject *)p->filter_index); if (p->filter_64) - gtk_object_unref ((GtkObject *)p->filter_64); + camel_object_unref ((CamelObject *)p->filter_64); if (p->filter_qp) - gtk_object_unref ((GtkObject *)p->filter_qp); + camel_object_unref ((CamelObject *)p->filter_qp); if (p->filter_save) - gtk_object_unref ((GtkObject *)p->filter_save); + camel_object_unref ((CamelObject *)p->filter_save); g_free(p); +} - ((GtkObjectClass *)(camel_folder_summary_parent))->finalize((GtkObject *)obj); +CamelType +camel_folder_summary_get_type (void) +{ + static CamelType type = CAMEL_INVALID_TYPE; + + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_object_get_type (), "CamelFolderSummary", + sizeof (CamelFolderSummary), + sizeof (CamelFolderSummaryClass), + (CamelObjectClassInitFunc) camel_folder_summary_class_init, + NULL, + (CamelObjectInitFunc) camel_folder_summary_init, + (CamelObjectFinalizeFunc) camel_folder_summary_finalize); + } + + return type; } /** @@ -217,7 +199,7 @@ camel_folder_summary_finalise (GtkObject *obj) CamelFolderSummary * camel_folder_summary_new (void) { - CamelFolderSummary *new = CAMEL_FOLDER_SUMMARY ( gtk_type_new (camel_folder_summary_get_type ())); + CamelFolderSummary *new = CAMEL_FOLDER_SUMMARY ( camel_object_new (camel_folder_summary_get_type ())); return new; } @@ -283,7 +265,7 @@ perform_content_info_load(CamelFolderSummary *s, FILE *in) guint32 count; CamelMessageContentInfo *ci, *part; - ci = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->content_info_load(s, in); + ci = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->content_info_load(s, in); camel_folder_summary_decode_uint32(in, &count); for (i=0;iklass)->summary_header_load(s, in) == -1) { + if ( ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->summary_header_load(s, in) == -1) { fclose(in); return -1; } @@ -319,7 +301,7 @@ camel_folder_summary_load(CamelFolderSummary *s) /* now read in each message ... */ /* FIXME: check returns */ for (i=0;isaved_count;i++) { - mi = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->message_info_load(s, in); + mi = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_load(s, in); if (s->build_content) { mi->content = perform_content_info_load(s, in); @@ -342,7 +324,7 @@ perform_content_info_save(CamelFolderSummary *s, FILE *out, CamelMessageContentI { CamelMessageContentInfo *part; - ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->content_info_save(s, out, ci); + ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->content_info_save(s, out, ci); camel_folder_summary_encode_uint32(out, my_list_size((struct _node **)&ci->childs)); part = ci->childs; while (part) { @@ -377,7 +359,7 @@ camel_folder_summary_save(CamelFolderSummary *s) io(printf("saving header\n")); - if ( ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->summary_header_save(s, out) == -1) { + if ( ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->summary_header_save(s, out) == -1) { fclose(out); return -1; } @@ -387,7 +369,7 @@ camel_folder_summary_save(CamelFolderSummary *s) count = camel_folder_summary_count(s); for (i=0;iklass)->message_info_save(s, out, mi); + ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_save(s, out, mi); if (s->build_content) { perform_content_info_save(s, out, mi->content); @@ -425,7 +407,7 @@ CamelMessageInfo *camel_folder_summary_add_from_header(CamelFolderSummary *s, st { CamelMessageInfo *info = NULL; - info = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->message_info_new(s, h); + info = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s))) -> message_info_new(s, h); camel_folder_summary_add(s, info); return info; @@ -441,7 +423,7 @@ CamelMessageInfo *camel_folder_summary_add_from_parser(CamelFolderSummary *s, Ca /* should this check the parser is in the right state, or assume it is?? */ if (camel_mime_parser_step(mp, &buffer, &len) != HSCAN_EOF) { - info = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->message_info_new_from_parser(s, mp); + info = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_new_from_parser(s, mp); camel_mime_parser_unstep(mp); @@ -472,7 +454,7 @@ perform_content_info_free(CamelFolderSummary *s, CamelMessageContentInfo *ci) CamelMessageContentInfo *pw, *pn; pw = ci->childs; - ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->content_info_free(s, ci); + ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->content_info_free(s, ci); while (pw) { pn = pw->next; perform_content_info_free(s, pw); @@ -498,7 +480,7 @@ camel_folder_summary_clear(CamelFolderSummary *s) CamelMessageInfo *mi = camel_folder_summary_index(s, i); CamelMessageContentInfo *ci = mi->content; - ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->message_info_free(s, mi); + ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_free(s, mi); if (s->build_content && ci) { perform_content_info_free(s, ci); } @@ -516,7 +498,7 @@ void camel_folder_summary_remove(CamelFolderSummary *s, CamelMessageInfo *info) g_hash_table_remove(s->messages_uid, info->uid); g_ptr_array_remove(s->messages, info); - ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->message_info_free(s, info); + ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_free(s, info); if (s->build_content && ci) { perform_content_info_free(s, ci); } @@ -875,7 +857,7 @@ static CamelMessageInfo * message_info_new_from_parser(CamelFolderSummary *s, Ca case HSCAN_HEADER: case HSCAN_MESSAGE: case HSCAN_MULTIPART: - mi = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->message_info_new(s, camel_mime_parser_headers_raw(mp)); + mi = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_new(s, camel_mime_parser_headers_raw(mp)); break; default: g_error("Invalid parser state"); @@ -892,7 +874,7 @@ static CamelMessageContentInfo * content_info_new_from_parser(CamelFolderSummary case HSCAN_HEADER: case HSCAN_MESSAGE: case HSCAN_MULTIPART: - ci = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->content_info_new(s, camel_mime_parser_headers_raw(mp)); + ci = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->content_info_new(s, camel_mime_parser_headers_raw(mp)); if (ci) { ci->type = camel_mime_parser_content_type(mp); header_content_type_ref(ci->type); @@ -1212,7 +1194,7 @@ summary_build_content_info(CamelFolderSummary *s, CamelMimeParser *mp) state = camel_mime_parser_step(mp, &buffer, &len); body = camel_mime_parser_tell(mp); - info = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->content_info_new_from_parser(s, mp); + info = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->content_info_new_from_parser(s, mp); info->pos = camel_mime_parser_tell_start_headers(mp); info->bodypos = body; @@ -1571,7 +1553,7 @@ int main(int argc, char **argv) int i; ibex *index; - gtk_init(&argc, &argv); + /*g_tk_init(&argc, &argv);*/ #if 0 { @@ -1640,12 +1622,12 @@ int main(int argc, char **argv) for (i=0;i #include -#define CAMEL_FOLDER_SUMMARY(obj) GTK_CHECK_CAST (obj, camel_folder_summary_get_type (), CamelFolderSummary) -#define CAMEL_FOLDER_SUMMARY_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_folder_summary_get_type (), CamelFolderSummaryClass) -#define IS_CAMEL_FOLDER_SUMMARY(obj) GTK_CHECK_TYPE (obj, camel_folder_summary_get_type ()) +#define CAMEL_FOLDER_SUMMARY(obj) CAMEL_CHECK_CAST (obj, camel_folder_summary_get_type (), CamelFolderSummary) +#define CAMEL_FOLDER_SUMMARY_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_folder_summary_get_type (), CamelFolderSummaryClass) +#define IS_CAMEL_FOLDER_SUMMARY(obj) CAMEL_CHECK_TYPE (obj, camel_folder_summary_get_type ()) /*typedef struct _CamelFolderSummary CamelFolderSummary;*/ typedef struct _CamelFolderSummaryClass CamelFolderSummaryClass; diff --git a/camel/camel-folder.c b/camel/camel-folder.c index dd469e78aa..8e498ad57b 100644 --- a/camel/camel-folder.c +++ b/camel/camel-folder.c @@ -34,76 +34,105 @@ static CamelObjectClass *parent_class = NULL; /* Returns the class for a CamelFolder */ -#define CF_CLASS(so) CAMEL_FOLDER_CLASS (GTK_OBJECT (so)->klass) +#define CF_CLASS(so) CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) -enum SIGNALS { - FOLDER_CHANGED, - MESSAGE_CHANGED, - LAST_SIGNAL -}; -static guint signals[LAST_SIGNAL] = { 0 }; +static void init (CamelFolder *folder, CamelStore *parent_store, + CamelFolder *parent_folder, const gchar *name, + gchar *separator, gboolean path_begins_with_sep, + CamelException *ex); -static void init(CamelFolder * folder, CamelStore * parent_store, - CamelFolder * parent_folder, const gchar * name, - gchar * separator, gboolean path_begins_with_sep, CamelException * ex); +static void camel_folder_finalize (CamelObject *object); -static void finalize(GtkObject * object); -static void folder_sync(CamelFolder * folder, gboolean expunge, CamelException * ex); +static void folder_sync (CamelFolder *folder, gboolean expunge, + CamelException *ex); -static const gchar *get_name(CamelFolder * folder); -static const gchar *get_full_name(CamelFolder * folder); +static const gchar *get_name (CamelFolder *folder); +static const gchar *get_full_name (CamelFolder *folder); -static gboolean can_hold_folders(CamelFolder * folder); -static gboolean can_hold_messages(CamelFolder * folder); -static guint32 get_permanent_flags(CamelFolder * folder); -static guint32 get_message_flags(CamelFolder * folder, const char *uid); -static void set_message_flags(CamelFolder * folder, const char *uid, guint32 flags, guint32 set); -static gboolean get_message_user_flag(CamelFolder * folder, const char *uid, const char *name); -static void set_message_user_flag(CamelFolder * folder, const char *uid, const char *name, gboolean value); -static GPtrArray *get_subfolder_names(CamelFolder * folder); -static void free_subfolder_names(CamelFolder * folder, GPtrArray * array); -static CamelFolder *get_subfolder(CamelFolder * folder, +static gboolean can_hold_folders (CamelFolder *folder); +static gboolean can_hold_messages (CamelFolder *folder); +static guint32 get_permanent_flags (CamelFolder *folder); +static guint32 get_message_flags (CamelFolder *folder, const char *uid); +static void set_message_flags (CamelFolder *folder, const char *uid, + guint32 flags, guint32 set); +static gboolean get_message_user_flag (CamelFolder *folder, const char *uid, + const char *name); +static void set_message_user_flag (CamelFolder *folder, const char *uid, + const char *name, gboolean value); - const gchar * folder_name, gboolean create, CamelException * ex); -static CamelFolder *get_parent_folder(CamelFolder * folder); -static CamelStore *get_parent_store(CamelFolder * folder); -static gint get_message_count(CamelFolder * folder); -static gint get_unread_message_count(CamelFolder * folder); +static GPtrArray *get_subfolder_names (CamelFolder *folder); +static void free_subfolder_names (CamelFolder *folder, + GPtrArray *array); +static CamelFolder *get_subfolder (CamelFolder *folder, + const gchar *folder_name, + gboolean create, + CamelException *ex); +static CamelFolder *get_parent_folder (CamelFolder *folder); +static CamelStore *get_parent_store (CamelFolder *folder); -static void expunge(CamelFolder * folder, CamelException * ex); +static gint get_message_count (CamelFolder *folder); +static gint get_unread_message_count (CamelFolder *folder); -static void append_message(CamelFolder * folder, CamelMimeMessage * message, const CamelMessageInfo *info, CamelException * ex); +static void expunge (CamelFolder *folder, + CamelException *ex); -static GPtrArray *get_uids(CamelFolder * folder); -static void free_uids(CamelFolder * folder, GPtrArray * array); -static GPtrArray *get_summary(CamelFolder * folder); -static void free_summary(CamelFolder * folder, GPtrArray * array); -static CamelMimeMessage *get_message(CamelFolder * folder, const gchar * uid, CamelException * ex); -static const CamelMessageInfo *get_message_info(CamelFolder * folder, const char *uid); +static void append_message (CamelFolder *folder, CamelMimeMessage *message, + const CamelMessageInfo *info, CamelException *ex); -static GPtrArray *search_by_expression(CamelFolder * folder, const char *exp, CamelException * ex); -static void search_free(CamelFolder * folder, GPtrArray * result); -static void copy_message_to(CamelFolder * source, const char *uid, CamelFolder * dest, CamelException * ex); +static GPtrArray *get_uids (CamelFolder *folder); +static void free_uids (CamelFolder *folder, + GPtrArray *array); +static GPtrArray *get_summary (CamelFolder *folder); +static void free_summary (CamelFolder *folder, + GPtrArray *array); -static void move_message_to(CamelFolder * source, const char *uid, CamelFolder * dest, CamelException * ex); +static const gchar *get_message_uid (CamelFolder *folder, + CamelMimeMessage *message); -static void freeze(CamelFolder * folder); -static void thaw(CamelFolder * folder); +static CamelMimeMessage *get_message (CamelFolder *folder, + const gchar *uid, + CamelException *ex); -static void folder_changed(CamelFolder * folder, int type); -static void message_changed(CamelFolder * folder, const char *uid); +static const CamelMessageInfo *get_message_info (CamelFolder *folder, + const char *uid); -static void camel_folder_class_init(CamelFolderClass * camel_folder_class) +static GPtrArray *search_by_expression (CamelFolder *folder, + const char *exp, + CamelException *ex); +static void search_free (CamelFolder * folder, + GPtrArray * result); + +static void copy_message_to (CamelFolder *source, + const char *uid, + CamelFolder *dest, + CamelException *ex); + +static void move_message_to (CamelFolder *source, + const char *uid, + CamelFolder *dest, + CamelException *ex); + +static void freeze (CamelFolder *folder); +static void thaw (CamelFolder *folder); + +static gboolean folder_changed (CamelObject *object, + /*int type*/gpointer event_data); +static gboolean message_changed (CamelObject *object, + /*const char *uid*/gpointer event_data); + +static void +camel_folder_class_init (CamelFolderClass *camel_folder_class) { - GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS(camel_folder_class); + CamelObjectClass *camel_object_class = + CAMEL_OBJECT_CLASS (camel_folder_class); - parent_class = gtk_type_class(camel_object_get_type()); + parent_class = camel_type_get_global_classfuncs (camel_object_get_type ()); /* virtual method definition */ camel_folder_class->init = init; @@ -138,72 +167,71 @@ static void camel_folder_class_init(CamelFolderClass * camel_folder_class) camel_folder_class->move_message_to = move_message_to; camel_folder_class->freeze = freeze; camel_folder_class->thaw = thaw; - camel_folder_class->folder_changed = folder_changed; - camel_folder_class->message_changed = message_changed; /* virtual method overload */ - gtk_object_class->finalize = finalize; + camel_object_class_declare_event (camel_object_class, "folder_changed", folder_changed); + camel_object_class_declare_event (camel_object_class, "message_changed", message_changed); + + /* + signals[FOLDER_CHANGED] = + gt_k_signal_new ("folder_changed", + GT_K_RUN_FIRST, + camel_object_class->type, + GT_K_SIGNAL_OFFSET (CamelFolderClass, + folder_changed), + gt_k_marshal_NONE__INT, + GT_K_TYPE_NONE, 1, GT_K_TYPE_INT); + + signals[MESSAGE_CHANGED] = + gt_k_signal_new ("message_changed", + GT_K_RUN_FIRST, + camel_object_class->type, + GT_K_SIGNAL_OFFSET (CamelFolderClass, + message_changed), + gt_k_marshal_NONE__STRING, + GT_K_TYPE_NONE, 1, GT_K_TYPE_STRING); + + camel_object_class_add_signals (camel_object_class, signals, LAST_SIGNAL); + */ +} - signals[FOLDER_CHANGED] = - gtk_signal_new("folder_changed", - GTK_RUN_FIRST, - gtk_object_class->type, - GTK_SIGNAL_OFFSET(CamelFolderClass, - folder_changed), gtk_marshal_NONE__INT, GTK_TYPE_NONE, 1, GTK_TYPE_INT); +static void +camel_folder_finalize (CamelObject *object) +{ + CamelFolder *camel_folder = CAMEL_FOLDER (object); + GList *m; - signals[MESSAGE_CHANGED] = - gtk_signal_new("message_changed", - GTK_RUN_FIRST, - gtk_object_class->type, - GTK_SIGNAL_OFFSET(CamelFolderClass, - message_changed), - gtk_marshal_NONE__STRING, GTK_TYPE_NONE, 1, GTK_TYPE_STRING); + g_free (camel_folder->name); + g_free (camel_folder->full_name); - gtk_object_class_add_signals(gtk_object_class, signals, LAST_SIGNAL); + if (camel_folder->parent_store) + camel_object_unref (CAMEL_OBJECT (camel_folder->parent_store)); + if (camel_folder->parent_folder) + camel_object_unref (CAMEL_OBJECT (camel_folder->parent_folder)); + for (m = camel_folder->messages_changed; m; m = m->next) + g_free (m->data); + g_list_free (camel_folder->messages_changed); } -GtkType camel_folder_get_type(void) +CamelType +camel_folder_get_type (void) { - static GtkType camel_folder_type = 0; - - if (!camel_folder_type) { - GtkTypeInfo camel_folder_info = { - "CamelFolder", - sizeof(CamelFolder), - sizeof(CamelFolderClass), - (GtkClassInitFunc) camel_folder_class_init, - (GtkObjectInitFunc) NULL, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; + static CamelType camel_folder_type = CAMEL_INVALID_TYPE; - camel_folder_type = gtk_type_unique(camel_object_get_type(), &camel_folder_info); + if (camel_folder_type == CAMEL_INVALID_TYPE) { + camel_folder_type = camel_type_register (CAMEL_OBJECT_TYPE, "CamelFolder", + sizeof (CamelFolder), + sizeof (CamelFolderClass), + (CamelObjectClassInitFunc) camel_folder_class_init, + NULL, + NULL, + (CamelObjectFinalizeFunc) camel_folder_finalize ); } return camel_folder_type; } -static void finalize(GtkObject * object) -{ - CamelFolder *camel_folder = CAMEL_FOLDER(object); - GList *m; - - g_free(camel_folder->name); - g_free(camel_folder->full_name); - - if (camel_folder->parent_store) - gtk_object_unref(GTK_OBJECT(camel_folder->parent_store)); - if (camel_folder->parent_folder) - gtk_object_unref(GTK_OBJECT(camel_folder->parent_folder)); - - for (m = camel_folder->messages_changed; m; m = m->next) - g_free(m->data); - g_list_free(camel_folder->messages_changed); - - GTK_OBJECT_CLASS(parent_class)->finalize(object); -} /** * init: init the folder @@ -218,31 +246,32 @@ static void finalize(GtkObject * object) * and name. **/ static void -init(CamelFolder * folder, CamelStore * parent_store, - CamelFolder * parent_folder, const gchar * name, - gchar * separator, gboolean path_begins_with_sep, CamelException * ex) +init (CamelFolder *folder, CamelStore *parent_store, + CamelFolder *parent_folder, const gchar *name, + gchar *separator, gboolean path_begins_with_sep, + CamelException *ex) { gchar *full_name; const gchar *parent_full_name; - g_return_if_fail(CAMEL_IS_FOLDER(folder)); - g_return_if_fail(CAMEL_IS_STORE(parent_store)); - g_return_if_fail(parent_folder == NULL || CAMEL_IS_FOLDER(parent_folder)); - g_return_if_fail(folder->parent_store == NULL); + g_return_if_fail (CAMEL_IS_FOLDER (folder)); + g_return_if_fail (CAMEL_IS_STORE (parent_store)); + g_return_if_fail (parent_folder == NULL || CAMEL_IS_FOLDER (parent_folder)); + g_return_if_fail (folder->parent_store == NULL); folder->parent_store = parent_store; - gtk_object_ref(GTK_OBJECT(parent_store)); + camel_object_ref (CAMEL_OBJECT (parent_store)); folder->parent_folder = parent_folder; if (parent_folder) - gtk_object_ref(GTK_OBJECT(parent_folder)); + camel_object_ref (CAMEL_OBJECT (parent_folder)); folder->separator = separator; folder->path_begins_with_sep = path_begins_with_sep; /* if the folder already has a name, free it */ - g_free(folder->name); - g_free(folder->full_name); + g_free (folder->name); + g_free (folder->full_name); /* set those fields to NULL now, so that if an exception occurs, they will be set anyway */ @@ -268,9 +297,12 @@ init(CamelFolder * folder, CamelStore * parent_store, folder->messages_changed = NULL; } -static void folder_sync(CamelFolder * folder, gboolean expunge, CamelException * ex) + +static void +folder_sync (CamelFolder *folder, gboolean expunge, CamelException *ex) { - g_warning("CamelFolder::sync not implemented for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::sync not implemented for `%s'", + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); } /** @@ -409,16 +441,20 @@ static CamelStore *get_parent_store(CamelFolder * folder) * * Return value: the parent store of the folder. **/ -CamelStore *camel_folder_get_parent_store(CamelFolder * folder) +CamelStore * +camel_folder_get_parent_store (CamelFolder *folder) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), NULL); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL); - return CF_CLASS(folder)->get_parent_store(folder); + return CF_CLASS (folder)->get_parent_store (folder); } -static GPtrArray *get_subfolder_names(CamelFolder * folder) + +static GPtrArray * +get_subfolder_names (CamelFolder *folder) { - g_warning("CamelFolder::get_subfolder_names not implemented for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::get_subfolder_names not implemented for `%s'", + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); return NULL; } @@ -430,17 +466,20 @@ static GPtrArray *get_subfolder_names(CamelFolder * folder) * subfolders. The array should not be modified and must be freed with * camel_folder_free_subfolder_names(). **/ -GPtrArray *camel_folder_get_subfolder_names(CamelFolder * folder) +GPtrArray * +camel_folder_get_subfolder_names (CamelFolder *folder) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), NULL); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL); - return CF_CLASS(folder)->get_subfolder_names(folder); + return CF_CLASS (folder)->get_subfolder_names (folder); } -static void free_subfolder_names(CamelFolder * folder, GPtrArray * array) + +static void +free_subfolder_names (CamelFolder *folder, GPtrArray *array) { - g_warning("CamelFolder::free_subfolder_names not implemented " - "for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::free_subfolder_names not implemented " + "for `%s'", camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); } /** @@ -450,18 +489,23 @@ static void free_subfolder_names(CamelFolder * folder, GPtrArray * array) * * Frees the array of names returned by camel_folder_get_subfolder_names(). **/ -void camel_folder_free_subfolder_names(CamelFolder * folder, GPtrArray * array) +void +camel_folder_free_subfolder_names (CamelFolder *folder, GPtrArray *array) { - g_return_if_fail(CAMEL_IS_FOLDER(folder)); + g_return_if_fail (CAMEL_IS_FOLDER (folder)); - CF_CLASS(folder)->free_subfolder_names(folder, array); + CF_CLASS (folder)->free_subfolder_names (folder, array); } -static void expunge(CamelFolder * folder, CamelException * ex) + +static void +expunge (CamelFolder *folder, CamelException *ex) { - g_warning("CamelFolder::expunge not implemented for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::expunge not implemented for `%s'", + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); } + /** * camel_folder_expunge: * @folder: the folder @@ -469,16 +513,20 @@ static void expunge(CamelFolder * folder, CamelException * ex) * * Delete messages which have been marked as "DELETED" **/ -void camel_folder_expunge(CamelFolder * folder, CamelException * ex) +void +camel_folder_expunge (CamelFolder *folder, CamelException *ex) { - g_return_if_fail(CAMEL_IS_FOLDER(folder)); + g_return_if_fail (CAMEL_IS_FOLDER (folder)); - CF_CLASS(folder)->expunge(folder, ex); + CF_CLASS (folder)->expunge (folder, ex); } -static gint get_message_count(CamelFolder * folder) + +static gint +get_message_count (CamelFolder *folder) { - g_warning("CamelFolder::get_message_count not implemented " "for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::get_message_count not implemented " + "for `%s'", camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); return -1; } @@ -488,17 +536,19 @@ static gint get_message_count(CamelFolder * folder) * * Return value: the number of messages in the folder, or -1 if unknown. **/ -gint camel_folder_get_message_count(CamelFolder * folder) +gint +camel_folder_get_message_count (CamelFolder *folder) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), -1); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), -1); - return CF_CLASS(folder)->get_message_count(folder); + return CF_CLASS (folder)->get_message_count (folder); } -static gint get_unread_message_count(CamelFolder * folder) +static gint +get_unread_message_count (CamelFolder *folder) { - g_warning("CamelFolder::get_unread_message_count not implemented " - "for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::get_unread_message_count not implemented " + "for `%s'", camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); return -1; } @@ -508,16 +558,21 @@ static gint get_unread_message_count(CamelFolder * folder) * * Return value: the number of unread messages in the folder, or -1 if unknown. **/ -gint camel_folder_get_unread_message_count(CamelFolder * folder) +gint +camel_folder_get_unread_message_count (CamelFolder *folder) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), -1); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), -1); - return CF_CLASS(folder)->get_unread_message_count(folder); + return CF_CLASS (folder)->get_unread_message_count (folder); } -static void append_message(CamelFolder * folder, CamelMimeMessage * message, const CamelMessageInfo *info, CamelException * ex) + +static void +append_message (CamelFolder *folder, CamelMimeMessage *message, + const CamelMessageInfo *info, CamelException *ex) { - g_warning("CamelFolder::append_message not implemented for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::append_message not implemented for `%s'", + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); return; } @@ -551,16 +606,20 @@ static guint32 get_permanent_flags(CamelFolder * folder) * stored on a message between sessions. If it includes %CAMEL_FLAG_USER, * then user-defined flags will be remembered. **/ -guint32 camel_folder_get_permanent_flags(CamelFolder * folder) +guint32 +camel_folder_get_permanent_flags (CamelFolder *folder) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), 0); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), 0); - return CF_CLASS(folder)->get_permanent_flags(folder); + return CF_CLASS (folder)->get_permanent_flags (folder); } -static guint32 get_message_flags(CamelFolder * folder, const char *uid) + +static guint32 +get_message_flags (CamelFolder *folder, const char *uid) { - g_warning("CamelFolder::get_message_flags not implemented for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::get_message_flags not implemented for `%s'", + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); return 0; } @@ -572,16 +631,21 @@ static guint32 get_message_flags(CamelFolder * folder, const char *uid) * Return value: the CamelMessageFlags that are set on the indicated * message. **/ -guint32 camel_folder_get_message_flags(CamelFolder * folder, const char *uid) +guint32 +camel_folder_get_message_flags (CamelFolder *folder, const char *uid) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), 0); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), 0); - return CF_CLASS(folder)->get_message_flags(folder, uid); + return CF_CLASS (folder)->get_message_flags (folder, uid); } -static void set_message_flags(CamelFolder * folder, const char *uid, guint32 flags, guint32 set) + +static void +set_message_flags (CamelFolder *folder, const char *uid, + guint32 flags, guint32 set) { - g_warning("CamelFolder::set_message_flags not implemented for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::set_message_flags not implemented for `%s'", + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); } /** @@ -595,17 +659,22 @@ static void set_message_flags(CamelFolder * folder, const char *uid, guint32 fla * on the indicated message. (This may or may not persist after the * folder or store is closed. See camel_folder_get_permanent_flags().) **/ -void camel_folder_set_message_flags(CamelFolder * folder, const char *uid, guint32 flags, guint32 set) +void +camel_folder_set_message_flags (CamelFolder *folder, const char *uid, + guint32 flags, guint32 set) { - g_return_if_fail(CAMEL_IS_FOLDER(folder)); + g_return_if_fail (CAMEL_IS_FOLDER (folder)); - CF_CLASS(folder)->set_message_flags(folder, uid, flags, set); + CF_CLASS (folder)->set_message_flags (folder, uid, flags, set); } -static gboolean get_message_user_flag(CamelFolder * folder, const char *uid, const char *name) + +static gboolean +get_message_user_flag (CamelFolder *folder, const char *uid, + const char *name) { - g_warning("CamelFolder::get_message_user_flag not implemented " - "for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::get_message_user_flag not implemented " + "for `%s'", camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); return FALSE; } @@ -617,17 +686,22 @@ static gboolean get_message_user_flag(CamelFolder * folder, const char *uid, con * * Return value: whether or not the given user flag is set on the message. **/ -gboolean camel_folder_get_message_user_flag(CamelFolder * folder, const char *uid, const char *name) +gboolean +camel_folder_get_message_user_flag (CamelFolder *folder, const char *uid, + const char *name) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), 0); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), 0); - return CF_CLASS(folder)->get_message_user_flag(folder, uid, name); + return CF_CLASS (folder)->get_message_user_flag (folder, uid, name); } -static void set_message_user_flag(CamelFolder * folder, const char *uid, const char *name, gboolean value) + +static void +set_message_user_flag (CamelFolder *folder, const char *uid, + const char *name, gboolean value) { - g_warning("CamelFolder::set_message_user_flag not implemented " - "for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::set_message_user_flag not implemented " + "for `%s'", camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); } /** @@ -641,16 +715,21 @@ static void set_message_user_flag(CamelFolder * folder, const char *uid, const c * on the indicated message. (This may or may not persist after the * folder or store is closed. See camel_folder_get_permanent_flags().) **/ -void camel_folder_set_message_user_flag(CamelFolder * folder, const char *uid, const char *name, gboolean value) +void +camel_folder_set_message_user_flag (CamelFolder *folder, const char *uid, + const char *name, gboolean value) { - g_return_if_fail(CAMEL_IS_FOLDER(folder)); + g_return_if_fail (CAMEL_IS_FOLDER (folder)); - CF_CLASS(folder)->set_message_user_flag(folder, uid, name, value); + CF_CLASS (folder)->set_message_user_flag (folder, uid, name, value); } -static const CamelMessageInfo *get_message_info(CamelFolder * folder, const char *uid) + +static const CamelMessageInfo * +get_message_info (CamelFolder *folder, const char *uid) { - g_warning("CamelFolder::get_message_info not implemented for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::get_message_info not implemented for `%s'", + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); return NULL; } @@ -661,27 +740,33 @@ static const CamelMessageInfo *get_message_info(CamelFolder * folder, const char * * Return value: the summary information for the indicated message **/ -const CamelMessageInfo *camel_folder_get_message_info(CamelFolder * folder, const char *uid) +const CamelMessageInfo * +camel_folder_get_message_info (CamelFolder *folder, const char *uid) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), NULL); - g_return_val_if_fail(uid != NULL, NULL); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL); + g_return_val_if_fail (uid != NULL, NULL); - return CF_CLASS(folder)->get_message_info(folder, uid); + return CF_CLASS (folder)->get_message_info (folder, uid); } + /* TODO: is this function required anyway? */ -gboolean camel_folder_has_summary_capability(CamelFolder * folder) +gboolean +camel_folder_has_summary_capability (CamelFolder *folder) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), FALSE); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), FALSE); return folder->has_summary_capability; } + /* UIDs stuff */ -static CamelMimeMessage *get_message(CamelFolder * folder, const gchar * uid, CamelException * ex) +static CamelMimeMessage * +get_message (CamelFolder *folder, const gchar *uid, CamelException *ex) { - g_warning("CamelFolder::get_message not implemented for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::get_message not implemented for `%s'", + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); return NULL; } @@ -697,16 +782,21 @@ static CamelMimeMessage *get_message(CamelFolder * folder, const gchar * uid, Ca * * Return value: Message corresponding to the UID **/ -CamelMimeMessage *camel_folder_get_message(CamelFolder * folder, const gchar * uid, CamelException * ex) +CamelMimeMessage * +camel_folder_get_message (CamelFolder *folder, const gchar *uid, + CamelException *ex) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), NULL); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL); - return CF_CLASS(folder)->get_message(folder, uid, ex); + return CF_CLASS (folder)->get_message (folder, uid, ex); } -static GPtrArray *get_uids(CamelFolder * folder) + +static GPtrArray * +get_uids (CamelFolder *folder) { - g_warning("CamelFolder::get_uids not implemented for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::get_uids not implemented for `%s'", + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); return NULL; } @@ -722,16 +812,20 @@ static GPtrArray *get_uids(CamelFolder * folder) * Return value: GPtrArray of UIDs corresponding to the messages * available in the folder. **/ -GPtrArray *camel_folder_get_uids(CamelFolder * folder) +GPtrArray * +camel_folder_get_uids (CamelFolder *folder) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), NULL); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL); - return CF_CLASS(folder)->get_uids(folder); + return CF_CLASS (folder)->get_uids (folder); } -static void free_uids(CamelFolder * folder, GPtrArray * array) + +static void +free_uids (CamelFolder *folder, GPtrArray *array) { - g_warning("CamelFolder::free_uids not implemented for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::free_uids not implemented for `%s'", + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); } /** @@ -741,16 +835,20 @@ static void free_uids(CamelFolder * folder, GPtrArray * array) * * Frees the array of UIDs returned by camel_folder_get_uids(). **/ -void camel_folder_free_uids(CamelFolder * folder, GPtrArray * array) +void +camel_folder_free_uids (CamelFolder *folder, GPtrArray *array) { - g_return_if_fail(CAMEL_IS_FOLDER(folder)); + g_return_if_fail (CAMEL_IS_FOLDER (folder)); - CF_CLASS(folder)->free_uids(folder, array); + CF_CLASS (folder)->free_uids (folder, array); } -static GPtrArray *get_summary(CamelFolder * folder) + +static GPtrArray * +get_summary (CamelFolder *folder) { - g_warning("CamelFolder::get_summary not implemented for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::get_summary not implemented for `%s'", + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); return NULL; } @@ -764,16 +862,20 @@ static GPtrArray *get_summary(CamelFolder * folder) * * Return value: an array of CamelMessageInfo **/ -GPtrArray *camel_folder_get_summary(CamelFolder * folder) +GPtrArray * +camel_folder_get_summary (CamelFolder *folder) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), NULL); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL); - return CF_CLASS(folder)->get_summary(folder); + return CF_CLASS (folder)->get_summary (folder); } -static void free_summary(CamelFolder * folder, GPtrArray * array) + +static void +free_summary (CamelFolder *folder, GPtrArray *array) { - g_warning("CamelFolder::free_summary not implemented for `%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::free_summary not implemented for `%s'", + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); } /** @@ -798,17 +900,20 @@ void camel_folder_free_summary(CamelFolder * folder, GPtrArray * array) * * Return value: %TRUE if the folder supports searching **/ -gboolean camel_folder_has_search_capability(CamelFolder * folder) +gboolean +camel_folder_has_search_capability (CamelFolder *folder) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), FALSE); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), FALSE); return folder->has_search_capability; } -static GPtrArray *search_by_expression(CamelFolder * folder, const char *expression, CamelException * ex) +static GPtrArray * +search_by_expression (CamelFolder *folder, const char *expression, + CamelException *ex) { - g_warning("CamelFolder::search_by_expression not implemented for " - "`%s'", gtk_type_name(GTK_OBJECT_TYPE(folder))); + g_warning ("CamelFolder::search_by_expression not implemented for " + "`%s'", camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder))); return NULL; } @@ -823,15 +928,18 @@ static GPtrArray *search_by_expression(CamelFolder * folder, const char *express * Return value: a list of uids of matching messages. The caller must * free the list and each of the elements when it is done. **/ -GPtrArray *camel_folder_search_by_expression(CamelFolder * folder, const char *expression, CamelException * ex) +GPtrArray * +camel_folder_search_by_expression (CamelFolder *folder, const char *expression, + CamelException *ex) { - g_return_val_if_fail(CAMEL_IS_FOLDER(folder), NULL); - g_return_val_if_fail(folder->has_search_capability, NULL); + g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL); + g_return_val_if_fail (folder->has_search_capability, NULL); - return CF_CLASS(folder)->search_by_expression(folder, expression, ex); + return CF_CLASS (folder)->search_by_expression (folder, expression, ex); } -void search_free(CamelFolder * folder, GPtrArray * result) +static void +search_free(CamelFolder * folder, GPtrArray * result) { int i; @@ -847,7 +955,8 @@ void search_free(CamelFolder * folder, GPtrArray * result) * * Free the result of a search. **/ -void camel_folder_search_free(CamelFolder * folder, GPtrArray * result) +void +camel_folder_search_free(CamelFolder * folder, GPtrArray * result) { g_return_if_fail(CAMEL_IS_FOLDER(folder)); g_return_if_fail(folder->has_search_capability); @@ -855,20 +964,23 @@ void camel_folder_search_free(CamelFolder * folder, GPtrArray * result) return CF_CLASS(folder)->search_free(folder, result); } -static void copy_message_to(CamelFolder * source, const char *uid, CamelFolder * dest, CamelException * ex) + +static void +copy_message_to (CamelFolder *source, const char *uid, CamelFolder *dest, + CamelException *ex) { CamelMimeMessage *msg; const CamelMessageInfo *info; /* Default implementation. */ - - msg = camel_folder_get_message(source, uid, ex); + + msg = camel_folder_get_message (source, uid, ex); if (!msg) return; - info = camel_folder_get_message_info(source, uid); - camel_folder_append_message(dest, msg, info, ex); - gtk_object_unref(GTK_OBJECT(msg)); - if (camel_exception_is_set(ex)) + info = camel_folder_get_message_info (source, uid); + camel_folder_append_message (dest, msg, info ? info->flags : 0, ex); + camel_object_unref (CAMEL_OBJECT (msg)); + if (camel_exception_is_set (ex)) return; } @@ -883,34 +995,40 @@ static void copy_message_to(CamelFolder * source, const char *uid, CamelFolder * * @dest folders have the same parent_store, this may be more efficient * than a camel_folder_append_message(). **/ -void camel_folder_copy_message_to(CamelFolder * source, const char *uid, CamelFolder * dest, CamelException * ex) +void +camel_folder_copy_message_to (CamelFolder *source, const char *uid, + CamelFolder *dest, CamelException *ex) { - g_return_if_fail(CAMEL_IS_FOLDER(source)); - g_return_if_fail(CAMEL_IS_FOLDER(dest)); - g_return_if_fail(uid != NULL); + g_return_if_fail (CAMEL_IS_FOLDER (source)); + g_return_if_fail (CAMEL_IS_FOLDER (dest)); + g_return_if_fail (uid != NULL); if (source->parent_store == dest->parent_store) { - return CF_CLASS(source)->copy_message_to(source, uid, dest, ex); + return CF_CLASS (source)->copy_message_to (source, uid, + dest, ex); } else - return copy_message_to(source, uid, dest, ex); + return copy_message_to (source, uid, dest, ex); } -static void move_message_to(CamelFolder * source, const char *uid, CamelFolder * dest, CamelException * ex) + +static void +move_message_to (CamelFolder *source, const char *uid, CamelFolder *dest, + CamelException *ex) { CamelMimeMessage *msg; const CamelMessageInfo *info; /* Default implementation. */ - - msg = camel_folder_get_message(source, uid, ex); + + msg = camel_folder_get_message (source, uid, ex); if (!msg) return; - info = camel_folder_get_message_info(source, uid); - camel_folder_append_message(dest, msg, info, ex); - gtk_object_unref(GTK_OBJECT(msg)); - if (camel_exception_is_set(ex)) + info = camel_folder_get_message_info (source, uid); + camel_folder_append_message (dest, msg, info ? info->flags : 0, ex); + camel_object_unref (CAMEL_OBJECT (msg)); + if (camel_exception_is_set (ex)) return; - camel_folder_delete_message(source, uid); + camel_folder_delete_message (source, uid); } /** @@ -978,23 +1096,23 @@ static void thaw(CamelFolder * folder) if (folder->folder_changed) { folder->folder_changed = FALSE; - gtk_signal_emit(GTK_OBJECT(folder), signals[FOLDER_CHANGED], 0); + camel_object_trigger_event (CAMEL_OBJECT (folder), "folder_changed", GINT_TO_POINTER(0)); } else if (folder->messages_changed) { /* FIXME: would be nice to not emit more than once for * a given message */ for (m = messages; m; m = m->next) { - gtk_signal_emit_by_name(GTK_OBJECT(folder), "message_changed", m->data); - g_free(m->data); + camel_object_trigger_event (CAMEL_OBJECT (folder), "message_changed", m->data); + g_free (m->data); } - g_list_free(messages); + g_list_free (messages); return; } if (messages) { for (m = messages; m; m = m->next) - g_free(m->data); - g_list_free(messages); + g_free (m->data); + g_list_free (messages); } } @@ -1005,38 +1123,54 @@ static void thaw(CamelFolder * folder) * Thaws the folder and emits any pending folder_changed or * message_changed signals. **/ -void camel_folder_thaw(CamelFolder * folder) +void +camel_folder_thaw (CamelFolder *folder) { - g_return_if_fail(CAMEL_IS_FOLDER(folder)); - g_return_if_fail(folder->frozen != 0); + g_return_if_fail (CAMEL_IS_FOLDER (folder)); + g_return_if_fail (folder->frozen != 0); - CF_CLASS(folder)->thaw(folder); + CF_CLASS (folder)->thaw (folder); } -/* Default signal implementations, which block emission when we're - * frozen. - */ -static void folder_changed(CamelFolder * folder, int type) + +/* Event hooks that block emission when frozen */ +static gboolean folder_changed (CamelObject *obj, /*int type*/gpointer event_data) { + CamelFolder *folder = CAMEL_FOLDER (obj); + if (folder->frozen) { - gtk_signal_emit_stop(GTK_OBJECT(folder), signals[FOLDER_CHANGED]); folder->folder_changed = TRUE; + return FALSE; } + + return TRUE; } -static void message_changed(CamelFolder * folder, const char *uid) +static gboolean message_changed (CamelObject *obj, /*const char *uid*/gpointer event_data) { + CamelFolder *folder = CAMEL_FOLDER (obj); + if (folder->frozen) { - gtk_signal_emit_stop(GTK_OBJECT(folder), signals[MESSAGE_CHANGED]); + /* + * if g_tk_signal_handler_pending (CAMEL_OBJECT (folder), + * signals[MESSAGE_CHANGED], + * FALSE)) { + */ /* Only record the UID if it will be useful later. */ - if (!folder->folder_changed && - gtk_signal_handler_pending(GTK_OBJECT(folder), signals[MESSAGE_CHANGED], FALSE)) { - folder->messages_changed = g_list_prepend(folder->messages_changed, g_strdup(uid)); + if (!folder->folder_changed) { + folder->messages_changed = + g_list_prepend (folder->messages_changed, + g_strdup ((gchar *)event_data)); } + + return FALSE; } + + return TRUE; } + /** * camel_folder_free_nop: * @folder: a folder diff --git a/camel/camel-folder.h b/camel/camel-folder.h index 949dbae52a..b394013d5d 100644 --- a/camel/camel-folder.h +++ b/camel/camel-folder.h @@ -37,9 +37,9 @@ extern "C" { #include #define CAMEL_FOLDER_TYPE (camel_folder_get_type ()) -#define CAMEL_FOLDER(obj) (GTK_CHECK_CAST((obj), CAMEL_FOLDER_TYPE, CamelFolder)) -#define CAMEL_FOLDER_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_FOLDER_TYPE, CamelFolderClass)) -#define CAMEL_IS_FOLDER(o) (GTK_CHECK_TYPE((o), CAMEL_FOLDER_TYPE)) +#define CAMEL_FOLDER(obj) (CAMEL_CHECK_CAST((obj), CAMEL_FOLDER_TYPE, CamelFolder)) +#define CAMEL_FOLDER_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_FOLDER_TYPE, CamelFolderClass)) +#define CAMEL_IS_FOLDER(o) (CAMEL_CHECK_TYPE((o), CAMEL_FOLDER_TYPE)) struct _CamelFolder { @@ -68,10 +68,12 @@ typedef struct { CamelObjectClass parent_class; /* signals */ - void (*folder_changed) (CamelFolder *, int type); - void (*message_changed) (CamelFolder *, - const char *uid); - + /* Not anymore! bwahahahah! + * void (*folder_changed) (CamelFolder *, int type); + * void (*message_changed) (CamelFolder *, + * const char *uid); + */ + /* Virtual methods */ void (*init) (CamelFolder *folder, CamelStore *parent_store, CamelFolder *parent_folder, const gchar *name, @@ -171,8 +173,8 @@ typedef struct { -/* Standard Gtk function */ -GtkType camel_folder_get_type (void); +/* Standard Camel function */ +CamelType camel_folder_get_type (void); /* public methods */ diff --git a/camel/camel-internet-address.c b/camel/camel-internet-address.c index 9abbc8c632..0e68f718c2 100644 --- a/camel/camel-internet-address.c +++ b/camel/camel-internet-address.c @@ -35,47 +35,16 @@ struct _address { char *address; }; -enum SIGNALS { - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = { 0 }; - -guint -camel_internet_address_get_type (void) -{ - static guint type = 0; - - if (!type) { - GtkTypeInfo type_info = { - "CamelInternetAddress", - sizeof (CamelInternetAddress), - sizeof (CamelInternetAddressClass), - (GtkClassInitFunc) camel_internet_address_class_init, - (GtkObjectInitFunc) camel_internet_address_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_address_get_type (), &type_info); - } - - return type; -} - static void camel_internet_address_class_init (CamelInternetAddressClass *klass) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; CamelAddressClass *address = (CamelAddressClass *) klass; - camel_internet_address_parent = gtk_type_class (camel_address_get_type ()); + camel_internet_address_parent = CAMEL_ADDRESS_CLASS (camel_type_get_global_classfuncs (camel_address_get_type ())); address->decode = internet_decode; address->encode = internet_encode; address->remove = internet_remove; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); } static void @@ -83,6 +52,24 @@ camel_internet_address_init (CamelInternetAddress *obj) { } +CamelType +camel_internet_address_get_type (void) +{ + static CamelType type = CAMEL_INVALID_TYPE; + + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_address_get_type (), "CamelInternetAddress", + sizeof (CamelInternetAddress), + sizeof (CamelInternetAddressClass), + (CamelObjectClassInitFunc) camel_internet_address_class_init, + NULL, + (CamelObjectInitFunc) camel_internet_address_init, + NULL); + } + + return type; +} + static int internet_decode (CamelAddress *a, const char *raw) { @@ -164,7 +151,7 @@ static void internet_remove (CamelAddress *a, int index) CamelInternetAddress * camel_internet_address_new (void) { - CamelInternetAddress *new = CAMEL_INTERNET_ADDRESS ( gtk_type_new (camel_internet_address_get_type ())); + CamelInternetAddress *new = CAMEL_INTERNET_ADDRESS ( camel_object_new (camel_internet_address_get_type ())); return new; } diff --git a/camel/camel-internet-address.h b/camel/camel-internet-address.h index 14fbd5436a..6b303eef8f 100644 --- a/camel/camel-internet-address.h +++ b/camel/camel-internet-address.h @@ -23,9 +23,9 @@ #include -#define CAMEL_INTERNET_ADDRESS(obj) GTK_CHECK_CAST (obj, camel_internet_address_get_type (), CamelInternetAddress) -#define CAMEL_INTERNET_ADDRESS_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_internet_address_get_type (), CamelInternetAddressClass) -#define IS_CAMEL_INTERNET_ADDRESS(obj) GTK_CHECK_TYPE (obj, camel_internet_address_get_type ()) +#define CAMEL_INTERNET_ADDRESS(obj) CAMEL_CHECK_CAST (obj, camel_internet_address_get_type (), CamelInternetAddress) +#define CAMEL_INTERNET_ADDRESS_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_internet_address_get_type (), CamelInternetAddressClass) +#define IS_CAMEL_INTERNET_ADDRESS(obj) CAMEL_CHECK_TYPE (obj, camel_internet_address_get_type ()) typedef struct _CamelInternetAddressClass CamelInternetAddressClass; diff --git a/camel/camel-medium.c b/camel/camel-medium.c index dcc5d31d67..4507c93595 100644 --- a/camel/camel-medium.c +++ b/camel/camel-medium.c @@ -35,7 +35,7 @@ static CamelDataWrapperClass *parent_class = NULL; /* Returns the class for a CamelMedium */ -#define CM_CLASS(so) CAMEL_MEDIUM_CLASS (GTK_OBJECT (so)->klass) +#define CM_CLASS(so) CAMEL_MEDIUM_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static void add_header (CamelMedium *medium, const gchar *header_name, const void *header_value); @@ -46,17 +46,16 @@ static const void *get_header (CamelMedium *medium, const gchar *header_name); static CamelDataWrapper *get_content_object (CamelMedium *medium); static void set_content_object (CamelMedium *medium, CamelDataWrapper *content); -static void finalize (GtkObject *object); static void camel_medium_class_init (CamelMediumClass *camel_medium_class) { - CamelDataWrapperClass *camel_data_wrapper_class = - CAMEL_DATA_WRAPPER_CLASS (camel_medium_class); - GtkObjectClass *gtk_object_class = - GTK_OBJECT_CLASS (camel_data_wrapper_class); + /* + * CamelDataWrapperClass *camel_data_wrapper_class = + * CAMEL_DATA_WRAPPER_CLASS (camel_medium_class); + */ - parent_class = gtk_type_class (camel_data_wrapper_get_type ()); + parent_class = CAMEL_DATA_WRAPPER_CLASS (camel_type_get_global_classfuncs (camel_data_wrapper_get_type ())); /* virtual method definition */ camel_medium_class->add_header = add_header; @@ -66,8 +65,6 @@ camel_medium_class_init (CamelMediumClass *camel_medium_class) camel_medium_class->set_content_object = set_content_object; camel_medium_class->get_content_object = get_content_object; - - gtk_object_class->finalize = finalize; } static void @@ -78,47 +75,39 @@ camel_medium_init (gpointer object, gpointer klass) camel_medium->content = NULL; } - -GtkType -camel_medium_get_type (void) -{ - static GtkType camel_medium_type = 0; - - if (!camel_medium_type) { - GtkTypeInfo camel_medium_info = - { - "CamelMedium", - sizeof (CamelMedium), - sizeof (CamelMediumClass), - (GtkClassInitFunc) camel_medium_class_init, - (GtkObjectInitFunc) camel_medium_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_medium_type = gtk_type_unique (camel_data_wrapper_get_type (), &camel_medium_info); - } - - return camel_medium_type; -} - static void -finalize (GtkObject *object) +camel_medium_finalize (CamelObject *object) { CamelMedium *medium = CAMEL_MEDIUM (object); if (medium->content) - gtk_object_unref (GTK_OBJECT (medium->content)); + camel_object_unref (CAMEL_OBJECT (medium->content)); +} + + +CamelType +camel_medium_get_type (void) +{ + static CamelType camel_medium_type = CAMEL_INVALID_TYPE; + + if (camel_medium_type == CAMEL_INVALID_TYPE) { + camel_medium_type = camel_type_register (CAMEL_DATA_WRAPPER_TYPE, "medium", + sizeof (CamelMedium), + sizeof (CamelMediumClass), + (CamelObjectClassInitFunc) camel_medium_class_init, + NULL, + (CamelObjectInitFunc) camel_medium_init, + (CamelObjectFinalizeFunc) camel_medium_finalize); + } - GTK_OBJECT_CLASS (parent_class)->finalize (object); + return camel_medium_type; } static void add_header (CamelMedium *medium, const gchar *header_name, const void *header_value) { - g_warning("No %s::add_header implemented, adding %s", gtk_type_name(((GtkObject *)medium)->klass->type), header_name); + g_warning("No %s::add_header implemented, adding %s", camel_type_to_name(CAMEL_OBJECT_GET_TYPE(medium)), header_name); } /** @@ -147,7 +136,7 @@ camel_medium_add_header (CamelMedium *medium, const gchar *header_name, static void set_header (CamelMedium *medium, const gchar *header_name, const void *header_value) { - g_warning("No %s::set_header implemented, setting %s", gtk_type_name(((GtkObject *)medium)->klass->type), header_name); + g_warning("No %s::set_header implemented, setting %s", camel_type_to_name(CAMEL_OBJECT_GET_TYPE(medium)), header_name); } /** @@ -172,7 +161,7 @@ camel_medium_set_header (CamelMedium *medium, const gchar *header_name, const vo static void remove_header (CamelMedium *medium, const gchar *header_name) { - g_warning("No %s::remove_header implemented, removing %s", gtk_type_name(((GtkObject *)medium)->klass->type), header_name); + g_warning("No %s::remove_header implemented, removing %s", camel_type_to_name(CAMEL_OBJECT_GET_TYPE(medium)), header_name); } /** @@ -196,7 +185,7 @@ camel_medium_remove_header (CamelMedium *medium, const gchar *header_name) static const void * get_header (CamelMedium *medium, const gchar *header_name) { - g_warning("No %s::get_header implemented, getting %s", gtk_type_name(((GtkObject *)medium)->klass->type), header_name); + g_warning("No %s::get_header implemented, getting %s", camel_type_to_name(CAMEL_OBJECT_GET_TYPE(medium)), header_name); return NULL; } @@ -252,8 +241,8 @@ static void set_content_object (CamelMedium *medium, CamelDataWrapper *content) { if (medium->content) - gtk_object_unref (GTK_OBJECT (medium->content)); - gtk_object_ref (GTK_OBJECT (content)); + camel_object_unref (CAMEL_OBJECT (medium->content)); + camel_object_ref (CAMEL_OBJECT (content)); medium->content = content; } diff --git a/camel/camel-medium.h b/camel/camel-medium.h index 2b6f77f825..9ce548ba1d 100644 --- a/camel/camel-medium.h +++ b/camel/camel-medium.h @@ -37,9 +37,9 @@ extern "C" { #include #define CAMEL_MEDIUM_TYPE (camel_medium_get_type ()) -#define CAMEL_MEDIUM(obj) (GTK_CHECK_CAST((obj), CAMEL_MEDIUM_TYPE, CamelMedium)) -#define CAMEL_MEDIUM_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_MEDIUM_TYPE, CamelMediumClass)) -#define CAMEL_IS_MEDIUM(o) (GTK_CHECK_TYPE((o), CAMEL_MEDIUM_TYPE)) +#define CAMEL_MEDIUM(obj) (CAMEL_CHECK_CAST((obj), CAMEL_MEDIUM_TYPE, CamelMedium)) +#define CAMEL_MEDIUM_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_MEDIUM_TYPE, CamelMediumClass)) +#define CAMEL_IS_MEDIUM(o) (CAMEL_CHECK_TYPE((o), CAMEL_MEDIUM_TYPE)) struct _CamelMedium @@ -70,8 +70,8 @@ typedef struct { } CamelMediumClass; -/* Standard Gtk function */ -GtkType camel_medium_get_type (void); +/* Standard Camel function */ +CamelType camel_medium_get_type (void); /* Header get/set interface */ void camel_medium_add_header (CamelMedium *medium, const gchar *header_name, const void *header_value); diff --git a/camel/camel-mime-filter-basic.c b/camel/camel-mime-filter-basic.c index 082fa209ad..4b351e4ff4 100644 --- a/camel/camel-mime-filter-basic.c +++ b/camel/camel-mime-filter-basic.c @@ -22,45 +22,57 @@ #include "camel-mime-utils.h" +static void reset(CamelMimeFilter *mf); +static void complete(CamelMimeFilter *mf, char *in, size_t len, + size_t prespace, char **out, + size_t *outlen, size_t *outprespace); +static void filter(CamelMimeFilter *mf, char *in, size_t len, + size_t prespace, char **out, + size_t *outlen, size_t *outprespace); + static void camel_mime_filter_basic_class_init (CamelMimeFilterBasicClass *klass); static void camel_mime_filter_basic_init (CamelMimeFilterBasic *obj); static CamelMimeFilterClass *camel_mime_filter_basic_parent; -enum SIGNALS { - LAST_SIGNAL -}; +static void +camel_mime_filter_basic_class_init (CamelMimeFilterBasicClass *klass) +{ + CamelMimeFilterClass *filter_class = (CamelMimeFilterClass *) klass; + + camel_mime_filter_basic_parent = CAMEL_MIME_FILTER_CLASS(camel_type_get_global_classfuncs (camel_mime_filter_get_type ())); -static guint signals[LAST_SIGNAL] = { 0 }; + filter_class->reset = reset; + filter_class->filter = filter; + filter_class->complete = complete; +} -guint +static void +camel_mime_filter_basic_init (CamelMimeFilterBasic *obj) +{ + obj->state = 0; + obj->save = 0; +} + + +CamelType camel_mime_filter_basic_get_type (void) { - static guint type = 0; + static CamelType type = CAMEL_INVALID_TYPE; - if (!type) { - GtkTypeInfo type_info = { - "CamelMimeFilterBasic", - sizeof (CamelMimeFilterBasic), - sizeof (CamelMimeFilterBasicClass), - (GtkClassInitFunc) camel_mime_filter_basic_class_init, - (GtkObjectInitFunc) camel_mime_filter_basic_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_mime_filter_get_type (), &type_info); + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_mime_filter_get_type (), "CamelMimeFilterBasic", + sizeof (CamelMimeFilterBasic), + sizeof (CamelMimeFilterBasicClass), + (CamelObjectClassInitFunc) camel_mime_filter_basic_class_init, + NULL, + (CamelObjectInitFunc) camel_mime_filter_basic_init, + NULL); } return type; } -static void -finalise(GtkObject *o) -{ - ((GtkObjectClass *)camel_mime_filter_basic_parent)->finalize (o); -} - /* should this 'flush' outstanding state/data bytes? */ static void reset(CamelMimeFilter *mf) @@ -164,30 +176,6 @@ donothing: *outprespace = prespace; } -static void -camel_mime_filter_basic_class_init (CamelMimeFilterBasicClass *klass) -{ - GtkObjectClass *object_class = (GtkObjectClass *) klass; - CamelMimeFilterClass *filter_class = (CamelMimeFilterClass *) klass; - - camel_mime_filter_basic_parent = gtk_type_class (camel_mime_filter_get_type ()); - - object_class->finalize = finalise; - - filter_class->reset = reset; - filter_class->filter = filter; - filter_class->complete = complete; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); -} - -static void -camel_mime_filter_basic_init (CamelMimeFilterBasic *obj) -{ - obj->state = 0; - obj->save = 0; -} - /** * camel_mime_filter_basic_new: * @@ -198,7 +186,7 @@ camel_mime_filter_basic_init (CamelMimeFilterBasic *obj) CamelMimeFilterBasic * camel_mime_filter_basic_new (void) { - CamelMimeFilterBasic *new = CAMEL_MIME_FILTER_BASIC ( gtk_type_new (camel_mime_filter_basic_get_type ())); + CamelMimeFilterBasic *new = CAMEL_MIME_FILTER_BASIC ( camel_object_new (camel_mime_filter_basic_get_type ())); return new; } diff --git a/camel/camel-mime-filter-basic.h b/camel/camel-mime-filter-basic.h index f700997fd2..42713e334d 100644 --- a/camel/camel-mime-filter-basic.h +++ b/camel/camel-mime-filter-basic.h @@ -23,9 +23,9 @@ #include -#define CAMEL_MIME_FILTER_BASIC(obj) GTK_CHECK_CAST (obj, camel_mime_filter_basic_get_type (), CamelMimeFilterBasic) -#define CAMEL_MIME_FILTER_BASIC_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_mime_filter_basic_get_type (), CamelMimeFilterBasicClass) -#define IS_CAMEL_MIME_FILTER_BASIC(obj) GTK_CHECK_TYPE (obj, camel_mime_filter_basic_get_type ()) +#define CAMEL_MIME_FILTER_BASIC(obj) CAMEL_CHECK_CAST (obj, camel_mime_filter_basic_get_type (), CamelMimeFilterBasic) +#define CAMEL_MIME_FILTER_BASIC_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_mime_filter_basic_get_type (), CamelMimeFilterBasicClass) +#define IS_CAMEL_MIME_FILTER_BASIC(obj) CAMEL_CHECK_TYPE (obj, camel_mime_filter_basic_get_type ()) typedef struct _CamelMimeFilterBasicClass CamelMimeFilterBasicClass; diff --git a/camel/camel-mime-filter-charset.c b/camel/camel-mime-filter-charset.c index eb9db60802..18c0c64c3a 100644 --- a/camel/camel-mime-filter-charset.c +++ b/camel/camel-mime-filter-charset.c @@ -29,39 +29,30 @@ static void camel_mime_filter_charset_class_init (CamelMimeFilterCharsetClass *klass); static void camel_mime_filter_charset_init (CamelMimeFilterCharset *obj); +static void camel_mime_filter_charset_finalize (CamelObject *o); static CamelMimeFilterClass *camel_mime_filter_charset_parent; -enum SIGNALS { - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = { 0 }; - -guint +CamelType camel_mime_filter_charset_get_type (void) { - static guint type = 0; + static CamelType type = CAMEL_INVALID_TYPE; - if (!type) { - GtkTypeInfo type_info = { - "CamelMimeFilterCharset", - sizeof (CamelMimeFilterCharset), - sizeof (CamelMimeFilterCharsetClass), - (GtkClassInitFunc) camel_mime_filter_charset_class_init, - (GtkObjectInitFunc) camel_mime_filter_charset_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_mime_filter_get_type (), &type_info); + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_mime_filter_get_type (), "CamelMimeFilterCharset", + sizeof (CamelMimeFilterCharset), + sizeof (CamelMimeFilterCharsetClass), + (CamelObjectClassInitFunc) camel_mime_filter_charset_class_init, + NULL, + (CamelObjectInitFunc) camel_mime_filter_charset_init, + (CamelObjectFinalizeFunc) camel_mime_filter_charset_finalize); } return type; } static void -finalise(GtkObject *o) +camel_mime_filter_charset_finalize(CamelObject *o) { CamelMimeFilterCharset *f = (CamelMimeFilterCharset *)o; @@ -71,8 +62,6 @@ finalise(GtkObject *o) unicode_iconv_close(f->ic); f->ic = (unicode_iconv_t) -1; } - - ((GtkObjectClass *)camel_mime_filter_charset_parent)->finalize (o); } static void @@ -191,18 +180,13 @@ donothing: static void camel_mime_filter_charset_class_init (CamelMimeFilterCharsetClass *klass) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; CamelMimeFilterClass *filter_class = (CamelMimeFilterClass *) klass; - camel_mime_filter_charset_parent = gtk_type_class (camel_mime_filter_get_type ()); - - object_class->finalize = finalise; + camel_mime_filter_charset_parent = CAMEL_MIME_FILTER_CLASS (camel_type_get_global_classfuncs (camel_mime_filter_get_type ())); filter_class->reset = reset; filter_class->filter = filter; filter_class->complete = complete; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); } static void @@ -221,19 +205,19 @@ camel_mime_filter_charset_init (CamelMimeFilterCharset *obj) CamelMimeFilterCharset * camel_mime_filter_charset_new (void) { - CamelMimeFilterCharset *new = CAMEL_MIME_FILTER_CHARSET ( gtk_type_new (camel_mime_filter_charset_get_type ())); + CamelMimeFilterCharset *new = CAMEL_MIME_FILTER_CHARSET ( camel_object_new (camel_mime_filter_charset_get_type ())); return new; } CamelMimeFilterCharset * camel_mime_filter_charset_new_convert(const char *from_charset, const char *to_charset) { - CamelMimeFilterCharset *new = CAMEL_MIME_FILTER_CHARSET ( gtk_type_new (camel_mime_filter_charset_get_type ())); + CamelMimeFilterCharset *new = CAMEL_MIME_FILTER_CHARSET ( camel_object_new (camel_mime_filter_charset_get_type ())); new->ic = unicode_iconv_open(to_charset, from_charset); if (new->ic == (unicode_iconv_t) -1) { g_warning("Cannot create charset conversion from %s to %s: %s", from_charset, to_charset, strerror(errno)); - gtk_object_unref((GtkObject *)new); + camel_object_unref((CamelObject *)new); new = NULL; } else { new->from = g_strdup(from_charset); diff --git a/camel/camel-mime-filter-charset.h b/camel/camel-mime-filter-charset.h index 866a9fd6bf..c53254c8ab 100644 --- a/camel/camel-mime-filter-charset.h +++ b/camel/camel-mime-filter-charset.h @@ -24,9 +24,9 @@ #include #include -#define CAMEL_MIME_FILTER_CHARSET(obj) GTK_CHECK_CAST (obj, camel_mime_filter_charset_get_type (), CamelMimeFilterCharset) -#define CAMEL_MIME_FILTER_CHARSET_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_mime_filter_charset_get_type (), CamelMimeFilterCharsetClass) -#define IS_CAMEL_MIME_FILTER_CHARSET(obj) GTK_CHECK_TYPE (obj, camel_mime_filter_charset_get_type ()) +#define CAMEL_MIME_FILTER_CHARSET(obj) CAMEL_CHECK_CAST (obj, camel_mime_filter_charset_get_type (), CamelMimeFilterCharset) +#define CAMEL_MIME_FILTER_CHARSET_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_mime_filter_charset_get_type (), CamelMimeFilterCharsetClass) +#define IS_CAMEL_MIME_FILTER_CHARSET(obj) CAMEL_CHECK_TYPE (obj, camel_mime_filter_charset_get_type ()) typedef struct _CamelMimeFilterCharsetClass CamelMimeFilterCharsetClass; diff --git a/camel/camel-mime-filter-crlf.c b/camel/camel-mime-filter-crlf.c index 8e3ff2175c..71a3e8bace 100644 --- a/camel/camel-mime-filter-crlf.c +++ b/camel/camel-mime-filter-crlf.c @@ -41,25 +41,19 @@ camel_mime_filter_crlf_class_init (CamelMimeFilterCRLFClass *klass) mime_filter_class->reset = reset; } -GtkType +CamelType camel_mime_filter_crlf_get_type (void) { - static GtkType type = 0; + static CamelType type = CAMEL_INVALID_TYPE; - if (!type) { - GtkTypeInfo type_info = { - "CamelMimeFilterCRLF", - sizeof (CamelMimeFilterCRLF), - sizeof (CamelMimeFilterCRLFClass), - (GtkClassInitFunc) camel_mime_filter_crlf_class_init, - (GtkObjectInitFunc) NULL, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL - }; - - type = gtk_type_unique (camel_mime_filter_get_type (), - &type_info); + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_mime_filter_get_type(), "CamelMimeFilterCRLF", + sizeof (CamelMimeFilterCRLF), + sizeof (CamelMimeFilterCRLFClass), + (CamelObjectClassInitFunc) camel_mime_filter_crlf_class_init, + NULL, + NULL, + NULL); } return type; @@ -146,7 +140,7 @@ reset (CamelMimeFilter *f) CamelMimeFilter * camel_mime_filter_crlf_new (CamelMimeFilterCRLFDirection direction, CamelMimeFilterCRLFMode mode) { - CamelMimeFilterCRLF *crlf = gtk_type_new (CAMEL_MIME_FILTER_CRLF_TYPE); + CamelMimeFilterCRLF *crlf = CAMEL_MIME_FILTER_CRLF(camel_object_new (CAMEL_MIME_FILTER_CRLF_TYPE)); crlf->direction = direction; crlf->mode = mode; diff --git a/camel/camel-mime-filter-crlf.h b/camel/camel-mime-filter-crlf.h index 27f78030e3..6ba109d154 100644 --- a/camel/camel-mime-filter-crlf.h +++ b/camel/camel-mime-filter-crlf.h @@ -26,9 +26,9 @@ #include #define CAMEL_MIME_FILTER_CRLF_TYPE (camel_mime_filter_crlf_get_type ()) -#define CAMEL_MIME_FILTER_CRLF(obj) GTK_CHECK_CAST (obj, CAMEL_MIME_FILTER_CRLF_TYPE, CamelMimeFilterCRLF) -#define CAMEL_MIME_FILTER_CRLF_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, CAMEL_MIME_FILTER_CRLF_TYPE, CamelMimeFilterCRLFClass) -#define CAMEL_IS_MIME_FILTER_CRLF(obj) GTK_CHECK_TYPE (obj, CAMEL_MIME_FILTER_CRLF_TYPE) +#define CAMEL_MIME_FILTER_CRLF(obj) CAMEL_CHECK_CAST (obj, CAMEL_MIME_FILTER_CRLF_TYPE, CamelMimeFilterCRLF) +#define CAMEL_MIME_FILTER_CRLF_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, CAMEL_MIME_FILTER_CRLF_TYPE, CamelMimeFilterCRLFClass) +#define CAMEL_IS_MIME_FILTER_CRLF(obj) CAMEL_CHECK_TYPE (obj, CAMEL_MIME_FILTER_CRLF_TYPE) typedef struct _CamelMimeFilterCRLFClass CamelMimeFilterCRLFClass; @@ -55,7 +55,7 @@ struct _CamelMimeFilterCRLFClass { CamelMimeFilterClass parent_class; }; -GtkType camel_mime_filter_crlf_get_type (void); +CamelType camel_mime_filter_crlf_get_type (void); CamelMimeFilter *camel_mime_filter_crlf_new (CamelMimeFilterCRLFDirection direction, CamelMimeFilterCRLFMode mode); diff --git a/camel/camel-mime-filter-from.c b/camel/camel-mime-filter-from.c index 719b9d708a..017a256471 100644 --- a/camel/camel-mime-filter-from.c +++ b/camel/camel-mime-filter-from.c @@ -32,33 +32,22 @@ struct _CamelMimeFilterFromPrivate { static void camel_mime_filter_from_class_init (CamelMimeFilterFromClass *klass); static void camel_mime_filter_from_init (CamelMimeFilterFrom *obj); -static void camel_mime_filter_from_finalise (GtkObject *obj); static CamelMimeFilterClass *camel_mime_filter_from_parent; -enum SIGNALS { - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = { 0 }; - -guint +CamelType camel_mime_filter_from_get_type (void) { - static guint type = 0; + static CamelType type = CAMEL_INVALID_TYPE; - if (!type) { - GtkTypeInfo type_info = { - "CamelMimeFilterFrom", - sizeof (CamelMimeFilterFrom), - sizeof (CamelMimeFilterFromClass), - (GtkClassInitFunc) camel_mime_filter_from_class_init, - (GtkObjectInitFunc) camel_mime_filter_from_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_mime_filter_get_type (), &type_info); + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_mime_filter_get_type (), "CamelMimeFilterFrom", + sizeof (CamelMimeFilterFrom), + sizeof (CamelMimeFilterFromClass), + (CamelObjectClassInitFunc) camel_mime_filter_from_class_init, + NULL, + (CamelObjectInitFunc) camel_mime_filter_from_init, + NULL); } return type; @@ -166,17 +155,12 @@ filter(CamelMimeFilter *mf, char *in, size_t len, size_t prespace, char **out, s static void camel_mime_filter_from_class_init (CamelMimeFilterFromClass *klass) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; CamelMimeFilterClass *filter_class = (CamelMimeFilterClass *) klass; - camel_mime_filter_from_parent = gtk_type_class (camel_mime_filter_get_type ()); - - object_class->finalize = camel_mime_filter_from_finalise; + camel_mime_filter_from_parent = CAMEL_MIME_FILTER_CLASS (camel_type_get_global_classfuncs (camel_mime_filter_get_type ())); filter_class->filter = filter; filter_class->complete = complete; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); } static void @@ -188,12 +172,6 @@ camel_mime_filter_from_init (CamelMimeFilterFrom *obj) obj->midline = FALSE; } -static void -camel_mime_filter_from_finalise (GtkObject *obj) -{ - ((GtkObjectClass *)(camel_mime_filter_from_parent))->finalize((GtkObject *)obj); -} - /** * camel_mime_filter_from_new: * @@ -204,7 +182,7 @@ camel_mime_filter_from_finalise (GtkObject *obj) CamelMimeFilterFrom * camel_mime_filter_from_new (void) { - CamelMimeFilterFrom *new = CAMEL_MIME_FILTER_FROM ( gtk_type_new (camel_mime_filter_from_get_type ())); + CamelMimeFilterFrom *new = CAMEL_MIME_FILTER_FROM ( camel_object_new (camel_mime_filter_from_get_type ())); return new; } @@ -218,7 +196,7 @@ int main(int argc, char **argv) char *buffer; int len, prespace; - gtk_init(&argc, &argv); + g_tk_init(&argc, &argv); f = camel_mime_filter_from_new(); diff --git a/camel/camel-mime-filter-from.h b/camel/camel-mime-filter-from.h index 2a97bcc0f0..ac526b6e15 100644 --- a/camel/camel-mime-filter-from.h +++ b/camel/camel-mime-filter-from.h @@ -22,12 +22,11 @@ #ifndef _CAMEL_MIME_FILTER_FROM_H #define _CAMEL_MIME_FILTER_FROM_H -#include #include -#define CAMEL_MIME_FILTER_FROM(obj) GTK_CHECK_CAST (obj, camel_mime_filter_from_get_type (), CamelMimeFilterFrom) -#define CAMEL_MIME_FILTER_FROM_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_mime_filter_from_get_type (), CamelMimeFilterFromClass) -#define IS_CAMEL_MIME_FILTER_FROM(obj) GTK_CHECK_TYPE (obj, camel_mime_filter_from_get_type ()) +#define CAMEL_MIME_FILTER_FROM(obj) CAMEL_CHECK_CAST (obj, camel_mime_filter_from_get_type (), CamelMimeFilterFrom) +#define CAMEL_MIME_FILTER_FROM_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_mime_filter_from_get_type (), CamelMimeFilterFromClass) +#define IS_CAMEL_MIME_FILTER_FROM(obj) CAMEL_CHECK_TYPE (obj, camel_mime_filter_from_get_type ()) typedef struct _CamelMimeFilterFrom CamelMimeFilterFrom; typedef struct _CamelMimeFilterFromClass CamelMimeFilterFromClass; diff --git a/camel/camel-mime-filter-index.c b/camel/camel-mime-filter-index.c index 53a9f72920..46e0f3f5e8 100644 --- a/camel/camel-mime-filter-index.c +++ b/camel/camel-mime-filter-index.c @@ -22,47 +22,35 @@ static void camel_mime_filter_index_class_init (CamelMimeFilterIndexClass *klass); -static void camel_mime_filter_index_init (CamelMimeFilterIndex *obj); +static void camel_mime_filter_index_finalize (CamelObject *o); static CamelMimeFilterClass *camel_mime_filter_index_parent; -enum SIGNALS { - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = { 0 }; - -guint +CamelType camel_mime_filter_index_get_type (void) { - static guint type = 0; + static CamelType type = CAMEL_INVALID_TYPE; - if (!type) { - GtkTypeInfo type_info = { - "CamelMimeFilterIndex", - sizeof (CamelMimeFilterIndex), - sizeof (CamelMimeFilterIndexClass), - (GtkClassInitFunc) camel_mime_filter_index_class_init, - (GtkObjectInitFunc) camel_mime_filter_index_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_mime_filter_get_type (), &type_info); + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_mime_filter_get_type (), "CamelMimeFilterIndex", + sizeof (CamelMimeFilterIndex), + sizeof (CamelMimeFilterIndexClass), + (CamelObjectClassInitFunc) camel_mime_filter_index_class_init, + NULL, + NULL, + (CamelObjectFinalizeFunc) camel_mime_filter_index_finalize); } return type; } static void -finalise(GtkObject *o) +camel_mime_filter_index_finalize(CamelObject *o) { CamelMimeFilterIndex *f = (CamelMimeFilterIndex *)o; g_free(f->name); f->index = NULL; /* ibex's need refcounting? */ - - ((GtkObjectClass *)camel_mime_filter_index_parent)->finalize (o); } static void @@ -112,23 +100,13 @@ donothing: static void camel_mime_filter_index_class_init (CamelMimeFilterIndexClass *klass) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; CamelMimeFilterClass *filter_class = (CamelMimeFilterClass *) klass; - camel_mime_filter_index_parent = gtk_type_class (camel_mime_filter_get_type ()); - - object_class->finalize = finalise; + camel_mime_filter_index_parent = CAMEL_MIME_FILTER_CLASS (camel_type_get_global_classfuncs (camel_mime_filter_get_type ())); /*filter_class->reset = reset;*/ filter_class->filter = filter; filter_class->complete = complete; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); -} - -static void -camel_mime_filter_index_init (CamelMimeFilterIndex *obj) -{ } /** @@ -141,7 +119,7 @@ camel_mime_filter_index_init (CamelMimeFilterIndex *obj) CamelMimeFilterIndex * camel_mime_filter_index_new (void) { - CamelMimeFilterIndex *new = CAMEL_MIME_FILTER_INDEX ( gtk_type_new (camel_mime_filter_index_get_type ())); + CamelMimeFilterIndex *new = CAMEL_MIME_FILTER_INDEX ( camel_object_new (camel_mime_filter_index_get_type ())); return new; } diff --git a/camel/camel-mime-filter-index.h b/camel/camel-mime-filter-index.h index 7dcc76b8ea..b0a9107852 100644 --- a/camel/camel-mime-filter-index.h +++ b/camel/camel-mime-filter-index.h @@ -24,9 +24,9 @@ #include #include -#define CAMEL_MIME_FILTER_INDEX(obj) GTK_CHECK_CAST (obj, camel_mime_filter_index_get_type (), CamelMimeFilterIndex) -#define CAMEL_MIME_FILTER_INDEX_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_mime_filter_index_get_type (), CamelMimeFilterIndexClass) -#define IS_CAMEL_MIME_FILTER_INDEX(obj) GTK_CHECK_TYPE (obj, camel_mime_filter_index_get_type ()) +#define CAMEL_MIME_FILTER_INDEX(obj) CAMEL_CHECK_CAST (obj, camel_mime_filter_index_get_type (), CamelMimeFilterIndex) +#define CAMEL_MIME_FILTER_INDEX_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_mime_filter_index_get_type (), CamelMimeFilterIndexClass) +#define IS_CAMEL_MIME_FILTER_INDEX(obj) CAMEL_CHECK_TYPE (obj, camel_mime_filter_index_get_type ()) typedef struct _CamelMimeFilterIndexClass CamelMimeFilterIndexClass; diff --git a/camel/camel-mime-filter-save.c b/camel/camel-mime-filter-save.c index b5b54a2ee6..e1761994ed 100644 --- a/camel/camel-mime-filter-save.c +++ b/camel/camel-mime-filter-save.c @@ -30,39 +30,30 @@ static void camel_mime_filter_save_class_init (CamelMimeFilterSaveClass *klass); static void camel_mime_filter_save_init (CamelMimeFilterSave *obj); +static void camel_mime_filter_save_finalize (CamelObject *o); static CamelMimeFilterClass *camel_mime_filter_save_parent; -enum SIGNALS { - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = { 0 }; - -guint +CamelType camel_mime_filter_save_get_type (void) { - static guint type = 0; + static CamelType type = CAMEL_INVALID_TYPE; - if (!type) { - GtkTypeInfo type_info = { - "CamelMimeFilterSave", - sizeof (CamelMimeFilterSave), - sizeof (CamelMimeFilterSaveClass), - (GtkClassInitFunc) camel_mime_filter_save_class_init, - (GtkObjectInitFunc) camel_mime_filter_save_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_mime_filter_get_type (), &type_info); + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_mime_filter_get_type (), "CamelMimeFilterSave", + sizeof (CamelMimeFilterSave), + sizeof (CamelMimeFilterSaveClass), + (CamelObjectClassInitFunc) camel_mime_filter_save_class_init, + NULL, + (CamelObjectInitFunc) camel_mime_filter_save_init, + (CamelObjectFinalizeFunc) camel_mime_filter_save_finalize); } return type; } static void -finalise(GtkObject *o) +camel_mime_filter_save_finalize(CamelObject *o) { CamelMimeFilterSave *f = (CamelMimeFilterSave *)o; @@ -71,8 +62,6 @@ finalise(GtkObject *o) /* FIXME: what do we do with failed writes???? */ close(f->fd); } - - ((GtkObjectClass *)camel_mime_filter_save_parent)->finalize (o); } static void @@ -107,17 +96,12 @@ filter(CamelMimeFilter *mf, char *in, size_t len, size_t prespace, char **out, s static void camel_mime_filter_save_class_init (CamelMimeFilterSaveClass *klass) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; CamelMimeFilterClass *filter_class = (CamelMimeFilterClass *) klass; - camel_mime_filter_save_parent = gtk_type_class (camel_mime_filter_get_type ()); - - object_class->finalize = finalise; + camel_mime_filter_save_parent = CAMEL_MIME_FILTER_CLASS (camel_type_get_global_classfuncs (camel_mime_filter_get_type ())); filter_class->reset = reset; filter_class->filter = filter; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); } static void @@ -136,7 +120,7 @@ camel_mime_filter_save_init (CamelMimeFilterSave *f) CamelMimeFilterSave * camel_mime_filter_save_new (void) { - CamelMimeFilterSave *new = CAMEL_MIME_FILTER_SAVE ( gtk_type_new (camel_mime_filter_save_get_type ())); + CamelMimeFilterSave *new = CAMEL_MIME_FILTER_SAVE ( camel_object_new (camel_mime_filter_save_get_type ())); return new; } @@ -151,7 +135,7 @@ camel_mime_filter_save_new_name (const char *name, int flags, int mode) if (new->fd != -1) { new->filename = g_strdup(name); } else { - gtk_object_unref((GtkObject *)new); + camel_object_unref((CamelObject *)new); new = NULL; } } diff --git a/camel/camel-mime-filter-save.h b/camel/camel-mime-filter-save.h index eb6e448560..abc1bf1186 100644 --- a/camel/camel-mime-filter-save.h +++ b/camel/camel-mime-filter-save.h @@ -23,9 +23,9 @@ #include -#define CAMEL_MIME_FILTER_SAVE(obj) GTK_CHECK_CAST (obj, camel_mime_filter_save_get_type (), CamelMimeFilterSave) -#define CAMEL_MIME_FILTER_SAVE_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_mime_filter_save_get_type (), CamelMimeFilterSaveClass) -#define IS_CAMEL_MIME_FILTER_SAVE(obj) GTK_CHECK_TYPE (obj, camel_mime_filter_save_get_type ()) +#define CAMEL_MIME_FILTER_SAVE(obj) CAMEL_CHECK_CAST (obj, camel_mime_filter_save_get_type (), CamelMimeFilterSave) +#define CAMEL_MIME_FILTER_SAVE_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_mime_filter_save_get_type (), CamelMimeFilterSaveClass) +#define IS_CAMEL_MIME_FILTER_SAVE(obj) CAMEL_CHECK_TYPE (obj, camel_mime_filter_save_get_type ()) typedef struct _CamelMimeFilterSaveClass CamelMimeFilterSaveClass; diff --git a/camel/camel-mime-filter.c b/camel/camel-mime-filter.c index 27cee890fe..19c4e095fe 100644 --- a/camel/camel-mime-filter.c +++ b/camel/camel-mime-filter.c @@ -28,43 +28,38 @@ struct _CamelMimeFilterPrivate { #define PRE_HEAD (64) #define BACK_HEAD (64) #define _PRIVATE(o) (((CamelMimeFilter *)(o))->priv) -#define FCLASS(o) ((CamelMimeFilterClass *)((GtkObject *)(o))->klass) - -static void camel_mime_filter_class_init (CamelMimeFilterClass *klass); -static void camel_mime_filter_init (CamelMimeFilter *obj); +#define FCLASS(o) ((CamelMimeFilterClass *)(CAMEL_OBJECT_GET_CLASS(o))) static CamelObjectClass *camel_mime_filter_parent; -enum SIGNALS { - LAST_SIGNAL -}; +static void complete (CamelMimeFilter *mf, char *in, size_t len, + size_t prespace, char **out, size_t *outlen, + size_t *outprespace); -static guint signals[LAST_SIGNAL] = { 0 }; +static void +camel_mime_filter_class_init (CamelMimeFilterClass *klass) +{ + camel_mime_filter_parent = camel_type_get_global_classfuncs (camel_object_get_type ()); -guint -camel_mime_filter_get_type (void) + klass->complete = complete; +} + +static void +camel_mime_filter_init (CamelMimeFilter *obj) { - static guint type = 0; - - if (!type) { - GtkTypeInfo type_info = { - "CamelMimeFilter", - sizeof (CamelMimeFilter), - sizeof (CamelMimeFilterClass), - (GtkClassInitFunc) camel_mime_filter_class_init, - (GtkObjectInitFunc) camel_mime_filter_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_object_get_type (), &type_info); - } - - return type; + obj->outreal = NULL; + obj->outbuf = NULL; + obj->outsize = 0; + + obj->backbuf = NULL; + obj->backsize = 0; + obj->backlen = 0; + + _PRIVATE(obj) = g_malloc0(sizeof(*obj->priv)); } static void -finalise(GtkObject *o) +camel_mime_filter_finalize(CamelObject *o) { CamelMimeFilter *f = (CamelMimeFilter *)o; struct _CamelMimeFilterPrivate *p = _PRIVATE(f); @@ -73,42 +68,30 @@ finalise(GtkObject *o) g_free(f->backbuf); g_free(p->inbuf); g_free(p); - - ((GtkObjectClass *)camel_mime_filter_parent)->finalize (o); } -static void -complete(CamelMimeFilter *mf, char *in, size_t len, size_t prespace, char **out, size_t *outlen, size_t *outprespace) -{ - /* default - do nothing */ -} - -static void -camel_mime_filter_class_init (CamelMimeFilterClass *klass) +CamelType +camel_mime_filter_get_type (void) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; + static CamelType camel_mime_filter_type = CAMEL_INVALID_TYPE; - camel_mime_filter_parent = gtk_type_class (camel_object_get_type ()); - - object_class->finalize = finalise; - - klass->complete = complete; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); + if (camel_mime_filter_type == CAMEL_INVALID_TYPE) { + camel_mime_filter_type = camel_type_register (CAMEL_OBJECT_TYPE, "CamelMimeFilter", + sizeof (CamelMimeFilter), + sizeof (CamelMimeFilterClass), + (CamelObjectClassInitFunc) camel_mime_filter_class_init, + NULL, + (CamelObjectInitFunc) camel_mime_filter_init, + (CamelObjectFinalizeFunc) camel_mime_filter_finalize); + } + + return camel_mime_filter_type; } static void -camel_mime_filter_init (CamelMimeFilter *obj) +complete(CamelMimeFilter *mf, char *in, size_t len, size_t prespace, char **out, size_t *outlen, size_t *outprespace) { - obj->outreal = NULL; - obj->outbuf = NULL; - obj->outsize = 0; - - obj->backbuf = NULL; - obj->backsize = 0; - obj->backlen = 0; - - _PRIVATE(obj) = g_malloc0(sizeof(*obj->priv)); + /* default - do nothing */ } /** @@ -121,7 +104,7 @@ camel_mime_filter_init (CamelMimeFilter *obj) CamelMimeFilter * camel_mime_filter_new (void) { - CamelMimeFilter *new = CAMEL_MIME_FILTER ( gtk_type_new (camel_mime_filter_get_type ())); + CamelMimeFilter *new = CAMEL_MIME_FILTER ( camel_object_new (camel_mime_filter_get_type ())); return new; } diff --git a/camel/camel-mime-filter.h b/camel/camel-mime-filter.h index 4576596bab..6e729b13c2 100644 --- a/camel/camel-mime-filter.h +++ b/camel/camel-mime-filter.h @@ -26,9 +26,10 @@ #include #include -#define CAMEL_MIME_FILTER(obj) GTK_CHECK_CAST (obj, camel_mime_filter_get_type (), CamelMimeFilter) -#define CAMEL_MIME_FILTER_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_mime_filter_get_type (), CamelMimeFilterClass) -#define IS_CAMEL_MIME_FILTER(obj) GTK_CHECK_TYPE (obj, camel_mime_filter_get_type ()) +#define CAMEL_MIME_FILTER_TYPE (camel_mime_filter_get_type ()) +#define CAMEL_MIME_FILTER(obj) CAMEL_CHECK_CAST (obj, camel_mime_filter_get_type (), CamelMimeFilter) +#define CAMEL_MIME_FILTER_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_mime_filter_get_type (), CamelMimeFilterClass) +#define IS_CAMEL_MIME_FILTER(obj) CAMEL_CHECK_TYPE (obj, camel_mime_filter_get_type ()) typedef struct _CamelMimeFilterClass CamelMimeFilterClass; @@ -61,7 +62,7 @@ struct _CamelMimeFilterClass { void (*reset)(CamelMimeFilter *f); }; -guint camel_mime_filter_get_type (void); +CamelType camel_mime_filter_get_type (void); CamelMimeFilter *camel_mime_filter_new (void); void camel_mime_filter_filter(CamelMimeFilter *f, diff --git a/camel/camel-mime-message.c b/camel/camel-mime-message.c index d7a8775b43..c3bd02cd05 100644 --- a/camel/camel-mime-message.c +++ b/camel/camel-mime-message.c @@ -58,27 +58,26 @@ static char *recipient_names[] = { }; static int write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream); -static void finalize (GtkObject *object); static void add_header (CamelMedium *medium, const char *header_name, const void *header_value); static void set_header (CamelMedium *medium, const char *header_name, const void *header_value); static void remove_header (CamelMedium *medium, const char *header_name); static int construct_from_parser (CamelMimePart *, CamelMimeParser *); +static void g_lib_is_uber_crappy_shit(gpointer whocares, gpointer getlost, gpointer blah); /* Returns the class for a CamelMimeMessage */ -#define CMM_CLASS(so) CAMEL_MIME_MESSAGE_CLASS (GTK_OBJECT(so)->klass) -#define CDW_CLASS(so) CAMEL_DATA_WRAPPER_CLASS (GTK_OBJECT(so)->klass) -#define CMD_CLASS(so) CAMEL_MEDIUM_CLASS (GTK_OBJECT(so)->klass) +#define CMM_CLASS(so) CAMEL_MIME_MESSAGE_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CDW_CLASS(so) CAMEL_DATA_WRAPPER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CMD_CLASS(so) CAMEL_MEDIUM_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static void camel_mime_message_class_init (CamelMimeMessageClass *camel_mime_message_class) { CamelDataWrapperClass *camel_data_wrapper_class = CAMEL_DATA_WRAPPER_CLASS (camel_mime_message_class); CamelMimePartClass *camel_mime_part_class = CAMEL_MIME_PART_CLASS (camel_mime_message_class); - GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (camel_mime_message_class); CamelMediumClass *camel_medium_class = CAMEL_MEDIUM_CLASS (camel_mime_message_class); int i; - parent_class = gtk_type_class (camel_mime_part_get_type ()); + parent_class = CAMEL_MIME_PART_CLASS(camel_type_get_global_classfuncs (camel_mime_part_get_type ())); header_name_table = g_hash_table_new (g_strcase_hash, g_strcase_equal); for (i=0;header_names[i];i++) @@ -92,8 +91,6 @@ camel_mime_message_class_init (CamelMimeMessageClass *camel_mime_message_class) camel_medium_class->remove_header = remove_header; camel_mime_part_class->construct_from_parser = construct_from_parser; - - gtk_object_class->finalize = finalize; } @@ -120,39 +117,8 @@ camel_mime_message_init (gpointer object, gpointer klass) mime_message->date_str = NULL; } -GtkType -camel_mime_message_get_type (void) -{ - static GtkType camel_mime_message_type = 0; - - if (!camel_mime_message_type) { - GtkTypeInfo camel_mime_message_info = - { - "CamelMimeMessage", - sizeof (CamelMimeMessage), - sizeof (CamelMimeMessageClass), - (GtkClassInitFunc) camel_mime_message_class_init, - (GtkObjectInitFunc) camel_mime_message_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_mime_message_type = gtk_type_unique (camel_mime_part_get_type (), &camel_mime_message_info); - } - - return camel_mime_message_type; -} - -/* annoying way to free objects in a hashtable, i mean, its not like anyone - would want to store them in a hashtable, really */ -static void g_lib_is_uber_crappy_shit(gpointer whocares, gpointer getlost, gpointer blah) -{ - gtk_object_unref((GtkObject *)getlost); -} - static void -finalize (GtkObject *object) +camel_mime_message_finalize (CamelObject *object) { CamelMimeMessage *message = CAMEL_MIME_MESSAGE (object); @@ -163,8 +129,33 @@ finalize (GtkObject *object) g_hash_table_foreach (message->recipients, g_lib_is_uber_crappy_shit, NULL); g_hash_table_destroy(message->recipients); +} + + +CamelType +camel_mime_message_get_type (void) +{ + static CamelType camel_mime_message_type = CAMEL_INVALID_TYPE; + + if (camel_mime_message_type == CAMEL_INVALID_TYPE) { + camel_mime_message_type = camel_type_register (camel_mime_part_get_type(), "CamelMimeMessage", + sizeof (CamelMimeMessage), + sizeof (CamelMimeMessageClass), + (CamelObjectClassInitFunc) camel_mime_message_class_init, + NULL, + (CamelObjectInitFunc) camel_mime_message_init, + (CamelObjectFinalizeFunc) camel_mime_message_finalize); + } + + return camel_mime_message_type; +} - GTK_OBJECT_CLASS (parent_class)->finalize (object); +/* annoying way to free objects in a hashtable, i mean, its not like anyone + would want to store them in a hashtable, really */ +/* peterw: somebody's not bitter :-) */ +static void g_lib_is_uber_crappy_shit(gpointer whocares, gpointer getlost, gpointer blah) +{ + camel_object_unref((CamelObject *)getlost); } @@ -173,7 +164,7 @@ CamelMimeMessage * camel_mime_message_new (void) { CamelMimeMessage *mime_message; - mime_message = gtk_type_new (CAMEL_MIME_MESSAGE_TYPE); + mime_message = CAMEL_MIME_MESSAGE(camel_object_new (CAMEL_MIME_MESSAGE_TYPE)); return mime_message; } diff --git a/camel/camel-mime-message.h b/camel/camel-mime-message.h index b52da923a9..7e90d7cbcc 100644 --- a/camel/camel-mime-message.h +++ b/camel/camel-mime-message.h @@ -42,9 +42,9 @@ extern "C" { #define CAMEL_MIME_MESSAGE_TYPE (camel_mime_message_get_type ()) -#define CAMEL_MIME_MESSAGE(obj) (GTK_CHECK_CAST((obj), CAMEL_MIME_MESSAGE_TYPE, CamelMimeMessage)) -#define CAMEL_MIME_MESSAGE_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_MIME_MESSAGE_TYPE, CamelMimeMessageClass)) -#define CAMEL_IS_MIME_MESSAGE(o) (GTK_CHECK_TYPE((o), CAMEL_MIME_MESSAGE_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 */ @@ -76,8 +76,8 @@ typedef struct { -/* Standard Gtk function */ -GtkType camel_mime_message_get_type (void); +/* Standard Camel function */ +CamelType camel_mime_message_get_type (void); /* public methods */ diff --git a/camel/camel-mime-parser.c b/camel/camel-mime-parser.c index a781479aeb..4b7b23ae37 100644 --- a/camel/camel-mime-parser.c +++ b/camel/camel-mime-parser.c @@ -303,65 +303,47 @@ static char *states[] = { static CamelObjectClass *camel_mime_parser_parent; -enum SIGNALS { - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = { 0 }; +static void +camel_mime_parser_class_init (CamelMimeParserClass *klass) +{ + camel_mime_parser_parent = camel_type_get_global_classfuncs (camel_object_get_type ()); +} -guint -camel_mime_parser_get_type (void) +static void +camel_mime_parser_init (CamelMimeParser *obj) { - static guint type = 0; - - if (!type) { - GtkTypeInfo type_info = { - "CamelMimeParser", - sizeof (CamelMimeParser), - sizeof (CamelMimeParserClass), - (GtkClassInitFunc) camel_mime_parser_class_init, - (GtkObjectInitFunc) camel_mime_parser_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_object_get_type (), &type_info); - } - - return type; + struct _header_scan_state *s; + + s = folder_scan_init(); + _PRIVATE(obj) = s; } static void -finalise(GtkObject *o) +camel_mime_parser_finalize(CamelObject *o) { struct _header_scan_state *s = _PRIVATE(o); #ifdef PURIFY purify_watch_remove_all(); #endif folder_scan_close(s); - - ((GtkObjectClass *)camel_mime_parser_parent)->finalize (o); } -static void -camel_mime_parser_class_init (CamelMimeParserClass *klass) +CamelType +camel_mime_parser_get_type (void) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; + static CamelType type = CAMEL_INVALID_TYPE; - camel_mime_parser_parent = gtk_type_class (camel_object_get_type ()); - - object_class->finalize = finalise; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); -} - -static void -camel_mime_parser_init (CamelMimeParser *obj) -{ - struct _header_scan_state *s; - - s = folder_scan_init(); - _PRIVATE(obj) = s; + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_object_get_type (), "CamelMimeParser", + sizeof (CamelMimeParser), + sizeof (CamelMimeParserClass), + (CamelObjectClassInitFunc) camel_mime_parser_class_init, + NULL, + (CamelObjectInitFunc) camel_mime_parser_init, + (CamelObjectFinalizeFunc) camel_mime_parser_finalize); + } + + return type; } /** @@ -374,7 +356,7 @@ camel_mime_parser_init (CamelMimeParser *obj) CamelMimeParser * camel_mime_parser_new (void) { - CamelMimeParser *new = CAMEL_MIME_PARSER ( gtk_type_new (camel_mime_parser_get_type ())); + CamelMimeParser *new = CAMEL_MIME_PARSER ( camel_object_new (camel_mime_parser_get_type ())); return new; } @@ -407,7 +389,7 @@ camel_mime_parser_filter_add(CamelMimeParser *m, CamelMimeFilter *mf) if (s->filterid == -1) s->filterid++; new->next = 0; - gtk_object_ref((GtkObject *)mf); + camel_object_ref((CamelObject *)mf); /* yes, this is correct, since 'next' is the first element of the struct */ f = (struct _header_scan_filter *)&s->filters; @@ -435,7 +417,7 @@ camel_mime_parser_filter_remove(CamelMimeParser *m, int id) while (f && f->next) { old = f->next; if (old->id == id) { - gtk_object_unref((GtkObject *)old->filter); + camel_object_unref((CamelObject *)old->filter); f->next = old->next; g_free(old); /* there should only be a single matching id, but @@ -1366,7 +1348,7 @@ folder_scan_close(struct _header_scan_state *s) if (s->fd != -1) close(s->fd); if (s->stream) { - gtk_object_unref((GtkObject *)s->stream); + camel_object_unref((CamelObject *)s->stream); } g_free(s); } @@ -1427,7 +1409,7 @@ folder_scan_init_with_fd(struct _header_scan_state *s, int fd) close(s->fd); s->fd = fd; if (s->stream) { - gtk_object_unref((GtkObject *)s->stream); + camel_object_unref((CamelObject *)s->stream); s->stream = NULL; } return 0; @@ -1447,9 +1429,9 @@ folder_scan_init_with_stream(struct _header_scan_state *s, CamelStream *stream) s->inptr = s->inbuf; s->inend[0] = '\n'; if (s->stream) - gtk_object_unref((GtkObject *)s->stream); + camel_object_unref((CamelObject *)s->stream); s->stream = stream; - gtk_object_ref((GtkObject *)stream); + camel_object_ref((CamelObject *)stream); if (s->fd != -1) { close(s->fd); s->fd = -1; diff --git a/camel/camel-mime-parser.h b/camel/camel-mime-parser.h index 2283ec6f98..5baa58c88e 100644 --- a/camel/camel-mime-parser.h +++ b/camel/camel-mime-parser.h @@ -27,9 +27,9 @@ #include #include -#define CAMEL_MIME_PARSER(obj) GTK_CHECK_CAST (obj, camel_mime_parser_get_type (), CamelMimeParser) -#define CAMEL_MIME_PARSER_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_mime_parser_get_type (), CamelMimeParserClass) -#define IS_CAMEL_MIME_PARSER(obj) GTK_CHECK_TYPE (obj, camel_mime_parser_get_type ()) +#define CAMEL_MIME_PARSER(obj) CAMEL_CHECK_CAST (obj, camel_mime_parser_get_type (), CamelMimeParser) +#define CAMEL_MIME_PARSER_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_mime_parser_get_type (), CamelMimeParserClass) +#define IS_CAMEL_MIME_PARSER(obj) CAMEL_CHECK_TYPE (obj, camel_mime_parser_get_type ()) typedef struct _CamelMimeParserClass CamelMimeParserClass; diff --git a/camel/camel-mime-part-utils.c b/camel/camel-mime-part-utils.c index 656520030c..68b1f1da75 100644 --- a/camel/camel-mime-part-utils.c +++ b/camel/camel-mime-part-utils.c @@ -61,7 +61,7 @@ simple_data_wrapper_construct_from_parser(CamelDataWrapper *dw, CamelMimeParser /* if we can't seek, dont have a stream/etc, then we must cache it */ source = camel_mime_parser_stream(mp); if (source) { - gtk_object_ref((GtkObject *)source); + camel_object_ref((CamelObject *)source); if (CAMEL_IS_SEEKABLE_STREAM (source)) { seekable_source = CAMEL_SEEKABLE_STREAM (source); cache = FALSE; @@ -135,7 +135,7 @@ simple_data_wrapper_construct_from_parser(CamelDataWrapper *dw, CamelMimeParser d(printf("Small message part, kept in memory!\n")); mem = camel_stream_mem_new_with_byte_array(buffer); camel_data_wrapper_construct_from_stream (dw, mem); - gtk_object_unref ((GtkObject *)mem); + camel_object_unref ((CamelObject *)mem); } else { CamelStream *sub; CamelStreamFilter *filter; @@ -159,11 +159,11 @@ simple_data_wrapper_construct_from_parser(CamelDataWrapper *dw, CamelMimeParser camel_stream_filter_add(filter, fch); } camel_data_wrapper_construct_from_stream (dw, (CamelStream *)filter); - gtk_object_unref ((GtkObject *)filter); + camel_object_unref ((CamelObject *)filter); } else { camel_data_wrapper_construct_from_stream (dw, sub); } - gtk_object_unref ((GtkObject *)sub); + camel_object_unref ((CamelObject *)sub); } camel_mime_parser_filter_remove(mp, decid); @@ -171,13 +171,13 @@ simple_data_wrapper_construct_from_parser(CamelDataWrapper *dw, CamelMimeParser camel_mime_parser_filter_remove(mp, chrid); if (fdec) - gtk_object_unref((GtkObject *)fdec); + camel_object_unref((CamelObject *)fdec); if (fcrlf) - gtk_object_unref((GtkObject *)fcrlf); + camel_object_unref((CamelObject *)fcrlf); if (fch) - gtk_object_unref((GtkObject *)fch); + camel_object_unref((CamelObject *)fch); if (source) - gtk_object_unref((GtkObject *)source); + camel_object_unref((CamelObject *)source); } @@ -214,7 +214,7 @@ camel_mime_part_construct_content_from_parser(CamelMimePart *dw, CamelMimeParser bodypart = (CamelDataWrapper *)camel_mime_part_new(); camel_mime_part_construct_from_parser((CamelMimePart *)bodypart, mp); camel_multipart_add_part((CamelMultipart *)content, (CamelMimePart *)bodypart); - gtk_object_unref ((GtkObject *)bodypart); + camel_object_unref ((CamelObject *)bodypart); } d(printf("Created multi-part\n")); @@ -228,7 +228,7 @@ camel_mime_part_construct_content_from_parser(CamelMimePart *dw, CamelMimeParser camel_data_wrapper_set_mime_type_field (content, camel_mime_part_get_content_type ((CamelMimePart *)dw)); camel_medium_set_content_object((CamelMedium *)dw, content); - gtk_object_unref ((GtkObject *)content); + camel_object_unref ((CamelObject *)content); } } diff --git a/camel/camel-mime-part.c b/camel/camel-mime-part.c index ab4c44b82f..4112857667 100644 --- a/camel/camel-mime-part.c +++ b/camel/camel-mime-part.c @@ -59,12 +59,9 @@ static GHashTable *header_name_table; static CamelMediumClass *parent_class=NULL; /* Returns the class for a CamelMimePart */ -#define CMP_CLASS(so) CAMEL_MIME_PART_CLASS (GTK_OBJECT(so)->klass) -#define CDW_CLASS(so) CAMEL_DATA_WRAPPER_CLASS (GTK_OBJECT(so)->klass) -#define CMD_CLASS(so) CAMEL_MEDIUM_CLASS (GTK_OBJECT(so)->klass) - -/* from GtkObject */ -static void finalize (GtkObject *object); +#define CMP_CLASS(so) CAMEL_MIME_PART_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CDW_CLASS(so) CAMEL_DATA_WRAPPER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CMD_CLASS(so) CAMEL_MEDIUM_CLASS (CAMEL_OBJECT_GET_CLASS(so)) /* from CamelDataWrapper */ static int write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream); @@ -106,9 +103,8 @@ camel_mime_part_class_init (CamelMimePartClass *camel_mime_part_class) { CamelMediumClass *camel_medium_class = CAMEL_MEDIUM_CLASS (camel_mime_part_class); CamelDataWrapperClass *camel_data_wrapper_class = CAMEL_DATA_WRAPPER_CLASS (camel_mime_part_class); - GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (camel_data_wrapper_class); - parent_class = gtk_type_class (camel_medium_get_type ()); + parent_class = CAMEL_MEDIUM_CLASS (camel_type_get_global_classfuncs (camel_medium_get_type ())); init_header_name_table(); camel_mime_part_class->construct_from_parser = construct_from_parser; @@ -122,8 +118,6 @@ camel_mime_part_class_init (CamelMimePartClass *camel_mime_part_class) camel_data_wrapper_class->write_to_stream = write_to_stream; camel_data_wrapper_class->construct_from_stream= construct_from_stream; - - gtk_object_class->finalize = finalize; } static void @@ -144,35 +138,8 @@ camel_mime_part_init (gpointer object, gpointer klass) } - - -GtkType -camel_mime_part_get_type (void) -{ - static GtkType camel_mime_part_type = 0; - - if (!camel_mime_part_type) { - GtkTypeInfo camel_mime_part_info = - { - "CamelMimePart", - sizeof (CamelMimePart), - sizeof (CamelMimePartClass), - (GtkClassInitFunc) camel_mime_part_class_init, - (GtkObjectInitFunc) camel_mime_part_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_mime_part_type = gtk_type_unique (camel_medium_get_type (), &camel_mime_part_info); - } - - return camel_mime_part_type; -} - - static void -finalize (GtkObject *object) +camel_mime_part_finalize (CamelObject *object) { CamelMimePart *mime_part = CAMEL_MIME_PART (object); @@ -185,13 +152,32 @@ finalize (GtkObject *object) if (mime_part->content_type) gmime_content_field_unref (mime_part->content_type); if (mime_part->temp_message_buffer) g_byte_array_free (mime_part->temp_message_buffer, TRUE); - if (mime_part->content_input_stream) gtk_object_unref (GTK_OBJECT (mime_part->content_input_stream)); + if (mime_part->content_input_stream) camel_object_unref (CAMEL_OBJECT (mime_part->content_input_stream)); header_raw_clear(&mime_part->headers); +} + - GTK_OBJECT_CLASS (parent_class)->finalize (object); + +CamelType +camel_mime_part_get_type (void) +{ + static CamelType camel_mime_part_type = CAMEL_INVALID_TYPE; + + if (camel_mime_part_type == CAMEL_INVALID_TYPE) { + camel_mime_part_type = camel_type_register (CAMEL_MEDIUM_TYPE, "CamelMimePart", + sizeof (CamelMimePart), + sizeof (CamelMimePartClass), + (CamelObjectClassInitFunc) camel_mime_part_class_init, + NULL, + (CamelObjectInitFunc) camel_mime_part_init, + (CamelObjectFinalizeFunc) camel_mime_part_finalize); + } + + return camel_mime_part_type; } + /* **** */ static gboolean @@ -533,10 +519,10 @@ write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream) 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); - gtk_object_unref((GtkObject *)crlf); + camel_object_unref((CamelObject *)crlf); } camel_stream_filter_add(filter_stream, filter); - gtk_object_unref((GtkObject *)filter); + camel_object_unref((CamelObject *)filter); stream = (CamelStream *)filter_stream; } @@ -544,7 +530,7 @@ write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream) count = camel_data_wrapper_write_to_stream (content, stream); if (filter_stream) { camel_stream_flush((CamelStream *)filter_stream); - gtk_object_unref((GtkObject *)filter_stream); + camel_object_unref((CamelObject *)filter_stream); } if (count == -1) return -1; @@ -618,7 +604,7 @@ construct_from_stream(CamelDataWrapper *dw, CamelStream *s) } else { ret = camel_mime_part_construct_from_parser((CamelMimePart *)dw, mp); } - gtk_object_unref((GtkObject *)mp); + camel_object_unref((CamelObject *)mp); return ret; } @@ -675,7 +661,7 @@ camel_mime_part_encoding_from_string (const gchar *string) CamelMimePart * camel_mime_part_new (void) { - return (CamelMimePart *)gtk_object_new (CAMEL_MIME_PART_TYPE, NULL); + return (CamelMimePart *)camel_object_new (CAMEL_MIME_PART_TYPE); } /** @@ -705,12 +691,12 @@ camel_mime_part_set_content (CamelMimePart *camel_mime_part, camel_data_wrapper_set_mime_type (dw, type); stream = camel_stream_mem_new_with_buffer (data, length); camel_data_wrapper_construct_from_stream (dw, stream); - gtk_object_unref (GTK_OBJECT (stream)); + camel_object_unref (CAMEL_OBJECT (stream)); camel_medium_set_content_object (medium, dw); - gtk_object_unref (GTK_OBJECT (dw)); + camel_object_unref (CAMEL_OBJECT (dw)); } else { if (medium->content) - gtk_object_unref (GTK_OBJECT (medium->content)); + camel_object_unref (CAMEL_OBJECT (medium->content)); medium->content = NULL; } } diff --git a/camel/camel-mime-part.h b/camel/camel-mime-part.h index 00a7bec876..e423553318 100644 --- a/camel/camel-mime-part.h +++ b/camel/camel-mime-part.h @@ -39,9 +39,9 @@ extern "C" { #include #define CAMEL_MIME_PART_TYPE (camel_mime_part_get_type ()) -#define CAMEL_MIME_PART(obj) (GTK_CHECK_CAST((obj), CAMEL_MIME_PART_TYPE, CamelMimePart)) -#define CAMEL_MIME_PART_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_MIME_PART_TYPE, CamelMimePartClass)) -#define CAMEL_IS_MIME_PART(o) (GTK_CHECK_TYPE((o), CAMEL_MIME_PART_TYPE)) +#define CAMEL_MIME_PART(obj) (CAMEL_CHECK_CAST((obj), CAMEL_MIME_PART_TYPE, CamelMimePart)) +#define CAMEL_MIME_PART_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_MIME_PART_TYPE, CamelMimePartClass)) +#define CAMEL_IS_MIME_PART(o) (CAMEL_CHECK_TYPE((o), CAMEL_MIME_PART_TYPE)) enum _CamelMimePartEncodingType { @@ -82,8 +82,8 @@ typedef struct _CamelMimePartClass { int (*construct_from_parser) (CamelMimePart *, CamelMimeParser *); } CamelMimePartClass; -/* Standard Gtk function */ -GtkType camel_mime_part_get_type (void); +/* Standard Camel function */ +CamelType camel_mime_part_get_type (void); /* public methods */ CamelMimePart * camel_mime_part_new (void); diff --git a/camel/camel-movemail.c b/camel/camel-movemail.c index d5cc335481..f587914a31 100644 --- a/camel/camel-movemail.c +++ b/camel/camel-movemail.c @@ -565,8 +565,8 @@ camel_movemail_solaris (int sfd, int dfd, CamelException *ex) } } - gtk_object_unref((GtkObject *)mp); - gtk_object_unref((GtkObject *)ffrom); + camel_object_unref((CamelObject *)mp); + camel_object_unref((CamelObject *)ffrom); return ret; @@ -577,8 +577,8 @@ fail: g_strerror (errno)); - gtk_object_unref((GtkObject *)mp); - gtk_object_unref((GtkObject *)ffrom); + camel_object_unref((CamelObject *)mp); + camel_object_unref((CamelObject *)ffrom); return -1; } diff --git a/camel/camel-multipart.c b/camel/camel-multipart.c index e28c6542bf..ebbad07047 100644 --- a/camel/camel-multipart.c +++ b/camel/camel-multipart.c @@ -56,17 +56,17 @@ static void set_boundary (CamelMultipart *multipart, static const gchar * get_boundary (CamelMultipart *multipart); static int write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream); -static void finalize (GtkObject *object); +static void unref_part (gpointer data, gpointer user_data); static CamelDataWrapperClass *parent_class = NULL; /* Returns the class for a CamelMultipart */ -#define CMP_CLASS(so) CAMEL_MULTIPART_CLASS (GTK_OBJECT(so)->klass) +#define CMP_CLASS(so) CAMEL_MULTIPART_CLASS (CAMEL_OBJECT_GET_CLASS(so)) /* Returns the class for a CamelDataWrapper */ -#define CDW_CLASS(so) CAMEL_DATA_WRAPPER_CLASS (GTK_OBJECT(so)->klass) +#define CDW_CLASS(so) CAMEL_DATA_WRAPPER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static void @@ -74,10 +74,8 @@ camel_multipart_class_init (CamelMultipartClass *camel_multipart_class) { CamelDataWrapperClass *camel_data_wrapper_class = CAMEL_DATA_WRAPPER_CLASS (camel_multipart_class); - GtkObjectClass *gtk_object_class = - GTK_OBJECT_CLASS (camel_multipart_class); - parent_class = gtk_type_class (camel_data_wrapper_get_type ()); + parent_class = CAMEL_DATA_WRAPPER_CLASS (camel_type_get_global_classfuncs (camel_data_wrapper_get_type ())); /* virtual method definition */ camel_multipart_class->add_part = add_part; @@ -91,8 +89,6 @@ camel_multipart_class_init (CamelMultipartClass *camel_multipart_class) /* virtual method overload */ camel_data_wrapper_class->write_to_stream = write_to_stream; - - gtk_object_class->finalize = finalize; } static void @@ -106,41 +102,8 @@ camel_multipart_init (gpointer object, gpointer klass) multipart->postface = NULL; } - -GtkType -camel_multipart_get_type (void) -{ - static GtkType camel_multipart_type = 0; - - if (!camel_multipart_type) { - GtkTypeInfo camel_multipart_info = - { - "CamelMultipart", - sizeof (CamelMultipart), - sizeof (CamelMultipartClass), - (GtkClassInitFunc) camel_multipart_class_init, - (GtkObjectInitFunc) camel_multipart_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_multipart_type = gtk_type_unique (camel_data_wrapper_get_type (), &camel_multipart_info); - } - - return camel_multipart_type; -} - -static void -unref_part (gpointer data, gpointer user_data) -{ - GtkObject *part = GTK_OBJECT (data); - - gtk_object_unref (part); -} - static void -finalize (GtkObject *object) +camel_multipart_finalize (CamelObject *object) { CamelMultipart *multipart = CAMEL_MULTIPART (object); @@ -152,11 +115,34 @@ finalize (GtkObject *object) g_free (multipart->preface); if (multipart->postface) g_free (multipart->postface); +} + - GTK_OBJECT_CLASS (parent_class)->finalize (object); +CamelType +camel_multipart_get_type (void) +{ + static CamelType camel_multipart_type = CAMEL_INVALID_TYPE; + + if (camel_multipart_type == CAMEL_INVALID_TYPE) { + camel_multipart_type = camel_type_register (camel_data_wrapper_get_type (), "CamelMultipart", + sizeof (CamelMultipart), + sizeof (CamelMultipartClass), + (CamelObjectClassInitFunc) camel_multipart_class_init, + NULL, + (CamelObjectInitFunc) camel_multipart_init, + (CamelObjectFinalizeFunc) camel_multipart_finalize); + } + + return camel_multipart_type; } +static void +unref_part (gpointer data, gpointer user_data) +{ + CamelObject *part = CAMEL_OBJECT (data); + camel_object_unref (part); +} /** * camel_multipart_new: @@ -170,7 +156,7 @@ camel_multipart_new (void) { CamelMultipart *multipart; - multipart = (CamelMultipart *)gtk_type_new (CAMEL_MULTIPART_TYPE); + multipart = (CamelMultipart *)camel_object_new (CAMEL_MULTIPART_TYPE); multipart->preface = NULL; multipart->postface = NULL; @@ -182,7 +168,7 @@ static void add_part (CamelMultipart *multipart, CamelMimePart *part) { multipart->parts = g_list_append (multipart->parts, part); - gtk_object_ref (GTK_OBJECT (part)); + camel_object_ref (CAMEL_OBJECT (part)); } /** @@ -206,7 +192,7 @@ static void add_part_at (CamelMultipart *multipart, CamelMimePart *part, guint index) { multipart->parts = g_list_insert (multipart->parts, part, index); - gtk_object_ref (GTK_OBJECT (part)); + camel_object_ref (CAMEL_OBJECT (part)); } /** @@ -236,7 +222,7 @@ remove_part (CamelMultipart *multipart, CamelMimePart *part) if (!multipart->parts) return; multipart->parts = g_list_remove (multipart->parts, part); - gtk_object_unref (GTK_OBJECT (part)); + camel_object_unref (CAMEL_OBJECT (part)); } /** @@ -278,7 +264,7 @@ remove_part_at (CamelMultipart *multipart, guint index) multipart->parts = g_list_remove_link (parts_list, part_to_remove); if (part_to_remove->data) - gtk_object_unref (GTK_OBJECT (part_to_remove->data)); + camel_object_unref (CAMEL_OBJECT (part_to_remove->data)); g_list_free_1 (part_to_remove); return removed_part; @@ -291,7 +277,7 @@ remove_part_at (CamelMultipart *multipart, guint index) * * Remove the indicated part from the multipart object. * - * Return value: the removed part. Note that it is gtk_object_unref()ed + * Return value: the removed part. Note that it is camel_object_unref()ed * before being returned, which may cause it to be destroyed. **/ CamelMimePart * diff --git a/camel/camel-multipart.h b/camel/camel-multipart.h index 709e73e51d..642cdb5255 100644 --- a/camel/camel-multipart.h +++ b/camel/camel-multipart.h @@ -37,9 +37,9 @@ extern "C" { #include #define CAMEL_MULTIPART_TYPE (camel_multipart_get_type ()) -#define CAMEL_MULTIPART(obj) (GTK_CHECK_CAST((obj), CAMEL_MULTIPART_TYPE, CamelMultipart)) -#define CAMEL_MULTIPART_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_MULTIPART_TYPE, CamelMultipartClass)) -#define CAMEL_IS_MULTIPART(o) (GTK_CHECK_TYPE((o), CAMEL_MULTIPART_TYPE)) +#define CAMEL_MULTIPART(obj) (CAMEL_CHECK_CAST((obj), CAMEL_MULTIPART_TYPE, CamelMultipart)) +#define CAMEL_MULTIPART_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_MULTIPART_TYPE, CamelMultipartClass)) +#define CAMEL_IS_MULTIPART(o) (CAMEL_CHECK_TYPE((o), CAMEL_MULTIPART_TYPE)) struct _CamelMultipart @@ -72,8 +72,8 @@ typedef struct { } CamelMultipartClass; -/* Standard Gtk function */ -GtkType camel_multipart_get_type (void); +/* Standard Camel function */ +CamelType camel_multipart_get_type (void); /* public methods */ diff --git a/camel/camel-news-address.c b/camel/camel-news-address.c index 671f0a5559..ebd35b80c7 100644 --- a/camel/camel-news-address.c +++ b/camel/camel-news-address.c @@ -22,53 +22,34 @@ static void camel_news_address_class_init (CamelNewsAddressClass *klass); -static void camel_news_address_init (CamelNewsAddress *obj); static CamelAddressClass *camel_news_address_parent; -enum SIGNALS { - LAST_SIGNAL -}; +static void +camel_news_address_class_init (CamelNewsAddressClass *klass) +{ + camel_news_address_parent = CAMEL_ADDRESS_CLASS (camel_type_get_global_classfuncs (camel_address_get_type ())); +} -static guint signals[LAST_SIGNAL] = { 0 }; -guint +CamelType camel_news_address_get_type (void) { - static guint type = 0; + static guint type = CAMEL_INVALID_TYPE; - if (!type) { - GtkTypeInfo type_info = { - "CamelNewsAddress", - sizeof (CamelNewsAddress), - sizeof (CamelNewsAddressClass), - (GtkClassInitFunc) camel_news_address_class_init, - (GtkObjectInitFunc) camel_news_address_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_address_get_type (), &type_info); + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_address_get_type (), "CamelNewsAddress", + sizeof (CamelNewsAddress), + sizeof (CamelNewsAddressClass), + (CamelObjectClassInitFunc) camel_news_address_class_init, + NULL, + NULL, + NULL); } return type; } -static void -camel_news_address_class_init (CamelNewsAddressClass *klass) -{ - GtkObjectClass *object_class = (GtkObjectClass *) klass; - - camel_news_address_parent = gtk_type_class (camel_address_get_type ()); - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); -} - -static void -camel_news_address_init (CamelNewsAddress *obj) -{ -} - /** * camel_news_address_new: * @@ -79,6 +60,6 @@ camel_news_address_init (CamelNewsAddress *obj) CamelNewsAddress * camel_news_address_new (void) { - CamelNewsAddress *new = CAMEL_NEWS_ADDRESS ( gtk_type_new (camel_news_address_get_type ())); + CamelNewsAddress *new = CAMEL_NEWS_ADDRESS ( camel_object_new (camel_news_address_get_type ())); return new; } diff --git a/camel/camel-news-address.h b/camel/camel-news-address.h index e25f907351..8d2aa03968 100644 --- a/camel/camel-news-address.h +++ b/camel/camel-news-address.h @@ -23,9 +23,9 @@ #include -#define CAMEL_NEWS_ADDRESS(obj) GTK_CHECK_CAST (obj, camel_news_address_get_type (), CamelNewsAddress) -#define CAMEL_NEWS_ADDRESS_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_news_address_get_type (), CamelNewsAddressClass) -#define IS_CAMEL_NEWS_ADDRESS(obj) GTK_CHECK_TYPE (obj, camel_news_address_get_type ()) +#define CAMEL_NEWS_ADDRESS(obj) CAMEL_CHECK_CAST (obj, camel_news_address_get_type (), CamelNewsAddress) +#define CAMEL_NEWS_ADDRESS_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_news_address_get_type (), CamelNewsAddressClass) +#define IS_CAMEL_NEWS_ADDRESS(obj) CAMEL_CHECK_TYPE (obj, camel_news_address_get_type ()) typedef struct _CamelNewsAddressClass CamelNewsAddressClass; diff --git a/camel/camel-object.c b/camel/camel-object.c index 3edce10d8a..849d47612e 100644 --- a/camel/camel-object.c +++ b/camel/camel-object.c @@ -26,32 +26,945 @@ #include #include "camel-object.h" +/* I just mashed the keyboard for these... */ +#define CAMEL_OBJECT_MAGIC_VALUE 0x77A344EF +#define CAMEL_OBJECT_CLASS_MAGIC_VALUE 0xEE26A990 +#define CAMEL_OBJECT_FINALIZED_VALUE 0x84AC3656 +#define CAMEL_OBJECT_CLASS_FINALIZED_VALUE 0x7621ABCD + +#define DEFAULT_PREALLOCS 8 + +#define BAST_CASTARD 1 /* Define to return NULL when casts fail */ + +#define NULL_PREP_VALUE ((gpointer)make_global_classfuncs) /* See camel_object_class_declare_event */ + +/* ** Quickie type system ************************************************* */ + +typedef struct _CamelTypeInfo +{ + CamelType self; + CamelType parent; + const gchar *name; + + size_t instance_size; + GMemChunk *instance_chunk; + CamelObjectInitFunc instance_init; + CamelObjectFinalizeFunc instance_finalize; + GList *free_instances; + + size_t classfuncs_size; + CamelObjectClassInitFunc class_init; + CamelObjectClassFinalizeFunc class_finalize; + CamelObjectClass *global_classfuncs; +} +CamelTypeInfo; + +typedef struct _CamelHookPair +{ + CamelObjectEventHookFunc func; + gpointer user_data; +} +CamelHookPair; + +/* ************************************************************************ */ + +static void camel_type_lock_up (void); +static void camel_type_lock_down (void); + +static void obj_init (CamelObject * obj); +static void obj_finalize (CamelObject * obj); +static void obj_class_init (CamelObjectClass * class); +static void obj_class_finalize (CamelObjectClass * class); + +static gboolean shared_is_of_type (CamelObjectShared * sh, CamelType ctype, + gboolean is_obj); +static void make_global_classfuncs (CamelTypeInfo * type_info); + +/* ************************************************************************ */ + +G_LOCK_DEFINE_STATIC (type_system); +G_LOCK_DEFINE_STATIC (type_system_level); +static GPrivate *type_system_locklevel = NULL; + +G_LOCK_DEFINE_STATIC (refcount); + +static gboolean type_system_initialized = FALSE; +static GHashTable *ctype_to_typeinfo = NULL; +static const CamelType camel_object_type = 1; +static CamelType cur_max_type = CAMEL_INVALID_TYPE; + +/* ************************************************************************ */ + +#define LOCK_VAL (GPOINTER_TO_INT (g_private_get (type_system_locklevel))) +#define LOCK_SET( val ) g_private_set (type_system_locklevel, GINT_TO_POINTER (val)) + static void -camel_object_init (gpointer object, gpointer klass) +camel_type_lock_up (void) { - GTK_OBJECT_UNSET_FLAGS (object, GTK_FLOATING); + G_LOCK (type_system_level); + + if (type_system_locklevel == NULL) + type_system_locklevel = g_private_new (GINT_TO_POINTER (0)); + + if (LOCK_VAL == 0) { + G_UNLOCK (type_system_level); + G_LOCK (type_system); + G_LOCK (type_system_level); + } + + LOCK_SET (LOCK_VAL + 1); + + G_UNLOCK (type_system_level); } -GtkType -camel_object_get_type (void) +static void +camel_type_lock_down (void) +{ + G_LOCK (type_system_level); + + if (type_system_locklevel == NULL) { + g_warning + ("camel_type_lock_down: lock down before a lock up?"); + type_system_locklevel = g_private_new (GINT_TO_POINTER (0)); + return; + } + + LOCK_SET (LOCK_VAL - 1); + + if (LOCK_VAL == 0) + G_UNLOCK (type_system); + + G_UNLOCK (type_system_level); +} + +void +camel_type_init (void) +{ + CamelTypeInfo *obj_info; + + camel_type_lock_up (); + + if (type_system_initialized) { + g_warning + ("camel_type_init: type system already initialized."); + camel_type_lock_down (); + return; + } + + type_system_initialized = TRUE; + ctype_to_typeinfo = g_hash_table_new (g_direct_hash, g_direct_equal); + + obj_info = g_new (CamelTypeInfo, 1); + obj_info->self = camel_object_type; + obj_info->parent = CAMEL_INVALID_TYPE; + obj_info->name = "CamelObject"; + + obj_info->instance_size = sizeof (CamelObject); + obj_info->instance_chunk = + g_mem_chunk_create (CamelObject, DEFAULT_PREALLOCS, + G_ALLOC_ONLY); + obj_info->instance_init = obj_init; + obj_info->instance_finalize = obj_finalize; + obj_info->free_instances = NULL; + + obj_info->classfuncs_size = sizeof (CamelObjectClass); + obj_info->class_init = obj_class_init; + obj_info->class_finalize = obj_class_finalize; + + g_hash_table_insert (ctype_to_typeinfo, + GINT_TO_POINTER (CAMEL_INVALID_TYPE), NULL); + g_hash_table_insert (ctype_to_typeinfo, + GINT_TO_POINTER (camel_object_type), obj_info); + + /* Sigh. Ugly */ + make_global_classfuncs (obj_info); + + cur_max_type = camel_object_type; + + camel_type_lock_down (); +} + +CamelType +camel_type_register (CamelType parent, const gchar * name, + size_t instance_size, size_t classfuncs_size, + CamelObjectClassInitFunc class_init, + CamelObjectClassFinalizeFunc class_finalize, + CamelObjectInitFunc instance_init, + CamelObjectFinalizeFunc instance_finalize) { - static GtkType camel_object_type = 0; + CamelTypeInfo *parent_info; + CamelTypeInfo *obj_info; + gchar *chunkname; + + g_return_val_if_fail (parent != CAMEL_INVALID_TYPE, + CAMEL_INVALID_TYPE); + g_return_val_if_fail (name, CAMEL_INVALID_TYPE); + g_return_val_if_fail (instance_size, CAMEL_INVALID_TYPE); + g_return_val_if_fail (classfuncs_size, CAMEL_INVALID_TYPE); + + camel_type_lock_up (); - if (!camel_object_type) { - GtkTypeInfo camel_object_info = - { - "CamelObject", - sizeof (CamelObject), - sizeof (CamelObjectClass), - (GtkClassInitFunc) NULL, - (GtkObjectInitFunc) camel_object_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; + if (type_system_initialized == FALSE) { + G_UNLOCK (type_system); + camel_type_init (); + G_LOCK (type_system); + } + + parent_info = + g_hash_table_lookup (ctype_to_typeinfo, + GINT_TO_POINTER (parent)); - camel_object_type = gtk_type_unique (gtk_object_get_type (), &camel_object_info); + if (parent_info == NULL) { + g_warning + ("camel_type_register: no such parent type %d of class `%s'", + parent, name); + camel_type_lock_down (); + return CAMEL_INVALID_TYPE; } + if (parent_info->instance_size > instance_size) { + g_warning + ("camel_type_register: instance of class `%s' would be smaller than parent `%s'", + name, parent_info->name); + camel_type_lock_down (); + return CAMEL_INVALID_TYPE; + } + + if (parent_info->classfuncs_size > classfuncs_size) { + g_warning + ("camel_type_register: classfuncs of class `%s' would be smaller than parent `%s'", + name, parent_info->name); + camel_type_lock_down (); + return CAMEL_INVALID_TYPE; + } + + cur_max_type++; + + obj_info = g_new (CamelTypeInfo, 1); + obj_info->self = cur_max_type; + obj_info->parent = parent; + obj_info->name = name; + + obj_info->instance_size = instance_size; + chunkname = + g_strdup_printf ("chunk for instances of Camel type `%s'", + name); + obj_info->instance_chunk = + g_mem_chunk_new (chunkname, instance_size, + instance_size * DEFAULT_PREALLOCS, + G_ALLOC_ONLY); + g_free (chunkname); + obj_info->instance_init = instance_init; + obj_info->instance_finalize = instance_finalize; + obj_info->free_instances = NULL; + + obj_info->classfuncs_size = classfuncs_size; + obj_info->class_init = class_init; + obj_info->class_finalize = class_finalize; + + g_hash_table_insert (ctype_to_typeinfo, + GINT_TO_POINTER (obj_info->self), obj_info); + + /* Sigh. Ugly. */ + make_global_classfuncs (obj_info); + + camel_type_lock_down (); + return obj_info->self; +} + +CamelObjectClass * +camel_type_get_global_classfuncs (CamelType type) +{ + CamelTypeInfo *type_info; + + g_return_val_if_fail (type != CAMEL_INVALID_TYPE, NULL); + + camel_type_lock_up (); + type_info = + g_hash_table_lookup (ctype_to_typeinfo, + GINT_TO_POINTER (type)); + camel_type_lock_down (); + + g_return_val_if_fail (type_info != NULL, NULL); + + return type_info->global_classfuncs; +} + +const gchar * +camel_type_to_name (CamelType type) +{ + CamelTypeInfo *type_info; + + g_return_val_if_fail (type != CAMEL_INVALID_TYPE, + "(the invalid type)"); + + camel_type_lock_up (); + type_info = + g_hash_table_lookup (ctype_to_typeinfo, + GINT_TO_POINTER (type)); + camel_type_lock_down (); + + g_return_val_if_fail (type_info != NULL, + "(a bad type parameter was specified)"); + + return type_info->name; +} + +/* ** The CamelObject ***************************************************** */ + +static void +obj_init (CamelObject * obj) +{ + obj->s.magic = CAMEL_OBJECT_MAGIC_VALUE; + obj->ref_count = 1; + obj->event_to_hooklist = NULL; + obj->in_event = 0; +} + +static void +obj_finalize (CamelObject * obj) +{ + g_return_if_fail (obj->s.magic == CAMEL_OBJECT_MAGIC_VALUE); + g_return_if_fail (obj->ref_count == 0); + g_return_if_fail (obj->in_event == 0); + + obj->s.magic = CAMEL_OBJECT_FINALIZED_VALUE; + + if (obj->event_to_hooklist) { + g_hash_table_foreach (obj->event_to_hooklist, (GHFunc) g_free, + NULL); + g_hash_table_destroy (obj->event_to_hooklist); + obj->event_to_hooklist = NULL; + } +} + +static void +obj_class_init (CamelObjectClass * class) +{ + class->s.magic = CAMEL_OBJECT_CLASS_MAGIC_VALUE; + + camel_object_class_declare_event (class, "finalize", NULL); +} + +static void +obj_class_finalize (CamelObjectClass * class) +{ + g_return_if_fail (class->s.magic == CAMEL_OBJECT_CLASS_MAGIC_VALUE); + + class->s.magic = CAMEL_OBJECT_CLASS_FINALIZED_VALUE; + + if (class->event_to_preplist) { + g_hash_table_foreach (class->event_to_preplist, + (GHFunc) g_free, NULL); + g_hash_table_destroy (class->event_to_preplist); + class->event_to_preplist = NULL; + } +} + +CamelType +camel_object_get_type (void) +{ + if (type_system_initialized == FALSE) + camel_type_init (); + return camel_object_type; } + +CamelObject * +camel_object_new (CamelType type) +{ + CamelTypeInfo *type_info; + GSList *parents = NULL; + GSList *head = NULL; + CamelObject *instance; + + g_return_val_if_fail (type != CAMEL_INVALID_TYPE, NULL); + + /* Look up the type */ + + camel_type_lock_up (); + + type_info = + g_hash_table_lookup (ctype_to_typeinfo, + GINT_TO_POINTER (type)); + + if (type_info == NULL) { + g_warning + ("camel_object_new: trying to create object of invalid type %d", + type); + camel_type_lock_down (); + return NULL; + } + + /* Grab an instance out of the freed ones if possible, alloc otherwise */ + + if (type_info->free_instances) { + GList *first; + + first = g_list_first (type_info->free_instances); + instance = first->data; + type_info->free_instances = + g_list_remove_link (type_info->free_instances, first); + g_list_free_1 (first); + } else { + instance = g_mem_chunk_alloc0 (type_info->instance_chunk); + } + + /* Init the instance and classfuncs a bit */ + + instance->s.type = type; + instance->classfuncs = type_info->global_classfuncs; + + /* Loop through the parents in simplest -> most complex order, initing the class and instance. + + * When parent = CAMEL_INVALID_TYPE and we're at the end of the line, _lookup returns NULL + * because we inserted it as corresponding to CAMEL_INVALID_TYPE. Clever, eh? + */ + + while (type_info) { + parents = g_slist_prepend (parents, type_info); + type_info = + g_hash_table_lookup (ctype_to_typeinfo, + GINT_TO_POINTER (type_info-> + parent)); + } + + head = parents; + + for (; parents && parents->data; parents = parents->next) { + CamelTypeInfo *thisinfo; + + thisinfo = parents->data; + if (thisinfo->instance_init) + (thisinfo->instance_init) (instance); + } + + g_slist_free (head); + + camel_type_lock_down (); + return instance; +} + +void +camel_object_ref (CamelObject * obj) +{ + g_return_if_fail (CAMEL_IS_OBJECT (obj)); + + G_LOCK (refcount); + obj->ref_count++; + G_UNLOCK (refcount); +} + +void +camel_object_unref (CamelObject * obj) +{ + CamelTypeInfo *type_info; + CamelTypeInfo *iter; + GSList *parents = NULL; + GSList *head = NULL; + + g_return_if_fail (CAMEL_IS_OBJECT (obj)); + + G_LOCK (refcount); + obj->ref_count--; + + if (obj->ref_count > 0) { + G_UNLOCK (refcount); + return; + } + + G_UNLOCK (refcount); + + /* Oh no! We want to emit a "finalized" event, but that function refs the object + * because it's not supposed to get finalized in an event, but it is being finalized + * right now, and AAUGH AAUGH AUGH AUGH! + * + * So we don't call camel_object_trigger_event. We do it ourselves. We even know + * that CamelObject doesn't provide a prep for the finalized event, so we plunge + * right in and call our hooks. + * + * And there was much rejoicing. + */ + +#define hooklist parents /*cough */ + + if (obj->event_to_hooklist) { + CamelHookPair *pair; + + hooklist = + g_hash_table_lookup (obj->event_to_hooklist, + "finalize"); + + while (hooklist && hooklist->data) { + pair = hooklist->data; + (pair->func) (obj, NULL, pair->user_data); + hooklist = hooklist->next; + } + } + + hooklist = NULL; /* Don't mess with this line */ + +#undef hooklist + + /* Destroy it! hahaha! */ + + camel_type_lock_up (); + + type_info = + g_hash_table_lookup (ctype_to_typeinfo, + GINT_TO_POINTER (obj->s.type)); + + if (type_info == NULL) { + g_warning + ("camel_object_unref: seemingly valid object has a bad type %d", + obj->s.type); + camel_type_lock_down (); + return; + } + + /* Loop through the parents in most complex -> simplest order, finalizing the class + * and instance. + * + * When parent = CAMEL_INVALID_TYPE and we're at the end of the line, _lookup returns NULL + * because we inserted it as corresponding to CAMEL_INVALID_TYPE. Clever, eh? + * + * Use iter to preserve type_info for free_{instance,classfunc}s + */ + + iter = type_info; + + while (iter) { + parents = g_slist_prepend (parents, iter); + iter = + g_hash_table_lookup (ctype_to_typeinfo, + GINT_TO_POINTER (iter->parent)); + } + + parents = g_slist_reverse (parents); + head = parents; + + for (; parents && parents->data; parents = parents->next) { + CamelTypeInfo *thisinfo; + + thisinfo = parents->data; + if (thisinfo->instance_finalize) + (thisinfo->instance_finalize) (obj); + } + + g_slist_free (head); + + /* A little bit of cleaning up. + + * Don't erase the type, so we can peek at it if a finalized object + * is check_cast'ed somewhere. + */ + + memset (obj, 0, type_info->instance_size); + obj->s.type = type_info->self; + obj->s.magic = CAMEL_OBJECT_FINALIZED_VALUE; + + /* Tuck away the pointer for use in a new object */ + + type_info->free_instances = + g_list_prepend (type_info->free_instances, obj); + + camel_type_lock_down (); +} + +gboolean +camel_object_is_of_type (CamelObject * obj, CamelType ctype) +{ + return shared_is_of_type ((CamelObjectShared *) obj, ctype, TRUE); +} + +gboolean +camel_object_class_is_of_type (CamelObjectClass * class, CamelType ctype) +{ + return shared_is_of_type ((CamelObjectShared *) class, ctype, FALSE); +} + +#ifdef BAST_CASTARD +#define ERRVAL NULL +#else +#define ERRVAL obj +#endif + +CamelObject * +camel_object_check_cast (CamelObject * obj, CamelType ctype) +{ + if (shared_is_of_type ((CamelObjectShared *) obj, ctype, TRUE)) + return obj; + return ERRVAL; +} + +CamelObjectClass * +camel_object_class_check_cast (CamelObjectClass * class, CamelType ctype) +{ + if (shared_is_of_type ((CamelObjectShared *) class, ctype, FALSE)) + return class; + return ERRVAL; +} + +#undef ERRVAL + +gchar * +camel_object_describe (CamelObject * obj) +{ + if (obj == NULL) + return g_strdup ("a NULL pointer"); + + if (obj->s.magic == CAMEL_OBJECT_MAGIC_VALUE) { + return g_strdup_printf ("an instance of `%s' at %p", + camel_type_to_name (obj->s.type), + obj); + } else if (obj->s.magic == CAMEL_OBJECT_FINALIZED_VALUE) { + return g_strdup_printf ("a finalized instance of `%s' at %p", + camel_type_to_name (obj->s.type), + obj); + } else if (obj->s.magic == CAMEL_OBJECT_CLASS_MAGIC_VALUE) { + return g_strdup_printf ("the classfuncs of `%s' at %p", + camel_type_to_name (obj->s.type), + obj); + } else if (obj->s.magic == CAMEL_OBJECT_CLASS_FINALIZED_VALUE) { + return + g_strdup_printf + ("the finalized classfuncs of `%s' at %p", + camel_type_to_name (obj->s.type), obj); + } + + return g_strdup ("not a CamelObject"); +} + +/* This is likely to be called in the class_init callback, + * and the type will likely be somewhat uninitialized. + * Is this a problem? We'll see.... + */ +void +camel_object_class_declare_event (CamelObjectClass * class, + const gchar * name, + CamelObjectEventPrepFunc prep) +{ + g_return_if_fail (CAMEL_IS_OBJECT_CLASS (class)); + g_return_if_fail (name); + + if (class->event_to_preplist == NULL) + class->event_to_preplist = + g_hash_table_new (g_str_hash, g_str_equal); + else if (g_hash_table_lookup (class->event_to_preplist, name) != NULL) { + g_warning + ("camel_object_class_declare_event: event `%s' already declared for `%s'", + name, camel_type_to_name (class->s.type)); + return; + } + + /* AIEEEEEEEEEEEEEEEEEEEEEE + + * I feel so naughty. Since it's valid to declare an event and not + * provide a hook, it should be valid to insert a NULL value into + * the table. However, then our lookup in trigger_event would be + * ambiguous, not telling us whether the event is undefined or whether + * it merely has no hook. + * + * So we create an 'NULL prep' value that != NULL... specifically, it + * equals the address of one of our static functions , because that + * can't possibly be your hook. + * + * Just don't forget to check for the 'evil value' and it'll work, + * I promise. + */ + + if (prep == NULL) + prep = NULL_PREP_VALUE; + + g_hash_table_insert (class->event_to_preplist, g_strdup (name), prep); +} + +void +camel_object_hook_event (CamelObject * obj, const gchar * name, + CamelObjectEventHookFunc hook, gpointer user_data) +{ + GSList *hooklist; + CamelHookPair *pair; + + g_return_if_fail (CAMEL_IS_OBJECT (obj)); + g_return_if_fail (name); + g_return_if_fail (hook); + + if (obj->event_to_hooklist == NULL) + obj->event_to_hooklist = + g_hash_table_new (g_str_hash, g_str_equal); + + pair = g_new (CamelHookPair, 1); + pair->func = hook; + pair->user_data = user_data; + + hooklist = g_hash_table_lookup (obj->event_to_hooklist, name); + hooklist = g_slist_prepend (hooklist, pair); + g_hash_table_insert (obj->event_to_hooklist, g_strdup (name), + hooklist); +} + +void +camel_object_unhook_event (CamelObject * obj, const gchar * name, + CamelObjectEventHookFunc hook, gpointer user_data) +{ + GSList *hooklist; + GSList *head; + + g_return_if_fail (CAMEL_IS_OBJECT (obj)); + g_return_if_fail (name); + g_return_if_fail (hook); + + if (obj->event_to_hooklist == NULL) { + g_warning + ("camel_object_unhook_event: trying to unhook `%s' from an instance " + "of `%s' with no hooks attached", name, + camel_type_to_name (obj->s.type)); + return; + } + + hooklist = g_hash_table_lookup (obj->event_to_hooklist, name); + + if (hooklist == NULL) { + g_warning + ("camel_object_unhook_event: trying to unhook `%s' from an instance " + "of `%s' with no hooks attached to that event.", + name, camel_type_to_name (obj->s.type)); + return; + } + + head = hooklist; + + while (hooklist) { + CamelHookPair *pair = (CamelHookPair *) hooklist->data; + + if (pair->func == hook && pair->user_data == user_data) { + g_free (hooklist->data); + head = g_slist_remove_link (head, hooklist); + g_slist_free_1 (hooklist); + g_hash_table_insert (obj->event_to_hooklist, name, + head); + return; + } + + hooklist = hooklist->next; + } + + g_warning + ("camel_object_unhook_event: cannot find hook/data pair %p/%p in an " + "instance of `%s' attached to `%s'", hook, user_data, + camel_type_to_name (obj->s.type), name); +} + +void +camel_object_trigger_event (CamelObject * obj, const gchar * name, + gpointer event_data) +{ + GSList *hooklist; + CamelHookPair *pair; + CamelObjectEventPrepFunc prep; + + g_return_if_fail (CAMEL_IS_OBJECT (obj)); + g_return_if_fail (name); + + if (obj->in_event) { + g_warning + ("camel_object_trigger_event: trying to trigger `%s' in class " + "`%s' while already triggering another event", name, + camel_type_to_name (obj->s.type)); + return; + } + + if (obj->classfuncs->event_to_preplist == NULL) { + g_warning + ("camel_object_trigger_event: trying to trigger `%s' in class " + "`%s' with no defined events.", name, + camel_type_to_name (obj->s.type)); + return; + } + + prep = g_hash_table_lookup (obj->classfuncs->event_to_preplist, name); + + if (prep == NULL) { + g_warning + ("camel_object_trigger_event: trying to trigger undefined " + "event `%s' in class `%s'.", name, + camel_type_to_name (obj->s.type)); + return; + } + + /* Ref so that it can't get destroyed in the event, which would + * be Bad. And it's a valid ref anyway... + */ + + camel_object_ref (obj); + obj->in_event = 1; + + if ((prep != NULL_PREP_VALUE && !prep (obj, event_data)) + || obj->event_to_hooklist == NULL) { + obj->in_event = 0; + camel_object_unref (obj); + return; + } + + hooklist = g_hash_table_lookup (obj->event_to_hooklist, name); + + while (hooklist && hooklist->data) { + pair = hooklist->data; + (pair->func) (obj, event_data, pair->user_data); + hooklist = hooklist->next; + } + + obj->in_event = 0; + camel_object_unref (obj); +} + +/* ** Static helpers ****************************************************** */ + +static gboolean +shared_is_of_type (CamelObjectShared * sh, CamelType ctype, gboolean is_obj) +{ + CamelTypeInfo *type_info; + gchar *targtype; + + if (is_obj) + targtype = "instance"; + else + targtype = "classdata"; + + if (ctype == CAMEL_INVALID_TYPE) { + g_warning + ("shared_is_of_type: trying to cast to CAMEL_INVALID_TYPE"); + return FALSE; + } + + if (sh == NULL) { + g_warning + ("shared_is_of_type: trying to cast NULL to %s of `%s'", + targtype, camel_type_to_name (ctype)); + return FALSE; + } + + if (sh->magic == CAMEL_OBJECT_FINALIZED_VALUE) { + g_warning + ("shared_is_of_type: trying to cast finalized instance " + "of `%s' into %s of `%s'", + camel_type_to_name (sh->type), targtype, + camel_type_to_name (ctype)); + return FALSE; + } + + if (sh->magic == CAMEL_OBJECT_CLASS_FINALIZED_VALUE) { + g_warning + ("shared_is_of_type: trying to cast finalized classdata " + "of `%s' into %s of `%s'", + camel_type_to_name (sh->type), targtype, + camel_type_to_name (ctype)); + return FALSE; + } + + if (is_obj) { + if (sh->magic == CAMEL_OBJECT_CLASS_MAGIC_VALUE) { + g_warning + ("shared_is_of_type: trying to cast classdata " + "of `%s' into instance of `%s'", + camel_type_to_name (sh->type), + camel_type_to_name (ctype)); + return FALSE; + } + + if (sh->magic != CAMEL_OBJECT_MAGIC_VALUE) { + g_warning + ("shared_is_of_type: trying to cast junk data " + "into instance of `%s'", + camel_type_to_name (ctype)); + return FALSE; + } + } else { + if (sh->magic == CAMEL_OBJECT_MAGIC_VALUE) { + g_warning + ("shared_is_of_type: trying to cast instance " + "of `%s' into classdata of `%s'", + camel_type_to_name (sh->type), + camel_type_to_name (ctype)); + return FALSE; + } + + if (sh->magic != CAMEL_OBJECT_CLASS_MAGIC_VALUE) { + g_warning + ("shared_is_of_type: trying to cast junk data " + "into classdata of `%s'", + camel_type_to_name (ctype)); + return FALSE; + } + } + + camel_type_lock_up (); + + type_info = + g_hash_table_lookup (ctype_to_typeinfo, + GINT_TO_POINTER (sh->type)); + + if (type_info == NULL) { + g_warning ("shared_is_of_type: seemingly valid %s has " + "bad type %d.", targtype, sh->type); + camel_type_lock_down (); + return FALSE; + } + + while (type_info) { + if (type_info->self == ctype) { + camel_type_lock_down (); + return TRUE; + } + + type_info = + g_hash_table_lookup (ctype_to_typeinfo, + GINT_TO_POINTER (type_info-> + parent)); + } + + g_warning + ("shared_is_of_type: %s of `%s' (@%p) is not also %s of `%s'", + targtype, camel_type_to_name (sh->type), sh, targtype, + camel_type_to_name (ctype)); + + camel_type_lock_down (); + return FALSE; +} + +static void +make_global_classfuncs (CamelTypeInfo * type_info) +{ + CamelObjectClass *funcs; + GSList *parents; + GSList *head; + + g_assert (type_info); + + funcs = g_malloc0 (type_info->classfuncs_size); + funcs->s.type = type_info->self; + + type_info->global_classfuncs = funcs; + + parents = NULL; + while (type_info) { + parents = g_slist_prepend (parents, type_info); + type_info = + g_hash_table_lookup (ctype_to_typeinfo, + GINT_TO_POINTER (type_info-> + parent)); + } + + head = parents; + + for (; parents && parents->data; parents = parents->next) { + CamelTypeInfo *thisinfo; + + thisinfo = parents->data; + if (thisinfo->class_init) + (thisinfo->class_init) (funcs); + } + + g_slist_free (head); +} diff --git a/camel/camel-object.h b/camel/camel-object.h index 2c6b4d0d5c..fdcf7b4a15 100644 --- a/camel/camel-object.h +++ b/camel/camel-object.h @@ -26,40 +26,120 @@ #ifndef CAMEL_OBJECT_H #define CAMEL_OBJECT_H 1 - #ifdef __cplusplus -extern "C" { +extern "C" +{ #pragma } -#endif /* __cplusplus }*/ +#endif /* __cplusplus } */ -#include +#include /* size_t */ #include - -#define CAMEL_OBJECT_TYPE (camel_object_get_type ()) -#define CAMEL_OBJECT(obj) (GTK_CHECK_CAST((obj), CAMEL_OBJECT_TYPE, CamelObject)) -#define CAMEL_OBJECT_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_OBJECT_TYPE, CamelObjectClass)) -#define CAMEL_IS_OBJECT(o) (GTK_CHECK_TYPE((o), CAMEL_OBJECT_TYPE)) - - -struct _CamelObject -{ - GtkObject parent_object; - -}; - - -typedef struct { - GtkObjectClass parent_class; - -} CamelObjectClass; - - -/* Standard Gtk function */ -GtkType camel_object_get_type (void); - +#include + +#ifdef G_DISABLE_CHECKS +#define CAMEL_CHECK_CAST( obj, ctype, ptype ) ((ptype *) obj) +#define CAMEL_CHECK_CLASS_CAST( class, ctype, ptype ) ((ptype *) class) +#define CAMEL_CHECK_TYPE( obj, ctype ) (TRUE) +#define CAMEL_CHECK_CLASS_TYPE( class, ctype ) (TRUE) +#else +#define CAMEL_CHECK_CAST( obj, ctype, ptype ) ((ptype *) camel_object_check_cast( (CamelObject *)(obj), (CamelType)(ctype) )) +#define CAMEL_CHECK_CLASS_CAST( class, ctype, ptype ) ((ptype *) camel_object_class_check_cast( (CamelObjectClass *)(class), (CamelType)(ctype) )) +#define CAMEL_CHECK_TYPE( obj, ctype ) (camel_object_is_of_type( (CamelObject *)(obj), (CamelType)(ctype) )) +#define CAMEL_CHECK_CLASS_TYPE( class, ctype ) (camel_object_class_is_of_type( (CamelObjectClass *)(class), (CamelType)(ctype) )) +#endif + +#define CAMEL_INVALID_TYPE ((CamelType)0) + +#define CAMEL_OBJECT_TYPE (camel_object_get_type ()) + +#define CAMEL_OBJECT(obj) (CAMEL_CHECK_CAST((obj), CAMEL_OBJECT_TYPE, CamelObject)) +#define CAMEL_OBJECT_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_OBJECT_TYPE, CamelObjectClass)) +#define CAMEL_IS_OBJECT(o) (CAMEL_CHECK_TYPE((o), CAMEL_OBJECT_TYPE)) +#define CAMEL_IS_OBJECT_CLASS(k) (CAMEL_CHECK_CLASS_TYPE((k), CAMEL_OBJECT_TYPE)) + +#define CAMEL_OBJECT_GET_CLASS(o) ((CamelObjectClass *)(CAMEL_OBJECT(o))->classfuncs) +#define CAMEL_OBJECT_GET_TYPE(o) ((CamelType)(CAMEL_OBJECT(o))->s.type) + + typedef guint32 CamelType; + + typedef struct _CamelObjectShared + { + guint32 magic; + CamelType type; + } + CamelObjectShared; + + typedef struct _CamelObjectClass + { + CamelObjectShared s; + + GHashTable *event_to_preplist; + } + CamelObjectClass; + + typedef struct _CamelObject + { + CamelObjectShared s; + guint32 ref_count:31; + guint32 in_event:1; + CamelObjectClass *classfuncs; + GHashTable *event_to_hooklist; + } + CamelObject; + + typedef void (*CamelObjectClassInitFunc) (CamelObjectClass *); + typedef void (*CamelObjectClassFinalizeFunc) (CamelObjectClass *); + typedef void (*CamelObjectInitFunc) (CamelObject *); + typedef void (*CamelObjectFinalizeFunc) (CamelObject *); + + typedef gboolean (*CamelObjectEventPrepFunc) (CamelObject *, + gpointer); + typedef void (*CamelObjectEventHookFunc) (CamelObject *, gpointer, + gpointer); + +/* The type system .... it's pretty simple..... */ + + void camel_type_init (void); + CamelType camel_type_register (CamelType parent, const gchar * name, + size_t instance_size, + size_t classfuncs_size, + CamelObjectClassInitFunc class_init, + CamelObjectClassFinalizeFunc + class_finalize, + CamelObjectInitFunc instance_init, + CamelObjectFinalizeFunc + instance_finalize); + CamelObjectClass *camel_type_get_global_classfuncs (CamelType type); + const gchar *camel_type_to_name (CamelType type); + + CamelType camel_object_get_type (void); + CamelObject *camel_object_new (CamelType type); + void camel_object_ref (CamelObject * obj); + void camel_object_unref (CamelObject * obj); + CamelObject *camel_object_check_cast (CamelObject * obj, + CamelType ctype); + CamelObjectClass *camel_object_class_check_cast (CamelObjectClass * + class, + CamelType ctype); + gboolean camel_object_is_of_type (CamelObject * obj, CamelType ctype); + gboolean camel_object_class_is_of_type (CamelObjectClass * class, + CamelType ctype); + gchar *camel_object_describe (CamelObject * obj); + void camel_object_class_declare_event (CamelObjectClass * class, + const gchar * name, + CamelObjectEventPrepFunc prep); + void camel_object_hook_event (CamelObject * obj, const gchar * name, + CamelObjectEventHookFunc hook, + gpointer user_data); + void camel_object_unhook_event (CamelObject * obj, const gchar * name, + CamelObjectEventHookFunc hook, + gpointer user_data); + void camel_object_trigger_event (CamelObject * obj, + const gchar * name, + gpointer event_data); #ifdef __cplusplus } -#endif /* __cplusplus */ +#endif /* __cplusplus */ -#endif /* CAMEL_OBJECT_H */ +#endif /* CAMEL_OBJECT_H */ diff --git a/camel/camel-provider.h b/camel/camel-provider.h index 4f2a67839f..00375029db 100644 --- a/camel/camel-provider.h +++ b/camel/camel-provider.h @@ -35,8 +35,8 @@ extern "C" { #pragma } #endif /* __cplusplus }*/ -#include #include +#include #define CAMEL_PROVIDER(obj) ((CamelProvider *)(obj)) @@ -78,7 +78,7 @@ typedef struct { int flags; - GtkType object_types [CAMEL_NUM_PROVIDER_TYPES]; + CamelType object_types [CAMEL_NUM_PROVIDER_TYPES]; GHashTable *service_cache; diff --git a/camel/camel-seekable-stream.c b/camel/camel-seekable-stream.c index 507c69dd48..c4ca950baa 100644 --- a/camel/camel-seekable-stream.c +++ b/camel/camel-seekable-stream.c @@ -29,7 +29,7 @@ static CamelStreamClass *parent_class = NULL; /* Returns the class for a CamelSeekableStream */ -#define CSS_CLASS(so) CAMEL_SEEKABLE_STREAM_CLASS (GTK_OBJECT(so)->klass) +#define CSS_CLASS(so) CAMEL_SEEKABLE_STREAM_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static off_t seek (CamelSeekableStream *stream, off_t offset, CamelStreamSeekPolicy policy); @@ -43,7 +43,7 @@ camel_seekable_stream_class_init (CamelSeekableStreamClass *camel_seekable_strea CamelStreamClass *camel_stream_class = CAMEL_STREAM_CLASS (camel_seekable_stream_class); - parent_class = gtk_type_class (camel_stream_get_type ()); + parent_class = CAMEL_STREAM_CLASS( camel_type_get_global_classfuncs( CAMEL_STREAM_TYPE ) ); /* seekable stream methods */ camel_seekable_stream_class->seek = seek; @@ -63,25 +63,20 @@ camel_seekable_stream_init (void *o) stream->bound_end = CAMEL_STREAM_UNBOUND; } -GtkType +CamelType camel_seekable_stream_get_type (void) { - static GtkType camel_seekable_stream_type = 0; - - if (!camel_seekable_stream_type) { - GtkTypeInfo camel_seekable_stream_info = - { - "CamelSeekableStream", - sizeof (CamelSeekableStream), - sizeof (CamelSeekableStreamClass), - (GtkClassInitFunc) camel_seekable_stream_class_init, - (GtkObjectInitFunc) camel_seekable_stream_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_seekable_stream_type = gtk_type_unique (camel_stream_get_type (), &camel_seekable_stream_info); + static CamelType camel_seekable_stream_type = CAMEL_INVALID_TYPE; + + if (camel_seekable_stream_type == CAMEL_INVALID_TYPE) { + camel_seekable_stream_type = camel_type_register( CAMEL_STREAM_TYPE, + "CamelSeekableStream", + sizeof( CamelSeekableStream ), + sizeof( CamelSeekableStreamClass ), + (CamelObjectClassInitFunc) camel_seekable_stream_class_init, + NULL, + (CamelObjectInitFunc) camel_seekable_stream_init, + NULL ); } return camel_seekable_stream_type; diff --git a/camel/camel-seekable-stream.h b/camel/camel-seekable-stream.h index f1cd5cdbca..0fc67d59f8 100644 --- a/camel/camel-seekable-stream.h +++ b/camel/camel-seekable-stream.h @@ -38,9 +38,9 @@ extern "C" { #include #define CAMEL_SEEKABLE_STREAM_TYPE (camel_seekable_stream_get_type ()) -#define CAMEL_SEEKABLE_STREAM(obj) (GTK_CHECK_CAST((obj), CAMEL_SEEKABLE_STREAM_TYPE, CamelSeekableStream)) -#define CAMEL_SEEKABLE_STREAM_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_SEEKABLE_STREAM_TYPE, CamelSeekableStreamClass)) -#define CAMEL_IS_SEEKABLE_STREAM(o) (GTK_CHECK_TYPE((o), CAMEL_SEEKABLE_STREAM_TYPE)) +#define CAMEL_SEEKABLE_STREAM(obj) (CAMEL_CHECK_CAST((obj), CAMEL_SEEKABLE_STREAM_TYPE, CamelSeekableStream)) +#define CAMEL_SEEKABLE_STREAM_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_SEEKABLE_STREAM_TYPE, CamelSeekableStreamClass)) +#define CAMEL_IS_SEEKABLE_STREAM(o) (CAMEL_CHECK_TYPE((o), CAMEL_SEEKABLE_STREAM_TYPE)) typedef enum @@ -72,8 +72,8 @@ typedef struct { off_t start, off_t end); } CamelSeekableStreamClass; -/* Standard Gtk function */ -GtkType camel_seekable_stream_get_type (void); +/* Standard Camel function */ +CamelType camel_seekable_stream_get_type (void); /* public methods */ off_t camel_seekable_stream_seek (CamelSeekableStream *stream, off_t offset, diff --git a/camel/camel-seekable-substream.c b/camel/camel-seekable-substream.c index 4fc5b5d853..d62fc3bba4 100644 --- a/camel/camel-seekable-substream.c +++ b/camel/camel-seekable-substream.c @@ -27,7 +27,7 @@ static CamelSeekableStreamClass *parent_class = NULL; /* Returns the class for a CamelSeekableSubStream */ -#define CSS_CLASS(so) CAMEL_SEEKABLE_SUBSTREAM_CLASS (GTK_OBJECT(so)->klass) +#define CSS_CLASS(so) CAMEL_SEEKABLE_SUBSTREAM_CLASS (CAMEL_OBJECT(so)->klass) static int stream_read (CamelStream *stream, char *buffer, unsigned int n); static int stream_write (CamelStream *stream, const char *buffer, unsigned int n); @@ -36,8 +36,6 @@ static int stream_close (CamelStream *stream); static gboolean eos (CamelStream *stream); static off_t stream_seek (CamelSeekableStream *stream, off_t offset, CamelStreamSeekPolicy policy); -static void finalize (GtkObject *object); - static void camel_seekable_substream_class_init (CamelSeekableSubstreamClass *camel_seekable_substream_class) @@ -46,10 +44,8 @@ camel_seekable_substream_class_init (CamelSeekableSubstreamClass *camel_seekable CAMEL_SEEKABLE_STREAM_CLASS (camel_seekable_substream_class); CamelStreamClass *camel_stream_class = CAMEL_STREAM_CLASS (camel_seekable_substream_class); - GtkObjectClass *gtk_object_class = - GTK_OBJECT_CLASS (camel_seekable_substream_class); - parent_class = gtk_type_class (camel_seekable_stream_get_type ()); + parent_class = CAMEL_SEEKABLE_STREAM_CLASS (camel_type_get_global_classfuncs (camel_seekable_stream_get_type ())); /* virtual method definition */ @@ -62,44 +58,35 @@ camel_seekable_substream_class_init (CamelSeekableSubstreamClass *camel_seekable camel_seekable_stream_class->seek = stream_seek; - gtk_object_class->finalize = finalize; -} - - -GtkType -camel_seekable_substream_get_type (void) -{ - static GtkType camel_seekable_substream_type = 0; - - if (!camel_seekable_substream_type) { - GtkTypeInfo camel_seekable_substream_info = - { - "CamelSeekableSubstream", - sizeof (CamelSeekableSubstream), - sizeof (CamelSeekableSubstreamClass), - (GtkClassInitFunc) camel_seekable_substream_class_init, - (GtkObjectInitFunc) NULL, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_seekable_substream_type = gtk_type_unique (camel_seekable_stream_get_type (), &camel_seekable_substream_info); - } - - return camel_seekable_substream_type; } static void -finalize (GtkObject *object) +camel_seekable_substream_finalize (CamelObject *object) { CamelSeekableSubstream *seekable_substream = CAMEL_SEEKABLE_SUBSTREAM (object); if (seekable_substream->parent_stream) - gtk_object_unref (GTK_OBJECT (seekable_substream->parent_stream)); + camel_object_unref (CAMEL_OBJECT (seekable_substream->parent_stream)); +} + + +CamelType +camel_seekable_substream_get_type (void) +{ + static CamelType camel_seekable_substream_type = CAMEL_INVALID_TYPE; + + if (camel_seekable_substream_type == CAMEL_INVALID_TYPE) { + camel_seekable_substream_type = camel_type_register (camel_seekable_stream_get_type (), "CamelSeekableSubstream", + sizeof (CamelSeekableSubstream), + sizeof (CamelSeekableSubstreamClass), + (CamelObjectClassInitFunc) camel_seekable_substream_class_init, + NULL, + NULL, + (CamelObjectFinalizeFunc) camel_seekable_substream_finalize); + } - GTK_OBJECT_CLASS (parent_class)->finalize (object); + return camel_seekable_substream_type; } /** @@ -128,11 +115,11 @@ camel_seekable_substream_new_with_seekable_stream_and_bounds (CamelSeekableStrea g_return_val_if_fail (CAMEL_IS_SEEKABLE_STREAM (parent_stream), NULL); /* Create the seekable substream. */ - seekable_substream = gtk_type_new (camel_seekable_substream_get_type ()); + seekable_substream = CAMEL_SEEKABLE_SUBSTREAM (camel_object_new (camel_seekable_substream_get_type ())); /* Initialize it. */ seekable_substream->parent_stream = parent_stream; - gtk_object_ref (GTK_OBJECT (parent_stream)); + camel_object_ref (CAMEL_OBJECT (parent_stream)); /* Set the bound of the substream. We can ignore any possible error * here, because if we fail to seek now, it will try again later. diff --git a/camel/camel-seekable-substream.h b/camel/camel-seekable-substream.h index 721d33380a..6ac5588a42 100644 --- a/camel/camel-seekable-substream.h +++ b/camel/camel-seekable-substream.h @@ -36,9 +36,9 @@ extern "C" { #include #define CAMEL_SEEKABLE_SUBSTREAM_TYPE (camel_seekable_substream_get_type ()) -#define CAMEL_SEEKABLE_SUBSTREAM(obj) (GTK_CHECK_CAST((obj), CAMEL_SEEKABLE_SUBSTREAM_TYPE, CamelSeekableSubstream)) -#define CAMEL_SEEKABLE_SUBSTREAM_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_SEEKABLE_SUBSTREAM_TYPE, CamelSeekableSubstreamClass)) -#define CAMEL_IS_SEEKABLE_SUBSTREAM(o) (GTK_CHECK_TYPE((o), CAMEL_SEEKABLE_SUBSTREAM_TYPE)) +#define CAMEL_SEEKABLE_SUBSTREAM(obj) (CAMEL_CHECK_CAST((obj), CAMEL_SEEKABLE_SUBSTREAM_TYPE, CamelSeekableSubstream)) +#define CAMEL_SEEKABLE_SUBSTREAM_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_SEEKABLE_SUBSTREAM_TYPE, CamelSeekableSubstreamClass)) +#define CAMEL_IS_SEEKABLE_SUBSTREAM(o) (CAMEL_CHECK_TYPE((o), CAMEL_SEEKABLE_SUBSTREAM_TYPE)) struct _CamelSeekableSubstream { @@ -53,8 +53,8 @@ typedef struct { } CamelSeekableSubstreamClass; -/* Standard Gtk function */ -GtkType camel_seekable_substream_get_type (void); +/* Standard Camel function */ +CamelType camel_seekable_substream_get_type (void); /* public methods */ diff --git a/camel/camel-service.c b/camel/camel-service.c index ec2e4d3712..5631b6caf5 100644 --- a/camel/camel-service.c +++ b/camel/camel-service.c @@ -34,7 +34,7 @@ static CamelObjectClass *parent_class = NULL; /* Returns the class for a CamelService */ -#define CSERV_CLASS(so) CAMEL_SERVICE_CLASS (GTK_OBJECT(so)->klass) +#define CSERV_CLASS(so) CAMEL_SERVICE_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static gboolean service_connect(CamelService *service, CamelException *ex); static gboolean service_disconnect(CamelService *service, CamelException *ex); @@ -42,18 +42,13 @@ static gboolean is_connected (CamelService *service); static GList * query_auth_types (CamelService *service, CamelException *ex); static void free_auth_types (CamelService *service, GList *authtypes); static char * get_name (CamelService *service, gboolean brief); -static void finalize (GtkObject *object); - static gboolean check_url (CamelService *service, CamelException *ex); static void camel_service_class_init (CamelServiceClass *camel_service_class) { - GtkObjectClass *gtk_object_class = - GTK_OBJECT_CLASS (camel_service_class); - - parent_class = gtk_type_class (camel_object_get_type ()); + parent_class = camel_type_get_global_classfuncs (CAMEL_OBJECT_TYPE); /* virtual method definition */ camel_service_class->connect = service_connect; @@ -62,50 +57,39 @@ camel_service_class_init (CamelServiceClass *camel_service_class) camel_service_class->query_auth_types = query_auth_types; camel_service_class->free_auth_types = free_auth_types; camel_service_class->get_name = get_name; - - /* virtual method overload */ - gtk_object_class->finalize = finalize; -} - -GtkType -camel_service_get_type (void) -{ - static GtkType camel_service_type = 0; - - if (!camel_service_type) { - GtkTypeInfo camel_service_info = - { - "CamelService", - sizeof (CamelService), - sizeof (CamelServiceClass), - (GtkClassInitFunc) camel_service_class_init, - (GtkObjectInitFunc) NULL, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_service_type = gtk_type_unique (camel_object_get_type (), - &camel_service_info); - } - - return camel_service_type; } static void -finalize (GtkObject *object) +camel_service_finalize (CamelObject *object) { CamelService *camel_service = CAMEL_SERVICE (object); if (camel_service->url) camel_url_free (camel_service->url); if (camel_service->session) - gtk_object_unref (GTK_OBJECT (camel_service->session)); - - GTK_OBJECT_CLASS (parent_class)->finalize (object); + camel_object_unref (CAMEL_OBJECT (camel_service->session)); } + +CamelType +camel_service_get_type (void) +{ + static CamelType camel_service_type = CAMEL_INVALID_TYPE; + + if (camel_service_type == CAMEL_INVALID_TYPE) { + camel_service_type = camel_type_register( CAMEL_OBJECT_TYPE, "CamelService", + sizeof (CamelService), + sizeof (CamelServiceClass), + (CamelObjectClassInitFunc) camel_service_class_init, + NULL, + NULL, + camel_service_finalize ); + } + + return camel_service_type; +} + static gboolean check_url (CamelService *service, CamelException *ex) { @@ -142,7 +126,7 @@ check_url (CamelService *service, CamelException *ex) /** * camel_service_new: create a new CamelService or subtype - * @type: the GtkType of the class to create + * @type: the CamelType of the class to create * @session: the session for the service * @url: the default URL for the service (may be NULL) * @ex: a CamelException @@ -153,22 +137,22 @@ check_url (CamelService *service, CamelException *ex) * Return value: the CamelService, or NULL. **/ CamelService * -camel_service_new (GtkType type, CamelSession *session, CamelURL *url, +camel_service_new (CamelType type, CamelSession *session, CamelURL *url, CamelException *ex) { CamelService *service; g_return_val_if_fail (CAMEL_IS_SESSION (session), NULL); - service = CAMEL_SERVICE (gtk_object_new (type, NULL)); + service = CAMEL_SERVICE (camel_object_new (type)); service->url = url; if (!url->empty && !check_url (service, ex)) { - gtk_object_unref (GTK_OBJECT (service)); + camel_object_unref (CAMEL_OBJECT (service)); return NULL; } service->session = session; - gtk_object_ref (GTK_OBJECT (session)); + camel_object_ref (CAMEL_OBJECT (session)); return service; } @@ -268,7 +252,7 @@ static char * get_name (CamelService *service, gboolean brief) { g_warning ("CamelService::get_name not implemented for `%s'", - gtk_type_name (GTK_OBJECT_TYPE (service))); + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (service))); return "???"; } diff --git a/camel/camel-service.h b/camel/camel-service.h index 1541e32e4a..50f0c2d4b4 100644 --- a/camel/camel-service.h +++ b/camel/camel-service.h @@ -39,9 +39,9 @@ extern "C" { #include #define CAMEL_SERVICE_TYPE (camel_service_get_type ()) -#define CAMEL_SERVICE(obj) (GTK_CHECK_CAST((obj), CAMEL_SERVICE_TYPE, CamelService)) -#define CAMEL_SERVICE_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_SERVICE_TYPE, CamelServiceClass)) -#define CAMEL_IS_SERVICE(o) (GTK_CHECK_TYPE((o), CAMEL_SERVICE_TYPE)) +#define CAMEL_SERVICE(obj) (CAMEL_CHECK_CAST((obj), CAMEL_SERVICE_TYPE, CamelService)) +#define CAMEL_SERVICE_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_SERVICE_TYPE, CamelServiceClass)) +#define CAMEL_IS_SERVICE(o) (CAMEL_CHECK_TYPE((o), CAMEL_SERVICE_TYPE)) struct _CamelService { @@ -105,7 +105,7 @@ typedef struct { /* public methods */ -CamelService * camel_service_new (GtkType type, +CamelService * camel_service_new (CamelType type, CamelSession *session, CamelURL *url, CamelException *ex); @@ -131,8 +131,8 @@ struct hostent * camel_service_gethost (CamelService *service, CamelException *ex); -/* Standard Gtk function */ -GtkType camel_service_get_type (void); +/* Standard Camel function */ +CamelType camel_service_get_type (void); #ifdef __cplusplus } diff --git a/camel/camel-session.c b/camel/camel-session.c index ec99e17964..f9f0584294 100644 --- a/camel/camel-session.c +++ b/camel/camel-session.c @@ -56,46 +56,34 @@ camel_session_destroy_provider (gpointer key, gpointer value, gpointer user_data } static void -camel_session_finalise (GtkObject *o) +camel_session_finalise (CamelObject *o) { CamelSession *session = (CamelSession *)o; g_hash_table_foreach_remove (session->providers, camel_session_destroy_provider, NULL); g_hash_table_destroy (session->providers); - - GTK_OBJECT_CLASS (parent_class)->finalize (o); } static void -camel_session_class_init (CamelServiceClass *camel_service_class) +camel_session_class_init (CamelSessionClass *camel_session_class) { - GtkObjectClass *object_class = (GtkObjectClass *)camel_service_class; - - parent_class = gtk_type_class (camel_object_get_type ()); - object_class->finalize = camel_session_finalise; + parent_class = camel_type_get_global_classfuncs (camel_object_get_type ()); } -GtkType +CamelType camel_session_get_type (void) { - static GtkType camel_session_type = 0; - - if (!camel_session_type) { - GtkTypeInfo camel_session_info = - { - "CamelSession", - sizeof (CamelSession), - sizeof (CamelSessionClass), - (GtkClassInitFunc) camel_session_class_init, - (GtkObjectInitFunc) camel_session_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_session_type = gtk_type_unique (camel_object_get_type (), - &camel_session_info); + static CamelType camel_session_type = CAMEL_INVALID_TYPE; + + if (camel_session_type == CAMEL_INVALID_TYPE) { + camel_session_type = camel_type_register (camel_object_get_type (), "CamelSession", + sizeof (CamelSession), + sizeof (CamelSessionClass), + (CamelObjectClassInitFunc) camel_session_class_init, + NULL, + (CamelObjectInitFunc) camel_session_init, + (CamelObjectFinalizeFunc) camel_session_finalise); } return camel_session_type; @@ -103,11 +91,15 @@ camel_session_get_type (void) CamelSession * -camel_session_new (CamelAuthCallback authenticator) +camel_session_new (CamelAuthCallback authenticator, + CamelTimeoutRegisterCallback registrar, + CamelTimeoutRemoveCallback remover) { - CamelSession *session = gtk_type_new (CAMEL_SESSION_TYPE); + CamelSession *session = CAMEL_SESSION (camel_object_new (CAMEL_SESSION_TYPE)); session->authenticator = authenticator; + session->registrar = registrar; + session->remover = remover; return session; } @@ -191,9 +183,10 @@ camel_session_list_providers (CamelSession *session, gboolean load) } static void -service_cache_remove (CamelService *service, CamelSession *session) +service_cache_remove (CamelService *service, gpointer event_data, gpointer user_data) { CamelProvider *provider; + CamelSession *session = CAMEL_SESSION (user_data); g_return_if_fail (CAMEL_IS_SESSION (session)); g_return_if_fail (service != NULL); @@ -247,14 +240,14 @@ camel_session_get_service (CamelSession *session, const char *url_string, service = g_hash_table_lookup (provider->service_cache, url); if (service != NULL) { camel_url_free (url); - gtk_object_ref (GTK_OBJECT (service)); + camel_object_ref (CAMEL_OBJECT (service)); return service; } service = camel_service_new (provider->object_types[type], session, url, ex); if (service) { g_hash_table_insert (provider->service_cache, url, service); - gtk_signal_connect (GTK_OBJECT (service), "destroy", service_cache_remove, session); + camel_object_hook_event (CAMEL_OBJECT (service), "finalize", (CamelObjectEventHookFunc) service_cache_remove, session); } return service; @@ -302,3 +295,52 @@ camel_session_query_authenticator (CamelSession *session, return session->authenticator (mode, prompt, secret, service, item, ex); } + +/** + * camel_session_register_timeout: Register a timeout to be called + * periodically. + * + * @session: the CamelSession + * @interval: the number of milliseconds interval between calls + * @callback: the function to call + * @user_data: extra data to be passed to the callback + * + * This function will use the registrar callback provided upon + * camel_session_new to register the timeout. The callback will + * be called every @interval milliseconds until it returns @FALSE. + * It will be passed one argument, @user_data. + * + * Returns a nonzero handle that can be used with + * camel_session_remove_timeout on success, and 0 on failure to + * register the timeout. + **/ + +guint +camel_session_register_timeout (CamelSession *session, + guint32 interval, + CamelTimeoutCallback callback, + gpointer user_data) +{ + g_return_val_if_fail (CAMEL_IS_SESSION (session), FALSE); + + return session->registrar (interval, callback, user_data); +} + +/** + * camel_session_remove_timeout: Remove a previously registered + * timeout. + * + * @session: the CamelSession + * @handle: a value returned from camel_session_register_timeout + * + * This function will use the remover callback provided upon + * camel_session_new to remove the timeout. + * + * Returns TRUE on success and FALSE on failure. + **/ + +gboolean camel_session_remove_timeout (CamelSession *session, + guint handle) +{ + return session->remover (handle); +} diff --git a/camel/camel-session.h b/camel/camel-session.h index 67dfe729fc..704ae6a613 100644 --- a/camel/camel-session.h +++ b/camel/camel-session.h @@ -38,9 +38,9 @@ extern "C" { #include #define CAMEL_SESSION_TYPE (camel_session_get_type ()) -#define CAMEL_SESSION(obj) (GTK_CHECK_CAST((obj), CAMEL_SESSION_TYPE, CamelSession)) -#define CAMEL_SESSION_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_SESSION_TYPE, CamelSessionClass)) -#define CAMEL_IS_SESSION(o) (GTK_CHECK_TYPE((o), CAMEL_SESSION_TYPE)) +#define CAMEL_SESSION(obj) (CAMEL_CHECK_CAST((obj), CAMEL_SESSION_TYPE, CamelSession)) +#define CAMEL_SESSION_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_SESSION_TYPE, CamelSessionClass)) +#define CAMEL_IS_SESSION(o) (CAMEL_CHECK_TYPE((o), CAMEL_SESSION_TYPE)) typedef enum { @@ -51,12 +51,19 @@ typedef char *(*CamelAuthCallback) (CamelAuthCallbackMode mode, char *data, gboolean secret, CamelService *service, char *item, CamelException *ex); +typedef gboolean (*CamelTimeoutCallback) (gpointer data); +typedef guint (*CamelTimeoutRegisterCallback) (guint32 interval, + CamelTimeoutCallback cb, + gpointer camel_data); +typedef gboolean (*CamelTimeoutRemoveCallback) (guint id); struct _CamelSession { CamelObject parent_object; CamelAuthCallback authenticator; + CamelTimeoutRegisterCallback registrar; + CamelTimeoutRemoveCallback remover; GHashTable *providers, *modules; }; @@ -69,13 +76,16 @@ typedef struct { /* public methods */ -/* Standard Gtk function */ -GtkType camel_session_get_type (void); +/* Standard Camel function */ +CamelType camel_session_get_type (void); CamelSession * camel_session_new (CamelAuthCallback - authenticator); - + authenticator, + CamelTimeoutRegisterCallback + registrar, + CamelTimeoutRemoveCallback + remover); void camel_session_register_provider (CamelSession *session, CamelProvider *provider); GList * camel_session_list_providers (CamelSession *session, @@ -99,6 +109,14 @@ char * camel_session_query_authenticator (CamelSession *session, char *item, CamelException *ex); +guint camel_session_register_timeout (CamelSession *session, + guint32 interval, + CamelTimeoutCallback callback, + gpointer user_data); + +gboolean camel_session_remove_timeout (CamelSession *session, + guint handle); + #ifdef __cplusplus } #endif /* __cplusplus */ diff --git a/camel/camel-store.c b/camel/camel-store.c index 3be983e081..dd2d5e41a0 100644 --- a/camel/camel-store.c +++ b/camel/camel-store.c @@ -32,7 +32,7 @@ static CamelServiceClass *parent_class = NULL; /* Returns the class for a CamelStore */ -#define CS_CLASS(so) CAMEL_STORE_CLASS (GTK_OBJECT(so)->klass) +#define CS_CLASS(so) CAMEL_STORE_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static CamelFolder *get_folder (CamelStore *store, const char *folder_name, gboolean create, CamelException *ex); @@ -51,15 +51,10 @@ static void cache_folder (CamelStore *store, const char *folder_name, CamelFolder *folder); static void uncache_folder (CamelStore *store, CamelFolder *folder); -static void finalize (GtkObject *object); - static void camel_store_class_init (CamelStoreClass *camel_store_class) { - GtkObjectClass *gtk_object_class = - GTK_OBJECT_CLASS (camel_store_class); - - parent_class = gtk_type_class (camel_service_get_type ()); + parent_class = CAMEL_SERVICE_CLASS (camel_type_get_global_classfuncs (camel_service_get_type ())); /* virtual method definition */ camel_store_class->get_folder = get_folder; @@ -71,9 +66,6 @@ camel_store_class_init (CamelStoreClass *camel_store_class) camel_store_class->lookup_folder = lookup_folder; camel_store_class->cache_folder = cache_folder; camel_store_class->uncache_folder = uncache_folder; - - /* virtual method override */ - gtk_object_class->finalize = finalize; } static void @@ -84,33 +76,8 @@ camel_store_init (void *o, void *k) store->folders = g_hash_table_new (g_str_hash, g_str_equal); } -GtkType -camel_store_get_type (void) -{ - static GtkType camel_store_type = 0; - - if (!camel_store_type) { - GtkTypeInfo camel_store_info = - { - "CamelStore", - sizeof (CamelStore), - sizeof (CamelStoreClass), - (GtkClassInitFunc) camel_store_class_init, - (GtkObjectInitFunc) camel_store_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_store_type = gtk_type_unique (CAMEL_SERVICE_TYPE, &camel_store_info); - } - - return camel_store_type; -} - - static void -finalize (GtkObject *object) +camel_store_finalize (CamelObject *object) { CamelStore *store = CAMEL_STORE (object); @@ -125,12 +92,31 @@ finalize (GtkObject *object) } +CamelType +camel_store_get_type (void) +{ + static CamelType camel_store_type = CAMEL_INVALID_TYPE; + + if (camel_store_type == CAMEL_INVALID_TYPE) { + camel_store_type = camel_type_register (CAMEL_SERVICE_TYPE, "CamelStore", + sizeof (CamelStore), + sizeof (CamelStoreClass), + (CamelObjectClassInitFunc) camel_store_class_init, + NULL, + (CamelObjectInitFunc) camel_store_init, + (CamelObjectFinalizeFunc) camel_store_finalize ); + } + + return camel_store_type; +} + + static CamelFolder * get_folder (CamelStore *store, const char *folder_name, gboolean create, CamelException *ex) { g_warning ("CamelStore::get_folder not implemented for `%s'", - gtk_type_name (GTK_OBJECT_TYPE (store))); + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (store))); return NULL; } @@ -138,17 +124,17 @@ static void delete_folder (CamelStore *store, const char *folder_name, CamelException *ex) { g_warning ("CamelStore::delete_folder not implemented for `%s'", - gtk_type_name (GTK_OBJECT_TYPE (store))); + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (store))); } static void rename_folder (CamelStore *store, const char *old_name, const char *new_name, CamelException *ex) { g_warning ("CamelStore::rename_folder not implemented for `%s'", - gtk_type_name (GTK_OBJECT_TYPE (store))); + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (store))); camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, "rename folder unimplemented for: %s", - gtk_type_name (GTK_OBJECT_TYPE (store))); + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (store))); } @@ -164,7 +150,7 @@ get_folder_name (CamelStore *store, const char *folder_name, CamelException *ex) { g_warning ("CamelStore::get_folder_name not implemented for `%s'", - gtk_type_name (GTK_OBJECT_TYPE (store))); + camel_type_to_name (CAMEL_OBJECT_GET_TYPE (store))); return NULL; } @@ -186,12 +172,17 @@ lookup_folder (CamelStore *store, const char *folder_name) if (store->folders) { CamelFolder *folder = g_hash_table_lookup (store->folders, folder_name); if (folder) - gtk_object_ref(GTK_OBJECT(folder)); + camel_object_ref(CAMEL_OBJECT(folder)); return folder; } return NULL; } +static void folder_finalize (CamelObject *folder, gpointer event_data, gpointer user_data) +{ + CS_CLASS (user_data)->uncache_folder (CAMEL_STORE(user_data), CAMEL_FOLDER(folder)); +} + static void cache_folder (CamelStore *store, const char *folder_name, CamelFolder *folder) { @@ -203,9 +194,16 @@ cache_folder (CamelStore *store, const char *folder_name, CamelFolder *folder) folder_name); } g_hash_table_insert (store->folders, g_strdup (folder_name), folder); - gtk_signal_connect_object (GTK_OBJECT (folder), "destroy", - GTK_SIGNAL_FUNC (CS_CLASS (store)->uncache_folder), - GTK_OBJECT (store)); + + camel_object_hook_event (CAMEL_OBJECT (folder), "finalize", folder_finalize, store); + + /* + * gt_k so as not to get caught by my little gt_k cleanliness detector. + * + * gt_k_signal_connect_object (CAMEL_OBJECT (folder), "destroy", + * GT_K_SIGNAL_FUNC (CS_CLASS (store)->uncache_folder), + * CAMEL_OBJECT (store)); + */ } static gboolean @@ -270,6 +268,9 @@ camel_store_get_folder (CamelStore *store, const char *folder_name, char *name; CamelFolder *folder = NULL; + if (!camel_service_is_connected (CAMEL_SERVICE (store))) + camel_service_connect (CAMEL_SERVICE (store), ex); + name = CS_CLASS (store)->get_folder_name (store, folder_name, ex); if (name) { folder = get_folder_internal (store, name, create, ex); diff --git a/camel/camel-store.h b/camel/camel-store.h index 3fc029d8c9..1ba2ff9869 100644 --- a/camel/camel-store.h +++ b/camel/camel-store.h @@ -34,12 +34,13 @@ extern "C" { #pragma } #endif /* __cplusplus }*/ +#include #include #define CAMEL_STORE_TYPE (camel_store_get_type ()) -#define CAMEL_STORE(obj) (GTK_CHECK_CAST((obj), CAMEL_STORE_TYPE, CamelStore)) -#define CAMEL_STORE_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_STORE_TYPE, CamelStoreClass)) -#define CAMEL_IS_STORE(o) (GTK_CHECK_TYPE((o), CAMEL_STORE_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)) struct _CamelStore @@ -86,8 +87,8 @@ typedef struct { } CamelStoreClass; -/* Standard Gtk function */ -GtkType camel_store_get_type (void); +/* Standard Camel function */ +CamelType camel_store_get_type (void); /* public methods */ CamelFolder * camel_store_get_folder (CamelStore *store, diff --git a/camel/camel-stream-buffer.c b/camel/camel-stream-buffer.c index 633e42095b..c25cda09bc 100644 --- a/camel/camel-stream-buffer.c +++ b/camel/camel-stream-buffer.c @@ -30,7 +30,7 @@ #include #include -static CamelStreamBufferClass *parent_class = NULL; +static CamelStreamClass *parent_class = NULL; enum { BUF_USER = 1<<0, /* user-supplied buffer, do not free */ @@ -44,9 +44,6 @@ static int stream_flush (CamelStream *stream); static int stream_close (CamelStream *stream); static gboolean stream_eos (CamelStream *stream); -static void finalize (GtkObject *object); -static void destroy (GtkObject *object); - static void init_vbuf(CamelStreamBuffer *sbf, CamelStream *s, CamelStreamBufferMode mode, char *buf, guint32 size); static void init(CamelStreamBuffer *sbuf, CamelStream *s, CamelStreamBufferMode mode); @@ -54,9 +51,8 @@ static void camel_stream_buffer_class_init (CamelStreamBufferClass *camel_stream_buffer_class) { CamelStreamClass *camel_stream_class = CAMEL_STREAM_CLASS (camel_stream_buffer_class); - GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (camel_stream_buffer_class); - parent_class = gtk_type_class (camel_stream_get_type ()); + parent_class = CAMEL_STREAM_CLASS (camel_type_get_global_classfuncs (camel_stream_get_type ())); /* virtual method definition */ camel_stream_buffer_class->init = init; @@ -68,10 +64,6 @@ camel_stream_buffer_class_init (CamelStreamBufferClass *camel_stream_buffer_clas camel_stream_class->flush = stream_flush; camel_stream_class->close = stream_close; camel_stream_class->eos = stream_eos; - - gtk_object_class->finalize = finalize; - gtk_object_class->destroy = destroy; - } static void @@ -90,46 +82,8 @@ camel_stream_buffer_init (gpointer object, gpointer klass) sbf->linebuf = g_malloc(sbf->linesize); } -GtkType -camel_stream_buffer_get_type (void) -{ - static GtkType camel_stream_buffer_type = 0; - - gdk_threads_enter (); - if (!camel_stream_buffer_type) { - GtkTypeInfo camel_stream_buffer_info = - { - "CamelStreamBuffer", - sizeof (CamelStreamBuffer), - sizeof (CamelStreamBufferClass), - (GtkClassInitFunc) camel_stream_buffer_class_init, - (GtkObjectInitFunc) camel_stream_buffer_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_stream_buffer_type = gtk_type_unique (camel_stream_get_type (), &camel_stream_buffer_info); - } - gdk_threads_leave (); - return camel_stream_buffer_type; -} - - static void -destroy (GtkObject *object) -{ - CamelStreamBuffer *stream_buffer = CAMEL_STREAM_BUFFER (object); - - /* NOP to remove warnings */ - stream_buffer->buf = stream_buffer->buf; - - GTK_OBJECT_CLASS (parent_class)->destroy (object); -} - - -static void -finalize (GtkObject *object) +camel_stream_buffer_finalize (CamelObject *object) { CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (object); @@ -137,13 +91,31 @@ finalize (GtkObject *object) g_free(sbf->buf); } if (sbf->stream) - gtk_object_unref(GTK_OBJECT(sbf->stream)); + camel_object_unref(CAMEL_OBJECT(sbf->stream)); g_free(sbf->linebuf); +} + - GTK_OBJECT_CLASS (parent_class)->finalize (object); +CamelType +camel_stream_buffer_get_type (void) +{ + static CamelType camel_stream_buffer_type = CAMEL_INVALID_TYPE; + + if (camel_stream_buffer_type == CAMEL_INVALID_TYPE) { + camel_stream_buffer_type = camel_type_register (camel_stream_get_type (), "CamelStreamBuffer", + sizeof (CamelStreamBuffer), + sizeof (CamelStreamBufferClass), + (CamelObjectClassInitFunc) camel_stream_buffer_class_init, + NULL, + (CamelObjectInitFunc) camel_stream_buffer_init, + (CamelObjectFinalizeFunc) camel_stream_buffer_finalize); + } + + return camel_stream_buffer_type; } + static void set_vbuf(CamelStreamBuffer *sbf, char *buf, CamelStreamBufferMode mode, int size) { @@ -166,9 +138,9 @@ init_vbuf(CamelStreamBuffer *sbf, CamelStream *s, CamelStreamBufferMode mode, ch { set_vbuf(sbf, buf, mode, size); if (sbf->stream) - gtk_object_unref(GTK_OBJECT(sbf->stream)); + camel_object_unref(CAMEL_OBJECT(sbf->stream)); sbf->stream = s; - gtk_object_ref(GTK_OBJECT(sbf->stream)); + camel_object_ref(CAMEL_OBJECT(sbf->stream)); } static void @@ -196,8 +168,8 @@ CamelStream * camel_stream_buffer_new (CamelStream *stream, CamelStreamBufferMode mode) { CamelStreamBuffer *sbf; - sbf = gtk_type_new (camel_stream_buffer_get_type ()); - CAMEL_STREAM_BUFFER_CLASS (GTK_OBJECT(sbf)->klass)->init (sbf, stream, mode); + sbf = CAMEL_STREAM_BUFFER (camel_object_new (camel_stream_buffer_get_type ())); + CAMEL_STREAM_BUFFER_CLASS (CAMEL_OBJECT_GET_CLASS(sbf))->init (sbf, stream, mode); return CAMEL_STREAM (sbf); } @@ -240,8 +212,8 @@ camel_stream_buffer_new (CamelStream *stream, CamelStreamBufferMode mode) CamelStream *camel_stream_buffer_new_with_vbuf (CamelStream *stream, CamelStreamBufferMode mode, char *buf, guint32 size) { CamelStreamBuffer *sbf; - sbf = gtk_type_new (camel_stream_buffer_get_type ()); - CAMEL_STREAM_BUFFER_CLASS (GTK_OBJECT(sbf)->klass)->init_vbuf (sbf, stream, mode, buf, size); + sbf = CAMEL_STREAM_BUFFER (camel_object_new (camel_stream_buffer_get_type ())); + CAMEL_STREAM_BUFFER_CLASS (CAMEL_OBJECT_GET_CLASS(sbf))->init_vbuf (sbf, stream, mode, buf, size); return CAMEL_STREAM (sbf); } diff --git a/camel/camel-stream-buffer.h b/camel/camel-stream-buffer.h index 367735e4e1..5c9037595a 100644 --- a/camel/camel-stream-buffer.h +++ b/camel/camel-stream-buffer.h @@ -38,9 +38,9 @@ extern "C" { #include #define CAMEL_STREAM_BUFFER_TYPE (camel_stream_buffer_get_type ()) -#define CAMEL_STREAM_BUFFER(obj) (GTK_CHECK_CAST((obj), CAMEL_STREAM_BUFFER_TYPE, CamelStreamBuffer)) -#define CAMEL_STREAM_BUFFER_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_STREAM_BUFFER_TYPE, CamelStreamBufferClass)) -#define CAMEL_IS_STREAM_BUFFER(o) (GTK_CHECK_TYPE((o), CAMEL_STREAM_BUFFER_TYPE)) +#define CAMEL_STREAM_BUFFER(obj) (CAMEL_CHECK_CAST((obj), CAMEL_STREAM_BUFFER_TYPE, CamelStreamBuffer)) +#define CAMEL_STREAM_BUFFER_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_STREAM_BUFFER_TYPE, CamelStreamBufferClass)) +#define CAMEL_IS_STREAM_BUFFER(o) (CAMEL_CHECK_TYPE((o), CAMEL_STREAM_BUFFER_TYPE)) typedef enum { @@ -83,8 +83,8 @@ typedef struct { } CamelStreamBufferClass; -/* Standard Gtk function */ -GtkType camel_stream_buffer_get_type (void); +/* Standard Camel function */ +CamelType camel_stream_buffer_get_type (void); /* public methods */ diff --git a/camel/camel-stream-filter.c b/camel/camel-stream-filter.c index 9051bdb64f..7d66928bf5 100644 --- a/camel/camel-stream-filter.c +++ b/camel/camel-stream-filter.c @@ -57,36 +57,35 @@ static int do_reset (CamelStream *stream); static CamelStreamClass *camel_stream_filter_parent; -enum SIGNALS { - LAST_SIGNAL -}; +static void +camel_stream_filter_class_init (CamelStreamFilterClass *klass) +{ + CamelStreamClass *camel_stream_class = (CamelStreamClass *) klass; -static guint signals[LAST_SIGNAL] = { 0 }; + camel_stream_filter_parent = CAMEL_STREAM_CLASS (camel_type_get_global_classfuncs (camel_stream_get_type ())); -guint -camel_stream_filter_get_type (void) + camel_stream_class->read = do_read; + camel_stream_class->write = do_write; + camel_stream_class->flush = do_flush; + camel_stream_class->close = do_close; + camel_stream_class->eos = do_eos; + camel_stream_class->reset = do_reset; + +} + +static void +camel_stream_filter_init (CamelStreamFilter *obj) { - static guint type = 0; - - if (!type) { - GtkTypeInfo type_info = { - "CamelStreamFilter", - sizeof (CamelStreamFilter), - sizeof (CamelStreamFilterClass), - (GtkClassInitFunc) camel_stream_filter_class_init, - (GtkObjectInitFunc) camel_stream_filter_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_stream_get_type (), &type_info); - } + struct _CamelStreamFilterPrivate *p; - return type; + _PRIVATE(obj) = p = g_malloc0(sizeof(*p)); + p->realbuffer = g_malloc(READ_SIZE + READ_PAD); + p->buffer = p->realbuffer + READ_PAD; + p->last_was_read = TRUE; } static void -finalise(GtkObject *o) +camel_stream_filter_finalize(CamelObject *o) { CamelStreamFilter *filter = (CamelStreamFilter *)o; struct _CamelStreamFilterPrivate *p = _PRIVATE(filter); @@ -95,49 +94,35 @@ finalise(GtkObject *o) f = p->filters; while (f) { fn = f->next; - gtk_object_unref((GtkObject *)f->filter); + camel_object_unref((CamelObject *)f->filter); g_free(f); f = fn; } g_free(p->realbuffer); g_free(p); - gtk_object_unref((GtkObject *)filter->source); - - GTK_OBJECT_CLASS (camel_stream_filter_parent)->finalize (o); + camel_object_unref((CamelObject *)filter->source); } -static void -camel_stream_filter_class_init (CamelStreamFilterClass *klass) -{ - GtkObjectClass *object_class = (GtkObjectClass *) klass; - CamelStreamClass *camel_stream_class = (CamelStreamClass *) klass; - - camel_stream_filter_parent = gtk_type_class (camel_stream_get_type ()); - - object_class->finalize = finalise; - - camel_stream_class->read = do_read; - camel_stream_class->write = do_write; - camel_stream_class->flush = do_flush; - camel_stream_class->close = do_close; - camel_stream_class->eos = do_eos; - camel_stream_class->reset = do_reset; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); -} - -static void -camel_stream_filter_init (CamelStreamFilter *obj) +CamelType +camel_stream_filter_get_type (void) { - struct _CamelStreamFilterPrivate *p; + static CamelType type = CAMEL_INVALID_TYPE; - _PRIVATE(obj) = p = g_malloc0(sizeof(*p)); - p->realbuffer = g_malloc(READ_SIZE + READ_PAD); - p->buffer = p->realbuffer + READ_PAD; - p->last_was_read = TRUE; + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (CAMEL_STREAM_TYPE, "CamelStreamFilter", + sizeof (CamelStreamFilter), + sizeof (CamelStreamFilterClass), + (CamelObjectClassInitFunc) camel_stream_filter_class_init, + NULL, + (CamelObjectInitFunc) camel_stream_filter_init, + (CamelObjectFinalizeFunc) camel_stream_filter_finalize); + } + + return type; } + /** * camel_stream_filter_new: * @@ -148,10 +133,10 @@ camel_stream_filter_init (CamelStreamFilter *obj) CamelStreamFilter * camel_stream_filter_new_with_stream(CamelStream *stream) { - CamelStreamFilter *new = CAMEL_STREAM_FILTER ( gtk_type_new (camel_stream_filter_get_type ())); + CamelStreamFilter *new = CAMEL_STREAM_FILTER ( camel_object_new (camel_stream_filter_get_type ())); new->source = stream; - gtk_object_ref ((GtkObject *)stream); + camel_object_ref ((CamelObject *)stream); return new; } @@ -179,7 +164,7 @@ camel_stream_filter_add(CamelStreamFilter *filter, CamelMimeFilter *mf) fn = g_malloc(sizeof(*fn)); fn->id = p->filterid++; fn->filter = mf; - gtk_object_ref((GtkObject *)mf); + camel_object_ref((CamelObject *)mf); /* sure, we could use a GList, but we wouldn't save much */ f = (struct _filter *)&p->filters; @@ -208,7 +193,7 @@ camel_stream_filter_remove(CamelStreamFilter *filter, int id) fn = f->next; if (fn->id == id) { f->next = fn->next; - gtk_object_unref((GtkObject *)fn->filter); + camel_object_unref((CamelObject *)fn->filter); g_free(fn); } f = f->next; diff --git a/camel/camel-stream-filter.h b/camel/camel-stream-filter.h index 0bc73732ec..d0683135c7 100644 --- a/camel/camel-stream-filter.h +++ b/camel/camel-stream-filter.h @@ -24,9 +24,9 @@ #include #include -#define CAMEL_STREAM_FILTER(obj) GTK_CHECK_CAST (obj, camel_stream_filter_get_type (), CamelStreamFilter) -#define CAMEL_STREAM_FILTER_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_stream_filter_get_type (), CamelStreamFilterClass) -#define IS_CAMEL_STREAM_FILTER(obj) GTK_CHECK_TYPE (obj, camel_stream_filter_get_type ()) +#define CAMEL_STREAM_FILTER(obj) CAMEL_CHECK_CAST (obj, camel_stream_filter_get_type (), CamelStreamFilter) +#define CAMEL_STREAM_FILTER_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_stream_filter_get_type (), CamelStreamFilterClass) +#define IS_CAMEL_STREAM_FILTER(obj) CAMEL_CHECK_TYPE (obj, camel_stream_filter_get_type ()) typedef struct _CamelStreamFilterClass CamelStreamFilterClass; diff --git a/camel/camel-stream-fs.c b/camel/camel-stream-fs.c index b1a7dde41a..17c6b98e08 100644 --- a/camel/camel-stream-fs.c +++ b/camel/camel-stream-fs.c @@ -35,7 +35,7 @@ static CamelSeekableStreamClass *parent_class = NULL; /* Returns the class for a CamelStreamFS */ -#define CSFS_CLASS(so) CAMEL_STREAM_FS_CLASS (GTK_OBJECT(so)->klass) +#define CSFS_CLASS(so) CAMEL_STREAM_FS_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static ssize_t stream_read (CamelStream *stream, char *buffer, size_t n); static ssize_t stream_write (CamelStream *stream, const char *buffer, size_t n); @@ -43,7 +43,6 @@ static int stream_flush (CamelStream *stream); static int stream_close (CamelStream *stream); static off_t stream_seek (CamelSeekableStream *stream, off_t offset, CamelStreamSeekPolicy policy); -static void finalize (GtkObject *object); static void camel_stream_fs_class_init (CamelStreamFsClass *camel_stream_fs_class) @@ -52,10 +51,8 @@ camel_stream_fs_class_init (CamelStreamFsClass *camel_stream_fs_class) CAMEL_SEEKABLE_STREAM_CLASS (camel_stream_fs_class); CamelStreamClass *camel_stream_class = CAMEL_STREAM_CLASS (camel_stream_fs_class); - GtkObjectClass *gtk_object_class = - GTK_OBJECT_CLASS (camel_stream_fs_class); - parent_class = gtk_type_class (camel_seekable_stream_get_type ()); + parent_class = CAMEL_SEEKABLE_STREAM_CLASS (camel_type_get_global_classfuncs (camel_seekable_stream_get_type ())); /* virtual method overload */ camel_stream_class->read = stream_read; @@ -64,8 +61,6 @@ camel_stream_fs_class_init (CamelStreamFsClass *camel_stream_fs_class) camel_stream_class->close = stream_close; camel_seekable_stream_class->seek = stream_seek; - - gtk_object_class->finalize = finalize; } static void @@ -76,39 +71,32 @@ camel_stream_fs_init (gpointer object, gpointer klass) stream->fd = -1; } -GtkType -camel_stream_fs_get_type (void) -{ - static GtkType camel_stream_fs_type = 0; - - if (!camel_stream_fs_type) { - GtkTypeInfo camel_stream_fs_info = - { - "CamelStreamFs", - sizeof (CamelStreamFs), - sizeof (CamelStreamFsClass), - (GtkClassInitFunc) camel_stream_fs_class_init, - (GtkObjectInitFunc) camel_stream_fs_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_stream_fs_type = gtk_type_unique (camel_seekable_stream_get_type (), &camel_stream_fs_info); - } - - return camel_stream_fs_type; -} - static void -finalize (GtkObject *object) +camel_stream_fs_finalize (CamelObject *object) { CamelStreamFs *stream_fs = CAMEL_STREAM_FS (object); if (stream_fs->fd != -1) close (stream_fs->fd); +} + - GTK_OBJECT_CLASS (parent_class)->finalize (object); +CamelType +camel_stream_fs_get_type (void) +{ + static CamelType camel_stream_fs_type = CAMEL_INVALID_TYPE; + + if (camel_stream_fs_type == CAMEL_INVALID_TYPE) { + camel_stream_fs_type = camel_type_register (camel_seekable_stream_get_type (), "CamelStreamFs", + sizeof (CamelStreamFs), + sizeof (CamelStreamFsClass), + (CamelObjectClassInitFunc) camel_stream_fs_class_init, + NULL, + (CamelObjectInitFunc) camel_stream_fs_init, + (CamelObjectFinalizeFunc) camel_stream_fs_finalize); + } + + return camel_stream_fs_type; } /** @@ -126,7 +114,7 @@ camel_stream_fs_new_with_fd (int fd) CamelStreamFs *stream_fs; off_t offset; - stream_fs = gtk_type_new (camel_stream_fs_get_type ()); + stream_fs = CAMEL_STREAM_FS (camel_object_new (camel_stream_fs_get_type ())); stream_fs->fd = fd; offset = lseek (fd, 0, SEEK_CUR); if (offset == -1) diff --git a/camel/camel-stream-fs.h b/camel/camel-stream-fs.h index 08ae49bddf..ea403f584f 100644 --- a/camel/camel-stream-fs.h +++ b/camel/camel-stream-fs.h @@ -41,9 +41,9 @@ extern "C" { #include #define CAMEL_STREAM_FS_TYPE (camel_stream_fs_get_type ()) -#define CAMEL_STREAM_FS(obj) (GTK_CHECK_CAST((obj), CAMEL_STREAM_FS_TYPE, CamelStreamFs)) -#define CAMEL_STREAM_FS_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_STREAM_FS_TYPE, CamelStreamFsClass)) -#define CAMEL_IS_STREAM_FS(o) (GTK_CHECK_TYPE((o), CAMEL_STREAM_FS_TYPE)) +#define CAMEL_STREAM_FS(obj) (CAMEL_CHECK_CAST((obj), CAMEL_STREAM_FS_TYPE, CamelStreamFs)) +#define CAMEL_STREAM_FS_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_STREAM_FS_TYPE, CamelStreamFsClass)) +#define CAMEL_IS_STREAM_FS(o) (CAMEL_CHECK_TYPE((o), CAMEL_STREAM_FS_TYPE)) struct _CamelStreamFs { @@ -57,8 +57,8 @@ typedef struct { } CamelStreamFsClass; -/* Standard Gtk function */ -GtkType camel_stream_fs_get_type (void); +/* Standard Camel function */ +CamelType camel_stream_fs_get_type (void); /* public methods */ CamelStream * camel_stream_fs_new_with_name (const char *name, int flags, mode_t mode); diff --git a/camel/camel-stream-mem.c b/camel/camel-stream-mem.c index 08c5e266d4..f5dab54a41 100644 --- a/camel/camel-stream-mem.c +++ b/camel/camel-stream-mem.c @@ -30,10 +30,10 @@ #include #include -static CamelStreamClass *parent_class = NULL; +static CamelSeekableStreamClass *parent_class = NULL; /* Returns the class for a CamelStreamMem */ -#define CSM_CLASS(so) CAMEL_STREAM_MEM_CLASS (GTK_OBJECT(so)->klass) +#define CSM_CLASS(so) CAMEL_STREAM_MEM_CLASS(CAMEL_OBJECT_GET_CLASS(so)) static ssize_t stream_read (CamelStream *stream, char *buffer, size_t n); static ssize_t stream_write (CamelStream *stream, const char *buffer, size_t n); @@ -41,7 +41,7 @@ static gboolean stream_eos (CamelStream *stream); static off_t stream_seek (CamelSeekableStream *stream, off_t offset, CamelStreamSeekPolicy policy); -static void finalize (GtkObject *object); +static void camel_stream_mem_finalize (CamelObject *object); static void camel_stream_mem_class_init (CamelStreamMemClass *camel_stream_mem_class) @@ -50,10 +50,8 @@ camel_stream_mem_class_init (CamelStreamMemClass *camel_stream_mem_class) CAMEL_SEEKABLE_STREAM_CLASS (camel_stream_mem_class); CamelStreamClass *camel_stream_class = CAMEL_STREAM_CLASS (camel_stream_mem_class); - GtkObjectClass *gtk_object_class = - GTK_OBJECT_CLASS (camel_stream_mem_class); - parent_class = gtk_type_class (camel_stream_get_type ()); + parent_class = CAMEL_SEEKABLE_STREAM_CLASS( camel_type_get_global_classfuncs( CAMEL_SEEKABLE_STREAM_TYPE ) ); /* virtual method overload */ camel_stream_class->read = stream_read; @@ -61,12 +59,10 @@ camel_stream_mem_class_init (CamelStreamMemClass *camel_stream_mem_class) camel_stream_class->eos = stream_eos; camel_seekable_stream_class->seek = stream_seek; - - gtk_object_class->finalize = finalize; } static void -camel_stream_mem_init (gpointer object, gpointer klass) +camel_stream_mem_init (CamelObject *object) { CamelStreamMem *stream_mem = CAMEL_STREAM_MEM (object); @@ -74,25 +70,20 @@ camel_stream_mem_init (gpointer object, gpointer klass) stream_mem->buffer = 0; } -GtkType +CamelType camel_stream_mem_get_type (void) { - static GtkType camel_stream_mem_type = 0; - - if (!camel_stream_mem_type) { - GtkTypeInfo camel_stream_mem_info = - { - "CamelStreamMem", - sizeof (CamelStreamMem), - sizeof (CamelStreamMemClass), - (GtkClassInitFunc) camel_stream_mem_class_init, - (GtkObjectInitFunc) camel_stream_mem_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_stream_mem_type = gtk_type_unique (camel_seekable_stream_get_type (), &camel_stream_mem_info); + static CamelType camel_stream_mem_type = CAMEL_INVALID_TYPE; + + if (camel_stream_mem_type == CAMEL_INVALID_TYPE) { + camel_stream_mem_type = camel_type_register( CAMEL_SEEKABLE_STREAM_TYPE, + "CamelStreamMem", + sizeof( CamelStreamMem ), + sizeof( CamelStreamMemClass ), + (CamelObjectClassInitFunc) camel_stream_mem_class_init, + NULL, + (CamelObjectInitFunc) camel_stream_mem_init, + (CamelObjectFinalizeFunc) camel_stream_mem_finalize ); } return camel_stream_mem_type; @@ -120,7 +111,7 @@ camel_stream_mem_new_with_byte_array (GByteArray *byte_array) { CamelStreamMem *stream_mem; - stream_mem = gtk_type_new (camel_stream_mem_get_type ()); + stream_mem = CAMEL_STREAM_MEM( camel_object_new (CAMEL_STREAM_MEM_TYPE) ); stream_mem->buffer = byte_array; stream_mem->owner = TRUE; @@ -147,14 +138,17 @@ void camel_stream_mem_set_buffer (CamelStreamMem *s, const char *buffer, } static void -finalize (GtkObject *object) +camel_stream_mem_finalize (CamelObject *object) { CamelStreamMem *stream_mem = CAMEL_STREAM_MEM (object); if (stream_mem->buffer && stream_mem->owner) g_byte_array_free (stream_mem->buffer, TRUE); - GTK_OBJECT_CLASS (parent_class)->finalize (object); + /* Will be called automagically in the Camel Type System! + * Wheeee! + * G_TK_OBJECT_CLASS (parent_class)->finalize (object); + */ } static ssize_t diff --git a/camel/camel-stream-mem.h b/camel/camel-stream-mem.h index cf62f09547..b27503efb6 100644 --- a/camel/camel-stream-mem.h +++ b/camel/camel-stream-mem.h @@ -37,9 +37,9 @@ extern "C" { #include #define CAMEL_STREAM_MEM_TYPE (camel_stream_mem_get_type ()) -#define CAMEL_STREAM_MEM(obj) (GTK_CHECK_CAST((obj), CAMEL_STREAM_MEM_TYPE, CamelStreamMem)) -#define CAMEL_STREAM_MEM_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_STREAM_MEM_TYPE, CamelStreamMemClass)) -#define CAMEL_IS_STREAM_MEM(o) (GTK_CHECK_TYPE((o), CAMEL_STREAM_MEM_TYPE)) +#define CAMEL_STREAM_MEM(obj) (CAMEL_CHECK_CAST((obj), CAMEL_STREAM_MEM_TYPE, CamelStreamMem)) +#define CAMEL_STREAM_MEM_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_STREAM_MEM_TYPE, CamelStreamMemClass)) +#define CAMEL_IS_STREAM_MEM(o) (CAMEL_CHECK_TYPE((o), CAMEL_STREAM_MEM_TYPE)) typedef struct _CamelStreamMemClass CamelStreamMemClass; @@ -56,8 +56,8 @@ struct _CamelStreamMemClass { /* Virtual methods */ }; -/* Standard Gtk function */ -GtkType camel_stream_mem_get_type (void); +/* Standard Camel function */ +CamelType camel_stream_mem_get_type (void); /* public methods */ CamelStream *camel_stream_mem_new (void); diff --git a/camel/camel-stream.c b/camel/camel-stream.c index 2cdabacaba..f649494b2d 100644 --- a/camel/camel-stream.c +++ b/camel/camel-stream.c @@ -29,7 +29,7 @@ static CamelObjectClass *parent_class = NULL; /* Returns the class for a CamelStream */ -#define CS_CLASS(so) CAMEL_STREAM_CLASS (GTK_OBJECT(so)->klass) +#define CS_CLASS(so) CAMEL_STREAM_CLASS(CAMEL_OBJECT_GET_CLASS(so)) static int stream_flush (CamelStream *stream); static int stream_close (CamelStream *stream); @@ -39,7 +39,7 @@ static gboolean stream_eos (CamelStream *stream); static void camel_stream_class_init (CamelStreamClass *camel_stream_class) { - parent_class = gtk_type_class (camel_object_get_type ()); + parent_class = camel_type_get_global_classfuncs( CAMEL_OBJECT_TYPE ); /* virtual method definition */ camel_stream_class->flush = stream_flush; @@ -47,26 +47,20 @@ camel_stream_class_init (CamelStreamClass *camel_stream_class) camel_stream_class->eos = stream_eos; } -GtkType +CamelType camel_stream_get_type (void) { - static GtkType camel_stream_type = 0; - - if (!camel_stream_type) { - GtkTypeInfo camel_stream_info = - { - "CamelStream", - sizeof (CamelStream), - sizeof (CamelStreamClass), - (GtkClassInitFunc) camel_stream_class_init, - (GtkObjectInitFunc) NULL, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_stream_type = gtk_type_unique (camel_object_get_type (), - &camel_stream_info); + static CamelType camel_stream_type = CAMEL_INVALID_TYPE; + + if (camel_stream_type == CAMEL_INVALID_TYPE) { + camel_stream_type = camel_type_register( CAMEL_OBJECT_TYPE, + "CamelStream", + sizeof( CamelStream ), + sizeof( CamelStreamClass ), + (CamelObjectClassInitFunc) camel_stream_class_init, + NULL, + NULL, + NULL ); } return camel_stream_type; diff --git a/camel/camel-stream.h b/camel/camel-stream.h index 5660ca6e4c..dec4e638e1 100644 --- a/camel/camel-stream.h +++ b/camel/camel-stream.h @@ -38,9 +38,9 @@ extern "C" { #include #define CAMEL_STREAM_TYPE (camel_stream_get_type ()) -#define CAMEL_STREAM(obj) (GTK_CHECK_CAST((obj), CAMEL_STREAM_TYPE, CamelStream)) -#define CAMEL_STREAM_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_STREAM_TYPE, CamelStreamClass)) -#define CAMEL_IS_STREAM(o) (GTK_CHECK_TYPE((o), CAMEL_STREAM_TYPE)) +#define CAMEL_STREAM(obj) (CAMEL_CHECK_CAST((obj), CAMEL_STREAM_TYPE, CamelStream)) +#define CAMEL_STREAM_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_STREAM_TYPE, CamelStreamClass)) +#define CAMEL_IS_STREAM(o) (CAMEL_CHECK_TYPE((o), CAMEL_STREAM_TYPE)) struct _CamelStream { @@ -63,8 +63,8 @@ typedef struct { } CamelStreamClass; -/* Standard Gtk function */ -GtkType camel_stream_get_type (void); +/* Standard Camel function */ +CamelType camel_stream_get_type (void); /* public methods */ ssize_t camel_stream_read (CamelStream *stream, char *buffer, size_t n); diff --git a/camel/camel-transport.c b/camel/camel-transport.c index 849248a6e7..ff07728f5f 100644 --- a/camel/camel-transport.c +++ b/camel/camel-transport.c @@ -28,27 +28,21 @@ #include "camel-exception.h" /* Returns the class for a CamelTransport */ -#define CT_CLASS(so) CAMEL_TRANSPORT_CLASS (GTK_OBJECT(so)->klass) +#define CT_CLASS(so) CAMEL_TRANSPORT_CLASS (CAMEL_OBJECT_GET_CLASS(so)) -GtkType +CamelType camel_transport_get_type (void) { - static GtkType camel_transport_type = 0; + static CamelType camel_transport_type = CAMEL_INVALID_TYPE; - if (!camel_transport_type) { - GtkTypeInfo camel_transport_info = - { - "CamelTransport", - sizeof (CamelTransport), - sizeof (CamelTransportClass), - (GtkClassInitFunc) NULL, - (GtkObjectInitFunc) NULL, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_transport_type = gtk_type_unique (CAMEL_SERVICE_TYPE, &camel_transport_info); + if (camel_transport_type == CAMEL_INVALID_TYPE) { + camel_transport_type = camel_type_register (CAMEL_SERVICE_TYPE, "CamelTransport", + sizeof (CamelTransport), + sizeof (CamelTransportClass), + NULL, + NULL, + NULL, + NULL); } return camel_transport_type; diff --git a/camel/camel-transport.h b/camel/camel-transport.h index fc8f0e3076..0b66bd8eac 100644 --- a/camel/camel-transport.h +++ b/camel/camel-transport.h @@ -37,9 +37,9 @@ extern "C" { #include #define CAMEL_TRANSPORT_TYPE (camel_transport_get_type ()) -#define CAMEL_TRANSPORT(obj) (GTK_CHECK_CAST((obj), CAMEL_TRANSPORT_TYPE, CamelTransport)) -#define CAMEL_TRANSPORT_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_TRANSPORT_TYPE, CamelTransportClass)) -#define CAMEL_IS_TRANSPORT(o) (GTK_CHECK_TYPE((o), CAMEL_TRANSPORT_TYPE)) +#define CAMEL_TRANSPORT(obj) (CAMEL_CHECK_CAST((obj), CAMEL_TRANSPORT_TYPE, CamelTransport)) +#define CAMEL_TRANSPORT_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_TRANSPORT_TYPE, CamelTransportClass)) +#define CAMEL_IS_TRANSPORT(o) (CAMEL_CHECK_TYPE((o), CAMEL_TRANSPORT_TYPE)) struct _CamelTransport @@ -75,8 +75,8 @@ gboolean camel_transport_send_to (CamelTransport *transport, GList *recipients, CamelException *ex); -/* Standard Gtk function */ -GtkType camel_transport_get_type (void); +/* Standard Camel function */ +CamelType camel_transport_get_type (void); #ifdef __cplusplus } diff --git a/camel/camel-types.h b/camel/camel-types.h index 62567da1d6..d6813cb863 100644 --- a/camel/camel-types.h +++ b/camel/camel-types.h @@ -46,7 +46,6 @@ typedef struct _CamelMimeParser CamelMimeParser; typedef struct _CamelMimePart CamelMimePart; typedef struct _CamelMultipart CamelMultipart; typedef struct _CamelNewsAddress CamelNewsAddress; -typedef struct _CamelObject CamelObject; typedef struct _CamelSeekableStream CamelSeekableStream; typedef struct _CamelSeekableSubstream CamelSeekableSubstream; typedef struct _CamelService CamelService; diff --git a/camel/providers/Makefile.am b/camel/providers/Makefile.am index 357956d8c6..dedeaa0b3b 100644 --- a/camel/providers/Makefile.am +++ b/camel/providers/Makefile.am @@ -1,5 +1,6 @@ ## Process this file with automake to produce Makefile.in +# SUBDIRS = mbox pop3 sendmail smtp vee SUBDIRS = mbox pop3 sendmail smtp vee imap mh nntp # these ones are disabled for the moment. diff --git a/camel/providers/imap/camel-imap-folder.c b/camel/providers/imap/camel-imap-folder.c index 9ab729d218..87554b120d 100644 --- a/camel/providers/imap/camel-imap-folder.c +++ b/camel/providers/imap/camel-imap-folder.c @@ -55,7 +55,7 @@ #define d(x) x -#define CF_CLASS(o) (CAMEL_FOLDER_CLASS (GTK_OBJECT (o)->klass)) +#define CF_CLASS(o) (CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(o))) static CamelFolderClass *parent_class = NULL; @@ -64,8 +64,6 @@ static void imap_init (CamelFolder *folder, CamelStore *parent_store, gchar *separator, gboolean path_begns_with_sep, CamelException *ex); -static void imap_finalize (GtkObject *object); - static void imap_sync (CamelFolder *folder, gboolean expunge, CamelException *ex); static void imap_expunge (CamelFolder *folder, CamelException *ex); @@ -88,6 +86,8 @@ static const CamelMessageInfo *imap_get_message_info (CamelFolder *folder, const static GPtrArray *imap_search_by_expression (CamelFolder *folder, const char *expression, CamelException *ex); +static void imap_finalize (CamelObject *object); + /* flag methods */ static guint32 imap_get_message_flags (CamelFolder *folder, const char *uid); static void imap_set_message_flags (CamelFolder *folder, const char *uid, guint32 flags, guint32 set); @@ -100,9 +100,8 @@ static void camel_imap_folder_class_init (CamelImapFolderClass *camel_imap_folder_class) { CamelFolderClass *camel_folder_class = CAMEL_FOLDER_CLASS (camel_imap_folder_class); - GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (camel_folder_class); - parent_class = gtk_type_class (camel_folder_get_type ()); + parent_class = CAMEL_FOLDER_CLASS(camel_type_get_global_classfuncs (camel_folder_get_type ())); /* virtual method definition */ @@ -133,8 +132,6 @@ camel_imap_folder_class_init (CamelImapFolderClass *camel_imap_folder_class) camel_folder_class->set_message_flags = imap_set_message_flags; camel_folder_class->get_message_user_flag = imap_get_message_user_flag; camel_folder_class->set_message_user_flag = imap_set_message_user_flag; - - gtk_object_class->finalize = imap_finalize; } static void @@ -153,25 +150,19 @@ camel_imap_folder_init (gpointer object, gpointer klass) imap_folder->lsub = NULL; } -GtkType +CamelType camel_imap_folder_get_type (void) { - static GtkType camel_imap_folder_type = 0; - - if (!camel_imap_folder_type) { - GtkTypeInfo camel_imap_folder_info = - { - "CamelImapFolder", - sizeof (CamelImapFolder), - sizeof (CamelImapFolderClass), - (GtkClassInitFunc) camel_imap_folder_class_init, - (GtkObjectInitFunc) camel_imap_folder_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_imap_folder_type = gtk_type_unique (CAMEL_FOLDER_TYPE, &camel_imap_folder_info); + static CamelType camel_imap_folder_type = CAMEL_INVALID_TYPE; + + if (camel_imap_folder_type == CAMEL_INVALID_TYPE) { + camel_imap_folder_type = camel_type_register (CAMEL_FOLDER_TYPE, "CamelImapFolder", + sizeof (CamelImapFolder), + sizeof (CamelImapFolderClass), + (CamelObjectClassInitFunc) camel_imap_folder_class_init, + NULL, + (CamelObjectInitFunc) camel_imap_folder_init, + (CamelObjectFinalizeFunc) imap_finalize); } return camel_imap_folder_type; @@ -180,7 +171,7 @@ camel_imap_folder_get_type (void) CamelFolder * camel_imap_folder_new (CamelStore *parent, char *folder_name, CamelException *ex) { - CamelFolder *folder = CAMEL_FOLDER (gtk_object_new (camel_imap_folder_get_type (), NULL)); + CamelFolder *folder = CAMEL_FOLDER (camel_object_new (camel_imap_folder_get_type ())); CamelURL *url = CAMEL_SERVICE (parent)->url; char *dir_sep; @@ -238,7 +229,7 @@ imap_folder_summary_free (CamelImapFolder *imap_folder) } static void -imap_finalize (GtkObject *object) +imap_finalize (CamelObject *object) { /* TODO: do we need to do more cleanup here? */ CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (object); @@ -964,9 +955,9 @@ imap_get_message (CamelFolder *folder, const gchar *uid, CamelException *ex) camel_stream_filter_remove (f_stream, id); camel_stream_close (CAMEL_STREAM (f_stream)); #endif - gtk_object_unref (GTK_OBJECT (msgstream)); - /*gtk_object_unref (GTK_OBJECT (f_stream));*/ - + camel_object_unref (CAMEL_OBJECT (msgstream)); + /*camel_object_unref (CAMEL_OBJECT (f_stream));*/ + d(fprintf (stderr, "*** We're returning... ***\n")); return msg; @@ -991,7 +982,7 @@ imap_get_message (CamelFolder *folder, const gchar *uid, CamelException *ex) /* Temp hack - basically we read in the entire message instead of getting a part as it's needed */ msgstream = camel_stream_mem_new (); camel_stream_write_to_stream (CAMEL_STREAM (imap_stream), msgstream); - gtk_object_unref (GTK_OBJECT (imap_stream)); + camel_object_unref (CAMEL_OBJECT (imap_stream)); f_stream = camel_stream_filter_new_with_stream (msgstream); filter = camel_mime_filter_crlf_new (CAMEL_MIME_FILTER_CRLF_DECODE, CAMEL_MIME_FILTER_CRLF_MODE_CRLF_DOTS); @@ -1005,13 +996,13 @@ imap_get_message (CamelFolder *folder, const gchar *uid, CamelException *ex) camel_stream_filter_remove (f_stream, id); camel_stream_close (CAMEL_STREAM (f_stream)); - gtk_object_unref (GTK_OBJECT (msgstream)); - gtk_object_unref (GTK_OBJECT (f_stream)); + camel_object_unref (CAMEL_OBJECT (msgstream)); + camel_object_unref (CAMEL_OBJECT (f_stream)); /*camel_data_wrapper_set_mime_type (cdw, "text/plain");*/ /*camel_medium_set_content_object (CAMEL_MEDIUM (msg), CAMEL_DATA_WRAPPER (cdw));*/ - /*gtk_object_unref (GTK_OBJECT (cdw));*/ + /*camel_object_unref (CAMEL_OBJECT (cdw));*/ return msg; #endif @@ -1492,6 +1483,13 @@ imap_search_by_expression (CamelFolder *folder, const char *expression, CamelExc return uids; } +static guint32 +imap_get_permanent_flags (CamelFolder *folder, CamelException *ex) +{ + /* return permamnant flags */ + return folder->permanent_flags; +} + static guint32 imap_get_message_flags (CamelFolder *folder, const char *uid) { @@ -1513,7 +1511,8 @@ imap_set_message_flags (CamelFolder *folder, const char *uid, guint32 flags, gui info->flags = (info->flags & ~flags) | (set & flags) | CAMEL_MESSAGE_FOLDER_FLAGGED; - gtk_signal_emit_by_name (GTK_OBJECT (folder), "message_changed", uid); + /*gtk_signal_emit_by_name (GTK_OBJECT (folder), "message_changed", uid);*/ + camel_object_trigger_event (CAMEL_OBJECT (folder), "message_changed", uid); } static gboolean @@ -1525,7 +1524,8 @@ imap_get_message_user_flag (CamelFolder *folder, const char *uid, const char *na static void imap_set_message_user_flag (CamelFolder *folder, const char *uid, const char *name, gboolean value) { - gtk_signal_emit_by_name (GTK_OBJECT (folder), "message_changed", uid); + /*gtk_signal_emit_by_name (GTK_OBJECT (folder), "message_changed", uid);*/ + camel_object_trigger_event (CAMEL_OBJECT (folder), "message_changed", uid); } void @@ -1561,5 +1561,6 @@ camel_imap_folder_changed (CamelFolder *folder, gint recent, CamelException *ex) } } - gtk_signal_emit_by_name (GTK_OBJECT (folder), "folder_changed", 0); + /*gtk_signal_emit_by_name (GTK_OBJECT (folder), "folder_changed", 0);*/ + camel_object_trigger_event (CAMEL_OBJECT (folder), "folder_changed", GINT_TO_POINTER (0)); } diff --git a/camel/providers/imap/camel-imap-folder.h b/camel/providers/imap/camel-imap-folder.h index d87df24905..bd1647c300 100644 --- a/camel/providers/imap/camel-imap-folder.h +++ b/camel/providers/imap/camel-imap-folder.h @@ -33,14 +33,13 @@ extern "C" { #pragma } #endif /* __cplusplus }*/ -#include #include "camel-folder.h" #include #define CAMEL_IMAP_FOLDER_TYPE (camel_imap_folder_get_type ()) -#define CAMEL_IMAP_FOLDER(obj) (GTK_CHECK_CAST((obj), CAMEL_IMAP_FOLDER_TYPE, CamelImapFolder)) -#define CAMEL_IMAP_FOLDER_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_IMAP_FOLDER_TYPE, CamelImapFolderClass)) -#define IS_CAMEL_IMAP_FOLDER(o) (GTK_CHECK_TYPE((o), CAMEL_IMAP_FOLDER_TYPE)) +#define CAMEL_IMAP_FOLDER(obj) (CAMEL_CHECK_CAST((obj), CAMEL_IMAP_FOLDER_TYPE, CamelImapFolder)) +#define CAMEL_IMAP_FOLDER_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_IMAP_FOLDER_TYPE, CamelImapFolderClass)) +#define IS_CAMEL_IMAP_FOLDER(o) (CAMEL_CHECK_TYPE((o), CAMEL_IMAP_FOLDER_TYPE)) typedef struct { CamelFolder parent_object; @@ -68,8 +67,8 @@ CamelFolder *camel_imap_folder_new (CamelStore *parent, char *folder_name, void camel_imap_folder_changed (CamelFolder *folder, gint recent, CamelException *ex); -/* Standard Gtk function */ -GtkType camel_imap_folder_get_type (void); +/* Standard Camel function */ +CamelType camel_imap_folder_get_type (void); #ifdef __cplusplus } diff --git a/camel/providers/imap/camel-imap-store.c b/camel/providers/imap/camel-imap-store.c index 2fc530f357..374107250d 100644 --- a/camel/providers/imap/camel-imap-store.c +++ b/camel/providers/imap/camel-imap-store.c @@ -56,7 +56,7 @@ static CamelServiceClass *service_class = NULL; -static void finalize (GtkObject *object); +static void finalize (CamelObject *object); static gboolean imap_create (CamelFolder *folder, CamelException *ex); static gboolean imap_connect (CamelService *service, CamelException *ex); static gboolean imap_disconnect (CamelService *service, CamelException *ex); @@ -74,18 +74,14 @@ static void camel_imap_store_class_init (CamelImapStoreClass *camel_imap_store_class) { /* virtual method overload */ - GtkObjectClass *object_class = - GTK_OBJECT_CLASS (camel_imap_store_class); CamelServiceClass *camel_service_class = CAMEL_SERVICE_CLASS (camel_imap_store_class); CamelStoreClass *camel_store_class = CAMEL_STORE_CLASS (camel_imap_store_class); - service_class = gtk_type_class (camel_service_get_type ()); + service_class = CAMEL_SERVICE_CLASS(camel_type_get_global_classfuncs (camel_service_get_type ())); /* virtual method overload */ - object_class->finalize = finalize; - camel_service_class->connect = imap_connect; camel_service_class->disconnect = imap_disconnect; camel_service_class->query_auth_types = query_auth_types; @@ -107,37 +103,31 @@ camel_imap_store_init (gpointer object, gpointer klass) CAMEL_SERVICE_URL_ALLOW_PATH); store->folders = g_hash_table_new (g_str_hash, g_str_equal); - CAMEL_IMAP_STORE (store)->dir_sep = NULL; + CAMEL_IMAP_STORE (store)->dir_sep = g_strdup ("/"); /*default*/ CAMEL_IMAP_STORE (store)->current_folder = NULL; CAMEL_IMAP_STORE (store)->timeout_id = 0; } -GtkType +CamelType camel_imap_store_get_type (void) { - static GtkType camel_imap_store_type = 0; - - if (!camel_imap_store_type) { - GtkTypeInfo camel_imap_store_info = - { - "CamelImapStore", - sizeof (CamelImapStore), - sizeof (CamelImapStoreClass), - (GtkClassInitFunc) camel_imap_store_class_init, - (GtkObjectInitFunc) camel_imap_store_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_imap_store_type = gtk_type_unique (CAMEL_STORE_TYPE, &camel_imap_store_info); + static CamelType camel_imap_store_type = CAMEL_INVALID_TYPE; + + if (camel_imap_store_type == CAMEL_INVALID_TYPE) { + camel_imap_store_type = camel_type_register (CAMEL_STORE_TYPE, "CamelImapStore", + sizeof (CamelImapStore), + sizeof (CamelImapStoreClass), + (CamelObjectClassInitFunc) camel_imap_store_class_init, + NULL, + (CamelObjectInitFunc) camel_imap_store_init, + (CamelObjectFinalizeFunc) finalize); } return camel_imap_store_type; } static void -finalize (GtkObject *object) +finalize (CamelObject *object) { CamelException ex; @@ -239,11 +229,13 @@ imap_connect (CamelService *service, CamelException *ex) gboolean authenticated = FALSE; /* FIXME: do we really need this here? */ - if (store->timeout_id) { - gtk_timeout_remove (store->timeout_id); - store->timeout_id = 0; - } - + /* + *if (store->timeout_id) { + * gtk_timeout_remove (store->timeout_id); + * store->timeout_id = 0; + *} + */ + h = camel_service_gethost (service, ex); if (!h) return FALSE; @@ -399,7 +391,10 @@ imap_connect (CamelService *service, CamelException *ex) g_free (result); /* Lets add a timeout so that we can hopefully prevent getting disconnected */ - store->timeout_id = gtk_timeout_add (600000, imap_noop, store); + /* FIXME fast timeout */ + store->timeout_id = camel_session_register_timeout (camel_service_get_session (service), + 10 * 60 * 1000, imap_noop, service); + /*store->timeout_id = gtk_timeout_add (600000, imap_noop, store);*/ return TRUE; } @@ -423,27 +418,28 @@ imap_disconnect (CamelService *service, CamelException *ex) if (!service_class->disconnect (service, ex)) return FALSE; - + if (store->istream) { - gtk_object_unref (GTK_OBJECT (store->istream)); + camel_object_unref (CAMEL_OBJECT (store->istream)); store->istream = NULL; } - + if (store->ostream) { - gtk_object_unref (GTK_OBJECT (store->ostream)); + camel_object_unref (CAMEL_OBJECT (store->ostream)); store->ostream = NULL; } - + g_free (store->dir_sep); store->dir_sep = NULL; - + store->current_folder = NULL; - + if (store->timeout_id) { - gtk_timeout_remove (store->timeout_id); + camel_session_remove_timeout (camel_service_get_session (CAMEL_SERVICE (store)), + store->timeout_id); store->timeout_id = 0; } - + return TRUE; } @@ -466,6 +462,8 @@ imap_folder_exists (CamelFolder *folder) dir_sep = CAMEL_IMAP_STORE (folder->parent_store)->dir_sep; + g_return_val_if_fail (dir_sep, FALSE); + if (url && url->path && *(url->path + 1) && strcmp (folder->full_name, "INBOX")) folder_path = g_strdup_printf ("%s%s%s", url->path + 1, dir_sep, folder->full_name); else @@ -510,6 +508,8 @@ imap_create (CamelFolder *folder, CamelException *ex) /* create the directory for the subfolder */ dir_sep = CAMEL_IMAP_STORE (folder->parent_store)->dir_sep; + g_return_val_if_fail (dir_sep, FALSE); + if (url && url->path && *(url->path + 1) && strcmp (folder->full_name, "INBOX")) folder_path = g_strdup_printf ("%s%s%s", url->path + 1, dir_sep, folder->full_name); else @@ -581,7 +581,7 @@ get_folder (CamelStore *store, const char *folder_name, gboolean create, CamelEx dir_sep = CAMEL_IMAP_STORE (store)->dir_sep; /* if we're trying to get the top-level dir, we really want the namespace */ - if (!strcmp (folder_name, dir_sep)) + if (!dir_sep || !strcmp (folder_name, dir_sep)) folder_path = g_strdup (url->path + 1); else folder_path = g_strdup (folder_name); @@ -599,7 +599,7 @@ get_folder (CamelStore *store, const char *folder_name, gboolean create, CamelEx return new_folder; } else { g_free (folder_path); - gtk_object_unref (GTK_OBJECT (new_folder)); + camel_object_unref (CAMEL_OBJECT (new_folder)); return NULL; } } diff --git a/camel/providers/imap/camel-imap-store.h b/camel/providers/imap/camel-imap-store.h index b8bb19f31c..a860fb84bd 100644 --- a/camel/providers/imap/camel-imap-store.h +++ b/camel/providers/imap/camel-imap-store.h @@ -32,13 +32,12 @@ extern "C" { #pragma } #endif /* __cplusplus }*/ -#include #include "camel-store.h" #define CAMEL_IMAP_STORE_TYPE (camel_imap_store_get_type ()) -#define CAMEL_IMAP_STORE(obj) (GTK_CHECK_CAST((obj), CAMEL_IMAP_STORE_TYPE, CamelImapStore)) -#define CAMEL_IMAP_STORE_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_IMAP_STORE_TYPE, CamelImapStoreClass)) -#define IS_CAMEL_IMAP_STORE(o) (GTK_CHECK_TYPE((o), CAMEL_IMAP_STORE_TYPE)) +#define CAMEL_IMAP_STORE(obj) (CAMEL_CHECK_CAST((obj), CAMEL_IMAP_STORE_TYPE, CamelImapStore)) +#define CAMEL_IMAP_STORE_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_IMAP_STORE_TYPE, CamelImapStoreClass)) +#define IS_CAMEL_IMAP_STORE(o) (CAMEL_CHECK_TYPE((o), CAMEL_IMAP_STORE_TYPE)) typedef enum { IMAP_LEVEL_UNKNOWN, @@ -46,6 +45,7 @@ typedef enum { IMAP_LEVEL_IMAP4REV1 } CamelImapServerLevel; + typedef struct { CamelStore parent_object; @@ -80,8 +80,8 @@ enum { CAMEL_IMAP_OK = 0, CAMEL_IMAP_NO, CAMEL_IMAP_BAD, CAMEL_IMAP_FAIL }; gint camel_imap_command (CamelImapStore *store, CamelFolder *folder, char **ret, char *fmt, ...); gint camel_imap_command_extended (CamelImapStore *store, CamelFolder *folder, char **ret, char *fmt, ...); -/* Standard Gtk function */ -GtkType camel_imap_store_get_type (void); +/* Standard Camel function */ +CamelType camel_imap_store_get_type (void); const gchar *camel_imap_store_get_toplevel_dir (CamelImapStore *store); diff --git a/camel/providers/imap/camel-imap-stream.c b/camel/providers/imap/camel-imap-stream.c index eb0a48a735..7b885437a2 100644 --- a/camel/providers/imap/camel-imap-stream.c +++ b/camel/providers/imap/camel-imap-stream.c @@ -30,30 +30,26 @@ static CamelStreamClass *parent_class = NULL; /* Returns the class for a CamelImapStream */ -#define CIS_CLASS(so) CAMEL_IMAP_STREAM_CLASS (GTK_OBJECT(so)->klass) +#define CIS_CLASS(so) CAMEL_IMAP_STREAM_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static ssize_t stream_read (CamelStream *stream, char *buffer, size_t n); static int stream_reset (CamelStream *stream); static gboolean stream_eos (CamelStream *stream); -static void finalize (GtkObject *object); +static void finalize (CamelObject *object); static void camel_imap_stream_class_init (CamelImapStreamClass *camel_imap_stream_class) { CamelStreamClass *camel_stream_class = CAMEL_STREAM_CLASS (camel_imap_stream_class); - GtkObjectClass *gtk_object_class = - GTK_OBJECT_CLASS (camel_imap_stream_class); - parent_class = gtk_type_class (camel_stream_get_type ()); + parent_class = CAMEL_STREAM_CLASS(camel_type_get_global_classfuncs (camel_stream_get_type ())); /* virtual method overload */ camel_stream_class->read = stream_read; camel_stream_class->reset = stream_reset; camel_stream_class->eos = stream_eos; - - gtk_object_class->finalize = finalize; } static void @@ -65,25 +61,19 @@ camel_imap_stream_init (gpointer object, gpointer klass) imap_stream->cache_ptr = NULL; } -GtkType +CamelType camel_imap_stream_get_type (void) { - static GtkType camel_imap_stream_type = 0; - - if (!camel_imap_stream_type) { - GtkTypeInfo camel_imap_stream_info = - { - "CamelImapStream", - sizeof (CamelImapStream), - sizeof (CamelImapStreamClass), - (GtkClassInitFunc) camel_imap_stream_class_init, - (GtkObjectInitFunc) camel_imap_stream_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_imap_stream_type = gtk_type_unique (camel_stream_get_type (), &camel_imap_stream_info); + static CamelType camel_imap_stream_type = CAMEL_INVALID_TYPE; + + if (camel_imap_stream_type == CAMEL_INVALID_TYPE) { + camel_imap_stream_type = camel_type_register (camel_stream_get_type (), "CamelImapStream", + sizeof (CamelImapStream), + sizeof (CamelImapStreamClass), + (CamelObjectClassInitFunc) camel_imap_stream_class_init, + NULL, + (CamelObjectInitFunc) camel_imap_stream_init, + (CamelObjectFinalizeFunc) finalize); } return camel_imap_stream_type; @@ -94,10 +84,10 @@ camel_imap_stream_new (CamelImapFolder *folder, char *command) { CamelImapStream *imap_stream; - imap_stream = gtk_type_new (camel_imap_stream_get_type ()); + imap_stream = CAMEL_IMAP_STREAM(camel_object_new (camel_imap_stream_get_type ())); imap_stream->folder = folder; - gtk_object_ref (GTK_OBJECT (imap_stream->folder)); + camel_object_ref (CAMEL_OBJECT (imap_stream->folder)); imap_stream->command = g_strdup (command); @@ -105,7 +95,7 @@ camel_imap_stream_new (CamelImapFolder *folder, char *command) } static void -finalize (GtkObject *object) +finalize (CamelObject *object) { CamelImapStream *imap_stream = CAMEL_IMAP_STREAM (object); @@ -113,9 +103,7 @@ finalize (GtkObject *object) g_free (imap_stream->command); if (imap_stream->folder) - gtk_object_unref (GTK_OBJECT (imap_stream->folder)); - - GTK_OBJECT_CLASS (parent_class)->finalize (object); + camel_object_unref (CAMEL_OBJECT (imap_stream->folder)); } static ssize_t @@ -141,13 +129,13 @@ stream_read (CamelStream *stream, char *buffer, size_t n) /* we got an error, dump this stuff */ g_free (result); imap_stream->cache = NULL; - gtk_object_unref (GTK_OBJECT (imap_stream->folder)); + camel_object_unref (CAMEL_OBJECT (imap_stream->folder)); return -1; } /* we don't need the folder anymore... */ - gtk_object_unref (GTK_OBJECT (imap_stream->folder)); + camel_object_unref (CAMEL_OBJECT (imap_stream->folder)); /* parse out the message part */ for (p = result; *p && *p != '{' && *p != '\n'; p++); diff --git a/camel/providers/imap/camel-imap-stream.h b/camel/providers/imap/camel-imap-stream.h index 2a6e2fc723..88881e7c1f 100644 --- a/camel/providers/imap/camel-imap-stream.h +++ b/camel/providers/imap/camel-imap-stream.h @@ -36,9 +36,9 @@ extern "C" { #include #define CAMEL_IMAP_STREAM_TYPE (camel_imap_stream_get_type ()) -#define CAMEL_IMAP_STREAM(obj) (GTK_CHECK_CAST((obj), CAMEL_IMAP_STREAM_TYPE, CamelImapStream)) -#define CAMEL_IMAP_STREAM_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_IMAP_STREAM_TYPE, CamelImapStreamClass)) -#define CAMEL_IS_IMAP_STREAM(o) (GTK_CHECK_TYPE((o), CAMEL_IMAP_STREAM_TYPE)) +#define CAMEL_IMAP_STREAM(obj) (CAMEL_CHECK_CAST((obj), CAMEL_IMAP_STREAM_TYPE, CamelImapStream)) +#define CAMEL_IMAP_STREAM_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_IMAP_STREAM_TYPE, CamelImapStreamClass)) +#define CAMEL_IS_IMAP_STREAM(o) (CAMEL_CHECK_TYPE((o), CAMEL_IMAP_STREAM_TYPE)) typedef struct _CamelImapStream CamelImapStream; typedef struct _CamelImapStreamClass CamelImapStreamClass; @@ -58,8 +58,8 @@ struct _CamelImapStreamClass { /* Virtual methods */ }; -/* Standard Gtk function */ -GtkType camel_imap_stream_get_type (void); +/* Standard Camel function */ +CamelType camel_imap_stream_get_type (void); /* public methods */ CamelStream *camel_imap_stream_new (CamelImapFolder *folder, char *command); diff --git a/camel/providers/mbox/camel-mbox-folder.c b/camel/providers/mbox/camel-mbox-folder.c index 68e0f5fd28..28defb7b87 100644 --- a/camel/providers/mbox/camel-mbox-folder.c +++ b/camel/providers/mbox/camel-mbox-folder.c @@ -48,47 +48,50 @@ #define d(x) -static CamelFolderClass *parent_class = NULL; +static CamelFolderClass *parent_class=NULL; /* Returns the class for a CamelMboxFolder */ -#define CMBOXF_CLASS(so) CAMEL_MBOX_FOLDER_CLASS (GTK_OBJECT(so)->klass) -#define CF_CLASS(so) CAMEL_FOLDER_CLASS (GTK_OBJECT(so)->klass) -#define CMBOXS_CLASS(so) CAMEL_STORE_CLASS (GTK_OBJECT(so)->klass) +#define CMBOXF_CLASS(so) CAMEL_MBOX_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CF_CLASS(so) CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CMBOXS_CLASS(so) CAMEL_STORE_CLASS (CAMEL_OBJECT_GET_CLASS(so)) -static void mbox_init(CamelFolder * folder, CamelStore * parent_store, - CamelFolder * parent_folder, const gchar * name, - gchar * separator, gboolean path_begins_with_sep, CamelException * ex); -static void mbox_sync(CamelFolder * folder, gboolean expunge, CamelException * ex); -static gint mbox_get_message_count(CamelFolder * folder); -static gint mbox_get_unread_message_count(CamelFolder * folder); -static void mbox_append_message(CamelFolder * folder, CamelMimeMessage * message, const CamelMessageInfo *info, CamelException * ex); -static GPtrArray *mbox_get_uids(CamelFolder * folder); -static GPtrArray *mbox_get_subfolder_names(CamelFolder * folder); -static GPtrArray *mbox_get_summary(CamelFolder * folder); -static CamelMimeMessage *mbox_get_message(CamelFolder * folder, const gchar * uid, CamelException * ex); +static void mbox_init (CamelFolder *folder, CamelStore *parent_store, + CamelFolder *parent_folder, const gchar *name, + gchar *separator, gboolean path_begins_with_sep, + CamelException *ex); -static void mbox_expunge(CamelFolder * folder, CamelException * ex); +static void mbox_sync (CamelFolder *folder, gboolean expunge, CamelException *ex); +static gint mbox_get_message_count (CamelFolder *folder); +static gint mbox_get_unread_message_count (CamelFolder *folder); +static void mbox_append_message (CamelFolder *folder, CamelMimeMessage *message, const CamelMessageInfo *info, CamelException *ex); +static GPtrArray *mbox_get_uids (CamelFolder *folder); +static GPtrArray *mbox_get_subfolder_names (CamelFolder *folder); +static GPtrArray *mbox_get_summary (CamelFolder *folder); +static CamelMimeMessage *mbox_get_message (CamelFolder *folder, const gchar *uid, CamelException *ex); -static const CamelMessageInfo *mbox_get_message_info(CamelFolder * folder, const char *uid); +static void mbox_expunge (CamelFolder *folder, CamelException *ex); -static GPtrArray *mbox_search_by_expression(CamelFolder * folder, const char *expression, CamelException * ex); +static const CamelMessageInfo *mbox_get_message_info (CamelFolder *folder, const char *uid); + +static GPtrArray *mbox_search_by_expression(CamelFolder *folder, const char *expression, CamelException *ex); static void mbox_search_free(CamelFolder * folder, GPtrArray * result); -static guint32 mbox_get_message_flags(CamelFolder * folder, const char *uid); -static void mbox_set_message_flags(CamelFolder * folder, const char *uid, guint32 flags, guint32 set); -static gboolean mbox_get_message_user_flag(CamelFolder * folder, const char *uid, const char *name); -static void mbox_set_message_user_flag(CamelFolder * folder, const char *uid, const char *name, gboolean value); +static guint32 mbox_get_message_flags (CamelFolder *folder, const char *uid); +static void mbox_set_message_flags (CamelFolder *folder, const char *uid, guint32 flags, guint32 set); +static gboolean mbox_get_message_user_flag (CamelFolder *folder, const char *uid, const char *name); +static void mbox_set_message_user_flag (CamelFolder *folder, const char *uid, const char *name, gboolean value); -static void mbox_finalize(GtkObject * object); -static void camel_mbox_folder_class_init(CamelMboxFolderClass * camel_mbox_folder_class) -{ - CamelFolderClass *camel_folder_class = CAMEL_FOLDER_CLASS(camel_mbox_folder_class); - GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS(camel_folder_class); +static void mbox_finalize (CamelObject *object); - parent_class = gtk_type_class(camel_folder_get_type()); +static void +camel_mbox_folder_class_init (CamelMboxFolderClass *camel_mbox_folder_class) +{ + CamelFolderClass *camel_folder_class = CAMEL_FOLDER_CLASS (camel_mbox_folder_class); + parent_class = CAMEL_FOLDER_CLASS(camel_type_get_global_classfuncs (camel_folder_get_type ())); + /* virtual method definition */ /* virtual method overload */ @@ -116,59 +119,53 @@ static void camel_mbox_folder_class_init(CamelMboxFolderClass * camel_mbox_folde camel_folder_class->set_message_flags = mbox_set_message_flags; camel_folder_class->get_message_user_flag = mbox_get_message_user_flag; camel_folder_class->set_message_user_flag = mbox_set_message_user_flag; - - gtk_object_class->finalize = mbox_finalize; - } -static void mbox_finalize(GtkObject * object) +static void +mbox_finalize (CamelObject *object) { - CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER(object); + CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER (object); - g_free(mbox_folder->folder_file_path); - g_free(mbox_folder->summary_file_path); - g_free(mbox_folder->folder_dir_path); - g_free(mbox_folder->index_file_path); + g_free (mbox_folder->folder_file_path); + g_free (mbox_folder->summary_file_path); + g_free (mbox_folder->folder_dir_path); + g_free (mbox_folder->index_file_path); - GTK_OBJECT_CLASS(parent_class)->finalize(object); } -GtkType camel_mbox_folder_get_type(void) +CamelType +camel_mbox_folder_get_type (void) { - static GtkType camel_mbox_folder_type = 0; - - if (!camel_mbox_folder_type) { - GtkTypeInfo camel_mbox_folder_info = { - "CamelMboxFolder", - sizeof(CamelMboxFolder), - sizeof(CamelMboxFolderClass), - (GtkClassInitFunc) camel_mbox_folder_class_init, - (GtkObjectInitFunc) NULL, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_mbox_folder_type = gtk_type_unique(CAMEL_FOLDER_TYPE, &camel_mbox_folder_info); + static CamelType camel_mbox_folder_type = CAMEL_INVALID_TYPE; + + if (camel_mbox_folder_type == CAMEL_INVALID_TYPE) { + camel_mbox_folder_type = camel_type_register (CAMEL_FOLDER_TYPE, "CamelMboxFolder", + sizeof (CamelMboxFolder), + sizeof (CamelMboxFolderClass), + (CamelObjectClassInitFunc) camel_mbox_folder_class_init, + NULL, + (CamelObjectInitFunc) NULL, + (CamelObjectFinalizeFunc) mbox_finalize); } - + return camel_mbox_folder_type; } -static void -mbox_init(CamelFolder * folder, CamelStore * parent_store, - CamelFolder * parent_folder, const gchar * name, gchar * separator, - gboolean path_begins_with_sep, CamelException * ex) +static void +mbox_init (CamelFolder *folder, CamelStore *parent_store, + CamelFolder *parent_folder, const gchar *name, gchar *separator, + gboolean path_begins_with_sep, CamelException *ex) { - CamelMboxFolder *mbox_folder = (CamelMboxFolder *) folder; + CamelMboxFolder *mbox_folder = (CamelMboxFolder *)folder; const gchar *root_dir_path; gchar *real_name; int forceindex; struct stat st; /* call parent method */ - parent_class->init(folder, parent_store, parent_folder, name, separator, path_begins_with_sep, ex); - if (camel_exception_get_id(ex)) + parent_class->init (folder, parent_store, parent_folder, + name, separator, path_begins_with_sep, ex); + if (camel_exception_get_id (ex)) return; /* we assume that the parent init @@ -179,108 +176,120 @@ mbox_init(CamelFolder * folder, CamelStore * parent_store, folder->has_search_capability = TRUE; folder->permanent_flags = CAMEL_MESSAGE_ANSWERED | - CAMEL_MESSAGE_DELETED | - CAMEL_MESSAGE_DRAFT | CAMEL_MESSAGE_FLAGGED | CAMEL_MESSAGE_SEEN | CAMEL_MESSAGE_USER; + CAMEL_MESSAGE_DELETED | + CAMEL_MESSAGE_DRAFT | + CAMEL_MESSAGE_FLAGGED | + CAMEL_MESSAGE_SEEN | + CAMEL_MESSAGE_USER; /* FIXME: we don't actually preserve user flags right now. */ - mbox_folder->summary = NULL; - mbox_folder->search = NULL; + mbox_folder->summary = NULL; + mbox_folder->search = NULL; /* now set the name info */ - g_free(mbox_folder->folder_file_path); - g_free(mbox_folder->folder_dir_path); - g_free(mbox_folder->index_file_path); + g_free (mbox_folder->folder_file_path); + g_free (mbox_folder->folder_dir_path); + g_free (mbox_folder->index_file_path); - root_dir_path = camel_mbox_store_get_toplevel_dir(CAMEL_MBOX_STORE(folder->parent_store)); + root_dir_path = camel_mbox_store_get_toplevel_dir (CAMEL_MBOX_STORE(folder->parent_store)); - real_name = g_basename(folder->full_name); - mbox_folder->folder_file_path = g_strdup_printf("%s/%s", root_dir_path, real_name); - mbox_folder->summary_file_path = g_strdup_printf("%s/%s-ev-summary", root_dir_path, real_name); - mbox_folder->folder_dir_path = g_strdup_printf("%s/%s.sdb", root_dir_path, real_name); - mbox_folder->index_file_path = g_strdup_printf("%s/%s.ibex", root_dir_path, real_name); + real_name = g_basename (folder->full_name); + mbox_folder->folder_file_path = g_strdup_printf ("%s/%s", root_dir_path, real_name); + mbox_folder->summary_file_path = g_strdup_printf ("%s/%s-ev-summary", root_dir_path, real_name); + mbox_folder->folder_dir_path = g_strdup_printf ("%s/%s.sdb", root_dir_path, real_name); + mbox_folder->index_file_path = g_strdup_printf ("%s/%s.ibex", root_dir_path, real_name); /* if we have no index file, force it */ forceindex = stat(mbox_folder->index_file_path, &st) == -1; - mbox_folder->index = ibex_open(mbox_folder->index_file_path, O_CREAT | O_RDWR, 0600); + mbox_folder->index = ibex_open(mbox_folder->index_file_path, O_CREAT|O_RDWR, 0600); if (mbox_folder->index == NULL) { /* yes, this isn't fatal at all */ - g_warning("Could not open/create index file: %s: indexing not performed", strerror(errno)); + g_warning("Could not open/create index file: %s: indexing not performed", + strerror(errno)); } /* no summary (disk or memory), and we're proverbially screwed */ - mbox_folder->summary = camel_mbox_summary_new(mbox_folder->summary_file_path, - mbox_folder->folder_file_path, mbox_folder->index); - if (mbox_folder->summary == NULL || camel_mbox_summary_load(mbox_folder->summary, forceindex) == -1) { - camel_exception_set(ex, CAMEL_EXCEPTION_FOLDER_INVALID, /* FIXME: right error code */ - "Could not create summary"); + mbox_folder->summary = camel_mbox_summary_new (mbox_folder->summary_file_path, + mbox_folder->folder_file_path, mbox_folder->index); + if (mbox_folder->summary == NULL + || camel_mbox_summary_load(mbox_folder->summary, forceindex) == -1) { + camel_exception_set (ex, + CAMEL_EXCEPTION_FOLDER_INVALID, /* FIXME: right error code */ + "Could not create summary"); return; } } -static void mbox_sync(CamelFolder * folder, gboolean expunge, CamelException * ex) +static void +mbox_sync (CamelFolder *folder, gboolean expunge, CamelException *ex) { - CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER(folder); + CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER (folder); if (expunge) - mbox_expunge(folder, ex); + mbox_expunge (folder, ex); else - camel_mbox_summary_sync(mbox_folder->summary, FALSE, ex); + camel_mbox_summary_sync (mbox_folder->summary, FALSE, ex); /* save index */ if (mbox_folder->index) ibex_save(mbox_folder->index); if (mbox_folder->summary) - camel_folder_summary_save(CAMEL_FOLDER_SUMMARY(mbox_folder->summary)); + camel_folder_summary_save (CAMEL_FOLDER_SUMMARY (mbox_folder->summary)); } -static void mbox_expunge(CamelFolder * folder, CamelException * ex) +static void +mbox_expunge (CamelFolder *folder, CamelException *ex) { - CamelMboxFolder *mbox = CAMEL_MBOX_FOLDER(folder); + CamelMboxFolder *mbox = CAMEL_MBOX_FOLDER (folder); - camel_mbox_summary_sync(mbox->summary, TRUE, ex); + camel_mbox_summary_sync (mbox->summary, TRUE, ex); /* TODO: check it actually changed */ - gtk_signal_emit_by_name(GTK_OBJECT(folder), "folder_changed", 0); + camel_object_trigger_event (CAMEL_OBJECT (folder), "folder_changed", GINT_TO_POINTER(0)); } -static gint mbox_get_message_count(CamelFolder * folder) +static gint +mbox_get_message_count (CamelFolder *folder) { - CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER(folder); - - g_return_val_if_fail(mbox_folder->summary != NULL, -1); + CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER (folder); - return camel_folder_summary_count(CAMEL_FOLDER_SUMMARY(mbox_folder->summary)); + g_return_val_if_fail (mbox_folder->summary != NULL, -1); + + return camel_folder_summary_count (CAMEL_FOLDER_SUMMARY (mbox_folder->summary)); } -static gint mbox_get_unread_message_count(CamelFolder * folder) +static gint +mbox_get_unread_message_count (CamelFolder *folder) { - CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER(folder); + CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER (folder); CamelMessageInfo *info; GPtrArray *infolist; gint i, max, count = 0; - g_return_val_if_fail(mbox_folder->summary != NULL, -1); + g_return_val_if_fail (mbox_folder->summary != NULL, -1); - max = camel_folder_summary_count(CAMEL_FOLDER_SUMMARY(mbox_folder->summary)); + max = camel_folder_summary_count (CAMEL_FOLDER_SUMMARY (mbox_folder->summary)); if (max == -1) return -1; - infolist = mbox_get_summary(folder); - + infolist = mbox_get_summary (folder); + for (i = 0; i < infolist->len; i++) { - info = (CamelMessageInfo *) g_ptr_array_index(infolist, i); + info = (CamelMessageInfo *) g_ptr_array_index (infolist, i); if (!(info->flags & CAMEL_MESSAGE_SEEN)) count++; } - + return count; } /* FIXME: this may need some tweaking for performance? */ -static void mbox_append_message(CamelFolder * folder, CamelMimeMessage * message, const CamelMessageInfo *info, CamelException * ex) +static void +mbox_append_message (CamelFolder *folder, CamelMimeMessage *message, + const CamelMessageInfo *info, CamelException *ex) { - CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER(folder); + CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER (folder); CamelStream *output_stream = NULL, *filter_stream = NULL; CamelMimeFilter *filter_from = NULL; CamelMessageInfo *newinfo; @@ -290,135 +299,147 @@ static void mbox_append_message(CamelFolder * folder, CamelMimeMessage * message guint32 uid; char *fromline = NULL; - if (stat(mbox_folder->folder_file_path, &st) != 0) + if (stat (mbox_folder->folder_file_path, &st) != 0) goto fail; - output_stream = camel_stream_fs_new_with_name(mbox_folder->folder_file_path, O_RDWR, 0600); + output_stream = camel_stream_fs_new_with_name (mbox_folder->folder_file_path, O_RDWR, 0600); if (output_stream == NULL) goto fail; if (st.st_size) { - seek = camel_seekable_stream_seek((CamelSeekableStream *) output_stream, st.st_size - 1, SEEK_SET); + seek = camel_seekable_stream_seek ((CamelSeekableStream *)output_stream, st.st_size - 1, SEEK_SET); if (++seek != st.st_size) goto fail; /* If the mbox doesn't end with a newline, fix that. */ - if (camel_stream_read(output_stream, &last, 1) != 1) + if (camel_stream_read (output_stream, &last, 1) != 1) goto fail; if (last != '\n') - camel_stream_write(output_stream, "\n", 1); + camel_stream_write (output_stream, "\n", 1); } else seek = 0; /* assign a new x-evolution header/uid */ - camel_medium_remove_header(CAMEL_MEDIUM(message), "X-Evolution"); - uid = camel_folder_summary_next_uid(CAMEL_FOLDER_SUMMARY(mbox_folder->summary)); + camel_medium_remove_header (CAMEL_MEDIUM (message), "X-Evolution"); + uid = camel_folder_summary_next_uid (CAMEL_FOLDER_SUMMARY (mbox_folder->summary)); /* important that the header matches exactly 00000000-0000 */ - xev = g_strdup_printf("%08x-%04x", uid, info?info->flags&0xffff:0); - camel_medium_add_header(CAMEL_MEDIUM(message), "X-Evolution", xev); - g_free(xev); + if (info) + xev = g_strdup_printf ("%08x-%04x", uid, info->flags & 0xFFFF); + else + xev = g_strdup_printf ("%08x-%04x", uid, 0); + camel_medium_add_header (CAMEL_MEDIUM (message), "X-Evolution", xev); + g_free (xev); /* we must write this to the non-filtered stream ... */ - fromline = camel_mbox_summary_build_from(CAMEL_MIME_PART(message)->headers); - if (camel_stream_write_string(output_stream, fromline) == -1) + fromline = camel_mbox_summary_build_from (CAMEL_MIME_PART (message)->headers); + if (camel_stream_write_string (output_stream, fromline) == -1) goto fail; /* and write the content to the filtering stream, that translated '\nFrom' into '\n>From' */ - filter_stream = (CamelStream *) camel_stream_filter_new_with_stream(output_stream); - filter_from = (CamelMimeFilter *) camel_mime_filter_from_new(); - camel_stream_filter_add((CamelStreamFilter *) filter_stream, filter_from); - if (camel_data_wrapper_write_to_stream(CAMEL_DATA_WRAPPER(message), filter_stream) == -1) + filter_stream = (CamelStream *)camel_stream_filter_new_with_stream (output_stream); + filter_from = (CamelMimeFilter *)camel_mime_filter_from_new (); + camel_stream_filter_add ((CamelStreamFilter *)filter_stream, filter_from); + if (camel_data_wrapper_write_to_stream (CAMEL_DATA_WRAPPER (message), filter_stream) == -1) goto fail; - if (camel_stream_close(filter_stream) == -1) + if (camel_stream_close (filter_stream) == -1) goto fail; /* filter stream ref's the output stream itself, so we need to unref it too */ - gtk_object_unref(GTK_OBJECT(filter_from)); - gtk_object_unref(GTK_OBJECT(filter_stream)); - gtk_object_unref(GTK_OBJECT(output_stream)); - g_free(fromline); + camel_object_unref (CAMEL_OBJECT (filter_from)); + camel_object_unref (CAMEL_OBJECT (filter_stream)); + camel_object_unref (CAMEL_OBJECT (output_stream)); + g_free (fromline); /* force a summary update - will only update from the new position, if it can */ - if (camel_mbox_summary_update(mbox_folder->summary, seek) == 0) { + if (camel_mbox_summary_update (mbox_folder->summary, seek) == 0) { char uidstr[16]; - sprintf(uidstr, "%u", uid); - if (info - && (newinfo = camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(mbox_folder->summary), uidstr))) { + + sprintf (uidstr, "%u", uid); + newinfo = camel_folder_summary_uid (CAMEL_FOLDER_SUMMARY (mbox_folder->summary), uidstr); + + if (info && newinfo) { CamelFlag *flag = info->user_flags; CamelTag *tag = info->user_tags; + while (flag) { - camel_flag_set(&newinfo->user_flags, flag->name, TRUE); + camel_flag_set (&(newinfo->user_flags), flag->name, TRUE); flag = flag->next; } + while (tag) { - camel_tag_set(&newinfo->user_tags, tag->name, tag->value); + camel_tag_set (&(newinfo->user_tags), tag->name, tag->value); tag = tag->next; } } - gtk_signal_emit_by_name(GTK_OBJECT(folder), "folder_changed", 0); + camel_object_trigger_event (CAMEL_OBJECT (folder), "folder_changed", GINT_TO_POINTER(0)); } + return; - fail: - if (camel_exception_is_set(ex)) { - camel_exception_setv(ex, camel_exception_get_id(ex), - "Cannot append message to mbox file: %s", camel_exception_get_description(ex)); +fail: + if (camel_exception_is_set (ex)) { + camel_exception_setv (ex, camel_exception_get_id (ex), + "Cannot append message to mbox file: %s", + camel_exception_get_description (ex)); } else { - camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, - "Cannot append message to mbox file: %s", g_strerror(errno)); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Cannot append message to mbox file: %s", + g_strerror (errno)); } if (filter_stream) { - /*camel_stream_close (filter_stream); */ - gtk_object_unref(GTK_OBJECT(filter_stream)); + /*camel_stream_close (filter_stream);*/ + camel_object_unref (CAMEL_OBJECT (filter_stream)); } if (output_stream) - gtk_object_unref(GTK_OBJECT(output_stream)); + camel_object_unref (CAMEL_OBJECT (output_stream)); if (filter_from) - gtk_object_unref(GTK_OBJECT(filter_from)); - - g_free(fromline); + camel_object_unref (CAMEL_OBJECT (filter_from)); + + g_free (fromline); /* make sure the file isn't munged by us */ if (seek != -1) { - int fd = open(mbox_folder->folder_file_path, O_WRONLY, 0600); - + int fd = open (mbox_folder->folder_file_path, O_WRONLY, 0600); + if (fd != -1) { - ftruncate(fd, st.st_size); + ftruncate (fd, st.st_size); close(fd); } } } -static GPtrArray *mbox_get_uids(CamelFolder * folder) +static GPtrArray * +mbox_get_uids (CamelFolder *folder) { GPtrArray *array; - CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER(folder); + CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER (folder); int i, count; - count = camel_folder_summary_count(CAMEL_FOLDER_SUMMARY(mbox_folder->summary)); - array = g_ptr_array_new(); - g_ptr_array_set_size(array, count); + count = camel_folder_summary_count (CAMEL_FOLDER_SUMMARY (mbox_folder->summary)); + array = g_ptr_array_new (); + g_ptr_array_set_size (array, count); for (i = 0; i < count; i++) { - CamelMboxMessageInfo *info = - (CamelMboxMessageInfo *) camel_folder_summary_index(CAMEL_FOLDER_SUMMARY(mbox_folder->summary), i); - - array->pdata[i] = g_strdup(info->info.uid); + CamelMboxMessageInfo *info = (CamelMboxMessageInfo *) camel_folder_summary_index ( + CAMEL_FOLDER_SUMMARY (mbox_folder->summary), i); + array->pdata[i] = g_strdup (info->info.uid); } - + return array; } -static GPtrArray *mbox_get_subfolder_names(CamelFolder * folder) +static GPtrArray * +mbox_get_subfolder_names (CamelFolder *folder) { /* No subfolders. */ - return g_ptr_array_new(); + return g_ptr_array_new (); } -static CamelMimeMessage *mbox_get_message(CamelFolder * folder, const gchar * uid, CamelException * ex) +static CamelMimeMessage * +mbox_get_message (CamelFolder *folder, const gchar *uid, CamelException *ex) { - CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER(folder); + CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER (folder); CamelStream *message_stream = NULL; CamelMimeMessage *message = NULL; CamelMboxMessageInfo *info; @@ -435,142 +456,156 @@ static CamelMimeMessage *mbox_get_message(CamelFolder * folder, const gchar * ui } /* if this has no content, its an error in the library */ - g_assert(info->info.content); - g_assert(info->frompos != -1); + g_assert (info->info.content); + g_assert (info->frompos != -1); /* where we read from */ - message_stream = camel_stream_fs_new_with_name(mbox_folder->folder_file_path, O_RDONLY, 0); + message_stream = camel_stream_fs_new_with_name (mbox_folder->folder_file_path, O_RDONLY, 0); if (message_stream == NULL) goto fail; /* we use a parser to verify the message is correct, and in the correct position */ - parser = camel_mime_parser_new(); - camel_mime_parser_init_with_stream(parser, message_stream); - gtk_object_unref(GTK_OBJECT(message_stream)); - camel_mime_parser_scan_from(parser, TRUE); - - camel_mime_parser_seek(parser, info->frompos, SEEK_SET); - if (camel_mime_parser_step(parser, &buffer, &len) != HSCAN_FROM) { - g_warning("File appears truncated"); + parser = camel_mime_parser_new (); + camel_mime_parser_init_with_stream (parser, message_stream); + camel_object_unref (CAMEL_OBJECT (message_stream)); + camel_mime_parser_scan_from (parser, TRUE); + + camel_mime_parser_seek (parser, info->frompos, SEEK_SET); + if (camel_mime_parser_step (parser, &buffer, &len) != HSCAN_FROM) { + g_warning ("File appears truncated"); goto fail; } - if (camel_mime_parser_tell_start_from(parser) != info->frompos) { - g_warning("Summary doesn't match the folder contents! eek!\n" - " expecting offset %ld got %ld", (long int)info->frompos, - (long int)camel_mime_parser_tell_start_from(parser)); + if (camel_mime_parser_tell_start_from (parser) != info->frompos) { + g_warning ("Summary doesn't match the folder contents! eek!\n" + " expecting offset %ld got %ld", (long int)info->frompos, + (long int)camel_mime_parser_tell_start_from (parser)); errno = EINVAL; goto fail; } - message = camel_mime_message_new(); - if (camel_mime_part_construct_from_parser(CAMEL_MIME_PART(message), parser) == -1) { - g_warning("Construction failed"); + message = camel_mime_message_new (); + if (camel_mime_part_construct_from_parser (CAMEL_MIME_PART (message), parser) == -1) { + g_warning ("Construction failed"); goto fail; } - gtk_object_unref(GTK_OBJECT(parser)); + camel_object_unref (CAMEL_OBJECT (parser)); return message; - fail: - camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID, "Cannot get message: %s", g_strerror(errno)); +fail: + camel_exception_setv (ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID, + "Cannot get message: %s", + g_strerror(errno)); if (parser) - gtk_object_unref(GTK_OBJECT(parser)); + camel_object_unref (CAMEL_OBJECT (parser)); if (message) - gtk_object_unref(GTK_OBJECT(message)); + camel_object_unref (CAMEL_OBJECT (message)); return NULL; } -GPtrArray *mbox_get_summary(CamelFolder * folder) +GPtrArray * +mbox_get_summary (CamelFolder *folder) { - CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER(folder); + CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER (folder); - return CAMEL_FOLDER_SUMMARY(mbox_folder->summary)->messages; + return CAMEL_FOLDER_SUMMARY (mbox_folder->summary)->messages; } /* get a single message info, by uid */ -static const CamelMessageInfo *mbox_get_message_info(CamelFolder * folder, const char *uid) +static const CamelMessageInfo * +mbox_get_message_info (CamelFolder *folder, const char *uid) { - CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER(folder); + CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER (folder); - return camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(mbox_folder->summary), uid); + return camel_folder_summary_uid (CAMEL_FOLDER_SUMMARY (mbox_folder->summary), uid); } -static GPtrArray *mbox_search_by_expression(CamelFolder * folder, const char *expression, CamelException * ex) +static GPtrArray * +mbox_search_by_expression (CamelFolder *folder, const char *expression, CamelException *ex) { - CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER(folder); + CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER (folder); if (mbox_folder->search == NULL) { - mbox_folder->search = camel_folder_search_new(); + mbox_folder->search = camel_folder_search_new (); } - camel_folder_search_set_folder(mbox_folder->search, folder); + camel_folder_search_set_folder (mbox_folder->search, folder); if (mbox_folder->summary) { /* FIXME: dont access summary array directly? */ - camel_folder_search_set_summary(mbox_folder->search, - CAMEL_FOLDER_SUMMARY(mbox_folder->summary)->messages); + camel_folder_search_set_summary (mbox_folder->search, + CAMEL_FOLDER_SUMMARY (mbox_folder->summary)->messages); } + + camel_folder_search_set_body_index (mbox_folder->search, mbox_folder->index); - camel_folder_search_set_body_index(mbox_folder->search, mbox_folder->index); - - return camel_folder_search_execute_expression(mbox_folder->search, expression, ex); + return camel_folder_search_execute_expression (mbox_folder->search, expression, ex); } -static void mbox_search_free(CamelFolder * folder, GPtrArray * result) +static void +mbox_search_free(CamelFolder * folder, GPtrArray * result) { CamelMboxFolder *mbox_folder = CAMEL_MBOX_FOLDER(folder); camel_folder_search_free_result(mbox_folder->search, result); } -static guint32 mbox_get_message_flags(CamelFolder * folder, const char *uid) +static guint32 +mbox_get_message_flags (CamelFolder *folder, const char *uid) { CamelMessageInfo *info; - CamelMboxFolder *mf = CAMEL_MBOX_FOLDER(folder); + CamelMboxFolder *mf = CAMEL_MBOX_FOLDER (folder); - info = camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(mf->summary), uid); - g_return_val_if_fail(info != NULL, 0); + info = camel_folder_summary_uid (CAMEL_FOLDER_SUMMARY (mf->summary), uid); + g_return_val_if_fail (info != NULL, 0); return info->flags; } -static void mbox_set_message_flags(CamelFolder * folder, const char *uid, guint32 flags, guint32 set) +static void +mbox_set_message_flags (CamelFolder *folder, const char *uid, guint32 flags, + guint32 set) { CamelMessageInfo *info; - CamelMboxFolder *mf = CAMEL_MBOX_FOLDER(folder); + CamelMboxFolder *mf = CAMEL_MBOX_FOLDER (folder); - info = camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(mf->summary), uid); - g_return_if_fail(info != NULL); + info = camel_folder_summary_uid (CAMEL_FOLDER_SUMMARY (mf->summary), uid); + g_return_if_fail (info != NULL); - info->flags = (info->flags & ~flags) | (set & flags) | CAMEL_MESSAGE_FOLDER_FLAGGED; - camel_folder_summary_touch(CAMEL_FOLDER_SUMMARY(mf->summary)); + info->flags = (info->flags & ~flags) | (set & flags) | + CAMEL_MESSAGE_FOLDER_FLAGGED; + camel_folder_summary_touch (CAMEL_FOLDER_SUMMARY (mf->summary)); - gtk_signal_emit_by_name(GTK_OBJECT(folder), "message_changed", uid); + camel_object_trigger_event (CAMEL_OBJECT (folder), "message_changed", uid); } -static gboolean mbox_get_message_user_flag(CamelFolder * folder, const char *uid, const char *name) +static gboolean +mbox_get_message_user_flag (CamelFolder *folder, const char *uid, + const char *name) { CamelMessageInfo *info; - CamelMboxFolder *mf = CAMEL_MBOX_FOLDER(folder); + CamelMboxFolder *mf = CAMEL_MBOX_FOLDER (folder); - info = camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(mf->summary), uid); - g_return_val_if_fail(info != NULL, FALSE); + info = camel_folder_summary_uid (CAMEL_FOLDER_SUMMARY (mf->summary), uid); + g_return_val_if_fail (info != NULL, FALSE); - return camel_flag_get(&info->user_flags, name); + return camel_flag_get (&info->user_flags, name); } -static void mbox_set_message_user_flag(CamelFolder * folder, const char *uid, const char *name, gboolean value) +static void +mbox_set_message_user_flag (CamelFolder *folder, const char *uid, + const char *name, gboolean value) { CamelMessageInfo *info; - CamelMboxFolder *mf = CAMEL_MBOX_FOLDER(folder); + CamelMboxFolder *mf = CAMEL_MBOX_FOLDER (folder); - info = camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(mf->summary), uid); - g_return_if_fail(info != NULL); + info = camel_folder_summary_uid (CAMEL_FOLDER_SUMMARY (mf->summary), uid); + g_return_if_fail (info != NULL); - camel_flag_set(&info->user_flags, name, value); + camel_flag_set (&info->user_flags, name, value); info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED; - camel_folder_summary_touch(CAMEL_FOLDER_SUMMARY(mf->summary)); - gtk_signal_emit_by_name(GTK_OBJECT(folder), "message_changed", uid); + camel_folder_summary_touch (CAMEL_FOLDER_SUMMARY (mf->summary)); + camel_object_trigger_event (CAMEL_OBJECT (folder), "message_changed", uid); } diff --git a/camel/providers/mbox/camel-mbox-folder.h b/camel/providers/mbox/camel-mbox-folder.h index d7dc361f14..7c5558f362 100644 --- a/camel/providers/mbox/camel-mbox-folder.h +++ b/camel/providers/mbox/camel-mbox-folder.h @@ -33,7 +33,6 @@ extern "C" { #pragma } #endif /* __cplusplus }*/ -#include #include #include #include @@ -42,9 +41,9 @@ extern "C" { /* #include "camel-store.h" */ #define CAMEL_MBOX_FOLDER_TYPE (camel_mbox_folder_get_type ()) -#define CAMEL_MBOX_FOLDER(obj) (GTK_CHECK_CAST((obj), CAMEL_MBOX_FOLDER_TYPE, CamelMboxFolder)) -#define CAMEL_MBOX_FOLDER_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_MBOX_FOLDER_TYPE, CamelMboxFolderClass)) -#define IS_CAMEL_MBOX_FOLDER(o) (GTK_CHECK_TYPE((o), CAMEL_MBOX_FOLDER_TYPE)) +#define CAMEL_MBOX_FOLDER(obj) (CAMEL_CHECK_CAST((obj), CAMEL_MBOX_FOLDER_TYPE, CamelMboxFolder)) +#define CAMEL_MBOX_FOLDER_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_MBOX_FOLDER_TYPE, CamelMboxFolderClass)) +#define IS_CAMEL_MBOX_FOLDER(o) (CAMEL_CHECK_TYPE((o), CAMEL_MBOX_FOLDER_TYPE)) typedef struct { CamelFolder parent_object; @@ -71,8 +70,8 @@ typedef struct { /* public methods */ -/* Standard Gtk function */ -GtkType camel_mbox_folder_get_type (void); +/* Standard Camel function */ +CamelType camel_mbox_folder_get_type (void); #ifdef __cplusplus } diff --git a/camel/providers/mbox/camel-mbox-store.c b/camel/providers/mbox/camel-mbox-store.c index 475fbd1352..e90c90275e 100644 --- a/camel/providers/mbox/camel-mbox-store.c +++ b/camel/providers/mbox/camel-mbox-store.c @@ -35,9 +35,9 @@ #include "camel-url.h" /* Returns the class for a CamelMboxStore */ -#define CMBOXS_CLASS(so) CAMEL_MBOX_STORE_CLASS (GTK_OBJECT(so)->klass) -#define CF_CLASS(so) CAMEL_FOLDER_CLASS (GTK_OBJECT(so)->klass) -#define CMBOXF_CLASS(so) CAMEL_MBOX_FOLDER_CLASS (GTK_OBJECT(so)->klass) +#define CMBOXS_CLASS(so) CAMEL_MBOX_STORE_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CF_CLASS(so) CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CMBOXF_CLASS(so) CAMEL_MBOX_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static char *get_name (CamelService *service, gboolean brief); static CamelFolder *get_folder (CamelStore *store, const char *folder_name, @@ -75,25 +75,19 @@ camel_mbox_store_init (gpointer object, gpointer klass) store->folders = g_hash_table_new (g_str_hash, g_str_equal); } -GtkType +CamelType camel_mbox_store_get_type (void) { - static GtkType camel_mbox_store_type = 0; + static CamelType camel_mbox_store_type = CAMEL_INVALID_TYPE; - if (!camel_mbox_store_type) { - GtkTypeInfo camel_mbox_store_info = - { - "CamelMboxStore", - sizeof (CamelMboxStore), - sizeof (CamelMboxStoreClass), - (GtkClassInitFunc) camel_mbox_store_class_init, - (GtkObjectInitFunc) camel_mbox_store_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_mbox_store_type = gtk_type_unique (CAMEL_STORE_TYPE, &camel_mbox_store_info); + if (camel_mbox_store_type == CAMEL_INVALID_TYPE) { + camel_mbox_store_type = camel_type_register (CAMEL_STORE_TYPE, "CamelMboxStore", + sizeof (CamelMboxStore), + sizeof (CamelMboxStoreClass), + (CamelObjectClassInitFunc) camel_mbox_store_class_init, + NULL, + (CamelObjectInitFunc) camel_mbox_store_init, + NULL); } return camel_mbox_store_type; @@ -156,7 +150,7 @@ get_folder (CamelStore *store, const char *folder_name, gboolean create, return NULL; } - new_folder = gtk_type_new (CAMEL_MBOX_FOLDER_TYPE); + new_folder = CAMEL_FOLDER (camel_object_new (CAMEL_MBOX_FOLDER_TYPE)); CF_CLASS (new_folder)->init (new_folder, store, NULL, folder_name, "/", TRUE, ex); diff --git a/camel/providers/mbox/camel-mbox-store.h b/camel/providers/mbox/camel-mbox-store.h index 06a971ada4..7b298b67f6 100644 --- a/camel/providers/mbox/camel-mbox-store.h +++ b/camel/providers/mbox/camel-mbox-store.h @@ -31,13 +31,12 @@ extern "C" { #pragma } #endif /* __cplusplus }*/ -#include #include "camel-store.h" #define CAMEL_MBOX_STORE_TYPE (camel_mbox_store_get_type ()) -#define CAMEL_MBOX_STORE(obj) (GTK_CHECK_CAST((obj), CAMEL_MBOX_STORE_TYPE, CamelMboxStore)) -#define CAMEL_MBOX_STORE_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_MBOX_STORE_TYPE, CamelMboxStoreClass)) -#define IS_CAMEL_MBOX_STORE(o) (GTK_CHECK_TYPE((o), CAMEL_MBOX_STORE_TYPE)) +#define CAMEL_MBOX_STORE(obj) (CAMEL_CHECK_CAST((obj), CAMEL_MBOX_STORE_TYPE, CamelMboxStore)) +#define CAMEL_MBOX_STORE_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_MBOX_STORE_TYPE, CamelMboxStoreClass)) +#define IS_CAMEL_MBOX_STORE(o) (CAMEL_CHECK_TYPE((o), CAMEL_MBOX_STORE_TYPE)) typedef struct { @@ -55,8 +54,8 @@ typedef struct { /* public methods */ -/* Standard Gtk function */ -GtkType camel_mbox_store_get_type (void); +/* Standard Camel function */ +CamelType camel_mbox_store_get_type (void); const gchar *camel_mbox_store_get_toplevel_dir (CamelMboxStore *store); diff --git a/camel/providers/mbox/camel-mbox-summary.c b/camel/providers/mbox/camel-mbox-summary.c index fc1eacafe7..b656205b1a 100644 --- a/camel/providers/mbox/camel-mbox-summary.c +++ b/camel/providers/mbox/camel-mbox-summary.c @@ -40,73 +40,58 @@ struct _CamelMboxSummaryPrivate { #define _PRIVATE(o) (((CamelMboxSummary *)(o))->priv) -static int summary_header_load(CamelFolderSummary *, FILE *); -static int summary_header_save(CamelFolderSummary *, FILE *); - -static CamelMessageInfo *message_info_new(CamelFolderSummary *, struct _header_raw *); -static CamelMessageInfo *message_info_new_from_parser(CamelFolderSummary *, CamelMimeParser *); -static CamelMessageInfo *message_info_load(CamelFolderSummary *, FILE *); -static int message_info_save(CamelFolderSummary *, FILE *, CamelMessageInfo *); +static int summary_header_load (CamelFolderSummary *, FILE *); +static int summary_header_save (CamelFolderSummary *, FILE *); +static CamelMessageInfo * message_info_new (CamelFolderSummary *, struct _header_raw *); +static CamelMessageInfo * message_info_new_from_parser (CamelFolderSummary *, CamelMimeParser *); +static CamelMessageInfo * message_info_load (CamelFolderSummary *, FILE *); +static int message_info_save (CamelFolderSummary *, FILE *, CamelMessageInfo *); /*static void message_info_free (CamelFolderSummary *, CamelMessageInfo *);*/ -static void camel_mbox_summary_class_init(CamelMboxSummaryClass * klass); -static void camel_mbox_summary_init(CamelMboxSummary *obj); -static void camel_mbox_summary_finalise(GtkObject * obj); +static void camel_mbox_summary_class_init (CamelMboxSummaryClass *klass); +static void camel_mbox_summary_init (CamelMboxSummary *obj); +static void camel_mbox_summary_finalise (CamelObject *obj); static CamelFolderSummaryClass *camel_mbox_summary_parent; -enum SIGNALS { - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = { 0 }; - -guint camel_mbox_summary_get_type(void) +CamelType +camel_mbox_summary_get_type (void) { - static guint type = 0; - - if (!type) { - GtkTypeInfo type_info = { - "CamelMboxSummary", - sizeof(CamelMboxSummary), - sizeof(CamelMboxSummaryClass), - (GtkClassInitFunc) camel_mbox_summary_class_init, - (GtkObjectInitFunc) camel_mbox_summary_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique(camel_folder_summary_get_type(), &type_info); + static CamelType type = CAMEL_INVALID_TYPE; + + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_folder_summary_get_type (), "CamelMboxSummary", + sizeof (CamelMboxSummary), + sizeof (CamelMboxSummaryClass), + (CamelObjectClassInitFunc) camel_mbox_summary_class_init, + NULL, + (CamelObjectInitFunc) camel_mbox_summary_init, + (CamelObjectFinalizeFunc) camel_mbox_summary_finalise); } - + return type; } static void -camel_mbox_summary_class_init(CamelMboxSummaryClass * klass) +camel_mbox_summary_class_init (CamelMboxSummaryClass *klass) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; CamelFolderSummaryClass *sklass = (CamelFolderSummaryClass *) klass; - - camel_mbox_summary_parent = gtk_type_class(camel_folder_summary_get_type()); - - object_class->finalize = camel_mbox_summary_finalise; + + camel_mbox_summary_parent = CAMEL_FOLDER_SUMMARY_CLASS(camel_type_get_global_classfuncs (camel_folder_summary_get_type ())); sklass->summary_header_load = summary_header_load; sklass->summary_header_save = summary_header_save; - sklass->message_info_new = message_info_new; + sklass->message_info_new = message_info_new; sklass->message_info_new_from_parser = message_info_new_from_parser; sklass->message_info_load = message_info_load; sklass->message_info_save = message_info_save; - /*sklass->message_info_free = message_info_free; */ - - gtk_object_class_add_signals(object_class, signals, LAST_SIGNAL); + /*sklass->message_info_free = message_info_free;*/ } static void -camel_mbox_summary_init(CamelMboxSummary *obj) +camel_mbox_summary_init (CamelMboxSummary *obj) { struct _CamelMboxSummaryPrivate *p; struct _CamelFolderSummary *s = (CamelFolderSummary *)obj; @@ -122,13 +107,11 @@ camel_mbox_summary_init(CamelMboxSummary *obj) } static void -camel_mbox_summary_finalise(GtkObject * obj) +camel_mbox_summary_finalise (CamelObject *obj) { - CamelMboxSummary *mbs = CAMEL_MBOX_SUMMARY(obj); + CamelMboxSummary *mbs = CAMEL_MBOX_SUMMARY (obj); - g_free(mbs->folder_path); - - ((GtkObjectClass *) (camel_mbox_summary_parent))->finalize(GTK_OBJECT(obj)); + g_free (mbs->folder_path); } /** @@ -139,203 +122,204 @@ camel_mbox_summary_finalise(GtkObject * obj) * Return value: A new CamelMboxSummary widget. **/ CamelMboxSummary * -camel_mbox_summary_new(const char *filename, const char *mbox_name, ibex * index) +camel_mbox_summary_new (const char *filename, const char *mbox_name, ibex *index) { - CamelMboxSummary *new = CAMEL_MBOX_SUMMARY(gtk_type_new(camel_mbox_summary_get_type())); - + CamelMboxSummary *new = CAMEL_MBOX_SUMMARY (camel_object_new (camel_mbox_summary_get_type ())); + if (new) { /* ?? */ - camel_folder_summary_set_build_content(CAMEL_FOLDER_SUMMARY(new), TRUE); - camel_folder_summary_set_filename(CAMEL_FOLDER_SUMMARY(new), filename); - new->folder_path = g_strdup(mbox_name); + camel_folder_summary_set_build_content (CAMEL_FOLDER_SUMMARY (new), TRUE); + camel_folder_summary_set_filename (CAMEL_FOLDER_SUMMARY (new), filename); + new->folder_path = g_strdup (mbox_name); new->index = index; } return new; } static int -summary_header_load(CamelFolderSummary *s, FILE * in) +summary_header_load (CamelFolderSummary *s, FILE *in) { - CamelMboxSummary *mbs = CAMEL_MBOX_SUMMARY(s); + CamelMboxSummary *mbs = CAMEL_MBOX_SUMMARY (s); - if (((CamelFolderSummaryClass *) camel_mbox_summary_parent)->summary_header_load(s, in) == -1) + if (((CamelFolderSummaryClass *)camel_mbox_summary_parent)->summary_header_load (s, in) == -1) return -1; - return camel_folder_summary_decode_uint32(in, &mbs->folder_size); + return camel_folder_summary_decode_uint32 (in, &mbs->folder_size); } static int -summary_header_save(CamelFolderSummary *s, FILE * out) +summary_header_save (CamelFolderSummary *s, FILE *out) { - CamelMboxSummary *mbs = CAMEL_MBOX_SUMMARY(s); + CamelMboxSummary *mbs = CAMEL_MBOX_SUMMARY (s); - if (((CamelFolderSummaryClass *) camel_mbox_summary_parent)->summary_header_save(s, out) == -1) + if (((CamelFolderSummaryClass *)camel_mbox_summary_parent)->summary_header_save (s, out) == -1) return -1; - return camel_folder_summary_encode_uint32(out, mbs->folder_size); + return camel_folder_summary_encode_uint32 (out, mbs->folder_size); } static int -header_evolution_decode(const char *in, guint32 * uid, guint32 * flags) +header_evolution_decode (const char *in, guint32 *uid, guint32 *flags) { - char *header; - - if (in && (header = header_token_decode(in))) { - if (strlen(header) == strlen("00000000-0000") - && sscanf(header, "%08x-%04x", uid, flags) == 2) { - g_free(header); - return *uid; - } - g_free(header); - } - - return -1; + char *header; + + if (in && (header = header_token_decode(in))) { + if (strlen (header) == strlen ("00000000-0000") + && sscanf (header, "%08x-%04x", uid, flags) == 2) { + g_free (header); + return *uid; + } + g_free (header); + } + + return -1; } static char * -header_evolution_encode(guint32 uid, guint32 flags) +header_evolution_encode (guint32 uid, guint32 flags) { - return g_strdup_printf("%08x-%04x", uid, flags & 0xffff); + return g_strdup_printf ("%08x-%04x", uid, flags & 0xffff); } static CamelMessageInfo * -message_info_new(CamelFolderSummary *s, struct _header_raw *h) +message_info_new (CamelFolderSummary *s, struct _header_raw *h) { CamelMessageInfo *mi; - mi = ((CamelFolderSummaryClass *) camel_mbox_summary_parent)->message_info_new(s, h); + mi = ((CamelFolderSummaryClass *)camel_mbox_summary_parent)->message_info_new (s, h); if (mi) { const char *xev; guint32 uid, flags; - CamelMboxMessageInfo *mbi = (CamelMboxMessageInfo *) mi; + CamelMboxMessageInfo *mbi = (CamelMboxMessageInfo *)mi; - xev = header_raw_find(&h, "X-Evolution", NULL); + xev = header_raw_find (&h, "X-Evolution", NULL); if (xev && header_evolution_decode(xev, &uid, &flags) != -1) { - g_free(mi->uid); - mi->uid = g_strdup_printf("%u", uid); + g_free (mi->uid); + mi->uid = g_strdup_printf ("%u", uid); mi->flags = flags; } else { /* to indicate it has no xev header? */ mi->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED | CAMEL_MESSAGE_FOLDER_NOXEV; - mi->uid = g_strdup_printf("%u", camel_folder_summary_next_uid(s)); + mi->uid = g_strdup_printf ("%u", camel_folder_summary_next_uid (s)); } mbi->frompos = -1; } - + return mi; } static CamelMessageInfo * -message_info_new_from_parser(CamelFolderSummary *s, CamelMimeParser * mp) +message_info_new_from_parser (CamelFolderSummary *s, CamelMimeParser *mp) { CamelMessageInfo *mi; - CamelMboxSummary *mbs = CAMEL_MBOX_SUMMARY(s); + CamelMboxSummary *mbs = CAMEL_MBOX_SUMMARY (s); - mi = ((CamelFolderSummaryClass *) camel_mbox_summary_parent)->message_info_new_from_parser(s, mp); + mi = ((CamelFolderSummaryClass *)camel_mbox_summary_parent)->message_info_new_from_parser (s, mp); if (mi) { - CamelMboxMessageInfo *mbi = (CamelMboxMessageInfo *) mi; + CamelMboxMessageInfo *mbi = (CamelMboxMessageInfo *)mi; - mbi->frompos = camel_mime_parser_tell_start_from(mp); + mbi->frompos = camel_mime_parser_tell_start_from (mp); /* do we want to index this message as we add it, as well? */ - if (mbs->index_force || (mi->flags & CAMEL_MESSAGE_FOLDER_FLAGGED) != 0 + if (mbs->index_force + || (mi->flags & CAMEL_MESSAGE_FOLDER_FLAGGED) != 0 || !ibex_contains_name(mbs->index, mi->uid)) { - camel_folder_summary_set_index(s, mbs->index); + + camel_folder_summary_set_index (s, mbs->index); } else { - camel_folder_summary_set_index(s, NULL); + camel_folder_summary_set_index (s, NULL); } } - + return mi; } static CamelMessageInfo * -message_info_load(CamelFolderSummary *s, FILE * in) +message_info_load (CamelFolderSummary *s, FILE *in) { CamelMessageInfo *mi; - io(printf("loading mbox message info\n")); + io (printf ("loading mbox message info\n")); - mi = ((CamelFolderSummaryClass *) camel_mbox_summary_parent)->message_info_load(s, in); + mi = ((CamelFolderSummaryClass *)camel_mbox_summary_parent)->message_info_load (s, in); if (mi) { - CamelMboxMessageInfo *mbi = (CamelMboxMessageInfo *) mi; + CamelMboxMessageInfo *mbi = (CamelMboxMessageInfo *)mi; - camel_folder_summary_decode_uint32(in, &mbi->frompos); + camel_folder_summary_decode_uint32 (in, &mbi->frompos); } - + return mi; } static int -message_info_save(CamelFolderSummary *s, FILE * out, CamelMessageInfo * mi) +message_info_save (CamelFolderSummary *s, FILE *out, CamelMessageInfo *mi) { - CamelMboxMessageInfo *mbi = (CamelMboxMessageInfo *) mi; + CamelMboxMessageInfo *mbi = (CamelMboxMessageInfo *)mi; - io(printf("saving mbox message info\n")); + io (printf ("saving mbox message info\n")); - ((CamelFolderSummaryClass *) camel_mbox_summary_parent)->message_info_save(s, out, mi); + ((CamelFolderSummaryClass *)camel_mbox_summary_parent)->message_info_save (s, out, mi); - return camel_folder_summary_encode_uint32(out, mbi->frompos); + return camel_folder_summary_encode_uint32 (out, mbi->frompos); } static int -summary_rebuild(CamelMboxSummary *mbs, off_t offset) +summary_rebuild (CamelMboxSummary *mbs, off_t offset) { - CamelFolderSummary *s = CAMEL_FOLDER_SUMMARY(mbs); + CamelFolderSummary *s = CAMEL_FOLDER_SUMMARY (mbs); CamelMimeParser *mp; int fd; int ok = 0; - fd = open(mbs->folder_path, O_RDONLY); + fd = open (mbs->folder_path, O_RDONLY); if (fd == -1) { - printf("%s failed to open: %s", mbs->folder_path, strerror(errno)); + printf ("%s failed to open: %s", mbs->folder_path, strerror (errno)); return -1; } - - mp = camel_mime_parser_new(); - camel_mime_parser_init_with_fd(mp, fd); - camel_mime_parser_scan_from(mp, TRUE); - camel_mime_parser_seek(mp, offset, SEEK_SET); + + mp = camel_mime_parser_new (); + camel_mime_parser_init_with_fd (mp, fd); + camel_mime_parser_scan_from (mp, TRUE); + camel_mime_parser_seek (mp, offset, SEEK_SET); if (offset > 0) { - if (camel_mime_parser_step(mp, NULL, NULL) == HSCAN_FROM) { - if (camel_mime_parser_tell_start_from(mp) != offset) { - g_warning - ("The next message didn't start where I expected\nbuilding summary from start"); - camel_mime_parser_drop_step(mp); + if (camel_mime_parser_step (mp, NULL, NULL) == HSCAN_FROM) { + if (camel_mime_parser_tell_start_from (mp) != offset) { + g_warning ("The next message didn't start where I expected\nbuilding summary from start"); + camel_mime_parser_drop_step (mp); offset = 0; - camel_mime_parser_seek(mp, offset, SEEK_SET); - camel_folder_summary_clear(CAMEL_FOLDER_SUMMARY(mbs)); + camel_mime_parser_seek (mp, offset, SEEK_SET); + camel_folder_summary_clear (CAMEL_FOLDER_SUMMARY (mbs)); } else { - camel_mime_parser_unstep(mp); + camel_mime_parser_unstep (mp); } } else { - gtk_object_unref(GTK_OBJECT(mp)); + camel_object_unref (CAMEL_OBJECT (mp)); /* end of file - no content? */ return -1; } } - while (camel_mime_parser_step(mp, NULL, NULL) == HSCAN_FROM) { + while (camel_mime_parser_step (mp, NULL, NULL) == HSCAN_FROM) { CamelMessageInfo *info; - info = camel_folder_summary_add_from_parser(CAMEL_FOLDER_SUMMARY(mbs), mp); + info = camel_folder_summary_add_from_parser (CAMEL_FOLDER_SUMMARY (mbs), mp); if (info == NULL) { - printf("Could not build info from file?\n"); + printf ("Could not build info from file?\n"); ok = -1; break; } - g_assert(camel_mime_parser_step(mp, NULL, NULL) == HSCAN_FROM_END); + g_assert (camel_mime_parser_step (mp, NULL, NULL) == HSCAN_FROM_END); } - gtk_object_unref(GTK_OBJECT(mp)); - + camel_object_unref (CAMEL_OBJECT (mp)); + /* update the file size/mtime in the summary */ if (ok != -1) { struct stat st; - if (stat(mbs->folder_path, &st) == 0) { + if (stat (mbs->folder_path, &st) == 0) { mbs->folder_size = st.st_size; s->time = st.st_mtime; } @@ -627,246 +611,260 @@ camel_mbox_summary_sync(CamelMboxSummary *mbs, gboolean expunge, CamelException char *fromline; /* make sure we're in sync */ - count = camel_folder_summary_count(s); + count = camel_folder_summary_count (s); if (count > 0) { - CamelMessageInfo *mi = camel_folder_summary_index(s, count - 1); - - camel_mbox_summary_update(mbs, mi->content->endpos); + CamelMessageInfo *mi = camel_folder_summary_index (s, count - 1); + camel_mbox_summary_update (mbs, mi->content->endpos); } else { - camel_mbox_summary_update(mbs, 0); + camel_mbox_summary_update (mbs, 0); } /* check if we have any work to do */ - d(printf("Performing sync, %d messages in inbox\n", count)); + d(printf ("Performing sync, %d messages in inbox\n", count)); for (i = 0; quick && i < count; i++) { - info = (CamelMboxMessageInfo *) camel_folder_summary_index(s, i); - if ((expunge && (info->info.flags & CAMEL_MESSAGE_DELETED)) - || (info->info.flags & CAMEL_MESSAGE_FOLDER_NOXEV)) + info = (CamelMboxMessageInfo *)camel_folder_summary_index (s, i); + if ((expunge && (info->info.flags & CAMEL_MESSAGE_DELETED)) || + (info->info.flags & CAMEL_MESSAGE_FOLDER_NOXEV)) quick = FALSE; else work |= (info->info.flags & CAMEL_MESSAGE_FOLDER_FLAGGED) != 0; } - d(printf("Options: %s %s %s\n", expunge ? "expunge" : "", quick ? "quick" : "", work ? "Work" : "")); + d(printf ("Options: %s %s %s\n", expunge ? "expunge" : "", quick ? "quick" : "", work ? "Work" : "")); if (quick && !work) return 0; - fd = open(mbs->folder_path, O_RDWR); + fd = open (mbs->folder_path, O_RDWR); if (fd == -1) { - camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, "Could not open summary %s", mbs->folder_path); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Could not open summary %s", mbs->folder_path); return -1; } - mp = camel_mime_parser_new(); - camel_mime_parser_scan_from(mp, TRUE); - camel_mime_parser_init_with_fd(mp, fd); + mp = camel_mime_parser_new (); + camel_mime_parser_scan_from (mp, TRUE); + camel_mime_parser_init_with_fd (mp, fd); if (!quick) { - tmpname = alloca(strlen(mbs->folder_path) + 5); - sprintf(tmpname, "%s.tmp", mbs->folder_path); - d(printf("Writing tmp file to %s\n", tmpname)); - retry_out: - fdout = open(tmpname, O_WRONLY | O_CREAT | O_EXCL, 0600); + tmpname = alloca (strlen (mbs->folder_path) + 5); + sprintf (tmpname, "%s.tmp", mbs->folder_path); + d(printf ("Writing tmp file to %s\n", tmpname)); + retry_out: + fdout = open (tmpname, O_WRONLY | O_CREAT | O_EXCL, 0600); if (fdout == -1) { if (errno == EEXIST) if (unlink(tmpname) != -1) goto retry_out; - - free(tmpname); + + free (tmpname); tmpname = NULL; - g_warning("Something failed (yo!)"); - camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, "Cannot open temporary mailbox: %s", - strerror(errno)); + g_warning ("Something failed (yo!)"); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Cannot open temporary mailbox: %s", strerror (errno)); goto error; } } for (i = 0; i < count; i++) { off_t frompos, bodypos, lastpos; - /* This has to be an int, not an off_t, because that's * what camel_mime_parser_header returns... FIXME. */ int xevoffset; - info = (CamelMboxMessageInfo *) camel_folder_summary_index(s, i); + info = (CamelMboxMessageInfo *)camel_folder_summary_index(s, i); - g_assert(info); + g_assert (info); - d(printf("Looking at message %s\n", info->info.uid)); + d(printf ("Looking at message %s\n", info->info.uid)); if (expunge && info->info.flags & CAMEL_MESSAGE_DELETED) { - d(printf("Deleting %s\n", info->info.uid)); + d(printf ("Deleting %s\n", info->info.uid)); - g_assert(!quick); + g_assert (!quick); offset -= (info->info.content->endpos - info->frompos); if (mbs->index) - ibex_unindex(mbs->index, info->info.uid); - camel_folder_summary_remove(s, (CamelMessageInfo *) info); + ibex_unindex (mbs->index, info->info.uid); + camel_folder_summary_remove (s, (CamelMessageInfo *)info); count--; i--; info = NULL; } else if (info->info.flags & (CAMEL_MESSAGE_FOLDER_NOXEV | CAMEL_MESSAGE_FOLDER_FLAGGED)) { int xevok = FALSE; - d(printf("Updating header for %s flags = %08x\n", info->info.uid, info->info.flags)); + d(printf ("Updating header for %s flags = %08x\n", info->info.uid, info->info.flags)); /* find the next message, header parts */ - camel_mime_parser_seek(mp, info->frompos, SEEK_SET); - if (camel_mime_parser_step(mp, &buffer, &len) != HSCAN_FROM) { - g_warning("camel_mime_parser_step failed (1)"); + camel_mime_parser_seek (mp, info->frompos, SEEK_SET); + if (camel_mime_parser_step (mp, &buffer, &len) != HSCAN_FROM) { + g_warning ("camel_mime_parser_step failed (1)"); goto error; } - if (camel_mime_parser_tell_start_from(mp) != info->frompos) { - g_warning("Summary/mbox mismatch, aborting sync"); - camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, "Summary mismatch, aborting sync"); + if (camel_mime_parser_tell_start_from (mp) != info->frompos) { + g_warning ("Summary/mbox mismatch, aborting sync"); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Summary mismatch, aborting sync"); goto error; } - - if (camel_mime_parser_step(mp, &buffer, &len) == HSCAN_FROM_END) { - g_warning("camel_mime_parser_step failed (2)"); + + if (camel_mime_parser_step (mp, &buffer, &len) == HSCAN_FROM_END) { + g_warning ("camel_mime_parser_step failed (2)"); goto error; } /* Check if the X-Evolution header is valid. */ - xev = camel_mime_parser_header(mp, "X-Evolution", &xevoffset); - if (xev && header_evolution_decode(xev, &uid, &flags) != -1) + xev = camel_mime_parser_header (mp, "X-Evolution", &xevoffset); + if (xev && header_evolution_decode (xev, &uid, &flags) != -1) xevok = TRUE; - xevnew = header_evolution_encode(strtoul(info->info.uid, NULL, 10), info->info.flags & 0xffff); + xevnew = header_evolution_encode (strtoul (info->info.uid, NULL, 10), info->info.flags & 0xffff); if (quick) { if (!xevok) { - g_warning("The summary told me I had an X-Evolution header, but i dont!"); - camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, - "Summary mismatch, X-Evolution header missing"); + g_warning ("The summary told me I had an X-Evolution header, but i dont!"); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Summary mismatch, X-Evolution header missing"); goto error; } - buffer = g_strdup_printf("X-Evolution: %s", xevnew); - lastpos = lseek(fd, 0, SEEK_CUR); - lseek(fd, xevoffset, SEEK_SET); + buffer = g_strdup_printf ("X-Evolution: %s", xevnew); + lastpos = lseek (fd, 0, SEEK_CUR); + lseek (fd, xevoffset, SEEK_SET); do { - len = write(fd, buffer, strlen(buffer)); + len = write (fd, buffer, strlen (buffer)); } while (len == -1 && errno == EINTR); - lseek(fd, lastpos, SEEK_SET); - g_free(buffer); + lseek (fd, lastpos, SEEK_SET); + g_free (buffer); if (len == -1) { - g_warning("Yahoo! len == -1"); + g_warning ("Yahoo! len == -1"); goto error; } } else { - frompos = lseek(fdout, 0, SEEK_CUR); - fromline = camel_mbox_summary_build_from(camel_mime_parser_headers_raw(mp)); - write(fdout, fromline, strlen(fromline)); - g_free(fromline); - if (header_write(fdout, camel_mime_parser_headers_raw(mp), xevnew) == -1) { - d(printf("Error writing to tmp mailbox\n")); - camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, - "Error writing to temp mailbox: %s", strerror(errno)); + frompos = lseek (fdout, 0, SEEK_CUR); + fromline = camel_mbox_summary_build_from (camel_mime_parser_headers_raw (mp)); + write (fdout, fromline, strlen(fromline)); + g_free (fromline); + if (header_write (fdout, camel_mime_parser_headers_raw (mp), xevnew) == -1) { + d(printf ("Error writing to tmp mailbox\n")); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Error writing to temp mailbox: %s", + strerror (errno)); goto error; } - bodypos = lseek(fdout, 0, SEEK_CUR); - d(printf("pos = %d, endpos = %d, bodypos = %d\n", - (int)info->info.content->pos, - (int)info->info.content->endpos, - (int)info->info.content->bodypos)); - if (copy_block(fd, fdout, info->info.content->bodypos, - info->info.content->endpos - info->info.content->bodypos) == -1) { - g_warning("Cannot copy data to output fd"); - camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, - "Cannot copy data to output fd: %s", strerror(errno)); + bodypos = lseek (fdout, 0, SEEK_CUR); + d(printf ("pos = %d, endpos = %d, bodypos = %d\n", + (int) info->info.content->pos, + (int) info->info.content->endpos, + (int) info->info.content->bodypos)); + if (copy_block (fd, fdout, info->info.content->bodypos, + info->info.content->endpos - info->info.content->bodypos) == -1) { + g_warning ("Cannot copy data to output fd"); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Cannot copy data to output fd: %s", + strerror (errno)); goto error; } info->frompos = frompos; offset = bodypos - info->info.content->bodypos; } info->info.flags &= 0xffff; - g_free(xevnew); + g_free (xevnew); xevnew = NULL; - camel_mime_parser_drop_step(mp); - camel_mime_parser_drop_step(mp); + camel_mime_parser_drop_step (mp); + camel_mime_parser_drop_step (mp); } else { if (!quick) { - if (copy_block(fd, fdout, info->frompos, info->info.content->endpos - info->frompos) == -1) { - g_warning("Cannot copy data to output fd"); - camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, - "Cannot copy data to output fd: %s", strerror(errno)); + if (copy_block (fd, fdout, info->frompos, + info->info.content->endpos - info->frompos) == -1) { + g_warning ("Cannot copy data to output fd"); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Cannot copy data to output fd: %s", + strerror (errno)); goto error; } /* update from pos here? */ info->frompos += offset; } else { - d(printf("Nothing to do for this message\n")); + d(printf ("Nothing to do for this message\n")); } } if (!quick && info != NULL && offset != 0) { - d(printf("offsetting content: %d\n", (int)offset)); - camel_folder_summary_offset_content(info->info.content, offset); - d(printf("pos = %d, endpos = %d, bodypos = %d\n", - (int)info->info.content->pos, - (int)info->info.content->endpos, - (int)info->info.content->bodypos)); + d(printf ("offsetting content: %d\n", (int) offset)); + camel_folder_summary_offset_content (info->info.content, offset); + d(printf ("pos = %d, endpos = %d, bodypos = %d\n", + (int) info->info.content->pos, + (int) info->info.content->endpos, + (int) info->info.content->bodypos)); } } - d(printf("Closing folders\n")); + d(printf ("Closing folders\n")); - if (close(fd) == -1) { - g_warning("Cannot close source folder: %s", strerror(errno)); - camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, "Could not close source folder %s: %s", - mbs->folder_path, strerror(errno)); + if (close (fd) == -1) { + g_warning ("Cannot close source folder: %s", strerror (errno)); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Could not close source folder %s: %s", + mbs->folder_path, strerror (errno)); goto error; } if (!quick) { - if (close(fdout) == -1) { - g_warning("Cannot close tmp folder: %s", strerror(errno)); - camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, "Could not close temp folder: %s", - strerror(errno)); + if (close (fdout) == -1) { + g_warning ("Cannot close tmp folder: %s", strerror (errno)); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Could not close temp folder: %s", + strerror (errno)); goto error; } - if (rename(tmpname, mbs->folder_path) == -1) { - g_warning("Cannot rename folder: %s", strerror(errno)); - camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, "Could not rename folder: %s", - strerror(errno)); + if (rename (tmpname, mbs->folder_path) == -1) { + g_warning ("Cannot rename folder: %s", strerror (errno)); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Could not rename folder: %s", + strerror (errno)); goto error; } tmpname = NULL; if (mbs->index) - ibex_save(mbs->index); + ibex_save (mbs->index); } - if (stat(mbs->folder_path, &st) == -1) { - g_warning("Hmm... stat(mbs->folder_path, &st) == -1"); - camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, "Unknown error: %s", strerror(errno)); + if (stat (mbs->folder_path, &st) == -1) { + g_warning ("Hmm... stat(mbs->folder_path, &st) == -1"); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Unknown error: %s", + strerror (errno)); goto error; } - camel_folder_summary_touch(s); + camel_folder_summary_touch (s); s->time = st.st_mtime; mbs->folder_size = st.st_size; - camel_folder_summary_save(s); - - gtk_object_unref(GTK_OBJECT(mp)); + camel_folder_summary_save (s); + camel_object_unref (CAMEL_OBJECT (mp)); + return 0; - error: + error: if (fd != -1) - close(fd); - + close (fd); + if (fdout != -1) - close(fdout); - - g_free(xevnew); - + close (fdout); + + g_free (xevnew); + if (tmpname) - unlink(tmpname); + unlink (tmpname); if (mp) - gtk_object_unref(GTK_OBJECT(mp)); + camel_object_unref (CAMEL_OBJECT (mp)); return -1; } + + + + + diff --git a/camel/providers/mbox/camel-mbox-summary.h b/camel/providers/mbox/camel-mbox-summary.h index b4e59fa343..2462b72078 100644 --- a/camel/providers/mbox/camel-mbox-summary.h +++ b/camel/providers/mbox/camel-mbox-summary.h @@ -22,14 +22,13 @@ #ifndef _CAMEL_MBOX_SUMMARY_H #define _CAMEL_MBOX_SUMMARY_H -#include #include #include #include -#define CAMEL_MBOX_SUMMARY(obj) GTK_CHECK_CAST (obj, camel_mbox_summary_get_type (), CamelMboxSummary) -#define CAMEL_MBOX_SUMMARY_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_mbox_summary_get_type (), CamelMboxSummaryClass) -#define IS_CAMEL_MBOX_SUMMARY(obj) GTK_CHECK_TYPE (obj, camel_mbox_summary_get_type ()) +#define CAMEL_MBOX_SUMMARY(obj) CAMEL_CHECK_CAST (obj, camel_mbox_summary_get_type (), CamelMboxSummary) +#define CAMEL_MBOX_SUMMARY_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_mbox_summary_get_type (), CamelMboxSummaryClass) +#define IS_CAMEL_MBOX_SUMMARY(obj) CAMEL_CHECK_TYPE (obj, camel_mbox_summary_get_type ()) typedef struct _CamelMboxSummary CamelMboxSummary; typedef struct _CamelMboxSummaryClass CamelMboxSummaryClass; diff --git a/camel/providers/mh/camel-mh-folder.c b/camel/providers/mh/camel-mh-folder.c index b10c8b1a65..e20b3fabb5 100644 --- a/camel/providers/mh/camel-mh-folder.c +++ b/camel/providers/mh/camel-mh-folder.c @@ -49,9 +49,9 @@ static CamelFolderClass *parent_class = NULL; /* Returns the class for a CamelMhFolder */ -#define CMHF_CLASS(so) CAMEL_MH_FOLDER_CLASS (GTK_OBJECT(so)->klass) -#define CF_CLASS(so) CAMEL_FOLDER_CLASS (GTK_OBJECT(so)->klass) -#define CMHS_CLASS(so) CAMEL_STORE_CLASS (GTK_OBJECT(so)->klass) +#define CMHF_CLASS(so) CAMEL_MH_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CF_CLASS(so) CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CMHS_CLASS(so) CAMEL_STORE_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static void mh_init(CamelFolder * folder, CamelStore * parent_store, CamelFolder * parent_folder, const gchar * name, @@ -78,14 +78,13 @@ static void mh_set_message_flags(CamelFolder * folder, const char *uid, guint32 static gboolean mh_get_message_user_flag(CamelFolder * folder, const char *uid, const char *name); static void mh_set_message_user_flag(CamelFolder * folder, const char *uid, const char *name, gboolean value); -static void mh_finalize(GtkObject * object); +static void mh_finalize(CamelObject * object); -static void camel_mh_folder_class_init(CamelMhFolderClass * camel_mh_folder_class) +static void camel_mh_folder_class_init(CamelObjectClass * camel_mh_folder_class) { CamelFolderClass *camel_folder_class = CAMEL_FOLDER_CLASS(camel_mh_folder_class); - GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS(camel_folder_class); - parent_class = gtk_type_class(camel_folder_get_type()); + parent_class = CAMEL_FOLDER_CLASS (camel_type_get_global_classfuncs(camel_folder_get_type())); /* virtual method definition */ @@ -114,11 +113,9 @@ static void camel_mh_folder_class_init(CamelMhFolderClass * camel_mh_folder_clas camel_folder_class->set_message_flags = mh_set_message_flags; camel_folder_class->get_message_user_flag = mh_get_message_user_flag; camel_folder_class->set_message_user_flag = mh_set_message_user_flag; - - gtk_object_class->finalize = mh_finalize; } -static void mh_finalize(GtkObject * object) +static void mh_finalize(CamelObject * object) { CamelMhFolder *mh_folder = CAMEL_MH_FOLDER(object); @@ -126,27 +123,20 @@ static void mh_finalize(GtkObject * object) g_free(mh_folder->summary_file_path); g_free(mh_folder->folder_dir_path); g_free(mh_folder->index_file_path); - - GTK_OBJECT_CLASS(parent_class)->finalize(object); } -GtkType camel_mh_folder_get_type(void) +CamelType camel_mh_folder_get_type(void) { - static GtkType camel_mh_folder_type = 0; - - if (!camel_mh_folder_type) { - GtkTypeInfo camel_mh_folder_info = { - "CamelMhFolder", - sizeof(CamelMhFolder), - sizeof(CamelMhFolderClass), - (GtkClassInitFunc) camel_mh_folder_class_init, - (GtkObjectInitFunc) NULL, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_mh_folder_type = gtk_type_unique(CAMEL_FOLDER_TYPE, &camel_mh_folder_info); + static CamelType camel_mh_folder_type = CAMEL_INVALID_TYPE; + + if (camel_mh_folder_type == CAMEL_INVALID_TYPE) { + camel_mh_folder_type = camel_type_register(CAMEL_FOLDER_TYPE, "CamelMhFolder", + sizeof(CamelMhFolder), + sizeof(CamelMhFolderClass), + (CamelObjectClassInitFunc) camel_mh_folder_class_init, + NULL, + (CamelObjectInitFunc) NULL, + (CamelObjectFinalizeFunc) mh_finalize); } return camel_mh_folder_type; @@ -238,7 +228,7 @@ static void mh_expunge(CamelFolder * folder, CamelException * ex) camel_mh_summary_sync(mh->summary, TRUE, ex); /* TODO: check it actually changed */ - gtk_signal_emit_by_name(GTK_OBJECT(folder), "folder_changed", 0); + camel_object_trigger_event(CAMEL_OBJECT(folder), "folder_changed", GINT_TO_POINTER (0)); } static gint mh_get_message_count(CamelFolder * folder) @@ -301,6 +291,7 @@ static void mh_append_message(CamelFolder * folder, CamelMimeMessage * message, /* index/summarise the message. Yes this re-reads it, its just simpler */ camel_mh_summary_add(mh_folder->summary, uid, TRUE); + if (info && (newinfo = camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(mh_folder->summary), uid))) { CamelFlag *flag = info->user_flags; @@ -316,7 +307,8 @@ static void mh_append_message(CamelFolder * folder, CamelMimeMessage * message, tag = tag->next; } } - gtk_signal_emit_by_name(GTK_OBJECT(folder), "folder_changed", 0); + + camel_object_trigger_event(CAMEL_OBJECT(folder), "folder_changed", GPOINTER_TO_INT (0)); g_free(name); g_free(uid); return; @@ -330,7 +322,7 @@ fail: "Cannot append message to mh file: %s", g_strerror(errno)); } if (output_stream) - gtk_object_unref(GTK_OBJECT(output_stream)); + camel_object_unref(CAMEL_OBJECT(output_stream)); if (name) { unlink(name); g_free(name); @@ -394,7 +386,7 @@ static CamelMimeMessage *mh_get_message(CamelFolder * folder, const gchar * uid, errno = EINVAL; goto fail; } - gtk_object_unref(GTK_OBJECT(message_stream)); + camel_object_unref(CAMEL_OBJECT(message_stream)); g_free(name); return message; @@ -404,10 +396,10 @@ fail: name, g_strerror(errno)); if (message_stream) - gtk_object_unref(GTK_OBJECT(message_stream)); + camel_object_unref(CAMEL_OBJECT(message_stream)); if (message) - gtk_object_unref(GTK_OBJECT(message)); + camel_object_unref(CAMEL_OBJECT(message)); g_free(name); @@ -478,7 +470,7 @@ static void mh_set_message_flags(CamelFolder * folder, const char *uid, guint32 info->flags = (info->flags & ~flags) | (set & flags) | CAMEL_MESSAGE_FOLDER_FLAGGED; camel_folder_summary_touch(CAMEL_FOLDER_SUMMARY(mf->summary)); - gtk_signal_emit_by_name(GTK_OBJECT(folder), "message_changed", uid); + camel_object_trigger_event (CAMEL_OBJECT(folder), "message_changed", uid); } static gboolean mh_get_message_user_flag(CamelFolder * folder, const char *uid, const char *name) @@ -503,5 +495,5 @@ static void mh_set_message_user_flag(CamelFolder * folder, const char *uid, cons camel_flag_set(&info->user_flags, name, value); info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED; camel_folder_summary_touch(CAMEL_FOLDER_SUMMARY(mf->summary)); - gtk_signal_emit_by_name(GTK_OBJECT(folder), "message_changed", uid); + camel_object_trigger_event (CAMEL_OBJECT(folder), "message_changed", uid); } diff --git a/camel/providers/mh/camel-mh-folder.h b/camel/providers/mh/camel-mh-folder.h index e014197442..37ff133c9e 100644 --- a/camel/providers/mh/camel-mh-folder.h +++ b/camel/providers/mh/camel-mh-folder.h @@ -31,16 +31,15 @@ extern "C" { #pragma } #endif /* __cplusplus } */ -#include #include #include #include #include "camel-mh-summary.h" #define CAMEL_MH_FOLDER_TYPE (camel_mh_folder_get_type ()) -#define CAMEL_MH_FOLDER(obj) (GTK_CHECK_CAST((obj), CAMEL_MH_FOLDER_TYPE, CamelMhFolder)) -#define CAMEL_MH_FOLDER_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_MH_FOLDER_TYPE, CamelMhFolderClass)) -#define IS_CAMEL_MH_FOLDER(o) (GTK_CHECK_TYPE((o), CAMEL_MH_FOLDER_TYPE)) +#define CAMEL_MH_FOLDER(obj) (CAMEL_CHECK_CAST((obj), CAMEL_MH_FOLDER_TYPE, CamelMhFolder)) +#define CAMEL_MH_FOLDER_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_MH_FOLDER_TYPE, CamelMhFolderClass)) +#define IS_CAMEL_MH_FOLDER(o) (CAMEL_CHECK_TYPE((o), CAMEL_MH_FOLDER_TYPE)) typedef struct { CamelFolder parent_object; @@ -64,8 +63,8 @@ typedef struct { /* public methods */ -/* Standard Gtk function */ -GtkType camel_mh_folder_get_type(void); +/* Standard Camel function */ +CamelType camel_mh_folder_get_type(void); #ifdef __cplusplus } diff --git a/camel/providers/mh/camel-mh-store.c b/camel/providers/mh/camel-mh-store.c index 42f3b474f6..c720cb1c91 100644 --- a/camel/providers/mh/camel-mh-store.c +++ b/camel/providers/mh/camel-mh-store.c @@ -36,9 +36,9 @@ #include "camel-url.h" /* Returns the class for a CamelMhStore */ -#define CMHS_CLASS(so) CAMEL_MH_STORE_CLASS (GTK_OBJECT(so)->klass) -#define CF_CLASS(so) CAMEL_FOLDER_CLASS (GTK_OBJECT(so)->klass) -#define CMHF_CLASS(so) CAMEL_MH_FOLDER_CLASS (GTK_OBJECT(so)->klass) +#define CMHS_CLASS(so) CAMEL_MH_STORE_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CF_CLASS(so) CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CMHF_CLASS(so) CAMEL_MH_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static char *get_name(CamelService * service, gboolean brief); static CamelFolder *get_folder(CamelStore * store, const char *folder_name, gboolean create, CamelException * ex); @@ -46,7 +46,7 @@ static void delete_folder(CamelStore * store, const char *folder_name, CamelExce static void rename_folder(CamelStore *store, const char *old_name, const char *new_name, CamelException *ex); static char *get_folder_name(CamelStore * store, const char *folder_name, CamelException * ex); -static void camel_mh_store_class_init(CamelMhStoreClass * camel_mh_store_class) +static void camel_mh_store_class_init(CamelObjectClass * camel_mh_store_class) { CamelStoreClass *camel_store_class = CAMEL_STORE_CLASS(camel_mh_store_class); CamelServiceClass *camel_service_class = CAMEL_SERVICE_CLASS(camel_mh_store_class); @@ -60,7 +60,7 @@ static void camel_mh_store_class_init(CamelMhStoreClass * camel_mh_store_class) camel_store_class->get_folder_name = get_folder_name; } -static void camel_mh_store_init(gpointer object, gpointer klass) +static void camel_mh_store_init(CamelObject * object) { CamelService *service = CAMEL_SERVICE(object); CamelStore *store = CAMEL_STORE(object); @@ -71,23 +71,18 @@ static void camel_mh_store_init(gpointer object, gpointer klass) store->folders = g_hash_table_new(g_str_hash, g_str_equal); } -GtkType camel_mh_store_get_type(void) +CamelType camel_mh_store_get_type(void) { - static GtkType camel_mh_store_type = 0; - - if (!camel_mh_store_type) { - GtkTypeInfo camel_mh_store_info = { - "CamelMhStore", - sizeof(CamelMhStore), - sizeof(CamelMhStoreClass), - (GtkClassInitFunc) camel_mh_store_class_init, - (GtkObjectInitFunc) camel_mh_store_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_mh_store_type = gtk_type_unique(CAMEL_STORE_TYPE, &camel_mh_store_info); + static CamelType camel_mh_store_type = CAMEL_INVALID_TYPE; + + if (camel_mh_store_type == CAMEL_INVALID_TYPE) { + camel_mh_store_type = camel_type_register(CAMEL_STORE_TYPE, "CamelMhStore", + sizeof(CamelMhStore), + sizeof(CamelMhStoreClass), + (CamelObjectClassInitFunc) camel_mh_store_class_init, + NULL, + (CamelObjectInitFunc) camel_mh_store_init, + NULL); } return camel_mh_store_type; @@ -109,10 +104,9 @@ static CamelFolder *get_folder(CamelStore * store, const char *folder_name, gboo name = g_strdup_printf("%s%s", CAMEL_SERVICE(store)->url->path, folder_name); - printf("getting folder: %s\n", name); + printf("getting folder: %s\n", name); if (stat(name, &st) == -1) { - printf("doesn't exist ...\n"); - + printf("doesn't exist ...\n"); if (errno != ENOENT) { camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, "Could not open folder `%s':" "\n%s", folder_name, g_strerror(errno)); @@ -137,7 +131,7 @@ static CamelFolder *get_folder(CamelStore * store, const char *folder_name, gboo goto done; } - new_folder = gtk_type_new(CAMEL_MH_FOLDER_TYPE); + new_folder = CAMEL_FOLDER (camel_object_new(CAMEL_MH_FOLDER_TYPE)); CF_CLASS(new_folder)->init(new_folder, store, NULL, folder_name, "/", TRUE, ex); done: diff --git a/camel/providers/mh/camel-mh-store.h b/camel/providers/mh/camel-mh-store.h index 7040b27ffe..e2e2bbb656 100644 --- a/camel/providers/mh/camel-mh-store.h +++ b/camel/providers/mh/camel-mh-store.h @@ -30,12 +30,11 @@ extern "C" { #pragma } #endif /* __cplusplus } */ -#include #include "camel-store.h" #define CAMEL_MH_STORE_TYPE (camel_mh_store_get_type ()) -#define CAMEL_MH_STORE(obj) (GTK_CHECK_CAST((obj), CAMEL_MH_STORE_TYPE, CamelMhStore)) -#define CAMEL_MH_STORE_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_MH_STORE_TYPE, CamelMhStoreClass)) -#define IS_CAMEL_MH_STORE(o) (GTK_CHECK_TYPE((o), CAMEL_MH_STORE_TYPE)) +#define CAMEL_MH_STORE(obj) (CAMEL_CHECK_CAST((obj), CAMEL_MH_STORE_TYPE, CamelMhStore)) +#define CAMEL_MH_STORE_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_MH_STORE_TYPE, CamelMhStoreClass)) +#define IS_CAMEL_MH_STORE(o) (CAMEL_CHECK_TYPE((o), CAMEL_MH_STORE_TYPE)) typedef struct { CamelStore parent_object; @@ -49,8 +48,8 @@ typedef struct { /* public methods */ -/* Standard Gtk function */ -GtkType camel_mh_store_get_type(void); +/* Standard Camel function */ +CamelType camel_mh_store_get_type(void); const gchar *camel_mh_store_get_toplevel_dir(CamelMhStore * store); diff --git a/camel/providers/mh/camel-mh-summary.c b/camel/providers/mh/camel-mh-summary.c index 36bfd2f2cf..dff025b258 100644 --- a/camel/providers/mh/camel-mh-summary.c +++ b/camel/providers/mh/camel-mh-summary.c @@ -18,8 +18,6 @@ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -#include - #include "camel-mh-summary.h" #include @@ -43,7 +41,7 @@ static CamelMessageInfo *message_info_new(CamelFolderSummary *, struct _header_r static void camel_mh_summary_class_init (CamelMhSummaryClass *class); static void camel_mh_summary_init (CamelMhSummary *gspaper); -static void camel_mh_summary_finalise (GtkObject *obj); +static void camel_mh_summary_finalise (CamelObject *obj); #define _PRIVATE(x) (((CamelMhSummary *)(x))->priv) @@ -53,23 +51,19 @@ struct _CamelMhSummaryPrivate { static CamelFolderSummaryClass *parent_class; -guint +CamelType camel_mh_summary_get_type (void) { - static guint type = 0; + static CamelType type = CAMEL_INVALID_TYPE; - if (!type) { - GtkTypeInfo type_info = { - "CamelMhSummary", - sizeof(CamelMhSummary), - sizeof(CamelMhSummaryClass), - (GtkClassInitFunc)camel_mh_summary_class_init, - (GtkObjectInitFunc)camel_mh_summary_init, - (GtkArgSetFunc)NULL, - (GtkArgGetFunc)NULL - }; - - type = gtk_type_unique(camel_folder_summary_get_type (), &type_info); + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register(camel_folder_summary_get_type (), "CamelMhSummary", + sizeof(CamelMhSummary), + sizeof(CamelMhSummaryClass), + (CamelObjectClassInitFunc)camel_mh_summary_class_init, + NULL, + (CamelObjectInitFunc)camel_mh_summary_init, + (CamelObjectFinalizeFunc)camel_mh_summary_finalise); } return type; @@ -78,17 +72,12 @@ camel_mh_summary_get_type (void) static void camel_mh_summary_class_init (CamelMhSummaryClass *class) { - GtkObjectClass *object_class; CamelFolderSummaryClass *sklass = (CamelFolderSummaryClass *) class; - object_class = (GtkObjectClass *)class; - parent_class = gtk_type_class(camel_folder_summary_get_type ()); - - object_class->finalize = camel_mh_summary_finalise; + parent_class = CAMEL_FOLDER_SUMMARY_CLASS (camel_type_get_global_classfuncs(camel_folder_summary_get_type ())); /* override methods */ sklass->message_info_new = message_info_new; - } static void @@ -103,13 +92,12 @@ camel_mh_summary_init (CamelMhSummary *o) } static void -camel_mh_summary_finalise(GtkObject *obj) +camel_mh_summary_finalise(CamelObject *obj) { CamelMhSummary *o = (CamelMhSummary *)obj; g_free(o->mh_path); - - ((GtkObjectClass *)(parent_class))->finalize(obj); + g_free(o->priv); } /** @@ -121,7 +109,7 @@ camel_mh_summary_finalise(GtkObject *obj) **/ CamelMhSummary *camel_mh_summary_new (const char *filename, const char *mhdir, ibex *index) { - CamelMhSummary *o = (CamelMhSummary *)gtk_type_new(camel_mh_summary_get_type ()); + CamelMhSummary *o = (CamelMhSummary *)camel_object_new(camel_mh_summary_get_type ()); camel_folder_summary_set_build_content((CamelFolderSummary *)o, TRUE); camel_folder_summary_set_filename((CamelFolderSummary *)o, filename); @@ -181,7 +169,7 @@ int camel_mh_summary_add(CamelMhSummary * mhs, const char *name, int forceindex } mhs->priv->current_uid = (char *)name; camel_folder_summary_add_from_parser((CamelFolderSummary *)mhs, mp); - gtk_object_unref((GtkObject *)mp); + camel_object_unref((CamelObject *)mp); mhs->priv->current_uid = NULL; camel_folder_summary_set_index((CamelFolderSummary *)mhs, NULL); g_free(filename); diff --git a/camel/providers/mh/camel-mh-summary.h b/camel/providers/mh/camel-mh-summary.h index b7c8867959..28376c5d9b 100644 --- a/camel/providers/mh/camel-mh-summary.h +++ b/camel/providers/mh/camel-mh-summary.h @@ -21,14 +21,13 @@ #ifndef _CAMEL_MH_SUMMARY_H #define _CAMEL_MH_SUMMARY_H -#include #include #include #include -#define CAMEL_MH_SUMMARY(obj) GTK_CHECK_CAST (obj, camel_mh_summary_get_type (), CamelMhSummary) -#define CAMEL_MH_SUMMARY_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_mh_summary_get_type (), CamelMhSummaryClass) -#define IS_CAMEL_MH_SUMMARY(obj) GTK_CHECK_TYPE (obj, camel_mh_summary_get_type ()) +#define CAMEL_MH_SUMMARY(obj) CAMEL_CHECK_CAST (obj, camel_mh_summary_get_type (), CamelMhSummary) +#define CAMEL_MH_SUMMARY_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_mh_summary_get_type (), CamelMhSummaryClass) +#define IS_CAMEL_MH_SUMMARY(obj) CAMEL_CHECK_TYPE (obj, camel_mh_summary_get_type ()) typedef struct _CamelMhSummary CamelMhSummary; typedef struct _CamelMhSummaryClass CamelMhSummaryClass; @@ -49,7 +48,7 @@ struct _CamelMhSummaryClass { /* signals */ }; -guint camel_mh_summary_get_type (void); +CamelType camel_mh_summary_get_type (void); CamelMhSummary *camel_mh_summary_new (const char *filename, const char *mhdir, ibex *index); /* methods */ diff --git a/camel/providers/nntp/Makefile.am b/camel/providers/nntp/Makefile.am index 247dffbfd4..4b7c385872 100644 --- a/camel/providers/nntp/Makefile.am +++ b/camel/providers/nntp/Makefile.am @@ -7,15 +7,14 @@ providerdir = $(pkglibdir)/camel-providers/$(VERSION) provider_LTLIBRARIES = libcamelnntp.la provider_DATA = libcamelnntp.urls -INCLUDES = -I.. \ - -I$(srcdir)/.. \ +INCLUDES = -I../.. \ -I$(top_srcdir)/camel \ -I$(top_srcdir)/intl \ -I$(top_srcdir)/libibex \ -I$(top_srcdir)/e-util \ -I$(top_srcdir) \ -I$(includedir) \ - $(GTK_INCLUDEDIR) \ + $(GTK_INCLUDEDIR) \ -DG_LOG_DOMAIN=\"camel-nntp-provider\" libcamelnntp_la_SOURCES = \ diff --git a/camel/providers/nntp/camel-nntp-folder.c b/camel/providers/nntp/camel-nntp-folder.c index dae572136e..5beabb5587 100644 --- a/camel/providers/nntp/camel-nntp-folder.c +++ b/camel/providers/nntp/camel-nntp-folder.c @@ -52,9 +52,9 @@ static CamelFolderClass *parent_class=NULL; /* Returns the class for a CamelNNTPFolder */ -#define CNNTPF_CLASS(so) CAMEL_NNTP_FOLDER_CLASS (GTK_OBJECT(so)->klass) -#define CF_CLASS(so) CAMEL_FOLDER_CLASS (GTK_OBJECT(so)->klass) -#define CNNTPS_CLASS(so) CAMEL_STORE_CLASS (GTK_OBJECT(so)->klass) +#define CNNTPF_CLASS(so) CAMEL_NNTP_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CF_CLASS(so) CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CNNTPS_CLASS(so) CAMEL_STORE_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static void @@ -270,21 +270,21 @@ nntp_folder_get_message (CamelFolder *folder, const gchar *uid, CamelException * message = camel_mime_message_new (); if (camel_data_wrapper_construct_from_stream ((CamelDataWrapper *)message, message_stream) == -1) { - gtk_object_unref (GTK_OBJECT (message)); - gtk_object_unref (GTK_OBJECT (message_stream)); + camel_object_unref (CAMEL_OBJECT (message)); + camel_object_unref (CAMEL_OBJECT (message_stream)); camel_exception_setv (ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID, /* XXX */ "Could not create message for message_id %s.", message_id); return NULL; } - gtk_object_unref (GTK_OBJECT (message_stream)); + camel_object_unref (CAMEL_OBJECT (message_stream)); /* init other fields? */ - gtk_object_ref (GTK_OBJECT (folder)); + camel_object_ref (CAMEL_OBJECT (folder)); #if 0 - gtk_signal_connect (GTK_OBJECT (message), "message_changed", message_changed, folder); + gtk_signal_connect (CAMEL_OBJECT (message), "message_changed", message_changed, folder); #endif return message; @@ -356,22 +356,19 @@ nntp_folder_get_message_info (CamelFolder *folder, const char *uid) } static void -nntp_folder_finalize (GtkObject *object) +nntp_folder_finalize (CamelObject *object) { CamelNNTPFolder *nntp_folder = CAMEL_NNTP_FOLDER (object); g_free (nntp_folder->summary_file_path); - - GTK_OBJECT_CLASS (parent_class)->finalize (object); } static void camel_nntp_folder_class_init (CamelNNTPFolderClass *camel_nntp_folder_class) { CamelFolderClass *camel_folder_class = CAMEL_FOLDER_CLASS (camel_nntp_folder_class); - GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (camel_folder_class); - parent_class = gtk_type_class (camel_folder_get_type ()); + parent_class = CAMEL_FOLDER_CLASS (camel_type_get_global_classfuncs (camel_folder_get_type ())); /* virtual method definition */ @@ -393,30 +390,21 @@ camel_nntp_folder_class_init (CamelNNTPFolderClass *camel_nntp_folder_class) camel_folder_class->free_subfolder_names = nntp_folder_free_subfolder_names; camel_folder_class->search_by_expression = nntp_folder_search_by_expression; camel_folder_class->get_message_info = nntp_folder_get_message_info; - - gtk_object_class->finalize = nntp_folder_finalize; - } -GtkType +CamelType camel_nntp_folder_get_type (void) { - static GtkType camel_nntp_folder_type = 0; + static CamelType camel_nntp_folder_type = CAMEL_INVALID_TYPE; - if (!camel_nntp_folder_type) { - GtkTypeInfo camel_nntp_folder_info = - { - "CamelNNTPFolder", - sizeof (CamelNNTPFolder), - sizeof (CamelNNTPFolderClass), - (GtkClassInitFunc) camel_nntp_folder_class_init, - (GtkObjectInitFunc) NULL, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_nntp_folder_type = gtk_type_unique (CAMEL_FOLDER_TYPE, &camel_nntp_folder_info); + if (camel_nntp_folder_type == CAMEL_INVALID_TYPE) { + camel_nntp_folder_type = camel_type_register (CAMEL_FOLDER_TYPE, "CamelNNTPFolder", + sizeof (CamelNNTPFolder), + sizeof (CamelNNTPFolderClass), + (CamelObjectClassInitFunc) camel_nntp_folder_class_init, + NULL, + (CamelObjectInitFunc) NULL, + (CamelObjectFinalizeFunc) nntp_folder_finalize); } return camel_nntp_folder_type; diff --git a/camel/providers/nntp/camel-nntp-folder.h b/camel/providers/nntp/camel-nntp-folder.h index f6c04bb005..9bbd1466b9 100644 --- a/camel/providers/nntp/camel-nntp-folder.h +++ b/camel/providers/nntp/camel-nntp-folder.h @@ -33,15 +33,14 @@ extern "C" { #pragma } #endif /* __cplusplus }*/ -#include #include "camel-folder.h" /* #include "camel-store.h" */ #define CAMEL_NNTP_FOLDER_TYPE (camel_nntp_folder_get_type ()) -#define CAMEL_NNTP_FOLDER(obj) (GTK_CHECK_CAST((obj), CAMEL_NNTP_FOLDER_TYPE, CamelNNTPFolder)) -#define CAMEL_NNTP_FOLDER_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_NNTP_FOLDER_TYPE, CamelNNTPFolderClass)) -#define IS_CAMEL_NNTP_FOLDER(o) (GTK_CHECK_TYPE((o), CAMEL_NNTP_FOLDER_TYPE)) +#define CAMEL_NNTP_FOLDER(obj) (CAMEL_CHECK_CAST((obj), CAMEL_NNTP_FOLDER_TYPE, CamelNNTPFolder)) +#define CAMEL_NNTP_FOLDER_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_NNTP_FOLDER_TYPE, CamelNNTPFolderClass)) +#define IS_CAMEL_NNTP_FOLDER(o) (CAMEL_CHECK_TYPE((o), CAMEL_NNTP_FOLDER_TYPE)) typedef struct { @@ -64,8 +63,8 @@ typedef struct { /* public methods */ -/* Standard Gtk function */ -GtkType camel_nntp_folder_get_type (void); +/* Standard Camel function */ +CamelType camel_nntp_folder_get_type (void); #ifdef __cplusplus } diff --git a/camel/providers/nntp/camel-nntp-provider.c b/camel/providers/nntp/camel-nntp-provider.c index 8badba0e9c..214fd4b0fa 100644 --- a/camel/providers/nntp/camel-nntp-provider.c +++ b/camel/providers/nntp/camel-nntp-provider.c @@ -68,10 +68,13 @@ camel_provider_module_init (CamelSession *session) nntp_provider.object_types[CAMEL_PROVIDER_TRANSPORT] = camel_nntp_transport_get_type(); #endif - + news_provider.service_cache = g_hash_table_new (camel_url_hash, camel_url_equal); nntp_provider.service_cache = g_hash_table_new (camel_url_hash, camel_url_equal); - + camel_session_register_provider (session, &news_provider); camel_session_register_provider (session, &nntp_provider); } + + + diff --git a/camel/providers/nntp/camel-nntp-store.c b/camel/providers/nntp/camel-nntp-store.c index a7b8f7df01..48537ed2b3 100644 --- a/camel/providers/nntp/camel-nntp-store.c +++ b/camel/providers/nntp/camel-nntp-store.c @@ -51,9 +51,9 @@ static CamelServiceClass *service_class = NULL; /* Returns the class for a CamelNNTPStore */ -#define CNNTPS_CLASS(so) CAMEL_NNTP_STORE_CLASS (GTK_OBJECT(so)->klass) -#define CF_CLASS(so) CAMEL_FOLDER_CLASS (GTK_OBJECT(so)->klass) -#define CNNTPF_CLASS(so) CAMEL_NNTP_FOLDER_CLASS (GTK_OBJECT(so)->klass) +#define CNNTPS_CLASS(so) CAMEL_NNTP_STORE_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CF_CLASS(so) CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) +#define CNNTPF_CLASS(so) CAMEL_NNTP_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so)) static gboolean ensure_news_dir_exists (CamelNNTPStore *store); @@ -134,8 +134,8 @@ nntp_store_disconnect (CamelService *service, CamelException *ex) if (!service_class->disconnect (service, ex)) return FALSE; - gtk_object_unref (GTK_OBJECT (store->ostream)); - gtk_object_unref (GTK_OBJECT (store->istream)); + camel_object_unref (CAMEL_OBJECT (store->ostream)); + camel_object_unref (CAMEL_OBJECT (store->istream)); store->ostream = NULL; store->istream = NULL; return TRUE; @@ -165,7 +165,7 @@ nntp_store_get_folder (CamelStore *store, const gchar *folder_name, /* call the standard routine for that when */ /* it is done ... */ - new_nntp_folder = gtk_type_new (CAMEL_NNTP_FOLDER_TYPE); + new_nntp_folder = CAMEL_NNTP_FOLDER (camel_object_new (CAMEL_NNTP_FOLDER_TYPE)); new_folder = CAMEL_FOLDER (new_nntp_folder); /* XXX We shouldn't be passing NULL here, but it's equivalent to @@ -186,7 +186,7 @@ nntp_store_get_folder_name (CamelStore *store, const char *folder_name, } static void -finalize (GtkObject *object) +finalize (CamelObject *object) { CamelException ex; @@ -198,16 +198,12 @@ finalize (GtkObject *object) static void camel_nntp_store_class_init (CamelNNTPStoreClass *camel_nntp_store_class) { - GtkObjectClass *object_class = - GTK_OBJECT_CLASS (camel_nntp_store_class); CamelStoreClass *camel_store_class = CAMEL_STORE_CLASS (camel_nntp_store_class); CamelServiceClass *camel_service_class = CAMEL_SERVICE_CLASS (camel_nntp_store_class); - service_class = gtk_type_class (camel_service_get_type ()); + service_class = CAMEL_SERVICE_CLASS (camel_type_get_global_classfuncs (camel_service_get_type ())); /* virtual method overload */ - object_class->finalize = finalize; - camel_service_class->connect = nntp_store_connect; camel_service_class->disconnect = nntp_store_disconnect; camel_service_class->get_name = nntp_store_get_name; @@ -226,25 +222,19 @@ camel_nntp_store_init (gpointer object, gpointer klass) service->url_flags = CAMEL_SERVICE_URL_NEED_HOST; } -GtkType +CamelType camel_nntp_store_get_type (void) { - static GtkType camel_nntp_store_type = 0; + static CamelType camel_nntp_store_type = CAMEL_INVALID_TYPE; - if (!camel_nntp_store_type) { - GtkTypeInfo camel_nntp_store_info = - { - "CamelNNTPStore", - sizeof (CamelNNTPStore), - sizeof (CamelNNTPStoreClass), - (GtkClassInitFunc) camel_nntp_store_class_init, - (GtkObjectInitFunc) camel_nntp_store_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_nntp_store_type = gtk_type_unique (CAMEL_STORE_TYPE, &camel_nntp_store_info); + if (camel_nntp_store_type == CAMEL_INVALID_TYPE) { + camel_nntp_store_type = camel_type_register (CAMEL_STORE_TYPE, "CamelNNTPStore", + sizeof (CamelNNTPStore), + sizeof (CamelNNTPStoreClass), + (CamelObjectClassInitFunc) camel_nntp_store_class_init, + NULL, + (CamelObjectInitFunc) camel_nntp_store_init, + (CamelObjectFinalizeFunc) finalize); } return camel_nntp_store_type; diff --git a/camel/providers/nntp/camel-nntp-store.h b/camel/providers/nntp/camel-nntp-store.h index 9d4d6edebc..3099f84962 100644 --- a/camel/providers/nntp/camel-nntp-store.h +++ b/camel/providers/nntp/camel-nntp-store.h @@ -31,14 +31,13 @@ extern "C" { #pragma } #endif /* __cplusplus }*/ -#include #include "camel-store.h" #include "camel-nntp-newsrc.h" #define CAMEL_NNTP_STORE_TYPE (camel_nntp_store_get_type ()) -#define CAMEL_NNTP_STORE(obj) (GTK_CHECK_CAST((obj), CAMEL_NNTP_STORE_TYPE, CamelNNTPStore)) -#define CAMEL_NNTP_STORE_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_NNTP_STORE_TYPE, CamelNNTPStoreClass)) -#define IS_CAMEL_NNTP_STORE(o) (GTK_CHECK_TYPE((o), CAMEL_NNTP_STORE_TYPE)) +#define CAMEL_NNTP_STORE(obj) (CAMEL_CHECK_CAST((obj), CAMEL_NNTP_STORE_TYPE, CamelNNTPStore)) +#define CAMEL_NNTP_STORE_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_NNTP_STORE_TYPE, CamelNNTPStoreClass)) +#define IS_CAMEL_NNTP_STORE(o) (CAMEL_CHECK_TYPE((o), CAMEL_NNTP_STORE_TYPE)) typedef struct { @@ -76,8 +75,8 @@ enum { CAMEL_NNTP_OK, CAMEL_NNTP_ERR, CAMEL_NNTP_FAIL }; int camel_nntp_command (CamelNNTPStore *store, char **ret, char *fmt, ...); char *camel_nntp_command_get_additional_data (CamelNNTPStore *store); -/* Standard Gtk function */ -GtkType camel_nntp_store_get_type (void); +/* Standard Camel function */ +CamelType camel_nntp_store_get_type (void); #ifdef __cplusplus } diff --git a/camel/providers/pop3/camel-pop3-folder.c b/camel/providers/pop3/camel-pop3-folder.c index 9733a5f114..6dbba64c20 100644 --- a/camel/providers/pop3/camel-pop3-folder.c +++ b/camel/providers/pop3/camel-pop3-folder.c @@ -33,10 +33,10 @@ #include #include -#define CF_CLASS(o) (CAMEL_FOLDER_CLASS (GTK_OBJECT (o)->klass)) +#define CF_CLASS(o) (CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(o))) static CamelFolderClass *parent_class; -static void pop3_finalize (GtkObject *object); +static void pop3_finalize (CamelObject *object); static void pop3_sync (CamelFolder *folder, gboolean expunge, CamelException *ex); @@ -56,10 +56,8 @@ camel_pop3_folder_class_init (CamelPop3FolderClass *camel_pop3_folder_class) { CamelFolderClass *camel_folder_class = CAMEL_FOLDER_CLASS (camel_pop3_folder_class); - GtkObjectClass *object_class = - GTK_OBJECT_CLASS (camel_pop3_folder_class); - parent_class = gtk_type_class (camel_folder_get_type ()); + parent_class = CAMEL_FOLDER_CLASS(camel_type_get_global_classfuncs (camel_folder_get_type ())); /* virtual method overload */ camel_folder_class->sync = pop3_sync; @@ -70,12 +68,10 @@ camel_pop3_folder_class_init (CamelPop3FolderClass *camel_pop3_folder_class) camel_folder_class->get_message = pop3_get_message; camel_folder_class->set_message_flags = pop3_set_message_flags; - - object_class->finalize = pop3_finalize; } static void -camel_pop3_folder_init (gpointer object, gpointer klass) +camel_pop3_folder_init (gpointer object) { CamelFolder *folder = CAMEL_FOLDER (object); @@ -85,32 +81,26 @@ camel_pop3_folder_init (gpointer object, gpointer klass) folder->has_search_capability = FALSE; } -GtkType +CamelType camel_pop3_folder_get_type (void) { - static GtkType camel_pop3_folder_type = 0; + static CamelType camel_pop3_folder_type = CAMEL_INVALID_TYPE; if (!camel_pop3_folder_type) { - GtkTypeInfo camel_pop3_folder_info = - { - "CamelPop3Folder", - sizeof (CamelPop3Folder), - sizeof (CamelPop3FolderClass), - (GtkClassInitFunc) camel_pop3_folder_class_init, - (GtkObjectInitFunc) camel_pop3_folder_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_pop3_folder_type = gtk_type_unique (CAMEL_FOLDER_TYPE, &camel_pop3_folder_info); + camel_pop3_folder_type = camel_type_register (CAMEL_FOLDER_TYPE, "CamelPop3Folder", + sizeof (CamelPop3Folder), + sizeof (CamelPop3FolderClass), + (CamelObjectClassInitFunc) camel_pop3_folder_class_init, + NULL, + (CamelObjectInitFunc) camel_pop3_folder_init, + (CamelObjectFinalizeFunc) pop3_finalize); } return camel_pop3_folder_type; } void -pop3_finalize (GtkObject *object) +pop3_finalize (CamelObject *object) { CamelPop3Folder *pop3_folder = CAMEL_POP3_FOLDER (object); @@ -171,7 +161,7 @@ camel_pop3_folder_new (CamelStore *parent, CamelException *ex) } } - pop3_folder = gtk_type_new (CAMEL_POP3_FOLDER_TYPE); + pop3_folder = CAMEL_POP3_FOLDER(camel_object_new (CAMEL_POP3_FOLDER_TYPE)); CF_CLASS (pop3_folder)->init ((CamelFolder *)pop3_folder, parent, NULL, "inbox", "/", TRUE, ex); pop3_folder->uids = uids; @@ -304,7 +294,7 @@ pop3_get_message (CamelFolder *folder, const char *uid, CamelException *ex) camel_data_wrapper_construct_from_stream (CAMEL_DATA_WRAPPER (msg), CAMEL_STREAM (msgstream)); - gtk_object_unref (GTK_OBJECT (msgstream)); + camel_object_unref (CAMEL_OBJECT (msgstream)); return msg; } diff --git a/camel/providers/pop3/camel-pop3-folder.h b/camel/providers/pop3/camel-pop3-folder.h index 89c16c4c89..b4cfd469b6 100644 --- a/camel/providers/pop3/camel-pop3-folder.h +++ b/camel/providers/pop3/camel-pop3-folder.h @@ -33,13 +33,12 @@ extern "C" { #pragma } #endif /* __cplusplus }*/ -#include #include "camel-folder.h" #define CAMEL_POP3_FOLDER_TYPE (camel_pop3_folder_get_type ()) -#define CAMEL_POP3_FOLDER(obj) (GTK_CHECK_CAST((obj), CAMEL_POP3_FOLDER_TYPE, CamelPop3Folder)) -#define CAMEL_POP3_FOLDER_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_POP3_FOLDER_TYPE, CamelPop3FolderClass)) -#define IS_CAMEL_POP3_FOLDER(o) (GTK_CHECK_TYPE((o), CAMEL_POP3_FOLDER_TYPE)) +#define CAMEL_POP3_FOLDER(obj) (CAMEL_CHECK_CAST((obj), CAMEL_POP3_FOLDER_TYPE, CamelPop3Folder)) +#define CAMEL_POP3_FOLDER_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_POP3_FOLDER_TYPE, CamelPop3FolderClass)) +#define IS_CAMEL_POP3_FOLDER(o) (CAMEL_CHECK_TYPE((o), CAMEL_POP3_FOLDER_TYPE)) typedef struct { @@ -63,8 +62,8 @@ typedef struct { /* public methods */ CamelFolder *camel_pop3_folder_new (CamelStore *parent, CamelException *ex); -/* Standard Gtk function */ -GtkType camel_pop3_folder_get_type (void); +/* Standard Camel function */ +CamelType camel_pop3_folder_get_type (void); #ifdef __cplusplus } diff --git a/camel/providers/pop3/camel-pop3-store.c b/camel/providers/pop3/camel-pop3-store.c index 953a286a25..3cab99e0dd 100644 --- a/camel/providers/pop3/camel-pop3-store.c +++ b/camel/providers/pop3/camel-pop3-store.c @@ -58,7 +58,7 @@ static CamelServiceClass *service_class = NULL; -static void finalize (GtkObject *object); +static void finalize (CamelObject *object); static gboolean pop3_connect (CamelService *service, CamelException *ex); static gboolean pop3_disconnect (CamelService *service, CamelException *ex); @@ -78,18 +78,14 @@ static int pop3_get_response (CamelPop3Store *store, char **ret); static void camel_pop3_store_class_init (CamelPop3StoreClass *camel_pop3_store_class) { - GtkObjectClass *object_class = - GTK_OBJECT_CLASS (camel_pop3_store_class); CamelServiceClass *camel_service_class = CAMEL_SERVICE_CLASS (camel_pop3_store_class); CamelStoreClass *camel_store_class = CAMEL_STORE_CLASS (camel_pop3_store_class); - service_class = gtk_type_class (camel_service_get_type ()); + service_class = CAMEL_SERVICE_CLASS(camel_type_get_global_classfuncs (camel_service_get_type ())); /* virtual method overload */ - object_class->finalize = finalize; - camel_service_class->connect = pop3_connect; camel_service_class->disconnect = pop3_disconnect; camel_service_class->query_auth_types = query_auth_types; @@ -111,32 +107,26 @@ camel_pop3_store_init (gpointer object, gpointer klass) service->url_flags = (CAMEL_SERVICE_URL_NEED_USER | CAMEL_SERVICE_URL_NEED_HOST); } -GtkType +CamelType camel_pop3_store_get_type (void) { - static GtkType camel_pop3_store_type = 0; + static CamelType camel_pop3_store_type = CAMEL_INVALID_TYPE; if (!camel_pop3_store_type) { - GtkTypeInfo camel_pop3_store_info = - { - "CamelPop3Store", - sizeof (CamelPop3Store), - sizeof (CamelPop3StoreClass), - (GtkClassInitFunc) camel_pop3_store_class_init, - (GtkObjectInitFunc) camel_pop3_store_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_pop3_store_type = gtk_type_unique (CAMEL_STORE_TYPE, &camel_pop3_store_info); + camel_pop3_store_type = camel_type_register (CAMEL_STORE_TYPE, "CamelPop3Store", + sizeof (CamelPop3Store), + sizeof (CamelPop3StoreClass), + (CamelObjectClassInitFunc) camel_pop3_store_class_init, + NULL, + (CamelObjectInitFunc) camel_pop3_store_init, + finalize); } return camel_pop3_store_type; } static void -finalize (GtkObject *object) +finalize (CamelObject *object) { CamelPop3Store *pop3_store = CAMEL_POP3_STORE (object); CamelException ex; @@ -548,11 +538,11 @@ pop3_disconnect (CamelService *service, CamelException *ex) d(printf ("POP3: Disconnecting from %s\n", service->url->host)); if (store->ostream) { - gtk_object_unref (GTK_OBJECT (store->ostream)); + camel_object_unref (CAMEL_OBJECT (store->ostream)); store->ostream = NULL; } if (store->istream) { - gtk_object_unref (GTK_OBJECT (store->istream)); + camel_object_unref (CAMEL_OBJECT (store->istream)); store->istream = NULL; } diff --git a/camel/providers/pop3/camel-pop3-store.h b/camel/providers/pop3/camel-pop3-store.h index 74174a32f2..f5e447d9ea 100644 --- a/camel/providers/pop3/camel-pop3-store.h +++ b/camel/providers/pop3/camel-pop3-store.h @@ -33,14 +33,13 @@ extern "C" { #pragma } #endif /* __cplusplus }*/ -#include #include "camel-types.h" #include "camel-store.h" #define CAMEL_POP3_STORE_TYPE (camel_pop3_store_get_type ()) -#define CAMEL_POP3_STORE(obj) (GTK_CHECK_CAST((obj), CAMEL_POP3_STORE_TYPE, CamelPop3Store)) -#define CAMEL_POP3_STORE_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_POP3_STORE_TYPE, CamelPop3StoreClass)) -#define IS_CAMEL_POP3_STORE(o) (GTK_CHECK_TYPE((o), CAMEL_POP3_STORE_TYPE)) +#define CAMEL_POP3_STORE(obj) (CAMEL_CHECK_CAST((obj), CAMEL_POP3_STORE_TYPE, CamelPop3Store)) +#define CAMEL_POP3_STORE_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_POP3_STORE_TYPE, CamelPop3StoreClass)) +#define IS_CAMEL_POP3_STORE(o) (CAMEL_CHECK_TYPE((o), CAMEL_POP3_STORE_TYPE)) typedef struct { @@ -70,8 +69,8 @@ int camel_pop3_command (CamelPop3Store *store, char **ret, char *fmt, ...); char *camel_pop3_command_get_additional_data (CamelPop3Store *store, CamelException *ex); -/* Standard Gtk function */ -GtkType camel_pop3_store_get_type (void); +/* Standard Camel function */ +CamelType camel_pop3_store_get_type (void); #ifdef __cplusplus } diff --git a/camel/providers/sendmail/camel-sendmail-transport.c b/camel/providers/sendmail/camel-sendmail-transport.c index 3facc42676..c53512ccb4 100644 --- a/camel/providers/sendmail/camel-sendmail-transport.c +++ b/camel/providers/sendmail/camel-sendmail-transport.c @@ -64,25 +64,19 @@ camel_sendmail_transport_class_init (CamelSendmailTransportClass *camel_sendmail camel_transport_class->send_to = _send_to; } -GtkType +CamelType camel_sendmail_transport_get_type (void) { - static GtkType camel_sendmail_transport_type = 0; + static CamelType camel_sendmail_transport_type = CAMEL_INVALID_TYPE; - if (!camel_sendmail_transport_type) { - GtkTypeInfo camel_sendmail_transport_info = - { - "CamelSendmailTransport", - sizeof (CamelSendmailTransport), - sizeof (CamelSendmailTransportClass), - (GtkClassInitFunc) camel_sendmail_transport_class_init, - (GtkObjectInitFunc) NULL, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_sendmail_transport_type = gtk_type_unique (CAMEL_TRANSPORT_TYPE, &camel_sendmail_transport_info); + if (camel_sendmail_transport_type == CAMEL_INVALID_TYPE) { + camel_sendmail_transport_type = camel_type_register (CAMEL_TRANSPORT_TYPE, "CamelSendmailTransport", + sizeof (CamelSendmailTransport), + sizeof (CamelSendmailTransportClass), + (CamelObjectClassInitFunc) camel_sendmail_transport_class_init, + NULL, + (CamelObjectInitFunc) NULL, + NULL); } return camel_sendmail_transport_type; @@ -148,13 +142,13 @@ _send_internal (CamelMedium *message, char **argv, CamelException *ex) out = camel_stream_fs_new_with_fd (fd[1]); if (camel_data_wrapper_write_to_stream (CAMEL_DATA_WRAPPER (message), out) == -1 || camel_stream_close(out) == -1) { - gtk_object_unref (GTK_OBJECT (out)); + camel_object_unref (CAMEL_OBJECT (out)); camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, "Could not send message: %s", strerror(errno)); return FALSE; } - gtk_object_unref (GTK_OBJECT (out)); + camel_object_unref (CAMEL_OBJECT (out)); /* Wait for sendmail to exit. */ while (waitpid (pid, &wstat, 0) == -1 && errno == EINTR) diff --git a/camel/providers/sendmail/camel-sendmail-transport.h b/camel/providers/sendmail/camel-sendmail-transport.h index 3f3714584a..bb5dca071b 100644 --- a/camel/providers/sendmail/camel-sendmail-transport.h +++ b/camel/providers/sendmail/camel-sendmail-transport.h @@ -37,9 +37,9 @@ extern "C" { #include "camel-transport.h" #define CAMEL_SENDMAIL_TRANSPORT_TYPE (camel_sendmail_transport_get_type ()) -#define CAMEL_SENDMAIL_TRANSPORT(obj) (GTK_CHECK_CAST((obj), CAMEL_SENDMAIL_TRANSPORT_TYPE, CamelSendmailTransport)) -#define CAMEL_SENDMAIL_TRANSPORT_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_SENDMAIL_TRANSPORT_TYPE, CamelSendmailTransportClass)) -#define CAMEL_IS_SENDMAIL_TRANSPORT(o) (GTK_CHECK_TYPE((o), CAMEL_SENDMAIL_TRANSPORT_TYPE)) +#define CAMEL_SENDMAIL_TRANSPORT(obj) (CAMEL_CHECK_CAST((obj), CAMEL_SENDMAIL_TRANSPORT_TYPE, CamelSendmailTransport)) +#define CAMEL_SENDMAIL_TRANSPORT_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_SENDMAIL_TRANSPORT_TYPE, CamelSendmailTransportClass)) +#define CAMEL_IS_SENDMAIL_TRANSPORT(o) (CAMEL_CHECK_TYPE((o), CAMEL_SENDMAIL_TRANSPORT_TYPE)) typedef struct { @@ -54,8 +54,8 @@ typedef struct { } CamelSendmailTransportClass; -/* Standard Gtk function */ -GtkType camel_sendmail_transport_get_type (void); +/* Standard Camel function */ +CamelType camel_sendmail_transport_get_type (void); #ifdef __cplusplus } diff --git a/camel/providers/smtp/camel-smtp-transport.c b/camel/providers/smtp/camel-smtp-transport.c index 0f70d6314e..83241b2cad 100644 --- a/camel/providers/smtp/camel-smtp-transport.c +++ b/camel/providers/smtp/camel-smtp-transport.c @@ -83,7 +83,7 @@ camel_smtp_transport_class_init (CamelSmtpTransportClass *camel_smtp_transport_c CamelServiceClass *camel_service_class = CAMEL_SERVICE_CLASS (camel_smtp_transport_class); - service_class = gtk_type_class (camel_service_get_type ()); + service_class = CAMEL_SERVICE_CLASS(camel_type_get_global_classfuncs (camel_service_get_type ())); /* virtual method overload */ camel_service_class->connect = smtp_connect; @@ -98,32 +98,26 @@ camel_smtp_transport_class_init (CamelSmtpTransportClass *camel_smtp_transport_c } static void -camel_smtp_transport_init (gpointer object, gpointer klass) +camel_smtp_transport_init (gpointer object) { CamelService *service = CAMEL_SERVICE (object); service->url_flags = CAMEL_SERVICE_URL_NEED_HOST; } -GtkType +CamelType camel_smtp_transport_get_type (void) { - static GtkType camel_smtp_transport_type = 0; - - if (!camel_smtp_transport_type) { - GtkTypeInfo camel_smtp_transport_info = - { - "CamelSmtpTransport", - sizeof (CamelSmtpTransport), - sizeof (CamelSmtpTransportClass), - (GtkClassInitFunc) camel_smtp_transport_class_init, - (GtkObjectInitFunc) camel_smtp_transport_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - camel_smtp_transport_type = gtk_type_unique (CAMEL_TRANSPORT_TYPE, &camel_smtp_transport_info); + static CamelType camel_smtp_transport_type = CAMEL_INVALID_TYPE; + + if (camel_smtp_transport_type == CAMEL_INVALID_TYPE) { + camel_smtp_transport_type = camel_type_register (CAMEL_TRANSPORT_TYPE, "CamelSmtpTransport", + sizeof (CamelSmtpTransport), + sizeof (CamelSmtpTransportClass), + (CamelObjectClassInitFunc) camel_smtp_transport_class_init, + NULL, + (CamelObjectInitFunc) camel_smtp_transport_init, + NULL); } return camel_smtp_transport_type; @@ -241,8 +235,8 @@ smtp_disconnect (CamelService *service, CamelException *ex) g_free (transport->esmtp_supported_authtypes); transport->esmtp_supported_authtypes = NULL; - gtk_object_unref (GTK_OBJECT (transport->ostream)); - gtk_object_unref (GTK_OBJECT (transport->istream)); + camel_object_unref (CAMEL_OBJECT (transport->ostream)); + camel_object_unref (CAMEL_OBJECT (transport->istream)); transport->ostream = NULL; transport->istream = NULL; @@ -691,7 +685,7 @@ smtp_data (CamelSmtpTransport *transport, CamelMedium *message, CamelException * camel_stream_filter_remove (filtered_stream, id); camel_stream_flush (CAMEL_STREAM(filtered_stream)); - gtk_object_unref (GTK_OBJECT(filtered_stream)); + camel_object_unref (CAMEL_OBJECT(filtered_stream)); /* terminate the message body */ diff --git a/camel/providers/smtp/camel-smtp-transport.h b/camel/providers/smtp/camel-smtp-transport.h index c11b8b4738..21bdaa03f7 100644 --- a/camel/providers/smtp/camel-smtp-transport.h +++ b/camel/providers/smtp/camel-smtp-transport.h @@ -43,9 +43,9 @@ extern "C" { #include "camel-transport.h" #define CAMEL_SMTP_TRANSPORT_TYPE (camel_smtp_transport_get_type ()) -#define CAMEL_SMTP_TRANSPORT(obj) (GTK_CHECK_CAST((obj), CAMEL_SMTP_TRANSPORT_TYPE, CamelSmtpTransport)) -#define CAMEL_SMTP_TRANSPORT_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_SMTP_TRANSPORT_TYPE, CamelSmtpTransportClass)) -#define IS_CAMEL_SMTP_TRANSPORT(o) (GTK_CHECK_TYPE((o), CAMEL_SMTP_TRANSPORT_TYPE)) +#define CAMEL_SMTP_TRANSPORT(obj) (CAMEL_CHECK_CAST((obj), CAMEL_SMTP_TRANSPORT_TYPE, CamelSmtpTransport)) +#define CAMEL_SMTP_TRANSPORT_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_SMTP_TRANSPORT_TYPE, CamelSmtpTransportClass)) +#define IS_CAMEL_SMTP_TRANSPORT(o) (CAMEL_CHECK_TYPE((o), CAMEL_SMTP_TRANSPORT_TYPE)) typedef struct { @@ -69,8 +69,8 @@ typedef struct { } CamelSmtpTransportClass; -/* Standard Gtk function */ -GtkType camel_smtp_transport_get_type (void); +/* Standard Camel function */ +CamelType camel_smtp_transport_get_type (void); #ifdef __cplusplus } diff --git a/camel/providers/vee/camel-vee-folder.c b/camel/providers/vee/camel-vee-folder.c index 18eb49bc98..87f2be856b 100644 --- a/camel/providers/vee/camel-vee-folder.c +++ b/camel/providers/vee/camel-vee-folder.c @@ -63,36 +63,26 @@ static void vee_set_message_user_flag (CamelFolder *folder, const char *uid, con static void camel_vee_folder_class_init (CamelVeeFolderClass *klass); static void camel_vee_folder_init (CamelVeeFolder *obj); -static void camel_vee_folder_finalise (GtkObject *obj); +static void camel_vee_folder_finalise (CamelObject *obj); static void vee_folder_build(CamelVeeFolder *vf, CamelException *ex); static void vee_folder_build_folder(CamelVeeFolder *vf, CamelFolder *source, CamelException *ex); static CamelFolderClass *camel_vee_folder_parent; -enum SIGNALS { - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = { 0 }; - -guint +CamelType camel_vee_folder_get_type (void) { - static guint type = 0; + static CamelType type = CAMEL_INVALID_TYPE; - if (!type) { - GtkTypeInfo type_info = { - "CamelVeeFolder", - sizeof (CamelVeeFolder), - sizeof (CamelVeeFolderClass), - (GtkClassInitFunc) camel_vee_folder_class_init, - (GtkObjectInitFunc) camel_vee_folder_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_folder_get_type (), &type_info); + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_folder_get_type (), "CamelVeeFolder", + sizeof (CamelVeeFolder), + sizeof (CamelVeeFolderClass), + (CamelObjectClassInitFunc) camel_vee_folder_class_init, + NULL, + (CamelObjectInitFunc) camel_vee_folder_init, + (CamelObjectFinalizeFunc) camel_vee_folder_finalise); } return type; @@ -101,10 +91,9 @@ camel_vee_folder_get_type (void) static void camel_vee_folder_class_init (CamelVeeFolderClass *klass) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; CamelFolderClass *folder_class = (CamelFolderClass *) klass; - camel_vee_folder_parent = gtk_type_class (camel_folder_get_type ()); + camel_vee_folder_parent = CAMEL_FOLDER_CLASS(camel_type_get_global_classfuncs (camel_folder_get_type ())); folder_class->init = vee_init; folder_class->sync = vee_sync; @@ -125,10 +114,6 @@ camel_vee_folder_class_init (CamelVeeFolderClass *klass) folder_class->set_message_flags = vee_set_message_flags; folder_class->get_message_user_flag = vee_get_message_user_flag; folder_class->set_message_user_flag = vee_set_message_user_flag; - - object_class->finalize = camel_vee_folder_finalise; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); } static void @@ -140,7 +125,7 @@ camel_vee_folder_init (CamelVeeFolder *obj) } static void -camel_vee_folder_finalise (GtkObject *obj) +camel_vee_folder_finalise (CamelObject *obj) { CamelVeeFolder *vf = (CamelVeeFolder *)obj; struct _CamelVeeFolderPrivate *p = _PRIVATE(vf); @@ -149,11 +134,9 @@ camel_vee_folder_finalise (GtkObject *obj) node = p->folders; while (node) { CamelFolder *f = node->data; - gtk_object_unref((GtkObject *)f); + camel_object_unref((CamelObject *)f); node = g_list_next(node); } - - ((GtkObjectClass *)(camel_vee_folder_parent))->finalize((GtkObject *)obj); } /** @@ -166,12 +149,12 @@ camel_vee_folder_finalise (GtkObject *obj) CamelVeeFolder * camel_vee_folder_new (void) { - CamelVeeFolder *new = CAMEL_VEE_FOLDER ( gtk_type_new (camel_vee_folder_get_type ())); + CamelVeeFolder *new = CAMEL_VEE_FOLDER ( camel_object_new (camel_vee_folder_get_type ())); return new; } static void -folder_changed(CamelFolder *sub, int type, CamelVeeFolder *vf) +folder_changed(CamelFolder *sub, gpointer type, CamelVeeFolder *vf) { CamelException *ex; @@ -179,7 +162,7 @@ folder_changed(CamelFolder *sub, int type, CamelVeeFolder *vf) vee_folder_build_folder(vf, sub, ex); camel_exception_free(ex); /* FIXME: should only raise follow-on event if the result changed */ - gtk_signal_emit_by_name((GtkObject *)vf, "folder_changed", 0); + camel_object_trigger_event( CAMEL_OBJECT(vf), "folder_changed", GINT_TO_POINTER(0)); } /* track flag changes in the summary */ @@ -203,7 +186,7 @@ message_changed(CamelFolder *f, const char *uid, CamelVeeFolder *mf) camel_flag_set(&vinfo->user_flags, flag->name, TRUE); flag = flag->next; } - gtk_signal_emit_by_name((GtkObject *)mf, "message_changed", vinfo->uid); + camel_object_trigger_event( CAMEL_OBJECT(mf), "message_changed", vinfo->uid); } g_free(vuid); } @@ -214,17 +197,17 @@ camel_vee_folder_add_folder(CamelVeeFolder *vf, CamelFolder *sub) struct _CamelVeeFolderPrivate *p = _PRIVATE(vf); CamelException *ex; - gtk_object_ref((GtkObject *)sub); + camel_object_ref((CamelObject *)sub); p->folders = g_list_append(p->folders, sub); - gtk_signal_connect((GtkObject *)sub, "folder_changed", folder_changed, vf); - gtk_signal_connect((GtkObject *)sub, "message_changed", message_changed, vf); + camel_object_hook_event ((CamelObject *)sub, "folder_changed", (CamelObjectEventHookFunc) folder_changed, vf); + camel_object_hook_event ((CamelObject *)sub, "message_changed", (CamelObjectEventHookFunc) message_changed, vf); ex = camel_exception_new(); vee_folder_build_folder(vf, sub, ex); camel_exception_free(ex); /* FIXME: should only raise follow-on event if the result changed */ - gtk_signal_emit_by_name((GtkObject *)vf, "folder_changed", 0); + camel_object_trigger_event( CAMEL_OBJECT(vf), "folder_changed", GINT_TO_POINTER(0)); } diff --git a/camel/providers/vee/camel-vee-folder.h b/camel/providers/vee/camel-vee-folder.h index ea2a82a25b..6f7c788125 100644 --- a/camel/providers/vee/camel-vee-folder.h +++ b/camel/providers/vee/camel-vee-folder.h @@ -22,12 +22,11 @@ #ifndef _CAMEL_VEE_FOLDER_H #define _CAMEL_VEE_FOLDER_H -#include #include -#define CAMEL_VEE_FOLDER(obj) GTK_CHECK_CAST (obj, camel_vee_folder_get_type (), CamelVeeFolder) -#define CAMEL_VEE_FOLDER_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_vee_folder_get_type (), CamelVeeFolderClass) -#define IS_CAMEL_VEE_FOLDER(obj) GTK_CHECK_TYPE (obj, camel_vee_folder_get_type ()) +#define CAMEL_VEE_FOLDER(obj) CAMEL_CHECK_CAST (obj, camel_vee_folder_get_type (), CamelVeeFolder) +#define CAMEL_VEE_FOLDER_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_vee_folder_get_type (), CamelVeeFolderClass) +#define IS_CAMEL_VEE_FOLDER(obj) CAMEL_CHECK_TYPE (obj, camel_vee_folder_get_type ()) typedef struct _CamelVeeFolder CamelVeeFolder; typedef struct _CamelVeeFolderClass CamelVeeFolderClass; diff --git a/camel/providers/vee/camel-vee-store.c b/camel/providers/vee/camel-vee-store.c index 4b1fc3f23b..8be8298b2c 100644 --- a/camel/providers/vee/camel-vee-store.c +++ b/camel/providers/vee/camel-vee-store.c @@ -32,33 +32,22 @@ struct _CamelVeeStorePrivate { static void camel_vee_store_class_init (CamelVeeStoreClass *klass); static void camel_vee_store_init (CamelVeeStore *obj); -static void camel_vee_store_finalise (GtkObject *obj); static CamelStoreClass *camel_vee_store_parent; -enum SIGNALS { - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = { 0 }; - -guint +CamelType camel_vee_store_get_type (void) { - static guint type = 0; + static CamelType type = CAMEL_INVALID_TYPE; - if (!type) { - GtkTypeInfo type_info = { - "CamelVeeStore", - sizeof (CamelVeeStore), - sizeof (CamelVeeStoreClass), - (GtkClassInitFunc) camel_vee_store_class_init, - (GtkObjectInitFunc) camel_vee_store_init, - (GtkArgSetFunc) NULL, - (GtkArgGetFunc) NULL - }; - - type = gtk_type_unique (camel_store_get_type (), &type_info); + if (type == CAMEL_INVALID_TYPE) { + type = camel_type_register (camel_store_get_type (), "CamelVeeStore", + sizeof (CamelVeeStore), + sizeof (CamelVeeStoreClass), + (CamelObjectClassInitFunc) camel_vee_store_class_init, + NULL, + (CamelObjectInitFunc) camel_vee_store_init, + NULL); } return type; @@ -68,18 +57,13 @@ static void camel_vee_store_class_init (CamelVeeStoreClass *klass) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; CamelStoreClass *store_class = (CamelStoreClass *) klass; - camel_vee_store_parent = gtk_type_class (camel_store_get_type ()); + camel_vee_store_parent = CAMEL_STORE_CLASS(camel_type_get_global_classfuncs (camel_store_get_type ())); /* virtual method overload */ store_class->get_folder = vee_get_folder; store_class->get_folder_name = vee_get_folder_name; - - object_class->finalize = camel_vee_store_finalise; - - gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); } static void @@ -90,12 +74,6 @@ camel_vee_store_init (CamelVeeStore *obj) p = _PRIVATE(obj) = g_malloc0(sizeof(*p)); } -static void -camel_vee_store_finalise (GtkObject *obj) -{ - ((GtkObjectClass *)(camel_vee_store_parent))->finalize((GtkObject *)obj); -} - /** * camel_vee_store_new: * @@ -106,7 +84,7 @@ camel_vee_store_finalise (GtkObject *obj) CamelVeeStore * camel_vee_store_new (void) { - CamelVeeStore *new = CAMEL_VEE_STORE ( gtk_type_new (camel_vee_store_get_type ())); + CamelVeeStore *new = CAMEL_VEE_STORE ( camel_object_new (camel_vee_store_get_type ())); return new; } @@ -115,9 +93,9 @@ vee_get_folder (CamelStore *store, const char *folder_name, gboolean create, Cam { CamelFolder *folder; - folder = gtk_type_new (camel_vee_folder_get_type()); + folder = CAMEL_FOLDER (camel_object_new (camel_vee_folder_get_type())); - ((CamelFolderClass *)((GtkObject *)folder)->klass)->init (folder, store, NULL, folder_name, "/", TRUE, ex); + ((CamelFolderClass *)(CAMEL_OBJECT_GET_CLASS(folder)))->init (folder, store, NULL, folder_name, "/", TRUE, ex); return folder; } diff --git a/camel/providers/vee/camel-vee-store.h b/camel/providers/vee/camel-vee-store.h index 848769296a..d4ed7a0610 100644 --- a/camel/providers/vee/camel-vee-store.h +++ b/camel/providers/vee/camel-vee-store.h @@ -22,12 +22,11 @@ #ifndef _CAMEL_VEE_STORE_H #define _CAMEL_VEE_STORE_H -#include #include -#define CAMEL_VEE_STORE(obj) GTK_CHECK_CAST (obj, camel_vee_store_get_type (), CamelVeeStore) -#define CAMEL_VEE_STORE_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_vee_store_get_type (), CamelVeeStoreClass) -#define IS_CAMEL_VEE_STORE(obj) GTK_CHECK_TYPE (obj, camel_vee_store_get_type ()) +#define CAMEL_VEE_STORE(obj) CAMEL_CHECK_CAST (obj, camel_vee_store_get_type (), CamelVeeStore) +#define CAMEL_VEE_STORE_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_vee_store_get_type (), CamelVeeStoreClass) +#define IS_CAMEL_VEE_STORE(obj) CAMEL_CHECK_TYPE (obj, camel_vee_store_get_type ()) typedef struct _CamelVeeStore CamelVeeStore; typedef struct _CamelVeeStoreClass CamelVeeStoreClass; -- cgit v1.2.3