gimplayer_pdb.c 36.1 KB
Newer Older
1
/* LIBGIMP - The GIMP Library
2
 * Copyright (C) 1995-2003 Peter Mattis and Spencer Kimball
3 4
 *
 * gimplayer_pdb.c
Manish Singh's avatar
Manish Singh committed
5
 *
6
 * This library is free software: you can redistribute it and/or
Marc Lehmann's avatar
Marc Lehmann committed
7
 * modify it under the terms of the GNU Lesser General Public
Manish Singh's avatar
Manish Singh committed
8
 * License as published by the Free Software Foundation; either
9
 * version 3 of the License, or (at your option) any later version.
10 11 12 13
 *
 * This library 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
14
 * Lesser General Public License for more details.
Manish Singh's avatar
Manish Singh committed
15
 *
Marc Lehmann's avatar
Marc Lehmann committed
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library.  If not, see
18
 * <https://www.gnu.org/licenses/>.
19 20
 */

21
/* NOTE: This file is auto-generated by pdbgen.pl */
Elliot Lee's avatar
Elliot Lee committed
22

Sven Neumann's avatar
Sven Neumann committed
23 24
#include "config.h"

25
#include "gimp.h"
Elliot Lee's avatar
Elliot Lee committed
26

27 28 29 30 31 32 33 34 35 36

/**
 * SECTION: gimplayer
 * @title: gimplayer
 * @short_description: Operations on a single layer.
 *
 * Operations on a single layer.
 **/


37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
/**
 * _gimp_layer_new:
 * @image_ID: The image to which to add the layer.
 * @width: The layer width.
 * @height: The layer height.
 * @type: The layer type.
 * @name: The layer name.
 * @opacity: The layer opacity.
 * @mode: The layer combination mode.
 *
 * Create a new layer.
 *
 * 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
52
 * automatic. Add the new layer with the gimp_image_insert_layer()
53 54 55 56
 * command. Other attributes such as layer mask modes, and offsets
 * should be set with explicit procedure calls.
 *
 * Returns: The newly created layer.
57
 **/
Elliot Lee's avatar
Elliot Lee committed
58
gint32
59 60 61 62 63 64 65
_gimp_layer_new (gint32         image_ID,
                 gint           width,
                 gint           height,
                 GimpImageType  type,
                 const gchar   *name,
                 gdouble        opacity,
                 GimpLayerMode  mode)
Elliot Lee's avatar
Elliot Lee committed
66
{
67
  GimpParam *return_vals;
68
  gint nreturn_vals;
69
  gint32 layer_ID = -1;
Elliot Lee's avatar
Elliot Lee committed
70

71
  return_vals = gimp_run_procedure ("gimp-layer-new",
72 73 74 75 76 77 78 79 80
                                    &nreturn_vals,
                                    GIMP_PDB_IMAGE, image_ID,
                                    GIMP_PDB_INT32, width,
                                    GIMP_PDB_INT32, height,
                                    GIMP_PDB_INT32, type,
                                    GIMP_PDB_STRING, name,
                                    GIMP_PDB_FLOAT, opacity,
                                    GIMP_PDB_INT32, mode,
                                    GIMP_PDB_END);
81 82

  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
Elliot Lee's avatar
Elliot Lee committed
83 84 85 86 87 88 89
    layer_ID = return_vals[1].data.d_layer;

  gimp_destroy_params (return_vals, nreturn_vals);

  return layer_ID;
}

90 91 92 93 94 95 96 97 98 99 100
/**
 * gimp_layer_new_from_visible:
 * @image_ID: The source image from where the content is copied.
 * @dest_image_ID: The destination image to which to add the layer.
 * @name: The layer name.
 *
 * Create a new layer from what is visible in an image.
 *
 * 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
101 102
 * gimp_image_insert_layer() command. Other attributes such as layer
 * mask modes, and offsets should be set with explicit procedure calls.
103 104 105
 *
 * Returns: The newly created layer.
 *
106
 * Since: 2.6
107
 **/
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
gint32
gimp_layer_new_from_visible (gint32       image_ID,
                             gint32       dest_image_ID,
                             const gchar *name)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gint32 layer_ID = -1;

  return_vals = gimp_run_procedure ("gimp-layer-new-from-visible",
                                    &nreturn_vals,
                                    GIMP_PDB_IMAGE, image_ID,
                                    GIMP_PDB_IMAGE, dest_image_ID,
                                    GIMP_PDB_STRING, name,
                                    GIMP_PDB_END);

  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
    layer_ID = return_vals[1].data.d_layer;

  gimp_destroy_params (return_vals, nreturn_vals);

  return layer_ID;
}

132 133 134 135 136 137 138 139 140 141
/**
 * gimp_layer_new_from_drawable:
 * @drawable_ID: The source drawable from where the new layer is copied.
 * @dest_image_ID: The destination image to which to add the layer.
 *
 * Create a new layer by copying an existing drawable.
 *
 * 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
142 143
 * gimp_image_insert_layer() command. Other attributes such as layer
 * mask modes, and offsets should be set with explicit procedure calls.
144 145
 *
 * Returns: The newly copied layer.
146
 **/
147 148
gint32
gimp_layer_new_from_drawable (gint32 drawable_ID,
149
                              gint32 dest_image_ID)
150 151 152 153 154
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gint32 layer_copy_ID = -1;

155
  return_vals = gimp_run_procedure ("gimp-layer-new-from-drawable",
156 157 158 159
                                    &nreturn_vals,
                                    GIMP_PDB_DRAWABLE, drawable_ID,
                                    GIMP_PDB_IMAGE, dest_image_ID,
                                    GIMP_PDB_END);
160 161 162 163 164 165 166 167 168

  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
    layer_copy_ID = return_vals[1].data.d_layer;

  gimp_destroy_params (return_vals, nreturn_vals);

  return layer_copy_ID;
}

169 170 171 172 173 174 175 176 177 178
/**
 * gimp_layer_group_new:
 * @image_ID: The image to which to add the layer group.
 *
 * Create a new layer group.
 *
 * 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.
179 180 181
 * Other procedures useful with layer groups:
 * gimp_image_reorder_item(), gimp_item_get_parent(),
 * gimp_item_get_children(), gimp_item_is_group().
182
 *
183 184
 * Returns: The newly created layer group.
 *
185
 * Since: 2.8
186
 **/
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
gint32
gimp_layer_group_new (gint32 image_ID)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gint32 layer_group_ID = -1;

  return_vals = gimp_run_procedure ("gimp-layer-group-new",
                                    &nreturn_vals,
                                    GIMP_PDB_IMAGE, image_ID,
                                    GIMP_PDB_END);

  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
    layer_group_ID = return_vals[1].data.d_layer;

  gimp_destroy_params (return_vals, nreturn_vals);

  return layer_group_ID;
}

207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
/**
 * _gimp_layer_copy:
 * @layer_ID: The layer to copy.
 * @add_alpha: Add an alpha channel to the copied layer.
 *
 * Copy a layer.
 *
 * 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.
 *
 * Returns: The newly copied layer.
222
 **/
Elliot Lee's avatar
Elliot Lee committed
223
gint32
224
_gimp_layer_copy (gint32   layer_ID,
225
                  gboolean add_alpha)
Elliot Lee's avatar
Elliot Lee committed
226
{
227
  GimpParam *return_vals;
228
  gint nreturn_vals;
229
  gint32 layer_copy_ID = -1;
Elliot Lee's avatar
Elliot Lee committed
230

231
  return_vals = gimp_run_procedure ("gimp-layer-copy",
232 233 234 235
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, add_alpha,
                                    GIMP_PDB_END);
Elliot Lee's avatar
Elliot Lee committed
236

237
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
238
    layer_copy_ID = return_vals[1].data.d_layer;
Elliot Lee's avatar
Elliot Lee committed
239 240 241

  gimp_destroy_params (return_vals, nreturn_vals);

242
  return layer_copy_ID;
Elliot Lee's avatar
Elliot Lee committed
243 244
}

245
/**
246 247
 * gimp_layer_add_alpha:
 * @layer_ID: The layer.
248
 *
249
 * Add an alpha channel to the layer if it doesn't already have one.
250
 *
251 252
 * This procedure adds an additional component to the specified layer
 * if it does not already possess an alpha channel. An alpha channel
253 254 255
 * 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.
256
 *
257
 * Returns: TRUE on success.
258
 **/
259 260
gboolean
gimp_layer_add_alpha (gint32 layer_ID)
Elliot Lee's avatar
Elliot Lee committed
261
{
262
  GimpParam *return_vals;
263
  gint nreturn_vals;
264
  gboolean success = TRUE;
Elliot Lee's avatar
Elliot Lee committed
265

266
  return_vals = gimp_run_procedure ("gimp-layer-add-alpha",
267 268 269
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);
Elliot Lee's avatar
Elliot Lee committed
270

271
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
272

Elliot Lee's avatar
Elliot Lee committed
273
  gimp_destroy_params (return_vals, nreturn_vals);
274

275
  return success;
Elliot Lee's avatar
Elliot Lee committed
276 277
}

278 279 280 281 282 283 284 285 286 287 288 289 290
/**
 * gimp_layer_flatten:
 * @layer_ID: The layer.
 *
 * Remove the alpha channel from the layer if it has one.
 *
 * 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.
 *
 * Returns: TRUE on success.
 *
291
 * Since: 2.4
292
 **/
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
gboolean
gimp_layer_flatten (gint32 layer_ID)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean success = TRUE;

  return_vals = gimp_run_procedure ("gimp-layer-flatten",
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);

  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

  gimp_destroy_params (return_vals, nreturn_vals);

  return success;
}

312 313 314 315 316 317 318
/**
 * gimp_layer_scale:
 * @layer_ID: The layer.
 * @new_width: New layer width.
 * @new_height: New layer height.
 * @local_origin: Use a local origin (as opposed to the image origin).
 *
319
 * Scale the layer using the default interpolation method.
320
 *
321
 * This procedure scales the layer so that its new width and height are
322
 * equal to the supplied parameters. The 'local-origin' parameter
323 324
 * 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
325 326
 * to an image. The interpolation method used can be set with
 * gimp_context_set_interpolation().
327 328
 *
 * Returns: TRUE on success.
329
 **/
330
gboolean
331
gimp_layer_scale (gint32   layer_ID,
332 333 334
                  gint     new_width,
                  gint     new_height,
                  gboolean local_origin)
Elliot Lee's avatar
Elliot Lee committed
335
{
336
  GimpParam *return_vals;
337
  gint nreturn_vals;
338
  gboolean success = TRUE;
Elliot Lee's avatar
Elliot Lee committed
339

340
  return_vals = gimp_run_procedure ("gimp-layer-scale",
341 342 343 344 345 346
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, new_width,
                                    GIMP_PDB_INT32, new_height,
                                    GIMP_PDB_INT32, local_origin,
                                    GIMP_PDB_END);
Elliot Lee's avatar
Elliot Lee committed
347

348 349
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

Elliot Lee's avatar
Elliot Lee committed
350
  gimp_destroy_params (return_vals, nreturn_vals);
351

352 353 354
  return success;
}

355 356 357 358 359
/**
 * gimp_layer_resize:
 * @layer_ID: The layer.
 * @new_width: New layer width.
 * @new_height: New layer height.
360 361
 * @offx: x offset between upper left corner of old and new layers: (old - new).
 * @offy: y offset between upper left corner of old and new layers: (old - new).
362 363 364
 *
 * Resize the layer to the specified extents.
 *
365
 * This procedure resizes the layer so that its new width and height
366 367 368 369 370
 * 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.
 *
 * Returns: TRUE on success.
371
 **/
372
gboolean
373
gimp_layer_resize (gint32 layer_ID,
374 375 376 377
                   gint   new_width,
                   gint   new_height,
                   gint   offx,
                   gint   offy)
Elliot Lee's avatar
Elliot Lee committed
378
{
379
  GimpParam *return_vals;
380
  gint nreturn_vals;
381
  gboolean success = TRUE;
Elliot Lee's avatar
Elliot Lee committed
382

383
  return_vals = gimp_run_procedure ("gimp-layer-resize",
384 385 386 387 388 389 390
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, new_width,
                                    GIMP_PDB_INT32, new_height,
                                    GIMP_PDB_INT32, offx,
                                    GIMP_PDB_INT32, offy,
                                    GIMP_PDB_END);
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408

  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

  gimp_destroy_params (return_vals, nreturn_vals);

  return success;
}

/**
 * gimp_layer_resize_to_image_size:
 * @layer_ID: The layer to resize.
 *
 * Resize a layer to the image size.
 *
 * This procedure resizes the layer so that it's new width and height
 * are equal to the width and height of its image container.
 *
 * Returns: TRUE on success.
409
 **/
410 411 412 413 414 415 416
gboolean
gimp_layer_resize_to_image_size (gint32 layer_ID)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean success = TRUE;

417
  return_vals = gimp_run_procedure ("gimp-layer-resize-to-image-size",
418 419 420
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);
Elliot Lee's avatar
Elliot Lee committed
421

422 423
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

Elliot Lee's avatar
Elliot Lee committed
424
  gimp_destroy_params (return_vals, nreturn_vals);
425 426

  return success;
Elliot Lee's avatar
Elliot Lee committed
427 428
}

429
/**
430
 * gimp_layer_set_offsets:
431
 * @layer_ID: The layer.
432 433
 * @offx: Offset in x direction.
 * @offy: Offset in y direction.
434
 *
435
 * Set the layer offsets.
436
 *
437 438 439
 * 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.
440 441
 *
 * Returns: TRUE on success.
442
 **/
443
gboolean
444
gimp_layer_set_offsets (gint32 layer_ID,
445 446
                        gint   offx,
                        gint   offy)
Elliot Lee's avatar
Elliot Lee committed
447
{
448
  GimpParam *return_vals;
449
  gint nreturn_vals;
450
  gboolean success = TRUE;
Elliot Lee's avatar
Elliot Lee committed
451

452
  return_vals = gimp_run_procedure ("gimp-layer-set-offsets",
453 454 455 456 457
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, offx,
                                    GIMP_PDB_INT32, offy,
                                    GIMP_PDB_END);
Elliot Lee's avatar
Elliot Lee committed
458

459 460
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

Elliot Lee's avatar
Elliot Lee committed
461
  gimp_destroy_params (return_vals, nreturn_vals);
462 463

  return success;
Elliot Lee's avatar
Elliot Lee committed
464 465
}

466
/**
467 468 469
 * gimp_layer_create_mask:
 * @layer_ID: The layer to which to add the mask.
 * @mask_type: The type of mask.
470
 *
471
 * Create a layer mask for the specified layer.
472
 *
473 474 475 476 477 478 479 480 481 482 483
 * 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.
484
 *
485 486
 * The layer mask still needs to be added to the layer. This can be
 * done with a call to gimp_layer_add_mask().
487
 *
488 489 490 491 492
 * 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.
493
 *
494
 * Returns: The newly created mask.
495
 **/
496 497
gint32
gimp_layer_create_mask (gint32          layer_ID,
498
                        GimpAddMaskType mask_type)
Elliot Lee's avatar
Elliot Lee committed
499
{
500
  GimpParam *return_vals;
501
  gint nreturn_vals;
502
  gint32 mask_ID = -1;
Elliot Lee's avatar
Elliot Lee committed
503

504
  return_vals = gimp_run_procedure ("gimp-layer-create-mask",
505 506 507 508
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, mask_type,
                                    GIMP_PDB_END);
Elliot Lee's avatar
Elliot Lee committed
509

510 511
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
    mask_ID = return_vals[1].data.d_layer_mask;
512

Elliot Lee's avatar
Elliot Lee committed
513
  gimp_destroy_params (return_vals, nreturn_vals);
514

515
  return mask_ID;
Elliot Lee's avatar
Elliot Lee committed
516 517
}

518
/**
519
 * gimp_layer_get_mask:
520 521 522 523 524 525 526 527
 * @layer_ID: The layer.
 *
 * Get the specified layer's mask if it exists.
 *
 * This procedure returns the specified layer's mask, or -1 if none
 * exists.
 *
 * Returns: The layer mask.
528
 **/
Elliot Lee's avatar
Elliot Lee committed
529
gint32
530
gimp_layer_get_mask (gint32 layer_ID)
Elliot Lee's avatar
Elliot Lee committed
531
{
532
  GimpParam *return_vals;
533
  gint nreturn_vals;
534
  gint32 mask_ID = -1;
Elliot Lee's avatar
Elliot Lee committed
535

536
  return_vals = gimp_run_procedure ("gimp-layer-get-mask",
537 538 539
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);
Elliot Lee's avatar
Elliot Lee committed
540

541
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
542
    mask_ID = return_vals[1].data.d_layer_mask;
Elliot Lee's avatar
Elliot Lee committed
543 544 545 546 547 548

  gimp_destroy_params (return_vals, nreturn_vals);

  return mask_ID;
}

549 550 551 552 553 554 555 556 557 558 559
/**
 * gimp_layer_from_mask:
 * @mask_ID: Mask for which to return the layer.
 *
 * Get the specified mask's layer.
 *
 * This procedure returns the specified mask's layer , or -1 if none
 * exists.
 *
 * Returns: The mask's layer.
 *
560
 * Since: 2.2
561
 **/
562 563 564 565 566 567 568
gint32
gimp_layer_from_mask (gint32 mask_ID)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gint32 layer_ID = -1;

569
  return_vals = gimp_run_procedure ("gimp-layer-from-mask",
570 571 572
                                    &nreturn_vals,
                                    GIMP_PDB_CHANNEL, mask_ID,
                                    GIMP_PDB_END);
573 574 575 576 577 578 579 580 581

  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
    layer_ID = return_vals[1].data.d_layer;

  gimp_destroy_params (return_vals, nreturn_vals);

  return layer_ID;
}

582 583
/**
 * gimp_layer_add_mask:
584 585
 * @layer_ID: The layer to receive the mask.
 * @mask_ID: The mask to add to the layer.
586 587 588 589 590 591 592
 *
 * Add a layer mask to the specified layer.
 *
 * 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 specified mask must exist and have
593 594 595
 * 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'.
596 597
 *
 * Returns: TRUE on success.
598
 **/
599 600
gboolean
gimp_layer_add_mask (gint32 layer_ID,
601
                     gint32 mask_ID)
602 603 604 605 606
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean success = TRUE;

607
  return_vals = gimp_run_procedure ("gimp-layer-add-mask",
608 609 610 611
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_CHANNEL, mask_ID,
                                    GIMP_PDB_END);
612 613 614 615 616 617 618 619 620 621

  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

  gimp_destroy_params (return_vals, nreturn_vals);

  return success;
}

/**
 * gimp_layer_remove_mask:
622 623
 * @layer_ID: The layer from which to remove mask.
 * @mode: Removal mode.
624 625 626 627 628 629 630
 *
 * Remove the specified layer mask from the layer.
 *
 * This procedure removes the specified layer mask from the layer. If
 * the mask doesn't exist, an error is returned.
 *
 * Returns: TRUE on success.
631
 **/
632 633
gboolean
gimp_layer_remove_mask (gint32            layer_ID,
634
                        GimpMaskApplyMode mode)
635 636 637 638 639
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean success = TRUE;

640
  return_vals = gimp_run_procedure ("gimp-layer-remove-mask",
641 642 643 644
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, mode,
                                    GIMP_PDB_END);
645 646 647 648 649 650 651 652

  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

  gimp_destroy_params (return_vals, nreturn_vals);

  return success;
}

653 654 655 656 657 658 659 660 661 662
/**
 * gimp_layer_is_floating_sel:
 * @layer_ID: The layer.
 *
 * Is the specified layer a floating selection?
 *
 * This procedure returns whether the layer is a floating selection.
 * Floating selections are special cases of layers which are attached
 * to a specific drawable.
 *
663
 * Returns: TRUE if the layer is a floating selection.
664
 **/
665
gboolean
666
gimp_layer_is_floating_sel (gint32 layer_ID)
Elliot Lee's avatar
Elliot Lee committed
667
{
668
  GimpParam *return_vals;
669
  gint nreturn_vals;
670
  gboolean is_floating_sel = FALSE;
Elliot Lee's avatar
Elliot Lee committed
671

672
  return_vals = gimp_run_procedure ("gimp-layer-is-floating-sel",
673 674 675
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);
Elliot Lee's avatar
Elliot Lee committed
676

677
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
678
    is_floating_sel = return_vals[1].data.d_int32;
Elliot Lee's avatar
Elliot Lee committed
679 680 681

  gimp_destroy_params (return_vals, nreturn_vals);

682
  return is_floating_sel;
Elliot Lee's avatar
Elliot Lee committed
683 684
}

685
/**
686
 * gimp_layer_get_lock_alpha:
687 688
 * @layer_ID: The layer.
 *
689
 * Get the lock alpha channel setting of the specified layer.
690
 *
691
 * This procedure returns the specified layer's lock alpha channel
692 693
 * setting.
 *
694
 * Returns: The layer's lock alpha channel setting.
695
 **/
696
gboolean
697
gimp_layer_get_lock_alpha (gint32 layer_ID)
Elliot Lee's avatar
Elliot Lee committed
698
{
699
  GimpParam *return_vals;
700
  gint nreturn_vals;
701
  gboolean lock_alpha = FALSE;
Elliot Lee's avatar
Elliot Lee committed
702

703
  return_vals = gimp_run_procedure ("gimp-layer-get-lock-alpha",
704 705 706
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);
Elliot Lee's avatar
Elliot Lee committed
707

708
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
709
    lock_alpha = return_vals[1].data.d_int32;
Elliot Lee's avatar
Elliot Lee committed
710 711 712

  gimp_destroy_params (return_vals, nreturn_vals);

713
  return lock_alpha;
Elliot Lee's avatar
Elliot Lee committed
714 715
}

716
/**
717
 * gimp_layer_set_lock_alpha:
718
 * @layer_ID: The layer.
719
 * @lock_alpha: The new layer's lock alpha channel setting.
720
 *
721
 * Set the lock alpha channel setting of the specified layer.
722
 *
723
 * This procedure sets the specified layer's lock alpha channel
724 725 726
 * setting.
 *
 * Returns: TRUE on success.
727
 **/
728
gboolean
729
gimp_layer_set_lock_alpha (gint32   layer_ID,
730
                           gboolean lock_alpha)
Elliot Lee's avatar
Elliot Lee committed
731
{
732
  GimpParam *return_vals;
733
  gint nreturn_vals;
734
  gboolean success = TRUE;
Elliot Lee's avatar
Elliot Lee committed
735

736
  return_vals = gimp_run_procedure ("gimp-layer-set-lock-alpha",
737 738 739 740
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, lock_alpha,
                                    GIMP_PDB_END);
Elliot Lee's avatar
Elliot Lee committed
741

742 743
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

Elliot Lee's avatar
Elliot Lee committed
744
  gimp_destroy_params (return_vals, nreturn_vals);
745 746

  return success;
Elliot Lee's avatar
Elliot Lee committed
747 748
}

749 750 751 752
/**
 * gimp_layer_get_apply_mask:
 * @layer_ID: The layer.
 *
753
 * Get the apply mask setting of the specified layer.
754
 *
755
 * This procedure returns the specified layer's apply mask setting. If
756 757
 * the value is TRUE, then the layer mask for this layer is currently
 * being composited with the layer's alpha channel.
758
 *
759
 * Returns: The layer's apply mask setting.
760
 **/
761 762 763 764 765 766 767
gboolean
gimp_layer_get_apply_mask (gint32 layer_ID)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean apply_mask = FALSE;

768
  return_vals = gimp_run_procedure ("gimp-layer-get-apply-mask",
769 770 771
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);
772 773 774 775 776 777 778 779 780 781 782 783

  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
    apply_mask = return_vals[1].data.d_int32;

  gimp_destroy_params (return_vals, nreturn_vals);

  return apply_mask;
}

/**
 * gimp_layer_set_apply_mask:
 * @layer_ID: The layer.
784
 * @apply_mask: The new layer's apply mask setting.
785
 *
786
 * Set the apply mask setting of the specified layer.
787
 *
788 789 790 791
 * 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.
792 793
 *
 * Returns: TRUE on success.
794
 **/
795 796
gboolean
gimp_layer_set_apply_mask (gint32   layer_ID,
797
                           gboolean apply_mask)
798 799 800 801 802
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean success = TRUE;

803
  return_vals = gimp_run_procedure ("gimp-layer-set-apply-mask",
804 805 806 807
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, apply_mask,
                                    GIMP_PDB_END);
808 809 810 811 812 813 814 815 816 817 818 819

  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

  gimp_destroy_params (return_vals, nreturn_vals);

  return success;
}

/**
 * gimp_layer_get_show_mask:
 * @layer_ID: The layer.
 *
820
 * Get the show mask setting of the specified layer.
821
 *
822
 * This procedure returns the specified layer's show mask setting. This
823 824 825
 * controls whether the layer or its mask is visible. TRUE indicates
 * that the mask should be visible. If the layer has no mask, then this
 * function returns an error.
826
 *
827
 * Returns: The layer's show mask setting.
828
 **/
829 830 831 832 833 834 835
gboolean
gimp_layer_get_show_mask (gint32 layer_ID)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean show_mask = FALSE;

836
  return_vals = gimp_run_procedure ("gimp-layer-get-show-mask",
837 838 839
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);
840 841 842 843 844 845 846 847 848 849 850 851

  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
    show_mask = return_vals[1].data.d_int32;

  gimp_destroy_params (return_vals, nreturn_vals);

  return show_mask;
}

/**
 * gimp_layer_set_show_mask:
 * @layer_ID: The layer.
852
 * @show_mask: The new layer's show mask setting.
853
 *
854
 * Set the show mask setting of the specified layer.
855
 *
856
 * This procedure sets the specified layer's show mask setting. This
857 858 859
 * 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.
860 861
 *
 * Returns: TRUE on success.
862
 **/
863 864
gboolean
gimp_layer_set_show_mask (gint32   layer_ID,
865
                          gboolean show_mask)
866 867 868 869 870
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean success = TRUE;

871
  return_vals = gimp_run_procedure ("gimp-layer-set-show-mask",
872 873 874 875
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, show_mask,
                                    GIMP_PDB_END);
876 877 878 879 880 881 882 883 884 885 886 887

  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

  gimp_destroy_params (return_vals, nreturn_vals);

  return success;
}

/**
 * gimp_layer_get_edit_mask:
 * @layer_ID: The layer.
 *
888
 * Get the edit mask setting of the specified layer.
889
 *
890
 * This procedure returns the specified layer's edit mask setting. If
891 892
 * the value is TRUE, then the layer mask for this layer is currently
 * active, and not the layer.
893
 *
894
 * Returns: The layer's edit mask setting.
895
 **/
896 897 898 899 900 901 902
gboolean
gimp_layer_get_edit_mask (gint32 layer_ID)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean edit_mask = FALSE;

903
  return_vals = gimp_run_procedure ("gimp-layer-get-edit-mask",
904 905 906
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);
907 908 909 910 911 912 913 914 915 916 917 918

  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
    edit_mask = return_vals[1].data.d_int32;

  gimp_destroy_params (return_vals, nreturn_vals);

  return edit_mask;
}

/**
 * gimp_layer_set_edit_mask:
 * @layer_ID: The layer.
919
 * @edit_mask: The new layer's edit mask setting.
920
 *
921
 * Set the edit mask setting of the specified layer.
922
 *
923 924 925 926
 * 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.
927 928
 *
 * Returns: TRUE on success.
929
 **/
930 931
gboolean
gimp_layer_set_edit_mask (gint32   layer_ID,
932
                          gboolean edit_mask)
933 934 935 936 937
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean success = TRUE;

938
  return_vals = gimp_run_procedure ("gimp-layer-set-edit-mask",
939 940 941 942
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, edit_mask,
                                    GIMP_PDB_END);
943 944 945 946 947 948 949 950

  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

  gimp_destroy_params (return_vals, nreturn_vals);

  return success;
}

951 952 953 954 955 956 957 958 959
/**
 * gimp_layer_get_opacity:
 * @layer_ID: The layer.
 *
 * Get the opacity of the specified layer.
 *
 * This procedure returns the specified layer's opacity.
 *
 * Returns: The layer opacity.
960
 **/
961 962 963
gdouble
gimp_layer_get_opacity (gint32 layer_ID)
{
964
  GimpParam *return_vals;
965
  gint nreturn_vals;
966
  gdouble opacity = 0.0;
967

968
  return_vals = gimp_run_procedure ("gimp-layer-get-opacity",
969 970 971
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);
Elliot Lee's avatar
Elliot Lee committed
972

973
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
974 975
    opacity = return_vals[1].data.d_float;

Elliot Lee's avatar
Elliot Lee committed
976
  gimp_destroy_params (return_vals, nreturn_vals);
977 978

  return opacity;
Elliot Lee's avatar
Elliot Lee committed
979 980
}

981 982 983 984 985 986 987 988 989 990
/**
 * gimp_layer_set_opacity:
 * @layer_ID: The layer.
 * @opacity: The new layer opacity.
 *
 * Set the opacity of the specified layer.
 *
 * This procedure sets the specified layer's opacity.
 *
 * Returns: TRUE on success.
991
 **/
992
gboolean
Elliot Lee's avatar
Elliot Lee committed
993
gimp_layer_set_opacity (gint32  layer_ID,
994
                        gdouble opacity)
Elliot Lee's avatar
Elliot Lee committed
995
{
996
  GimpParam *return_vals;
997
  gint nreturn_vals;
998
  gboolean success = TRUE;
Elliot Lee's avatar
Elliot Lee committed
999

1000
  return_vals = gimp_run_procedure ("gimp-layer-set-opacity",
1001 1002 1003 1004
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_FLOAT, opacity,
                                    GIMP_PDB_END);
Elliot Lee's avatar
Elliot Lee committed
1005

1006 1007
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

Elliot Lee's avatar
Elliot Lee committed
1008
  gimp_destroy_params (return_vals, nreturn_vals);
1009 1010

  return success;
Elliot Lee's avatar
Elliot Lee committed
1011 1012
}

1013 1014 1015 1016 1017 1018 1019 1020 1021
/**
 * gimp_layer_get_mode:
 * @layer_ID: The layer.
 *
 * Get the combination mode of the specified layer.
 *
 * This procedure returns the specified layer's combination mode.
 *
 * Returns: The layer combination mode.
1022
 **/
1023
GimpLayerMode
1024
gimp_layer_get_mode (gint32 layer_ID)
Elliot Lee's avatar
Elliot Lee committed
1025
{
1026
  GimpParam *return_vals;
1027
  gint nreturn_vals;
1028
  GimpLayerMode mode = 0;
Elliot Lee's avatar
Elliot Lee committed
1029

1030
  return_vals = gimp_run_procedure ("gimp-layer-get-mode",
1031 1032 1033
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);
Elliot Lee's avatar
Elliot Lee committed
1034

1035
  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
1036 1037
    mode = return_vals[1].data.d_int32;

Elliot Lee's avatar
Elliot Lee committed
1038
  gimp_destroy_params (return_vals, nreturn_vals);
1039 1040

  return mode;
Elliot Lee's avatar
Elliot Lee committed
1041 1042
}

1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
/**
 * gimp_layer_set_mode:
 * @layer_ID: The layer.
 * @mode: The new layer combination mode.
 *
 * Set the combination mode of the specified layer.
 *
 * This procedure sets the specified layer's combination mode.
 *
 * Returns: TRUE on success.
1053
 **/
1054
gboolean
1055 1056
gimp_layer_set_mode (gint32        layer_ID,
                     GimpLayerMode mode)
Elliot Lee's avatar
Elliot Lee committed
1057
{
1058
  GimpParam *return_vals;
1059
  gint nreturn_vals;
1060
  gboolean success = TRUE;
Elliot Lee's avatar
Elliot Lee committed
1061

1062
  return_vals = gimp_run_procedure ("gimp-layer-set-mode",
1063 1064 1065 1066
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, mode,
                                    GIMP_PDB_END);
1067

1068 1069
  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

1070
  gimp_destroy_params (return_vals, nreturn_vals);
1071 1072

  return success;
1073
}
1074

1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 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
/**
 * gimp_layer_get_blend_space:
 * @layer_ID: The layer.
 *
 * Get the blend space of the specified layer.
 *
 * This procedure returns the specified layer's blend space.
 *
 * Returns: The layer blend space.
 *
 * Since: 2.10
 **/
GimpLayerColorSpace
gimp_layer_get_blend_space (gint32 layer_ID)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  GimpLayerColorSpace blend_space = 0;

  return_vals = gimp_run_procedure ("gimp-layer-get-blend-space",
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);

  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
    blend_space = return_vals[1].data.d_int32;

  gimp_destroy_params (return_vals, nreturn_vals);

  return blend_space;
}

/**
 * gimp_layer_set_blend_space:
 * @layer_ID: The layer.
 * @blend_space: The new layer blend space.
 *
 * Set the blend space of the specified layer.
 *
 * This procedure sets the specified layer's blend space.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.10
 **/
gboolean
gimp_layer_set_blend_space (gint32              layer_ID,
                            GimpLayerColorSpace blend_space)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean success = TRUE;

  return_vals = gimp_run_procedure ("gimp-layer-set-blend-space",
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, blend_space,
                                    GIMP_PDB_END);

  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

  gimp_destroy_params (return_vals, nreturn_vals);

  return success;
}

/**
 * gimp_layer_get_composite_space:
 * @layer_ID: The layer.
 *
 * Get the composite space of the specified layer.
 *
 * This procedure returns the specified layer's composite space.
 *
 * Returns: The layer composite space.
 *
 * Since: 2.10
 **/
GimpLayerColorSpace
gimp_layer_get_composite_space (gint32 layer_ID)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  GimpLayerColorSpace composite_space = 0;

  return_vals = gimp_run_procedure ("gimp-layer-get-composite-space",
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);

  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
    composite_space = return_vals[1].data.d_int32;

  gimp_destroy_params (return_vals, nreturn_vals);

  return composite_space;
}

/**
 * gimp_layer_set_composite_space:
 * @layer_ID: The layer.
 * @composite_space: The new layer composite space.
 *
 * Set the composite space of the specified layer.
 *
 * This procedure sets the specified layer's composite space.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.10
 **/
gboolean
gimp_layer_set_composite_space (gint32              layer_ID,
                                GimpLayerColorSpace composite_space)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean success = TRUE;

  return_vals = gimp_run_procedure ("gimp-layer-set-composite-space",
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, composite_space,
                                    GIMP_PDB_END);

  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

  gimp_destroy_params (return_vals, nreturn_vals);

  return success;
}

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 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
/**
 * gimp_layer_get_composite_mode:
 * @layer_ID: The layer.
 *
 * Get the composite mode of the specified layer.
 *
 * This procedure returns the specified layer's composite mode.
 *
 * Returns: The layer composite mode.
 *
 * Since: 2.10
 **/
GimpLayerCompositeMode
gimp_layer_get_composite_mode (gint32 layer_ID)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  GimpLayerCompositeMode composite_mode = 0;

  return_vals = gimp_run_procedure ("gimp-layer-get-composite-mode",
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_END);

  if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
    composite_mode = return_vals[1].data.d_int32;

  gimp_destroy_params (return_vals, nreturn_vals);

  return composite_mode;
}

/**
 * gimp_layer_set_composite_mode:
 * @layer_ID: The layer.
 * @composite_mode: The new layer composite mode.
 *
 * Set the composite mode of the specified layer.
 *
 * This procedure sets the specified layer's composite mode.
 *
 * Returns: TRUE on success.
 *
 * Since: 2.10
 **/
gboolean
gimp_layer_set_composite_mode (gint32                 layer_ID,
                               GimpLayerCompositeMode composite_mode)
{
  GimpParam *return_vals;
  gint nreturn_vals;
  gboolean success = TRUE;

  return_vals = gimp_run_procedure ("gimp-layer-set-composite-mode",
                                    &nreturn_vals,
                                    GIMP_PDB_LAYER, layer_ID,
                                    GIMP_PDB_INT32, composite_mode,
                                    GIMP_PDB_END);

  success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;

  gimp_destroy_params (return_vals, nreturn_vals);

  return success;
}