Changeset 2076

Show
Ignore:
Timestamp:
06/05/07 16:29:19
Author:
pvanhoof
Message:

Deleting the cache

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/ChangeLog

    r2075 r2076  
    33        * Bugfix for LOGINDISABLED on IMAP 
    44        * Bugfix when connecting (connection status problem) 
     5        * Added the tny_store_account_delete_cache API 
     6 
     7        * This was a major API change 
    58 
    692007-06-03  Johannes Schmid  <johannes.schmid@openismus.com> 
  • trunk/libtinymail-camel/camel-lite/camel/camel-store.c

    r1943 r2076  
    7777 
    7878static void noop (CamelStore *store, CamelException *ex); 
     79static void delete_cache (CamelStore *store); 
    7980 
    8081static void construct (CamelService *service, CamelSession *session, 
     
    113114        camel_store_class->noop = noop; 
    114115        camel_store_class->get_recent_messages = get_recent_messages; 
     116        camel_store_class->delete_cache = delete_cache; 
    115117 
    116118        /* virtual method overload */ 
     
    181183} 
    182184 
     185 
     186static void  
     187delete_cache (CamelStore *store) 
     188{ 
     189} 
     190 
     191void  
     192camel_store_delete_cache (CamelStore *store) 
     193{ 
     194        CS_CLASS (store)->delete_cache (store); 
     195} 
    183196 
    184197GPtrArray*  
  • trunk/libtinymail-camel/camel-lite/camel/camel-store.h

    r1943 r2076  
    191191                                                     const char *folder_name,  
    192192                                                     int *unseen, int *messages); 
     193        void             (*delete_cache)              (CamelStore *store); 
    193194 
    194195} CamelStoreClass; 
     
    266267                                                       int *unseen, int *messages); 
    267268 
     269void             camel_store_delete_cache            (CamelStore *store); 
     270 
    268271 
    269272typedef struct _CamelISubscribe CamelISubscribe; 
  • trunk/libtinymail-camel/camel-lite/camel/camel-string-utils.c

    r1193 r2076  
    3030 
    3131#include "camel-string-utils.h" 
     32 
     33#include <sys/types.h> 
     34#include <sys/stat.h> 
     35#include <unistd.h> 
     36#include <stdio.h> 
     37#include <dirent.h> 
     38 
     39 
     40static int 
     41isdir (char *name) 
     42{ 
     43        struct stat st; 
     44        if (stat (name, &st)) 
     45                return 0; 
     46        return S_ISDIR (st.st_mode); 
     47} 
     48 
     49static char *ignored_names[] = { ".", "..", NULL }; 
     50static int ignorent (char *name) 
     51{ 
     52        char **p; 
     53        for (p = ignored_names; *p; p++) 
     54                if (strcmp (name, *p) == 0) 
     55                        return 1; 
     56        return 0; 
     57} 
     58 
     59void camel_du (char *name, int *my_size) 
     60{ 
     61        DIR *dir; 
     62        struct dirent *ent; 
     63 
     64        chdir (name); 
     65        dir = opendir (name); 
     66 
     67        if (!dir) 
     68                return; 
     69 
     70        while ((ent = readdir (dir))) 
     71        { 
     72                if (!ignorent (ent->d_name)) 
     73                { 
     74                        char *p = g_strdup_printf ("%s/%s", name, ent->d_name); 
     75                        if (isdir (p)) 
     76                                camel_du (p, my_size); 
     77                        else  
     78                        { 
     79                                struct stat st; 
     80                                if (stat (p, &st) == 0) 
     81                                        *my_size += st.st_size; 
     82                        } 
     83                        g_free (p); 
     84                } 
     85        } 
     86 
     87        closedir (dir); 
     88} 
     89 
     90static char *ignored_dnames[] = { ".", "..", NULL }; 
     91static int ignorentd (char *name) 
     92{ 
     93        char **p; 
     94        for (p = ignored_dnames; *p; p++) 
     95                if (strcmp (name, *p) == 0) 
     96                        return 1; 
     97        return 0; 
     98} 
     99 
     100void  
     101camel_rm (char *name) 
     102{ 
     103        DIR *dir; 
     104        struct dirent *ent; 
     105 
     106        chdir (name); 
     107        dir = opendir (name); 
     108 
     109        if (!dir) 
     110                return; 
     111 
     112        while ((ent = readdir (dir))) 
     113        { 
     114                if (!ignorentd (ent->d_name)) 
     115                { 
     116                        char *p = g_strdup_printf ("%s/%s", name, ent->d_name); 
     117                        if (isdir (p)) 
     118                                camel_rm (p); 
     119                        else  
     120                                remove (p); 
     121                        g_free (p); 
     122                } 
     123        } 
     124 
     125        closedir (dir); 
     126 
     127        remove (name); 
     128} 
    32129 
    33130int 
  • trunk/libtinymail-camel/camel-lite/camel/camel-string-utils.h

    r1943 r2076  
    2929G_BEGIN_DECLS 
    3030 
     31void camel_du (char *name, int *my_size); 
     32void camel_rm (char *name); 
     33 
    3134int   camel_strcase_equal (gconstpointer a, gconstpointer b); 
    3235guint camel_strcase_hash  (gconstpointer v); 
  • trunk/libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-store.c

    r2075 r2076  
    4646#include "camel/camel-folder.h" 
    4747#include "camel/camel-net-utils.h" 
     48#include "camel/camel-string-utils.h" 
    4849#include "camel/camel-private.h" 
    4950#include "camel/camel-sasl.h" 
     
    140141static GPtrArray* imap_get_recent_messages (CamelStore *store, const char *folder_name, int *unseen, int *messages); 
    141142 
    142 static void let_idle_die (CamelImapStore *imap_store) 
     143 
     144static void  
     145imap_delete_cache  (CamelStore *store) 
     146
     147        CamelImapStore *imap_store = (CamelImapStore *) store; 
     148        gchar *folder_dir = imap_store->storage_path; 
     149        camel_rm (folder_dir); 
     150
     151 
     152static void  
     153let_idle_die (CamelImapStore *imap_store) 
    143154{ 
    144155        if (imap_store->idle_signal > 0)  
     
    209220        camel_service_class->query_auth_types = query_auth_types; 
    210221        camel_service_class->get_name = imap_get_name; 
    211          
     222 
     223        camel_store_class->delete_cache = imap_delete_cache; 
    212224        camel_store_class->hash_folder_name = hash_folder_name; 
    213225        camel_store_class->compare_folder_name = compare_folder_name; 
     
    31673179 
    31683180 
    3169 static int 
    3170 isdir (char *name) 
    3171 
    3172         struct stat st; 
    3173         if (stat (name, &st)) 
    3174                 return 0; 
    3175         return S_ISDIR (st.st_mode); 
    3176 
    3177  
    3178 static char *ignored_names[] = { ".", "..", "subfolders", NULL }; 
    3179  
    3180 int 
    3181 ignorent (char *name) 
    3182 
    3183         char **p; 
    3184         for (p = ignored_names; *p; p++) 
    3185                 if (strcmp (name, *p) == 0) 
    3186                         return 1; 
    3187         return 0; 
    3188 
    3189  
    3190  
    3191 void 
    3192 my_du (char *name, int *my_size) 
    3193 
    3194         DIR *dir; 
    3195         struct dirent *ent; 
    3196  
    3197         chdir (name); 
    3198         dir = opendir (name); 
    3199  
    3200         if (!dir) 
    3201                 return; 
    3202  
    3203         while ((ent = readdir (dir))) 
    3204         { 
    3205                 if (!ignorent (ent->d_name)) 
    3206                 { 
    3207                         char *p = g_strdup_printf ("%s/%s", name, ent->d_name); 
    3208                         if (isdir (p)) 
    3209                                 my_du (p, my_size); 
    3210                         else  
    3211                         { 
    3212                                 struct stat st; 
    3213                                 if (stat (p, &st) == 0) 
    3214                                         *my_size += st.st_size; 
    3215                         } 
    3216                         g_free (p); 
    3217                 } 
    3218         } 
    3219  
    3220         closedir (dir); 
    3221 
     3181 
    32223182 
    32233183static void 
     
    32313191 
    32323192        g_free(storage_path); 
    3233         my_du (folder_dir, &msize); 
     3193        camel_du (folder_dir, &msize); 
    32343194 
    32353195        folder = camel_object_bag_peek(store->folders, fi->full_name); 
  • trunk/libtinymail-camel/camel-lite/camel/providers/nntp/camel-nntp-store.c

    r1943 r2076  
    4747#include "camel/camel-tcp-stream-ssl.h" 
    4848#include "camel/camel-url.h" 
     49#include "camel/camel-string-utils.h" 
    4950 
    5051#include "camel-nntp-summary.h" 
     
    7778                            CamelException *ex); 
    7879 
     80 
     81static void  
     82nntp_delete_cache  (CamelStore *store) 
     83{ 
     84        CamelNNTPStore *nntp_store = (CamelNNTPStore *) store; 
     85        gchar *folder_dir = nntp_store->storage_path; 
     86        camel_rm (folder_dir); 
     87} 
    7988 
    8089static gboolean 
     
    10151024        camel_service_class->query_auth_types = nntp_store_query_auth_types; 
    10161025        camel_service_class->get_name = nntp_store_get_name; 
    1017          
     1026 
     1027        camel_store_class->delete_cache = nntp_delete_cache; 
    10181028        camel_disco_store_class->can_work_offline = nntp_can_work_offline; 
    10191029        camel_disco_store_class->connect_online = nntp_connect_online; 
  • trunk/libtinymail-camel/camel-lite/camel/providers/pop3/camel-pop3-store.c

    r2069 r2076  
    6363#include "camel-tcp-stream.h" 
    6464#include "camel-url.h" 
     65#include "camel/camel-string-utils.h" 
    6566 
    6667#ifdef HAVE_SSL 
     
    9091static CamelFolder *get_trash  (CamelStore *store, CamelException *ex); 
    9192 
     93 
     94 
     95static void  
     96pop3_delete_cache  (CamelStore *store) 
     97{ 
     98        CamelPOP3Store *pop3_store = (CamelPOP3Store *) store; 
     99        gchar *folder_dir = pop3_store->storage_path; 
     100        camel_rm (folder_dir); 
     101} 
     102 
     103 
    92104static gboolean 
    93105pop3_can_work_offline (CamelDiscoStore *disco_store) 
     
    145157} 
    146158 
    147  
    148  
    149 static int 
    150 isdir (char *name) 
    151 { 
    152         struct stat st; 
    153         if (stat (name, &st)) 
    154                 return 0; 
    155         return S_ISDIR (st.st_mode); 
    156 } 
    157  
    158 static char *ignored_names[] = { ".", "..", NULL }; 
    159  
    160 int 
    161 ignorent (char *name) 
    162 { 
    163         char **p; 
    164         for (p = ignored_names; *p; p++) 
    165                 if (strcmp (name, *p) == 0) 
    166                         return 1; 
    167         return 0; 
    168 } 
    169  
    170  
    171 void 
    172 my_du (char *name, int *my_size) 
    173 { 
    174         DIR *dir; 
    175         struct dirent *ent; 
    176  
    177         chdir (name); 
    178         dir = opendir (name); 
    179  
    180         if (!dir) 
    181                 return; 
    182  
    183         while ((ent = readdir (dir))) 
    184         { 
    185                 if (!ignorent (ent->d_name)) 
    186                 { 
    187                         char *p = g_strdup_printf ("%s/%s", name, ent->d_name); 
    188                         if (isdir (p)) 
    189                                 my_du (p, my_size); 
    190                         else  
    191                         { 
    192                                 struct stat st; 
    193                                 if (stat (p, &st) == 0) 
    194                                         *my_size += st.st_size; 
    195                         } 
    196                         g_free (p); 
    197                 } 
    198         } 
    199  
    200         closedir (dir); 
    201 } 
    202159 
    203160static CamelFolderInfo * 
     
    217174        fi->total = 0; 
    218175 
    219         my_du (folder_dir, &msize); 
     176        camel_du (folder_dir, &msize); 
    220177 
    221178        spath = g_strdup_printf ("%s/summary.mmap", folder_dir); 
     
    861818        camel_store_class->get_trash = get_trash; 
    862819 
     820        camel_store_class->delete_cache = pop3_delete_cache; 
     821 
    863822        camel_disco_store_class->can_work_offline = pop3_can_work_offline; 
    864823        camel_disco_store_class->connect_online = pop3_connect_online; 
  • trunk/libtinymail-camel/tny-camel-store-account.c

    r2027 r2076  
    9393 
    9494static void  
     95tny_camel_store_account_delete_cache (TnyStoreAccount *self) 
     96{ 
     97        TNY_CAMEL_STORE_ACCOUNT_GET_CLASS (self)->delete_cache_func (self); 
     98} 
     99 
     100static void  
     101tny_camel_store_account_delete_cache_default (TnyStoreAccount *self) 
     102{ 
     103        TnyCamelAccountPriv *apriv = TNY_CAMEL_ACCOUNT_GET_PRIVATE (self); 
     104        CamelStore *store = CAMEL_STORE (apriv->service); 
     105 
     106        camel_store_delete_cache (store); 
     107} 
     108 
     109static void  
    95110tny_camel_store_account_prepare (TnyCamelAccount *self) 
    96111{ 
     
    11381153        klass->unsubscribe_func = tny_camel_store_account_unsubscribe; 
    11391154        klass->find_folder_func = tny_camel_store_account_find_folder; 
     1155        klass->delete_cache_func = tny_camel_store_account_delete_cache; 
    11401156 
    11411157        return; 
     
    11631179        class->remove_observer_func = tny_camel_store_account_remove_observer_default; 
    11641180        class->find_folder_func = tny_camel_store_account_find_folder_default; 
     1181        class->delete_cache_func = tny_camel_store_account_delete_cache_default; 
    11651182 
    11661183        /* Protected default implementation */ 
  • trunk/libtinymail-camel/tny-camel-store-account.h

    r1879 r2076  
    5858 
    5959        TnyFolder * (*find_folder_func) (TnyStoreAccount *self, const gchar *url_string, GError **err); 
     60        void (*delete_cache_func) (TnyStoreAccount *self); 
    6061 
    6162        /* protected virtual methods*/ 
  • trunk/libtinymail/tny-store-account.c

    r1866 r2076  
    2929 
    3030guint tny_store_account_signals [TNY_STORE_ACCOUNT_LAST_SIGNAL]; 
     31 
     32 
     33/** 
     34 * tny_store_account_delete_cache: 
     35 * @self: a #TnyStoreAccount object 
     36 * 
     37 * Delete the cache of a store account 
     38 **/ 
     39void  
     40tny_store_account_delete_cache (TnyStoreAccount *self) 
     41{ 
     42#ifdef DBC /* require */ 
     43        g_assert (TNY_IS_STORE_ACCOUNT (self)); 
     44        g_assert (TNY_STORE_ACCOUNT_GET_IFACE (self)->delete_cache_func != NULL); 
     45#endif 
     46 
     47        TNY_STORE_ACCOUNT_GET_IFACE (self)->delete_cache_func (self); 
     48 
     49        return; 
     50} 
     51 
    3152 
    3253/** 
  • trunk/libtinymail/tny-store-account.h

    r1737 r2076  
    6060        void (*unsubscribe_func) (TnyStoreAccount *self, TnyFolder *folder); 
    6161        TnyFolder * (*find_folder_func) (TnyStoreAccount *self, const gchar *url_string, GError **err); 
     62        void (*delete_cache_func) (TnyStoreAccount *self); 
    6263}; 
    6364 
     
    6768void tny_store_account_unsubscribe (TnyStoreAccount *self, TnyFolder *folder); 
    6869TnyFolder* tny_store_account_find_folder (TnyStoreAccount *self, const gchar *url_string, GError **err); 
    69  
     70void tny_store_account_delete_cache (TnyStoreAccount *self); 
    7071 
    7172G_END_DECLS 
  • trunk/tests/c-demo/tny-demoui-summary-view.c

    r2019 r2076  
    998998} 
    999999 
     1000 
     1001static void  
     1002on_uncache_account_activate (GtkMenuItem *mitem, gpointer user_data) 
     1003{ 
     1004        TnyDemouiSummaryView *self = user_data; 
     1005        TnyDemouiSummaryViewPriv *priv = TNY_DEMOUI_SUMMARY_VIEW_GET_PRIVATE (self); 
     1006        GtkTreeIter iter; 
     1007        GtkTreeModel *model; 
     1008 
     1009        if (gtk_tree_selection_get_selected (priv->mailbox_select, &model, &iter)) 
     1010        { 
     1011                gint type; 
     1012 
     1013                gtk_tree_model_get (model, &iter,  
     1014                        TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN,  
     1015                        &type, -1); 
     1016 
     1017                if (type != TNY_FOLDER_TYPE_ROOT)  
     1018                {  
     1019                        TnyFolder *folder; 
     1020                        TnyStoreAccount *acc; 
     1021                        GtkWidget *dialog, *label; 
     1022                        gint result; 
     1023                        gchar *str = NULL; 
     1024 
     1025                        gtk_tree_model_get (model, &iter,  
     1026                                TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,  
     1027                                &folder, -1); 
     1028 
     1029                        dialog = gtk_dialog_new_with_buttons (_("Uncache an account"), 
     1030                                  GTK_WINDOW (gtk_widget_get_parent (GTK_WIDGET (self))), 
     1031                                  GTK_DIALOG_MODAL, 
     1032                                  GTK_STOCK_OK, 
     1033                                  GTK_RESPONSE_ACCEPT, 
     1034                                  GTK_STOCK_CANCEL, 
     1035                                  GTK_RESPONSE_REJECT, 
     1036                                  NULL); 
     1037 
     1038                        acc = TNY_STORE_ACCOUNT (tny_folder_get_account (folder)); 
     1039 
     1040                        str = g_strdup_printf (_("Are you sure you want to uncache the account %s?"), 
     1041                                tny_account_get_name (TNY_ACCOUNT (acc))); 
     1042                        label = gtk_label_new (str); 
     1043                        g_free (str); 
     1044 
     1045                        gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), label); 
     1046                        gtk_widget_show (label); 
     1047 
     1048                        result = gtk_dialog_run (GTK_DIALOG (dialog)); 
     1049 
     1050                        switch (result) 
     1051                        { 
     1052                                case GTK_RESPONSE_ACCEPT:  
     1053                                        tny_store_account_delete_cache (acc); 
     1054                                break; 
     1055 
     1056                                default: 
     1057                                break; 
     1058                        } 
     1059 
     1060                        g_object_unref (acc); 
     1061 
     1062                        if (dialog) 
     1063                                gtk_widget_destroy (dialog); 
     1064                        g_object_unref (folder); 
     1065                } 
     1066 
     1067        } 
     1068} 
     1069 
     1070 
    10001071static void  
    10011072on_create_folder_activate (GtkMenuItem *mitem, gpointer user_data) 
     
    11571228        int button, event_time; 
    11581229        GtkSelectionMode mode; 
    1159         GtkWidget *mrename, *mdelete, *mcreate, *mmerge
     1230        GtkWidget *mrename, *mdelete, *mcreate, *mmerge, *muncache
    11601231#ifdef ASYNCWORKER 
    11611232        GtkWidget *fdown; 
     
    11671238        mcreate = gtk_menu_item_new_with_label (_("Create folder")); 
    11681239        mdelete = gtk_menu_item_new_with_label (_("Delete folder")); 
     1240        muncache = gtk_menu_item_new_with_label (_("Uncache account of this folder")); 
    11691241 
    11701242#ifdef ASYNCWORKER 
     
    11791251                mmerge = gtk_menu_item_new_with_label (_("Select one folder mode")); 
    11801252 
     1253        g_signal_connect (G_OBJECT (muncache), "activate", 
     1254                G_CALLBACK (on_uncache_account_activate), user_data); 
    11811255        g_signal_connect (G_OBJECT (mrename), "activate", 
    11821256                G_CALLBACK (on_rename_folder_activate), user_data); 
     
    11951269        gtk_menu_prepend (menu, mcreate); 
    11961270        gtk_menu_prepend (menu, mdelete); 
     1271        gtk_menu_prepend (menu, muncache); 
    11971272        gtk_menu_prepend (menu, mmerge); 
    11981273#ifdef ASYNCWORKER 
     
    12041279        gtk_widget_show (mcreate); 
    12051280        gtk_widget_show (mdelete); 
     1281        gtk_widget_show (muncache); 
    12061282        gtk_widget_show (mmerge); 
    12071283