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; }
/** * e_source_util_remove: * @source: the #ESource to be removed * @alert_sink: an #EAlertSink * * Requests the D-Bus service to delete the key files for @source and all of * its descendants and broadcast their removal to all clients. If an error * occurs, an #EAlert will be posted to @alert_sink. * * This function does not block. The returned #EActivity can either be * ignored or passed to something that can display activity status to the * user, such as e_shell_backend_add_activity(). * * Returns: an #EActivity to track the operation **/ EActivity * e_source_util_remove (ESource *source, EAlertSink *alert_sink) { AsyncContext *async_context; GCancellable *cancellable; g_return_val_if_fail (E_IS_SOURCE (source), NULL); g_return_val_if_fail (E_IS_ALERT_SINK (alert_sink), NULL); cancellable = g_cancellable_new (); async_context = g_slice_new0 (AsyncContext); async_context->activity = e_activity_new (); e_activity_set_alert_sink (async_context->activity, alert_sink); e_activity_set_cancellable (async_context->activity, cancellable); e_source_remove ( source, cancellable, source_util_remove_cb, async_context); g_object_unref (cancellable); return async_context->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); }
static void action_address_book_refresh_cb (GtkAction *action, EBookShellView *book_shell_view) { EBookShellSidebar *book_shell_sidebar; ESourceSelector *selector; EClient *client = NULL; ESource *source; EActivity *activity; EAlertSink *alert_sink; EShellBackend *shell_backend; EShellContent *shell_content; EShellView *shell_view; EShell *shell; GCancellable *cancellable; book_shell_sidebar = book_shell_view->priv->book_shell_sidebar; selector = e_book_shell_sidebar_get_selector (book_shell_sidebar); shell_view = E_SHELL_VIEW (book_shell_view); shell_backend = e_shell_view_get_shell_backend (shell_view); shell_content = e_shell_view_get_shell_content (shell_view); shell = e_shell_backend_get_shell (shell_backend); source = e_source_selector_ref_primary_selection (selector); if (source != NULL) { client = e_client_selector_ref_cached_client ( E_CLIENT_SELECTOR (selector), source); if (!client) { ESource *primary; e_shell_allow_auth_prompt_for (shell, source); primary = e_source_selector_ref_primary_selection (selector); if (primary == source) e_source_selector_set_primary_selection (selector, source); g_clear_object (&primary); } g_object_unref (source); } if (client == NULL) return; g_return_if_fail (e_client_check_refresh_supported (client)); alert_sink = E_ALERT_SINK (shell_content); activity = e_activity_new (); cancellable = g_cancellable_new (); e_activity_set_alert_sink (activity, alert_sink); e_activity_set_cancellable (activity, cancellable); e_shell_allow_auth_prompt_for (shell, source); e_client_refresh (client, cancellable, address_book_refresh_done_cb, activity); e_shell_backend_add_activity (shell_backend, activity); g_object_unref (cancellable); g_object_unref (client); }
/** * 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; }