void
e_task_shell_view_set_status_message (ETaskShellView *task_shell_view,
const gchar *status_message,
gdouble percent)
{
EActivity *activity;
EShellView *shell_view;
EShellBackend *shell_backend;
g_return_if_fail (E_IS_TASK_SHELL_VIEW (task_shell_view));
activity = task_shell_view->priv->activity;
shell_view = E_SHELL_VIEW (task_shell_view);
shell_backend = e_shell_view_get_shell_backend (shell_view);
if (status_message == NULL || *status_message == '\0') {
if (activity != NULL) {
e_activity_set_state (activity, E_ACTIVITY_COMPLETED);
g_object_unref (activity);
activity = NULL;
}
} else if (activity == NULL) {
activity = e_activity_new ();
e_activity_set_percent (activity, percent);
e_activity_set_text (activity, status_message);
e_shell_backend_add_activity (shell_backend, activity);
} else {
e_activity_set_percent (activity, percent);
e_activity_set_text (activity, status_message);
}
task_shell_view->priv->activity = activity;
}
static void
shell_prepare_for_online (EShell *shell)
{
/* Are preparations already in progress? */
if (shell->priv->preparing_for_line_change != NULL)
return;
shell->priv->preparing_for_line_change = e_activity_new ();
e_activity_set_text (
shell->priv->preparing_for_line_change,
_("Preparing to go online..."));
g_object_add_toggle_ref (
G_OBJECT (shell->priv->preparing_for_line_change),
(GToggleNotify) shell_ready_for_online, shell);
g_object_add_weak_pointer (
G_OBJECT (shell->priv->preparing_for_line_change),
&shell->priv->preparing_for_line_change);
g_signal_emit (
shell, signals[PREPARE_FOR_ONLINE], 0,
shell->priv->preparing_for_line_change);
g_object_unref (shell->priv->preparing_for_line_change);
}
/**
* e_alert_sink_submit_thread_job:
* @alert_sink: an #EAlertSink instance
* @description: user-friendly description of the job, to be shown in UI
* @alert_ident: in case of an error, this alert identificator is used
* for EAlert construction
* @alert_arg_0: (allow-none): in case of an error, use this string as
* the first argument to the EAlert construction; the second argument
* is the actual error message; can be #NULL, in which case only
* the error message is passed to the EAlert construction
* @func: function to be run in a dedicated thread
* @user_data: (allow-none): custom data passed into @func; can be #NULL
* @free_user_data: (allow-none): function to be called on @user_data,
* when the job is over; can be #NULL
*
* Runs the @func in a dedicated thread. Any error is propagated to UI.
* The cancellable passed into the @func is a #CamelOperation, thus
* the caller can overwrite progress and description message on it.
*
* Returns: (transfer full): Newly created #EActivity on success.
* The caller is responsible to g_object_unref() it when done with it.
*
* Note: The @free_user_data, if set, is called in the main thread.
*
* Note: This function should be called only from the main thread.
*
* Since: 3.16
**/
EActivity *
e_alert_sink_submit_thread_job (EAlertSink *alert_sink,
const gchar *description,
const gchar *alert_ident,
const gchar *alert_arg_0,
EAlertSinkThreadJobFunc func,
gpointer user_data,
GDestroyNotify free_user_data)
{
EActivity *activity;
GCancellable *cancellable;
EAlertSinkThreadJobData *job_data;
GThread *thread;
g_return_val_if_fail (E_IS_ALERT_SINK (alert_sink), NULL);
g_return_val_if_fail (description != NULL, NULL);
g_return_val_if_fail (func != NULL, NULL);
activity = e_activity_new ();
cancellable = camel_operation_new ();
e_activity_set_alert_sink (activity, alert_sink);
e_activity_set_cancellable (activity, cancellable);
e_activity_set_text (activity, description);
camel_operation_push_message (cancellable, "%s", description);
job_data = g_new0 (EAlertSinkThreadJobData, 1);
job_data->activity = g_object_ref (activity);
job_data->alert_ident = g_strdup (alert_ident);
job_data->alert_arg_0 = g_strdup (alert_arg_0);
job_data->error = NULL;
job_data->func = func;
job_data->user_data = user_data;
job_data->free_user_data = free_user_data;
thread = g_thread_try_new (G_STRFUNC, e_alert_sink_thread_job, job_data, &job_data->error);
g_object_unref (cancellable);
if (thread) {
g_thread_unref (thread);
} else {
g_prefix_error (&job_data->error, _("Failed to create a thread: "));
g_timeout_add (1, e_alert_sink_thread_job_done_cb, job_data);
}
return activity;
}
static void
shell_prepare_for_quit (EShell *shell)
{
GtkApplication *application;
GList *list, *iter;
/* Are preparations already in progress? */
if (shell->priv->preparing_for_quit != NULL)
return;
application = GTK_APPLICATION (shell);
shell->priv->inhibit_cookie = gtk_application_inhibit (
application, NULL,
GTK_APPLICATION_INHIBIT_SWITCH |
GTK_APPLICATION_INHIBIT_LOGOUT |
GTK_APPLICATION_INHIBIT_SUSPEND,
_("Preparing to quit"));
shell->priv->preparing_for_quit = e_activity_new ();
e_activity_set_text (
shell->priv->preparing_for_quit,
_("Preparing to quit..."));
g_object_add_toggle_ref (
G_OBJECT (shell->priv->preparing_for_quit),
(GToggleNotify) shell_ready_for_quit, shell);
g_object_add_weak_pointer (
G_OBJECT (shell->priv->preparing_for_quit),
&shell->priv->preparing_for_quit);
g_signal_emit (
shell, signals[PREPARE_FOR_QUIT], 0,
shell->priv->preparing_for_quit);
g_object_unref (shell->priv->preparing_for_quit);
/* Desensitize all watched windows to prevent user action. */
list = gtk_application_get_windows (application);
for (iter = list; iter != NULL; iter = iter->next)
gtk_widget_set_sensitive (GTK_WIDGET (iter->data), FALSE);
}
/**
* e_file_replace_contents_async:
* @file: input #GFile
* @contents: string of contents to replace the file with
* @length: the length of @contents in bytes
* @etag: a new entity tag for the @file, or %NULL
* @make_backup: %TRUE if a backup should be created
* @flags: a set of #GFileCreateFlags
* @callback: a #GAsyncReadyCallback to call when the request is satisfied
* @user_data: the data to pass to the callback function
*
* This is a wrapper for g_file_replace_contents_async() that also returns
* an #EActivity to track the file operation. Cancelling the activity will
* cancel the file operation. See g_file_replace_contents_async() for more
* details.
*
* Returns: an #EActivity for the file operation
**/
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)
{
GSimpleAsyncResult *simple;
GCancellable *cancellable;
AsyncContext *context;
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);
if (filename != NULL)
basename = g_filename_display_basename (filename);
else
basename = g_strdup (_("(Unknown 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 ();
context = g_slice_new0 (AsyncContext);
context->activity = e_activity_new ();
e_activity_set_text (context->activity, description);
e_activity_set_cancellable (context->activity, cancellable);
simple = g_simple_async_result_new (
G_OBJECT (file), callback, user_data,
e_file_replace_contents_async);
g_simple_async_result_set_op_res_gpointer (
simple, context, (GDestroyNotify) async_context_free);
g_file_replace_contents_async (
file, contents, length, etag,
make_backup, flags, cancellable,
(GAsyncReadyCallback) file_replace_contents_cb,
simple);
g_object_unref (cancellable);
g_free (description);
g_free (basename);
g_free (filename);
g_free (hostname);
g_free (uri);
return context->activity;
}
