mirror of
https://gitlab.gnome.org/GNOME/gimp.git
synced 2025-07-03 17:33:25 +00:00
8005eea835
because it confuses gtk-doc and breaks some links. Also change the "Index of new symbols in GIMP 2.x" sections to be what seems to be the modern standard (looked at the GLib and GTK+ docs), and update some other stuff.
1009 lines
30 KiB
C
1009 lines
30 KiB
C
/* LIBGIMP - The GIMP Library
|
|
* Copyright (C) 1995-2003 Peter Mattis and Spencer Kimball
|
|
*
|
|
* gimpdrawable_pdb.c
|
|
*
|
|
* This library is free software: you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see
|
|
* <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/* NOTE: This file is auto-generated by pdbgen.pl */
|
|
|
|
#include "config.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include "gimp.h"
|
|
|
|
|
|
/**
|
|
* SECTION: gimpdrawable
|
|
* @title: gimpdrawable
|
|
* @short_description: Functions to manipulate drawables.
|
|
*
|
|
* Functions to manipulate drawables.
|
|
**/
|
|
|
|
|
|
/**
|
|
* _gimp_drawable_get_format:
|
|
* @drawable_ID: The drawable.
|
|
*
|
|
* Returns the drawable's Babl format
|
|
*
|
|
* This procedure returns the drawable's Babl format.
|
|
*
|
|
* Returns: The drawable's Babl format.
|
|
*
|
|
* Since: 2.10
|
|
**/
|
|
gchar *
|
|
_gimp_drawable_get_format (gint32 drawable_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gchar *format = NULL;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-get-format",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
format = g_strdup (return_vals[1].data.d_string);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return format;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_type:
|
|
* @drawable_ID: The drawable.
|
|
*
|
|
* Returns the drawable's type.
|
|
*
|
|
* This procedure returns the drawable's type.
|
|
*
|
|
* Returns: The drawable's type.
|
|
**/
|
|
GimpImageType
|
|
gimp_drawable_type (gint32 drawable_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
GimpImageType type = 0;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-type",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
type = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return type;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_type_with_alpha:
|
|
* @drawable_ID: The drawable.
|
|
*
|
|
* Returns the drawable's type with alpha.
|
|
*
|
|
* This procedure returns the drawable's type as if had an alpha
|
|
* channel. If the type is currently Gray, for instance, the returned
|
|
* type would be GrayA. If the drawable already has an alpha channel,
|
|
* the drawable's type is simply returned.
|
|
*
|
|
* Returns: The drawable's type with alpha.
|
|
**/
|
|
GimpImageType
|
|
gimp_drawable_type_with_alpha (gint32 drawable_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
GimpImageType type_with_alpha = 0;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-type-with-alpha",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
type_with_alpha = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return type_with_alpha;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_has_alpha:
|
|
* @drawable_ID: The drawable.
|
|
*
|
|
* Returns TRUE if the drawable has an alpha channel.
|
|
*
|
|
* This procedure returns whether the specified drawable has an alpha
|
|
* channel. This can only be true for layers, and the associated type
|
|
* will be one of: { RGBA , GRAYA, INDEXEDA }.
|
|
*
|
|
* Returns: Does the drawable have an alpha channel?
|
|
**/
|
|
gboolean
|
|
gimp_drawable_has_alpha (gint32 drawable_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean has_alpha = FALSE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-has-alpha",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
has_alpha = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return has_alpha;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_is_rgb:
|
|
* @drawable_ID: The drawable.
|
|
*
|
|
* Returns whether the drawable is an RGB type.
|
|
*
|
|
* This procedure returns TRUE if the specified drawable is of type {
|
|
* RGB, RGBA }.
|
|
*
|
|
* Returns: TRUE if the drawable is an RGB type.
|
|
**/
|
|
gboolean
|
|
gimp_drawable_is_rgb (gint32 drawable_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean is_rgb = FALSE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-is-rgb",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
is_rgb = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return is_rgb;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_is_gray:
|
|
* @drawable_ID: The drawable.
|
|
*
|
|
* Returns whether the drawable is a grayscale type.
|
|
*
|
|
* This procedure returns TRUE if the specified drawable is of type {
|
|
* Gray, GrayA }.
|
|
*
|
|
* Returns: TRUE if the drawable is a grayscale type.
|
|
**/
|
|
gboolean
|
|
gimp_drawable_is_gray (gint32 drawable_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean is_gray = FALSE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-is-gray",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
is_gray = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return is_gray;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_is_indexed:
|
|
* @drawable_ID: The drawable.
|
|
*
|
|
* Returns whether the drawable is an indexed type.
|
|
*
|
|
* This procedure returns TRUE if the specified drawable is of type {
|
|
* Indexed, IndexedA }.
|
|
*
|
|
* Returns: TRUE if the drawable is an indexed type.
|
|
**/
|
|
gboolean
|
|
gimp_drawable_is_indexed (gint32 drawable_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean is_indexed = FALSE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-is-indexed",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
is_indexed = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return is_indexed;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_bpp:
|
|
* @drawable_ID: The drawable.
|
|
*
|
|
* Returns the bytes per pixel.
|
|
*
|
|
* This procedure returns the number of bytes per pixel, which
|
|
* corresponds to the number of components unless
|
|
* gimp_plugin_enable_precision() was called.
|
|
*
|
|
* Returns: Bytes per pixel.
|
|
**/
|
|
gint
|
|
gimp_drawable_bpp (gint32 drawable_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gint bpp = 0;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-bpp",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
bpp = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return bpp;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_width:
|
|
* @drawable_ID: The drawable.
|
|
*
|
|
* Returns the width of the drawable.
|
|
*
|
|
* This procedure returns the specified drawable's width in pixels.
|
|
*
|
|
* Returns: Width of drawable.
|
|
**/
|
|
gint
|
|
gimp_drawable_width (gint32 drawable_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gint width = 0;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-width",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
width = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return width;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_height:
|
|
* @drawable_ID: The drawable.
|
|
*
|
|
* Returns the height of the drawable.
|
|
*
|
|
* This procedure returns the specified drawable's height in pixels.
|
|
*
|
|
* Returns: Height of drawable.
|
|
**/
|
|
gint
|
|
gimp_drawable_height (gint32 drawable_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gint height = 0;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-height",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
height = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return height;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_offsets:
|
|
* @drawable_ID: The drawable.
|
|
* @offset_x: x offset of drawable.
|
|
* @offset_y: y offset of drawable.
|
|
*
|
|
* Returns the offsets for the drawable.
|
|
*
|
|
* This procedure returns the specified drawable's offsets. This only
|
|
* makes sense if the drawable is a layer since channels are anchored.
|
|
* The offsets of a channel will be returned as 0.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
gimp_drawable_offsets (gint32 drawable_ID,
|
|
gint *offset_x,
|
|
gint *offset_y)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-offsets",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
*offset_x = 0;
|
|
*offset_y = 0;
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
if (success)
|
|
{
|
|
*offset_x = return_vals[1].data.d_int32;
|
|
*offset_y = return_vals[2].data.d_int32;
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_set_image:
|
|
* @drawable_ID: The drawable.
|
|
* @image_ID: The image.
|
|
*
|
|
* Deprecated: There is no replacement for this procedure.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
gimp_drawable_set_image (gint32 drawable_ID,
|
|
gint32 image_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-set-image",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_mask_bounds:
|
|
* @drawable_ID: The drawable.
|
|
* @x1: x coordinate of the upper left corner of selection bounds.
|
|
* @y1: y coordinate of the upper left corner of selection bounds.
|
|
* @x2: x coordinate of the lower right corner of selection bounds.
|
|
* @y2: y coordinate of the lower right corner of selection bounds.
|
|
*
|
|
* Find the bounding box of the current selection in relation to the
|
|
* specified drawable.
|
|
*
|
|
* This procedure returns whether there is a selection. If there is
|
|
* one, the upper left and lower right-hand corners of its bounding box
|
|
* are returned. These coordinates are specified relative to the
|
|
* drawable's origin, and bounded by the drawable's extents. Please
|
|
* note that the pixel specified by the lower right-hand coordinate of
|
|
* the bounding box is not part of the selection. The selection ends at
|
|
* the upper left corner of this pixel. This means the width of the
|
|
* selection can be calculated as (x2 - x1), its height as (y2 - y1).
|
|
* Note that the returned boolean does NOT correspond with the returned
|
|
* region being empty or not, it always returns whether the selection
|
|
* is non_empty. See gimp_drawable_mask_intersect() for a boolean
|
|
* return value which is more useful in most cases.
|
|
*
|
|
* Returns: TRUE if there is a selection.
|
|
**/
|
|
gboolean
|
|
gimp_drawable_mask_bounds (gint32 drawable_ID,
|
|
gint *x1,
|
|
gint *y1,
|
|
gint *x2,
|
|
gint *y2)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean non_empty = FALSE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-mask-bounds",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
{
|
|
non_empty = return_vals[1].data.d_int32;
|
|
*x1 = return_vals[2].data.d_int32;
|
|
*y1 = return_vals[3].data.d_int32;
|
|
*x2 = return_vals[4].data.d_int32;
|
|
*y2 = return_vals[5].data.d_int32;
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return non_empty;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_mask_intersect:
|
|
* @drawable_ID: The drawable.
|
|
* @x: x coordinate of the upper left corner of the intersection.
|
|
* @y: y coordinate of the upper left corner of the intersection.
|
|
* @width: width of the intersection.
|
|
* @height: height of the intersection.
|
|
*
|
|
* Find the bounding box of the current selection in relation to the
|
|
* specified drawable.
|
|
*
|
|
* This procedure returns whether there is an intersection between the
|
|
* drawable and the selection. Unlike gimp_drawable_mask_bounds(), the
|
|
* intersection's bounds are returned as x, y, width, height.
|
|
* If there is no selection this function returns TRUE and the returned
|
|
* bounds are the extents of the whole drawable.
|
|
*
|
|
* Returns: TRUE if the returned area is not empty.
|
|
*
|
|
* Since: 2.2
|
|
**/
|
|
gboolean
|
|
gimp_drawable_mask_intersect (gint32 drawable_ID,
|
|
gint *x,
|
|
gint *y,
|
|
gint *width,
|
|
gint *height)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean non_empty = FALSE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-mask-intersect",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
{
|
|
non_empty = return_vals[1].data.d_int32;
|
|
*x = return_vals[2].data.d_int32;
|
|
*y = return_vals[3].data.d_int32;
|
|
*width = return_vals[4].data.d_int32;
|
|
*height = return_vals[5].data.d_int32;
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return non_empty;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_merge_shadow:
|
|
* @drawable_ID: The drawable.
|
|
* @undo: Push merge to undo stack?
|
|
*
|
|
* Merge the shadow buffer with the specified drawable.
|
|
*
|
|
* This procedure combines the contents of the drawable's shadow buffer
|
|
* (for temporary processing) with the specified drawable. The 'undo'
|
|
* parameter specifies whether to add an undo step for the operation.
|
|
* Requesting no undo is useful for such applications as 'auto-apply'.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
gimp_drawable_merge_shadow (gint32 drawable_ID,
|
|
gboolean undo)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-merge-shadow",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_INT32, undo,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_free_shadow:
|
|
* @drawable_ID: The drawable.
|
|
*
|
|
* Free the specified drawable's shadow data (if it exists).
|
|
*
|
|
* This procedure is intended as a memory saving device. If any shadow
|
|
* memory has been allocated, it will be freed automatically when the
|
|
* drawable is removed from the image, or when the plug-in procedure
|
|
* which allocated it returns.
|
|
*
|
|
* Returns: TRUE on success.
|
|
*
|
|
* Since: 2.6
|
|
**/
|
|
gboolean
|
|
gimp_drawable_free_shadow (gint32 drawable_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-free-shadow",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_update:
|
|
* @drawable_ID: The drawable.
|
|
* @x: x coordinate of upper left corner of update region.
|
|
* @y: y coordinate of upper left corner of update region.
|
|
* @width: Width of update region.
|
|
* @height: Height of update region.
|
|
*
|
|
* Update the specified region of the drawable.
|
|
*
|
|
* This procedure updates the specified region of the drawable. The (x,
|
|
* y) coordinate pair is relative to the drawable's origin, not to the
|
|
* image origin. Therefore, the entire drawable can be updated using
|
|
* (0, 0, width, height).
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
gimp_drawable_update (gint32 drawable_ID,
|
|
gint x,
|
|
gint y,
|
|
gint width,
|
|
gint height)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-update",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_INT32, x,
|
|
GIMP_PDB_INT32, y,
|
|
GIMP_PDB_INT32, width,
|
|
GIMP_PDB_INT32, height,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_get_pixel:
|
|
* @drawable_ID: The drawable.
|
|
* @x_coord: The x coordinate.
|
|
* @y_coord: The y coordinate.
|
|
* @num_channels: The number of channels for the pixel.
|
|
*
|
|
* Gets the value of the pixel at the specified coordinates.
|
|
*
|
|
* This procedure gets the pixel value at the specified coordinates.
|
|
* The 'num_channels' argument must always be equal to the
|
|
* bytes-per-pixel value for the specified drawable.
|
|
*
|
|
* Returns: The pixel value.
|
|
**/
|
|
guint8 *
|
|
gimp_drawable_get_pixel (gint32 drawable_ID,
|
|
gint x_coord,
|
|
gint y_coord,
|
|
gint *num_channels)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
guint8 *pixel = NULL;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-get-pixel",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_INT32, x_coord,
|
|
GIMP_PDB_INT32, y_coord,
|
|
GIMP_PDB_END);
|
|
|
|
*num_channels = 0;
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
{
|
|
*num_channels = return_vals[1].data.d_int32;
|
|
pixel = g_new (guint8, *num_channels);
|
|
memcpy (pixel,
|
|
return_vals[2].data.d_int8array,
|
|
*num_channels * sizeof (guint8));
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return pixel;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_set_pixel:
|
|
* @drawable_ID: The drawable.
|
|
* @x_coord: The x coordinate.
|
|
* @y_coord: The y coordinate.
|
|
* @num_channels: The number of channels for the pixel.
|
|
* @pixel: The pixel value.
|
|
*
|
|
* Sets the value of the pixel at the specified coordinates.
|
|
*
|
|
* This procedure sets the pixel value at the specified coordinates.
|
|
* The 'num_channels' argument must always be equal to the
|
|
* bytes-per-pixel value for the specified drawable. Note that this
|
|
* function is not undoable, you should use it only on drawables you
|
|
* just created yourself.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
gimp_drawable_set_pixel (gint32 drawable_ID,
|
|
gint x_coord,
|
|
gint y_coord,
|
|
gint num_channels,
|
|
const guint8 *pixel)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-set-pixel",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_INT32, x_coord,
|
|
GIMP_PDB_INT32, y_coord,
|
|
GIMP_PDB_INT32, num_channels,
|
|
GIMP_PDB_INT8ARRAY, pixel,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_fill:
|
|
* @drawable_ID: The drawable.
|
|
* @fill_type: The type of fill.
|
|
*
|
|
* Fill the drawable with the specified fill mode.
|
|
*
|
|
* This procedure fills the drawable. If the fill mode is foreground
|
|
* the current foreground color is used. If the fill mode is
|
|
* background, the current background color is used. If the fill type
|
|
* is white, then white is used. Transparent fill only affects layers
|
|
* with an alpha channel, in which case the alpha channel is set to
|
|
* transparent. If the drawable has no alpha channel, it is filled to
|
|
* white. No fill leaves the drawable's contents undefined.
|
|
* This procedure is unlike gimp_edit_fill() or the bucket fill tool
|
|
* because it fills regardless of a selection. Its main purpose is to
|
|
* fill a newly created drawable before adding it to the image. This
|
|
* operation cannot be undone.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
gimp_drawable_fill (gint32 drawable_ID,
|
|
GimpFillType fill_type)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-fill",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_INT32, fill_type,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_offset:
|
|
* @drawable_ID: The drawable to offset.
|
|
* @wrap_around: wrap image around or fill vacated regions.
|
|
* @fill_type: fill vacated regions of drawable with background or transparent.
|
|
* @offset_x: offset by this amount in X direction.
|
|
* @offset_y: offset by this amount in Y direction.
|
|
*
|
|
* Offset the drawable by the specified amounts in the X and Y
|
|
* directions
|
|
*
|
|
* This procedure offsets the specified drawable by the amounts
|
|
* specified by 'offset_x' and 'offset_y'. If 'wrap_around' is set to
|
|
* TRUE, then portions of the drawable which are offset out of bounds
|
|
* are wrapped around. Alternatively, the undefined regions of the
|
|
* drawable can be filled with transparency or the background color, as
|
|
* specified by the 'fill-type' parameter.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
gimp_drawable_offset (gint32 drawable_ID,
|
|
gboolean wrap_around,
|
|
GimpOffsetType fill_type,
|
|
gint offset_x,
|
|
gint offset_y)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-offset",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_INT32, wrap_around,
|
|
GIMP_PDB_INT32, fill_type,
|
|
GIMP_PDB_INT32, offset_x,
|
|
GIMP_PDB_INT32, offset_y,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* _gimp_drawable_thumbnail:
|
|
* @drawable_ID: The drawable.
|
|
* @width: The requested thumbnail width.
|
|
* @height: The requested thumbnail height.
|
|
* @actual_width: The previews width.
|
|
* @actual_height: The previews height.
|
|
* @bpp: The previews bpp.
|
|
* @thumbnail_data_count: The number of bytes in thumbnail data.
|
|
* @thumbnail_data: The thumbnail data.
|
|
*
|
|
* Get a thumbnail of a drawable.
|
|
*
|
|
* This function gets data from which a thumbnail of a drawable preview
|
|
* can be created. Maximum x or y dimension is 1024 pixels. The pixels
|
|
* are returned in RGB[A] or GRAY[A] format. The bpp return value gives
|
|
* the number of bytes in the image.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
_gimp_drawable_thumbnail (gint32 drawable_ID,
|
|
gint width,
|
|
gint height,
|
|
gint *actual_width,
|
|
gint *actual_height,
|
|
gint *bpp,
|
|
gint *thumbnail_data_count,
|
|
guint8 **thumbnail_data)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-thumbnail",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_INT32, width,
|
|
GIMP_PDB_INT32, height,
|
|
GIMP_PDB_END);
|
|
|
|
*actual_width = 0;
|
|
*actual_height = 0;
|
|
*bpp = 0;
|
|
*thumbnail_data_count = 0;
|
|
*thumbnail_data = NULL;
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
if (success)
|
|
{
|
|
*actual_width = return_vals[1].data.d_int32;
|
|
*actual_height = return_vals[2].data.d_int32;
|
|
*bpp = return_vals[3].data.d_int32;
|
|
*thumbnail_data_count = return_vals[4].data.d_int32;
|
|
*thumbnail_data = g_new (guint8, *thumbnail_data_count);
|
|
memcpy (*thumbnail_data,
|
|
return_vals[5].data.d_int8array,
|
|
*thumbnail_data_count * sizeof (guint8));
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* _gimp_drawable_sub_thumbnail:
|
|
* @drawable_ID: The drawable.
|
|
* @src_x: The x coordinate of the area.
|
|
* @src_y: The y coordinate of the area.
|
|
* @src_width: The width of the area.
|
|
* @src_height: The height of the area.
|
|
* @dest_width: The thumbnail width.
|
|
* @dest_height: The thumbnail height.
|
|
* @width: The previews width.
|
|
* @height: The previews height.
|
|
* @bpp: The previews bpp.
|
|
* @thumbnail_data_count: The number of bytes in thumbnail data.
|
|
* @thumbnail_data: The thumbnail data.
|
|
*
|
|
* Get a thumbnail of a sub-area of a drawable drawable.
|
|
*
|
|
* This function gets data from which a thumbnail of a drawable preview
|
|
* can be created. Maximum x or y dimension is 1024 pixels. The pixels
|
|
* are returned in RGB[A] or GRAY[A] format. The bpp return value gives
|
|
* the number of bytes in the image.
|
|
*
|
|
* Returns: TRUE on success.
|
|
*
|
|
* Since: 2.2
|
|
**/
|
|
gboolean
|
|
_gimp_drawable_sub_thumbnail (gint32 drawable_ID,
|
|
gint src_x,
|
|
gint src_y,
|
|
gint src_width,
|
|
gint src_height,
|
|
gint dest_width,
|
|
gint dest_height,
|
|
gint *width,
|
|
gint *height,
|
|
gint *bpp,
|
|
gint *thumbnail_data_count,
|
|
guint8 **thumbnail_data)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-sub-thumbnail",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_INT32, src_x,
|
|
GIMP_PDB_INT32, src_y,
|
|
GIMP_PDB_INT32, src_width,
|
|
GIMP_PDB_INT32, src_height,
|
|
GIMP_PDB_INT32, dest_width,
|
|
GIMP_PDB_INT32, dest_height,
|
|
GIMP_PDB_END);
|
|
|
|
*width = 0;
|
|
*height = 0;
|
|
*bpp = 0;
|
|
*thumbnail_data_count = 0;
|
|
*thumbnail_data = NULL;
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
if (success)
|
|
{
|
|
*width = return_vals[1].data.d_int32;
|
|
*height = return_vals[2].data.d_int32;
|
|
*bpp = return_vals[3].data.d_int32;
|
|
*thumbnail_data_count = return_vals[4].data.d_int32;
|
|
*thumbnail_data = g_new (guint8, *thumbnail_data_count);
|
|
memcpy (*thumbnail_data,
|
|
return_vals[5].data.d_int8array,
|
|
*thumbnail_data_count * sizeof (guint8));
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_drawable_foreground_extract:
|
|
* @drawable_ID: The drawable.
|
|
* @mode: The algorithm to use.
|
|
* @mask_ID: Tri-Map.
|
|
*
|
|
* Extract the foreground of a drawable using a given trimap.
|
|
*
|
|
* Image Segmentation by Uniform Color Clustering, see
|
|
* http://www.inf.fu-berlin.de/inst/pubs/tr-b-05-07.pdf
|
|
*
|
|
* Returns: TRUE on success.
|
|
*
|
|
* Since: 2.4
|
|
**/
|
|
gboolean
|
|
gimp_drawable_foreground_extract (gint32 drawable_ID,
|
|
GimpForegroundExtractMode mode,
|
|
gint32 mask_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp-drawable-foreground-extract",
|
|
&nreturn_vals,
|
|
GIMP_PDB_DRAWABLE, drawable_ID,
|
|
GIMP_PDB_INT32, mode,
|
|
GIMP_PDB_DRAWABLE, mask_ID,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|