Changeset 1700

Show
Ignore:
Timestamp:
03/05/07 20:48:13
Author:
pvanhoof
Message:

A few major changes

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/ChangeLog

    r1696 r1700  
     12007-03-05  Philip Van Hoof  <pvanhoof@gnome.org> 
     2 
     3        * Bugfix for ticket #26 
     4        * Major changes in the TnyCamelHeader type 
     5        * A new type called TnyCamelMsgHeader 
     6        * Changes in the TnyCamelFolder type 
     7        * API changes in the TnyPlatformFactory interface 
     8        * Memory consumption reduction (major ones) 
     9        * Split and cleanup of the TnyHeader implementations 
     10        * Produced patch for Modest to cope with the changes 
     11 
     12        * This was a major API change in libtinymailui and libtinymail-camel 
     13 
    1142007-03-04  Dirk-Jan C. Binnema <djcb@djcbsoftware.nl> 
    215 
  • trunk/libtinymail-camel/Makefile.am

    r1689 r1700  
    5454        tny-camel-msg.c \ 
    5555        tny-camel-header.c \ 
     56        tny-camel-msg-header-priv.h \ 
     57        tny-camel-msg-header.c \ 
    5658        tny-camel-partial-msg-receive-strategy.c \ 
    5759        tny-camel-full-msg-receive-strategy.c \ 
  • trunk/libtinymail-camel/tny-camel-folder.c

    r1695 r1700  
    147147                                priv->unread_length++; 
    148148                        priv->cached_length++; 
    149                         TnyHeader *hdr = tny_camel_header_new (); 
     149                        TnyHeader *hdr = _tny_camel_header_new (); 
    150150                        if (!change) 
    151151                                change = tny_folder_change_new (TNY_FOLDER (self)); 
     
    165165                if (info) 
    166166                { 
    167                         TnyHeader *hdr = tny_camel_header_new (); 
     167                        TnyHeader *hdr = _tny_camel_header_new (); 
    168168                        priv->cached_length--; 
    169169                        priv->unread_sync++; 
     
    10321032 
    10331033        /* TODO: Proxy instantiation (happens a lot, could use a pool) */ 
    1034         header = tny_camel_header_new (); 
     1034 
     1035        header = _tny_camel_header_new (); 
    10351036 
    10361037        _tny_camel_header_set_folder (TNY_CAMEL_HEADER (header), TNY_CAMEL_FOLDER (self), priv); 
    10371038        _tny_camel_header_set_camel_message_info (TNY_CAMEL_HEADER (header), mi, FALSE); 
    1038  
    1039         /* Get rid of the reference already. I know this is ugly */ 
    1040         /* camel_folder_free_message_info (cfol, mi); */ 
    10411039 
    10421040        tny_list_prepend (headers, (GObject*)header); 
  • trunk/libtinymail-camel/tny-camel-full-msg-receive-strategy.c

    r1567 r1700  
    2929#include <tny-header.h> 
    3030#include <tny-camel-msg.h> 
    31 #include <tny-camel-header.h> 
    3231 
    3332#include <camel/camel-folder.h> 
     
    4342#include "tny-camel-account-priv.h" 
    4443#include "tny-camel-folder-priv.h" 
     44#include "tny-camel-msg-header-priv.h" 
    4545 
    4646static GObjectClass *parent_class = NULL; 
     
    7777                if (camel_message && CAMEL_IS_OBJECT (camel_message)) 
    7878                { 
    79                         TnyCamelHeader *nheader = TNY_CAMEL_HEADER (tny_camel_header_new ()); 
    80  
     79                        TnyHeader *nheader = _tny_camel_msg_header_new (CAMEL_MIME_MESSAGE (camel_message), folder); 
    8180                        message = tny_camel_msg_new (); 
    8281                        _tny_camel_msg_set_folder (TNY_CAMEL_MSG (message), folder); 
     82                        _tny_camel_msg_set_header (TNY_CAMEL_MSG (message), nheader); 
    8383                        _tny_camel_mime_part_set_part (TNY_CAMEL_MIME_PART (message),  
    84                                 CAMEL_MIME_PART (camel_message));  
    85                         _tny_camel_header_set_camel_mime_message (nheader, camel_message); 
    86                         _tny_camel_msg_set_header (TNY_CAMEL_MSG (message), nheader); 
     84                                                CAMEL_MIME_PART (camel_message));  
    8785                        g_object_unref (G_OBJECT (nheader)); 
    8886                } 
  • trunk/libtinymail-camel/tny-camel-header-priv.h

    r1588 r1700  
    2121 */ 
    2222 
     23#include <glib.h> 
     24#include <glib-object.h> 
     25#include <tny-header.h> 
     26 
    2327#include <camel/camel.h> 
    2428#include <camel/camel-folder-summary.h> 
     
    2731#include "tny-camel-folder-priv.h" 
    2832 
    29 typedef struct _WriteInfo WriteInfo; 
    30 struct _WriteInfo 
    31 
    32         CamelMimeMessage *msg; 
    33         gchar *mime_from; 
    34 }; 
     33 
     34G_BEGIN_DECLS 
     35 
     36#define TNY_TYPE_CAMEL_HEADER             (tny_camel_header_get_type ()) 
     37#define TNY_CAMEL_HEADER(obj)             ((TnyCamelHeader*)obj) 
     38#define TNY_CAMEL_HEADER_CLASS(vtable)    (G_TYPE_CHECK_CLASS_CAST ((vtable), TNY_TYPE_CAMEL_HEADER, TnyCamelHeaderClass)) 
     39#define TNY_IS_CAMEL_HEADER(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TNY_TYPE_CAMEL_HEADER)) 
     40#define TNY_IS_CAMEL_HEADER_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), TNY_TYPE_CAMEL_HEADER)) 
     41#define TNY_CAMEL_HEADER_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), TNY_TYPE_CAMEL_HEADER, TnyCamelHeaderClass)) 
     42 
     43typedef struct _TnyCamelHeader TnyCamelHeader; 
     44typedef struct _TnyCamelHeaderClass TnyCamelHeaderClass; 
    3545 
    3646 
     
    3949{ 
    4050        GObject parent; 
    41         gpointer info; 
     51        CamelMessageInfo *info; 
    4252        TnyCamelFolder *folder; 
    43         guchar write:2; 
    4453}; 
    4554 
     
    4958}; 
    5059 
     60GType tny_camel_header_get_type (void); 
     61TnyHeader* _tny_camel_header_new (void); 
     62 
    5163void _tny_camel_header_set_camel_message_info (TnyCamelHeader *self, CamelMessageInfo *camel_message_info, gboolean knowit); 
    5264void _tny_camel_header_set_folder (TnyCamelHeader *self, TnyCamelFolder *folder, TnyCamelFolderPriv *tpriv); 
    53 void _tny_camel_header_set_camel_mime_message (TnyCamelHeader *self, CamelMimeMessage *camel_mime_message); 
    5465void _tny_camel_header_set_as_memory (TnyCamelHeader *self, CamelMessageInfo *camel_message_info); 
    5566 
     67G_END_DECLS 
     68 
    5669#endif 
     70 
  • trunk/libtinymail-camel/tny-camel-header.c

    r1588 r1700  
    4242static GObjectClass *parent_class = NULL; 
    4343 
    44 static void  
    45 unref_info (TnyCamelHeader *self) 
    46 { 
    47         if (self->info && self->write == 0) 
    48                 camel_message_info_free (self->info); 
    49 } 
    50  
    51 static void  
    52 destroy_write (TnyCamelHeader *self) 
    53 { 
    54         /* Also check out tny-msg.c: tny_msg_finalize (read the stupid hack) */ 
    55         if (((WriteInfo*)self->info)->msg) 
    56                 camel_object_unref (CAMEL_OBJECT (((WriteInfo*)self->info)->msg)); 
    57  
    58         if (((WriteInfo*)self->info)->mime_from && ((WriteInfo*)self->info)->mime_from != NULL) 
    59                 g_free (((WriteInfo*)self->info)->mime_from); 
    60  
    61         g_slice_free (WriteInfo, self->info); 
    62         self->info = NULL; 
    63         self->write = 3; 
    64 } 
    65  
    66 static void  
    67 destroy_mem (TnyCamelHeader *self) 
    68 { 
    69         if (self->info) 
    70                 camel_message_info_free ((CamelMessageInfo*) self->info); 
    71         self->info = NULL; 
    72         self->write = 3; 
    73 } 
    74  
    75  
    76 static void 
    77 prepare_for_write (TnyCamelHeader *self) 
    78 { 
    79         if (self->write != 1) 
    80         { 
    81                 self->info = g_slice_new0 (WriteInfo); 
    82                 ((WriteInfo*)self->info)->msg = camel_mime_message_new (); 
    83                 ((WriteInfo*)self->info)->mime_from = NULL; 
    84                 self->write = 1; 
    85         }  
    86  
    87         return; 
    88 } 
    8944 
    9045void  
     
    9449                g_warning ("Strange behaviour: Overwriting existing message info"); 
    9550 
    96         if (self->write == 1) 
    97                 destroy_write (self); 
    98         else if (self->write == 2) 
    99                 destroy_mem (self); 
    100         else if (self->write == 0) 
    101                 unref_info (self); 
     51        if (self->info) 
     52                camel_message_info_free (self->info); 
    10253 
    10354        camel_message_info_ref (camel_message_info); 
    104  
    10555        self->info = camel_message_info; 
    106         self->write = 0; 
    10756 
    10857        return; 
     
    11564                g_warning ("Strange behaviour: Overwriting existing message info"); 
    11665 
    117         if (self->write == 1) 
    118                 destroy_write (self); 
    119         else if (self->write == 2) 
    120                 destroy_mem (self); 
    121         else if (self->write == 0) 
    122                 unref_info (self); 
     66        if (self->info) 
     67                camel_message_info_free (self->info); 
    12368 
    12469        self->info = info; 
    125         self->write = 2; 
    126  
    127         return; 
    128 
    129  
    130  
    131 void  
    132 _tny_camel_header_set_camel_mime_message (TnyCamelHeader *self, CamelMimeMessage *camel_mime_message) 
    133 
    134         if (G_UNLIKELY (self->info)) 
    135                 g_warning ("Strange behaviour: Overwriting existing message info"); 
    136  
    137         if (self->write == 1) 
    138                 destroy_write (self); 
    139         else if (self->write == 2) 
    140                 destroy_mem (self); 
    141         else if (self->write == 0) 
    142                 unref_info (self); 
    143  
    144         self->info = g_slice_new0 (WriteInfo); 
    145         ((WriteInfo*)self->info)->mime_from = NULL; 
    146         self->write = 1; 
    147  
    148         ((WriteInfo*)self->info)->msg = camel_mime_message; 
    149         camel_object_ref (CAMEL_OBJECT (camel_mime_message)); 
    150  
    151         return; 
    152 
     70 
     71        return; 
     72
     73 
     74 
    15375static const gchar* 
    15476tny_camel_header_get_replyto (TnyHeader *self) 
     
    15779        const gchar *retval = NULL; 
    15880 
    159         if (G_UNLIKELY (!me->info)) 
    160                 return NULL; 
    161  
    162         if (G_UNLIKELY (me->write == 1))  
    163         { 
    164                 CamelInternetAddress *addr = (CamelInternetAddress*) 
    165                         camel_mime_message_get_reply_to (((WriteInfo*)me->info)->msg); 
    166                 if (addr) 
    167                         retval = camel_address_format (CAMEL_ADDRESS (addr)); 
    168         } 
    169  
    17081        return retval; 
    17182} 
     
    17586tny_camel_header_set_bcc (TnyHeader *self, const gchar *bcc) 
    17687{ 
    177         TnyCamelHeader *me; 
    178         CamelInternetAddress *addr; 
    179  
    180         me = TNY_CAMEL_HEADER (self); 
    181         addr = camel_internet_address_new (); 
    182  
    183         _foreach_email_add_to_inet_addr (bcc, addr); 
    184  
    185         prepare_for_write (me); 
    186  
    187         camel_mime_message_set_recipients (((WriteInfo*)me->info)->msg,  
    188                 CAMEL_RECIPIENT_TYPE_BCC, addr); 
    189  
    190         camel_object_unref (CAMEL_OBJECT (addr)); 
    191  
     88        g_warning ("tny_header_set_bcc: This is a summary header instance. You can't modify it.\n"); 
    19289        return; 
    19390} 
     
    19693tny_camel_header_set_cc (TnyHeader *self, const gchar *cc) 
    19794{ 
    198         TnyCamelHeader *me = TNY_CAMEL_HEADER (self);     
    199         CamelInternetAddress *addr = camel_internet_address_new (); 
    200  
    201         _foreach_email_add_to_inet_addr (cc, addr); 
    202  
    203         prepare_for_write (me); 
    204  
    205         camel_mime_message_set_recipients (((WriteInfo*)me->info)->msg,  
    206                 CAMEL_RECIPIENT_TYPE_CC, addr); 
    207         camel_object_unref (CAMEL_OBJECT (addr)); 
    208  
     95        g_warning ("tny_header_set_cc: This is a summary header instance. You can't modify it.\n"); 
    20996        return; 
    21097} 
     
    213100tny_camel_header_set_from (TnyHeader *self, const gchar *from) 
    214101{ 
    215         TnyCamelHeader *me = TNY_CAMEL_HEADER (self);     
    216         CamelInternetAddress *addr = camel_internet_address_new (); 
    217         gchar *dup; 
    218  
    219         dup = g_strdup (from); 
    220         _string_to_camel_inet_addr (dup, addr); 
    221         g_free (dup); 
    222  
    223         prepare_for_write (me); 
    224  
    225         camel_mime_message_set_from (((WriteInfo*)me->info)->msg, addr); 
    226         camel_object_unref (CAMEL_OBJECT (addr)); 
    227  
     102        g_warning ("tny_header_set_from: This is a summary header instance. You can't modify it.\n"); 
    228103        return; 
    229104} 
     
    232107tny_camel_header_set_subject (TnyHeader *self, const gchar *subject) 
    233108{ 
    234         TnyCamelHeader *me = TNY_CAMEL_HEADER (self);     
    235         prepare_for_write (me); 
    236         camel_mime_message_set_subject (((WriteInfo*)me->info)->msg, subject); 
    237  
     109        g_warning ("tny_header_set_subject: This is a summary header instance. You can't modify it.\n"); 
    238110        return; 
    239111} 
     
    242114tny_camel_header_set_to (TnyHeader *self, const gchar *to) 
    243115{ 
    244         TnyCamelHeader *me = TNY_CAMEL_HEADER (self);     
    245         CamelInternetAddress *addr = camel_internet_address_new (); 
    246         gchar *dup; 
    247  
    248         dup = g_strdup (to); 
    249         _foreach_email_add_to_inet_addr (dup, addr); 
    250         g_free (dup); 
    251  
    252         prepare_for_write (me); 
    253  
    254         camel_mime_message_set_recipients (((WriteInfo*)me->info)->msg,  
    255                 CAMEL_RECIPIENT_TYPE_TO, addr); 
    256  
    257         camel_object_unref (CAMEL_OBJECT (addr)); 
    258  
     116        g_warning ("tny_header_set_to: This is a summary header instance. You can't modify it.\n"); 
    259117        return; 
    260118} 
     
    264122tny_camel_header_set_replyto (TnyHeader *self, const gchar *replyto) 
    265123{ 
    266         TnyCamelHeader *me = TNY_CAMEL_HEADER (self);     
    267         CamelInternetAddress *addr = camel_internet_address_new (); 
    268         gchar *dup; 
    269  
    270         dup = g_strdup (replyto); 
    271         _foreach_email_add_to_inet_addr (dup, addr); 
    272         g_free (dup); 
    273  
    274         prepare_for_write (me); 
    275  
    276         camel_mime_message_set_reply_to (((WriteInfo*)me->info)->msg, addr); 
    277  
    278         camel_object_unref (CAMEL_OBJECT (addr)); 
    279  
     124        g_warning ("tny_header_set_bcc: This is a summary header instance. You can't modify it.\n"); 
    280125        return; 
    281126} 
     
    288133        const gchar *retval = NULL; 
    289134 
    290         if (G_UNLIKELY (!me->info)) 
    291                 return NULL; 
    292  
    293         if (G_UNLIKELY (me->write == 1)) 
    294                 retval = camel_medium_get_header (CAMEL_MEDIUM (((WriteInfo*)me->info)->msg), "cc"); 
    295         else 
    296                 retval = camel_message_info_cc ((CamelMessageInfo*)me->info); 
     135        retval = camel_message_info_cc (me->info); 
    297136 
    298137        return retval; 
     
    302141tny_camel_header_get_bcc (TnyHeader *self) 
    303142{ 
    304         TnyCamelHeader *me = TNY_CAMEL_HEADER (self); 
    305         const gchar *retval = NULL; 
    306  
    307         if (G_UNLIKELY (!me->info)) 
    308                 return NULL; 
    309  
    310         if (G_UNLIKELY (me->write == 1)) 
    311                 retval = camel_medium_get_header (CAMEL_MEDIUM (((WriteInfo*)me->info)->msg), "bcc"); 
    312  
    313         return retval; 
     143        g_warning ("tny_header_get_bcc: This is a summary header instance. It has no bcc.\n"); 
     144        return NULL; 
    314145} 
    315146 
     
    320151        TnyHeaderFlags retval = 0; 
    321152 
    322         if (G_UNLIKELY (me->write == 1)) 
    323         { 
    324                 g_warning ("tny_camel_header_get_flags: This is a header for a new message!\n"); 
    325                 return retval; 
    326         } 
    327  
    328153        /* This is only legal because the flags between CamelLite and Tinymail are equalized */ 
    329         retval = camel_message_info_flags ((CamelMessageInfo*)me->info); 
     154        retval = camel_message_info_flags (me->info); 
    330155 
    331156        return retval; 
     
    337162        TnyCamelHeader *me = TNY_CAMEL_HEADER (self); 
    338163 
    339         if (G_UNLIKELY (me->write == 1)) 
    340         { 
    341                 g_warning ("tny_camel_header_get_flags: This is a header for a new message!\n"); 
    342                 return; 
    343         }  
    344  
    345164        /* This is only legal because the flags between CamelLite and Tinymail are equalized */ 
    346         camel_message_info_set_flags ((CamelMessageInfo*)me->info, mask, ~0); 
     165        camel_message_info_set_flags (me->info, mask, ~0); 
    347166 
    348167        return; 
     
    354173        TnyCamelHeader *me = TNY_CAMEL_HEADER (self); 
    355174 
    356         if (G_UNLIKELY (me->write == 1)) 
    357         { 
    358                 g_warning ("tny_camel_header_get_flags: This is a header for a new message!\n"); 
    359                 return; 
    360         } 
    361  
    362         camel_message_info_set_flags ((CamelMessageInfo*)me->info, mask, 0); 
     175        camel_message_info_set_flags (me->info, mask, 0); 
    363176 
    364177        return; 
     
    371184        time_t retval = 0; 
    372185 
    373         if (G_UNLIKELY (!me->info)) 
    374                 return retval; 
    375  
    376         if (G_UNLIKELY (me->write == 1)) 
    377         { 
    378                 int tzone; 
    379  
    380                 retval = camel_mime_message_get_date (((WriteInfo*)me->info)->msg, &tzone); 
    381  
    382                 if (retval == CAMEL_MESSAGE_DATE_CURRENT) 
    383                         retval = camel_mime_message_get_date_received (((WriteInfo*)me->info)->msg, &tzone); 
    384                 if (retval == CAMEL_MESSAGE_DATE_CURRENT) 
    385                 { 
    386                         time (&retval); 
    387                         tzone = 0; 
    388                 } 
    389  
    390                 retval += (tzone / 100) * 60 * 60; 
    391                 retval += (tzone % 100) * 60; 
    392         } else 
    393                 retval = camel_message_info_date_received ((CamelMessageInfo*)me->info); 
     186        retval = camel_message_info_date_received (me->info); 
    394187 
    395188        return retval; 
     
    402195        time_t retval = 0; 
    403196 
    404         if (G_UNLIKELY (!me->info)) 
    405                 return retval; 
    406  
    407         if (G_UNLIKELY (me->write == 1)) 
    408         { 
    409                 int tzone; 
    410                 retval = camel_mime_message_get_date (((WriteInfo*)me->info)->msg, &tzone); 
    411  
    412                 if (retval == CAMEL_MESSAGE_DATE_CURRENT) 
    413                         retval = camel_mime_message_get_date_received (((WriteInfo*)me->info)->msg, &tzone); 
    414                 if (retval == CAMEL_MESSAGE_DATE_CURRENT) 
    415                 { 
    416                         time (&retval); 
    417                         tzone = 0; 
    418                 } 
    419  
    420                 retval += (tzone / 100) * 60 * 60; 
    421                 retval += (tzone % 100) * 60; 
    422         } else 
    423                 retval = camel_message_info_date_sent ((CamelMessageInfo*)me->info); 
     197        retval = camel_message_info_date_sent (me->info); 
    424198 
    425199        return retval; 
     
    432206        const gchar *retval = NULL; 
    433207 
    434         if (G_UNLIKELY (!me->info)) 
    435                 return NULL; 
    436  
    437         if (G_UNLIKELY (me->write == 1)) 
    438         { 
    439                 if (G_LIKELY (!((WriteInfo*)me->info)->mime_from)) 
    440                 { 
    441                         CamelInternetAddress *addr = (CamelInternetAddress*) 
    442                                 camel_mime_message_get_from (((WriteInfo*)me->info)->msg); 
    443                                 if (addr) 
    444                                         ((WriteInfo*)me->info)->mime_from = camel_address_format (CAMEL_ADDRESS (addr)); 
    445                                 else ((WriteInfo*)me->info)->mime_from = NULL; 
    446                 } 
    447  
    448                 retval = (const gchar*)((WriteInfo*)me->info)->mime_from; 
    449         } else 
    450                 retval = camel_message_info_from ((CamelMimeMessage*)me->info); 
     208        retval = camel_message_info_from (me->info); 
    451209 
    452210        return retval; 
     
    459217        const gchar *retval = NULL; 
    460218 
    461         if (G_UNLIKELY (!me->info)) 
    462                 return NULL; 
    463  
    464         if (G_UNLIKELY (me->write == 1)) 
    465                 retval = camel_mime_message_get_subject (((WriteInfo*)me->info)->msg); 
    466         else 
    467                 retval = camel_message_info_subject ((CamelMessageInfo*)me->info); 
     219        retval = camel_message_info_subject (me->info); 
    468220 
    469221        return retval; 
     
    477229        const gchar *retval = NULL; 
    478230 
    479         if (G_UNLIKELY (!me->info)) 
    480                 return NULL; 
    481  
    482         if (G_UNLIKELY (me->write == 1)) 
    483                 retval = camel_medium_get_header (CAMEL_MEDIUM (((WriteInfo*)me->info)->msg), "to"); 
    484         else 
    485                 retval = camel_message_info_to ((CamelMessageInfo*)me->info); 
     231        retval = camel_message_info_to (me->info); 
    486232 
    487233        return retval; 
     
    494240        const gchar *retval = NULL; 
    495241 
    496         if (G_UNLIKELY (!me->info)) 
    497                 return NULL; 
    498  
    499         if (G_UNLIKELY (me->write == 1)) 
    500                 retval = camel_mime_message_get_message_id (((WriteInfo*)me->info)->msg); 
    501         else 
    502                 retval = (const gchar*) camel_message_info_message_id ((CamelMessageInfo*)me->info); 
     242        retval = (const gchar*) camel_message_info_message_id (me->info); 
    503243 
    504244        return retval; 
     
    513253        guint retval; 
    514254 
    515         if (G_UNLIKELY (!me->info)) 
    516                 return 0; 
    517  
    518         if (G_UNLIKELY (me->write == 1)) 
    519         { 
    520                 CamelStreamNull *sn = (CamelStreamNull *)camel_stream_null_new(); 
    521                 camel_data_wrapper_write_to_stream((CamelDataWrapper *)((WriteInfo*)me->info)->msg, (CamelStream *)sn); 
    522                 retval = (guint) sn->written; 
    523                 camel_object_unref((CamelObject *)sn); 
    524         } else 
    525                 retval = (guint) camel_message_info_size ((CamelMessageInfo*)me->info); 
     255        retval = (guint) camel_message_info_size (me->info); 
    526256 
    527257        return retval; 
     
    536266        const gchar *retval = NULL; 
    537267 
    538         if (G_UNLIKELY (!me->info) || G_UNLIKELY (me->write == 1)) 
    539                 return NULL; 
    540  
    541         retval = camel_message_info_uid ((CamelMessageInfo*)me->info); 
     268        retval = camel_message_info_uid (me->info); 
    542269 
    543270        return retval; 
     
    549276        TnyCamelHeader *self = (TnyCamelHeader*) object; 
    550277 
    551         if (G_UNLIKELY (self->write == 1)) 
    552                 destroy_write (self); 
    553         else if (G_UNLIKELY (self->write == 2)) 
    554                 destroy_mem (self); 
    555         else if (self->write == 0) 
    556                 unref_info (self); 
     278        if (self->info) 
     279                camel_message_info_free (self->info); 
    557280 
    558281        if (self->folder) 
     
    563286        } 
    564287 
    565         /* Normally we do camel_folder_free_message_info here, but we already got 
    566         rid of our initial reference at tny-folder.c:add_message_with_uid 
    567         I know this is actually ugly */ 
    568  
    569288        (*parent_class->finalize) (object); 
    570289 
     
    572291} 
    573292 
    574 /** 
    575  * tny_camel_header_new: 
    576  * 
    577  * 
    578  * Return value: A new #TnyHeader instance implemented for Camel 
    579  **/ 
    580293TnyHeader* 
    581 tny_camel_header_new (void) 
     294_tny_camel_header_new (void) 
    582295{ 
    583296        TnyCamelHeader *self = g_object_new (TNY_TYPE_CAMEL_HEADER, NULL); 
    584          
     297 
    585298        self->info = NULL; 
    586         self->write = 3
    587  
    588         return (TnyHeader*)self; 
     299        self->folder = NULL
     300 
     301        return (TnyHeader*) self; 
    589302} 
    590303 
     
    594307        TnyCamelHeader *me = TNY_CAMEL_HEADER (self); 
    595308        fpriv->headers_managed++; 
    596         me->folder = (TnyCamelFolder*)folder; 
     309        me->folder = (TnyCamelFolder*) folder; 
    597310 
    598311        return; 
     
    607320                g_object_ref (G_OBJECT (me->folder)); 
    608321 
    609         return (TnyFolder*)me->folder; 
     322        return (TnyFolder*) me->folder; 
    610323} 
    611324 
  • trunk/libtinymail-camel/tny-camel-header.h

    r1240 r1700  
    1 #ifndef TNY_CAMEL_HEADER_H 
    2 #define TNY_CAMEL_HEADER_H 
    3  
    4 /* libtinymail-camel - The Tiny Mail base library for Camel 
    5  * Copyright (C) 2006-2007 Philip Van Hoof <pvanhoof@gnome.org> 
    6  * 
    7  * This library is free software; you can redistribute it and/or 
    8  * modify it under the terms of the GNU Lesser General Public 
    9  * License as published by the Free Software Foundation; either 
    10  * version 2 of the License, or (at your option) any later version. 
    11  * 
    12  * This library is distributed in the hope that it will be useful, 
    13  * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
    15  * Lesser General Public License for more details. 
    16  * 
    17  * You should have received a copy of the GNU Lesser General Public 
    18  * License along with self library; if not, write to the 
    19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 
    20  * Boston, MA 02111-1307, USA. 
    21  */ 
    22  
    23 #include <glib.h> 
    24 #include <glib-object.h> 
    25 #include <tny-header.h> 
    26  
    27 G_BEGIN_DECLS 
    28  
    29 #define TNY_TYPE_CAMEL_HEADER             (tny_camel_header_get_type ()) 
    30 #define TNY_CAMEL_HEADER(obj)             ((TnyCamelHeader*)obj) 
    31 /* #define TNY_CAMEL_HEADER(obj)          (G_TYPE_CHECK_INSTANCE_CAST ((obj), TNY_TYPE_CAMEL_HEADER, TnyCamelHeader)) */ 
    32 #define TNY_CAMEL_HEADER_CLASS(vtable)    (G_TYPE_CHECK_CLASS_CAST ((vtable), TNY_TYPE_CAMEL_HEADER, TnyCamelHeaderClass)) 
    33 #define TNY_IS_CAMEL_HEADER(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TNY_TYPE_CAMEL_HEADER)) 
    34 #define TNY_IS_CAMEL_HEADER_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), TNY_TYPE_CAMEL_HEADER)) 
    35 #define TNY_CAMEL_HEADER_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), TNY_TYPE_CAMEL_HEADER, TnyCamelHeaderClass)) 
    36  
    37 typedef struct _TnyCamelHeader TnyCamelHeader; 
    38 typedef struct _TnyCamelHeaderClass TnyCamelHeaderClass; 
    39  
    40  
    41 GType tny_camel_header_get_type (void); 
    42 TnyHeader* tny_camel_header_new (void); 
    43  
    44  
    45 G_END_DECLS 
    46  
    47 #endif 
  • trunk/libtinymail-camel/tny-camel-mime-part.c

    r1463 r1700  
    3131#include <tny-camel-shared.h> 
    3232#include <tny-list.h> 
    33 #include <tny-camel-header.h> 
    3433#include <tny-camel-msg.h> 
    3534 
     
    3736 
    3837#include "tny-camel-mime-part-priv.h" 
     38#include "tny-camel-msg-header-priv.h" 
    3939 
    4040#include <camel/camel-url.h> 
     
    119119                        if (camel_content_type_is (type, "message", "rfc822")) 
    120120                        { 
    121                                 TnyCamelHeader *nheader = TNY_CAMEL_HEADER (tny_camel_header_new ()); 
    122121                                CamelDataWrapper *c = camel_medium_get_content_object (CAMEL_MEDIUM (tpart)); 
    123122                         
    124123                                if (c)  
    125124                                { 
     125                                        TnyHeader *nheader = _tny_camel_msg_header_new (CAMEL_MIME_MESSAGE (c), NULL); 
    126126                                        newpart = TNY_MIME_PART (tny_camel_msg_new ()); 
    127                                         _tny_camel_header_set_camel_mime_message (nheader, CAMEL_MIME_MESSAGE (c)); 
    128127                                        _tny_camel_msg_set_header (TNY_CAMEL_MSG (newpart), nheader); 
    129128                                        _tny_camel_mime_part_set_part (TNY_CAMEL_MIME_PART (newpart), CAMEL_MIME_PART (c)); 
  • trunk/libtinymail-camel/tny-camel-msg-priv.h

    r1192 r1700  
    3030        GMutex *message_lock; 
    3131        GMutex *header_lock; 
    32         TnyHeader *header; 
    3332        GMutex *parts_lock; 
    3433        GMutex *folder_lock; 
    3534        TnyFolder *folder; 
     35        TnyHeader *header; 
    3636}; 
    3737 
    3838CamelMimeMessage* _tny_camel_msg_get_camel_mime_message (TnyCamelMsg *self); 
    3939void _tny_camel_msg_set_folder (TnyCamelMsg *self, TnyFolder *folder); 
    40 void _tny_camel_msg_set_header (TnyCamelMsg *self, TnyCamelHeader *header); 
     40void _tny_camel_msg_set_header (TnyCamelMsg *self, TnyHeader *header); 
    4141 
    4242#endif 
  • trunk/libtinymail-camel/tny-camel-msg.c

    <
    r1466 r1700  
    4343#include "tny-camel-msg-priv.h" 
    4444#include "tny-camel-mime-part-priv.h" 
    45 #include "tny-camel-header-priv.h" 
     45#include "tny-camel-msg-header-priv.h" 
    4646 
    4747#define TNY_CAMEL_MSG_GET_PRIVATE(o)    \ 
     
    6363 
    6464 
    65  
    6665static TnyFolder*  
    6766tny_camel_msg_get_folder (TnyMsg *self) 
     
    7877        g_mutex_lock (priv->folder_lock); 
    7978        retval = priv->folder; 
    80         g_object_ref (G_OBJECT (retval)); 
     79        if (retval) 
     80                g_object_ref (G_OBJECT (retval)); 
    8181        g_mutex_unlock (priv->folder_lock); 
    8282 
     
    107107} 
    108108 
     109void  
     110_tny_camel_msg_set_header (TnyCamelMsg *self, TnyHeader *header) 
     111{ 
     112        TnyCamelMsgPriv *priv = TNY_CAMEL_MSG_GET_PRIVATE (self); 
     113        g_mutex_lock (priv->header_lock); 
     114        priv->header = TNY_HEADER (g_object_ref (G_OBJECT (header))); 
     115        g_mutex_unlock (priv->header_lock); 
     116        return; 
     117} 
     118 
    109119static TnyHeader* 
    110120tny_camel_msg_get_header_default (TnyMsg *self) 
     
    114124 
    115125        g_mutex_lock (priv->header_lock); 
    116         retval = priv->header; 
    117         if (retval) 
    118                 g_object_ref (G_OBJECT (retval)); 
    119         else { 
     126 
     127        if (!priv->header) 
     128        { 
    120129                CamelMimeMessage *msg; 
    121                 priv->header = tny_camel_header_new (); 
    122130                msg = _tny_camel_msg_get_camel_mime_message (TNY_CAMEL_MSG (self)); 
    123                 _tny_camel_header_set_camel_mime_message  
    124                         (TNY_CAMEL_HEADER (priv->header), msg); 
    125                 retval = priv->header; 
     131                /* Read _tny_camel_msg_header_new too! */ 
     132                priv->header = _tny_camel_msg_header_new (msg, priv->folder); 
    126133        } 
     134 
     135        retval = TNY_HEADER (g_object_ref (G_OBJECT (priv->header))); 
     136 
    127137        g_mutex_unlock (priv->header_lock); 
    128138 
    129139        return retval; 
    130140} 
    131  
    132  
    133  
    134 void 
    135 _tny_camel_msg_set_header (TnyCamelMsg *self, TnyCamelHeader *header) 
    136 { 
    137         TnyCamelMsgPriv *priv = TNY_CAMEL_MSG_GET_PRIVATE (self); 
    138         g_mutex_lock (priv->header_lock); 
    139  
    140         if (priv->header) 
    141                 g_object_unref (G_OBJECT (priv->header)); 
    142  
    143         g_object_ref (G_OBJECT (header)); 
    144         priv->header = TNY_HEADER (header); 
    145         g_mutex_unlock (priv->header_lock); 
    146         return; 
    147 } 
    148  
    149 static void 
    150 tny_camel_msg_set_header (TnyMsg *self, TnyHeader *header) 
    151 { 
    152         TNY_CAMEL_MSG_GET_CLASS (self)->set_header_func (self, header); 
    153         return; 
    154 } 
    155  
    156 static void 
    157 tny_camel_msg_set_header_default (TnyMsg *self, TnyHeader *header) 
    158 { 
    159         CamelMimeMessage *msg; 
    160         TnyCamelMsgPriv *priv = TNY_CAMEL_MSG_GET_PRIVATE (self); 
    161         /* CamelInternetAddress *from, *recipients, *replyto; 
    162         const gchar *str; */ 
    163  
    164         g_assert (TNY_IS_CAMEL_HEADER (header)); 
    165  
    166         g_mutex_lock (priv->header_lock); 
    167  
    168         if (priv->header) 
    169                 g_object_unref (G_OBJECT (priv->header)); 
    170         g_object_ref (G_OBJECT (header)); 
    171  
    172         priv->header = header; 
    173  
    174         if (((TnyCamelHeader *)header)->write == 1) 
    175         { 
    176                 TnyCamelMimePartPriv *ppriv = TNY_CAMEL_MIME_PART_GET_PRIVATE (self); 
    177                 g_mutex_lock (ppriv->part_lock); 
    178                 if (ppriv->part)  
    179                 { 
    180                         /* TODO: copy old part over? */ 
    181                         camel_object_unref (CAMEL_OBJECT (ppriv->part)); 
    182                 } 
    183                 /* Add a reference? */ 
    184                 ppriv->part = (CamelMimePart *) ((WriteInfo*)((TnyCamelHeader *)header)->info)->msg; 
    185                 g_mutex_unlock (ppriv->part_lock); 
    186         } else { 
    187                 msg = _tny_camel_msg_get_camel_mime_message (TNY_CAMEL_MSG (self)); 
    188                 _tny_camel_header_set_camel_mime_message  
    189                         (TNY_CAMEL_HEADER (priv->header), msg); 
    190         } 
    191  
    192 /* 
    193         from = camel_internet_address_new (); 
    194         str = tny_header_get_from (header); 
    195         _foreach_email_add_to_inet_addr (str, from); 
    196         camel_mime_message_set_from (msg, from); 
    197         camel_object_unref (CAMEL_OBJECT (from)); 
    198  
    199         replyto = camel_internet_address_new (); 
    200         str = tny_header_get_replyto (header); 
    201         _foreach_email_add_to_inet_addr (str, replyto); 
    202         camel_mime_message_set_from (msg, replyto); 
    203         camel_object_unref (CAMEL_OBJECT (replyto)); 
    204  
    205         recipients = camel_internet_address_new (); 
    206         str = tny_header_get_to (header); 
    207         _foreach_email_add_to_inet_addr (str, recipients); 
    208         camel_mime_message_set_recipients (msg, CAMEL_RECIPIENT_TYPE_TO, recipients); 
    209         camel_object_unref (CAMEL_OBJECT (recipients)); 
    210  
    211         str = tny_header_get_cc (header); 
    212         _foreach_email_add_to_inet_addr (str, recipients); 
    213