Changeset 1194

Show
Ignore:
Timestamp:
11/21/06 11:59:29
Author:
pvanhoof
Message:

Support for rfc822 messages

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/ChangeLog

    r1192 r1194  
     12006-11-21  Philip van Hoof <pvanhoof@gnome.org> 
     2 
     3        * Major changes in TnyMsg and TnyMimePart 
     4        * First support for message/rfc822 messages 
     5 
     6        * This was a major API change in all libraries 
     7 
    182006-11-20  Philip van Hoof <pvanhoof@gnome.org> 
    29 
  • trunk/libtinymail-camel/tny-camel-mime-part.c

    r1192 r1194  
    3030#include <camel/camel-data-wrapper.h> 
    3131#include <tny-camel-shared.h> 
     32#include <tny-list.h> 
    3233 
    3334static GObjectClass *parent_class = NULL; 
     
    5354 
    5455/* Locking warning: tny-camel-msg.c also locks priv->part_lock */ 
     56 
     57 
     58 
     59typedef gboolean (*CamelPartFunc)(CamelMimeMessage *, CamelMimePart *, void *data); 
     60 
     61static gboolean 
     62message_foreach_part_rec (CamelMimeMessage *msg, CamelMimePart *part, CamelPartFunc callback, void *data, gboolean firstpart) 
     63{ 
     64        CamelDataWrapper *containee; 
     65        int parts, i; 
     66        int go = TRUE; 
     67 
     68        if (!firstpart && callback (msg, part, data) == FALSE) 
     69                        return FALSE;  
     70 
     71        containee = camel_medium_get_content_object (CAMEL_MEDIUM (part)); 
     72 
     73        if (G_UNLIKELY (containee == NULL)) 
     74                return go; 
     75 
     76        if (G_LIKELY (CAMEL_IS_MULTIPART (containee))) 
     77        { 
     78                parts = camel_multipart_get_number (CAMEL_MULTIPART (containee)); 
     79                for (i = 0; go && i < parts; i++)  
     80                { 
     81                        CamelMimePart *part = camel_multipart_get_part (CAMEL_MULTIPART (containee), i); 
     82                        if (part) 
     83                                go = message_foreach_part_rec (msg, part, callback, data, FALSE); 
     84                        else go = FALSE; 
     85                } 
     86                 
     87        } else if (G_LIKELY (CAMEL_IS_MIME_MESSAGE (containee))) 
     88                go = message_foreach_part_rec (msg, (CamelMimePart *)containee, callback, data, FALSE); 
     89 
     90        return go; 
     91} 
     92 
     93static gboolean 
     94received_a_part (CamelMimeMessage *message, CamelMimePart *part, void *data) 
     95{ 
     96        TnyList *list = data; 
     97        TnyMimePart *tpart; 
     98 
     99        if (!part) 
     100                return FALSE; 
     101 
     102        tpart = tny_camel_mime_part_new (part); 
     103 
     104        tny_list_prepend (list, (GObject*)tpart); 
     105        g_object_unref (G_OBJECT (tpart)); 
     106 
     107        return TRUE; 
     108} 
     109 
     110static void 
     111tny_camel_mime_part_get_parts (TnyMimePart *self, TnyList *list) 
     112{ 
     113        TNY_CAMEL_MIME_PART_GET_CLASS (self)->get_parts_func (self, list); 
     114        return; 
     115} 
     116 
     117static void 
     118tny_camel_mime_part_get_parts_default (TnyMimePart *self, TnyList *list) 
     119{ 
     120        TnyCamelMimePartPriv *priv = TNY_CAMEL_MIME_PART_GET_PRIVATE (self); 
     121        gboolean go = TRUE; 
     122 
     123        g_assert (TNY_IS_LIST (list)); 
     124 
     125        g_mutex_lock (priv->part_lock); 
     126 
     127        message_foreach_part_rec ((CamelMimeMessage*)priv->part,  
     128                (CamelMimePart *)priv->part, received_a_part, list, TRUE);  
     129 
     130        g_mutex_unlock (priv->part_lock); 
     131 
     132        return; 
     133} 
     134 
     135 
     136 
     137static gint 
     138tny_camel_mime_part_add_part (TnyMimePart *self, TnyMimePart *part) 
     139{ 
     140        return TNY_CAMEL_MIME_PART_GET_CLASS (self)->add_part_func (self, part); 
     141} 
     142 
     143static gint 
     144tny_camel_mime_part_add_part_default (TnyMimePart *self, TnyMimePart *part) 
     145{ 
     146        TnyCamelMimePartPriv *priv = TNY_CAMEL_MIME_PART_GET_PRIVATE (self); 
     147        CamelMedium *medium; 
     148        CamelDataWrapper *containee; 
     149        gint curl = 0, retval = 0; 
     150        CamelMimePart *cpart; 
     151 
     152        /* Yes, indeed (I don't yet support non TnyCamelMimePart mime part  
     153           instances, and I know I should. Feel free to implement the copying 
     154           if you really need it) */ 
     155 
     156        g_assert (TNY_IS_CAMEL_MIME_PART (part)); 
     157 
     158        g_mutex_lock (priv->part_lock); 
     159 
     160        medium = CAMEL_MEDIUM (priv->part); 
     161        containee = camel_medium_get_content_object (medium); 
     162 
     163        /* Warp it into a multipart */ 
     164        if (G_UNLIKELY (!containee) || G_LIKELY (!CAMEL_IS_MULTIPART (containee))) 
     165        { 
     166                /* TODO: restore original mime part? */ 
     167                if (G_LIKELY (containee)) 
     168                        camel_object_unref (CAMEL_OBJECT (containee)); 
     169 
     170                curl = 0; 
     171 
     172                containee = (CamelDataWrapper*)camel_multipart_new (); 
     173                camel_multipart_set_boundary ((CamelMultipart*)containee, NULL); 
     174                camel_medium_set_content_object (medium, containee); 
     175        } 
     176 
     177        cpart = tny_camel_mime_part_get_part (TNY_CAMEL_MIME_PART (part)); 
     178        camel_multipart_add_part ((CamelMultipart*)containee, cpart); 
     179        camel_object_unref (CAMEL_OBJECT (cpart)); 
     180 
     181        retval = camel_multipart_get_number ((CamelMultipart*)containee); 
     182 
     183        /* Warning: large lock that locks code, not data */ 
     184        g_mutex_unlock (priv->part_lock); 
     185 
     186        return retval; 
     187} 
     188 
     189/* TODO: camel_mime_message_set_date(msg, time(0), 930); */ 
     190 
     191static void  
     192tny_camel_mime_part_del_part (TnyMimePart *self,  TnyMimePart *part) 
     193{ 
     194        TNY_CAMEL_MIME_PART_GET_CLASS (self)->del_part_func (self, part); 
     195        return; 
     196} 
     197 
     198static void  
     199tny_camel_mime_part_del_part_default (TnyMimePart *self, TnyMimePart *part) 
     200{ 
     201        TnyCamelMimePartPriv *priv = TNY_CAMEL_MIME_PART_GET_PRIVATE (self); 
     202        CamelDataWrapper *containee; 
     203        CamelMimePart *cpart; 
     204 
     205        /* Yes, indeed (I don't yet support non TnyCamelMimePart mime part  
     206           instances, and I know I should. Feel free to implement the copying 
     207           if you really need it) */ 
     208 
     209        g_assert (TNY_IS_CAMEL_MIME_PART (part)); 
     210 
     211        g_mutex_lock (priv->part_lock); 
     212 
     213        containee = camel_medium_get_content_object (CAMEL_MEDIUM (priv->part)); 
     214 
     215        cpart = tny_camel_mime_part_get_part (TNY_CAMEL_MIME_PART (part)); 
     216        camel_multipart_remove_part (CAMEL_MULTIPART (containee), cpart); 
     217        camel_object_unref (CAMEL_OBJECT (cpart)); 
     218 
     219        /* Warning: large lock that locks code, not data */ 
     220        g_mutex_unlock (priv->part_lock); 
     221 
     222        return; 
     223} 
     224 
     225 
    55226 
    56227static gboolean  
     
    675846        klass->is_attachment_func = tny_camel_mime_part_is_attachment; 
    676847        klass->decode_to_stream_func = tny_camel_mime_part_decode_to_stream; 
     848        klass->get_parts_func = tny_camel_mime_part_get_parts; 
     849        klass->add_part_func = tny_camel_mime_part_add_part; 
     850        klass->del_part_func = tny_camel_mime_part_del_part; 
    677851 
    678852        return; 
     
    704878        class->is_attachment_func = tny_camel_mime_part_is_attachment_default; 
    705879        class->decode_to_stream_func = tny_camel_mime_part_decode_to_stream_default; 
     880        class->get_parts_func = tny_camel_mime_part_get_parts_default; 
     881        class->add_part_func = tny_camel_mime_part_add_part_default; 
     882        class->del_part_func = tny_camel_mime_part_del_part_default; 
    706883 
    707884        object_class->finalize = tny_camel_mime_part_finalize; 
  • trunk/libtinymail-camel/tny-camel-mime-part.h

    r1103 r1194  
    6565        void (*set_content_type_func) (TnyMimePart *self, const gchar *contenttype); 
    6666        gboolean (*is_attachment_func) (TnyMimePart *self); 
     67        void (*get_parts_func) (TnyMimePart *self, TnyList *list); 
     68        void (*del_part_func) (TnyMimePart *self, TnyMimePart *part); 
     69        gint (*add_part_func) (TnyMimePart *self, TnyMimePart *part); 
    6770}; 
    6871 
  • trunk/libtinymail-camel/tny-camel-msg.c

    r1192 r1194  
    4949 
    5050 
    51 typedef gboolean (*CamelPartFunc)(CamelMimeMessage *, CamelMimePart *, void *data); 
    52  
    53 static gboolean 
    54 message_foreach_part_rec (CamelMimeMessage *msg, CamelMimePart *part, CamelPartFunc callback, void *data) 
    55 { 
    56         CamelDataWrapper *containee; 
    57         int parts, i; 
    58         int go = TRUE; 
    59          
    60         if (callback (msg, part, data) == FALSE) 
    61                 return FALSE; 
    62          
    63         containee = camel_medium_get_content_object (CAMEL_MEDIUM (part)); 
    64          
    65         if (G_UNLIKELY (containee == NULL)) 
    66                 return go; 
    67          
    68         if (G_LIKELY (CAMEL_IS_MULTIPART (containee))) 
    69         { 
    70                 parts = camel_multipart_get_number (CAMEL_MULTIPART (containee)); 
    71                 for (i = 0; go && i < parts; i++)  
    72                 { 
    73                         CamelMimePart *part = camel_multipart_get_part (CAMEL_MULTIPART (containee), i); 
    74                         if (part) 
    75                                 go = message_foreach_part_rec (msg, part, callback, data); 
    76                         else go = FALSE; 
    77                 } 
    78                  
    79         } else if (G_LIKELY (CAMEL_IS_MIME_MESSAGE (containee))) 
    80                 go = message_foreach_part_rec (msg, (CamelMimePart *)containee, callback, data); 
    81  
    82         return go; 
    83 } 
    84  
    85  
    86  
    8751CamelMimeMessage*  
    8852_tny_camel_msg_get_camel_mime_message (TnyCamelMsg *self) 
     
    13094} 
    13195 
    132 static void 
    133 tny_camel_msg_get_parts (TnyMsg *self, TnyList *list) 
    134 { 
    135         TNY_CAMEL_MSG_GET_CLASS (self)->get_parts_func (self, list); 
    136         return; 
    137 } 
    138  
    139  
    140 static gboolean 
    141 received_a_part (CamelMimeMessage *message, CamelMimePart *part, void *data) 
    142 { 
    143         TnyList *list = data; 
    144         TnyMimePart *tpart; 
    145  
    146         if (!part) 
    147                 return FALSE; 
    148  
    149 /*  
    150         Support for RFC822 
    151  
    152         CamelContentType *type; 
    153  
    154         type = camel_mime_part_get_content_type (part); 
    155  
    156         printf ("->%s/%s\n", type->type, type->subtype); 
    157  
    158         This seems to be incorrect :(  
    159  
    160         if (camel_content_type_is (type, "message", "rfc822")) 
    161         { 
    162                 CamelDataWrapper *containee = camel_medium_get_content_object (CAMEL_MEDIUM (part)); 
    163                 if (containee && CAMEL_IS_MIME_MESSAGE (containee)) 
    164                 { 
    165                         TnyCamelHeader *nheader = TNY_CAMEL_HEADER (tny_camel_header_new ()); 
    166  
    167                         tpart = TNY_MIME_PART (tny_camel_msg_new ()); 
    168                         tny_camel_mime_part_set_part (TNY_CAMEL_MIME_PART (tpart),  
    169                                         CAMEL_MIME_PART (containee));  
    170  
    171                         _tny_camel_header_set_camel_mime_message (nheader,  
    172                                         CAMEL_MIME_MESSAGE (containee)); 
    173                         _tny_camel_msg_set_header (TNY_CAMEL_MSG (tpart), nheader); 
    174  
    175                         g_object_unref (G_OBJECT (nheader)); 
    176                 } else 
    177                         g_warning ("Can't construct message/rfc822 mime part\n"); 
    178  
    179         } else 
    180 */ 
    181                 tpart = tny_camel_mime_part_new (part); 
    182  
    183         tny_list_prepend (list, (GObject*)tpart); 
    184         g_object_unref (G_OBJECT (tpart)); 
    185  
    186         return TRUE; 
    187 } 
    188  
    189 static void 
    190 tny_camel_msg_get_parts_default (TnyMsg *self, TnyList *list) 
    191 { 
    192         TnyCamelMsgPriv *priv = TNY_CAMEL_MSG_GET_PRIVATE (self); 
    193         TnyCamelMimePartPriv *ppriv = TNY_CAMEL_MIME_PART_GET_PRIVATE (self); 
    194         gint parts, i; 
    195         gboolean go = TRUE; 
    196         CamelDataWrapper *containee; 
    197         g_assert (TNY_IS_LIST (list)); 
    198  
    199         g_mutex_lock (priv->parts_lock); 
    200  
    201         containee = camel_medium_get_content_object (CAMEL_MEDIUM (ppriv->part)); 
    202  
    203         if (containee == NULL) 
    204         { 
    205                 g_warning ("Message has no content\n"); 
    206                 return; 
    207         } 
    208  
    209         if (CAMEL_IS_MULTIPART (containee)) 
    210         { 
    211                 parts = camel_multipart_get_number (CAMEL_MULTIPART (containee)); 
    212                 for (i = 0; go && i < parts; i++)  
    213                 { 
    214                                 CamelMimePart *part = camel_multipart_get_part (CAMEL_MULTIPART (containee), i); 
    215                                 go = received_a_part (CAMEL_MIME_MESSAGE (ppriv->part), part, list); 
    216                 } 
    217         } 
    218  
    219         /* strange camel ...  
    220         camel_object_unref (CAMEL_OBJECT (containee)); 
    221  
    222         Old style ... (recursively) 
    223         message_foreach_part_rec ((CamelMimeMessage*)ppriv->part,  
    224                 (CamelMimePart *)ppriv->part, received_a_part, list); */ 
    225  
    226         g_mutex_unlock (priv->parts_lock); 
    227  
    228         return; 
    229 } 
    23096 
    23197 
     
    251117 
    252118 
    253 static gint 
    254 tny_camel_msg_add_part (TnyMsg *self, TnyMimePart *part) 
    255 { 
    256         return TNY_CAMEL_MSG_GET_CLASS (self)->add_part_func (self, part); 
    257 } 
    258  
    259 static gint 
    260 tny_camel_msg_add_part_default (TnyMsg *self, TnyMimePart *part) 
    261 { 
    262         TnyCamelMsgPriv *priv = TNY_CAMEL_MSG_GET_PRIVATE (self); 
    263         TnyCamelMimePartPriv *ppriv = TNY_CAMEL_MIME_PART_GET_PRIVATE (self); 
    264         CamelMedium *medium; 
    265         CamelDataWrapper *containee; 
    266         gint curl = 0, retval = 0; 
    267         CamelMimePart *cpart; 
    268  
    269         /* Yes, indeed (I don't yet support non TnyCamelMimePart mime part  
    270            instances, and I know I should. Feel free to implement the copying 
    271            if you really need it) */ 
    272  
    273         g_assert (TNY_IS_CAMEL_MIME_PART (part)); 
    274  
    275         g_mutex_lock (priv->message_lock); 
    276         g_mutex_lock (ppriv->part_lock); 
    277  
    278         medium = CAMEL_MEDIUM (ppriv->part); 
    279         containee = camel_medium_get_content_object (medium); 
    280  
    281         /* Warp it into a multipart */ 
    282         if (G_UNLIKELY (!containee) || G_LIKELY (!CAMEL_IS_MULTIPART (containee))) 
    283         { 
    284                 /* TODO: restore original mime part? */ 
    285                 if (G_LIKELY (containee)) 
    286                         camel_object_unref (CAMEL_OBJECT (containee)); 
    287  
    288                 curl = 0; 
    289  
    290                 containee = (CamelDataWrapper*)camel_multipart_new (); 
    291                 camel_multipart_set_boundary ((CamelMultipart*)containee, NULL); 
    292                 camel_medium_set_content_object (medium, containee); 
    293         } 
    294  
    295         g_mutex_lock (priv->parts_lock); 
    296  
    297         cpart = tny_camel_mime_part_get_part (TNY_CAMEL_MIME_PART (part)); 
    298         camel_multipart_add_part ((CamelMultipart*)containee, cpart); 
    299         camel_object_unref (CAMEL_OBJECT (cpart)); 
    300  
    301         retval = camel_multipart_get_number ((CamelMultipart*)containee); 
    302         g_mutex_unlock (priv->parts_lock); 
    303  
    304         /* Warning: large lock that locks code, not data */ 
    305         g_mutex_unlock (ppriv->part_lock); 
    306         g_mutex_unlock (priv->message_lock); 
    307  
    308         return retval; 
    309 } 
    310  
    311 /* TODO: camel_mime_message_set_date(msg, time(0), 930); */ 
    312  
    313 static void  
    314 tny_camel_msg_del_part (TnyMsg *self,  TnyMimePart *part) 
    315 { 
    316         TNY_CAMEL_MSG_GET_CLASS (self)->del_part_func (self, part); 
    317         return; 
    318 } 
    319  
    320 static void  
    321 tny_camel_msg_del_part_default (TnyMsg *self, TnyMimePart *part) 
    322 { 
    323         TnyCamelMsgPriv *priv = TNY_CAMEL_MSG_GET_PRIVATE (self); 
    324         TnyCamelMimePartPriv *ppriv = TNY_CAMEL_MIME_PART_GET_PRIVATE (self); 
    325         CamelDataWrapper *containee; 
    326         CamelMimePart *cpart; 
    327  
    328         /* Yes, indeed (I don't yet support non TnyCamelMimePart mime part  
    329            instances, and I know I should. Feel free to implement the copying 
    330            if you really need it) */ 
    331  
    332         g_assert (TNY_IS_CAMEL_MIME_PART (part)); 
    333  
    334         g_mutex_lock (priv->message_lock); 
    335  
    336         containee = camel_medium_get_content_object (CAMEL_MEDIUM (ppriv->part)); 
    337  
    338         cpart = tny_camel_mime_part_get_part (TNY_CAMEL_MIME_PART (part)); 
    339         camel_multipart_remove_part (CAMEL_MULTIPART (containee), cpart); 
    340         camel_object_unref (CAMEL_OBJECT (cpart)); 
    341  
    342         /* Warning: large lock that locks code, not data */ 
    343         g_mutex_unlock (priv->message_lock); 
    344  
    345         return; 
    346 } 
    347119 
    348120void 
     
    465237        TnyMsgIface *klass = (TnyMsgIface *)g; 
    466238 
    467         klass->get_parts_func = tny_camel_msg_get_parts; 
    468239        klass->get_header_func = tny_camel_msg_get_header; 
    469240        klass->set_header_func = tny_camel_msg_set_header; 
    470         klass->add_part_func = tny_camel_msg_add_part; 
    471         klass->del_part_func = tny_camel_msg_del_part; 
    472241        klass->get_folder_func = tny_camel_msg_get_folder; 
    473242 
     
    483252        object_class = (GObjectClass*) class; 
    484253 
    485         class->get_parts_func = tny_camel_msg_get_parts_default; 
    486254        class->get_header_func = tny_camel_msg_get_header_default; 
    487255        class->set_header_func = tny_camel_msg_set_header_default; 
    488         class->add_part_func = tny_camel_msg_add_part_default; 
    489         class->del_part_func = tny_camel_msg_del_part_default; 
    490256        class->get_folder_func = tny_camel_msg_get_folder_default; 
    491257 
  • trunk/libtinymail-camel/tny-camel-msg.h

    r1102 r1194  
    5252 
    5353        /* virtual methods */ 
    54         void (*get_parts_func) (TnyMsg *self, TnyList *list); 
    5554        TnyHeader* (*get_header_func) (TnyMsg *self); 
    5655        TnyFolder* (*get_folder_func) (TnyMsg *self); 
    5756        void (*set_header_func) (TnyMsg *self, TnyHeader *header); 
    58         void (*del_part_func) (TnyMsg *self, TnyMimePart *part); 
    59         gint (*add_part_func) (TnyMsg *self, TnyMimePart *part); 
    60  
    6157}; 
    6258 
  • trunk/libtinymail-test/tny-msg-test.c

    r965 r1194  
    7676        TnyMimePart *part = TNY_MIME_PART (tny_camel_mime_part_new (cpart)); 
    7777     
    78         tny_msg_add_part (iface, part); 
     78        tny_mime_part_add_part (TNY_MIME_PART (iface), part); 
    7979 
    80         tny_msg_get_parts (iface, parts); 
     80        tny_mime_part_get_parts (TNY_MIME_PART (iface), parts); 
    8181        length = tny_list_get_length (parts); 
    8282        g_object_unref (G_OBJECT (parts)); 
     
    8888 
    8989        parts = tny_simple_list_new (); 
    90         tny_msg_del_part (iface, part); 
    91         tny_msg_get_parts (iface, parts); 
     90        tny_mime_part_del_part (TNY_MIME_PART (iface), part); 
     91        tny_mime_part_get_parts (TNY_MIME_PART (iface), parts); 
    9292        length = tny_list_get_length (parts); 
    9393        g_object_unref (G_OBJECT (parts)); 
  • trunk/libtinymail/tny-mime-part.c

    r1139 r1194  
    2222#include <tny-mime-part.h> 
    2323 
    24 /** 
    25  * tny_mime_part_is_attachment: 
    26  * @self: a #TnyMimePart object 
    27  *  
    28  * Figures out whether or not a mime part is an attachment. An attachmen
    29  * is typically something with a original filename. Examples are attached 
    30  * files. Examples that will return FALSE are PGP signatures
     24 
     25/** 
     26 * tny_mime_part_get_parts: 
     27 * @self: a #TnyMimePart object 
     28 * @list: a #TnyList objec
     29 *  
     30 * Get a read-only list of mime-parts of this mime part
    3131 * 
    3232 * Example: 
     
    3434 * TnyMsg *message = ... 
    3535 * TnyList *parts = tny_simple_list_new (); 
    36  * tny_msg_get_parts (message, parts); 
     36 * tny_mime_part_get_parts (TNY_MIME_PART (message), parts); 
     37 * iter = tny_list_create_iterator (parts); 
     38 * while (!tny_iterator_is_done (iter)) 
     39 * { 
     40 *      TnyMimePart *part = TNY_MIME_PART (tny_iterator_get_current (iter)); 
     41 *      g_object_unref (G_OBJECT (part)); 
     42 *      tny_iterator_next (iter); 
     43 * } 
     44 * g_object_unref (G_OBJECT (iter)); 
     45 * g_object_unref (G_OBJECT (parts)); 
     46 * </programlisting></informalexample> 
     47 * 
     48 **/ 
     49void 
     50tny_mime_part_get_parts (TnyMimePart *self, TnyList *list) 
     51
     52#ifdef DEBUG 
     53        if (!TNY_MIME_PART_GET_IFACE (self)->get_parts_func) 
     54                g_critical ("You must implement tny_mime_part_get_parts\n"); 
     55#endif 
     56 
     57        TNY_MIME_PART_GET_IFACE (self)->get_parts_func (self, list); 
     58        return; 
     59
     60 
     61 
     62 
     63/** 
     64 * tny_mime_part_add_part: 
     65 * @self: a #TnyMimePart object 
     66 * @part: the mime-part to add 
     67 *  
     68 * Add a mime-part to a mime part 
     69 * 
     70 * Return value: The id of the added mime-part 
     71 * 
     72 **/ 
     73gint 
     74tny_mime_part_add_part (TnyMimePart *self, TnyMimePart *part) 
     75
     76#ifdef DEBUG 
     77        if (!TNY_MIME_PART_GET_IFACE (self)->add_part_func) 
     78                g_critical ("You must implement tny_mime_part_add_part\n"); 
     79#endif 
     80 
     81        return TNY_MIME_PART_GET_IFACE (self)->add_part_func (self, part); 
     82
     83 
     84/** 
     85 * tny_mime_part_del_part: 
     86 * @self: a #TnyMimePart object 
     87 * @part: the mime-part to delete 
     88 *  
     89 * Delete a mime-part from a mime part 
     90 * 
     91 **/ 
     92void 
     93tny_mime_part_del_part (TnyMimePart *self, TnyMimePart *part) 
     94
     95#ifdef DEBUG 
     96        if (!TNY_MIME_PART_GET_IFACE (self)->del_part_func) 
     97                g_critical ("You must implement tny_mime_part_del_part\n"); 
     98#endif 
     99 
     100        TNY_MIME_PART_GET_IFACE (self)->del_part_func (self, part); 
     101        return; 
     102
     103 
     104/** 
     105 * tny_mime_part_is_attachment: 
     106 * @self: a #TnyMimePart object 
     107 *  
     108 * Figures out whether or not a mime part is an attachment. An attachment 
     109 * is typically something with a original filename. Examples are attached 
     110 * files. Examples that will return FALSE are PGP signatures. 
     111 * 
     112 * Example: 
     113 * <informalexample><programlisting> 
     114 * TnyMsg *message = ... 
     115 * TnyList *parts = tny_simple_list_new (); 
     116 * tny_mime_part_get_parts (TNY_MIME_PART (message), parts); 
    37117 * iter = tny_list_create_iterator (parts); 
    38118 * while (!tny_iterator_is_done (iter)) 
     
    402482 * TnyMsg *message = ... 
    403483 * TnyList *parts = tny_simple_list_new (); 
    404  * tny_msg_get_parts (message, parts); 
     484 * tny_mime_part_get_parts (TNY_MIME_PART (message), parts); 
    405485 * iter = tny_list_create_iterator (parts); 
    406486 * while (!tny_iterator_is_done (iter)) 
  • trunk/libtinymail/tny-mime-part.h

    r940 r1194  
    5959        void (*set_content_type_func) (TnyMimePart *self, const gchar *contenttype); 
    6060        gboolean (*is_attachment_func) (TnyMimePart *self); 
     61        void (*get_parts_func) (TnyMimePart *self, TnyList *list); 
     62        void (*del_part_func) (TnyMimePart *self, TnyMimePart *part); 
     63        gint (*add_part_func) (TnyMimePart *self, TnyMimePart *part); 
    6164}; 
    6265 
     
    7982gboolean tny_mime_part_is_attachment (TnyMimePart *self); 
    8083void tny_mime_part_decode_to_stream (TnyMimePart *self, TnyStream *stream); 
     84void tny_mime_part_get_parts (TnyMimePart *self, TnyList *list); 
     85gint tny_mime_part_add_part (TnyMimePart *self, TnyMimePart *part); 
     86void tny_mime_part_del_part (TnyMimePart *self, TnyMimePart *part); 
    8187 
    8288G_END_DECLS 
  • trunk/libtinymail/tny-msg.c

    r908 r1194  
    4444 
    4545 
    46 /** 
    47  * tny_msg_get_parts: 
    48  * @self: a #TnyMsg object 
    49  * @list: a #TnyList object 
    50  *  
    51  * Get a read-only list of mime-parts of this message. 
    52  * 
    53  * Example: 
    54  * <informalexample><programlisting> 
    55  * TnyMsg *message = ... 
    56  * TnyList *parts = tny_simple_list_new (); 
    57  * tny_msg_get_parts (message, parts); 
    58  * iter = tny_list_create_iterator (parts); 
    59  * while (!tny_iterator_is_done (iter)) 
    60  * { 
    61  *      TnyMimePart *part = TNY_MIME_PART (tny_iterator_get_current (iter)); 
    62  *      g_object_unref (G_OBJECT (part)); 
    63  *      tny_iterator_next (iter); 
    64  * } 
    65  * g_object_unref (G_OBJECT (iter)); 
    66  * g_object_unref (G_OBJECT (parts)); 
    67  * </programlisting></informalexample> 
    68  * 
    69  **/ 
    70 void 
    71 tny_msg_get_parts (TnyMsg *self, TnyList *list) 
    72 { 
    73 #ifdef DEBUG 
    74         if (!TNY_MSG_GET_IFACE (self)->get_parts_func) 
    75                 g_critical ("You must implement tny_msg_get_parts\n"); 
    76 #endif 
    77  
    78         TNY_MSG_GET_IFACE (self)->get_parts_func (self, list); 
    79         return; 
    80 } 
    8146 
    8247 
     
    10065        return TNY_MSG_GET_IFACE (self)->get_header_func (self); 
    10166} 
    102  
    103  
    104 /** 
    105  * tny_msg_add_part: 
    106  * @self: a #TnyMsg object 
    107  * @part: the mime-part to add 
    108  *  
    109  * Add a mime-part to a message 
    110  * 
    111  * Return value: The id of the added mime-part 
    112  * 
    113  **/ 
    114 gint 
    115 tny_msg_add_part (TnyMsg *self, TnyMimePart *part) 
    116 { 
    117 #ifdef DEBUG 
    118         if (!TNY_MSG_GET_IFACE (self)->add_part_func) 
    119                 g_critical ("You must implement tny_msg_add_part\n"); 
    120 #endif 
    121  
    122         return TNY_MSG_GET_IFACE (self)->add_part_func (self, part); 
    123 } 
    124  
    125 /** 
    126  * tny_msg_del_part: 
    127  * @self: a #TnyMsg object 
    128  * @part: the mime-part to delete 
    129  *  
    130  * Delete a mime-part from a message 
    131  * 
    132  **/ 
    133 void 
    134 tny_msg_del_part (TnyMsg *self, TnyMimePart *part) 
    135 { 
    136 #ifdef DEBUG 
    137         if (!TNY_MSG_GET_IFACE (self)->del_part_func) 
    138                 g_critical ("You must implement tny_msg_del_part\n"); 
    139 #endif 
    140  
    141         TNY_MSG_GET_IFACE (self)->del_part_func (self, part); 
    142         return; 
    143 } 
    144  
    14567 
    14668/** 
  • trunk/libtinymail/tny-msg.h

    r1102 r1194  
    4343        GTypeInterface parent; 
    4444 
    45         void (*get_parts_func) (TnyMsg *self, TnyList *list); 
    4645        TnyHeader* (*get_header_func) (TnyMsg *self); 
    4746        TnyFolder* (*get_folder_func) (TnyMsg *self); 
    4847        void (*set_header_func) (TnyMsg *self, TnyHeader *header); 
    49         void (*del_part_func) (TnyMsg *self, TnyMimePart *part); 
    50         gint (*add_part_func) (TnyMsg *self, TnyMimePart *part); 
    5148}; 
    5249 
    5350GType tny_msg_get_type (void); 
    5451 
    55 void tny_msg_get_parts (TnyMsg *self, TnyList *list); 
    5652TnyHeader* tny_msg_get_header (TnyMsg *self); 
    57 gint tny_msg_add_part (TnyMsg *self, TnyMimePart *part); 
    58 void tny_msg_del_part (TnyMsg *self, TnyMimePart *part); 
    5953TnyFolder* tny_msg_get_folder (TnyMsg *self); 
    6054void tny_msg_set_header (TnyMsg *self, TnyHeader *header); 
  • trunk/libtinymailui-gtk/tny-gtk-msg-view.c

    r1192 r1194  
    6161struct _TnyGtkMsgViewPriv 
    6262{ 
    63         TnyMimePart *part; TnyMsg *msg; 
     63        TnyMimePart *part; 
    6464        TnyHeaderView *headerview; 
    6565        GtkIconView *attachview; 
     
    8686 
    8787 
     88static void tny_gtk_msg_view_display_parts (TnyMsgView *self, TnyList *parts); 
    8889static void remove_mime_part_viewer (TnyMimePartView *mpview, GtkContainer *mpviewers); 
    8990 
     
    317318{ 
    318319        TnyGtkMsgViewPriv *priv = TNY_GTK_MSG_VIEW_GET_PRIVATE (self); 
    319          
    320         return (priv->msg)?TNY_MSG (g_object_ref (priv->msg)):NULL; 
     320 
     321        return (priv->part && TNY_IS_MSG (priv->part))?TNY_MSG (g_object_ref (priv->part)):NULL; 
    321322} 
    322323 
     
    347348                retval = tny_gtk_text_mime_part_view_new (); 
    348349 
    349         /* Inline message RFC822 (unsupported for now, it wont work) */ 
    350         } else if (priv->display_rfc822 && TNY_IS_MSG (part) &&  
    351                         tny_mime_part_content_type_is (part, "message/rfc822")) 
     350        /* Inline message RFC822 */ 
     351        } else if (priv->display_rfc822 && tny_mime_part_content_type_is (part, "message/rfc822")) 
    352352        { 
    353353                retval = TNY_MIME_PART_VIEW (tny_gtk_msg_view_new ()); 
     
    378378 
    379379 
    380  
    381 static void 
    382 tny_gtk_msg_view_set_msg (TnyMsgView *self, TnyMsg *msg) 
    383 
    384         TNY_GTK_MSG_VIEW_GET_CLASS (self)->set_msg_func (self, msg); 
     380static void 
     381tny_mime_part_view_proxy_func_set_part (TnyMimePartView *mpview, TnyMimePart *part) 
     382
     383                if (tny_mime_part_content_type_is (part, "message/rfc822")) 
     384                { 
     385                        TnyList *list = tny_simple_list_new (); 
     386                        tny_mime_part_get_parts (part, list); 
     387                        tny_gtk_msg_view_display_parts (TNY_MSG_VIEW (mpview), list); 
     388                        g_object_unref (G_OBJECT (list)); 
     389                } else 
     390                        tny_mime_part_view_set_part (mpview, part); 
    385391} 
    386392 
     
    390396        RealizePriv *prv = user_data; 
    391397 
    392         tny_mime_part_view_set_part (TNY_MIME_PART_VIEW (widget), prv->part); 
     398        tny_mime_part_view_proxy_func_set_part (TNY_MIME_PART_VIEW (widget), prv->part); 
    393399        g_signal_handler_disconnect (widget, prv->signal); 
    394400 
    395401        g_slice_free (RealizePriv, prv); 
    396402} 
     403 
    397404 
    398405static void 
     
    441448                                        "realize", G_CALLBACK (on_mpview_realize), prv); 
    442449                        } else 
    443                                 tny_mime_part_view_set_part (mpview, part); 
     450                                tny_mime_part_view_proxy_func_set_part (mpview, part); 
    444451                } else if (TNY_IS_GTK_ATTACHMENT_MIME_PART_VIEW (mpview))  
    445                         tny_mime_part_view_set_part (mpview, part); 
     452                        tny_mime_part_view_proxy_func_set_part (mpview, part); 
    446453                else if (!TNY_IS_GTK_ATTACHMENT_MIME_PART_VIEW (mpview))  
    447454                { 
    448455                        priv->unattached_views = g_list_prepend (priv->unattached_views, mpview); 
    449                         tny_mime_part_view_set_part (mpview, part); 
     456                        tny_mime_part_view_proxy_func_set_part (mpview, part); 
    450457                } 
    451458        } 
     
    469476} 
    470477 
    471 int d,i; 
     478static void 
     479tny_gtk_msg_view_set_msg (TnyMsgView *self, TnyMsg *msg) 
     480
     481        TNY_GTK_MSG_VIEW_GET_CLASS (self)->set_msg_func (self, msg); 
     482
    472483 
    473484static void  
    474485tny_gtk_msg_view_set_msg_default (TnyMsgView *self, TnyMsg *msg) 
    475486{ 
    476         TnyGtkMsgViewPriv *priv = TNY_GTK_MSG_VIEW_GET_PRIVATE (self); 
    477  
    478         tny_msg_view_clear (self); 
    479  
    480         if (msg) 
    481         { 
    482                 TnyGtkMsgViewPriv *priv = TNY_GTK_MSG_VIEW_GET_PRIVATE (self); 
    483                 TnyHeader *header; 
    484                 TnyIterator *iterator; 
    485                 TnyList *list; 
    486  
    487                 g_assert (TNY_IS_MSG (msg)); 
    488  
    489                 list = tny_simple_list_new (); 
    490                 priv->msg = g_object_ref (G_OBJECT (msg)); 
    491  
    492                 header = TNY_HEADER (tny_msg_get_header (priv->msg)); 
    493                 g_return_if_fail (TNY_IS_HEADER (header)); 
    494                 tny_header_view_set_header (priv->headerview, header); 
    495                 g_object_unref (G_OBJECT (header)); 
    496                 gtk_widget_show (GTK_WIDGET (priv->headerview)); 
    497  
    498                 tny_gtk_msg_view_display_part (self, TNY_MIME_PART (msg)); 
    499  
    500                 tny_msg_get_parts (priv->msg, list); 
    501                 tny_gtk_msg_view_display_parts (self, list); 
    502                 g_object_unref (G_OBJECT (list)); 
    503         } 
     487 
     488        tny_mime_part_view_set_part (TNY_MIME_PART_VIEW (self), TNY_MIME_PART (msg)); 
    504489 
    505490        return; 
     
    526511        priv->unattached_views = NULL; 
    527512 
    528         if (G_LIKELY (priv->msg)) 
    529                 g_object_unref (G_OBJECT (priv->msg)); 
    530         priv->msg = NULL; 
     513        if (G_LIKELY (priv->part)) 
     514                g_object_unref (G_OBJECT (priv->part)); 
     515        priv->part = NULL; 
    531516} 
    532517 
     
    561546} 
    562547 
     548 
    563549static void  
    564550tny_gtk_msg_view_mp_set_part_default (TnyMimePartView *self, TnyMimePart *part) 
     
    566552        TnyGtkMsgViewPriv *priv = TNY_GTK_MSG_VIEW_GET_PRIVATE (self); 
    567553 
    568         if (TNY_IS_MSG (part)) 
    569                 tny_msg_view_set_msg (TNY_MSG_VIEW (self), TNY_MSG (part)); 
    570         else 
     554        tny_msg_view_clear (self); 
     555 
     556        if (part) 
     557        { 
     558                TnyIterator *iterator; 
     559                TnyList *list; 
     560 
     561                g_assert (TNY_IS_MIME_PART (part)); 
     562 
     563                if (TNY_IS_MSG (part)) 
     564                { 
     565                        TnyHeader *header; 
     566                        header = TNY_HEADER (tny_msg_get_header (TNY_MSG (part))); 
     567                        g_return_if_fail (TNY_IS_HEADER (header)); 
     568                        tny_header_view_set_header (priv->headerview, header); 
     569                        g_object_unref (G_OBJECT (header)); 
     570                        gtk_widget_show (GTK_WIDGET (priv->headerview)); 
     571                }  
     572 
     573                list = tny_simple_list_new (); 
     574                priv->part = g_object_ref (G_OBJECT (part)); 
     575 
    571576                tny_gtk_msg_view_display_part (TNY_MSG_VIEW (self), part); 
    572  
    573         priv->part = TNY_MIME_PART (g_object_ref (part)); 
    574  
    575         return; 
    576 
    577  
     577                tny_mime_part_get_parts (part, list); 
     578                tny_gtk_msg_view_display_parts (TNY_MSG_VIEW (self), list); 
     579                g_object_unref (G_OBJECT (list)); 
     580        } 
     581 
     582        return; 
     583
    578584 
    579585 
     
    623629        priv->display_plain = TRUE; 
    624630        priv->display_attachments = TRUE; 
    625         priv->display_rfc822 = FALSE; 
     631        priv->display_rfc822 = TRUE; 
    626632        priv->display_one_body = FALSE; 
    627633 
     
    629635 
    630636        priv->unattached_views = NULL; 
    631         priv->msg = NULL; 
     637        priv->part = NULL; 
    632638 
    633639        gtk_scrolled_window_set_hadjustment (GTK_SCROLLED_WINDOW (self), NULL); 
     
    691697 
    692698        clear_prv (priv); 
    693  
    694         if (G_LIKELY (priv->msg)) 
    695                 g_object_unref (G_OBJECT (priv->msg)); 
    696699 
    697700        if (G_LIKELY (priv->part)) 
  • trunk/libtinymailui/tny-msg-view.c