AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
2daea9e459
gtk2/gtk/gtklistview.c

1161 lines
34 KiB
C
Raw Normal View History

gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
/*
* Copyright © 2018 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 <http://www.gnu.org/licenses/>.
*
* Authors: Benjamin Otte <otte@gnome.org>
*/
#include "config.h"
columnview: Set accessible roles Use the TREE_GRID, ROW, COLUMN_HEADER and GRID_CELL roles for the various widgets involved in a GtkColumnView. To enable this, we subclass GtkListView for the internal list in the column view.
2020-10-15 04:09:06 +00:00
#include "gtklistviewprivate.h"
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
listbase: Compute rubberband region on-demand Instead of storing the active items as we go, compute the affected items whenever the rubberband changes and in particular when the rubberband ends. That way, the rubberband is guaranteed to select a rectangle even after scrolling very far. This is achieved by having a get_items_in_rect() vfunc that selects all the items in the rubberbanded rectangle and returns them as a bitset.
2020-06-26 00:56:38 +00:00
#include "gtkbitset.h"
Add GtkListBase This is a base item for GTK's list widgets so they can share some (read: hopefully a lot of) code.
2019-10-22 06:01:16 +00:00
#include "gtklistbaseprivate.h"
listview: Add GtkListItemManager It's all stubs for now, but here's the basic ideas about what this object is supposed to do: (1) It's supposed to be handling all the child GtkWidgets that are used by the listview, so that the listview can concern itself with how many items it needs and where to put them. (2) It's meant to do the caching of widgets that are not (currently) used. (3) It's meant to track items that remain in the model across items-changed emissions and just change position. (2) It's code that can be shared between listview and potential other widgets like a GridView. It's also free to assume that the number of items it's supposed to manage doesn't grow too much, so it's free to use O(N) algorithms.
2018-09-20 03:18:34 +00:00
#include "gtklistitemmanagerprivate.h"
listview: Track focus movements and update selection When focus moves via tab/arrow, we need to select the new item.
2019-10-15 21:45:33 +00:00
#include "gtkmain.h"
listview: Implement GtkOrientable
2019-10-06 03:46:50 +00:00
#include "gtkprivate.h"
listitemfactory: Split implementation out .. into gtkfunctionslistitemfactory.c Now we can add a different implmenetation.
2019-06-10 01:43:52 +00:00
#include "gtkrbtreeprivate.h"
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
#include "gtkwidgetprivate.h"
listview: Set accessible roles Use the LIST and LIST_ITEM roles for GtkListView and its children. Use the GRID and GRID_CELL roles for GtkGridView and its children.
2020-10-15 03:34:51 +00:00
#include "gtkmultiselection.h"
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
/* Maximum number of list items created by the listview.
* For debugging, you can set this to G_MAXUINT to ensure
* there's always a list item for every row.
*/
#define GTK_LIST_VIEW_MAX_LIST_ITEMS 200
listitemmanager: Add trackers ... and replace the anchor tracking with a tracker. Trackers track an item through the list across changes and ensure that this item (and potentially siblings before/after it) are always backed by a GtkListItem and that if the item gets removed a replacement gets chosen. This is now used for tracking the anchor but can also be used to add trackers for the cursor later.
2019-02-27 07:45:28 +00:00
/* Extra items to keep above + below every tracker */
#define GTK_LIST_VIEW_EXTRA_ITEMS 2
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* GtkListView:
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* `GtkListView` presents a large dynamic list of items.
list widgets: Document css structure We didn't fill in this expected part of the widget documentation yet.
2020-06-04 14:05:17 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* `GtkListView` uses its factory to generate one row widget for each visible
* item and shows them in a linear display, either vertically or horizontally.
docs: Expand list widget docs Begin to flesh out the long descriptions for GtkListView, GtkGridView and GtkColumnView.
2020-06-04 19:33:53 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* The [property@Gtk.ListView:show-separators] property offers a simple way to
* display separators between the rows.
*
* `GtkListView` allows the user to select items according to the selection
docs: Update list widgets docs Removed sentence that claimed the view will wrap the model in a GtkSingleSelection, as it's no longer true. Fixed the code example in GtkListView for the same reason. Fixed a small typo in GtkDropDown docs.
2020-09-06 15:19:24 +00:00
* characteristics of the model. For models that allow multiple selected items,
* it is possible to turn on _rubberband selection_, using
listview: Convert docs
2021-02-28 18:09:48 +00:00
* [property@Gtk.ListView:enable-rubberband].
docs: Expand list widget docs Begin to flesh out the long descriptions for GtkListView, GtkGridView and GtkColumnView.
2020-06-04 19:33:53 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* If you need multiple columns with headers, see [class@Gtk.ColumnView].
docs: Expand list widget docs Begin to flesh out the long descriptions for GtkListView, GtkGridView and GtkColumnView.
2020-06-04 19:33:53 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* To learn more about the list widget framework, see the
* [overview](section-list-widget.html).
docs: Expand list widget docs Begin to flesh out the long descriptions for GtkListView, GtkGridView and GtkColumnView.
2020-06-04 19:33:53 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* An example of using `GtkListView`:
* ```c
listview: Add an example to the docs The example is an excerpt from the applauncher demo in gtk4-demo.
2020-06-05 00:11:35 +00:00
* static void
* setup_listitem_cb (GtkListItemFactory *factory,
* GtkListItem *list_item)
* {
* GtkWidget *image;
*
* image = gtk_image_new ();
* gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
* gtk_list_item_set_child (list_item, image);
* }
*
* static void
* bind_listitem_cb (GtkListItemFactory *factory,
* GtkListItem *list_item)
* {
* GtkWidget *image;
* GAppInfo *app_info;
*
* image = gtk_list_item_get_child (list_item);
* app_info = gtk_list_item_get_item (list_item);
* gtk_image_set_from_gicon (GTK_IMAGE (image), g_app_info_get_icon (app_info));
* }
*
* static void
* activate_cb (GtkListView *list,
* guint position,
* gpointer unused)
* {
* GAppInfo *app_info;
*
docs: Update list widgets docs Removed sentence that claimed the view will wrap the model in a GtkSingleSelection, as it's no longer true. Fixed the code example in GtkListView for the same reason. Fixed a small typo in GtkDropDown docs.
2020-09-06 15:19:24 +00:00
* app_info = g_list_model_get_item (G_LIST_MODEL (gtk_list_view_get_model (list)), position);
listview: Add an example to the docs The example is an excerpt from the applauncher demo in gtk4-demo.
2020-06-05 00:11:35 +00:00
* g_app_info_launch (app_info, NULL, NULL, NULL);
* g_object_unref (app_info);
* }
*
* ...
*
listview: Revise constructors Make both gtk_list_view_new and gtk_list_view_new_with_factory take a model as first argument, and make all arguments allow-none and transfer full. Update all callers.
2020-07-26 22:27:23 +00:00
* model = create_application_list ();
*
listview: Add an example to the docs The example is an excerpt from the applauncher demo in gtk4-demo.
2020-06-05 00:11:35 +00:00
* factory = gtk_signal_list_item_factory_new ();
* g_signal_connect (factory, "setup", G_CALLBACK (setup_listitem_cb), NULL);
* g_signal_connect (factory, "bind", G_CALLBACK (bind_listitem_cb), NULL);
*
docs: Update list widgets docs Removed sentence that claimed the view will wrap the model in a GtkSingleSelection, as it's no longer true. Fixed the code example in GtkListView for the same reason. Fixed a small typo in GtkDropDown docs.
2020-09-06 15:19:24 +00:00
* list = gtk_list_view_new (GTK_SELECTION_MODEL (gtk_single_selection_new (model)), factory);
listview: Add an example to the docs The example is an excerpt from the applauncher demo in gtk4-demo.
2020-06-05 00:11:35 +00:00
*
* g_signal_connect (list, "activate", G_CALLBACK (activate_cb), NULL);
*
* gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), list);
listview: Convert docs
2021-02-28 18:09:48 +00:00
* ```
listview: Add an example to the docs The example is an excerpt from the applauncher demo in gtk4-demo.
2020-06-05 00:11:35 +00:00
*
list widgets: Document css structure We didn't fill in this expected part of the widget documentation yet.
2020-06-04 14:05:17 +00:00
* # CSS nodes
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* ```
lists: Mention list style classes in docs Document that GtkListView, GtkColumnView and GtkListBox support .rich-list, .navigation-sidebar and .data-table style classes.
2020-08-05 20:41:53 +00:00
* listview[.separators][.rich-list][.navigation-sidebar][.data-table]
listitemwidget: Have .activatable style class if the item is activatable Match GtkListBox, so it's possible to use the same styles for them. Update GtkListView and GtkGridView docs to reflect that, fix a few gtk-doc formatting leftovers along the way.
2021-05-17 13:05:05 +00:00
* ├── row[.activatable]
list widgets: Document css structure We didn't fill in this expected part of the widget documentation yet.
2020-06-04 14:05:17 +00:00
* │
listitemwidget: Have .activatable style class if the item is activatable Match GtkListBox, so it's possible to use the same styles for them. Update GtkListView and GtkGridView docs to reflect that, fix a few gtk-doc formatting leftovers along the way.
2021-05-17 13:05:05 +00:00
* ├── row[.activatable]
list widgets: Document css structure We didn't fill in this expected part of the widget documentation yet.
2020-06-04 14:05:17 +00:00
* │
* ┊
* ╰── [rubberband]
listview: Convert docs
2021-02-28 18:09:48 +00:00
* ```
list widgets: Document css structure We didn't fill in this expected part of the widget documentation yet.
2020-06-04 14:05:17 +00:00
*
listitemwidget: Have .activatable style class if the item is activatable Match GtkListBox, so it's possible to use the same styles for them. Update GtkListView and GtkGridView docs to reflect that, fix a few gtk-doc formatting leftovers along the way.
2021-05-17 13:05:05 +00:00
* `GtkListView` uses a single CSS node named `listview`. It may carry the
* `.separators` style class, when [property@Gtk.ListView:show-separators]
* property is set. Each child widget uses a single CSS node named `row`.
Fix documentation syntax Properties use : in their link syntax.
2021-05-20 23:16:59 +00:00
* If the [property@Gtk.ListItem:activatable] property is set, the
listitemwidget: Have .activatable style class if the item is activatable Match GtkListBox, so it's possible to use the same styles for them. Update GtkListView and GtkGridView docs to reflect that, fix a few gtk-doc formatting leftovers along the way.
2021-05-17 13:05:05 +00:00
* corresponding row will have the `.activatable` style class. For
* rubberband selection, a node with name `rubberband` is used.
lists: Mention list style classes in docs Document that GtkListView, GtkColumnView and GtkListBox support .rich-list, .navigation-sidebar and .data-table style classes.
2020-08-05 20:41:53 +00:00
*
* The main listview node may also carry style classes to select
* the style of [list presentation](ListContainers.html#list-styles):
* .rich-list, .navigation-sidebar or .data-table.
docs: Document more accessible roles GtkListView and GtkGridView were missing this as well.
2020-10-21 02:53:30 +00:00
*
* # Accessibility
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* `GtkListView` uses the %GTK_ACCESSIBLE_ROLE_LIST role, and the list
* items use the %GTK_ACCESSIBLE_ROLE_LIST_ITEM role.
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
*/
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
typedef struct _ListRow ListRow;
typedef struct _ListRowAugment ListRowAugment;
struct _ListRow
{
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
GtkListItemManagerItem parent;
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
guint height; /* per row */
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
};
struct _ListRowAugment
{
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
GtkListItemManagerItemAugment parent;
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
guint height; /* total */
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
};
enum
{
PROP_0,
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
PROP_FACTORY,
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
PROP_MODEL,
listview: Add gtk_list_view_set_show_separators() Do the same thing that GtkListBox does in commit 0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44
2019-06-04 01:01:15 +00:00
PROP_SHOW_SEPARATORS,
listview: Add single-click-activate Add a single-click-activate property to GtkListView.
2019-12-14 01:57:57 +00:00
PROP_SINGLE_CLICK_ACTIVATE,
Add rubberband api Add an ::enable-rubberband property to GtkListView, GtkGridView and GtkColumnView.
2019-12-23 19:47:19 +00:00
PROP_ENABLE_RUBBERBAND,
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
N_PROPS
};
listview: Implement activation - a GtkListview::activate signal - a GtkListItem::activatable property - activate list items on double clicks and <Enter> presses
2019-10-15 21:06:36 +00:00
enum {
ACTIVATE,
LAST_SIGNAL
};
listbase: Move orientable implementation here
2019-10-24 00:07:37 +00:00
G_DEFINE_TYPE (GtkListView, gtk_list_view, GTK_TYPE_LIST_BASE)
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
static GParamSpec *properties[N_PROPS] = { NULL, };
listview: Implement activation - a GtkListview::activate signal - a GtkListItem::activatable property - activate list items on double clicks and <Enter> presses
2019-10-15 21:06:36 +00:00
static guint signals[LAST_SIGNAL] = { 0 };
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
static void G_GNUC_UNUSED
dump (GtkListView *self)
{
ListRow *row;
guint n_widgets, n_list_rows;
n_widgets = 0;
n_list_rows = 0;
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
//g_print ("ANCHOR: %u - %u\n", self->anchor_start, self->anchor_end);
for (row = gtk_list_item_manager_get_first (self->item_manager);
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
row;
row = gtk_rb_tree_node_get_next (row))
{
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
if (row->parent.widget)
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
n_widgets++;
n_list_rows++;
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
g_print (" %4u%s (%upx)\n", row->parent.n_items, row->parent.widget ? " (widget)" : "", row->height);
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
}
g_print (" => %u widgets in %u list rows\n", n_widgets, n_list_rows);
}
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
static void
list_row_augment (GtkRbTree *tree,
gpointer node_augment,
gpointer node,
gpointer left,
gpointer right)
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
{
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
ListRow *row = node;
ListRowAugment *aug = node_augment;
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
gtk_list_item_manager_augment_node (tree, node_augment, node, left, right);
aug->height = row->height * row->parent.n_items;
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
if (left)
{
ListRowAugment *left_aug = gtk_rb_tree_get_augment (tree, left);
aug->height += left_aug->height;
}
if (right)
{
ListRowAugment *right_aug = gtk_rb_tree_get_augment (tree, right);
aug->height += right_aug->height;
}
}
listview: Implement an anchor The anchor selection is very basic: just anchor the top row. That's vastly better than any other widget already though.
2018-09-19 05:08:30 +00:00
static ListRow *
gtk_list_view_get_row_at_y (GtkListView *self,
int y,
int *offset)
{
ListRow *row, *tmp;
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
row = gtk_list_item_manager_get_root (self->item_manager);
listview: Implement an anchor The anchor selection is very basic: just anchor the top row. That's vastly better than any other widget already though.
2018-09-19 05:08:30 +00:00
while (row)
{
tmp = gtk_rb_tree_node_get_left (row);
if (tmp)
{
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
ListRowAugment *aug = gtk_list_item_manager_get_item_augment (self->item_manager, tmp);
listview: Implement an anchor The anchor selection is very basic: just anchor the top row. That's vastly better than any other widget already though.
2018-09-19 05:08:30 +00:00
if (y < aug->height)
{
row = tmp;
continue;
}
y -= aug->height;
}
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
if (y < row->height * row->parent.n_items)
listview: Implement an anchor The anchor selection is very basic: just anchor the top row. That's vastly better than any other widget already though.
2018-09-19 05:08:30 +00:00
break;
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
y -= row->height * row->parent.n_items;
listview: Implement an anchor The anchor selection is very basic: just anchor the top row. That's vastly better than any other widget already though.
2018-09-19 05:08:30 +00:00
row = gtk_rb_tree_node_get_right (row);
}
if (offset)
*offset = row ? y : 0;
return row;
}
static int
list_row_get_y (GtkListView *self,
ListRow *row)
{
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
ListRow *parent, *left;
int y;
left = gtk_rb_tree_node_get_left (row);
if (left)
{
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
ListRowAugment *aug = gtk_list_item_manager_get_item_augment (self->item_manager, left);
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
y = aug->height;
}
else
y = 0;
listview: Implement an anchor The anchor selection is very basic: just anchor the top row. That's vastly better than any other widget already though.
2018-09-19 05:08:30 +00:00
for (parent = gtk_rb_tree_node_get_parent (row);
parent != NULL;
parent = gtk_rb_tree_node_get_parent (row))
{
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
left = gtk_rb_tree_node_get_left (parent);
listview: Implement an anchor The anchor selection is very basic: just anchor the top row. That's vastly better than any other widget already though.
2018-09-19 05:08:30 +00:00
if (left != row)
{
if (left)
{
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
ListRowAugment *aug = gtk_list_item_manager_get_item_augment (self->item_manager, left);
listview: Implement an anchor The anchor selection is very basic: just anchor the top row. That's vastly better than any other widget already though.
2018-09-19 05:08:30 +00:00
y += aug->height;
}
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
y += parent->height * parent->parent.n_items;
listview: Implement an anchor The anchor selection is very basic: just anchor the top row. That's vastly better than any other widget already though.
2018-09-19 05:08:30 +00:00
}
row = parent;
}
return y ;
}
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
static int
gtk_list_view_get_list_height (GtkListView *self)
{
ListRow *row;
ListRowAugment *aug;
listbase: Take over anchor handling With that, pretty much all code but allocating the widgets is gone from the gridview and listview.
2019-10-26 06:49:27 +00:00
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
row = gtk_list_item_manager_get_root (self->item_manager);
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
if (row == NULL)
return 0;
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
aug = gtk_list_item_manager_get_item_augment (self->item_manager, row);
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
return aug->height;
}
listbase: Add vfuncs to convert positions to/from coordinates ... and use that to implement PageUp/PageDown. With that, all keyboard handling has been moved to GtkListBase.
2019-10-25 05:39:57 +00:00
static gboolean
gtk_list_view_get_allocation_along (GtkListBase *base,
guint pos,
int *offset,
int *size)
{
GtkListView *self = GTK_LIST_VIEW (base);
ListRow *row;
guint skip;
int y;
row = gtk_list_item_manager_get_nth (self->item_manager, pos, &skip);
if (row == NULL)
{
if (offset)
*offset = 0;
if (size)
*size = 0;
return FALSE;
}
y = list_row_get_y (self, row);
y += skip * row->height;
if (offset)
*offset = y;
if (size)
*size = row->height;
return TRUE;
}
static gboolean
gtk_list_view_get_allocation_across (GtkListBase *base,
guint pos,
int *offset,
int *size)
{
GtkListView *self = GTK_LIST_VIEW (base);
if (offset)
*offset = 0;
if (size)
*size = self->list_width;
return TRUE;
}
listbase: Compute rubberband region on-demand Instead of storing the active items as we go, compute the affected items whenever the rubberband changes and in particular when the rubberband ends. That way, the rubberband is guaranteed to select a rectangle even after scrolling very far. This is achieved by having a get_items_in_rect() vfunc that selects all the items in the rubberbanded rectangle and returns them as a bitset.
2020-06-26 00:56:38 +00:00
static GtkBitset *
gtk_list_view_get_items_in_rect (GtkListBase *base,
const cairo_rectangle_int_t *rect)
{
GtkListView *self = GTK_LIST_VIEW (base);
guint first, last, n_items;
GtkBitset *result;
ListRow *row;
result = gtk_bitset_new_empty ();
listview: Return an empty bitset when selecting only empty space Return an empty bitset if the user selects exclusively below the last row.
2022-07-25 23:59:35 +00:00
if (rect->y >= gtk_list_view_get_list_height (self))
return result;
listbase: Compute rubberband region on-demand Instead of storing the active items as we go, compute the affected items whenever the rubberband changes and in particular when the rubberband ends. That way, the rubberband is guaranteed to select a rectangle even after scrolling very far. This is achieved by having a get_items_in_rect() vfunc that selects all the items in the rubberbanded rectangle and returns them as a bitset.
2020-06-26 00:56:38 +00:00
n_items = gtk_list_base_get_n_items (base);
if (n_items == 0)
return result;
row = gtk_list_view_get_row_at_y (self, rect->y, NULL);
if (row)
first = gtk_list_item_manager_get_item_position (self->item_manager, row);
else
first = rect->y < 0 ? 0 : n_items - 1;
row = gtk_list_view_get_row_at_y (self, rect->y + rect->height, NULL);
if (row)
last = gtk_list_item_manager_get_item_position (self->item_manager, row);
else
listview: Fix selection for last item in get_items_in_rect Make the last item dependent on y + height
2022-07-26 00:01:28 +00:00
last = rect->y + rect->height < 0 ? 0 : n_items - 1;
listbase: Compute rubberband region on-demand Instead of storing the active items as we go, compute the affected items whenever the rubberband changes and in particular when the rubberband ends. That way, the rubberband is guaranteed to select a rectangle even after scrolling very far. This is achieved by having a get_items_in_rect() vfunc that selects all the items in the rubberbanded rectangle and returns them as a bitset.
2020-06-26 00:56:38 +00:00
gtk_bitset_add_range_closed (result, first, last);
return result;
}
listbase: Move focus moving keybindings here The focus tracker is not yet moved because that depends on scroll_to() support and we don't have that yet. Whoops. So we use a hack.
2019-10-24 04:49:38 +00:00
static guint
gtk_list_view_move_focus_along (GtkListBase *base,
guint pos,
int steps)
{
if (steps < 0)
return pos - MIN (pos, -steps);
else
{
listbase: Take over anchor handling With that, pretty much all code but allocating the widgets is gone from the gridview and listview.
2019-10-26 06:49:27 +00:00
pos += MIN (gtk_list_base_get_n_items (base) - pos - 1, steps);
listbase: Move focus moving keybindings here The focus tracker is not yet moved because that depends on scroll_to() support and we don't have that yet. Whoops. So we use a hack.
2019-10-24 04:49:38 +00:00
}
return pos;
}
listbase: Add vfuncs to convert positions to/from coordinates ... and use that to implement PageUp/PageDown. With that, all keyboard handling has been moved to GtkListBase.
2019-10-25 05:39:57 +00:00
static gboolean
gtk_list_view_get_position_from_allocation (GtkListBase *base,
int across,
int along,
guint *pos,
cairo_rectangle_int_t *area)
{
GtkListView *self = GTK_LIST_VIEW (base);
ListRow *row;
int remaining;
if (across >= self->list_width)
return FALSE;
listview: Allow starting rubberband in empty space below last row Rubberband does not work when initiated past the last row (warning is printed "Could not start rubberbanding: No item). Clamp y at the max height of the widgets in the listview
2022-07-26 00:00:46 +00:00
along = CLAMP (along, 0, gtk_list_view_get_list_height (self) - 1);
listbase: Add vfuncs to convert positions to/from coordinates ... and use that to implement PageUp/PageDown. With that, all keyboard handling has been moved to GtkListBase.
2019-10-25 05:39:57 +00:00
row = gtk_list_view_get_row_at_y (self, along, &remaining);
if (row == NULL)
return FALSE;
*pos = gtk_list_item_manager_get_item_position (self->item_manager, row);
g_assert (remaining < row->height * row->parent.n_items);
*pos += remaining / row->height;
if (area)
{
area->x = 0;
area->width = self->list_width;
area->y = along - remaining % row->height;
area->height = row->height;
}
return TRUE;
}
listbase: Move focus moving keybindings here The focus tracker is not yet moved because that depends on scroll_to() support and we don't have that yet. Whoops. So we use a hack.
2019-10-24 04:49:38 +00:00
static guint
gtk_list_view_move_focus_across (GtkListBase *base,
guint pos,
int steps)
{
return pos;
}
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
static int
compare_ints (gconstpointer first,
gconstpointer second)
{
return *(int *) first - *(int *) second;
}
static guint
gtk_list_view_get_unknown_row_height (GtkListView *self,
GArray *heights)
{
g_return_val_if_fail (heights->len > 0, 0);
/* return the median and hope rows are generally uniform with few outliers */
g_array_sort (heights, compare_ints);
return g_array_index (heights, int, heights->len / 2);
}
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
static void
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
gtk_list_view_measure_across (GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural)
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
{
GtkListView *self = GTK_LIST_VIEW (widget);
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
ListRow *row;
int min, nat, child_min, child_nat;
/* XXX: Figure out how to split a given height into per-row heights.
* Good luck! */
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
for_size = -1;
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
min = 0;
nat = 0;
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
for (row = gtk_list_item_manager_get_first (self->item_manager);
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
row != NULL;
row = gtk_rb_tree_node_get_next (row))
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
{
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
/* ignore unavailable rows */
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
if (row->parent.widget == NULL)
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
continue;
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
gtk_widget_measure (row->parent.widget,
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
orientation, for_size,
&child_min, &child_nat, NULL, NULL);
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
min = MAX (min, child_min);
nat = MAX (nat, child_nat);
}
*minimum = min;
*natural = nat;
}
static void
gtk_list_view_measure_list (GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural)
{
GtkListView *self = GTK_LIST_VIEW (widget);
ListRow *row;
int min, nat, child_min, child_nat;
GArray *min_heights, *nat_heights;
guint n_unknown;
min_heights = g_array_new (FALSE, FALSE, sizeof (int));
nat_heights = g_array_new (FALSE, FALSE, sizeof (int));
n_unknown = 0;
min = 0;
nat = 0;
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
for (row = gtk_list_item_manager_get_first (self->item_manager);
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
row != NULL;
row = gtk_rb_tree_node_get_next (row))
{
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
if (row->parent.widget)
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
{
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
gtk_widget_measure (row->parent.widget,
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
orientation, for_size,
&child_min, &child_nat, NULL, NULL);
g_array_append_val (min_heights, child_min);
g_array_append_val (nat_heights, child_nat);
min += child_min;
nat += child_nat;
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
}
else
{
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
n_unknown += row->parent.n_items;
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
}
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
}
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
if (n_unknown)
{
min += n_unknown * gtk_list_view_get_unknown_row_height (self, min_heights);
nat += n_unknown * gtk_list_view_get_unknown_row_height (self, nat_heights);
}
g_array_free (min_heights, TRUE);
g_array_free (nat_heights, TRUE);
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
*minimum = min;
*natural = nat;
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
}
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
static void
gtk_list_view_measure (GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
{
listview: Implement GtkOrientable
2019-10-06 03:46:50 +00:00
GtkListView *self = GTK_LIST_VIEW (widget);
listbase: Move orientable implementation here
2019-10-24 00:07:37 +00:00
if (orientation == gtk_list_base_get_orientation (GTK_LIST_BASE (self)))
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
gtk_list_view_measure_list (widget, orientation, for_size, minimum, natural);
listview: Implement GtkOrientable
2019-10-06 03:46:50 +00:00
else
gtk_list_view_measure_across (widget, orientation, for_size, minimum, natural);
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
}
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
static void
gtk_list_view_size_allocate (GtkWidget *widget,
int width,
int height,
int baseline)
{
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
GtkListView *self = GTK_LIST_VIEW (widget);
ListRow *row;
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
GArray *heights;
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
int min, nat, row_height;
listview: Port various gridview improvements - Handle anchor as align + top/bottom This fixes behavior for cells that are higher than the view - Add gtk_list_view_adjustment_is_flipped() This should fix RTL handling of horizontal lists - Fix scrolling This should make scrolling more reliable, particularly on short lists that are only a few pages long.
2019-10-22 01:21:39 +00:00
int x, y;
listbase: Move orientable implementation here
2019-10-24 00:07:37 +00:00
GtkOrientation orientation, opposite_orientation;
listview: Use the correct scroll policy Use the horizontal policy for horizontal decisions, not the vertical one. This broke in 0011ce949c3580e02c4b2c3d83584a6c6e82090c.
2020-11-24 13:19:06 +00:00
GtkScrollablePolicy scroll_policy, opposite_scroll_policy;
listview: Implement GtkOrientable
2019-10-06 03:46:50 +00:00
listbase: Move orientable implementation here
2019-10-24 00:07:37 +00:00
orientation = gtk_list_base_get_orientation (GTK_LIST_BASE (self));
opposite_orientation = OPPOSITE_ORIENTATION (orientation);
scroll_policy = gtk_list_base_get_scroll_policy (GTK_LIST_BASE (self), orientation);
listview: Use the correct scroll policy Use the horizontal policy for horizontal decisions, not the vertical one. This broke in 0011ce949c3580e02c4b2c3d83584a6c6e82090c.
2020-11-24 13:19:06 +00:00
opposite_scroll_policy = gtk_list_base_get_scroll_policy (GTK_LIST_BASE (self), opposite_orientation);
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
/* step 0: exit early if list is empty */
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
if (gtk_list_item_manager_get_root (self->item_manager) == NULL)
listviews: Reset scrollbar adjustment when list is empty In a list with a visible scrollbar, the scrollbar usually becomes invisible when the numbers of items is less than the required amount to scroll. If, however, the list is emptied all at once, the scrollbar remains. This happens because when there's an empty list gtk_list_view_size_allocate() returns early before the scrollbar adjustment is updated. Given that the list is empty, simply reset the adjustment values to zero. Fixes: https://gitlab.gnome.org/GNOME/gtk/-/issues/4370
2022-07-12 19:42:28 +00:00
{
gtk_list_base_update_adjustments (GTK_LIST_BASE (self), 0, 0, 0, 0, &x, &y);
return;
}
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
/* step 1: determine width of the list */
listview: Implement GtkOrientable
2019-10-06 03:46:50 +00:00
gtk_widget_measure (widget, opposite_orientation,
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
-1,
&min, &nat, NULL, NULL);
listbase: Move orientable implementation here
2019-10-24 00:07:37 +00:00
self->list_width = orientation == GTK_ORIENTATION_VERTICAL ? width : height;
listview: Use the correct scroll policy Use the horizontal policy for horizontal decisions, not the vertical one. This broke in 0011ce949c3580e02c4b2c3d83584a6c6e82090c.
2020-11-24 13:19:06 +00:00
if (opposite_scroll_policy == GTK_SCROLL_MINIMUM)
listview: Implement GtkOrientable
2019-10-06 03:46:50 +00:00
self->list_width = MAX (min, self->list_width);
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
else
listview: Implement GtkOrientable
2019-10-06 03:46:50 +00:00
self->list_width = MAX (nat, self->list_width);
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
/* step 2: determine height of known list items */
heights = g_array_new (FALSE, FALSE, sizeof (int));
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
for (row = gtk_list_item_manager_get_first (self->item_manager);
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
row != NULL;
row = gtk_rb_tree_node_get_next (row))
{
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
if (row->parent.widget == NULL)
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
continue;
listbase: Move orientable implementation here
2019-10-24 00:07:37 +00:00
gtk_widget_measure (row->parent.widget, orientation,
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
self->list_width,
&min, &nat, NULL, NULL);
listbase: Move GtkScrollable implementation Shared code between GtkGridView and GtkListView.
2019-10-22 21:46:34 +00:00
if (scroll_policy == GTK_SCROLL_MINIMUM)
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
row_height = min;
else
row_height = nat;
if (row->height != row_height)
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
{
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
row->height = row_height;
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
gtk_rb_tree_node_mark_dirty (row);
}
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
g_array_append_val (heights, row_height);
}
/* step 3: determine height of unknown items */
row_height = gtk_list_view_get_unknown_row_height (self, heights);
g_array_free (heights, TRUE);
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
for (row = gtk_list_item_manager_get_first (self->item_manager);
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
row != NULL;
row = gtk_rb_tree_node_get_next (row))
{
listitemmanager: Move list of listitems here All the listview infrastructure moved with it, so the next step is moving that back...
2019-02-06 19:48:08 +00:00
if (row->parent.widget)
listview: Only allocate necesary rows This is the big one. The listview only allocates 200 rows around the visible row now. Everything else is kept in ListRow instances with row->widget == NULL. For rows without a widget, we assign the median height of the child widgets as the row's height and then do all calculations as if there were widgets that had requested that height (like setting adjustment values or reacting to adjustment value changes). When the view is scrolled, we bind the 200 rows to the new visible area, so that the part of the listview that can be seen is always allocated.
2018-09-25 23:37:38 +00:00
continue;
if (row->height != row_height)
{
row->height = row_height;
gtk_rb_tree_node_mark_dirty (row);
}
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
}
/* step 3: update the adjustments */
listbase: Take over anchor handling With that, pretty much all code but allocating the widgets is gone from the gridview and listview.
2019-10-26 06:49:27 +00:00
gtk_list_base_update_adjustments (GTK_LIST_BASE (self),
self->list_width,
gtk_list_view_get_list_height (self),
gtk_widget_get_size (widget, opposite_orientation),
gtk_widget_get_size (widget, orientation),
&x, &y);
x = -x;
y = -y;
listview: Implement GtkScrollable Scrolling in a very basic form is also supported
2018-09-18 17:58:19 +00:00
/* step 4: actually allocate the widgets */
listview: Implement GtkOrientable
2019-10-06 03:46:50 +00:00
listview: Port various gridview improvements - Handle anchor as align + top/bottom This fixes behavior for cells that are higher than the view - Add gtk_list_view_adjustment_is_flipped() This should fix RTL handling of horizontal lists - Fix scrolling This should make scrolling more reliable, particularly on short lists that are only a few pages long.
2019-10-22 01:21:39 +00:00
for (row = gtk_list_item_manager_get_first (self->item_manager);
row != NULL;
row = gtk_rb_tree_node_get_next (row))
listview: Implement GtkOrientable
2019-10-06 03:46:50 +00:00
{
listview: Port various gridview improvements - Handle anchor as align + top/bottom This fixes behavior for cells that are higher than the view - Add gtk_list_view_adjustment_is_flipped() This should fix RTL handling of horizontal lists - Fix scrolling This should make scrolling more reliable, particularly on short lists that are only a few pages long.
2019-10-22 01:21:39 +00:00
if (row->parent.widget)
listview: Implement GtkOrientable
2019-10-06 03:46:50 +00:00
{
listbase: Move a common function from the children into GtkListBase We want to use it for the rubberband later.
2020-06-24 02:49:21 +00:00
gtk_list_base_size_allocate_child (GTK_LIST_BASE (self),
listview: Port various gridview improvements - Handle anchor as align + top/bottom This fixes behavior for cells that are higher than the view - Add gtk_list_view_adjustment_is_flipped() This should fix RTL handling of horizontal lists - Fix scrolling This should make scrolling more reliable, particularly on short lists that are only a few pages long.
2019-10-22 01:21:39 +00:00
row->parent.widget,
x,
y,
self->list_width,
row->height);
listview: Implement GtkOrientable
2019-10-06 03:46:50 +00:00
}
listview: Port various gridview improvements - Handle anchor as align + top/bottom This fixes behavior for cells that are higher than the view - Add gtk_list_view_adjustment_is_flipped() This should fix RTL handling of horizontal lists - Fix scrolling This should make scrolling more reliable, particularly on short lists that are only a few pages long.
2019-10-22 01:21:39 +00:00
y += row->height * row->parent.n_items;
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
}
listview: Allocate rubberband at end of size_allocate() Otherwise the rubberband uses the wrong scroll offsets.
2020-06-26 00:55:53 +00:00
gtk_list_base_allocate_rubberband (GTK_LIST_BASE (self));
listview: Make widget actually do something The thing we're actually doing is create and maintain a widget for every row. That's it. Also add a testcase using this. The testcase quickly allocates too many rows though and then becomes unresponsive though. You have been warned.
2018-09-18 02:56:19 +00:00
}
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
static void
gtk_list_view_dispose (GObject *object)
{
GtkListView *self = GTK_LIST_VIEW (object);
listbase: Move item manager here Nothing really changes, because both ListView and GridView still keep self->item_manager around, but it's set up to point at the base's item manager. This way we can slowly move things to GtkListBase that need the item manager (like trackers).
2019-10-23 00:34:28 +00:00
self->item_manager = NULL;
listview: Introduce GtkListItemFactory Thisis the abstraction I intend to use for creating widgets and binding them to the item out of the listview. For now this is a very dumb wrapper around the functions that exist in the API. But it leaves the freedom to turn this into public API, make an interface out of it and most of all write different implementations, in particular one that uses GtkBuilder.
2018-09-17 05:29:50 +00:00
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
G_OBJECT_CLASS (gtk_list_view_parent_class)->dispose (object);
}
static void
gtk_list_view_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GtkListView *self = GTK_LIST_VIEW (object);
switch (property_id)
{
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
case PROP_FACTORY:
g_value_set_object (value, gtk_list_item_manager_get_factory (self->item_manager));
break;
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
case PROP_MODEL:
listbase: Take over anchor handling With that, pretty much all code but allocating the widgets is gone from the gridview and listview.
2019-10-26 06:49:27 +00:00
g_value_set_object (value, gtk_list_base_get_model (GTK_LIST_BASE (self)));
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
break;
listview: Add gtk_list_view_set_show_separators() Do the same thing that GtkListBox does in commit 0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44
2019-06-04 01:01:15 +00:00
case PROP_SHOW_SEPARATORS:
g_value_set_boolean (value, self->show_separators);
break;
listview: Add single-click-activate Add a single-click-activate property to GtkListView.
2019-12-14 01:57:57 +00:00
case PROP_SINGLE_CLICK_ACTIVATE:
g_value_set_boolean (value, gtk_list_item_manager_get_single_click_activate (self->item_manager));
break;
Add rubberband api Add an ::enable-rubberband property to GtkListView, GtkGridView and GtkColumnView.
2019-12-23 19:47:19 +00:00
case PROP_ENABLE_RUBBERBAND:
g_value_set_boolean (value, gtk_list_base_get_enable_rubberband (GTK_LIST_BASE (self)));
break;
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gtk_list_view_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GtkListView *self = GTK_LIST_VIEW (object);
switch (property_id)
{
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
case PROP_FACTORY:
gtk_list_view_set_factory (self, g_value_get_object (value));
break;
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
case PROP_MODEL:
gtk_list_view_set_model (self, g_value_get_object (value));
break;
listview: Add gtk_list_view_set_show_separators() Do the same thing that GtkListBox does in commit 0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44
2019-06-04 01:01:15 +00:00
case PROP_SHOW_SEPARATORS:
gtk_list_view_set_show_separators (self, g_value_get_boolean (value));
break;
listview: Add single-click-activate Add a single-click-activate property to GtkListView.
2019-12-14 01:57:57 +00:00
case PROP_SINGLE_CLICK_ACTIVATE:
gtk_list_view_set_single_click_activate (self, g_value_get_boolean (value));
break;
Add rubberband api Add an ::enable-rubberband property to GtkListView, GtkGridView and GtkColumnView.
2019-12-23 19:47:19 +00:00
case PROP_ENABLE_RUBBERBAND:
gtk_list_view_set_enable_rubberband (self, g_value_get_boolean (value));
break;
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
listview: Implement activation - a GtkListview::activate signal - a GtkListItem::activatable property - activate list items on double clicks and <Enter> presses
2019-10-15 21:06:36 +00:00
static void
gtk_list_view_activate_item (GtkWidget *widget,
const char *action_name,
GVariant *parameter)
{
GtkListView *self = GTK_LIST_VIEW (widget);
guint pos;
if (!g_variant_check_format_string (parameter, "u", FALSE))
return;
g_variant_get (parameter, "u", &pos);
listbase: Take over anchor handling With that, pretty much all code but allocating the widgets is gone from the gridview and listview.
2019-10-26 06:49:27 +00:00
if (pos >= gtk_list_base_get_n_items (GTK_LIST_BASE (self)))
listview: Implement activation - a GtkListview::activate signal - a GtkListItem::activatable property - activate list items on double clicks and <Enter> presses
2019-10-15 21:06:36 +00:00
return;
g_signal_emit (widget, signals[ACTIVATE], 0, pos);
}
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
static void
gtk_list_view_class_init (GtkListViewClass *klass)
{
listbase: Move GtkScrollable implementation Shared code between GtkGridView and GtkListView.
2019-10-22 21:46:34 +00:00
GtkListBaseClass *list_base_class = GTK_LIST_BASE_CLASS (klass);
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
listbase: Move GtkScrollable implementation Shared code between GtkGridView and GtkListView.
2019-10-22 21:46:34 +00:00
listbase: Move item manager here Nothing really changes, because both ListView and GridView still keep self->item_manager around, but it's set up to point at the base's item manager. This way we can slowly move things to GtkListBase that need the item manager (like trackers).
2019-10-23 00:34:28 +00:00
list_base_class->list_item_name = "row";
listview: Set accessible roles Use the LIST and LIST_ITEM roles for GtkListView and its children. Use the GRID and GRID_CELL roles for GtkGridView and its children.
2020-10-15 03:34:51 +00:00
list_base_class->list_item_role = GTK_ACCESSIBLE_ROLE_LIST_ITEM;
listbase: Move item manager here Nothing really changes, because both ListView and GridView still keep self->item_manager around, but it's set up to point at the base's item manager. This way we can slowly move things to GtkListBase that need the item manager (like trackers).
2019-10-23 00:34:28 +00:00
list_base_class->list_item_size = sizeof (ListRow);
list_base_class->list_item_augment_size = sizeof (ListRowAugment);
list_base_class->list_item_augment_func = list_row_augment;
listbase: Add vfuncs to convert positions to/from coordinates ... and use that to implement PageUp/PageDown. With that, all keyboard handling has been moved to GtkListBase.
2019-10-25 05:39:57 +00:00
list_base_class->get_allocation_along = gtk_list_view_get_allocation_along;
list_base_class->get_allocation_across = gtk_list_view_get_allocation_across;
listbase: Compute rubberband region on-demand Instead of storing the active items as we go, compute the affected items whenever the rubberband changes and in particular when the rubberband ends. That way, the rubberband is guaranteed to select a rectangle even after scrolling very far. This is achieved by having a get_items_in_rect() vfunc that selects all the items in the rubberbanded rectangle and returns them as a bitset.
2020-06-26 00:56:38 +00:00
list_base_class->get_items_in_rect = gtk_list_view_get_items_in_rect;
listbase: Add vfuncs to convert positions to/from coordinates ... and use that to implement PageUp/PageDown. With that, all keyboard handling has been moved to GtkListBase.
2019-10-25 05:39:57 +00:00
list_base_class->get_position_from_allocation = gtk_list_view_get_position_from_allocation;
listbase: Move focus moving keybindings here The focus tracker is not yet moved because that depends on scroll_to() support and we don't have that yet. Whoops. So we use a hack.
2019-10-24 04:49:38 +00:00
list_base_class->move_focus_along = gtk_list_view_move_focus_along;
list_base_class->move_focus_across = gtk_list_view_move_focus_across;
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
widget_class->measure = gtk_list_view_measure;
widget_class->size_allocate = gtk_list_view_size_allocate;
gobject_class->dispose = gtk_list_view_dispose;
gobject_class->get_property = gtk_list_view_get_property;
gobject_class->set_property = gtk_list_view_set_property;
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* GtkListView:factory: (attributes org.gtk.Property.get=gtk_list_view_get_factory org.gtk.Property.set=gtk_list_view_set_factory)
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* Factory for populating list items.
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
*/
properties[PROP_FACTORY] =
Remove all nicks and blurbs from param specs Those property features don't seem to be in use anywhere. They are redundant since the docs cover the same information and more. They also created unnecessary translation work. Closes #4904
2022-05-11 12:19:39 +00:00
g_param_spec_object ("factory", NULL, NULL,
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
GTK_TYPE_LIST_ITEM_FACTORY,
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* GtkListView:model: (attributes org.gtk.Property.get=gtk_list_view_get_model org.gtk.Property.set=gtk_list_view_set_model)
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* Model for the items displayed.
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
*/
properties[PROP_MODEL] =
Remove all nicks and blurbs from param specs Those property features don't seem to be in use anywhere. They are redundant since the docs cover the same information and more. They also created unnecessary translation work. Closes #4904
2022-05-11 12:19:39 +00:00
g_param_spec_object ("model", NULL, NULL,
list widgets: Use selection models in the api Change the apis in GtkListView, GtkColumnView and GtkGridView to be explicitly about GtkSelectionModel, to make it obvious that the widgets handle selection. Update all users.
2020-08-31 21:06:48 +00:00
GTK_TYPE_SELECTION_MODEL,
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
listview: Add gtk_list_view_set_show_separators() Do the same thing that GtkListBox does in commit 0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44
2019-06-04 01:01:15 +00:00
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* GtkListView:show-separators: (attributes org.gtk.Property.get=gtk_list_view_get_show_separators org.gtk.Property.set=gtk_list_view_set_show_separators)
listview: Add gtk_list_view_set_show_separators() Do the same thing that GtkListBox does in commit 0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44
2019-06-04 01:01:15 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* Show separators between rows.
listview: Add gtk_list_view_set_show_separators() Do the same thing that GtkListBox does in commit 0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44
2019-06-04 01:01:15 +00:00
*/
properties[PROP_SHOW_SEPARATORS] =
Remove all nicks and blurbs from param specs Those property features don't seem to be in use anywhere. They are redundant since the docs cover the same information and more. They also created unnecessary translation work. Closes #4904
2022-05-11 12:19:39 +00:00
g_param_spec_boolean ("show-separators", NULL, NULL,
listview: Add gtk_list_view_set_show_separators() Do the same thing that GtkListBox does in commit 0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44
2019-06-04 01:01:15 +00:00
FALSE,
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
listview: Add single-click-activate Add a single-click-activate property to GtkListView.
2019-12-14 01:57:57 +00:00
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* GtkListView:single-click-activate: (attributes org.gtk.Property.get=gtk_list_view_get_single_click_activate org.gtk.Property.set=gtk_list_view_set_single_click_activate)
listview: Add single-click-activate Add a single-click-activate property to GtkListView.
2019-12-14 01:57:57 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* Activate rows on single click and select them on hover.
listview: Add single-click-activate Add a single-click-activate property to GtkListView.
2019-12-14 01:57:57 +00:00
*/
properties[PROP_SINGLE_CLICK_ACTIVATE] =
Remove all nicks and blurbs from param specs Those property features don't seem to be in use anywhere. They are redundant since the docs cover the same information and more. They also created unnecessary translation work. Closes #4904
2022-05-11 12:19:39 +00:00
g_param_spec_boolean ("single-click-activate", NULL, NULL,
listview: Add single-click-activate Add a single-click-activate property to GtkListView.
2019-12-14 01:57:57 +00:00
FALSE,
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
Add rubberband api Add an ::enable-rubberband property to GtkListView, GtkGridView and GtkColumnView.
2019-12-23 19:47:19 +00:00
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* GtkListView:enable-rubberband: (attributes org.gtk.Property.get=gtk_list_view_get_enable_rubberband org.gtk.Property.set=gtk_list_view_set_enable_rubberband)
Add rubberband api Add an ::enable-rubberband property to GtkListView, GtkGridView and GtkColumnView.
2019-12-23 19:47:19 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* Allow rubberband selection.
Add rubberband api Add an ::enable-rubberband property to GtkListView, GtkGridView and GtkColumnView.
2019-12-23 19:47:19 +00:00
*/
properties[PROP_ENABLE_RUBBERBAND] =
Remove all nicks and blurbs from param specs Those property features don't seem to be in use anywhere. They are redundant since the docs cover the same information and more. They also created unnecessary translation work. Closes #4904
2022-05-11 12:19:39 +00:00
g_param_spec_boolean ("enable-rubberband", NULL, NULL,
Add rubberband api Add an ::enable-rubberband property to GtkListView, GtkGridView and GtkColumnView.
2019-12-23 19:47:19 +00:00
FALSE,
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
g_object_class_install_properties (gobject_class, N_PROPS, properties);
listview: Implement activation - a GtkListview::activate signal - a GtkListItem::activatable property - activate list items on double clicks and <Enter> presses
2019-10-15 21:06:36 +00:00
/**
* GtkListView::activate:
listview: Convert docs
2021-02-28 18:09:48 +00:00
* @self: The `GtkListView`
listview: Implement activation - a GtkListview::activate signal - a GtkListItem::activatable property - activate list items on double clicks and <Enter> presses
2019-10-15 21:06:36 +00:00
* @position: position of item to activate
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* Emitted when a row has been activated by the user,
listview: Implement activation - a GtkListview::activate signal - a GtkListItem::activatable property - activate list items on double clicks and <Enter> presses
2019-10-15 21:06:36 +00:00
* usually via activating the GtkListView|list.activate-item action.
*
* This allows for a convenient way to handle activation in a listview.
listview: Convert docs
2021-02-28 18:09:48 +00:00
* See [method@Gtk.ListItem.set_activatable] for details on how to use
* this signal.
listview: Implement activation - a GtkListview::activate signal - a GtkListItem::activatable property - activate list items on double clicks and <Enter> presses
2019-10-15 21:06:36 +00:00
*/
signals[ACTIVATE] =
g_signal_new (I_("activate"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
g_cclosure_marshal_VOID__UINT,
G_TYPE_NONE, 1,
G_TYPE_UINT);
g_signal_set_va_marshaller (signals[ACTIVATE],
G_TYPE_FROM_CLASS (gobject_class),
g_cclosure_marshal_VOID__UINTv);
/**
* GtkListView|list.activate-item:
* @position: position of item to activate
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* Activates the item given in @position by emitting the
* [signal@Gtk.ListView::activate] signal.
listview: Implement activation - a GtkListview::activate signal - a GtkListItem::activatable property - activate list items on double clicks and <Enter> presses
2019-10-15 21:06:36 +00:00
*/
gtk_widget_class_install_action (widget_class,
"list.activate-item",
"u",
gtk_list_view_activate_item);
Change css names of list widget The new names are GtkListView - listview row GtkGridView - gridview child GtkColumView - columnview header columnview listview row Adwaita css has been updated to preserve existing styles. Fixes: #2818
2020-06-04 12:42:55 +00:00
gtk_widget_class_set_css_name (widget_class, I_("listview"));
listview: Set accessible roles Use the LIST and LIST_ITEM roles for GtkListView and its children. Use the GRID and GRID_CELL roles for GtkGridView and its children.
2020-10-15 03:34:51 +00:00
gtk_widget_class_set_accessible_role (widget_class, GTK_ACCESSIBLE_ROLE_LIST);
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
}
static void
gtk_list_view_init (GtkListView *self)
{
listbase: Move item manager here Nothing really changes, because both ListView and GridView still keep self->item_manager around, but it's set up to point at the base's item manager. This way we can slowly move things to GtkListBase that need the item manager (like trackers).
2019-10-23 00:34:28 +00:00
self->item_manager = gtk_list_base_get_manager (GTK_LIST_BASE (self));
listbase: Take over anchor handling With that, pretty much all code but allocating the widgets is gone from the gridview and listview.
2019-10-26 06:49:27 +00:00
gtk_list_base_set_anchor_max_widgets (GTK_LIST_BASE (self),
GTK_LIST_VIEW_MAX_LIST_ITEMS,
GTK_LIST_VIEW_EXTRA_ITEMS);
Add .view to view widgets
2020-06-26 04:37:57 +00:00
gtk_widget_add_css_class (GTK_WIDGET (self), "view");
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
}
/**
* gtk_list_view_new:
docs: Reduce redundancy Remove a boatload of "or %NULL" from nullable parameters and return values. gi-docgen generates suitable text from the annotation that we don't need to duplicate. This adds a few missing nullable annotations too.
2021-05-21 00:45:06 +00:00
* @model: (nullable) (transfer full): the model to use
* @factory: (nullable) (transfer full): The factory to populate items with
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* Creates a new `GtkListView` that uses the given @factory for
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
* mapping items to widgets.
*
* The function takes ownership of the
list widgets: Simplify the constructors Now that both arguments to the _new_with_factory() constructors are nullable, there's no good reason to keep a separate _new() around. Just make gtk_list_view_new() and gtk_grid_view_new() take both a model and a factory.
2020-09-01 16:24:06 +00:00
* arguments, so you can write code like
listview: Convert docs
2021-02-28 18:09:48 +00:00
* ```c
* list_view = gtk_list_view_new (create_model (),
* gtk_builder_list_item_factory_new_from_resource ("/resource.ui"));
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
* ```
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* Returns: a new `GtkListView` using the given @model and @factory
*/
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
GtkWidget *
list widgets: Simplify the constructors Now that both arguments to the _new_with_factory() constructors are nullable, there's no good reason to keep a separate _new() around. Just make gtk_list_view_new() and gtk_grid_view_new() take both a model and a factory.
2020-09-01 16:24:06 +00:00
gtk_list_view_new (GtkSelectionModel *model,
GtkListItemFactory *factory)
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
{
GtkWidget *result;
list widgets: Use selection models in the api Change the apis in GtkListView, GtkColumnView and GtkGridView to be explicitly about GtkSelectionModel, to make it obvious that the widgets handle selection. Update all users.
2020-08-31 21:06:48 +00:00
g_return_val_if_fail (model == NULL || GTK_IS_SELECTION_MODEL (model), NULL);
listview: Revise constructors Make both gtk_list_view_new and gtk_list_view_new_with_factory take a model as first argument, and make all arguments allow-none and transfer full. Update all callers.
2020-07-26 22:27:23 +00:00
g_return_val_if_fail (factory == NULL || GTK_IS_LIST_ITEM_FACTORY (factory), NULL);
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
result = g_object_new (GTK_TYPE_LIST_VIEW,
listview: Revise constructors Make both gtk_list_view_new and gtk_list_view_new_with_factory take a model as first argument, and make all arguments allow-none and transfer full. Update all callers.
2020-07-26 22:27:23 +00:00
"model", model,
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
"factory", factory,
NULL);
listview: Revise constructors Make both gtk_list_view_new and gtk_list_view_new_with_factory take a model as first argument, and make all arguments allow-none and transfer full. Update all callers.
2020-07-26 22:27:23 +00:00
/* consume the references */
g_clear_object (&model);
g_clear_object (&factory);
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
return result;
}
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* gtk_list_view_get_model: (attributes org.gtk.Method.get_property=model)
* @self: a `GtkListView`
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
*
* Gets the model that's currently used to read the items displayed.
*
* Returns: (nullable) (transfer none): The model in use
listview: Convert docs
2021-02-28 18:09:48 +00:00
*/
list widgets: Use selection models in the api Change the apis in GtkListView, GtkColumnView and GtkGridView to be explicitly about GtkSelectionModel, to make it obvious that the widgets handle selection. Update all users.
2020-08-31 21:06:48 +00:00
GtkSelectionModel *
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
gtk_list_view_get_model (GtkListView *self)
{
g_return_val_if_fail (GTK_IS_LIST_VIEW (self), NULL);
listbase: Take over anchor handling With that, pretty much all code but allocating the widgets is gone from the gridview and listview.
2019-10-26 06:49:27 +00:00
return gtk_list_base_get_model (GTK_LIST_BASE (self));
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
}
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* gtk_list_view_set_model: (attributes org.gtk.Method.set_property=model)
* @self: a `GtkListView`
docs: Reduce redundancy Remove a boatload of "or %NULL" from nullable parameters and return values. gi-docgen generates suitable text from the annotation that we don't need to duplicate. This adds a few missing nullable annotations too.
2021-05-21 00:45:06 +00:00
* @model: (nullable) (transfer none): the model to use
listview: Add initial support for displaying selections
2018-10-03 16:53:06 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* Sets the model to use.
*
* This must be a [iface@Gtk.SelectionModel] to use.
*/
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
void
list widgets: Use selection models in the api Change the apis in GtkListView, GtkColumnView and GtkGridView to be explicitly about GtkSelectionModel, to make it obvious that the widgets handle selection. Update all users.
2020-08-31 21:06:48 +00:00
gtk_list_view_set_model (GtkListView *self,
GtkSelectionModel *model)
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
{
g_return_if_fail (GTK_IS_LIST_VIEW (self));
list widgets: Use selection models in the api Change the apis in GtkListView, GtkColumnView and GtkGridView to be explicitly about GtkSelectionModel, to make it obvious that the widgets handle selection. Update all users.
2020-08-31 21:06:48 +00:00
g_return_if_fail (model == NULL || GTK_IS_SELECTION_MODEL (model));
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
listbase: Take over anchor handling With that, pretty much all code but allocating the widgets is gone from the gridview and listview.
2019-10-26 06:49:27 +00:00
if (!gtk_list_base_set_model (GTK_LIST_BASE (self), model))
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
return;
listview: Set accessible roles Use the LIST and LIST_ITEM roles for GtkListView and its children. Use the GRID and GRID_CELL roles for GtkGridView and its children.
2020-10-15 03:34:51 +00:00
gtk_accessible_update_property (GTK_ACCESSIBLE (self),
GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE, GTK_IS_MULTI_SELECTION (model),
-1);
gtk: Add a GtkListView skeleton
2018-09-16 18:52:06 +00:00
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MODEL]);
}
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* gtk_list_view_get_factory: (attributes org.gtk.Method.get_property=factory)
* @self: a `GtkListView`
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
*
* Gets the factory that's currently used to populate list items.
*
* Returns: (nullable) (transfer none): The factory in use
listview: Convert docs
2021-02-28 18:09:48 +00:00
*/
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
GtkListItemFactory *
gtk_list_view_get_factory (GtkListView *self)
listview: Introduce GtkListItemFactory Thisis the abstraction I intend to use for creating widgets and binding them to the item out of the listview. For now this is a very dumb wrapper around the functions that exist in the API. But it leaves the freedom to turn this into public API, make an interface out of it and most of all write different implementations, in particular one that uses GtkBuilder.
2018-09-17 05:29:50 +00:00
{
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
g_return_val_if_fail (GTK_IS_LIST_VIEW (self), NULL);
listview: Introduce GtkListItemFactory Thisis the abstraction I intend to use for creating widgets and binding them to the item out of the listview. For now this is a very dumb wrapper around the functions that exist in the API. But it leaves the freedom to turn this into public API, make an interface out of it and most of all write different implementations, in particular one that uses GtkBuilder.
2018-09-17 05:29:50 +00:00
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
return gtk_list_item_manager_get_factory (self->item_manager);
listview: Introduce GtkListItemFactory Thisis the abstraction I intend to use for creating widgets and binding them to the item out of the listview. For now this is a very dumb wrapper around the functions that exist in the API. But it leaves the freedom to turn this into public API, make an interface out of it and most of all write different implementations, in particular one that uses GtkBuilder.
2018-09-17 05:29:50 +00:00
}
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* gtk_list_view_set_factory: (attributes org.gtk.Method.set_property=factory)
* @self: a `GtkListView`
docs: Reduce redundancy Remove a boatload of "or %NULL" from nullable parameters and return values. gi-docgen generates suitable text from the annotation that we don't need to duplicate. This adds a few missing nullable annotations too.
2021-05-21 00:45:06 +00:00
* @factory: (nullable) (transfer none): the factory to use
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
*
listview: Convert docs
2021-02-28 18:09:48 +00:00
* Sets the `GtkListItemFactory` to use for populating list items.
*/
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
void
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
gtk_list_view_set_factory (GtkListView *self,
GtkListItemFactory *factory)
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
{
g_return_if_fail (GTK_IS_LIST_VIEW (self));
listview: Fix return_if_fail()s
2022-02-26 02:04:53 +00:00
g_return_if_fail (factory == NULL || GTK_IS_LIST_ITEM_FACTORY (factory));
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
if (factory == gtk_list_item_manager_get_factory (self->item_manager))
return;
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
gtk_list_item_manager_set_factory (self->item_manager, factory);
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_FACTORY]);
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
}
listview: Add gtk_list_view_set_show_separators() Do the same thing that GtkListBox does in commit 0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44
2019-06-04 01:01:15 +00:00
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* gtk_list_view_set_show_separators: (attributes org.gtk.Method.set_property=show-separators)
* @self: a `GtkListView`
listview: Add gtk_list_view_set_show_separators() Do the same thing that GtkListBox does in commit 0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44
2019-06-04 01:01:15 +00:00
* @show_separators: %TRUE to show separators
*
* Sets whether the list box should show separators
* between rows.
*/
void
gtk_list_view_set_show_separators (GtkListView *self,
gboolean show_separators)
{
g_return_if_fail (GTK_IS_LIST_VIEW (self));
if (self->show_separators == show_separators)
return;
self->show_separators = show_separators;
if (show_separators)
listview: Use gtk_widget_add_css_class No need to use the style context api for this anymore.
2020-06-03 21:36:52 +00:00
gtk_widget_add_css_class (GTK_WIDGET (self), "separators");
listview: Add gtk_list_view_set_show_separators() Do the same thing that GtkListBox does in commit 0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44
2019-06-04 01:01:15 +00:00
else
listview: Use gtk_widget_add_css_class No need to use the style context api for this anymore.
2020-06-03 21:36:52 +00:00
gtk_widget_remove_css_class (GTK_WIDGET (self), "separators");
listview: Add gtk_list_view_set_show_separators() Do the same thing that GtkListBox does in commit 0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44
2019-06-04 01:01:15 +00:00
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SHOW_SEPARATORS]);
}
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* gtk_list_view_get_show_separators: (attributes org.gtk.Method.get_property=show-separators)
* @self: a `GtkListView`
listview: Add gtk_list_view_set_show_separators() Do the same thing that GtkListBox does in commit 0249bd4f8a03ec473f3ca9d4324a3a8b75bd3f44
2019-06-04 01:01:15 +00:00
*
* Returns whether the list box should show separators
* between rows.
*
* Returns: %TRUE if the list box shows separators
*/
gboolean
gtk_list_view_get_show_separators (GtkListView *self)
{
g_return_val_if_fail (GTK_IS_LIST_VIEW (self), FALSE);
return self->show_separators;
}
listview: Add single-click-activate Add a single-click-activate property to GtkListView.
2019-12-14 01:57:57 +00:00
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* gtk_list_view_set_single_click_activate: (attributes org.gtk.Method.set_property=single-click-activate)
* @self: a `GtkListView`
listview: Add single-click-activate Add a single-click-activate property to GtkListView.
2019-12-14 01:57:57 +00:00
* @single_click_activate: %TRUE to activate items on single click
*
* Sets whether rows should be activated on single click and
* selected on hover.
*/
void
gtk_list_view_set_single_click_activate (GtkListView *self,
gboolean single_click_activate)
{
g_return_if_fail (GTK_IS_LIST_VIEW (self));
if (single_click_activate == gtk_list_item_manager_get_single_click_activate (self->item_manager))
return;
gtk_list_item_manager_set_single_click_activate (self->item_manager, single_click_activate);
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SINGLE_CLICK_ACTIVATE]);
}
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* gtk_list_view_get_single_click_activate: (attributes org.gtk.Method.set_property=single-click-activate)
* @self: a `GtkListView`
listview: Add single-click-activate Add a single-click-activate property to GtkListView.
2019-12-14 01:57:57 +00:00
*
* Returns whether rows will be activated on single click and
* selected on hover.
*
* Returns: %TRUE if rows are activated on single click
*/
gboolean
gtk_list_view_get_single_click_activate (GtkListView *self)
{
g_return_val_if_fail (GTK_IS_LIST_VIEW (self), FALSE);
return gtk_list_item_manager_get_single_click_activate (self->item_manager);
}
Add rubberband api Add an ::enable-rubberband property to GtkListView, GtkGridView and GtkColumnView.
2019-12-23 19:47:19 +00:00
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* gtk_list_view_set_enable_rubberband: (attributes org.gtk.Method.set_property=enable-rubberband)
* @self: a `GtkListView`
Add rubberband api Add an ::enable-rubberband property to GtkListView, GtkGridView and GtkColumnView.
2019-12-23 19:47:19 +00:00
* @enable_rubberband: %TRUE to enable rubberband selection
*
* Sets whether selections can be changed by dragging with the mouse.
*/
void
gtk_list_view_set_enable_rubberband (GtkListView *self,
gboolean enable_rubberband)
{
g_return_if_fail (GTK_IS_LIST_VIEW (self));
if (enable_rubberband == gtk_list_base_get_enable_rubberband (GTK_LIST_BASE (self)))
return;
gtk_list_base_set_enable_rubberband (GTK_LIST_BASE (self), enable_rubberband);
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ENABLE_RUBBERBAND]);
}
/**
listview: Convert docs
2021-02-28 18:09:48 +00:00
* gtk_list_view_get_enable_rubberband: (attributes org.gtk.Method.get_property=enable-rubberband)
* @self: a `GtkListView`
Add rubberband api Add an ::enable-rubberband property to GtkListView, GtkGridView and GtkColumnView.
2019-12-23 19:47:19 +00:00
*
* Returns whether rows can be selected by dragging with the mouse.
*
* Returns: %TRUE if rubberband selection is enabled
*/
gboolean
gtk_list_view_get_enable_rubberband (GtkListView *self)
{
g_return_val_if_fail (GTK_IS_LIST_VIEW (self), FALSE);
return gtk_list_base_get_enable_rubberband (GTK_LIST_BASE (self));
}
Reference in New Issue Copy Permalink