app: add gimp_drawable_filter_set_add_alpha()

Add an optional "format" parameter to gimp_drawable_merge_filter(),
which specifies the format to use for the output, possibly changing
the drawable's format.

In GimpDrawableFilter, add a gimp_drawable_filter_set_add_alpha()
function, which allows the filter to add an alpha channel to the
drawable when committed (by passing an appropriate format to
gimp_drawable_merge_filter()).

app/core/gimpdrawable-filters.c

@@ -111,6 +111,7 @@ gimp_drawable_merge_filter (GimpDrawable *drawable,
                             GimpFilter   *filter,
                             GimpProgress *progress,
                             const gchar  *undo_desc,
+                            const Babl   *format,
                             gboolean      clip,
                             gboolean      cancellable,
                             gboolean      update)
@@ -121,7 +122,7 @@ gimp_drawable_merge_filter (GimpDrawable *drawable,
   const Babl     *applicator_output_format = NULL;
   GeglBuffer     *buffer                   = NULL;
   GeglBuffer     *dest_buffer;
-  GeglBuffer     *undo_buffer;
+  GeglBuffer     *undo_buffer              = NULL;
   GeglRectangle   undo_rect;
   GeglBuffer     *cache                    = NULL;
   GeglRectangle  *rects                    = NULL;
@@ -137,6 +138,9 @@ gimp_drawable_merge_filter (GimpDrawable *drawable,
   applicator  = gimp_filter_get_applicator (filter);
   dest_buffer = gimp_drawable_get_buffer (drawable);
 
+  if (format == gimp_drawable_get_format (drawable))
+    format = NULL;
+
   rect = gegl_node_get_bounding_box (gimp_filter_get_node (filter));
 
   if (! clip && gegl_rectangle_equal (&rect,
@@ -153,11 +157,19 @@ gimp_drawable_merge_filter (GimpDrawable *drawable,
         {
           return TRUE;
         }
+
+      if (format)
+        {
+          buffer = gegl_buffer_new (gegl_buffer_get_extent (dest_buffer),
+                                    format);
+
+          dest_buffer = buffer;
+        }
     }
   else
     {
       buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, rect.width, rect.height),
-                                gimp_drawable_get_format (drawable));
+                                format);
 
       dest_buffer = g_object_new (GEGL_TYPE_BUFFER,
                                   "source",  buffer,
@@ -193,7 +205,7 @@ gimp_drawable_merge_filter (GimpDrawable *drawable,
         gimp_applicator_set_output_format (applicator, NULL);
     }
 
-  if (clip)
+  if (! buffer)
     {
       gegl_rectangle_align_to_buffer (
         &undo_rect,
@@ -231,9 +243,19 @@ gimp_drawable_merge_filter (GimpDrawable *drawable,
 
       if (clip)
         {
-          gimp_drawable_push_undo (drawable, undo_desc, undo_buffer,
+          if (buffer)
-                                   undo_rect.x, undo_rect.y,
+            {
-                                   undo_rect.width, undo_rect.height);
+              gimp_drawable_set_buffer_full (drawable,
+                                             TRUE, undo_desc,
+                                             buffer, NULL,
+                                             FALSE);
+            }
+          else
+            {
+              gimp_drawable_push_undo (drawable, undo_desc, undo_buffer,
+                                       undo_rect.x, undo_rect.y,
+                                       undo_rect.width, undo_rect.height);
+            }
         }
       else
         {
@@ -289,7 +311,8 @@ gimp_drawable_merge_filter (GimpDrawable *drawable,
 
   if (clip)
     {
-      g_object_unref (undo_buffer);
+      g_clear_object (&undo_buffer);
+      g_clear_object (&buffer);
     }
   else
     {

app/core/gimpdrawable-filters.h

@@ -37,6 +37,7 @@ gboolean        gimp_drawable_merge_filter  (GimpDrawable *drawable,
                                              GimpFilter   *filter,
                                              GimpProgress *progress,
                                              const gchar  *undo_desc,
+                                             const Babl   *format,
                                              gboolean      clip,
                                              gboolean      cancellable,
                                              gboolean      update);

app/core/gimpdrawablefilter.c

@@ -77,6 +77,7 @@ struct _GimpDrawableFilter
   GimpLayerColorSpace     blend_space;
   GimpLayerColorSpace     composite_space;
   GimpLayerCompositeMode  composite_mode;
+  gboolean                add_alpha;
   gboolean                color_managed;
   gboolean                gamma_hack;
 
@@ -434,6 +435,23 @@ gimp_drawable_filter_set_mode (GimpDrawableFilter     *filter,
     }
 }
 
+void
+gimp_drawable_filter_set_add_alpha (GimpDrawableFilter *filter,
+                                    gboolean            add_alpha)
+{
+  g_return_if_fail (GIMP_IS_DRAWABLE_FILTER (filter));
+
+  if (add_alpha != filter->add_alpha)
+    {
+      filter->add_alpha = add_alpha;
+
+      gimp_drawable_filter_sync_format (filter);
+
+      if (gimp_drawable_filter_is_filtering (filter))
+        gimp_drawable_filter_update_drawable (filter, NULL);
+    }
+}
+
 void
 gimp_drawable_filter_set_color_managed (GimpDrawableFilter *filter,
                                         gboolean            color_managed)
@@ -499,6 +517,10 @@ gimp_drawable_filter_commit (GimpDrawableFilter *filter,
 
   if (gimp_drawable_filter_is_filtering (filter))
     {
+      const Babl *format;
+
+      format = gimp_applicator_get_output_format (filter->applicator);
+
       gimp_drawable_filter_set_preview (filter, FALSE,
                                         filter->preview_alignment,
                                         filter->preview_position);
@@ -507,6 +529,7 @@ gimp_drawable_filter_commit (GimpDrawableFilter *filter,
                                             GIMP_FILTER (filter),
                                             progress,
                                             gimp_object_get_name (filter),
+                                            format,
                                             filter->filter_clip,
                                             cancellable,
                                             FALSE);
@@ -803,9 +826,14 @@ gimp_drawable_filter_sync_affect (GimpDrawableFilter *filter)
 static void
 gimp_drawable_filter_sync_format (GimpDrawableFilter *filter)
 {
-  gimp_applicator_set_output_format (
+  const Babl *format;
-    filter->applicator,
+
-    gimp_drawable_get_format (filter->drawable));
+  if (filter->add_alpha && GIMP_IS_LAYER (filter->drawable))
+    format = gimp_drawable_get_format_with_alpha (filter->drawable);
+  else
+    format = gimp_drawable_get_format (filter->drawable);
+
+  gimp_applicator_set_output_format (filter->applicator, format);
 }
 
 static void

app/core/gimpdrawablefilter.h

@@ -73,6 +73,8 @@ void       gimp_drawable_filter_set_mode       (GimpDrawableFilter  *filter,
                                                 GimpLayerColorSpace  blend_space,
                                                 GimpLayerColorSpace  composite_space,
                                                 GimpLayerCompositeMode composite_mode);
+void       gimp_drawable_filter_set_add_alpha  (GimpDrawableFilter  *filter,
+                                                gboolean             add_alpha);
 
 void       gimp_drawable_filter_set_color_managed
                                                (GimpDrawableFilter  *filter,

app/core/gimplayer-floating-selection.c

@@ -142,7 +142,7 @@ floating_sel_anchor (GimpLayer *layer)
   if (filter)
     {
       gimp_drawable_merge_filter (drawable, filter, NULL, NULL,
-                                  FALSE, FALSE, FALSE);
+                                  NULL, FALSE, FALSE, FALSE);
     }
 
   gimp_image_remove_layer (image, layer, TRUE, NULL);