Changeset 1956

Show
Ignore:
Timestamp:
05/15/07 19:39:36
Author:
pvanhoof
Message:

A new implementation for tny_folder_copy_async

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/ChangeLog

    r1955 r1956  
    22 
    33        * A new implementation for tny_folder_copy in libtinymail-camel 
     4        * A new implementation for tny_folder_copy_async in libtinymail-camel 
     5        * Changed the TnyCopyFolderCallback function description 
     6 
     7        * This was a major API change 
    48 
    592007-05-14  Philip Van Hoof  <pvanhoof@gnome.org> 
  • trunk/libtinymail-camel/tny-camel-folder.c

    r1955 r1956  
    17841784} 
    17851785 
    1786 static TnyFolder
    1787 tny_camel_folder_copy_default (TnyFolder *self, TnyFolderStore *into, const gchar *new_name, gboolean del, GError **err
     1786static CpyRecRet
     1787tny_camel_folder_copy_shared (TnyFolder *self, TnyFolderStore *into, const gchar *new_name, gboolean del, GError **err, GList *rems, GList *adds
    17881788{ 
    17891789        TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (self); 
     
    17931793        GError *nerr = NULL; 
    17941794 
    1795         GList *rems=NULL, *adds=NULL; 
    1796  
    1797         if (!_tny_session_check_operation (TNY_FOLDER_PRIV_GET_SESSION(priv), err,  
    1798                         TNY_FOLDER_ERROR, TNY_FOLDER_ERROR_COPY)) 
    1799                 return NULL; 
     1795        CpyRecRet *retc = g_slice_new0 (CpyRecRet); 
    18001796 
    18011797        g_static_rec_mutex_lock (priv->folder_lock); 
     
    18601856        { 
    18611857                CpyRecRet *cpyr; 
    1862  
    18631858                tny_debug ("tny_folder_copy: recurse_copy\n"); 
    18641859                cpyr = recurse_copy (self, into, new_name, del, &nerr, adds, rems); 
     
    18691864        } 
    18701865 
     1866        retc->created = retval; 
     1867        retc->adds = adds; 
     1868        retc->rems = rems; 
     1869 
     1870        g_static_rec_mutex_unlock (priv->folder_lock); 
     1871 
     1872        return retc; 
     1873} 
     1874 
     1875static TnyFolder* 
     1876tny_camel_folder_copy_default (TnyFolder *self, TnyFolderStore *into, const gchar *new_name, gboolean del, GError **err) 
     1877{ 
     1878        TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (self); 
     1879        GList *rems=NULL, *adds=NULL; 
     1880        TnyFolder *retval = NULL; 
     1881        GError *nerr = NULL; 
     1882        CpyRecRet *cpyr; 
     1883 
     1884        if (!_tny_session_check_operation (TNY_FOLDER_PRIV_GET_SESSION(priv), err,  
     1885                        TNY_FOLDER_ERROR, TNY_FOLDER_ERROR_COPY)) 
     1886                return NULL; 
     1887 
     1888        cpyr = tny_camel_folder_copy_shared (self, into, new_name, del, &nerr, rems, adds); 
     1889 
     1890        retval = cpyr->created; 
     1891        rems = cpyr->rems; 
     1892        adds = cpyr->adds; 
     1893 
     1894        g_slice_free (CpyRecRet, cpyr); 
     1895 
    18711896        if (nerr != NULL) 
     1897        { 
    18721898                g_propagate_error (err, nerr); 
    1873         else 
     1899                g_error_free (nerr); 
     1900        } else 
    18741901                notify_folder_observers_about_copy (adds, rems, del); 
    18751902 
    1876         g_static_rec_mutex_unlock (priv->folder_lock); 
    1877  
    18781903        _tny_session_stop_operation (TNY_FOLDER_PRIV_GET_SESSION (priv)); 
    18791904 
     
    18821907 
    18831908 
    1884  
    1885  
    1886  
    18871909typedef struct  
    18881910{ 
    18891911        TnyFolder *self; 
    1890         TnyFolderStore *from; 
    18911912        TnyFolderStore *into; 
    18921913        gchar *new_name; 
    18931914        gboolean delete_originals; 
    18941915        GError *err; 
     1916 
    18951917        gpointer user_data; 
    18961918        guint depth; 
     
    19011923        TnyIdleStopper *stopper; 
    19021924        gboolean cancelled; 
     1925        GList *rems, *adds; 
    19031926} CopyFolderInfo; 
    19041927 
    19051928 
    1906 static void  
    1907 inform_observers_about_folder_copy (TnyFolder *self, TnyFolderStore *from, TnyFolderStore *to, gboolean del_orig, const gchar *new_name, TnyFolder *new_folder) 
    1908 { 
    1909         TnyFolderStoreChange *tochange = tny_folder_store_change_new (to); 
    1910         TnyFolderStoreChange *fromchange = tny_folder_store_change_new (from); 
    1911         TnyFolderChange *origchange = tny_folder_change_new (self); 
    1912 /*      TnyList *folders = tny_simple_list_new (); */ 
    1913 /*      TnyIterator *iter; */ 
    1914          
    1915         /* Notify change name (if neccesary) */ 
    1916         if (to == from && del_orig) { 
    1917                 if (strcmp (tny_folder_get_name (self), new_name)) {             
    1918                         tny_folder_change_set_rename (origchange, new_name); 
    1919                         notify_folder_observers_about (self, origchange); 
    1920                 } 
    1921         } 
    1922                  
    1923         /* Notify deletion  (if neccesary) */ 
    1924         if (del_orig) { 
    1925                 tny_folder_store_change_add_removed_folder (fromchange, self); 
    1926                 notify_folder_store_observers_about (from, fromchange); 
    1927         } 
    1928  
    1929         /* Notify addition */ 
    1930         tny_folder_store_change_add_created_folder (tochange, new_folder); 
    1931         notify_folder_store_observers_about (to, tochange); 
    1932          
    1933         /* Notify subfolders addition */ 
    1934 /*      tny_folder_store_get_folders (TNY_FOLDER_STORE(self), folders, NULL, NULL); */ 
    1935 /*      iter = tny_list_create_iterator (folders); */ 
    1936 /*      while (!tny_iterator_is_done (iter)) { */ 
    1937                  
    1938 /*              TnyFolder *folder = (TnyFolder*) tny_iterator_get_current (iter); */ 
    1939 /*              TnyFolderStoreChange *change = tny_folder_store_change_new (TNY_FOLDER_STORE(self)); */ 
    1940 /*              tny_folder_store_change_add_created_folder (change, folder); */ 
    1941 /*              notify_folder_store_observers_about (TNY_FOLDER_STORE(self), change); */ 
    1942  
    1943 /*              tny_iterator_next (iter); */ 
    1944  
    1945 /*              g_object_unref (G_OBJECT (folder)); */ 
    1946 /*              g_object_unref (G_OBJECT (change)); */ 
    1947 /*      } */ 
    1948          
    1949         /* Free */ 
    1950 /*      g_object_unref (G_OBJECT (iter)); */ 
    1951 /*      g_object_unref (G_OBJECT (folders)); */ 
    1952         g_object_unref (G_OBJECT (tochange)); 
    1953         g_object_unref (G_OBJECT (fromchange)); 
    1954         g_object_unref (G_OBJECT (origchange)); 
    1955 } 
    1956  
    19571929static void 
    19581930tny_camel_folder_copy_async_destroyer (gpointer thr_user_data) 
    19591931{ 
    19601932        CopyFolderInfo *info = (CopyFolderInfo *) thr_user_data; 
     1933        TnyFolderChange *change; 
    19611934        TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (info->self); 
    1962         TnyCamelFolderPriv *priv_from = TNY_CAMEL_FOLDER_GET_PRIVATE (info->from); 
    1963         TnyCamelFolderPriv *priv_to = TNY_CAMEL_FOLDER_GET_PRIVATE (info->into); 
    1964  
    1965         inform_observers_about_folder_copy (info->self, 
    1966                                             info->from,  
    1967                                             info->into,  
    1968                                             info->delete_originals,  
    1969                                             info->new_name, 
    1970                                             info->new_folder); 
    1971          
     1935 
     1936        if (info->err == NULL) 
     1937        { 
     1938                notify_folder_observers_about_copy (info->adds, info->rems,  
     1939                        info->delete_originals); 
     1940        } 
     1941 
    19721942        /* thread reference */ 
     1943        g_object_ref (G_OBJECT (info->into)); 
     1944        g_object_unref (G_OBJECT (info->self)); 
    19731945        _tny_camel_folder_unreason (priv); 
    1974         g_object_unref (G_OBJECT (info->self)); 
    1975         _tny_camel_folder_unreason (priv_to); 
    1976         g_object_unref (G_OBJECT (info->into)); 
    1977         _tny_camel_folder_unreason (priv_from); 
    1978         g_object_unref (G_OBJECT (info->from)); 
    19791946 
    19801947        if (info->err) 
     
    19851952        tny_idle_stopper_destroy (info->stopper); 
    19861953        info->stopper = NULL; 
    1987  
    1988         g_free(info->new_name); 
     1954        g_free (info->new_name); 
     1955 
    19891956        g_slice_free (CopyFolderInfo, info); 
    19901957} 
     
    19961963 
    19971964        if (info->callback) 
    1998                 info->callback (info->self, info->into, info->new_name, info->cancelled, &info->err, info->user_data); 
     1965                info->callback (info->self, info->into, info->cancelled,  
     1966                        info->new_folder, &info->err, info->user_data); 
    19991967 
    20001968        /* Prevent status callbacks from being called after this 
     
    20352003        CopyFolderInfo *info = thr_user_data; 
    20362004        TnyFolder *self = info->self; 
    2037         TnyFolder *new_folder = NULL; 
    2038         TnyFolderStore *into = info->into; 
    2039         TnyFolderStore *from = info->from; 
    2040         TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (self); 
    2041         TnyCamelFolderPriv *priv_dst = TNY_CAMEL_FOLDER_GET_PRIVATE (into); 
    2042         TnyCamelFolderPriv *priv_from = TNY_CAMEL_FOLDER_GET_PRIVATE (from); 
     2005        TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (self); 
    20432006        TnyCamelAccountPriv *apriv = TNY_CAMEL_ACCOUNT_GET_PRIVATE (priv->account); 
    2044         CamelException ex = CAMEL_EXCEPTION_INITIALISER
    2045         GError *err = NULL
     2007        GError *nerr = NULL
     2008        CpyRecRet *cpyr
    20462009 
    20472010        g_static_rec_mutex_lock (priv->folder_lock); 
    20482011 
    2049         /* Load oldparent foler */ 
    2050         if (!load_folder_no_lock (priv_from)) 
    2051         { 
    2052                 tny_camel_folder_copy_async_destroyer (info); 
    2053                 g_static_rec_mutex_unlock (priv->folder_lock); 
    2054                 g_thread_exit (NULL); 
    2055                 return NULL; 
    2056         } 
    2057  
    2058         /* Load directory to move */ 
    2059         if (!load_folder_no_lock (priv)) 
    2060         { 
    2061                 tny_camel_folder_copy_async_destroyer (info); 
    2062                 g_static_rec_mutex_unlock (priv->folder_lock); 
    2063                 g_thread_exit (NULL); 
    2064                 return NULL; 
    2065         } 
    2066  
    2067         /* Load new_parent foler */ 
    2068         if (!load_folder_no_lock (priv_dst)) 
    2069         { 
    2070                 tny_camel_folder_copy_async_destroyer (info); 
    2071                 g_static_rec_mutex_unlock (priv->folder_lock); 
    2072                 g_thread_exit (NULL); 
    2073                 return NULL; 
    2074         } 
    2075  
    20762012        info->cancelled = FALSE; 
    20772013 
    2078         /* start camel operations */ 
    20792014        _tny_camel_account_start_camel_operation (TNY_CAMEL_ACCOUNT (priv->account),  
    2080                 tny_camel_folder_copy_async_status, info,  
    2081                 "Fetching summary information for new messages in folder"); 
    2082  
    2083         /* Do work */ 
    2084         new_folder = tny_camel_folder_copy (self, info->into, info->new_name, info->delete_originals, &info->err); 
    2085  
    2086         /* Check cancelation and stop operation */ 
     2015                tny_camel_folder_copy_async_status, info, "Copying folder"); 
     2016 
     2017        info->adds = NULL; info->rems = NULL; 
     2018 
     2019        cpyr = tny_camel_folder_copy_shared (info->self, info->into,  
     2020                        info->new_name, info->delete_originals, &nerr,  
     2021                        info->rems, info->adds); 
     2022 
     2023        info->new_folder = cpyr->created; 
     2024        info->rems = cpyr->rems; 
     2025        info->adds = cpyr->adds; 
     2026 
     2027        g_slice_free (CpyRecRet, cpyr); 
     2028 
    20872029        info->cancelled = camel_operation_cancel_check (apriv->cancel); 
     2030 
    20882031        _tny_camel_account_stop_camel_operation (TNY_CAMEL_ACCOUNT (priv->account)); 
    20892032 
    2090         /* Get data */ 
    2091         info->new_folder = new_folder; 
    2092  
    2093         /* Stop operation and check errors */ 
    20942033        info->err = NULL; 
    2095         if (camel_exception_is_set (&ex)) 
    2096         { 
    2097                 g_set_error (&err, TNY_FOLDER_ERROR,  
    2098                         TNY_FOLDER_ERROR_REFRESH, 
    2099                         camel_exception_get_description (&ex)); 
    2100                 if (err != NULL) 
    2101                         info->err = g_error_copy ((const GError *) err); 
    2102         } 
    2103  
     2034        if (nerr != NULL) 
     2035        { 
     2036                g_propagate_error (&info->err, nerr); 
     2037                g_error_free (nerr); 
     2038        } 
    21042039 
    21052040        g_static_rec_mutex_unlock (priv->folder_lock); 
    21062041 
    2107         /* Call calback if it exists */ 
    21082042        if (info->callback) 
    21092043        { 
     
    21182052                } 
    21192053        } else { /* Thread reference */ 
    2120                 g_object_unref (G_OBJECT (self)); 
     2054                g_object_ref (info->into); 
     2055                g_object_unref (info->self); 
    21212056                _tny_camel_folder_unreason (priv); 
    2122                 g_object_unref (G_OBJECT (into)); 
    2123                 _tny_camel_folder_unreason (priv_dst); 
    2124                 g_object_unref (G_OBJECT (from)); 
    2125                 _tny_camel_folder_unreason (priv_from); 
    21262057        } 
    21272058        g_thread_exit (NULL); 
     
    21402071tny_camel_folder_copy_async_default (TnyFolder *self, TnyFolderStore *into, const gchar *new_name, gboolean del, TnyCopyFolderCallback callback, TnyStatusCallback status_callback, gpointer user_data) 
    21412072{ 
    2142         CopyFolderInfo *info = NULL; 
    2143         GThread *thread = NULL; 
     2073        TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (self); 
     2074        CopyFolderInfo *info; 
     2075        GThread *thread; 
    21442076        GError *err = NULL; 
    2145         TnyFolderStore *from = NULL; 
    2146         TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (self); 
    2147         TnyCamelFolderPriv *priv_to = TNY_CAMEL_FOLDER_GET_PRIVATE (into); 
    2148         TnyCamelFolderPriv *priv_from = NULL; 
    21492077 
    21502078        if (!_tny_session_check_operation (TNY_FOLDER_PRIV_GET_SESSION(priv), &err,  
    2151                         TNY_FOLDER_ERROR, TNY_FOLDER_ERROR_REFRESH)) 
     2079                        TNY_FOLDER_ERROR, TNY_FOLDER_ERROR_COPY)) 
    21522080        { 
    21532081                if (callback) 
    2154                         callback (self, info->into, info->new_name, TRUE, &info->err, user_data); 
     2082                       callback (self, into, TRUE, NULL, &err, user_data); 
    21552083                g_error_free (err); 
    21562084                return; 
    21572085        } 
    21582086 
    2159         from = tny_folder_get_folder_store (self); 
    2160         priv_from = TNY_CAMEL_FOLDER_GET_PRIVATE (from); 
    2161  
    2162         /* Idle info for the status callback: */ 
    21632087        info = g_slice_new (CopyFolderInfo); 
    2164         info->from = from; 
     2088 
     2089        info->cancelled = FALSE; 
     2090        info->session = TNY_FOLDER_PRIV_GET_SESSION (priv); 
     2091        info->self = self; 
    21652092        info->into = into; 
    2166         info->new_name = g_strdup(new_name); 
    2167         info->delete_originals = del; 
    2168         info->session = TNY_FOLDER_PRIV_GET_SESSION (priv); 
    2169         info->err = NULL; 
    2170         info->self = self; 
    21712093        info->callback = callback; 
    21722094        info->status_callback = status_callback; 
    21732095        info->user_data = user_data; 
    21742096        info->depth = g_main_depth (); 
    2175          
     2097        info->err = NULL; 
     2098        info->delete_originals = del; 
     2099        info->new_name = g_strdup (new_name); 
     2100 
    21762101        /* Use a ref count because we do not know which of the 2 idle callbacks  
    21772102         * will be the last, and we can only unref self in the last callback: 
    2178          * This is destroyed in the idle GDestroyNotify callback.*/ 
     2103         * This is destroyed in the idle GDestroyNotify callback. */ 
    21792104 
    21802105        info->stopper = tny_idle_stopper_new(); 
    21812106 
    21822107        /* thread reference */ 
     2108        _tny_camel_folder_reason (priv); 
    21832109        g_object_ref (G_OBJECT (info->self)); 
    2184         _tny_camel_folder_reason (priv); 
    21852110        g_object_ref (G_OBJECT (info->into)); 
    2186         _tny_camel_folder_reason (priv_to); 
    2187         _tny_camel_folder_reason (priv_from); 
    2188  
    2189         /* This will cause the idle status callback to be called, 
    2190          * via _tny_camel_account_start_camel_operation, 
    2191          * and also calls the idle main callback: */ 
    21922111 
    21932112        thread = g_thread_create (tny_camel_folder_copy_async_thread, 
  • trunk/libtinymail/tny-shared.h

    r1955 r1956  
    8181typedef struct _TnyFolderStoreQueryItemClass TnyFolderStoreQueryItemClass; 
    8282typedef void (*TnyGetFoldersCallback) (TnyFolderStore *self, TnyList *list, GError **err, gpointer user_data); 
    83 typedef void (*TnyCopyFolderCallback) (TnyFolder *self, TnyFolderStore *into, const gchar *new_name, gboolean cancelled, GError **err, gpointer user_data); 
     83typedef void (*TnyCopyFolderCallback) (TnyFolder *self, TnyFolderStore *into, gboolean cancelled, TnyFolder *new_folder, GError **err, gpointer user_data); 
    8484typedef enum _TnyFolderSignal TnyFolderSignal; 
    8585typedef enum _TnyDeviceSignal TnyDeviceSignal;