mirror of https://github.com/GNOME/gimp.git
642 lines
18 KiB
C
642 lines
18 KiB
C
/* LIBGIMP - The GIMP Library
|
|
* Copyright (C) 1995-2003 Peter Mattis and Spencer Kimball
|
|
*
|
|
* gimppaths_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 2 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, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
/* NOTE: This file is autogenerated by pdbgen.pl */
|
|
|
|
#include "config.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include "gimp.h"
|
|
|
|
/**
|
|
* gimp_path_list:
|
|
* @image_ID: The ID of the image to list the paths from.
|
|
* @num_paths: The number of paths returned.
|
|
*
|
|
* List the paths associated with the passed image.
|
|
*
|
|
* List the paths associated with the passed image.
|
|
*
|
|
* Returns: List of the paths belonging to this image.
|
|
*/
|
|
gchar **
|
|
gimp_path_list (gint32 image_ID,
|
|
gint *num_paths)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gchar **path_list = NULL;
|
|
gint i;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_list",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_END);
|
|
|
|
*num_paths = 0;
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
{
|
|
*num_paths = return_vals[1].data.d_int32;
|
|
path_list = g_new (gchar *, *num_paths);
|
|
for (i = 0; i < *num_paths; i++)
|
|
path_list[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return path_list;
|
|
}
|
|
|
|
/**
|
|
* gimp_path_get_current:
|
|
* @image_ID: The ID of the image to get the current path from.
|
|
*
|
|
* The name of the current path. Error if no paths.
|
|
*
|
|
* The name of the current path. Error if no paths.
|
|
*
|
|
* Returns: The name of the current path.
|
|
*/
|
|
gchar *
|
|
gimp_path_get_current (gint32 image_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gchar *name = NULL;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_get_current",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
name = g_strdup (return_vals[1].data.d_string);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* gimp_path_set_current:
|
|
* @image_ID: The ID of the image in which a path will become current.
|
|
* @name: The name of the path to make current.
|
|
*
|
|
* Sets the current path associated with the passed image.
|
|
*
|
|
* Sets a named path as the current path.
|
|
*
|
|
* Returns: TRUE on success.
|
|
*/
|
|
gboolean
|
|
gimp_path_set_current (gint32 image_ID,
|
|
const gchar *name)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_set_current",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_STRING, name,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_path_delete:
|
|
* @image_ID: The ID of the image to delete the path from.
|
|
* @name: The name of the path to delete.
|
|
*
|
|
* Delete the named path associated with the passed image.
|
|
*
|
|
* Delete the named path.
|
|
*
|
|
* Returns: TRUE on success.
|
|
*/
|
|
gboolean
|
|
gimp_path_delete (gint32 image_ID,
|
|
const gchar *name)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_delete",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_STRING, name,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_path_get_points:
|
|
* @image_ID: The ID of the image to list the paths from.
|
|
* @name: The name of the path whose points should be listed.
|
|
* @path_closed: Return if the path is closed. (0 = path open, 1 = path closed).
|
|
* @num_path_point_details: The number of points returned. Each point is made up of (x, y, pnt_type) of floats.
|
|
* @points_pairs: The points in the path represented as 3 floats. The first is the x pos, next is the y pos, last is the type of the pnt. The type field is dependant on the path type. For beziers (type 1 paths) the type can either be (1.0 = BEZIER_ANCHOR, 2.0 = BEZIER_CONTROL, 3.0 = BEZIER_MOVE). Note all points are returned in pixel resolution.
|
|
*
|
|
* List the points associated with the named path.
|
|
*
|
|
* List the points associated with the named path.
|
|
*
|
|
* Returns: The type of the path. Currently only one type (1 = Bezier) is supported.
|
|
*/
|
|
gint
|
|
gimp_path_get_points (gint32 image_ID,
|
|
const gchar *name,
|
|
gint *path_closed,
|
|
gint *num_path_point_details,
|
|
gdouble **points_pairs)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gint path_type = 0;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_get_points",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_STRING, name,
|
|
GIMP_PDB_END);
|
|
|
|
*num_path_point_details = 0;
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
{
|
|
path_type = return_vals[1].data.d_int32;
|
|
*path_closed = return_vals[2].data.d_int32;
|
|
*num_path_point_details = return_vals[3].data.d_int32;
|
|
*points_pairs = g_new (gdouble, *num_path_point_details);
|
|
memcpy (*points_pairs, return_vals[4].data.d_floatarray,
|
|
*num_path_point_details * sizeof (gdouble));
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return path_type;
|
|
}
|
|
|
|
/**
|
|
* gimp_path_set_points:
|
|
* @image_ID: The ID of the image to set the paths in.
|
|
* @name: The name of the path to create. If it exists then a unique name will be created - query the list of paths if you want to make sure that the name of the path you create is unique. This will be set as the current path.
|
|
* @ptype: The type of the path. Currently only one type (1 = Bezier) is supported.
|
|
* @num_path_points: The number of elements in the array, i.e. the number of points in the path * 3. Each point is made up of (x, y, type) of floats. Currently only the creation of bezier curves is allowed. The type parameter must be set to (1) to indicate a BEZIER type curve. Note that for BEZIER curves, points must be given in the following order: ACCACCAC... If the path is not closed the last control point is missed off. Points consist of three control points (control/anchor/control) so for a curve that is not closed there must be at least two points passed (2 x,y pairs). If (num_path_points/3) % 3 = 0 then the path is assumed to be closed and the points are ACCACCACCACC.
|
|
* @points_pairs: The points in the path represented as 3 floats. The first is the x pos, next is the y pos, last is the type of the pnt. The type field is dependant on the path type. For beziers (type 1 paths) the type can either be (1.0 = BEZIER_ANCHOR, 2.0 = BEZIER_CONTROL, 3.0= BEZIER_MOVE). Note all points are returned in pixel resolution.
|
|
*
|
|
* Set the points associated with the named path.
|
|
*
|
|
* Set the points associated with the named path.
|
|
*
|
|
* Returns: TRUE on success.
|
|
*/
|
|
gboolean
|
|
gimp_path_set_points (gint32 image_ID,
|
|
const gchar *name,
|
|
gint ptype,
|
|
gint num_path_points,
|
|
const gdouble *points_pairs)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_set_points",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_STRING, name,
|
|
GIMP_PDB_INT32, ptype,
|
|
GIMP_PDB_INT32, num_path_points,
|
|
GIMP_PDB_FLOATARRAY, points_pairs,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_path_stroke_current:
|
|
* @image_ID: The ID of the image which contains the path to stroke.
|
|
*
|
|
* Stroke the current path in the passed image.
|
|
*
|
|
* Stroke the current path in the passed image.
|
|
*
|
|
* Returns: TRUE on success.
|
|
*/
|
|
gboolean
|
|
gimp_path_stroke_current (gint32 image_ID)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_stroke_current",
|
|
&nreturn_vals,
|
|
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_path_get_point_at_dist:
|
|
* @image_ID: The ID of the image the paths belongs to.
|
|
* @distance: The distance along the path.
|
|
* @y_point: The y position of the point.
|
|
* @slope: The slope (dy / dx) at the specified point.
|
|
*
|
|
* Get point on a path at a specified distance along the path.
|
|
*
|
|
* This will return the x,y position of a point at a given distance
|
|
* along the bezier curve. The distance will be obtained by first
|
|
* digitizing the curve internally and then walking along the curve.
|
|
* For a closed curve the start of the path is the first point on the
|
|
* path that was created. This might not be obvious. Note the current
|
|
* path is used.
|
|
*
|
|
* Returns: The x position of the point.
|
|
*/
|
|
gint
|
|
gimp_path_get_point_at_dist (gint32 image_ID,
|
|
gdouble distance,
|
|
gint *y_point,
|
|
gdouble *slope)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gint x_point = 0;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_get_point_at_dist",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_FLOAT, distance,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
{
|
|
x_point = return_vals[1].data.d_int32;
|
|
*y_point = return_vals[2].data.d_int32;
|
|
*slope = return_vals[3].data.d_float;
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return x_point;
|
|
}
|
|
|
|
/**
|
|
* gimp_path_get_tattoo:
|
|
* @image_ID: The image.
|
|
* @name: The name of the path whose tattoo should be obtained.
|
|
*
|
|
* Returns the tattoo associated with the name path.
|
|
*
|
|
* This procedure returns the tattoo associated with the specified
|
|
* path. A tattoo is a unique and permanent identifier attached to a
|
|
* path that can be used to uniquely identify a path within an image
|
|
* even between sessions.
|
|
*
|
|
* Returns: The tattoo associated with the named path.
|
|
*/
|
|
gint
|
|
gimp_path_get_tattoo (gint32 image_ID,
|
|
const gchar *name)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gint tattoo = 0;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_get_tattoo",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_STRING, name,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
tattoo = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return tattoo;
|
|
}
|
|
|
|
/**
|
|
* gimp_path_set_tattoo:
|
|
* @image_ID: The image.
|
|
* @name: the name of the path whose tattoo should be set.
|
|
* @tattovalue: The tattoo associated with the name path. Only values returned from 'path_get_tattoo' should be used here.
|
|
*
|
|
* Sets the tattoo associated with the named path.
|
|
*
|
|
* This procedure sets the tattoo associated with the specified path. A
|
|
* tattoo is a unique and permenant identifier attached to a path that
|
|
* can be used to uniquely identify a path within an image even between
|
|
* sessions. Note that the value passed to this function must have been
|
|
* obtained from a previous call to path_get_tattoo.
|
|
*
|
|
* Returns: TRUE on success.
|
|
*/
|
|
gboolean
|
|
gimp_path_set_tattoo (gint32 image_ID,
|
|
const gchar *name,
|
|
gint tattovalue)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_set_tattoo",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_STRING, name,
|
|
GIMP_PDB_INT32, tattovalue,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_get_path_by_tattoo:
|
|
* @image_ID: The image.
|
|
* @tattoo: The tattoo of the required path.
|
|
*
|
|
* Return the name of the path with the given tattoo.
|
|
*
|
|
* The procedure returns the name of the path in the specified image
|
|
* which has the passed tattoo. The tattoos are unique within the image
|
|
* and will be preserved across sessions and through renaming of the
|
|
* path. An error is returned if no path with the specified tattoo can
|
|
* be found.
|
|
*
|
|
* Returns: The name of the path with the specified tattoo.
|
|
*/
|
|
gchar *
|
|
gimp_get_path_by_tattoo (gint32 image_ID,
|
|
gint tattoo)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gchar *name = NULL;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_get_path_by_tattoo",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_INT32, tattoo,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
name = g_strdup (return_vals[1].data.d_string);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* gimp_path_get_locked:
|
|
* @image_ID: The image.
|
|
* @name: The name of the path whose locked status should be obtained.
|
|
*
|
|
* Returns the locked status associated with the named path.
|
|
*
|
|
* This procedure returns the lock status associated with the specified
|
|
* path. A path can be \"locked\" which means that the transformation
|
|
* tool operations will also apply to the path.
|
|
*
|
|
* Returns: TRUE if the path is locked, FALSE otherwise.
|
|
*/
|
|
gboolean
|
|
gimp_path_get_locked (gint32 image_ID,
|
|
const gchar *name)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean locked = FALSE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_get_locked",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_STRING, name,
|
|
GIMP_PDB_END);
|
|
|
|
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
|
|
locked = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return locked;
|
|
}
|
|
|
|
/**
|
|
* gimp_path_set_locked:
|
|
* @image_ID: The image.
|
|
* @name: the name of the path whose locked status should be set.
|
|
* @locked: Whether the path is locked.
|
|
*
|
|
* Set the locked status associated with the named path.
|
|
*
|
|
* This procedure sets the lock status associated with the specified
|
|
* path. A path can be \"locked\" which means that the transformation
|
|
* tool operations will also apply to the path.
|
|
*
|
|
* Returns: TRUE on success.
|
|
*/
|
|
gboolean
|
|
gimp_path_set_locked (gint32 image_ID,
|
|
const gchar *name,
|
|
gboolean locked)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_set_locked",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_STRING, name,
|
|
GIMP_PDB_INT32, locked,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_path_to_selection:
|
|
* @image_ID: The image.
|
|
* @name: The name of the path which should be made into selection.
|
|
* @op: The desired operation with current selection.
|
|
* @antialias: Antialias selection.
|
|
* @feather: Feather selection.
|
|
* @feather_radius_x: Feather radius x.
|
|
* @feather_radius_y: Feather radius y.
|
|
*
|
|
* Transforms the active path into a selection
|
|
*
|
|
* This procedure renders the desired path into the current selection.
|
|
*
|
|
* Returns: TRUE on success.
|
|
*/
|
|
gboolean
|
|
gimp_path_to_selection (gint32 image_ID,
|
|
const gchar *name,
|
|
GimpChannelOps op,
|
|
gboolean antialias,
|
|
gboolean feather,
|
|
gdouble feather_radius_x,
|
|
gdouble feather_radius_y)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_to_selection",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_STRING, name,
|
|
GIMP_PDB_INT32, op,
|
|
GIMP_PDB_INT32, antialias,
|
|
GIMP_PDB_INT32, feather,
|
|
GIMP_PDB_FLOAT, feather_radius_x,
|
|
GIMP_PDB_FLOAT, feather_radius_y,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_path_import:
|
|
* @image_ID: The image.
|
|
* @filename: The name of the SVG file to import.
|
|
* @merge: Merge paths into a single vectors object.
|
|
* @scale: Scale the SVG to image dimensions.
|
|
*
|
|
* Import paths from an SVG file.
|
|
*
|
|
* This procedure imports paths from an SVG file. SVG elements other
|
|
* than paths and basic shapes are ignored.
|
|
*
|
|
* Returns: TRUE on success.
|
|
*/
|
|
gboolean
|
|
gimp_path_import (gint32 image_ID,
|
|
const gchar *filename,
|
|
gboolean merge,
|
|
gboolean scale)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_import",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_STRING, filename,
|
|
GIMP_PDB_INT32, merge,
|
|
GIMP_PDB_INT32, scale,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gimp_path_import_string:
|
|
* @image_ID: The image.
|
|
* @string: A string that must be a complete and valid SVG document.
|
|
* @length: Number of bytes in string or -1 if the string is NULL terminated.
|
|
* @merge: Merge paths into a single vectors object.
|
|
* @scale: Scale the SVG to image dimensions.
|
|
*
|
|
* Import paths from an SVG string.
|
|
*
|
|
* This procedure works like gimp_path_import() but takes a string
|
|
* rather than reading the SVG from a file. This allows you to write
|
|
* scripts that generate SVG and feed it to GIMP.
|
|
*
|
|
* Returns: TRUE on success.
|
|
*
|
|
* Since: GIMP 2.4
|
|
*/
|
|
gboolean
|
|
gimp_path_import_string (gint32 image_ID,
|
|
const gchar *string,
|
|
gint length,
|
|
gboolean merge,
|
|
gboolean scale)
|
|
{
|
|
GimpParam *return_vals;
|
|
gint nreturn_vals;
|
|
gboolean success = TRUE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_path_import_string",
|
|
&nreturn_vals,
|
|
GIMP_PDB_IMAGE, image_ID,
|
|
GIMP_PDB_STRING, string,
|
|
GIMP_PDB_INT32, length,
|
|
GIMP_PDB_INT32, merge,
|
|
GIMP_PDB_INT32, scale,
|
|
GIMP_PDB_END);
|
|
|
|
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return success;
|
|
}
|