Fix minimize button on border-less windows, see #2345

.gitlab-ci.yml

@@ -12,7 +12,11 @@ stages:
     - subprojects/libepoxy/
     - subprojects/pango/
 
-.build-artifacts:
+fedora-x86_64: &fedora-x86_64-defaults
+  image: registry.gitlab.gnome.org/gnome/gtk/master:v8
+  stage: build
+  script:
+    - bash -x ./.gitlab-ci/test-docker.sh
   artifacts:
     when: always
     reports:
@@ -25,35 +29,14 @@ stages:
       - "${CI_PROJECT_DIR}/_build/report.html"
       - "${CI_PROJECT_DIR}/_build/testsuite/reftests/output/*.png"
       - "${CI_PROJECT_DIR}/_build/testsuite/gsk/compare/*/*.png"
-
-.fedora-build-defaults: &fedora-build-defaults
-  image: registry.gitlab.gnome.org/gnome/gtk/master:v8
-  stage: build
-  script:
-    - bash -x ./.gitlab-ci/test-docker.sh
-  extends: .build-artifacts
-
-fedora-x86_64:
-  <<: *fedora-build-defaults
-  extends: .build-artifacts
   cache:
     key: "$CI_JOB_NAME"
     <<: *cache-paths
 
 fedora-x86_64-staticlibs:
-  <<: *fedora-build-defaults
   variables:
     EXTRA_MESON_FLAGS: "-Ddefault_library=both"
-  cache:
-    key: "$CI_JOB_NAME"
-    <<: *cache-paths
-
-# Uncached release build
-fedora-x86_64-release:
-  <<: *fedora-build-defaults
-  allow_failure: true
-  variables:
-    EXTRA_MESON_FLAGS: "-Dbuildtype=release"
+  <<: *fedora-x86_64-defaults
 
 .mingw-defaults: &mingw-defaults
   stage: build

CONTRIBUTING.md

@@ -174,7 +174,7 @@ maintainers review your contribution.
 
 Each contribution is reviewed by the core developers of the GTK project.
 
-The [CODEOWNERS](./docs/CODEOWNERS) document contains the list of core
+The [CODE-OWNERS](./docs/CODE-OWNERS) document contains the list of core
 contributors to GTK and the areas for which they are responsible; you
 should ensure to receive their review and signoff on your changes.
 

demos/gtk-demo/clipboard.c

@@ -119,76 +119,48 @@ get_image_paintable (GtkImage *image)
 }
 
 static void
-drag_begin (GtkDragSource *source,
-            GdkDrag       *drag,
-            GtkWidget     *widget)
+drag_begin (GtkWidget      *widget,
+            GdkDrag        *drag,
+            gpointer        data)
 {
   GdkPaintable *paintable;
 
   paintable = get_image_paintable (GTK_IMAGE (widget));
   if (paintable)
     {
-      gtk_drag_source_set_icon (source, paintable, -2, -2);
+      gtk_drag_set_icon_paintable (drag, paintable, -2, -2);
       g_object_unref (paintable);
     }
 }
 
-static void
-get_texture (GValue   *value,
-             gpointer  data)
+void
+drag_data_get (GtkWidget        *widget,
+               GdkDrag          *drag,
+               GtkSelectionData *selection_data,
+               guint             info,
+               gpointer          data)
 {
-  GdkPaintable *paintable = get_image_paintable (GTK_IMAGE (data));
+  GdkPaintable *paintable;
 
+  paintable = get_image_paintable (GTK_IMAGE (widget));
   if (GDK_IS_TEXTURE (paintable))
-    g_value_set_object (value, paintable);
-}
-
-static GdkContentProvider *
-prepare_drag (GtkDragSource *source,
-              double         x,
-              double         y,
-              GtkWidget     *image)
-{
-  return gdk_content_provider_new_with_callback (GDK_TYPE_TEXTURE, get_texture, image);
+    gtk_selection_data_set_texture (selection_data, GDK_TEXTURE (paintable));
 }
 
 static void
-got_texture (GObject *source,
-             GAsyncResult *result,
-             gpointer data)
+drag_data_received (GtkWidget        *widget,
+                    GdkDrop          *drop,
+                    GtkSelectionData *selection_data,
+                    gpointer          data)
 {
-  GdkDrop *drop = GDK_DROP (source);
-  GtkWidget *image = data;
-  const GValue *value;
-  GError *error = NULL;
-
-  value = gdk_drop_read_value_finish (drop, result, &error);
-  if (value)
+  if (gtk_selection_data_get_length (selection_data) > 0)
     {
-      GdkTexture *texture = g_value_get_object (value);
-      gtk_image_set_from_paintable (GTK_IMAGE (image), GDK_PAINTABLE (texture));
-    }
-  else
-    {
-      g_print ("Failed to get data: %s\n", error->message);
-      g_error_free (error);
-    }
-}
+      GdkTexture *texture;
 
-static gboolean
-drag_drop (GtkDropTarget *dest,
-           GdkDrop       *drop,
-           int            x,
-           int            y,
-           GtkWidget     *widget)
-{
-  if (gdk_drop_has_value (drop, GDK_TYPE_TEXTURE))
-    {
-      gdk_drop_read_value_async (drop, GDK_TYPE_TEXTURE, G_PRIORITY_DEFAULT, NULL, got_texture, widget);
-      return TRUE;
+      texture = gtk_selection_data_get_texture (selection_data);
+      gtk_image_set_from_paintable (GTK_IMAGE (data), GDK_PAINTABLE (texture));
+      g_object_unref (texture);
     }
-
-  return FALSE;
 }
 
 static void
@@ -199,8 +171,12 @@ copy_image (GSimpleAction *action,
   GdkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (data));
   GdkPaintable *paintable = get_image_paintable (GTK_IMAGE (data));
 
+  g_print ("copy image\n");
   if (GDK_IS_TEXTURE (paintable))
-    gdk_clipboard_set_texture (clipboard, GDK_TEXTURE (paintable));
+    {
+g_print ("set clipboard\n");
+      gdk_clipboard_set_texture (clipboard, GDK_TEXTURE (paintable));
+    }
 
   if (paintable)
     g_object_unref (paintable);
@@ -271,9 +247,6 @@ do_clipboard (GtkWidget *do_widget)
         { "paste", paste_image, NULL, NULL, NULL },
       };
       GActionGroup *actions;
-      GtkDragSource *source;
-      GtkDropTarget *dest;
-      GdkContentFormats *formats;
 
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
       gtk_window_set_display (GTK_WINDOW (window),
@@ -332,21 +305,22 @@ do_clipboard (GtkWidget *do_widget)
 
       /* Create the first image */
       image = gtk_image_new_from_icon_name ("dialog-warning");
-      gtk_image_set_pixel_size (GTK_IMAGE (image), 48);
       gtk_container_add (GTK_CONTAINER (hbox), image);
 
       /* make image a drag source */
-      source = gtk_drag_source_new ();
-      g_signal_connect (source, "prepare", G_CALLBACK (prepare_drag), NULL);
-      g_signal_connect (source, "drag-begin", G_CALLBACK (drag_begin), image);
-      gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (source));
+      gtk_drag_source_set (image, GDK_BUTTON1_MASK, NULL, GDK_ACTION_COPY);
+      gtk_drag_source_add_image_targets (image);
+      g_signal_connect (image, "drag-begin",
+                        G_CALLBACK (drag_begin), image);
+      g_signal_connect (image, "drag-data-get",
+                        G_CALLBACK (drag_data_get), image);
 
       /* accept drops on image */
-      formats = gdk_content_formats_new_for_gtype (GDK_TYPE_TEXTURE);
-      dest = gtk_drop_target_new (formats, GDK_ACTION_COPY);
-      gdk_content_formats_unref (formats);
-      g_signal_connect (dest, "drag-drop", G_CALLBACK (drag_drop), image);
-      gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (dest));
+      gtk_drag_dest_set (image, GTK_DEST_DEFAULT_ALL,
+                         NULL, GDK_ACTION_COPY);
+      gtk_drag_dest_add_image_targets (image);
+      g_signal_connect (image, "drag-data-received",
+                        G_CALLBACK (drag_data_received), image);
 
       /* context menu on image */
       gesture = gtk_gesture_click_new ();
@@ -363,21 +337,22 @@ do_clipboard (GtkWidget *do_widget)
 
       /* Create the second image */
       image = gtk_image_new_from_icon_name ("process-stop");
-      gtk_image_set_pixel_size (GTK_IMAGE (image), 48);
       gtk_container_add (GTK_CONTAINER (hbox), image);
 
       /* make image a drag source */
-      source = gtk_drag_source_new ();
-      g_signal_connect (source, "prepare", G_CALLBACK (prepare_drag), NULL);
-      g_signal_connect (source, "drag-begin", G_CALLBACK (drag_begin), image);
-      gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (source));
+      gtk_drag_source_set (image, GDK_BUTTON1_MASK, NULL, GDK_ACTION_COPY);
+      gtk_drag_source_add_image_targets (image);
+      g_signal_connect (image, "drag-begin",
+                        G_CALLBACK (drag_begin), image);
+      g_signal_connect (image, "drag-data-get",
+                        G_CALLBACK (drag_data_get), image);
 
       /* accept drops on image */
-      formats = gdk_content_formats_new_for_gtype (GDK_TYPE_TEXTURE);
-      dest = gtk_drop_target_new (formats, GDK_ACTION_COPY);
-      gdk_content_formats_unref (formats);
-      g_signal_connect (dest, "drag-drop", G_CALLBACK (drag_drop), image);
-      gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (dest));
+      gtk_drag_dest_set (image, GTK_DEST_DEFAULT_ALL,
+                         NULL, GDK_ACTION_COPY);
+      gtk_drag_dest_add_image_targets (image);
+      g_signal_connect (image, "drag-data-received",
+                        G_CALLBACK (drag_data_received), image);
 
       /* context menu on image */
       gesture = gtk_gesture_click_new ();

demos/gtk-demo/infobar.c

@@ -97,7 +97,6 @@ do_infobar (GtkWidget *do_widget)
       gtk_label_set_wrap (GTK_LABEL (label), TRUE);
       gtk_label_set_xalign (GTK_LABEL (label), 0);
       gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (bar))), label);
-      gtk_info_bar_set_default_response (GTK_INFO_BAR (bar), GTK_RESPONSE_OK);
 
       button = gtk_toggle_button_new_with_label ("Question");
       g_object_bind_property (bar, "revealed", button, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);

demos/icon-browser/iconbrowserwin.c

@@ -5,6 +5,9 @@
 #include <gtk/gtk.h>
 
 /* Drag 'n Drop */
+static const char *target_table[] = {
+  "text/uri-list"
+};
 
 typedef struct
 {
@@ -73,11 +76,30 @@ search_text_changed (GtkEntry *entry, IconBrowserWindow *win)
   gtk_tree_model_filter_refilter (win->filter_model);
 }
 
+static GdkPixbuf *
+get_icon (GtkWidget *image, const gchar *name, gint size)
+{
+  GtkIconInfo *info;
+  GtkStyleContext *context;
+  GdkTexture *texture;
+  GdkPixbuf *pixbuf;
+
+  context = gtk_widget_get_style_context (image);
+  info = gtk_icon_theme_lookup_icon (gtk_icon_theme_get_default (), name, size, 0);
+  texture = GDK_TEXTURE (gtk_icon_info_load_symbolic_for_context (info, context, NULL, NULL));
+  pixbuf = gdk_pixbuf_get_from_texture (texture);
+  g_object_unref (texture);
+  g_object_unref (info);
+
+  return pixbuf;
+}
+
 static void
 set_image (GtkWidget *image, const gchar *name, gint size)
 {
   gtk_image_set_from_icon_name (GTK_IMAGE (image), name);
   gtk_image_set_pixel_size (GTK_IMAGE (image), size);
+  gtk_drag_source_set_icon_name (image, name);
 }
 
 static void
@@ -343,107 +365,78 @@ search_mode_toggled (GObject *searchbar, GParamSpec *pspec, IconBrowserWindow *w
     gtk_list_box_unselect_all (GTK_LIST_BOX (win->context_list));
 }
 
-static GdkPaintable *
-get_image_paintable (GtkImage *image)
+static void
+get_image_data (GtkWidget        *widget,
+                GdkDrag          *drag,
+                GtkSelectionData *selection,
+                guint             target_info,
+                gpointer          data)
 {
-  const gchar *icon_name;
-  GtkIconTheme *icon_theme;
-  GtkIconInfo *icon_info;
-  int size;
+  GtkWidget *image;
+  const gchar *name;
+  gint size;
+  GdkPixbuf *pixbuf;
 
-  switch (gtk_image_get_storage_type (image))
-    {
-    case GTK_IMAGE_PAINTABLE:
-      return g_object_ref (gtk_image_get_paintable (image));
-    case GTK_IMAGE_ICON_NAME:
-      icon_name = gtk_image_get_icon_name (image);
-      size = gtk_image_get_pixel_size (image);
-      icon_theme = gtk_icon_theme_get_for_display (gtk_widget_get_display (GTK_WIDGET (image)));
-      icon_info = gtk_icon_theme_lookup_icon (icon_theme, icon_name, size,
-                                              GTK_ICON_LOOKUP_FORCE_SIZE | GTK_ICON_LOOKUP_GENERIC_FALLBACK);
-      if (icon_info == NULL)
-        return NULL;
-      return gtk_icon_info_load_icon (icon_info, NULL);
-    default:
-      g_warning ("Image storage type %d not handled",
-                 gtk_image_get_storage_type (image));
-      return NULL;
-    }
+  image = gtk_bin_get_child (GTK_BIN (widget));
+
+  name = gtk_image_get_icon_name (GTK_IMAGE (image));
+  size = gtk_image_get_pixel_size (GTK_IMAGE (image));
+
+  pixbuf = get_icon (image, name, size);
+  gtk_selection_data_set_pixbuf (selection, pixbuf);
+  g_object_unref (pixbuf);
 }
 
 static void
-drag_begin (GtkDragSource *source,
-            GdkDrag       *drag,
-            GtkWidget     *widget)
+get_scalable_image_data (GtkWidget        *widget,
+                         GdkDrag          *drag,
+                         GtkSelectionData *selection,
+                         guint             target_info,
+                         gpointer          data)
 {
-  GdkPaintable *paintable;
-
-  paintable = get_image_paintable (GTK_IMAGE (widget));
-  if (paintable)
-    {
-      int w, h;
-
-      w = gdk_paintable_get_intrinsic_width (paintable);
-      h = gdk_paintable_get_intrinsic_height (paintable);
-      gtk_drag_source_set_icon (source, paintable, w, h);
-      g_object_unref (paintable);
-    }
-}
-
-static void
-get_texture (GValue   *value,
-             gpointer  data)
-{
-  GdkPaintable *paintable = get_image_paintable (GTK_IMAGE (data));
-
-  if (GDK_IS_TEXTURE (paintable))
-    g_value_set_object (value, paintable);
-}
-
-static void
-get_file (GValue   *value,
-          gpointer  data)
-{
-  const char *name;
+  gchar *uris[2];
   GtkIconInfo *info;
+  GtkWidget *image;
   GFile *file;
+  const gchar *name;
 
-  name = gtk_image_get_icon_name (GTK_IMAGE (data));
+  image = gtk_bin_get_child (GTK_BIN (widget));
+  name = gtk_image_get_icon_name (GTK_IMAGE (image));
 
   info = gtk_icon_theme_lookup_icon (gtk_icon_theme_get_default (), name, -1, 0);
   file = g_file_new_for_path (gtk_icon_info_get_filename (info));
-  g_value_set_object (value, file);
-  g_object_unref (file);
+  uris[0] = g_file_get_uri (file);
+  uris[1] = NULL;
+
+  gtk_selection_data_set_uris (selection, uris);
+
+  g_free (uris[0]);
   g_object_unref (info);
+  g_object_unref (file);
 }
 
 static void
 setup_image_dnd (GtkWidget *image)
 {
-  GdkContentProvider *content;
-  GtkDragSource *source;
-
-  source = gtk_drag_source_new ();
-  content = gdk_content_provider_new_with_callback (GDK_TYPE_TEXTURE, get_texture, image);
-  gtk_drag_source_set_content (source, content);
-  g_object_unref (content);
-  g_signal_connect (source, "drag-begin", G_CALLBACK (drag_begin), image);
-  gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (source));
+  gtk_drag_source_set (image, GDK_BUTTON1_MASK, NULL, GDK_ACTION_COPY);
+  gtk_drag_source_add_image_targets (image);
+  g_signal_connect (image, "drag-data-get", G_CALLBACK (get_image_data), NULL);
 }
 
 static void
 setup_scalable_image_dnd (GtkWidget *image)
 {
-  GdkContentProvider *content;
-  GtkDragSource *source;
+  GtkWidget *parent;
+  GdkContentFormats *targets;
 
-  source = gtk_drag_source_new ();
-  content = gdk_content_provider_new_with_callback (G_TYPE_FILE, get_file, image);
-  gtk_drag_source_set_content (source, content);
-  g_object_unref (content);
+  parent = gtk_widget_get_parent (image);
+  targets = gdk_content_formats_new (target_table, G_N_ELEMENTS (target_table));
+  gtk_drag_source_set (parent, GDK_BUTTON1_MASK,
+                       targets,
+                       GDK_ACTION_COPY);
+  gdk_content_formats_unref (targets);
 
-  g_signal_connect (source, "drag-begin", G_CALLBACK (drag_begin), image);
-  gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (source));
+  g_signal_connect (parent, "drag-data-get", G_CALLBACK (get_scalable_image_data), NULL);
 }
 
 static void
@@ -453,7 +446,8 @@ icon_browser_window_init (IconBrowserWindow *win)
 
   gtk_widget_init_template (GTK_WIDGET (win));
 
-  list = gdk_content_formats_new_for_gtype (G_TYPE_STRING);
+  list = gdk_content_formats_new (NULL, 0);
+  list = gtk_content_formats_add_text_targets (list);
   gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW (win->list),
                                           GDK_BUTTON1_MASK,
                                           list,
@@ -465,6 +459,7 @@ icon_browser_window_init (IconBrowserWindow *win)
   setup_image_dnd (win->image3);
   setup_image_dnd (win->image4);
   setup_image_dnd (win->image5);
+  setup_image_dnd (win->image6);
   setup_scalable_image_dnd (win->image6);
 
   win->contexts = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, context_free);

docs/reference/gsk/gsk4-sections.txt

@@ -30,7 +30,6 @@ GskRenderNodeType
 gsk_render_node_get_node_type
 gsk_render_node_draw
 GskSerializationError
-GskParseErrorFunc
 gsk_render_node_serialize
 gsk_render_node_deserialize
 gsk_render_node_write_to_file

docs/reference/gtk/gtk4-docs.xml

@@ -344,13 +344,6 @@
       <xi:include href="xml/gtkpadcontroller.xml" />
     </chapter>
 
-    <chapter>
-      <title>Data exchange, clipboards and Drag-and-Drop</title>
-      <xi:include href="xml/gtkdragsource.xml"/>
-      <xi:include href="xml/gtkdragicon.xml"/>
-      <xi:include href="xml/gtkdroptarget.xml"/>
-    </chapter>
-
   </part>
 
   <part  id="gtkbase">
@@ -359,6 +352,7 @@
     <xi:include href="xml/gtkfeatures.xml" />
     <xi:include href="xml/gtkaccelgroup.xml" />
     <xi:include href="xml/gtkaccelmap.xml" />
+    <xi:include href="xml/gtkdnd.xml" />
     <xi:include href="xml/gtksettings.xml" />
     <xi:include href="xml/gtkbindings.xml" />
     <xi:include href="xml/gtkenums.xml" />

docs/reference/gtk/gtk4-sections.txt

@@ -5001,6 +5001,49 @@ GTK_TYPE_SELECTION_DATA
 gtk_selection_data_get_type
 </SECTION>
 
+<SECTION>
+<FILE>gtkdnd</FILE>
+<TITLE>Drag and Drop</TITLE>
+GtkDestDefaults
+GtkDragResult
+
+<SUBSECTION Destination Side>
+gtk_drag_dest_set
+gtk_drag_dest_unset
+gtk_drag_dest_find_target
+gtk_drag_dest_get_target_list
+gtk_drag_dest_set_target_list
+gtk_drag_dest_add_text_targets
+gtk_drag_dest_add_image_targets
+gtk_drag_dest_add_uri_targets
+gtk_drag_dest_set_track_motion
+gtk_drag_dest_get_track_motion
+gtk_drag_get_data
+gtk_drag_get_source_widget
+gtk_drag_highlight
+gtk_drag_unhighlight
+
+<SUBSECTION Source Side>
+gtk_drag_begin
+gtk_drag_cancel
+gtk_drag_set_icon_widget
+gtk_drag_set_icon_paintable
+gtk_drag_set_icon_name
+gtk_drag_set_icon_gicon
+gtk_drag_set_icon_default
+gtk_drag_check_threshold
+gtk_drag_source_set
+gtk_drag_source_set_icon_name
+gtk_drag_source_set_icon_gicon
+gtk_drag_source_set_icon_paintable
+gtk_drag_source_unset
+gtk_drag_source_set_target_list
+gtk_drag_source_get_target_list
+gtk_drag_source_add_text_targets
+gtk_drag_source_add_image_targets
+gtk_drag_source_add_uri_targets
+</SECTION>
+
 <SECTION>
 <FILE>gtkbindings</FILE>
 <TITLE>Bindings</TITLE>
@@ -7148,69 +7191,3 @@ gtk_constraint_guide_get_max_size
 GTK_TYPE_CONSTRAINT_GUIDE
 gtk_constraint_guide_get_tyoe
 </SECTION>
-
-<SECTION>
-<FILE>gtkdragsource</FILE>
-GtkDragSource
-gtk_drag_source_new
-gtk_drag_source_set_content
-gtk_drag_source_get_content
-gtk_drag_source_set_actions
-gtk_drag_source_get_actions
-gtk_drag_source_set_icon
-gtk_drag_source_drag_cancel
-gtk_drag_source_get_drag
-gtk_drag_check_threshold
-<SUBSECTION Standard>
-GTK_TYPE_DRAG_SOURCE
-GTK_DRAG_SOURCE
-GTK_DRAG_SOURCE_CLASS
-GTK_IS_DRAG_SOURCE
-GTK_IS_DRAG_SOURCE_CLASS
-GTK_DRAG_SOURCE_GET_CLASS
-<SUBSECTION Private>
-gtk_drag_source_get_type
-</SECTION>
-
-<SECTION>
-<FILE>gtkdroptarget</FILE>
-GtkDropTarget
-gtk_drop_target_new
-gtk_drop_target_set_formats
-gtk_drop_target_get_formats
-gtk_drop_target_set_actions
-gtk_drop_target_get_actions
-gtk_drop_target_get_drop
-gtk_drop_target_find_mimetype
-gtk_drop_target_read_selection
-gtk_drop_target_read_selection_finish
-gtk_drag_highlight
-gtk_drag_unhighlight
-
-<SUBSECTION Standard>
-GTK_TYPE_DROP_TARGET
-GTK_DROP_TARGET
-GTK_DROP_TARGET_CLASS
-GTK_IS_DROP_TARGET
-GTK_IS_DROP_TARGET_CLASS
-GTK_DROP_TARGET_GET_CLASS
-<SUBSECTION Private>
-gtk_drop_target_get_type
-</SECTION>
-
-<SECTION>
-<FILE>gtkdragicon</FILE>
-GtkDragIcon
-gtk_drag_icon_new_for_drag
-gtk_drag_icon_set_from_paintable
-
-<SUBSECTION Standard>
-GTK_TYPE_DRAG_ICON
-GTK_DRAG_ICON
-GTK_DRAG_ICON_CLASS
-GTK_IS_DRAG_ICON
-GTK_IS_DRAG_ICON_CLASS
-GTK_DRAG_ICON_GET_CLASS
-<SUBSECTION Private>
-gtk_drag_icon_get_type
-</SECTION>

docs/reference/gtk/gtk4.types.in

@@ -57,10 +57,7 @@ gtk_constraint_target_get_type
 gtk_container_get_type
 gtk_css_provider_get_type
 gtk_dialog_get_type
-gtk_drag_icon_get_type
-gtk_drag_source_get_type
 gtk_drawing_area_get_type
-gtk_drop_target_get_type
 gtk_editable_get_type
 gtk_entry_buffer_get_type
 gtk_entry_completion_get_type

docs/reference/gtk/meson.build

@@ -48,6 +48,7 @@ private_headers = [
   'gtkcssfontfeaturesvalueprivate.h',
   'gtkcssfontvariationsvalueprivate.h',
   'gtkcssiconthemevalueprivate.h',
+  'gtkcssimagebuiltinprivate.h',
   'gtkcssimagecrossfadeprivate.h',
   'gtkcssimagefallbackprivate.h',
   'gtkcssimageiconthemeprivate.h',
@@ -96,6 +97,7 @@ private_headers = [
   'gtkcsswidgetnodeprivate.h',
   'gtkcsswin32sizevalueprivate.h',
   'gtkdialogprivate.h',
+  'gtkdndprivate.h',
   'gtkentryprivate.h',
   'gtkeventcontrollerlegacyprivate.h',
   'gtkeventcontrollerprivate.h',

docs/reference/gtk/migrating-3to4.xml

@@ -903,37 +903,6 @@
         gtk_tooltip_set_custom().
       </para>
     </section>
-
-    <section>
-      <title>Switch to the new DND api</title>
-      <para>
-        The source-side DND apis in GTK 4 have been changed to use an event controller, #GtkDragSource.
-      </para>
-      <para>
-        Instead of calling gtk_drag_source_set() and connecting to #GtkWidget signals, you create
-        a #GtkDragSource object, attach it to the widget with gtk_widget_add_controller(), and connect
-        to #GtkDragSource signals. Instead of calling gtk_drag_begin() on a widget to start a drag
-        manually, call gdk_drag_begin().
-      </para>
-      <para>
-        The ::drag-data-get signal has been replaced by the #GtkDragSource::prepare signal, which
-        returns a #GdkContentProvider for the drag operation.
-      </para>
-      <para>
-        The destination-side DND apis in GTK 4 have also been changed to use and event controller,
-        #GTkDropTarget.
-      </para>
-      <para>
-        Instead of calling gtk_drag_dest_set() and connecting to #GtkWidget signals, you create
-        a #GtkDropTarget object, attach it to the widget with gtk_widget_add_controller(), and
-        connect to #GtkDropTarget signals.
-      </para>
-      <para>
-        The ::drag-motion signal has been renamed to #GtkDragSource::accept, and instead of
-        ::drag-data-received, you need to use async read methods on the #GdkDrop object, such
-        as gdk_drop_read_value_async() or gdk_drop_read_text_async().
-      </para>
-    </section>
   </section>
 
 </chapter>

gdk/broadway/gdkdevice-broadway.c

@@ -303,7 +303,7 @@ gdk_broadway_device_surface_at_position (GdkDevice       *device,
                                          GdkModifierType *mask,
                                          gboolean         get_toplevel)
 {
-  GdkSurface *surface = NULL;
+  GdkSurface *surface;
 
   gdk_broadway_device_query_state (device, NULL, &surface, NULL, NULL, win_x, win_y, mask);
 

gdk/filetransferportal.c

@@ -42,40 +42,6 @@
 #include "filetransferportalprivate.h"
 
 static GDBusProxy *file_transfer_proxy = NULL;
-static gboolean done;
-static guint timeout_id;
-
-static void
-got_proxy (GObject *source,
-           GAsyncResult *result,
-           gpointer data)
-{
-  GError *error = NULL;
-
-  file_transfer_proxy = g_dbus_proxy_new_for_bus_finish (result, &error);
-  if (!file_transfer_proxy)
-    {
-      g_message ("failed to get file transfer portal proxy: %s", error->message);
-      g_error_free (error);
-    }
-
-  done = TRUE;
-}
-
-static gboolean
-give_up_on_proxy (gpointer data)
-{
-  GCancellable *cancellable = data;
-
-  g_cancellable_cancel (cancellable);
-
-  timeout_id = 0;
-  done = TRUE;
-
-  g_main_context_wakeup (NULL);
-
-  return G_SOURCE_REMOVE;
-}
 
 static GDBusProxy *
 ensure_file_transfer_portal (void)
@@ -83,29 +49,16 @@ ensure_file_transfer_portal (void)
   if (file_transfer_proxy == NULL)
     {
       GError *error = NULL;
-      GCancellable *cancellable;
 
-      cancellable = g_cancellable_new ();
-
-      g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
-                                G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES
-                                | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS
-                                | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
-                                NULL,
-                                "org.freedesktop.portal.Documents",
-                                "/org/freedesktop/portal/documents",
-                                "org.freedesktop.portal.FileTransfer",
-                                cancellable,
-                                got_proxy,
-                                NULL);
-
-      timeout_id = g_timeout_add_full (1000, 0, give_up_on_proxy, cancellable, g_object_unref);
-
-      while (!done)
-        g_main_context_iteration (NULL, TRUE);
-
-      if (timeout_id)
-        g_source_remove (timeout_id);
+      file_transfer_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+                                                           G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES
+                                                           | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS
+                                                           | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+                                                           NULL,
+                                                           "org.freedesktop.portal.Documents",
+                                                           "/org/freedesktop/portal/documents",
+                                                           "org.freedesktop.portal.FileTransfer",
+                                                           NULL, &error);
 
       if (error)
         {

gdk/gdkcontentdeserializer.c

@@ -24,7 +24,6 @@
 #include "gdkcontentformats.h"
 #include "filetransferportalprivate.h"
 #include "gdktexture.h"
-#include "gdkrgbaprivate.h"
 
 #include <gdk-pixbuf/gdk-pixbuf.h>
 
@@ -849,63 +848,6 @@ file_uri_deserializer (GdkContentDeserializer *deserializer)
   g_object_unref (output);
 }
 
-static void
-color_deserializer_finish (GObject      *source,
-                           GAsyncResult *result,
-                           gpointer      deserializer)
-{
-  GOutputStream *stream = G_OUTPUT_STREAM (source);
-  GError *error = NULL;
-  gssize written;
-
-  written = g_output_stream_splice_finish (stream, result, &error);
-  if (written < 0)
-    {
-      gdk_content_deserializer_return_error (deserializer, error);
-      return;
-    }
-  else if (written == 0)
-    {
-      GdkRGBA black = GDK_RGBA ("000");
-
-      /* Never return NULL, we only return that on error */
-      g_value_set_boxed (gdk_content_deserializer_get_value (deserializer), &black);
-    }
-  else
-    {
-      guint16 *data;
-      GdkRGBA rgba;
-
-      data = (guint16 *)g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (stream));
-      rgba.red = data[0] / 65535.0;
-      rgba.green = data[1] / 65535.0;
-      rgba.blue = data[2] / 65535.0;
-      rgba.alpha = data[3] / 65535.0;
-
-      g_value_set_boxed (gdk_content_deserializer_get_value (deserializer), &rgba);
-    }
-  gdk_content_deserializer_return_success (deserializer);
-}
-
-static void
-color_deserializer (GdkContentDeserializer *deserializer)
-{
-  GOutputStream *output;
-  guint16 *data;
-
-  data = g_new0 (guint16, 4);
-  output = g_memory_output_stream_new (data, 4 * sizeof (guint16), NULL, g_free);
-
-  g_output_stream_splice_async (output,
-                                gdk_content_deserializer_get_input_stream (deserializer),
-                                G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
-                                gdk_content_deserializer_get_priority (deserializer),
-                                gdk_content_deserializer_get_cancellable (deserializer),
-                                color_deserializer_finish,
-                                deserializer);
-  g_object_unref (output);
-}
-
 static void
 init (void)
 {
@@ -1014,11 +956,5 @@ init (void)
                                      string_deserializer,
                                      (gpointer) "ASCII",
                                      NULL);
-
-  gdk_content_register_deserializer ("application/x-color",
-                                     GDK_TYPE_RGBA,
-                                     color_deserializer,
-                                     NULL,
-                                     NULL);
 }
 

gdk/gdkcontentproviderimpl.c

@@ -21,7 +21,6 @@
 #include "gdkcontentprovider.h"
 
 #include "gdkcontentformats.h"
-#include "gdkcontentserializer.h"
 #include "gdkintl.h"
 #include "gdkcontentproviderimpl.h"
 
@@ -281,232 +280,3 @@ gdk_content_provider_new_for_bytes (const char *mime_type,
   
   return GDK_CONTENT_PROVIDER (content);
 }
-
-#define GDK_TYPE_CONTENT_PROVIDER_CALLBACK            (gdk_content_provider_callback_get_type ())
-#define GDK_CONTENT_PROVIDER_CALLBACK(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_CONTENT_PROVIDER_CALLBACK, GdkContentProviderCallback))
-
-typedef struct _GdkContentProviderCallback GdkContentProviderCallback;
-typedef struct _GdkContentProviderCallbackClass GdkContentProviderCallbackClass;
-
-struct _GdkContentProviderCallback
-{
-  GdkContentProvider parent;
-
-  GType type;
-  GdkContentProviderGetValueFunc func;
-  gpointer data;
-};
-
-struct _GdkContentProviderCallbackClass
-{
-  GdkContentProviderClass parent_class;
-};
-
-GType gdk_content_provider_callback_get_type (void) G_GNUC_CONST;
-
-G_DEFINE_TYPE (GdkContentProviderCallback, gdk_content_provider_callback, GDK_TYPE_CONTENT_PROVIDER)
-
-static GdkContentFormats *
-gdk_content_provider_callback_ref_formats (GdkContentProvider *provider)
-{
-  GdkContentProviderCallback *callback = GDK_CONTENT_PROVIDER_CALLBACK (provider);
-
-  return gdk_content_formats_new_for_gtype (callback->type);
-}
-
-static gboolean
-gdk_content_provider_callback_get_value (GdkContentProvider  *provider,
-                                         GValue              *value,
-                                         GError             **error)
-{
-  GdkContentProviderCallback *callback = GDK_CONTENT_PROVIDER_CALLBACK (provider);
-
-  if (G_VALUE_HOLDS (value, callback->type) && callback->func != NULL)
-    {
-      callback->func (value, callback->data);
-      return TRUE;
-    }
-
-  return GDK_CONTENT_PROVIDER_CLASS (gdk_content_provider_callback_parent_class)->get_value (provider, value, error);
-}
-
-static void
-gdk_content_provider_callback_class_init (GdkContentProviderCallbackClass *class)
-{
-  GdkContentProviderClass *provider_class = GDK_CONTENT_PROVIDER_CLASS (class);
-
-  provider_class->ref_formats = gdk_content_provider_callback_ref_formats;
-  provider_class->get_value = gdk_content_provider_callback_get_value;
-}
-
-static void
-gdk_content_provider_callback_init (GdkContentProviderCallback *content)
-{
-}
-
-/**
- * gdk_content_provider_new_for_callback:
- * @type: the type that the callback provides
- * @func: callback to populate a #GValue
- * @data: (closure): data that gets passed to @func
- *
- * Create a content provider that provides data that is provided via a callback.
- *
- * Returns: a new #GdkContentProvider
- **/
-GdkContentProvider *
-gdk_content_provider_new_with_callback (GType                          type,
-                                        GdkContentProviderGetValueFunc func,
-                                        gpointer                       data)
-{
-  GdkContentProviderCallback *content;
-
-  content = g_object_new (GDK_TYPE_CONTENT_PROVIDER_CALLBACK, NULL);
-  content->type = type;
-  content->func = func;
-  content->data = data;
-  
-  return GDK_CONTENT_PROVIDER (content);
-}
-
-#define GDK_TYPE_CONTENT_PROVIDER_CALLBACK2            (gdk_content_provider_callback2_get_type ())
-#define GDK_CONTENT_PROVIDER_CALLBACK2(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_CONTENT_PROVIDER_CALLBACK2, GdkContentProviderCallback2))
-
-typedef struct _GdkContentProviderCallback2 GdkContentProviderCallback2;
-typedef struct _GdkContentProviderCallback2Class GdkContentProviderCallback2Class;
-
-struct _GdkContentProviderCallback2
-{
-  GdkContentProvider parent;
-
-  GdkContentFormats *formats;
-  GdkContentProviderGetBytesFunc func;
-  gpointer data;
-};
-
-struct _GdkContentProviderCallback2Class
-{
-  GdkContentProviderClass parent_class;
-};
-
-GType gdk_content_provider_callback2_get_type (void) G_GNUC_CONST;
-
-G_DEFINE_TYPE (GdkContentProviderCallback2, gdk_content_provider_callback2, GDK_TYPE_CONTENT_PROVIDER)
-
-static GdkContentFormats *
-gdk_content_provider_callback2_ref_formats (GdkContentProvider *provider)
-{
-  GdkContentProviderCallback2 *callback = GDK_CONTENT_PROVIDER_CALLBACK2 (provider);
-
-  return gdk_content_formats_ref (callback->formats);
-}
-
-static void
-gdk_content_provider_callback2_write_mime_type_done (GObject      *stream,
-                                                     GAsyncResult *result,
-                                                     gpointer      task)
-{
-  GError *error = NULL;
-
-  if (!g_output_stream_write_all_finish (G_OUTPUT_STREAM (stream), result, NULL, &error))
-    g_task_return_error (task, error);
-  else
-    g_task_return_boolean (task, TRUE);
-
-  g_object_unref (task);
-}
-
-static void
-gdk_content_provider_callback2_write_mime_type_async (GdkContentProvider     *provider,
-                                                      const char             *mime_type,
-                                                      GOutputStream          *stream,
-                                                      int                     io_priority,
-                                                      GCancellable           *cancellable,
-                                                      GAsyncReadyCallback     callback,
-                                                      gpointer                user_data)
-{
-  GdkContentProviderCallback2 *content = GDK_CONTENT_PROVIDER_CALLBACK2 (provider);
-  GTask *task;
-  GBytes *bytes;
-
-  task = g_task_new (content, cancellable, callback, user_data);
-  g_task_set_priority (task, io_priority);
-  g_task_set_source_tag (task, gdk_content_provider_callback2_write_mime_type_async);
-
-  if (!gdk_content_formats_contain_mime_type (content->formats, mime_type))
-    {
-      g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
-                               _("Cannot provide contents as “%s”"), mime_type);
-      g_object_unref (task);
-      return;
-    }
-
-  bytes = content->func (mime_type, content->data);
-  if (!bytes)
-    {
-      g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
-                               _("Failed to get contents as “%s”"), mime_type);
-      g_object_unref (task);
-      return;
-    }
-
-  g_object_set_data_full (G_OBJECT (task), "bytes", bytes, (GDestroyNotify)g_bytes_unref);
-
-  g_output_stream_write_all_async (stream,
-                                   g_bytes_get_data (bytes, NULL),
-                                   g_bytes_get_size (bytes),
-                                   io_priority,
-                                   cancellable,
-                                   gdk_content_provider_callback2_write_mime_type_done,
-                                   task);
-}
-
-static gboolean
-gdk_content_provider_callback2_write_mime_type_finish (GdkContentProvider *provider,
-                                                       GAsyncResult       *result,
-                                                       GError            **error)
-{
-  g_return_val_if_fail (g_task_is_valid (result, provider), FALSE);
-  g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == gdk_content_provider_callback2_write_mime_type_async, FALSE);
-
-  return g_task_propagate_boolean (G_TASK (result), error);
-}
-
-static void
-gdk_content_provider_callback2_class_init (GdkContentProviderCallback2Class *class)
-{
-  GdkContentProviderClass *provider_class = GDK_CONTENT_PROVIDER_CLASS (class);
-
-  provider_class->ref_formats = gdk_content_provider_callback2_ref_formats;
-  provider_class->write_mime_type_async = gdk_content_provider_callback2_write_mime_type_async;
-  provider_class->write_mime_type_finish = gdk_content_provider_callback2_write_mime_type_finish;
-}
-
-static void
-gdk_content_provider_callback2_init (GdkContentProviderCallback2 *content)
-{
-}
-
-/**
- * gdk_content_provider_new_with_formats:
- * @formats: formats to advertise
- * @func: callback to populate a #GValue
- * @data: data that gets passed to @func
- *
- * Create a content provider that provides data that is provided via a callback.
- *
- * Returns: a new #GdkContentProvider
- **/
-GdkContentProvider *
-gdk_content_provider_new_with_formats (GdkContentFormats              *formats,
-                                       GdkContentProviderGetBytesFunc  func,
-                                       gpointer                        data)
-{
-  GdkContentProviderCallback2 *content;
-  content = g_object_new (GDK_TYPE_CONTENT_PROVIDER_CALLBACK2, NULL);
-  content->formats = gdk_content_formats_union_serialize_mime_types (gdk_content_formats_ref (formats));
-  content->func = func;
-  content->data = data;
-  
-  return GDK_CONTENT_PROVIDER (content);
-}

gdk/gdkcontentproviderimpl.h

@@ -35,21 +35,6 @@ GDK_AVAILABLE_IN_ALL
 GdkContentProvider *    gdk_content_provider_new_for_bytes              (const char             *mime_type,
                                                                          GBytes                 *bytes);
 
-typedef void (*GdkContentProviderGetValueFunc) (GValue   *value,
-                                                gpointer  data);
-
-GDK_AVAILABLE_IN_ALL
-GdkContentProvider *    gdk_content_provider_new_with_callback (GType                           type,
-                                                                GdkContentProviderGetValueFunc  func,
-                                                                gpointer                        data);
-
-typedef GBytes * (*GdkContentProviderGetBytesFunc) (const char *mime_type,
-                                                    gpointer    data);
-
-GDK_AVAILABLE_IN_ALL
-GdkContentProvider *    gdk_content_provider_new_with_formats  (GdkContentFormats              *formats,
-                                                                GdkContentProviderGetBytesFunc  func,
-                                                                gpointer                        data);
 
 G_END_DECLS
 

gdk/gdkcontentserializer.c

@@ -25,7 +25,6 @@
 #include "gdkpixbuf.h"
 #include "filetransferportalprivate.h"
 #include "gdktextureprivate.h"
-#include "gdkrgba.h"
 
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <string.h>
@@ -863,48 +862,6 @@ file_text_serializer (GdkContentSerializer *serializer)
   gdk_content_serializer_set_task_data (serializer, path, g_free);
 }
 
-static void
-color_serializer_finish (GObject      *source,
-                         GAsyncResult *result,
-                         gpointer      serializer)
-{
-  GOutputStream *stream = G_OUTPUT_STREAM (source);
-  GError *error = NULL;
-
-  if (!g_output_stream_write_all_finish (stream, result, NULL, &error))
-    gdk_content_serializer_return_error (serializer, error);
-  else
-    gdk_content_serializer_return_success (serializer);
-}
-
-static void
-color_serializer (GdkContentSerializer *serializer)
-{
-  const GValue *value;
-  GdkRGBA *rgba;
-  guint16 *data;
-
-  value = gdk_content_serializer_get_value (serializer);
-  rgba = g_value_get_boxed (value);
-  data = g_new0 (guint16, 4);
-  if (rgba)
-    {
-      data[0] = (guint16) (rgba->red * 65535);
-      data[1] = (guint16) (rgba->green * 65535);
-      data[2] = (guint16) (rgba->blue * 65535);
-      data[3] = (guint16) (rgba->alpha * 65535);
-    }
-
-  g_output_stream_write_all_async (gdk_content_serializer_get_output_stream (serializer),
-                                   data,
-                                   4 * sizeof (guint16),
-                                   gdk_content_serializer_get_priority (serializer),
-                                   gdk_content_serializer_get_cancellable (serializer),
-                                   color_serializer_finish,
-                                   serializer);
-  gdk_content_serializer_set_task_data (serializer, data, g_free);
-}
-
 static void
 init (void)
 {
@@ -1027,11 +984,5 @@ init (void)
                                    string_serializer,
                                    (gpointer) "ASCII",
                                    NULL);
-
-  gdk_content_register_serializer (GDK_TYPE_RGBA,
-                                   "application/x-color",
-                                   color_serializer,
-                                   NULL,
-                                   NULL);
 }
 

gdk/gdkdrag.c

@@ -90,30 +90,20 @@ G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GdkDrag, gdk_drag, G_TYPE_OBJECT)
 
 /**
  * SECTION:dnd
- * @Title: Drag And Drop
- * @Short_description: Functions for controlling drag and drop handling
+ * @title: Drag And Drop
+ * @short_description: Functions for controlling drag and drop handling
  *
- * These functions provide a low-level interface for drag and drop.
+ * These functions provide a low level interface for drag and drop.
  *
  * The GdkDrag object represents the source side of an ongoing DND operation.
  * It is created when a drag is started, and stays alive for duration of
- * the DND operation. After a drag has been started with gdk_drag_begin(),
- * the caller gets informed about the status of the ongoing drag operation
- * with signals on the #GtkDrag object.
+ * the DND operation.
  *
  * The GdkDrop object represents the target side of an ongoing DND operation.
- * Possible drop sites get informed about the status of the ongoing drag operation
- * with events of type %GDK_DRAG_ENTER, %GDK_DRAG_LEAVE, %GDK_DRAG_MOTION and
- * %GDK_DROP_START. The #GdkDrop object can be obtained from these #GdkEvents
- * using gdk_event_get_drop().
- *
- * The actual data transfer is initiated from the target side via an async
- * read, using one of the GdkDrop functions for this purpose: gdk_drop_read_async(),
- * gdk_drop_read_value_async() or gdk_drop_read_text_async().
  * 
- * GTK provides a higher level abstraction based on top of these functions,
- * and so they are not normally needed in GTK applications. See the
- * [Drag and Drop][gtk4-Drag-and-Drop] section of the GTK documentation
+ * GTK+ provides a higher level abstraction based on top of these functions,
+ * and so they are not normally needed in GTK+ applications. See the
+ * [Drag and Drop][gtk4-Drag-and-Drop] section of the GTK+ documentation
  * for more information.
  */
 

gdk/gdkdrop.c

@@ -448,10 +448,7 @@ gdk_drop_get_surface (GdkDrop *self)
  * Returns the possible actions for this #GdkDrop. If this value
  * contains multiple actions - ie gdk_drag_action_is_unique()
  * returns %FALSE for the result - gdk_drag_finish() must choose
- * the action to use when accepting the drop. This will only
- * happen if you passed %GDK_ACTION_ASK as one of the possible
- * actions in gdk_drag_status(). %GDK_ACTION_ASK itself will not
- * be included in the actions returned by this function.
+ * the action to use when accepting the drop.
  *
  * This value may change over the lifetime of the #GdkDrop both
  * as a response to source side actions as well as to calls to
@@ -1001,30 +998,3 @@ gdk_drop_emit_drop_event (GdkDrop  *self,
   gdk_drop_do_emit_event (event, dont_queue);
 }
 
-/**
- * gdk_drop_has_value:
- * @self: a #GdkDrop
- * @type: the type to check
- *
- * Returns whether calling gdk_drop_read_value_async() for @type
- * can succeed.
- *
- * Returns: %TRUE if the data can be deserialized to the given type
- */ 
-gboolean
-gdk_drop_has_value (GdkDrop *self,
-                    GType    type)
-{
-  GdkContentFormats *formats;
-  gboolean ret;
-
-  formats = gdk_content_formats_ref (gdk_drop_get_formats (self));
-  formats = gdk_content_formats_union_deserialize_gtypes (formats);
-
-  ret = gdk_content_formats_contain_gtype (formats, type);
-
-  gdk_content_formats_unref (formats);
-
-  return ret;
-}
-

gdk/gdkdrop.h

@@ -92,9 +92,6 @@ char *                  gdk_drop_read_text_finish       (GdkDrop
                                                          GAsyncResult           *result,
                                                          GError                **error);
 
-GDK_AVAILABLE_IN_ALL
-gboolean                gdk_drop_has_value              (GdkDrop                *self,
-                                                         GType                   type);
 
 G_END_DECLS
 

gdk/gdkevents.c

@@ -1013,13 +1013,6 @@ gdk_event_set_coords (GdkEvent *event,
       event->touchpad_pinch.x = x;
       event->touchpad_pinch.y = y;
       break;
-    case GDK_DRAG_ENTER:
-    case GDK_DRAG_LEAVE:
-    case GDK_DRAG_MOTION:
-    case GDK_DROP_START:
-      event->dnd.x = x;
-      event->dnd.y = y;
-      break;
     default:
       break;
     }

gdk/gdkglcontext.c

@@ -955,8 +955,7 @@ gdk_gl_context_check_extensions (GdkGLContext *context)
   if (priv->use_es < 0)
     priv->use_es = !epoxy_is_desktop_gl ();
 
-  priv->has_debug_output = epoxy_has_gl_extension ("GL_ARB_debug_output") ||
-                           epoxy_has_gl_extension ("GL_KHR_debug");
+  priv->has_debug_output = epoxy_has_gl_extension ("GL_ARB_debug_output");
 
 #ifdef G_ENABLE_CONSISTENCY_CHECKS
   if (priv->has_debug_output)

gdk/gdkrgba.c

@@ -100,7 +100,7 @@ gdk_rgba_free (GdkRGBA *rgba)
 gboolean
 gdk_rgba_is_clear (const GdkRGBA *rgba)
 {
-  return rgba->alpha < ((float) 0x00ff / (float) 0xffff);
+  return rgba->alpha < ((double) 0x00ff / (double) 0xffff);
 }
 
 /**
@@ -115,7 +115,7 @@ gdk_rgba_is_clear (const GdkRGBA *rgba)
 gboolean
 gdk_rgba_is_opaque (const GdkRGBA *rgba)
 {
-  return rgba->alpha > ((float)0xff00 / (float)0xffff);
+  return rgba->alpha > ((double)0xff00 / (double)0xffff);
 }
 
 #define SKIP_WHITESPACES(s) while (*(s) == ' ') (s)++;
@@ -398,25 +398,23 @@ gdk_rgba_to_string (const GdkRGBA *rgba)
 
 static gboolean
 parse_color_channel_value (GtkCssParser *parser,
-                           float        *value,
+                           double       *value,
                            gboolean      is_percentage)
 {
-  double dvalue;
-
   if (is_percentage)
     {
-      if (!gtk_css_parser_consume_percentage (parser, &dvalue))
+      if (!gtk_css_parser_consume_percentage (parser, value))
         return FALSE;
 
-      *value = CLAMP (dvalue, 0.0, 100.0) / 100.0;
+      *value = CLAMP (*value, 0.0, 100.0) / 100.0;
       return TRUE;
     }
   else
     {
-      if (!gtk_css_parser_consume_number (parser, &dvalue))
+      if (!gtk_css_parser_consume_number (parser, value))
         return FALSE;
 
-      *value = CLAMP (dvalue, 0.0, 255.0) / 255.0;
+      *value = CLAMP (*value, 0.0, 255.0) / 255.0;
       return TRUE;
     }
 }
@@ -427,7 +425,6 @@ parse_color_channel (GtkCssParser *parser,
                      gpointer      data)
 {
   GdkRGBA *rgba = data;
-  double dvalue;
 
   switch (arg)
   {
@@ -453,10 +450,10 @@ parse_color_channel (GtkCssParser *parser,
       return 1;
 
     case 3:
-      if (!gtk_css_parser_consume_number (parser, &dvalue))
+      if (!gtk_css_parser_consume_number (parser, &rgba->alpha))
         return 0;
 
-      rgba->alpha = CLAMP (dvalue, 0.0, 1.0);
+      rgba->alpha = CLAMP (rgba->alpha, 0.0, 1.0);
       return 1;
 
     default:

gdk/gdkrgba.h

@@ -36,10 +36,10 @@ G_BEGIN_DECLS
 
 struct _GdkRGBA
 {
-  float red;
-  float green;
-  float blue;
-  float alpha;
+  gdouble red;
+  gdouble green;
+  gdouble blue;
+  gdouble alpha;
 };
 
 #define GDK_TYPE_RGBA (gdk_rgba_get_type ())

gdk/gdkseat.c

@@ -248,10 +248,10 @@ gdk_seat_get_capabilities (GdkSeat *seat)
  *          elsewhere.
  * @event: (nullable): the event that is triggering the grab, or %NULL if none
  *         is available.
- * @prepare_func: (nullable) (scope call): function to
+ * @prepare_func: (nullable) (scope call) (closure prepare_func_data): function to
  *                prepare the surface to be grabbed, it can be %NULL if @surface is
  *                visible before this call.
- * @prepare_func_data: (closure): user data to pass to @prepare_func
+ * @prepare_func_data: user data to pass to @prepare_func
  *
  * Grabs the seat so that all events corresponding to the given @capabilities
  * are passed to this application until the seat is ungrabbed with gdk_seat_ungrab(),

gdk/gdksurface.c

@@ -3583,13 +3583,7 @@ gdk_surface_register_dnd (GdkSurface *surface)
  *
  * Starts a drag and creates a new drag context for it.
  *
- * This function is called by the drag source. After this call, you
- * probably want to set up the drag icon using the surface returned
- * by gdk_drag_get_drag_surface().
- *
- * Note: if @actions include %GDK_ACTION_MOVE, you need to listen for
- * the #GdkDrag::dnd-finished signal and delete the data at the source
- * if gdk_drag_get_selected_action() returns %GDK_ACTION_MOVE.
+ * This function is called by the drag source.
  *
  * Returns: (transfer full) (nullable): a newly created #GdkDrag or
  *     %NULL on error.

gdk/gdktypes.h

@@ -568,12 +568,11 @@ typedef enum
  * @GDK_ACTION_MOVE: Move the data, i.e. first copy it, then delete
  *  it from the source using the DELETE target of the X selection protocol.
  * @GDK_ACTION_LINK: Add a link to the data. Note that this is only
- *  useful if source and destination agree on what it means, and is not
- *  supported on all platforms.
+ *  useful if source and destination agree on what it means.
  * @GDK_ACTION_ASK: Ask the user what to do with the data.
  *
- * Used in #GdkDrop and #GdkDrag to indicate the actions that the
- * destination can and should do with the dropped data.
+ * Used in #GdkDrag to indicate what the destination
+ * should do with the dropped data.
  */
 typedef enum
 {

gdk/quartz/gdkdisplay-quartz.c

@@ -55,6 +55,9 @@ _gdk_quartz_display_open (const gchar *display_name)
   if (_gdk_display != NULL)
     return NULL;
 
+  /* Initialize application */
+  [NSApplication sharedApplication];
+
   _gdk_display = g_object_new (gdk_quartz_display_get_type (), NULL);
   _gdk_device_manager = _gdk_device_manager_new (_gdk_display);
 
@@ -64,8 +67,6 @@ _gdk_quartz_display_open (const gchar *display_name)
 
   _gdk_quartz_events_init ();
 
-  /* Initialize application */
-  [NSApplication sharedApplication];
 #if 0
   /* FIXME: Remove the #if 0 when we have these functions */
   _gdk_quartz_dnd_init ();

gdk/quartz/gdkkeys-quartz.c

@@ -680,6 +680,7 @@ gdk_quartz_keymap_translate_keyboard_state (GdkKeymap       *keymap,
 {
   guint tmp_keyval;
   GdkModifierType bit;
+  guint tmp_modifiers = 0;
 
   if (keyval)
     *keyval = 0;
@@ -693,23 +694,24 @@ gdk_quartz_keymap_translate_keyboard_state (GdkKeymap       *keymap,
   if (hardware_keycode < 0 || hardware_keycode >= NUM_KEYCODES)
     return FALSE;
 
+  /* Check if modifiers modify the keyval */
+  for (bit = GDK_SHIFT_MASK; bit < GDK_BUTTON1_MASK; bit <<= 1)
+    {
+      if (translate_keysym (hardware_keycode,
+                            (bit == GDK_MOD1_MASK) ? 0 : group,
+                            state & ~bit,
+                            NULL, NULL) !=
+	  translate_keysym (hardware_keycode,
+                            (bit == GDK_MOD1_MASK) ? 1 : group,
+                            state | bit,
+                            NULL, NULL))
+	tmp_modifiers |= bit;
+    }
+
   tmp_keyval = translate_keysym (hardware_keycode, group, state, level, effective_group);
 
-  /* Check if modifiers modify the keyval */
   if (consumed_modifiers)
-    {
-      guint tmp_modifiers = (state & GDK_MODIFIER_MASK);
-
-      for (bit = 1; bit <= tmp_modifiers; bit <<= 1)
-        {
-          if ((bit & tmp_modifiers) &&
-              translate_keysym (hardware_keycode, group, state & ~bit,
-                                NULL, NULL) == tmp_keyval)
-            tmp_modifiers &= ~bit;
-        }
-
-      *consumed_modifiers = tmp_modifiers;
-    }
+    *consumed_modifiers = tmp_modifiers;
 
   if (keyval)
     *keyval = tmp_keyval; 

gdk/quartz/gdksurface-quartz.c

@@ -795,7 +795,8 @@ _gdk_quartz_display_create_surface_impl (GdkDisplay    *display,
 
         if (window->surface_type == GDK_SURFACE_TEMP)
           {
-            style_mask = NSBorderlessWindowMask;
+            /* without NSMiniaturizableWindowMask window will not minimize */
+            style_mask = NSBorderlessWindowMask | NSMiniaturizableWindowMask;
           }
         else
           {
@@ -2710,6 +2711,7 @@ gdk_surface_impl_quartz_class_init (GdkSurfaceImplQuartzClass *klass)
   impl_class->set_decorations = gdk_quartz_surface_set_decorations;
   impl_class->get_decorations = gdk_quartz_surface_get_decorations;
   impl_class->set_functions = gdk_quartz_surface_set_functions;
+  impl_class->set_functions = gdk_quartz_surface_set_functions;
   impl_class->begin_resize_drag = gdk_quartz_surface_begin_resize_drag;
   impl_class->begin_move_drag = gdk_quartz_surface_begin_move_drag;
   impl_class->set_opacity = gdk_quartz_surface_set_opacity;

gdk/wayland/gdkdevice-wayland.c

@@ -1258,8 +1258,6 @@ data_device_enter (void                  *data,
   seat->pending_offer = NULL;
 
   seat->drop = gdk_wayland_drop_new (device, seat->drag, formats, dest_surface, offer, serial);
-  gdk_wayland_drop_set_source_actions (seat->drop, seat->pending_source_actions);
-  gdk_wayland_drop_set_action (seat->drop, seat->pending_action);
 
   gdk_wayland_seat_discard_pending_offer (seat);
 

gdk/wayland/gdkdrag-wayland.c

@@ -173,7 +173,7 @@ gdk_wayland_drag_drop_done (GdkDrag  *drag,
   GdkWaylandDrag *drag_wayland = GDK_WAYLAND_DRAG (drag);
   GdkDevice *device = gdk_drag_get_device (drag);
 
-  gdk_wayland_seat_set_drag (gdk_device_get_seat (device), NULL);
+  gdk_wayland_seat_set_drag (gdk_device_get_seat (device), drag);
 
   if (success)
     {

gdk/wayland/gdkdrop-wayland.c

@@ -51,6 +51,7 @@ struct _GdkWaylandDrop
   struct wl_data_offer *offer;
   uint32_t source_actions;
   uint32_t action;
+  GdkDragAction selected_action;
   uint32_t serial;
 };
 
@@ -115,43 +116,43 @@ gdk_wayland_drop_drop_set_status (GdkWaylandDrop *drop_wayland,
 }
 
 static void
-gdk_wayland_drop_commit_status (GdkWaylandDrop *wayland_drop,
-                                GdkDragAction   actions)
+gdk_wayland_drop_commit_status (GdkWaylandDrop *wayland_drop)
 {
   GdkDisplay *display;
+  uint32_t dnd_actions;
 
   display = gdk_drop_get_display (GDK_DROP (wayland_drop));
 
+  dnd_actions = gdk_to_wl_actions (wayland_drop->selected_action);
+
   if (GDK_WAYLAND_DISPLAY (display)->data_device_manager_version >=
       WL_DATA_OFFER_SET_ACTIONS_SINCE_VERSION)
     {
-      uint32_t dnd_actions;
-      uint32_t preferred_action;
-
-      dnd_actions = gdk_to_wl_actions (actions);
-
-      if (dnd_actions & WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY)
-        preferred_action = WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY;
-      else if (dnd_actions & WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE)
-        preferred_action = WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE;
-      else if (dnd_actions & WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK)
-        preferred_action = WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK;
+      if (gdk_drag_action_is_unique (wayland_drop->selected_action))
+        {
+          wl_data_offer_set_actions (wayland_drop->offer, dnd_actions, dnd_actions);
+        }
       else
-        preferred_action = 0;
-
-      wl_data_offer_set_actions (wayland_drop->offer, dnd_actions, preferred_action);
+        {
+          wl_data_offer_set_actions (wayland_drop->offer,
+                                     dnd_actions | WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK,
+                                     WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK);
+        }
     }
 
-  gdk_wayland_drop_drop_set_status (wayland_drop, actions != 0);
+  gdk_wayland_drop_drop_set_status (wayland_drop, wayland_drop->selected_action != 0);
 }
 
 static void
 gdk_wayland_drop_status (GdkDrop       *drop,
-                         GdkDragAction  actions)
+                         GdkDragAction  action)
 {
-  GdkWaylandDrop *wayland_drop = GDK_WAYLAND_DROP (drop);
+  GdkWaylandDrop *wayland_drop;
 
-  gdk_wayland_drop_commit_status (wayland_drop, actions);
+  wayland_drop = GDK_WAYLAND_DROP (drop);
+  wayland_drop->selected_action = action;
+
+  gdk_wayland_drop_commit_status (wayland_drop);
 }
 
 static void
@@ -162,9 +163,11 @@ gdk_wayland_drop_finish (GdkDrop       *drop,
   GdkDisplay *display = gdk_drop_get_display (drop);
   GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
 
+  wayland_drop->selected_action = action;
+
   if (action)
     {
-      gdk_wayland_drop_commit_status (wayland_drop, action);
+      gdk_wayland_drop_commit_status (wayland_drop);
 
       if (display_wayland->data_device_manager_version >=
           WL_DATA_OFFER_FINISH_SINCE_VERSION)
@@ -285,8 +288,7 @@ gdk_wayland_drop_update_actions (GdkWaylandDrop *drop)
   GdkDragAction gdk_actions = 0;
   uint32_t wl_actions;
 
-  if (drop->action == 0 ||
-      drop->action & WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK)
+  if (drop->action & WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK)
     wl_actions = drop->source_actions;
   else
     wl_actions = drop->action;

gdk/wayland/gdksurface-wayland.c

@@ -4109,7 +4109,7 @@ gdk_wayland_surface_is_exported (GdkSurface *surface)
  * gdk_wayland_surface_export_handle:
  * @surface: the #GdkSurface to obtain a handle for
  * @callback: callback to call with the handle
- * @user_data: (closure): user data for @callback
+ * @user_data: user data for @callback
  * @destroy_func: destroy notify for @user_data
  *
  * Asynchronously obtains a handle for a surface that can be passed

gdk/x11/gdkdrop-x11.c

@@ -747,7 +747,7 @@ gdk_x11_drop_status (GdkDrop       *drop,
                      GdkDragAction  actions)
 {
   GdkX11Drop *drop_x11 = GDK_X11_DROP (drop);
-  GdkDragAction possible_actions, suggested_action;
+  GdkDragAction possible_actions;
   XEvent xev;
   GdkDisplay *display;
 
@@ -755,17 +755,6 @@ gdk_x11_drop_status (GdkDrop       *drop,
 
   possible_actions = actions & gdk_drop_get_actions (drop);
 
-  if (drop_x11->suggested_action != 0)
-    suggested_action = drop_x11->suggested_action;
-  else if (possible_actions & GDK_ACTION_COPY)
-    suggested_action = GDK_ACTION_COPY;
-  else if (possible_actions & GDK_ACTION_MOVE)
-    suggested_action = GDK_ACTION_MOVE;
-  else if (possible_actions & GDK_ACTION_ASK)
-    suggested_action = GDK_ACTION_ASK;
-  else
-    suggested_action = 0;
-
   xev.xclient.type = ClientMessage;
   xev.xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "XdndStatus");
   xev.xclient.format = 32;
@@ -775,7 +764,7 @@ gdk_x11_drop_status (GdkDrop       *drop,
   xev.xclient.data.l[1] = (possible_actions != 0) ? (2 | 1) : 0;
   xev.xclient.data.l[2] = 0;
   xev.xclient.data.l[3] = 0;
-  xev.xclient.data.l[4] = xdnd_action_to_atom (display, suggested_action);
+  xev.xclient.data.l[4] = xdnd_action_to_atom (display, possible_actions);
 
   if (gdk_drop_get_drag (drop))
     {

gsk/gl/gskgldriver.c

@@ -590,27 +590,29 @@ gsk_gl_driver_create_texture (GskGLDriver *self,
   return t->texture_id;
 }
 
-void
-gsk_gl_driver_create_render_target (GskGLDriver *self,
-                                    int          width,
-                                    int          height,
-                                    int         *out_texture_id,
-                                    int         *out_render_target_id)
+static int
+create_render_target (GskGLDriver *self,
+                      int          texture_id,
+                      gboolean     add_depth_buffer,
+                      gboolean     add_stencil_buffer)
 {
-  GLuint fbo_id;
-  Texture *texture;
+  GLuint fbo_id, depth_stencil_buffer_id;
+  Texture *t;
 
-  g_return_if_fail (self->in_frame);
+  g_return_val_if_fail (GSK_IS_GL_DRIVER (self), -1);
+  g_return_val_if_fail (self->in_frame, -1);
 
-  texture = create_texture (self, width, height);
-  gsk_gl_driver_bind_source_texture (self, texture->texture_id);
-  gsk_gl_driver_init_texture_empty (self, texture->texture_id, GL_NEAREST, GL_NEAREST);
+  t = gsk_gl_driver_get_texture (self, texture_id);
+  if (t == NULL)
+    return -1;
+
+  if (t->fbo.fbo_id != 0)
+    fbo_clear (&t->fbo);
 
   glGenFramebuffers (1, &fbo_id);
   glBindFramebuffer (GL_FRAMEBUFFER, fbo_id);
-  glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->texture_id, 0);
+  glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, t->texture_id, 0);
 
-#if 0
   if (add_depth_buffer || add_stencil_buffer)
     {
       glGenRenderbuffersEXT (1, &depth_stencil_buffer_id);
@@ -636,18 +638,34 @@ gsk_gl_driver_create_render_target (GskGLDriver *self,
       if (add_stencil_buffer)
         glFramebufferRenderbufferEXT (GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
                                       GL_RENDERBUFFER, depth_stencil_buffer_id);
-  texture->fbo.depth_stencil_id = depth_stencil_buffer_id;
     }
-#endif
 
-  texture->fbo.fbo_id = fbo_id;
+  t->fbo.fbo_id = fbo_id;
+  t->fbo.depth_stencil_id = depth_stencil_buffer_id;
 
   g_assert_cmphex (glCheckFramebufferStatus (GL_FRAMEBUFFER), ==, GL_FRAMEBUFFER_COMPLETE);
-
   glBindFramebuffer (GL_FRAMEBUFFER, self->default_fbo.fbo_id);
 
-  *out_texture_id = texture->texture_id;
-  *out_render_target_id = fbo_id;
+  return fbo_id;
+}
+
+void
+gsk_gl_driver_create_render_target (GskGLDriver *self,
+                                    int          width,
+                                    int          height,
+                                    int         *out_texture_id,
+                                    int         *out_render_target_id)
+{
+  int texture_id, render_target;
+
+  texture_id = gsk_gl_driver_create_texture (self, width, height);
+  gsk_gl_driver_bind_source_texture (self, texture_id);
+  gsk_gl_driver_init_texture_empty (self, texture_id, GL_NEAREST, GL_NEAREST);
+
+  render_target = create_render_target (self, texture_id, FALSE, FALSE);
+
+  *out_texture_id = texture_id;
+  *out_render_target_id = render_target;
 }
 
 /* Mark the texture permanent, meaning it won'e be reused by the GLDriver.

gsk/gl/gskglglyphcache.c

@@ -195,15 +195,10 @@ upload_glyph (GlyphCacheKey    *key,
     {
       glPixelStorei (GL_UNPACK_ROW_LENGTH, r.stride / 4);
       glBindTexture (GL_TEXTURE_2D, value->texture_id);
-
-      if (gdk_gl_context_get_use_es (gdk_gl_context_get_current ()))
-        glTexSubImage2D (GL_TEXTURE_2D, 0, r.x, r.y, r.width, r.height,
-                         GL_RGBA, GL_UNSIGNED_BYTE,
-                         r.data);
-      else
-        glTexSubImage2D (GL_TEXTURE_2D, 0, r.x, r.y, r.width, r.height,
-                         GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
-                         r.data);
+      glTexSubImage2D (GL_TEXTURE_2D, 0,
+                       r.x, r.y, r.width, r.height,
+                       GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
+                       r.data);
       glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
       g_free (r.data);
     }

gsk/gl/gskgliconcache.c

@@ -83,7 +83,7 @@ gsk_gl_icon_cache_begin_frame (GskGLIconCache *self,
     }
 
   if (self->timestamp % MAX_FRAME_AGE == 0)
-    {
+    {  
       g_hash_table_iter_init (&iter, self->icons);
       while (g_hash_table_iter_next (&iter, (gpointer *)&texture, (gpointer *)&icon_data))
         {
@@ -134,7 +134,6 @@ gsk_gl_icon_cache_lookup_or_add (GskGLIconCache  *self,
     int packed_y = 0;
     cairo_surface_t *surface;
     unsigned char *surface_data;
-    guint gl_format;
 
     gsk_gl_texture_atlases_pack (self->atlases, width + 2, height + 2, &atlas, &packed_x, &packed_y);
 
@@ -156,37 +155,30 @@ gsk_gl_icon_cache_lookup_or_add (GskGLIconCache  *self,
     surface_data = cairo_image_surface_get_data (surface);
     gdk_gl_context_push_debug_group_printf (gdk_gl_context_get_current (),
                                             "Uploading texture");
-
-    if (gdk_gl_context_get_use_es (gdk_gl_context_get_current ()))
-      gl_format = GL_RGBA;
-    else
-      gl_format = GL_BGRA;
-
     glBindTexture (GL_TEXTURE_2D, atlas->texture_id);
 
     glTexSubImage2D (GL_TEXTURE_2D, 0,
                      packed_x + 1, packed_y + 1,
                      width, height,
-                     gl_format,
-                     GL_UNSIGNED_BYTE,
+                     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
                      surface_data);
     /* Padding top */
     glTexSubImage2D (GL_TEXTURE_2D, 0,
                      packed_x + 1, packed_y,
                      width, 1,
-                     gl_format, GL_UNSIGNED_BYTE,
+                     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
                      surface_data);
     /* Padding left */
     glTexSubImage2D (GL_TEXTURE_2D, 0,
                      packed_x, packed_y + 1,
                      1, height,
-                     gl_format, GL_UNSIGNED_BYTE,
+                     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
                      surface_data);
     /* Padding top left */
     glTexSubImage2D (GL_TEXTURE_2D, 0,
                      packed_x, packed_y,
                      1, 1,
-                     gl_format, GL_UNSIGNED_BYTE,
+                     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
                      surface_data);
 
     /* Padding right */
@@ -195,13 +187,13 @@ gsk_gl_icon_cache_lookup_or_add (GskGLIconCache  *self,
     glTexSubImage2D (GL_TEXTURE_2D, 0,
                      packed_x + width + 1, packed_y + 1,
                      1, height,
-                     gl_format, GL_UNSIGNED_BYTE,
+                     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
                      surface_data);
     /* Padding top right */
     glTexSubImage2D (GL_TEXTURE_2D, 0,
                      packed_x + width + 1, packed_y,
                      1, 1,
-                     gl_format, GL_UNSIGNED_BYTE,
+                     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
                      surface_data);
     /* Padding bottom */
     glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
@@ -210,13 +202,13 @@ gsk_gl_icon_cache_lookup_or_add (GskGLIconCache  *self,
     glTexSubImage2D (GL_TEXTURE_2D, 0,
                      packed_x + 1, packed_y + 1 + height,
                      width, 1,
-                     gl_format, GL_UNSIGNED_BYTE,
+                     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
                      surface_data);
     /* Padding bottom left */
     glTexSubImage2D (GL_TEXTURE_2D, 0,
                      packed_x, packed_y + 1 + height,
                      1, 1,
-                     gl_format, GL_UNSIGNED_BYTE,
+                     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
                      surface_data);
     /* Padding bottom right */
     glPixelStorei (GL_UNPACK_ROW_LENGTH, width);
@@ -224,8 +216,9 @@ gsk_gl_icon_cache_lookup_or_add (GskGLIconCache  *self,
     glTexSubImage2D (GL_TEXTURE_2D, 0,
                      packed_x + 1 + width, packed_y + 1 + height,
                      1, 1,
-                     gl_format, GL_UNSIGNED_BYTE,
+                     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
                      surface_data);
+
     /* Reset this */
     glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
     glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
@@ -246,7 +239,7 @@ gsk_gl_icon_cache_lookup_or_add (GskGLIconCache  *self,
       char *filename = g_strdup_printf ("atlas_%u_%d.png", atlas->texture_id, k++);
 
       glBindTexture (GL_TEXTURE_2D, atlas->texture_id);
-      glGetTexImage (GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
+      glGetTexImage (GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
       s = cairo_image_surface_create_for_data (data, CAIRO_FORMAT_ARGB32, atlas->width, atlas->height, stride);
       cairo_surface_write_to_png (s, filename);
 

gsk/gl/gskglrenderops.c

@@ -8,46 +8,6 @@ rect_equal (const graphene_rect_t *a,
   return memcmp (a, b, sizeof (graphene_rect_t)) == 0;
 }
 
-static inline gboolean
-rounded_rect_equal (const GskRoundedRect *r1,
-                    const GskRoundedRect *r2)
-{
-  int i;
-
-  if (!r1)
-    return FALSE;
-
-  if (r1->bounds.origin.x != r2->bounds.origin.x ||
-      r1->bounds.origin.y != r2->bounds.origin.y ||
-      r1->bounds.size.width != r2->bounds.size.width ||
-      r1->bounds.size.height != r2->bounds.size.height)
-    return FALSE;
-
-  for (i = 0; i < 4; i ++)
-    if (r1->corner[i].width != r2->corner[i].width ||
-        r1->corner[i].height != r2->corner[i].height)
-      return FALSE;
-
-  return TRUE;
-}
-
-static inline gboolean
-rounded_rect_corners_equal (const GskRoundedRect *r1,
-                            const GskRoundedRect *r2)
-{
-  int i;
-
-  if (!r1)
-    return FALSE;
-
-  for (i = 0; i < 4; i ++)
-    if (r1->corner[i].width != r2->corner[i].width ||
-        r1->corner[i].height != r2->corner[i].height)
-      return FALSE;
-
-  return TRUE;
-}
-
 static inline ProgramState *
 get_current_program_state (RenderOpBuilder *builder)
 {
@@ -81,6 +41,16 @@ ops_finish (RenderOpBuilder *builder)
   builder->current_viewport = GRAPHENE_RECT_INIT (0, 0, 0, 0);
 }
 
+static inline void
+rgba_to_float (const GdkRGBA *c,
+               float         *f)
+{
+  f[0] = c->red;
+  f[1] = c->green;
+  f[2] = c->blue;
+  f[3] = c->alpha;
+}
+
 /* Debugging only! */
 void
 ops_dump_framebuffer (RenderOpBuilder *builder,
@@ -127,12 +97,15 @@ static void
 extract_matrix_metadata (GskTransform      *transform,
                          OpsMatrixMetadata *md)
 {
-  float dummy;
-
   switch (gsk_transform_get_category (transform))
     {
     case GSK_TRANSFORM_CATEGORY_IDENTITY:
+      md->scale_x = 1;
+      md->scale_y = 1;
+    break;
+
     case GSK_TRANSFORM_CATEGORY_2D_TRANSLATE:
+      gsk_transform_to_translate (transform, &md->translate_x, &md->translate_y);
       md->scale_x = 1;
       md->scale_y = 1;
     break;
@@ -140,7 +113,7 @@ extract_matrix_metadata (GskTransform      *transform,
     case GSK_TRANSFORM_CATEGORY_2D_AFFINE:
       gsk_transform_to_affine (transform,
                                &md->scale_x, &md->scale_y,
-                               &dummy, &dummy);
+                               &md->translate_x, &md->translate_y);
     break;
 
     case GSK_TRANSFORM_CATEGORY_UNKNOWN:
@@ -156,6 +129,9 @@ extract_matrix_metadata (GskTransform      *transform,
 
         /* TODO: 90% sure this is incorrect. But we should never hit this code
          * path anyway. */
+        md->translate_x = graphene_matrix_get_value (&m, 3, 0);
+        md->translate_y = graphene_matrix_get_value (&m, 3, 1);
+
         graphene_vec3_init (&col1,
                             graphene_matrix_get_value (&m, 0, 0),
                             graphene_matrix_get_value (&m, 1, 0),
@@ -180,13 +156,17 @@ ops_transform_bounds_modelview (const RenderOpBuilder *builder,
                                 const graphene_rect_t *src,
                                 graphene_rect_t       *dst)
 {
+  const MatrixStackEntry *head;
+
   g_assert (builder->mv_stack != NULL);
   g_assert (builder->mv_stack->len >= 1);
 
+  head = &g_array_index (builder->mv_stack, MatrixStackEntry, builder->mv_stack->len - 1);
+
   gsk_transform_transform_bounds (builder->current_modelview, src, dst);
 
-  dst->origin.x += builder->dx * builder->scale_x;
-  dst->origin.y += builder->dy * builder->scale_y;
+  dst->origin.x += builder->dx * head->metadata.scale_x;
+  dst->origin.y += builder->dy * head->metadata.scale_y;
 }
 
 void
@@ -225,6 +205,11 @@ void
 ops_set_program (RenderOpBuilder *builder,
                  const Program   *program)
 {
+  /* The tricky part about this is that we want to initialize all uniforms of a program
+   * to the current value from the builder, but only once. */
+  static const GskRoundedRect empty_clip;
+  static const graphene_matrix_t empty_matrix;
+  static const graphene_rect_t empty_rect;
   OpProgram *op;
   ProgramState *program_state;
 
@@ -238,7 +223,9 @@ ops_set_program (RenderOpBuilder *builder,
 
   program_state = &builder->program_state[program->index];
 
-  if (memcmp (&builder->current_projection, &program_state->projection, sizeof (graphene_matrix_t)) != 0)
+  /* If the projection is not yet set for this program, we use the current one. */
+  if (memcmp (&empty_matrix, &program_state->projection, sizeof (graphene_matrix_t)) == 0 ||
+      memcmp (&builder->current_projection, &program_state->projection, sizeof (graphene_matrix_t)) != 0)
     {
       OpMatrix *opm;
 
@@ -258,7 +245,8 @@ ops_set_program (RenderOpBuilder *builder,
       program_state->modelview = gsk_transform_ref (builder->current_modelview);
     }
 
-  if (!rect_equal (&builder->current_viewport, &program_state->viewport))
+  if (rect_equal (&empty_rect, &program_state->viewport) ||
+      !rect_equal (&builder->current_viewport, &program_state->viewport))
     {
       OpViewport *opv;
 
@@ -267,13 +255,13 @@ ops_set_program (RenderOpBuilder *builder,
       program_state->viewport = builder->current_viewport;
     }
 
-  if (!rounded_rect_equal (builder->current_clip, &program_state->clip))
+  if (memcmp (&empty_clip, &program_state->clip, sizeof (GskRoundedRect)) == 0 ||
+      memcmp (&builder->current_clip, &program_state->clip, sizeof (GskRoundedRect)) != 0)
     {
       OpClip *opc;
 
       opc = ops_begin (builder, OP_CHANGE_CLIP);
       opc->clip = *builder->current_clip;
-      opc->send_corners = !rounded_rect_corners_equal (builder->current_clip, &program_state->clip);
       program_state->clip = *builder->current_clip;
     }
 
@@ -295,25 +283,15 @@ ops_set_clip (RenderOpBuilder      *builder,
   OpClip *op;
 
   if (current_program_state &&
-      rounded_rect_equal (&current_program_state->clip, clip))
+      memcmp (&current_program_state->clip, clip,sizeof (GskRoundedRect)) == 0)
     return;
 
   if (!(op = op_buffer_peek_tail_checked (&builder->render_ops, OP_CHANGE_CLIP)))
-    {
-      op = op_buffer_add (&builder->render_ops, OP_CHANGE_CLIP);
-      op->send_corners = !current_program_state ||
-                         !rounded_rect_corners_equal (&current_program_state->clip, clip);
-    }
-  else
-    {
-      /* If the op before sent the corners, this one needs, too */
-      op->send_corners |= !current_program_state ||
-                          !rounded_rect_corners_equal (&current_program_state->clip, clip);
-    }
+    op = op_buffer_add (&builder->render_ops, OP_CHANGE_CLIP);
 
   op->clip = *clip;
 
-  if (current_program_state)
+  if (builder->current_program != NULL)
     current_program_state->clip = *clip;
 }
 
@@ -365,6 +343,7 @@ ops_set_modelview_internal (RenderOpBuilder *builder,
                             GskTransform    *transform)
 {
   ProgramState *current_program_state = get_current_program_state (builder);
+  graphene_matrix_t matrix;
   OpMatrix *op;
 
 #if 0
@@ -374,10 +353,12 @@ ops_set_modelview_internal (RenderOpBuilder *builder,
     return;
 #endif
 
+  gsk_transform_to_matrix (transform, &matrix);
+
   if (!(op = op_buffer_peek_tail_checked (&builder->render_ops, OP_CHANGE_MODELVIEW)))
     op = op_buffer_add (&builder->render_ops, OP_CHANGE_MODELVIEW);
 
-  gsk_transform_to_matrix (transform, &op->matrix);
+  op->matrix = matrix;
 
   if (builder->current_program != NULL)
     {
@@ -616,7 +597,7 @@ ops_set_color (RenderOpBuilder *builder,
   current_program_state->color = *color;
 
   op = ops_begin (builder, OP_CHANGE_COLOR);
-  op->rgba = color;
+  op->rgba = *color;
 }
 
 void
@@ -639,8 +620,8 @@ ops_set_color_matrix (RenderOpBuilder         *builder,
   current_program_state->color_matrix.offset = *offset;
 
   op = ops_begin (builder, OP_CHANGE_COLOR_MATRIX);
-  op->matrix = matrix;
-  op->offset = offset;
+  op->matrix = *matrix;
+  op->offset = *offset;
 }
 
 void
@@ -687,17 +668,19 @@ ops_set_border_color (RenderOpBuilder *builder,
 {
   ProgramState *current_program_state = get_current_program_state (builder);
   OpBorder *op;
+  float fcolor[4];
 
-  if (gdk_rgba_equal (color, &current_program_state->border.color))
+  rgba_to_float (color, fcolor);
+
+  if (memcmp (fcolor, &current_program_state->border.color, sizeof fcolor) == 0)
     return;
 
   op = op_buffer_add (&builder->render_ops, OP_CHANGE_BORDER_COLOR);
-  op->color = color;
-
-  current_program_state->border.color = *color;
+  memcpy (op->color, fcolor, sizeof (float[4]));
+  memcpy (current_program_state->border.color, fcolor, sizeof (float[4]));
 }
 
-GskQuadVertex *
+void
 ops_draw (RenderOpBuilder     *builder,
           const GskQuadVertex  vertex_data[GL_N_VERTICES])
 {
@@ -714,14 +697,7 @@ ops_draw (RenderOpBuilder     *builder,
       op->vao_size = GL_N_VERTICES;
     }
 
-  if (vertex_data)
-    {
-      g_array_append_vals (builder->vertices, vertex_data, GL_N_VERTICES);
-      return NULL; /* Better not use this on the caller side */
-    }
-
-  g_array_set_size (builder->vertices, builder->vertices->len + GL_N_VERTICES);
-  return &g_array_index (builder->vertices, GskQuadVertex, builder->vertices->len - GL_N_VERTICES);
+  g_array_append_vals (builder->vertices, vertex_data, GL_N_VERTICES);
 }
 
 /* The offset is only valid for the current modelview.

gsk/gl/gskglrenderopsprivate.h

@@ -15,8 +15,12 @@
 #define GL_N_VERTICES 6
 #define GL_N_PROGRAMS 13
 
+
+
 typedef struct
 {
+  float translate_x;
+  float translate_y;
   float scale_x;
   float scale_y;
 
@@ -40,10 +44,14 @@ struct _Program
   int position_location;
   int uv_location;
   int alpha_location;
+  int blend_mode_location;
   int viewport_location;
   int projection_location;
   int modelview_location;
-  int clip_rect_location;
+  int clip_location;
+  int clip_corner_widths_location;
+  int clip_corner_heights_location;
+
   union {
     struct {
       int color_location;
@@ -58,6 +66,7 @@ struct _Program
     struct {
       int num_color_stops_location;
       int color_stops_location;
+      int color_offsets_location;
       int start_point_location;
       int end_point_location;
     } linear_gradient;
@@ -70,13 +79,19 @@ struct _Program
       int color_location;
       int spread_location;
       int offset_location;
-      int outline_rect_location;
+      int outline_location;
+      int corner_widths_location;
+      int corner_heights_location;
     } inset_shadow;
     struct {
-      int outline_rect_location;
+      int outline_location;
+      int corner_widths_location;
+      int corner_heights_location;
     } outset_shadow;
     struct {
-      int outline_rect_location;
+      int outline_location;
+      int corner_widths_location;
+      int corner_heights_location;
       int color_location;
       int spread_location;
       int offset_location;
@@ -84,7 +99,9 @@ struct _Program
     struct {
       int color_location;
       int widths_location;
-      int outline_rect_location;
+      int outline_location;
+      int corner_widths_location;
+      int corner_heights_location;
     } border;
     struct {
       int source2_location;
@@ -118,7 +135,7 @@ typedef struct
     } color_matrix;
     struct {
       float widths[4];
-      GdkRGBA color;
+      float color[4];
       GskRoundedRect outline;
     } border;
   };
@@ -213,7 +230,7 @@ void              ops_set_border_width   (RenderOpBuilder         *builder,
 void              ops_set_border_color   (RenderOpBuilder         *builder,
                                           const GdkRGBA           *color);
 
-GskQuadVertex *   ops_draw               (RenderOpBuilder        *builder,
+void              ops_draw               (RenderOpBuilder        *builder,
                                           const GskQuadVertex     vertex_data[GL_N_VERTICES]);
 
 void              ops_offset             (RenderOpBuilder        *builder,

gsk/gl/gskglshaderbuilder.c

@@ -1,198 +0,0 @@
-#include "config.h"
-
-#include "gskglshaderbuilderprivate.h"
-
-#include "gskdebugprivate.h"
-
-#include <gdk/gdk.h>
-#include <epoxy/gl.h>
-
-void
-gsk_gl_shader_builder_init (GskGLShaderBuilder *self,
-                            const char         *vs_preamble_resource_path,
-                            const char         *fs_preamble_resource_path)
-{
-  memset (self, 0, sizeof (*self));
-
-  self->vs_preamble = g_resources_lookup_data (vs_preamble_resource_path, 0, NULL);
-  self->fs_preamble = g_resources_lookup_data (fs_preamble_resource_path, 0, NULL);
-
-  g_assert (self->vs_preamble);
-  g_assert (self->fs_preamble);
-}
-
-void
-gsk_gl_shader_builder_finish (GskGLShaderBuilder *self)
-{
-  g_bytes_unref (self->vs_preamble);
-  g_bytes_unref (self->fs_preamble);
-}
-
-void
-gsk_gl_shader_builder_set_glsl_version (GskGLShaderBuilder *self,
-                                        int                 version)
-{
-  self->version = version;
-}
-
-static gboolean
-check_shader_error (int     shader_id,
-                    GError **error)
-{
-  int status;
-  int log_len;
-  char *buffer;
-  int code_len;
-  char *code;
-
-  glGetShaderiv (shader_id, GL_COMPILE_STATUS, &status);
-
-  if (G_LIKELY (status == GL_TRUE))
-    return TRUE;
-
-  glGetShaderiv (shader_id, GL_INFO_LOG_LENGTH, &log_len);
-  buffer = g_malloc0 (log_len + 1);
-  glGetShaderInfoLog (shader_id, log_len, NULL, buffer);
-
-  glGetShaderiv (shader_id, GL_SHADER_SOURCE_LENGTH, &code_len);
-  code = g_malloc0 (code_len + 1);
-  glGetShaderSource (shader_id, code_len, NULL, code);
-
-  g_set_error (error, GDK_GL_ERROR, GDK_GL_ERROR_COMPILATION_FAILED,
-               "Compilation failure in shader.\nError message: %s\n\nSource code:\n%s\n\n",
-               buffer,
-               code);
-
-  g_free (buffer);
-  g_free (code);
-
-  return FALSE;
-}
-
-int
-gsk_gl_shader_builder_create_program (GskGLShaderBuilder  *self,
-                                      const char          *resource_path,
-                                      GError             **error)
-{
-
-  GBytes *source_bytes = g_resources_lookup_data (resource_path, 0, NULL);
-  char version_buffer[64];
-  const char *source;
-  const char *vertex_shader_start;
-  const char *fragment_shader_start;
-  int vertex_id;
-  int fragment_id;
-  int program_id = -1;
-  int status;
-
-  g_assert (source_bytes);
-
-  source = g_bytes_get_data (source_bytes, NULL);
-  vertex_shader_start = strstr (source, "VERTEX_SHADER");
-  fragment_shader_start = strstr (source, "FRAGMENT_SHADER");
-
-  g_assert (vertex_shader_start);
-  g_assert (fragment_shader_start);
-
-  /* They both start at the next newline */
-  vertex_shader_start = strstr (vertex_shader_start, "\n");
-  fragment_shader_start = strstr (fragment_shader_start, "\n");
-
-  g_snprintf (version_buffer, sizeof (version_buffer),
-              "#version %d\n", self->version);
-
-  vertex_id = glCreateShader (GL_VERTEX_SHADER);
-  glShaderSource (vertex_id, 7,
-                  (const char *[]) {
-                    version_buffer,
-                    self->debugging ? "#define GSK_DEBUG 1\n" : "",
-                    self->legacy ? "#define GSK_LEGACY 1\n" : "",
-                    self->gl3 ? "#define GSK_GL3 1\n" : "",
-                    self->gles ? "#define GSK_GLES 1\n" : "",
-                    g_bytes_get_data (self->vs_preamble, NULL),
-                    vertex_shader_start
-                  },
-                  (int[]) {
-                    -1,
-                    -1,
-                    -1,
-                    -1,
-                    -1,
-                    -1,
-                    fragment_shader_start - vertex_shader_start
-                  });
-  glCompileShader (vertex_id);
-
-  if (!check_shader_error (vertex_id, error))
-    {
-      glDeleteShader (vertex_id);
-      goto out;
-    }
-
-  fragment_id = glCreateShader (GL_FRAGMENT_SHADER);
-  glShaderSource (fragment_id, 7,
-                  (const char *[]) {
-                    version_buffer,
-                    self->debugging ? "#define GSK_DEBUG 1\n" : "",
-                    self->legacy ? "#define GSK_LEGACY 1\n" : "",
-                    self->gl3 ? "#define GSK_GL3 1\n" : "",
-                    self->gles ? "#define GSK_GLES 1\n" : "",
-                    g_bytes_get_data (self->fs_preamble, NULL),
-                    fragment_shader_start
-                  },
-                  (int[]) {
-                    -1,
-                    -1,
-                    -1,
-                    -1,
-                    -1,
-                    -1,
-                    -1,
-                  });
-  glCompileShader (fragment_id);
-
-  if (!check_shader_error (fragment_id, error))
-    {
-      glDeleteShader (fragment_id);
-      goto out;
-    }
-
-  program_id = glCreateProgram ();
-  glAttachShader (program_id, vertex_id);
-  glAttachShader (program_id, fragment_id);
-  glLinkProgram (program_id);
-
-  glGetProgramiv (program_id, GL_LINK_STATUS, &status);
-  if (status == GL_FALSE)
-    {
-      char *buffer = NULL;
-      int log_len = 0;
-
-      glGetProgramiv (program_id, GL_INFO_LOG_LENGTH, &log_len);
-
-      buffer = g_malloc0 (log_len + 1);
-      glGetProgramInfoLog (program_id, log_len, NULL, buffer);
-
-      g_warning ("Linking failure in shader:\n%s", buffer);
-      g_set_error (error, GDK_GL_ERROR, GDK_GL_ERROR_LINK_FAILED,
-                   "Linking failure in shader: %s", buffer);
-
-      g_free (buffer);
-
-      glDeleteProgram (program_id);
-
-      goto out;
-    }
-
-  glDetachShader (program_id, vertex_id);
-  glDeleteShader (vertex_id);
-
-  glDetachShader (program_id, fragment_id);
-  glDeleteShader (fragment_id);
-
-out:
-  g_bytes_unref (source_bytes);
-
-  return program_id;
-}
-

gsk/gl/gskglshaderbuilderprivate.h

@@ -1,38 +0,0 @@
-#ifndef __GSK_SHADER_BUILDER_PRIVATE_H__
-#define __GSK_SHADER_BUILDER_PRIVATE_H__
-
-#include <gdk/gdk.h>
-#include <graphene.h>
-
-G_BEGIN_DECLS
-
-typedef struct
-{
-  GBytes *vs_preamble;
-  GBytes *fs_preamble;
-
-  int version;
-
-  guint debugging: 1;
-  guint gles: 1;
-  guint gl3: 1;
-  guint legacy: 1;
-
-} GskGLShaderBuilder;
-
-
-void   gsk_gl_shader_builder_init             (GskGLShaderBuilder  *self,
-                                               const char          *vs_preamble_resource_path,
-                                               const char          *fs_preamble_resource_path);
-void   gsk_gl_shader_builder_finish           (GskGLShaderBuilder  *self);
-
-void   gsk_gl_shader_builder_set_glsl_version (GskGLShaderBuilder  *self,
-                                               int                  version);
-
-int    gsk_gl_shader_builder_create_program   (GskGLShaderBuilder  *self,
-                                               const char          *resource_path,
-                                               GError             **error);
-
-G_END_DECLS
-
-#endif /* __GSK_SHADER_BUILDER_PRIVATE_H__ */

gsk/gl/gskgltextureatlas.c

@@ -166,8 +166,7 @@ gsk_gl_texture_atlases_pack (GskGLTextureAtlases *self,
       g_ptr_array_add (self->atlases, atlas);
 
       /* Pack it onto that one, which surely has enough space... */
-      if (!gsk_gl_texture_atlas_pack (atlas, width, height, &x, &y))
-        g_assert_not_reached ();
+      gsk_gl_texture_atlas_pack (atlas, width, height, &x, &y);
 
       GSK_NOTE(GLYPH_CACHE, g_message ("adding new atlas"));
     }
@@ -305,5 +304,5 @@ gsk_gl_texture_atlas_realize (GskGLTextureAtlas *atlas)
   atlas->texture_id = create_shared_texture (atlas->width, atlas->height);
   gdk_gl_context_label_object_printf (gdk_gl_context_get_current (),
                                       GL_TEXTURE, atlas->texture_id,
-                                      "Texture atlas %d", atlas->texture_id);
+                                      "Glyph atlas %d", atlas->texture_id);
 }

gsk/gl/gskshaderbuilder.c

@@ -0,0 +1,332 @@
+#include "config.h"
+
+#include "gskshaderbuilderprivate.h"
+
+#include "gskdebugprivate.h"
+
+#include <gdk/gdk.h>
+#include <epoxy/gl.h>
+
+struct _GskShaderBuilder
+{
+  GObject parent_instance;
+
+  char *resource_base_path;
+  char *vertex_preamble;
+  char *fragment_preamble;
+
+
+  int common_vertex_shader_id;
+
+  int version;
+
+  GPtrArray *defines;
+
+  /* We reuse this one for all the shaders */
+  GString *shader_code;
+};
+
+G_DEFINE_TYPE (GskShaderBuilder, gsk_shader_builder, G_TYPE_OBJECT)
+
+static void
+gsk_shader_builder_finalize (GObject *gobject)
+{
+  GskShaderBuilder *self = GSK_SHADER_BUILDER (gobject);
+
+  g_free (self->resource_base_path);
+  g_free (self->vertex_preamble);
+  g_free (self->fragment_preamble);
+  g_string_free (self->shader_code, TRUE);
+
+  g_clear_pointer (&self->defines, g_ptr_array_unref);
+
+  if (self->common_vertex_shader_id > 0)
+    glDeleteShader (self->common_vertex_shader_id);
+
+  G_OBJECT_CLASS (gsk_shader_builder_parent_class)->finalize (gobject);
+}
+
+static void
+gsk_shader_builder_class_init (GskShaderBuilderClass *klass)
+{
+  G_OBJECT_CLASS (klass)->finalize = gsk_shader_builder_finalize;
+}
+
+static void
+gsk_shader_builder_init (GskShaderBuilder *self)
+{
+  self->defines = g_ptr_array_new_with_free_func (g_free);
+  self->shader_code = g_string_new (NULL);
+}
+
+GskShaderBuilder *
+gsk_shader_builder_new (void)
+{
+  return g_object_new (GSK_TYPE_SHADER_BUILDER, NULL);
+}
+
+void
+gsk_shader_builder_set_resource_base_path (GskShaderBuilder *builder,
+                                           const char       *base_path)
+{
+  g_return_if_fail (GSK_IS_SHADER_BUILDER (builder));
+
+  g_free (builder->resource_base_path);
+  builder->resource_base_path = g_strdup (base_path);
+}
+
+void
+gsk_shader_builder_set_vertex_preamble (GskShaderBuilder *builder,
+                                        const char       *vertex_preamble)
+{
+  g_return_if_fail (GSK_IS_SHADER_BUILDER (builder));
+
+  g_free (builder->vertex_preamble);
+  builder->vertex_preamble = g_strdup (vertex_preamble);
+}
+
+void
+gsk_shader_builder_set_fragment_preamble (GskShaderBuilder *builder,
+                                          const char       *fragment_preamble)
+{
+  g_return_if_fail (GSK_IS_SHADER_BUILDER (builder));
+
+  g_free (builder->fragment_preamble);
+  builder->fragment_preamble = g_strdup (fragment_preamble);
+}
+
+void
+gsk_shader_builder_set_version (GskShaderBuilder *builder,
+                                int               version)
+{
+  g_return_if_fail (GSK_IS_SHADER_BUILDER (builder));
+
+  builder->version = version;
+}
+
+void
+gsk_shader_builder_add_define (GskShaderBuilder *builder,
+                               const char       *define_name,
+                               const char       *define_value)
+{
+  g_return_if_fail (GSK_IS_SHADER_BUILDER (builder));
+  g_return_if_fail (define_name != NULL && *define_name != '\0');
+  g_return_if_fail (define_value != NULL && *define_value != '\0');
+
+  g_ptr_array_add (builder->defines, g_strdup (define_name));
+  g_ptr_array_add (builder->defines, g_strdup (define_value));
+}
+
+static gboolean
+lookup_shader_code (GString *code,
+                    const char *base_path,
+                    const char *shader_file,
+                    GError **error)
+{
+  GBytes *source;
+  char *path;
+
+  if (base_path != NULL)
+    path = g_build_filename (base_path, shader_file, NULL);
+  else
+    path = g_strdup (shader_file);
+
+  source = g_resources_lookup_data (path, 0, error);
+  g_free (path);
+
+  if (source == NULL)
+    return FALSE;
+
+  g_string_append (code, g_bytes_get_data (source, NULL));
+
+  g_bytes_unref (source);
+
+  return TRUE;
+}
+
+static int
+gsk_shader_builder_compile_shader (GskShaderBuilder *builder,
+                                   int               shader_type,
+                                   const char       *shader_preamble,
+                                   const char       *shader_source,
+                                   GError          **error)
+{
+  GString *code;
+  const char *source;
+  int shader_id;
+  int status;
+  int i;
+
+  /* Clear possibly previously set shader code */
+  g_string_erase (builder->shader_code, 0, -1);
+  code = builder->shader_code;
+
+  if (builder->version > 0)
+    {
+      g_string_append_printf (code, "#version %d\n", builder->version);
+      g_string_append_c (code, '\n');
+    }
+
+  for (i = 0; i < builder->defines->len; i += 2)
+    {
+      const char *name = g_ptr_array_index (builder->defines, i);
+      const char *value = g_ptr_array_index (builder->defines, i + 1);
+
+      g_string_append (code, "#define");
+      g_string_append_c (code, ' ');
+      g_string_append (code, name);
+      g_string_append_c (code, ' ');
+      g_string_append (code, value);
+      g_string_append_c (code, '\n');
+    }
+
+  g_string_append_c (code, '\n');
+
+  if (!lookup_shader_code (code, builder->resource_base_path, shader_preamble, error))
+    {
+      return -1;
+    }
+
+  g_string_append_c (code, '\n');
+
+  if (!lookup_shader_code (code, builder->resource_base_path, shader_source, error))
+    {
+      return -1;
+    }
+
+  source = code->str;
+
+  shader_id = glCreateShader (shader_type);
+  glShaderSource (shader_id, 1, (const GLchar **) &source, NULL);
+  glCompileShader (shader_id);
+
+#ifdef G_ENABLE_DEBUG
+  if (GSK_DEBUG_CHECK (SHADERS))
+    {
+      g_print ("*** Compiling %s shader from '%s' + '%s' ***\n"
+               "%s\n",
+               shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment",
+               shader_preamble, shader_source,
+               source);
+    }
+#endif
+
+  glGetShaderiv (shader_id, GL_COMPILE_STATUS, &status);
+  if (status == GL_FALSE)
+    {
+      int log_len;
+      char *buffer;
+
+      glGetShaderiv (shader_id, GL_INFO_LOG_LENGTH, &log_len);
+
+      buffer = g_malloc0 (log_len + 1);
+      glGetShaderInfoLog (shader_id, log_len, NULL, buffer);
+
+      g_set_error (error, GDK_GL_ERROR, GDK_GL_ERROR_COMPILATION_FAILED,
+                   "Compilation failure in %s shader:\n%s",
+                   shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment",
+                   buffer);
+      g_free (buffer);
+
+      glDeleteShader (shader_id);
+
+      return -1;
+    }
+
+  return shader_id;
+}
+
+void
+gsk_shader_builder_set_common_vertex_shader (GskShaderBuilder  *self,
+                                             const char        *vertex_shader,
+                                             GError           **error)
+{
+  int shader_id;
+
+
+  shader_id = gsk_shader_builder_compile_shader (self,
+                                                 GL_VERTEX_SHADER,
+                                                 self->vertex_preamble,
+                                                 vertex_shader,
+                                                 error);
+
+  g_assert (shader_id > 0);
+  self->common_vertex_shader_id = shader_id;
+}
+
+int
+gsk_shader_builder_create_program (GskShaderBuilder *builder,
+                                   const char       *fragment_shader,
+                                   const char       *vertex_shader,
+                                   GError          **error)
+{
+  int vertex_id;
+  int fragment_id;
+  int program_id;
+  int status;
+
+  g_return_val_if_fail (GSK_IS_SHADER_BUILDER (builder), -1);
+  g_return_val_if_fail (fragment_shader != NULL, -1);
+  g_return_val_if_fail (builder->common_vertex_shader_id != 0, -1);
+
+  if (vertex_shader == NULL)
+    vertex_id = builder->common_vertex_shader_id;
+  else
+    vertex_id = gsk_shader_builder_compile_shader (builder, GL_VERTEX_SHADER,
+                                                   builder->vertex_preamble,
+                                                   vertex_shader,
+                                                   error);
+  if (vertex_id < 0)
+      return -1;
+
+  fragment_id = gsk_shader_builder_compile_shader (builder, GL_FRAGMENT_SHADER,
+                                                   builder->fragment_preamble,
+                                                   fragment_shader,
+                                                   error);
+  if (fragment_id < 0)
+    {
+      glDeleteShader (vertex_id);
+      return -1;
+    }
+
+  program_id = glCreateProgram ();
+  glAttachShader (program_id, vertex_id);
+  glAttachShader (program_id, fragment_id);
+  glLinkProgram (program_id);
+
+  glGetProgramiv (program_id, GL_LINK_STATUS, &status);
+  if (status == GL_FALSE)
+    {
+      char *buffer = NULL;
+      int log_len = 0;
+
+      glGetProgramiv (program_id, GL_INFO_LOG_LENGTH, &log_len);
+
+      buffer = g_malloc0 (log_len + 1);
+      glGetProgramInfoLog (program_id, log_len, NULL, buffer);
+
+      g_set_error (error, GDK_GL_ERROR, GDK_GL_ERROR_LINK_FAILED,
+                   "Linking failure in shader:\n%s", buffer);
+      g_free (buffer);
+
+      glDeleteProgram (program_id);
+      program_id = -1;
+
+      goto out;
+    }
+
+out:
+  if (vertex_id > 0)
+    {
+      /* We delete the common vertex shader when destroying the shader builder */
+      glDetachShader (program_id, vertex_id);
+    }
+
+  if (fragment_id > 0)
+    {
+      glDetachShader (program_id, fragment_id);
+      glDeleteShader (fragment_id);
+    }
+
+  return program_id;
+}

gsk/gl/gskshaderbuilderprivate.h

@@ -0,0 +1,39 @@
+#ifndef __GSK_SHADER_BUILDER_PRIVATE_H__
+#define __GSK_SHADER_BUILDER_PRIVATE_H__
+
+#include <gdk/gdk.h>
+#include <graphene.h>
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_SHADER_BUILDER (gsk_shader_builder_get_type ())
+
+G_DECLARE_FINAL_TYPE (GskShaderBuilder, gsk_shader_builder, GSK, SHADER_BUILDER, GObject)
+
+GskShaderBuilder *      gsk_shader_builder_new                          (void);
+
+void                    gsk_shader_builder_set_version                  (GskShaderBuilder *builder,
+                                                                         int               version);
+void                    gsk_shader_builder_set_resource_base_path       (GskShaderBuilder *builder,
+                                                                         const char       *base_path);
+void                    gsk_shader_builder_set_vertex_preamble          (GskShaderBuilder *builder,
+                                                                         const char       *shader_preamble);
+void                    gsk_shader_builder_set_fragment_preamble        (GskShaderBuilder *builder,
+                                                                         const char       *shader_preamble);
+
+void                    gsk_shader_builder_add_define                   (GskShaderBuilder *builder,
+                                                                         const char       *define_name,
+                                                                         const char       *define_value);
+
+void                    gsk_shader_builder_set_common_vertex_shader     (GskShaderBuilder  *self,
+                                                                         const char        *vertex_shader,
+                                                                         GError           **error);
+
+int                     gsk_shader_builder_create_program               (GskShaderBuilder *builder,
+                                                                         const char       *fragment_shader,
+                                                                         const char       *vertex_shader,
+                                                                         GError          **error);
+
+G_END_DECLS
+
+#endif /* __GSK_SHADER_BUILDER_PRIVATE_H__ */

gsk/gl/opbuffer.h

@@ -77,7 +77,7 @@ typedef struct
 
 typedef struct
 {
-  const GdkRGBA *rgba;
+  GdkRGBA rgba;
 } OpColor;
 
 typedef struct
@@ -88,7 +88,6 @@ typedef struct
 typedef struct
 {
   GskRoundedRect clip;
-  guint send_corners: 1;
 } OpClip;
 
 typedef struct
@@ -109,7 +108,8 @@ typedef struct
 
 typedef struct
 {
-  const GskColorStop *color_stops;
+  float color_offsets[8];
+  float color_stops[4 * 8];
   graphene_point_t start_point;
   graphene_point_t end_point;
   int n_color_stops;
@@ -117,8 +117,8 @@ typedef struct
 
 typedef struct
 {
-  const graphene_matrix_t *matrix;
-  const graphene_vec4_t *offset;
+  graphene_matrix_t matrix;
+  graphene_vec4_t offset;
 } OpColorMatrix;
 
 typedef struct
@@ -130,16 +130,18 @@ typedef struct
 
 typedef struct
 {
-  GskRoundedRect outline;
+  float outline[4];
+  float corner_widths[4];
+  float corner_heights[4];
   float spread;
   float offset[2];
-  const GdkRGBA *color;
+  float color[4];
 } OpShadow;
 
 typedef struct
 {
   float widths[4];
-  const GdkRGBA *color;
+  float color[4];
   GskRoundedRect outline;
 } OpBorder;
 

gsk/gskrendernode.h

@@ -41,7 +41,7 @@ typedef struct _GskShadow               GskShadow;
 
 struct _GskColorStop
 {
-  float offset;
+  double offset;
   GdkRGBA color;
 };
 
@@ -210,11 +210,11 @@ GskTransform *          gsk_transform_node_get_transform        (GskRenderNode
 
 GDK_AVAILABLE_IN_ALL
 GskRenderNode *         gsk_opacity_node_new                    (GskRenderNode            *child,
-                                                                 float                     opacity);
+                                                                 double                    opacity);
 GDK_AVAILABLE_IN_ALL
 GskRenderNode *         gsk_opacity_node_get_child              (GskRenderNode            *node);
 GDK_AVAILABLE_IN_ALL
-float                   gsk_opacity_node_get_opacity            (GskRenderNode            *node);
+double                  gsk_opacity_node_get_opacity            (GskRenderNode            *node);
 
 GDK_AVAILABLE_IN_ALL
 GskRenderNode *         gsk_color_matrix_node_new               (GskRenderNode            *child,
@@ -280,13 +280,13 @@ GskBlendMode            gsk_blend_node_get_blend_mode           (GskRenderNode
 GDK_AVAILABLE_IN_ALL
 GskRenderNode *         gsk_cross_fade_node_new                 (GskRenderNode            *start,
                                                                  GskRenderNode            *end,
-                                                                 float                     progress);
+                                                                 double                    progress);
 GDK_AVAILABLE_IN_ALL
 GskRenderNode *         gsk_cross_fade_node_get_start_child     (GskRenderNode            *node);
 GDK_AVAILABLE_IN_ALL
 GskRenderNode *         gsk_cross_fade_node_get_end_child       (GskRenderNode            *node);
 GDK_AVAILABLE_IN_ALL
-float                   gsk_cross_fade_node_get_progress        (GskRenderNode            *node);
+double                  gsk_cross_fade_node_get_progress        (GskRenderNode            *node);
 
 GDK_AVAILABLE_IN_ALL
 GskRenderNode *         gsk_text_node_new                       (PangoFont                *font,
@@ -307,11 +307,11 @@ const graphene_point_t *gsk_text_node_get_offset                (GskRenderNode
 
 GDK_AVAILABLE_IN_ALL
 GskRenderNode *         gsk_blur_node_new                       (GskRenderNode            *child,
-                                                                 float                     radius);
+                                                                 double                    radius);
 GDK_AVAILABLE_IN_ALL
 GskRenderNode *         gsk_blur_node_get_child                 (GskRenderNode            *node);
 GDK_AVAILABLE_IN_ALL
-float                   gsk_blur_node_get_radius                (GskRenderNode            *node);
+double                  gsk_blur_node_get_radius                (GskRenderNode            *node);
 
 G_END_DECLS
 

gsk/gskrendernodeimpl.c

@@ -2197,7 +2197,7 @@ struct _GskOpacityNode
   GskRenderNode render_node;
 
   GskRenderNode *child;
-  float opacity;
+  double opacity;
 };
 
 static void
@@ -2267,7 +2267,7 @@ static const GskRenderNodeClass GSK_OPACITY_NODE_CLASS = {
  */
 GskRenderNode *
 gsk_opacity_node_new (GskRenderNode *child,
-                      float          opacity)
+                      double         opacity)
 {
   GskOpacityNode *self;
 
@@ -2301,7 +2301,7 @@ gsk_opacity_node_get_child (GskRenderNode *node)
   return self->child;
 }
 
-float
+double
 gsk_opacity_node_get_opacity (GskRenderNode *node)
 {
   GskOpacityNode *self = (GskOpacityNode *) node;
@@ -3278,7 +3278,7 @@ struct _GskCrossFadeNode
 
   GskRenderNode *start;
   GskRenderNode *end;
-  float          progress;
+  double         progress;
 };
 
 static void
@@ -3352,7 +3352,7 @@ static const GskRenderNodeClass GSK_CROSS_FADE_NODE_CLASS = {
 GskRenderNode *
 gsk_cross_fade_node_new (GskRenderNode *start,
                          GskRenderNode *end,
-                         float          progress)
+                         double         progress)
 {
   GskCrossFadeNode *self;
 
@@ -3390,7 +3390,7 @@ gsk_cross_fade_node_get_end_child (GskRenderNode *node)
   return self->end;
 }
 
-float
+double
 gsk_cross_fade_node_get_progress (GskRenderNode *node)
 {
   GskCrossFadeNode *self = (GskCrossFadeNode *) node;
@@ -3634,7 +3634,7 @@ struct _GskBlurNode
   GskRenderNode render_node;
 
   GskRenderNode *child;
-  float radius;
+  double radius;
 };
 
 static void
@@ -3882,7 +3882,7 @@ static const GskRenderNodeClass GSK_BLUR_NODE_CLASS = {
  */
 GskRenderNode *
 gsk_blur_node_new (GskRenderNode *child,
-                   float          radius)
+                   double         radius)
 {
   GskBlurNode *self;
   float clip_radius = gsk_cairo_blur_compute_pixels (radius);
@@ -3911,7 +3911,7 @@ gsk_blur_node_get_child (GskRenderNode *node)
   return self->child;
 }
 
-float
+double
 gsk_blur_node_get_radius (GskRenderNode *node)
 {
   GskBlurNode *self = (GskBlurNode *) node;

gsk/gskrendernodeparser.c

@@ -433,13 +433,9 @@ parse_stops (GtkCssParser *parser,
 
   for (;;)
     {
-     double dval;
-
-      if (!gtk_css_parser_consume_number (parser, &dval))
+      if (!gtk_css_parser_consume_number (parser, &stop.offset))
         goto error;
 
-      stop.offset = dval;
-
       if (!gdk_rgba_parser_parse (parser, &stop.color))
         goto error;
 

gsk/gsktransform.c

@@ -685,54 +685,16 @@ gsk_rotate_transform_finalize (GskTransform *self)
 {
 }
 
-static inline void
-_sincos (float  deg,
-         float *out_s,
-         float *out_c)
-{
-  if (deg == 90.0)
-    {
-      *out_c = 0.0;
-      *out_s = 1.0;
-    }
-  else if (deg == 180.0)
-    {
-      *out_c = -1.0;
-      *out_s = 0.0;
-    }
-  else if (deg == 270.0)
-    {
-      *out_c = 0.0;
-      *out_s = -1.0;
-    }
-  else if (deg == 0.0)
-    {
-      *out_c = 1.0;
-      *out_s = 0.0;
-    }
-  else
-    {
-      float angle = deg * M_PI / 180.0;
-
-#ifdef HAVE_SINCOSF
-      sincosf (angle, out_s, out_c);
-#else
-      *out_s = sinf (angle);
-      *out_c = cosf (angle);
-#endif
-
-    }
-}
-
 static void
 gsk_rotate_transform_to_matrix (GskTransform      *transform,
                                 graphene_matrix_t *out_matrix)
 {
   GskRotateTransform *self = (GskRotateTransform *) transform;
-  float c, s;
-
-  _sincos (self->angle, &s, &c);
+  float rad, c, s;
 
+  rad = self->angle * M_PI / 180.f;
+  c = cosf (rad);
+  s = sinf (rad);
   graphene_matrix_init_from_2d (out_matrix,
                                 c, s,
                                 -s, c,
@@ -749,12 +711,14 @@ gsk_rotate_transform_apply_2d (GskTransform *transform,
                                float        *out_dy)
 {
   GskRotateTransform *self = (GskRotateTransform *) transform;
-  float s, c, xx, xy, yx, yy;
+  float s, c, rad, xx, xy, yx, yy;
 
   if (fmodf (self->angle, 360.0f) == 0.0)
     return;
 
-  _sincos (self->angle, &s, &c);
+  rad = self->angle * G_PI / 180.0f;
+  s = sinf (rad);
+  c = cosf (rad);
 
   xx =  c * *out_xx + s * *out_xy;
   yx =  c * *out_yx + s * *out_yy;
@@ -821,22 +785,6 @@ static const GskTransformClass GSK_ROTATE_TRANSFORM_CLASS =
   gsk_rotate_transform_equal,
 };
 
-static inline float
-normalize_angle (float angle)
-{
-  float f;
-
-  if (angle >= 0 && angle < 360)
-    return angle;
-
-  f = angle - (360 * ((int)(angle / 360.0)));
-
-  if (f < 0)
-    f = 360 + f;
-
-  return f;
-}
-
 /**
  * gsk_transform_rotate:
  * @next: (allow-none) (transfer full): the next transform
@@ -867,7 +815,7 @@ gsk_transform_rotate (GskTransform *next,
                                 GSK_TRANSFORM_CATEGORY_2D,
                                 next);
 
-  result->angle = normalize_angle (angle);
+  result->angle = angle;
 
   return &result->parent;
 }
@@ -990,7 +938,7 @@ gsk_transform_rotate_3d (GskTransform          *next,
                                 GSK_TRANSFORM_CATEGORY_3D,
                                 next);
 
-  result->angle = normalize_angle (angle);
+  result->angle = angle;
   graphene_vec3_init_from_vec3 (&result->axis, axis);
 
   return &result->parent;
@@ -1085,9 +1033,9 @@ gsk_scale_transform_equal (GskTransform *first_transform,
   GskScaleTransform *first = (GskScaleTransform *) first_transform;
   GskScaleTransform *second = (GskScaleTransform *) second_transform;
 
-  return G_APPROX_VALUE (first->factor_x, second->factor_x, FLT_EPSILON) &&
-         G_APPROX_VALUE (first->factor_y, second->factor_y, FLT_EPSILON) &&
-         G_APPROX_VALUE (first->factor_z, second->factor_z, FLT_EPSILON);
+  return G_APPROX_VALUE (first->factor_x, second->factor_x, 0.01f) &&
+         G_APPROX_VALUE (first->factor_y, second->factor_y, 0.01f) &&
+         G_APPROX_VALUE (first->factor_z, second->factor_z, 0.01f);
 }
 
 static void
@@ -1672,10 +1620,10 @@ gsk_transform_equal (GskTransform *first,
   if (first == NULL || second == NULL)
     return FALSE;
 
-  if (first->transform_class != second->transform_class)
+  if (!gsk_transform_equal (first->next, second->next))
     return FALSE;
 
-  if (!gsk_transform_equal (first->next, second->next))
+  if (first->transform_class != second->transform_class)
     return FALSE;
 
   return first->transform_class->equal (first, second);
@@ -1738,10 +1686,7 @@ gsk_transform_transform_bounds (GskTransform          *self,
         float dx, dy;
 
         gsk_transform_to_translate (self, &dx, &dy);
-        out_rect->origin.x = rect->origin.x + dx;
-        out_rect->origin.y = rect->origin.y + dy;
-        out_rect->size.width = rect->size.width;
-        out_rect->size.height = rect->size.height;
+        graphene_rect_offset_r (rect, dx, dy, out_rect);
       }
     break;
 
@@ -1751,10 +1696,13 @@ gsk_transform_transform_bounds (GskTransform          *self,
 
         gsk_transform_to_affine (self, &scale_x, &scale_y, &dx, &dy);
 
-        out_rect->origin.x = (rect->origin.x * scale_x) + dx;
-        out_rect->origin.y = (rect->origin.y * scale_y) + dy;
-        out_rect->size.width = rect->size.width * scale_x;
-        out_rect->size.height = rect->size.height * scale_y;
+        *out_rect = *rect;
+        out_rect->origin.x *= scale_x;
+        out_rect->origin.y *= scale_y;
+        out_rect->size.width *= scale_x;
+        out_rect->size.height *= scale_y;
+        out_rect->origin.x += dx;
+        out_rect->origin.y += dy;
       }
     break;
 

gsk/meson.build

@@ -1,19 +1,24 @@
 gsk_private_gl_shaders = [
-  'resources/glsl/preamble.fs.glsl',
-  'resources/glsl/preamble.vs.glsl',
-  'resources/glsl/border.glsl',
-  'resources/glsl/blit.glsl',
-  'resources/glsl/coloring.glsl',
-  'resources/glsl/color.glsl',
-  'resources/glsl/linear_gradient.glsl',
-  'resources/glsl/color_matrix.glsl',
-  'resources/glsl/blur.glsl',
-  'resources/glsl/inset_shadow.glsl',
-  'resources/glsl/outset_shadow.glsl',
-  'resources/glsl/unblurred_outset_shadow.glsl',
-  'resources/glsl/cross_fade.glsl',
-  'resources/glsl/blend.glsl',
-  'resources/glsl/repeat.glsl',
+  'resources/glsl/blit.fs.glsl',
+  'resources/glsl/blit.vs.glsl',
+  'resources/glsl/color.fs.glsl',
+  'resources/glsl/coloring.fs.glsl',
+  'resources/glsl/color_matrix.fs.glsl',
+  'resources/glsl/linear_gradient.fs.glsl',
+  'resources/glsl/blur.fs.glsl',
+  'resources/glsl/inset_shadow.fs.glsl',
+  'resources/glsl/outset_shadow.fs.glsl',
+  'resources/glsl/unblurred_outset_shadow.fs.glsl',
+  'resources/glsl/border.fs.glsl',
+  'resources/glsl/cross_fade.fs.glsl',
+  'resources/glsl/blend.fs.glsl',
+  'resources/glsl/repeat.fs.glsl',
+  'resources/glsl/es2_common.fs.glsl',
+  'resources/glsl/es2_common.vs.glsl',
+  'resources/glsl/gl3_common.fs.glsl',
+  'resources/glsl/gl3_common.vs.glsl',
+  'resources/glsl/gl_common.fs.glsl',
+  'resources/glsl/gl_common.vs.glsl',
 ]
 
 gsk_public_sources = files([
@@ -33,7 +38,7 @@ gsk_private_sources = files([
   'gskdebug.c',
   'gskprivate.c',
   'gskprofiler.c',
-  'gl/gskglshaderbuilder.c',
+  'gl/gskshaderbuilder.c',
   'gl/gskglprofiler.c',
   'gl/gskglglyphcache.c',
   'gl/gskglimage.c',

gsk/resources/glsl/blend.fs.glsl

@@ -1,11 +1,3 @@
-// VERTEX_SHADER:
-void main() {
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-
-  vUv = vec2(aUv.x, aUv.y);
-}
-
-// FRAGMENT_SHADER:
 uniform int u_mode;
 uniform sampler2D u_source2;
 
@@ -272,39 +264,73 @@ void main() {
 
   vec4 result;
   if (u_mode == 0)
-    result = normal(top_color, bottom_color);
+    {
+      result = normal(top_color, bottom_color);
+    }
   else if (u_mode == 1)
-    result = multiply(top_color, bottom_color);
+    {
+      result = multiply(top_color, bottom_color);
+    }
   else if (u_mode == 2)
-    result = screen(top_color, bottom_color);
+    {
+      result = screen(top_color, bottom_color);
+    }
   else if (u_mode == 3)
-    result = overlay(top_color, bottom_color);
+    {
+      result = overlay(top_color, bottom_color);
+    }
   else if (u_mode == 4)
-    result = darken(top_color, bottom_color);
+    {
+      result = darken(top_color, bottom_color);
+    }
   else if (u_mode == 5)
-    result = lighten(top_color, bottom_color);
+    {
+      result = lighten(top_color, bottom_color);
+    }
   else if (u_mode == 6)
-    result = color_dodge(top_color, bottom_color);
+    {
+      result = color_dodge(top_color, bottom_color);
+    }
   else if (u_mode == 7)
-    result = color_burn(top_color, bottom_color);
+    {
+      result = color_burn(top_color, bottom_color);
+    }
   else if (u_mode == 8)
-    result = hard_light(top_color, bottom_color);
+    {
+      result = hard_light(top_color, bottom_color);
+    }
   else if (u_mode == 9)
-    result = soft_light(top_color, bottom_color);
+    {
+      result = soft_light(top_color, bottom_color);
+    }
   else if (u_mode == 10)
-    result = difference(top_color, bottom_color);
+    {
+      result = difference(top_color, bottom_color);
+    }
   else if (u_mode == 11)
-    result = exclusion(top_color, bottom_color);
+    {
+      result = exclusion(top_color, bottom_color);
+    }
   else if (u_mode == 12)
-    result = color(top_color, bottom_color);
+    {
+      result = color(top_color, bottom_color);
+    }
   else if (u_mode == 13)
-    result = hue(top_color, bottom_color);
+    {
+      result = hue(top_color, bottom_color);
+    }
   else if (u_mode == 14)
-    result = saturation(top_color, bottom_color);
+    {
+      result = saturation(top_color, bottom_color);
+    }
   else if (u_mode == 15)
-    result = luminosity(top_color, bottom_color);
+    {
+      result = luminosity(top_color, bottom_color);
+    }
   else
-    discard;
+    {
+      discard;
+    }
 
   setOutputColor(result * u_alpha);
 }

gsk/resources/glsl/blit.fs.glsl

@@ -0,0 +1,5 @@
+void main() {
+  vec4 diffuse = Texture(u_source, vUv);
+
+  setOutputColor(diffuse * u_alpha);
+}

gsk/resources/glsl/blit.glsl

@@ -1,13 +0,0 @@
-// VERTEX_SHADER:
-void main() {
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-
-  vUv = vec2(aUv.x, aUv.y);
-}
-
-// FRAGMENT_SHADER:
-void main() {
-  vec4 diffuse = Texture(u_source, vUv);
-
-  setOutputColor(diffuse * u_alpha);
-}

gsk/resources/glsl/blit.vs.glsl

@@ -0,0 +1,5 @@
+void main() {
+  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
+
+  vUv = vec2(aUv.x, aUv.y);
+}

gsk/resources/glsl/blur.fs.glsl

@@ -0,0 +1,38 @@
+uniform float u_blur_radius;
+uniform vec2 u_blur_size;
+uniform vec2 u_blur_dir;
+
+const float PI = 3.14159265;
+const float RADIUS_MULTIPLIER = 3.0;
+
+// blur_radius 0 is NOT supported and MUST be caught before.
+
+// Partially from http://callumhay.blogspot.com/2010/09/gaussian-blur-shader-glsl.html
+void main() {
+  float sigma = u_blur_radius; // *shrug*
+  float blur_radius = u_blur_radius * RADIUS_MULTIPLIER;
+  vec3 incrementalGaussian;
+  incrementalGaussian.x = 1.0 / (sqrt(2.0 * PI) * sigma);
+  incrementalGaussian.y = exp(-0.5 / (sigma * sigma));
+  incrementalGaussian.z = incrementalGaussian.y * incrementalGaussian.y;
+
+  vec2 pixel_step = vec2(1.0) / u_blur_size;
+
+  float coefficientSum = 0;
+  vec4 sum = Texture(u_source, vUv) * incrementalGaussian.x;
+  coefficientSum += incrementalGaussian.x;
+  incrementalGaussian.xy *= incrementalGaussian.yz;
+
+  int pixels_per_side = int(floor(blur_radius / 2.0));
+  for (int i = 1; i <= pixels_per_side; i++) {
+    vec2 p = i * pixel_step * u_blur_dir;
+
+    sum += Texture(u_source, vUv - p) * incrementalGaussian.x;
+    sum += Texture(u_source, vUv + p) * incrementalGaussian.x;
+
+    coefficientSum += 2.0 * incrementalGaussian.x;
+    incrementalGaussian.xy *= incrementalGaussian.yz;
+  }
+
+  setOutputColor(sum / coefficientSum);
+}

gsk/resources/glsl/blur.glsl

@@ -1,58 +0,0 @@
-// VERTEX_SHADER:
-uniform float u_blur_radius;
-uniform vec2 u_blur_size;
-uniform vec2 u_blur_dir;
-
-_OUT_ vec2 pixel_step;
-_OUT_ float pixels_per_side;
-_OUT_ vec3 initial_gaussian;
-
-const float PI = 3.14159265;
-const float RADIUS_MULTIPLIER = 3.0;
-
-void main() {
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-
-  vUv = vec2(aUv.x, aUv.y);
-
-  pixel_step = (vec2(1.0) / u_blur_size) * u_blur_dir;
-  pixels_per_side = floor(u_blur_radius * RADIUS_MULTIPLIER / 2.0);
-
-  float sigma = u_blur_radius; // *shrug*
-  initial_gaussian.x = 1.0 / (sqrt(2.0 * PI) * sigma);
-  initial_gaussian.y = exp(-0.5 / (sigma * sigma));
-  initial_gaussian.z = initial_gaussian.y * initial_gaussian.y;
-}
-
-// FRAGMENT_SHADER:
-uniform float u_blur_radius;
-uniform vec2 u_blur_size;
-
-_IN_ vec2 pixel_step;
-_IN_ float pixels_per_side;
-_IN_ vec3 initial_gaussian;
-
-// blur_radius 0 is NOT supported and MUST be caught before.
-
-// Partially from http://callumhay.blogspot.com/2010/09/gaussian-blur-shader-glsl.html
-void main() {
-  vec3 incrementalGaussian = initial_gaussian;
-
-  float coefficientSum = 0.0;
-  vec4 sum = Texture(u_source, vUv) * incrementalGaussian.x;
-  coefficientSum += incrementalGaussian.x;
-  incrementalGaussian.xy *= incrementalGaussian.yz;
-
-  vec2 p = pixel_step;
-  for (int i = 1; i <= int(pixels_per_side); i++) {
-    sum += Texture(u_source, vUv - p) * incrementalGaussian.x;
-    sum += Texture(u_source, vUv + p) * incrementalGaussian.x;
-
-    coefficientSum += 2.0 * incrementalGaussian.x;
-    incrementalGaussian.xy *= incrementalGaussian.yz;
-
-    p += pixel_step;
-  }
-
-  setOutputColor(sum / coefficientSum);
-}

gsk/resources/glsl/border.fs.glsl

@@ -0,0 +1,30 @@
+uniform vec4 u_color;
+uniform vec4 u_widths;
+
+uniform vec4 u_outline;
+uniform vec4 u_corner_widths;
+uniform vec4 u_corner_heights;
+
+void main() {
+  vec4 bounds = u_outline;
+
+  bounds.z = bounds.x + bounds.z;
+  bounds.w = bounds.y + bounds.w;
+
+  vec4 f = gl_FragCoord;
+  f.x += u_viewport.x;
+  f.y = (u_viewport.y + u_viewport.w) - f.y;
+
+  RoundedRect routside = RoundedRect (bounds, u_corner_widths, u_corner_heights);
+  RoundedRect rinside = rounded_rect_shrink (routside, u_widths);
+
+  float alpha = clamp (rounded_rect_coverage (routside, f.xy) -
+                       rounded_rect_coverage (rinside, f.xy),
+                       0.0, 1.0);
+
+  /* Pre-multiply */
+  vec4 color = u_color;
+  color.rgb *= color.a;
+
+  setOutputColor (color * alpha * u_alpha);
+}

gsk/resources/glsl/border.glsl

@@ -1,33 +0,0 @@
-// VERTEX_SHADER:
-uniform vec4 u_color;
-
-_OUT_ vec4 final_color;
-
-void main() {
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-
-  final_color = u_color;
-  final_color.rgb *= final_color.a; // pre-multiply
-  final_color *= u_alpha;
-}
-
-// FRAGMENT_SHADER:
-uniform vec4 u_widths;
-uniform vec4[3] u_outline_rect;
-
-_IN_ vec4 final_color;
-
-void main() {
-  vec4 f = gl_FragCoord;
-  f.x += u_viewport.x;
-  f.y = (u_viewport.y + u_viewport.w) - f.y;
-
-  RoundedRect outside = create_rect(u_outline_rect);
-  RoundedRect inside = rounded_rect_shrink (outside, u_widths);
-
-  float alpha = clamp (rounded_rect_coverage (outside, f.xy) -
-                       rounded_rect_coverage (inside, f.xy),
-                       0.0, 1.0);
-
-  setOutputColor(final_color * alpha);
-}

gsk/resources/glsl/color.fs.glsl

@@ -0,0 +1,9 @@
+uniform vec4 u_color;
+
+void main() {
+  vec4 color = u_color;
+
+  // Pre-multiply alpha
+  color.rgb *= color.a;
+  setOutputColor(color * u_alpha);
+}

gsk/resources/glsl/color.glsl

@@ -1,21 +0,0 @@
-// VERTEX_SHADER:
-uniform vec4 u_color;
-
-_OUT_ vec4 final_color;
-
-void main() {
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-
-  final_color = u_color;
-  // Pre-multiply alpha
-  final_color.rgb *= final_color.a;
-  final_color *= u_alpha;
-}
-
-// FRAGMENT_SHADER:
-_IN_ vec4 final_color;
-
-void main() {
-  setOutputColor(final_color);
-}
-

gsk/resources/glsl/color_matrix.fs.glsl

@@ -1,23 +1,18 @@
-// VERTEX_SHADER:
-void main() {
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-
-  vUv = vec2(aUv.x, aUv.y);
-}
-
-// FRAGMENT_SHADER:
 uniform mat4 u_color_matrix;
 uniform vec4 u_color_offset;
 
 void main() {
-  vec4 color = Texture(u_source, vUv);
+  vec4 diffuse = Texture(u_source, vUv);
+  vec4 color;
+
+  color = diffuse;
 
   // Un-premultilpy
   if (color.a != 0.0)
     color.rgb /= color.a;
 
   color = u_color_matrix * color + u_color_offset;
-  color = clamp(color, 0.0, 1.0);
+  color = clamp(color, 0.0f, 1.0f);
 
   color.rgb *= color.a;
 

gsk/resources/glsl/coloring.fs.glsl

@@ -0,0 +1,15 @@
+uniform vec4 u_color;
+
+void main() {
+  vec4 diffuse = Texture(u_source, vUv);
+  vec4 color = u_color;
+
+  // pre-multiply
+  color.rgb *= color.a;
+
+  // u_source is drawn using cairo, so already pre-multiplied.
+  color = vec4(color.rgb * diffuse.a * u_alpha,
+               color.a * diffuse.a * u_alpha);
+
+  setOutputColor(color);
+}

gsk/resources/glsl/coloring.glsl

@@ -1,25 +0,0 @@
-// VERTEX_SHADER:
-uniform vec4 u_color;
-
-_OUT_ vec4 final_color;
-
-void main() {
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-
-  vUv = vec2(aUv.x, aUv.y);
-
-  final_color = u_color;
-  // pre-multiply
-  final_color.rgb *= final_color.a;
-  final_color *= u_alpha;
-}
-
-// FRAGMENT_SHADER:
-
-_IN_ vec4 final_color;
-
-void main() {
-  vec4 diffuse = Texture(u_source, vUv);
-
-  setOutputColor(final_color * diffuse.a);
-}

gsk/resources/glsl/cross_fade.fs.glsl

@@ -1,11 +1,4 @@
-// VERTEX_SHADER:
-void main() {
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
 
-  vUv = vec2(aUv.x, aUv.y);
-}
-
-// FRAGMENT_SHADER:
 uniform float u_progress;
 uniform sampler2D u_source2;
 

gsk/resources/glsl/es2_common.fs.glsl

@@ -0,0 +1,105 @@
+precision mediump float;
+
+uniform sampler2D u_source;
+uniform sampler2D u_mask;
+uniform mat4 u_projection;
+uniform mat4 u_modelview;
+uniform float u_alpha;
+uniform int uBlendMode;
+uniform vec4 u_viewport;
+
+// In GtkSnapshot coordinates
+uniform vec4 u_clip;
+uniform vec4 u_clip_corner_widths;
+uniform vec4 u_clip_corner_heights;
+
+varying vec2 vUv;
+
+
+struct RoundedRect
+{
+  vec4 bounds;
+  vec4 corner_widths;
+  vec4 corner_heights;
+};
+
+float
+ellipsis_dist (vec2 p, vec2 radius)
+{
+  if (radius == vec2(0, 0))
+    return 0.0;
+
+  vec2 p0 = p / radius;
+  vec2 p1 = 2.0 * p0 / radius;
+
+  return (dot(p0, p0) - 1.0) / length (p1);
+}
+
+float
+ellipsis_coverage (vec2 point, vec2 center, vec2 radius)
+{
+  float d = ellipsis_dist (point - center, radius);
+  return clamp (0.5 - d, 0.0, 1.0);
+}
+
+float
+rounded_rect_coverage (RoundedRect r, vec2 p)
+{
+  if (p.x < r.bounds.x || p.y < r.bounds.y ||
+      p.x >= r.bounds.z || p.y >= r.bounds.w)
+    return 0.0;
+
+  vec2 rad_tl = vec2(r.corner_widths.x, r.corner_heights.x);
+  vec2 rad_tr = vec2(r.corner_widths.y, r.corner_heights.y);
+  vec2 rad_br = vec2(r.corner_widths.z, r.corner_heights.z);
+  vec2 rad_bl = vec2(r.corner_widths.w, r.corner_heights.w);
+
+  vec2 ref_tl = r.bounds.xy + vec2( r.corner_widths.x,  r.corner_heights.x);
+  vec2 ref_tr = r.bounds.zy + vec2(-r.corner_widths.y,  r.corner_heights.y);
+  vec2 ref_br = r.bounds.zw + vec2(-r.corner_widths.z, -r.corner_heights.z);
+  vec2 ref_bl = r.bounds.xw + vec2( r.corner_widths.w, -r.corner_heights.w);
+
+  float d_tl = ellipsis_coverage(p, ref_tl, rad_tl);
+  float d_tr = ellipsis_coverage(p, ref_tr, rad_tr);
+  float d_br = ellipsis_coverage(p, ref_br, rad_br);
+  float d_bl = ellipsis_coverage(p, ref_bl, rad_bl);
+
+  vec4 corner_coverages = 1.0 - vec4(d_tl, d_tr, d_br, d_bl);
+
+  bvec4 is_out = bvec4(p.x < ref_tl.x && p.y < ref_tl.y,
+                       p.x > ref_tr.x && p.y < ref_tr.y,
+                       p.x > ref_br.x && p.y > ref_br.y,
+                       p.x < ref_bl.x && p.y > ref_bl.y);
+
+  return 1.0 - dot(vec4(is_out), corner_coverages);
+}
+
+RoundedRect
+rounded_rect_shrink (RoundedRect r, vec4 amount)
+{
+  vec4 new_bounds = r.bounds + vec4(1.0,1.0,-1.0,-1.0) * amount.wxyz;
+  vec4 new_widths = max (r.corner_widths - amount.wyyw, 0.0);
+  vec4 new_heights = max (r.corner_heights - amount.xxzz, 0.0);
+
+  return RoundedRect (new_bounds, new_widths, new_heights);
+}
+
+vec4 Texture(sampler2D sampler, vec2 texCoords) {
+  return texture2D(sampler, texCoords);
+}
+
+void setOutputColor(vec4 color) {
+  vec4 clipBounds = u_clip;
+  vec4 f = gl_FragCoord;
+
+  f.x += u_viewport.x;
+  f.y = (u_viewport.y + u_viewport.w) - f.y;
+
+  clipBounds.z = clipBounds.x + clipBounds.z;
+  clipBounds.w = clipBounds.y + clipBounds.w;
+
+  RoundedRect r = RoundedRect(clipBounds, u_clip_corner_widths, u_clip_corner_heights);
+
+  gl_FragColor = color * rounded_rect_coverage(r, f.xy);
+  /*gl_FragColor = color;*/
+}

gsk/resources/glsl/es2_common.vs.glsl

@@ -0,0 +1,9 @@
+precision mediump float;
+
+uniform mat4 u_projection;
+uniform mat4 u_modelview;
+
+attribute vec2 aPosition;
+attribute vec2 aUv;
+
+varying vec2 vUv;

gsk/resources/glsl/gl3_common.fs.glsl

@@ -1,33 +1,21 @@
-#ifdef GSK_GL3
 precision highp float;
-#endif
-
-#ifdef GSK_GLES
-precision highp float;
-#endif
-
 
 uniform sampler2D u_source;
-uniform mat4 u_projection;
-uniform mat4 u_modelview;
-uniform float u_alpha;// = 1.0;
+uniform sampler2D u_mask;
+uniform mat4 u_projection = mat4(1.0);
+uniform mat4 u_modelview = mat4(1.0);
+uniform float u_alpha = 1.0;
+uniform int uBlendMode;
 uniform vec4 u_viewport;
-uniform vec4[3] u_clip_rect;
 
-#if GSK_GLES
-#define _OUT_ varying
-#define _IN_ varying
-#elif GSK_LEGACY
-#define _OUT_ varying
-#define _IN_ varying
-_OUT_ vec4 outputColor;
-#else
-#define _OUT_ out
-#define _IN_ in
-_OUT_ vec4 outputColor;
-#endif
-_IN_ vec2 vUv;
+// In GtkSnapshot coordinates
+uniform vec4 u_clip;
+uniform vec4 u_clip_corner_widths  = vec4(0, 0, 0, 0);
+uniform vec4 u_clip_corner_heights = vec4(0, 0, 0, 0);
 
+in vec2 vUv;
+
+out vec4 outputColor;
 
 
 struct RoundedRect
@@ -37,16 +25,6 @@ struct RoundedRect
   vec4 corner_heights;
 };
 
-// Transform from a GskRoundedRect to a RoundedRect as we need it.
-RoundedRect
-create_rect(vec4 data[3])
-{
-  vec4 bounds = vec4(data[0].xy, data[0].xy + data[0].zw);
-  vec4 widths = vec4(data[1].x, data[1].z, data[2].x, data[2].z);
-  vec4 heights = vec4(data[1].y, data[1].w, data[2].y, data[2].w);
-  return RoundedRect(bounds, widths, heights);
-}
-
 float
 ellipsis_dist (vec2 p, vec2 radius)
 {
@@ -98,7 +76,6 @@ rounded_rect_coverage (RoundedRect r, vec2 p)
   return 1.0 - dot(vec4(is_out), corner_coverages);
 }
 
-// amount is: top, right, bottom, left
 RoundedRect
 rounded_rect_shrink (RoundedRect r, vec4 amount)
 {
@@ -107,46 +84,40 @@ rounded_rect_shrink (RoundedRect r, vec4 amount)
   vec4 new_heights = vec4(0);
 
   // Left top
-  if (r.corner_widths.x  > 0.0) new_widths.x = r.corner_widths.x - amount.w;
-  if (r.corner_heights.x > 0.0) new_heights.x = r.corner_heights.x - amount.x;
+  if (r.corner_widths.x  > 0) new_widths.x = r.corner_widths.x - amount.w;
+  if (r.corner_heights.x > 0) new_heights.x = r.corner_heights.x - amount.x;
 
   // Top right
-  if (r.corner_widths.y  > 0.0) new_widths.y = r.corner_widths.y - amount.y;
-  if (r.corner_heights.y > 0.0) new_heights.y = r.corner_heights.y - amount.x;
+  if (r.corner_widths.y > 0) new_widths.y = r.corner_widths.y - amount.y;
+  if (r.corner_heights.y > 0) new_heights.y = r.corner_heights.y - amount.x;
 
   // Bottom right
-  if (r.corner_widths.z  > 0.0) new_widths.z = r.corner_widths.z - amount.y;
-  if (r.corner_heights.z > 0.0) new_heights.z = r.corner_heights.z - amount.z;
+  if (r.corner_widths.z > 0) new_widths.z = r.corner_widths.z - amount.y;
+  if (r.corner_heights.z > 0) new_heights.z = r.corner_heights.z - amount.z;
 
   // Bottom left
-  if (r.corner_widths.w  > 0.0) new_widths.w = r.corner_widths.w - amount.w;
-  if (r.corner_heights.w > 0.0) new_heights.w = r.corner_heights.w - amount.z;
+  if (r.corner_widths.w > 0) new_widths.w = r.corner_widths.w - amount.w;
+  if (r.corner_heights.w > 0) new_heights.w = r.corner_heights.w - amount.z;
 
   return RoundedRect (new_bounds, new_widths, new_heights);
 }
 
 vec4 Texture(sampler2D sampler, vec2 texCoords) {
-#if GSK_GLES
-  return texture2D(sampler, texCoords);
-#elif GSK_LEGACY
-  return texture2D(sampler, texCoords);
-#else
   return texture(sampler, texCoords);
-#endif
 }
 
 void setOutputColor(vec4 color) {
+  vec4 clipBounds = u_clip;
   vec4 f = gl_FragCoord;
 
   f.x += u_viewport.x;
   f.y = (u_viewport.y + u_viewport.w) - f.y;
 
-#if GSK_GLES
-  gl_FragColor = color * rounded_rect_coverage(create_rect(u_clip_rect), f.xy);
-#elif GSK_LEGACY
-  gl_FragColor = color * rounded_rect_coverage(create_rect(u_clip_rect), f.xy);
-#else
-  outputColor = color * rounded_rect_coverage(create_rect(u_clip_rect), f.xy);
-#endif
+  clipBounds.z = clipBounds.x + clipBounds.z;
+  clipBounds.w = clipBounds.y + clipBounds.w;
+
+  RoundedRect r = RoundedRect(clipBounds, u_clip_corner_widths, u_clip_corner_heights);
+
+  outputColor = color * rounded_rect_coverage(r, f.xy);
   /*outputColor = color;*/
 }

gsk/resources/glsl/gl3_common.vs.glsl

@@ -0,0 +1,7 @@
+uniform mat4 u_projection;
+uniform mat4 u_modelview;
+
+in vec2 aPosition;
+in vec2 aUv;
+
+out vec2 vUv;

gsk/resources/glsl/gl_common.fs.glsl

@@ -0,0 +1,102 @@
+uniform sampler2D u_source;
+uniform sampler2D u_mask;
+uniform mat4 u_projection;
+uniform mat4 u_modelview;
+uniform float u_alpha;
+uniform int uBlendMode;
+uniform vec4 u_viewport;
+
+// In GtkSnapshot coordinates
+uniform vec4 u_clip;
+uniform vec4 u_clip_corner_widths;
+uniform vec4 u_clip_corner_heights;
+
+varying vec2 vUv;
+
+
+struct RoundedRect
+{
+  vec4 bounds;
+  vec4 corner_widths;
+  vec4 corner_heights;
+};
+
+float
+ellipsis_dist (vec2 p, vec2 radius)
+{
+  if (radius == vec2(0, 0))
+    return 0.0;
+
+  vec2 p0 = p / radius;
+  vec2 p1 = 2.0 * p0 / radius;
+
+  return (dot(p0, p0) - 1.0) / length (p1);
+}
+
+float
+ellipsis_coverage (vec2 point, vec2 center, vec2 radius)
+{
+  float d = ellipsis_dist (point - center, radius);
+  return clamp (0.5 - d, 0.0, 1.0);
+}
+
+float
+rounded_rect_coverage (RoundedRect r, vec2 p)
+{
+  if (p.x < r.bounds.x || p.y < r.bounds.y ||
+      p.x >= r.bounds.z || p.y >= r.bounds.w)
+    return 0.0;
+
+  vec2 rad_tl = vec2(r.corner_widths.x, r.corner_heights.x);
+  vec2 rad_tr = vec2(r.corner_widths.y, r.corner_heights.y);
+  vec2 rad_br = vec2(r.corner_widths.z, r.corner_heights.z);
+  vec2 rad_bl = vec2(r.corner_widths.w, r.corner_heights.w);
+
+  vec2 ref_tl = r.bounds.xy + vec2( r.corner_widths.x,  r.corner_heights.x);
+  vec2 ref_tr = r.bounds.zy + vec2(-r.corner_widths.y,  r.corner_heights.y);
+  vec2 ref_br = r.bounds.zw + vec2(-r.corner_widths.z, -r.corner_heights.z);
+  vec2 ref_bl = r.bounds.xw + vec2( r.corner_widths.w, -r.corner_heights.w);
+
+  float d_tl = ellipsis_coverage(p, ref_tl, rad_tl);
+  float d_tr = ellipsis_coverage(p, ref_tr, rad_tr);
+  float d_br = ellipsis_coverage(p, ref_br, rad_br);
+  float d_bl = ellipsis_coverage(p, ref_bl, rad_bl);
+
+  vec4 corner_coverages = 1.0 - vec4(d_tl, d_tr, d_br, d_bl);
+
+  bvec4 is_out = bvec4(p.x < ref_tl.x && p.y < ref_tl.y,
+                       p.x > ref_tr.x && p.y < ref_tr.y,
+                       p.x > ref_br.x && p.y > ref_br.y,
+                       p.x < ref_bl.x && p.y > ref_bl.y);
+
+  return 1.0 - dot(vec4(is_out), corner_coverages);
+}
+
+RoundedRect
+rounded_rect_shrink (RoundedRect r, vec4 amount)
+{
+  vec4 new_bounds = r.bounds + vec4(1.0,1.0,-1.0,-1.0) * amount.wxyz;
+  vec4 new_widths = max (r.corner_widths - amount.wyyw, 0.0);
+  vec4 new_heights = max (r.corner_heights - amount.xxzz, 0.0);
+
+  return RoundedRect (new_bounds, new_widths, new_heights);
+}
+
+vec4 Texture(sampler2D sampler, vec2 texCoords) {
+  return texture2D(sampler, texCoords);
+}
+
+void setOutputColor(vec4 color) {
+  vec4 clipBounds = u_clip;
+  vec4 f = gl_FragCoord;
+
+  f.x += u_viewport.x;
+  f.y = (u_viewport.y + u_viewport.w) - f.y;
+
+  clipBounds.z = clipBounds.x + clipBounds.z;
+  clipBounds.w = clipBounds.y + clipBounds.w;
+
+  RoundedRect r = RoundedRect(clipBounds, u_clip_corner_widths, u_clip_corner_heights);
+
+  gl_FragColor = color * rounded_rect_coverage(r, f.xy);
+}

gsk/resources/glsl/gl_common.vs.glsl

@@ -0,0 +1,7 @@
+uniform mat4 u_projection;
+uniform mat4 u_modelview;
+
+attribute vec2 aPosition;
+attribute vec2 aUv;
+
+varying vec2 vUv;

gsk/resources/glsl/inset_shadow.fs.glsl

@@ -0,0 +1,26 @@
+uniform float u_spread;
+uniform vec4 u_color;
+uniform vec2 u_offset;
+uniform vec4 u_outline;
+uniform vec4 u_corner_widths;
+uniform vec4 u_corner_heights;
+
+
+void main() {
+  vec4 f = gl_FragCoord;
+
+  f.x += u_viewport.x;
+  f.y = (u_viewport.y + u_viewport.w) - f.y;
+
+  RoundedRect outline = RoundedRect(vec4(u_outline.xy, u_outline.xy + u_outline.zw),
+                                    u_corner_widths, u_corner_heights);
+  RoundedRect inside = rounded_rect_shrink(outline, vec4(u_spread));
+
+
+  vec2 offset = vec2(u_offset.x, - u_offset.y);
+  vec4 color = vec4(u_color.rgb * u_color.a, u_color.a);
+  color = color * clamp (rounded_rect_coverage (outline, f.xy) -
+                         rounded_rect_coverage (inside, f.xy - offset),
+                         0.0, 1.0);
+  setOutputColor(color * u_alpha);
+}

gsk/resources/glsl/inset_shadow.glsl

@@ -1,34 +0,0 @@
-// VERTEX_SHADER:
-uniform vec4 u_color;
-
-_OUT_ vec4 final_color;
-
-void main() {
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-
-  final_color = u_color;
-  final_color.rgb *= final_color.a;
-  final_color *= u_alpha;
-}
-
-// FRAGMENT_SHADER:
-uniform float u_spread;
-uniform vec2 u_offset;
-uniform vec4[3] u_outline_rect;
-
-_IN_ vec4 final_color;
-
-void main() {
-  vec4 f = gl_FragCoord;
-  vec4 color;
-
-  f.x += u_viewport.x;
-  f.y = (u_viewport.y + u_viewport.w) - f.y;
-
-  RoundedRect outside = create_rect(u_outline_rect);
-  RoundedRect inside = rounded_rect_shrink(outside, vec4(u_spread));
-  color = final_color * clamp (rounded_rect_coverage (outside, f.xy) -
-                               rounded_rect_coverage (inside, f.xy - u_offset),
-                               0.0, 1.0);
-  setOutputColor(color);
-}

gsk/resources/glsl/linear_gradient.fs.glsl

@@ -0,0 +1,45 @@
+uniform vec4 u_color_stops[8];
+uniform float u_color_offsets[8];
+uniform int u_num_color_stops;
+uniform vec2 u_start_point;
+uniform vec2 u_end_point;
+
+vec4 fragCoord() {
+  vec4 f = gl_FragCoord;
+  f.x += u_viewport.x;
+  f.y = (u_viewport.y + u_viewport.w) - f.y;
+  return f;
+}
+
+void main() {
+  vec2 startPoint = (u_modelview * vec4(u_start_point, 0, 1)).xy;
+  vec2 endPoint   = (u_modelview * vec4(u_end_point,   0, 1)).xy;
+  float maxDist   = length(endPoint - startPoint);
+
+  // Position relative to startPoint
+  vec2 pos = fragCoord().xy - startPoint;
+
+  // Gradient direction
+  vec2 gradient = endPoint - startPoint;
+  float gradientLength = length(gradient);
+
+  // Current pixel, projected onto the line between the start point and the end point
+  // The projection will be relative to the start point!
+  vec2 proj = (dot(gradient, pos) / (gradientLength * gradientLength)) * gradient;
+
+  // Offset of the current pixel
+  float offset = length(proj) / maxDist;
+
+  vec4 color = u_color_stops[0];
+  for (int i = 1; i < u_num_color_stops; i ++) {
+    if (offset >= u_color_offsets[i - 1])  {
+      float o = (offset - u_color_offsets[i - 1]) / (u_color_offsets[i] - u_color_offsets[i - 1]);
+      color = mix(u_color_stops[i - 1], u_color_stops[i], clamp(o, 0.0, 1.0));
+    }
+  }
+
+  /* Pre-multiply */
+  color.rgb *= color.a;
+
+  setOutputColor(color * u_alpha);
+}

gsk/resources/glsl/linear_gradient.glsl

@@ -1,81 +0,0 @@
-// VERTEX_SHADER
-uniform vec2 u_start_point;
-uniform vec2 u_end_point;
-uniform float u_color_stops[8 * 5];
-uniform int u_num_color_stops;
-
-_OUT_ vec2 startPoint;
-_OUT_ vec2 endPoint;
-_OUT_ float maxDist;
-_OUT_ vec2 gradient;
-_OUT_ float gradientLength;
-_OUT_ vec4 color_stops[8];
-_OUT_ float color_offsets[8];
-
-void main() {
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-
-  startPoint = (u_modelview * vec4(u_start_point, 0, 1)).xy;
-  endPoint   = (u_modelview * vec4(u_end_point,   0, 1)).xy;
-  maxDist    = length(endPoint - startPoint);
-
-  // Gradient direction
-  gradient = endPoint - startPoint;
-  gradientLength = length(gradient);
-
-  for (int i = 0; i < u_num_color_stops; i ++) {
-    color_offsets[i] = u_color_stops[(i * 5) + 0];
-    color_stops[i].r = u_color_stops[(i * 5) + 1];
-    color_stops[i].g = u_color_stops[(i * 5) + 2];
-    color_stops[i].b = u_color_stops[(i * 5) + 3];
-    color_stops[i].a = u_color_stops[(i * 5) + 4];
-  }
-}
-
-// FRAGMENT_SHADER:
-#ifdef GSK_LEGACY
-uniform int u_num_color_stops;
-#else
-uniform highp int u_num_color_stops; // Why? Because it works like this.
-#endif
-
-_IN_ vec2 startPoint;
-_IN_ vec2 endPoint;
-_IN_ float maxDist;
-_IN_ vec2 gradient;
-_IN_ float gradientLength;
-_IN_ vec4 color_stops[8];
-_IN_ float color_offsets[8];
-
-
-vec4 fragCoord() {
-  vec4 f = gl_FragCoord;
-  f.x += u_viewport.x;
-  f.y = (u_viewport.y + u_viewport.w) - f.y;
-  return f;
-}
-
-void main() {
-  // Position relative to startPoint
-  vec2 pos = fragCoord().xy - startPoint;
-
-  // Current pixel, projected onto the line between the start point and the end point
-  // The projection will be relative to the start point!
-  vec2 proj = (dot(gradient, pos) / (gradientLength * gradientLength)) * gradient;
-
-  // Offset of the current pixel
-  float offset = length(proj) / maxDist;
-
-  vec4 color = color_stops[0];
-  for (int i = 1; i < u_num_color_stops; i ++) {
-    if (offset >= color_offsets[i - 1])  {
-      float o = (offset - color_offsets[i - 1]) / (color_offsets[i] - color_offsets[i - 1]);
-      color = mix(color_stops[i - 1], color_stops[i], clamp(o, 0.0, 1.0));
-    }
-  }
-
-  /* Pre-multiply */
-  color.rgb *= color.a;
-
-  setOutputColor(color * u_alpha);
-}

gsk/resources/glsl/outset_shadow.fs.glsl

@@ -0,0 +1,16 @@
+uniform vec4 u_outline;
+uniform vec4 u_corner_widths;//= vec4(0, 0, 0, 0);
+uniform vec4 u_corner_heights;// = vec4(0, 0, 0, 0);
+
+void main() {
+  vec4 f = gl_FragCoord;
+
+  f.x += u_viewport.x;
+  f.y = (u_viewport.y + u_viewport.w) - f.y;
+
+  RoundedRect outline = RoundedRect(vec4(u_outline.xy, u_outline.xy + u_outline.zw), u_corner_widths, u_corner_heights);
+
+  vec4 color = Texture(u_source, vUv);
+  color = color * (1.0 -  clamp(rounded_rect_coverage (outline, f.xy), 0.0, 1.0));
+  setOutputColor(color * u_alpha);
+}

gsk/resources/glsl/outset_shadow.glsl

@@ -1,21 +0,0 @@
-// VERTEX_SHADER:
-void main() {
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-
-  vUv = vec2(aUv.x, aUv.y);
-}
-
-// FRAGMENT_SHADER:
-uniform vec4[3] u_outline_rect;
-
-void main() {
-  vec4 f = gl_FragCoord;
-
-  f.x += u_viewport.x;
-  f.y = (u_viewport.y + u_viewport.w) - f.y;
-
-  RoundedRect outline = create_rect(u_outline_rect);
-  vec4 color = Texture(u_source, vUv);
-  color = color * (1.0 -  clamp(rounded_rect_coverage(outline, f.xy), 0.0, 1.0));
-  setOutputColor(color * u_alpha);
-}

gsk/resources/glsl/preamble.vs.glsl

@@ -1,27 +0,0 @@
-uniform mat4 u_projection;
-uniform mat4 u_modelview;
-uniform float u_alpha;
-
-#ifdef GSK_GLES
-precision highp float;
-#endif
-
-#if GSK_GLES
-#define _OUT_ varying
-#define _IN_ varying
-attribute vec2 aPosition;
-attribute vec2 aUv;
-_OUT_ vec2 vUv;
-#elif GSK_LEGACY
-#define _OUT_ varying
-#define _IN_ varying
-attribute vec2 aPosition;
-attribute vec2 aUv;
-_OUT_ vec2 vUv;
-#else
-#define _OUT_ out
-#define _IN_ in
-_IN_ vec2 aPosition;
-_IN_ vec2 aUv;
-_OUT_ vec2 vUv;
-#endif

gsk/resources/glsl/repeat.fs.glsl

@@ -1,11 +1,3 @@
-// VERTEX_SHADER:
-void main() {
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-
-  vUv = vec2(aUv.x, aUv.y);
-}
-
-// FRAGMENT_SHADER:
 uniform vec4 u_child_bounds;
 uniform vec4 u_texture_rect;
 

gsk/resources/glsl/unblurred_outset_shadow.fs.glsl

@@ -0,0 +1,26 @@
+uniform float u_spread;
+uniform vec4 u_color;
+uniform vec2 u_offset;
+uniform vec4 u_outline;
+uniform vec4 u_corner_widths;
+uniform vec4 u_corner_heights;
+
+
+void main() {
+  vec4 f = gl_FragCoord;
+
+  f.x += u_viewport.x;
+  f.y = (u_viewport.y + u_viewport.w) - f.y;
+
+  RoundedRect inside = RoundedRect(vec4(u_outline.xy, u_outline.xy + u_outline.zw),
+                                    u_corner_widths, u_corner_heights);
+
+  RoundedRect outline = rounded_rect_shrink(inside, vec4(- u_spread));
+
+  vec2 offset = vec2(u_offset.x, - u_offset.y);
+  vec4 color = vec4(u_color.rgb * u_color.a, u_color.a);
+  color = color * clamp (rounded_rect_coverage (outline, f.xy - offset) -
+                         rounded_rect_coverage (inside, f.xy),
+                         0.0, 1.0);
+  setOutputColor(color * u_alpha);
+}

gsk/resources/glsl/unblurred_outset_shadow.glsl

@@ -1,34 +0,0 @@
-// VERTEX_SHADER:
-uniform vec4 u_color;
-
-_OUT_ vec4 final_color;
-
-void main() {
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-
-  final_color = u_color;
-  final_color.rgb *= final_color.a;
-  final_color *= u_alpha;
-}
-
-// FRAGMENT_SHADER:
-uniform float u_spread;
-uniform vec2 u_offset;
-uniform vec4[3] u_outline_rect;
-
-_IN_ vec4 final_color;
-
-void main() {
-  vec4 f = gl_FragCoord;
-  vec4 color;
-
-  f.x += u_viewport.x;
-  f.y = (u_viewport.y + u_viewport.w) - f.y;
-
-  RoundedRect inside = create_rect(u_outline_rect);
-  RoundedRect outside = rounded_rect_shrink(inside, vec4(- u_spread));
-  color = final_color * clamp (rounded_rect_coverage (outside, f.xy - u_offset) -
-                               rounded_rect_coverage (inside, f.xy),
-                               0.0, 1.0);
-  setOutputColor(color);
-}

gtk.supp

@@ -27,15 +27,6 @@
    fun:gtk_media_file_extension_init
 }
 
-# AMD driver
-{
-  radeonsi_dri general
-  Memcheck:Leak
-  fun:calloc
-  ...
-  obj:/usr/lib/dri/radeonsi_dri.so
-}
-
 # mesa driver stuff
 {
    i965 addr4

gtk/gtk.h

@@ -90,8 +90,8 @@
 #include <gtk/gtkcustomlayout.h>
 #include <gtk/gtkdebug.h>
 #include <gtk/gtkdialog.h>
+#include <gtk/gtkdnd.h>
 #include <gtk/gtkdragdest.h>
-#include <gtk/gtkdragicon.h>
 #include <gtk/gtkdragsource.h>
 #include <gtk/gtkdrawingarea.h>
 #include <gtk/gtkeditable.h>

gtk/gtkbin.c

@@ -36,7 +36,6 @@
  */
 
 #include "config.h"
-#include "gtkwidgetprivate.h"
 #include "gtkbin.h"
 
 
@@ -45,6 +44,23 @@ typedef struct
   GtkWidget *child;
 } GtkBinPrivate;
 
+static void gtk_bin_add         (GtkContainer   *container,
+			         GtkWidget      *widget);
+static void gtk_bin_remove      (GtkContainer   *container,
+			         GtkWidget      *widget);
+static void gtk_bin_forall      (GtkContainer   *container,
+				 GtkCallback     callback,
+				 gpointer        callback_data);
+static GType gtk_bin_child_type (GtkContainer   *container);
+
+static void               gtk_bin_measure                         (GtkWidget      *widget,
+                                                                   GtkOrientation  orientation,
+                                                                   int             for_size,
+                                                                   int            *minimum,
+                                                                   int            *natural,
+                                                                   int            *minimum_baseline,
+                                                                   int            *natural_baseline);
+
 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GtkBin, gtk_bin, GTK_TYPE_CONTAINER)
 
 static void
@@ -56,7 +72,7 @@ gtk_bin_size_allocate (GtkWidget *widget,
   GtkBin *bin = GTK_BIN (widget);
   GtkBinPrivate *priv = gtk_bin_get_instance_private (bin);
 
-  if (priv->child && _gtk_widget_get_visible (priv->child))
+  if (priv->child && gtk_widget_get_visible (priv->child))
     gtk_widget_size_allocate (priv->child,
                               &(GtkAllocation) {
                                 0, 0,
@@ -64,6 +80,26 @@ gtk_bin_size_allocate (GtkWidget *widget,
                               }, baseline);
 }
 
+static void
+gtk_bin_class_init (GtkBinClass *class)
+{
+  GtkWidgetClass *widget_class = (GtkWidgetClass*) class;
+  GtkContainerClass *container_class = (GtkContainerClass*) class;
+
+  widget_class->measure = gtk_bin_measure;
+  widget_class->size_allocate = gtk_bin_size_allocate;
+
+  container_class->add = gtk_bin_add;
+  container_class->remove = gtk_bin_remove;
+  container_class->forall = gtk_bin_forall;
+  container_class->child_type = gtk_bin_child_type;
+}
+
+static void
+gtk_bin_init (GtkBin *bin)
+{
+}
+
 static GType
 gtk_bin_child_type (GtkContainer *container)
 {
@@ -143,7 +179,7 @@ gtk_bin_measure (GtkWidget *widget,
 {
   GtkBinPrivate *priv = gtk_bin_get_instance_private (GTK_BIN (widget));
 
-  if (priv->child != NULL && _gtk_widget_get_visible (priv->child))
+  if (priv->child != NULL && gtk_widget_get_visible (priv->child))
     {
       gtk_widget_measure (priv->child,
                           orientation,
@@ -158,26 +194,6 @@ gtk_bin_measure (GtkWidget *widget,
     }
 }
 
-static void
-gtk_bin_class_init (GtkBinClass *class)
-{
-  GtkWidgetClass *widget_class = (GtkWidgetClass*) class;
-  GtkContainerClass *container_class = (GtkContainerClass*) class;
-
-  widget_class->measure = gtk_bin_measure;
-  widget_class->size_allocate = gtk_bin_size_allocate;
-
-  container_class->add = gtk_bin_add;
-  container_class->remove = gtk_bin_remove;
-  container_class->forall = gtk_bin_forall;
-  container_class->child_type = gtk_bin_child_type;
-}
-
-static void
-gtk_bin_init (GtkBin *bin)
-{
-}
-
 /**
  * gtk_bin_get_child:
  * @bin: a #GtkBin

gtk/gtkbuilderscope.c

@@ -412,7 +412,7 @@ gtk_builder_cscope_init (GtkBuilderCScope *self)
  * Calling this function is only necessary if you want to add custom
  * callbacks via gtk_builder_cscope_add_callback_symbol().
  *
- * Returns: (transfer full): a new #GtkBuilderCScope
+ * Returns: a new #GtkBuilderCScope
  **/
 GtkBuilderScope *
 gtk_builder_cscope_new (void)
@@ -502,7 +502,7 @@ gtk_builder_cscope_add_callback_symbols (GtkBuilderCScope *self,
  * Fetches a symbol previously added to @self
  * with gtk_builder_cscope_add_callback_symbol().
  *
- * Returns: (nullable) (transfer none): The callback symbol in @builder for @callback_name, or %NULL
+ * Returns: (nullable): The callback symbol in @builder for @callback_name, or %NULL
  */
 GCallback
 gtk_builder_cscope_lookup_callback_symbol (GtkBuilderCScope *self,

gtk/gtkcalendar.c

@@ -72,6 +72,7 @@
 #endif
 
 #include "gtkcalendar.h"
+#include "gtkdnd.h"
 #include "gtkdragdest.h"
 #include "gtkintl.h"
 #include "gtkmain.h"
@@ -86,10 +87,6 @@
 #include "gtkgesturedrag.h"
 #include "gtkeventcontrollerscroll.h"
 #include "gtkeventcontrollerkey.h"
-#include "gtkdragsource.h"
-#include "gtknative.h"
-#include "gtkicontheme.h"
-#include "gtkdragicon.h"
 
 #define TIMEOUT_INITIAL  500
 #define TIMEOUT_REPEAT    50
@@ -251,6 +248,7 @@ struct _GtkCalendarPrivate
   guint need_timer  : 1;
 
   guint in_drag : 1;
+  guint drag_highlight : 1;
 
   guint32 timer;
   gint click_child;
@@ -331,17 +329,22 @@ static gboolean gtk_calendar_query_tooltip  (GtkWidget        *widget,
                                              gboolean          keyboard_mode,
                                              GtkTooltip       *tooltip);
 
-static gboolean gtk_calendar_drag_accept        (GtkDropTarget    *dest,
+static void     gtk_calendar_drag_data_get      (GtkWidget        *widget,
+                                                 GdkDrag          *drag, 
+                                                 GtkSelectionData *selection_data);
+static void     gtk_calendar_drag_data_received (GtkWidget        *widget,
                                                  GdkDrop          *drop,
-                                                 GtkCalendar      *calendar);
-static void     gtk_calendar_drag_leave         (GtkDropTarget    *dest,
+                                                 GtkSelectionData *selection_data);
+static gboolean gtk_calendar_drag_motion        (GtkWidget        *widget,
                                                  GdkDrop          *drop,
-                                                 GtkCalendar      *calendar);
-static gboolean gtk_calendar_drag_drop          (GtkDropTarget    *dest,
+                                                 gint              x,
+                                                 gint              y);
+static void     gtk_calendar_drag_leave         (GtkWidget        *widget,
+                                                 GdkDrop          *drop);
+static gboolean gtk_calendar_drag_drop          (GtkWidget        *widget,
                                                  GdkDrop          *drop,
-                                                 int               x,
-                                                 int               y,
-                                                 GtkCalendar      *calendar);
+                                                 gint              x,
+                                                 gint              y);
 
 
 static void calendar_start_spinning (GtkCalendar *calendar,
@@ -389,6 +392,12 @@ gtk_calendar_class_init (GtkCalendarClass *class)
   widget_class->grab_notify = gtk_calendar_grab_notify;
   widget_class->query_tooltip = gtk_calendar_query_tooltip;
 
+  widget_class->drag_data_get = gtk_calendar_drag_data_get;
+  widget_class->drag_motion = gtk_calendar_drag_motion;
+  widget_class->drag_leave = gtk_calendar_drag_leave;
+  widget_class->drag_drop = gtk_calendar_drag_drop;
+  widget_class->drag_data_received = gtk_calendar_drag_data_received;
+
   /**
    * GtkCalendar:year:
    *
@@ -666,8 +675,6 @@ gtk_calendar_init (GtkCalendar *calendar)
 #else
   gchar *week_start;
 #endif
-  GdkContentFormats *formats;
-  GtkDropTarget *dest;
 
   gtk_widget_set_can_focus (widget, TRUE);
 
@@ -785,17 +792,11 @@ gtk_calendar_init (GtkCalendar *calendar)
   priv->click_child = -1;
 
   priv->in_drag = 0;
+  priv->drag_highlight = 0;
 
-  formats = gdk_content_formats_new_for_gtype (G_TYPE_STRING);
-  dest = gtk_drop_target_new (formats, GDK_ACTION_COPY);
-  gdk_content_formats_unref (formats);
+  gtk_drag_dest_set (widget, 0, NULL, GDK_ACTION_COPY);
+  gtk_drag_dest_add_text_targets (widget);
 
-  g_signal_connect (dest, "accept", G_CALLBACK (gtk_calendar_drag_accept), calendar);
-  g_signal_connect (dest, "drag-leave", G_CALLBACK (gtk_calendar_drag_leave), calendar);
-  g_signal_connect (dest, "drag-drop", G_CALLBACK (gtk_calendar_drag_drop), calendar);
-
-  gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (dest));
-  
   priv->year_before = 0;
 
   /* Translate to calendar:YM if you want years to be displayed
@@ -2394,6 +2395,7 @@ calendar_snapshot_arrow (GtkCalendar *calendar,
 {
   GtkWidget *widget = GTK_WIDGET (calendar);
   GtkCalendarPrivate *priv = gtk_calendar_get_instance_private (calendar);
+  GtkCssImageBuiltinType image_type;
   GtkStyleContext *context;
   GtkStateFlags state;
   GdkRectangle rect;
@@ -2416,11 +2418,19 @@ calendar_snapshot_arrow (GtkCalendar *calendar,
                                   rect.x, rect.y,
                                   rect.width, rect.height);
 
+  if (arrow == ARROW_MONTH_LEFT || arrow == ARROW_YEAR_LEFT)
+    image_type = GTK_CSS_IMAGE_BUILTIN_ARROW_LEFT;
+  else
+    image_type = GTK_CSS_IMAGE_BUILTIN_ARROW_RIGHT;
+
   gtk_snapshot_save (snapshot);
   gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT(
                           rect.x + (rect.width - 8) / 2,
                           rect.y + (rect.height - 8) / 2));
-  gtk_css_style_snapshot_icon (gtk_style_context_lookup_style (context), snapshot, 8, 8);
+  gtk_css_style_snapshot_icon (gtk_style_context_lookup_style (context),
+                               snapshot,
+                               8, 8,
+                               image_type);
   gtk_snapshot_restore (snapshot);
 
   gtk_style_context_restore (context);
@@ -2660,27 +2670,6 @@ gtk_calendar_drag_begin (GtkGestureDrag *gesture,
   priv->in_drag = TRUE;
 }
 
-static GdkContentProvider *
-get_calendar_content (GtkCalendar *calendar)
-{
-  GtkCalendarPrivate *priv = gtk_calendar_get_instance_private (calendar);
-  GDate *date;
-  gchar str[128];
-  GValue value = G_VALUE_INIT;
-  GdkContentProvider *content;
-
-  date = g_date_new_dmy (priv->selected_day, priv->month + 1, priv->year);
-  g_date_strftime (str, 127, "%x", date);
-  g_free (date);
-
-  g_value_init (&value, G_TYPE_STRING);
-  g_value_set_string (&value, str);
-  content = gdk_content_provider_new_for_value (&value);
-  g_value_unset (&value);
-
-  return content;
-}
-
 static void
 gtk_calendar_drag_update (GtkGestureDrag *gesture,
                           double          x,
@@ -2691,12 +2680,8 @@ gtk_calendar_drag_update (GtkGestureDrag *gesture,
   GtkCalendar *calendar = GTK_CALENDAR (widget);
   GtkCalendarPrivate *priv = gtk_calendar_get_instance_private (calendar);
   gdouble start_x, start_y;
-  GdkContentProvider *content;
-  GdkDevice *device;
   GdkDrag *drag;
-  GtkIconTheme *theme;
-  GdkPaintable *paintable;
-  GdkSurface *surface;
+  GdkContentFormats *targets;
 
   if (!priv->in_drag)
     return;
@@ -2706,22 +2691,19 @@ gtk_calendar_drag_update (GtkGestureDrag *gesture,
 
   gtk_gesture_drag_get_start_point (gesture, &start_x, &start_y);
 
-  surface = gtk_native_get_surface (gtk_widget_get_native (widget));
-  device = gtk_gesture_get_device (GTK_GESTURE (gesture));
+  gtk_event_controller_reset (GTK_EVENT_CONTROLLER (gesture));
 
-  content = get_calendar_content (calendar);
-
-  drag = gdk_drag_begin (surface, device, content, GDK_ACTION_COPY, start_x, start_y);
-
-  theme = gtk_icon_theme_get_for_display (gtk_widget_get_display (widget));
-  paintable = gtk_icon_theme_load_icon (theme, "text-x-generic", 32, 0, NULL);
-  gtk_drag_icon_set_from_paintable (drag, paintable, 0, 0);
-  g_clear_object (&paintable);
-
-  g_object_unref (content);
-  g_object_unref (drag);
+  targets = gdk_content_formats_new (NULL, 0);
+  targets = gtk_content_formats_add_text_targets (targets);
+  drag = gtk_drag_begin (widget,
+                         gtk_gesture_get_device (GTK_GESTURE (gesture)),
+                         targets, GDK_ACTION_COPY,
+                         start_x, start_y);
 
   priv->in_drag = 0;
+  gdk_content_formats_unref (targets);
+
+  gtk_drag_set_icon_default (drag);
 }
 
 static gboolean
@@ -2941,6 +2923,24 @@ gtk_calendar_grab_notify (GtkWidget *widget,
  *          Drag and Drop               *
  ****************************************/
 
+static void
+gtk_calendar_drag_data_get (GtkWidget        *widget,
+                            GdkDrag          *drag,
+                            GtkSelectionData *selection_data)
+{
+  GtkCalendar *calendar = GTK_CALENDAR (widget);
+  GtkCalendarPrivate *priv = gtk_calendar_get_instance_private (calendar);
+  GDate *date;
+  gchar str[128];
+  gsize len;
+
+  date = g_date_new_dmy (priv->selected_day, priv->month + 1, priv->year);
+  len = g_date_strftime (str, 127, "%x", date);
+  gtk_selection_data_set_text (selection_data, str, len);
+
+  g_free (date);
+}
+
 /* Get/set whether drag_motion requested the drag data and
  * drag_data_received should thus not actually insert the data,
  * since the data doesn’t result from a drop.
@@ -2962,33 +2962,87 @@ get_status_pending (GdkDrop *drop)
 }
 
 static void
-gtk_calendar_drag_leave (GtkDropTarget *dest,
-                         GdkDrop       *drop,
-                         GtkCalendar   *calendar)
+gtk_calendar_drag_leave (GtkWidget *widget,
+                         GdkDrop   *drop)
 {
+  GtkCalendar *calendar = GTK_CALENDAR (widget);
+  GtkCalendarPrivate *priv = gtk_calendar_get_instance_private (calendar);
+
+  priv->drag_highlight = 0;
+  gtk_drag_unhighlight (widget);
+}
+
+static gboolean
+gtk_calendar_drag_motion (GtkWidget      *widget,
+                          GdkDrop        *drop,
+                          gint            x,
+                          gint            y)
+{
+  GtkCalendar *calendar = GTK_CALENDAR (widget);
+  GtkCalendarPrivate *priv = gtk_calendar_get_instance_private (calendar);
+  GdkAtom target;
+
+  if (!priv->drag_highlight)
+    {
+      priv->drag_highlight = 1;
+      gtk_drag_highlight (widget);
+    }
+
+  target = gtk_drag_dest_find_target (widget, drop, NULL);
+  if (target == NULL || gdk_drop_get_actions (drop) == 0)
+    gdk_drop_status (drop, 0);
+  else if (get_status_pending (drop) == 0)
+    {
+      set_status_pending (drop, gdk_drop_get_actions (drop));
+      gtk_drag_get_data (widget, drop, target);
+    }
+
+  return TRUE;
+}
+
+static gboolean
+gtk_calendar_drag_drop (GtkWidget      *widget,
+                        GdkDrop        *drop,
+                        gint            x,
+                        gint            y)
+{
+  GdkAtom target;
+
+  target = gtk_drag_dest_find_target (widget, drop, NULL);
+  if (target != NULL)
+    {
+      gtk_drag_get_data (widget, drop, target);
+      return TRUE;
+    }
+
+  return FALSE;
 }
 
 static void
-got_text (GObject      *source,
-          GAsyncResult *result,
-          gpointer      data)
+gtk_calendar_drag_data_received (GtkWidget        *widget,
+                                 GdkDrop          *drop,
+                                 GtkSelectionData *selection_data)
 {
-  GtkDropTarget *dest = GTK_DROP_TARGET (data);
-  GtkCalendar *calendar = GTK_CALENDAR (gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (dest)));
+  GtkCalendar *calendar = GTK_CALENDAR (widget);
   GtkCalendarPrivate *priv = gtk_calendar_get_instance_private (calendar);
-  GdkDrop *drop = GDK_DROP (source);
   guint day, month, year;
   gchar *str;
   GDate *date;
   GdkDragAction suggested_action;
 
   suggested_action = get_status_pending (drop);
-  set_status_pending (drop, 0);
-
-  str = gdk_drop_read_text_finish (drop, result, NULL);
 
   if (suggested_action)
     {
+      set_status_pending (drop, 0);
+
+      /* We are getting this data due to a request in drag_motion,
+       * rather than due to a request in drag_drop, so we are just
+       * supposed to call drag_status, not actually paste in the
+       * data.
+       */
+      str = (gchar*) gtk_selection_data_get_text (selection_data);
+
       if (str)
         {
           date = g_date_new ();
@@ -3000,13 +3054,14 @@ got_text (GObject      *source,
         }
       else
         suggested_action = 0;
+
       gdk_drop_status (drop, suggested_action);
-      if (suggested_action == 0)
-        gtk_drop_target_deny_drop (dest, drop);
+
       return;
     }
 
   date = g_date_new ();
+  str = (gchar*) gtk_selection_data_get_text (selection_data);
   if (str)
     {
       g_date_set_parse (date, str);
@@ -3018,7 +3073,6 @@ got_text (GObject      *source,
       g_warning ("Received invalid date data");
       g_date_free (date);
       gdk_drop_finish (drop, 0);
-      gtk_drop_target_deny_drop (dest, drop);
       return;
     }
 
@@ -3029,6 +3083,7 @@ got_text (GObject      *source,
 
   gdk_drop_finish (drop, suggested_action);
 
+
   g_object_freeze_notify (G_OBJECT (calendar));
   if (!(priv->display_flags & GTK_CALENDAR_NO_MONTH_CHANGE)
       && (priv->display_flags & GTK_CALENDAR_SHOW_HEADING))
@@ -3037,47 +3092,6 @@ got_text (GObject      *source,
   g_object_thaw_notify (G_OBJECT (calendar));
 }
 
-static gboolean
-gtk_calendar_drag_accept (GtkDropTarget *dest,
-                          GdkDrop       *drop,
-                          GtkCalendar   *calendar)
-{
-  GdkAtom target;
-
-  target = gtk_drop_target_find_mimetype (dest);
-  if (!target || gdk_drop_get_actions (drop) == 0)
-    {
-      gdk_drop_status (drop, 0);
-      return FALSE;
-    }
-  else if (get_status_pending (drop) == 0)
-    {
-      set_status_pending (drop, gdk_drop_get_actions (drop));
-      gdk_drop_read_text_async (drop, NULL, got_text, dest);
-    }
-  return TRUE;
-}
-
-static gboolean
-gtk_calendar_drag_drop (GtkDropTarget  *dest,
-                        GdkDrop        *drop,
-                        int             x,
-                        int             y,
-                        GtkCalendar    *calendar)
-{
-  GdkAtom target;
-
-  target = gtk_drop_target_find_mimetype (dest);
-  if (target != NULL)
-    {
-      set_status_pending (drop, 0);
-      gdk_drop_read_text_async (drop, NULL, got_text, dest);
-      return TRUE;
-    }
-
-  return FALSE;
-}
-
 
 /****************************************
  *              Public API              *

gtk/gtkcellrenderertoggle.c

@@ -406,6 +406,7 @@ gtk_cell_renderer_toggle_snapshot (GtkCellRenderer      *cell,
   gint xpad, ypad;
   GtkStateFlags state;
   GtkBorder padding, border;
+  GtkCssImageBuiltinType image_type;
 
   gtk_cell_renderer_toggle_get_size (cell, widget, cell_area,
 				     &x_offset, &y_offset,
@@ -451,12 +452,32 @@ gtk_cell_renderer_toggle_snapshot (GtkCellRenderer      *cell,
   gtk_style_context_get_padding (context, &padding);
   gtk_style_context_get_border (context, &border);
 
+  if (priv->radio)
+    {
+      if (state & GTK_STATE_FLAG_INCONSISTENT)
+        image_type = GTK_CSS_IMAGE_BUILTIN_OPTION_INCONSISTENT;
+      else if (state & GTK_STATE_FLAG_CHECKED)
+        image_type = GTK_CSS_IMAGE_BUILTIN_OPTION;
+      else
+        image_type = GTK_CSS_IMAGE_BUILTIN_NONE;
+    }
+  else
+    {
+      if (state & GTK_STATE_FLAG_INCONSISTENT)
+        image_type = GTK_CSS_IMAGE_BUILTIN_CHECK_INCONSISTENT;
+      else if (state & GTK_STATE_FLAG_CHECKED)
+        image_type = GTK_CSS_IMAGE_BUILTIN_CHECK;
+      else
+        image_type = GTK_CSS_IMAGE_BUILTIN_NONE;
+    }
+
   gtk_snapshot_translate (snapshot,
                           &GRAPHENE_POINT_INIT (cell_area->x + x_offset + xpad + padding.left + border.left,
                                                 cell_area->y + y_offset + ypad + padding.top + border.top));
   gtk_css_style_snapshot_icon (gtk_style_context_lookup_style (context), snapshot,
                                width - padding.left - padding.right - border.left - border.right,
-                               height - padding.top - padding.bottom - border.top - border.bottom);
+                               height - padding.top - padding.bottom - border.top - border.bottom,
+                               image_type);
 
   gtk_style_context_restore (context);
   gtk_snapshot_pop (snapshot);

gtk/gtkcheckbutton.c

@@ -98,6 +98,7 @@ static void
 gtk_check_button_update_node_state (GtkWidget *widget)
 {
   GtkCheckButtonPrivate *priv = gtk_check_button_get_instance_private (GTK_CHECK_BUTTON (widget));
+  GtkCssImageBuiltinType image_type;
   GtkStateFlags state;
 
   if (!priv->indicator_widget)
@@ -105,6 +106,17 @@ gtk_check_button_update_node_state (GtkWidget *widget)
 
   state = gtk_widget_get_state_flags (widget);
 
+  /* XXX: This is somewhat awkward here, but there's no better
+   * way to update the icon
+   */
+  if (state & GTK_STATE_FLAG_CHECKED)
+    image_type = GTK_IS_RADIO_BUTTON (widget) ? GTK_CSS_IMAGE_BUILTIN_OPTION : GTK_CSS_IMAGE_BUILTIN_CHECK;
+  else if (state & GTK_STATE_FLAG_INCONSISTENT)
+    image_type = GTK_IS_RADIO_BUTTON (widget) ? GTK_CSS_IMAGE_BUILTIN_OPTION_INCONSISTENT : GTK_CSS_IMAGE_BUILTIN_CHECK_INCONSISTENT;
+  else
+    image_type = GTK_CSS_IMAGE_BUILTIN_NONE;
+
+  gtk_icon_set_image (GTK_ICON (priv->indicator_widget), image_type);
   gtk_widget_set_state_flags (priv->indicator_widget, state, TRUE);
 }
 

gtk/gtkcolorbutton.c

@@ -36,6 +36,7 @@
 #include "gtkcolorchooserprivate.h"
 #include "gtkcolorchooserdialog.h"
 #include "gtkcolorswatchprivate.h"
+#include "gtkdnd.h"
 #include "gtkdragdest.h"
 #include "gtkdragsource.h"
 #include "gtkintl.h"
@@ -44,9 +45,6 @@
 #include "gtkprivate.h"
 #include "gtksnapshot.h"
 #include "gtkstylecontext.h"
-#include "gtkdragsource.h"
-#include "gtkdragdest.h"
-#include "gtkeventcontroller.h"
 
 
 /**
@@ -123,6 +121,21 @@ static void gtk_color_button_get_property  (GObject          *object,
 static void gtk_color_button_clicked       (GtkButton        *button,
                                             gpointer          user_data);
 
+/* source side drag signals */
+static void gtk_color_button_drag_begin    (GtkWidget        *widget,
+                                            GdkDrag          *drag,
+                                            gpointer          data);
+static void gtk_color_button_drag_data_get (GtkWidget        *widget,
+                                            GdkDrag          *drag,
+                                            GtkSelectionData *selection_data,
+                                            GtkColorButton   *button);
+
+/* target side drag signals */
+static void gtk_color_button_drag_data_received (GtkWidget        *widget,
+                                                 GdkDrop          *drop,
+                                                 GtkSelectionData *selection_data,
+                                                 GtkColorButton   *button);
+
 
 static guint color_button_signals[LAST_SIGNAL] = { 0 };
 
@@ -232,64 +245,91 @@ gtk_color_button_class_init (GtkColorButtonClass *klass)
 }
 
 static void
-got_color (GObject      *source,
-           GAsyncResult *result,
-           gpointer      data)
+gtk_color_button_drag_data_received (GtkWidget        *widget,
+                                     GdkDrop          *drop,
+                                     GtkSelectionData *selection_data,
+                                     GtkColorButton   *button)
 {
-  GdkDrop *drop = GDK_DROP (source);
-  const GValue *value;
+  GtkColorButtonPrivate *priv = gtk_color_button_get_instance_private (button);
+  gint length;
+  guint16 *dropped;
 
-  value = gdk_drop_read_value_finish (drop, result, NULL);
-  if (value)
-    {
-      GdkRGBA *color = g_value_get_boxed (value);
-      gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (data), color);
-      gdk_drop_finish (drop, GDK_ACTION_COPY);
-    }
-  else
-    gdk_drop_finish (drop, 0);
-}
+  length = gtk_selection_data_get_length (selection_data);
 
-static gboolean
-gtk_color_button_drag_drop (GtkDropTarget  *dest,
-                            GdkDrop        *drop,
-                            int             x,
-                            int             y,
-                            GtkColorButton *button)
-{
-  if (gdk_drop_has_value (drop, GDK_TYPE_RGBA))
+  if (length < 0)
+    return;
+
+  /* We accept drops with the wrong format, since the KDE color
+   * chooser incorrectly drops application/x-color with format 8.
+   */
+  if (length != 8)
     {
-      gdk_drop_read_value_async (drop, GDK_TYPE_RGBA, G_PRIORITY_DEFAULT, NULL, got_color, button);
-      return TRUE;
+      g_warning ("%s: Received invalid color data", G_STRFUNC);
+      return;
     }
 
-  return FALSE;
+
+  dropped = (guint16 *) gtk_selection_data_get_data (selection_data);
+
+  priv->rgba.red = dropped[0] / 65535.;
+  priv->rgba.green = dropped[1] / 65535.;
+  priv->rgba.blue = dropped[2] / 65535.;
+  priv->rgba.alpha = dropped[3] / 65535.;
+
+  gtk_color_swatch_set_rgba (GTK_COLOR_SWATCH (priv->swatch), &priv->rgba);
+
+  g_signal_emit (button, color_button_signals[COLOR_SET], 0);
+
+  g_object_freeze_notify (G_OBJECT (button));
+  g_object_notify (G_OBJECT (button), "rgba");
+  g_object_thaw_notify (G_OBJECT (button));
 }
 
 static void
-gtk_color_button_drag_begin (GtkDragSource  *source,
-                             GdkDrag        *drag,
-                             GtkColorButton *button)
+set_color_icon (GdkDrag        *drag,
+                const GdkRGBA  *rgba)
 {
-  GtkColorButtonPrivate *priv = gtk_color_button_get_instance_private (button);
   GtkSnapshot *snapshot;
   GdkPaintable *paintable;
 
   snapshot = gtk_snapshot_new ();
-  gtk_snapshot_append_color (snapshot, &priv->rgba, &GRAPHENE_RECT_INIT(0, 0, 48, 32));
+  gtk_snapshot_append_color (snapshot,
+                             rgba,
+                             &GRAPHENE_RECT_INIT(0, 0, 48, 32));
   paintable = gtk_snapshot_free_to_paintable (snapshot, NULL);
 
-  gtk_drag_source_set_icon (source, paintable, 0, 0);
-
+  gtk_drag_set_icon_paintable (drag, paintable, 0, 0);
   g_object_unref (paintable);
 }
 
 static void
-get_rgba_value (GValue   *value,
-                gpointer  data)
+gtk_color_button_drag_begin (GtkWidget      *widget,
+                             GdkDrag        *drag,
+                             gpointer        data)
 {
-  GtkColorButtonPrivate *priv = gtk_color_button_get_instance_private (GTK_COLOR_BUTTON (data));
-  g_value_set_boxed (value, &priv->rgba);
+  GtkColorButton *button = data;
+  GtkColorButtonPrivate *priv = gtk_color_button_get_instance_private (button);
+
+  set_color_icon (drag, &priv->rgba);
+}
+
+static void
+gtk_color_button_drag_data_get (GtkWidget        *widget,
+                                GdkDrag          *drag,
+                                GtkSelectionData *selection_data,
+                                GtkColorButton   *button)
+{
+  GtkColorButtonPrivate *priv = gtk_color_button_get_instance_private (button);
+  guint16 dropped[4];
+
+  dropped[0] = (guint16) (priv->rgba.red * 65535);
+  dropped[1] = (guint16) (priv->rgba.green * 65535);
+  dropped[2] = (guint16) (priv->rgba.blue * 65535);
+  dropped[3] = (guint16) (priv->rgba.alpha * 65535);
+
+  gtk_selection_data_set (selection_data,
+                          gtk_selection_data_get_target (selection_data),
+                          16, (guchar *)dropped, 8);
 }
 
 static void
@@ -300,9 +340,6 @@ gtk_color_button_init (GtkColorButton *button)
   PangoRectangle rect;
   GtkStyleContext *context;
   GdkContentFormats *targets;
-  GdkContentProvider *content;
-  GtkDragSource *source;
-  GtkDropTarget *dest;
 
   priv->button = gtk_button_new ();
   g_signal_connect (priv->button, "clicked", G_CALLBACK (gtk_color_button_clicked), button);
@@ -327,17 +364,23 @@ gtk_color_button_init (GtkColorButton *button)
   priv->use_alpha = FALSE;
 
   targets = gdk_content_formats_new (drop_types, G_N_ELEMENTS (drop_types));
-  dest = gtk_drop_target_new (targets, GDK_ACTION_COPY);
-  g_signal_connect (dest, "drag-drop", G_CALLBACK (gtk_color_button_drag_drop), button);
-  gtk_widget_add_controller (GTK_WIDGET (button), GTK_EVENT_CONTROLLER (dest));
+  gtk_drag_dest_set (priv->button,
+                     GTK_DEST_DEFAULT_MOTION |
+                     GTK_DEST_DEFAULT_HIGHLIGHT |
+                     GTK_DEST_DEFAULT_DROP,
+                     targets,
+                     GDK_ACTION_COPY);
+  gtk_drag_source_set (priv->button,
+                       GDK_BUTTON1_MASK|GDK_BUTTON3_MASK,
+                       targets,
+                       GDK_ACTION_COPY);
   gdk_content_formats_unref (targets);
-
-  source = gtk_drag_source_new ();
-  content = gdk_content_provider_new_with_callback (GDK_TYPE_RGBA, get_rgba_value, button);
-  gtk_drag_source_set_content (source, content);
-  g_object_unref (content);
-  g_signal_connect (source, "drag-begin", G_CALLBACK (gtk_color_button_drag_begin), button);
-  gtk_widget_add_controller (priv->button, GTK_EVENT_CONTROLLER (source));
+  g_signal_connect (priv->button, "drag-begin",
+                    G_CALLBACK (gtk_color_button_drag_begin), button);
+  g_signal_connect (priv->button, "drag-data-received",
+                    G_CALLBACK (gtk_color_button_drag_data_received), button);
+  g_signal_connect (priv->button, "drag-data-get",
+                    G_CALLBACK (gtk_color_button_drag_data_get), button);
 
   context = gtk_widget_get_style_context (GTK_WIDGET (priv->button));
   gtk_style_context_add_class (context, "color");

gtk/gtkcolorchooserwidget.c

@@ -530,8 +530,7 @@ gtk_color_chooser_widget_init (GtkColorChooserWidget *cc)
   GtkWidget *button;
   GtkWidget *label;
   gint i;
-  double color[4];
-  GdkRGBA rgba;
+  GdkRGBA color;
   GVariant *variant;
   GVariantIter iter;
   gboolean selected;
@@ -569,20 +568,14 @@ gtk_color_chooser_widget_init (GtkColorChooserWidget *cc)
   g_variant_iter_init (&iter, variant);
   i = 0;
   p = NULL;
-  while (g_variant_iter_loop (&iter, "(dddd)", &color[0], &color[1], &color[2], &color[3]))
+  while (g_variant_iter_loop (&iter, "(dddd)", &color.red, &color.green, &color.blue, &color.alpha))
     {
       i++;
       p = gtk_color_swatch_new ();
-
-      rgba.red = color[0];
-      rgba.green = color[1];
-      rgba.blue = color[2];
-      rgba.alpha = color[3];
-
-      gtk_color_swatch_set_rgba (GTK_COLOR_SWATCH (p), &rgba);
+      gtk_color_swatch_set_rgba (GTK_COLOR_SWATCH (p), &color);
       gtk_color_swatch_set_can_drop (GTK_COLOR_SWATCH (p), TRUE);
       atk_obj = gtk_widget_get_accessible (p);
-      name = accessible_color_name (&rgba);
+      name = accessible_color_name (&color);
       text = g_strdup_printf (_("Custom color %d: %s"), i, name);
       atk_object_set_name (atk_obj, text);
       g_free (text);
@@ -605,15 +598,9 @@ gtk_color_chooser_widget_init (GtkColorChooserWidget *cc)
 
   g_settings_get (priv->settings, I_("selected-color"), "(bdddd)",
                   &selected,
-                  &color[0], &color[1], &color[2], &color[3]);
+                  &color.red, &color.green, &color.blue, &color.alpha);
   if (selected)
-    {
-      rgba.red = color[0];
-      rgba.green = color[1];
-      rgba.blue = color[2];
-      rgba.alpha = color[3];
-      gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (cc), &rgba);
-    }
+    gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (cc), &color);
 
   gtk_widget_hide (GTK_WIDGET (priv->editor));
 }

gtk/gtkcoloreditor.c

@@ -555,7 +555,7 @@ gtk_color_editor_get_rgba (GtkColorChooser *chooser,
                            GdkRGBA         *color)
 {
   GtkColorEditor *editor = GTK_COLOR_EDITOR (chooser);
-  float h, s, v;
+  gdouble h, s, v;
 
   h = gtk_adjustment_get_value (editor->priv->h_adj);
   s = gtk_adjustment_get_value (editor->priv->s_adj);
@@ -569,7 +569,7 @@ gtk_color_editor_set_rgba (GtkColorChooser *chooser,
                            const GdkRGBA   *color)
 {
   GtkColorEditor *editor = GTK_COLOR_EDITOR (chooser);
-  float h, s, v;
+  gdouble h, s, v;
 
   gtk_rgb_to_hsv (color->red, color->green, color->blue, &h, &s, &v);
 

gtk/gtkcolorpickerportal.c

@@ -149,11 +149,11 @@ portal_response_received (GDBusConnection *connection,
 
   if (response == 0)
     {
-      double d1, d2, d3;
+      GdkRGBA c;
 
-      if (g_variant_lookup (ret, "color", "(ddd)", &d1, &d2, &d3))
-        g_task_return_pointer (picker->task,
-                               gdk_rgba_copy (&(GdkRGBA){d1, d2, d3, 1.0f}), (GDestroyNotify)gdk_rgba_free);
+      c.alpha = 1.0;
+      if (g_variant_lookup (ret, "color", "(ddd)", &c.red, &c.green, &c.blue))
+        g_task_return_pointer (picker->task, gdk_rgba_copy (&c), (GDestroyNotify)gdk_rgba_free);
       else
         g_task_return_new_error (picker->task,
                                  G_IO_ERROR,

gtk/gtkcolorpickershell.c

@@ -129,15 +129,15 @@ color_picked (GObject      *source,
     }
   else
     {
-      double d1, d2, d3;
+      GdkRGBA c;
 
       g_variant_get (ret, "(@a{sv})", &dict);
 
-      if (!g_variant_lookup (dict, "color", "(ddd)", &d1, &d2, &d3))
+      c.alpha = 1;
+      if (!g_variant_lookup (dict, "color", "(ddd)", &c.red, &c.green, &c.blue))
         g_task_return_new_error (picker->task, G_IO_ERROR, G_IO_ERROR_FAILED, "No color received");
       else
-        g_task_return_pointer (picker->task,
-                               gdk_rgba_copy (&(GdkRGBA){d1, d2, d3, 1.0f}), (GDestroyNotify)gdk_rgba_free);
+        g_task_return_pointer (picker->task, gdk_rgba_copy (&c), (GDestroyNotify)gdk_rgba_free);
 
       g_variant_unref (dict);
       g_variant_unref (ret);

gtk/gtkcolorplane.c

@@ -118,8 +118,8 @@ create_texture (GtkColorPlane *plane)
   gint width, height, stride;
   guint red, green, blue;
   guint32 *data, *p;
-  float h, s, v;
-  float r, g, b;
+  gdouble h, s, v;
+  gdouble r, g, b;
   gdouble sf, vf;
   gint x, y;
 

gtk/gtkcolorscale.c

@@ -78,7 +78,7 @@ gtk_color_scale_snapshot_trough (GtkColorScale  *scale,
           GBytes *bytes;
           guchar *data, *p;
           gdouble h;
-          float r, g, b;
+          gdouble r, g, b;
           gdouble f;
           int hue_x, hue_y;
 

gtk/gtkcolorswatch.c

@@ -22,6 +22,7 @@
 #include "gtkbox.h"
 #include "gtkcolorchooserprivate.h"
 #include "gtkcssnodeprivate.h"
+#include "gtkdnd.h"
 #include "gtkdragdest.h"
 #include "gtkdragsource.h"
 #include "gtkgesturelongpress.h"
@@ -39,7 +40,6 @@
 #include "gtkwidgetprivate.h"
 #include "gtkeventcontrollerkey.h"
 #include "gtknative.h"
-#include "gtkdragsource.h"
 
 #include "a11y/gtkcolorswatchaccessibleprivate.h"
 
@@ -66,7 +66,6 @@ typedef struct
   GtkWidget *overlay_widget;
 
   GtkWidget *popover;
-  GtkDropTarget *dest;
 } GtkColorSwatchPrivate;
 
 enum
@@ -74,8 +73,7 @@ enum
   PROP_ZERO,
   PROP_RGBA,
   PROP_SELECTABLE,
-  PROP_HAS_MENU,
-  PROP_CAN_DROP
+  PROP_HAS_MENU
 };
 
 G_DEFINE_TYPE_WITH_PRIVATE (GtkColorSwatch, gtk_color_swatch, GTK_TYPE_WIDGET)
@@ -115,57 +113,87 @@ swatch_snapshot (GtkWidget   *widget,
   gtk_widget_snapshot_child (widget, priv->overlay_widget, snapshot);
 }
 
+
 static void
-gtk_color_swatch_drag_begin (GtkDragSource  *source,
-                             GdkDrag        *drag,
-                             GtkColorSwatch *swatch)
+drag_set_color_icon (GdkDrag        *drag,
+                     const GdkRGBA  *color)
 {
-  GtkColorSwatchPrivate *priv = gtk_color_swatch_get_instance_private (swatch);
   GtkSnapshot *snapshot;
   GdkPaintable *paintable;
 
   snapshot = gtk_snapshot_new ();
-  gtk_snapshot_append_color (snapshot, &priv->color, &GRAPHENE_RECT_INIT(0, 0, 48, 32));
+  gtk_snapshot_append_color (snapshot,
+                             color,
+                             &GRAPHENE_RECT_INIT(0, 0, 48, 32));
   paintable = gtk_snapshot_free_to_paintable (snapshot, NULL);
 
-  gtk_drag_source_set_icon (source, paintable, 0, 0);
-
+  gtk_drag_set_icon_paintable (drag, paintable, 4, 4);
   g_object_unref (paintable);
 }
 
 static void
-got_color (GObject      *source,
-           GAsyncResult *result,
-           gpointer      data)
+swatch_drag_begin (GtkWidget      *widget,
+                   GdkDrag        *drag)
 {
-  GdkDrop *drop = GDK_DROP (source);
-  const GValue *value;
+  GtkColorSwatch *swatch = GTK_COLOR_SWATCH (widget);
+  GdkRGBA color;
 
-  value = gdk_drop_read_value_finish (drop, result, NULL);
-  if (value)
-    {
-      GdkRGBA *color = g_value_get_boxed (value);
-      gtk_color_swatch_set_rgba (GTK_COLOR_SWATCH (data), color);
-      gdk_drop_finish (drop, GDK_ACTION_COPY);
-    }
-  else
-    gdk_drop_finish (drop, 0);
+  gtk_color_swatch_get_rgba (swatch, &color);
+  drag_set_color_icon (drag, &color);
 }
 
-static gboolean
-swatch_drag_drop (GtkDropTarget  *dest,
-                  GdkDrop        *drop,
-                  int             x,
-                  int             y,
-                  GtkColorSwatch *swatch)
+static void
+swatch_drag_data_get (GtkWidget        *widget,
+                      GdkDrag          *drag,
+                      GtkSelectionData *selection_data)
 {
-  if (gdk_drop_has_value (drop, GDK_TYPE_RGBA))
+  GtkColorSwatch *swatch = GTK_COLOR_SWATCH (widget);
+  guint16 vals[4];
+  GdkRGBA color;
+
+  gtk_color_swatch_get_rgba (swatch, &color);
+
+  vals[0] = color.red * 0xffff;
+  vals[1] = color.green * 0xffff;
+  vals[2] = color.blue * 0xffff;
+  vals[3] = color.alpha * 0xffff;
+
+  gtk_selection_data_set (selection_data,
+                          g_intern_static_string ("application/x-color"),
+                          16, (guchar *)vals, 8);
+}
+
+static void
+swatch_drag_data_received (GtkWidget        *widget,
+                           GdkDrop          *drop,
+                           GtkSelectionData *selection_data)
+{
+  gint length;
+  guint16 *vals;
+  GdkRGBA color;
+
+  length = gtk_selection_data_get_length (selection_data);
+
+  if (length < 0)
+    return;
+
+  /* We accept drops with the wrong format, since the KDE color
+   * chooser incorrectly drops application/x-color with format 8.
+   */
+  if (length != 8)
     {
-      gdk_drop_read_value_async (drop, GDK_TYPE_RGBA, G_PRIORITY_DEFAULT, NULL, got_color, swatch);
-      return TRUE;
+      g_warning ("Received invalid color data");
+      return;
     }
 
-  return FALSE;
+  vals = (guint16 *) gtk_selection_data_get_data (selection_data);
+
+  color.red   = (gdouble)vals[0] / 0xffff;
+  color.green = (gdouble)vals[1] / 0xffff;
+  color.blue  = (gdouble)vals[2] / 0xffff;
+  color.alpha = (gdouble)vals[3] / 0xffff;
+
+  gtk_color_swatch_set_rgba (GTK_COLOR_SWATCH (widget), &color);
 }
 
 static void
@@ -427,9 +455,6 @@ swatch_get_property (GObject    *object,
     case PROP_HAS_MENU:
       g_value_set_boolean (value, priv->has_menu);
       break;
-    case PROP_CAN_DROP:
-      g_value_set_boolean (value, priv->dest != NULL);
-      break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
@@ -456,9 +481,6 @@ swatch_set_property (GObject      *object,
     case PROP_HAS_MENU:
       priv->has_menu = g_value_get_boolean (value);
       break;
-    case PROP_CAN_DROP:
-      gtk_color_swatch_set_can_drop (swatch, g_value_get_boolean (value));
-      break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
@@ -473,7 +495,7 @@ swatch_finalize (GObject *object)
 
   g_free (priv->icon);
   gtk_widget_unparent (priv->overlay_widget);
- 
+
   G_OBJECT_CLASS (gtk_color_swatch_parent_class)->finalize (object);
 }
 
@@ -501,6 +523,9 @@ gtk_color_swatch_class_init (GtkColorSwatchClass *class)
 
   widget_class->measure = gtk_color_swatch_measure;
   widget_class->snapshot = swatch_snapshot;
+  widget_class->drag_begin = swatch_drag_begin;
+  widget_class->drag_data_get = swatch_drag_data_get;
+  widget_class->drag_data_received = swatch_drag_data_received;
   widget_class->popup_menu = swatch_popup_menu;
   widget_class->size_allocate = swatch_size_allocate;
   widget_class->state_flags_changed = swatch_state_flags_changed;
@@ -514,9 +539,6 @@ gtk_color_swatch_class_init (GtkColorSwatchClass *class)
   g_object_class_install_property (object_class, PROP_HAS_MENU,
       g_param_spec_boolean ("has-menu", P_("Has Menu"), P_("Whether the swatch should offer customization"),
                             TRUE, GTK_PARAM_READWRITE));
-  g_object_class_install_property (object_class, PROP_CAN_DROP,
-      g_param_spec_boolean ("can-drop", P_("Can Drop"), P_("Whether the swatch should accept drops"),
-                            FALSE, GTK_PARAM_READWRITE));
 
   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_COLOR_SWATCH_ACCESSIBLE);
   gtk_widget_class_set_css_name (widget_class, I_("colorswatch"));
@@ -529,6 +551,7 @@ gtk_color_swatch_init (GtkColorSwatch *swatch)
   GtkEventController *controller;
   GtkGesture *gesture;
 
+  priv = gtk_color_swatch_get_instance_private (swatch);
   priv->use_alpha = TRUE;
   priv->selectable = TRUE;
   priv->has_menu = TRUE;
@@ -578,14 +601,6 @@ static const char *dnd_targets[] = {
   "application/x-color"
 };
 
-static void
-get_rgba_value (GValue   *value,
-                gpointer  data)
-{
-  GtkColorSwatchPrivate *priv = gtk_color_swatch_get_instance_private (GTK_COLOR_SWATCH (data));
-  g_value_set_boxed (value, &priv->color);
-}
-
 void
 gtk_color_swatch_set_rgba (GtkColorSwatch *swatch,
                            const GdkRGBA  *color)
@@ -597,16 +612,12 @@ gtk_color_swatch_set_rgba (GtkColorSwatch *swatch,
 
   if (!priv->has_color)
     {
-      GdkContentProvider *content;
-      GtkDragSource *source;
-
-      source = gtk_drag_source_new ();
-      content = gdk_content_provider_new_with_callback (GDK_TYPE_RGBA, get_rgba_value, swatch);
-      gtk_drag_source_set_content (source, content);
-      g_object_unref (content);
-      g_signal_connect (source, "drag-begin", G_CALLBACK (gtk_color_swatch_drag_begin), swatch);
-
-      gtk_widget_add_controller (GTK_WIDGET (swatch), GTK_EVENT_CONTROLLER (source));
+      GdkContentFormats *targets = gdk_content_formats_new (dnd_targets, G_N_ELEMENTS (dnd_targets));
+      gtk_drag_source_set (GTK_WIDGET (swatch),
+                           GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
+                           targets,
+                           GDK_ACTION_COPY | GDK_ACTION_MOVE);
+      gdk_content_formats_unref (targets);
     }
 
   priv->has_color = TRUE;
@@ -666,28 +677,21 @@ void
 gtk_color_swatch_set_can_drop (GtkColorSwatch *swatch,
                                gboolean        can_drop)
 {
-  GtkColorSwatchPrivate *priv = gtk_color_swatch_get_instance_private (swatch);
-
-  if (can_drop == (priv->dest != NULL))
-    return;
-
-  if (can_drop && !priv->dest)
+  if (can_drop)
     {
-      GdkContentFormats *targets;
-
-      targets = gdk_content_formats_new (dnd_targets, G_N_ELEMENTS (dnd_targets));
-      priv->dest = gtk_drop_target_new (targets, GDK_ACTION_COPY);
-      g_signal_connect (priv->dest, "drag-drop", G_CALLBACK (swatch_drag_drop), swatch);
-      gtk_widget_add_controller (GTK_WIDGET (swatch), GTK_EVENT_CONTROLLER (priv->dest));
+      GdkContentFormats *targets = gdk_content_formats_new (dnd_targets, G_N_ELEMENTS (dnd_targets));
+      gtk_drag_dest_set (GTK_WIDGET (swatch),
+                         GTK_DEST_DEFAULT_HIGHLIGHT |
+                         GTK_DEST_DEFAULT_MOTION |
+                         GTK_DEST_DEFAULT_DROP,
+                         targets,
+                         GDK_ACTION_COPY);
       gdk_content_formats_unref (targets);
     }
-  if (!can_drop && priv->dest)
+  else
     {
-      gtk_widget_remove_controller (GTK_WIDGET (swatch), GTK_EVENT_CONTROLLER (priv->dest));
-      priv->dest = NULL;
+      gtk_drag_dest_unset (GTK_WIDGET (swatch));
     }
-
-  g_object_notify (G_OBJECT (swatch), "can-drop");
 }
 
 void

gtk/gtkcolorutils.c

@@ -39,12 +39,12 @@
 
 /* Converts from HSV to RGB */
 static void
-hsv_to_rgb (float *h,
-            float *s,
-            float *v)
+hsv_to_rgb (gdouble *h,
+            gdouble *s,
+            gdouble *v)
 {
-  float hue, saturation, value;
-  float f, p, q, t;
+  gdouble hue, saturation, value;
+  gdouble f, p, q, t;
 
   if (*s == 0.0)
     {
@@ -112,14 +112,14 @@ hsv_to_rgb (float *h,
 
 /* Converts from RGB to HSV */
 static void
-rgb_to_hsv (float *r,
-            float *g,
-            float *b)
+rgb_to_hsv (gdouble *r,
+            gdouble *g,
+            gdouble *b)
 {
-  float red, green, blue;
-  float h, s, v;
-  float min, max;
-  float delta;
+  gdouble red, green, blue;
+  gdouble h, s, v;
+  gdouble min, max;
+  gdouble delta;
 
   red = *r;
   green = *g;
@@ -200,8 +200,8 @@ rgb_to_hsv (float *r,
  * output values will be in the same range.
  */
 void
-gtk_hsv_to_rgb (float  h, float  s, float  v,
-                float *r, float *g, float *b)
+gtk_hsv_to_rgb (gdouble  h, gdouble  s, gdouble  v,
+                gdouble *r, gdouble *g, gdouble *b)
 {
   g_return_if_fail (h >= 0.0 && h <= 1.0);
   g_return_if_fail (s >= 0.0 && s <= 1.0);
@@ -234,8 +234,8 @@ gtk_hsv_to_rgb (float  h, float  s, float  v,
  * output values will be in the same range.
  */
 void
-gtk_rgb_to_hsv (float  r, float  g, float  b,
-                float *h, float *s, float *v)
+gtk_rgb_to_hsv (gdouble  r, gdouble  g, gdouble  b,
+                gdouble *h, gdouble *s, gdouble *v)
 {
   g_return_if_fail (r >= 0.0 && r <= 1.0);
   g_return_if_fail (g >= 0.0 && g <= 1.0);

gtk/gtkcolorutils.h

@@ -40,11 +40,11 @@
 G_BEGIN_DECLS
 
 GDK_AVAILABLE_IN_ALL
-void gtk_hsv_to_rgb (float  h, float  s, float  v,
-                     float *r, float *g, float *b);
+void gtk_hsv_to_rgb (gdouble  h, gdouble  s, gdouble  v,
+                     gdouble *r, gdouble *g, gdouble *b);
 GDK_AVAILABLE_IN_ALL
-void gtk_rgb_to_hsv (float  r, float  g, float  b,
-                     float *h, float *s, float *v);
+void gtk_rgb_to_hsv (gdouble  r, gdouble  g, gdouble  b,
+                     gdouble *h, gdouble *s, gdouble *v);
 
 G_END_DECLS