Changeset 1654

Show
Ignore:
Timestamp:
02/18/07 15:27:42
Author:
pvanhoof
Message:

Various fixes

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/ChangeLog

    r1649 r1654  
     12007-02-18  Philip Van Hoof  <pvanhoof@gnome.org> 
     2 
     3        * Various fixes for the folder create, rename and delete functionality 
     4 
    152007-02-16  Philip Van Hoof  <pvanhoof@gnome.org> 
    26 
  • trunk/libtinymail-camel/tny-camel-folder.c

    r1650 r1654  
    20732073                if ((*ccfoln == '/') && (strrchr (ccfoln, '/') == ccfoln)) 
    20742074                { 
     2075                        CamelException subex = CAMEL_EXCEPTION_INITIALISER; 
     2076 
     2077                        if (camel_store_supports_subscriptions (store)) 
     2078                                camel_store_subscribe_folder (store, cfolname, &subex); 
     2079 
    20752080                        camel_store_delete_folder (store, cfolname, &ex); 
    20762081 
     
    20832088                        } else  
    20842089                        { 
     2090                                if (camel_store_supports_subscriptions (store)) 
     2091                                        camel_store_unsubscribe_folder (store, cfolname, &subex); 
     2092 
    20852093                                changed = TRUE; 
    20862094                                g_free (cpriv->folder_name);  
     
    21452153        TnyFolder *folder; CamelFolderInfo *info; 
    21462154        TnyFolderStoreChange *change; 
     2155        CamelException subex = CAMEL_EXCEPTION_INITIALISER; 
    21472156 
    21482157        if (!_tny_session_check_operation (TNY_FOLDER_PRIV_GET_SESSION(priv), err,  
     
    21942203                return NULL; 
    21952204        } 
     2205 
     2206        g_assert (info != NULL); 
     2207 
     2208        if (camel_store_supports_subscriptions (store)) 
     2209                camel_store_subscribe_folder (store, info->full_name, &subex); 
    21962210 
    21972211        folder = _tny_camel_folder_new (); 
  • trunk/libtinymail-camel/tny-camel-store-account.c

    r1650 r1654  
    389389        TnyCamelFolderPriv *cpriv = TNY_CAMEL_FOLDER_GET_PRIVATE (cfol); 
    390390        CamelStore *store; 
    391          
     391        CamelException subex = CAMEL_EXCEPTION_INITIALISER; 
     392 
    392393        g_assert (TNY_IS_CAMEL_FOLDER (folder)); 
    393394 
     
    425426        g_assert (cpriv->folder_name != NULL); 
    426427 
    427         /* Unsubscribe : camel should do it by itself but it does not do it */ 
    428  
    429         if (camel_store_supports_subscriptions (store) &&   
    430                         camel_store_folder_subscribed (store, cpriv->folder_name)) 
    431                 camel_store_unsubscribe_folder (store, cpriv->folder_name, NULL); 
     428        if (camel_store_supports_subscriptions (store)) 
     429                camel_store_subscribe_folder (store, cpriv->folder_name, &subex); 
    432430 
    433431        camel_store_delete_folder (store, cpriv->folder_name, &ex); 
    434          
     432 
    435433        if (camel_exception_is_set (&ex))  
    436434        { 
     
    441439        } else  
    442440        { 
    443                 TnyFolderStoreChange *change;    
     441                if (camel_store_supports_subscriptions (store)) 
     442                        camel_store_unsubscribe_folder (store, cpriv->folder_name, &subex); 
     443 
     444                TnyFolderStoreChange *change; 
    444445                change = tny_folder_store_change_new (self); 
    445446                tny_folder_store_change_add_removed_folder (change, folder); 
    446447                notify_folder_store_observers_about (self, change); 
    447                 g_object_unref (G_OBJECT (change));             
     448                g_object_unref (G_OBJECT (change));      
    448449        } 
    449450 
     
    472473        TnyFolder *folder; CamelFolderInfo *info; CamelStore *store; 
    473474        TnyFolderStoreChange *change; 
     475        CamelException subex = CAMEL_EXCEPTION_INITIALISER; 
    474476 
    475477        if (!_tny_session_check_operation (apriv->session, err,  
     
    535537 
    536538        g_assert (info != NULL); 
     539 
     540        if (camel_store_supports_subscriptions (store)) 
     541                camel_store_subscribe_folder (store, info->full_name, &subex); 
    537542 
    538543        folder = _tny_camel_folder_new (); 
  • trunk/libtinymail/tny-folder-store.c

    r1636 r1654  
    107107 * @err: a #GError object or NULL 
    108108 * 
    109  * Creates a new folder in @self. The value returned is the newly created folder 
    110  * instance and must be unreferenced after use. 
     109 * Creates a new folder in @self. If not NULL, the value returned is the newly  
     110 * created folder instance and must be unreferenced after use. 
    111111 * 
    112112 * Example: 
     
    115115 * TnyFolder *createfol; 
    116116 * createfol = tny_folder_store_create_folder (store, "Test", NULL); 
    117  * g_object_unref (G_OBJECT (createfol)); 
     117 * if (createfol) g_object_unref (G_OBJECT (createfol)); 
    118118 * </programlisting></informalexample> 
    119119 *  
    120  * Return value: A new folder instance representing the folder that was created 
     120 * Return value: A new folder instance representing the folder that was created or NULL in case of failure 
    121121 * 
    122122 **/ 
  • trunk/libtinymailui-gtk/tny-gtk-folder-store-tree-model.c

    r1651 r1654  
    7070                gtk_tree_store_append (model, tree_iter, hlrp->parent_tree_iter); 
    7171 
     72                /* This adds a reference count to folder too. When it gets removed, that 
     73                   reference count is decreased automatically by the gtktreestore infra- 
     74                   structure. */ 
     75 
    7276                gtk_tree_store_set (model, tree_iter, 
    7377                        TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN,  
     
    134138                me->store_observables = g_list_prepend (me->store_observables, folder); 
    135139 
     140                /* This adds a reference count to folder too. When it gets removed, that 
     141                   reference count is decreased automatically by the gtktreestore infra- 
     142                   structure. */ 
     143 
    136144                gtk_tree_store_set (model, &tree_iter, 
    137145                        TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN,  
     
    210218                func (model, name_iter, NULL); 
    211219 
     220        /* This adds a reference count to folder_store too. When it gets removed, 
     221           that reference count is decreased automatically by the gtktreestore 
     222           infrastructure. */ 
     223 
    212224        gtk_tree_store_set (model, name_iter, 
    213225                TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, root_name, 
     
    484496                if (citem == item) 
    485497                { 
     498                        /* This removes a reference count */ 
    486499                        gtk_tree_store_remove (GTK_TREE_STORE (me), &iter); 
    487500                        g_object_unref (G_OBJECT (item)); 
     
    501514        TnyGtkFolderStoreTreeModel *copy = g_object_new (TNY_TYPE_GTK_FOLDER_STORE_TREE_MODEL, NULL); 
    502515 
    503         /* This only copies the TnyList pieces. The result is not a 
    504            correct or good TnyHeaderListModel. But it will be a correct 
    505            TnyList instance. It is the only thing the user of this 
    506            method expects. 
    507  
    508            The new list will point to the same instances, of course. It's 
    509            only a copy of the list-nodes of course. */ 
     516        /* This only copies the TnyList pieces. The result is not a correct or good 
     517           TnyHeaderListModel. But it will be a correct TnyList instance. It's the  
     518           only thing the user of this method expects (that is the contract of it). 
     519 
     520           The new list will point to the same instances, of course. It's only a  
     521           copy of the list-nodes of course. */ 
    510522 
    511523        g_mutex_lock (me->iterator_lock); 
     
    533545 
    534546 
    535 typedef void (*pernodeexec) (GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data1, gpointer user_data2); 
    536  
    537 static void 
    538 foreach_node_execute (GtkTreeModel *model, GtkTreeIter *iter, pernodeexec func, gpointer user_data1, gpointer user_data2)  
    539 
    540         do  
    541         { 
    542                         GtkTreeIter kids; 
    543                         if (gtk_tree_model_iter_children (model, &kids, iter)) 
    544                                 foreach_node_execute (model, &kids, func, user_data1, user_data2); 
    545  
    546                         func (model, iter, user_data1, user_data2); 
    547         } while (gtk_tree_model_iter_next (model, iter)); 
    548 
    549  
    550 static void 
    551 updater (GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data1, gpointer user_data2) 
     547static gboolean  
     548updater (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer user_data1) 
    552549{ 
    553550        gint type; 
     
    583580 
    584581        g_object_unref (G_OBJECT (changed_folder)); 
    585 
    586  
    587  
    588 static void 
    589 creater (GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data1, gpointer user_data2) 
     582 
     583        return FALSE; 
     584
     585 
     586 
     587static gboolean  
     588creater (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer user_data1) 
    590589{ 
    591590        gint type; 
     
    619618 
    620619                                gtk_tree_store_append (GTK_TREE_STORE (model), &newiter, iter); 
     620 
     621                                /* This adds a reference count to folder_store too. When it gets  
     622                                   removed, that reference count is decreased automatically by  
     623                                   the gtktreestore infrastructure. */ 
    621624 
    622625                                gtk_tree_store_set (GTK_TREE_STORE (model), &newiter, 
     
    646649 
    647650        g_object_unref (G_OBJECT (parentstore)); 
    648 
    649  
    650  
    651  
    652 static void 
    653 deleter (GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data1, gpointer user_data2) 
     651 
     652        return FALSE; 
     653
     654 
     655 
     656static gboolean  
     657deleter (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer user_data1) 
    654658{ 
    655659        gint type; 
    656         TnyFolderStoreChange *change = user_data1; 
    657         TnyFolderStore *parentstore = tny_folder_store_change_get_folder_store (change); 
     660        GObject *folder = user_data1; 
    658661 
    659662        gtk_tree_model_get (model, iter,  
     
    663666        if (type != TNY_FOLDER_TYPE_ROOT)  
    664667        { 
    665                 TnyFolderStore *fol; 
     668                GObject *fol; 
    666669 
    667670                gtk_tree_model_get (model, iter,  
     
    669672                        &fol, -1); 
    670673 
    671                 if (fol == parentstore) 
    672                 { 
    673                         TnyList *removed = tny_simple_list_new (); 
    674                         TnyIterator *miter; 
    675  
    676                         tny_folder_store_change_get_removed_folders (change, removed); 
    677                         miter = tny_list_create_iterator (removed); 
    678  
    679                         while (!tny_iterator_is_done (miter)) 
    680                         { 
    681                                 GtkTreeIter kids; 
    682                                 TnyFolder *folder = TNY_FOLDER (tny_iterator_get_current (miter)); 
    683  
    684                                 if (gtk_tree_model_iter_children (model, &kids, iter)) 
    685                                   while (gtk_tree_model_iter_next (model, &kids)) 
    686                                   { 
    687                                         gint ntype; 
    688                                         gtk_tree_model_get (model, &kids,  
    689                                                 TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN,  
    690                                                 &ntype, -1); 
    691  
    692                                         if (ntype != TNY_FOLDER_TYPE_ROOT) 
    693                                         { 
    694                                                 TnyFolder *nfol; 
    695                                                 gtk_tree_model_get (model, &kids,  
    696                                                         TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,  
    697                                                         &nfol, -1); 
    698  
    699                                                 if (nfol == folder) 
    700                                                         gtk_tree_store_remove (GTK_TREE_STORE (model), &kids); 
    701  
    702                                                 g_object_unref (G_OBJECT (nfol)); 
    703                                         } 
    704                                   } 
    705                                 g_object_unref (G_OBJECT (folder)); 
    706  
    707                                 tny_iterator_next (miter); 
    708                         } 
    709  
    710                         g_object_unref (G_OBJECT (miter)); 
    711                         g_object_unref (G_OBJECT (removed)); 
    712  
    713                 } 
     674                if (fol == folder) 
     675                        gtk_tree_store_remove (GTK_TREE_STORE (model), iter); 
    714676 
    715677                g_object_unref (G_OBJECT (fol)); 
    716678        } 
    717679 
    718         g_object_unref (G_OBJECT (parentstore))
     680        return FALSE
    719681} 
    720682 
     
    729691                changed & TNY_FOLDER_CHANGE_CHANGED_UNREAD_COUNT) 
    730692        { 
    731                 GtkTreeIter iter; 
    732                 if (gtk_tree_model_get_iter_first (model, &iter)) 
    733                         foreach_node_execute (model, &iter, updater, change, NULL); 
    734         } 
    735 
    736  
     693                gtk_tree_model_foreach (model, updater, change); 
     694        } 
     695
     696 
     697 
     698static gboolean 
     699find_store_iter (GtkTreeModel *model, GtkTreeIter *iter, GtkTreeIter *f, gpointer user_data) 
     700
     701        do 
     702        { 
     703                GtkTreeIter child; 
     704                gint type; 
     705 
     706                gtk_tree_model_get (model, iter,  
     707                        TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN,  
     708                        &type, -1); 
     709 
     710                if (type != TNY_FOLDER_TYPE_ROOT)  
     711                { 
     712                        TnyFolderStore *fol; 
     713                        gboolean found = FALSE; 
     714 
     715                        gtk_tree_model_get (model, iter,  
     716                                TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,  
     717                                &fol, -1); 
     718 
     719                        if (fol == user_data) 
     720                                found = TRUE; 
     721 
     722                        g_object_unref (G_OBJECT (fol)); 
     723 
     724                        if (found) { 
     725                                *f = *iter; 
     726                                return TRUE; 
     727                        } 
     728                } 
     729 
     730                if (gtk_tree_model_iter_children (model, &child, iter)) 
     731                { 
     732                        if (find_store_iter (model, &child, f, user_data)) 
     733                                return TRUE; 
     734                } 
     735 
     736        } while (gtk_tree_model_iter_next (model, iter)); 
     737 
     738        return FALSE; 
     739
    737740 
    738741static void 
     
    744747        if (changed & TNY_FOLDER_STORE_CHANGE_CHANGED_CREATED_FOLDERS) 
    745748        { 
    746                 GtkTreeIter iter; 
    747                 if (gtk_tree_model_get_iter_first (model, &iter)) 
    748                         foreach_node_execute (model, &iter, creater, change, NULL); 
     749                TnyFolderStore *parentstore = tny_folder_store_change_get_folder_store (change); 
     750                GtkTreeIter first, iter; 
     751 
     752                if (gtk_tree_model_get_iter_first (model, &first) &&  
     753                        find_store_iter (model, &first, &iter, parentstore)) 
     754                { 
     755                        TnyList *created = tny_simple_list_new (); 
     756                        TnyIterator *miter; 
     757 
     758                        tny_folder_store_change_get_created_folders (change, created); 
     759                        miter = tny_list_create_iterator (created); 
     760 
     761                        while (!tny_iterator_is_done (miter)) 
     762                        { 
     763                                GtkTreeIter newiter; 
     764                                TnyFolder *folder = TNY_FOLDER (tny_iterator_get_current (miter)); 
     765 
     766                                gtk_tree_store_append (GTK_TREE_STORE (model), &newiter, &iter); 
     767 
     768                                /* This adds a reference count to folder_store too. When it gets  
     769                                   removed, that reference count is decreased automatically by  
     770                                   the gtktreestore infrastructure. */ 
     771 
     772                                gtk_tree_store_set (GTK_TREE_STORE (model), &newiter, 
     773                                        TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN,  
     774                                        tny_folder_get_name (TNY_FOLDER (folder)), 
     775                                        TNY_GTK_FOLDER_STORE_TREE_MODEL_UNREAD_COLUMN,  
     776                                        tny_folder_get_unread_count (TNY_FOLDER (folder)), 
     777                                        TNY_GTK_FOLDER_STORE_TREE_MODEL_ALL_COLUMN,  
     778                                        tny_folder_get_all_count (TNY_FOLDER (folder)), 
     779                                        TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, 
     780                                        tny_folder_get_folder_type (TNY_FOLDER (folder)), 
     781                                        TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, 
     782                                        folder, -1); 
     783 
     784                                g_object_unref (G_OBJECT (folder)); 
     785                                tny_iterator_next (miter); 
     786                        } 
     787                        g_object_unref (G_OBJECT (miter)); 
     788                        g_object_unref (G_OBJECT (created)); 
     789                } 
     790                g_object_unref (G_OBJECT (parentstore)); 
    749791        } 
    750792 
    751793        if (changed & TNY_FOLDER_STORE_CHANGE_CHANGED_REMOVED_FOLDERS) 
    752794        { 
    753                 GtkTreeIter iter; 
    754                 if (gtk_tree_model_get_iter_first (model, &iter)) 
    755                         foreach_node_execute (model, &iter, deleter, change, NULL); 
     795                TnyList *removed = tny_simple_list_new (); 
     796                TnyIterator *miter; 
     797 
     798                tny_folder_store_change_get_removed_folders (change, removed); 
     799                miter = tny_list_create_iterator (removed); 
     800 
     801                while (!tny_iterator_is_done (miter)) 
     802                { 
     803                        TnyFolder *folder = TNY_FOLDER (tny_iterator_get_current (miter)); 
     804                        gtk_tree_model_foreach (model, deleter, folder); 
     805                        g_object_unref (G_OBJECT (folder)); 
     806                        tny_iterator_next (miter); 
     807                } 
     808                g_object_unref (G_OBJECT (miter)); 
     809                g_object_unref (G_OBJECT (removed)); 
    756810        } 
    757811} 
  • trunk/tests/c-demo/tny-demoui-summary-view.c

    r1653 r1654  
    869869                                        const gchar *newname = gtk_entry_get_text (GTK_ENTRY (entry)); 
    870870 
    871                                         tny_folder_store_create_folder (folderstore, newname, &err); 
     871                                        TnyFolder *created = tny_folder_store_create_folder (folderstore, newname, &err); 
     872 
     873                                        if (created) /* Can be NULL on failure */ 
     874                                                g_object_unref (G_OBJECT (created)); 
    872875 
    873876                                        if (err != NULL)