diff options
Diffstat (limited to 'src/gs-shell.c')
| -rw-r--r-- | src/gs-shell.c | 2725 |
1 files changed, 2725 insertions, 0 deletions
diff --git a/src/gs-shell.c b/src/gs-shell.c new file mode 100644 index 0000000..91946ee --- /dev/null +++ b/src/gs-shell.c @@ -0,0 +1,2725 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- + * vi:set noexpandtab tabstop=8 shiftwidth=8: + * + * Copyright (C) 2013-2017 Richard Hughes <richard@hughsie.com> + * Copyright (C) 2013 Matthias Clasen <mclasen@redhat.com> + * Copyright (C) 2014-2020 Kalev Lember <klember@redhat.com> + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include "config.h" + +#include <adwaita.h> +#include <malloc.h> +#include <string.h> +#include <glib/gi18n.h> + +#ifdef HAVE_MOGWAI +#include <libmogwai-schedule-client/scheduler.h> +#endif + +#include "gs-common.h" +#include "gs-shell.h" +#include "gs-basic-auth-dialog.h" +#include "gs-details-page.h" +#include "gs-installed-page.h" +#include "gs-metered-data-dialog.h" +#include "gs-moderate-page.h" +#include "gs-loading-page.h" +#include "gs-search-page.h" +#include "gs-overview-page.h" +#include "gs-updates-page.h" +#include "gs-category-page.h" +#include "gs-extras-page.h" +#include "gs-repos-dialog.h" +#include "gs-prefs-dialog.h" +#include "gs-update-dialog.h" +#include "gs-update-monitor.h" +#include "gs-utils.h" + +#define NARROW_WIDTH_THRESHOLD 800 + +static const gchar *page_name[] = { + "unknown", + "overview", + "installed", + "search", + "updates", + "details", + "category", + "extras", + "moderate", + "loading", +}; + +typedef struct { + GsShellMode mode; + GtkWidget *focus; + GsCategory *category; + gchar *search; + GsApp *app; + gdouble vscroll_position; +} BackEntry; + +struct _GsShell +{ + AdwApplicationWindow parent_object; + + GSettings *settings; + GCancellable *cancellable; + GsPluginLoader *plugin_loader; + GtkWidget *header_start_widget; + GtkWidget *header_end_widget; + GQueue *back_entry_stack; + GPtrArray *modal_dialogs; + gchar *events_info_uri; + AdwLeaflet *main_leaflet; + AdwLeaflet *details_leaflet; + AdwViewStack *stack_loading; + AdwViewStack *stack_main; + AdwViewStack *stack_sub; + GsPage *page; + + GBinding *sub_page_header_title_binding; + +#ifdef HAVE_MOGWAI + MwscScheduler *scheduler; + gboolean scheduler_held; + gulong scheduler_invalidated_handler; +#endif /* HAVE_MOGWAI */ + + GtkWidget *main_header; + GtkWidget *details_header; + GtkWidget *metered_updates_bar; + GtkWidget *search_button; + GtkWidget *entry_search; + GtkWidget *search_bar; + GtkWidget *button_back; + GtkWidget *button_back2; + GtkWidget *notification_event; + GtkWidget *button_events_sources; + GtkWidget *button_events_no_space; + GtkWidget *button_events_network_settings; + GtkWidget *button_events_restart_required; + GtkWidget *button_events_more_info; + GtkWidget *button_events_dismiss; + GtkWidget *label_events; + GtkWidget *primary_menu; + GtkWidget *sub_page_header_title; + + gboolean activate_after_setup; + gboolean is_narrow; + gint allocation_width; + guint allocation_changed_cb_id; + + GsPage *pages[GS_SHELL_MODE_LAST]; +}; + +G_DEFINE_TYPE (GsShell, gs_shell, ADW_TYPE_APPLICATION_WINDOW) + +typedef enum { + PROP_IS_NARROW = 1, + PROP_ALLOCATION_WIDTH, +} GsShellProperty; + +enum { + SIGNAL_LOADED, + SIGNAL_LAST +}; + +static GParamSpec *obj_props[PROP_ALLOCATION_WIDTH + 1] = { NULL, }; + +static guint signals [SIGNAL_LAST] = { 0 }; + +static void +modal_dialog_unmapped_cb (GtkWidget *dialog, + GsShell *shell) +{ + g_debug ("modal dialog %p unmapped", dialog); + g_ptr_array_remove (shell->modal_dialogs, dialog); +} + +void +gs_shell_modal_dialog_present (GsShell *shell, GtkWindow *window) +{ + GtkWindow *parent; + + /* show new modal on top of old modal */ + if (shell->modal_dialogs->len > 0) { + parent = g_ptr_array_index (shell->modal_dialogs, + shell->modal_dialogs->len - 1); + g_debug ("using old modal %p as parent", parent); + } else { + parent = GTK_WINDOW (shell); + g_debug ("using main window"); + } + gtk_window_set_transient_for (window, parent); + + /* add to stack, transfer ownership to here */ + g_ptr_array_add (shell->modal_dialogs, window); + g_signal_connect (GTK_WIDGET (window), "unmap", + G_CALLBACK (modal_dialog_unmapped_cb), shell); + + /* present the new one */ + gtk_window_set_modal (window, TRUE); + gtk_window_present (window); +} + +void +gs_shell_activate (GsShell *shell) +{ + /* Waiting for plugin loader to setup first */ + if (shell->plugin_loader == NULL) { + shell->activate_after_setup = TRUE; + return; + } + + gtk_widget_show (GTK_WIDGET (shell)); + gtk_window_present (GTK_WINDOW (shell)); +} + +static void +gs_shell_set_header_start_widget (GsShell *shell, GtkWidget *widget) +{ + GtkWidget *old_widget; + + old_widget = shell->header_start_widget; + + if (shell->header_start_widget == widget) + return; + + if (widget != NULL) { + g_object_ref (widget); + adw_header_bar_pack_start (ADW_HEADER_BAR (shell->main_header), widget); + } + + shell->header_start_widget = widget; + + if (old_widget != NULL) { + adw_header_bar_remove (ADW_HEADER_BAR (shell->main_header), old_widget); + g_object_unref (old_widget); + } +} + +static void +gs_shell_set_header_end_widget (GsShell *shell, GtkWidget *widget) +{ + GtkWidget *old_widget; + + old_widget = shell->header_end_widget; + + if (shell->header_end_widget == widget) + return; + + if (widget != NULL) { + g_object_ref (widget); + adw_header_bar_pack_end (ADW_HEADER_BAR (shell->main_header), widget); + } + + shell->header_end_widget = widget; + + if (old_widget != NULL) { + adw_header_bar_remove (ADW_HEADER_BAR (shell->main_header), old_widget); + g_object_unref (old_widget); + } +} + +static void +gs_shell_refresh_auto_updates_ui (GsShell *shell) +{ + gboolean automatic_updates_paused; + gboolean automatic_updates_enabled; + + automatic_updates_enabled = g_settings_get_boolean (shell->settings, "download-updates"); + +#ifdef HAVE_MOGWAI + automatic_updates_paused = (shell->scheduler == NULL || !mwsc_scheduler_get_allow_downloads (shell->scheduler)); +#else + automatic_updates_paused = gs_plugin_loader_get_network_metered (shell->plugin_loader); +#endif + + gtk_info_bar_set_revealed (GTK_INFO_BAR (shell->metered_updates_bar), + gs_shell_get_mode (shell) != GS_SHELL_MODE_LOADING && + automatic_updates_enabled && + automatic_updates_paused); + gtk_info_bar_set_default_response (GTK_INFO_BAR (shell->metered_updates_bar), GTK_RESPONSE_OK); +} + +static void +gs_shell_metered_updates_bar_response_cb (GtkInfoBar *info_bar, + gint response_id, + gpointer user_data) +{ + GsShell *shell = GS_SHELL (user_data); + GtkWidget *dialog; + + dialog = gs_metered_data_dialog_new (GTK_WINDOW (shell)); + gs_shell_modal_dialog_present (shell, GTK_WINDOW (dialog)); +} + +static void +gs_shell_download_updates_changed_cb (GSettings *settings, + const gchar *key, + gpointer user_data) +{ + GsShell *shell = user_data; + + gs_shell_refresh_auto_updates_ui (shell); +} + +static void +gs_shell_network_metered_notify_cb (GsPluginLoader *plugin_loader, + GParamSpec *pspec, + gpointer user_data) +{ +#ifndef HAVE_MOGWAI + GsShell *shell = user_data; + + /* @automatic_updates_paused only depends on network-metered if we’re + * compiled without Mogwai. */ + gs_shell_refresh_auto_updates_ui (shell); +#endif +} + +#ifdef HAVE_MOGWAI +static void +scheduler_invalidated_cb (GsShell *shell) +{ + /* The scheduler shouldn’t normally be invalidated, since we Hold() it + * until we’re done with it. However, if the scheduler is stopped by + * systemd (`systemctl stop mogwai-scheduled`) this signal will be + * emitted. It may also be invalidated while our main window is hidden, + * as we release our Hold() then. */ + g_signal_handler_disconnect (shell->scheduler, + shell->scheduler_invalidated_handler); + shell->scheduler_invalidated_handler = 0; + shell->scheduler_held = FALSE; + + g_clear_object (&shell->scheduler); +} + +static void +scheduler_allow_downloads_changed_cb (GsShell *shell) +{ + gs_shell_refresh_auto_updates_ui (shell); +} + +static void +scheduler_hold_cb (GObject *source_object, + GAsyncResult *result, + gpointer data) +{ + g_autoptr(GError) error_local = NULL; + MwscScheduler *scheduler = (MwscScheduler *) source_object; + g_autoptr(GsShell) shell = data; /* reference added when starting the async operation */ + + if (mwsc_scheduler_hold_finish (scheduler, result, &error_local)) { + shell->scheduler_held = TRUE; + } else if (!g_error_matches (error_local, G_DBUS_ERROR, G_DBUS_ERROR_FAILED)) { + g_warning ("Couldn't hold the Mogwai Scheduler daemon: %s", + error_local->message); + } + + g_clear_error (&error_local); + + shell->scheduler_invalidated_handler = + g_signal_connect_swapped (scheduler, "invalidated", + (GCallback) scheduler_invalidated_cb, + shell); + + g_signal_connect_object (scheduler, "notify::allow-downloads", + (GCallback) scheduler_allow_downloads_changed_cb, + shell, + G_CONNECT_SWAPPED); + + g_assert (shell->scheduler == NULL); + shell->scheduler = scheduler; + + /* Update the UI accordingly. */ + gs_shell_refresh_auto_updates_ui (shell); +} + +static void +scheduler_release_cb (GObject *source_object, + GAsyncResult *result, + gpointer data) +{ + MwscScheduler *scheduler = (MwscScheduler *) source_object; + g_autoptr(GsShell) shell = data; /* reference added when starting the async operation */ + g_autoptr(GError) error_local = NULL; + + if (!mwsc_scheduler_release_finish (scheduler, result, &error_local)) + g_warning ("Couldn't release the Mogwai Scheduler daemon: %s", + error_local->message); + + shell->scheduler_held = FALSE; + g_clear_object (&shell->scheduler); +} + +static void +scheduler_ready_cb (GObject *source_object, + GAsyncResult *result, + gpointer data) +{ + MwscScheduler *scheduler; + g_autoptr(GError) error_local = NULL; + g_autoptr(GsShell) shell = data; /* reference added when starting the async operation */ + + scheduler = mwsc_scheduler_new_finish (result, &error_local); + + if (scheduler == NULL) { + g_warning ("%s: Error getting Mogwai Scheduler: %s", G_STRFUNC, + error_local->message); + return; + } + + mwsc_scheduler_hold_async (scheduler, + "monitoring allow-downloads property", + NULL, + scheduler_hold_cb, + g_object_ref (shell)); +} +#endif /* HAVE_MOGWAI */ + +static void +gs_shell_basic_auth_start_cb (GsPluginLoader *plugin_loader, + const gchar *remote, + const gchar *realm, + GsBasicAuthCallback callback, + gpointer callback_data, + GsShell *shell) +{ + GtkWidget *dialog; + + dialog = gs_basic_auth_dialog_new (GTK_WINDOW (shell), remote, realm, callback, callback_data); + gs_shell_modal_dialog_present (shell, GTK_WINDOW (dialog)); + + /* just destroy */ + g_signal_connect_swapped (dialog, "response", + G_CALLBACK (gtk_window_destroy), dialog); +} + +static gboolean +gs_shell_ask_untrusted_cb (GsPluginLoader *plugin_loader, + const gchar *title, + const gchar *msg, + const gchar *details, + const gchar *accept_label, + GsShell *shell) +{ + return gs_utils_ask_user_accepts (GTK_WINDOW (shell), title, msg, details, accept_label); +} + +static void +free_back_entry (BackEntry *entry) +{ + if (entry->focus != NULL) + g_object_remove_weak_pointer (G_OBJECT (entry->focus), + (gpointer *) &entry->focus); + g_clear_object (&entry->category); + g_clear_object (&entry->app); + g_free (entry->search); + g_free (entry); +} + +static void +gs_shell_clean_back_entry_stack (GsShell *shell) +{ + BackEntry *entry; + + while ((entry = g_queue_pop_head (shell->back_entry_stack)) != NULL) { + free_back_entry (entry); + } +} + +static gboolean +gs_shell_get_mode_is_main (GsShellMode mode) +{ + switch (mode) { + case GS_SHELL_MODE_OVERVIEW: + case GS_SHELL_MODE_INSTALLED: + case GS_SHELL_MODE_SEARCH: + case GS_SHELL_MODE_UPDATES: + case GS_SHELL_MODE_LOADING: + return TRUE; + case GS_SHELL_MODE_DETAILS: + case GS_SHELL_MODE_CATEGORY: + case GS_SHELL_MODE_EXTRAS: + case GS_SHELL_MODE_MODERATE: + return FALSE; + default: + return TRUE; + } +} + +static void search_bar_search_mode_enabled_changed_cb (GtkSearchBar *search_bar, + GParamSpec *pspec, + GsShell *shell); +static void gs_overview_page_button_cb (GtkWidget *widget, GsShell *shell); + +static void +update_header_widgets (GsShell *shell) +{ + GsShellMode mode = gs_shell_get_mode (shell); + + /* only show the search button in overview and search pages */ + g_signal_handlers_block_by_func (shell->search_bar, search_bar_search_mode_enabled_changed_cb, shell); + + /* hide unless we're going to search */ + gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (shell->search_bar), + mode == GS_SHELL_MODE_SEARCH); + + g_signal_handlers_unblock_by_func (shell->search_bar, search_bar_search_mode_enabled_changed_cb, shell); +} + +static void +stack_notify_visible_child_cb (GObject *object, + GParamSpec *pspec, + gpointer user_data) +{ + GsShell *shell = GS_SHELL (user_data); + GsPage *page; + GtkWidget *widget; + GsShellMode mode = gs_shell_get_mode (shell); + gsize i; + + update_header_widgets (shell); + + /* do action for mode */ + page = shell->pages[mode]; + + if (mode == GS_SHELL_MODE_OVERVIEW || + mode == GS_SHELL_MODE_INSTALLED || + mode == GS_SHELL_MODE_UPDATES) + gs_shell_clean_back_entry_stack (shell); + + if (shell->page != NULL) + gs_page_switch_from (shell->page); + g_set_object (&shell->page, page); + gs_page_switch_to (page); + + /* update header bar widgets */ + switch (mode) { + case GS_SHELL_MODE_OVERVIEW: + case GS_SHELL_MODE_INSTALLED: + case GS_SHELL_MODE_SEARCH: + gtk_widget_show (shell->search_button); + break; + case GS_SHELL_MODE_UPDATES: + gtk_widget_hide (shell->search_button); + break; + default: + /* We don't care about changing the visibility of the search + * button in modes appearing in sub-pages. */ + break; + } + + widget = gs_page_get_header_start_widget (page); + switch (mode) { + case GS_SHELL_MODE_OVERVIEW: + case GS_SHELL_MODE_INSTALLED: + case GS_SHELL_MODE_UPDATES: + case GS_SHELL_MODE_SEARCH: + gs_shell_set_header_start_widget (shell, widget); + break; + default: + g_assert (widget == NULL); + break; + } + + widget = gs_page_get_header_end_widget (page); + switch (mode) { + case GS_SHELL_MODE_OVERVIEW: + case GS_SHELL_MODE_INSTALLED: + case GS_SHELL_MODE_UPDATES: + case GS_SHELL_MODE_SEARCH: + gs_shell_set_header_end_widget (shell, widget); + break; + default: + g_assert (widget == NULL); + break; + } + + g_clear_object (&shell->sub_page_header_title_binding); + shell->sub_page_header_title_binding = g_object_bind_property (adw_view_stack_get_visible_child (shell->stack_sub), "title", + shell->sub_page_header_title, "label", + G_BINDING_SYNC_CREATE); + + /* refresh the updates bar when moving out of the loading mode, but only + * if the Mogwai scheduler state is already known, to avoid spuriously + * showing the updates bar */ +#ifdef HAVE_MOGWAI + if (shell->scheduler != NULL) +#else + if (TRUE) +#endif + gs_shell_refresh_auto_updates_ui (shell); + + /* destroy any existing modals */ + if (shell->modal_dialogs != NULL) { + /* block signal emission of 'unmapped' since that will + * call g_ptr_array_remove_index. The unmapped signal may + * be emitted whilst running unref handlers for + * g_ptr_array_set_size */ + for (i = 0; i < shell->modal_dialogs->len; ++i) { + GtkWidget *dialog = g_ptr_array_index (shell->modal_dialogs, i); + g_signal_handlers_disconnect_by_func (dialog, + modal_dialog_unmapped_cb, + shell); + gtk_window_destroy (GTK_WINDOW (dialog)); + } + g_ptr_array_set_size (shell->modal_dialogs, 0); + } +} + +void +gs_shell_change_mode (GsShell *shell, + GsShellMode mode, + gpointer data, + gboolean scroll_up) +{ + GsApp *app; + GsPage *page; + gboolean mode_is_main = gs_shell_get_mode_is_main (mode); + + if (gs_shell_get_mode (shell) == mode && + (mode != GS_SHELL_MODE_DETAILS || + data == gs_details_page_get_app (GS_DETAILS_PAGE (shell->pages[mode])))) { + return; + } + + /* switch page */ + if (mode == GS_SHELL_MODE_LOADING) { + adw_view_stack_set_visible_child_name (shell->stack_loading, "loading"); + return; + } + + adw_view_stack_set_visible_child_name (shell->stack_loading, "main"); + if (mode == GS_SHELL_MODE_DETAILS) { + adw_leaflet_set_visible_child_name (shell->details_leaflet, "details"); + } else { + adw_leaflet_set_visible_child_name (shell->details_leaflet, "main"); + /* We only change the main leaflet when not reaching the details + * page to preserve the navigation history in the UI's state. + * First change the page, then the leaflet, to avoid load of + * the previously shown page, which will be changed shortly after. */ + adw_view_stack_set_visible_child_name (mode_is_main ? shell->stack_main : shell->stack_sub, page_name[mode]); + adw_leaflet_set_visible_child_name (shell->main_leaflet, mode_is_main ? "main" : "sub"); + } + + /* do any mode-specific actions */ + page = shell->pages[mode]; + + if (mode == GS_SHELL_MODE_SEARCH) { + gs_search_page_set_text (GS_SEARCH_PAGE (page), data); + gtk_editable_set_text (GTK_EDITABLE (shell->entry_search), data); + gtk_editable_set_position (GTK_EDITABLE (shell->entry_search), -1); + } else if (mode == GS_SHELL_MODE_DETAILS) { + app = GS_APP (data); + if (gs_app_get_metadata_item (app, "GnomeSoftware::show-metainfo") != NULL) { + gs_details_page_set_metainfo (GS_DETAILS_PAGE (page), + gs_app_get_local_file (app)); + } else if (gs_app_get_local_file (app) != NULL) { + gs_details_page_set_local_file (GS_DETAILS_PAGE (page), + gs_app_get_local_file (app)); + } else if (gs_app_get_metadata_item (app, "GnomeSoftware::from-url") != NULL) { + gs_details_page_set_url (GS_DETAILS_PAGE (page), + gs_app_get_metadata_item (app, "GnomeSoftware::from-url")); + } else { + gs_details_page_set_app (GS_DETAILS_PAGE (page), data); + } + } else if (mode == GS_SHELL_MODE_CATEGORY) { + gs_category_page_set_category (GS_CATEGORY_PAGE (page), + GS_CATEGORY (data)); + } + + if (scroll_up) + gs_page_scroll_up (page); +} + +static gboolean +overlay_get_child_position_cb (GtkOverlay *overlay, + GtkWidget *widget, + GdkRectangle *allocation, + gpointer user_data) +{ + GsShell *self = GS_SHELL (user_data); + GtkRequisition overlay_natural_size; + + /* Override the default position of the in-app notification overlay + * to position it below the header bar. The overlay can’t easily be + * moved in the widget hierarchy so it doesn’t have the header bar as + * a child, since there are several header bars in different pages of + * a AdwLeaflet. */ + g_assert (gtk_widget_is_ancestor (self->main_header, GTK_WIDGET (overlay))); + + gtk_widget_get_preferred_size (widget, NULL, &overlay_natural_size); + + allocation->width = overlay_natural_size.width; + allocation->height = overlay_natural_size.height; + + allocation->x = gtk_widget_get_allocated_width (GTK_WIDGET (overlay)) / 2 - overlay_natural_size.width / 2; + allocation->y = gtk_widget_get_allocated_height (GTK_WIDGET (self->main_header)); + + return TRUE; +} + +static void +gs_overview_page_button_cb (GtkWidget *widget, GsShell *shell) +{ + GsShellMode mode; + mode = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), + "gnome-software::overview-mode")); + gs_shell_change_mode (shell, mode, NULL, TRUE); +} + +static void +save_back_entry (GsShell *shell) +{ + BackEntry *entry; + + entry = g_new0 (BackEntry, 1); + entry->mode = gs_shell_get_mode (shell); + + entry->focus = gtk_window_get_focus (GTK_WINDOW (shell)); + if (entry->focus != NULL) + g_object_add_weak_pointer (G_OBJECT (entry->focus), + (gpointer *) &entry->focus); + + switch (entry->mode) { + case GS_SHELL_MODE_CATEGORY: + entry->category = gs_category_page_get_category (GS_CATEGORY_PAGE (shell->pages[GS_SHELL_MODE_CATEGORY])); + g_object_ref (entry->category); + g_debug ("pushing back entry for %s with %s", + page_name[entry->mode], + gs_category_get_id (entry->category)); + break; + case GS_SHELL_MODE_SEARCH: + entry->search = g_strdup (gs_search_page_get_text (GS_SEARCH_PAGE (shell->pages[GS_SHELL_MODE_SEARCH]))); + g_debug ("pushing back entry for %s with %s", + page_name[entry->mode], entry->search); + break; + case GS_SHELL_MODE_DETAILS: + entry->app = g_object_ref (gs_details_page_get_app (GS_DETAILS_PAGE (shell->pages[GS_SHELL_MODE_DETAILS]))); + entry->vscroll_position = gs_details_page_get_vscroll_position (GS_DETAILS_PAGE (shell->pages[GS_SHELL_MODE_DETAILS])); + break; + default: + g_debug ("pushing back entry for %s", page_name[entry->mode]); + break; + } + + g_queue_push_head (shell->back_entry_stack, entry); +} + +static void +gs_shell_plugin_events_sources_cb (GtkWidget *widget, GsShell *shell) +{ + gs_shell_show_sources (shell); +} + +static void +gs_shell_plugin_events_no_space_cb (GtkWidget *widget, GsShell *shell) +{ + g_autoptr(GError) error = NULL; + if (!g_spawn_command_line_async ("baobab", &error)) + g_warning ("failed to exec baobab: %s", error->message); +} + +static void +gs_shell_plugin_events_network_settings_cb (GtkWidget *widget, GsShell *shell) +{ + g_autoptr(GError) error = NULL; + if (!g_spawn_command_line_async ("gnome-control-center network", &error)) + g_warning ("failed to exec gnome-control-center: %s", error->message); +} + +static void +gs_shell_plugin_events_more_info_cb (GtkWidget *widget, GsShell *shell) +{ + g_autoptr(GError) error = NULL; + if (!g_app_info_launch_default_for_uri (shell->events_info_uri, NULL, &error)) { + g_warning ("failed to launch URI %s: %s", + shell->events_info_uri, error->message); + } +} + +static void +gs_shell_plugin_events_restart_required_cb (GtkWidget *widget, GsShell *shell) +{ + g_autoptr(GError) error = NULL; + if (!g_spawn_command_line_async (LIBEXECDIR "/gnome-software-restarter", &error)) + g_warning ("failed to restart: %s", error->message); +} + +/* this is basically a workaround for GtkSearchEntry. Due to delayed emission of the search-changed + * signal it can't be blocked during insertion of text into the entry. Therefore we block the + * precursor of that signal to be able to add text to the entry without firing the handlers + * connected to "search-changed" + */ +static void +block_changed (GtkEditable *editable, + gpointer user_data) +{ + g_signal_stop_emission_by_name (editable, "changed"); +} + +static void +block_changed_signal (GtkSearchEntry *entry) +{ + g_signal_connect (entry, "changed", G_CALLBACK (block_changed), NULL); +} + +static void +unblock_changed_signal (GtkSearchEntry *entry) +{ + g_signal_handlers_disconnect_by_func (entry, G_CALLBACK (block_changed), NULL); +} + +static void +gs_shell_go_back (GsShell *shell) +{ + BackEntry *entry; + + /* nothing to do */ + if (g_queue_is_empty (shell->back_entry_stack)) { + g_debug ("no back stack, showing overview"); + gs_shell_change_mode (shell, GS_SHELL_MODE_OVERVIEW, NULL, FALSE); + return; + } + + entry = g_queue_pop_head (shell->back_entry_stack); + + switch (entry->mode) { + case GS_SHELL_MODE_UNKNOWN: + case GS_SHELL_MODE_LOADING: + /* happens when using --search, --details, --install, etc. options */ + g_debug ("popping back entry for %s", page_name[entry->mode]); + gs_shell_change_mode (shell, GS_SHELL_MODE_OVERVIEW, NULL, FALSE); + break; + case GS_SHELL_MODE_CATEGORY: + g_debug ("popping back entry for %s with %s", + page_name[entry->mode], + gs_category_get_id (entry->category)); + gs_shell_change_mode (shell, entry->mode, entry->category, FALSE); + break; + case GS_SHELL_MODE_SEARCH: + g_debug ("popping back entry for %s with %s", + page_name[entry->mode], entry->search); + + /* set the text in the entry and move cursor to the end */ + block_changed_signal (GTK_SEARCH_ENTRY (shell->entry_search)); + gtk_editable_set_text (GTK_EDITABLE (shell->entry_search), entry->search); + gtk_editable_set_position (GTK_EDITABLE (shell->entry_search), -1); + unblock_changed_signal (GTK_SEARCH_ENTRY (shell->entry_search)); + + /* set the mode directly */ + gs_shell_change_mode (shell, entry->mode, + (gpointer) entry->search, FALSE); + break; + case GS_SHELL_MODE_DETAILS: + g_debug ("popping back entry for %s with app %s and vscroll position %f", + page_name[entry->mode], + gs_app_get_unique_id (entry->app), + entry->vscroll_position); + gs_shell_change_mode (shell, entry->mode, entry->app, FALSE); + gs_details_page_set_vscroll_position (GS_DETAILS_PAGE (shell->pages[GS_SHELL_MODE_DETAILS]), entry->vscroll_position); + break; + default: + g_debug ("popping back entry for %s", page_name[entry->mode]); + gs_shell_change_mode (shell, entry->mode, NULL, FALSE); + break; + } + + if (entry->focus != NULL) + gtk_widget_grab_focus (entry->focus); + + free_back_entry (entry); +} + +static void +gs_shell_details_back_button_cb (GtkWidget *widget, GsShell *shell) +{ + gs_shell_go_back (shell); +} + +static void +gs_shell_back_button_cb (GtkWidget *widget, GsShell *shell) +{ + gs_shell_go_back (shell); +} + +static void +gs_shell_reload_cb (GsPluginLoader *plugin_loader, GsShell *shell) +{ + for (gsize i = 0; i < G_N_ELEMENTS (shell->pages); i++) { + GsPage *page = shell->pages[i]; + if (page != NULL) + gs_page_reload (page); + } +} + +static void +gs_shell_details_page_metainfo_loaded_cb (GtkWidget *details_page, + GsApp *app, + GsShell *self) +{ + g_return_if_fail (GS_IS_APP (app)); + g_return_if_fail (GS_IS_SHELL (self)); + + /* If the user has manually loaded some metainfo to + * preview, override the featured carousel with it too, + * so they can see how it looks in the carousel. */ + gs_overview_page_override_featured (GS_OVERVIEW_PAGE (self->pages[GS_SHELL_MODE_OVERVIEW]), app); +} + +static gboolean +change_mode_idle (gpointer user_data) +{ + GsShell *shell = user_data; + + gs_page_reload (GS_PAGE (shell->pages[GS_SHELL_MODE_UPDATES])); + gs_page_reload (GS_PAGE (shell->pages[GS_SHELL_MODE_INSTALLED])); + + /* Switch only when still on the loading page, otherwise the page + could be changed from the command line or such, which would mean + hiding the chosen page. */ + if (gs_shell_get_mode (shell) == GS_SHELL_MODE_LOADING) + gs_shell_change_mode (shell, GS_SHELL_MODE_OVERVIEW, NULL, TRUE); + + return G_SOURCE_REMOVE; +} + +static void +overview_page_refresh_done (GsOverviewPage *overview_page, gpointer data) +{ + GsShell *shell = data; + + g_signal_handlers_disconnect_by_func (overview_page, overview_page_refresh_done, data); + + /* now that we're finished with the loading page, connect the reload signal handler */ + g_signal_connect (shell->plugin_loader, "reload", + G_CALLBACK (gs_shell_reload_cb), shell); + + /* schedule to change the mode in an idle callback, since it can take a + * while and this callback handler is typically called at the end of a + * long main context iteration already */ + g_idle_add (change_mode_idle, shell); +} + +static void +initial_refresh_done (GsLoadingPage *loading_page, gpointer data) +{ + GsShell *shell = data; + gboolean been_overview; + + g_signal_handlers_disconnect_by_func (loading_page, initial_refresh_done, data); + + been_overview = gs_shell_get_mode (shell) == GS_SHELL_MODE_OVERVIEW; + + g_signal_emit (shell, signals[SIGNAL_LOADED], 0); + + /* if the "loaded" signal handler didn't change the mode, kick off async + * overview page refresh, and switch to the page once done */ + if (gs_shell_get_mode (shell) == GS_SHELL_MODE_LOADING || been_overview) { + g_signal_connect (shell->pages[GS_SHELL_MODE_OVERVIEW], "refreshed", + G_CALLBACK (overview_page_refresh_done), shell); + gs_page_reload (GS_PAGE (shell->pages[GS_SHELL_MODE_OVERVIEW])); + return; + } + + /* now that we're finished with the loading page, connect the reload signal handler */ + g_signal_connect (shell->plugin_loader, "reload", + G_CALLBACK (gs_shell_reload_cb), shell); +} + +static gboolean +window_keypress_handler (GtkEventControllerKey *key_controller, + guint keyval, + guint keycode, + GdkModifierType state, + GsShell *shell) +{ + /* handle ctrl+f shortcut */ + if ((state & GDK_CONTROL_MASK) > 0 && keyval == GDK_KEY_f) { + if (!gtk_search_bar_get_search_mode (GTK_SEARCH_BAR (shell->search_bar))) { + GsShellMode mode = gs_shell_get_mode (shell); + + gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (shell->search_bar), TRUE); + gtk_widget_grab_focus (shell->entry_search); + + /* If the mode doesn't have a search button, + * switch to the search page right away, + * otherwise we would show the search bar + * without a button to toggle it. */ + switch (mode) { + case GS_SHELL_MODE_OVERVIEW: + case GS_SHELL_MODE_INSTALLED: + case GS_SHELL_MODE_SEARCH: + break; + default: + gs_shell_show_search (shell, ""); + break; + } + } else { + gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (shell->search_bar), FALSE); + } + return GDK_EVENT_STOP; + } + + return GDK_EVENT_PROPAGATE; +} + +static void +search_changed_handler (GObject *entry, GsShell *shell) +{ + g_autofree gchar *text = NULL; + + text = g_strdup (gtk_editable_get_text (GTK_EDITABLE (entry))); + if (strlen (text) >= 2) { + if (gs_shell_get_mode (shell) != GS_SHELL_MODE_SEARCH) { + save_back_entry (shell); + gs_shell_change_mode (shell, GS_SHELL_MODE_SEARCH, + (gpointer) text, TRUE); + } else { + gs_search_page_set_text (GS_SEARCH_PAGE (shell->pages[GS_SHELL_MODE_SEARCH]), text); + gs_page_switch_to (shell->pages[GS_SHELL_MODE_SEARCH]); + gs_page_scroll_up (shell->pages[GS_SHELL_MODE_SEARCH]); + } + } +} + +static void +search_bar_search_mode_enabled_changed_cb (GtkSearchBar *search_bar, + GParamSpec *pspec, + GsShell *shell) +{ + /* go back when exiting the search view */ + if (gs_shell_get_mode (shell) == GS_SHELL_MODE_SEARCH && + !gtk_search_bar_get_search_mode (search_bar)) + gs_shell_go_back (shell); +} + +static void +go_back (GsShell *shell) +{ + if (adw_leaflet_get_adjacent_child (shell->details_leaflet, + ADW_NAVIGATION_DIRECTION_BACK)) { + gtk_widget_activate (shell->button_back2); + } else { + gtk_widget_activate (shell->button_back); + } +} + +static gboolean +window_key_pressed_cb (GtkEventControllerKey *key_controller, + guint keyval, + guint keycode, + GdkModifierType state, + GsShell *shell) +{ + gboolean is_rtl = gtk_widget_get_direction (shell->button_back) == GTK_TEXT_DIR_RTL; + gboolean is_alt = (state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_ALT_MASK)) == GDK_ALT_MASK; + + if ((!is_rtl && is_alt && keyval == GDK_KEY_Left) || + (is_rtl && is_alt && keyval == GDK_KEY_Right) || + keyval == GDK_KEY_Back) { + go_back (shell); + return GDK_EVENT_STOP; + } + + return GDK_EVENT_PROPAGATE; +} + +static void +window_button_pressed_cb (GtkGestureClick *click_gesture, + gint n_press, + gdouble x, + gdouble y, + GsShell *shell) +{ + go_back (shell); + + gtk_gesture_set_state (GTK_GESTURE (click_gesture), GTK_EVENT_SEQUENCE_CLAIMED); +} + +static gboolean +main_window_closed_cb (GtkWidget *dialog, gpointer user_data) +{ + GsShell *shell = user_data; + + /* hide any notifications */ + g_application_withdraw_notification (g_application_get_default (), + "installed"); + g_application_withdraw_notification (g_application_get_default (), + "install-resources"); + + /* clear any in-app notification */ + gtk_revealer_set_reveal_child (GTK_REVEALER (shell->notification_event), FALSE); + + /* release our hold on the download scheduler */ +#ifdef HAVE_MOGWAI + if (shell->scheduler != NULL) { + if (shell->scheduler_invalidated_handler > 0) + g_signal_handler_disconnect (shell->scheduler, + shell->scheduler_invalidated_handler); + shell->scheduler_invalidated_handler = 0; + + if (shell->scheduler_held) + mwsc_scheduler_release_async (shell->scheduler, + NULL, + scheduler_release_cb, + g_object_ref (shell)); + else + g_clear_object (&shell->scheduler); + } +#endif /* HAVE_MOGWAI */ + + gs_shell_clean_back_entry_stack (shell); + gtk_widget_hide (dialog); + +#ifdef __GLIBC__ + /* Free unused memory with GNU extension of malloc.h */ + malloc_trim (0); +#endif + + return TRUE; +} + +static void +gs_shell_main_window_mapped_cb (GtkWidget *widget, GsShell *shell) +{ + gs_plugin_loader_set_scale (shell->plugin_loader, + (guint) gtk_widget_get_scale_factor (widget)); + + /* Set up the updates bar. Do this here rather than in gs_shell_setup() + * since we only want to hold the scheduler open while the gnome-software + * main window is visible, and not while we’re running in the background. */ +#ifdef HAVE_MOGWAI + if (shell->scheduler == NULL) + mwsc_scheduler_new_async (shell->cancellable, + (GAsyncReadyCallback) scheduler_ready_cb, + g_object_ref (shell)); +#else + gs_shell_refresh_auto_updates_ui (shell); +#endif /* HAVE_MOGWAI */ +} + +static void +gs_shell_main_window_realized_cb (GtkWidget *widget, GsShell *shell) +{ + GdkRectangle geometry; + GdkSurface *surface; + GdkDisplay *display; + GdkMonitor *monitor; + + display = gtk_widget_get_display (GTK_WIDGET (shell)); + surface = gtk_native_get_surface (GTK_NATIVE (shell)); + monitor = gdk_display_get_monitor_at_surface (display, surface); + + /* adapt the window for low and medium resolution screens */ + if (monitor != NULL) { + gdk_monitor_get_geometry (monitor, &geometry); + if (geometry.width < 800 || geometry.height < 600) { + } else if (geometry.width < 1366 || geometry.height < 768) { + gtk_window_set_default_size (GTK_WINDOW (shell), 1050, 600); + } + } +} + +typedef enum { + GS_SHELL_EVENT_BUTTON_NONE = 0, + GS_SHELL_EVENT_BUTTON_SOURCES = 1 << 0, + GS_SHELL_EVENT_BUTTON_NO_SPACE = 1 << 1, + GS_SHELL_EVENT_BUTTON_NETWORK_SETTINGS = 1 << 2, + GS_SHELL_EVENT_BUTTON_MORE_INFO = 1 << 3, + GS_SHELL_EVENT_BUTTON_RESTART_REQUIRED = 1 << 4, + GS_SHELL_EVENT_BUTTON_LAST +} GsShellEventButtons; + +static gboolean +gs_shell_has_disk_examination_app (void) +{ + g_autofree gchar *baobab = g_find_program_in_path ("baobab"); + return (baobab != NULL); +} + +static void +gs_shell_show_event_app_notify (GsShell *shell, + const gchar *title, + GsShellEventButtons buttons) +{ + /* set visible */ + gtk_revealer_set_reveal_child (GTK_REVEALER (shell->notification_event), TRUE); + + /* sources button */ + gtk_widget_set_visible (shell->button_events_sources, + (buttons & GS_SHELL_EVENT_BUTTON_SOURCES) > 0); + + /* no-space button */ + gtk_widget_set_visible (shell->button_events_no_space, + (buttons & GS_SHELL_EVENT_BUTTON_NO_SPACE) > 0 && + gs_shell_has_disk_examination_app()); + + /* network settings button */ + gtk_widget_set_visible (shell->button_events_network_settings, + (buttons & GS_SHELL_EVENT_BUTTON_NETWORK_SETTINGS) > 0); + + /* restart button */ + gtk_widget_set_visible (shell->button_events_restart_required, + (buttons & GS_SHELL_EVENT_BUTTON_RESTART_REQUIRED) > 0); + + /* more-info button */ + gtk_widget_set_visible (shell->button_events_more_info, + (buttons & GS_SHELL_EVENT_BUTTON_MORE_INFO) > 0); + + /* dismiss button */ + gtk_widget_set_visible (shell->button_events_dismiss, + (buttons & GS_SHELL_EVENT_BUTTON_RESTART_REQUIRED) == 0); + + /* set title */ + gtk_label_set_markup (GTK_LABEL (shell->label_events), title); + gtk_widget_set_visible (shell->label_events, title != NULL); +} + +void +gs_shell_show_notification (GsShell *shell, const gchar *title) +{ + gs_shell_show_event_app_notify (shell, title, GS_SHELL_EVENT_BUTTON_NONE); +} + +static gchar * +gs_shell_get_title_from_origin (GsApp *app) +{ + /* get a title, falling back */ + if (gs_app_get_origin_hostname (app) != NULL) { + /* TRANSLATORS: this is part of the in-app notification, + * where the %s is the truncated hostname, e.g. + * 'alt.fedoraproject.org' */ + return g_strdup_printf (_("“%s”"), gs_app_get_origin_hostname (app)); + } + if (gs_app_get_origin (app) != NULL) { + /* TRANSLATORS: this is part of the in-app notification, + * where the %s is the origin id, e.g. 'fedora' */ + return g_strdup_printf (_("“%s”"), gs_app_get_origin (app)); + } + return g_strdup_printf ("“%s”", gs_app_get_id (app)); +} + +/* return a name for the app, using quotes if the name is more than one word */ +static gchar * +gs_shell_get_title_from_app (GsApp *app) +{ + const gchar *tmp = gs_app_get_name (app); + if (tmp != NULL) { + if (g_strstr_len (tmp, -1, " ") != NULL) { + /* TRANSLATORS: this is part of the in-app notification, + * where the %s is a multi-word localised app name + * e.g. 'Getting things GNOME!" */ + return g_strdup_printf (_("“%s”"), tmp); + } + return g_strdup (tmp); + } + return g_strdup_printf (_("“%s”"), gs_app_get_id (app)); +} + +static gchar * +get_first_lines (const gchar *str) +{ + const gchar *end = str; + /* Some errors can have an "introduction", thus pick few initial lines, not only the first. */ + for (guint lines = 0; end != NULL && lines < 7; lines++) { + end = strchr (end, '\n'); + if (end != NULL) + end++; + } + if (end != NULL) { + g_autofree gchar *tmp = g_strndup (str, end - str); + /* Translators: The '%s' is replaced with an error message, which had been shortened. + The dots at the end are there to highlight that to the user. */ + return g_strdup_printf (_("%s…"), tmp); + } + return g_strdup (str); +} + +static void +gs_shell_append_detailed_error (GsShell *shell, GString *str, const GError *error) +{ + g_autofree gchar *text = get_first_lines (error->message); + if (text != NULL) { + g_autofree gchar *escaped = g_markup_escape_text (text, -1); + g_string_append_printf (str, ":\n%s", escaped); + } +} + +static gboolean +gs_shell_show_event_refresh (GsShell *shell, GsPluginEvent *event) +{ + GsApp *origin = gs_plugin_event_get_origin (event); + GsShellEventButtons buttons = GS_SHELL_EVENT_BUTTON_NONE; + const GError *error = gs_plugin_event_get_error (event); + GsPluginAction action = gs_plugin_event_get_action (event); + g_autofree gchar *str_origin = NULL; + g_autoptr(GString) str = g_string_new (NULL); + + /* ignore any errors from background downloads */ + if (!gs_plugin_event_has_flag (event, GS_PLUGIN_EVENT_FLAG_INTERACTIVE)) + return FALSE; + + if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_DOWNLOAD_FAILED)) { + if (origin != NULL) { + str_origin = gs_shell_get_title_from_origin (origin); + if (gs_app_get_bundle_kind (origin) == AS_BUNDLE_KIND_CABINET) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the source (e.g. "alt.fedoraproject.org") */ + g_string_append_printf (str, _("Unable to download " + "firmware updates from %s"), + str_origin); + } else { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the source (e.g. "alt.fedoraproject.org") */ + g_string_append_printf (str, _("Unable to download updates from %s"), + str_origin); + if (!gs_app_has_management_plugin (origin, NULL)) + buttons |= GS_SHELL_EVENT_BUTTON_SOURCES; + } + } else { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Unable to download updates")); + } + gs_shell_append_detailed_error (shell, str, error); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_NETWORK)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Unable to download updates: " + "internet access was required but wasn’t available")); + buttons |= GS_SHELL_EVENT_BUTTON_NETWORK_SETTINGS; + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SPACE)) { + if (origin != NULL) { + str_origin = gs_shell_get_title_from_origin (origin); + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the source (e.g. "alt.fedoraproject.org") */ + g_string_append_printf (str, _("Unable to download updates " + "from %s: not enough disk space"), + str_origin); + } else { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Unable to download updates: " + "not enough disk space")); + } + buttons |= GS_SHELL_EVENT_BUTTON_NO_SPACE; + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AUTH_REQUIRED)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Unable to download updates: " + "authentication was required")); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AUTH_INVALID)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Unable to download updates: " + "authentication was invalid")); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SECURITY)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Unable to download updates: you do not have" + " permission to install software")); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_CANCELLED) || + g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { + /* Do nothing. */ + } else { + if (action == GS_PLUGIN_ACTION_DOWNLOAD) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Unable to download updates")); + } else { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Unable to get list of updates")); + } + gs_shell_append_detailed_error (shell, str, error); + } + + if (str->len == 0) + return FALSE; + + /* add more-info button */ + if (origin != NULL) { + const gchar *uri = gs_app_get_url (origin, AS_URL_KIND_HELP); + if (uri != NULL) { + g_free (shell->events_info_uri); + shell->events_info_uri = g_strdup (uri); + buttons |= GS_SHELL_EVENT_BUTTON_MORE_INFO; + } + } + + /* show in-app notification */ + gs_shell_show_event_app_notify (shell, str->str, buttons); + return TRUE; +} + +static gboolean +gs_shell_show_event_install (GsShell *shell, GsPluginEvent *event) +{ + GsApp *app = gs_plugin_event_get_app (event); + GsApp *origin = gs_plugin_event_get_origin (event); + GsShellEventButtons buttons = GS_SHELL_EVENT_BUTTON_NONE; + const GError *error = gs_plugin_event_get_error (event); + g_autofree gchar *str_app = NULL; + g_autofree gchar *str_origin = NULL; + g_autoptr(GString) str = g_string_new (NULL); + + str_app = gs_shell_get_title_from_app (app); + + if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_DOWNLOAD_FAILED)) { + if (origin != NULL) { + str_origin = gs_shell_get_title_from_origin (origin); + /* TRANSLATORS: failure text for the in-app notification, + * where the first %s is the application name (e.g. "GIMP") and + * the second %s is the origin, e.g. "Fedora Project [fedoraproject.org]" */ + g_string_append_printf (str, _("Unable to install %s as " + "download failed from %s"), + str_app, str_origin); + } else { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to install %s " + "as download failed"), + str_app); + } + gs_shell_append_detailed_error (shell, str, error); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NOT_SUPPORTED)) { + if (origin != NULL) { + str_origin = gs_shell_get_title_from_origin (origin); + /* TRANSLATORS: failure text for the in-app notification, + * where the first %s is the application name (e.g. "GIMP") + * and the second %s is the name of the runtime, e.g. + * "GNOME SDK [flatpak.gnome.org]" */ + g_string_append_printf (str, _("Unable to install %s as " + "runtime %s not available"), + str_app, str_origin); + } else { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to install %s " + "as not supported"), + str_app); + } + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_NETWORK)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Unable to install: internet access was " + "required but wasn’t available")); + buttons |= GS_SHELL_EVENT_BUTTON_NETWORK_SETTINGS; + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_INVALID_FORMAT)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Unable to install: the application has an invalid format")); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SPACE)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to install %s: " + "not enough disk space"), + str_app); + buttons |= GS_SHELL_EVENT_BUTTON_NO_SPACE; + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AUTH_REQUIRED)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append_printf (str, _("Unable to install %s: " + "authentication was required"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AUTH_INVALID)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to install %s: " + "authentication was invalid"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SECURITY)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to install %s: " + "you do not have permission to " + "install software"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AC_POWER_REQUIRED)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "Dell XPS 13") */ + g_string_append_printf (str, _("Unable to install %s: " + "AC power is required"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_BATTERY_LEVEL_TOO_LOW)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "Dell XPS 13") */ + g_string_append_printf (str, _("Unable to install %s: " + "The battery level is too low"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_CANCELLED) || + g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { + /* Do nothing. */ + } else { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to install %s"), str_app); + gs_shell_append_detailed_error (shell, str, error); + } + + if (str->len == 0) + return FALSE; + + /* add more-info button */ + if (origin != NULL) { + const gchar *uri = gs_app_get_url (origin, AS_URL_KIND_HELP); + if (uri != NULL) { + g_free (shell->events_info_uri); + shell->events_info_uri = g_strdup (uri); + buttons |= GS_SHELL_EVENT_BUTTON_MORE_INFO; + } + } + + /* show in-app notification */ + gs_shell_show_event_app_notify (shell, str->str, buttons); + return TRUE; +} + +static gboolean +gs_shell_show_event_update (GsShell *shell, GsPluginEvent *event) +{ + GsApp *app = gs_plugin_event_get_app (event); + GsApp *origin = gs_plugin_event_get_origin (event); + GsShellEventButtons buttons = GS_SHELL_EVENT_BUTTON_NONE; + const GError *error = gs_plugin_event_get_error (event); + g_autofree gchar *str_app = NULL; + g_autofree gchar *str_origin = NULL; + g_autoptr(GString) str = g_string_new (NULL); + + /* ignore any errors from background downloads */ + if (!gs_plugin_event_has_flag (event, GS_PLUGIN_EVENT_FLAG_INTERACTIVE)) + return FALSE; + + if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_DOWNLOAD_FAILED)) { + if (app != NULL && origin != NULL) { + str_app = gs_shell_get_title_from_app (app); + str_origin = gs_shell_get_title_from_origin (origin); + /* TRANSLATORS: failure text for the in-app notification, + * where the first %s is the app name (e.g. "GIMP") and + * the second %s is the origin, e.g. "Fedora" or + * "Fedora Project [fedoraproject.org]" */ + g_string_append_printf (str, _("Unable to update %s from %s as download failed"), + str_app, str_origin); + buttons = TRUE; + } else if (app != NULL) { + str_app = gs_shell_get_title_from_app (app); + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to update %s as download failed"), + str_app); + } else if (origin != NULL) { + str_origin = gs_shell_get_title_from_origin (origin); + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the origin, e.g. "Fedora" or + * "Fedora Project [fedoraproject.org]" */ + g_string_append_printf (str, _("Unable to install updates from %s as download failed"), + str_origin); + } else { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append_printf (str, _("Unable to install updates as download failed")); + } + gs_shell_append_detailed_error (shell, str, error); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_NETWORK)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Unable to update: " + "internet access was required but " + "wasn’t available")); + buttons |= GS_SHELL_EVENT_BUTTON_NETWORK_SETTINGS; + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SPACE)) { + if (app != NULL) { + str_app = gs_shell_get_title_from_app (app); + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to update %s: " + "not enough disk space"), + str_app); + } else { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append_printf (str, _("Unable to install updates: " + "not enough disk space")); + } + buttons |= GS_SHELL_EVENT_BUTTON_NO_SPACE; + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AUTH_REQUIRED)) { + if (app != NULL) { + str_app = gs_shell_get_title_from_app (app); + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to update %s: " + "authentication was required"), + str_app); + } else { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append_printf (str, _("Unable to install updates: " + "authentication was required")); + } + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AUTH_INVALID)) { + if (app != NULL) { + str_app = gs_shell_get_title_from_app (app); + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to update %s: " + "authentication was invalid"), + str_app); + } else { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append_printf (str, _("Unable to install updates: " + "authentication was invalid")); + } + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SECURITY)) { + if (app != NULL) { + str_app = gs_shell_get_title_from_app (app); + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to update %s: " + "you do not have permission to " + "update software"), + str_app); + } else { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append_printf (str, _("Unable to install updates: " + "you do not have permission to " + "update software")); + } + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AC_POWER_REQUIRED)) { + if (app != NULL) { + str_app = gs_shell_get_title_from_app (app); + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "Dell XPS 13") */ + g_string_append_printf (str, _("Unable to update %s: " + "AC power is required"), + str_app); + } else { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "Dell XPS 13") */ + g_string_append_printf (str, _("Unable to install updates: " + "AC power is required")); + } + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_BATTERY_LEVEL_TOO_LOW)) { + if (app != NULL) { + str_app = gs_shell_get_title_from_app (app); + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "Dell XPS 13") */ + g_string_append_printf (str, _("Unable to update %s: " + "The battery level is too low"), + str_app); + } else { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "Dell XPS 13") */ + g_string_append_printf (str, _("Unable to install updates: " + "The battery level is too low")); + } + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_CANCELLED) || + g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { + /* Do nothing. */ + } else { + if (app != NULL) { + str_app = gs_shell_get_title_from_app (app); + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to update %s"), str_app); + } else { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append_printf (str, _("Unable to install updates")); + } + gs_shell_append_detailed_error (shell, str, error); + } + + if (str->len == 0) + return FALSE; + + /* add more-info button */ + if (origin != NULL) { + const gchar *uri = gs_app_get_url (origin, AS_URL_KIND_HELP); + if (uri != NULL) { + g_free (shell->events_info_uri); + shell->events_info_uri = g_strdup (uri); + buttons |= GS_SHELL_EVENT_BUTTON_MORE_INFO; + } + } + + /* show in-app notification */ + gs_shell_show_event_app_notify (shell, str->str, buttons); + return TRUE; +} + +static gboolean +gs_shell_show_event_upgrade (GsShell *shell, GsPluginEvent *event) +{ + GsApp *app = gs_plugin_event_get_app (event); + GsApp *origin = gs_plugin_event_get_origin (event); + GsShellEventButtons buttons = GS_SHELL_EVENT_BUTTON_NONE; + const GError *error = gs_plugin_event_get_error (event); + g_autoptr(GString) str = g_string_new (NULL); + g_autofree gchar *str_app = NULL; + g_autofree gchar *str_origin = NULL; + + str_app = g_strdup_printf ("%s %s", gs_app_get_name (app), gs_app_get_version (app)); + + if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_DOWNLOAD_FAILED)) { + if (origin != NULL) { + str_origin = gs_shell_get_title_from_origin (origin); + /* TRANSLATORS: failure text for the in-app notification, + * where the first %s is the distro name (e.g. "Fedora 25") and + * the second %s is the origin, e.g. "Fedora Project [fedoraproject.org]" */ + g_string_append_printf (str, _("Unable to upgrade to %s from %s"), + str_app, str_origin); + } else { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the app name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to upgrade to %s " + "as download failed"), + str_app); + } + gs_shell_append_detailed_error (shell, str, error); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_NETWORK)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the distro name (e.g. "Fedora 25") */ + g_string_append_printf (str, _("Unable to upgrade to %s: " + "internet access was required but " + "wasn’t available"), + str_app); + buttons |= GS_SHELL_EVENT_BUTTON_NETWORK_SETTINGS; + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SPACE)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the distro name (e.g. "Fedora 25") */ + g_string_append_printf (str, _("Unable to upgrade to %s: " + "not enough disk space"), + str_app); + buttons |= GS_SHELL_EVENT_BUTTON_NO_SPACE; + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AUTH_REQUIRED)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the distro name (e.g. "Fedora 25") */ + g_string_append_printf (str, _("Unable to upgrade to %s: " + "authentication was required"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AUTH_INVALID)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the distro name (e.g. "Fedora 25") */ + g_string_append_printf (str, _("Unable to upgrade to %s: " + "authentication was invalid"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SECURITY)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the distro name (e.g. "Fedora 25") */ + g_string_append_printf (str, _("Unable to upgrade to %s: " + "you do not have permission to upgrade"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AC_POWER_REQUIRED)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the distro name (e.g. "Fedora 25") */ + g_string_append_printf (str, _("Unable to upgrade to %s: " + "AC power is required"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_BATTERY_LEVEL_TOO_LOW)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the distro name (e.g. "Fedora 25") */ + g_string_append_printf (str, _("Unable to upgrade to %s: " + "The battery level is too low"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_CANCELLED) || + g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { + /* Do nothing. */ + } else { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the distro name (e.g. "Fedora 25") */ + g_string_append_printf (str, _("Unable to upgrade to %s"), str_app); + gs_shell_append_detailed_error (shell, str, error); + } + + if (str->len == 0) + return FALSE; + + /* add more-info button */ + if (origin != NULL) { + const gchar *uri = gs_app_get_url (origin, AS_URL_KIND_HELP); + if (uri != NULL) { + g_free (shell->events_info_uri); + shell->events_info_uri = g_strdup (uri); + buttons |= GS_SHELL_EVENT_BUTTON_MORE_INFO; + } + } + + /* show in-app notification */ + gs_shell_show_event_app_notify (shell, str->str, buttons); + return TRUE; +} + +static gboolean +gs_shell_show_event_remove (GsShell *shell, GsPluginEvent *event) +{ + GsApp *app = gs_plugin_event_get_app (event); + GsApp *origin = gs_plugin_event_get_origin (event); + GsShellEventButtons buttons = GS_SHELL_EVENT_BUTTON_NONE; + const GError *error = gs_plugin_event_get_error (event); + g_autoptr(GString) str = g_string_new (NULL); + g_autofree gchar *str_app = NULL; + + str_app = gs_shell_get_title_from_app (app); + + if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AUTH_REQUIRED)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to remove %s: authentication was required"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AUTH_INVALID)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to remove %s: authentication was invalid"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SECURITY)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to remove %s: you do not have" + " permission to remove software"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AC_POWER_REQUIRED)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to remove %s: " + "AC power is required"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_BATTERY_LEVEL_TOO_LOW)) { + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to remove %s: " + "The battery level is too low"), + str_app); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_CANCELLED) || + g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { + /* Do nothing. */ + } else { + /* non-interactive generic */ + if (!gs_plugin_event_has_flag (event, GS_PLUGIN_EVENT_FLAG_INTERACTIVE)) + return FALSE; + /* TRANSLATORS: failure text for the in-app notification, + * where the %s is the application name (e.g. "GIMP") */ + g_string_append_printf (str, _("Unable to remove %s"), str_app); + gs_shell_append_detailed_error (shell, str, error); + } + + if (str->len == 0) + return FALSE; + + /* add more-info button */ + if (origin != NULL) { + const gchar *uri = gs_app_get_url (origin, AS_URL_KIND_HELP); + if (uri != NULL) { + g_free (shell->events_info_uri); + shell->events_info_uri = g_strdup (uri); + buttons |= GS_SHELL_EVENT_BUTTON_MORE_INFO; + } + } + + /* show in-app notification */ + gs_shell_show_event_app_notify (shell, str->str, buttons); + return TRUE; +} + +static gboolean +gs_shell_show_event_launch (GsShell *shell, GsPluginEvent *event) +{ + GsApp *app = gs_plugin_event_get_app (event); + GsApp *origin = gs_plugin_event_get_origin (event); + GsShellEventButtons buttons = GS_SHELL_EVENT_BUTTON_NONE; + const GError *error = gs_plugin_event_get_error (event); + g_autoptr(GString) str = g_string_new (NULL); + g_autofree gchar *str_app = NULL; + g_autofree gchar *str_origin = NULL; + + if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NOT_SUPPORTED)) { + if (app != NULL && origin != NULL) { + str_app = gs_shell_get_title_from_app (app); + str_origin = gs_shell_get_title_from_origin (origin); + /* TRANSLATORS: failure text for the in-app notification, + * where the first %s is the application name (e.g. "GIMP") + * and the second %s is the name of the runtime, e.g. + * "GNOME SDK [flatpak.gnome.org]" */ + g_string_append_printf (str, _("Unable to launch %s: %s is not installed"), + str_app, + str_origin); + } else { + /* non-interactive generic */ + if (!gs_plugin_event_has_flag (event, GS_PLUGIN_EVENT_FLAG_INTERACTIVE)) + return FALSE; + /* TRANSLATORS: we failed to get a proper error code */ + g_string_append (str, _("Sorry, something went wrong")); + gs_shell_append_detailed_error (shell, str, error); + } + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SPACE)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Not enough disk space — free up some space " + "and try again")); + buttons |= GS_SHELL_EVENT_BUTTON_NO_SPACE; + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_CANCELLED) || + g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { + /* Do nothing. */ + } else { + /* non-interactive generic */ + if (!gs_plugin_event_has_flag (event, GS_PLUGIN_EVENT_FLAG_INTERACTIVE)) + return FALSE; + /* TRANSLATORS: we failed to get a proper error code */ + g_string_append (str, _("Sorry, something went wrong")); + gs_shell_append_detailed_error (shell, str, error); + } + + if (str->len == 0) + return FALSE; + + /* add more-info button */ + if (origin != NULL) { + const gchar *uri = gs_app_get_url (origin, AS_URL_KIND_HELP); + if (uri != NULL) { + g_free (shell->events_info_uri); + shell->events_info_uri = g_strdup (uri); + buttons |= GS_SHELL_EVENT_BUTTON_MORE_INFO; + } + } + + /* show in-app notification */ + gs_shell_show_event_app_notify (shell, str->str, buttons); + return TRUE; +} + +static gboolean +gs_shell_show_event_file_to_app (GsShell *shell, GsPluginEvent *event) +{ + GsShellEventButtons buttons = GS_SHELL_EVENT_BUTTON_NONE; + const GError *error = gs_plugin_event_get_error (event); + g_autoptr(GString) str = g_string_new (NULL); + + if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NOT_SUPPORTED)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Failed to install file: not supported")); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SECURITY)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Failed to install file: authentication failed")); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SPACE)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Not enough disk space — free up some space " + "and try again")); + buttons |= GS_SHELL_EVENT_BUTTON_NO_SPACE; + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_CANCELLED) || + g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { + /* Do nothing. */ + } else { + /* non-interactive generic */ + if (!gs_plugin_event_has_flag (event, GS_PLUGIN_EVENT_FLAG_INTERACTIVE)) + return FALSE; + /* TRANSLATORS: we failed to get a proper error code */ + g_string_append (str, _("Sorry, something went wrong")); + gs_shell_append_detailed_error (shell, str, error); + } + + if (str->len == 0) + return FALSE; + + /* show in-app notification */ + gs_shell_show_event_app_notify (shell, str->str, buttons); + return TRUE; +} + +static gboolean +gs_shell_show_event_url_to_app (GsShell *shell, GsPluginEvent *event) +{ + GsShellEventButtons buttons = GS_SHELL_EVENT_BUTTON_NONE; + const GError *error = gs_plugin_event_get_error (event); + g_autoptr(GString) str = g_string_new (NULL); + + if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NOT_SUPPORTED)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Failed to install: not supported")); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SECURITY)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Failed to install: authentication failed")); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SPACE)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Not enough disk space — free up some space " + "and try again")); + buttons |= GS_SHELL_EVENT_BUTTON_NO_SPACE; + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_CANCELLED) || + g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { + /* Do nothing. */ + } else { + /* non-interactive generic */ + if (!gs_plugin_event_has_flag (event, GS_PLUGIN_EVENT_FLAG_INTERACTIVE)) + return FALSE; + /* TRANSLATORS: we failed to get a proper error code */ + g_string_append (str, _("Sorry, something went wrong")); + gs_shell_append_detailed_error (shell, str, error); + } + + if (str->len == 0) + return FALSE; + + /* show in-app notification */ + gs_shell_show_event_app_notify (shell, str->str, buttons); + return TRUE; +} + +static gboolean +gs_shell_show_event_fallback (GsShell *shell, GsPluginEvent *event) +{ + GsApp *origin = gs_plugin_event_get_origin (event); + GsShellEventButtons buttons = GS_SHELL_EVENT_BUTTON_NONE; + const GError *error = gs_plugin_event_get_error (event); + g_autoptr(GString) str = g_string_new (NULL); + g_autofree gchar *str_origin = NULL; + + if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_DOWNLOAD_FAILED)) { + if (origin != NULL) { + str_origin = gs_shell_get_title_from_origin (origin); + /* TRANSLATORS: failure text for the in-app notification, + * the %s is the origin, e.g. "Fedora" or + * "Fedora Project [fedoraproject.org]" */ + g_string_append_printf (str, _("Unable to contact %s"), + str_origin); + } + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_NO_SPACE)) { + /* TRANSLATORS: failure text for the in-app notification */ + g_string_append (str, _("Not enough disk space — free up some space " + "and try again")); + buttons |= GS_SHELL_EVENT_BUTTON_NO_SPACE; + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_RESTART_REQUIRED)) { + /* TRANSLATORS: failure text for the in-app notification, where the 'Software' means this application, aka 'GNOME Software'. */ + g_string_append (str, _("Software needs to be restarted to use new plugins.")); + buttons |= GS_SHELL_EVENT_BUTTON_RESTART_REQUIRED; + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_AC_POWER_REQUIRED)) { + /* TRANSLATORS: need to be connected to the AC power */ + g_string_append (str, _("AC power is required")); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_BATTERY_LEVEL_TOO_LOW)) { + /* TRANSLATORS: not enough juice to do this safely */ + g_string_append (str, _("The battery level is too low")); + } else if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_CANCELLED) || + g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { + /* Do nothing. */ + } else { + /* non-interactive generic */ + if (!gs_plugin_event_has_flag (event, GS_PLUGIN_EVENT_FLAG_INTERACTIVE)) + return FALSE; + /* TRANSLATORS: we failed to get a proper error code */ + g_string_append (str, _("Sorry, something went wrong")); + gs_shell_append_detailed_error (shell, str, error); + } + + if (str->len == 0) + return FALSE; + + /* add more-info button */ + if (origin != NULL) { + const gchar *uri = gs_app_get_url (origin, AS_URL_KIND_HELP); + if (uri != NULL) { + g_free (shell->events_info_uri); + shell->events_info_uri = g_strdup (uri); + buttons |= GS_SHELL_EVENT_BUTTON_MORE_INFO; + } + } + + /* show in-app notification */ + gs_shell_show_event_app_notify (shell, str->str, buttons); + return TRUE; +} + +static gboolean +gs_shell_show_event (GsShell *shell, GsPluginEvent *event) +{ + const GError *error; + GsPluginAction action; + GsPluginJob *job; + + /* get error */ + error = gs_plugin_event_get_error (event); + if (error == NULL) + return FALSE; + + /* name and shame the plugin */ + if (g_error_matches (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_TIMED_OUT)) { + gs_shell_show_event_app_notify (shell, error->message, + GS_SHELL_EVENT_BUTTON_NONE); + return TRUE; + } + + job = gs_plugin_event_get_job (event); + if (GS_IS_PLUGIN_JOB_REFRESH_METADATA (job)) + return gs_shell_show_event_refresh (shell, event); + + /* split up the events by action */ + action = gs_plugin_event_get_action (event); + switch (action) { + case GS_PLUGIN_ACTION_DOWNLOAD: + return gs_shell_show_event_refresh (shell, event); + case GS_PLUGIN_ACTION_INSTALL: + case GS_PLUGIN_ACTION_INSTALL_REPO: + case GS_PLUGIN_ACTION_ENABLE_REPO: + return gs_shell_show_event_install (shell, event); + case GS_PLUGIN_ACTION_UPDATE: + return gs_shell_show_event_update (shell, event); + case GS_PLUGIN_ACTION_UPGRADE_DOWNLOAD: + return gs_shell_show_event_upgrade (shell, event); + case GS_PLUGIN_ACTION_REMOVE: + case GS_PLUGIN_ACTION_REMOVE_REPO: + case GS_PLUGIN_ACTION_DISABLE_REPO: + return gs_shell_show_event_remove (shell, event); + case GS_PLUGIN_ACTION_LAUNCH: + return gs_shell_show_event_launch (shell, event); + case GS_PLUGIN_ACTION_FILE_TO_APP: + return gs_shell_show_event_file_to_app (shell, event); + case GS_PLUGIN_ACTION_URL_TO_APP: + return gs_shell_show_event_url_to_app (shell, event); + default: + break; + } + + /* capture some warnings every time */ + return gs_shell_show_event_fallback (shell, event); +} + +static void +gs_shell_rescan_events (GsShell *shell) +{ + g_autoptr(GsPluginEvent) event = NULL; + + /* find the first active event and show it */ + event = gs_plugin_loader_get_event_default (shell->plugin_loader); + if (event != NULL) { + if (!gs_shell_show_event (shell, event)) { + GsPluginAction action = gs_plugin_event_get_action (event); + const GError *error = gs_plugin_event_get_error (event); + if (error != NULL && + !g_error_matches (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_CANCELLED) && + !g_error_matches (error, + G_IO_ERROR, + G_IO_ERROR_CANCELLED)) { + g_warning ("not handling error %s for action %s: %s", + gs_plugin_error_to_string (error->code), + gs_plugin_action_to_string (action), + error->message); + } + gs_plugin_event_add_flag (event, GS_PLUGIN_EVENT_FLAG_INVALID); + return; + } + gs_plugin_event_add_flag (event, GS_PLUGIN_EVENT_FLAG_VISIBLE); + return; + } + + /* nothing to show */ + gtk_revealer_set_reveal_child (GTK_REVEALER (shell->notification_event), FALSE); +} + +static void +gs_shell_events_notify_cb (GsPluginLoader *plugin_loader, + GParamSpec *pspec, + GsShell *shell) +{ + gs_shell_rescan_events (shell); +} + +static void +gs_shell_plugin_event_dismissed_cb (GtkButton *button, GsShell *shell) +{ + guint i; + g_autoptr(GPtrArray) events = NULL; + + /* mark any events currently showing as invalid */ + events = gs_plugin_loader_get_events (shell->plugin_loader); + for (i = 0; i < events->len; i++) { + GsPluginEvent *event = g_ptr_array_index (events, i); + if (gs_plugin_event_has_flag (event, GS_PLUGIN_EVENT_FLAG_VISIBLE)) { + gs_plugin_event_add_flag (event, GS_PLUGIN_EVENT_FLAG_INVALID); + gs_plugin_event_remove_flag (event, GS_PLUGIN_EVENT_FLAG_VISIBLE); + } + } + + /* show the next event */ + gs_shell_rescan_events (shell); +} + +static void +gs_shell_setup_pages (GsShell *shell) +{ + for (gsize i = 0; i < G_N_ELEMENTS (shell->pages); i++) { + g_autoptr(GError) error = NULL; + GsPage *page = shell->pages[i]; + if (page != NULL && + !gs_page_setup (page, shell, + shell->plugin_loader, + shell->cancellable, + &error)) { + g_warning ("Failed to setup panel: %s", error->message); + } + } +} + +static void +gs_shell_add_about_menu_item (GsShell *shell) +{ + g_autoptr(GMenuItem) menu_item = NULL; + + /* TRANSLATORS: this is the menu item that opens the about window */ + menu_item = g_menu_item_new (_("About Software"), "app.about"); + g_menu_append_item (G_MENU (shell->primary_menu), menu_item); +} + +static void +updates_page_notify_counter_cb (GObject *obj, + GParamSpec *pspec, + gpointer user_data) +{ + GsPage *page = GS_PAGE (obj); + GsShell *shell = GS_SHELL (user_data); + AdwViewStackPage *stack_page; + gboolean needs_attention; + + /* Update the needs-attention child property of the page in the + * AdwViewStack. There’s no need to account for whether it’s the currently + * visible page, as the CSS rules do that for us. This can’t be a simple + * property binding, though, as it’s a binding between an object + * property and a child property. */ + needs_attention = (gs_page_get_counter (page) > 0); + + stack_page = adw_view_stack_get_page (shell->stack_main, GTK_WIDGET (page)); + adw_view_stack_page_set_needs_attention (stack_page, needs_attention); +} + +static void +category_page_app_clicked_cb (GsCategoryPage *page, + GsApp *app, + gpointer user_data) +{ + GsShell *shell = GS_SHELL (user_data); + + gs_shell_show_app (shell, app); +} + +static void +details_page_app_clicked_cb (GsDetailsPage *page, + GsApp *app, + gpointer user_data) +{ + GsShell *shell = GS_SHELL (user_data); + + gs_shell_show_app (shell, app); +} + +void +gs_shell_setup (GsShell *shell, GsPluginLoader *plugin_loader, GCancellable *cancellable) +{ + GsOdrsProvider *odrs_provider; + + g_return_if_fail (GS_IS_SHELL (shell)); + + shell->plugin_loader = g_object_ref (plugin_loader); + g_signal_connect_object (shell->plugin_loader, "notify::events", + G_CALLBACK (gs_shell_events_notify_cb), + shell, 0); + g_signal_connect_object (shell->plugin_loader, "notify::network-metered", + G_CALLBACK (gs_shell_network_metered_notify_cb), + shell, 0); + g_signal_connect_object (shell->plugin_loader, "basic-auth-start", + G_CALLBACK (gs_shell_basic_auth_start_cb), + shell, 0); + g_signal_connect_object (shell->plugin_loader, "ask-untrusted", + G_CALLBACK (gs_shell_ask_untrusted_cb), + shell, 0); + + g_object_bind_property (shell->plugin_loader, "allow-updates", + shell->pages[GS_SHELL_MODE_UPDATES], "visible", + G_BINDING_SYNC_CREATE); + + shell->cancellable = g_object_ref (cancellable); + + shell->settings = g_settings_new ("org.gnome.software"); + + /* set up pages */ + gs_shell_setup_pages (shell); + + /* set up the metered data info bar and mogwai */ + g_signal_connect (shell->settings, "changed::download-updates", + (GCallback) gs_shell_download_updates_changed_cb, shell); + + odrs_provider = gs_plugin_loader_get_odrs_provider (shell->plugin_loader); + gs_details_page_set_odrs_provider (GS_DETAILS_PAGE (shell->pages[GS_SHELL_MODE_DETAILS]), odrs_provider); + gs_moderate_page_set_odrs_provider (GS_MODERATE_PAGE (shell->pages[GS_SHELL_MODE_MODERATE]), odrs_provider); + + /* coldplug */ + gs_shell_rescan_events (shell); + + /* primary menu */ + gs_shell_add_about_menu_item (shell); + + if (g_settings_get_boolean (shell->settings, "download-updates")) { + /* show loading page, which triggers the initial refresh */ + gs_shell_change_mode (shell, GS_SHELL_MODE_LOADING, NULL, TRUE); + } else { + g_debug ("Skipped refresh of the repositories due to 'download-updates' disabled"); + initial_refresh_done (GS_LOADING_PAGE (shell->pages[GS_SHELL_MODE_LOADING]), shell); + + if (g_settings_get_boolean (shell->settings, "first-run")) + g_settings_set_boolean (shell->settings, "first-run", FALSE); + } + + if (shell->activate_after_setup) { + shell->activate_after_setup = FALSE; + gs_shell_activate (shell); + } +} + +void +gs_shell_reset_state (GsShell *shell) +{ + /* reset to overview, unless we're in the loading state which advances + * to overview on its own */ + if (gs_shell_get_mode (shell) != GS_SHELL_MODE_LOADING) + gs_shell_change_mode (shell, GS_SHELL_MODE_OVERVIEW, NULL, TRUE); + + gs_shell_clean_back_entry_stack (shell); +} + +void +gs_shell_set_mode (GsShell *shell, GsShellMode mode) +{ + gs_shell_change_mode (shell, mode, NULL, TRUE); +} + +GsShellMode +gs_shell_get_mode (GsShell *shell) +{ + const gchar *name; + + if (g_strcmp0 (adw_view_stack_get_visible_child_name (shell->stack_loading), "loading") == 0) + return GS_SHELL_MODE_LOADING; + + if (g_strcmp0 (adw_leaflet_get_visible_child_name (shell->details_leaflet), "details") == 0) + return GS_SHELL_MODE_DETAILS; + + if (g_strcmp0 (adw_leaflet_get_visible_child_name (shell->main_leaflet), "main") == 0) + name = adw_view_stack_get_visible_child_name (shell->stack_main); + else + name = adw_view_stack_get_visible_child_name (shell->stack_sub); + + for (gsize i = 0; i < G_N_ELEMENTS (page_name); i++) + if (g_strcmp0 (page_name[i], name) == 0) + return i; + + g_assert_not_reached (); +} + +const gchar * +gs_shell_get_mode_string (GsShell *shell) +{ + GsShellMode mode = gs_shell_get_mode (shell); + return page_name[mode]; +} + +void +gs_shell_install (GsShell *shell, GsApp *app, GsShellInteraction interaction) +{ + save_back_entry (shell); + gs_shell_change_mode (shell, GS_SHELL_MODE_DETAILS, + (gpointer) app, TRUE); + gs_page_install_app (shell->pages[GS_SHELL_MODE_DETAILS], app, interaction, shell->cancellable); +} + +void +gs_shell_uninstall (GsShell *shell, GsApp *app) +{ + save_back_entry (shell); + gs_shell_change_mode (shell, GS_SHELL_MODE_DETAILS, (gpointer) app, TRUE); + gs_page_remove_app (shell->pages[GS_SHELL_MODE_DETAILS], app, shell->cancellable); +} + +void +gs_shell_show_installed_updates (GsShell *shell) +{ + GtkWidget *dialog; + + dialog = gs_update_dialog_new (shell->plugin_loader); + + gs_shell_modal_dialog_present (shell, GTK_WINDOW (dialog)); +} + +void +gs_shell_show_sources (GsShell *shell) +{ + GtkWidget *dialog; + + /* use if available */ + if (g_spawn_command_line_async ("software-properties-gtk", NULL)) + return; + + dialog = gs_repos_dialog_new (GTK_WINDOW (shell), shell->plugin_loader); + gs_shell_modal_dialog_present (shell, GTK_WINDOW (dialog)); +} + +void +gs_shell_show_prefs (GsShell *shell) +{ + GtkWidget *dialog; + + dialog = gs_prefs_dialog_new (GTK_WINDOW (shell), shell->plugin_loader); + gs_shell_modal_dialog_present (shell, GTK_WINDOW (dialog)); +} + +void +gs_shell_show_app (GsShell *shell, GsApp *app) +{ + save_back_entry (shell); + gs_shell_change_mode (shell, GS_SHELL_MODE_DETAILS, app, TRUE); + gs_shell_activate (shell); +} + +void +gs_shell_show_category (GsShell *shell, GsCategory *category) +{ + save_back_entry (shell); + gs_shell_change_mode (shell, GS_SHELL_MODE_CATEGORY, category, TRUE); +} + +void gs_shell_show_extras_search (GsShell *shell, const gchar *mode, gchar **resources, const gchar *desktop_id, const gchar *ident) +{ + save_back_entry (shell); + gs_extras_page_search (GS_EXTRAS_PAGE (shell->pages[GS_SHELL_MODE_EXTRAS]), mode, resources, desktop_id, ident); + gs_shell_change_mode (shell, GS_SHELL_MODE_EXTRAS, NULL, TRUE); + gs_shell_activate (shell); +} + +void +gs_shell_show_search (GsShell *shell, const gchar *search) +{ + save_back_entry (shell); + gs_shell_change_mode (shell, GS_SHELL_MODE_SEARCH, + (gpointer) search, TRUE); +} + +void +gs_shell_show_local_file (GsShell *shell, GFile *file) +{ + g_autoptr(GsApp) app = gs_app_new (NULL); + save_back_entry (shell); + gs_app_set_local_file (app, file); + gs_shell_change_mode (shell, GS_SHELL_MODE_DETAILS, + (gpointer) app, TRUE); + gs_shell_activate (shell); +} + +/** + * gs_shell_show_metainfo: + * @shell: a #GsShell + * @file: path to a metainfo file to display + * + * Open a metainfo file and display it on the details page as if it were + * published in a repository configured on the system. + * + * This is intended for app developers to be able to test their metainfo files + * locally. + * + * Since: 42 + */ +void +gs_shell_show_metainfo (GsShell *shell, GFile *file) +{ + g_autoptr(GsApp) app = gs_app_new (NULL); + + g_return_if_fail (GS_IS_SHELL (shell)); + g_return_if_fail (G_IS_FILE (file)); + save_back_entry (shell); + gs_app_set_metadata (app, "GnomeSoftware::show-metainfo", "1"); + gs_app_set_local_file (app, file); + gs_shell_change_mode (shell, GS_SHELL_MODE_DETAILS, + (gpointer) app, TRUE); + gs_shell_activate (shell); +} + +void +gs_shell_show_search_result (GsShell *shell, const gchar *id, const gchar *search) +{ + save_back_entry (shell); + gs_search_page_set_appid_to_show (GS_SEARCH_PAGE (shell->pages[GS_SHELL_MODE_SEARCH]), id); + gs_shell_change_mode (shell, GS_SHELL_MODE_SEARCH, + (gpointer) search, TRUE); +} + +void +gs_shell_show_uri (GsShell *shell, const gchar *url) +{ + gtk_show_uri (GTK_WINDOW (shell), url, GDK_CURRENT_TIME); +} + +/** + * gs_shell_get_is_narrow: + * @shell: a #GsShell + * + * Get the value of #GsShell:is-narrow. + * + * Returns: %TRUE if the window is in narrow mode, %FALSE otherwise + * + * Since: 41 + */ +gboolean +gs_shell_get_is_narrow (GsShell *shell) +{ + g_return_val_if_fail (GS_IS_SHELL (shell), FALSE); + + return shell->is_narrow; +} + +static gint +gs_shell_get_allocation_width (GsShell *self) +{ + return self->allocation_width; +} + +static void +gs_shell_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) +{ + GsShell *shell = GS_SHELL (object); + + switch ((GsShellProperty) prop_id) { + case PROP_IS_NARROW: + g_value_set_boolean (value, gs_shell_get_is_narrow (shell)); + break; + case PROP_ALLOCATION_WIDTH: + g_value_set_int (value, gs_shell_get_allocation_width (shell)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_shell_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) +{ + switch ((GsShellProperty) prop_id) { + case PROP_IS_NARROW: + case PROP_ALLOCATION_WIDTH: + /* Read only. */ + g_assert_not_reached (); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_shell_dispose (GObject *object) +{ + GsShell *shell = GS_SHELL (object); + + g_clear_object (&shell->sub_page_header_title_binding); + + if (shell->back_entry_stack != NULL) { + g_queue_free_full (shell->back_entry_stack, (GDestroyNotify) free_back_entry); + shell->back_entry_stack = NULL; + } + g_clear_object (&shell->cancellable); + g_clear_object (&shell->plugin_loader); + g_clear_object (&shell->header_start_widget); + g_clear_object (&shell->header_end_widget); + g_clear_object (&shell->page); + g_clear_pointer (&shell->events_info_uri, g_free); + g_clear_pointer (&shell->modal_dialogs, g_ptr_array_unref); + g_clear_object (&shell->settings); + +#ifdef HAVE_MOGWAI + if (shell->scheduler != NULL) { + if (shell->scheduler_invalidated_handler > 0) + g_signal_handler_disconnect (shell->scheduler, + shell->scheduler_invalidated_handler); + + if (shell->scheduler_held) + mwsc_scheduler_release_async (shell->scheduler, + NULL, + scheduler_release_cb, + g_object_ref (shell)); + else + g_clear_object (&shell->scheduler); + } +#endif /* HAVE_MOGWAI */ + + G_OBJECT_CLASS (gs_shell_parent_class)->dispose (object); +} + +static gboolean +allocation_changed_cb (gpointer user_data) +{ + GsShell *shell = GS_SHELL (user_data); + GtkAllocation allocation; + gboolean is_narrow; + GtkStyleContext *context; + + gtk_widget_get_allocation (GTK_WIDGET (shell), &allocation); + + is_narrow = allocation.width <= NARROW_WIDTH_THRESHOLD; + + if (shell->is_narrow != is_narrow) { + shell->is_narrow = is_narrow; + g_object_notify_by_pspec (G_OBJECT (shell), obj_props[PROP_IS_NARROW]); + } + + if (shell->allocation_width != allocation.width) { + shell->allocation_width = allocation.width; + g_object_notify_by_pspec (G_OBJECT (shell), obj_props[PROP_ALLOCATION_WIDTH]); + } + + shell->allocation_changed_cb_id = 0; + + context = gtk_widget_get_style_context (GTK_WIDGET (shell)); + + if (is_narrow) + gtk_style_context_add_class (context, "narrow"); + else + gtk_style_context_remove_class (context, "narrow"); + + return G_SOURCE_REMOVE; +} + +static void +gs_shell_size_allocate (GtkWidget *widget, + gint width, + gint height, + gint baseline) +{ + GsShell *shell = GS_SHELL (widget); + + GTK_WIDGET_CLASS (gs_shell_parent_class)->size_allocate (widget, + width, + height, + baseline); + + /* Delay updating is-narrow so children can adapt to it, which isn't + * possible during the widget's allocation phase as it would break their + * size request. + */ + if (shell->allocation_changed_cb_id == 0) + shell->allocation_changed_cb_id = g_idle_add (allocation_changed_cb, shell); +} + +static void +gs_shell_class_init (GsShellClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + object_class->get_property = gs_shell_get_property; + object_class->set_property = gs_shell_set_property; + object_class->dispose = gs_shell_dispose; + + widget_class->size_allocate = gs_shell_size_allocate; + + /** + * GsShell:is-narrow: + * + * Whether the window is in narrow mode. + * + * Pages can track this property to adapt to the available width. + * + * Since: 41 + */ + obj_props[PROP_IS_NARROW] = + g_param_spec_boolean ("is-narrow", NULL, NULL, + FALSE, + G_PARAM_READABLE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY); + + /** + * GsShell:allocation-width: + * + * The last allocation width for the window. + * + * The pages can track this property, possibly in combination with the #GsShell:is-narrow, + * to adapt its content to the available width. + * + * Since: 43 + */ + obj_props[PROP_ALLOCATION_WIDTH] = + g_param_spec_int ("allocation-width", NULL, NULL, + G_MININT, G_MAXINT, 0, + G_PARAM_READABLE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY); + + g_object_class_install_properties (object_class, G_N_ELEMENTS (obj_props), obj_props); + + signals [SIGNAL_LOADED] = + g_signal_new ("loaded", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/Software/gs-shell.ui"); + + gtk_widget_class_bind_template_child (widget_class, GsShell, main_header); + gtk_widget_class_bind_template_child (widget_class, GsShell, main_leaflet); + gtk_widget_class_bind_template_child (widget_class, GsShell, details_header); + gtk_widget_class_bind_template_child (widget_class, GsShell, details_leaflet); + gtk_widget_class_bind_template_child (widget_class, GsShell, stack_loading); + gtk_widget_class_bind_template_child (widget_class, GsShell, stack_main); + gtk_widget_class_bind_template_child (widget_class, GsShell, stack_sub); + gtk_widget_class_bind_template_child (widget_class, GsShell, metered_updates_bar); + gtk_widget_class_bind_template_child (widget_class, GsShell, search_button); + gtk_widget_class_bind_template_child (widget_class, GsShell, entry_search); + gtk_widget_class_bind_template_child (widget_class, GsShell, search_bar); + gtk_widget_class_bind_template_child (widget_class, GsShell, button_back); + gtk_widget_class_bind_template_child (widget_class, GsShell, button_back2); + gtk_widget_class_bind_template_child (widget_class, GsShell, notification_event); + gtk_widget_class_bind_template_child (widget_class, GsShell, button_events_sources); + gtk_widget_class_bind_template_child (widget_class, GsShell, button_events_no_space); + gtk_widget_class_bind_template_child (widget_class, GsShell, button_events_network_settings); + gtk_widget_class_bind_template_child (widget_class, GsShell, button_events_restart_required); + gtk_widget_class_bind_template_child (widget_class, GsShell, button_events_more_info); + gtk_widget_class_bind_template_child (widget_class, GsShell, button_events_dismiss); + gtk_widget_class_bind_template_child (widget_class, GsShell, label_events); + gtk_widget_class_bind_template_child (widget_class, GsShell, primary_menu); + gtk_widget_class_bind_template_child (widget_class, GsShell, sub_page_header_title); + + gtk_widget_class_bind_template_child_full (widget_class, "overview_page", FALSE, G_STRUCT_OFFSET (GsShell, pages[GS_SHELL_MODE_OVERVIEW])); + gtk_widget_class_bind_template_child_full (widget_class, "updates_page", FALSE, G_STRUCT_OFFSET (GsShell, pages[GS_SHELL_MODE_UPDATES])); + gtk_widget_class_bind_template_child_full (widget_class, "installed_page", FALSE, G_STRUCT_OFFSET (GsShell, pages[GS_SHELL_MODE_INSTALLED])); + gtk_widget_class_bind_template_child_full (widget_class, "moderate_page", FALSE, G_STRUCT_OFFSET (GsShell, pages[GS_SHELL_MODE_MODERATE])); + gtk_widget_class_bind_template_child_full (widget_class, "loading_page", FALSE, G_STRUCT_OFFSET (GsShell, pages[GS_SHELL_MODE_LOADING])); + gtk_widget_class_bind_template_child_full (widget_class, "search_page", FALSE, G_STRUCT_OFFSET (GsShell, pages[GS_SHELL_MODE_SEARCH])); + gtk_widget_class_bind_template_child_full (widget_class, "details_page", FALSE, G_STRUCT_OFFSET (GsShell, pages[GS_SHELL_MODE_DETAILS])); + gtk_widget_class_bind_template_child_full (widget_class, "category_page", FALSE, G_STRUCT_OFFSET (GsShell, pages[GS_SHELL_MODE_CATEGORY])); + gtk_widget_class_bind_template_child_full (widget_class, "extras_page", FALSE, G_STRUCT_OFFSET (GsShell, pages[GS_SHELL_MODE_EXTRAS])); + + gtk_widget_class_bind_template_callback (widget_class, gs_shell_main_window_mapped_cb); + gtk_widget_class_bind_template_callback (widget_class, gs_shell_main_window_realized_cb); + gtk_widget_class_bind_template_callback (widget_class, main_window_closed_cb); + gtk_widget_class_bind_template_callback (widget_class, window_key_pressed_cb); + gtk_widget_class_bind_template_callback (widget_class, window_keypress_handler); + gtk_widget_class_bind_template_callback (widget_class, window_button_pressed_cb); + gtk_widget_class_bind_template_callback (widget_class, gs_shell_details_back_button_cb); + gtk_widget_class_bind_template_callback (widget_class, gs_shell_back_button_cb); + gtk_widget_class_bind_template_callback (widget_class, gs_overview_page_button_cb); + gtk_widget_class_bind_template_callback (widget_class, updates_page_notify_counter_cb); + gtk_widget_class_bind_template_callback (widget_class, category_page_app_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, search_bar_search_mode_enabled_changed_cb); + gtk_widget_class_bind_template_callback (widget_class, search_changed_handler); + gtk_widget_class_bind_template_callback (widget_class, gs_shell_plugin_events_sources_cb); + gtk_widget_class_bind_template_callback (widget_class, gs_shell_plugin_events_no_space_cb); + gtk_widget_class_bind_template_callback (widget_class, gs_shell_plugin_events_network_settings_cb); + gtk_widget_class_bind_template_callback (widget_class, gs_shell_plugin_events_restart_required_cb); + gtk_widget_class_bind_template_callback (widget_class, gs_shell_plugin_events_more_info_cb); + gtk_widget_class_bind_template_callback (widget_class, gs_shell_plugin_event_dismissed_cb); + gtk_widget_class_bind_template_callback (widget_class, gs_shell_metered_updates_bar_response_cb); + gtk_widget_class_bind_template_callback (widget_class, stack_notify_visible_child_cb); + gtk_widget_class_bind_template_callback (widget_class, initial_refresh_done); + gtk_widget_class_bind_template_callback (widget_class, overlay_get_child_position_cb); + gtk_widget_class_bind_template_callback (widget_class, gs_shell_details_page_metainfo_loaded_cb); + gtk_widget_class_bind_template_callback (widget_class, details_page_app_clicked_cb); + + gtk_widget_class_add_binding_action (widget_class, GDK_KEY_q, GDK_CONTROL_MASK, "window.close", NULL); +} + +static void +gs_shell_init (GsShell *shell) +{ + gtk_widget_init_template (GTK_WIDGET (shell)); + + gtk_search_bar_connect_entry (GTK_SEARCH_BAR (shell->search_bar), GTK_EDITABLE (shell->entry_search)); + + shell->back_entry_stack = g_queue_new (); + shell->modal_dialogs = g_ptr_array_new (); +} + +GsShell * +gs_shell_new (void) +{ + return GS_SHELL (g_object_new (GS_TYPE_SHELL, NULL)); +} |