Make sorter constructors return exact types

Make functions like gtk_custom_sorter_new() return
the actual type they construct.

Update all callers.

demos/constraint-editor/constraint-view.c

@@ -177,11 +177,11 @@ constraint_view_init (ConstraintView *self)
   guides = gtk_constraint_layout_observe_guides (GTK_CONSTRAINT_LAYOUT (manager));
 
   all_constraints = gtk_constraint_layout_observe_constraints (GTK_CONSTRAINT_LAYOUT (manager));
-  filter = gtk_custom_filter_new (omit_internal, NULL, NULL);
+  filter = GTK_FILTER (gtk_custom_filter_new (omit_internal, NULL, NULL));
   constraints = (GListModel *)gtk_filter_list_model_new (all_constraints, filter);
 
   all_children = gtk_widget_observe_children (GTK_WIDGET (self));
-  filter = gtk_custom_filter_new (omit_internal, NULL, NULL);
+  filter = GTK_FILTER (gtk_custom_filter_new (omit_internal, NULL, NULL));
   children = (GListModel *)gtk_filter_list_model_new (all_children, filter);
 
   list = g_list_store_new (G_TYPE_LIST_MODEL);

demos/gtk-demo/listview_colors.c

@@ -1022,31 +1022,31 @@ do_listview_colors (GtkWidget *do_widget)
       /* An empty multisorter doesn't do any sorting and the sortmodel is
        * smart enough to know that.
        */
-      sorter = gtk_multi_sorter_new ();
+      sorter = GTK_SORTER (gtk_multi_sorter_new ());
       set_title (sorter, "Unsorted");
       g_list_store_append (sorters, sorter);
       g_object_unref (sorter);
 
-      sorter = gtk_string_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "name"));
+      sorter = GTK_SORTER (gtk_string_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "name")));
       set_title (sorter, "Name");
       g_list_store_append (sorters, sorter);
       g_object_unref (sorter);
 
-      multi_sorter = gtk_multi_sorter_new ();
+      multi_sorter = GTK_SORTER (gtk_multi_sorter_new ());
 
-      sorter = gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "red"));
+      sorter = GTK_SORTER (gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "red")));
       gtk_numeric_sorter_set_sort_order (GTK_NUMERIC_SORTER (sorter), GTK_SORT_DESCENDING);
       set_title (sorter, "Red");
       g_list_store_append (sorters, sorter);
       gtk_multi_sorter_append (GTK_MULTI_SORTER (multi_sorter), sorter);
 
-      sorter = gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "green"));
+      sorter = GTK_SORTER (gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "green")));
       gtk_numeric_sorter_set_sort_order (GTK_NUMERIC_SORTER (sorter), GTK_SORT_DESCENDING);
       set_title (sorter, "Green");
       g_list_store_append (sorters, sorter);
       gtk_multi_sorter_append (GTK_MULTI_SORTER (multi_sorter), sorter);
 
-      sorter = gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "blue"));
+      sorter = GTK_SORTER (gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "blue")));
       gtk_numeric_sorter_set_sort_order (GTK_NUMERIC_SORTER (sorter), GTK_SORT_DESCENDING);
       set_title (sorter, "Blue");
       g_list_store_append (sorters, sorter);
@@ -1056,21 +1056,21 @@ do_listview_colors (GtkWidget *do_widget)
       g_list_store_append (sorters, multi_sorter);
       g_object_unref (multi_sorter);
 
-      multi_sorter = gtk_multi_sorter_new ();
+      multi_sorter = GTK_SORTER (gtk_multi_sorter_new ());
 
-      sorter = gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "hue"));
+      sorter = GTK_SORTER (gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "hue")));
       gtk_numeric_sorter_set_sort_order (GTK_NUMERIC_SORTER (sorter), GTK_SORT_DESCENDING);
       set_title (sorter, "Hue");
       g_list_store_append (sorters, sorter);
       gtk_multi_sorter_append (GTK_MULTI_SORTER (multi_sorter), sorter);
 
-      sorter = gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "saturation"));
+      sorter = GTK_SORTER (gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "saturation")));
       gtk_numeric_sorter_set_sort_order (GTK_NUMERIC_SORTER (sorter), GTK_SORT_DESCENDING);
       set_title (sorter, "Saturation");
       g_list_store_append (sorters, sorter);
       gtk_multi_sorter_append (GTK_MULTI_SORTER (multi_sorter), sorter);
 
-      sorter = gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "value"));
+      sorter = GTK_SORTER (gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "value")));
       gtk_numeric_sorter_set_sort_order (GTK_NUMERIC_SORTER (sorter), GTK_SORT_DESCENDING);
       set_title (sorter, "Value");
       g_list_store_append (sorters, sorter);

demos/gtk-demo/listview_settings.c

@@ -247,7 +247,7 @@ transform_settings_to_keys (GBinding     *binding,
   sort_model = gtk_sort_list_model_new (G_LIST_MODEL (store),
                                         g_object_ref (gtk_column_view_get_sorter (GTK_COLUMN_VIEW (data))));
 
-  filter = gtk_string_filter_new (gtk_property_expression_new (SETTINGS_TYPE_KEY, NULL, "name"));
+  filter = GTK_FILTER (gtk_string_filter_new (gtk_property_expression_new (SETTINGS_TYPE_KEY, NULL, "name")));
   g_set_object (&current_filter, filter);
   filter_model = gtk_filter_list_model_new (G_LIST_MODEL (sort_model), filter);
 

demos/gtk-demo/listview_words.c

@@ -179,7 +179,7 @@ do_listview_words (GtkWidget *do_widget)
         }
       g_object_unref (file);
 
-      filter = gtk_string_filter_new (gtk_property_expression_new (GTK_TYPE_STRING_OBJECT, NULL, "string"));
+      filter = GTK_FILTER (gtk_string_filter_new (gtk_property_expression_new (GTK_TYPE_STRING_OBJECT, NULL, "string")));
       filter_model = gtk_filter_list_model_new (G_LIST_MODEL (stringlist), filter);
       gtk_filter_list_model_set_incremental (filter_model, TRUE);
 

demos/gtk-demo/main.c

@@ -695,9 +695,11 @@ filter_demo (GtkDemo *demo)
 }
 
 static gboolean
-demo_filter_by_name (GtkTreeListRow     *row,
-                     GtkFilterListModel *model)
+demo_filter_by_name (gpointer item,
+                     gpointer user_data)
 {
+  GtkTreeListRow *row = item;
+  GtkFilterListModel *model = user_data;
   GListModel *children;
   GtkDemo *demo;
   guint i, n;
@@ -865,9 +867,10 @@ activate (GApplication *app)
                                        NULL,
                                        NULL);
   filter_model = gtk_filter_list_model_new (G_LIST_MODEL (treemodel), NULL);
-  filter = gtk_custom_filter_new ((GtkCustomFilterFunc)demo_filter_by_name, filter_model, NULL);
+  filter = GTK_FILTER (gtk_custom_filter_new (demo_filter_by_name, filter_model, NULL));
   gtk_filter_list_model_set_filter (filter_model, filter);
   g_object_unref (filter);
+
   search_entry = GTK_WIDGET (gtk_builder_get_object (builder, "search-entry"));
   g_signal_connect (search_entry, "search-changed", G_CALLBACK (demo_search_changed_cb), filter);
 

demos/icon-browser/iconbrowserwin.c

@@ -357,7 +357,7 @@ icon_browser_window_init (IconBrowserWindow *win)
 
   filter = gtk_filter_list_model_get_filter (GTK_FILTER_LIST_MODEL (win->icon_filter_model));
 
-  win->name_filter = gtk_custom_filter_new (filter_by_icon_name, NULL, NULL);
+  win->name_filter = GTK_FILTER (gtk_custom_filter_new (filter_by_icon_name, NULL, NULL));
 
   gtk_multi_filter_append (GTK_MULTI_FILTER (filter), g_object_ref (win->name_filter));
 }

gtk/gtkboolfilter.c

@@ -195,10 +195,10 @@ gtk_bool_filter_init (GtkBoolFilter *self)
  *
  * Returns: a new #GtkBoolFilter
  **/
-GtkFilter *
+GtkBoolFilter *
 gtk_bool_filter_new (GtkExpression *expression)
 {
-  GtkFilter *result;
+  GtkBoolFilter *result;
 
   result = g_object_new (GTK_TYPE_BOOL_FILTER,
                          "expression", expression,

gtk/gtkboolfilter.h

@@ -34,7 +34,7 @@ GDK_AVAILABLE_IN_ALL
 G_DECLARE_FINAL_TYPE (GtkBoolFilter, gtk_bool_filter, GTK, BOOL_FILTER, GtkFilter)
 
 GDK_AVAILABLE_IN_ALL
-GtkFilter *             gtk_bool_filter_new                     (GtkExpression          *expression);
+GtkBoolFilter *         gtk_bool_filter_new                     (GtkExpression          *expression);
 
 GDK_AVAILABLE_IN_ALL
 GtkExpression *         gtk_bool_filter_get_expression          (GtkBoolFilter          *self);

gtk/gtkcolumnview.c

@@ -1163,7 +1163,7 @@ gtk_column_view_init (GtkColumnView *self)
   g_signal_connect (controller, "leave", G_CALLBACK (gtk_column_view_drag_leave), NULL);
   gtk_widget_add_controller (GTK_WIDGET (self), controller);
 
-  self->sorter = gtk_column_view_sorter_new ();
+  self->sorter = GTK_SORTER (gtk_column_view_sorter_new ());
   self->factory = gtk_column_list_item_factory_new (self);
   self->listview = GTK_LIST_VIEW (gtk_list_view_new (NULL,
         GTK_LIST_ITEM_FACTORY (g_object_ref (self->factory))));

gtk/gtkcolumnviewsorter.c

@@ -146,7 +146,7 @@ gtk_column_view_sorter_init (GtkColumnViewSorter *self)
   self->sorters = g_sequence_new (free_sorter);
 }
 
-GtkSorter *
+GtkColumnViewSorter *
 gtk_column_view_sorter_new (void)
 {
   return g_object_new (GTK_TYPE_COLUMN_VIEW_SORTER, NULL);

gtk/gtkcolumnviewsorterprivate.h

@@ -34,7 +34,7 @@ G_BEGIN_DECLS
 
 G_DECLARE_FINAL_TYPE (GtkColumnViewSorter, gtk_column_view_sorter, GTK, COLUMN_VIEW_SORTER, GtkSorter)
 
-GtkSorter *             gtk_column_view_sorter_new              (void);
+GtkColumnViewSorter *   gtk_column_view_sorter_new              (void);
 
 gboolean                gtk_column_view_sorter_add_column       (GtkColumnViewSorter    *self,
                                                                  GtkColumnViewColumn    *column);

gtk/gtkcustomfilter.c

@@ -108,9 +108,9 @@ gtk_custom_filter_init (GtkCustomFilter *self)
  * If the filter func changes its filtering behavior,
  * gtk_filter_changed() needs to be called.
  *
- * Returns: a new #GtkFilter
+ * Returns: a new #GtkCustomFilter
  **/
-GtkFilter *
+GtkCustomFilter *
 gtk_custom_filter_new (GtkCustomFilterFunc match_func,
                        gpointer            user_data,
                        GDestroyNotify      user_destroy)
@@ -121,7 +121,7 @@ gtk_custom_filter_new (GtkCustomFilterFunc match_func,
 
   gtk_custom_filter_set_filter_func (result, match_func, user_data, user_destroy);
 
-  return GTK_FILTER (result);
+  return result;
 }
 
 /**

gtk/gtkcustomfilter.h

@@ -45,7 +45,7 @@ typedef gboolean (* GtkCustomFilterFunc) (gpointer item, gpointer user_data);
 GDK_AVAILABLE_IN_ALL
 G_DECLARE_FINAL_TYPE (GtkCustomFilter, gtk_custom_filter, GTK, CUSTOM_FILTER, GtkFilter)
 GDK_AVAILABLE_IN_ALL
-GtkFilter *             gtk_custom_filter_new                   (GtkCustomFilterFunc     match_func,
+GtkCustomFilter *       gtk_custom_filter_new                   (GtkCustomFilterFunc     match_func,
                                                                  gpointer                user_data,
                                                                  GDestroyNotify          user_destroy);
 

gtk/gtkcustompaperunixdialog.c

@@ -323,7 +323,7 @@ gtk_custom_paper_unix_dialog_init (GtkCustomPaperUnixDialog *dialog)
 
   full_list = G_LIST_MODEL (gtk_flatten_list_model_new (G_LIST_MODEL (printer_list_list)));
 
-  filter = gtk_custom_filter_new (match_func, NULL, NULL);
+  filter = GTK_FILTER (gtk_custom_filter_new (match_func, NULL, NULL));
   dialog->printer_list = G_LIST_MODEL (gtk_filter_list_model_new (full_list, filter));
 
   dialog->custom_paper_list = g_list_store_new (GTK_TYPE_PAGE_SETUP);

gtk/gtkcustomsorter.c

@@ -110,9 +110,9 @@ gtk_custom_sorter_init (GtkCustomSorter *self)
  *
  * If @sort_func is %NULL, all items are considered equal.
  *
- * Returns: a new #GtkSorter
+ * Returns: a new #GtkCustomSorter
  */
-GtkSorter *
+GtkCustomSorter *
 gtk_custom_sorter_new (GCompareDataFunc sort_func,
                        gpointer         user_data,
                        GDestroyNotify   user_destroy)
@@ -123,7 +123,7 @@ gtk_custom_sorter_new (GCompareDataFunc sort_func,
 
   gtk_custom_sorter_set_sort_func (sorter, sort_func, user_data, user_destroy);
 
-  return GTK_SORTER (sorter);
+  return sorter;
 }
 
 /**

gtk/gtkcustomsorter.h

@@ -34,7 +34,7 @@ GDK_AVAILABLE_IN_ALL
 G_DECLARE_FINAL_TYPE (GtkCustomSorter, gtk_custom_sorter, GTK, CUSTOM_SORTER, GtkSorter)
 
 GDK_AVAILABLE_IN_ALL
-GtkSorter *             gtk_custom_sorter_new                   (GCompareDataFunc        sort_func,
+GtkCustomSorter *       gtk_custom_sorter_new                   (GCompareDataFunc        sort_func,
                                                                  gpointer                user_data,
                                                                  GDestroyNotify          user_destroy);
 

gtk/gtkdropdown.c

@@ -203,11 +203,11 @@ update_filter (GtkDropDown *self)
 
       if (self->expression)
         {
-          filter = gtk_string_filter_new (gtk_expression_ref (self->expression));
+          filter = GTK_FILTER (gtk_string_filter_new (gtk_expression_ref (self->expression)));
           gtk_string_filter_set_match_mode (GTK_STRING_FILTER (filter), GTK_STRING_FILTER_MATCH_MODE_PREFIX);
         }
       else
-        filter = gtk_every_filter_new ();
+        filter = GTK_FILTER (gtk_every_filter_new ());
       gtk_filter_list_model_set_filter (GTK_FILTER_LIST_MODEL (self->filter_model), filter);
       g_object_unref (filter);
     }

gtk/gtkmultifilter.c

@@ -302,9 +302,9 @@ gtk_any_filter_init (GtkAnyFilter *self)
  * In particular, this means that if no filter has been added to
  * it, the filter matches no item.
  *
- * Returns: a new #GtkFilter
+ * Returns: a new #GtkAnyFilter
  **/
-GtkFilter *
+GtkAnyFilter *
 gtk_any_filter_new (void)
 {
   return g_object_new (GTK_TYPE_ANY_FILTER, NULL);
@@ -400,9 +400,9 @@ gtk_every_filter_init (GtkEveryFilter *self)
  * In particular, this means that if no filter has been added to
  * it, the filter matches every item.
  *
- * Returns: a new #GtkFilter
+ * Returns: a new #GtkEveryFilter
  **/
-GtkFilter *
+GtkEveryFilter *
 gtk_every_filter_new (void)
 {
   return g_object_new (GTK_TYPE_EVERY_FILTER, NULL);

gtk/gtkmultifilter.h

@@ -44,13 +44,13 @@ void                    gtk_multi_filter_remove                 (GtkMultiFilter
 GDK_AVAILABLE_IN_ALL
 GDK_DECLARE_INTERNAL_TYPE (GtkAnyFilter, gtk_any_filter, GTK, ANY_FILTER, GtkMultiFilter)
 GDK_AVAILABLE_IN_ALL
-GtkFilter *             gtk_any_filter_new                      (void);
+GtkAnyFilter *          gtk_any_filter_new                      (void);
 
 #define GTK_TYPE_EVERY_FILTER             (gtk_every_filter_get_type ())
 GDK_AVAILABLE_IN_ALL
 GDK_DECLARE_INTERNAL_TYPE (GtkEveryFilter, gtk_every_filter, GTK, EVERY_FILTER, GtkMultiFilter)
 GDK_AVAILABLE_IN_ALL
-GtkFilter *             gtk_every_filter_new                    (void);
+GtkEveryFilter *        gtk_every_filter_new                    (void);
 
 
 G_END_DECLS

gtk/gtkmultisorter.c

@@ -375,9 +375,9 @@ gtk_multi_sorter_init (GtkMultiSorter *self)
  * no sorter has been added to it, it will always compare
  * items as equal.
  *
- * Returns: a new #GtkSorter
+ * Returns: a new #GtkMultiSorter
  */
-GtkSorter *
+GtkMultiSorter *
 gtk_multi_sorter_new (void)
 {
   return g_object_new (GTK_TYPE_MULTI_SORTER, NULL);

gtk/gtkmultisorter.h

@@ -34,7 +34,7 @@ GDK_AVAILABLE_IN_ALL
 G_DECLARE_FINAL_TYPE (GtkMultiSorter, gtk_multi_sorter, GTK, MULTI_SORTER, GtkSorter)
 
 GDK_AVAILABLE_IN_ALL
-GtkSorter *             gtk_multi_sorter_new                    (void);
+GtkMultiSorter *        gtk_multi_sorter_new                    (void);
 
 GDK_AVAILABLE_IN_ALL
 void                    gtk_multi_sorter_append                 (GtkMultiSorter         *self,

gtk/gtknumericsorter.c

@@ -587,12 +587,12 @@ gtk_numeric_sorter_init (GtkNumericSorter *self)
  * Smaller numbers will be sorted first. You can call
  * gtk_numeric_sorter_set_sort_order() to change this.
  *
- * Returns: a new #GtkSorter
+ * Returns: a new #GtkNumericSorter
  */
-GtkSorter *
+GtkNumericSorter *
 gtk_numeric_sorter_new (GtkExpression *expression)
 {
-  GtkSorter *result;
+  GtkNumericSorter *result;
 
   result = g_object_new (GTK_TYPE_NUMERIC_SORTER,
                          "expression", expression,

gtk/gtknumericsorter.h

@@ -34,7 +34,7 @@ GDK_AVAILABLE_IN_ALL
 G_DECLARE_FINAL_TYPE (GtkNumericSorter, gtk_numeric_sorter, GTK, NUMERIC_SORTER, GtkSorter)
 
 GDK_AVAILABLE_IN_ALL
-GtkSorter *             gtk_numeric_sorter_new                   (GtkExpression          *expression);
+GtkNumericSorter *      gtk_numeric_sorter_new                   (GtkExpression          *expression);
 
 GDK_AVAILABLE_IN_ALL
 GtkExpression *         gtk_numeric_sorter_get_expression        (GtkNumericSorter       *self);

gtk/gtkpagesetupunixdialog.c

@@ -324,7 +324,7 @@ gtk_page_setup_unix_dialog_init (GtkPageSetupUnixDialog *dialog)
 
   full_list = G_LIST_MODEL (gtk_flatten_list_model_new (G_LIST_MODEL (printer_list_list)));
 
-  filter = gtk_custom_filter_new (match_func, NULL, NULL);
+  filter = GTK_FILTER (gtk_custom_filter_new (match_func, NULL, NULL));
   dialog->printer_list = G_LIST_MODEL (gtk_filter_list_model_new (full_list, filter));
 
   factory = gtk_signal_list_item_factory_new ();

gtk/gtkprintunixdialog.c

@@ -742,7 +742,8 @@ gtk_print_unix_dialog_init (GtkPrintUnixDialog *dialog)
   GListModel *selection;
   GtkSorter *sorter;
   GtkFilter *filter;
-  GtkFilter *filter1;
+  GtkStringFilter *filter1;
+  GtkCustomFilter *filter2;
   GtkListItemFactory *factory;
   GListStore *store;
   GListModel *paper_size_list;
@@ -810,22 +811,22 @@ gtk_print_unix_dialog_init (GtkPrintUnixDialog *dialog)
 
   /* Load backends */
   model = load_print_backends (dialog);
-  sorter = gtk_custom_sorter_new (default_printer_list_sort_func, NULL, NULL);
+  sorter = GTK_SORTER (gtk_custom_sorter_new (default_printer_list_sort_func, NULL, NULL));
   sorted = G_LIST_MODEL (gtk_sort_list_model_new (model, sorter));
 
-  filter = gtk_every_filter_new ();
+  filter = GTK_FILTER (gtk_every_filter_new ());
 
   filter1 = gtk_string_filter_new (
                 gtk_cclosure_expression_new (G_TYPE_STRING,
                                              NULL, 0, NULL,
                                              G_CALLBACK (get_printer_key),
                                              NULL, NULL));
-  gtk_string_filter_set_match_mode (GTK_STRING_FILTER (filter1), GTK_STRING_FILTER_MATCH_MODE_SUBSTRING);
-  gtk_string_filter_set_ignore_case (GTK_STRING_FILTER (filter1), TRUE);
-  gtk_multi_filter_append (GTK_MULTI_FILTER (filter), filter1);
+  gtk_string_filter_set_match_mode (filter1, GTK_STRING_FILTER_MATCH_MODE_SUBSTRING);
+  gtk_string_filter_set_ignore_case (filter1, TRUE);
+  gtk_multi_filter_append (GTK_MULTI_FILTER (filter), GTK_FILTER (filter1));
 
-  filter1 = gtk_custom_filter_new (is_printer_active, dialog, NULL);
-  gtk_multi_filter_append (GTK_MULTI_FILTER (filter), filter1);
+  filter2 = gtk_custom_filter_new (is_printer_active, dialog, NULL);
+  gtk_multi_filter_append (GTK_MULTI_FILTER (filter), GTK_FILTER (filter2));
 
   filtered = G_LIST_MODEL (gtk_filter_list_model_new (sorted, filter));
 

gtk/gtkstringfilter.c

@@ -313,10 +313,10 @@ gtk_string_filter_init (GtkStringFilter *self)
  *
  * Returns: a new #GtkStringFilter
  **/
-GtkFilter *
+GtkStringFilter *
 gtk_string_filter_new (GtkExpression *expression)
 {
-  GtkFilter *result;
+  GtkStringFilter *result;
 
   result = g_object_new (GTK_TYPE_STRING_FILTER,
                          "expression", expression,

gtk/gtkstringfilter.h

@@ -51,7 +51,7 @@ GDK_AVAILABLE_IN_ALL
 G_DECLARE_FINAL_TYPE (GtkStringFilter, gtk_string_filter, GTK, STRING_FILTER, GtkFilter)
 
 GDK_AVAILABLE_IN_ALL
-GtkFilter *             gtk_string_filter_new                   (GtkExpression          *expression);
+GtkStringFilter *       gtk_string_filter_new                   (GtkExpression          *expression);
 
 GDK_AVAILABLE_IN_ALL
 const char *            gtk_string_filter_get_search            (GtkStringFilter        *self);

gtk/gtkstringsorter.c

@@ -333,12 +333,12 @@ gtk_string_sorter_init (GtkStringSorter *self)
  * Unless an expression is set on it, this sorter will always
  * compare items as invalid.
  *
- * Returns: a new #GtkSorter
+ * Returns: a new #GtkStringSorter
  */
-GtkSorter *
+GtkStringSorter *
 gtk_string_sorter_new (GtkExpression *expression)
 {
-  GtkSorter *result;
+  GtkStringSorter *result;
 
   result = g_object_new (GTK_TYPE_STRING_SORTER,
                          "expression", expression,

gtk/gtkstringsorter.h

@@ -34,7 +34,7 @@ GDK_AVAILABLE_IN_ALL
 G_DECLARE_FINAL_TYPE (GtkStringSorter, gtk_string_sorter, GTK, STRING_SORTER, GtkSorter)
 
 GDK_AVAILABLE_IN_ALL
-GtkSorter *             gtk_string_sorter_new                   (GtkExpression          *expression);
+GtkStringSorter *       gtk_string_sorter_new                   (GtkExpression          *expression);
 
 GDK_AVAILABLE_IN_ALL
 GtkExpression *         gtk_string_sorter_get_expression        (GtkStringSorter        *self);

gtk/gtktreelistrowsorter.c

@@ -567,12 +567,12 @@ gtk_tree_list_row_sorter_init (GtkTreeListRowSorter *self)
  * Note that this sorter relies on #GtkTreeListModel:passthrough
  * being %FALSE as it can only sort #GtkTreeListRows.
  *
- * Returns: a new #GtkSorter
+ * Returns: a new #GtkTreeListRowSorter
  */
-GtkSorter *
+GtkTreeListRowSorter *
 gtk_tree_list_row_sorter_new (GtkSorter *sorter)
 {
-  GtkSorter *result;
+  GtkTreeListRowSorter *result;
 
   g_return_val_if_fail (sorter == NULL || GTK_IS_SORTER (sorter), NULL);
 

gtk/gtktreelistrowsorter.h

@@ -34,7 +34,7 @@ GDK_AVAILABLE_IN_ALL
 G_DECLARE_FINAL_TYPE (GtkTreeListRowSorter, gtk_tree_list_row_sorter, GTK, TREE_LIST_ROW_SORTER, GtkSorter)
 
 GDK_AVAILABLE_IN_ALL
-GtkSorter *             gtk_tree_list_row_sorter_new                   (GtkSorter            *sorter);
+GtkTreeListRowSorter *  gtk_tree_list_row_sorter_new                   (GtkSorter            *sorter);
 
 GDK_AVAILABLE_IN_ALL
 GtkSorter *             gtk_tree_list_row_sorter_get_sorter            (GtkTreeListRowSorter *self);

gtk/inspector/a11y.c

@@ -230,7 +230,7 @@ update_attributes (GtkInspectorA11y *sl)
 {
   GtkATContext *context;
   GListStore *store;
-  GtkFilter *filter;
+  GtkBoolFilter *filter;
   GtkFilterListModel *filter_model;
   GtkNoSelection *selection;
   GObject *obj;
@@ -311,9 +311,9 @@ update_attributes (GtkInspectorA11y *sl)
   g_type_class_unref (eclass);
 
   filter = gtk_bool_filter_new (gtk_property_expression_new (accessible_attribute_get_type (), NULL, "is-default"));
-  gtk_bool_filter_set_invert (GTK_BOOL_FILTER (filter), TRUE);
+  gtk_bool_filter_set_invert (filter, TRUE);
 
-  filter_model = gtk_filter_list_model_new (G_LIST_MODEL (store), filter);
+  filter_model = gtk_filter_list_model_new (G_LIST_MODEL (store), GTK_FILTER (filter));
   selection = gtk_no_selection_new (G_LIST_MODEL (filter_model));
   gtk_column_view_set_model (GTK_COLUMN_VIEW (sl->attributes), GTK_SELECTION_MODEL (selection));
   g_object_unref (selection);

gtk/inspector/actions.c

@@ -389,11 +389,11 @@ constructed (GObject *object)
   g_signal_connect_swapped (sl->button, "clicked",
                             G_CALLBACK (refresh_all), sl);
 
-  sorter = gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING,
+  sorter = GTK_SORTER (gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING,
                                                                NULL,
                                                                0, NULL,
                                                                (GCallback)holder_name,
-                                                               NULL, NULL));
+                                                               NULL, NULL)));
   gtk_column_view_column_set_sorter (sl->name, sorter);
   g_object_unref (sorter);
 

gtk/inspector/controllers.c

@@ -246,7 +246,7 @@ gtk_inspector_controllers_set_object (GtkInspectorControllers *self,
 
   flatten_model = gtk_flatten_list_model_new (G_LIST_MODEL (map_model));
 
-  sorter = gtk_custom_sorter_new (compare_controllers, NULL, NULL);
+  sorter = GTK_SORTER (gtk_custom_sorter_new (compare_controllers, NULL, NULL));
   sort_model = gtk_sort_list_model_new (G_LIST_MODEL (flatten_model), sorter);
 
   gtk_list_box_bind_model (GTK_LIST_BOX (self->listbox),

gtk/inspector/object-tree.c

@@ -1135,8 +1135,9 @@ toplevel_filter_func (gpointer item,
 static GListModel *
 create_root_model (GdkDisplay *display)
 {
-  GtkFilter *custom_filter;
-  GtkFilterListModel *filter;
+  GtkFilter *filter;
+  GtkFilterListModel *filter_model;
+  GListModel *model;
   GListStore *list, *special;
   gpointer item;
 
@@ -1150,12 +1151,11 @@ create_root_model (GdkDisplay *display)
   g_list_store_append (list, special);
   g_object_unref (special);
 
-  filter = gtk_filter_list_model_new (NULL, NULL);
-  custom_filter = gtk_custom_filter_new (toplevel_filter_func, display, NULL);
-  gtk_filter_list_model_set_filter (filter, custom_filter);
-  gtk_filter_list_model_set_model (filter, gtk_window_get_toplevels ());
-  g_list_store_append (list, filter);
-  g_object_unref (filter);
+  filter = GTK_FILTER (gtk_custom_filter_new (toplevel_filter_func, display, NULL));
+  model = gtk_window_get_toplevels ();
+  filter_model = gtk_filter_list_model_new (g_object_ref (model), filter);
+  g_list_store_append (list, filter_model);
+  g_object_unref (filter_model);
 
   return G_LIST_MODEL (gtk_flatten_list_model_new (G_LIST_MODEL (list)));
 }

gtk/inspector/prop-list.c

@@ -59,7 +59,7 @@ struct _GtkInspectorPropListPrivate
   GtkWidget *search_entry;
   GtkWidget *search_stack;
   GtkWidget *list;
-  GtkFilter *filter;
+  GtkStringFilter *filter;
   GtkColumnViewColumn *name;
   GtkColumnViewColumn *type;
   GtkColumnViewColumn *origin;
@@ -114,31 +114,31 @@ gtk_inspector_prop_list_init (GtkInspectorPropList *pl)
   pl->priv = gtk_inspector_prop_list_get_instance_private (pl);
   gtk_widget_init_template (GTK_WIDGET (pl));
   pl->priv->filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_match_mode (GTK_STRING_FILTER (pl->priv->filter), GTK_STRING_FILTER_MATCH_MODE_SUBSTRING);
+  gtk_string_filter_set_match_mode (pl->priv->filter, GTK_STRING_FILTER_MATCH_MODE_SUBSTRING);
 
-  sorter = gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL,
+  sorter = GTK_SORTER (gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL,
                                                                0, NULL,
                                                                (GCallback)holder_prop,
-                                                               NULL, NULL));
+                                                               NULL, NULL)));
  
-  gtk_string_filter_set_expression (GTK_STRING_FILTER (pl->priv->filter),
+  gtk_string_filter_set_expression (pl->priv->filter,
                                     gtk_string_sorter_get_expression (GTK_STRING_SORTER (sorter)));
 
   gtk_column_view_column_set_sorter (pl->priv->name, sorter);
   g_object_unref (sorter);
 
-  sorter = gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL,
+  sorter = GTK_SORTER (gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL,
                                                                0, NULL,
                                                                (GCallback)holder_type,
-                                                               NULL, NULL));
+                                                               NULL, NULL)));
 
   gtk_column_view_column_set_sorter (pl->priv->type, sorter);
   g_object_unref (sorter);
 
-  sorter = gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL,
+  sorter = GTK_SORTER (gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL,
                                                                0, NULL,
                                                                (GCallback)holder_origin,
-                                                               NULL, NULL));
+                                                               NULL, NULL)));
 
   gtk_column_view_column_set_sorter (pl->priv->origin, sorter);
   g_object_unref (sorter);
@@ -217,7 +217,7 @@ update_filter (GtkInspectorPropList *pl,
   const char *text;
 
   text = gtk_editable_get_text (GTK_EDITABLE (entry));
-  gtk_string_filter_set_search (GTK_STRING_FILTER (pl->priv->filter), text);
+  gtk_string_filter_set_search (pl->priv->filter, text);
 }
 
 static void
@@ -622,7 +622,7 @@ gtk_inspector_prop_list_set_object (GtkInspectorPropList *pl,
   if (GTK_IS_WIDGET (object))
     g_signal_connect_object (object, "destroy", G_CALLBACK (cleanup_object), pl, G_CONNECT_SWAPPED);
 
-  filtered = G_LIST_MODEL (gtk_filter_list_model_new (G_LIST_MODEL (store), g_object_ref (pl->priv->filter)));
+  filtered = G_LIST_MODEL (gtk_filter_list_model_new (G_LIST_MODEL (store), g_object_ref (GTK_FILTER (pl->priv->filter))));
   sorted = gtk_sort_list_model_new (filtered, NULL);
   list = G_LIST_MODEL (gtk_no_selection_new (G_LIST_MODEL (sorted)));
 

gtk/inspector/resource-list.c

@@ -652,26 +652,26 @@ gtk_inspector_resource_list_init (GtkInspectorResourceList *rl)
   gtk_search_bar_connect_entry (GTK_SEARCH_BAR (rl->search_bar),
                                 GTK_EDITABLE (rl->search_entry));
 
-  sorter = gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL,
+  sorter = GTK_SORTER (gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL,
                                                                0, NULL,
                                                                (GCallback)holder_name,
-                                                               NULL, NULL));
+                                                               NULL, NULL)));
 
   gtk_column_view_column_set_sorter (rl->path, sorter);
   g_object_unref (sorter);
 
-  sorter = gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_INT, NULL,
+  sorter = GTK_SORTER (gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_INT, NULL,
                                                                 0, NULL,
                                                                 (GCallback)holder_count,
-                                                                NULL, NULL));
+                                                                NULL, NULL)));
 
   gtk_column_view_column_set_sorter (rl->count, sorter);
   g_object_unref (sorter);
 
-  sorter = gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_UINT64, NULL,
+  sorter = GTK_SORTER (gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_UINT64, NULL,
                                                                 0, NULL,
                                                                 (GCallback)holder_size,
-                                                                NULL, NULL));
+                                                                NULL, NULL)));
 
   gtk_column_view_column_set_sorter (rl->size, sorter);
   g_object_unref (sorter);
@@ -709,7 +709,7 @@ constructed (GObject *object)
                                             NULL);
 
   column_sorter = gtk_column_view_get_sorter (GTK_COLUMN_VIEW (rl->list));
-  sorter = gtk_tree_list_row_sorter_new (g_object_ref (column_sorter));
+  sorter = GTK_SORTER (gtk_tree_list_row_sorter_new (g_object_ref (column_sorter)));
   sort_model = G_LIST_MODEL (gtk_sort_list_model_new (g_object_ref (G_LIST_MODEL (rl->tree_model)), sorter));
   rl->selection = gtk_single_selection_new (sort_model);
 

tests/testcolumnview.c

@@ -665,7 +665,7 @@ add_extra_columns (GtkColumnView   *view,
       column = gtk_column_view_column_new_with_factory (extra_columns[i].title,
           gtk_builder_list_item_factory_new_from_bytes (scope, bytes));
       g_bytes_unref (bytes);
-      sorter = gtk_custom_sorter_new (compare_file_attribute, (gpointer) extra_columns[i].attribute, NULL);
+      sorter = GTK_SORTER (gtk_custom_sorter_new (compare_file_attribute, (gpointer) extra_columns[i].attribute, NULL));
       gtk_column_view_column_set_sorter (column, sorter);
       g_object_unref (sorter);
       gtk_column_view_append_column (view, column);
@@ -753,10 +753,10 @@ main (int argc, char *argv[])
                                   create_list_model_for_file_info,
                                   NULL, NULL);
 
-  sorter = gtk_tree_list_row_sorter_new (g_object_ref (gtk_column_view_get_sorter (GTK_COLUMN_VIEW (view))));
+  sorter = GTK_SORTER (gtk_tree_list_row_sorter_new (g_object_ref (gtk_column_view_get_sorter (GTK_COLUMN_VIEW (view)))));
   sort = gtk_sort_list_model_new (G_LIST_MODEL (tree), sorter);
 
-  custom_filter = gtk_custom_filter_new (match_file, g_object_ref (search_entry), g_object_unref);
+  custom_filter = GTK_FILTER (gtk_custom_filter_new (match_file, g_object_ref (search_entry), g_object_unref));
   filter = gtk_filter_list_model_new (G_LIST_MODEL (sort), custom_filter);
   g_signal_connect (search_entry, "search-changed", G_CALLBACK (search_changed_cb), custom_filter);
 

tests/testlistview-animating.c

@@ -126,7 +126,7 @@ main (int   argc,
   store = g_list_store_new (G_TYPE_OBJECT);
   for (i = 0; i < AVERAGE; i++)
     add (store);
-  sorter = gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_UINT, NULL, 0, NULL, (GCallback)get_number, NULL, NULL));
+  sorter = GTK_SORTER (gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_UINT, NULL, 0, NULL, (GCallback)get_number, NULL, NULL)));
   sort = gtk_sort_list_model_new (G_LIST_MODEL (store), sorter);
 
   win = gtk_window_new ();

tests/testlistview.c

@@ -325,7 +325,7 @@ create_list_model_for_directory (gpointer file)
     return NULL;
 
   dir = create_directory_list (file);
-  sorter = gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL, 0, NULL, (GCallback) get_file_path, NULL, NULL));
+  sorter = GTK_SORTER (gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL, 0, NULL, (GCallback) get_file_path, NULL, NULL)));
 
   return G_LIST_MODEL (gtk_sort_list_model_new (G_LIST_MODEL (dir), sorter));
 }
@@ -629,7 +629,7 @@ main (int argc, char *argv[])
                                   NULL, NULL);
   g_object_unref (root);
 
-  custom_filter = gtk_custom_filter_new (match_file, search_entry, NULL);
+  custom_filter = GTK_FILTER (gtk_custom_filter_new (match_file, search_entry, NULL));
   filter = gtk_filter_list_model_new (G_LIST_MODEL (tree), custom_filter);
   g_signal_connect (search_entry, "search-changed", G_CALLBACK (search_changed_cb), custom_filter);
 

testsuite/gtk/expression.c

@@ -38,7 +38,7 @@ test_property (void)
   GtkStringFilter *filter;
   guint counter = 0;
 
-  filter = GTK_STRING_FILTER (gtk_string_filter_new (NULL));
+  filter = gtk_string_filter_new (NULL);
   expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, NULL, "search");
   watch = gtk_expression_watch (expr, filter, inc_counter, &counter, NULL);
 
@@ -192,7 +192,7 @@ test_nested (void)
   GtkExpression *list_expr;
   GtkExpression *filter_expr;
   GtkExpression *expr;
-  GtkFilter *filter;
+  GtkStringFilter *filter;
   GListModel *list;
   GtkFilterListModel *filtered;
   GValue value = G_VALUE_INIT;
@@ -201,9 +201,9 @@ test_nested (void)
   guint counter = 0;
 
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "word");
+  gtk_string_filter_set_search (filter, "word");
   list = G_LIST_MODEL (g_list_store_new (G_TYPE_OBJECT));
-  filtered = gtk_filter_list_model_new (list, g_object_ref (filter));
+  filtered = gtk_filter_list_model_new (list, g_object_ref (GTK_FILTER (filter)));
 
   list_expr = gtk_object_expression_new (G_OBJECT (filtered));
   filter_expr = gtk_property_expression_new (GTK_TYPE_FILTER_LIST_MODEL, list_expr, "filter");
@@ -227,13 +227,13 @@ test_nested (void)
   g_assert_cmpstr (g_value_get_string (&value), ==, "salad");
   g_value_unset (&value);
 
-  gtk_filter_list_model_set_filter (filtered, filter);
+  gtk_filter_list_model_set_filter (filtered, GTK_FILTER (filter));
   g_assert_cmpint (counter, ==, 0);
 
   g_clear_object (&filter);
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "salad");
-  gtk_filter_list_model_set_filter (filtered, filter);
+  gtk_string_filter_set_search (filter, "salad");
+  gtk_filter_list_model_set_filter (filtered, GTK_FILTER (filter));
   g_assert_cmpint (counter, ==, 1);
   counter = 0;
 
@@ -242,7 +242,7 @@ test_nested (void)
   g_assert_cmpstr (g_value_get_string (&value), ==, "salad");
   g_value_unset (&value);
 
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "bar");
+  gtk_string_filter_set_search (filter, "bar");
   g_assert_cmpint (counter, ==, 1);
   counter = 0;
 
@@ -279,7 +279,7 @@ test_nested_this_destroyed (void)
   GtkExpression *list_expr;
   GtkExpression *filter_expr;
   GtkExpression *expr;
-  GtkFilter *filter;
+  GtkStringFilter *filter;
   GListModel *list;
   GtkFilterListModel *filtered;
   GValue value = G_VALUE_INIT;
@@ -288,9 +288,9 @@ test_nested_this_destroyed (void)
   guint counter = 0;
 
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "word");
+  gtk_string_filter_set_search (filter, "word");
   list = G_LIST_MODEL (g_list_store_new (G_TYPE_OBJECT));
-  filtered = gtk_filter_list_model_new (list, g_object_ref (filter));
+  filtered = gtk_filter_list_model_new (list, g_object_ref (GTK_FILTER (filter)));
 
   list_expr = gtk_object_expression_new (G_OBJECT (filtered));
   filter_expr = gtk_property_expression_new (GTK_TYPE_FILTER_LIST_MODEL, list_expr, "filter");
@@ -307,15 +307,15 @@ test_nested_this_destroyed (void)
   g_assert_cmpint (counter, ==, 0);
 
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "salad");
-  gtk_filter_list_model_set_filter (filtered, filter);
+  gtk_string_filter_set_search (filter, "salad");
+  gtk_filter_list_model_set_filter (filtered, GTK_FILTER (filter));
   g_assert_cmpint (counter, ==, 1);
   counter = 0;
 
   res = gtk_expression_watch_evaluate (watch, &value);
   g_assert_false (res);
 
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "bar");
+  gtk_string_filter_set_search (filter, "bar");
   g_assert_cmpint (counter, ==, 0);
 
   gtk_filter_list_model_set_filter (filtered, NULL);
@@ -346,7 +346,7 @@ test_type_mismatch (void)
   GValue value = G_VALUE_INIT;
   gboolean res;
 
-  filter = gtk_any_filter_new ();
+  filter = GTK_FILTER (gtk_any_filter_new ());
 
   expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, gtk_constant_expression_new (GTK_TYPE_ANY_FILTER, filter), "search");
 
@@ -362,8 +362,8 @@ test_type_mismatch (void)
 static void
 test_this (void)
 {
-  GtkFilter *filter;
-  GtkFilter *filter2;
+  GtkStringFilter *filter;
+  GtkStringFilter *filter2;
   GtkExpression *expr;
   GValue value = G_VALUE_INIT;
   gboolean res;
@@ -371,10 +371,10 @@ test_this (void)
   expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, NULL, "search");
 
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "word");
+  gtk_string_filter_set_search (filter, "word");
 
   filter2 = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter2), "sausage");
+  gtk_string_filter_set_search (filter2, "sausage");
 
   res = gtk_expression_evaluate (expr, filter, &value);
   g_assert_true (res);
@@ -417,8 +417,8 @@ test_constant_watch_this_destroyed (void)
 static void
 test_bind (void)
 {
-  GtkFilter *target;
-  GtkFilter *source;
+  GtkStringFilter *target;
+  GtkStringFilter *source;
   GtkExpression *expr;
   GtkExpressionWatch *watch;
   GValue value = G_VALUE_INIT;
@@ -427,25 +427,25 @@ test_bind (void)
   expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, NULL, "search");
 
   target = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (target), "word");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (target)), ==, "word");
+  gtk_string_filter_set_search (target, "word");
+  g_assert_cmpstr (gtk_string_filter_get_search (target), ==, "word");
 
   source = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (source), "sausage");
+  gtk_string_filter_set_search (source, "sausage");
 
   watch = gtk_expression_bind (expr, target, "search", source);
   gtk_expression_watch_ref (watch);
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (target)), ==, "sausage");
+  g_assert_cmpstr (gtk_string_filter_get_search (target), ==, "sausage");
 
-  gtk_string_filter_set_search (GTK_STRING_FILTER (source), "salad");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (target)), ==, "salad");
+  gtk_string_filter_set_search (source, "salad");
+  g_assert_cmpstr (gtk_string_filter_get_search (target), ==, "salad");
   res = gtk_expression_watch_evaluate (watch, &value);
   g_assert_true (res);
   g_assert_cmpstr (g_value_get_string (&value), ==, "salad"); 
   g_value_unset (&value);
 
   g_object_unref (source);
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (target)), ==, "salad");
+  g_assert_cmpstr (gtk_string_filter_get_search (target), ==, "salad");
   res = gtk_expression_watch_evaluate (watch, &value);
   g_assert_false (res);
   g_assert_false (G_IS_VALUE (&value));
@@ -458,7 +458,7 @@ test_bind (void)
 static void
 test_bind_self (void)
 {
-  GtkFilter *filter;
+  GtkStringFilter *filter;
   GtkExpression *expr;
 
   expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER,
@@ -466,11 +466,11 @@ test_bind_self (void)
                                       "ignore-case");
 
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "word");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter)), ==, "word");
+  gtk_string_filter_set_search (filter, "word");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "word");
 
   gtk_expression_bind (expr, filter, "search", filter);
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter)), ==, "TRUE");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "TRUE");
 
   g_object_unref (filter);
 }
@@ -480,7 +480,7 @@ test_bind_self (void)
 static void
 test_bind_child (void)
 {
-  GtkFilter *filter;
+  GtkStringFilter *filter;
   GtkFilterListModel *child, *target;
   GtkExpression *expr;
 
@@ -489,15 +489,15 @@ test_bind_child (void)
                                       "filter");
 
   filter = gtk_string_filter_new (NULL);
-  child = gtk_filter_list_model_new (NULL, filter);
+  child = gtk_filter_list_model_new (NULL, GTK_FILTER (filter));
   target = gtk_filter_list_model_new (G_LIST_MODEL (child), NULL);
 
   gtk_expression_bind (expr, target, "filter", child);
   g_assert_true (gtk_filter_list_model_get_filter (child) == gtk_filter_list_model_get_filter (target));
 
   filter = gtk_string_filter_new (NULL);
-  gtk_filter_list_model_set_filter (child, filter);
-  g_assert_true (filter == gtk_filter_list_model_get_filter (target));
+  gtk_filter_list_model_set_filter (child, GTK_FILTER (filter));
+  g_assert_true (GTK_FILTER (filter) == gtk_filter_list_model_get_filter (target));
   g_assert_true (gtk_filter_list_model_get_filter (child) == gtk_filter_list_model_get_filter (target));
   g_object_unref (filter);
 
@@ -508,9 +508,9 @@ test_bind_child (void)
 static void
 test_nested_bind (void)
 {
-  GtkFilter *filter;
-  GtkFilter *filter2;
-  GtkFilter *filter3;
+  GtkStringFilter *filter;
+  GtkStringFilter *filter2;
+  GtkStringFilter *filter3;
   GListModel *list;
   GtkFilterListModel *filtered;
   GtkExpression *expr;
@@ -519,10 +519,10 @@ test_nested_bind (void)
   GValue value = G_VALUE_INIT;
 
   filter2 = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter2), "sausage");
+  gtk_string_filter_set_search (filter2, "sausage");
 
   list = G_LIST_MODEL (g_list_store_new (G_TYPE_OBJECT));
-  filtered = gtk_filter_list_model_new (list, g_object_ref (filter2));
+  filtered = gtk_filter_list_model_new (list, g_object_ref (GTK_FILTER (filter2)));
 
   filter_expr = gtk_property_expression_new (GTK_TYPE_FILTER_LIST_MODEL,
                                              gtk_object_expression_new (G_OBJECT (filtered)),
@@ -530,17 +530,17 @@ test_nested_bind (void)
   expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, gtk_expression_ref (filter_expr), "search");
 
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "word");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter)), ==, "word");
+  gtk_string_filter_set_search (filter, "word");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "word");
 
   gtk_expression_bind (gtk_expression_ref (expr), filter, "search", NULL);
 
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter2), "sausage");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter)), ==, "sausage");
+  gtk_string_filter_set_search (filter2, "sausage");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "sausage");
 
   filter3 = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter3), "banana");
-  gtk_filter_list_model_set_filter (filtered, filter3);
+  gtk_string_filter_set_search (filter3, "banana");
+  gtk_filter_list_model_set_filter (filtered, GTK_FILTER (filter3));
 
   /* check that the expressions evaluate correctly */
   res = gtk_expression_evaluate (filter_expr, NULL, &value);
@@ -554,7 +554,7 @@ test_nested_bind (void)
   g_value_unset (&value);
 
   /* and the bind too */
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter)), ==, "banana");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "banana");
 
   g_object_unref (filter);
   g_object_unref (filter2);
@@ -592,8 +592,8 @@ test_double_bind (void)
   GtkExpression *filter_expr;
   GtkExpression *params[2];
 
-  filter1 = GTK_STRING_FILTER (gtk_string_filter_new (NULL));
-  filter2 = GTK_STRING_FILTER (gtk_string_filter_new (NULL));
+  filter1 = gtk_string_filter_new (NULL);
+  filter2 = gtk_string_filter_new (NULL);
 
   filter_expr = gtk_object_expression_new (G_OBJECT (filter1));
 
@@ -607,11 +607,11 @@ test_double_bind (void)
 
   gtk_expression_bind (gtk_expression_ref (expr), filter2, "search", NULL);
 
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter1), "Banana");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter2)), ==, "banana");
+  gtk_string_filter_set_search (filter1, "Banana");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter2), ==, "banana");
 
-  gtk_string_filter_set_ignore_case (GTK_STRING_FILTER (filter1), FALSE);
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter2)), ==, "Banana");
+  gtk_string_filter_set_ignore_case (filter1, FALSE);
+  g_assert_cmpstr (gtk_string_filter_get_search (filter2), ==, "Banana");
 
   gtk_expression_unref (expr);
   gtk_expression_unref (filter_expr);
@@ -633,9 +633,9 @@ test_binds (void)
   GtkExpression *filter2_expr;
   GtkExpression *params[2];
 
-  filter1 = GTK_STRING_FILTER (gtk_string_filter_new (NULL));
-  filter2 = GTK_STRING_FILTER (gtk_string_filter_new (NULL));
-  filter3 = GTK_STRING_FILTER (gtk_string_filter_new (NULL));
+  filter1 = gtk_string_filter_new (NULL);
+  filter2 = gtk_string_filter_new (NULL);
+  filter3 = gtk_string_filter_new (NULL);
 
   filter1_expr = gtk_object_expression_new (G_OBJECT (filter1));
   filter2_expr = gtk_object_expression_new (G_OBJECT (filter2));
@@ -653,20 +653,20 @@ test_binds (void)
   gtk_expression_bind (gtk_expression_ref (expr), filter3, "search", NULL);
   gtk_expression_bind (gtk_expression_ref (expr2), filter3, "ignore-case", NULL);
 
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter1), "Banana");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter3)), ==, "banana");
-  g_assert_true (gtk_string_filter_get_ignore_case (GTK_STRING_FILTER (filter3)));
+  gtk_string_filter_set_search (filter1, "Banana");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter3), ==, "banana");
+  g_assert_true (gtk_string_filter_get_ignore_case (filter3));
 
-  gtk_string_filter_set_ignore_case (GTK_STRING_FILTER (filter2), FALSE);
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter3)), ==, "Banana");
-  g_assert_false (gtk_string_filter_get_ignore_case (GTK_STRING_FILTER (filter3)));
+  gtk_string_filter_set_ignore_case (filter2, FALSE);
+  g_assert_cmpstr (gtk_string_filter_get_search (filter3), ==, "Banana");
+  g_assert_false (gtk_string_filter_get_ignore_case (filter3));
 
   /* invalidate the first bind */
   g_object_unref (filter1);
 
-  gtk_string_filter_set_ignore_case (GTK_STRING_FILTER (filter2), TRUE);
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter3)), ==, "Banana");
-  g_assert_true (gtk_string_filter_get_ignore_case (GTK_STRING_FILTER (filter3)));
+  gtk_string_filter_set_ignore_case (filter2, TRUE);
+  g_assert_cmpstr (gtk_string_filter_get_search (filter3), ==, "Banana");
+  g_assert_true (gtk_string_filter_get_ignore_case (filter3));
 
   gtk_expression_unref (expr);
   gtk_expression_unref (expr2);
@@ -681,7 +681,7 @@ test_binds (void)
 static void
 test_bind_object (void)
 {
-  GtkFilter *filter;
+  GtkStringFilter *filter;
   GListStore *store;
   GtkFilterListModel *model;
   GtkExpression *expr;
@@ -694,11 +694,11 @@ test_bind_object (void)
 
   gtk_expression_bind (gtk_expression_ref (expr), model, "filter", NULL);
 
-  g_assert_true (gtk_filter_list_model_get_filter (model) == filter);
+  g_assert_true (gtk_filter_list_model_get_filter (model) == GTK_FILTER (filter));
 
   g_object_unref (filter);
 
-  g_assert_true (gtk_filter_list_model_get_filter (model) == filter);
+  g_assert_true (gtk_filter_list_model_get_filter (model) == GTK_FILTER (filter));
 
   gtk_expression_unref (expr);
   g_object_unref (model);

testsuite/gtk/filter.c

@@ -207,7 +207,7 @@ test_simple (void)
   GtkFilterListModel *model;
   GtkFilter *filter;
 
-  filter = gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (3), NULL);
+  filter = GTK_FILTER (gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (3), NULL));
   model = new_model (20, filter);
   g_object_unref (filter);
   assert_model (model, "3 6 9 12 15 18");
@@ -220,9 +220,9 @@ test_any_simple (void)
   GtkFilterListModel *model;
   GtkFilter *any, *filter1, *filter2;
 
-  any = gtk_any_filter_new ();
-  filter1 = gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (3), NULL);
-  filter2 = gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (5), NULL);
+  any = GTK_FILTER (gtk_any_filter_new ());
+  filter1 = GTK_FILTER (gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (3), NULL));
+  filter2 = GTK_FILTER (gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (5), NULL));
 
   model = new_model (20, any);
   assert_model (model, "");
@@ -253,12 +253,12 @@ test_string_simple (void)
   GtkFilterListModel *model;
   GtkFilter *filter;
 
-  filter = gtk_string_filter_new (
+  filter = GTK_FILTER (gtk_string_filter_new (
                gtk_cclosure_expression_new (G_TYPE_STRING,
                                             NULL,
                                             0, NULL,
                                             G_CALLBACK (get_string),
-                                            NULL, NULL));
+                                            NULL, NULL)));
 
   model = new_model (20, filter);
   assert_model (model, "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20");
@@ -276,12 +276,12 @@ test_string_properties (void)
   GtkFilterListModel *model;
   GtkFilter *filter;
 
-  filter = gtk_string_filter_new (
+  filter = GTK_FILTER (gtk_string_filter_new (
                gtk_cclosure_expression_new (G_TYPE_STRING,
                                             NULL,
                                             0, NULL,
                                             G_CALLBACK (get_spelled_out),
-                                            NULL, NULL));
+                                            NULL, NULL)));
 
   model = new_model (1000, filter);
   gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "thirte");
@@ -316,12 +316,12 @@ test_bool_simple (void)
   GtkExpression *expr;
   GtkFilter *filter;
 
-  filter = gtk_bool_filter_new (
+  filter = GTK_FILTER (gtk_bool_filter_new (
                gtk_cclosure_expression_new (G_TYPE_BOOLEAN,
                                             NULL,
                                             0, NULL,
                                             G_CALLBACK (divisible_by),
-                                            GUINT_TO_POINTER (3), NULL));
+                                            GUINT_TO_POINTER (3), NULL)));
   model = new_model (20, filter);
   assert_model (model, "3 6 9 12 15 18");
 
@@ -358,10 +358,10 @@ test_every_dispose (void)
 {
   GtkFilter *filter, *filter1, *filter2;
 
-  filter = gtk_every_filter_new ();
+  filter = GTK_FILTER (gtk_every_filter_new ());
 
-  filter1 = gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (3), NULL);
-  filter2 = gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (5), NULL);
+  filter1 = GTK_FILTER (gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (3), NULL));
+  filter2 = GTK_FILTER (gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (5), NULL));
 
   g_object_ref (filter1);
   g_object_ref (filter2);

testsuite/gtk/filterlistmodel-exhaustive.c

@@ -217,11 +217,11 @@ create_filter (gsize id)
   {
     case 0:
       /* GTK_FILTER_MATCH_ALL */
-      return gtk_string_filter_new (NULL);
+      return GTK_FILTER (gtk_string_filter_new (NULL));
 
     case 1:
       /* GTK_FILTER_MATCH_NONE */
-      filter = gtk_string_filter_new (NULL);
+      filter = GTK_FILTER (gtk_string_filter_new (NULL));
       gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "does not matter, because no expression");
       return filter;
 
@@ -229,7 +229,7 @@ create_filter (gsize id)
     case 3:
     case 4:
       /* match all As, Bs and nothing */
-      filter = gtk_string_filter_new (gtk_property_expression_new (GTK_TYPE_STRING_OBJECT, NULL, "string"));
+      filter = GTK_FILTER (gtk_string_filter_new (gtk_property_expression_new (GTK_TYPE_STRING_OBJECT, NULL, "string")));
       if (id == 2)
         gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "A");
       else if (id == 3)
@@ -302,7 +302,7 @@ test_two_filters (gconstpointer model_id)
   source = create_source_model (10, 10);
   model1 = create_filter_list_model (model_id, source, NULL);
   model2 = create_filter_list_model (model_id, G_LIST_MODEL (model1), NULL);
-  every = gtk_every_filter_new ();
+  every = GTK_FILTER (gtk_every_filter_new ());
   compare = create_filter_list_model (model_id, source, every);
   g_object_unref (every);
   g_object_unref (source);
@@ -364,7 +364,7 @@ test_model_changes (gconstpointer model_id)
   gsize i;
 
   filter = create_random_filter (TRUE);
-  multi = gtk_every_filter_new ();
+  multi = GTK_FILTER (gtk_every_filter_new ());
   if (filter)
     gtk_multi_filter_append (GTK_MULTI_FILTER (multi), filter);
 

testsuite/gtk/filterlistmodel.c

@@ -164,7 +164,7 @@ new_model (guint               size,
   GString *changes;
 
   if (filter_func)
-    filter = gtk_custom_filter_new (filter_func, data, NULL);
+    filter = GTK_FILTER (gtk_custom_filter_new (filter_func, data, NULL));
   else
     filter = NULL;
   result = gtk_filter_list_model_new (g_object_ref (G_LIST_MODEL (new_store (1, size, 1))), filter);
@@ -234,9 +234,9 @@ test_empty_set_filter (void)
 {
   GtkFilterListModel *filter;
   GtkFilter *custom;
-  
+
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (20), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (20), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 3 4 5 6 7 8 9 10");
@@ -244,7 +244,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (7), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (7), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 3 4 5 6");
@@ -252,7 +252,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (0), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (0), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "");
@@ -260,7 +260,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (0), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (0), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 3 4 5 6 7 8 9 10");
@@ -268,7 +268,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (3), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (3), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "4 5 6 7 8 9 10");
@@ -276,7 +276,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (20), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (20), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "");
@@ -284,7 +284,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_near, GUINT_TO_POINTER (5), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_near, GUINT_TO_POINTER (5), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "3 4 5 6 7");
@@ -292,7 +292,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (5), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (5), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 8 9 10");
@@ -310,37 +310,37 @@ test_change_filter (void)
   assert_model (filter, "1 2 8 9 10");
   assert_changes (filter, "");
 
-  custom = gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (6), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (6), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 3 9 10");
   assert_changes (filter, "2-1+1");
 
-  custom = gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (9), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (9), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 3 4 5 6");
   assert_changes (filter, "3-2+3");
 
-  custom = gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (6), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (6), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 3 4 5");
   assert_changes (filter, "-5");
 
-  custom = gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (4), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (4), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "5 6 7 8 9 10");
   assert_changes (filter, "0-5+6");
 
-  custom = gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (2), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (2), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "5 6 7 8 9 10");
   assert_changes (filter, "");
 
-  custom = gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (4), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (4), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 7 8 9 10");
@@ -354,14 +354,14 @@ test_incremental (void)
 {
   GtkFilterListModel *filter;
   GtkFilter *custom;
-  
+
   /* everything is filtered */
   filter = new_model (1000, is_larger_than, GUINT_TO_POINTER (10000));
   gtk_filter_list_model_set_incremental (filter, TRUE);
   assert_model (filter, "");
   assert_changes (filter, "");
 
-  custom = gtk_custom_filter_new (is_near, GUINT_TO_POINTER (512), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_near, GUINT_TO_POINTER (512), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "");

testsuite/gtk/sorter.c

@@ -274,7 +274,7 @@ test_simple (void)
   model = new_model (20, NULL);
   assert_not_model (model, "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20");
 
-  sorter = gtk_custom_sorter_new (compare_numbers, NULL, NULL);
+  sorter = GTK_SORTER (gtk_custom_sorter_new (compare_numbers, NULL, NULL));
   gtk_sort_list_model_set_sorter (model, sorter);
   g_object_unref (sorter);
 
@@ -296,7 +296,7 @@ test_string (void)
   model = new_model (20, NULL);
   assert_not_model (model, "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20");
 
-  sorter = gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL, 0, NULL, (GCallback)get_string, NULL, NULL));
+  sorter = GTK_SORTER (gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL, 0, NULL, (GCallback)get_string, NULL, NULL)));
 
   gtk_sort_list_model_set_sorter (model, sorter);
   g_object_unref (sorter);
@@ -330,7 +330,7 @@ test_change (void)
   GtkExpression *expression;
   int counter = 0;
 
-  sorter = gtk_string_sorter_new (NULL);
+  sorter = GTK_SORTER (gtk_string_sorter_new (NULL));
   g_signal_connect (sorter, "changed", G_CALLBACK (inc_counter), &counter);
 
   expression = gtk_cclosure_expression_new (G_TYPE_STRING, NULL, 0, NULL, (GCallback)get_string, NULL, NULL);
@@ -360,7 +360,7 @@ test_numeric (void)
   model = new_model (20, NULL);
   assert_not_model (model, "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20");
 
-  sorter = gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_UINT, NULL, 0, NULL, (GCallback)get_number, NULL, NULL));
+  sorter = GTK_SORTER (gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_UINT, NULL, 0, NULL, (GCallback)get_number, NULL, NULL)));
   gtk_sort_list_model_set_sorter (model, sorter);
   assert_model (model, "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20");
 
@@ -409,7 +409,7 @@ test_multi (void)
   model = new_model (20, NULL);
   assert_not_model (model, "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20");
 
-  sorter2 = gtk_numeric_sorter_new (NULL);
+  sorter2 = GTK_SORTER (gtk_numeric_sorter_new (NULL));
   gtk_sort_list_model_set_sorter (model, sorter2);
   expression = gtk_cclosure_expression_new (G_TYPE_UINT, NULL, 0, NULL, (GCallback)get_number, NULL, NULL);
   gtk_numeric_sorter_set_expression (GTK_NUMERIC_SORTER (sorter2), expression);
@@ -417,10 +417,10 @@ test_multi (void)
 
   assert_model (model, "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20");
 
-  sorter = gtk_multi_sorter_new ();
+  sorter = GTK_SORTER (gtk_multi_sorter_new ());
   gtk_sort_list_model_set_sorter (model, sorter);
 
-  sorter1 = gtk_custom_sorter_new (compare_even, NULL, NULL);
+  sorter1 = GTK_SORTER (gtk_custom_sorter_new (compare_even, NULL, NULL));
   gtk_multi_sorter_append (GTK_MULTI_SORTER (sorter), sorter1);
   gtk_multi_sorter_append (GTK_MULTI_SORTER (sorter), sorter2);
 
@@ -446,8 +446,8 @@ test_multi_destruct (void)
 {
   GtkSorter *multi, *sorter;
 
-  multi = gtk_multi_sorter_new ();
-  sorter = gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_UINT, NULL, 0, NULL, (GCallback)get_number, NULL, NULL));
+  multi = GTK_SORTER (gtk_multi_sorter_new ());
+  sorter = GTK_SORTER (gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_UINT, NULL, 0, NULL, (GCallback)get_number, NULL, NULL)));
   gtk_multi_sorter_append (GTK_MULTI_SORTER (multi), g_object_ref (sorter));
   g_object_unref (multi);
 
@@ -470,13 +470,13 @@ test_multi_changes (void)
   model = gtk_sort_list_model_new (G_LIST_MODEL (new_store (1, 20, 1)), NULL);
   assert_model (model, "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20");
 
-  multi = gtk_multi_sorter_new ();
+  multi = GTK_SORTER (gtk_multi_sorter_new ());
   g_signal_connect (multi, "changed", G_CALLBACK (inc_counter), &counter);
   gtk_sort_list_model_set_sorter (model, multi);
   assert_model (model, "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20");
   g_assert_cmpint (counter, ==, 0);
 
-  sorter1 = gtk_numeric_sorter_new (NULL);
+  sorter1 = GTK_SORTER (gtk_numeric_sorter_new (NULL));
   gtk_multi_sorter_append (GTK_MULTI_SORTER (multi), sorter1);
   assert_model (model, "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20");
   g_assert_cmpint (counter, ==, 1);
@@ -491,7 +491,7 @@ test_multi_changes (void)
   assert_model (model, "4 9 14 19 3 8 13 18 2 7 12 17 1 6 11 16 5 10 15 20");
   g_assert_cmpint (counter, ==, 3);
 
-  sorter2 = gtk_custom_sorter_new (compare_even, NULL, NULL);
+  sorter2 = GTK_SORTER (gtk_custom_sorter_new (compare_even, NULL, NULL));
   gtk_multi_sorter_append (GTK_MULTI_SORTER (multi), sorter2);
   assert_model (model, "4 14 9 19 8 18 3 13 2 12 7 17 6 16 1 11 10 20 5 15");
   g_assert_cmpint (counter, ==, 4);
@@ -500,7 +500,7 @@ test_multi_changes (void)
   assert_model (model, "10 20 5 15 6 16 1 11 2 12 7 17 8 18 3 13 4 14 9 19");
   g_assert_cmpint (counter, ==, 5);
 
-  sorter3 = gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL, 0, NULL, (GCallback)get_spelled_out, NULL, NULL));
+  sorter3 = GTK_SORTER (gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL, 0, NULL, (GCallback)get_spelled_out, NULL, NULL)));
   gtk_multi_sorter_append (GTK_MULTI_SORTER (multi), sorter3);
   assert_model (model, "10 20 15 5 6 16 11 1 12 2 7 17 8 18 13 3 4 14 9 19");
   g_assert_cmpint (counter, ==, 6);
@@ -524,13 +524,13 @@ test_multi_changes (void)
 static GtkSorter *
 even_odd_sorter_new (void)
 {
-  return gtk_custom_sorter_new (compare_even, NULL, NULL);
+  return GTK_SORTER (gtk_custom_sorter_new (compare_even, NULL, NULL));
 }
 
 static GtkSorter *
 numeric_sorter_new (void)
 {
-  return gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_UINT, NULL, 0, NULL, (GCallback)get_number, NULL, NULL));
+  return GTK_SORTER (gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_UINT, NULL, 0, NULL, (GCallback)get_number, NULL, NULL)));
 }
 
 static void
@@ -615,8 +615,8 @@ test_stable (void)
   GtkSorter *multi, *a, *b;
   guint i;
 
-  a = gtk_multi_sorter_new ();
-  b = gtk_multi_sorter_new ();
+  a = GTK_SORTER (gtk_multi_sorter_new ());
+  b = GTK_SORTER (gtk_multi_sorter_new ());
   /* We create 2 setups:
    * 1. sortmodel (multisorter [a, b])
    * 2. sortmodel (b) => sortmodel (a)
@@ -627,7 +627,7 @@ test_stable (void)
    * All we do is make a and b random sorters and assert that the 2 setups
    * produce the same order every time.
    */
-  multi = gtk_multi_sorter_new ();
+  multi = GTK_SORTER (gtk_multi_sorter_new ());
   gtk_multi_sorter_append (GTK_MULTI_SORTER (multi), a);
   gtk_multi_sorter_append (GTK_MULTI_SORTER (multi), b);
   model1 = new_model (20, multi);

testsuite/gtk/sortlistmodel-exhaustive.c

@@ -252,12 +252,12 @@ create_sorter (gsize id)
   switch (id)
   {
     case 0:
-      return gtk_string_sorter_new (NULL);
+      return GTK_SORTER (gtk_string_sorter_new (NULL));
 
     case 1:
     case 2:
       /* match all As, Bs and nothing */
-      sorter = gtk_string_sorter_new (gtk_property_expression_new (GTK_TYPE_STRING_OBJECT, NULL, "string"));
+      sorter = GTK_SORTER (gtk_string_sorter_new (gtk_property_expression_new (GTK_TYPE_STRING_OBJECT, NULL, "string")));
       if (id == 1)
         gtk_string_sorter_set_ignore_case (GTK_STRING_SORTER (sorter), TRUE);
       return sorter;
@@ -304,7 +304,7 @@ test_two_sorters (gconstpointer model_id)
   model2 = create_sort_list_model (model_id, TRUE, source, NULL);
   /* can't track changes from a sortmodel, where the same items get reordered */
   model1 = create_sort_list_model (model_id, FALSE, G_LIST_MODEL (model2), NULL);
-  every = gtk_multi_sorter_new ();
+  every = GTK_SORTER (gtk_multi_sorter_new ());
   compare = create_sort_list_model (model_id, TRUE, source, every);
   g_object_unref (every);
   g_object_unref (source);

testsuite/gtk/sortlistmodel.c

@@ -219,7 +219,7 @@ new_model (gpointer model)
     {
       GtkSorter *sorter;
 
-      sorter = gtk_custom_sorter_new (compare, NULL, NULL);
+      sorter = GTK_SORTER (gtk_custom_sorter_new (compare, NULL, NULL));
       result = gtk_sort_list_model_new (g_object_ref (model), sorter);
     }
   else
@@ -312,7 +312,7 @@ test_set_sorter (void)
   assert_model (sort, "2 4 6 8 10");
   assert_changes (sort, "");
 
-  sorter = gtk_custom_sorter_new (compare_modulo, GUINT_TO_POINTER (5), NULL);
+  sorter = GTK_SORTER (gtk_custom_sorter_new (compare_modulo, GUINT_TO_POINTER (5), NULL));
   gtk_sort_list_model_set_sorter (sort, sorter);
   g_object_unref (sorter);
   assert_model (sort, "10 6 2 8 4");
@@ -322,7 +322,7 @@ test_set_sorter (void)
   assert_model (sort, "4 8 2 6 10");
   assert_changes (sort, "0-5+5");
 
-  sorter = gtk_custom_sorter_new (compare, NULL, NULL);
+  sorter = GTK_SORTER (gtk_custom_sorter_new (compare, NULL, NULL));
   gtk_sort_list_model_set_sorter (sort, sorter);
   g_object_unref (sorter);
   assert_model (sort, "2 4 6 8 10");
@@ -424,7 +424,7 @@ test_stability (void)
   assert_model (sort, "1 11 21 31");
   assert_changes (sort, "");
 
-  sorter = gtk_custom_sorter_new (compare_modulo, GUINT_TO_POINTER (5), NULL);
+  sorter = GTK_SORTER (gtk_custom_sorter_new (compare_modulo, GUINT_TO_POINTER (5), NULL));
   gtk_sort_list_model_set_sorter (sort, sorter);
   g_object_unref (sorter);
   assert_model (sort, "11 31 21 1");
@@ -467,7 +467,7 @@ test_incremental_remove (void)
 
   gtk_sort_list_model_set_model (model, G_LIST_MODEL (store));
 
-  sorter = gtk_custom_sorter_new (compare, NULL, NULL);
+  sorter = GTK_SORTER (gtk_custom_sorter_new (compare, NULL, NULL));
   gtk_sort_list_model_set_sorter (model, sorter);
   g_object_unref (sorter);
 

testsuite/gtk/treesorter.c

@@ -175,7 +175,7 @@ test_simple (void)
   model = new_model (3);
   assert_model (model, "1 2 21 3 31 32 321");
 
-  sorter = gtk_tree_list_row_sorter_new (NULL);
+  sorter = GTK_SORTER (gtk_tree_list_row_sorter_new (NULL));
   sort = gtk_sort_list_model_new (model, sorter);
   assert_model (sort, "1 2 21 3 31 32 321");
 
@@ -185,7 +185,7 @@ test_simple (void)
 static GtkSorter *
 new_numeric_sorter (void)
 {
-  return gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_UINT, NULL, 0, NULL, (GCallback)get_number, NULL, NULL));
+  return GTK_SORTER (gtk_numeric_sorter_new (gtk_cclosure_expression_new (G_TYPE_UINT, NULL, 0, NULL, (GCallback)get_number, NULL, NULL)));
 }
 
 static void
@@ -198,7 +198,7 @@ test_compare_total_order (void)
   model = new_model (3);
   assert_model (model, "1 2 21 3 31 32 321");
 
-  sorter = gtk_tree_list_row_sorter_new (new_numeric_sorter ());
+  sorter = GTK_SORTER (gtk_tree_list_row_sorter_new (new_numeric_sorter ()));
 
   n = g_list_model_get_n_items (model);
   for (i = 0; i < n; i++)
@@ -228,7 +228,7 @@ test_compare_no_order (void)
   model = new_model (3);
   assert_model (model, "1 2 21 3 31 32 321");
 
-  sorter = gtk_tree_list_row_sorter_new (NULL);
+  sorter = GTK_SORTER (gtk_tree_list_row_sorter_new (NULL));
 
   n = g_list_model_get_n_items (model);
   for (i = 0; i < n; i++)