From: Benjamin Otte Date: Mon, 13 Mar 2023 16:39:52 +0000 (+0100) Subject: columnviewrowwidget: Drop unneeded stuff X-Git-Tag: archive/raspbian/4.12.3+ds-1+rpi1~1^2^2^2~22^2~1^2~514^2~6 X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=3a6bfe9e9ddfbe7bf336d3a489900e3868e617e3;p=gtk4.git columnviewrowwidget: Drop unneeded stuff Also remove the GtkColumnListItemFactory and GtkColumnViewLayout objects by folding them into GtkColumnViewRowWidget. --- diff --git a/gtk/gtkcolumnlistitemfactory.c b/gtk/gtkcolumnlistitemfactory.c deleted file mode 100644 index cbf80b34be..0000000000 --- a/gtk/gtkcolumnlistitemfactory.c +++ /dev/null @@ -1,181 +0,0 @@ -/* - * Copyright © 2019 Benjamin Otte - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - * Authors: Benjamin Otte - */ - -#include "config.h" - -#include "gtkcolumnlistitemfactoryprivate.h" - -#include "gtkboxlayout.h" -#include "gtkcolumnviewcolumnprivate.h" -#include "gtkcolumnviewlayoutprivate.h" -#include "gtklistitemfactoryprivate.h" -#include "gtklistitemprivate.h" - -struct _GtkColumnListItemFactory -{ - GtkListItemFactory parent_instance; - - GtkColumnView *view; /* no reference, the view references us */ -}; - -struct _GtkColumnListItemFactoryClass -{ - GtkListItemFactoryClass parent_class; -}; - -G_DEFINE_TYPE (GtkColumnListItemFactory, gtk_column_list_item_factory, GTK_TYPE_LIST_ITEM_FACTORY) - -static void -gtk_column_list_item_factory_setup (GtkListItemFactory *factory, - GObject *item, - gboolean bind, - GFunc func, - gpointer data) -{ - GtkColumnListItemFactory *self = GTK_COLUMN_LIST_ITEM_FACTORY (factory); - GtkColumnViewRowWidget *widget = data; - GListModel *columns; - guint i; - - /* FIXME: evil */ - gtk_widget_set_layout_manager (GTK_WIDGET (widget), - gtk_column_view_layout_new (self->view)); - - GTK_LIST_ITEM_FACTORY_CLASS (gtk_column_list_item_factory_parent_class)->setup (factory, item, bind, func, data); - - columns = gtk_column_view_get_columns (self->view); - - for (i = 0; i < g_list_model_get_n_items (columns); i++) - { - GtkColumnViewColumn *column = g_list_model_get_item (columns, i); - - if (gtk_column_view_column_get_visible (column)) - gtk_column_list_item_factory_add_column (self, - widget, - column, - FALSE); - - g_object_unref (column); - } -} - -static void -gtk_column_list_item_factory_teardown (GtkListItemFactory *factory, - GObject *item, - gboolean unbind, - GFunc func, - gpointer data) -{ - GtkColumnViewRowWidget *widget = data; - GtkWidget *child; - - GTK_LIST_ITEM_FACTORY_CLASS (gtk_column_list_item_factory_parent_class)->teardown (factory, item, unbind, func, data); - - while ((child = gtk_widget_get_first_child (GTK_WIDGET (widget)))) - { - gtk_column_view_row_widget_remove_child (GTK_COLUMN_VIEW_ROW_WIDGET (widget), child); - } -} - -static void -gtk_column_list_item_factory_update (GtkListItemFactory *factory, - GObject *item, - gboolean unbind, - gboolean bind, - GFunc func, - gpointer data) -{ - GtkListItem *list_item = GTK_LIST_ITEM (item); - GtkWidget *child; - gboolean selectable = TRUE; - gboolean activatable = TRUE; - - GTK_LIST_ITEM_FACTORY_CLASS (gtk_column_list_item_factory_parent_class)->update (factory, item, unbind, bind, func, data); - - for (child = gtk_widget_get_first_child (GTK_WIDGET (list_item->owner)); - child; - child = gtk_widget_get_next_sibling (child)) - { - GtkListItem *cell_item; - - gtk_list_item_base_update (GTK_LIST_ITEM_BASE (child), - gtk_list_item_get_position (list_item), - gtk_list_item_get_item (list_item), - gtk_list_item_get_selected (list_item)); - - cell_item = gtk_list_factory_widget_get_object (GTK_LIST_FACTORY_WIDGET (child)); - if (cell_item) - { - selectable &= gtk_list_item_get_selectable (cell_item); - activatable &= gtk_list_item_get_activatable (cell_item); - } - } - - /* This really does not belong here, but doing better - * requires considerable plumbing that we don't have now, - * and something like this is needed to fix the filechooser - * in select_folder mode. - */ - gtk_list_item_set_selectable (list_item, selectable); - gtk_list_item_set_activatable (list_item, activatable); -} - -static void -gtk_column_list_item_factory_class_init (GtkColumnListItemFactoryClass *klass) -{ - GtkListItemFactoryClass *factory_class = GTK_LIST_ITEM_FACTORY_CLASS (klass); - - factory_class->setup = gtk_column_list_item_factory_setup; - factory_class->teardown = gtk_column_list_item_factory_teardown; - factory_class->update = gtk_column_list_item_factory_update; -} - -static void -gtk_column_list_item_factory_init (GtkColumnListItemFactory *self) -{ -} - -GtkColumnListItemFactory * -gtk_column_list_item_factory_new (GtkColumnView *view) -{ - GtkColumnListItemFactory *result; - - result = g_object_new (GTK_TYPE_COLUMN_LIST_ITEM_FACTORY, NULL); - - result->view = view; - - return result; -} - -void -gtk_column_list_item_factory_add_column (GtkColumnListItemFactory *factory, - GtkColumnViewRowWidget *list_item, - GtkColumnViewColumn *column, - gboolean check_bind) -{ - GtkListItemBase *base = GTK_LIST_ITEM_BASE (list_item); - GtkWidget *cell; - - cell = gtk_column_view_cell_new (column); - gtk_column_view_row_widget_add_child (GTK_COLUMN_VIEW_ROW_WIDGET (list_item), GTK_WIDGET (cell)); - gtk_list_item_base_update (GTK_LIST_ITEM_BASE (cell), - gtk_list_item_base_get_position (base), - gtk_list_item_base_get_item (base), - gtk_list_item_base_get_selected (base)); -} diff --git a/gtk/gtkcolumnlistitemfactoryprivate.h b/gtk/gtkcolumnlistitemfactoryprivate.h deleted file mode 100644 index 320502b4e5..0000000000 --- a/gtk/gtkcolumnlistitemfactoryprivate.h +++ /dev/null @@ -1,62 +0,0 @@ -/* - * Copyright © 2019 Benjamin Otte - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - * Authors: Benjamin Otte - */ - -#ifndef __GTK_COLUMN_LIST_ITEM_FACTORY_H__ -#define __GTK_COLUMN_LIST_ITEM_FACTORY_H__ - -#include -#include - -G_BEGIN_DECLS - -#define GTK_TYPE_COLUMN_LIST_ITEM_FACTORY (gtk_column_list_item_factory_get_type ()) -#define GTK_COLUMN_LIST_ITEM_FACTORY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_COLUMN_LIST_ITEM_FACTORY, GtkColumnListItemFactory)) -#define GTK_COLUMN_LIST_ITEM_FACTORY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_COLUMN_LIST_ITEM_FACTORY, GtkColumnListItemFactoryClass)) -#define GTK_IS_COLUMN_LIST_ITEM_FACTORY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_COLUMN_LIST_ITEM_FACTORY)) -#define GTK_IS_COLUMN_LIST_ITEM_FACTORY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_COLUMN_LIST_ITEM_FACTORY)) -#define GTK_COLUMN_LIST_ITEM_FACTORY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_COLUMN_LIST_ITEM_FACTORY, GtkColumnListItemFactoryClass)) - -/** - * GtkColumnListItemFactory: - * - * The object for the `GtkColumnListItemFactory`. - **/ -typedef struct _GtkColumnListItemFactory GtkColumnListItemFactory; -typedef struct _GtkColumnListItemFactoryClass GtkColumnListItemFactoryClass; - - -GType gtk_column_list_item_factory_get_type (void) G_GNUC_CONST; - -GtkColumnListItemFactory * - gtk_column_list_item_factory_new (GtkColumnView *view); - -void gtk_column_list_item_factory_add_column (GtkColumnListItemFactory *factory, - GtkColumnViewRowWidget *list_item, - GtkColumnViewColumn *column, - gboolean check_bind); -void gtk_column_list_item_factory_remove_column - (GtkColumnListItemFactory *factory, - GtkColumnViewRowWidget *list_item, - guint col_pos, - GtkColumnViewColumn *column); - - -G_END_DECLS - -#endif /* __GTK_COLUMN_LIST_ITEM_FACTORY_H__ */ diff --git a/gtk/gtkcolumnview.c b/gtk/gtkcolumnview.c index 46878f5bbe..e564a12d4e 100644 --- a/gtk/gtkcolumnview.c +++ b/gtk/gtkcolumnview.c @@ -23,9 +23,7 @@ #include "gtkboxlayout.h" #include "gtkbuildable.h" -#include "gtkcolumnlistitemfactoryprivate.h" #include "gtkcolumnviewcolumnprivate.h" -#include "gtkcolumnviewlayoutprivate.h" #include "gtkcolumnviewsorterprivate.h" #include "gtkcssnodeprivate.h" #include "gtkdropcontrollermotion.h" @@ -142,9 +140,7 @@ gtk_column_list_view_create_list_widget (GtkListBase *base) GtkListView *self = GTK_LIST_VIEW (base); GtkWidget *result; - result = gtk_column_view_row_widget_new (self->factory, - "row", - GTK_ACCESSIBLE_ROLE_ROW); + result = gtk_column_view_row_widget_new (FALSE); gtk_list_factory_widget_set_single_click_activate (GTK_LIST_FACTORY_WIDGET (result), self->single_click_activate); @@ -173,7 +169,6 @@ struct _GtkColumnView GtkWidget *header; GtkListView *listview; - GtkColumnListItemFactory *factory; GtkSorter *sorter; @@ -503,7 +498,6 @@ gtk_column_view_dispose (GObject *object) g_clear_pointer (&self->header, gtk_widget_unparent); g_clear_pointer ((GtkWidget **) &self->listview, gtk_widget_unparent); - g_clear_object (&self->factory); g_clear_object (&self->sorter); clear_adjustment (self); @@ -1288,9 +1282,8 @@ gtk_column_view_init (GtkColumnView *self) self->columns = g_list_store_new (GTK_TYPE_COLUMN_VIEW_COLUMN); - self->header = gtk_column_view_row_widget_new (NULL, "header", GTK_ACCESSIBLE_ROLE_ROW); + self->header = gtk_column_view_row_widget_new (TRUE); gtk_widget_set_can_focus (self->header, FALSE); - gtk_widget_set_layout_manager (self->header, gtk_column_view_layout_new (self)); gtk_widget_set_parent (self->header, GTK_WIDGET (self)); controller = GTK_EVENT_CONTROLLER (gtk_gesture_click_new ()); @@ -1320,9 +1313,7 @@ gtk_column_view_init (GtkColumnView *self) gtk_widget_add_controller (GTK_WIDGET (self), controller); self->sorter = GTK_SORTER (gtk_column_view_sorter_new ()); - self->factory = gtk_column_list_item_factory_new (self); self->listview = GTK_LIST_VIEW (g_object_new (GTK_TYPE_COLUMN_LIST_VIEW, NULL)); - gtk_list_view_set_factory (self->listview, GTK_LIST_ITEM_FACTORY (self->factory)); gtk_widget_set_hexpand (GTK_WIDGET (self->listview), TRUE); gtk_widget_set_vexpand (GTK_WIDGET (self->listview), TRUE); g_signal_connect (self->listview, "activate", G_CALLBACK (gtk_column_view_activate_cb), self); diff --git a/gtk/gtkcolumnviewlayout.c b/gtk/gtkcolumnviewlayout.c deleted file mode 100644 index 6f9dfdb13c..0000000000 --- a/gtk/gtkcolumnviewlayout.c +++ /dev/null @@ -1,177 +0,0 @@ -/* - * Copyright © 2019 Benjamin Otte - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - * Authors: Benjamin Otte - */ - -#include "config.h" - -#include "gtkcolumnviewlayoutprivate.h" - -#include "gtkcolumnviewcellprivate.h" -#include "gtkcolumnviewcolumnprivate.h" -#include "gtkcolumnviewprivate.h" -#include "gtkcolumnviewtitleprivate.h" -#include "gtkwidgetprivate.h" - -struct _GtkColumnViewLayout -{ - GtkLayoutManager parent_instance; - - GtkColumnView *view; /* no reference */ -}; - -G_DEFINE_TYPE (GtkColumnViewLayout, gtk_column_view_layout, GTK_TYPE_LAYOUT_MANAGER) - -static void -gtk_column_view_layout_measure_along (GtkColumnViewLayout *self, - GtkWidget *widget, - int for_size, - int *minimum, - int *natural, - int *minimum_baseline, - int *natural_baseline) -{ - GtkOrientation orientation = GTK_ORIENTATION_VERTICAL; - GtkWidget *child; - guint i, n; - GtkRequestedSize *sizes = NULL; - - if (for_size > -1) - { - n = g_list_model_get_n_items (gtk_column_view_get_columns (self->view)); - sizes = g_newa (GtkRequestedSize, n); - gtk_column_view_distribute_width (self->view, for_size, sizes); - } - - for (child = _gtk_widget_get_first_child (widget), i = 0; - child != NULL; - child = _gtk_widget_get_next_sibling (child), i++) - { - int child_min = 0; - int child_nat = 0; - int child_min_baseline = -1; - int child_nat_baseline = -1; - - if (!gtk_widget_should_layout (child)) - continue; - - gtk_widget_measure (child, orientation, - for_size > -1 ? sizes[i].minimum_size : -1, - &child_min, &child_nat, - &child_min_baseline, &child_nat_baseline); - - *minimum = MAX (*minimum, child_min); - *natural = MAX (*natural, child_nat); - - if (child_min_baseline > -1) - *minimum_baseline = MAX (*minimum_baseline, child_min_baseline); - if (child_nat_baseline > -1) - *natural_baseline = MAX (*natural_baseline, child_nat_baseline); - } -} - -static void -gtk_column_view_layout_measure (GtkLayoutManager *layout, - GtkWidget *widget, - GtkOrientation orientation, - int for_size, - int *minimum, - int *natural, - int *minimum_baseline, - int *natural_baseline) -{ - GtkColumnViewLayout *self = GTK_COLUMN_VIEW_LAYOUT (layout); - - if (orientation == GTK_ORIENTATION_HORIZONTAL) - { - gtk_column_view_measure_across (GTK_COLUMN_VIEW (self->view), - minimum, - natural); - } - else - { - gtk_column_view_layout_measure_along (self, - widget, - for_size, - minimum, - natural, - minimum_baseline, - natural_baseline); - } -} - -static void -gtk_column_view_layout_allocate (GtkLayoutManager *layout_manager, - GtkWidget *widget, - int width, - int height, - int baseline) -{ - GtkWidget *child; - - for (child = _gtk_widget_get_first_child (widget); - child != NULL; - child = _gtk_widget_get_next_sibling (child)) - { - GtkColumnViewColumn *column; - int col_x, col_width, min; - - if (!gtk_widget_should_layout (child)) - continue; - - if (GTK_IS_COLUMN_VIEW_CELL (child)) - { - column = gtk_column_view_cell_get_column (GTK_COLUMN_VIEW_CELL (child)); - gtk_column_view_column_get_allocation (column, &col_x, &col_width); - } - else - { - column = gtk_column_view_title_get_column (GTK_COLUMN_VIEW_TITLE (child)); - gtk_column_view_column_get_header_allocation (column, &col_x, &col_width); - } - - gtk_widget_measure (child, GTK_ORIENTATION_HORIZONTAL, -1, &min, NULL, NULL, NULL); - - gtk_widget_size_allocate (child, &(GtkAllocation) { col_x, 0, MAX (min, col_width), height }, baseline); - } -} - -static void -gtk_column_view_layout_class_init (GtkColumnViewLayoutClass *klass) -{ - GtkLayoutManagerClass *layout_manager_class = GTK_LAYOUT_MANAGER_CLASS (klass); - - layout_manager_class->measure = gtk_column_view_layout_measure; - layout_manager_class->allocate = gtk_column_view_layout_allocate; -} - -static void -gtk_column_view_layout_init (GtkColumnViewLayout *self) -{ -} - -GtkLayoutManager * -gtk_column_view_layout_new (GtkColumnView *view) -{ - GtkColumnViewLayout *result; - - result = g_object_new (GTK_TYPE_COLUMN_VIEW_LAYOUT, NULL); - - result->view = view; - - return GTK_LAYOUT_MANAGER (result); -} diff --git a/gtk/gtkcolumnviewlayoutprivate.h b/gtk/gtkcolumnviewlayoutprivate.h deleted file mode 100644 index 6e786cdbd5..0000000000 --- a/gtk/gtkcolumnviewlayoutprivate.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright © 2019 Benjamin Otte - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - * Authors: Benjamin Otte - */ - -#ifndef __GTK_COLUMN_VIEW_LAYOUT_PRIVATE_H__ -#define __GTK_COLUMN_VIEW_LAYOUT_PRIVATE_H__ - -#include -#include - -G_BEGIN_DECLS - -#define GTK_TYPE_COLUMN_VIEW_LAYOUT (gtk_column_view_layout_get_type ()) - -G_DECLARE_FINAL_TYPE (GtkColumnViewLayout, gtk_column_view_layout, GTK, COLUMN_VIEW_LAYOUT, GtkLayoutManager) - -GtkLayoutManager * gtk_column_view_layout_new (GtkColumnView *view); - - -#endif /* __GTK_COLUMN_VIEW_LAYOUT_PRIVATE_H__ */ diff --git a/gtk/gtkcolumnviewrowwidget.c b/gtk/gtkcolumnviewrowwidget.c index 06a57b9d11..2bd47337aa 100644 --- a/gtk/gtkcolumnviewrowwidget.c +++ b/gtk/gtkcolumnviewrowwidget.c @@ -1,5 +1,5 @@ /* - * Copyright © 2018 Benjamin Otte + * Copyright © 2023 Benjamin Otte * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -22,6 +22,10 @@ #include "gtkcolumnviewrowwidgetprivate.h" #include "gtkbinlayout.h" +#include "gtkcolumnviewprivate.h" +#include "gtkcolumnviewcellprivate.h" +#include "gtkcolumnviewcolumnprivate.h" +#include "gtkcolumnviewtitleprivate.h" #include "gtklistitemfactoryprivate.h" #include "gtklistbaseprivate.h" #include "gtkwidget.h" @@ -29,6 +33,64 @@ G_DEFINE_TYPE (GtkColumnViewRowWidget, gtk_column_view_row_widget, GTK_TYPE_LIST_FACTORY_WIDGET) +static GtkColumnView * +gtk_column_view_row_widget_get_column_view (GtkColumnViewRowWidget *self) +{ + GtkWidget *parent = _gtk_widget_get_parent (GTK_WIDGET (self)); + + if (GTK_IS_COLUMN_VIEW (parent)) + return GTK_COLUMN_VIEW (parent); + + parent = _gtk_widget_get_parent (parent); + g_assert (GTK_IS_COLUMN_VIEW (parent)); + + return GTK_COLUMN_VIEW (parent); +} + +static gboolean +gtk_column_view_row_widget_is_header (GtkColumnViewRowWidget *self) +{ + return gtk_widget_get_css_name (GTK_WIDGET (self)) == g_intern_static_string ("header"); +} + +static void +gtk_column_view_row_widget_update (GtkListItemBase *base, + guint position, + gpointer item, + gboolean selected) +{ + GtkColumnViewRowWidget *self = GTK_COLUMN_VIEW_ROW_WIDGET (base); + GtkListFactoryWidget *fw = GTK_LIST_FACTORY_WIDGET (base); + gboolean selectable, activatable; + GtkWidget *child; + + if (gtk_column_view_row_widget_is_header (self)) + return; + + GTK_LIST_ITEM_BASE_CLASS (gtk_column_view_row_widget_parent_class)->update (base, position, item, selected); + + /* This really does not belong here, but doing better + * requires considerable plumbing that we don't have now, + * and something like this is needed to fix the filechooser + * in select_folder mode. + */ + selectable = TRUE; + activatable = TRUE; + + for (child = gtk_widget_get_first_child (GTK_WIDGET (self)); + child; + child = gtk_widget_get_next_sibling (child)) + { + gtk_list_item_base_update (GTK_LIST_ITEM_BASE (child), position, item, selected); + + selectable &= gtk_list_factory_widget_get_selectable (GTK_LIST_FACTORY_WIDGET (child)); + activatable &= gtk_list_factory_widget_get_activatable (GTK_LIST_FACTORY_WIDGET (child)); + } + + gtk_list_factory_widget_set_selectable (fw, selectable); + gtk_list_factory_widget_set_activatable (fw, activatable); +} + static gboolean gtk_column_view_row_widget_focus (GtkWidget *widget, GtkDirectionType direction) @@ -87,17 +149,184 @@ gtk_column_view_row_widget_grab_focus (GtkWidget *widget) return GTK_WIDGET_CLASS (gtk_column_view_row_widget_parent_class)->grab_focus (widget); } +static void +gtk_column_view_row_widget_root (GtkWidget *widget) +{ + GtkColumnViewRowWidget *self = GTK_COLUMN_VIEW_ROW_WIDGET (widget); + + GTK_WIDGET_CLASS (gtk_column_view_row_widget_parent_class)->root (widget); + + if (!gtk_column_view_row_widget_is_header (self)) + { + GtkListItemBase *base = GTK_LIST_ITEM_BASE (self); + GListModel *columns; + guint i; + + columns = gtk_column_view_get_columns (gtk_column_view_row_widget_get_column_view (self)); + + for (i = 0; i < g_list_model_get_n_items (columns); i++) + { + GtkColumnViewColumn *column = g_list_model_get_item (columns, i); + + if (gtk_column_view_column_get_visible (column)) + { + GtkWidget *cell; + + cell = gtk_column_view_cell_new (column); + gtk_column_view_row_widget_add_child (self, cell); + gtk_list_item_base_update (GTK_LIST_ITEM_BASE (cell), + gtk_list_item_base_get_position (base), + gtk_list_item_base_get_item (base), + gtk_list_item_base_get_selected (base)); + } + + g_object_unref (column); + } + } +} + +static void +gtk_column_view_row_widget_unroot (GtkWidget *widget) +{ + GtkColumnViewRowWidget *self = GTK_COLUMN_VIEW_ROW_WIDGET (widget); + GtkWidget *child; + + if (!gtk_column_view_row_widget_is_header (self)) + { + while ((child = gtk_widget_get_first_child (GTK_WIDGET (self)))) + { + gtk_column_view_row_widget_remove_child (self, child); + } + } + + GTK_WIDGET_CLASS (gtk_column_view_row_widget_parent_class)->unroot (widget); +} + +static void +gtk_column_view_row_widget_measure_along (GtkColumnViewRowWidget *self, + int for_size, + int *minimum, + int *natural, + int *minimum_baseline, + int *natural_baseline) +{ + GtkOrientation orientation = GTK_ORIENTATION_VERTICAL; + GtkColumnView *view; + GtkWidget *child; + guint i, n; + GtkRequestedSize *sizes = NULL; + + view = gtk_column_view_row_widget_get_column_view (self); + + if (for_size > -1) + { + n = g_list_model_get_n_items (gtk_column_view_get_columns (view)); + sizes = g_newa (GtkRequestedSize, n); + gtk_column_view_distribute_width (view, for_size, sizes); + } + + for (child = _gtk_widget_get_first_child (GTK_WIDGET (self)), i = 0; + child != NULL; + child = _gtk_widget_get_next_sibling (child), i++) + { + int child_min = 0; + int child_nat = 0; + int child_min_baseline = -1; + int child_nat_baseline = -1; + + if (!gtk_widget_should_layout (child)) + continue; + + gtk_widget_measure (child, orientation, + for_size > -1 ? sizes[i].minimum_size : -1, + &child_min, &child_nat, + &child_min_baseline, &child_nat_baseline); + + *minimum = MAX (*minimum, child_min); + *natural = MAX (*natural, child_nat); + + if (child_min_baseline > -1) + *minimum_baseline = MAX (*minimum_baseline, child_min_baseline); + if (child_nat_baseline > -1) + *natural_baseline = MAX (*natural_baseline, child_nat_baseline); + } +} + +static void +gtk_column_view_row_widget_measure (GtkWidget *widget, + GtkOrientation orientation, + int for_size, + int *minimum, + int *natural, + int *minimum_baseline, + int *natural_baseline) +{ + GtkColumnViewRowWidget *self = GTK_COLUMN_VIEW_ROW_WIDGET (widget); + + if (orientation == GTK_ORIENTATION_HORIZONTAL) + { + gtk_column_view_measure_across (gtk_column_view_row_widget_get_column_view (self), + minimum, + natural); + } + else + { + gtk_column_view_row_widget_measure_along (self, + for_size, + minimum, + natural, + minimum_baseline, + natural_baseline); + } +} + +static void +gtk_column_view_row_widget_allocate (GtkWidget *widget, + int width, + int height, + int baseline) +{ + GtkWidget *child; + + for (child = _gtk_widget_get_first_child (widget); + child != NULL; + child = _gtk_widget_get_next_sibling (child)) + { + GtkColumnViewColumn *column; + int col_x, col_width, min; + + if (!gtk_widget_should_layout (child)) + continue; + + if (GTK_IS_COLUMN_VIEW_CELL (child)) + column = gtk_column_view_cell_get_column (GTK_COLUMN_VIEW_CELL (child)); + else + column = gtk_column_view_title_get_column (GTK_COLUMN_VIEW_TITLE (child)); + gtk_column_view_column_get_header_allocation (column, &col_x, &col_width); + + gtk_widget_measure (child, GTK_ORIENTATION_HORIZONTAL, -1, &min, NULL, NULL, NULL); + + gtk_widget_size_allocate (child, &(GtkAllocation) { col_x, 0, MAX (min, col_width), height }, baseline); + } +} + static void gtk_column_view_row_widget_class_init (GtkColumnViewRowWidgetClass *klass) { + GtkListItemBaseClass *base_class = GTK_LIST_ITEM_BASE_CLASS (klass); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + base_class->update = gtk_column_view_row_widget_update; widget_class->focus = gtk_column_view_row_widget_focus; widget_class->grab_focus = gtk_column_view_row_widget_grab_focus; + widget_class->measure = gtk_column_view_row_widget_measure; + widget_class->size_allocate = gtk_column_view_row_widget_allocate; + widget_class->root = gtk_column_view_row_widget_root; + widget_class->unroot = gtk_column_view_row_widget_unroot; /* This gets overwritten by gtk_column_view_row_widget_new() but better safe than sorry */ - gtk_widget_class_set_css_name (widget_class, I_("row")); - gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT); + gtk_widget_class_set_css_name (widget_class, g_intern_static_string ("row")); + gtk_widget_class_set_accessible_role (widget_class, GTK_ACCESSIBLE_ROLE_ROW); } static void @@ -107,16 +336,10 @@ gtk_column_view_row_widget_init (GtkColumnViewRowWidget *self) } GtkWidget * -gtk_column_view_row_widget_new (GtkListItemFactory *factory, - const char *css_name, - GtkAccessibleRole role) +gtk_column_view_row_widget_new (gboolean is_header) { - g_return_val_if_fail (css_name != NULL, NULL); - return g_object_new (GTK_TYPE_COLUMN_VIEW_ROW_WIDGET, - "css-name", css_name, - "accessible-role", role, - "factory", factory, + "css-name", is_header ? "header" : "row", "selectable", TRUE, "activatable", TRUE, NULL); diff --git a/gtk/gtkcolumnviewrowwidgetprivate.h b/gtk/gtkcolumnviewrowwidgetprivate.h index b4ea9b2413..b55a7ab45b 100644 --- a/gtk/gtkcolumnviewrowwidgetprivate.h +++ b/gtk/gtkcolumnviewrowwidgetprivate.h @@ -1,5 +1,5 @@ /* - * Copyright © 2018 Benjamin Otte + * Copyright © 2023 Benjamin Otte * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -46,9 +46,7 @@ struct _GtkColumnViewRowWidgetClass GType gtk_column_view_row_widget_get_type (void) G_GNUC_CONST; -GtkWidget * gtk_column_view_row_widget_new (GtkListItemFactory *factory, - const char *css_name, - GtkAccessibleRole role); +GtkWidget * gtk_column_view_row_widget_new (gboolean is_header); void gtk_column_view_row_widget_add_child (GtkColumnViewRowWidget *self, GtkWidget *child); diff --git a/gtk/gtklistitemwidget.c b/gtk/gtklistitemwidget.c index 31489b4f81..871d6d0d1a 100644 --- a/gtk/gtklistitemwidget.c +++ b/gtk/gtklistitemwidget.c @@ -27,10 +27,7 @@ #include "gtklistitemfactoryprivate.h" #include "gtklistitemprivate.h" #include "gtklistbaseprivate.h" -#include "gtkmain.h" -#include "gtkselectionmodel.h" #include "gtkwidget.h" -#include "gtkwidgetprivate.h" G_DEFINE_TYPE (GtkListItemWidget, gtk_list_item_widget, GTK_TYPE_LIST_FACTORY_WIDGET) diff --git a/gtk/meson.build b/gtk/meson.build index c43a916847..bfe69528a3 100644 --- a/gtk/meson.build +++ b/gtk/meson.build @@ -38,10 +38,8 @@ gtk_private_sources = files([ 'gtkcolorpickershell.c', 'gtkcolorscale.c', 'gtkcolorswatch.c', - 'gtkcolumnlistitemfactory.c', 'gtkcolumnviewcell.c', 'gtkcolumnviewrowwidget.c', - 'gtkcolumnviewlayout.c', 'gtkcolumnviewtitle.c', 'gtkconstraintexpression.c', 'gtkconstraintsolver.c',