Changeset 1287

Show
Ignore:
Timestamp:
12/01/06 00:30:26
Author:
pvanhoof
Message:

Bugfixes and stuff for send-queues

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libtinymail-camel/camel-lite/camel/camel-folder-summary.c

    r1211 r1287  
    196196        g_hash_table_foreach(p->filter_charset, free_o_name, 0); 
    197197 
    198         if (p->filter_index
     198        if (p->filter_index && CAMEL_IS_OBJECT (p->filter_index)
    199199                camel_object_unref((CamelObject *)p->filter_index); 
    200         if (p->filter_64
     200        if (p->filter_64 && CAMEL_IS_OBJECT (p->filter_64)
    201201                camel_object_unref((CamelObject *)p->filter_64); 
    202         if (p->filter_qp
     202        if (p->filter_qp && CAMEL_IS_OBJECT (p->filter_qp)
    203203                camel_object_unref((CamelObject *)p->filter_qp); 
    204         if (p->filter_uu
     204        if (p->filter_uu && CAMEL_IS_OBJECT (p->filter_uu)
    205205                camel_object_unref((CamelObject *)p->filter_uu); 
    206         if (p->filter_save
     206        if (p->filter_save && CAMEL_IS_OBJECT (p->filter_save)
    207207                camel_object_unref((CamelObject *)p->filter_save); 
    208         if (p->filter_html
     208        if (p->filter_html && CAMEL_IS_OBJECT (p->filter_html)
    209209                camel_object_unref((CamelObject *)p->filter_html); 
    210  
    211         if (p->filter_stream) 
     210        if (p->filter_stream && CAMEL_IS_OBJECT (p->filter_stream)) 
    212211                camel_object_unref((CamelObject *)p->filter_stream); 
    213         if (p->index
     212        if (p->index && CAMEL_IS_OBJECT (p->index)
    214213                camel_object_unref((CamelObject *)p->index); 
    215214 
  • trunk/libtinymail-camel/camel-lite/camel/providers/local/camel-local-folder.c

    r1045 r1287  
    134134        folder->summary = NULL; 
    135135        local_folder->search = NULL; 
     136        local_folder->index = NULL; 
    136137 
    137138        local_folder->priv = g_malloc0(sizeof(*local_folder->priv)); 
     
    151152        } 
    152153 
    153         if (local_folder->search) { 
     154        if (local_folder->search && CAMEL_IS_OBJECT (local_folder->search)) { 
    154155                camel_object_unref((CamelObject *)local_folder->search); 
    155156        } 
    156157 
    157         if (local_folder->index
     158        if (local_folder->index && CAMEL_IS_OBJECT (local_folder->index)
    158159                camel_object_unref((CamelObject *)local_folder->index); 
    159160 
  • trunk/libtinymail-camel/camel-lite/camel/providers/local/camel-local-summary.c

    r1043 r1287  
    431431                d(printf("Added, uid = %s\n", mi->uid)); 
    432432                if (info) { 
     433#ifdef NON_TINYMAIL_FEATURES 
     434 
    433435                        const CamelTag *tag = camel_message_info_user_tags(info); 
    434436                        const CamelFlag *flag = camel_message_info_user_flags(info); 
     
    443445                                tag = tag->next; 
    444446                        } 
     447#endif 
    445448 
    446449                        mi->info.flags |= (camel_message_info_flags(info) & 0xffff); 
  • trunk/libtinymail-camel/camel-lite/camel/providers/smtp/camel-smtp-transport.c

    r1027 r1287  
    313313         
    314314        if (ssl_mode != MODE_TLS) { 
     315 
     316                int i = 0; 
     317 
     318                i++; 
     319 
    315320                /* we're done */ 
    316321                return TRUE; 
    317         } 
     322        } else { 
    318323         
    319324#ifdef HAVE_SSL 
     
    370375         
    371376        return TRUE; 
    372          
     377 
     378        } 
     379 
    373380 exception_cleanup: 
    374381         
  • trunk/libtinymail-camel/tny-camel-folder-priv.h

    r1240 r1287  
    3737        CamelFolder *folder; 
    3838        gchar *folder_name; 
    39         TnyStoreAccount *account
     39        TnyAccount *account; CamelStore *store
    4040        guint cached_length, unread_length; 
    4141        gboolean subscribed; 
     
    6363void _tny_camel_folder_check_uncache (TnyCamelFolder *self, TnyCamelFolderPriv *priv); 
    6464void _tny_camel_folder_set_iter (TnyCamelFolder *folder, CamelFolderInfo *iter); 
    65 void _tny_camel_folder_set_account (TnyCamelFolder *self, TnyStoreAccount *account); 
     65void _tny_camel_folder_set_account (TnyCamelFolder *self, TnyAccount *account); 
    6666 
    6767void _tny_camel_folder_set_folder (TnyCamelFolder *self, CamelFolder *camel_folder); 
  • trunk/libtinymail-camel/tny-camel-folder.c

    r1270 r1287  
    168168        { 
    169169                CamelException ex = CAMEL_EXCEPTION_INITIALISER; 
    170                 CamelStore *store = (CamelStore*) _tny_camel_account_get_service  
    171                         (TNY_CAMEL_ACCOUNT (priv->account)); 
     170                CamelStore *store = priv->store; 
    172171 
    173172#ifdef HEALTHY_CHECK 
     
    196195                } 
    197196 
    198                 priv->subscribed =  
    199                         camel_store_folder_subscribed (store, 
     197                if (store->flags & CAMEL_STORE_SUBSCRIPTIONS) 
     198                        priv->subscribed =  
     199                                camel_store_folder_subscribed (store, 
    200200                                                       camel_folder_get_full_name (priv->folder)); 
     201                else  
     202                        priv->subscribed = TRUE; 
     203 
    201204                priv->cached_length = camel_folder_get_message_count (priv->folder); 
    202205 
     
    391394                        return; 
    392395                } 
    393                 store = (CamelStore*) _tny_camel_account_get_service  
    394                         (TNY_CAMEL_ACCOUNT (priv->account)); 
     396                store = priv->store; 
    395397                cfolder = _tny_camel_folder_get_camel_folder (TNY_CAMEL_FOLDER (self)); 
    396398                priv->subscribed = camel_store_folder_subscribed (store,  
     
    473475 
    474476 
    475 static TnyStoreAccount*   
     477static TnyAccount*   
    476478tny_camel_folder_get_account (TnyFolder *self) 
    477479{ 
     
    479481} 
    480482 
    481 static TnyStoreAccount*   
     483static TnyAccount*   
    482484tny_camel_folder_get_account_default (TnyFolder *self) 
    483485{ 
    484486        TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (self); 
    485487 
    486         return TNY_STORE_ACCOUNT (g_object_ref (priv->account)); 
     488        return TNY_ACCOUNT (g_object_ref (priv->account)); 
    487489} 
    488490 
    489491void 
    490 _tny_camel_folder_set_account (TnyCamelFolder *self, TnyStoreAccount *account) 
    491 
    492         TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (self); 
    493  
    494         g_assert (TNY_IS_CAMEL_STORE_ACCOUNT (account)); 
    495  
    496         priv->account = TNY_STORE_ACCOUNT (account); 
     492_tny_camel_folder_set_account (TnyCamelFolder *self, TnyAccount *account) 
     493
     494        TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (self); 
     495 
     496        g_assert (TNY_IS_CAMEL_ACCOUNT (account)); 
     497 
     498        priv->account = account; 
     499        priv->store = (CamelStore*) _tny_camel_account_get_service (TNY_CAMEL_ACCOUNT (priv->account)); 
    497500 
    498501        return; 
     
    12741277{ 
    12751278        TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (self); 
    1276         CamelStore *store = (CamelStore*) _tny_camel_account_get_service  
    1277                 (TNY_CAMEL_ACCOUNT (priv->account)); 
     1279        CamelStore *store = priv->store; 
    12781280        TnyCamelFolder *cfol = TNY_CAMEL_FOLDER (folder); 
    12791281        TnyCamelFolderPriv *cpriv = TNY_CAMEL_FOLDER_GET_PRIVATE (cfol); 
     
    13241326{ 
    13251327        TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (self); 
    1326         TnyCamelStoreAccountPriv *apriv = TNY_CAMEL_STORE_ACCOUNT_GET_PRIVATE (priv->account); 
    13271328 
    13281329        _tny_camel_folder_set_id (folder, info->full_name); 
     
    13321333        _tny_camel_folder_set_name (folder, info->name); 
    13331334        _tny_camel_folder_set_iter (folder, info); 
    1334          
    1335         apriv->managed_folders = g_list_prepend (apriv->managed_folders, folder); 
    1336         _tny_camel_folder_set_account (folder, TNY_STORE_ACCOUNT (priv->account)); 
     1335 
     1336        if (TNY_IS_CAMEL_STORE_ACCOUNT (priv->account)) 
     1337        { 
     1338                TnyCamelStoreAccountPriv *apriv = TNY_CAMEL_STORE_ACCOUNT_GET_PRIVATE (priv->account);   
     1339                apriv->managed_folders = g_list_prepend (apriv->managed_folders, folder); 
     1340        } 
     1341 
     1342        _tny_camel_folder_set_account (folder, priv->account); 
    13371343} 
    13381344 
     
    13701376        } 
    13711377 
    1372         store = (CamelStore*) _tny_camel_account_get_service (TNY_CAMEL_ACCOUNT (priv->account))
     1378        store = (CamelStore*) priv->store
    13731379 
    13741380        g_assert (CAMEL_IS_STORE (store)); 
     
    14531459{ 
    14541460        TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (self); 
    1455         TnyCamelStoreAccountPriv *apriv = TNY_CAMEL_STORE_ACCOUNT_GET_PRIVATE (priv->account); 
    14561461        CamelFolderInfo *iter; 
    14571462 
     
    14601465        if (!priv->iter && priv->iter_parented) 
    14611466        { 
    1462                 CamelStore *store = (CamelStore*) _tny_camel_account_get_service (TNY_CAMEL_ACCOUNT (priv->account))
     1467                CamelStore *store = priv->store
    14631468                CamelException ex = CAMEL_EXCEPTION_INITIALISER; 
    14641469 
     
    16951700        g_mutex_lock (priv->folder_lock); 
    16961701 
    1697         if (priv->account
     1702        if (priv->account && TNY_IS_CAMEL_STORE_ACCOUNT (priv->account)
    16981703        { 
    16991704                TnyCamelStoreAccountPriv *apriv = TNY_CAMEL_STORE_ACCOUNT_GET_PRIVATE (priv->account); 
     
    17031708        if (!priv->iter_parented && priv->iter) 
    17041709        { 
    1705                 CamelStore *store = (CamelStore*) _tny_camel_account_get_service (TNY_CAMEL_ACCOUNT (priv->account))
     1710                CamelStore *store = priv->store
    17061711                camel_store_free_folder_info (store, priv->iter); 
    17071712        } 
  • trunk/libtinymail-camel/tny-camel-folder.h

    r1262 r1287  
    6060        const gchar* (*get_name_func) (TnyFolder *self); 
    6161        const gchar* (*get_id_func) (TnyFolder *self); 
    62         TnyStoreAccount* (*get_account_func) (TnyFolder *self); 
     62        TnyAccount* (*get_account_func) (TnyFolder *self); 
    6363        void (*set_name_func) (TnyFolder *self, const gchar *name, GError **err); 
    6464        TnyFolderType (*get_folder_type_func) (TnyFolder *self); 
  • trunk/libtinymail-camel/tny-camel-send-queue-priv.h

    r1233 r1287  
    2222 
    2323#include <tny-camel-transport-account.h> 
     24#include <tny-folder.h> 
    2425 
    2526typedef struct _TnyCamelSendQueuePriv TnyCamelSendQueuePriv; 
     
    2728struct _TnyCamelSendQueuePriv 
    2829{ 
    29         GMutex *todo_lock; 
    3030        TnyTransportAccount *trans_account; 
     31        TnyFolder *sentbox_cache, *outbox_cache; 
    3132        guint total; 
    3233        GThread *thread; 
    33         gchar *path
     34        GMutex *todo_lock; gboolean creating_spin
    3435}; 
    3536 
  • trunk/libtinymail-camel/tny-camel-send-queue.c

    r1267 r1287  
    2828#include <tny-folder.h> 
    2929 
     30#include <tny-camel-folder.h> 
     31#include <tny-transport-account.h> 
     32 
    3033static GObjectClass *parent_class = NULL; 
    3134 
    3235#include "tny-camel-send-queue-priv.h" 
     36#include "tny-camel-folder-priv.h" 
     37#include "tny-camel-account-priv.h" 
    3338 
    3439#define TNY_CAMEL_SEND_QUEUE_GET_PRIVATE(o)     \ 
    3540        (G_TYPE_INSTANCE_GET_PRIVATE ((o), TNY_TYPE_CAMEL_SEND_QUEUE, TnyCamelSendQueuePriv)) 
     41 
    3642 
    3743 
     
    4450        guint i = 0, length = 0; 
    4551        TnyList *list; 
     52 
     53        priv->creating_spin = FALSE; 
    4654 
    4755        list = tny_simple_list_new (); 
     
    7280                        tny_folder_get_headers (outbox, headers, TRUE, NULL); 
    7381                        length = tny_list_get_length (headers); 
     82 
    7483                        priv->total = length; 
    7584                        if (length <= 0) 
     
    8998                { 
    9099                        TnyList *hassent = tny_simple_list_new (); 
     100                        GError *err = NULL; 
    91101 
    92102                        tny_list_prepend (hassent, G_OBJECT (header)); 
    93103                        /* TODO handle and report errors here */ 
    94                         msg = tny_folder_get_msg (sentbox, header, NULL); 
     104                        msg = tny_folder_get_msg (outbox, header, &err); 
     105 
     106 
     107                        /* TODO handle and report errors here */ 
    95108                        g_object_unref (G_OBJECT (header));      
    96109 
    97                         /* TODO handle and report errors here */ 
    98                         tny_transport_account_send (priv->trans_account, msg, NULL); 
     110                        if (err == NULL) 
     111                                tny_transport_account_send (priv->trans_account, msg, NULL); 
     112                        else 
     113                                g_print ("error: %s\n", err->message); 
    99114 
    100115                        g_mutex_lock (priv->todo_lock); 
     
    109124 
    110125                        g_signal_emit (self, tny_send_queue_signals [TNY_SEND_QUEUE_MSG_SENT],  
    111                                 3, msg, i, priv->total); 
     126                                0, msg, i, priv->total); 
    112127 
    113128                        i++; 
     
    126141        g_object_unref (G_OBJECT (outbox)); 
    127142 
     143        priv->thread = NULL; 
     144 
    128145        g_thread_exit (NULL); 
    129146        return NULL; 
    130147} 
     148 
     149static void  
     150create_worker (TnySendQueue *self) 
     151{ 
     152        TnyCamelSendQueuePriv *priv = TNY_CAMEL_SEND_QUEUE_GET_PRIVATE (self); 
     153 
     154        while (priv->creating_spin); 
     155 
     156        priv->creating_spin = TRUE; 
     157        priv->thread = g_thread_create (thread_main, self, TRUE, NULL); 
     158 
     159        return; 
     160} 
     161 
    131162 
    132163static void 
     
    159190                priv->total++; 
    160191 
    161                 if (priv->total == 1
    162                         priv->thread = g_thread_create (thread_main, self, TRUE, NULL); 
     192                if (priv->total >= 1 && !priv->thread && !priv->creating_spin
     193                        create_worker (self); 
    163194 
    164195                g_object_unref (G_OBJECT (outbox)); 
     
    167198 
    168199        return; 
     200} 
     201 
     202 
     203static TnyFolder* 
     204create_maildir (TnySendQueue *self, const gchar *name) 
     205{ 
     206        TnyCamelSendQueuePriv *priv = TNY_CAMEL_SEND_QUEUE_GET_PRIVATE (self); 
     207        TnyCamelAccountPriv *apriv = TNY_CAMEL_ACCOUNT_GET_PRIVATE (TNY_CAMEL_ACCOUNT (priv->trans_account)); 
     208        CamelStore *store = (CamelStore*) apriv->service; 
     209        CamelSession *session = (CamelSession*) apriv->session; 
     210        CamelException ex = CAMEL_EXCEPTION_INITIALISER; 
     211        gchar *full_path; 
     212        const gchar *aname; 
     213        CamelStore *mdstore = NULL; 
     214 
     215        aname = tny_account_get_name (TNY_ACCOUNT (priv->trans_account)); 
     216        if (aname == NULL) 
     217                aname = tny_account_get_id (TNY_ACCOUNT (priv->trans_account)); 
     218 
     219        g_assert (aname); 
     220 
     221        full_path = g_strdup_printf ("maildir://%s/%s/maildir", session->storage_path, aname); 
     222 
     223        mdstore = camel_session_get_store(session, full_path, &ex); 
     224 
     225        /*      mdstore = _tny_camel_account_get_service (TNY_CAMEL_ACCOUNT (priv->trans_account)); */ 
     226 
     227        if (!camel_exception_is_set (&ex) && mdstore) 
     228        { 
     229                CamelFolder *cfolder = NULL; 
     230 
     231                cfolder = camel_store_get_folder (mdstore, name, CAMEL_STORE_FOLDER_CREATE, &ex); 
     232                if (!camel_exception_is_set (&ex) && cfolder) 
     233                { 
     234                        CamelFolderInfo *iter; 
     235 
     236                        /* camel_object_unref (CAMEL_OBJECT (cfolder)); */ 
     237 
     238                        iter = camel_store_get_folder_info (mdstore, name,  
     239                                        CAMEL_STORE_FOLDER_INFO_FAST|CAMEL_STORE_FOLDER_INFO_NO_VIRTUAL,&ex); 
     240 
     241                        if (!camel_exception_is_set (&ex) && iter) 
     242                        { 
     243                                TnyCamelFolder *folder = TNY_CAMEL_FOLDER (tny_camel_folder_new ()); 
     244                                TnyCamelFolderPriv *fpriv = TNY_CAMEL_FOLDER_GET_PRIVATE (folder); 
     245 
     246                                _tny_camel_folder_set_id (folder, iter->full_name); 
     247                                _tny_camel_folder_set_folder_type (folder, iter); 
     248                                _tny_camel_folder_set_unread_count (folder, iter->unread); 
     249                                _tny_camel_folder_set_all_count (folder, iter->total); 
     250                                _tny_camel_folder_set_name (folder, iter->name); 
     251                                _tny_camel_folder_set_iter (folder, iter); 
     252                                _tny_camel_folder_set_account (folder, TNY_ACCOUNT (priv->trans_account)); 
     253 
     254                                fpriv->store = mdstore; 
     255 
     256                                g_free (full_path); 
     257 
     258                                return TNY_FOLDER (folder); 
     259 
     260                        } 
     261 
     262                } else  
     263                { 
     264                        g_critical (_("Can't create folder \"%s\" in %s"), name, full_path); 
     265                        if (cfolder && CAMEL_IS_OBJECT (cfolder)) 
     266                                camel_object_unref (CAMEL_OBJECT (cfolder)); 
     267                } 
     268        } else  
     269        { 
     270                g_critical (_("Can't create store on %s"), full_path); 
     271                if (store && CAMEL_IS_OBJECT (mdstore)) 
     272                        camel_object_unref (CAMEL_OBJECT (mdstore)); 
     273        } 
     274 
     275        g_free (full_path); 
     276 
     277        return NULL; 
    169278} 
    170279 
     
    178287tny_camel_send_queue_get_sentbox_default (TnySendQueue *self) 
    179288{ 
    180         /* TODO: Implement using Maildir in priv->path + "/sentbox" */ 
    181  
    182         g_critical (" This TnySendQueue implementation doesn't yet support a sentbox"); 
    183  
    184         return NULL; 
     289        TnyCamelSendQueuePriv *priv = TNY_CAMEL_SEND_QUEUE_GET_PRIVATE (self); 
     290 
     291        if (!priv->sentbox_cache) 
     292                priv->sentbox_cache = create_maildir (self, "sentbox"); 
     293 
     294        return TNY_FOLDER (g_object_ref (G_OBJECT (priv->sentbox_cache))); 
    185295} 
    186296 
     
    195305tny_camel_send_queue_get_outbox_default (TnySendQueue *self) 
    196306{ 
    197         /* TODO: Implement using Maildir in priv->path + "/outbox" */ 
    198  
    199         g_critical (" This TnySendQueue implementation doesn't yet support an outbox"); 
    200  
    201         return NULL; 
     307        TnyCamelSendQueuePriv *priv = TNY_CAMEL_SEND_QUEUE_GET_PRIVATE (self); 
     308 
     309        if (!priv->outbox_cache) 
     310                priv->outbox_cache = create_maildir (self, "outbox"); 
     311 
     312        return TNY_FOLDER (g_object_ref (G_OBJECT (priv->outbox_cache))); 
    202313} 
    203314 
     
    210321        g_mutex_lock (priv->todo_lock); 
    211322                 
    212         if (priv->path) 
    213                 g_free (priv->path); 
     323        if (priv->sentbox_cache) 
     324                g_object_unref (G_OBJECT (priv->sentbox_cache)); 
     325 
     326        if (priv->outbox_cache) 
     327                g_object_unref (G_OBJECT (priv->outbox_cache)); 
    214328 
    215329        g_mutex_unlock (priv->todo_lock); 
     
    239353         
    240354        priv->trans_account = TNY_TRANSPORT_ACCOUNT (g_object_ref (G_OBJECT (trans_account))); 
    241  
    242         /* TODO: Do some camel-specific stuff to get priv->path right, it's where 
    243            the sentbox and the outbox are going to be located or must be located in 
    244            case they are already created */ 
     355         
     356        g_mutex_lock (priv->todo_lock); 
     357        { 
     358                TnyFolder *outbox; 
     359                TnyList *headers = tny_simple_list_new (); 
     360 
     361                outbox = tny_send_queue_get_outbox (TNY_SEND_QUEUE (self)); 
     362 
     363                /* TODO handle and report errors here */ 
     364                tny_folder_get_headers (outbox, headers, TRUE, NULL); 
     365                priv->total = tny_list_get_length (headers); 
     366                g_object_unref (G_OBJECT (headers)); 
     367 
     368                if (priv->total >= 1) 
     369                        create_worker (TNY_SEND_QUEUE (self)); 
     370 
     371                g_object_unref (G_OBJECT (outbox)); 
     372        } 
     373        g_mutex_unlock (priv->todo_lock); 
     374 
    245375 
    246376        return TNY_SEND_QUEUE (self); 
     
    286416        TnyCamelSendQueuePriv *priv = TNY_CAMEL_SEND_QUEUE_GET_PRIVATE (self); 
    287417 
    288         priv->path = NULL; 
     418        priv->creating_spin = FALSE; 
     419        priv->sentbox_cache = NULL; 
     420        priv->outbox_cache = NULL; 
    289421        priv->todo_lock = g_mutex_new (); 
    290422 
  • trunk/libtinymail-camel/tny-camel-store-account.c

    r1270 r1287  
    517517                        _tny_camel_folder_set_iter (folder, iter); 
    518518                        priv->managed_folders = g_list_prepend (priv->managed_folders, folder); 
    519                         _tny_camel_folder_set_account (folder, TNY_STORE_ACCOUNT (self)); 
     519                        _tny_camel_folder_set_account (folder, TNY_ACCOUNT (self)); 
    520520 
    521521                        tny_list_prepend (list, G_OBJECT (folder)); 
  • trunk/libtinymail-camel/tny-camel-transport-account.c

    r1273 r1287  
    107107                        apriv->url_string, &ex); 
    108108 
    109         if (camel_exception_is_set (&ex)
     109        if (camel_exception_is_set (&ex) || !transport
    110110        { 
    111111                g_set_error (err, TNY_TRANSPORT_ACCOUNT_ERROR,  
     
    113113                        camel_exception_get_description (&ex)); 
    114114 
    115                 if (transport && CAMEL_IS_TRANSPORT (transport)) 
     115                if (transport && CAMEL_IS_OBJECT (transport)) 
    116116                        camel_object_unref (CAMEL_OBJECT (transport)); 
    117117 
  • trunk/libtinymail-gnome-desktop/tny-gnome-account-store.c

    r1212 r1287  
    186186{ 
    187187        gchar *retval = NULL; 
    188         const gchar *accountid = tny_account_get_id (account); 
     188        const gchar *accountid; 
     189 
     190        gdk_threads_enter (); 
     191 
     192        accountid = tny_account_get_id (account); 
    189193 
    190194        if (G_UNLIKELY (!passwords)) 
     
    226230                *cancel = FALSE; 
    227231        } 
     232 
     233        gdk_threads_leave (); 
    228234 
    229235        return retval; 
     
    275281        } 
    276282 
     283        gdk_threads_enter (); 
     284 
    277285        dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, 
    278286                                  gtktype, GTK_BUTTONS_YES_NO, prompt); 
     
    282290 
    283291        gtk_widget_destroy (dialog); 
     292 
     293        gdk_threads_leave (); 
    284294 
    285295        return retval; 
  • trunk/libtinymail/tny-folder.c

    r1265 r1287  
    357357 * 
    358358 **/ 
    359 TnyStoreAccount*   
     359TnyAccount*   
    360360tny_folder_get_account (TnyFolder *self) 
    361361{ 
  • trunk/libtinymail/tny-folder.h

    r1262 r1287  
    8080        const gchar* (*get_name_func) (TnyFolder *self); 
    8181        const gchar* (*get_id_func) (TnyFolder *self); 
    82         TnyStoreAccount* (*get_account_func) (TnyFolder *self); 
     82        TnyAccount* (*get_account_func) (TnyFolder *self); 
    8383        void (*set_name_func) (TnyFolder *self, const gchar *name, GError **err); 
    8484        TnyFolderType (*get_folder_type_func) (TnyFolder *self); 
     
    101101TnyMsg* tny_folder_get_msg (TnyFolder *self, TnyHeader *header, GError **err); 
    102102void tny_folder_get_headers (TnyFolder *self, TnyList *headers, gboolean refresh, GError **err); 
    103 TnyStoreAccount* tny_folder_get_account (TnyFolder *self); 
     103TnyAccount* tny_folder_get_account (TnyFolder *self); 
    104104const gchar* tny_folder_get_id (TnyFolder *self); 
    105105const gchar* tny_folder_get_name (TnyFolder *self); 
  • trunk/libtinymail/tny-msg.c

    r1199 r1287  
    121121 
    122122                g_type_interface_add_prerequisite (type, TNY_TYPE_MIME_PART);  
     123 
     124                g_type_interface_add_prerequisite (type, G_TYPE_OBJECT); 
     125 
    123126        } 
    124127 
  • trunk/tinymail/tny-demoui-summary-view.c

    r1281 r1287  
    2626#include <gdk/gdkkeysyms.h> 
    2727 
     28#include <tny-simple-list.h> 
     29#include <tny-iterator.h> 
    2830#include <tny-platform-factory.h> 
    2931 
     
    7375static GObjectClass *parent_class = NULL; 
    7476 
     77#include <tny-camel-send-queue.h> 
     78#include <tny-camel-transport-account.h> 
     79 
     80static TnySendQueue *queue = NULL; 
    7581 
    7682typedef struct _TnyDemouiSummaryViewPriv TnyDemouiSummaryViewPriv; 
     
    504510                        GtkTreeViewColumn *col,  gpointer userdata) 
    505511{ 
     512        TnyDemouiSummaryViewPriv *priv = userdata; 
    506513        GtkTreeModel *model; 
    507514        GtkTreeIter iter; 
     
    548555                                if (G_LIKELY (msg)) 
    549556                                { 
     557 
     558/* DEBUG                 
     559                                        TnyAccountStore *astore = priv->account_store; 
     560                                        TnyList *accs = tny_simple_list_new (); 
     561                                        tny_account_store_get_accounts (astore, accs, TNY_ACCOUNT_STORE_TRANSPORT_ACCOUNTS); 
     562                                        TnyIterator *iter = tny_list_create_iterator (accs); 
     563                                        TnyCamelTransportAccount *acc = (TnyCamelTransportAccount *) tny_iterator_get_current (iter); 
     564 
     565                                        g_print ("--> %s\n", tny_account_get_name (TNY_ACCOUNT (acc))); 
     566                 
     567                                        if (!queue) 
     568                                                queue = tny_camel_send_queue_new (acc); 
     569                 
     570                                        tny_send_queue_add (queue, msg); 
     571 
     572                                        g_object_unref (G_OBJECT (acc)); 
     573                                        g_object_unref (G_OBJECT (iter)); 
     574                                        g_object_unref (G_OBJECT (accs)); 
     575*/ 
     576 
    550577                                        msgwin = tny_gtk_msg_window_new ( 
    551578                                                tny_platform_factory_new_msg_view (platfact)); 
     
    556583                                        gtk_widget_show (GTK_WIDGET (msgwin)); 
    557584                                } else { 
     585 
     586 
     587 
    558588                                        msgwin = tny_gtk_msg_window_new ( 
    559589                                                tny_platform_factory_new_msg_view (platfact)); 
     
    777807        gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE); 
    778808        g_signal_connect(G_OBJECT (priv->header_view), "row-activated",  
    779                 G_CALLBACK (on_header_view_tree_row_activated), priv->header_view); 
     809                G_CALLBACK (on_header_view_tree_row_activated), priv); 
    780810 
    781811        g_signal_connect(G_OBJECT (priv->header_view), "key-press-event",