layer.pdb 32.2 KB
Newer Older
1
# GIMP - The GNU Image Manipulation Program
2 3
# Copyright (C) 1995 Spencer Kimball and Peter Mattis

4
# This program is free software: you can redistribute it and/or modify
5
# it under the terms of the GNU General Public License as published by
6
# the Free Software Foundation; either version 3 of the License, or
7 8 9 10 11 12 13 14
# (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
15
# along with this program.  If not, see <https://www.gnu.org/licenses/>.
16 17 18 19 20 21 22

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

sub layer_new {
    $blurb = 'Create a new layer.';

    $help = <<'HELP';
23 24 25 26 27 28
This procedure creates a new layer with the specified width, height,
and type.  Name, opacity, and mode are also supplied parameters. The
new layer still needs to be added to the image, as this is not
automatic. Add the new layer with the gimp_image_insert_layer()
command. Other attributes such as layer mask modes, and offsets should
be set with explicit procedure calls.
29 30 31 32 33
HELP

    &std_pdb_misc;

    @inargs = (
34 35
	{ name => 'image', type => 'image',
	  desc => 'The image to which to add the layer' },
36
	{ name => 'width', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
37
	  desc => 'The layer width' },
38
	{ name => 'height', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
39
	  desc => 'The layer height' },
40
	{ name => 'type', type => 'enum GimpImageType',
41
	  desc => 'The layer type' },
42
	{ name => 'name', type => 'string',
43
	  desc => 'The layer name', null_ok => 1 },
44
	{ name => 'opacity', type => '0 <= float <= 100',
45
	  desc => 'The layer opacity' },
46
	{ name => 'mode', type => 'enum GimpLayerMode',
47
          default => 'GIMP_LAYER_MODE_NORMAL',
48
	  desc => 'The layer combination mode' }
49 50 51
    );

    @outargs = (
52
	{ name => 'layer', type => 'layer', wrap => 1,
53
	  desc => 'The newly created layer' }
54 55 56 57 58
    );

    %invoke = (
	code => <<'CODE'
{
59 60 61 62
  GimpImageBaseType  base_type = GIMP_RGB;
  gboolean           has_alpha = FALSE;
  const Babl        *format;

63 64
  if (mode == GIMP_LAYER_MODE_OVERLAY_LEGACY)
    mode = GIMP_LAYER_MODE_SOFTLIGHT_LEGACY;
65

66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
  switch (type)
    {
    case GIMP_RGB_IMAGE:
      base_type = GIMP_RGB;
      has_alpha = FALSE;
      break;

    case GIMP_RGBA_IMAGE:
      base_type = GIMP_RGB;
      has_alpha = TRUE;
      break;

    case GIMP_GRAY_IMAGE:
      base_type = GIMP_GRAY;
      has_alpha = FALSE;
      break;

    case GIMP_GRAYA_IMAGE:
      base_type = GIMP_GRAY;
      has_alpha = TRUE;
      break;

    case GIMP_INDEXED_IMAGE:
      base_type = GIMP_INDEXED;
      has_alpha = FALSE;
      break;

    case GIMP_INDEXEDA_IMAGE:
      base_type = GIMP_INDEXED;
      has_alpha = TRUE;
      break;
    }

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
  if (base_type == GIMP_GRAY)
    {
      /* do not use gimp_image_get_layer_format() because it might
       * be the floating selection of a channel or mask, we will
       * fix the format in image-add-layer and floating-sel-attach
       */
      format = gimp_image_get_format (image, base_type,
                                      gimp_image_get_precision (image),
                                      has_alpha,
                                      NULL /* will fix later */);
    }
  else
    {
      format = gimp_image_get_layer_format (image, has_alpha);
    }
114

115
  layer = gimp_layer_new (image, width, height,
116
                          format, name, opacity / 100.0, mode);
117 118 119

  if (! layer)
    success = FALSE;
120 121 122 123 124
}
CODE
    );
}

125 126 127 128
sub layer_new_from_visible {
    $blurb = 'Create a new layer from what is visible in an image.';

    $help = <<'HELP';
129 130 131 132 133
This procedure creates a new layer from what is visible in the given
image.  The new layer still needs to be added to the destination
image, as this is not automatic. Add the new layer with the
gimp_image_insert_layer() command.  Other attributes such as layer
mask modes, and offsets should be set with explicit procedure calls.
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
HELP

    &neo_pdb_misc('2008', '2.6');

    @inargs = (
	{ name => 'image', type => 'image',
	  desc => 'The source image from where the content is copied' },
	{ name => 'dest_image', type => 'image',
	  desc => 'The destination image to which to add the layer' },
	{ name => 'name', type => 'string',
	  desc => 'The layer name', null_ok => 1 }
     );

    @outargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The newly created layer' }
    );

    %invoke = (
	code => <<'CODE'
{
155 156
  GimpPickable     *pickable = GIMP_PICKABLE (image);
  GimpColorProfile *profile;
157

158 159
  gimp_pickable_flush (pickable);

160
  profile = gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (image));
161

162 163 164 165 166 167
  layer = gimp_layer_new_from_gegl_buffer (gimp_pickable_get_buffer (pickable),
                                           dest_image,
                                           gimp_image_get_layer_format (dest_image,
                                                                        TRUE),
                                           name,
                                           GIMP_OPACITY_OPAQUE,
168
                                           gimp_image_get_default_new_layer_mode (dest_image),
169
                                           profile);
170 171 172 173 174 175 176 177 178
}
CODE
    );
}

sub layer_new_from_drawable {
    $blurb = 'Create a new layer by copying an existing drawable.';

    $help = <<'HELP';
179 180 181 182 183
This procedure creates a new layer as a copy of the specified
drawable.  The new layer still needs to be added to the image, as this
is not automatic.  Add the new layer with the
gimp_image_insert_layer() command. Other attributes such as layer mask
modes, and offsets should be set with explicit procedure calls.
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
HELP

    &std_pdb_misc;

    @inargs = (
	{ name => 'drawable', type => 'drawable',
	  desc => 'The source drawable from where the new layer is copied' },
	{ name => 'dest_image', type => 'image',
	  desc => 'The destination image to which to add the layer' }
     );

    @outargs = (
	{ name => 'layer_copy', type => 'layer',
	  desc => 'The newly copied layer' }
    );

    %invoke = (
	code => <<'CODE'
{
  GType     new_type;
  GimpItem *new_item;

  if (GIMP_IS_LAYER (drawable))
    new_type = G_TYPE_FROM_INSTANCE (drawable);
  else
    new_type = GIMP_TYPE_LAYER;

211
  new_item = gimp_item_convert (GIMP_ITEM (drawable), dest_image, new_type);
212 213 214 215 216 217 218 219 220 221

  if (new_item)
    layer_copy = GIMP_LAYER (new_item);
  else
    success = FALSE;
}
CODE
    );
}

222 223 224 225 226 227 228 229
sub layer_group_new {
    $blurb = 'Create a new layer group.';

    $help = <<'HELP';
This procedure creates a new layer group. Attributes such as layer mode
and opacity should be set with explicit procedure calls. Add the new
layer group (which is a kind of layer) with the
gimp_image_insert_layer() command.
230 231 232

Other procedures useful with layer groups: gimp_image_reorder_item(),
gimp_item_get_parent(), gimp_item_get_children(), gimp_item_is_group().
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
HELP

    &barak_pdb_misc('2010', '2.8');

    @inargs = (
	{ name => 'image', type => 'image',
	  desc => 'The image to which to add the layer group' }
    );

    @outargs = (
	{ name => 'layer_group', type => 'layer',
	  desc => 'The newly created layer group' }
    );
    %invoke = (
	code => <<'CODE'
{
  layer_group = gimp_group_layer_new (image);

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

258 259 260 261 262 263 264 265 266 267 268 269 270 271
sub layer_copy {
    $blurb = 'Copy a layer.';

    $help = <<'HELP';
This procedure copies the specified layer and returns the copy. The newly
copied layer is for use within the original layer's image. It should not be
subsequently added to any other image. The copied layer can optionally have an
added alpha channel. This is useful if the background layer in an image is
being copied and added to the same image.
HELP

    &std_pdb_misc;

    @inargs = (
272 273
	{ name => 'layer', type => 'layer',
	  desc => 'The layer to copy' },
274 275 276 277 278
	{ name => 'add_alpha', type => 'boolean',
	  desc => 'Add an alpha channel to the copied layer' }
    );

    @outargs = (
279
	{ name => 'layer_copy', type => 'layer', wrap => 1,
280
	  desc => 'The newly copied layer' }
281 282 283
    );

    %invoke = (
284 285 286
	code => <<'CODE'
{
  layer_copy = GIMP_LAYER (gimp_item_duplicate (GIMP_ITEM (layer),
287 288 289 290 291 292 293 294 295 296
                                                G_TYPE_FROM_INSTANCE (layer)));
  if (layer_copy)
    {
      if (add_alpha)
        gimp_layer_add_alpha (layer_copy);
    }
  else
    {
      success = FALSE;
    }
297 298
}
CODE
299 300 301 302
    );
}

sub layer_create_mask {
303
    $blurb = 'Create a layer mask for the specified layer.';
304 305

    $help = <<'HELP';
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
This procedure creates a layer mask for the specified layer.

Layer masks serve as an additional alpha channel for a layer. Different
types of masks are allowed for initialisation:

- white mask (leaves the layer fully visible);

- black mask (gives the layer complete transparency);

- the layer's alpha channel (either a copy, or a transfer, which leaves
the layer fully visible, but which may be more useful than a white mask);

- the current selection;

- a grayscale copy of the layer;

- or a copy of the active channel.


The layer mask still needs to be added to the layer. This can be done
with a call to gimp_layer_add_mask().


gimp_layer_create_mask() will fail if there are no active channels on
the image, when called with 'ADD-CHANNEL-MASK'. It will return a black
mask when called with 'ADD-ALPHA-MASK' or 'ADD-ALPHA-TRANSFER-MASK' on
a layer with no alpha channels, or with 'ADD-SELECTION-MASK' when there
is no selection on the image.
334 335
HELP

336
    &std_pdb_misc();
337 338

    @inargs = (
339 340
	{ name => 'layer', type => 'layer',
	  desc => 'The layer to which to add the mask' },
341
 	{ name => 'mask_type', type => 'enum GimpAddMaskType',
342
	  desc => 'The type of mask' }
343 344 345
    );

    @outargs = (
346
	{ name => 'mask', type => 'layer_mask',
347
	  desc => 'The newly created mask' }
348 349 350 351
    );

    %invoke = (
	code => <<'CODE'
352
{
353
  GimpChannel *channel = NULL;
354

355
  if (mask_type == GIMP_ADD_MASK_CHANNEL)
356
    {
357
      channel = gimp_image_get_active_channel (gimp_item_get_image (GIMP_ITEM (layer)));
358 359 360 361 362 363 364 365 366 367 368 369

      if (! channel)
        success = FALSE;
    }

  if (success)
    {
      mask = gimp_layer_create_mask (layer, mask_type, channel);

      if (! mask)
        success = FALSE;
    }
370
}
371 372 373 374
CODE
    );
}

375 376 377 378 379 380 381
sub layer_add_mask {
    $blurb = 'Add a layer mask to the specified layer.';

    $help = <<'HELP';
This procedure adds a layer mask to the specified layer. Layer masks serve as
an additional alpha channel for a layer. This procedure will fail if a number
of prerequisites aren't met. The layer cannot already have a layer mask. The
382
specified mask must exist and have the same dimensions as the layer. The layer must have been created for use with the specified image and the mask must have been created with the procedure 'gimp-layer-create-mask'.
383 384 385 386 387
HELP

    &std_pdb_misc;

    @inargs = (
388 389
	{ name => 'layer', type => 'layer',
	  desc => 'The layer to receive the mask' },
390 391 392 393 394 395 396
	{ name => 'mask', type => 'layer_mask',
	  desc => 'The mask to add to the layer' }
    );

    %invoke = (
	code => <<'CODE'
{
397 398
  if (gimp_pdb_item_is_floating (GIMP_ITEM (mask),
                                 gimp_item_get_image (GIMP_ITEM (layer)),
399
                                 error))
400
    success = (gimp_layer_add_mask (layer, mask, TRUE, error) == mask);
401 402
  else
    success = FALSE;
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
}
CODE
    );
}

sub layer_remove_mask {
    $blurb = 'Remove the specified layer mask from the layer.';

    $help = <<'HELP';
This procedure removes the specified layer mask from the layer. If the mask
doesn't exist, an error is returned.
HELP

    &std_pdb_misc;

    @inargs = (
419 420
	{ name => 'layer', type => 'layer',
	  desc => 'The layer from which to remove mask' },
421
	{ name => 'mode', type => 'enum GimpMaskApplyMode',
422
	  desc => 'Removal mode' }
423 424
    );

425 426
    %invoke = (
	code => <<'CODE'
427
{
428 429 430 431 432 433
  GimpPDBItemModify modify = 0;

  if (mode == GIMP_MASK_APPLY)
    modify |= GIMP_PDB_ITEM_CONTENT;

  if (gimp_pdb_item_is_attached (GIMP_ITEM (layer), NULL, modify, error) &&
434
      gimp_layer_get_mask (layer) &&
435 436
      (mode == GIMP_MASK_DISCARD ||
       gimp_pdb_item_is_not_group (GIMP_ITEM (layer), error)))
437
    gimp_layer_apply_mask (layer, mode, TRUE);
438 439
  else
    success = FALSE;
440 441 442
}
CODE
    );
443 444
}

445
sub layer_scale {
446
    $blurb = 'Scale the layer using the default interpolation method.';
447

448 449
    $help = <<'HELP';
This procedure scales the layer so that its new width and height are
450
equal to the supplied parameters. The 'local-origin' parameter
451 452
specifies whether to scale from the center of the layer, or from the
image origin. This operation only works if the layer has been added to
453 454
an image. The interpolation method used can be set with
gimp_context_set_interpolation().
455
HELP
456 457 458 459 460 461

    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' },
462
	{ name => 'new_width', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
463
	  desc => 'New layer width' },
464
	{ name => 'new_height', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
465
	  desc => 'New layer height' },
466 467 468 469 470 471 472
	{ name => 'local_origin', type => 'boolean',
	  desc => 'Use a local origin (as opposed to the image origin)' }
    );

    %invoke = (
	code => <<'CODE'
{
473
  if (gimp_pdb_item_is_attached (GIMP_ITEM (layer), NULL,
474 475
                                 GIMP_PDB_ITEM_CONTENT | GIMP_PDB_ITEM_POSITION,
                                 error))
476
    {
477 478
      GimpPDBContext *pdb_context = GIMP_PDB_CONTEXT (context);

479
      if (progress)
480
        gimp_progress_start (progress, FALSE, _("Scaling"));
481 482

      gimp_item_scale_by_origin (GIMP_ITEM (layer), new_width, new_height,
483
                                 pdb_context->interpolation, progress,
484 485 486 487 488
                                 local_origin);

      if (progress)
        gimp_progress_end (progress);
    }
489
  else
490 491 492 493 494 495 496 497
    {
      success = FALSE;
    }
}
CODE
    );
}

498
sub layer_resize {
499
    $blurb = 'Resize the layer to the specified extents.';
500

501 502 503 504 505
    $help = <<'HELP';
This procedure resizes the layer so that its new width and height are
equal to the supplied parameters. Offsets are also provided which
describe the position of the previous layer's content. This operation
only works if the layer has been added to an image.
506
HELP
507 508 509 510 511 512

    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' },
513
	{ name => 'new_width', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
514
	  desc => 'New layer width' },
515
	{ name => 'new_height', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
516
	  desc => 'New layer height' },
517 518 519 520 521 522 523 524 525 526 527
	{ name => 'offx', type => 'int32',
	  desc => 'x offset between upper left corner of old and
		   new layers: (old - new)' },
	{ name => 'offy', type => 'int32',
	  desc => 'y offset between upper left corner of old and
		   new layers: (old - new)' }
    );

    %invoke = (
	code => <<'CODE'
{
528
  if (gimp_pdb_item_is_attached (GIMP_ITEM (layer), NULL,
529 530
                                 GIMP_PDB_ITEM_CONTENT | GIMP_PDB_ITEM_POSITION,
                                 error))
531
    gimp_item_resize (GIMP_ITEM (layer), context, GIMP_FILL_TRANSPARENT,
532
                      new_width, new_height, offx, offy);
533 534
  else
    success = FALSE;
535 536 537
}
CODE
    );
538 539
}

540 541 542 543 544 545 546 547
sub layer_resize_to_image_size {
    $blurb = 'Resize a layer to the image size.';

    $help = <<'HELP';
This procedure resizes the layer so that it's new width and height are equal to
the width and height of its image container.
HELP

548
    &yosh_pdb_misc('2003');
549

550 551 552 553
    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer to resize' }
    );
554

555 556
    %invoke = (
	code => <<'CODE'
557
{
558
  if (gimp_pdb_item_is_attached (GIMP_ITEM (layer), NULL,
559 560
                                 GIMP_PDB_ITEM_CONTENT | GIMP_PDB_ITEM_POSITION,
                                 error))
561
    gimp_layer_resize_to_image (layer, context, GIMP_FILL_TRANSPARENT);
562 563
  else
    success = FALSE;
564 565
}
CODE
566
    );
567 568
}

569 570 571 572 573 574
sub layer_add_alpha {
    $blurb = <<'BLURB';
Add an alpha channel to the layer if it doesn't already have one.
BLURB

    $help = <<'HELP';
575 576 577 578 579
This procedure adds an additional component to the specified layer if
it does not already possess an alpha channel. An alpha channel makes
it possible to clear and erase to transparency, instead of the
background color. This transforms layers of type RGB to RGBA, GRAY to
GRAYA, and INDEXED to INDEXEDA.
580 581 582 583
HELP

    &std_pdb_misc;

584 585 586 587
    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' }
    );
588

589 590
    %invoke = (
	code => <<'CODE'
591
{
592
  if (gimp_pdb_item_is_modifiable (GIMP_ITEM (layer),
593
                                   GIMP_PDB_ITEM_CONTENT, error) &&
594
      gimp_pdb_item_is_not_group (GIMP_ITEM (layer), error))
595 596 597
    {
      gimp_layer_add_alpha (layer);
    }
598 599
  else
   success = FALSE;
600 601 602
}
CODE
    );
603 604
}

605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
sub layer_flatten {
    $blurb = <<'BLURB';
Remove the alpha channel from the layer if it has one.
BLURB

    $help = <<'HELP';
This procedure removes the alpha channel from a layer, blending all
(partially) transparent pixels in the layer against the background
color. This transforms layers of type RGBA to RGB, GRAYA to
GRAY, and INDEXEDA to INDEXED.
HELP

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

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' }
    );

    %invoke = (
	code => <<'CODE'
{
627
  if (gimp_pdb_item_is_modifiable (GIMP_ITEM (layer),
628
                                   GIMP_PDB_ITEM_CONTENT, error) &&
629
      gimp_pdb_item_is_not_group (GIMP_ITEM (layer), error))
630 631 632
    {
      gimp_layer_remove_alpha (layer, context);
    }
633 634
  else
   success = FALSE;
635 636 637 638 639
}
CODE
    );
}

640 641 642 643 644 645 646 647 648
sub layer_set_offsets {
    $blurb = 'Set the layer offsets.';

    $help = <<'HELP';
This procedure sets the offsets for the specified layer. The offsets are
relative to the image origin and can be any values. This operation is valid
only on layers which have been added to an image.
HELP

649 650 651 652 653 654 655 656 657 658 659 660 661 662
    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' },
	{ name => 'offx', type => 'int32',
	  desc => "Offset in x direction" },
	{ name => 'offy', type => 'int32',
	  desc => "Offset in y direction" }
    );

    %invoke = (
	code => <<'CODE'
{
663
  if (gimp_pdb_item_is_modifiable (GIMP_ITEM (layer),
664 665
                                   GIMP_PDB_ITEM_POSITION, error))
    {
666 667
      gint offset_x;
      gint offset_y;
668

669 670 671
      gimp_item_get_offset (GIMP_ITEM (layer), &offset_x, &offset_y);
      offx -= offset_x;
      offy -= offset_y;
672

673
      if (gimp_item_get_linked (GIMP_ITEM (layer)))
674 675 676 677 678 679 680
        {
          gimp_item_linked_translate (GIMP_ITEM (layer), offx, offy, TRUE);
        }
      else
        {
          gimp_item_translate (GIMP_ITEM (layer), offx, offy, TRUE);
        }
681 682 683
    }
  else
    success = FALSE;
684 685 686
}
CODE
    );
687 688
}

689
sub layer_get_mask {
690 691 692
    $blurb = "Get the specified layer's mask if it exists.";

    $help = <<'HELP';
Manish Singh's avatar
Manish Singh committed
693
This procedure returns the specified layer's mask, or -1 if none exists.
694 695 696 697
HELP

    &std_pdb_misc;

698 699 700 701
    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' }
    );
702 703

    @outargs = (
704
	{ name => 'mask', type => 'layer_mask',
705
	  desc => 'The layer mask',
Manish Singh's avatar
Manish Singh committed
706
	  return_fail => -1 }
707
    );
708 709 710 711 712 713 714 715

    %invoke = (
	code => <<'CODE'
{
  mask = gimp_layer_get_mask (layer);
}
CODE
    );
716 717
}

718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
sub layer_from_mask {
    $blurb = "Get the specified mask's layer.";

    $help = <<'HELP';
This procedure returns the specified mask's layer , or -1 if none exists.
HELP

    $author = $copyright = 'Geert Jordaens';
    $date = '2004';
    $since = '2.2';

    @inargs = (
        { name => 'mask', type => 'layer_mask',
          desc => 'Mask for which to return the layer' }
    );

    @outargs = (
735
        { name => 'layer', type => 'layer',
736 737 738 739 740 741 742 743 744 745 746 747 748
          desc => 'The mask\'s layer',
	  return_fail => -1 }
    );

    %invoke = (
        code => <<'CODE'
{
  layer = gimp_layer_mask_get_layer (mask);
}
CODE
    );
}

749 750 751 752 753 754 755 756 757 758
sub layer_is_floating_sel {
    $blurb = 'Is the specified layer a floating selection?';

    $help = <<'HELP';
This procedure returns whether the layer is a floating selection. Floating
selections are special cases of layers which are attached to a specific
drawable.
HELP

    &std_pdb_misc;
759

760 761 762 763
    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' }
    );
764 765 766

    @outargs = (
	{ name => 'is_floating_sel', type => 'boolean',
767
	  desc => 'TRUE if the layer is a floating selection' }
768 769 770 771 772 773 774 775
    );

    %invoke = (
	code => <<'CODE'
{
  is_floating_sel = gimp_layer_is_floating_sel (layer);
}
CODE
776 777 778
    );
}

779 780
sub layer_get_lock_alpha {
    $blurb = 'Get the lock alpha channel setting of the specified layer.';
781

782 783
    $help = <<'HELP';
This procedure returns the specified layer's lock alpha channel setting.
784
HELP
785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811

    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' }
    );

    @outargs = (
	{ name => 'lock_alpha', type => 'boolean',
	  desc => 'The layer\'s lock alpha channel setting' }
    );

    %invoke = (
	code => <<'CODE'
{
  lock_alpha = gimp_layer_get_lock_alpha (layer);
}
CODE
    );
}

sub layer_set_lock_alpha {
    $blurb = 'Set the lock alpha channel setting of the specified layer.';

    $help = <<'HELP';
This procedure sets the specified layer's lock alpha channel setting.
812 813
HELP

814 815 816 817 818 819 820 821 822 823 824 825
    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' },
	{ name => 'lock_alpha', type => 'boolean',
	  desc => 'The new layer\'s lock alpha channel setting' }
    );

    %invoke = (
	code => <<'CODE'
{
826 827 828 829
  if (gimp_layer_can_lock_alpha (layer))
    gimp_layer_set_lock_alpha (layer, lock_alpha, TRUE);
  else
    success = FALSE;
830 831 832 833 834 835 836 837 838 839
}
CODE
    );
}

sub layer_get_apply_mask {
    $blurb = 'Get the apply mask setting of the specified layer.';

    $help = <<'HELP';
This procedure returns the specified layer's apply mask setting. If
840
the value is TRUE, then the layer mask for this layer is currently
841
being composited with the layer's alpha channel.
842
HELP
843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859

    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' }
    );

    @outargs = (
	{ name => 'apply_mask', type => 'boolean',
	  desc => 'The layer\'s apply mask setting' }
    );

    %invoke = (
	code => <<'CODE'
{
  if (layer->mask)
860
    apply_mask = gimp_layer_get_apply_mask (layer);
861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
  else
    apply_mask = FALSE;
}
CODE
    );
}

sub layer_set_apply_mask {
    $blurb = 'Set the apply mask setting of the specified layer.';

    $help = <<'HELP';
This procedure sets the specified layer's apply mask setting. This
controls whether the layer's mask is currently affecting the alpha
channel. If there is no layer mask, this function will return an
error.
876 877
HELP

878 879 880 881 882 883 884 885 886 887 888 889 890
    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' },
	{ name => 'apply_mask', type => 'boolean',
	  desc => 'The new layer\'s apply mask setting' }
    );

    %invoke = (
	code => <<'CODE'
{
  if (layer->mask)
891
    gimp_layer_set_apply_mask (layer, apply_mask, TRUE);
892 893 894 895 896 897 898 899 900 901 902 903
  else
    success = FALSE;
}
CODE
    );
}

sub layer_get_show_mask {
    $blurb = 'Get the show mask setting of the specified layer.';

    $help = <<'HELP';
This procedure returns the specified layer's show mask setting. This
904 905
controls whether the layer or its mask is visible. TRUE indicates
that the mask should be visible. If the layer has no mask,
906
then this function returns an error.
907
HELP
908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924

    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' }
    );

    @outargs = (
	{ name => 'show_mask', type => 'boolean',
	  desc => 'The layer\'s show mask setting' }
    );

    %invoke = (
	code => <<'CODE'
{
  if (layer->mask)
925
    show_mask = gimp_layer_get_show_mask (layer);
926 927 928 929 930 931 932 933 934 935 936 937
  else
    show_mask = FALSE;
}
CODE
    );
}

sub layer_set_show_mask {
    $blurb = 'Set the show mask setting of the specified layer.';

    $help = <<'HELP';
This procedure sets the specified layer's show mask setting. This
938 939 940
controls whether the layer or its mask is visible. TRUE indicates that
the mask should be visible. If there is no layer mask, this function
will return an error.
941
HELP
942

943 944 945 946 947 948 949 950 951 952 953 954 955
    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' },
	{ name => 'show_mask', type => 'boolean',
	  desc => 'The new layer\'s show mask setting' }
    );

    %invoke = (
	code => <<'CODE'
{
  if (layer->mask)
956
    gimp_layer_set_show_mask (layer, show_mask, TRUE);
957 958 959 960 961 962 963 964 965 966 967 968
  else
    success = FALSE;
}
CODE
    );
}

sub layer_get_edit_mask {
    $blurb = 'Get the edit mask setting of the specified layer.';

    $help = <<'HELP';
This procedure returns the specified layer's edit mask setting. If
969
the value is TRUE, then the layer mask for this layer is currently
970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
active, and not the layer.
HELP

    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' }
    );

    @outargs = (
	{ name => 'edit_mask', type => 'boolean',
	  desc => 'The layer\'s edit mask setting' }
    );

    %invoke = (
	code => <<'CODE'
{
  if (layer->mask)
989
    edit_mask = gimp_layer_get_edit_mask (layer);
990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
  else
    edit_mask = FALSE;
}
CODE
    );
}

sub layer_set_edit_mask {
    $blurb = 'Set the edit mask setting of the specified layer.';

    $help = <<'HELP';
This procedure sets the specified layer's edit mask setting. This
controls whether the layer or it's mask is currently active for
editing.  If the specified layer has no layer mask, then this
procedure will return an error.
HELP
1006

1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019
    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' },
	{ name => 'edit_mask', type => 'boolean',
	  desc => 'The new layer\'s edit mask setting' }
    );

    %invoke = (
	code => <<'CODE'
{
  if (layer->mask)
1020
    gimp_layer_set_edit_mask (layer, edit_mask);
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
  else
    success = FALSE;
}
CODE
    );
}

sub layer_get_opacity {
    $blurb = 'Get the opacity of the specified layer.';
    $help  = "This procedure returns the specified layer's opacity.";

    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' }
    );

    @outargs = (
	{ name => 'opacity', type => '0 <= float <= 100',
	  desc => 'The layer opacity' }
    );

    %invoke = (
	code => <<'CODE'
{
  opacity = gimp_layer_get_opacity (layer) * 100.0;
}
CODE
    );
}

sub layer_set_opacity {
    $blurb = 'Set the opacity of the specified layer.';
    $help  = "This procedure sets the specified layer's opacity.";

    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' },
	{ name => 'opacity', type => '0 <= float <= 100',
1063
	  desc => 'The new layer opacity' }
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
    );

    %invoke = (
	code => <<'CODE'
{
  gimp_layer_set_opacity (layer, opacity / 100.0, TRUE);
}
CODE
    );
}

sub layer_get_mode {
    $blurb = 'Get the combination mode of the specified layer.';
    $help  = "This procedure returns the specified layer's combination mode.";

    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' }
    );

    @outargs = (
1087
	{ name => 'mode', type => 'enum GimpLayerMode',
1088
          default => 'GIMP_LAYER_MODE_NORMAL',
1089
	  desc => 'The layer combination mode' }
1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
    );

    %invoke = (
	code => <<'CODE'
{
  mode = gimp_layer_get_mode (layer);
}
CODE
    );
}

sub layer_set_mode {
    $blurb = 'Set the combination mode of the specified layer.';
    $help  = "This procedure sets the specified layer's combination mode.";

    &std_pdb_misc;

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' },
1110
	{ name => 'mode', type => 'enum GimpLayerMode',
1111
          default => 'GIMP_LAYER_MODE_NORMAL',
1112
	  desc => 'The new layer combination mode' }
1113 1114 1115 1116 1117
    );

    %invoke = (
	code => <<'CODE'
{
1118 1119
  if (mode == GIMP_LAYER_MODE_OVERLAY_LEGACY)
    mode = GIMP_LAYER_MODE_SOFTLIGHT_LEGACY;
1120

Ell's avatar
Ell committed
1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
  if (gimp_viewable_get_children (GIMP_VIEWABLE (layer)) == NULL)
    {
      if (! (gimp_layer_mode_get_context (mode) & GIMP_LAYER_MODE_CONTEXT_LAYER))
        success = FALSE;
    }
  else
    {
      if (! (gimp_layer_mode_get_context (mode) & GIMP_LAYER_MODE_CONTEXT_GROUP))
        success = FALSE;
    }

  if (success)
    gimp_layer_set_mode (layer, mode, TRUE);
1134 1135 1136 1137
}
CODE
    );
}
1138

1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
sub layer_get_blend_space {
    $blurb = 'Get the blend space of the specified layer.';
    $help  = "This procedure returns the specified layer's blend space.";

    &ell_pdb_misc('2017', '2.10');

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' }
    );

    @outargs = (
	{ name => 'blend_space', type => 'enum GimpLayerColorSpace',
	  desc => 'The layer blend space' }
    );

    %invoke = (
	code => <<'CODE'
{
  blend_space = gimp_layer_get_blend_space (layer);
}
CODE
    );
}

sub layer_set_blend_space {
    $blurb = 'Set the blend space of the specified layer.';
    $help  = "This procedure sets the specified layer's blend space.";

    &ell_pdb_misc('2017', '2.10');

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' },
	{ name => 'blend_space', type => 'enum GimpLayerColorSpace',
	  desc => 'The new layer blend space' }
    );

    %invoke = (
	code => <<'CODE'
{
  gimp_layer_set_blend_space (layer, blend_space, TRUE);
}
CODE
    );
}

sub layer_get_composite_space {
    $blurb = 'Get the composite space of the specified layer.';
    $help  = "This procedure returns the specified layer's composite space.";

    &ell_pdb_misc('2017', '2.10');

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' }
    );

    @outargs = (
	{ name => 'composite_space', type => 'enum GimpLayerColorSpace',
	  desc => 'The layer composite space' }
    );

    %invoke = (
	code => <<'CODE'
{
  composite_space = gimp_layer_get_composite_space (layer);
}
CODE
    );
}

sub layer_set_composite_space {
    $blurb = 'Set the composite space of the specified layer.';
    $help  = "This procedure sets the specified layer's composite space.";

    &ell_pdb_misc('2017', '2.10');

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' },
	{ name => 'composite_space', type => 'enum GimpLayerColorSpace',
	  desc => 'The new layer composite space' }
    );

    %invoke = (
	code => <<'CODE'
{
  gimp_layer_set_composite_space (layer, composite_space, TRUE);
}
CODE
    );
}

1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
sub layer_get_composite_mode {
    $blurb = 'Get the composite mode of the specified layer.';
    $help  = "This procedure returns the specified layer's composite mode.";

    &ell_pdb_misc('2017', '2.10');

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' }
    );

    @outargs = (
	{ name => 'composite_mode', type => 'enum GimpLayerCompositeMode',
	  desc => 'The layer composite mode' }
    );

    %invoke = (
	code => <<'CODE'
{
1252
  composite_mode = gimp_layer_get_composite_mode (layer);
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273
}
CODE
    );
}

sub layer_set_composite_mode {
    $blurb = 'Set the composite mode of the specified layer.';
    $help  = "This procedure sets the specified layer's composite mode.";

    &ell_pdb_misc('2017', '2.10');

    @inargs = (
	{ name => 'layer', type => 'layer',
	  desc => 'The layer' },
	{ name => 'composite_mode', type => 'enum GimpLayerCompositeMode',
	  desc => 'The new layer composite mode' }
    );

    %invoke = (
	code => <<'CODE'
{
1274
  gimp_layer_set_composite_mode (layer, composite_mode, TRUE);
1275 1276 1277 1278 1279
}
CODE
    );
}

1280 1281 1282
@headers = qw(<cairo.h>
              "libgimpbase/gimpbase.h"
              "libgimpcolor/gimpcolor.h"
1283
              "core/gimp.h"
1284
              "core/gimpimage-color-profile.h"
1285 1286
              "core/gimpimage-undo.h"
              "core/gimpitem-linked.h"
1287
              "core/gimpgrouplayer.h"
1288
              "core/gimplayer-new.h"
1289
              "core/gimppickable.h"
1290
              "core/gimpprogress.h"
Ell's avatar
Ell committed
1291
              "operations/layer-modes/gimp-layer-modes.h"
1292
              "gimppdbcontext.h"
1293
              "gimppdb-utils.h"
1294
              "gimp-intl.h");
1295

1296
@procs = qw(layer_new
1297
            layer_new_from_visible
1298
            layer_new_from_drawable
1299
            layer_group_new
1300 1301 1302
            layer_copy
            layer_add_alpha
            layer_flatten
1303
            layer_scale
1304 1305 1306 1307 1308
            layer_resize layer_resize_to_image_size
            layer_set_offsets
            layer_create_mask
            layer_get_mask
            layer_from_mask
1309 1310 1311 1312 1313 1314 1315
            layer_add_mask layer_remove_mask
	    layer_is_floating_sel
            layer_get_lock_alpha layer_set_lock_alpha
            layer_get_apply_mask layer_set_apply_mask
            layer_get_show_mask layer_set_show_mask
            layer_get_edit_mask layer_set_edit_mask
            layer_get_opacity layer_set_opacity
1316
            layer_get_mode layer_set_mode
1317 1318
            layer_get_blend_space layer_set_blend_space
            layer_get_composite_space layer_set_composite_space
1319
            layer_get_composite_mode layer_set_composite_mode);
1320

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

$desc = 'Layer';
1324 1325 1326
$doc_title = 'gimplayer';
$doc_short_desc = 'Operations on a single layer.';
$doc_long_desc = 'Operations on a single layer.';
1327 1328

1;