863 lines
33 KiB
C
863 lines
33 KiB
C
/* LIBPIKA - The PIKA Library
|
|
* Copyright (C) 1995-2003 Peter Mattis and Spencer Kimball
|
|
*
|
|
* pikapainttools_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
|
|
* <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/* NOTE: This file is auto-generated by pdbgen.pl */
|
|
|
|
#include "config.h"
|
|
|
|
#include "stamp-pdbgen.h"
|
|
|
|
#include "pika.h"
|
|
|
|
|
|
/**
|
|
* SECTION: pikapainttools
|
|
* @title: pikapainttools
|
|
* @short_description: Access to toolbox paint tools.
|
|
*
|
|
* Functions giving access to toolbox paint tools.
|
|
**/
|
|
|
|
|
|
/**
|
|
* pika_airbrush:
|
|
* @drawable: The affected drawable.
|
|
* @pressure: The pressure of the airbrush strokes.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Paint in the current brush with varying pressure. Paint application
|
|
* is time-dependent.
|
|
*
|
|
* This tool simulates the use of an airbrush. Paint pressure
|
|
* represents the relative intensity of the paint application. High
|
|
* pressure results in a thicker layer of paint while low pressure
|
|
* results in a thinner layer.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_airbrush (PikaDrawable *drawable,
|
|
gdouble pressure,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_DOUBLE, pressure,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 3), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-airbrush",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_airbrush_default:
|
|
* @drawable: The affected drawable.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Paint in the current brush with varying pressure. Paint application
|
|
* is time-dependent.
|
|
*
|
|
* This tool simulates the use of an airbrush. It is similar to
|
|
* pika_airbrush() except that the pressure is derived from the
|
|
* airbrush tools options box. It the option has not been set the
|
|
* default for the option will be used.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_airbrush_default (PikaDrawable *drawable,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 2), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-airbrush-default",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_clone:
|
|
* @drawable: The affected drawable.
|
|
* @src_drawable: The source drawable.
|
|
* @clone_type: The type of clone.
|
|
* @src_x: The x coordinate in the source image.
|
|
* @src_y: The y coordinate in the source image.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Clone from the source to the dest drawable using the current brush
|
|
*
|
|
* This tool clones (copies) from the source drawable starting at the
|
|
* specified source coordinates to the dest drawable. If the
|
|
* \"clone_type\" argument is set to PATTERN-CLONE, then the current
|
|
* pattern is used as the source and the \"src_drawable\" argument is
|
|
* ignored. Pattern cloning assumes a tileable pattern and mods the sum
|
|
* of the src coordinates and subsequent stroke offsets with the width
|
|
* and height of the pattern. For image cloning, if the sum of the src
|
|
* coordinates and subsequent stroke offsets exceeds the extents of the
|
|
* src drawable, then no paint is transferred. The clone tool is
|
|
* capable of transforming between any image types including
|
|
* RGB->Indexed--although converting from any type to indexed is
|
|
* significantly slower.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_clone (PikaDrawable *drawable,
|
|
PikaDrawable *src_drawable,
|
|
PikaCloneType clone_type,
|
|
gdouble src_x,
|
|
gdouble src_y,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
PIKA_TYPE_DRAWABLE, src_drawable,
|
|
PIKA_TYPE_CLONE_TYPE, clone_type,
|
|
G_TYPE_DOUBLE, src_x,
|
|
G_TYPE_DOUBLE, src_y,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 6), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-clone",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_clone_default:
|
|
* @drawable: The affected drawable.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Clone from the source to the dest drawable using the current brush
|
|
*
|
|
* This tool clones (copies) from the source drawable starting at the
|
|
* specified source coordinates to the dest drawable. This function
|
|
* performs exactly the same as the pika_clone() function except that
|
|
* the tools arguments are obtained from the clones option dialog. It
|
|
* this dialog has not been activated then the dialogs default values
|
|
* will be used.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_clone_default (PikaDrawable *drawable,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 2), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-clone-default",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_convolve:
|
|
* @drawable: The affected drawable.
|
|
* @pressure: The pressure.
|
|
* @convolve_type: Convolve type.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Convolve (Blur, Sharpen) using the current brush.
|
|
*
|
|
* This tool convolves the specified drawable with either a sharpening
|
|
* or blurring kernel. The pressure parameter controls the magnitude of
|
|
* the operation. Like the paintbrush, this tool linearly interpolates
|
|
* between the specified stroke coordinates.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_convolve (PikaDrawable *drawable,
|
|
gdouble pressure,
|
|
PikaConvolveType convolve_type,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_DOUBLE, pressure,
|
|
PIKA_TYPE_CONVOLVE_TYPE, convolve_type,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 4), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-convolve",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_convolve_default:
|
|
* @drawable: The affected drawable.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Convolve (Blur, Sharpen) using the current brush.
|
|
*
|
|
* This tool convolves the specified drawable with either a sharpening
|
|
* or blurring kernel. This function performs exactly the same as the
|
|
* pika_convolve() function except that the tools arguments are
|
|
* obtained from the convolve option dialog. It this dialog has not
|
|
* been activated then the dialogs default values will be used.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_convolve_default (PikaDrawable *drawable,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 2), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-convolve-default",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_dodgeburn:
|
|
* @drawable: The affected drawable.
|
|
* @exposure: The exposure of the strokes.
|
|
* @dodgeburn_type: The type either dodge or burn.
|
|
* @dodgeburn_mode: The mode.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Dodgeburn image with varying exposure.
|
|
*
|
|
* Dodgeburn. More details here later.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_dodgeburn (PikaDrawable *drawable,
|
|
gdouble exposure,
|
|
PikaDodgeBurnType dodgeburn_type,
|
|
PikaTransferMode dodgeburn_mode,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_DOUBLE, exposure,
|
|
PIKA_TYPE_DODGE_BURN_TYPE, dodgeburn_type,
|
|
PIKA_TYPE_TRANSFER_MODE, dodgeburn_mode,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 5), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-dodgeburn",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_dodgeburn_default:
|
|
* @drawable: The affected drawable.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Dodgeburn image with varying exposure. This is the same as the
|
|
* pika_dodgeburn() function except that the exposure, type and mode
|
|
* are taken from the tools option dialog. If the dialog has not been
|
|
* activated then the defaults as used by the dialog will be used.
|
|
*
|
|
* Dodgeburn. More details here later.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_dodgeburn_default (PikaDrawable *drawable,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 2), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-dodgeburn-default",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_eraser:
|
|
* @drawable: The affected drawable.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
* @hardness: How to apply the brush.
|
|
* @method: The paint method to use.
|
|
*
|
|
* Erase using the current brush.
|
|
*
|
|
* This tool erases using the current brush mask. If the specified
|
|
* drawable contains an alpha channel, then the erased pixels will
|
|
* become transparent. Otherwise, the eraser tool replaces the contents
|
|
* of the drawable with the background color. Like paintbrush, this
|
|
* tool linearly interpolates between the specified stroke coordinates.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_eraser (PikaDrawable *drawable,
|
|
gint num_strokes,
|
|
const gdouble *strokes,
|
|
PikaBrushApplicationMode hardness,
|
|
PikaPaintApplicationMode method)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
PIKA_TYPE_BRUSH_APPLICATION_MODE, hardness,
|
|
PIKA_TYPE_PAINT_APPLICATION_MODE, method,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 2), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-eraser",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_eraser_default:
|
|
* @drawable: The affected drawable.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Erase using the current brush.
|
|
*
|
|
* This tool erases using the current brush mask. This function
|
|
* performs exactly the same as the pika_eraser() function except that
|
|
* the tools arguments are obtained from the eraser option dialog. It
|
|
* this dialog has not been activated then the dialogs default values
|
|
* will be used.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_eraser_default (PikaDrawable *drawable,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 2), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-eraser-default",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_heal:
|
|
* @drawable: The affected drawable.
|
|
* @src_drawable: The source drawable.
|
|
* @src_x: The x coordinate in the source image.
|
|
* @src_y: The y coordinate in the source image.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Heal from the source to the dest drawable using the current brush
|
|
*
|
|
* This tool heals the source drawable starting at the specified source
|
|
* coordinates to the dest drawable. For image healing, if the sum of
|
|
* the src coordinates and subsequent stroke offsets exceeds the
|
|
* extents of the src drawable, then no paint is transferred. The
|
|
* healing tool is capable of transforming between any image types
|
|
* except RGB->Indexed.
|
|
*
|
|
* Returns: TRUE on success.
|
|
*
|
|
* Since: 2.4
|
|
**/
|
|
gboolean
|
|
pika_heal (PikaDrawable *drawable,
|
|
PikaDrawable *src_drawable,
|
|
gdouble src_x,
|
|
gdouble src_y,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
PIKA_TYPE_DRAWABLE, src_drawable,
|
|
G_TYPE_DOUBLE, src_x,
|
|
G_TYPE_DOUBLE, src_y,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 5), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-heal",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_heal_default:
|
|
* @drawable: The affected drawable.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Heal from the source to the dest drawable using the current brush
|
|
*
|
|
* This tool heals from the source drawable starting at the specified
|
|
* source coordinates to the dest drawable. This function performs
|
|
* exactly the same as the pika_heal() function except that the tools
|
|
* arguments are obtained from the healing option dialog. It this
|
|
* dialog has not been activated then the dialogs default values will
|
|
* be used.
|
|
*
|
|
* Returns: TRUE on success.
|
|
*
|
|
* Since: 2.4
|
|
**/
|
|
gboolean
|
|
pika_heal_default (PikaDrawable *drawable,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 2), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-heal-default",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_paintbrush:
|
|
* @drawable: The affected drawable.
|
|
* @fade_out: Fade out parameter.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
* @method: The paint method to use.
|
|
* @gradient_length: Length of gradient to draw.
|
|
*
|
|
* Paint in the current brush with optional fade out parameter and pull
|
|
* colors from a gradient.
|
|
*
|
|
* This tool is the standard paintbrush. It draws linearly interpolated
|
|
* lines through the specified stroke coordinates. It operates on the
|
|
* specified drawable in the foreground color with the active brush.
|
|
* The 'fade-out' parameter is measured in pixels and allows the brush
|
|
* stroke to linearly fall off. The pressure is set to the maximum at
|
|
* the beginning of the stroke. As the distance of the stroke nears the
|
|
* fade-out value, the pressure will approach zero. The gradient-length
|
|
* is the distance to spread the gradient over. It is measured in
|
|
* pixels. If the gradient-length is 0, no gradient is used.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_paintbrush (PikaDrawable *drawable,
|
|
gdouble fade_out,
|
|
gint num_strokes,
|
|
const gdouble *strokes,
|
|
PikaPaintApplicationMode method,
|
|
gdouble gradient_length)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_DOUBLE, fade_out,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
PIKA_TYPE_PAINT_APPLICATION_MODE, method,
|
|
G_TYPE_DOUBLE, gradient_length,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 3), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-paintbrush",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_paintbrush_default:
|
|
* @drawable: The affected drawable.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Paint in the current brush. The fade out parameter and pull colors
|
|
* from a gradient parameter are set from the paintbrush options
|
|
* dialog. If this dialog has not been activated then the dialog
|
|
* defaults will be used.
|
|
*
|
|
* This tool is similar to the standard paintbrush. It draws linearly
|
|
* interpolated lines through the specified stroke coordinates. It
|
|
* operates on the specified drawable in the foreground color with the
|
|
* active brush. The 'fade-out' parameter is measured in pixels and
|
|
* allows the brush stroke to linearly fall off (value obtained from
|
|
* the option dialog). The pressure is set to the maximum at the
|
|
* beginning of the stroke. As the distance of the stroke nears the
|
|
* fade-out value, the pressure will approach zero. The gradient-length
|
|
* (value obtained from the option dialog) is the distance to spread
|
|
* the gradient over. It is measured in pixels. If the gradient-length
|
|
* is 0, no gradient is used.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_paintbrush_default (PikaDrawable *drawable,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 2), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-paintbrush-default",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_pencil:
|
|
* @drawable: The affected drawable.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Paint in the current brush without sub-pixel sampling.
|
|
*
|
|
* This tool is the standard pencil. It draws linearly interpolated
|
|
* lines through the specified stroke coordinates. It operates on the
|
|
* specified drawable in the foreground color with the active brush.
|
|
* The brush mask is treated as though it contains only black and white
|
|
* values. Any value below half is treated as black; any above half, as
|
|
* white.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_pencil (PikaDrawable *drawable,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 2), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-pencil",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_smudge:
|
|
* @drawable: The affected drawable.
|
|
* @pressure: The pressure of the smudge strokes.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Smudge image with varying pressure.
|
|
*
|
|
* This tool simulates a smudge using the current brush. High pressure
|
|
* results in a greater smudge of paint while low pressure results in a
|
|
* lesser smudge.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_smudge (PikaDrawable *drawable,
|
|
gdouble pressure,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_DOUBLE, pressure,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 3), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-smudge",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* pika_smudge_default:
|
|
* @drawable: The affected drawable.
|
|
* @num_strokes: Number of stroke control points (count each coordinate as 2 points).
|
|
* @strokes: (array length=num_strokes) (element-type gdouble): Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }.
|
|
*
|
|
* Smudge image with varying pressure.
|
|
*
|
|
* This tool simulates a smudge using the current brush. It behaves
|
|
* exactly the same as pika_smudge() except that the pressure value is
|
|
* taken from the smudge tool options or the options default if the
|
|
* tools option dialog has not been activated.
|
|
*
|
|
* Returns: TRUE on success.
|
|
**/
|
|
gboolean
|
|
pika_smudge_default (PikaDrawable *drawable,
|
|
gint num_strokes,
|
|
const gdouble *strokes)
|
|
{
|
|
PikaValueArray *args;
|
|
PikaValueArray *return_vals;
|
|
gboolean success = TRUE;
|
|
|
|
args = pika_value_array_new_from_types (NULL,
|
|
PIKA_TYPE_DRAWABLE, drawable,
|
|
G_TYPE_INT, num_strokes,
|
|
PIKA_TYPE_FLOAT_ARRAY, NULL,
|
|
G_TYPE_NONE);
|
|
pika_value_set_float_array (pika_value_array_index (args, 2), strokes, num_strokes);
|
|
|
|
return_vals = _pika_pdb_run_procedure_array (pika_get_pdb (),
|
|
"pika-smudge-default",
|
|
args);
|
|
pika_value_array_unref (args);
|
|
|
|
success = PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS;
|
|
|
|
pika_value_array_unref (return_vals);
|
|
|
|
return success;
|
|
}
|
