From aa66a17e401d73cbe394ed7f99bf73350e9b938b Mon Sep 17 00:00:00 2001 From: Matthew Barnes Date: Fri, 6 Nov 2009 13:33:55 -0500 Subject: Test drive EIOActivity with a simple asynchronous function. Rename e-fsutils to e-file-utils. This is where we'll add asynchronous functions for common file I/O operations with EActivity integration. Start with e_file_replace_contents_async() (and corresponding finish() function). This is a simple wrapper for g_file_replace_contents_async() which also returns an EActivity. It replaces e_write_file_uri(). Also redesign EIOActivity to -contain- a GAsyncResult rather than implement the interface for itself. This is easier for now but I may change my mind again when I figure out how to tie centralized error reporting into the EActivity framework. --- e-util/Makefile.am | 4 +- e-util/e-file-utils.c | 281 ++++++++++++++++++++++++++++++++++++++++++++++++ e-util/e-file-utils.h | 49 +++++++++ e-util/e-fsutils.c | 158 --------------------------- e-util/e-fsutils.h | 35 ------ e-util/e-io-activity.c | 206 ++++++++++++++++++++++------------- e-util/e-io-activity.h | 12 ++- shell/e-shell-migrate.c | 2 +- 8 files changed, 470 insertions(+), 277 deletions(-) create mode 100644 e-util/e-file-utils.c create mode 100644 e-util/e-file-utils.h delete mode 100644 e-util/e-fsutils.c delete mode 100644 e-util/e-fsutils.h diff --git a/e-util/Makefile.am b/e-util/Makefile.am index bc5e7cd4fc..ecc3220f29 100644 --- a/e-util/Makefile.am +++ b/e-util/Makefile.am @@ -24,8 +24,8 @@ eutilinclude_HEADERS = \ e-dialog-widgets.h \ e-error.h \ e-event.h \ + e-file-utils.h \ e-folder-map.h \ - e-fsutils.h \ e-html-utils.h \ e-icon-factory.h \ e-import.h \ @@ -98,8 +98,8 @@ libeutil_la_SOURCES = \ e-dialog-widgets.c \ e-error.c \ e-event.c \ + e-file-utils.c \ e-folder-map.c \ - e-fsutils.c \ e-html-utils.c \ e-icon-factory.c \ e-import.c \ diff --git a/e-util/e-file-utils.c b/e-util/e-file-utils.c new file mode 100644 index 0000000000..f8adcc7a60 --- /dev/null +++ b/e-util/e-file-utils.c @@ -0,0 +1,281 @@ +/* + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with the program; if not, see + * + * + * Authors: + * Michael Zucchi + * + * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com) + * + */ + +#include + +#include +#include +#include + +/* This isn't as portable as, say, the stuff in GNU coreutils. But I care not for OSF1. */ +#ifdef HAVE_STATVFS +# ifdef HAVE_SYS_STATVFS_H +# include +# endif +#else +#ifdef HAVE_STATFS +# ifdef HAVE_SYS_PARAM_H +# include /* bsd interface */ +# endif +# ifdef HAVE_SYS_MOUNT_H +# include +# endif +#endif +#endif + +#include +#include + +#include +#include +#include + +#include "e-file-utils.h" +#include "e-io-activity.h" + +static void +file_replace_contents_cb (GFile *file, + GAsyncResult *result, + EActivity *activity) +{ + gchar *new_etag; + gboolean success; + GError *error = NULL; + + success = g_file_replace_contents_finish ( + file, result, &new_etag, &error); + + result = e_io_activity_get_async_result (E_IO_ACTIVITY (activity)); + + g_object_set_data_full ( + G_OBJECT (result), + "__new_etag__", new_etag, + (GDestroyNotify) g_free); + + g_simple_async_result_set_op_res_gboolean ( + G_SIMPLE_ASYNC_RESULT (result), success); + + if (error != NULL) { + g_simple_async_result_set_from_error ( + G_SIMPLE_ASYNC_RESULT (result), error); + g_error_free (error); + } + + e_activity_complete (activity); + + g_object_unref (activity); +} + +EActivity * +e_file_replace_contents_async (GFile *file, + const gchar *contents, + gsize length, + const gchar *etag, + gboolean make_backup, + GFileCreateFlags flags, + GAsyncReadyCallback callback, + gpointer user_data) +{ + EActivity *activity; + GSimpleAsyncResult *simple; + GCancellable *cancellable; + const gchar *format; + gchar *description; + gchar *basename; + gchar *filename; + gchar *hostname; + gchar *uri; + + g_return_val_if_fail (G_IS_FILE (file), NULL); + g_return_val_if_fail (contents != NULL, NULL); + + uri = g_file_get_uri (file); + filename = g_filename_from_uri (uri, &hostname, NULL); + basename = g_filename_display_basename (filename); + + if (hostname != NULL) { + /* Translators: The string value is the basename of a file. */ + format = _("Writing \"%s\""); + description = g_strdup_printf (format, basename); + } else { + /* Translators: The first string value is the basename of a + * remote file, the second string value is the hostname. */ + format = _("Writing \"%s\" to %s"); + description = g_strdup_printf (format, basename, hostname); + } + + cancellable = g_cancellable_new (); + + simple = g_simple_async_result_new ( + G_OBJECT (file), callback, user_data, + e_file_replace_contents_async); + + activity = e_io_activity_new ( + description, G_ASYNC_RESULT (simple), cancellable); + + g_file_replace_contents_async ( + file, contents, length, etag, + make_backup, flags, cancellable, + (GAsyncReadyCallback) file_replace_contents_cb, + activity); + + g_object_unref (cancellable); + g_object_unref (simple); + + g_free (description); + g_free (basename); + g_free (filename); + g_free (hostname); + g_free (uri); + + return activity; +} + +gboolean +e_file_replace_contents_finish (GFile *file, + GAsyncResult *result, + gchar **new_etag, + GError **error) +{ + GSimpleAsyncResult *simple; + + g_return_val_if_fail (G_IS_FILE (file), FALSE); + g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE); + + simple = G_SIMPLE_ASYNC_RESULT (result); + + if (g_simple_async_result_propagate_error (simple, error)) + return FALSE; + + if (new_etag != NULL) + *new_etag = g_object_steal_data ( + G_OBJECT (result), "__new_etag__"); + + return TRUE; +} + +/** + * e_fsutils_usage: + * @path: + * + * Calculate the amount of disk space used by a given path. + * + * Return value: The number of 1024 byte blocks used by the + * filesystem. + **/ +glong e_fsutils_usage(const gchar *inpath) +{ + GDir *dir; + const gchar *d; + long size = 0; + GSList *paths; + + /* iterative, depth-first scan, because i can ... */ + paths = g_slist_prepend(NULL, g_strdup(inpath)); + + while (paths) { + gchar *path = paths->data; + + paths = g_slist_remove_link(paths, paths); + + dir = g_dir_open(path, 0, NULL); + if (dir == NULL) { + g_free(path); + goto fail; + } + + while ((d = g_dir_read_name(dir))) { + gchar *full_path; + struct stat st; + + full_path = g_build_filename(path, d, NULL); + if (g_stat(full_path, &st) == -1) { + g_free(full_path); + g_dir_close(dir); + g_free(path); + goto fail; + } else if (S_ISDIR(st.st_mode)) { + paths = g_slist_prepend(paths, full_path); + full_path = NULL; + } else if (S_ISREG(st.st_mode)) { + /* This is in 512 byte blocks. st_blksize is page size on linux, + on *BSD it might be significant. */ +#ifndef G_OS_WIN32 + size += st.st_blocks/2; +#endif + } + + g_free(full_path); + } + + g_dir_close(dir); + g_free(path); + } + + return size; + +fail: + g_slist_foreach(paths, (GFunc)g_free, NULL); + g_slist_free(paths); + + return -1; +} + +/** + * e_fsutils_avail: + * @path: + * + * Find the available disk space at the given path. + * + * Return value: -1 if it could not be determined, otherwise the + * number of disk blocks, expressed as system-independent, 1024 byte + * blocks. + **/ +glong +e_fsutils_avail(const gchar *path) +{ +#if defined(HAVE_STATVFS) + struct statvfs stfs; + + if (statvfs(path, &stfs) == -1) + return -1; + + /* Assumes that frsize === power of 2 */ + if (stfs.f_frsize >= 1024) + return stfs.f_bavail * (stfs.f_frsize / 1024); + else + return stfs.f_bavail / (1024 / stfs.f_frsize); +#elif defined(HAVE_STATFS) + struct statfs stfs; + + if (statfs(path, &stfs) == -1) + return -1; + + /* For BSD this isn't clear, it may be dependent on f_bsize */ + return stfs.f_bavail / 2; +#else + errno = ENOSYS; + return -1; +#endif +} + diff --git a/e-util/e-file-utils.h b/e-util/e-file-utils.h new file mode 100644 index 0000000000..147b9b5b79 --- /dev/null +++ b/e-util/e-file-utils.h @@ -0,0 +1,49 @@ +/* + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with the program; if not, see + * + * + * Authors: + * Michael Zucchi + * + * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com) + * + */ + +#ifndef E_FILE_UTILS_H +#define E_FILE_UTILS_H + +#include +#include + +G_BEGIN_DECLS + +EActivity * e_file_replace_contents_async (GFile *file, + const gchar *contents, + gsize length, + const gchar *etag, + gboolean make_backup, + GFileCreateFlags flags, + GAsyncReadyCallback callback, + gpointer user_data); +gboolean e_file_replace_contents_finish (GFile *file, + GAsyncResult *result, + gchar **new_etag, + GError **error); + +glong e_fsutils_usage (const gchar *path); +glong e_fsutils_avail (const gchar *path); + +G_END_DECLS + +#endif /* E_FILE_UTILS_H */ diff --git a/e-util/e-fsutils.c b/e-util/e-fsutils.c deleted file mode 100644 index c5426f8c81..0000000000 --- a/e-util/e-fsutils.c +++ /dev/null @@ -1,158 +0,0 @@ -/* - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) version 3. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with the program; if not, see - * - * - * Authors: - * Michael Zucchi - * - * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com) - * - */ - -#include - -#include -#include -#include - -/* This isn't as portable as, say, the stuff in GNU coreutils. But I care not for OSF1. */ -#ifdef HAVE_STATVFS -# ifdef HAVE_SYS_STATVFS_H -# include -# endif -#else -#ifdef HAVE_STATFS -# ifdef HAVE_SYS_PARAM_H -# include /* bsd interface */ -# endif -# ifdef HAVE_SYS_MOUNT_H -# include -# endif -#endif -#endif - -#include -#include - -#include -#include - -#include "e-fsutils.h" - -/** - * e_fsutils_usage: - * @path: - * - * Calculate the amount of disk space used by a given path. - * - * Return value: The number of 1024 byte blocks used by the - * filesystem. - **/ -glong e_fsutils_usage(const gchar *inpath) -{ - GDir *dir; - const gchar *d; - long size = 0; - GSList *paths; - - /* iterative, depth-first scan, because i can ... */ - paths = g_slist_prepend(NULL, g_strdup(inpath)); - - while (paths) { - gchar *path = paths->data; - - paths = g_slist_remove_link(paths, paths); - - dir = g_dir_open(path, 0, NULL); - if (dir == NULL) { - g_free(path); - goto fail; - } - - while ((d = g_dir_read_name(dir))) { - gchar *full_path; - struct stat st; - - full_path = g_build_filename(path, d, NULL); - if (g_stat(full_path, &st) == -1) { - g_free(full_path); - g_dir_close(dir); - g_free(path); - goto fail; - } else if (S_ISDIR(st.st_mode)) { - paths = g_slist_prepend(paths, full_path); - full_path = NULL; - } else if (S_ISREG(st.st_mode)) { - /* This is in 512 byte blocks. st_blksize is page size on linux, - on *BSD it might be significant. */ -#ifndef G_OS_WIN32 - size += st.st_blocks/2; -#endif - } - - g_free(full_path); - } - - g_dir_close(dir); - g_free(path); - } - - return size; - -fail: - g_slist_foreach(paths, (GFunc)g_free, NULL); - g_slist_free(paths); - - return -1; -} - -/** - * e_fsutils_avail: - * @path: - * - * Find the available disk space at the given path. - * - * Return value: -1 if it could not be determined, otherwise the - * number of disk blocks, expressed as system-independent, 1024 byte - * blocks. - **/ -glong -e_fsutils_avail(const gchar *path) -{ -#if defined(HAVE_STATVFS) - struct statvfs stfs; - - if (statvfs(path, &stfs) == -1) - return -1; - - /* Assumes that frsize === power of 2 */ - if (stfs.f_frsize >= 1024) - return stfs.f_bavail * (stfs.f_frsize / 1024); - else - return stfs.f_bavail / (1024 / stfs.f_frsize); -#elif defined(HAVE_STATFS) - struct statfs stfs; - - if (statfs(path, &stfs) == -1) - return -1; - - /* For BSD this isn't clear, it may be dependent on f_bsize */ - return stfs.f_bavail / 2; -#else - errno = ENOSYS; - return -1; -#endif -} - diff --git a/e-util/e-fsutils.h b/e-util/e-fsutils.h deleted file mode 100644 index 6143e487ab..0000000000 --- a/e-util/e-fsutils.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) version 3. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with the program; if not, see - * - * - * Authors: - * Michael Zucchi - * - * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com) - * - */ - -#ifndef E_FSUTILS_H -#define E_FSUTILS_H - -#include - -G_BEGIN_DECLS - -glong e_fsutils_usage(const gchar *path); -glong e_fsutils_avail(const gchar *path); - -G_END_DECLS - -#endif /* !E_FOLDER_MAP_H */ diff --git a/e-util/e-io-activity.c b/e-util/e-io-activity.c index 086ee10529..9569e42914 100644 --- a/e-util/e-io-activity.c +++ b/e-util/e-io-activity.c @@ -26,19 +26,41 @@ ((obj), E_TYPE_IO_ACTIVITY, EIOActivityPrivate)) struct _EIOActivityPrivate { - GObject *source_object; + GAsyncResult *async_result; GCancellable *cancellable; - GAsyncReadyCallback callback; - gpointer user_data; }; enum { PROP_0, + PROP_ASYNC_RESULT, PROP_CANCELLABLE }; static gpointer parent_class; +static void +io_activity_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (property_id) { + case PROP_ASYNC_RESULT: + e_io_activity_set_async_result ( + E_IO_ACTIVITY (object), + g_value_get_object (value)); + return; + + case PROP_CANCELLABLE: + e_io_activity_set_cancellable ( + E_IO_ACTIVITY (object), + g_value_get_object (value)); + return; + } + + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); +} + static void io_activity_get_property (GObject *object, guint property_id, @@ -46,6 +68,12 @@ io_activity_get_property (GObject *object, GParamSpec *pspec) { switch (property_id) { + case PROP_ASYNC_RESULT: + g_value_set_object ( + value, e_io_activity_get_async_result ( + E_IO_ACTIVITY (object))); + return; + case PROP_CANCELLABLE: g_value_set_object ( value, e_io_activity_get_cancellable ( @@ -63,9 +91,9 @@ io_activity_dispose (GObject *object) priv = E_IO_ACTIVITY_GET_PRIVATE (object); - if (priv->source_object != NULL) { - g_object_unref (priv->source_object); - priv->source_object = NULL; + if (priv->async_result != NULL) { + g_object_unref (priv->async_result); + priv->async_result = NULL; } if (priv->cancellable != NULL) { @@ -80,55 +108,37 @@ io_activity_dispose (GObject *object) static void io_activity_cancelled (EActivity *activity) { - EIOActivityPrivate *priv; - - priv = E_IO_ACTIVITY_GET_PRIVATE (activity); + EIOActivity *io_activity; + GCancellable *cancellable; /* Chain up to parent's cancelled() method. */ E_ACTIVITY_CLASS (parent_class)->cancelled (activity); - g_cancellable_cancel (priv->cancellable); + io_activity = E_IO_ACTIVITY (activity); + cancellable = e_io_activity_get_cancellable (io_activity); + + if (cancellable != NULL) + g_cancellable_cancel (cancellable); } static void io_activity_completed (EActivity *activity) { - EIOActivityPrivate *priv; - - priv = E_IO_ACTIVITY_GET_PRIVATE (activity); + EIOActivity *io_activity; + GAsyncResult *async_result; /* Chain up to parent's completed() method. */ E_ACTIVITY_CLASS (parent_class)->completed (activity); - /* Clear the function pointer after invoking it - * to guarantee it will not be invoked again. */ - if (priv->callback != NULL) { - priv->callback ( - priv->source_object, - G_ASYNC_RESULT (activity), - priv->user_data); - priv->callback = NULL; - } -} - -static gpointer -io_activity_get_user_data (GAsyncResult *async_result) -{ - EIOActivityPrivate *priv; + io_activity = E_IO_ACTIVITY (activity); + async_result = e_io_activity_get_async_result (io_activity); - priv = E_IO_ACTIVITY_GET_PRIVATE (async_result); - - return priv->user_data; -} - -static GObject * -io_activity_get_source_object (GAsyncResult *async_result) -{ - EIOActivityPrivate *priv; - - priv = E_IO_ACTIVITY_GET_PRIVATE (async_result); - - return priv->source_object; + /* We know how to invoke a GSimpleAsyncResult. For any other + * type of GAsyncResult the caller will have to take measures + * to invoke it himself. */ + if (G_IS_SIMPLE_ASYNC_RESULT (async_result)) + g_simple_async_result_complete ( + G_SIMPLE_ASYNC_RESULT (async_result)); } static void @@ -141,6 +151,7 @@ io_activity_class_init (EIOActivityClass *class) g_type_class_add_private (class, sizeof (EIOActivityPrivate)); object_class = G_OBJECT_CLASS (class); + object_class->set_property = io_activity_set_property; object_class->get_property = io_activity_get_property; object_class->dispose = io_activity_dispose; @@ -148,6 +159,17 @@ io_activity_class_init (EIOActivityClass *class) activity_class->cancelled = io_activity_cancelled; activity_class->completed = io_activity_completed; + g_object_class_install_property ( + object_class, + PROP_ASYNC_RESULT, + g_param_spec_object ( + "async-result", + "Asynchronous Result", + NULL, + G_TYPE_ASYNC_RESULT, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT)); + g_object_class_install_property ( object_class, PROP_CANCELLABLE, @@ -156,22 +178,14 @@ io_activity_class_init (EIOActivityClass *class) "Cancellable", NULL, G_TYPE_CANCELLABLE, - G_PARAM_READABLE)); -} - -static void -io_activity_iface_init (GAsyncResultIface *iface) -{ - iface->get_user_data = io_activity_get_user_data; - iface->get_source_object = io_activity_get_source_object; + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT)); } static void io_activity_init (EIOActivity *io_activity) { io_activity->priv = E_IO_ACTIVITY_GET_PRIVATE (io_activity); - - io_activity->priv->cancellable = g_cancellable_new (); } GType @@ -193,45 +207,57 @@ e_io_activity_get_type (void) NULL /* value_table */ }; - static const GInterfaceInfo iface_info = { - (GInterfaceInitFunc) io_activity_iface_init, - (GInterfaceFinalizeFunc) NULL, - NULL /* interface_data */ - }; - type = g_type_register_static ( E_TYPE_ACTIVITY, "EIOActivity", &type_info, 0); - - g_type_add_interface_static ( - type, G_TYPE_ASYNC_RESULT, &iface_info); } return type; } EActivity * -e_io_activity_new (GObject *source_object, - const gchar *primary_text, - GAsyncReadyCallback callback, - gpointer user_data) +e_io_activity_new (const gchar *primary_text, + GAsyncResult *async_result, + GCancellable *cancellable) { - EActivity *activity; - EIOActivityPrivate *priv; - - g_return_val_if_fail (G_IS_OBJECT (source_object), NULL); g_return_val_if_fail (primary_text != NULL, NULL); - g_return_val_if_fail (callback != NULL, NULL); - activity = g_object_new ( - E_TYPE_IO_ACTIVITY, "primary-text", primary_text, NULL); + if (async_result != NULL) + g_return_val_if_fail (G_IS_ASYNC_RESULT (async_result), NULL); - /* XXX Should these be construct properties? */ - priv = E_IO_ACTIVITY_GET_PRIVATE (activity); - priv->source_object = g_object_ref (source_object); - priv->callback = callback; - priv->user_data = user_data; + if (cancellable != NULL) + g_return_val_if_fail (G_IS_CANCELLABLE (cancellable), NULL); - return activity; + return g_object_new ( + E_TYPE_IO_ACTIVITY, + "async-result", async_result, "cancellable", + cancellable, "primary-text", primary_text, NULL); +} + +GAsyncResult * +e_io_activity_get_async_result (EIOActivity *io_activity) +{ + g_return_val_if_fail (E_IS_IO_ACTIVITY (io_activity), NULL); + + return io_activity->priv->async_result; +} + +void +e_io_activity_set_async_result (EIOActivity *io_activity, + GAsyncResult *async_result) +{ + g_return_if_fail (E_IS_IO_ACTIVITY (io_activity)); + + if (async_result != NULL) { + g_return_if_fail (G_IS_ASYNC_RESULT (async_result)); + g_object_ref (async_result); + } + + if (io_activity->priv->async_result != NULL) + g_object_unref (io_activity->priv->async_result); + + io_activity->priv->async_result = async_result; + + g_object_notify (G_OBJECT (io_activity), "async-result"); } GCancellable * @@ -241,3 +267,29 @@ e_io_activity_get_cancellable (EIOActivity *io_activity) return io_activity->priv->cancellable; } + +void +e_io_activity_set_cancellable (EIOActivity *io_activity, + GCancellable *cancellable) +{ + g_return_if_fail (E_IS_IO_ACTIVITY (io_activity)); + + if (cancellable != NULL) { + g_return_if_fail (G_IS_CANCELLABLE (cancellable)); + g_object_ref (cancellable); + } + + if (io_activity->priv->cancellable != NULL) + g_object_unref (io_activity->priv->cancellable); + + io_activity->priv->cancellable = cancellable; + + g_object_freeze_notify (G_OBJECT (io_activity)); + + e_activity_set_allow_cancel ( + E_ACTIVITY (io_activity), (cancellable != NULL)); + + g_object_notify (G_OBJECT (io_activity), "cancellable"); + + g_object_thaw_notify (G_OBJECT (io_activity)); +} diff --git a/e-util/e-io-activity.h b/e-util/e-io-activity.h index c94953af3e..773417472d 100644 --- a/e-util/e-io-activity.h +++ b/e-util/e-io-activity.h @@ -60,11 +60,15 @@ struct _EIOActivityClass { }; GType e_io_activity_get_type (void); -EActivity * e_io_activity_new (GObject *source_object, - const gchar *primary_text, - GAsyncReadyCallback callback, - gpointer user_data); +EActivity * e_io_activity_new (const gchar *primary_text, + GAsyncResult *async_result, + GCancellable *cancellable); +GAsyncResult * e_io_activity_get_async_result (EIOActivity *io_activity); +void e_io_activity_set_async_result (EIOActivity *io_activity, + GAsyncResult *async_result); GCancellable * e_io_activity_get_cancellable (EIOActivity *io_activity); +void e_io_activity_set_cancellable (EIOActivity *io_activity, + GCancellable *cancellable); G_END_DECLS diff --git a/shell/e-shell-migrate.c b/shell/e-shell-migrate.c index a330d9d1a5..d7c8312a86 100644 --- a/shell/e-shell-migrate.c +++ b/shell/e-shell-migrate.c @@ -29,7 +29,7 @@ #include "e-util/e-bconf-map.h" #include "e-util/e-error.h" -#include "e-util/e-fsutils.h" +#include "e-util/e-file-utils.h" #include "e-util/e-util.h" #include "es-event.h" -- cgit