static GimpValueArray *
selection_save_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
GimpChannel *channel = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
if (success)
{
channel = gimp_selection_save (GIMP_SELECTION (gimp_image_get_mask (image)));
if (! channel)
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 void
gimp_image_duplicate_mask (GimpImage *image,
GimpImage *new_image)
{
GimpDrawable *mask;
GimpDrawable *new_mask;
mask = GIMP_DRAWABLE (gimp_image_get_mask (image));
new_mask = GIMP_DRAWABLE (gimp_image_get_mask (new_image));
gegl_buffer_copy (gimp_drawable_get_buffer (mask), NULL,
gimp_drawable_get_buffer (new_mask), NULL);
GIMP_CHANNEL (new_mask)->bounds_known = FALSE;
GIMP_CHANNEL (new_mask)->boundary_known = FALSE;
}
void
select_stroke_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *image;
GimpDrawable *drawable;
GtkWidget *widget;
GtkWidget *dialog;
return_if_no_image (image, data);
return_if_no_widget (widget, data);
drawable = gimp_image_get_active_drawable (image);
if (! drawable)
{
gimp_message (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING,
_("There is no active layer or channel to stroke to."));
return;
}
dialog = stroke_dialog_new (GIMP_ITEM (gimp_image_get_mask (image)),
action_data_get_context (data),
_("Stroke Selection"),
GIMP_STOCK_SELECTION_STROKE,
GIMP_HELP_SELECTION_STROKE,
widget);
gtk_widget_show (dialog);
}
static GimpValueArray *
selection_translate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
gint32 offx;
gint32 offy;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
offx = g_value_get_int (gimp_value_array_index (args, 1));
offy = g_value_get_int (gimp_value_array_index (args, 2));
if (success)
{
gimp_item_translate (GIMP_ITEM (gimp_image_get_mask (image)),
offx, offy, TRUE);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
GimpTransformResize
gimp_drawable_transform_get_effective_clip (GimpDrawable *drawable,
GeglBuffer *orig_buffer,
GimpTransformResize clip_result)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), clip_result);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)),
clip_result);
g_return_val_if_fail (orig_buffer == NULL || GEGL_IS_BUFFER (orig_buffer),
clip_result);
/* Always clip unfloated buffers since they must keep their size */
if (GIMP_IS_CHANNEL (drawable))
{
if (orig_buffer)
{
if (! babl_format_has_alpha (gegl_buffer_get_format (orig_buffer)))
clip_result = GIMP_TRANSFORM_RESIZE_CLIP;
}
else
{
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
if (gimp_channel_is_empty (gimp_image_get_mask (image)))
clip_result = GIMP_TRANSFORM_RESIZE_CLIP;
}
}
return clip_result;
}
static void
select_grow_callback (GtkWidget *widget,
gdouble size,
GimpUnit unit,
gpointer data)
{
GimpImage *image = GIMP_IMAGE (data);
gdouble radius_x;
gdouble radius_y;
radius_x = radius_y = select_grow_pixels = ROUND (size);
if (unit != GIMP_UNIT_PIXEL)
{
gdouble factor;
factor = (MAX (image->xresolution, image->yresolution) /
MIN (image->xresolution, image->yresolution));
if (image->xresolution == MIN (image->xresolution, image->yresolution))
radius_y *= factor;
else
radius_x *= factor;
}
gimp_channel_grow (gimp_image_get_mask (image), radius_x, radius_y, TRUE);
gimp_image_flush (image);
}
static GimpValueArray *
selection_is_empty_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gboolean is_empty = FALSE;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
if (success)
{
is_empty = gimp_channel_is_empty (gimp_image_get_mask (image));
}
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), is_empty);
return return_vals;
}
static void
select_shrink_callback (GtkWidget *widget,
gdouble size,
GimpUnit unit,
gpointer data)
{
GimpImage *image = GIMP_IMAGE (data);
GtkWidget *button = g_object_get_data (G_OBJECT (widget), "edge-lock-toggle");
gint radius_x;
gint radius_y;
radius_x = radius_y = select_shrink_pixels = ROUND (size);
select_shrink_edge_lock =
! gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
if (unit != GIMP_UNIT_PIXEL)
{
gdouble factor;
factor = (MAX (image->xresolution, image->yresolution) /
MIN (image->xresolution, image->yresolution));
if (image->xresolution == MIN (image->xresolution, image->yresolution))
radius_y *= factor;
else
radius_x *= factor;
}
gimp_channel_shrink (gimp_image_get_mask (image), radius_x, radius_y,
select_shrink_edge_lock, TRUE);
gimp_image_flush (image);
}
static void
select_feather_callback (GtkWidget *widget,
gdouble size,
GimpUnit unit,
gpointer data)
{
GimpImage *image = GIMP_IMAGE (data);
gdouble radius_x;
gdouble radius_y;
radius_x = radius_y = select_feather_radius = size;
if (unit != GIMP_UNIT_PIXEL)
{
gdouble xres;
gdouble yres;
gdouble factor;
gimp_image_get_resolution (image, &xres, &yres);
factor = (MAX (xres, yres) /
MIN (xres, yres));
if (xres == MIN (xres, yres))
radius_y *= factor;
else
radius_x *= factor;
}
gimp_channel_feather (gimp_image_get_mask (image), radius_x, radius_y, TRUE);
gimp_image_flush (image);
}
static GValueArray *
selection_value_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GValueArray *args,
GError **error)
{
gboolean success = TRUE;
GValueArray *return_vals;
GimpImage *image;
gint32 x;
gint32 y;
gint32 value = 0;
image = gimp_value_get_image (&args->values[0], gimp);
x = g_value_get_int (&args->values[1]);
y = g_value_get_int (&args->values[2]);
if (success)
{
value = gimp_pickable_get_opacity_at (GIMP_PICKABLE (gimp_image_get_mask (image)), x, y);
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_set_int (&return_vals->values[1], value);
return return_vals;
}
void
select_float_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *image;
GtkWidget *widget;
GError *error = NULL;
return_if_no_image (image, data);
return_if_no_widget (widget, data);
if (gimp_selection_float (GIMP_SELECTION (gimp_image_get_mask (image)),
gimp_image_get_active_drawable (image),
action_data_get_context (data),
TRUE, 0, 0, &error))
{
gimp_image_flush (image);
}
else
{
gimp_message_literal (image->gimp,
G_OBJECT (widget), GIMP_MESSAGE_WARNING,
error->message);
g_clear_error (&error);
}
}
static GValueArray *
selection_combine_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpChannel *channel;
gint32 operation;
channel = gimp_value_get_channel (&args->values[0], gimp);
operation = g_value_get_enum (&args->values[1]);
if (success)
{
GimpImage *image;
gint off_x, off_y;
image = gimp_item_get_image (GIMP_ITEM (channel));
gimp_item_offsets (GIMP_ITEM (channel), &off_x, &off_y);
gimp_channel_select_channel (gimp_image_get_mask (image),
_("Channel to Selection"),
channel,
off_x, off_y,
operation,
FALSE, 0.0, 0.0);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GValueArray *
selection_save_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GValueArray *args,
GError **error)
{
gboolean success = TRUE;
GValueArray *return_vals;
GimpImage *image;
GimpChannel *channel = NULL;
image = gimp_value_get_image (&args->values[0], gimp);
if (success)
{
channel = gimp_selection_save (gimp_image_get_mask (image));
if (! channel)
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
gimp_value_set_channel (&return_vals->values[1], channel);
return return_vals;
}
static GValueArray *
selection_layer_alpha_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpLayer *layer;
layer = gimp_value_get_layer (&args->values[0], gimp);
if (success)
{
GimpImage *image = gimp_item_get_image (GIMP_ITEM (layer));
gimp_channel_select_alpha (gimp_image_get_mask (image),
GIMP_DRAWABLE (layer),
GIMP_CHANNEL_OP_REPLACE, FALSE, 0.0, 0.0);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static void
gimp_selection_editor_set_image (GimpImageEditor *image_editor,
GimpImage *image)
{
GimpSelectionEditor *editor = GIMP_SELECTION_EDITOR (image_editor);
if (image_editor->image)
{
g_signal_handlers_disconnect_by_func (image_editor->image,
gimp_selection_editor_mask_changed,
editor);
}
GIMP_IMAGE_EDITOR_CLASS (parent_class)->set_image (image_editor, image);
if (image)
{
g_signal_connect (image, "mask-changed",
G_CALLBACK (gimp_selection_editor_mask_changed),
editor);
gimp_view_set_viewable (GIMP_VIEW (editor->view),
GIMP_VIEWABLE (gimp_image_get_mask (image)));
}
else
{
gimp_view_set_viewable (GIMP_VIEW (editor->view), NULL);
}
}
static GimpValueArray *
selection_border_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
gint32 radius;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
radius = g_value_get_int (gimp_value_array_index (args, 1));
if (success)
{
/* FIXME: "feather" and "edge-lock" hardcoded to TRUE */
gimp_channel_border (gimp_image_get_mask (image),
radius, radius, TRUE, TRUE, TRUE);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
void
floating_sel_anchor (GimpLayer *layer)
{
GimpImage *image;
GimpDrawable *drawable;
GimpFilter *filter = NULL;
gint off_x, off_y;
gint dr_off_x, dr_off_y;
g_return_if_fail (GIMP_IS_LAYER (layer));
g_return_if_fail (gimp_layer_is_floating_sel (layer));
/* Don't let gimp_image_remove_layer free the layer while we still need it */
g_object_ref (layer);
image = gimp_item_get_image (GIMP_ITEM (layer));
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_ANCHOR,
C_("undo-type", "Anchor Floating Selection"));
drawable = gimp_layer_get_floating_sel_drawable (layer);
gimp_item_get_offset (GIMP_ITEM (layer), &off_x, &off_y);
gimp_item_get_offset (GIMP_ITEM (drawable), &dr_off_x, &dr_off_y);
if (gimp_item_get_visible (GIMP_ITEM (layer)) &&
gimp_rectangle_intersect (off_x, off_y,
gimp_item_get_width (GIMP_ITEM (layer)),
gimp_item_get_height (GIMP_ITEM (layer)),
dr_off_x, dr_off_y,
gimp_item_get_width (GIMP_ITEM (drawable)),
gimp_item_get_height (GIMP_ITEM (drawable)),
NULL, NULL, NULL, NULL))
{
filter = gimp_drawable_get_floating_sel_filter (drawable);
g_object_ref (filter);
}
/* first remove the filter, then merge it, or we will get warnings
* about already connected nodes
*/
gimp_image_remove_layer (image, layer, TRUE, NULL);
if (filter)
{
gimp_drawable_merge_filter (drawable, filter, NULL, NULL);
g_object_unref (filter);
}
gimp_image_undo_group_end (image);
/* invalidate the boundaries */
gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (gimp_image_get_mask (image)));
g_object_unref (layer);
}
void
select_all_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *image;
return_if_no_image (image, data);
gimp_channel_all (gimp_image_get_mask (image), TRUE);
gimp_image_flush (image);
}
static GimpValueArray *
flip_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpDrawable *drawable;
gint32 flip_type;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
flip_type = g_value_get_enum (gimp_value_array_index (args, 1));
if (success)
{
gint x, y, width, height;
success = gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, TRUE, error);
if (success &&
gimp_item_mask_intersect (GIMP_ITEM (drawable), &x, &y, &width, &height))
{
gdouble axis;
gimp_transform_get_flip_axis (x, y, width, height,
flip_type, TRUE, &axis);
if (! gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) &&
! gimp_channel_is_empty (gimp_image_get_mask (gimp_item_get_image (GIMP_ITEM (drawable)))))
{
if (! gimp_drawable_transform_flip (drawable, context,
flip_type, axis, FALSE))
{
success = FALSE;
}
}
else
{
gimp_item_flip (GIMP_ITEM (drawable), context,
flip_type, axis, FALSE);
}
}
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
gimp_value_set_drawable (gimp_value_array_index (return_vals, 1), drawable);
return return_vals;
}
static void
gimp_undo_create_preview_private (GimpUndo *undo,
GimpContext *context)
{
GimpImage *image = undo->image;
GimpViewable *preview_viewable;
GimpViewSize preview_size;
gint width;
gint height;
switch (undo->undo_type)
{
case GIMP_UNDO_GROUP_IMAGE_QUICK_MASK:
case GIMP_UNDO_GROUP_MASK:
case GIMP_UNDO_MASK:
preview_viewable = GIMP_VIEWABLE (gimp_image_get_mask (image));
break;
default:
preview_viewable = GIMP_VIEWABLE (image);
break;
}
preview_size = image->gimp->config->undo_preview_size;
if (gimp_image_get_width (image) <= preview_size &&
gimp_image_get_height (image) <= preview_size)
{
width = gimp_image_get_width (image);
height = gimp_image_get_height (image);
}
else
{
if (gimp_image_get_width (image) > gimp_image_get_height (image))
{
width = preview_size;
height = MAX (1, (gimp_image_get_height (image) * preview_size /
gimp_image_get_width (image)));
}
else
{
height = preview_size;
width = MAX (1, (gimp_image_get_width (image) * preview_size /
gimp_image_get_height (image)));
}
}
undo->preview = gimp_viewable_get_new_preview (preview_viewable, context,
width, height);
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (undo));
}
static GimpBuffer *
gimp_edit_extract (GimpImage *image,
GimpPickable *pickable,
GimpContext *context,
gboolean cut_pixels,
GError **error)
{
GeglBuffer *buffer;
gint offset_x;
gint offset_y;
if (cut_pixels)
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_CUT,
C_("undo-type", "Cut"));
/* Cut/copy the mask portion from the image */
buffer = gimp_selection_extract (GIMP_SELECTION (gimp_image_get_mask (image)),
pickable, context,
cut_pixels, FALSE,
&offset_x, &offset_y, error);
if (cut_pixels)
gimp_image_undo_group_end (image);
if (buffer)
{
GimpBuffer *gimp_buffer;
gdouble res_x;
gdouble res_y;
gimp_buffer = gimp_buffer_new (buffer, _("Global Buffer"),
offset_x, offset_y, FALSE);
g_object_unref (buffer);
gimp_image_get_resolution (image, &res_x, &res_y);
gimp_buffer_set_resolution (gimp_buffer, res_x, res_y);
gimp_buffer_set_unit (gimp_buffer, gimp_image_get_unit (image));
if (GIMP_IS_COLOR_MANAGED (pickable))
{
GimpColorProfile *profile =
gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (pickable));
if (profile)
gimp_buffer_set_color_profile (gimp_buffer, profile);
}
return gimp_buffer;
}
return NULL;
}
static GimpValueArray *
image_select_contiguous_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
gint32 operation;
GimpDrawable *drawable;
gdouble x;
gdouble y;
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);
x = g_value_get_double (gimp_value_array_index (args, 3));
y = g_value_get_double (gimp_value_array_index (args, 4));
if (success)
{
GimpPDBContext *pdb_context = GIMP_PDB_CONTEXT (context);
if (pdb_context->sample_merged ||
gimp_pdb_item_is_attached (GIMP_ITEM (drawable), image, 0, error))
{
gimp_channel_select_fuzzy (gimp_image_get_mask (image),
drawable,
pdb_context->sample_merged,
x, y,
pdb_context->sample_threshold,
pdb_context->sample_transparent,
pdb_context->sample_criterion,
pdb_context->diagonal_neighbors,
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);
}
GimpObject *
gimp_edit_cut (GimpImage *image,
GimpDrawable *drawable,
GimpContext *context,
GError **error)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
if (GIMP_IS_LAYER (drawable) &&
gimp_channel_is_empty (gimp_image_get_mask (image)))
{
GimpImage *clip_image;
clip_image = gimp_image_new_from_drawable (image->gimp, drawable);
gimp_container_remove (image->gimp->images, GIMP_OBJECT (clip_image));
gimp_set_clipboard_image (image->gimp, clip_image);
g_object_unref (clip_image);
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_CUT,
C_("undo-type", "Cut Layer"));
gimp_image_remove_layer (image, GIMP_LAYER (drawable),
TRUE, NULL);
gimp_image_undo_group_end (image);
return GIMP_OBJECT (gimp_get_clipboard_image (image->gimp));
}
else
{
GimpBuffer *buffer;
buffer = gimp_edit_extract (image, GIMP_PICKABLE (drawable),
context, TRUE, error);
if (buffer)
{
gimp_set_clipboard_buffer (image->gimp, buffer);
g_object_unref (buffer);
return GIMP_OBJECT (gimp_get_clipboard_buffer (image->gimp));
}
}
return NULL;
}
void
floating_sel_anchor (GimpLayer *layer)
{
GimpImage *image;
GimpDrawable *drawable;
g_return_if_fail (GIMP_IS_LAYER (layer));
g_return_if_fail (gimp_layer_is_floating_sel (layer));
image = gimp_item_get_image (GIMP_ITEM (layer));
if (! gimp_layer_is_floating_sel (layer))
{
gimp_message (image->gimp, NULL, GIMP_MESSAGE_WARNING,
_("Cannot anchor this layer because "
"it is not a floating selection."));
return;
}
/* Start a floating selection anchoring undo */
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_ANCHOR,
_("Anchor Floating Selection"));
/* Invalidate the previews of the layer that will be composited
* with the floating section.
*/
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (layer->fs.drawable));
/* Relax the floating selection */
floating_sel_relax (layer, TRUE);
/* Composite the floating selection contents */
floating_sel_composite (layer,
GIMP_ITEM (layer)->offset_x,
GIMP_ITEM (layer)->offset_y,
GIMP_ITEM (layer)->width,
GIMP_ITEM (layer)->height, TRUE);
drawable = layer->fs.drawable;
/* remove the floating selection */
gimp_image_remove_layer (image, layer);
/* end the group undo */
gimp_image_undo_group_end (image);
/* invalidate the boundaries */
gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (gimp_image_get_mask (image)));
}
static gboolean
gimp_drawable_edit_can_fill_direct (GimpDrawable *drawable,
GimpFillOptions *options)
{
GimpImage *image;
GimpContext *context;
gdouble opacity;
GimpComponentMask affect;
GimpLayerMode mode;
GimpLayerCompositeMode composite_mode;
GimpLayerCompositeRegion composite_region;
image = gimp_item_get_image (GIMP_ITEM (drawable));
context = GIMP_CONTEXT (options);
opacity = gimp_context_get_opacity (context);
affect = gimp_drawable_get_active_mask (drawable);
mode = gimp_context_get_paint_mode (context);
composite_mode = gimp_layer_mode_get_paint_composite_mode (mode);
composite_region = gimp_layer_mode_get_included_region (mode, composite_mode);
if (gimp_channel_is_empty (gimp_image_get_mask (image)) &&
opacity == GIMP_OPACITY_OPAQUE &&
affect == GIMP_COMPONENT_MASK_ALL &&
gimp_layer_mode_is_trivial (mode) &&
(! gimp_layer_mode_is_subtractive (mode) ^
! (composite_region & GIMP_LAYER_COMPOSITE_REGION_SOURCE)))
{
switch (gimp_fill_options_get_style (options))
{
case GIMP_FILL_STYLE_SOLID:
return TRUE;
case GIMP_FILL_STYLE_PATTERN:
{
GimpPattern *pattern;
GimpTempBuf *mask;
const Babl *format;
pattern = gimp_context_get_pattern (context);
mask = gimp_pattern_get_mask (pattern);
format = gimp_temp_buf_get_format (mask);
return ! babl_format_has_alpha (format);
}
}
}
return FALSE;
}
void
gimp_image_resize_to_selection (GimpImage *image,
GimpContext *context,
GimpProgress *progress)
{
GimpChannel *selection = gimp_image_get_mask (image);
gint x, y, w, h;
if (gimp_item_bounds (GIMP_ITEM (selection), &x, &y, &w, &h))
{
gimp_image_resize (image, context,
w, h, -x, -y,
progress);
}
}
void
select_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *image = action_data_get_image (data);
GimpDrawable *drawable = NULL;
gboolean fs = FALSE;
gboolean sel = FALSE;
gboolean writable = FALSE;
gboolean children = FALSE;
if (image)
{
drawable = gimp_image_get_active_drawable (image);
if (drawable)
{
writable = ! gimp_item_is_content_locked (GIMP_ITEM (drawable));
if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
children = TRUE;
}
fs = (gimp_image_get_floating_selection (image) != NULL);
sel = ! gimp_channel_is_empty (gimp_image_get_mask (image));
}
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
SET_SENSITIVE ("select-all", drawable);
SET_SENSITIVE ("select-none", drawable && sel);
SET_SENSITIVE ("select-invert", drawable);
SET_SENSITIVE ("select-float", writable && !children && sel);
SET_SENSITIVE ("select-feather", drawable && sel);
SET_SENSITIVE ("select-sharpen", drawable && sel);
SET_SENSITIVE ("select-shrink", drawable && sel);
SET_SENSITIVE ("select-grow", drawable && sel);
SET_SENSITIVE ("select-border", drawable && sel);
SET_SENSITIVE ("select-flood", drawable && sel);
SET_SENSITIVE ("select-save", drawable && !fs);
SET_SENSITIVE ("select-stroke", writable && !children && sel);
SET_SENSITIVE ("select-stroke-last-values", writable && !children && sel);
#undef SET_SENSITIVE
}
void
select_save_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *image;
GtkWidget *widget;
return_if_no_image (image, data);
return_if_no_widget (widget, data);
gimp_selection_save (gimp_image_get_mask (image));
gimp_image_flush (image);
gimp_dialog_factory_dialog_raise (global_dock_factory,
gtk_widget_get_screen (widget),
"gimp-channel-list", -1);
}
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);
}
void
select_stroke_last_vals_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *image;
GimpDrawable *drawable;
GimpContext *context;
GtkWidget *widget;
GimpStrokeOptions *options;
GError *error = NULL;
return_if_no_image (image, data);
return_if_no_context (context, data);
return_if_no_widget (widget, data);
drawable = gimp_image_get_active_drawable (image);
if (! drawable)
{
gimp_message_literal (image->gimp,
G_OBJECT (widget), GIMP_MESSAGE_WARNING,
_("There is no active layer or channel to stroke to."));
return;
}
options = g_object_get_data (G_OBJECT (image->gimp), "saved-stroke-options");
if (options)
g_object_ref (options);
else
options = gimp_stroke_options_new (image->gimp, context, TRUE);
if (! gimp_item_stroke (GIMP_ITEM (gimp_image_get_mask (image)),
drawable, context, options, NULL,
TRUE, NULL, &error))
{
gimp_message_literal (image->gimp,
G_OBJECT (widget), GIMP_MESSAGE_WARNING,
error->message);
g_clear_error (&error);
}
else
{
gimp_image_flush (image);
}
g_object_unref (options);
}
