static GimpValueArray *
image_select_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
gint32 operation;
GimpDrawable *drawable;
GimpRGB color;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
operation = g_value_get_enum (gimp_value_array_index (args, 1));
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp);
gimp_value_get_rgb (gimp_value_array_index (args, 3), &color);
if (success)
{
GimpPDBContext *pdb_context = GIMP_PDB_CONTEXT (context);
if (pdb_context->sample_merged ||
gimp_pdb_item_is_attached (GIMP_ITEM (drawable), image, FALSE, error))
{
gimp_channel_select_by_color (gimp_image_get_mask (image), drawable,
pdb_context->sample_merged,
&color,
pdb_context->sample_threshold,
pdb_context->sample_transparent,
pdb_context->sample_criterion,
operation,
pdb_context->antialias,
pdb_context->feather,
pdb_context->feather_radius_x,
pdb_context->feather_radius_y);
}
else
success = FALSE;
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
image_set_color_profile_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
gint32 num_bytes;
const guint8 *color_profile;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
num_bytes = g_value_get_int (gimp_value_array_index (args, 1));
color_profile = gimp_value_get_int8array (gimp_value_array_index (args, 2));
if (success)
{
if (color_profile)
{
GimpColorProfile *profile;
profile = gimp_color_profile_new_from_icc_profile (color_profile,
num_bytes,
error);
if (profile)
{
success = gimp_image_set_color_profile (image, profile, error);
g_object_unref (profile);
}
else
success = FALSE;
}
else
{
success = gimp_image_set_color_profile (image, NULL, error);
}
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
edit_copy_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpDrawable *drawable;
gboolean non_empty = FALSE;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
if (success)
{
if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, 0, error))
{
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
GError *my_error = NULL;
non_empty = gimp_edit_copy (image, drawable, context, &my_error) != NULL;
if (! non_empty)
{
gimp_message_literal (gimp,
G_OBJECT (progress), GIMP_MESSAGE_WARNING,
my_error->message);
g_clear_error (&my_error);
}
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_set_boolean (gimp_value_array_index (return_vals, 1), non_empty);
return return_vals;
}
static GimpValueArray *
image_set_color_profile_from_file_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
const gchar *uri;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
uri = g_value_get_string (gimp_value_array_index (args, 1));
if (success)
{
if (uri)
{
GFile *file = g_file_new_for_uri (uri);
GimpColorProfile *profile;
profile = gimp_color_profile_new_from_file (file, error);
if (profile)
{
success = gimp_image_set_color_profile (image, profile, error);
g_object_unref (profile);
}
else
success = FALSE;
g_object_unref (file);
}
else
{
success = gimp_image_set_color_profile (image, NULL, error);
}
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
image_get_effective_color_profile_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint32 num_bytes = 0;
guint8 *profile_data = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
if (success)
{
GimpColorProfile *profile;
const guint8 *data;
gsize length;
profile = gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (image));
data = gimp_color_profile_get_icc_profile (profile, &length);
profile_data = g_memdup (data, length);
num_bytes = length;
g_object_unref (profile);
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), num_bytes);
gimp_value_take_int8array (gimp_value_array_index (return_vals, 2), profile_data, num_bytes);
}
return return_vals;
}
static GimpValueArray *
procedural_db_get_data_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *identifier;
gint32 bytes = 0;
guint8 *data = NULL;
identifier = g_value_get_string (gimp_value_array_index (args, 0));
if (success)
{
gchar *canonical = gimp_canonicalize_identifier (identifier);
const guint8 *orig_data;
orig_data = gimp_plug_in_manager_get_data (gimp->plug_in_manager,
canonical, &bytes);
g_free (canonical);
if (orig_data)
data = g_memdup (orig_data, bytes);
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), bytes);
gimp_value_take_int8array (gimp_value_array_index (return_vals, 2), data, bytes);
}
return return_vals;
}
static GimpValueArray *
procedural_db_query_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *name;
const gchar *blurb;
const gchar *help;
const gchar *author;
const gchar *copyright;
const gchar *date;
const gchar *proc_type;
gint32 num_matches = 0;
gchar **procedure_names = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0));
blurb = g_value_get_string (gimp_value_array_index (args, 1));
help = g_value_get_string (gimp_value_array_index (args, 2));
author = g_value_get_string (gimp_value_array_index (args, 3));
copyright = g_value_get_string (gimp_value_array_index (args, 4));
date = g_value_get_string (gimp_value_array_index (args, 5));
proc_type = g_value_get_string (gimp_value_array_index (args, 6));
if (success)
{
success = gimp_pdb_query (gimp->pdb,
name, blurb, help, author,
copyright, date, proc_type,
&num_matches, &procedure_names,
error);
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), num_matches);
gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), procedure_names, num_matches);
}
return return_vals;
}
static GimpValueArray *
patterns_get_pattern_data_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *name;
gchar *actual_name = NULL;
gint32 width = 0;
gint32 height = 0;
gint32 mask_bpp = 0;
gint32 length = 0;
guint8 *mask_data = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0));
if (success)
{
GimpPattern *pattern;
if (name && strlen (name))
pattern = gimp_pdb_get_pattern (gimp, name, error);
else
pattern = gimp_context_get_pattern (context);
if (pattern)
{
actual_name = g_strdup (gimp_object_get_name (pattern));
width = gimp_temp_buf_get_width (pattern->mask);
height = gimp_temp_buf_get_height (pattern->mask);
mask_bpp = babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (pattern->mask));
length = gimp_temp_buf_get_data_size (pattern->mask);
mask_data = g_memdup (gimp_temp_buf_get_data (pattern->mask), length);
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_take_string (gimp_value_array_index (return_vals, 1), actual_name);
g_value_set_int (gimp_value_array_index (return_vals, 2), width);
g_value_set_int (gimp_value_array_index (return_vals, 3), height);
g_value_set_int (gimp_value_array_index (return_vals, 4), mask_bpp);
g_value_set_int (gimp_value_array_index (return_vals, 5), length);
gimp_value_take_int8array (gimp_value_array_index (return_vals, 6), mask_data, length);
}
return return_vals;
}
static GimpValueArray *
palette_duplicate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *name;
gchar *copy_name = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0));
if (success)
{
GimpPalette *palette = gimp_pdb_get_palette (gimp, name, FALSE, error);
if (palette)
{
GimpPalette *palette_copy = (GimpPalette *)
gimp_data_factory_data_duplicate (gimp->palette_factory,
GIMP_DATA (palette));
if (palette_copy)
copy_name = g_strdup (gimp_object_get_name (palette_copy));
else
success = FALSE;
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_take_string (gimp_value_array_index (return_vals, 1), copy_name);
return return_vals;
}
static GimpValueArray *
palette_entry_get_name_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *name;
gint32 entry_num;
gchar *entry_name = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0));
entry_num = g_value_get_int (gimp_value_array_index (args, 1));
if (success)
{
GimpPalette *palette = gimp_pdb_get_palette (gimp, name, FALSE, error);
if (palette)
{
GimpPaletteEntry *entry = gimp_palette_get_entry (palette, entry_num);
if (entry)
entry_name = g_strdup (entry->name);
else
success = FALSE;
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_take_string (gimp_value_array_index (return_vals, 1), entry_name);
return return_vals;
}
static GimpValueArray *
palette_add_entry_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *name;
const gchar *entry_name;
GimpRGB color;
gint32 entry_num = 0;
name = g_value_get_string (gimp_value_array_index (args, 0));
entry_name = g_value_get_string (gimp_value_array_index (args, 1));
gimp_value_get_rgb (gimp_value_array_index (args, 2), &color);
if (success)
{
GimpPalette *palette = gimp_pdb_get_palette (gimp, name, TRUE, error);
if (palette)
{
GimpPaletteEntry *entry =
gimp_palette_add_entry (palette, -1, entry_name, &color);
entry_num = entry->position;
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_set_int (gimp_value_array_index (return_vals, 1), entry_num);
return return_vals;
}
static GimpValueArray *
image_add_sample_point_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint32 position_x;
gint32 position_y;
gint32 sample_point = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
position_x = g_value_get_int (gimp_value_array_index (args, 1));
position_y = g_value_get_int (gimp_value_array_index (args, 2));
if (success)
{
if (position_x <= gimp_image_get_width (image) &&
position_y <= gimp_image_get_height (image))
{
GimpSamplePoint *sp;
sp = gimp_image_add_sample_point_at_pos (image, position_x, position_y,
TRUE);
sample_point = gimp_sample_point_get_ID (sp);
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_set_uint (gimp_value_array_index (return_vals, 1), sample_point);
return return_vals;
}
static GimpValueArray *
image_find_next_sample_point_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint32 sample_point;
gint32 next_sample_point = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
sample_point = g_value_get_uint (gimp_value_array_index (args, 1));
if (success)
{
GimpSamplePoint *sp = gimp_image_get_next_sample_point (image, sample_point,
&success);
if (sp)
next_sample_point = gimp_sample_point_get_ID (sp);
if (! success)
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Image '%s' (%d) does not contain sample point with ID %d"),
gimp_image_get_display_name (image),
gimp_image_get_ID (image),
sample_point);
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_set_uint (gimp_value_array_index (return_vals, 1), next_sample_point);
return return_vals;
}
static GimpValueArray *
get_parasite_list_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
GimpValueArray *return_vals;
gint32 num_parasites = 0;
gchar **parasites = NULL;
parasites = gimp_parasite_list (gimp, &num_parasites);
return_vals = gimp_procedure_get_return_values (procedure, TRUE, NULL);
g_value_set_int (gimp_value_array_index (return_vals, 1), num_parasites);
gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), parasites, num_parasites);
return return_vals;
}
static GimpValueArray *
image_get_sample_point_position_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint32 sample_point;
gint32 position_x = 0;
gint32 position_y = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
sample_point = g_value_get_uint (gimp_value_array_index (args, 1));
if (success)
{
GimpSamplePoint *sp = gimp_pdb_image_get_sample_point (image, sample_point,
error);
if (sp)
gimp_sample_point_get_position (sp, &position_x, &position_y);
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), position_x);
g_value_set_int (gimp_value_array_index (return_vals, 2), position_y);
}
return return_vals;
}
static GimpValueArray *
image_grid_get_spacing_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gdouble xspacing = 0.0;
gdouble yspacing = 0.0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
if (success)
{
GimpGrid *grid = gimp_image_get_grid (image);
if (grid)
g_object_get (grid,
"xspacing", &xspacing,
"yspacing", &yspacing,
NULL);
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_set_double (gimp_value_array_index (return_vals, 1), xspacing);
g_value_set_double (gimp_value_array_index (return_vals, 2), yspacing);
}
return return_vals;
}
static GimpValueArray *
channel_new_from_component_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint32 component;
const gchar *name;
GimpChannel *channel = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
component = g_value_get_enum (gimp_value_array_index (args, 1));
name = g_value_get_string (gimp_value_array_index (args, 2));
if (success)
{
if (gimp_image_get_component_format (image, component) != NULL)
channel = gimp_channel_new_from_component (image,
component, name, NULL);
if (channel)
gimp_item_set_visible (GIMP_ITEM (channel), FALSE, FALSE);
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
gimp_value_set_channel (gimp_value_array_index (return_vals, 1), channel);
return return_vals;
}
static GimpValueArray *
edit_named_paste_as_new_image_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *buffer_name;
GimpImage *image = NULL;
buffer_name = g_value_get_string (gimp_value_array_index (args, 0));
if (success)
{
GimpBuffer *buffer = gimp_pdb_get_buffer (gimp, buffer_name, error);
if (buffer)
{
image = gimp_edit_paste_as_new_image (gimp, GIMP_OBJECT (buffer));
if (! image)
success = FALSE;
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
gimp_value_set_image (gimp_value_array_index (return_vals, 1), image);
return return_vals;
}
static GimpValueArray *
palette_rename_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *name;
const gchar *new_name;
gchar *actual_name = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0));
new_name = g_value_get_string (gimp_value_array_index (args, 1));
if (success)
{
GimpPalette *palette = gimp_pdb_get_palette (gimp, name, TRUE, error);
if (palette)
{
gimp_object_set_name (GIMP_OBJECT (palette), new_name);
actual_name = g_strdup (gimp_object_get_name (palette));
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_take_string (gimp_value_array_index (return_vals, 1), actual_name);
return return_vals;
}
static GimpValueArray *
image_add_vguide_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint32 xposition;
gint32 guide = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
xposition = g_value_get_int (gimp_value_array_index (args, 1));
if (success)
{
if (xposition <= gimp_image_get_width (image))
{
GimpGuide *g;
g = gimp_image_add_vguide (image, xposition, TRUE);
guide = gimp_guide_get_ID (g);
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_set_uint (gimp_value_array_index (return_vals, 1), guide);
return return_vals;
}
static GimpValueArray *
edit_copy_visible_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gboolean non_empty = FALSE;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
if (success)
{
GError *my_error = NULL;
non_empty = gimp_edit_copy_visible (image, context, &my_error) != NULL;
if (! non_empty)
{
gimp_message_literal (gimp,
G_OBJECT (progress), GIMP_MESSAGE_WARNING,
my_error->message);
g_clear_error (&my_error);
}
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_set_boolean (gimp_value_array_index (return_vals, 1), non_empty);
return return_vals;
}
static gint
plug_in_collect_item_args (GtkAction *action,
GimpImage *image,
GimpItem *item,
GParamSpec **pspecs,
GimpValueArray *args,
gint n_args)
{
if (gimp_value_array_length (args) > n_args &&
GIMP_IS_PARAM_SPEC_IMAGE_ID (pspecs[n_args]))
{
if (image)
{
gimp_value_set_image (gimp_value_array_index (args, n_args), image);
n_args++;
if (gimp_value_array_length (args) > n_args &&
GIMP_IS_PARAM_SPEC_ITEM_ID (pspecs[n_args]))
{
if (item &&
g_type_is_a (G_TYPE_FROM_INSTANCE (item),
GIMP_PARAM_SPEC_ITEM_ID (pspecs[n_args])->item_type))
{
gimp_value_set_item (gimp_value_array_index (args, n_args),
item);
n_args++;
}
else
{
g_warning ("Uh-oh, no active item for the plug-in!");
return -1;
}
}
}
}
return n_args;
}
static GimpValueArray *
image_select_polygon_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
gint32 operation;
gint32 num_segs;
const gdouble *segs;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
operation = g_value_get_enum (gimp_value_array_index (args, 1));
num_segs = g_value_get_int (gimp_value_array_index (args, 2));
segs = gimp_value_get_floatarray (gimp_value_array_index (args, 3));
if (success)
{
GimpPDBContext *pdb_context = GIMP_PDB_CONTEXT (context);
gimp_channel_select_polygon (gimp_image_get_mask (image),
_("Free Select"),
num_segs / 2,
(GimpVector2 *) segs,
operation,
pdb_context->antialias,
pdb_context->feather,
pdb_context->feather_radius_x,
pdb_context->feather_radius_y,
TRUE);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
file_save_thumbnail_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
const gchar *filename;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
filename = g_value_get_string (gimp_value_array_index (args, 1));
if (success)
{
success = file_utils_save_thumbnail (image, filename);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
image_flip_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
gint32 flip_type;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
flip_type = g_value_get_enum (gimp_value_array_index (args, 1));
if (success)
{
gimp_image_flip (image, context, flip_type, NULL);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
channel_set_opacity_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpChannel *channel;
gdouble opacity;
channel = gimp_value_get_channel (gimp_value_array_index (args, 0), gimp);
opacity = g_value_get_double (gimp_value_array_index (args, 1));
if (success)
{
gimp_channel_set_opacity (channel, opacity / 100.0, TRUE);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
channel_set_show_masked_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpChannel *channel;
gboolean show_masked;
channel = gimp_value_get_channel (gimp_value_array_index (args, 0), gimp);
show_masked = g_value_get_boolean (gimp_value_array_index (args, 1));
if (success)
{
gimp_channel_set_show_masked (channel, show_masked);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
image_convert_set_dither_matrix_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
gint32 width;
gint32 height;
gint32 matrix_length;
const guint8 *matrix;
width = g_value_get_int (gimp_value_array_index (args, 0));
height = g_value_get_int (gimp_value_array_index (args, 1));
matrix_length = g_value_get_int (gimp_value_array_index (args, 2));
matrix = gimp_value_get_int8array (gimp_value_array_index (args, 3));
if (success)
{
if (width == 0 || height == 0 || matrix_length == width * height)
{
gimp_image_convert_type_set_dither_matrix (matrix, width, height);
}
else
{
g_set_error_literal (error, GIMP_PDB_ERROR,
GIMP_PDB_ERROR_INVALID_ARGUMENT,
"Dither matrix length must be width * height");
success = FALSE;
}
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
image_select_round_rectangle_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
gint32 operation;
gdouble x;
gdouble y;
gdouble width;
gdouble height;
gdouble corner_radius_x;
gdouble corner_radius_y;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
operation = g_value_get_enum (gimp_value_array_index (args, 1));
x = g_value_get_double (gimp_value_array_index (args, 2));
y = g_value_get_double (gimp_value_array_index (args, 3));
width = g_value_get_double (gimp_value_array_index (args, 4));
height = g_value_get_double (gimp_value_array_index (args, 5));
corner_radius_x = g_value_get_double (gimp_value_array_index (args, 6));
corner_radius_y = g_value_get_double (gimp_value_array_index (args, 7));
if (success)
{
GimpPDBContext *pdb_context = GIMP_PDB_CONTEXT (context);
gimp_channel_select_round_rect (gimp_image_get_mask (image),
(gint) x, (gint) y,
(gint) width, (gint) height,
corner_radius_x,
corner_radius_y,
operation,
pdb_context->antialias,
pdb_context->feather,
pdb_context->feather_radius_x,
pdb_context->feather_radius_y,
TRUE);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
patterns_get_pattern_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
gchar *name = NULL;
gint32 width = 0;
gint32 height = 0;
GimpPattern *pattern = gimp_context_get_pattern (context);
if (pattern)
{
name = g_strdup (gimp_object_get_name (pattern));
width = gimp_temp_buf_get_width (pattern->mask);
height = gimp_temp_buf_get_height (pattern->mask);
}
else
success = FALSE;
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_take_string (gimp_value_array_index (return_vals, 1), name);
g_value_set_int (gimp_value_array_index (return_vals, 2), width);
g_value_set_int (gimp_value_array_index (return_vals, 3), height);
}
return return_vals;
}
