Changeset 1984

Show
Ignore:
Timestamp:
05/16/07 23:13:59
Author:
pvanhoof
Message:

Removed a API on TnyFolder

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/ChangeLog

    r1972 r1984  
     12007-05-16  Philip Van Hoof  <pvanhoof@gnome.org> 
     2 
     3        * Removed the unworkable tny_folder_set_name, old code should replace 
     4        this with tny_folder_copy with the del parameter set to TRUE and the 
     5        folder store being the one you get using tny_folder_get_folder_store 
     6 
     7        * This was a major API change 
     8 
    192007-05-16  Murray Cumming  <murrayc@murrayc.com> 
    210 

  • trunk/libtinymail-camel/tny-camel-folder.c

    r1983 r1984  
    26122612 
    26132613        return; 
    2614 } 
    2615  
    2616  
    2617 static void 
    2618 tny_camel_folder_set_name (TnyFolder *self, const gchar *name, GError **err) 
    2619 { 
    2620         TNY_CAMEL_FOLDER_GET_CLASS (self)->set_name_func (self, name, err); 
    2621         return; 
    2622 } 
    2623  
    2624 static void 
    2625 tny_camel_folder_set_name_default (TnyFolder *self, const gchar *name, GError **err) 
    2626 { 
    2627         TnyCamelFolderPriv *priv = TNY_CAMEL_FOLDER_GET_PRIVATE (self); 
    2628         CamelFolder *cfolder; 
    2629         CamelFolderInfo *parent_info; 
    2630         const gchar *old_path; 
    2631         gchar *new_path; 
    2632         CamelException ex = CAMEL_EXCEPTION_INITIALISER; 
    2633         gboolean changed = FALSE; 
    2634         gboolean was_sub = FALSE; 
    2635  
    2636         if (!_tny_session_check_operation (TNY_FOLDER_PRIV_GET_SESSION(priv), err,  
    2637                         TNY_FOLDER_ERROR, TNY_FOLDER_ERROR_SET_NAME)) 
    2638                 return; 
    2639  
    2640  
    2641         g_static_rec_mutex_lock (priv->folder_lock); 
    2642  
    2643         if (!priv->folder || !priv->loaded || !CAMEL_IS_FOLDER (priv->folder)) 
    2644                 if (!load_folder_no_lock (priv))  
    2645                 { 
    2646                         g_static_rec_mutex_unlock (priv->folder_lock); 
    2647                         _tny_session_stop_operation (TNY_FOLDER_PRIV_GET_SESSION (priv)); 
    2648                         return; 
    2649                 } 
    2650  
    2651         if (!priv->iter) { 
    2652                 _tny_session_stop_operation (TNY_FOLDER_PRIV_GET_SESSION (priv)); 
    2653                 g_static_rec_mutex_unlock (priv->folder_lock); 
    2654                 return; 
    2655         } 
    2656  
    2657         /* Create new full name */ 
    2658         cfolder = _tny_camel_folder_get_camel_folder (TNY_CAMEL_FOLDER (self)); 
    2659         old_path = camel_folder_get_full_name (cfolder); 
    2660         parent_info = priv->iter->parent; 
    2661  
    2662         if (parent_info) 
    2663                 new_path = g_strdup_printf ("%s/%s", parent_info->full_name, name); 
    2664         else 
    2665         { 
    2666                 if (!priv->iter_parented) 
    2667                 { 
    2668                         char *nold_path = g_strdup (old_path); 
    2669                         char *lastslash = strrchr (nold_path, '/'); 
    2670                         if (lastslash) 
    2671                         { 
    2672                                 *lastslash = '\0'; 
    2673                                 new_path = g_strdup_printf ("%s/%s", nold_path, name); 
    2674                                 g_free (nold_path); 
    2675                         } else { 
    2676                                 g_free (nold_path); 
    2677                                 g_set_error (err, TNY_FOLDER_ERROR,  
    2678                                         TNY_FOLDER_ERROR_SET_NAME, 
    2679                                         "Can't rename %s to %s", old_path, name); 
    2680                                 goto errorh; 
    2681                         } 
    2682                 } else { 
    2683                         g_set_error (err, TNY_FOLDER_ERROR,  
    2684                                 TNY_FOLDER_ERROR_SET_NAME, 
    2685                                 "Can't rename the root INBOX folder"); 
    2686                         goto errorh; 
    2687                 } 
    2688         } 
    2689  
    2690         /* Check that the name really changes */ 
    2691         if (!strcmp (old_path, new_path))  
    2692         { 
    2693                 g_free (new_path);  
    2694                 /* It's not really an error, just a NOOP */ 
    2695                 goto errorh; 
    2696         } 
    2697  
    2698         /* Rename folder */ 
    2699  
    2700         if (camel_store_supports_subscriptions (cfolder->parent_store)) 
    2701                 was_sub = camel_store_folder_subscribed (cfolder->parent_store, old_path); 
    2702  
    2703         camel_store_rename_folder (cfolder->parent_store, old_path, (const gchar *) new_path, &ex); 
    2704  
    2705         if (camel_store_supports_subscriptions (cfolder->parent_store)) 
    2706         { 
    2707                 camel_store_unsubscribe_folder (cfolder->parent_store, old_path, NULL); 
    2708  
    2709                 if (was_sub) 
    2710                         camel_store_subscribe_folder (cfolder->parent_store, new_path, NULL); 
    2711                 else 
    2712                         camel_store_unsubscribe_folder (cfolder->parent_store, new_path, NULL); 
    2713         } 
    2714  
    2715         g_free (new_path); 
    2716  
    2717         if (camel_exception_is_set (&ex)) 
    2718         { 
    2719                 g_set_error (err, TNY_FOLDER_ERROR,  
    2720                         TNY_FOLDER_ERROR_SET_NAME, 
    2721                         camel_exception_get_description (&ex)); 
    2722  
    2723                 camel_exception_clear (&ex); 
    2724  
    2725         } else if (priv->cached_name) 
    2726         { 
    2727                 changed = TRUE; 
    2728                 g_free (priv->cached_name); 
    2729                 priv->cached_name = g_strdup (name); 
    2730         } 
    2731  
    2732 errorh: 
    2733  
    2734         g_static_rec_mutex_unlock (priv->folder_lock); 
    2735  
    2736         if (changed) 
    2737         { 
    2738                 TnyFolderChange *change; 
    2739  
    2740                 change = tny_folder_change_new (self); 
    2741                 tny_folder_change_set_rename (change, name); 
    2742                 notify_folder_observers_about (self, change); 
    2743                 g_object_unref (G_OBJECT (change)); 
    2744         } 
    2745  
    2746         _tny_session_stop_operation (TNY_FOLDER_PRIV_GET_SESSION (priv)); 
    27472614} 
    27482615 
    …… 
    36773544        klass->get_msg_async_func = tny_camel_folder_get_msg_async; 
    36783545        klass->get_id_func = tny_camel_folder_get_id; 
    3679         klass->set_name_func = tny_camel_folder_set_name; 
    36803546        klass->get_name_func = tny_camel_folder_get_name; 
    36813547        klass->get_folder_type_func = tny_camel_folder_get_folder_type; 
    …… 
    37373603        class->get_msg_async_func = tny_camel_folder_get_msg_async_default; 
    37383604        class->get_id_func = tny_camel_folder_get_id_default; 
    3739         class->set_name_func = tny_camel_folder_set_name_default; 
    37403605        class->get_name_func = tny_camel_folder_get_name_default; 
    37413606        class->get_folder_type_func = tny_camel_folder_get_folder_type_default; 

  • trunk/libtinymail-camel/tny-camel-folder.h

    r1936 r1984  
    6868        const gchar* (*get_id_func) (TnyFolder *self); 
    6969        TnyAccount* (*get_account_func) (TnyFolder *self); 
    70         void (*set_name_func) (TnyFolder *self, const gchar *name, GError **err); 
    7170        TnyFolderType (*get_folder_type_func) (TnyFolder *self); 
    7271        guint (*get_all_count_func) (TnyFolder *self); 

  • trunk/libtinymail-camel/tny-camel-nntp-folder.c

    r1866 r1984  
    107107        object_class = (GObjectClass*) class; 
    108108 
    109         TNY_CAMEL_FOLDER_CLASS (class)->set_name_func = tny_camel_nntp_folder_set_name; 
    110109        TNY_CAMEL_FOLDER_CLASS (class)->remove_folder_func = tny_camel_nntp_folder_remove_folder; 
    111110        TNY_CAMEL_FOLDER_CLASS (class)->create_folder_func = tny_camel_nntp_folder_create_folder; 

  • trunk/libtinymail-camel/tny-camel-pop-folder.c

    r1866 r1984  
    9292 
    9393static void  
    94 tny_camel_pop_folder_set_name (TnyFolder *self, const gchar *name, GError **err) 
    95 { 
    96         g_set_error (err, TNY_FOLDER_STORE_ERROR,  
    97                                 TNY_FOLDER_STORE_ERROR_CREATE_FOLDER, 
    98                                 "You can't use the tny_folder_set_name API on POP folders"); 
    99         return; 
    100 } 
    101  
    102  
    103 static void  
    10494tny_camel_pop_folder_class_init (TnyCamelPOPFolderClass *class) 
    10595{ 
    …… 
    10999        object_class = (GObjectClass*) class; 
    110100 
    111         TNY_CAMEL_FOLDER_CLASS (class)->set_name_func = tny_camel_pop_folder_set_name; 
    112101        TNY_CAMEL_FOLDER_CLASS (class)->remove_folder_func = tny_camel_pop_folder_remove_folder; 
    113102        TNY_CAMEL_FOLDER_CLASS (class)->create_folder_func = tny_camel_pop_folder_create_folder; 

  • trunk/libtinymail/tny-folder.c

    r1970 r1984  
    11511151 
    11521152 
    1153 /** 
    1154  * tny_folder_set_name: 
    1155  * @self: a TnyFolder object 
    1156  * @name: a new name for the folder 
    1157  * @err: a #GError object or NULL 
    1158  *  
    1159  * Rename a folder. Most services require the name to be unique in the  
    1160  * parent folder. A rename operation that didn't succeed will put an error  
    1161  * in @err. 
    1162  * 
    1163  **/ 
    1164 void 
    1165 tny_folder_set_name (TnyFolder *self, const gchar *name, GError **err) 
    1166 { 
    1167 #ifdef DBC /* require */ 
    1168         g_assert (TNY_IS_FOLDER (self)); 
    1169         g_assert (name); 
    1170         g_assert (strlen (name) > 0); 
    1171         g_assert (TNY_FOLDER_GET_IFACE (self)->set_name_func != NULL); 
    1172 #endif 
    1173  
    1174         TNY_FOLDER_GET_IFACE (self)->set_name_func (self, name, err); 
    1175  
    1176 #ifdef DBC /* ensure */ 
    1177         g_assert (!strcmp (tny_folder_get_name (self), name)); 
    1178 #endif 
    1179  
    1180         return; 
    1181 } 
    11821153 
    11831154/** 

  • trunk/libtinymail/tny-folder.h

    r1936 r1984  
    100100        const gchar* (*get_id_func) (TnyFolder *self); 
    101101        TnyAccount* (*get_account_func) (TnyFolder *self); 
    102         void (*set_name_func) (TnyFolder *self, const gchar *name, GError **err); 
    103102        TnyFolderType (*get_folder_type_func) (TnyFolder *self); 
    104103        guint (*get_all_count_func) (TnyFolder *self); 
    …… 
    137136const gchar* tny_folder_get_id (TnyFolder *self); 
    138137const gchar* tny_folder_get_name (TnyFolder *self); 
    139 void tny_folder_set_name (TnyFolder *self, const gchar *name, GError **err); 
    140138TnyFolderType tny_folder_get_folder_type (TnyFolder *self); 
    141139guint tny_folder_get_all_count (TnyFolder *self); 

  • trunk/libtinymail/tny-merge-folder.c

    r1924 r1984  
    382382} 
    383383 
    384 static void 
    385 tny_merge_folder_set_name (TnyFolder *self, const gchar *name, GError **err) 
    386 { 
    387         TnyMergeFolderPriv *priv = TNY_MERGE_FOLDER_GET_PRIVATE (self); 
    388  
    389         g_static_rec_mutex_lock (priv->lock); 
    390  
    391         if (priv->name) 
    392                 g_free (priv->name); 
    393         priv->name = g_strdup (name); 
    394  
    395         g_static_rec_mutex_unlock (priv->lock); 
    396  
    397         return; 
    398 } 
    399384 
    400385static TnyFolderType 
    …… 
    10431028        klass->get_id_func = tny_merge_folder_get_id; 
    10441029        klass->get_account_func = tny_merge_folder_get_account; 
    1045         klass->set_name_func = tny_merge_folder_set_name; 
    10461030        klass->get_folder_type_func = tny_merge_folder_get_folder_type; 
    10471031        klass->get_all_count_func = tny_merge_folder_get_all_count; 

  • trunk/tests/c-demo/tny-demoui-summary-view.c

    r1957 r1984  
    830830                                &folder, -1); 
    831831 
    832                         dialog = gtk_dialog_new_with_buttons (_("Rename a folder"), 
     832                        dialog = gtk_dialog_new_with_buttons (_("Rename or copy a folder (first OK=rename)"), 
     833                                                          GTK_WINDOW (gtk_widget_get_parent (GTK_WIDGET (self))), 
     834                                                          GTK_DIALOG_MODAL, 
     835                                                          GTK_STOCK_OK, 
     836                                                          GTK_RESPONSE_ACCEPT, 
     837                                                          GTK_STOCK_OK, 
     838                                                          GTK_RESPONSE_YES, 
     839                                                          GTK_STOCK_CANCEL, 
     840                                                          GTK_RESPONSE_REJECT, 
     841                                                          NULL); 
     842 
     843                        entry = gtk_entry_new (); 
     844                        gtk_entry_set_text (GTK_ENTRY (entry), tny_folder_get_name (folder)); 
     845                        gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), entry); 
     846                        gtk_widget_show (entry); 
     847 
     848                        result = gtk_dialog_run (GTK_DIALOG (dialog)); 
     849 
     850                        switch (result) 
     851                        { 
     852                                case GTK_RESPONSE_YES: 
     853                                case GTK_RESPONSE_ACCEPT:  
     854                                { 
     855                                        gboolean copy = (result == GTK_RESPONSE_YES); 
     856                                        GError *err = NULL; 
     857                                        const gchar *newname = gtk_entry_get_text (GTK_ENTRY (entry)); 
     858                                        TnyFolderStore *into = tny_folder_get_folder_store (folder); 
     859                                        TnyFolder *nfol = tny_folder_copy (folder, into, newname, copy, &err); 
     860 
     861                                        if (err != NULL) 
     862                                        { 
     863                                                GtkWidget *edialog; 
     864 
     865                                                gtk_widget_destroy (dialog); 
     866                                                dialog = NULL; 
     867 
     868                                                edialog = gtk_message_dialog_new ( 
     869                                                                                  GTK_WINDOW (gtk_widget_get_parent (GTK_WIDGET (self))), 
     870                                                                                  GTK_DIALOG_DESTROY_WITH_PARENT, 
     871                                                                                  GTK_MESSAGE_ERROR, 
     872                                                                                  GTK_BUTTONS_CLOSE, 
     873                                                                                  err->message); 
     874                                                g_signal_connect_swapped (edialog, "response", 
     875                                                        G_CALLBACK (gtk_widget_destroy), edialog); 
     876                                                gtk_widget_show_all (edialog); 
     877                                                g_error_free (err); 
     878                                        } 
     879 
     880                                        if (into) 
     881                                                g_object_unref (into); 
     882 
     883                                        if (nfol) 
     884                                                g_object_unref (nfol); 
     885 
     886                                } 
     887                                break; 
     888 
     889                                default: 
     890                                break; 
     891                        } 
     892 
     893                        if (dialog) 
     894                                gtk_widget_destroy (dialog); 
     895                        g_object_unref (G_OBJECT (folder)); 
     896                } 
     897 
     898        } 
     899 
     900} 
     901 
     902static void  
     903on_delete_folder_activate (GtkMenuItem *mitem, gpointer user_data) 
     904{ 
     905        TnyDemouiSummaryView *self = user_data; 
     906        TnyDemouiSummaryViewPriv *priv = TNY_DEMOUI_SUMMARY_VIEW_GET_PRIVATE (self); 
     907        GtkTreeIter iter; 
     908        GtkTreeModel *model; 
     909 
     910        if (gtk_tree_selection_get_selected (priv->mailbox_select, &model, &iter)) 
     911        { 
     912                gint type; 
     913 
     914                gtk_tree_model_get (model, &iter,  
     915                        TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN,  
     916                        &type, -1); 
     917 
     918                if (type != TNY_FOLDER_TYPE_ROOT)  
     919                {  
     920                        TnyFolder *folder; 
     921                        GtkWidget *dialog, *label; 
     922                        gint result; 
     923 
     924                        gtk_tree_model_get (model, &iter,  
     925                                TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,  
     926                                &folder, -1); 
     927 
     928                        dialog = gtk_dialog_new_with_buttons (_("Delete a folder"), 
    833929                                                                                                  GTK_WINDOW (gtk_widget_get_parent (GTK_WIDGET (self))), 
    834930                                                                                                  GTK_DIALOG_MODAL, 
    …… 
    839935                                                                                                  NULL); 
    840936 
     937                        label = gtk_label_new (_("Are you sure you want to delete this folder?")); 
     938                        gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), label); 
     939                        gtk_widget_show (label); 
     940 
     941                        result = gtk_dialog_run (GTK_DIALOG (dialog)); 
     942 
     943                        switch (result) 
     944                        { 
     945                                case GTK_RESPONSE_ACCEPT:  
     946                                { 
     947                                        GError *err = NULL; 
     948                                        TnyFolderStore *folderstore = tny_folder_get_folder_store (folder); 
     949 
     950                                        tny_folder_store_remove_folder (folderstore, folder, &err); 
     951 
     952                                        if (err != NULL) 
     953                                        { 
     954                                                GtkWidget *edialog; 
     955 
     956                                                gtk_widget_destroy (dialog); 
     957                                                dialog = NULL; 
     958 
     959                                                edialog = gtk_message_dialog_new ( 
     960                                                                                  GTK_WINDOW (gtk_widget_get_parent (GTK_WIDGET (self))), 
     961                                                                                  GTK_DIALOG_DESTROY_WITH_PARENT, 
     962                                                                                  GTK_MESSAGE_ERROR, 
     963                                                                                  GTK_BUTTONS_CLOSE, 
     964                                                                                  err->message); 
     965                                                g_signal_connect_swapped (edialog, "response", 
     966                                                        G_CALLBACK (gtk_widget_destroy), edialog); 
     967                                                gtk_widget_show_all (edialog); 
     968                                                g_error_free (err); 
     969                                        } 
     970 
     971                                        g_object_unref (G_OBJECT (folderstore)); 
     972                                } 
     973                                break; 
     974 
     975                                default: 
     976                                break; 
     977                        } 
     978 
     979                        if (dialog) 
     980                                gtk_widget_destroy (dialog); 
     981                        g_object_unref (G_OBJECT (folder)); 
     982                } 
     983 
     984        } 
     985} 
     986 
     987static void  
     988on_create_folder_activate (GtkMenuItem *mitem, gpointer user_data) 
     989{ 
     990        TnyDemouiSummaryView *self = user_data; 
     991        TnyDemouiSummaryViewPriv *priv = TNY_DEMOUI_SUMMARY_VIEW_GET_PRIVATE (self); 
     992        GtkTreeIter iter; 
     993        GtkTreeModel *model; 
     994 
     995        if (gtk_tree_selection_get_selected (priv->mailbox_select, &model, &iter)) 
     996        { 
     997                gint type; 
     998 
     999                gtk_tree_model_get (model, &iter,  
     1000                        TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN,  
     1001                        &type, -1); 
     1002 
     1003                if (type != TNY_FOLDER_TYPE_ROOT)  
     1004                {  
     1005                        TnyFolderStore *folderstore; 
     1006                        GtkWidget *dialog, *entry; 
     1007                        gint result; 
     1008 
     1009                        gtk_tree_model_get (model, &iter,  
     1010                                TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,  
     1011                                &folderstore, -1); 
     1012 
     1013                        dialog = gtk_dialog_new_with_buttons (_("Create a folder"), 
     1014                                                                                                  GTK_WINDOW (gtk_widget_get_parent (GTK_WIDGET (self))), 
     1015                                                                                                  GTK_DIALOG_MODAL, 
     1016                                                                                                  GTK_STOCK_OK, 
     1017                                                                                                  GTK_RESPONSE_ACCEPT, 
     1018                                                                                                  GTK_STOCK_CANCEL, 
     1019                                                                                                  GTK_RESPONSE_REJECT, 
     1020                                                                                                  NULL); 
     1021 
    8411022                        entry = gtk_entry_new (); 
    842                         gtk_entry_set_text (GTK_ENTRY (entry), tny_folder_get_name (folder)); 
     1023                        gtk_entry_set_text (GTK_ENTRY (entry), _("New folder")); 
    8431024                        gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), entry); 
    8441025                        gtk_widget_show (entry); 
    …… 
    8521033                                        GError *err = NULL; 
    8531034                                        const gchar *newname = gtk_entry_get_text (GTK_ENTRY (entry)); 
    854                                         tny_folder_set_name (folder, newname, &err); 
     1035 
     1036                                        TnyFolder *created = tny_folder_store_create_folder (folderstore, newname, &err); 
     1037 
     1038                                        if (created) /* Can be NULL on failure */ 
     1039                                                g_object_unref (G_OBJECT (created)); 
    8551040 
    8561041                                        if (err != NULL) 
    …… 
    8811066                        if (dialog) 
    8821067                                gtk_widget_destroy (dialog); 
    883                         g_object_unref (G_OBJECT (folder)); 
    884                 } 
    885  
    886         } 
    887  
    888 } 
    889  
    890 static void  
    891 on_delete_folder_activate (GtkMenuItem *mitem, gpointer user_data) 
    892 { 
    893         TnyDemouiSummaryView *self = user_data; 
    894         TnyDemouiSummaryViewPriv *priv = TNY_DEMOUI_SUMMARY_VIEW_GET_PRIVATE (self); 
    895         GtkTreeIter iter; 
    896         GtkTreeModel *model; 
    897  
    898         if (gtk_tree_selection_get_selected (priv->mailbox_select, &model, &iter)) 
    899         { 
    900                 gint type; 
    901  
    902                 gtk_tree_model_get (model, &iter,  
    903                         TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN,  
    904                         &type, -1); 
    905  
    906                 if (type != TNY_FOLDER_TYPE_ROOT)  
    907                 {  
    908                         TnyFolder *folder; 
    909                         GtkWidget *dialog, *label; 
    910                         gint result; 
    911  
    912                         gtk_tree_model_get (model, &iter,  
    913                                 TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,  
    914                                 &folder, -1); 
    915  
    916                         dialog = gtk_dialog_new_with_buttons (_("Delete a folder"), 
    917                                                                                                   GTK_WINDOW (gtk_widget_get_parent (GTK_WIDGET (self))), 
    918                                                                                                   GTK_DIALOG_MODAL, 
    919                                                                                                   GTK_STOCK_OK, 
    920                                                                                                   GTK_RESPONSE_ACCEPT, 
    921                                                                                                   GTK_STOCK_CANCEL, 
    922                                                                                                   GTK_RESPONSE_REJECT, 
    923                                                                                                   NULL); 
    924  
    925                         label = gtk_label_new (_("Are you sure you want to delete this folder?")); 
    926                         gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), label); 
    927                         gtk_widget_show (label); 
    928  
    929                         result = gtk_dialog_run (GTK_DIALOG (dialog)); 
    930  
    931                         switch (result) 
    932                         { 
    933                                 case GTK_RESPONSE_ACCEPT:  
    934                                 { 
    935                                         GError *err = NULL; 
    936                                         TnyFolderStore *folderstore = tny_folder_get_folder_store (folder); 
    937  
    938                                         tny_folder_store_remove_folder (folderstore, folder, &err); 
    939  
    940                                         if (err != NULL) 
    941                                         { 
    942                                                 GtkWidget *edialog; 
    943  
    944                                                 gtk_widget_destroy (dialog); 
    945                                                 dialog = NULL; 
    946  
    947                                                 edialog = gtk_message_dialog_new ( 
    948                                                                                   GTK_WINDOW (gtk_widget_get_parent (GTK_WIDGET (self))), 
    949                                                                                   GTK_DIALOG_DESTROY_WITH_PARENT, 
    950                                                                                   GTK_MESSAGE_ERROR, 
    951                                                                                   GTK_BUTTONS_CLOSE, 
    952                                                                                   err->message); 
    953                                                 g_signal_connect_swapped (edialog, "response", 
    954                                                         G_CALLBACK (gtk_widget_destroy), edialog); 
    955                                                 gtk_widget_show_all (edialog); 
    956                                                 g_error_free (err); 
    957                                         } 
    958  
    959                                         g_object_unref (G_OBJECT (folderstore)); 
    960                                 } 
    961                                 break; 
    962  
    963                                 default: 
    964                                 break; 
    965                         } 
    966  
    967                         if (dialog) 
    968                                 gtk_widget_destroy (dialog); 
    969                         g_object_unref (G_OBJECT (folder)); 
    970                 } 
    971  
    972         } 
    973 } 
    974  
    975 static void  
    976 on_create_folder_activate (GtkMenuItem *mitem, gpointer user_data) 
    977 { 
    978         TnyDemouiSummaryView *self = user_data; 
    979         TnyDemouiSummaryViewPriv *priv = TNY_DEMOUI_SUMMARY_VIEW_GET_PRIVATE (self); 
    980         GtkTreeIter iter; 
    981         GtkTreeModel *model; 
    982  
    983         if (gtk_tree_selection_get_selected (priv->mailbox_select, &model, &iter)) 
    984         { 
    985                 gint type; 
    986  
    987                 gtk_tree_model_get (model, &iter,  
    988                         TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN,  
    989                         &type, -1); 
    990  
    991                 if (type != TNY_FOLDER_TYPE_ROOT)  
    992                 {  
    993                         TnyFolderStore *folderstore; 
    994                         GtkWidget *dialog, *entry; 
    995                         gint result; 
    996  
    997                         gtk_tree_model_get (model, &iter,  
    998                                 TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,  
    999                                 &folderstore, -1); 
    1000  
    1001                         dialog = gtk_dialog_new_with_buttons (_("Create a folder"), 
    1002                                                                                                   GTK_WINDOW (gtk_widget_get_parent (GTK_WIDGET (self))), 
    1003                                                                                                   GTK_DIALOG_MODAL, 
    1004                                                                                                   GTK_STOCK_OK, 
    1005                                                                                                   GTK_RESPONSE_ACCEPT, 
    1006                                                                                                   GTK_STOCK_CANCEL, 
    1007                                                                                                   GTK_RESPONSE_REJECT, 
    1008                                                                                                   NULL); 
    1009  
    1010                         entry = gtk_entry_new (); 
    1011                         gtk_entry_set_text (GTK_ENTRY (entry), _("New folder")); 
    1012                         gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), entry); 
    1013                         gtk_widget_show (entry); 
    1014  
    1015                         result = gtk_dialog_run (GTK_DIALOG (dialog)); 
    1016  
    1017                         switch (result) 
    1018                         { 
    1019                                 case GTK_RESPONSE_ACCEPT:  
    1020                                 { 
    1021                                         GError *err = NULL; 
    1022                                         const gchar *newname = gtk_entry_get_text (GTK_ENTRY (entry)); 
    1023  
    1024                                         TnyFolder *created = tny_folder_store_create_folder (folderstore, newname, &err); 
    1025  
    1026                                         if (created) /* Can be NULL on failure */ 
    1027                                                 g_object_unref (G_OBJECT (created)); 
    1028  
    1029                                         if (err != NULL) 
    1030                                         { 
    1031                                                 GtkWidget *edialog; 
    1032  
    1033                                                 gtk_widget_destroy (dialog); 
    1034                                                 dialog = NULL; 
    1035  
    1036                                                 edialog = gtk_message_dialog_new ( 
    1037                                                                                   GTK_WINDOW (gtk_widget_get_parent (GTK_WIDGET (self))), 
    1038                                                                                   GTK_DIALOG_DESTROY_WITH_PARENT, 
    1039                                                                                   GTK_MESSAGE_ERROR, 
    1040                                                                                   GTK_BUTTONS_CLOSE, 
    1041                                                                                   err->message); 
    1042                                                 g_signal_connect_swapped (edialog, "response", 
    1043                                                         G_CALLBACK (gtk_widget_destroy), edialog); 
    1044                                                 gtk_widget_show_all (edialog); 
    1045                                                 g_error_free (err); 
    1046                                         } 
    1047                                 } 
    1048                                 break; 
    1049  
    1050                                 default: 
    1051                                 break; 
    1052                         } 
    1053  
    1054                         if (dialog) 
    1055                                 gtk_widget_destroy (dialog); 
    10561068                        g_object_unref (G_OBJECT (folderstore)); 
    10571069                }