filechooser: Use dropdown convenience api

No need to do things the hard way.

demos/gtk-demo/font_features.c

@@ -21,75 +21,7 @@
 #include "script-names.h"
 #include "language-names.h"
 
-/* {{{ ScriptLang object */
-
-G_DECLARE_FINAL_TYPE (ScriptLang, script_lang, SCRIPT, LANG, GObject)
-
-struct _ScriptLang
-{
-  GObject parent;
-
-  char *langname;
-  unsigned int script_index;
-  unsigned int lang_index;
-  hb_tag_t lang_tag;
-};
-
-struct _ScriptLangClass
-{
-  GObjectClass parent_class;
-};
-
-G_DEFINE_TYPE (ScriptLang, script_lang, G_TYPE_OBJECT)
-
-static void
-script_lang_init (ScriptLang *self)
-{
-}
-
-static void
-script_lang_finalize (GObject *object)
-{
-  ScriptLang *self = SCRIPT_LANG (object);
-
-  g_free (self->langname);
-
-  G_OBJECT_CLASS (script_lang_parent_class)->finalize (object);
-}
-
-static void
-script_lang_class_init (ScriptLangClass *class)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (class);
-
-  object_class->finalize = script_lang_finalize;
-}
-
-static ScriptLang *
-script_lang_new (const char   *langname,
-                 unsigned int  script_index,
-                 unsigned int  lang_index,
-                 hb_tag_t      lang_tag)
-{
-  ScriptLang *self;
-
-  self = g_object_new (script_lang_get_type (), NULL);
-
-  self->langname = g_strdup (langname);
-  self->script_index = script_index;
-  self->lang_index = lang_index;
-  self->lang_tag = lang_tag;
-
-  return self;
-}
-
-static char *
-script_lang_get_langname (ScriptLang *self)
-{
-  return g_strdup (self->langname);
-}
-
-/* }}} */
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
 
 #define MAKE_TAG(a,b,c,d) (unsigned int)(((a) << 24) | ((b) << 16) | ((c) <<  8) | (d))
 
@@ -163,10 +95,6 @@ demo_free (gpointer data)
   g_clear_pointer (&demo->axes, g_hash_table_unref);
   g_clear_pointer (&demo->text, g_free);
 
-  gtk_style_context_remove_provider_for_display (gdk_display_get_default (),
-                                                 GTK_STYLE_PROVIDER (demo->provider));
-  g_object_unref (demo->provider);
-
   g_free (demo);
 }
 
@@ -544,6 +472,8 @@ update_display (void)
   GString *s;
   char *text;
   gboolean has_feature;
+  GtkTreeIter iter;
+  GtkTreeModel *model;
   PangoFontDescription *desc;
   GList *l;
   PangoAttrList *attrs;
@@ -646,13 +576,14 @@ update_display (void)
 
   features = g_string_free (s, FALSE);
 
-  if (gtk_drop_down_get_selected (GTK_DROP_DOWN (demo->script_lang)) != 0)
+  if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (demo->script_lang), &iter))
     {
-      ScriptLang *selected;
+      hb_tag_t lang_tag;
 
-      selected = gtk_drop_down_get_selected_item (GTK_DROP_DOWN (demo->script_lang));
+      model = gtk_combo_box_get_model (GTK_COMBO_BOX (demo->script_lang));
+      gtk_tree_model_get (model, &iter, 3, &lang_tag, -1);
 
-      lang = pango_language_from_string (hb_language_to_string (hb_ot_tag_to_language (selected->lang_tag)));
+      lang = pango_language_from_string (hb_language_to_string (hb_ot_tag_to_language (lang_tag)));
     }
   else
     lang = NULL;
@@ -809,30 +740,40 @@ tag_pair_equal (gconstpointer a, gconstpointer b)
   return pair_a->script_tag == pair_b->script_tag && pair_a->lang_tag == pair_b->lang_tag;
 }
 
-
-static GtkOrdering
-script_sort (const void *item1,
-             const void *item2,
-             void       *data)
+static int
+script_sort_func (GtkTreeModel *model,
+                  GtkTreeIter  *a,
+                  GtkTreeIter  *b,
+                  gpointer      user_data)
 {
-  ScriptLang *a = (ScriptLang *)item1;
-  ScriptLang *b = (ScriptLang *)item2;
+  char *sa, *sb;
+  int ret;
 
-  return strcmp (a->langname, b->langname);
+  gtk_tree_model_get (model, a, 0, &sa, -1);
+  gtk_tree_model_get (model, b, 0, &sb, -1);
+
+  ret = strcmp (sa, sb);
+
+  g_free (sa);
+  g_free (sb);
+
+  return ret;
 }
 
 static void
 update_script_combo (void)
 {
-  GListStore *store;
-  GtkSortListModel *sortmodel;
+  GtkListStore *store;
   hb_font_t *hb_font;
+  int i, j, k;
   PangoFont *pango_font;
   GHashTable *tags;
   GHashTableIter iter;
   TagPair *pair;
   char *lang;
   hb_tag_t active;
+  GtkTreeIter active_iter;
+  gboolean have_active = FALSE;
 
   lang = gtk_font_chooser_get_language (GTK_FONT_CHOOSER (demo->font));
 
@@ -842,7 +783,7 @@ update_script_combo (void)
 
   g_free (lang);
 
-  store = g_list_store_new (script_lang_get_type ());
+  store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);
 
   pango_font = get_pango_font ();
   hb_font = pango_font_get_hb_font (pango_font);
@@ -866,19 +807,19 @@ update_script_combo (void)
 
       hb_face = hb_font_get_face (hb_font);
 
-      for (guint i = 0; i < 2; i++)
+      for (i= 0; i < 2; i++)
         {
           hb_tag_t scripts[80];
           unsigned int script_count = G_N_ELEMENTS (scripts);
 
           hb_ot_layout_table_get_script_tags (hb_face, tables[i], 0, &script_count, scripts);
-          for (guint j = 0; j < script_count; j++)
+          for (j = 0; j < script_count; j++)
             {
               hb_tag_t languages[80];
               unsigned int language_count = G_N_ELEMENTS (languages);
 
               hb_ot_layout_script_get_language_tags (hb_face, tables[i], j, 0, &language_count, languages);
-              for (guint k = 0; k < language_count; k++)
+              for (k = 0; k < language_count; k++)
                 {
                   pair = g_new (TagPair, 1);
                   pair->script_tag = scripts[j];
@@ -898,6 +839,7 @@ update_script_combo (void)
     {
       const char *langname;
       char langbuf[5];
+      GtkTreeIter tree_iter;
 
       if (pair->lang_tag == 0 && pair->script_tag == 0)
         langname = NC_("Language", "None");
@@ -914,31 +856,31 @@ update_script_combo (void)
             }
         }
 
-      g_list_store_append (store, script_lang_new (langname,
-                                                   pair->script_index,
-                                                   pair->lang_index,
-                                                   pair->lang_tag));
+      gtk_list_store_insert_with_values (store, &tree_iter, -1,
+                                         0, langname,
+                                         1, pair->script_index,
+                                         2, pair->lang_index,
+                                         3, pair->lang_tag,
+                                         -1);
+      if (pair->lang_tag == active)
+        {
+          have_active = TRUE;
+          active_iter = tree_iter;
+        }
     }
 
   g_hash_table_destroy (tags);
 
-  sortmodel = gtk_sort_list_model_new (G_LIST_MODEL (store),
-                                       GTK_SORTER (gtk_custom_sorter_new (script_sort, NULL, NULL)));
-  gtk_drop_down_set_model (GTK_DROP_DOWN (demo->script_lang), G_LIST_MODEL (sortmodel));
-
-  for (guint i = 0; i < g_list_model_get_n_items (G_LIST_MODEL (sortmodel)); i++)
-    {
-      ScriptLang *item = g_list_model_get_item (G_LIST_MODEL (sortmodel), i);
-      g_object_unref (item);
-
-      if (item->lang_tag == active)
-        {
-          gtk_drop_down_set_selected (GTK_DROP_DOWN (demo->script_lang), i);
-          break;
-        }
-    }
-
-  g_object_unref (sortmodel);
+  gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store),
+                                           script_sort_func, NULL, NULL);
+  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
+                                        GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
+                                        GTK_SORT_ASCENDING);
+  gtk_combo_box_set_model (GTK_COMBO_BOX (demo->script_lang), GTK_TREE_MODEL (store));
+  if (have_active)
+    gtk_combo_box_set_active_iter (GTK_COMBO_BOX (demo->script_lang), &active_iter);
+  else
+    gtk_combo_box_set_active_iter (GTK_COMBO_BOX (demo->script_lang), 0);
 }
 
 static char *
@@ -963,19 +905,27 @@ static void
 update_features (void)
 {
   int i, j;
+  GtkTreeModel *model;
+  GtkTreeIter iter;
+  guint script_index, lang_index;
+  hb_tag_t lang_tag;
   PangoFont *pango_font;
   hb_font_t *hb_font;
   GList *l;
-  ScriptLang *selected;
 
   /* set feature presence checks from the font features */
 
-  if (gtk_drop_down_get_selected (GTK_DROP_DOWN (demo->script_lang)) == 0)
+  if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (demo->script_lang), &iter))
     return;
 
-  selected = gtk_drop_down_get_selected_item (GTK_DROP_DOWN (demo->script_lang));
+  model = gtk_combo_box_get_model (GTK_COMBO_BOX (demo->script_lang));
+  gtk_tree_model_get (model, &iter,
+                      1, &script_index,
+                      2, &lang_index,
+                      3, &lang_tag,
+                      -1);
 
-  if (selected->lang_tag == 0) /* None is selected */
+  if (lang_tag == 0) /* None is selected */
     {
       for (l = demo->feature_items; l; l = l->next)
         {
@@ -1016,8 +966,8 @@ update_features (void)
 
           hb_ot_layout_language_get_feature_tags (hb_face,
                                                   tables[i],
-                                                  selected->script_index,
-                                                  selected->lang_index,
+                                                  script_index,
+                                                  lang_index,
                                                   0,
                                                   &count,
                                                   features);
@@ -1039,8 +989,8 @@ update_features (void)
 
                   hb_ot_layout_language_find_feature (hb_face,
                                                       tables[i],
-                                                      selected->script_index,
-                                                      selected->lang_index,
+                                                      script_index,
+                                                      lang_index,
                                                       features[j],
                                                       &feature_index);
 
@@ -1372,9 +1322,10 @@ free_instance (gpointer data)
 }
 
 static void
-add_instance (hb_face_t     *face,
-              unsigned int   index,
-              GtkStringList *strings)
+add_instance (hb_face_t    *face,
+              unsigned int  index,
+              GtkWidget    *combo,
+              int           pos)
 {
   Instance *instance;
   hb_ot_name_id_t name_id;
@@ -1390,20 +1341,20 @@ add_instance (hb_face_t     *face,
   instance->index = index;
 
   g_hash_table_add (demo->instances, instance);
-  gtk_string_list_append (GTK_STRING_LIST (strings), instance->name);
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), instance->name);
 }
 
 static void
 unset_instance (GtkAdjustment *adjustment)
 {
   if (demo->instance_combo)
-    gtk_drop_down_set_selected (GTK_DROP_DOWN (demo->instance_combo), 0);
+    gtk_combo_box_set_active (GTK_COMBO_BOX (demo->instance_combo), 0);
 }
 
 static void
-instance_changed (GtkDropDown *combo)
+instance_changed (GtkComboBox *combo)
 {
-  const char *text;
+  char *text;
   Instance *instance;
   Instance ikey;
   int i;
@@ -1415,12 +1366,11 @@ instance_changed (GtkDropDown *combo)
   hb_font_t *hb_font;
   hb_face_t *hb_face;
 
-  text = gtk_string_list_get_string (GTK_STRING_LIST (gtk_drop_down_get_model (combo)),
-                                     gtk_drop_down_get_selected (combo));
+  text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (combo));
   if (text[0] == '\0')
     goto out;
 
-  ikey.name = (char *) text;
+  ikey.name = text;
   instance = g_hash_table_lookup (demo->instances, &ikey);
   if (!instance)
     {
@@ -1461,6 +1411,7 @@ instance_changed (GtkDropDown *combo)
     }
 
 out:
+  g_free (text);
   g_clear_object (&pango_font);
   g_free (ai);
   g_free (coords);
@@ -1570,7 +1521,6 @@ update_font_variations (void)
     {
       GtkWidget *label;
       GtkWidget *combo;
-      GtkStringList *strings;
 
       label = gtk_label_new ("Instance");
       gtk_label_set_xalign (GTK_LABEL (label), 0);
@@ -1578,28 +1528,26 @@ update_font_variations (void)
       gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
       gtk_grid_attach (GTK_GRID (demo->variations_grid), label, 0, -1, 1, 1);
 
-      strings = gtk_string_list_new (NULL);
-      combo = gtk_drop_down_new (G_LIST_MODEL (strings), NULL);
-
+      combo = gtk_combo_box_text_new ();
       gtk_widget_set_halign (combo, GTK_ALIGN_START);
       gtk_widget_set_valign (combo, GTK_ALIGN_BASELINE);
 
-      gtk_string_list_append (strings, "");
+      gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "");
 
       for (i = 0; i < hb_ot_var_get_named_instance_count (hb_face); i++)
-        add_instance (hb_face, i, strings);
+        add_instance (hb_face, i, combo, i);
 
       for (i = 0; i < hb_ot_var_get_named_instance_count (hb_face); i++)
         {
           if (matches_instance (hb_face, i, n_axes, design_coords))
             {
-              gtk_drop_down_set_selected (GTK_DROP_DOWN (combo), i + 1);
+              gtk_combo_box_set_active (GTK_COMBO_BOX (combo), i + 1);
               break;
             }
         }
 
       gtk_grid_attach (GTK_GRID (demo->variations_grid), combo, 1, -1, 3, 1);
-      g_signal_connect (combo, "notify::selecte", G_CALLBACK (instance_changed), NULL);
+      g_signal_connect (combo, "changed", G_CALLBACK (instance_changed), NULL);
       demo->instance_combo = combo;
    }
 
@@ -1746,7 +1694,6 @@ do_font_features (GtkWidget *do_widget)
       GtkBuilder *builder;
       GtkBuilderScope *scope;
       GtkEventController *controller;
-      GtkExpression *expression;
 
       builder = gtk_builder_new ();
 
@@ -1780,9 +1727,6 @@ do_font_features (GtkWidget *do_widget)
       demo->description = GTK_WIDGET (gtk_builder_get_object (builder, "description"));
       demo->font = GTK_WIDGET (gtk_builder_get_object (builder, "font"));
       demo->script_lang = GTK_WIDGET (gtk_builder_get_object (builder, "script_lang"));
-      expression = gtk_cclosure_expression_new (G_TYPE_STRING, NULL, 0, NULL, G_CALLBACK (script_lang_get_langname), NULL, NULL);
-      gtk_drop_down_set_expression (GTK_DROP_DOWN (demo->script_lang), expression);
-      gtk_expression_unref (expression);
       demo->feature_list = GTK_WIDGET (gtk_builder_get_object (builder, "feature_list"));
       demo->stack = GTK_WIDGET (gtk_builder_get_object (builder, "stack"));
       demo->entry = GTK_WIDGET (gtk_builder_get_object (builder, "entry"));
@@ -1801,8 +1745,8 @@ do_font_features (GtkWidget *do_widget)
       demo->swin = GTK_WIDGET (gtk_builder_get_object (builder, "swin"));
 
       demo->provider = gtk_css_provider_new ();
-      gtk_style_context_add_provider_for_display (gdk_display_get_default (),
-                                                  GTK_STYLE_PROVIDER (demo->provider), 800);
+      gtk_style_context_add_provider (gtk_widget_get_style_context (demo->swin),
+                                      GTK_STYLE_PROVIDER (demo->provider), 800);
 
       basic_value_changed (demo->size_adjustment, demo->size_entry);
       basic_value_changed (demo->letterspacing_adjustment, demo->letterspacing_entry);
@@ -1880,5 +1824,3 @@ do_font_features (GtkWidget *do_widget)
 
   return window;
 }
-
-/* vim:set foldmethod=marker expandtab: */

demos/gtk-demo/font_features.ui

@@ -259,10 +259,16 @@
                           <object class="GtkBox" id="feature_list">
                             <property name="orientation">vertical</property>
                             <child>
-                              <object class="GtkDropDown" id="script_lang">
+                              <object class="GtkComboBox" id="script_lang">
                                 <property name="tooltip-text" translatable="yes">Language System</property>
                                 <property name="margin-top">10</property>
-                                <signal name="notify::selected" handler="font_features_script_changed" swapped="no"/>
+                                <signal name="changed" handler="font_features_script_changed" swapped="no"/>
+                                <child>
+                                  <object class="GtkCellRendererText"/>
+                                  <attributes>
+                                    <attribute name="text">0</attribute>
+                                  </attributes>
+                                </child>
                               </object>
                             </child>
                           </object>

examples/bp/bloatpad.c

@@ -360,7 +360,7 @@ combo_changed (GtkDropDown *combo,
   char **accels;
   char *str;
 
-  action = gtk_string_object_get_string (GTK_STRING_OBJECT (gtk_drop_down_get_selected_item (combo)));
+  action = gtk_drop_down_get_selected_string (combo);
 
   if (!action)
     return;
@@ -400,7 +400,7 @@ response (GtkDialog *dialog,
       return;
     }
 
-  action = gtk_string_object_get_string (GTK_STRING_OBJECT (gtk_drop_down_get_selected_item (combo)));
+  action = gtk_drop_down_get_selected_string (combo);
 
   if (!action)
     return;

gtk/gtkcolorchooser.h

@@ -83,32 +83,6 @@ void     gtk_color_chooser_add_palette    (GtkColorChooser *chooser,
                                            int              n_colors,
                                            GdkRGBA         *colors);
 
-
-typedef void (*GtkColorChooserPrepareCallback) (GtkColorChooser *chooser,
-                                                gpointer         user_data);
-
-GDK_AVAILABLE_IN_ALL
-void     gtk_choose_color                 (GtkWindow                      *parent,
-                                           const char                     *title,
-                                           GCancellable                   *cancellable,
-                                           GAsyncReadyCallback             callback,
-                                           gpointer                        user_data);
-
-GDK_AVAILABLE_IN_ALL
-void     gtk_choose_color_full            (GtkWindow                      *parent,
-                                           const char                     *title,
-                                           GtkColorChooserPrepareCallback  prepare,
-                                           gpointer                        prepare_data,
-                                           GCancellable                   *cancellable,
-                                           GAsyncReadyCallback             callback,
-                                           gpointer                        user_data);
-
-GDK_AVAILABLE_IN_ALL
-gboolean gtk_choose_color_finish          (GtkColorChooser                *chooser,
-                                           GAsyncResult                   *result,
-                                           GdkRGBA                        *color,
-                                           GError                        **error);
-
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkColorChooser, g_object_unref)
 
 G_END_DECLS

gtk/gtkcolorchooserwindow.c

@@ -1,439 +0,0 @@
-/* GTK - The GIMP Toolkit
- * Copyright (C) 2012 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "config.h"
-
-#include "gtkwindow.h"
-#include "gtkwindowprivate.h"
-#include "gtkbutton.h"
-#include "gtkbox.h"
-#include "gtkprivate.h"
-#include "gtksettings.h"
-
-#include "gtkcolorchooserprivate.h"
-#include "gtkcolorchooserwindowprivate.h"
-#include "gtkcolorchooserwidget.h"
-
-/*
- * GtkColorChooserWindow:
- *
- * A window for choosing a color.
- *
- * ![An example GtkColorChooserWindow](colorchooser.png)
- *
- * `GtkColorChooserWindow` implements the [iface@Gtk.ColorChooser] interface
- * and does not provide much API of its own.
- *
- * To create a `GtkColorChooserWindow`, use [ctor@Gtk.ColorChooserWindow.new].
- *
- * To change the initially selected color, use
- * [method@Gtk.ColorChooser.set_rgba]. To get the selected color use
- * [method@Gtk.ColorChooser.get_rgba].
- */
-
-typedef struct _GtkColorChooserWindowClass   GtkColorChooserWindowClass;
-
-struct _GtkColorChooserWindow
-{
-  GtkWindow parent_instance;
-
-  GtkWidget *chooser;
-};
-
-struct _GtkColorChooserWindowClass
-{
-  GtkWindowClass parent_class;
-};
-
-enum
-{
-  PROP_ZERO,
-  PROP_RGBA,
-  PROP_USE_ALPHA,
-  PROP_SHOW_EDITOR
-};
-
-static void gtk_color_chooser_window_iface_init (GtkColorChooserInterface *iface);
-
-G_DEFINE_TYPE_WITH_CODE (GtkColorChooserWindow, gtk_color_chooser_window, GTK_TYPE_WINDOW,
-                         G_IMPLEMENT_INTERFACE (GTK_TYPE_COLOR_CHOOSER,
-                                                gtk_color_chooser_window_iface_init))
-
-static void
-propagate_notify (GObject               *o,
-                  GParamSpec            *pspec,
-                  GtkColorChooserWindow *cc)
-{
-  g_object_notify (G_OBJECT (cc), pspec->name);
-}
-
-static void
-save_color (GtkColorChooserWindow *window)
-{
-  GdkRGBA color;
-
-  /* This causes the color chooser widget to save the
-   * selected and custom colors to GSettings.
-   */
-  gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (window), &color);
-  gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (window), &color);
-}
-
-enum
-{
-  RESPONSE_OK,
-  RESPONSE_CANCEL
-};
-
-static void
-response_cb (GtkWindow *window,
-             int        response);
-
-static void
-color_activated_cb (GtkColorChooser *chooser,
-                    GdkRGBA         *color,
-                    GtkWindow       *window)
-{
-  save_color (GTK_COLOR_CHOOSER_WINDOW (window));
-  response_cb (GTK_WINDOW (window), RESPONSE_OK);
-}
-
-static void
-ok_button_cb (GtkButton *button,
-              GtkWindow *window)
-{
-  response_cb (window, RESPONSE_OK);
-}
-
-static void
-cancel_button_cb (GtkButton *button,
-                  GtkWindow *window)
-{
-  response_cb (window, RESPONSE_CANCEL);
-}
-
-static void
-gtk_color_chooser_window_init (GtkColorChooserWindow *cc)
-{
-  gtk_widget_init_template (GTK_WIDGET (cc));
-}
-
-static void
-gtk_color_chooser_window_unmap (GtkWidget *widget)
-{
-  GTK_WIDGET_CLASS (gtk_color_chooser_window_parent_class)->unmap (widget);
-
-  /* We never want the window to come up with the editor,
-   * even if it was showing the editor the last time it was used.
-   */
-  g_object_set (widget, "show-editor", FALSE, NULL);
-}
-
-static void
-gtk_color_chooser_window_get_property (GObject    *object,
-                                       guint       prop_id,
-                                       GValue     *value,
-                                       GParamSpec *pspec)
-{
-  GtkColorChooserWindow *cc = GTK_COLOR_CHOOSER_WINDOW (object);
-
-  switch (prop_id)
-    {
-    case PROP_RGBA:
-      {
-        GdkRGBA color;
-
-        gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (cc), &color);
-        g_value_set_boxed (value, &color);
-      }
-      break;
-    case PROP_USE_ALPHA:
-      g_value_set_boolean (value, gtk_color_chooser_get_use_alpha (GTK_COLOR_CHOOSER (cc->chooser)));
-      break;
-    case PROP_SHOW_EDITOR:
-      {
-        gboolean show_editor;
-        g_object_get (cc->chooser, "show-editor", &show_editor, NULL);
-        g_value_set_boolean (value, show_editor);
-      }
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-gtk_color_chooser_window_set_property (GObject      *object,
-                                       guint         prop_id,
-                                       const GValue *value,
-                                       GParamSpec   *pspec)
-{
-  GtkColorChooserWindow *cc = GTK_COLOR_CHOOSER_WINDOW (object);
-
-  switch (prop_id)
-    {
-    case PROP_RGBA:
-      gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (cc), g_value_get_boxed (value));
-      break;
-    case PROP_USE_ALPHA:
-      if (gtk_color_chooser_get_use_alpha (GTK_COLOR_CHOOSER (cc->chooser)) != g_value_get_boolean (value))
-        {
-          gtk_color_chooser_set_use_alpha (GTK_COLOR_CHOOSER (cc->chooser), g_value_get_boolean (value));
-          g_object_notify_by_pspec (object, pspec);
-        }
-      break;
-    case PROP_SHOW_EDITOR:
-      g_object_set (cc->chooser,
-                    "show-editor", g_value_get_boolean (value),
-                    NULL);
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-gtk_color_chooser_window_dispose (GObject *object)
-{
-  GtkColorChooserWindow *cc = GTK_COLOR_CHOOSER_WINDOW (object);
-
-  g_clear_pointer (&cc->chooser, gtk_widget_unparent);
-
-  G_OBJECT_CLASS (gtk_color_chooser_window_parent_class)->dispose (object);
-}
-
-static void
-gtk_color_chooser_window_class_init (GtkColorChooserWindowClass *class)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (class);
-  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
-
-  object_class->dispose = gtk_color_chooser_window_dispose;
-  object_class->get_property = gtk_color_chooser_window_get_property;
-  object_class->set_property = gtk_color_chooser_window_set_property;
-
-  widget_class->unmap = gtk_color_chooser_window_unmap;
-
-  g_object_class_override_property (object_class, PROP_RGBA, "rgba");
-  g_object_class_override_property (object_class, PROP_USE_ALPHA, "use-alpha");
-  g_object_class_install_property (object_class, PROP_SHOW_EDITOR,
-      g_param_spec_boolean ("show-editor", NULL, NULL,
-                            FALSE, GTK_PARAM_READWRITE));
-
-  /* Bind class to template
-   */
-  gtk_widget_class_set_template_from_resource (widget_class,
-                                               "/org/gtk/libgtk/ui/gtkcolorchooserwindow.ui");
-  gtk_widget_class_bind_template_child (widget_class, GtkColorChooserWindow, chooser);
-  gtk_widget_class_bind_template_callback (widget_class, propagate_notify);
-  gtk_widget_class_bind_template_callback (widget_class, color_activated_cb);
-  gtk_widget_class_bind_template_callback (widget_class, ok_button_cb);
-  gtk_widget_class_bind_template_callback (widget_class, cancel_button_cb);
-}
-
-static void
-gtk_color_chooser_window_get_rgba (GtkColorChooser *chooser,
-                                   GdkRGBA         *color)
-{
-  GtkColorChooserWindow *cc = GTK_COLOR_CHOOSER_WINDOW (chooser);
-
-  gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (cc->chooser), color);
-}
-
-static void
-gtk_color_chooser_window_set_rgba (GtkColorChooser *chooser,
-                                   const GdkRGBA   *color)
-{
-  GtkColorChooserWindow *cc = GTK_COLOR_CHOOSER_WINDOW (chooser);
-
-  gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (cc->chooser), color);
-}
-
-static void
-gtk_color_chooser_window_add_palette (GtkColorChooser *chooser,
-                                      GtkOrientation   orientation,
-                                      int              colors_per_line,
-                                      int              n_colors,
-                                      GdkRGBA         *colors)
-{
-  GtkColorChooserWindow *cc = GTK_COLOR_CHOOSER_WINDOW (chooser);
-
-  gtk_color_chooser_add_palette (GTK_COLOR_CHOOSER (cc->chooser),
-                                 orientation, colors_per_line, n_colors, colors);
-}
-
-static void
-gtk_color_chooser_window_iface_init (GtkColorChooserInterface *iface)
-{
-  iface->get_rgba = gtk_color_chooser_window_get_rgba;
-  iface->set_rgba = gtk_color_chooser_window_set_rgba;
-  iface->add_palette = gtk_color_chooser_window_add_palette;
-}
-
-/*
- * gtk_color_chooser_window_new:
- * @title: (nullable): Title of the window
- * @parent: (nullable): Transient parent of the window
- *
- * Creates a new `GtkColorChooserWindow`.
- *
- * Returns: a new `GtkColorChooserWindow`
- */
-GtkWidget *
-gtk_color_chooser_window_new (const char *title,
-                              GtkWindow   *parent)
-{
-  return g_object_new (GTK_TYPE_COLOR_CHOOSER_WINDOW,
-                       "title", title,
-                       "transient-for", parent,
-                       NULL);
-}
-
-static void
-cancelled_cb (GCancellable *cancellable,
-              GtkWindow    *window)
-{
-  response_cb (window, RESPONSE_CANCEL);
-}
-
-static void
-response_cb (GtkWindow *window,
-             int        response)
-{
-  GTask *task = G_TASK (g_object_get_data (G_OBJECT (window), "task"));
-  GCancellable *cancellable = g_task_get_cancellable (task);
-
-  if (cancellable)
-    g_signal_handlers_disconnect_by_func (cancellable, cancelled_cb, window);
-
-  if (response == RESPONSE_OK)
-    {
-      save_color (GTK_COLOR_CHOOSER_WINDOW (window));
-      g_task_return_boolean (task, TRUE);
-    }
-  else
-    g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_CANCELLED, "Cancelled");
-
-  g_object_unref (task);
-  gtk_window_destroy (GTK_WINDOW (window));
-}
-
-/**
- * gtk_choose_color:
- * @parent: (nullable): parent window
- * @title: title for the color chooser
- * @cancellable: (nullable): a `GCancellable` to cancel the operation
- * @callback: (scope async): callback to call when the action is complete
- * @user_data: (closure callback): data to pass to @callback
- *
- * This function presents a color chooser to let the user
- * pick a color.
- *
- * The @callback will be called when the window is closed.
- * It should call [function@Gtk.choose_color_finish] to
- * find out whether the operation was completed successfully,
- * and to obtain the resulting color.
- */
-void
-gtk_choose_color (GtkWindow           *parent,
-                  const char          *title,
-                  GCancellable        *cancellable,
-                  GAsyncReadyCallback  callback,
-                  gpointer             user_data)
-{
-  gtk_choose_color_full (parent, title, NULL, NULL, cancellable, callback, user_data);
-}
-
-/**
- * gtk_choose_color_full:
- * @parent: (nullable): parent window
- * @title: title for the color chooser
- * @prepare: (nullable) (scope call): callback to set up the color chooser
- * @prepare_data: (closure prepare): data to pass to @prepare
- * @cancellable: (nullable): a `GCancellable` to cancel the operation
- * @callback: (scope async): callback to call when the action is complete
- * @user_data: (closure callback): data to pass to @callback
- *
- * This function presents a color chooser to let the user
- * pick a color.
- *
- * In addition to [function@Gtk.choose_color], this function takes
- * a @prepare callback that lets you set up the color chooser according
- * to your needs.
- *
- * The @callback will be called when the window is closed.
- * It should call [function@Gtk.choose_color_finish] to
- * find out whether the operation was completed successfully,
- * and to obtain the resulting color.
- */
-void
-gtk_choose_color_full (GtkWindow                      *parent,
-                       const char                     *title,
-                       GtkColorChooserPrepareCallback  prepare,
-                       gpointer                        prepare_data,
-                       GCancellable                   *cancellable,
-                       GAsyncReadyCallback             callback,
-                       gpointer                        user_data)
-{
-  GtkWidget *window;
-  GTask *task;
-
-  window = gtk_color_chooser_window_new (title, parent);
-  if (prepare)
-    prepare (GTK_COLOR_CHOOSER (window), prepare);
-
-  if (cancellable)
-    g_signal_connect (cancellable, "cancelled", G_CALLBACK (cancelled_cb), window);
-
-  task = g_task_new (window, cancellable, callback, user_data);
-  g_task_set_source_tag (task, gtk_choose_color_full);
-
-  g_object_set_data (G_OBJECT (window), "task", task);
-
-  gtk_window_present (GTK_WINDOW (window));
-}
-
-/**
- * gtk_choose_color_finish:
- * @chooser: the `GtkColorChooser`
- * @result: `GAsyncResult` that was passed to @callback
- * @color: return location for the color
- * @error: return location for an error
- *
- * Finishes a gtk_choose_color() or gtk_choose_color_full() call
- * and returns the results.
- *
- * If this function returns `TRUE`, @color contains
- * the color that was chosen.
- *
- * Returns: `TRUE` if the operation was successful
- */
-gboolean
-gtk_choose_color_finish (GtkColorChooser  *chooser,
-                         GAsyncResult     *result,
-                         GdkRGBA          *color,
-                         GError          **error)
-{
-  if (!g_task_propagate_boolean (G_TASK (result), error))
-    return FALSE;
-
-  gtk_color_chooser_get_rgba (chooser, color);
-
-  return TRUE;
-}

gtk/gtkcolorchooserwindowprivate.h

@@ -1,46 +0,0 @@
-/* GTK - The GIMP Toolkit
- * Copyright (C) 2012 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __GTK_COLOR_CHOOSER_WINDOW_PRIVATE_H___
-#define __GTK_COLOR_CHOOSER_WINDOW_PRIVATE_H__
-
-#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
-#error "Only <gtk/gtk.h> can be included directly."
-#endif
-
-#include <gtk/gtkwindow.h>
-
-G_BEGIN_DECLS
-
-#define GTK_TYPE_COLOR_CHOOSER_WINDOW              (gtk_color_chooser_window_get_type ())
-#define GTK_COLOR_CHOOSER_WINDOW(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COLOR_CHOOSER_WINDOW, GtkColorChooserWindow))
-#define GTK_IS_COLOR_CHOOSER_WINDOW(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COLOR_CHOOSER_WINDOW))
-
-typedef struct _GtkColorChooserWindow        GtkColorChooserWindow;
-
-GDK_AVAILABLE_IN_ALL
-GType       gtk_color_chooser_window_get_type (void) G_GNUC_CONST;
-
-GDK_AVAILABLE_IN_ALL
-GtkWidget * gtk_color_chooser_window_new      (const char *title,
-                                               GtkWindow   *parent);
-
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkColorChooserWindow, g_object_unref)
-
-G_END_DECLS
-
-#endif /* __GTK_COLOR_CHOOSER_WINDOW_PRIVATE_H__ */

gtk/gtkdropdown.c

@@ -133,6 +133,7 @@ enum
   PROP_MODEL,
   PROP_SELECTED,
   PROP_SELECTED_ITEM,
+  PROP_SELECTED_STRING,
   PROP_ENABLE_SEARCH,
   PROP_EXPRESSION,
   PROP_SHOW_ARROW,
@@ -247,6 +248,7 @@ selection_item_changed (GtkSingleSelection *selection,
     }
 
   g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SELECTED_ITEM]);
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SELECTED_STRING]);
 }
 
 static void
@@ -358,6 +360,10 @@ gtk_drop_down_get_property (GObject    *object,
       g_value_set_object (value, gtk_drop_down_get_selected_item (self));
       break;
 
+    case PROP_SELECTED_STRING:
+      g_value_set_string (value, gtk_drop_down_get_selected_string (self));
+      break;
+
     case PROP_ENABLE_SEARCH:
       g_value_set_boolean (value, self->enable_search);
       break;
@@ -402,6 +408,10 @@ gtk_drop_down_set_property (GObject      *object,
       gtk_drop_down_set_selected (self, g_value_get_uint (value));
       break;
 
+    case PROP_SELECTED_STRING:
+      gtk_drop_down_set_selected_string (self, g_value_get_string (value));
+      break;
+
     case PROP_ENABLE_SEARCH:
       gtk_drop_down_set_enable_search (self, g_value_get_boolean (value));
       break;
@@ -545,6 +555,22 @@ gtk_drop_down_class_init (GtkDropDownClass *klass)
                        G_TYPE_OBJECT,
                        G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 
+  /**
+   * GtkDropDown:selected-string: (attributes org.gtk.Property.get=gtk_drop_down_get_selected_string org.gtk.Property.set=gtk_drop_down_set_selected_string)
+   *
+   * The value of the string property of the selected item,
+   * if it is a [class@Gtk.StringObject].
+   *
+   * This is only useful for dropdowns with a [class@Gtk.StringList] as model,
+   * such as those created by [ctor@Gtk.DropDown.new_from_strings].
+   *
+   * Since: 4.10
+   */
+  properties[PROP_SELECTED_STRING] =
+    g_param_spec_string ("selected-string", NULL, NULL,
+                         NULL,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
   /**
    * GtkDropDown:enable-search: (attributes org.gtk.Property.get=gtk_drop_down_get_enable_search org.gtk.Property.set=gtk_drop_down_set_enable_search)
    *
@@ -784,8 +810,7 @@ gtk_drop_down_new (GListModel    *model,
  * gtk_drop_down_new_from_strings:
  * @strings: (array zero-terminated=1): The strings to put in the dropdown
  *
- * Creates a new `GtkDropDown` that is populated with
- * the strings.
+ * Creates a new `GtkDropDown` that is populated with the strings.
  *
  * Returns: a new `GtkDropDown`
  */
@@ -1016,6 +1041,81 @@ gtk_drop_down_get_selected_item (GtkDropDown *self)
   return gtk_single_selection_get_selected_item (GTK_SINGLE_SELECTION (self->selection));
 }
 
+/**
+ * gtk_drop_down_get_selected_string: (attributes org.gtk.Method.get_property=selected-string)
+ * @self: a `GtkDropDown`
+ *
+ * Gets the string value for the selected [class@Gtk.StringObject].
+ *
+ * If no item is selected, or items are of another type, %NULL is returned.
+ *
+ * This function is meant for dropdowns with a [class@Gtk.StringList] as model,
+ * such as those created by [ctor@Gtk.DropDown.new_from_strings].
+ *
+ * Returns: (transfer none) (nullable): The string value for selected item
+ *
+ * Since: 4.10
+ */
+const char *
+gtk_drop_down_get_selected_string (GtkDropDown *self)
+{
+  gpointer item;
+
+  g_return_val_if_fail (GTK_IS_DROP_DOWN (self), NULL);
+
+  if (self->selection == NULL)
+    return NULL;
+
+  item = gtk_single_selection_get_selected_item (GTK_SINGLE_SELECTION (self->selection));
+
+  if (GTK_IS_STRING_OBJECT (item))
+    return gtk_string_object_get_string (GTK_STRING_OBJECT (item));
+
+  return NULL;
+}
+
+/**
+ * gtk_drop_down_set_selected_string:
+ * @self: a `GtkDropDown`
+ * @string: the string to select
+ *
+ * Selects the first [class@Gtk.StringObject] whose string property
+ * matches @string.
+ *
+ * If items are not `GtkStringObjects`, the selection is not changed.
+ *
+ * This function is meant for dropdowns with a [class@Gtk.StringList] as model,
+ * such as those created by [ctor@Gtk.DropDown.new_from_strings].
+ *
+ * Since: 4.10
+ */
+void
+gtk_drop_down_set_selected_string (GtkDropDown *self,
+                                   const char  *string)
+{
+  g_return_if_fail (GTK_IS_DROP_DOWN (self));
+  g_return_if_fail (string != NULL);
+
+  if (self->selection == NULL)
+    return;
+
+  for (guint i = 0; i < g_list_model_get_n_items (G_LIST_MODEL (self->selection)); i++)
+    {
+      gpointer item = g_list_model_get_item (G_LIST_MODEL (self->selection), i);
+
+      g_object_unref (item);
+
+      if (!GTK_IS_STRING_OBJECT (item))
+        break;
+
+      if (g_str_equal (gtk_string_object_get_string (GTK_STRING_OBJECT (item)), string))
+        {
+          gtk_single_selection_set_selected (GTK_SINGLE_SELECTION (self->selection), i);
+          break;
+        }
+    }
+}
+
 /**
  * gtk_drop_down_set_enable_search: (attributes org.gtk.Method.set_property=enable-search)
  * @self: a `GtkDropDown`

gtk/gtkdropdown.h

@@ -52,6 +52,13 @@ guint           gtk_drop_down_get_selected                      (GtkDropDown
 GDK_AVAILABLE_IN_ALL
 gpointer        gtk_drop_down_get_selected_item                 (GtkDropDown            *self);
 
+GDK_AVAILABLE_IN_4_10
+const char *    gtk_drop_down_get_selected_string               (GtkDropDown            *self);
+
+GDK_AVAILABLE_IN_4_10
+void            gtk_drop_down_set_selected_string               (GtkDropDown            *self,
+                                                                 const char             *string);
+
 GDK_AVAILABLE_IN_ALL
 void            gtk_drop_down_set_factory                       (GtkDropDown            *self,
                                                                  GtkListItemFactory     *factory);

gtk/gtkfilechooser.h

@@ -183,34 +183,6 @@ GDK_AVAILABLE_IN_ALL
 const char *         gtk_file_chooser_get_choice           (GtkFileChooser      *chooser,
                                                             const char          *id);
 
-
-typedef void (*GtkFileChooserPrepareCallback) (GtkFileChooser  *chooser,
-                                               gpointer         user_data);
-
-GDK_AVAILABLE_IN_ALL
-void     gtk_choose_file                  (GtkWindow                      *parent,
-                                           const char                     *title,
-                                           GtkFileChooserAction            action,
-                                           GCancellable                   *cancellable,
-                                           GAsyncReadyCallback             callback,
-                                           gpointer                        user_data);
-
-GDK_AVAILABLE_IN_ALL
-void     gtk_choose_file_full             (GtkWindow                      *parent,
-                                           const char                     *title,
-                                           GtkFileChooserAction            action,
-                                           GtkFileChooserPrepareCallback   prepare,
-                                           gpointer                        prepare_data,
-                                           GCancellable                   *cancellable,
-                                           GAsyncReadyCallback             callback,
-                                           gpointer                        user_data);
-
-GDK_AVAILABLE_IN_ALL
-gboolean gtk_choose_file_finish           (GtkFileChooser                 *chooser,
-                                           GAsyncResult                   *result,
-                                           GError                        **error);
-
-
 G_END_DECLS
 
 #endif /* __GTK_FILE_CHOOSER_H__ */

gtk/gtkfilechooserdialog.c

@@ -735,140 +735,3 @@ gtk_file_chooser_dialog_new (const char           *title,
 
   return result;
 }
-
-
-static void
-cancelled_cb (GCancellable *cancellable,
-              GtkDialog    *dialog)
-{
-  gtk_dialog_response (dialog, GTK_RESPONSE_CANCEL);
-}
-
-static void
-choose_response_cb (GtkDialog *dialog,
-                    int        response,
-                    GTask     *task)
-{
-  GCancellable *cancellable = g_task_get_cancellable (task);
-
-  if (cancellable)
-    g_signal_handlers_disconnect_by_func (cancellable, cancelled_cb, dialog);
-
-  if (response == GTK_RESPONSE_OK)
-    g_task_return_boolean (task, TRUE);
-  else
-    g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_CANCELLED, "Cancelled");
-
-  g_object_unref (task);
-  gtk_window_destroy (GTK_WINDOW (dialog));
-}
-
-/**
- * gtk_choose_file:
- * @parent: (nullable): parent window
- * @title: title for the font chooser
- * @action: the action for the file chooser
- * @cancellable: (nullable): a `GCancellable` to cancel the operation
- * @callback: (scope async): callback to call when the action is complete
- * @user_data: (closure callback): data to pass to @callback
- *
- * This function presents a file chooser to let the user
- * pick a file.
- *
- * The @callback will be called when the dialog is closed.
- * It should call [function@Gtk.choose_file_finish] to
- * find out whether the operation was completed successfully,
- * and use [class@Gtk.FileChooser] API to obtain the results.
- */
-void
-gtk_choose_file (GtkWindow            *parent,
-                 const char           *title,
-                 GtkFileChooserAction  action,
-                 GCancellable         *cancellable,
-                 GAsyncReadyCallback   callback,
-                 gpointer              user_data)
-{
-  gtk_choose_file_full (parent, title, action, NULL, NULL, cancellable, callback, user_data);
-}
-
-/**
- * gtk_choose_file_full:
- * @parent: (nullable): parent window
- * @title: title for the file chooser
- * @action: the action for the file chooser
- * @prepare: (nullable) (scope call): callback to set up the file chooser
- * @prepare_data: (closure prepare): data to pass to @prepare
- * @cancellable: (nullable): a `GCancellable` to cancel the operation
- * @callback: (scope async): callback to call when the action is complete
- * @user_data: (closure callback): data to pass to @callback
- *
- * This function presents a file chooser to let the user
- * choose a file.
- *
- * In addition to [function@Gtk.choose_file], this function takes
- * a @prepare callback that lets you set up the file chooser according
- * to your needs.
- *
- * The @callback will be called when the dialog is closed.
- * It should use [function@Gtk.choose_file_finish] to find
- * out whether the operation was completed successfully,
- * and use [class@Gtk.FileChooser] API to obtain the results.
- */
-void
-gtk_choose_file_full (GtkWindow                      *parent,
-                      const char                     *title,
-                      GtkFileChooserAction            action,
-                      GtkFileChooserPrepareCallback   prepare,
-                      gpointer                        prepare_data,
-                      GCancellable                   *cancellable,
-                      GAsyncReadyCallback             callback,
-                      gpointer                        user_data)
-{
-  GtkWidget *dialog;
-  GTask *task;
-  const char *button[] = {
-    N_("_Open"),
-    N_("_Save"),
-    N_("_Select")
-  };
-
-  dialog = gtk_file_chooser_dialog_new (title, parent, action,
-                                        _("_Cancel"), GTK_RESPONSE_CANCEL,
-                                        _(button[action]), GTK_RESPONSE_OK,
-                                        NULL);
-
-  if (prepare)
-    prepare (GTK_FILE_CHOOSER (dialog), prepare);
-
-  if (cancellable)
-    g_signal_connect (cancellable, "cancelled", G_CALLBACK (cancelled_cb), dialog);
-
-  task = g_task_new (dialog, cancellable, callback, user_data);
-  g_task_set_source_tag (task, gtk_choose_file_full);
-
-  g_signal_connect (dialog, "response", G_CALLBACK (choose_response_cb), task);
-
-  gtk_window_present (GTK_WINDOW (dialog));
-}
-
-/**
- * gtk_choose_file_finish:
- * @chooser: the `GtkFileChooser`
- * @result: `GAsyncResult` that was passed to @callback
- * @error: return location for an error
- *
- * Finishes a gtk_choose_file() or gtk_choose_file_full() call
- * and returns whether the operation was successful.
- *
- * If this function returns `TRUE`, you can use
- * [class@Gtk.FileChooser] API to get the results.
- *
- * Returns: `TRUE` if the operation was successful
- */
-gboolean
-gtk_choose_file_finish (GtkFileChooser  *chooser,
-                        GAsyncResult     *result,
-                        GError          **error)
-{
-  return g_task_propagate_boolean (G_TASK (result), error);
-}

gtk/gtkfilechooserwidget.c

@@ -7338,8 +7338,6 @@ gtk_file_chooser_widget_add_choice (GtkFileChooser  *chooser,
       gtk_box_append (GTK_BOX (box), gtk_label_new (label));
 
       combo = gtk_drop_down_new_from_strings ((const char * const *)option_labels);
-      g_object_set_data_full (G_OBJECT (combo), "options",
-                              g_strdupv ((char **)options), (GDestroyNotify)g_strfreev);
       g_hash_table_insert (impl->choices, g_strdup (id), combo);
       gtk_box_append (GTK_BOX (box), combo);
 
@@ -7396,21 +7394,8 @@ gtk_file_chooser_widget_set_choice (GtkFileChooser  *chooser,
 
   if (GTK_IS_BOX (widget))
     {
-      guint i;
-      const char **options;
-      GtkWidget *dropdown;
-
-      dropdown = gtk_widget_get_last_child (widget);
-
-      options = (const char **) g_object_get_data (G_OBJECT (dropdown), "options");
-      for (i = 0; options[i]; i++)
-        {
-          if (strcmp (option, options[i]) == 0)
-            {
-              gtk_drop_down_set_selected (GTK_DROP_DOWN (dropdown), i);
-              break;
-            }
-        }
+      GtkWidget *dropdown = gtk_widget_get_last_child (widget);
+      gtk_drop_down_set_selected_string (GTK_DROP_DOWN (dropdown), option);
     }
   else if (GTK_IS_CHECK_BUTTON (widget))
     gtk_check_button_set_active (GTK_CHECK_BUTTON (widget), g_str_equal (option, "true"));
@@ -7428,19 +7413,9 @@ gtk_file_chooser_widget_get_choice (GtkFileChooser  *chooser,
 
   widget = (GtkWidget *)g_hash_table_lookup (impl->choices, id);
   if (GTK_IS_DROP_DOWN (widget))
-    {
-      const char **options;
-      guint selected;
-
-      options = (const char **) g_object_get_data (G_OBJECT (widget), "options");
-      selected = gtk_drop_down_get_selected (GTK_DROP_DOWN (widget));
-
-      return options[selected];
-    }
+    return gtk_drop_down_get_selected_string (GTK_DROP_DOWN (widget));
   else if (GTK_IS_CHECK_BUTTON (widget))
-    {
-      return gtk_check_button_get_active (GTK_CHECK_BUTTON (widget)) ? "true" : "false";
-    }
+    return gtk_check_button_get_active (GTK_CHECK_BUTTON (widget)) ? "true" : "false";
 
   return NULL;
 }

gtk/gtkfontchooser.h

@@ -161,31 +161,6 @@ GDK_AVAILABLE_IN_ALL
 void             gtk_font_chooser_set_language             (GtkFontChooser   *fontchooser,
                                                             const char       *language);
 
-typedef void (*GtkFontChooserPrepareCallback) (GtkFontChooser  *chooser,
-                                               gpointer         user_data);
-
-GDK_AVAILABLE_IN_ALL
-void     gtk_choose_font                  (GtkWindow                      *parent,
-                                           const char                     *title,
-                                           GCancellable                   *cancellable,
-                                           GAsyncReadyCallback             callback,
-                                           gpointer                        user_data);
-
-GDK_AVAILABLE_IN_ALL
-void     gtk_choose_font_full             (GtkWindow                      *parent,
-                                           const char                     *title,
-                                           GtkFontChooserPrepareCallback   prepare,
-                                           gpointer                        prepare_data,
-                                           GCancellable                   *cancellable,
-                                           GAsyncReadyCallback             callback,
-                                           gpointer                        user_data);
-
-GDK_AVAILABLE_IN_ALL
-gboolean gtk_choose_font_finish           (GtkFontChooser                 *chooser,
-                                           GAsyncResult                   *result,
-                                           GError                        **error);
-
-
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkFontChooser, g_object_unref)
 
 G_END_DECLS

gtk/gtkfontchooserdialog.c

@@ -324,127 +324,3 @@ gtk_font_chooser_dialog_buildable_get_internal_child (GtkBuildable *buildable,
 
   return parent_buildable_iface->get_internal_child (buildable, builder, childname);
 }
-
-
-static void
-cancelled_cb (GCancellable *cancellable,
-              GtkDialog    *dialog)
-{
-  gtk_dialog_response (dialog, GTK_RESPONSE_CANCEL);
-}
-
-static void
-response_cb (GtkDialog *dialog,
-             int        response,
-             GTask     *task)
-{
-  GCancellable *cancellable = g_task_get_cancellable (task);
-
-  if (cancellable)
-    g_signal_handlers_disconnect_by_func (cancellable, cancelled_cb, dialog);
-
-  if (response == GTK_RESPONSE_OK)
-    g_task_return_boolean (task, TRUE);
-  else
-    g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_CANCELLED, "Cancelled");
-
-  g_object_unref (task);
-  gtk_window_destroy (GTK_WINDOW (dialog));
-}
-
-/**
- * gtk_choose_font:
- * @parent: (nullable): parent window
- * @title: title for the font chooser
- * @cancellable: (nullable): a `GCancellable` to cancel the operation
- * @callback: (scope async): callback to call when the action is complete
- * @user_data: (closure callback): data to pass to @callback
- *
- * This function presents a font chooser to let the user
- * pick a font.
- *
- * The @callback will be called when the dialog is closed.
- * It should call [function@Gtk.choose_font_finish] to
- * find out whether the operation was completed successfully,
- * and use [class@Gtk.FontChooser] API to obtain the results.
- */
-void
-gtk_choose_font (GtkWindow           *parent,
-                 const char          *title,
-                 GCancellable        *cancellable,
-                 GAsyncReadyCallback  callback,
-                 gpointer             user_data)
-{
-  gtk_choose_font_full (parent, title, NULL, NULL, cancellable, callback, user_data);
-}
-
-/**
- * gtk_choose_font_full:
- * @parent: (nullable): parent window
- * @title: title for the font chooser
- * @prepare: (nullable) (scope call): callback to set up the font chooser
- * @prepare_data: (closure prepare): data to pass to @prepare
- * @cancellable: (nullable): a `GCancellable` to cancel the operation
- * @callback: (scope async): callback to call when the action is complete
- * @user_data: (closure callback): data to pass to @callback
- *
- * This function presents a font chooser to let the user
- * choose a font.
- *
- * In addition to [function@Gtk.choose_font], this function takes
- * a @prepare callback that lets you set up the font chooser according
- * to your needs.
- *
- * The @callback will be called when the dialog is closed.
- * It should use [function@Gtk.choose_font_finish] to find
- * out whether the operation was completed successfully,
- * and use [class@Gtk.FontChooser] API to obtain the results.
- */
-void
-gtk_choose_font_full (GtkWindow                      *parent,
-                      const char                     *title,
-                      GtkFontChooserPrepareCallback   prepare,
-                      gpointer                        prepare_data,
-                      GCancellable                   *cancellable,
-                      GAsyncReadyCallback             callback,
-                      gpointer                        user_data)
-{
-  GtkWidget *dialog;
-  GTask *task;
-
-  dialog = gtk_font_chooser_dialog_new (title, parent);
-  if (prepare)
-    prepare (GTK_FONT_CHOOSER (dialog), prepare);
-
-  if (cancellable)
-    g_signal_connect (cancellable, "cancelled", G_CALLBACK (cancelled_cb), dialog);
-
-  task = g_task_new (dialog, cancellable, callback, user_data);
-  g_task_set_source_tag (task, gtk_choose_font_full);
-
-  g_signal_connect (dialog, "response", G_CALLBACK (response_cb), task);
-
-  gtk_window_present (GTK_WINDOW (dialog));
-}
-
-/**
- * gtk_choose_font_finish:
- * @chooser: the `GtkFontChooser`
- * @result: `GAsyncResult` that was passed to @callback
- * @error: return location for an error
- *
- * Finishes a gtk_choose_font() or gtk_choose_font_full() call
- * and returns whether the operation was successful.
- *
- * If this function returns `TRUE`, you can use
- * [class@Gtk.FontChooser] API to get the results.
- *
- * Returns: `TRUE` if the operation was successful
- */
-gboolean
-gtk_choose_font_finish (GtkFontChooser  *chooser,
-                        GAsyncResult     *result,
-                        GError          **error)
-{
-  return g_task_propagate_boolean (G_TASK (result), error);
-}

gtk/meson.build

@@ -186,7 +186,6 @@ gtk_public_sources = files([
   'gtkcolorchooser.c',
   'gtkcolorchooserdialog.c',
   'gtkcolorchooserwidget.c',
-  'gtkcolorchooserwindow.c',
   'gtkcolorutils.c',
   'gtkcolumnview.c',
   'gtkcolumnviewcolumn.c',

gtk/ui/gtkcolorchooserwindow.ui

@@ -1,54 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<interface domain="gtk40">
-  <template class="GtkColorChooserWindow" parent="GtkWindow">
-    <property name="title" translatable="yes">Select a Color</property>
-    <property name="resizable">0</property>
-    <property name="default-widget">ok_button</property>
-    <child type="titlebar">
-      <object class="GtkHeaderBar">
-        <property name="show-title-buttons">0</property>
-        <child type="start">
-          <object class="GtkButton" id="cancel_button">
-            <property name="use-underline">1</property>
-            <property name="label" translatable="yes">_Cancel</property>
-            <signal name="clicked" handler="cancel_button_cb"/>
-          </object>
-        </child>
-        <child type="end">
-          <object class="GtkButton" id="ok_button">
-            <property name="label" translatable="yes">_Select</property>
-            <property name="use-underline">1</property>
-            <signal name="clicked" handler="ok_button_cb"/>
-            <style>
-              <class name="suggested-action"/>
-            </style>
-          </object>
-        </child>
-      </object>
-    </child>
-    <child>
-      <object class="GtkBox">
-        <property name="orientation">1</property>
-        <property name="spacing">2</property>
-        <property name="margin-start">5</property>
-        <property name="margin-end">5</property>
-        <property name="margin-top">5</property>
-        <property name="margin-bottom">5</property>
-        <child>
-          <object class="GtkColorChooserWidget" id="chooser">
-            <property name="margin-start">5</property>
-            <property name="margin-end">5</property>
-            <property name="margin-top">5</property>
-            <property name="margin-bottom">5</property>
-            <property name="rgba">rgb(255,255,255)</property>
-            <property name="hexpand">1</property>
-            <property name="vexpand">1</property>
-            <signal name="color-activated" handler="color_activated_cb" swapped="no"/>
-            <signal name="notify::rgba" handler="propagate_notify" swapped="no"/>
-            <signal name="notify::show-editor" handler="propagate_notify" swapped="no"/>
-          </object>
-        </child>
-      </object>
-    </child>
-  </template>
-</interface>