void
edit_fill_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpImage *image;
GimpDrawable *drawable;
GimpFillType fill_type;
GimpFillOptions *options;
GError *error = NULL;
return_if_no_drawable (image, drawable, data);
fill_type = (GimpFillType) value;
options = gimp_fill_options_new (action_data_get_gimp (data), NULL, FALSE);
if (gimp_fill_options_set_by_fill_type (options,
action_data_get_context (data),
fill_type, &error))
{
gimp_edit_fill (image, drawable, options, NULL);
gimp_image_flush (image);
}
else
{
gimp_message_literal (image->gimp, NULL, GIMP_MESSAGE_WARNING,
error->message);
g_clear_error (&error);
}
g_object_unref (options);
}
void
gimp_edit_clear (GimpImage *image,
GimpDrawable *drawable,
GimpContext *context)
{
GimpFillOptions *options;
g_return_if_fail (GIMP_IS_IMAGE (image));
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));
g_return_if_fail (GIMP_IS_CONTEXT (context));
options = gimp_fill_options_new (context->gimp);
if (gimp_drawable_has_alpha (drawable))
gimp_fill_options_set_by_fill_type (options, context,
GIMP_FILL_TRANSPARENT, NULL);
else
gimp_fill_options_set_by_fill_type (options, context,
GIMP_FILL_BACKGROUND, NULL);
gimp_edit_fill (image, drawable, options, C_("undo-type", "Clear"));
g_object_unref (options);
}
void
edit_fill_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpImage *image;
GimpDrawable *drawable;
GimpFillType fill_type;
GError *error = NULL;
return_if_no_drawable (image, drawable, data);
fill_type = (GimpFillType) value;
if (gimp_edit_fill (image, drawable, action_data_get_context (data),
fill_type, GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE,
&error))
{
gimp_image_flush (image);
}
else
{
gimp_message_literal (image->gimp, NULL, GIMP_MESSAGE_WARNING,
error->message);
g_clear_error (&error);
}
}
static void
gimp_display_shell_dnd_fill (GimpDisplayShell *shell,
GimpFillOptions *options,
const gchar *undo_desc)
{
GimpImage *image = gimp_display_get_image (shell->display);
GimpDrawable *drawable;
if (shell->display->gimp->busy)
return;
if (! image)
return;
drawable = gimp_image_get_active_drawable (image);
if (! drawable)
return;
if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
{
gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display),
GIMP_MESSAGE_ERROR,
_("Cannot modify the pixels of layer groups."));
return;
}
if (gimp_item_is_content_locked (GIMP_ITEM (drawable)))
{
gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display),
GIMP_MESSAGE_ERROR,
_("The active layer's pixels are locked."));
return;
}
/* FIXME: there should be a virtual method for this that the
* GimpTextLayer can override.
*/
if (gimp_fill_options_get_style (options) == GIMP_FILL_STYLE_SOLID &&
gimp_item_is_text_layer (GIMP_ITEM (drawable)))
{
GimpRGB color;
gimp_context_get_foreground (GIMP_CONTEXT (options), &color);
gimp_text_layer_set (GIMP_TEXT_LAYER (drawable), NULL,
"color", &color,
NULL);
}
else
{
gimp_edit_fill (image, drawable, options, undo_desc);
}
gimp_display_shell_dnd_flush (shell, image);
}
static void modos (GimpDrawable *drawable ,gint image)
{
gint width, height;
// getting the image size
width = gimp_image_width(image);
height = gimp_image_height(image);
// filling in the various parameters of rect_select which is image, x-cord, y-cord, width, height, Operation, feather, feather_radius
gimp_rect_select(image, 0, 0, width, height, 0, 0, 0);
// filling the various parameters of ellipse_select which is image, x-cord, y-cord (in this thickness of the frame), adjusted width and height with regards to thickness, SUBTRACT operation, Making the pic clear, feather, feather-radius
gimp_ellipse_select (image, vals.xcord,vals.ycord, width - (2*vals.xcord), height - (2*vals.ycord), 1, TRUE, vals.xcord/4, vals.ycord/8);
//Two parameters: drawable id, and fill type. (0-Foreground, 1-Background, 2-Whitefill, 3-Transparentfill, 4-Patterfill)
gimp_edit_fill (drawable->drawable_id, vals.framecolor);
}
void
edit_fill_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpImage *image;
GimpDrawable *drawable;
GimpFillType fill_type;
return_if_no_drawable (image, drawable, data);
fill_type = (GimpFillType) value;
gimp_edit_fill (image, drawable, action_data_get_context (data),
fill_type, GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
gimp_image_flush (image);
}
static void
gimp_bucket_fill_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpBucketFillOptions *options = GIMP_BUCKET_FILL_TOOL_GET_OPTIONS (tool);
GimpImage *image = gimp_display_get_image (display);
if ((release_type == GIMP_BUTTON_RELEASE_CLICK ||
release_type == GIMP_BUTTON_RELEASE_NO_MOTION) &&
gimp_image_coords_in_active_pickable (image, coords,
options->sample_merged, TRUE))
{
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpContext *context = GIMP_CONTEXT (options);
gint x, y;
x = coords->x;
y = coords->y;
if (! options->sample_merged)
{
gint off_x, off_y;
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
x -= off_x;
y -= off_y;
}
if (options->fill_selection)
{
GimpFillType fill_type;
switch (options->fill_mode)
{
default:
case GIMP_BUCKET_FILL_FG:
fill_type = GIMP_FOREGROUND_FILL;
break;
case GIMP_BUCKET_FILL_BG:
fill_type = GIMP_BACKGROUND_FILL;
break;
case GIMP_BUCKET_FILL_PATTERN:
fill_type = GIMP_PATTERN_FILL;
break;
}
gimp_edit_fill (image, drawable, context, fill_type,
gimp_context_get_opacity (context),
gimp_context_get_paint_mode (context));
gimp_image_flush (image);
}
else
{
GError *error = NULL;
if (! gimp_drawable_bucket_fill (drawable,
context,
options->fill_mode,
gimp_context_get_paint_mode (context),
gimp_context_get_opacity (context),
options->fill_transparent,
options->fill_criterion,
options->threshold / 255.0,
options->sample_merged,
x, y, &error))
{
gimp_message_literal (display->gimp, G_OBJECT (display),
GIMP_MESSAGE_WARNING, error->message);
g_clear_error (&error);
}
else
{
gimp_image_flush (image);
}
}
}
GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state,
release_type, display);
tool->display = NULL;
tool->drawable = NULL;
}
static void
border (gint32 image_ID)
{
GdkPixbuf *pixbuf = NULL;
int texture_width;
int texture_height;
gdouble margin_x;
gdouble margin_y;
pixbuf = gdk_pixbuf_new_from_inline (-1, bvals.border->texture, FALSE, NULL);
if (pixbuf)
{
texture_width = gdk_pixbuf_get_width (pixbuf);
texture_height = gdk_pixbuf_get_height (pixbuf);
gint32 texture_image = gimp_image_new (texture_width, texture_height, GIMP_RGB);
gint32 texture_layer = gimp_layer_new_from_pixbuf (texture_image, "texture", pixbuf, 100, GIMP_NORMAL_MODE, 0, 0);
gimp_image_add_layer (texture_image, texture_layer, -1);
gint width = gimp_image_width (image_ID);
gint height = gimp_image_height (image_ID);
if (bvals.border->top || bvals.border->bottom || bvals.border->left || bvals.border->right)
{
width += bvals.border->left + bvals.border->right;
height += bvals.border->top + bvals.border->bottom;
gimp_image_resize (image_ID,
width,
height,
bvals.border->left,
bvals.border->top);
}
gint32 layer = gimp_layer_new (image_ID, "border",
width, height,
GIMP_RGBA_IMAGE,
100,
GIMP_NORMAL_MODE);
gimp_image_add_layer (image_ID, layer, -1);
if (width > texture_width - bvals.border->length)
margin_x = (texture_width - bvals.border->length) / 2;
else
margin_x = (gdouble) width / 2;
if (height > texture_height - bvals.border->length)
margin_y = (texture_height - bvals.border->length) / 2;
else
margin_y = (gdouble) height / 2;
/* fix gimp_context_set_pattern ("Clipboard") only works on English versions of Gimp */
//gimp_context_set_pattern ("Clipboard");
INIT_I18N ();
gimp_context_set_pattern (_("Clipboard"));
if (width > margin_x * 2) {
/* top */
gimp_rect_select (texture_image,
margin_x,
0,
texture_width - margin_x * 2,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
margin_x,
0,
width - margin_x * 2,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
/* bottom */
gimp_rect_select (texture_image,
margin_x,
texture_height - margin_y,
texture_width - margin_x * 2,
texture_height,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
margin_x,
height - margin_y,
width - margin_x * 2,
height,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
}
if (height > margin_y * 2) {
/* left */
gimp_rect_select (texture_image,
0,
margin_y,
margin_x,
texture_height - margin_y * 2,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
0,
margin_y,
margin_x,
height - margin_y * 2,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
/* right */
gimp_rect_select (texture_image,
texture_width - margin_x,
margin_y,
margin_x,
texture_height - margin_y * 2,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
width - margin_x,
margin_y,
margin_x,
height - margin_y * 2,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
}
/* top left */
gimp_rect_select (texture_image,
0,
0,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
0,
0,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
/* top right */
gimp_rect_select (texture_image,
texture_width - margin_x,
0,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
width - margin_x,
0,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
/* bottom left */
gimp_rect_select (texture_image,
0,
texture_height - margin_y,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
0,
height - margin_y,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
/* bottom right */
gimp_rect_select (texture_image,
texture_width - margin_x,
texture_height - margin_y,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_copy (texture_layer);
gimp_rect_select (image_ID,
width - margin_x,
height - margin_y,
margin_x,
margin_y,
GIMP_CHANNEL_OP_REPLACE, FALSE, 0);
gimp_edit_fill (layer, GIMP_PATTERN_FILL);
gimp_image_merge_down(image_ID, layer, GIMP_CLIP_TO_IMAGE);
gimp_selection_none (image_ID);
}
}
/* --------------------------------------------
* gap_fg_from_selection_exec_apply_run
* --------------------------------------------
* generate a tri map from the current selection by filling the shrinked
* shape with white, the expanded shape with black and the borderline
* between shrinked and expanded selection with medium gray.
* the trimap is attached as layermask to the input drawable,
* and used as input for the foreground selection via alpha matting algorithm,
* that creates a resulting layer with trimmed selection.
*
*/
gint
gap_fg_from_selection_exec_apply_run (gint32 image_id, gint32 drawable_id
, gboolean doProgress, gboolean doFlush
, GapFgSelectValues *fsValPtr)
{
GimpRGB color;
gint32 activeSelection;
gint32 shrinkedSelection;
gint32 trimap;
gboolean hadSelection;
gint rc;
rc = 0;
trimap = -1;
activeSelection = -1;
shrinkedSelection = -1;
hadSelection = FALSE;
gimp_context_push();
gimp_image_undo_group_start(image_id);
if (gimp_selection_is_empty(image_id) == TRUE)
{
if (gimp_drawable_has_alpha(drawable_id) == FALSE)
{
/* if the layer has no alpha select all */
gimp_selection_all(image_id);
}
else
{
gimp_selection_layer_alpha(drawable_id);
}
activeSelection = gimp_selection_save(image_id);
}
else
{
activeSelection = gimp_selection_save(image_id);
hadSelection = TRUE;
}
trimap = gimp_layer_get_mask(drawable_id);
if (trimap < 0)
{
/* create trimap as new layermask */
trimap = gimp_layer_create_mask(drawable_id, GIMP_ADD_BLACK_MASK);
gimp_layer_add_mask(drawable_id, trimap);
}
else
{
/* use BLACK color to fill the already existing layermask
* (note that gimp_drawable_fill is used to fill the entire mask
* regardless to the current selection)
*/
color.r = 0.0;
color.g = 0.0;
color.b = 0.0;
color.a = 1.0;
gimp_context_set_background (&color);
gimp_drawable_fill(trimap, GIMP_BACKGROUND_FILL);
}
gimp_selection_sharpen(image_id);
if (fsValPtr->innerRadius > 0)
{
gimp_selection_shrink(image_id, fsValPtr->innerRadius);
}
shrinkedSelection = gimp_selection_save(image_id);
/* use WHITE color to mark foreground regions
*/
color.r = 1.0;
color.g = 1.0;
color.b = 1.0;
color.a = 1.0;
gimp_context_set_background (&color);
gimp_edit_fill(trimap, GIMP_BACKGROUND_FILL);
gimp_selection_load(activeSelection);
gimp_selection_sharpen(image_id);
if (fsValPtr->outerRadius > 0)
{
gimp_selection_grow(image_id, fsValPtr->outerRadius);
}
gimp_selection_combine(shrinkedSelection, GIMP_CHANNEL_OP_SUBTRACT);
/* use medium GRAY to mark undefined regions
*/
color.r = 0.5;
color.g = 0.5;
color.b = 0.5;
color.a = 1.0;
gimp_context_set_background (&color);
gimp_edit_fill(trimap, GIMP_BACKGROUND_FILL);
gimp_selection_none(image_id);
/* perform the foreground selection (that creates the resulting layer) */
{
GapFgExtractValues fgExtractValues;
GapFgExtractValues *fgValPtr;
fgValPtr = &fgExtractValues;
fgValPtr->input_drawable_id = drawable_id;
fgValPtr->tri_map_drawable_id = trimap;
fgValPtr->create_result = TRUE;
fgValPtr->create_layermask = fsValPtr->create_layermask;
fgValPtr->lock_color = fsValPtr->lock_color;
fgValPtr->colordiff_threshold = fsValPtr->colordiff_threshold;
rc = gap_fg_matting_exec_apply_run (image_id, drawable_id
, doProgress, doFlush
, fgValPtr
);
}
/* restore original selection */
if (hadSelection == TRUE)
{
gimp_selection_load(activeSelection);
}
gimp_image_undo_group_end(image_id);
gimp_context_pop();
return (rc);
} /* end gap_fg_from_selection_exec_apply_run */
