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; }