Update upstream

app/gegl/pika-gegl-utils.c

@@ -26,13 +26,19 @@
 
 #include <string.h>
 
+#include <cairo.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
 #include <gegl.h>
 #include <gegl-plugin.h>
 
+#include "libpikacolor/pikacolor.h"
+
 #include "pika-gegl-types.h"
 
+#include "core/pikapattern.h"
 #include "core/pikaprogress.h"
 
+#include "pika-babl.h"
 #include "pika-gegl-loops.h"
 #include "pika-gegl-utils.h"
 
@@ -337,6 +343,100 @@ pika_gegl_buffer_dup (GeglBuffer *buffer)
   return new_buffer;
 }
 
+GeglBuffer *
+pika_gegl_buffer_resize (GeglBuffer   *buffer,
+                         gint          new_width,
+                         gint          new_height,
+                         gint          offset_x,
+                         gint          offset_y,
+                         PikaRGB      *color,
+                         PikaPattern  *pattern,
+                         gint          pattern_offset_x,
+                         gint          pattern_offset_y)
+{
+  GeglBuffer          *new_buffer;
+  gboolean             intersect;
+  GeglRectangle        copy_rect;
+  const GeglRectangle *extent;
+  const Babl          *format;
+
+  g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL);
+
+  extent     = gegl_buffer_get_extent (buffer);
+  format     = gegl_buffer_get_format (buffer);
+  new_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, new_width, new_height),
+                                format);
+
+  intersect = gegl_rectangle_intersect (&copy_rect,
+                                        GEGL_RECTANGLE (0, 0, extent->width,
+                                                        extent->height),
+                                        GEGL_RECTANGLE (offset_x, offset_y,
+                                                        new_width, new_height));
+
+  if (! intersect                   ||
+      copy_rect.width  != new_width ||
+      copy_rect.height != new_height)
+    {
+      /*  Clear the new buffer if needed and color/pattern is given */
+      if (pattern)
+        {
+          GeglBuffer       *src_buffer;
+          GeglBuffer       *dest_buffer;
+          PikaColorProfile *src_profile;
+          PikaColorProfile *dest_profile;
+
+          src_buffer = pika_pattern_create_buffer (pattern);
+
+          src_profile  = pika_babl_format_get_color_profile (
+                           gegl_buffer_get_format (src_buffer));
+          dest_profile = pika_babl_format_get_color_profile (
+                           gegl_buffer_get_format (new_buffer));
+
+          if (pika_color_transform_can_gegl_copy (src_profile, dest_profile))
+            {
+              dest_buffer = g_object_ref (src_buffer);
+            }
+          else
+            {
+              dest_buffer = gegl_buffer_new (gegl_buffer_get_extent (src_buffer),
+                                             gegl_buffer_get_format (new_buffer));
+
+              pika_gegl_convert_color_profile (src_buffer,  NULL, src_profile,
+                                               dest_buffer, NULL, dest_profile,
+                                               PIKA_COLOR_RENDERING_INTENT_PERCEPTUAL,
+                                               TRUE, NULL);
+            }
+
+          g_object_unref (src_profile);
+          g_object_unref (dest_profile);
+
+          gegl_buffer_set_pattern (new_buffer, NULL, dest_buffer,
+                                   pattern_offset_x, pattern_offset_y);
+
+          g_object_unref (src_buffer);
+          g_object_unref (dest_buffer);
+        }
+      else if (color)
+        {
+          GeglColor *gegl_color;
+
+          gegl_color = pika_gegl_color_new (color, gegl_buffer_get_format (buffer));
+          gegl_buffer_set_color (new_buffer, NULL, gegl_color);
+          g_object_unref (gegl_color);
+        }
+    }
+
+  if (intersect && copy_rect.width && copy_rect.height)
+    {
+      /*  Copy the pixels in the intersection  */
+      pika_gegl_buffer_copy (buffer, &copy_rect, GEGL_ABYSS_NONE, new_buffer,
+                             GEGL_RECTANGLE (copy_rect.x - offset_x,
+                                             copy_rect.y - offset_y, 0, 0));
+    }
+
+  return new_buffer;
+}
+
 gboolean
 pika_gegl_buffer_set_extent (GeglBuffer          *buffer,
                              const GeglRectangle *extent)

app/gegl/pika-gegl-utils.h

@@ -59,6 +59,15 @@ gboolean      pika_gegl_param_spec_has_key            (GParamSpec          *pspe
                                                        const gchar         *value);
 
 GeglBuffer  * pika_gegl_buffer_dup                    (GeglBuffer          *buffer);
+GeglBuffer  * pika_gegl_buffer_resize                 (GeglBuffer          *buffer,
+                                                       gint                 new_width,
+                                                       gint                 new_height,
+                                                       gint                 offset_x,
+                                                       gint                 offset_y,
+                                                       PikaRGB             *color,
+                                                       PikaPattern         *pattern,
+                                                       gint                 pattern_offset_x,
+                                                       gint                 pattern_offset_y);
 
 gboolean      pika_gegl_buffer_set_extent             (GeglBuffer          *buffer,
                                                        const GeglRectangle *extent);