summaryrefslogtreecommitdiffstats
path: root/src/gs-category-page.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/gs-category-page.c')
-rw-r--r--src/gs-category-page.c693
1 files changed, 693 insertions, 0 deletions
diff --git a/src/gs-category-page.c b/src/gs-category-page.c
new file mode 100644
index 0000000..ba57ed2
--- /dev/null
+++ b/src/gs-category-page.c
@@ -0,0 +1,693 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ * vi:set noexpandtab tabstop=8 shiftwidth=8:
+ *
+ * Copyright (C) 2013 Richard Hughes <richard@hughsie.com>
+ * Copyright (C) 2013 Matthias Clasen <mclasen@redhat.com>
+ * Copyright (C) 2014-2018 Kalev Lember <klember@redhat.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#include "config.h"
+
+#include <string.h>
+#include <glib/gi18n.h>
+
+#include "gs-app-list-private.h"
+#include "gs-common.h"
+#include "gs-featured-carousel.h"
+#include "gs-summary-tile.h"
+#include "gs-category-page.h"
+#include "gs-utils.h"
+
+struct _GsCategoryPage
+{
+ GsPage parent_instance;
+
+ GsPluginLoader *plugin_loader;
+ GCancellable *cancellable;
+ GsCategory *category;
+ GsCategory *subcategory;
+
+ GtkWidget *top_carousel;
+ GtkWidget *category_detail_box;
+ GtkWidget *scrolledwindow_category;
+ GtkWidget *featured_flow_box;
+ GtkWidget *recently_updated_flow_box;
+ GtkWidget *web_apps_flow_box;
+};
+
+G_DEFINE_TYPE (GsCategoryPage, gs_category_page, GS_TYPE_PAGE)
+
+#define MAX_RECENTLY_UPDATED_APPS 18
+
+typedef enum {
+ PROP_CATEGORY = 1,
+ /* Override properties: */
+ PROP_TITLE,
+} GsCategoryPageProperty;
+
+static GParamSpec *obj_props[PROP_CATEGORY + 1] = { NULL, };
+
+typedef enum {
+ SIGNAL_APP_CLICKED,
+} GsCategoryPageSignal;
+
+static guint obj_signals[SIGNAL_APP_CLICKED + 1] = { 0, };
+
+static void
+app_tile_clicked (GsAppTile *tile, gpointer data)
+{
+ GsCategoryPage *self = GS_CATEGORY_PAGE (data);
+ GsApp *app;
+
+ app = gs_app_tile_get_app (tile);
+ g_signal_emit (self, obj_signals[SIGNAL_APP_CLICKED], 0, app);
+}
+
+static void
+top_carousel_app_clicked_cb (GsFeaturedCarousel *carousel,
+ GsApp *app,
+ gpointer user_data)
+{
+ GsCategoryPage *self = GS_CATEGORY_PAGE (user_data);
+
+ g_signal_emit (self, obj_signals[SIGNAL_APP_CLICKED], 0, app);
+}
+
+static gint
+_max_results_sort_cb (GsApp *app1, GsApp *app2, gpointer user_data)
+{
+ gint name_sort = gs_utils_sort_strcmp (gs_app_get_name (app1), gs_app_get_name (app2));
+
+ if (name_sort != 0)
+ return name_sort;
+
+ return gs_app_get_rating (app1) - gs_app_get_rating (app2);
+}
+
+static void
+gs_category_page_add_placeholders (GsCategoryPage *self,
+ GtkFlowBox *flow_box,
+ guint n_placeholders)
+{
+ gs_widget_remove_all (GTK_WIDGET (flow_box), (GsRemoveFunc) gtk_flow_box_remove);
+
+ for (guint i = 0; i < n_placeholders; ++i) {
+ GtkWidget *tile = gs_summary_tile_new (NULL);
+ gtk_flow_box_insert (flow_box, tile, -1);
+ gtk_widget_set_can_focus (gtk_widget_get_parent (tile), FALSE);
+ gtk_widget_remove_css_class (tile, "activatable");
+ }
+
+ gtk_widget_show (GTK_WIDGET (flow_box));
+}
+
+typedef struct {
+ GsCategoryPage *page; /* (owned) */
+ GHashTable *featured_app_ids; /* (owned) (nullable) (element-type utf8 utf8) */
+ gboolean get_featured_apps_finished;
+ GsAppList *apps; /* (owned) (nullable) */
+ gboolean get_main_apps_finished;
+} LoadCategoryData;
+
+static void
+load_category_data_free (LoadCategoryData *data)
+{
+ g_clear_object (&data->page);
+ g_clear_pointer (&data->featured_app_ids, g_hash_table_unref);
+ g_clear_object (&data->apps);
+ g_free (data);
+}
+
+static void load_category_finish (LoadCategoryData *data);
+
+static void
+gs_category_page_get_featured_apps_cb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ LoadCategoryData *data = user_data;
+ GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (source_object);
+ g_autoptr(GError) local_error = NULL;
+ g_autoptr(GsAppList) list = NULL;
+ g_autoptr(GHashTable) featured_app_ids = NULL;
+
+ list = gs_plugin_loader_job_process_finish (plugin_loader,
+ res,
+ &local_error);
+ if (list == NULL) {
+ if (!g_error_matches (local_error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_CANCELLED) &&
+ !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+ g_warning ("failed to get featured apps for category apps: %s", local_error->message);
+ data->get_featured_apps_finished = TRUE;
+ load_category_finish (data);
+ return;
+ }
+
+ featured_app_ids = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+
+ for (guint i = 0; i < gs_app_list_length (list); i++) {
+ GsApp *app = gs_app_list_index (list, i);
+
+ g_hash_table_add (featured_app_ids, g_strdup (gs_app_get_id (app)));
+ }
+
+ data->featured_app_ids = g_steal_pointer (&featured_app_ids);
+ data->get_featured_apps_finished = TRUE;
+ load_category_finish (data);
+}
+
+static void
+gs_category_page_get_apps_cb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ LoadCategoryData *data = user_data;
+ GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (source_object);
+ g_autoptr(GError) local_error = NULL;
+ g_autoptr(GsAppList) list = NULL;
+
+ list = gs_plugin_loader_job_process_finish (plugin_loader,
+ res,
+ &local_error);
+ if (list == NULL) {
+ if (!g_error_matches (local_error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_CANCELLED) &&
+ !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+ g_warning ("failed to get apps for category apps: %s", local_error->message);
+ data->get_main_apps_finished = TRUE;
+ load_category_finish (data);
+ return;
+ }
+
+ data->apps = g_steal_pointer (&list);
+ data->get_main_apps_finished = TRUE;
+ load_category_finish (data);
+}
+
+static gboolean
+app_has_hi_res_icon (GsCategoryPage *self,
+ GsApp *app)
+{
+ g_autoptr(GIcon) icon = NULL;
+
+ /* This is the minimum icon size needed by `GsFeatureTile`. */
+ icon = gs_app_get_icon_for_size (app,
+ 128,
+ gtk_widget_get_scale_factor (GTK_WIDGET (self)),
+ NULL);
+
+ /* Returning TRUE means to keep the app in the list */
+ return (icon != NULL);
+}
+
+static GsAppList *
+choose_top_carousel_apps (LoadCategoryData *data,
+ guint64 recently_updated_cutoff_secs)
+{
+ const guint n_top_carousel_apps = 5;
+ g_autoptr(GPtrArray) candidates = g_ptr_array_new_with_free_func (NULL);
+ g_autoptr(GsAppList) top_carousel_apps = gs_app_list_new ();
+ guint top_carousel_seed;
+ g_autoptr(GRand) top_carousel_rand = NULL;
+
+ /* The top carousel should contain @n_top_carousel_apps, taken from the
+ * set of featured or recently updated apps which have hi-res icons.
+ *
+ * The apps in the top carousel should be changed on a fixed schedule,
+ * once a week.
+ */
+ top_carousel_seed = (g_get_real_time () / G_USEC_PER_SEC) / (7 * 24 * 60 * 60);
+ top_carousel_rand = g_rand_new_with_seed (top_carousel_seed);
+ g_debug ("Top carousel seed: %u", top_carousel_seed);
+
+ for (guint i = 0; i < gs_app_list_length (data->apps); i++) {
+ GsApp *app = gs_app_list_index (data->apps, i);
+ gboolean is_featured, is_recently_updated, is_hi_res;
+
+ is_featured = (data->featured_app_ids != NULL &&
+ g_hash_table_contains (data->featured_app_ids, gs_app_get_id (app)));
+ is_recently_updated = (gs_app_get_release_date (app) > recently_updated_cutoff_secs);
+ is_hi_res = app_has_hi_res_icon (data->page, app);
+
+ if ((is_featured || is_recently_updated) && is_hi_res)
+ g_ptr_array_add (candidates, app);
+ }
+
+ /* If there aren’t enough candidate apps to populate the top carousel,
+ * return an empty app list. */
+ if (candidates->len < n_top_carousel_apps) {
+ g_debug ("Only %u candidate apps for top carousel; returning empty", candidates->len);
+ goto out;
+ }
+
+ /* Select @n_top_carousel_apps from @candidates uniformly randomly
+ * without replacement. */
+ for (guint i = 0; i < n_top_carousel_apps; i++) {
+ guint random_index = g_rand_int_range (top_carousel_rand, 0, candidates->len);
+ GsApp *app = g_ptr_array_index (candidates, random_index);
+
+ gs_app_list_add (top_carousel_apps, app);
+ g_ptr_array_remove_index_fast (candidates, random_index);
+ }
+
+ out:
+ g_assert (gs_app_list_length (top_carousel_apps) == 0 ||
+ gs_app_list_length (top_carousel_apps) == n_top_carousel_apps);
+
+ return g_steal_pointer (&top_carousel_apps);
+}
+
+static gint
+compare_release_date_cb (gconstpointer aa,
+ gconstpointer bb)
+{
+ GsApp *app_a = gs_app_tile_get_app ((GsAppTile *) aa);
+ GsApp *app_b = gs_app_tile_get_app ((GsAppTile *) bb);
+ guint64 release_date_a = gs_app_get_release_date (app_a);
+ guint64 release_date_b = gs_app_get_release_date (app_b);
+
+ if (release_date_a == release_date_b)
+ return g_utf8_collate (gs_app_get_name (app_a), gs_app_get_name (app_b));
+
+ return release_date_a < release_date_b ? -1 : 1;
+}
+
+static void
+load_category_finish (LoadCategoryData *data)
+{
+ GsCategoryPage *self = data->page;
+ guint64 recently_updated_cutoff_secs;
+ guint64 n_recently_updated = 0;
+ guint64 min_release_date = G_MAXUINT64;
+ GSList *recently_updated = NULL, *link;
+ g_autoptr(GsAppList) top_carousel_apps = NULL;
+
+ if (!data->get_featured_apps_finished ||
+ !data->get_main_apps_finished)
+ return;
+
+ /* Remove the loading tiles. */
+ gs_widget_remove_all (self->featured_flow_box, (GsRemoveFunc) gtk_flow_box_remove);
+ gs_widget_remove_all (self->recently_updated_flow_box, (GsRemoveFunc) gtk_flow_box_remove);
+ gs_widget_remove_all (self->web_apps_flow_box, (GsRemoveFunc) gtk_flow_box_remove);
+ gs_widget_remove_all (self->category_detail_box, (GsRemoveFunc) gtk_flow_box_remove);
+
+ /* Last 30 days */
+ recently_updated_cutoff_secs = g_get_real_time () / G_USEC_PER_SEC - 30 * 24 * 60 * 60;
+
+ /* Apps to go in the top carousel */
+ top_carousel_apps = choose_top_carousel_apps (data, recently_updated_cutoff_secs);
+
+ for (guint i = 0; i < gs_app_list_length (data->apps); i++) {
+ GsApp *app = gs_app_list_index (data->apps, i);
+ gboolean is_featured, is_recently_updated;
+ guint64 release_date;
+ GtkWidget *flow_box = self->category_detail_box;
+ GtkWidget *tile;
+
+ /* To be listed in the top carousel? */
+ if (gs_app_list_lookup (top_carousel_apps, gs_app_get_unique_id (app)) != NULL)
+ continue;
+
+ release_date = gs_app_get_release_date (app);
+ is_featured = (data->featured_app_ids != NULL &&
+ g_hash_table_contains (data->featured_app_ids, gs_app_get_id (app)));
+ is_recently_updated = (release_date > recently_updated_cutoff_secs);
+
+ tile = gs_summary_tile_new (app);
+ g_signal_connect (tile, "clicked",
+ G_CALLBACK (app_tile_clicked), self);
+
+ if (is_featured) {
+ flow_box = self->featured_flow_box;
+ } else if (is_recently_updated) {
+ if (n_recently_updated < MAX_RECENTLY_UPDATED_APPS) {
+ recently_updated = g_slist_insert_sorted (recently_updated, tile, compare_release_date_cb);
+ n_recently_updated++;
+ if (min_release_date > release_date)
+ min_release_date = release_date;
+ flow_box = NULL;
+ } else if (release_date >= min_release_date) {
+ recently_updated = g_slist_insert_sorted (recently_updated, tile, compare_release_date_cb);
+ tile = recently_updated->data;
+ recently_updated = g_slist_remove (recently_updated, tile);
+ min_release_date = gs_app_get_release_date (gs_app_tile_get_app (GS_APP_TILE (recently_updated->data)));
+ }
+ } else if (gs_app_get_kind (app) == AS_COMPONENT_KIND_WEB_APP) {
+ flow_box = self->web_apps_flow_box;
+ }
+
+ if (flow_box != NULL) {
+ gtk_flow_box_insert (GTK_FLOW_BOX (flow_box), tile, -1);
+ gtk_widget_set_can_focus (gtk_widget_get_parent (tile), FALSE);
+ }
+ }
+
+ for (link = recently_updated; link != NULL; link = g_slist_next (link)) {
+ GtkWidget *tile = link->data;
+ gtk_flow_box_insert (GTK_FLOW_BOX (self->recently_updated_flow_box), tile, -1);
+ gtk_widget_set_can_focus (gtk_widget_get_parent (tile), FALSE);
+ }
+
+ g_slist_free (recently_updated);
+
+ gtk_widget_set_visible (self->top_carousel, gs_app_list_length (top_carousel_apps) > 0);
+ gs_featured_carousel_set_apps (GS_FEATURED_CAROUSEL (self->top_carousel), top_carousel_apps);
+
+ /* Show each of the flow boxes if they have any children. */
+ gtk_widget_set_visible (self->featured_flow_box, gtk_flow_box_get_child_at_index (GTK_FLOW_BOX (self->featured_flow_box), 0) != NULL);
+ gtk_widget_set_visible (self->recently_updated_flow_box, gtk_flow_box_get_child_at_index (GTK_FLOW_BOX (self->recently_updated_flow_box), 0) != NULL);
+ gtk_widget_set_visible (self->web_apps_flow_box, gtk_flow_box_get_child_at_index (GTK_FLOW_BOX (self->web_apps_flow_box), 0) != NULL);
+ gtk_widget_set_visible (self->category_detail_box, gtk_flow_box_get_child_at_index (GTK_FLOW_BOX (self->category_detail_box), 0) != NULL);
+
+ load_category_data_free (data);
+}
+
+static void
+gs_category_page_load_category (GsCategoryPage *self)
+{
+ GsCategory *featured_subcat = NULL;
+ GtkAdjustment *adj = NULL;
+ g_autoptr(GsPluginJob) featured_plugin_job = NULL;
+ g_autoptr(GsAppQuery) main_query = NULL;
+ g_autoptr(GsPluginJob) main_plugin_job = NULL;
+ LoadCategoryData *load_data = NULL;
+
+ g_assert (self->subcategory != NULL);
+
+ featured_subcat = gs_category_find_child (self->category, "featured");
+
+ g_cancellable_cancel (self->cancellable);
+ g_clear_object (&self->cancellable);
+ self->cancellable = g_cancellable_new ();
+
+ g_debug ("search using %s/%s",
+ gs_category_get_id (self->category),
+ gs_category_get_id (self->subcategory));
+
+ gs_featured_carousel_set_apps (GS_FEATURED_CAROUSEL (self->top_carousel), NULL);
+ gtk_widget_show (self->top_carousel);
+ gs_category_page_add_placeholders (self, GTK_FLOW_BOX (self->category_detail_box),
+ MIN (30, gs_category_get_size (self->subcategory)));
+ gs_category_page_add_placeholders (self, GTK_FLOW_BOX (self->recently_updated_flow_box), MAX_RECENTLY_UPDATED_APPS);
+
+ if (gs_plugin_loader_get_enabled (self->plugin_loader, "epiphany"))
+ gs_category_page_add_placeholders (self, GTK_FLOW_BOX (self->web_apps_flow_box), 12);
+
+ if (featured_subcat != NULL) {
+ /* set up the placeholders as having the featured category is a good
+ * indicator that there will be featured apps */
+ gs_category_page_add_placeholders (self, GTK_FLOW_BOX (self->featured_flow_box), 6);
+ gtk_widget_show (self->top_carousel);
+ } else {
+ gs_widget_remove_all (self->featured_flow_box, (GsRemoveFunc) gtk_flow_box_remove);
+ gtk_widget_hide (self->featured_flow_box);
+ gtk_widget_hide (self->top_carousel);
+ }
+
+ /* Load the list of apps in the category, and also the list of all
+ * featured apps, in parallel.
+ *
+ * The list of featured apps has to be loaded separately (we can’t just
+ * query each app for its featured status) since it’s provided by a
+ * separate appstream file (org.gnome.Software.Featured.xml) and hence
+ * produces separate `GsApp` instances with stub data. In particular,
+ * they don’t have enough category data to match the main category
+ * query.
+ *
+ * Once both queries have returned, turn the list of featured apps into
+ * a filter, and split the main list in four:
+ * - Featured apps
+ * - Recently updated apps
+ * - Web apps
+ * - Everything else
+ * Then populate the UI.
+ *
+ * The `featured_subcat` can be `NULL` when loading the special ‘addons’
+ * category.
+ */
+ load_data = g_new0 (LoadCategoryData, 1);
+ load_data->page = g_object_ref (self);
+
+ if (featured_subcat != NULL) {
+ g_autoptr(GsAppQuery) featured_query = NULL;
+
+ featured_query = gs_app_query_new ("category", featured_subcat,
+ "refine-flags", GS_PLUGIN_REFINE_FLAGS_REQUIRE_KUDOS,
+ "sort-func", gs_utils_app_sort_name,
+ NULL);
+ featured_plugin_job = gs_plugin_job_list_apps_new (featured_query, GS_PLUGIN_LIST_APPS_FLAGS_INTERACTIVE);
+ gs_plugin_loader_job_process_async (self->plugin_loader,
+ featured_plugin_job,
+ self->cancellable,
+ gs_category_page_get_featured_apps_cb,
+ load_data);
+ } else {
+ /* Skip it */
+ load_data->get_featured_apps_finished = TRUE;
+ }
+
+ main_query = gs_app_query_new ("category", self->subcategory,
+ "refine-flags", GS_PLUGIN_REFINE_FLAGS_REQUIRE_ICON |
+ GS_PLUGIN_REFINE_FLAGS_REQUIRE_RATING |
+ GS_PLUGIN_REFINE_FLAGS_REQUIRE_KUDOS,
+ "dedupe-flags", GS_APP_LIST_FILTER_FLAG_PREFER_INSTALLED |
+ GS_APP_LIST_FILTER_FLAG_KEY_ID_PROVIDES,
+ "sort-func", _max_results_sort_cb,
+ NULL);
+ main_plugin_job = gs_plugin_job_list_apps_new (main_query, GS_PLUGIN_LIST_APPS_FLAGS_INTERACTIVE);
+ gs_plugin_loader_job_process_async (self->plugin_loader,
+ main_plugin_job,
+ self->cancellable,
+ gs_category_page_get_apps_cb,
+ load_data);
+
+ /* scroll the list of apps to the beginning, otherwise it will show
+ * with the previous scroll value */
+ adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (self->scrolledwindow_category));
+ gtk_adjustment_set_value (adj, gtk_adjustment_get_lower (adj));
+}
+
+static void
+gs_category_page_reload (GsPage *page)
+{
+ GsCategoryPage *self = GS_CATEGORY_PAGE (page);
+
+ if (self->subcategory == NULL)
+ return;
+
+ gs_category_page_load_category (self);
+}
+
+void
+gs_category_page_set_category (GsCategoryPage *self, GsCategory *category)
+{
+ GsCategory *all_subcat = NULL;
+
+ /* this means we've come from the app-view -> back */
+ if (self->category == category)
+ return;
+
+ /* set the category */
+ all_subcat = gs_category_find_child (category, "all");
+
+ g_set_object (&self->category, category);
+ g_set_object (&self->subcategory, all_subcat);
+
+ /* load the apps from it */
+ if (all_subcat != NULL)
+ gs_category_page_load_category (self);
+
+ /* notify of the updates — the category’s title will have changed too */
+ g_object_notify (G_OBJECT (self), "category");
+ g_object_notify (G_OBJECT (self), "title");
+}
+
+GsCategory *
+gs_category_page_get_category (GsCategoryPage *self)
+{
+ return self->category;
+}
+
+static gint
+recently_updated_sort_cb (GtkFlowBoxChild *child1,
+ GtkFlowBoxChild *child2,
+ gpointer user_data)
+{
+ GsSummaryTile *tile1 = GS_SUMMARY_TILE (gtk_flow_box_child_get_child (child1));
+ GsSummaryTile *tile2 = GS_SUMMARY_TILE (gtk_flow_box_child_get_child (child2));
+ GsApp *app1 = gs_app_tile_get_app (GS_APP_TILE (tile1));
+ GsApp *app2 = gs_app_tile_get_app (GS_APP_TILE (tile2));
+ guint64 release_date1 = 0, release_date2 = 0;
+
+ /* Placeholder tiles have no app. */
+ if (app1 != NULL)
+ release_date1 = gs_app_get_release_date (app1);
+ if (app2 != NULL)
+ release_date2 = gs_app_get_release_date (app2);
+
+ /* Don’t use the normal subtraction trick, as there’s the possibility
+ * for overflow in the conversion from guint64 to gint. */
+ if (release_date1 > release_date2)
+ return -1;
+ else if (release_date2 > release_date1)
+ return 1;
+ else
+ return 0;
+}
+
+static void
+gs_category_page_init (GsCategoryPage *self)
+{
+ gtk_widget_init_template (GTK_WIDGET (self));
+
+ /* Sort the recently updated apps by update date. */
+ gtk_flow_box_set_sort_func (GTK_FLOW_BOX (self->recently_updated_flow_box),
+ recently_updated_sort_cb,
+ NULL,
+ NULL);
+
+ gs_featured_carousel_set_apps (GS_FEATURED_CAROUSEL (self->top_carousel), NULL);
+}
+
+static void
+gs_category_page_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GsCategoryPage *self = GS_CATEGORY_PAGE (object);
+
+ switch ((GsCategoryPageProperty) prop_id) {
+ case PROP_TITLE:
+ if (self->category != NULL)
+ g_value_set_string (value, gs_category_get_name (self->category));
+ else
+ g_value_set_string (value, NULL);
+ break;
+ case PROP_CATEGORY:
+ g_value_set_object (value, self->category);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gs_category_page_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GsCategoryPage *self = GS_CATEGORY_PAGE (object);
+
+ switch ((GsCategoryPageProperty) prop_id) {
+ case PROP_TITLE:
+ /* Read only */
+ g_assert_not_reached ();
+ break;
+ case PROP_CATEGORY:
+ gs_category_page_set_category (self, g_value_get_object (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gs_category_page_dispose (GObject *object)
+{
+ GsCategoryPage *self = GS_CATEGORY_PAGE (object);
+
+ g_cancellable_cancel (self->cancellable);
+ g_clear_object (&self->cancellable);
+
+ g_clear_object (&self->category);
+ g_clear_object (&self->subcategory);
+ g_clear_object (&self->plugin_loader);
+
+ G_OBJECT_CLASS (gs_category_page_parent_class)->dispose (object);
+}
+
+static gboolean
+gs_category_page_setup (GsPage *page,
+ GsShell *shell,
+ GsPluginLoader *plugin_loader,
+ GCancellable *cancellable,
+ GError **error)
+{
+ GsCategoryPage *self = GS_CATEGORY_PAGE (page);
+
+ self->plugin_loader = g_object_ref (plugin_loader);
+
+ return TRUE;
+}
+
+static void
+gs_category_page_class_init (GsCategoryPageClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GsPageClass *page_class = GS_PAGE_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+ object_class->get_property = gs_category_page_get_property;
+ object_class->set_property = gs_category_page_set_property;
+ object_class->dispose = gs_category_page_dispose;
+
+ page_class->reload = gs_category_page_reload;
+ page_class->setup = gs_category_page_setup;
+
+ /**
+ * GsCategoryPage:category: (nullable)
+ *
+ * The category to display the apps from.
+ *
+ * This may be %NULL if no category is selected. If so, the behaviour
+ * of the widget will be safe, but undefined.
+ *
+ * Since: 41
+ */
+ obj_props[PROP_CATEGORY] =
+ g_param_spec_object ("category", NULL, NULL,
+ GS_TYPE_CATEGORY,
+ G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+ g_object_class_install_properties (object_class, G_N_ELEMENTS (obj_props), obj_props);
+
+ g_object_class_override_property (object_class, PROP_TITLE, "title");
+
+ /**
+ * GsCategoryPage::app-clicked:
+ * @app: the #GsApp which was clicked on
+ *
+ * Emitted when one of the app tiles is clicked. Typically the caller
+ * should display the details of the given app in the callback.
+ *
+ * Since: 41
+ */
+ obj_signals[SIGNAL_APP_CLICKED] =
+ g_signal_new ("app-clicked",
+ G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST,
+ 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT,
+ G_TYPE_NONE, 1, GS_TYPE_APP);
+
+ gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/Software/gs-category-page.ui");
+
+ gtk_widget_class_bind_template_child (widget_class, GsCategoryPage, top_carousel);
+ gtk_widget_class_bind_template_child (widget_class, GsCategoryPage, category_detail_box);
+ gtk_widget_class_bind_template_child (widget_class, GsCategoryPage, scrolledwindow_category);
+ gtk_widget_class_bind_template_child (widget_class, GsCategoryPage, featured_flow_box);
+ gtk_widget_class_bind_template_child (widget_class, GsCategoryPage, recently_updated_flow_box);
+ gtk_widget_class_bind_template_child (widget_class, GsCategoryPage, web_apps_flow_box);
+
+ gtk_widget_class_bind_template_callback (widget_class, top_carousel_app_clicked_cb);
+}
+
+GsCategoryPage *
+gs_category_page_new (void)
+{
+ return g_object_new (GS_TYPE_CATEGORY_PAGE, NULL);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-06 02:22:38 +0000