Revert "stringlist: Use an array"

This reverts commit bf367b219b.

demos/gtk-demo/demo.gresource.xml

@@ -225,6 +225,7 @@
     <file>listview_minesweeper.c</file>
     <file>listview_settings.c</file>
     <file>listview_weather.c</file>
+    <file>listview_words.c</file>
     <file>list_store.c</file>
     <file>markup.c</file>
     <file>modelbutton.c</file>

demos/gtk-demo/listview_words.c

@@ -0,0 +1,241 @@
+/* Lists/Words
+ *
+ * This demo shows filtering a long list - of words.
+ *
+ * You should have the file `/usr/share/dict/words` installed for
+ * this demo to work.
+ */
+
+#include <gtk/gtk.h>
+
+static GtkWidget *window = NULL;
+static GtkWidget *progress;
+
+const char *factory_text =
+"<?xml version='1.0' encoding='UTF-8'?>\n"
+"<interface>\n"
+"  <template class='GtkListItem'>\n"
+"    <property name='child'>\n"
+"      <object class='GtkLabel'>\n"
+"        <property name='ellipsize'>end</property>\n"
+"        <property name='xalign'>0</property>\n"
+"        <binding name='label'>\n"
+"          <lookup name='string' type='GtkStringObject'>\n"
+"            <lookup name='item'>GtkListItem</lookup>\n"
+"          </lookup>\n"
+"        </binding>\n"
+"      </object>\n"
+"    </property>\n"
+"  </template>\n"
+"</interface>\n";
+
+static void
+update_title_cb (GtkFilterListModel *model)
+{
+  guint total;
+  char *title;
+  guint pending;
+
+  total = g_list_model_get_n_items (gtk_filter_list_model_get_model (model));
+  pending = gtk_filter_list_model_get_pending (model);
+
+  title = g_strdup_printf ("%u lines", g_list_model_get_n_items (G_LIST_MODEL (model)));
+
+  gtk_widget_set_visible (progress, pending != 0);
+  gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress), (total - pending) / (double) total);
+  gtk_window_set_title (GTK_WINDOW (window), title);
+  g_free (title);
+}
+
+static void
+read_lines_cb (GObject      *object,
+               GAsyncResult *result,
+               gpointer      data)
+{
+  GBufferedInputStream *stream = G_BUFFERED_INPUT_STREAM (object);
+  GtkStringList *stringlist = data;
+  GError *error = NULL;
+  gsize size;
+  GPtrArray *lines;
+  gssize n_filled;
+  const char *buffer, *newline;
+
+  n_filled = g_buffered_input_stream_fill_finish (stream, result, &error);
+  if (n_filled < 0)
+    {
+      g_print ("Could not read data: %s\n", error->message);
+      g_clear_error (&error);
+      return;
+    }
+
+  buffer = g_buffered_input_stream_peek_buffer (stream, &size);
+
+  if (n_filled == 0)
+    {
+      if (size)
+        gtk_string_list_take (stringlist, g_utf8_make_valid (buffer, size));
+      return;
+    }
+
+  lines = NULL;
+  while ((newline = memchr (buffer, '\n', size)))
+    {
+      if (newline > buffer)
+        {
+          if (lines == NULL)
+            lines = g_ptr_array_new_with_free_func (g_free);
+          g_ptr_array_add (lines, g_utf8_make_valid (buffer, newline - buffer));
+        }
+      if (g_input_stream_skip (G_INPUT_STREAM (stream), newline - buffer + 1, NULL, &error) < 0)
+        {
+          g_clear_error (&error);
+          break;
+        }
+      buffer = g_buffered_input_stream_peek_buffer (stream, &size);
+    }
+  if (lines == NULL)
+    {
+      g_buffered_input_stream_set_buffer_size (stream, g_buffered_input_stream_get_buffer_size (stream) + 4096);
+    }
+  else
+    {
+      g_ptr_array_add (lines, NULL);
+      gtk_string_list_splice (stringlist, g_list_model_get_n_items (G_LIST_MODEL (stringlist)), 0, (const char **) lines->pdata);
+      g_ptr_array_free (lines, TRUE);
+    }
+
+  g_buffered_input_stream_fill_async (stream, -1, G_PRIORITY_HIGH_IDLE, NULL, read_lines_cb, data);
+}
+               
+static void
+file_is_open_cb (GObject      *file,
+                 GAsyncResult *result,
+                 gpointer      data)
+{
+  GError *error = NULL;
+  GFileInputStream *file_stream;
+  GBufferedInputStream *stream;
+
+  file_stream = g_file_read_finish (G_FILE (file), result, &error);
+  if (file_stream == NULL)
+    {
+      g_print ("Could not open file: %s\n", error->message);
+      g_error_free (error);
+      return;
+    }
+
+  stream = G_BUFFERED_INPUT_STREAM (g_buffered_input_stream_new (G_INPUT_STREAM (file_stream)));
+  g_buffered_input_stream_fill_async (stream, -1, G_PRIORITY_HIGH_IDLE, NULL, read_lines_cb, data);
+  g_object_unref (stream);
+}
+
+static void
+load_file (GtkStringList *list,
+           GFile         *file)
+{
+  gtk_string_list_splice (list, 0, g_list_model_get_n_items (G_LIST_MODEL (list)), NULL);
+  g_file_read_async (file, G_PRIORITY_HIGH_IDLE, NULL, file_is_open_cb, list);
+}
+
+static void
+file_selected_cb (GtkWidget     *button,
+                  GtkStringList *stringlist)
+{
+  GFile *file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (button));
+
+  if (file)
+    {
+      load_file (stringlist, file);
+      g_object_unref (file);
+    }
+}
+
+GtkWidget *
+do_listview_words (GtkWidget *do_widget)
+{
+  if (window == NULL)
+    {
+      GtkWidget *header, *listview, *sw, *vbox, *search_entry, *open_button, *overlay;
+      GtkFilterListModel *filter_model;
+      GtkNoSelection *selection;
+      GtkStringList *stringlist;
+      GtkFilter *filter;
+      GtkExpression *expression;
+      GFile *file;
+
+      file = g_file_new_for_path ("/usr/share/dict/words");
+      if (g_file_query_exists (file, NULL))
+        {
+          stringlist = gtk_string_list_new (NULL);
+          load_file (stringlist, file);
+        }
+      else
+        {
+          char **words;
+          words = g_strsplit ("lorem ipsum dolor sit amet consectetur adipisci elit sed eiusmod tempor incidunt labore et dolore magna aliqua ut enim ad minim veniam quis nostrud exercitation ullamco laboris nisi ut aliquid ex ea commodi consequat", " ", -1);
+          stringlist = gtk_string_list_new ((const char **) words);
+          g_strfreev (words);
+        }
+
+      filter = gtk_string_filter_new ();
+      expression = gtk_property_expression_new (GTK_TYPE_STRING_OBJECT, NULL, "string");
+      gtk_string_filter_set_expression (GTK_STRING_FILTER (filter), expression);
+      gtk_expression_unref (expression);
+      filter_model = gtk_filter_list_model_new (G_LIST_MODEL (stringlist), filter);
+      gtk_filter_list_model_set_incremental (filter_model, TRUE);
+
+      window = gtk_window_new ();
+      gtk_window_set_default_size (GTK_WINDOW (window), 400, 600);
+
+      header = gtk_header_bar_new ();
+      gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), TRUE);
+      open_button = gtk_file_chooser_button_new ("_Open", GTK_FILE_CHOOSER_ACTION_OPEN);
+      g_signal_connect (open_button, "file-set", G_CALLBACK (file_selected_cb), stringlist);
+      gtk_header_bar_pack_start (GTK_HEADER_BAR (header), open_button);
+      gtk_window_set_titlebar (GTK_WINDOW (window), header);
+
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer*)&window);
+
+      vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+      gtk_window_set_child (GTK_WINDOW (window), vbox);
+
+      search_entry = gtk_search_entry_new ();
+      g_object_bind_property (search_entry, "text", filter, "search", 0);
+      gtk_box_append (GTK_BOX (vbox), search_entry);
+
+      overlay = gtk_overlay_new ();
+      gtk_box_append (GTK_BOX (vbox), overlay);
+
+      progress = gtk_progress_bar_new ();
+      gtk_widget_set_halign (progress, GTK_ALIGN_FILL);
+      gtk_widget_set_valign (progress, GTK_ALIGN_START);
+      gtk_widget_set_hexpand (progress, TRUE);
+      gtk_overlay_add_overlay (GTK_OVERLAY (overlay), progress);
+
+      sw = gtk_scrolled_window_new ();
+      gtk_overlay_set_child (GTK_OVERLAY (overlay), sw);
+
+      listview = gtk_list_view_new_with_factory (
+          gtk_builder_list_item_factory_new_from_bytes (NULL,
+              g_bytes_new_static (factory_text, strlen (factory_text))));
+      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), listview);
+      selection = gtk_no_selection_new (G_LIST_MODEL (filter_model));
+      gtk_list_view_set_model (GTK_LIST_VIEW (listview), G_LIST_MODEL (selection));
+      g_object_unref (selection);
+
+      g_signal_connect (filter_model, "items-changed", G_CALLBACK (update_title_cb), progress);
+      g_signal_connect (filter_model, "notify::pending", G_CALLBACK (update_title_cb), progress);
+      update_title_cb (filter_model);
+
+      g_object_unref (filter_model);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/meson.build

@@ -49,6 +49,7 @@ demos = files([
   'listview_minesweeper.c',
   'listview_settings.c',
   'listview_weather.c',
+  'listview_words.c',
   'markup.c',
   'modelbutton.c',
   'overlay.c',

docs/reference/gtk/gtk4-sections.txt

@@ -348,6 +348,7 @@ GtkBitset
 gtk_bitset_ref
 gtk_bitset_unref
 gtk_bitset_new_empty
+gtk_bitset_new_range
 gtk_bitset_copy
 <SUBSECTION>
 gtk_bitset_contains
@@ -355,6 +356,9 @@ gtk_bitset_is_empty
 gtk_bitset_equals
 gtk_bitset_get_minimum
 gtk_bitset_get_maximum
+gtk_bitset_get_size
+gtk_bitset_get_size_in_range
+gtk_bitset_get_nth
 <SUBSECTION>
 gtk_bitset_remove_all
 gtk_bitset_add
@@ -1540,6 +1544,9 @@ gtk_filter_list_model_set_model
 gtk_filter_list_model_get_model
 gtk_filter_list_model_set_filter
 gtk_filter_list_model_get_filter
+gtk_filter_list_model_set_incremental
+gtk_filter_list_model_get_incremental
+gtk_filter_list_model_get_pending
 <SUBSECTION Standard>
 GTK_FILTER_LIST_MODEL
 GTK_IS_FILTER_LIST_MODEL

gtk/a11y/gtkcellaccessible.c

@@ -295,7 +295,6 @@ gtk_cell_accessible_action_do_action (AtkAction *action,
   GtkCellAccessible *cell = GTK_CELL_ACCESSIBLE (action);
   GtkCellAccessibleParent *parent;
 
-  cell = GTK_CELL_ACCESSIBLE (action);
   if (gtk_accessible_get_widget (GTK_ACCESSIBLE (cell)) == NULL)
     return FALSE;
 

gtk/a11y/gtkpasswordentryaccessible.c

@@ -65,7 +65,7 @@ static gunichar
 gtk_password_entry_accessible_get_character_at_offset (AtkText *atk_text,
                                                        gint     offset)
 {
-  GtkText *text = get_text_widget (GTK_ACCESSIBLE (atk_text));
+  GtkText *text;
   char *contents, *index;
   gunichar result;
 

gtk/gtkbitset.c

@@ -193,12 +193,82 @@ gtk_bitset_get_maximum (const GtkBitset *self)
   return roaring_bitmap_maximum (&self->roaring);
 }
 
+/**
+ * gtk_bitset_get_size:
+ * @self: a #GtkBitSet
+ *
+ * Gets the number of values that were added to the set.  
+ * For example, if the set is empty, 0 is returned.
+ *
+ * Note that this function returns a #guint64, because when all values are
+ * set, the return value is #G_MAXUINT + 1. Unless you are sure this cannot
+ * happen (it can't with #GListModel), be sure to use a 64bit type.
+ *
+ * Returns: The number of values in the set.
+ **/
+guint64
+gtk_bitset_get_size (const GtkBitset *self)
+{
+  g_return_val_if_fail (self != NULL, 0);
+
+  return roaring_bitmap_get_cardinality (&self->roaring);
+}
+
+/**
+ * gtk_bitset_get_size_in_range:
+ * @self: a #GtkBitSet
+ * @first: the first element to include
+ * @last: the last element to include
+ *
+ * Gets the number of values that are part of the set from @first to @last
+ * (inclusive).
+ *
+ * Note that this function returns a #guint64, because when all values are
+ * set, the return value is #G_MAXUINT + 1. Unless you are sure this cannot
+ * happen (it can't with #GListModel), be sure to use a 64bit type.
+ *
+ * Returns: The number of values in the set from @first to @last.
+ **/
+guint64
+gtk_bitset_get_size_in_range (const GtkBitset *self,
+                              guint            first,
+                              guint            last)
+{
+  g_return_val_if_fail (self != NULL, 0);
+  g_return_val_if_fail (last >= first, 0);
+
+  return roaring_bitmap_range_cardinality (&self->roaring, first, ((uint64_t) last) + 1);
+}
+
+/**
+ * gtk_bitset_get_nth:
+ * @self: a #GtkBitset
+ * @nth: index of the item to get
+ *
+ * Returns the value of the @nth item in self.
+ *
+ * If @nth is >= the size of @self, 0 is returned.
+ *
+ * Returns: the value of the @nth item in @self
+ **/
+guint
+gtk_bitset_get_nth (const GtkBitset *self,
+                    guint            nth)
+{
+  uint32_t result;
+
+  if (!roaring_bitmap_select (&self->roaring, nth, &result))
+    return 0;
+
+  return result;
+}
+
 /**
  * gtk_bitset_new_empty:
  *
  * Creates a new empty bitset.
  *
- * Returns: A new empty bitset.
+ * Returns: A new empty bitset
  **/
 GtkBitset *
 gtk_bitset_new_empty (void)
@@ -214,6 +284,28 @@ gtk_bitset_new_empty (void)
   return self;
 }
 
+/**
+ * gtk_bitset_new_range:
+ * @start: first value to add
+ * @n_items: number of consecutive values to add
+ *
+ * Creates a bitset with the given range set.
+ *
+ * Returns: A new bitset
+ **/
+GtkBitset *
+gtk_bitset_new_range (guint start,
+                      guint n_items)
+{
+  GtkBitset *self;
+
+  self = gtk_bitset_new_empty ();
+
+  gtk_bitset_add_range (self, start, n_items);
+
+  return self;
+}
+
 /**
  * gtk_bitset_copy:
  * @self: a #GtkBitset

gtk/gtkbitset.h

@@ -48,6 +48,15 @@ GDK_AVAILABLE_IN_ALL
 gboolean                gtk_bitset_equals                       (const GtkBitset        *self,
                                                                  const GtkBitset        *other);
 GDK_AVAILABLE_IN_ALL
+guint64                 gtk_bitset_get_size                     (const GtkBitset        *self);
+GDK_AVAILABLE_IN_ALL
+guint64                 gtk_bitset_get_size_in_range            (const GtkBitset        *self,
+                                                                 guint                   first,
+                                                                 guint                   last);
+GDK_AVAILABLE_IN_ALL
+guint                   gtk_bitset_get_nth                      (const GtkBitset        *self,
+                                                                 guint                   nth);
+GDK_AVAILABLE_IN_ALL
 guint                   gtk_bitset_get_minimum                  (const GtkBitset        *self);
 GDK_AVAILABLE_IN_ALL
 guint                   gtk_bitset_get_maximum                  (const GtkBitset        *self);
@@ -56,6 +65,9 @@ GDK_AVAILABLE_IN_ALL
 GtkBitset *             gtk_bitset_new_empty                    (void);
 GDK_AVAILABLE_IN_ALL
 GtkBitset *             gtk_bitset_copy                         (const GtkBitset        *self);
+GDK_AVAILABLE_IN_ALL
+GtkBitset *             gtk_bitset_new_range                    (guint                   start,
+                                                                 guint                   n_items);
 
 GDK_AVAILABLE_IN_ALL
 void                    gtk_bitset_remove_all                   (GtkBitset              *self);

gtk/gtkdropdown.c

@@ -943,7 +943,7 @@ gtk_drop_down_set_from_strings (GtkDropDown       *self,
 
   set_default_factory (self);
 
-  model = G_LIST_MODEL (gtk_string_list_new ((const char **)texts));
+  model = G_LIST_MODEL (gtk_string_list_new (texts));
   gtk_drop_down_set_model (self, model);
   g_object_unref (model);
 }

gtk/gtkfilterlistmodel.c

@@ -21,7 +21,7 @@
 
 #include "gtkfilterlistmodel.h"
 
-#include "gtkrbtreeprivate.h"
+#include "gtkbitset.h"
 #include "gtkintl.h"
 #include "gtkprivate.h"
 
@@ -35,30 +35,22 @@
  * listmodel.
  * It hides some elements from the other model according to
  * criteria given by a #GtkFilter.
+ *
+ * The model can be set up to do incremental searching, so that
+ * filtering long lists doesn't block the UI. See
+ * gtk_filter_list_model_set_incremental() for details.
  */
 
 enum {
   PROP_0,
   PROP_FILTER,
+  PROP_INCREMENTAL,
   PROP_ITEM_TYPE,
   PROP_MODEL,
+  PROP_PENDING,
   NUM_PROPERTIES
 };
 
-typedef struct _FilterNode FilterNode;
-typedef struct _FilterAugment FilterAugment;
-
-struct _FilterNode
-{
-  guint visible : 1;
-};
-
-struct _FilterAugment
-{
-  guint n_items;
-  guint n_visible;
-};
-
 struct _GtkFilterListModel
 {
   GObject parent_instance;
@@ -67,8 +59,11 @@ struct _GtkFilterListModel
   GListModel *model;
   GtkFilter *filter;
   GtkFilterMatch strictness;
+  gboolean incremental;
 
-  GtkRbTree *items; /* NULL if strictness != GTK_FILTER_MATCH_SOME */
+  GtkBitset *matches; /* NULL if strictness != GTK_FILTER_MATCH_SOME */
+  GtkBitset *pending; /* not yet filtered items or NULL if all filtered */
+  guint pending_cb; /* idle callback handle */
 };
 
 struct _GtkFilterListModelClass
@@ -78,119 +73,6 @@ struct _GtkFilterListModelClass
 
 static GParamSpec *properties[NUM_PROPERTIES] = { NULL, };
 
-static void
-gtk_filter_list_model_augment (GtkRbTree *filter,
-                               gpointer   _aug,
-                               gpointer   _node,
-                               gpointer   left,
-                               gpointer   right)
-{
-  FilterNode *node = _node;
-  FilterAugment *aug = _aug;
-
-  aug->n_items = 1;
-  aug->n_visible = node->visible ? 1 : 0;
-
-  if (left)
-    {
-      FilterAugment *left_aug = gtk_rb_tree_get_augment (filter, left);
-      aug->n_items += left_aug->n_items;
-      aug->n_visible += left_aug->n_visible;
-    }
-  if (right)
-    {
-      FilterAugment *right_aug = gtk_rb_tree_get_augment (filter, right);
-      aug->n_items += right_aug->n_items;
-      aug->n_visible += right_aug->n_visible;
-    }
-}
-
-static FilterNode *
-gtk_filter_list_model_get_nth_filtered (GtkRbTree *tree,
-                                        guint      position,
-                                        guint     *out_unfiltered)
-{
-  FilterNode *node, *tmp;
-  guint unfiltered;
-
-  node = gtk_rb_tree_get_root (tree);
-  unfiltered = 0;
-
-  while (node)
-    {
-      tmp = gtk_rb_tree_node_get_left (node);
-      if (tmp)
-        {
-          FilterAugment *aug = gtk_rb_tree_get_augment (tree, tmp);
-          if (position < aug->n_visible)
-            {
-              node = tmp;
-              continue;
-            }
-          position -= aug->n_visible;
-          unfiltered += aug->n_items;
-        }
-
-      if (node->visible)
-        {
-          if (position == 0)
-            break;
-          position--;
-        }
-
-      unfiltered++;
-
-      node = gtk_rb_tree_node_get_right (node);
-    }
-
-  if (out_unfiltered)
-    *out_unfiltered = unfiltered;
-
-  return node;
-}
-
-static FilterNode *
-gtk_filter_list_model_get_nth (GtkRbTree *tree,
-                               guint      position,
-                               guint     *out_filtered)
-{
-  FilterNode *node, *tmp;
-  guint filtered;
-
-  node = gtk_rb_tree_get_root (tree);
-  filtered = 0;
-
-  while (node)
-    {
-      tmp = gtk_rb_tree_node_get_left (node);
-      if (tmp)
-        {
-          FilterAugment *aug = gtk_rb_tree_get_augment (tree, tmp);
-          if (position < aug->n_items)
-            {
-              node = tmp;
-              continue;
-            }
-          position -= aug->n_items;
-          filtered += aug->n_visible;
-        }
-
-      if (position == 0)
-        break;
-
-      position--;
-      if (node->visible)
-        filtered++;
-
-      node = gtk_rb_tree_node_get_right (node);
-    }
-
-  if (out_filtered)
-    *out_filtered = filtered;
-
-  return node;
-}
-
 static GType
 gtk_filter_list_model_get_item_type (GListModel *list)
 {
@@ -203,8 +85,6 @@ static guint
 gtk_filter_list_model_get_n_items (GListModel *list)
 {
   GtkFilterListModel *self = GTK_FILTER_LIST_MODEL (list);
-  FilterAugment *aug;
-  FilterNode *node;
 
   switch (self->strictness)
     {
@@ -215,18 +95,12 @@ gtk_filter_list_model_get_n_items (GListModel *list)
       return g_list_model_get_n_items (self->model);
 
     case GTK_FILTER_MATCH_SOME:
-      break;
+      return gtk_bitset_get_size (self->matches);
 
     default:
       g_assert_not_reached ();
+      return 0;
     }
-
-  node = gtk_rb_tree_get_root (self->items);
-  if (node == NULL)
-    return 0;
-
-  aug = gtk_rb_tree_get_augment (self->items, node);
-  return aug->n_visible;
 }
 
 static gpointer
@@ -246,7 +120,9 @@ gtk_filter_list_model_get_item (GListModel *list,
       break;
 
     case GTK_FILTER_MATCH_SOME:
-      gtk_filter_list_model_get_nth_filtered (self->items, position, &unfiltered);
+      unfiltered = gtk_bitset_get_nth (self->matches, position);
+      if (unfiltered == 0 && position >= gtk_bitset_get_size (self->matches))
+        return NULL;
       break;
 
     default:
@@ -268,8 +144,8 @@ G_DEFINE_TYPE_WITH_CODE (GtkFilterListModel, gtk_filter_list_model, G_TYPE_OBJEC
                          G_IMPLEMENT_INTERFACE (G_TYPE_LIST_MODEL, gtk_filter_list_model_model_init))
 
 static gboolean
-gtk_filter_list_model_run_filter (GtkFilterListModel *self,
-                                  guint               position)
+gtk_filter_list_model_run_filter_on_item (GtkFilterListModel *self,
+                                          guint               position)
 {
   gpointer item;
   gboolean visible;
@@ -284,26 +160,120 @@ gtk_filter_list_model_run_filter (GtkFilterListModel *self,
   return visible;
 }
 
-static guint
-gtk_filter_list_model_add_items (GtkFilterListModel *self,
-                                 FilterNode         *after,
-                                 guint               position,
-                                 guint               n_items)
+static void
+gtk_filter_list_model_run_filter (GtkFilterListModel *self,
+                                  guint               n_steps)
 {
-  FilterNode *node;
-  guint i, n_visible;
+  GtkBitsetIter iter;
+  guint i, pos;
+  gboolean more;
 
-  n_visible = 0;
+  g_return_if_fail (GTK_IS_FILTER_LIST_MODEL (self));
   
-  for (i = 0; i < n_items; i++)
+  if (self->pending == NULL)
+    return;
+
+  for (i = 0, more = gtk_bitset_iter_init_first (&iter, self->pending, &pos);
+       i < n_steps && more;
+       i++, more = gtk_bitset_iter_next (&iter, &pos))
     {
-      node = gtk_rb_tree_insert_before (self->items, after);
-      node->visible = gtk_filter_list_model_run_filter (self, position + i);
-      if (node->visible)
-        n_visible++;
+      if (gtk_filter_list_model_run_filter_on_item (self, pos))
+        gtk_bitset_add (self->matches, pos);
     }
 
-  return n_visible;
+  if (more)
+    gtk_bitset_remove_range_closed (self->pending, 0, pos);
+  else
+    g_clear_pointer (&self->pending, gtk_bitset_unref);
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PENDING]);
+
+  return;
+}
+
+static void
+gtk_filter_list_model_stop_filtering (GtkFilterListModel *self)
+{
+  gboolean notify_pending = self->pending != NULL;
+
+  g_clear_pointer (&self->pending, gtk_bitset_unref);
+  g_clear_handle_id (&self->pending_cb, g_source_remove);
+
+  if (notify_pending)
+    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PENDING]);
+}
+
+static void
+gtk_filter_list_model_emit_items_changed_for_changes (GtkFilterListModel *self,
+                                                      GtkBitset          *old)
+{
+  GtkBitset *changes;
+
+  changes = gtk_bitset_copy (self->matches);
+  gtk_bitset_difference (changes, old);
+  if (!gtk_bitset_is_empty (changes))
+    {
+      guint min, max;
+
+      min = gtk_bitset_get_minimum (changes);
+      max = gtk_bitset_get_maximum (changes);
+      g_list_model_items_changed (G_LIST_MODEL (self),
+                                  min > 0 ? gtk_bitset_get_size_in_range (self->matches, 0, min - 1) : 0,
+                                  gtk_bitset_get_size_in_range (old, min, max),
+                                  gtk_bitset_get_size_in_range (self->matches, min, max));
+    }
+  gtk_bitset_unref (changes);
+  gtk_bitset_unref (old);
+}
+
+static gboolean
+gtk_filter_list_model_run_filter_cb (gpointer data)
+{
+  GtkFilterListModel *self = data;
+  GtkBitset *old;
+
+  old = gtk_bitset_copy (self->matches);
+  gtk_filter_list_model_run_filter (self, 512);
+
+  if (self->pending == NULL)
+    gtk_filter_list_model_stop_filtering (self);
+
+  gtk_filter_list_model_emit_items_changed_for_changes (self, old);
+
+  return G_SOURCE_CONTINUE;
+}
+
+/* NB: bitset is (transfer full) */
+static void
+gtk_filter_list_model_start_filtering (GtkFilterListModel *self,
+                                       GtkBitset          *items)
+{
+  if (self->pending)
+    {
+      gtk_bitset_union (self->pending, items);
+      gtk_bitset_unref (items);
+      g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PENDING]);
+      return;
+    }
+
+  if (gtk_bitset_is_empty (items))
+    {
+      gtk_bitset_unref (items);
+      return;
+    }
+
+  self->pending = items;
+
+  if (!self->incremental)
+    {
+      gtk_filter_list_model_run_filter (self, G_MAXUINT);
+      g_assert (self->pending == NULL);
+      return;
+    }
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PENDING]);
+  g_assert (self->pending_cb == 0);
+  self->pending_cb = g_idle_add (gtk_filter_list_model_run_filter_cb, self);
+  g_source_set_name_by_id (self->pending_cb, "[gtk] gtk_filter_list_model_run_filter_cb");
 }
 
 static void
@@ -313,8 +283,7 @@ gtk_filter_list_model_items_changed_cb (GListModel         *model,
                                         guint               added,
                                         GtkFilterListModel *self)
 {
-  FilterNode *node;
-  guint i, filter_position, filter_removed, filter_added;
+  guint filter_removed, filter_added;
 
   switch (self->strictness)
     {
@@ -332,22 +301,22 @@ gtk_filter_list_model_items_changed_cb (GListModel         *model,
       g_assert_not_reached ();
     }
 
-  node = gtk_filter_list_model_get_nth (self->items, position, &filter_position);
+  if (removed > 0)
+    filter_removed = gtk_bitset_get_size_in_range (self->matches, position, position + removed - 1);
+  else
+    filter_removed = 0;
 
-  filter_removed = 0;
-  for (i = 0; i < removed; i++)
-    {
-      FilterNode *next = gtk_rb_tree_node_get_next (node);
-      if (node->visible)
-        filter_removed++;
-      gtk_rb_tree_remove (self->items, node);
-      node = next;
-    }
+  gtk_bitset_slice (self->matches, position, removed, added);
+  if (self->pending)
+    gtk_bitset_slice (self->pending, position, removed, added);
 
-  filter_added = gtk_filter_list_model_add_items (self, node, position, added);
+  gtk_filter_list_model_start_filtering (self, gtk_bitset_new_range (position, added));
+  filter_added = gtk_bitset_get_size_in_range (self->matches, position, position + added - 1);
 
   if (filter_removed > 0 || filter_added > 0)
-    g_list_model_items_changed (G_LIST_MODEL (self), filter_position, filter_removed, filter_added);
+    g_list_model_items_changed (G_LIST_MODEL (self),
+                                gtk_bitset_get_size_in_range (self->matches, 0, position),
+                                filter_removed, filter_added);
 }
 
 static void
@@ -364,6 +333,10 @@ gtk_filter_list_model_set_property (GObject      *object,
       gtk_filter_list_model_set_filter (self, g_value_get_object (value));
       break;
 
+    case PROP_INCREMENTAL:
+      gtk_filter_list_model_set_incremental (self, g_value_get_boolean (value));
+      break;
+
     case PROP_ITEM_TYPE:
       self->item_type = g_value_get_gtype (value);
       break;
@@ -392,6 +365,10 @@ gtk_filter_list_model_get_property (GObject     *object,
       g_value_set_object (value, self->filter);
       break;
 
+    case PROP_INCREMENTAL:
+      g_value_set_boolean (value, self->incremental);
+      break;
+
     case PROP_ITEM_TYPE:
       g_value_set_gtype (value, self->item_type);
       break;
@@ -400,6 +377,10 @@ gtk_filter_list_model_get_property (GObject     *object,
       g_value_set_object (value, self->model);
       break;
 
+    case PROP_PENDING:
+      g_value_set_uint (value, gtk_filter_list_model_get_pending (self));
+      break;
+
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
@@ -412,109 +393,16 @@ gtk_filter_list_model_clear_model (GtkFilterListModel *self)
   if (self->model == NULL)
     return;
 
+  gtk_filter_list_model_stop_filtering (self);
   g_signal_handlers_disconnect_by_func (self->model, gtk_filter_list_model_items_changed_cb, self);
   g_clear_object (&self->model);
-  if (self->items)
-    gtk_rb_tree_remove_all (self->items);
-}
-
-/*<private>
- * gtk_filter_list_model_find_filtered:
- * @self: a #GtkFilterListModel
- * @start: (out) (caller-allocates): number of unfiltered items
- *     at start of list
- * @end: (out) (caller-allocates): number of unfiltered items
- *     at end of list
- * @n_items: (out) (caller-allocates): number of unfiltered items in
- *     list
- *
- * Checks if elements in self->items are filtered out and returns
- * the range that they occupy.  
- * This function is intended to be used for GListModel::items-changed
- * emissions, so it is called in an intermediate state for @self.
- *
- * Returns: %TRUE if elements are filtered out, %FALSE if none are
- **/
-static gboolean
-gtk_filter_list_model_find_filtered (GtkFilterListModel *self,
-                                     guint              *start,
-                                     guint              *end,
-                                     guint              *n_items)
-{
-  FilterNode *root, *node, *tmp;
-  FilterAugment *aug;
-
-  if (self->items == NULL || self->model == NULL)
-    return FALSE;
-
-  root = gtk_rb_tree_get_root (self->items);
-  if (root == NULL)
-    return FALSE; /* empty parent model */
-
-  aug = gtk_rb_tree_get_augment (self->items, root);
-  if (aug->n_items == aug->n_visible)
-    return FALSE; /* all items visible */
-
-  /* find first filtered */
-  *start = 0;
-  *end = 0;
-  *n_items = aug->n_visible;
-
-  node = root;
-  while (node)
-    {
-      tmp = gtk_rb_tree_node_get_left (node);
-      if (tmp)
-        {
-          aug = gtk_rb_tree_get_augment (self->items, tmp);
-          if (aug->n_visible < aug->n_items)
-            {
-              node = tmp;
-              continue;
-            }
-          *start += aug->n_items;
-        }
-
-      if (!node->visible)
-        break;
-
-      (*start)++;
-
-      node = gtk_rb_tree_node_get_right (node);
-    }
-
-  /* find last filtered by doing everything the opposite way */
-  node = root;
-  while (node)
-    {
-      tmp = gtk_rb_tree_node_get_right (node);
-      if (tmp)
-        {
-          aug = gtk_rb_tree_get_augment (self->items, tmp);
-          if (aug->n_visible < aug->n_items)
-            {
-              node = tmp;
-              continue;
-            }
-          *end += aug->n_items;
-        }
-
-      if (!node->visible)
-        break;
-
-      (*end)++;
-
-      node = gtk_rb_tree_node_get_left (node);
-    }
-
-  return TRUE;
+  if (self->matches)
+    gtk_bitset_remove_all (self->matches);
 }
 
 static void
-gtk_filter_list_model_refilter (GtkFilterListModel *self);
-
-static void
-gtk_filter_list_model_update_strictness_and_refilter (GtkFilterListModel *self)
+gtk_filter_list_model_refilter (GtkFilterListModel *self,
+                                GtkFilterChange     change)
 {
   GtkFilterMatch new_strictness;
 
@@ -532,8 +420,9 @@ gtk_filter_list_model_update_strictness_and_refilter (GtkFilterListModel *self)
     case GTK_FILTER_MATCH_NONE:
       {
         guint n_before = g_list_model_get_n_items (G_LIST_MODEL (self));
-        g_clear_pointer (&self->items, gtk_rb_tree_unref);
+        g_clear_pointer (&self->matches, gtk_bitset_unref);
         self->strictness = new_strictness;
+        gtk_filter_list_model_stop_filtering (self);
         if (n_before > 0)
           g_list_model_items_changed (G_LIST_MODEL (self), 0, n_before, 0);
       }
@@ -553,16 +442,35 @@ gtk_filter_list_model_update_strictness_and_refilter (GtkFilterListModel *self)
         case GTK_FILTER_MATCH_SOME:
           {
             guint start, end, n_before, n_after;
+
+            gtk_filter_list_model_stop_filtering (self);
             self->strictness = new_strictness;
-            if (gtk_filter_list_model_find_filtered (self, &start, &end, &n_before))
+            n_after = g_list_model_get_n_items (G_LIST_MODEL (self));
+            start = gtk_bitset_get_minimum (self->matches);
+            end = gtk_bitset_get_maximum (self->matches);
+
+            n_before = gtk_bitset_get_size (self->matches);
+            if (n_before == n_after)
               {
-                n_after = g_list_model_get_n_items (G_LIST_MODEL (self));
-                g_clear_pointer (&self->items, gtk_rb_tree_unref);
-                g_list_model_items_changed (G_LIST_MODEL (self), start, n_before - end - start, n_after - end - start);
+                g_clear_pointer (&self->matches, gtk_bitset_unref);
               }
             else
               {
-                g_clear_pointer (&self->items, gtk_rb_tree_unref);
+                GtkBitset *inverse;
+
+                inverse = gtk_bitset_new_range (0, n_after);
+                gtk_bitset_subtract (inverse, self->matches);
+                /* otherwise all items would be visible */
+                g_assert (!gtk_bitset_is_empty (inverse));
+
+                /* find first filtered */
+                start = gtk_bitset_get_minimum (inverse);
+                end = n_after - gtk_bitset_get_maximum (inverse) - 1;
+
+                gtk_bitset_unref (inverse);
+
+                g_clear_pointer (&self->matches, gtk_bitset_unref);
+                g_list_model_items_changed (G_LIST_MODEL (self), start, n_before - end - start, n_after - end - start);
               }
           }
           break;
@@ -574,40 +482,44 @@ gtk_filter_list_model_update_strictness_and_refilter (GtkFilterListModel *self)
       break;
 
     case GTK_FILTER_MATCH_SOME:
-      switch (self->strictness)
-        {
-        case GTK_FILTER_MATCH_NONE:
+      {
+        GtkBitset *old, *pending;
+      
+        if (self->matches == NULL)
           {
-            guint n_after;
-            self->strictness = new_strictness;
-            self->items = gtk_rb_tree_new (FilterNode,
-                                           FilterAugment,
-                                           gtk_filter_list_model_augment,
-                                           NULL, NULL);
-            n_after = gtk_filter_list_model_add_items (self, NULL, 0, g_list_model_get_n_items (self->model));
-            if (n_after > 0)
-              g_list_model_items_changed (G_LIST_MODEL (self), 0, 0, n_after);
+            if (self->strictness == GTK_FILTER_MATCH_ALL)
+              old = gtk_bitset_new_range (0, g_list_model_get_n_items (self->model));
+            else
+              old = gtk_bitset_new_empty ();
           }
-          break;
-        case GTK_FILTER_MATCH_ALL:
+        else
           {
-            guint start, end, n_before, n_after;
-            self->strictness = new_strictness;
-            self->items = gtk_rb_tree_new (FilterNode,
-                                           FilterAugment,
-                                           gtk_filter_list_model_augment,
-                                           NULL, NULL);
-            n_before = g_list_model_get_n_items (self->model);
-            gtk_filter_list_model_add_items (self, NULL, 0, n_before);
-            if (gtk_filter_list_model_find_filtered (self, &start, &end, &n_after))
-              g_list_model_items_changed (G_LIST_MODEL (self), start, n_before - end - start, n_after - end - start);
+            old = self->matches;
           }
-          break;
-        default:
-        case GTK_FILTER_MATCH_SOME:
-          gtk_filter_list_model_refilter (self);
-          break;
-        }
+        self->strictness = new_strictness;
+        switch (change)
+          {
+          default:
+            g_assert_not_reached ();
+            G_GNUC_FALLTHROUGH;
+          case GTK_FILTER_CHANGE_DIFFERENT:
+            self->matches = gtk_bitset_new_empty ();
+            pending = gtk_bitset_new_range (0, g_list_model_get_n_items (self->model));
+            break;
+          case GTK_FILTER_CHANGE_LESS_STRICT:
+            self->matches = gtk_bitset_copy (old);
+            pending = gtk_bitset_new_range (0, g_list_model_get_n_items (self->model));
+            gtk_bitset_subtract (pending, self->matches);
+            break;
+          case GTK_FILTER_CHANGE_MORE_STRICT:
+            self->matches = gtk_bitset_new_empty ();
+            pending = gtk_bitset_copy (old);
+            break;
+          }
+        gtk_filter_list_model_start_filtering (self, pending);
+
+        gtk_filter_list_model_emit_items_changed_for_changes (self, old);
+      }
     }
 }
 
@@ -616,7 +528,7 @@ gtk_filter_list_model_filter_changed_cb (GtkFilter          *filter,
                                          GtkFilterChange     change,
                                          GtkFilterListModel *self)
 {
-  gtk_filter_list_model_update_strictness_and_refilter (self);
+  gtk_filter_list_model_refilter (self, change);
 }
 
 static void
@@ -636,7 +548,7 @@ gtk_filter_list_model_dispose (GObject *object)
 
   gtk_filter_list_model_clear_model (self);
   gtk_filter_list_model_clear_filter (self);
-  g_clear_pointer (&self->items, gtk_rb_tree_unref);
+  g_clear_pointer (&self->matches, gtk_bitset_unref);
 
   G_OBJECT_CLASS (gtk_filter_list_model_parent_class)->dispose (object);
 }
@@ -662,6 +574,18 @@ gtk_filter_list_model_class_init (GtkFilterListModelClass *class)
                            GTK_TYPE_FILTER,
                            GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
 
+  /**
+   * GtkFilterListModel:incremental:
+   *
+   * If the model should filter items incrementally
+   */
+  properties[PROP_INCREMENTAL] =
+      g_param_spec_boolean ("incremental",
+                            P_("Incremental"),
+                            P_("Filer items incrementally"),
+                            FALSE,
+                            GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
+
   /**
    * GtkFilterListModel:item-type:
    *
@@ -686,6 +610,18 @@ gtk_filter_list_model_class_init (GtkFilterListModelClass *class)
                            G_TYPE_LIST_MODEL,
                            GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_EXPLICIT_NOTIFY);
 
+  /**
+   * GtkFilterListModel:pending:
+   *
+   * Number of items not yet filtered
+   */
+  properties[PROP_PENDING] =
+      g_param_spec_uint ("pending",
+                         P_("Pending"),
+                         P_("Number of items not yet filtered"),
+                         0, G_MAXUINT, 0,
+                         GTK_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY);
+
   g_object_class_install_properties (gobject_class, NUM_PROPERTIES, properties);
 }
 
@@ -728,7 +664,7 @@ gtk_filter_list_model_new (GListModel *model,
  *
  * Creates a new empty filter list model set up to return items of type @item_type.
  * It is up to the application to set a proper filter and model to ensure
- * the item type is matched.
+ * the item type is matches.
  *
  * Returns: a new #GtkFilterListModel
  **/
@@ -769,7 +705,7 @@ gtk_filter_list_model_set_filter (GtkFilterListModel *self,
     }
   else
     {
-      gtk_filter_list_model_update_strictness_and_refilter (self);
+      gtk_filter_list_model_refilter (self, GTK_FILTER_CHANGE_LESS_STRICT);
     }
 
   g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_FILTER]);
@@ -828,13 +764,18 @@ gtk_filter_list_model_set_model (GtkFilterListModel *self,
       if (removed == 0)
         {
           self->strictness = GTK_FILTER_MATCH_NONE;
-          gtk_filter_list_model_update_strictness_and_refilter (self);
+          gtk_filter_list_model_refilter (self, GTK_FILTER_CHANGE_LESS_STRICT);
           added = 0;
         }
-      else if (self->items)
-        added = gtk_filter_list_model_add_items (self, NULL, 0, g_list_model_get_n_items (model));
+      else if (self->matches)
+        {
+          gtk_filter_list_model_start_filtering (self, gtk_bitset_new_range (0, g_list_model_get_n_items (model)));
+          added = gtk_bitset_get_size (self->matches);
+        }
       else
-        added = g_list_model_get_n_items (model);
+        {
+          added = g_list_model_get_n_items (model);
+        }
     }
   else
     {
@@ -864,54 +805,89 @@ gtk_filter_list_model_get_model (GtkFilterListModel *self)
   return self->model;
 }
 
-static void
-gtk_filter_list_model_refilter (GtkFilterListModel *self)
+/**
+ * gtk_filter_list_model_set_incremental:
+ * @self: a #GtkFilterListModel
+ * @incremental: %TRUE to enable incremental filtering
+ *
+ * When incremental filtering is enabled, the filterlistmodel will not run
+ * filters immediately, but will instead queue an idle handler that
+ * incrementally filters the items and adds them to the list. This of course
+ * means that items are not instantly added to the list, but only appear
+ * incrementally.
+ *
+ * When your filter blocks the UI while filtering, you might consider
+ * turning this on. Depending on your model and filters, this may become
+ * interesting around 10,000 to 100,000 items.
+ *
+ * By default, incremental filtering is disabled.
+ **/
+void
+gtk_filter_list_model_set_incremental (GtkFilterListModel *self,
+                                       gboolean            incremental)
 {
-  FilterNode *node;
-  guint i, first_change, last_change;
-  guint n_is_visible, n_was_visible;
-  gboolean visible;
-
   g_return_if_fail (GTK_IS_FILTER_LIST_MODEL (self));
-  
-  if (self->items == NULL || self->model == NULL)
+
+  if (self->incremental == incremental)
     return;
 
-  first_change = G_MAXUINT;
-  last_change = 0;
-  n_is_visible = 0;
-  n_was_visible = 0;
-  for (i = 0, node = gtk_rb_tree_get_first (self->items);
-       node != NULL;
-       i++, node = gtk_rb_tree_node_get_next (node))
-    {
-      visible = gtk_filter_list_model_run_filter (self, i);
-      if (visible == node->visible)
-        {
-          if (visible)
-            {
-              n_is_visible++;
-              n_was_visible++;
-            }
-          continue;
-        }
+  self->incremental = incremental;
 
-      node->visible = visible;
-      gtk_rb_tree_node_mark_dirty (node);
-      first_change = MIN (n_is_visible, first_change);
-      if (visible)
-        n_is_visible++;
-      else
-        n_was_visible++;
-      last_change = MAX (n_is_visible, last_change);
+  if (!incremental)
+    {
+      GtkBitset *old;
+      gtk_filter_list_model_run_filter (self, G_MAXUINT);
+
+      old = gtk_bitset_copy (self->matches);
+      gtk_filter_list_model_run_filter (self, 512);
+
+      gtk_filter_list_model_stop_filtering (self);
+
+      gtk_filter_list_model_emit_items_changed_for_changes (self, old);
     }
 
-  if (first_change <= last_change)
-    {
-      g_list_model_items_changed (G_LIST_MODEL (self),
-                                  first_change,
-                                  last_change - first_change + n_was_visible - n_is_visible,
-                                  last_change - first_change);
-    }
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_INCREMENTAL]);
 }
 
+/**
+ * gtk_filter_list_model_get_incremental:
+ * @self: a #GtkFilterListModel
+ *
+ * Returns whether incremental filtering was enabled via
+ * gtk_filter_list_model_set_incremental().
+ *
+ * Returns: %TRUE if incremental filtering is enabled
+ **/
+gboolean
+gtk_filter_list_model_get_incremental (GtkFilterListModel *self)
+{
+  g_return_val_if_fail (GTK_IS_FILTER_LIST_MODEL (self), FALSE);
+
+  return self->incremental;
+}
+
+/**
+ * gtk_filter_list_model_get_pending:
+ * @self: a #GtkFilterListModel
+ *
+ * Returns the number of items that have not been filtered yet.
+ *
+ * When incremental filtering is not enabled, this always returns 0.
+ *
+ * You can use this value to check if @self is busy filtering by
+ * comparing the return value to 0 or you can compute the percentage
+ * of the filter remaining by dividing the return value by
+ * g_list_model_get_n_items(gtk_filter_list_model_get_model (self)).
+ *
+ * Returns: The number of items not yet filtered
+ **/
+guint
+gtk_filter_list_model_get_pending (GtkFilterListModel *self)
+{
+  g_return_val_if_fail (GTK_IS_FILTER_LIST_MODEL (self), FALSE);
+
+  if (self->pending == NULL)
+    return 0;
+
+  return gtk_bitset_get_size (self->pending);
+}

gtk/gtkfilterlistmodel.h

@@ -52,6 +52,14 @@ void                    gtk_filter_list_model_set_model         (GtkFilterListMo
                                                                  GListModel             *model);
 GDK_AVAILABLE_IN_ALL
 GListModel *            gtk_filter_list_model_get_model         (GtkFilterListModel     *self);
+GDK_AVAILABLE_IN_ALL
+void                    gtk_filter_list_model_set_incremental   (GtkFilterListModel     *self,
+                                                                 gboolean                incremental);
+GDK_AVAILABLE_IN_ALL
+gboolean                gtk_filter_list_model_get_incremental   (GtkFilterListModel     *self);
+GDK_AVAILABLE_IN_ALL
+guint                   gtk_filter_list_model_get_pending       (GtkFilterListModel     *self);
+
 
 G_END_DECLS
 

gtk/gtkscrolledwindow.c

@@ -546,19 +546,8 @@ gtk_scrolled_window_compute_expand (GtkWidget *widget,
                                     gboolean  *hexpand,
                                     gboolean  *vexpand)
 {
-  GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
-  GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
-
-  if (priv->child)
-    {
-      *hexpand = gtk_widget_compute_expand (priv->child, GTK_ORIENTATION_HORIZONTAL);
-      *vexpand = gtk_widget_compute_expand (priv->child, GTK_ORIENTATION_VERTICAL);
-    }
-  else
-    {
-      *hexpand = FALSE;
-      *vexpand = FALSE;
-    }
+  *hexpand = TRUE;
+  *vexpand = TRUE;
 }
 
 static GtkSizeRequestMode

gtk/gtkstringfilter.c

@@ -110,9 +110,9 @@ gtk_string_filter_match (GtkFilter *filter,
       !gtk_expression_evaluate (self->expression, item, &value))
     return FALSE;
   s = g_value_get_string (&value);
-  if (s == NULL)
-    return FALSE;
   prepared = gtk_string_filter_prepare (self, s);
+  if (prepared == NULL)
+    return FALSE;
 
   switch (self->match_mode)
     {

gtk/gtkstringlist.c

@@ -138,20 +138,13 @@ gtk_string_object_class_init (GtkStringObjectClass *class)
 
   pspec = g_param_spec_string ("string", "String", "String",
                                NULL,
-                               G_PARAM_READWRITE |
-                               G_PARAM_CONSTRUCT_ONLY |
+                               G_PARAM_READABLE |
                                G_PARAM_STATIC_STRINGS);
 
   g_object_class_install_property (object_class, PROP_STRING, pspec);
 
 }
 
-static GtkStringObject *
-gtk_string_object_new (const char *string)
-{
-  return g_object_new (GTK_TYPE_STRING_OBJECT, "string", string, NULL);
-}
-
 static GtkStringObject *
 gtk_string_object_new_take (char *string)
 {
@@ -163,6 +156,12 @@ gtk_string_object_new_take (char *string)
   return obj;
 }
 
+static GtkStringObject *
+gtk_string_object_new (const char *string)
+{
+  return gtk_string_object_new_take (g_strdup (string));
+}
+
 /**
  * gtk_string_object_get_string:
  * @self: a #GtkStringObject
@@ -432,15 +431,13 @@ gtk_string_list_init (GtkStringList *self)
  * Returns: a new #GtkStringList
  */
 GtkStringList *
-gtk_string_list_new (const char **strings)
+gtk_string_list_new (const char * const *strings)
 {
   GtkStringList *self;
-  guint i;
 
   self = g_object_new (GTK_TYPE_STRING_LIST, NULL);
 
-  for (i = 0; strings[i]; i++)
-    g_sequence_append (self->items, gtk_string_object_new (strings[i]));
+  gtk_string_list_splice (self, 0, 0, strings);
 
   return self;
 }
@@ -450,11 +447,10 @@ gtk_string_list_new (const char **strings)
  * @self: a #GtkStringList
  * @position: the position at which to make the change
  * @n_removals: the number of strings to remove
- * @additions: (array length=n_additions): the strings to add
- * @n_additions: the number of items to add
+ * @additions: (array zero-terminated=1) (nullable): The strings to add
  *
- * Changes @self by removing @n_removals strings and adding @n_additions
- * strings to it.
+ * Changes @self by removing @n_removals strings and adding @additions
+ * to it.
  *
  * This function is more efficient than gtk_string_list_insert() and
  * gtk_string_list_remove(), because it only emits
@@ -467,14 +463,13 @@ gtk_string_list_new (const char **strings)
  * of the list at the time this function is called).
  */
 void
-gtk_string_list_splice (GtkStringList  *self,
-                        guint           position,
-                        guint           n_removals,
-                        const char    **additions,
-                        guint           n_additions)
+gtk_string_list_splice (GtkStringList      *self,
+                        guint               position,
+                        guint               n_removals,
+                        const char * const *additions)
 {
   GSequenceIter *it;
-  guint n_items;
+  guint add, n_items;
 
   g_return_if_fail (GTK_IS_STRING_LIST (self));
   g_return_if_fail (position + n_removals >= position); /* overflow */
@@ -494,17 +489,18 @@ gtk_string_list_splice (GtkStringList  *self,
       it = end;
     }
 
-  if (n_additions)
+  if (additions)
     {
-      gint i;
-
-      for (i = 0; i < n_additions; i++)
+      for (add = 0; additions[add]; add++)
         {
-          g_sequence_insert_before (it, gtk_string_object_new (additions[i]));
+          g_sequence_insert_before (it, gtk_string_object_new (additions[add]));
         }
     }
+  else
+    add = 0;
 
-  g_list_model_items_changed (G_LIST_MODEL (self), position, n_removals, n_additions);
+  if (n_removals || add)
+    g_list_model_items_changed (G_LIST_MODEL (self), position, n_removals, add);
 }
 
 /**
@@ -589,8 +585,8 @@ gtk_string_list_remove (GtkStringList *self,
  * @self: a #GtkStringList
  * @position: the position to get the string for
  *
- * Gets the string that is at @position in @self. @position
- * must be smaller than the current length of the list.
+ * Gets the string that is at @position in @self. If @self
+ * does not contain @position items, %NULL is returned.
  *
  * This function returns the const char *. To get the
  * object wrapping it, use g_list_model_get_item().

gtk/gtkstringlist.h

@@ -45,30 +45,29 @@ GDK_AVAILABLE_IN_ALL
 G_DECLARE_FINAL_TYPE (GtkStringList, gtk_string_list, GTK, STRING_LIST, GObject)
 
 GDK_AVAILABLE_IN_ALL
-GtkStringList * gtk_string_list_new             (const char **strings);
+GtkStringList * gtk_string_list_new             (const char * const    *strings);
 
 GDK_AVAILABLE_IN_ALL
-void            gtk_string_list_append          (GtkStringList *self,
-                                                 const char    *string);
+void            gtk_string_list_append          (GtkStringList         *self,
+                                                 const char            *string);
 
 GDK_AVAILABLE_IN_ALL
-void            gtk_string_list_take            (GtkStringList *self,
-                                                 char          *string);
+void            gtk_string_list_take            (GtkStringList         *self,
+                                                 char                  *string);
 
 GDK_AVAILABLE_IN_ALL
-void            gtk_string_list_remove          (GtkStringList *self,
-                                                 guint          position);
+void            gtk_string_list_remove          (GtkStringList         *self,
+                                                 guint                  position);
 
 GDK_AVAILABLE_IN_ALL
-void            gtk_string_list_splice          (GtkStringList  *self,
-                                                 guint           position,
-                                                 guint           n_removals,
-                                                 const char    **additions,
-                                                 guint           n_additions);
+void            gtk_string_list_splice          (GtkStringList         *self,
+                                                 guint                  position,
+                                                 guint                  n_removals,
+                                                 const char * const    *additions);
 
 GDK_AVAILABLE_IN_ALL
-const char *    gtk_string_list_get_string      (GtkStringList *self,
-                                                 guint          position);
+const char *    gtk_string_list_get_string      (GtkStringList         *self,
+                                                 guint                  position);
 
 G_END_DECLS
 

tests/testlistview.c

@@ -618,7 +618,7 @@ main (int argc, char *argv[])
   gtk_search_entry_set_key_capture_widget (GTK_SEARCH_ENTRY (search_entry), sw);
   gtk_box_append (GTK_BOX (vbox), sw);
 
-  listview = gtk_grid_view_new_with_factory (
+  listview = gtk_list_view_new_with_factory (
     gtk_functions_list_item_factory_new (setup_widget,
                                          NULL,
                                          NULL, NULL));
@@ -645,7 +645,7 @@ main (int argc, char *argv[])
   selectionmodel = file_info_selection_new (G_LIST_MODEL (filter));
   g_object_unref (filter);
 
-  gtk_grid_view_set_model (GTK_GRID_VIEW (listview), G_LIST_MODEL (selectionmodel));
+  gtk_list_view_set_model (GTK_LIST_VIEW (listview), G_LIST_MODEL (selectionmodel));
 
   statusbar = gtk_statusbar_new ();
   gtk_widget_add_tick_callback (statusbar, (GtkTickCallback) update_statusbar, NULL, NULL);

testsuite/gtk/listmodel-performance.c

@@ -0,0 +1,91 @@
+#include <gtk/gtk.h>
+
+static GObject *
+get_object (const char *string)
+{
+  GtkStringList *list;
+  GObject *obj;
+
+  list = gtk_string_list_new ((const char *[]){string, NULL});
+  obj = g_list_model_get_item (G_LIST_MODEL (list), 0);
+  g_object_unref (list);
+
+  return obj;
+}
+
+static GListModel *
+make_store (guint n_items)
+{
+  GListStore *store;
+  guint i;
+
+  store = g_list_store_new (GTK_TYPE_STRING_OBJECT);
+
+  for (i = 0; i < n_items; i++)
+    {
+      char *string;
+      GObject *obj;
+
+      string = g_strdup_printf ("item %d", i);
+      obj = get_object (string);
+      g_list_store_append (store, obj);
+      g_object_unref (obj);
+      g_free (string);
+    }
+
+  return G_LIST_MODEL (store);
+}
+
+static void
+do_random_access (guint size)
+{
+  GListModel *model;
+  guint i;
+  guint position;
+  GtkStringObject *obj;
+  gint64 start, end;
+  guint iterations = 10000000;
+
+  model = make_store (size);
+
+  start = g_get_monotonic_time ();
+
+  for (i = 0; i < iterations; i++)
+    {
+      position = g_random_int_range (0, size);
+      obj = g_list_model_get_item (model, position);
+      if (g_getenv ("PRINT_ACCESS"))
+        g_print ("%s", gtk_string_object_get_string (obj));
+      g_object_unref (obj);
+    }
+
+  end = g_get_monotonic_time ();
+
+  g_print ("size %u: %g accesses per second\n",
+           size,
+           (iterations / (double) G_TIME_SPAN_SECOND) * ((double)(end - start)));
+
+  g_object_unref (model);
+}
+
+static void
+random_access (void)
+{
+  do_random_access (1e1);
+  do_random_access (1e2);
+  do_random_access (1e3);
+  do_random_access (1e4);
+  do_random_access (1e5);
+  do_random_access (1e6);
+  do_random_access (1e7);
+}
+
+int
+main (int argc, char *argv[])
+{
+  gtk_test_init (&argc, &argv);
+
+  g_test_add_func ("/liststore/random-access", random_access);
+
+  return g_test_run ();
+}

testsuite/gtk/meson.build

@@ -76,6 +76,7 @@ tests = [
   ['revealer-size'],
   ['widgetorder'],
   ['widget-refcount'],
+  ['listmodel-performance'],
 ]
 
 # Tests that are expected to fail

testsuite/gtk/stringlist.c

@@ -184,7 +184,7 @@ test_splice (void)
 
   assert_model (list, "a b c d e");
 
-  gtk_string_list_splice (list, 2, 2, (const char *[]){ "x", "y", "z" }, 3);
+  gtk_string_list_splice (list, 2, 2, (const char *[]){ "x", "y", "z", NULL });
 
   assert_model (list, "a b x y z e");
   assert_changes (list, "2-2+3");