Changeset 1740

Show
Ignore:
Timestamp:
03/20/07 23:04:27
Author:
pvanhoof
Message:

Potential fix for ticket 30

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/ChangeLog

    r1739 r1740  
     12007-03-20  Philip Van Hoof  <pvanhoof@gnome.org> 
     2 
     3        * Although this needs a lot testing, potential fix for ticket #30 
     4 
    152007-03-19  Philip Van Hoof  <pvanhoof@gnome.org> 
    26 
  • trunk/libtinymail-camel/camel-lite/camel/camel-folder-summary.c

    r1739 r1740  
    149149        mi->flags &= ~CAMEL_MESSAGE_PARTIAL; 
    150150        mi->flags &= ~CAMEL_MESSAGE_EXPUNGED; 
    151         mi->flags &= ~CAMEL_MESSAGE_FREED; 
    152151        mi->flags &= ~CAMEL_MESSAGE_SECURE; 
    153152        mi->flags &= ~CAMEL_MESSAGE_FOLDER_FLAGGED; 
    154         /* CAMEL_MESSAGE_INFO_NEEDS_FREE  
    155         CAMEL_MESSAGE_INFO_UID_NEEDS_FREE */ 
    156         mi->flags &= ~CAMEL_MESSAGE_USER; 
    157153 
    158154} 
     
    402398{ 
    403399        CamelFolderSummary *new = CAMEL_FOLDER_SUMMARY ( camel_object_new (camel_folder_summary_get_type ())); 
    404  
    405400        new->folder = folder; 
    406          
    407401        return new; 
    408402} 
     
    715709                goto error; 
    716710 
     711        if (s->messages && s->messages->len > s->saved_count) 
     712        { 
     713                int r, curlen = s->messages->len; 
     714                for (r = curlen - 1; r >= s->saved_count - 1; r--) 
     715                {  
     716                        CamelMessageInfo *ri = g_ptr_array_index (s->messages, r); 
     717                        if (ri) 
     718                                camel_folder_summary_remove (s, ri); 
     719                } 
     720        } 
     721 
    717722        /* now read in each message ... */ 
    718         for (i=0;i<s->saved_count;i++)  
     723        for (i=0; i < s->saved_count; i++)  
    719724        { 
    720725                gboolean must_add = FALSE; 
    721726                s->idx = i; 
     727 
    722728                mi = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_load(s, &must_add); 
    723729 
     
    32393245        if (mi == NULL || mi->refcount <=0) 
    32403246                retval = (void*) 0; 
     3247        if (((CamelMessageInfoBase*)mi)->flags & CAMEL_MESSAGE_FREED) 
     3248                retval = "Invalid"; 
    32413249        else switch (id)  
    32423250        { 
     
    35473555                retval = info_set_flags(mi, flags, set); 
    35483556 
    3549         g_static_rec_mutex_lock (&global_lock); 
     3557        g_static_rec_mutex_unlock (&global_lock); 
    35503558 
    35513559        return retval; 
  • trunk/libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-command.c

    r1699 r1740  
    209209        /* g_mutex_unlock (store->stream_lock);*/ 
    210210 
    211         camel_imap_store_stop_idle (store); 
     211 
     212        /* Also read imap_update_summary and all of the IDLE crap */ 
     213        if (!store->dontdistridlehack)  
     214                camel_imap_store_stop_idle (store); 
     215        /* else 
     216                printf ("dont distr\n"); */ 
    212217 
    213218        /* Check for current folder */ 
  • trunk/libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-folder.c

    r1739 r1740  
    29352935   GPtrArray *needheaders; 
    29362936   guint32 flags; 
    2937    int i, seq=0; 
     2937   int seq=0; 
    29382938   CamelImapResponseType type; 
    29392939   const char *header_spec; 
     
    29712971   camel_folder_summary_prepare_hash (folder->summary); 
    29722972 
     2973   store->dontdistridlehack = TRUE; 
     2974 
    29732975   while (more) 
    29742976   { 
     
    30003002                more = FALSE; 
    30013003                camel_folder_summary_kill_hash (folder->summary); 
     3004                store->dontdistridlehack = FALSE; 
    30023005                return; 
    30033006        } 
     
    30143017                        { if (!camel_operation_cancel_check (NULL)) 
    30153018                                g_warning ("IMAP error getting UIDs (2)");  
    3016                           camel_operation_end (NULL); return; } 
     3019                          camel_operation_end (NULL);  
     3020                          store->dontdistridlehack = FALSE; return; } 
    30173021                cnt = imap_get_uids (folder, store, ex, needheaders, (exists - seq) - cnt); 
    30183022 
     
    30273031                        more = FALSE; 
    30283032                        camel_folder_summary_kill_hash (folder->summary); 
     3033                        store->dontdistridlehack = FALSE; 
    30293034                        return; 
    30303035                } 
     
    30423047                                        g_warning ("IMAP error getting UIDs (3)"); 
    30433048                                        camel_folder_summary_kill_hash (folder->summary); 
    3044                                   camel_operation_end (NULL); return; } 
     3049                                  camel_operation_end (NULL);  
     3050                                  store->dontdistridlehack = FALSE; return; } 
    30453051                        camel_folder_summary_clear (folder->summary); 
    30463052                        tcnt = cnt = imap_get_uids (folder, store, ex, needheaders, (exists - seq) - tcnt); 
     
    30563062                                more = FALSE; 
    30573063                                camel_folder_summary_kill_hash (folder->summary); 
     3064                                store->dontdistridlehack = FALSE; 
    30583065                                return; 
    30593066                        } 
     
    30903097                                more = FALSE; 
    30913098                                camel_folder_summary_kill_hash (folder->summary); 
     3099                                store->dontdistridlehack = FALSE; 
    30923100                                return; 
    30933101                        } 
     
    31423150                                                for (r = curlen-1; r >= sequence -1; r--) 
    31433151                                                {  
    3144                                                         CamelMessageInfo *ri = g_ptr_array_index (folder->summary->messages, i); (folder->summary, i); 
    3145                                                         if (ri) 
     3152                                                        printf ("curlen=%d, r=%d, seq=%d\n", curlen, r, sequence); 
     3153                                                        CamelMessageInfo *ri = g_ptr_array_index (folder->summary->messages, r); 
     3154                                                        if (ri) { 
     3155 
     3156                                                                /* CamelFolderChangeInfo *uchange = camel_folder_change_info_new (); 
     3157                                                                camel_folder_change_info_remove_uid (uchange, camel_message_info_uid (mi)); 
     3158                                                                if (camel_folder_change_info_changed (uchange)) 
     3159                                                                        camel_object_trigger_event (CAMEL_OBJECT (folder), "folder_changed", uchange); 
     3160                                                                camel_folder_change_info_free (uchange); */ 
     3161 
     3162                                                                ((CamelMessageInfoBase*)ri)->flags |= CAMEL_MESSAGE_EXPUNGED; 
     3163                                                                ((CamelMessageInfoBase*)ri)->flags |= CAMEL_MESSAGE_FREED; 
    31463164                                                                camel_folder_summary_remove (folder->summary, ri); 
     3165                                                        } 
    31473166                                                } 
    31483167                                        } else { 
     
    31873206                                more = FALSE; 
    31883207                                camel_folder_summary_kill_hash (folder->summary); 
     3208                                store->dontdistridlehack = FALSE; 
    31893209                                return; 
    31903210                        } 
     
    32113231 
    32123232   imap_folder->need_rescan = oldrescval; 
     3233   store->dontdistridlehack = FALSE; 
    32133234 
    32143235} 
     
    32293250 
    32303251static void  
    3231 process_idle_response (IdleResponse *idle_resp, gboolean restart
     3252process_idle_response (IdleResponse *idle_resp
    32323253{ 
    32333254        CamelImapStore *store; 
     
    32673288                                                changes = camel_folder_change_info_new(); 
    32683289                                        camel_folder_change_info_change_uid(changes, info->uid); 
    3269                                         /* flags_to_label(idle_resp->folder, (CamelImapMessageInfo *)info); */ 
    32703290                                } 
    32713291                                camel_message_info_free (info); 
     
    32863306                idle_resp->expunged, &ex); 
    32873307 
    3288         /* Restart the idle if needed */ 
    3289         if (restart) 
    3290                 camel_imap_folder_start_idle (idle_resp->folder); 
    3291  
    32923308} 
    32933309 
     
    33063322        { 
    33073323                char *fptr = resp; 
    3308  
    3309                 /* 2 FETCH (FLAGS (\Recent \Seen)) 
    3310                  * 3 FETCH (FLAGS (\Recent \Seen)) 
    3311                  * 4 FETCH (FLAGS (\Recent \Seen)) */ 
    33123324 
    33133325                FetchIdleResponse *fid = g_slice_new0 (FetchIdleResponse); 
     
    33583370} 
    33593371 
     3372static void 
     3373idle_real_start (CamelImapStore *store) 
     3374{ 
     3375        g_mutex_lock (store->stream_lock); 
     3376        store->idle_prefix = g_strdup_printf ("%c%.5u",  
     3377                store->tag_prefix, store->command++); 
     3378        camel_stream_printf (store->ostream, "%s IDLE\r\n", 
     3379                store->idle_prefix); 
     3380        g_mutex_unlock (store->stream_lock); 
     3381 
     3382} 
     3383 
    33603384static IdleResponse* 
    3361 idle_deal_with_stuff (CamelFolder *folder, CamelImapStore *store, gboolean done, gboolean *had_err
     3385idle_deal_with_stuff (CamelFolder *folder, CamelImapStore *store, gboolean *had_err, gboolean needlock, gboolean *hadlock
    33623386{ 
    33633387  IdleResponse *idle_resp = NULL; 
     
    33803404 
    33813405  locked = CAMEL_SERVICE_REC_TRYLOCK (store, connect_lock); 
     3406  if (needlock && !locked) 
     3407  { 
     3408        CAMEL_SERVICE_REC_LOCK (store, connect_lock); 
     3409        locked = TRUE; 
     3410  } 
     3411 
    33823412  if (locked) 
    33833413  { 
     3414        *hadlock = TRUE; 
     3415 
    33843416        if (store->current_folder) 
    33853417        { 
     
    34023434                        g_free (resp); 
    34033435 
    3404                 if (done) 
     3436                g_mutex_lock (store->stream_lock); 
     3437                if (!camel_disco_store_check_online ((CamelDiscoStore*)store, &ex)) 
     3438                        { g_mutex_unlock (store->stream_lock); return NULL; } 
     3439                if (store->istream == NULL || ((CamelObject *)store->istream)->ref_count <= 0) 
     3440                        { g_mutex_unlock (store->stream_lock); return NULL; } 
     3441                if (store->ostream == NULL || ((CamelObject *)store->istream)->ref_count <= 0) 
     3442                        { g_mutex_unlock (store->stream_lock); return NULL; } 
     3443                if (store->ostream && CAMEL_IS_STREAM (store->ostream)) 
     3444                        nwritten = camel_stream_printf (store->ostream, "DONE\r\n"); 
     3445                g_mutex_unlock (store->stream_lock); 
     3446 
     3447                if (nwritten == -1)  
     3448                        goto outofhere; 
     3449 
     3450                resp = NULL; 
     3451                while ((type = camel_imap_command_response_idle (store, &resp, &ex)) == CAMEL_IMAP_RESPONSE_UNTAGGED)  
    34053452                { 
    3406                         g_mutex_lock (store->stream_lock); 
    3407                         if (!camel_disco_store_check_online ((CamelDiscoStore*)store, &ex)) 
    3408                                 { g_mutex_unlock (store->stream_lock); return NULL; } 
    3409                         if (store->istream == NULL || ((CamelObject *)store->istream)->ref_count <= 0) 
    3410                                 { g_mutex_unlock (store->stream_lock); return NULL; } 
    3411                         if (store->ostream == NULL || ((CamelObject *)store->istream)->ref_count <= 0) 
    3412                                 { g_mutex_unlock (store->stream_lock); return NULL; } 
    3413                         if (store->ostream && CAMEL_IS_STREAM (store->ostream)) 
    3414                                 nwritten = camel_stream_printf (store->ostream, "DONE\r\n"); 
    3415                         g_mutex_unlock (store->stream_lock); 
    3416  
    3417                         if (nwritten == -1)  
    3418                                 goto outofhere; 
    3419  
    3420                         while ((type = camel_imap_command_response_idle (store, &resp, &ex)) == CAMEL_IMAP_RESPONSE_UNTAGGED)  
     3453                        /* printf ("D resp: %s\n", resp); */ 
     3454                        if (strchr (resp, '*') != NULL && (strstr (resp, "EXISTS") || 
     3455                                strstr (resp, "FETCH") || strstr (resp, "EXPUNGE") ||  
     3456                                strstr (resp, "RECENT"))) 
    34213457                        { 
    3422                                 /* printf ("D resp: %s\n", resp); */ 
    3423                                 if (strchr (resp, '*') != NULL && (strstr (resp, "EXISTS") || 
    3424                                         strstr (resp, "FETCH") || strstr (resp, "EXPUNGE") ||  
    3425                                         strstr (resp, "RECENT"))) 
    3426                                 { 
    3427                                         if (!idle_resp) 
    3428                                                 idle_resp = idle_response_new (folder); 
    3429                                         read_idle_response (folder, resp, idle_resp); 
    3430                                 } 
    3431                                 g_free (resp); resp=NULL; 
     3458                                if (!idle_resp) 
     3459                                        idle_resp = idle_response_new (folder); 
     3460                                read_idle_response (folder, resp, idle_resp); 
    34323461                        } 
    3433  
    3434                         if (type == CAMEL_IMAP_RESPONSE_ERROR) 
    3435                                 *had_err = TRUE; 
    3436  
    3437                         if (resp) 
    3438                                 g_free (resp); 
    3439                 } 
    3440         } else if (done) { 
     3462                        g_free (resp); resp=NULL; 
     3463                } 
     3464 
     3465                if (type == CAMEL_IMAP_RESPONSE_ERROR) 
     3466                        *had_err = TRUE; 
     3467 
     3468                if (resp) 
     3469                        g_free (resp); 
     3470 
     3471        } else { 
    34413472                g_mutex_lock (store->stream_lock); 
    34423473                if (!camel_disco_store_check_online ((CamelDiscoStore*)store, &ex)) 
     
    34613492 
    34623493        CAMEL_SERVICE_REC_UNLOCK (store, connect_lock); 
    3463   } else if (done) { 
    3464         /* Little bit strange situation, let's warn */ 
    3465         g_warning ("Locking bug in tinymail in %s:%d", __FILE__, __LINE__); 
    3466  
    3467         g_mutex_lock (store->stream_lock); 
    3468         if (!camel_disco_store_check_online ((CamelDiscoStore*)store, &ex)) 
    3469                 { g_mutex_unlock (store->stream_lock); return NULL; } 
    3470         if (store->istream == NULL || ((CamelObject *)store->istream)->ref_count <= 0) 
    3471                 { g_mutex_unlock (store->stream_lock); return NULL; } 
    3472         if (store->ostream == NULL || ((CamelObject *)store->istream)->ref_count <= 0) 
    3473                 { g_mutex_unlock (store->stream_lock); return NULL; } 
    3474         if (store->ostream && CAMEL_IS_STREAM (store->ostream)) 
    3475         nwritten = camel_stream_printf (store->ostream, "DONE\r\n"); 
    3476         g_mutex_unlock (store->stream_lock); 
    3477         if (nwritten != -1)  
    3478         { 
    3479                 resp = NULL; 
    3480                 while ((type = camel_imap_command_response_idle (store, &resp, &ex)) == CAMEL_IMAP_RESPONSE_UNTAGGED)  
    3481                         { g_free (resp); resp=NULL; } 
    3482                 if (resp) 
    3483                         g_free (resp); 
    3484         } 
    3485   } 
     3494  }  
    34863495 
    34873496  return idle_resp; 
     
    35153524        if (store->capabilities & IMAP_CAPABILITY_IDLE) 
    35163525        { 
    3517  
     3526                gboolean hadlock = FALSE; 
    35183527                g_free (store->idle_prefix); 
    35193528                store->idle_prefix = NULL; 
     
    35223531                        g_source_remove (store->idle_signal); 
    35233532 
    3524                 idle_resp = idle_deal_with_stuff (folder, store, TRUE, &had_err); 
     3533                idle_resp = idle_deal_with_stuff (folder, store, &had_err, TRUE, &hadlock); 
    35253534 
    35263535                /* Outside of the lock of course */ 
    35273536                if (idle_resp && !had_err) 
    3528                         process_idle_response (idle_resp, FALSE); 
     3537                        process_idle_response (idle_resp); 
     3538 
     3539                /* idle_real_start (store); */ 
    35293540 
    35303541                if (idle_resp)  
     
    35413552        CamelImapFolder *imap_folder; 
    35423553        CamelImapStore *store; 
    3543         gboolean had_err = FALSE
     3554        gboolean had_err = FALSE, hadlock = FALSE
    35443555        CamelException ex = CAMEL_EXCEPTION_INITIALISER; 
    35453556 
     
    35723583        if (store->idle_prefix != NULL) 
    35733584        { 
    3574                 IdleResponse *idle_resp = idle_deal_with_stuff (folder, store, FALSE, &had_err); 
     3585                IdleResponse *idle_resp = idle_deal_with_stuff (folder, store, &had_err, FALSE, &hadlock); 
    35753586 
    35763587                if (idle_resp && !had_err) 
    3577                         process_idle_response (idle_resp, TRUE); 
     3588                        process_idle_response (idle_resp); 
     3589 
     3590                if (hadlock) 
     3591                        idle_real_start (store); 
     3592 
    35783593                if (idle_resp) 
    35793594                        idle_response_free (idle_resp); 
     
    35963611} 
    35973612 
    3598 static void  
    3599 imap_set_push_email (CamelFolder *folder, gboolean setting) 
    3600 { 
    3601         CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder); 
    3602  
    3603         if (imap_folder->do_push_email && !setting) { 
    3604                 imap_folder->do_push_email = setting; 
    3605                 camel_imap_folder_stop_idle (folder); 
    3606         } 
    3607  
    3608         if (!imap_folder->do_push_email && setting) { 
    3609                 imap_folder->do_push_email = setting; 
    3610                 camel_imap_folder_start_idle (folder); 
    3611         } 
    3612  
    3613         return; 
    3614 } 
    36153613 
    36163614void 
     
    36423640                        folder->folder_flags |= CAMEL_FOLDER_HAS_PUSHEMAIL_CAPABILITY; 
    36433641 
    3644                         g_mutex_lock (store->stream_lock); 
    3645                         store->idle_prefix = g_strdup_printf ("%c%.5u",  
    3646                                 store->tag_prefix, store->command++); 
    3647                         camel_stream_printf (store->ostream, "%s IDLE\r\n", 
    3648                                 store->idle_prefix); 
    3649                         g_mutex_unlock (store->stream_lock); 
     3642                        idle_real_start (store); 
    36503643 
    36513644                        store->idle_signal = g_timeout_add (5 * 1000, idle_timeout_checker, folder); 
     
    36583651} 
    36593652 
     3653 
     3654static void  
     3655imap_set_push_email (CamelFolder *folder, gboolean setting) 
     3656{ 
     3657        CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder); 
     3658 
     3659        if (imap_folder->do_push_email && !setting) { 
     3660                imap_folder->do_push_email = setting; 
     3661                camel_imap_folder_stop_idle (folder); 
     3662        } 
     3663 
     3664        if (!imap_folder->do_push_email && setting) { 
     3665                imap_folder->do_push_email = setting; 
     3666                camel_imap_folder_start_idle (folder); 
     3667        } 
     3668 
     3669        return; 
     3670} 
    36603671/* Called with the store's connect_lock locked */ 
    36613672void 
     
    36973708 
    36983709        len = camel_folder_summary_count (folder->summary); 
    3699         if (exists > len) 
     3710 
     3711        if (exists > len) { 
     3712                camel_imap_folder_stop_idle (folder); 
    37003713                imap_update_summary (folder, exists, changes, ex); 
     3714                /* camel_imap_folder_start_idle (folder); will happen later? */ 
     3715        } 
    37013716 
    37023717        if (camel_folder_change_info_changed (changes)) 
     
    37163731        CamelMessageInfo *info; 
    37173732        int len; 
    3718          
     3733 
     3734        /* printf ("FOR IDLE: %d vs %d\n", exists, camel_folder_summary_count (folder->summary)); */ 
     3735 
    37193736        changes = camel_folder_change_info_new (); 
    37203737        if (expunged) { 
     
    38003817        CamelImapStore *store = CAMEL_IMAP_STORE (folder->parent_store); 
    38013818        CamelStream *stream = NULL; 
    3802         gboolean connected = FALSE
     3819        gboolean connected = FALSE, idle_rt = FALSE
    38033820        CamelException tex = CAMEL_EXCEPTION_INITIALISER; 
    38043821        ssize_t nread = 0;  
     
    39003917                        nread = 1; 
    39013918 
     3919                        /* Stops idle */ 
    39023920                        camel_imap_command_start (store, folder, ex, 
    39033921                                "UID FETCH %s BINARY.PEEK[%s]", uid, section_text); 
     
    39813999                        g_mutex_unlock (store->stream_lock); 
    39824000                        CAMEL_SERVICE_REC_UNLOCK (store, connect_lock); 
    3983                         camel_imap_store_start_idle (store); 
     4001                        /* Starts idle */ 
     4002                        camel_imap_folder_start_idle ((CamelFolder *) imap_folder); 
     4003                        idle_rt = TRUE; 
    39844004 
    39854005                        if (err) 
     
    39974017                        nread = 0; 
    39984018 
     4019                        /* Stops idle */ 
    39994020                        if (store->server_level < IMAP_LEVEL_IMAP4REV1 && !*section_text) 
    40004021                                camel_imap_command_start (store, folder, ex, 
     
    40784099                        g_mutex_unlock (store->stream_lock); 
    40794100                        CAMEL_SERVICE_REC_UNLOCK (store, connect_lock); 
    4080                         camel_imap_store_start_idle (store); 
     4101                        /* Starts idle */ 
     4102                        camel_imap_folder_start_idle ((CamelFolder *) imap_folder); 
     4103                        idle_rt = TRUE; 
    40814104 
    40824105                        if (nread <= 0)  
     
    41174140                        nread = 0; 
    41184141 
     4142                        /* Stops idle */ 
    41194143                        camel_imap_command_start (store, folder, ex, 
    41204144                                "UID FETCH %s BODY.PEEK[%s]", uid, infos[t]); 
     
    42234247                        g_mutex_unlock (store->stream_lock); 
    42244248                        CAMEL_SERVICE_REC_UNLOCK (store, connect_lock); 
     4249                        /* Starts idle */ 
    42254250                        camel_imap_store_start_idle (store); 
     4251                        idle_rt = TRUE; 
    42264252 
    42274253                        if (nread <= 0)  
     
    42504276 
    42514277errorhander: 
     4278 
     4279        if (!idle_rt) 
     4280                camel_imap_folder_start_idle ((CamelFolder *) imap_folder); 
    42524281 
    42534282        CAMEL_IMAP_FOLDER_REC_UNLOCK (imap_folder, cache_lock); 
  • trunk/libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-store.c

    r1697 r1740  
    263263        CamelImapStore *imap_store = CAMEL_IMAP_STORE (object); 
    264264 
     265        imap_store->dontdistridlehack = FALSE; 
    265266        imap_store->idle_signal = 0; 
    266267        imap_store->idle_prefix = NULL; 
  • trunk/libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-store.h

    r1549 r1740  
    143143        gchar *idle_prefix; 
    144144        guint idle_signal; 
     145        gboolean dontdistridlehack; 
    145146}; 
    146147 
  • trunk/libtinymailui-gtk/tny-gtk-header-list-model.c

    r1710 r1740  
    226226tny_gtk_header_list_model_get_value (GtkTreeModel *self, GtkTreeIter *iter, gint column, GValue *value) 
    227227{ 
    228         TnyHeader *header = NULL; 
    229228        TnyGtkHeaderListModel *list_model = TNY_GTK_HEADER_LIST_MODEL (self); 
    230229        const gchar *str; 
     
    248247        } 
    249248 
    250         header = list_model->items->pdata[i]; 
    251  
    252         if (((GObject*)header)->ref_count <= 0) 
    253         { 
    254                 g_warning ("GtkTreeModel in invalid state\n"); 
    255                 g_static_rec_mutex_unlock (list_model->iterator_lock); 
    256                 g_mutex_unlock (list_model->folder_lock); 
    257                 return; 
    258         } 
    259  
    260249        switch (column)  
    261250        { 
    262251                case TNY_GTK_HEADER_LIST_MODEL_CC_COLUMN: 
    263252                        g_value_init (value, G_TYPE_STRING); 
    264                         str = tny_header_get_cc (header); 
     253                        str = tny_header_get_cc ((TnyHeader*) list_model->items->pdata[i]); 
    265254                        if (str) 
    266255                                g_value_set_string (value, str); 
     
    268257                case TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_COLUMN: 
    269258                        g_value_init (value, G_TYPE_STRING); 
    270                         rdate = _get_readable_date (tny_header_get_date_sent (header)); 
     259                        rdate = _get_readable_date (tny_header_get_date_sent ((TnyHeader*) list_model->items->pdata[i])); 
    271260                        if (rdate) 
    272261                                g_value_set_string (value, rdate); 
     
    276265                case TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_COLUMN: 
    277266                        g_value_init (value, G_TYPE_STRING); 
    278                         rdate = _get_readable_date (tny_header_get_date_received (header)); 
     267                        rdate = _get_readable_date (tny_header_get_date_received ((TnyHeader*) list_model->items->pdata[i])); 
    279268                        if (rdate) 
    280269                                g_value_set_string (value, rdate); 
     
    285274                        g_value_init (value, G_TYPE_INT); 
    286275                        g_value_set_int (value,  
    287                                             tny_header_get_date_sent (header)); 
     276                                            tny_header_get_date_sent ((TnyHeader*) list_model->items->pdata[i])); 
    288277                        break; 
    289278                case TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN: 
    290279                        g_value_init (value, G_TYPE_INT); 
    291280                        g_value_set_int (value,  
    292                                          tny_header_get_date_received (header)); 
     281                                         tny_header_get_date_received ((TnyHeader*) list_model->items->pdata[i])); 
    293282                        break; 
    294283 
    295284                case TNY_GTK_HEADER_LIST_MODEL_MESSAGE_SIZE_COLUMN: 
    296285                        g_value_init (value, G_TYPE_INT); 
    297                         g_value_set_int (value, tny_header_get_message_size(header)); 
     286                        g_value_set_int (value, tny_header_get_message_size((TnyHeader*) list_model->items->pdata[i])); 
    298287                        break;                   
    299288                case TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN: 
    300289                        g_value_init (value, G_TYPE_OBJECT); 
    301                         g_value_set_object (value, header); 
     290                        g_value_set_object (value, (TnyHeader*) list_model->items->pdata[i]); 
    302291                        break; 
    303292                case TNY_GTK_HEADER_LIST_MODEL_TO_COLUMN: 
    304293                        g_value_init (value, G_TYPE_STRING); 
    305                         str = tny_header_get_to (header); 
     294                        str = tny_header_get_to ((TnyHeader*) list_model->items->pdata[i]); 
    306295                        if (str) 
    307296                                g_value_set_string (value, str); 
     
    309298                case TNY_GTK_HEADER_LIST_MODEL_SUBJECT_COLUMN: 
    310299                        g_value_init (value, G_TYPE_STRING); 
    311                         str = tny_header_get_subject (header); 
     300                        str = tny_header_get_subject ((TnyHeader*) list_model->items->pdata[i]); 
    312301                        if (str) 
    313302                                g_value_set_string (value, str); 
     
    315304                case TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN: 
    316305                        g_value_init (value, G_TYPE_STRING); 
    317                         str = tny_header_get_from (header); 
     306                        str = tny_header_get_from ((TnyHeader*) list_model->items->pdata[i]); 
    318307                        if (str) 
    319308                                g_value_set_string (value, str); 
     
    321310                case TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN: 
    322311                        g_value_init (value, G_TYPE_INT); 
    323                         g_value_set_int (value, tny_header_get_flags (header)); 
     312                        g_value_set_int (value, tny_header_get_flags ((TnyHeader*) list_model->items->pdata[i])); 
    324313                        break; 
    325314                default: