# GIMP - The GNU Image Manipulation Program
# Copyright (C) 1995 Spencer Kimball and Peter Mattis

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.

# "Perlized" from C source by Manish Singh <yosh@gimp.org>

sub edit_cut {
    $blurb = 'Cut from the specified drawables.';

    $help = <<'HELP';
If there is a selection in the image, then the area specified by the
selection is cut from the specified drawables and placed in an internal
GIMP edit buffer. It can subsequently be retrieved using the
gimp_edit_paste() command. If there is no selection and only one
specified drawable, then the specified drawable will be removed and its
contents stored in the internal GIMP edit buffer.

This procedure will return %FALSE if the selected area lies completely
outside the bounds of the current drawables and there is nothing to cut
from.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'drawables', type => 'drawablearray',
         desc => 'The drawables to cut from' }
    );

    @outargs = (
 { name => 'non_empty', type => 'boolean',
   desc => 'TRUE if the cut was successful,
                   FALSE if there was nothing to copy from' }
    );

    %invoke = (
 code => <<CODE
{
  GimpImage *image         = NULL;
  GList     *drawable_list = NULL;
  gint       i;

  for (i = 0; drawables[i] != NULL; i++)
    {
      if (! gimp_pdb_item_is_attached (GIMP_ITEM (drawables[i]), NULL,
                                       GIMP_PDB_ITEM_CONTENT, error) ||
          ! gimp_pdb_item_is_not_group (GIMP_ITEM (drawables[i]), error))
        {
          success = FALSE;
          break;
        }

      if (! image)
        {
          image = gimp_item_get_image (GIMP_ITEM (drawables[i]));
        }
      else if (image != gimp_item_get_image (GIMP_ITEM (drawables[i])))
        {
          success = FALSE;
          gimp_message_literal (gimp,
                                G_OBJECT (progress), GIMP_MESSAGE_WARNING,
                                _("All specified drawables must belong to the same image."));
          break;
        }

      drawable_list = g_list_prepend (drawable_list, (gpointer) drawables[i]);
    }

  if (success && image)
    {
      GError *my_error = NULL;

      non_empty = gimp_edit_cut (image, drawable_list, context, &my_error) != NULL;

      if (! non_empty)
        {
          gimp_message_literal (gimp,
                                G_OBJECT (progress), GIMP_MESSAGE_WARNING,
                                my_error->message);
          g_clear_error (&my_error);
        }
    }
  else
    {
      success = FALSE;
    }
  g_list_free (drawable_list);
}
CODE
    );
}

sub edit_copy {
    $blurb = 'Copy from the specified drawables.';

    $help = <<'HELP';
If there is a selection in the image, then the area specified by the
selection is copied from the specified drawables and placed in an
internal GIMP edit buffer. It can subsequently be retrieved using the
gimp_edit_paste() command.  If there is no selection, then the
specified drawables' contents will be stored in the internal GIMP edit
buffer.

This procedure will return %FALSE if the selected area lies
completely outside the bounds of the current drawables and there is
nothing to copy from.

All the drawables must belong to the same image.
HELP

    &std_pdb_misc;

    @inargs = (
 { name => 'drawables', type => 'drawablearray',
          desc => 'Drawables to copy from' }
    );

    @outargs = (
 { name => 'non_empty', type => 'boolean',
   desc => 'TRUE if the cut was successful,
                   FALSE if there was nothing to copy from' }
    );

    %invoke = (
 code => <<CODE
{
  GimpImage *image          = NULL;
  GList     *drawables_list = NULL;
  gint       i;

  for (i = 0; drawables[i] != NULL; i++)
    {
      if (! gimp_pdb_item_is_attached (GIMP_ITEM (drawables[i]), NULL, 0, error))
        {
          success = FALSE;
          break;
        }
      if (image == NULL)
        {
          image = gimp_item_get_image (GIMP_ITEM (drawables[i]));
        }
      else if (image != gimp_item_get_image (GIMP_ITEM (drawables[i])))
        {
          success = FALSE;
          break;
        }
      drawables_list = g_list_prepend (drawables_list, (gpointer) drawables[i]);
    }

  if (success && g_list_length (drawables_list) > 0)
    {
      GError *my_error = NULL;

      non_empty = gimp_edit_copy (image, drawables_list, context, FALSE, &my_error) != NULL;

      if (! non_empty)
        {
          gimp_message_literal (gimp,
                                G_OBJECT (progress), GIMP_MESSAGE_WARNING,
                                my_error->message);
          g_clear_error (&my_error);
        }
    }
  else
    success = FALSE;

  g_list_free (drawables_list);
}
CODE
    );
}

sub edit_copy_visible {
    $blurb = 'Copy from the projection.';

    $help = <<'HELP';
If there is a selection in the image, then the area specified by the
selection is copied from the projection and placed in an internal GIMP
edit buffer. It can subsequently be retrieved using the
gimp_edit_paste() command. If there is no selection, then the
projection's contents will be stored in the internal GIMP edit buffer.
HELP

    &mitch_pdb_misc('2004', '2.2');

    @inargs = (
 { name => 'image', type => 'image',
   desc => "The image to copy from" }
    );

    @outargs = (
 { name => 'non_empty', type => 'boolean',
   desc => 'TRUE if the copy was successful' }
    );

    %invoke = (
 code => <<CODE
{
  GError *my_error = NULL;

  non_empty = gimp_edit_copy_visible (image, context, &my_error) != NULL;

  if (! non_empty)
    {
      gimp_message_literal (gimp,
                            G_OBJECT (progress), GIMP_MESSAGE_WARNING,
                            my_error->message);
      g_clear_error (&my_error);
    }
}
CODE
    );
}

sub edit_paste {
    $blurb = 'Paste buffer to the specified drawable.';

    $help = <<'HELP';
This procedure pastes a copy of the internal GIMP edit buffer to the
specified drawable. The GIMP edit buffer will be empty unless a call
was previously made to either [func@Gimp.edit_cut] or [func@Gimp.edit_copy].
The "paste_into" option specifies whether to clear the current image
selection, or to paste the buffer "behind" the selection. This allows
the selection to act as a mask for the pasted buffer. Anywhere that
the selection mask is non-zero, the pasted buffer will show
through.
The pasted data may be a floating selection when relevant, layers otherwise.
If the image has a floating selection at the time of pasting, the old
floating selection will be anchored to its drawable before the new
floating selection is added.

This procedure returns the new drawables (floating or not). If the result
is a floating selection, it will already be attached to the specified
drawable, and a subsequent call to [func@Gimp.floating_sel_attach] is not needed.
HELP

    &std_pdb_misc;

    @inargs = (
 { name => 'drawable', type => 'drawable',
   desc => 'The drawable to paste to' },
        { name => 'paste_into', type => 'boolean',
   desc => 'Clear selection, or paste behind it?' }
    );

    @outargs = (
        { name => 'new_drawables', type => 'drawablearray',
          desc => 'The list of pasted layers.' }
    );

    %invoke = (
 code => <<CODE
{
  GimpObject *paste = gimp_get_clipboard_object (gimp);

  if (paste &&
      gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
                                 GIMP_PDB_ITEM_CONTENT, error) &&
      gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
    {
      GList *drawables = NULL;
      GList *list;
      gint   num_drawables;
      gint   i;

      if (drawable != NULL)
        drawables = g_list_prepend (drawables, drawable);

      list = gimp_edit_paste (gimp_item_get_image (GIMP_ITEM (drawable)),
                              drawables, paste,
                              paste_into ?
                              GIMP_PASTE_TYPE_FLOATING_INTO :
                              GIMP_PASTE_TYPE_FLOATING,
                              context, FALSE,
                              -1, -1, -1, -1);
      g_list_free (drawables);

      if (! list)
        success = FALSE;

      num_drawables = g_list_length (list);
      new_drawables = g_new0 (GimpDrawable *, num_drawables + 1);

      for (i = 0; i < num_drawables; i++, list = g_list_next (list))
        new_drawables[i] = g_object_ref (list->data);

      g_list_free (list);
    }
  else
    success = FALSE;
}
CODE
    );
}

sub edit_paste_as_new_image {
    $blurb = 'Paste buffer to a new image.';

    $help = <<'HELP';
This procedure pastes a copy of the internal GIMP edit buffer to a new
image.  The GIMP edit buffer will be empty unless a call was
previously made to either gimp_edit_cut() or gimp_edit_copy(). This
procedure returns the new image or -1 if the edit buffer was empty.
HELP

    &mitch_pdb_misc('2005', '2.10');

    @outargs = (
 { name => 'image', type => 'image',
   desc => 'The new image' }
    );
    %invoke = (
 code => <<CODE
{
  GimpObject *paste = gimp_get_clipboard_object (gimp);

  if (paste)
    {
      image = gimp_edit_paste_as_new_image (gimp, paste, context);

      if (! image)
        success = FALSE;
    }
}
CODE
    );
}

sub edit_named_cut {
    $blurb = 'Cut into a named buffer.';

    $help = <<'HELP';
This procedure works like gimp_edit_cut(), but additionally stores the
cut buffer into a named buffer that will stay available for later
pasting, regardless of any intermediate copy or cut operations.
HELP

    &mitch_pdb_misc('2005', '2.4');

    @inargs = (
        { name => 'drawables', type => 'drawablearray',
         desc => 'The drawables to cut from' },
        { name => 'buffer_name', type => 'string', non_empty => 1,
          desc => 'The name of the buffer to create' }
    );

    @outargs = (
 { name => 'real_name', type => 'string',
   desc => 'The real name given to the buffer, or NULL if the
                   cut failed' }
    );

    %invoke = (
 code => <<CODE
{
  GimpImage *image         = NULL;
  GList     *drawable_list = NULL;
  gint       i;

  for (i = 0; drawables[i] != NULL; i++)
    {
      if (! gimp_pdb_item_is_attached (GIMP_ITEM (drawables[i]), NULL,
                                       GIMP_PDB_ITEM_CONTENT, error) ||
          ! gimp_pdb_item_is_not_group (GIMP_ITEM (drawables[i]), error))
        {
          success = FALSE;
          break;
        }

      if (! image)
        {
          image = gimp_item_get_image (GIMP_ITEM (drawables[i]));
        }
      else if (image != gimp_item_get_image (GIMP_ITEM (drawables[i])))
        {
          success = FALSE;
          gimp_message_literal (gimp,
                                G_OBJECT (progress), GIMP_MESSAGE_WARNING,
                                _("All specified drawables must belong to the same image."));
          break;
        }

      drawable_list = g_list_prepend (drawable_list, (gpointer) drawables[i]);
    }

  if (success && image)
    {
      GError *my_error = NULL;

      real_name = (gchar *) gimp_edit_named_cut (image, buffer_name,
                                                 drawable_list, context, &my_error);

      if (real_name)
        {
          real_name = g_strdup (real_name);
        }
      else
        {
          gimp_message_literal (gimp,
                                G_OBJECT (progress), GIMP_MESSAGE_WARNING,
                                my_error->message);
          g_clear_error (&my_error);
        }
    }
  else
    {
      success = FALSE;
    }
  g_list_free (drawable_list);
}
CODE
    );
}

sub edit_named_copy {
    $blurb = 'Copy into a named buffer.';

    $help = <<'HELP';
This procedure works like gimp_edit_copy(), but additionally stores the
copied buffer into a named buffer that will stay available for later
pasting, regardless of any intermediate copy or cut operations.
HELP

    &mitch_pdb_misc('2005', '2.4');

    @inargs = (
        { name => 'drawables', type => 'drawablearray',
         desc => 'The drawables to copy from' },
        { name => 'buffer_name', type => 'string', non_empty => 1,
          desc => 'The name of the buffer to create' }
    );

    @outargs = (
 { name => 'real_name', type => 'string',
   desc => 'The real name given to the buffer, or NULL if the
                   copy failed' }
    );

    %invoke = (
 code => <<CODE
{
  GimpImage *image         = NULL;
  GList     *drawable_list = NULL;
  gint       i;

  for (i = 0; drawables[i] != NULL; i++)
    {
      if (! gimp_pdb_item_is_attached (GIMP_ITEM (drawables[i]), NULL,
                                       0, error))
        {
          success = FALSE;
          break;
        }

      if (! image)
        {
          image = gimp_item_get_image (GIMP_ITEM (drawables[i]));
        }
      else if (image != gimp_item_get_image (GIMP_ITEM (drawables[i])))
        {
          success = FALSE;
          gimp_message_literal (gimp,
                                G_OBJECT (progress), GIMP_MESSAGE_WARNING,
                                _("All specified drawables must belong to the same image."));
          break;
        }

      drawable_list = g_list_prepend (drawable_list, (gpointer) drawables[i]);
    }

  if (success && image)
    {
      GError *my_error = NULL;

      real_name = (gchar *) gimp_edit_named_copy (image, buffer_name,
                                                  drawable_list, context, &my_error);

      if (real_name)
        {
          real_name = g_strdup (real_name);
        }
      else
        {
          gimp_message_literal (gimp,
                                G_OBJECT (progress), GIMP_MESSAGE_WARNING,
                                my_error->message);
          g_clear_error (&my_error);
        }
    }
  else
    {
      success = FALSE;
    }
  g_list_free (drawable_list);
}
CODE
    );
}

sub edit_named_copy_visible {
    $blurb = 'Copy from the projection into a named buffer.';

    $help = <<'HELP';
This procedure works like gimp_edit_copy_visible(), but additionally
stores the copied buffer into a named buffer that will stay available
for later pasting, regardless of any intermediate copy or cut
operations.
HELP

    &mitch_pdb_misc('2005', '2.4');

    @inargs = (
 { name => 'image', type => 'image',
   desc => "The image to copy from" },
        { name => 'buffer_name', type => 'string', non_empty => 1,
          desc => 'The name of the buffer to create' }
    );

    @outargs = (
 { name => 'real_name', type => 'string',
   desc => 'The real name given to the buffer, or NULL if the
                   copy failed' }
    );

    %invoke = (
 code => <<CODE
{
  GError *my_error = NULL;

  real_name = (gchar *) gimp_edit_named_copy_visible (image, buffer_name,
                                                      context, &my_error);

  if (real_name)
    {
      real_name = g_strdup (real_name);
    }
  else
    {
      gimp_message_literal (gimp,
                            G_OBJECT (progress), GIMP_MESSAGE_WARNING,
                            my_error->message);
      g_clear_error (&my_error);
    }
}
CODE
    );
}

sub edit_named_paste {
    $blurb = 'Paste named buffer to the specified drawable.';

    $help = <<'HELP';
This procedure works like gimp_edit_paste() but pastes a named buffer
instead of the global buffer.
HELP

    &mitch_pdb_misc('2005', '2.4');

    @inargs = (
 { name => 'drawable', type => 'drawable',
   desc => 'The drawable to paste to' },
        { name => 'buffer_name', type => 'string',
          desc => 'The name of the buffer to paste' },
        { name => 'paste_into', type => 'boolean',
   desc => 'Clear selection, or paste behind it?' }
    );

    @outargs = (
 { name  => 'floating_sel', type  => 'layer',
   desc  => 'The new floating selection' }
    );

    %invoke = (
 code => <<CODE
{
  GimpBuffer *buffer = gimp_pdb_get_buffer (gimp, buffer_name, error);

  if (buffer &&
      gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
                                 GIMP_PDB_ITEM_CONTENT, error) &&
      gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
    {
      GList *drawables = NULL;
      GList *layers;

      if (drawable != NULL)
        drawables = g_list_prepend (drawables, drawable);

      layers = gimp_edit_paste (gimp_item_get_image (GIMP_ITEM (drawable)),
                                drawables, GIMP_OBJECT (buffer),
                                paste_into ?
                                GIMP_PASTE_TYPE_FLOATING_INTO :
                                GIMP_PASTE_TYPE_FLOATING,
                                context, FALSE,
                                -1, -1, -1, -1);
      g_list_free (drawables);

      if (! layers)
        success = FALSE;
      else
        floating_sel = layers->data;

      g_list_free (layers);
    }
  else
    success = FALSE;
}
CODE
    )
}

sub edit_named_paste_as_new_image {
    $blurb = 'Paste named buffer to a new image.';

    $help = <<'HELP';
This procedure works like gimp_edit_paste_as_new_image() but pastes a
named buffer instead of the global buffer.
HELP

    &mitch_pdb_misc('2005', '2.10');

    @inargs = (
        { name => 'buffer_name', type => 'string',
          desc => 'The name of the buffer to paste' }
    );

    @outargs = (
 { name => 'image', type => 'image',
   desc => 'The new image' }
    );

    %invoke = (
 code => <<CODE
{
  GimpBuffer *buffer = gimp_pdb_get_buffer (gimp, buffer_name, error);

  if (buffer)
    {
      image = gimp_edit_paste_as_new_image (gimp, GIMP_OBJECT (buffer), context);

      if (! image)
        success = FALSE;
    }
  else
    success = FALSE;
}
CODE
    );
}


@headers = qw("libgimpconfig/gimpconfig.h"
              "core/gimp.h"
              "core/gimp-edit.h"
              "core/gimpdrawable-edit.h"
              "core/gimpbuffer.h"
              "core/gimpimage.h"
              "core/gimpprogress.h"
              "gimppdb-utils.h"
              "gimppdbcontext.h"
              "gimp-intl.h");

@procs = qw(edit_cut
            edit_copy
            edit_copy_visible
            edit_paste
            edit_paste_as_new_image
            edit_named_cut
            edit_named_copy
            edit_named_copy_visible
            edit_named_paste
            edit_named_paste_as_new_image);

%exports = (app => [@procs], lib => [@procs]);

$desc = 'Edit procedures';
$doc_title = 'gimpedit';
$doc_short_desc = 'Edit menu functions (cut, copy, paste, clear, etc.)';
$doc_long_desc = 'Edit menu functions (cut, copy, paste, clear, etc.)';

1;