void
view_use_gegl_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *image;
GimpDisplayShell *shell;
GList *layers;
GList *list;
gboolean active;
return_if_no_image (image, data);
return_if_no_shell (shell, data);
active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
gimp_image_get_projection (image)->use_gegl = active;
layers = gimp_image_get_layer_list (image);
for (list = layers; list; list = g_list_next (list))
{
GimpLayer *layer = list->data;
if (GIMP_IS_GROUP_LAYER (layer))
gimp_group_layer_get_projection (GIMP_GROUP_LAYER (layer))->use_gegl = active;
}
g_list_free (layers);
gimp_image_invalidate (image, 0, 0,
gimp_image_get_width (image),
gimp_image_get_height (image));
gimp_image_flush (image);
}
static void
gimp_cage_tool_image_map_flush (GimpImageMap *image_map,
GimpTool *tool)
{
GimpImage *image = gimp_display_get_image (tool->display);
gimp_projection_flush (gimp_image_get_projection (image));
}
static void
gimp_seamless_clone_tool_filter_flush (GimpDrawableFilter *filter,
GimpTool *tool)
{
GimpImage *image = gimp_display_get_image (tool->display);
gimp_projection_flush (gimp_image_get_projection (image));
}
static void
gimp_sample_point_editor_set_image (GimpImageEditor *image_editor,
GimpImage *image)
{
GimpSamplePointEditor *editor = GIMP_SAMPLE_POINT_EDITOR (image_editor);
if (image_editor->image)
{
g_signal_handlers_disconnect_by_func (image_editor->image,
gimp_sample_point_editor_point_added,
editor);
g_signal_handlers_disconnect_by_func (image_editor->image,
gimp_sample_point_editor_point_removed,
editor);
g_signal_handlers_disconnect_by_func (image_editor->image,
gimp_sample_point_editor_point_moved,
editor);
g_signal_handlers_disconnect_by_func (gimp_image_get_projection (image_editor->image),
gimp_sample_point_editor_proj_update,
editor);
}
GIMP_IMAGE_EDITOR_CLASS (parent_class)->set_image (image_editor, image);
if (image)
{
g_signal_connect (image, "sample-point-added",
G_CALLBACK (gimp_sample_point_editor_point_added),
editor);
g_signal_connect (image, "sample-point-removed",
G_CALLBACK (gimp_sample_point_editor_point_removed),
editor);
g_signal_connect (image, "sample-point-moved",
G_CALLBACK (gimp_sample_point_editor_point_moved),
editor);
g_signal_connect (gimp_image_get_projection (image), "update",
G_CALLBACK (gimp_sample_point_editor_proj_update),
editor);
}
gimp_sample_point_editor_points_changed (editor);
}
gboolean
gimp_image_pick_color (GimpImage *image,
GimpDrawable *drawable,
gint x,
gint y,
gboolean sample_merged,
gboolean sample_average,
gdouble average_radius,
const Babl **sample_format,
GimpRGB *color,
gint *color_index)
{
GimpPickable *pickable;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (drawable == NULL || GIMP_IS_DRAWABLE (drawable), FALSE);
g_return_val_if_fail (drawable == NULL ||
gimp_item_get_image (GIMP_ITEM (drawable)) == image,
FALSE);
if (! sample_merged)
{
if (! drawable)
drawable = gimp_image_get_active_drawable (image);
if (! drawable)
return FALSE;
}
if (sample_merged)
{
pickable = GIMP_PICKABLE (gimp_image_get_projection (image));
}
else
{
gint off_x, off_y;
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
x -= off_x;
y -= off_y;
pickable = GIMP_PICKABLE (drawable);
}
/* Do *not* call gimp_pickable_flush() here because it's too expensive
* to call it unconditionally each time e.g. the cursor view is updated.
* Instead, call gimp_pickable_flush() in the callers if needed.
*/
if (sample_format)
*sample_format = gimp_pickable_get_format (pickable);
return gimp_pickable_pick_color (pickable, x, y,
sample_average, average_radius,
color, color_index);
}
static void
gimp_image_map_tool_flush (GimpImageMap *image_map,
GimpImageMapTool *image_map_tool)
{
GimpTool *tool = GIMP_TOOL (image_map_tool);
GimpDisplay *display = tool->display;
gimp_projection_flush_now (gimp_image_get_projection (display->image));
gimp_display_flush_now (display);
}
static void
gimp_paint_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpPaintOptions *paint_options = GIMP_PAINT_TOOL_GET_OPTIONS (tool);
GimpPaintCore *core = paint_tool->core;
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpCoords curr_coords;
gint off_x, off_y;
GIMP_TOOL_CLASS (parent_class)->motion (tool, coords, time, state, display);
if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool)))
return;
curr_coords = *coords;
gimp_paint_core_smooth_coords (core, paint_options, &curr_coords);
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
curr_coords.x -= off_x;
curr_coords.y -= off_y;
/* don't paint while the Shift key is pressed for line drawing */
if (paint_tool->draw_line)
{
gimp_paint_core_set_current_coords (core, &curr_coords);
return;
}
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
gimp_paint_core_interpolate (core, drawable, paint_options,
&curr_coords, time);
gimp_projection_flush_now (gimp_image_get_projection (image));
gimp_display_flush_now (display);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_n_point_deformation_tool_apply_deformation (GimpNPointDeformationTool *npd_tool)
{
GimpTool *tool = GIMP_TOOL (npd_tool);
GimpNPointDeformationOptions *npd_options;
GeglBuffer *buffer;
GimpImage *image;
gint width, height, prev;
npd_options = GIMP_N_POINT_DEFORMATION_TOOL_GET_OPTIONS (npd_tool);
image = gimp_display_get_image (tool->display);
buffer = gimp_drawable_get_buffer (tool->drawable);
width = gegl_buffer_get_width (buffer);
height = gegl_buffer_get_height (buffer);
prev = npd_options->rigidity;
npd_options->rigidity = 0;
gimp_n_point_deformation_tool_set_options (npd_tool, npd_options);
npd_options->rigidity = prev;
gimp_drawable_push_undo (tool->drawable, _("N-Point Deformation"), NULL,
0, 0, width, height);
gimp_gegl_apply_operation (NULL, NULL, _("N-Point Deformation"),
npd_tool->npd_node,
gimp_drawable_get_buffer (tool->drawable),
NULL);
gimp_drawable_update (tool->drawable,
0, 0, width, height);
gimp_projection_flush (gimp_image_get_projection (image));
}
void
gimp_source_core_motion (GimpSourceCore *source_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
const GimpCoords *coords)
{
GimpPaintCore *paint_core = GIMP_PAINT_CORE (source_core);
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
GimpDynamics *dynamics = GIMP_BRUSH_CORE (paint_core)->dynamics;
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
GimpPickable *src_pickable = NULL;
GeglBuffer *src_buffer = NULL;
GeglRectangle src_rect;
gint src_offset_x;
gint src_offset_y;
GeglBuffer *paint_buffer;
gint paint_buffer_x;
gint paint_buffer_y;
gint paint_area_offset_x;
gint paint_area_offset_y;
gint paint_area_width;
gint paint_area_height;
gdouble fade_point;
gdouble opacity;
fade_point = gimp_paint_options_get_fade (paint_options, image,
paint_core->pixel_dist);
opacity = gimp_dynamics_get_linear_value (dynamics,
GIMP_DYNAMICS_OUTPUT_OPACITY,
coords,
paint_options,
fade_point);
if (opacity == 0.0)
return;
src_offset_x = source_core->offset_x;
src_offset_y = source_core->offset_y;
if (gimp_source_core_use_source (source_core, options))
{
src_pickable = GIMP_PICKABLE (source_core->src_drawable);
if (options->sample_merged)
{
GimpImage *src_image = gimp_pickable_get_image (src_pickable);
gint off_x, off_y;
src_pickable = GIMP_PICKABLE (gimp_image_get_projection (src_image));
gimp_item_get_offset (GIMP_ITEM (source_core->src_drawable),
&off_x, &off_y);
src_offset_x += off_x;
src_offset_y += off_y;
}
gimp_pickable_flush (src_pickable);
}
paint_buffer = gimp_paint_core_get_paint_buffer (paint_core, drawable,
paint_options, coords,
&paint_buffer_x,
&paint_buffer_y);
if (! paint_buffer)
return;
paint_area_offset_x = 0;
paint_area_offset_y = 0;
paint_area_width = gegl_buffer_get_width (paint_buffer);
paint_area_height = gegl_buffer_get_height (paint_buffer);
if (gimp_source_core_use_source (source_core, options))
{
src_buffer =
GIMP_SOURCE_CORE_GET_CLASS (source_core)->get_source (source_core,
drawable,
paint_options,
src_pickable,
src_offset_x,
src_offset_y,
paint_buffer,
paint_buffer_x,
paint_buffer_y,
&paint_area_offset_x,
&paint_area_offset_y,
&paint_area_width,
&paint_area_height,
&src_rect);
if (! src_buffer)
return;
}
/* Set the paint buffer to transparent */
gegl_buffer_clear (paint_buffer, NULL);
GIMP_SOURCE_CORE_GET_CLASS (source_core)->motion (source_core,
drawable,
paint_options,
coords,
opacity,
src_pickable,
src_buffer,
&src_rect,
src_offset_x,
src_offset_y,
paint_buffer,
paint_buffer_x,
paint_buffer_y,
paint_area_offset_x,
paint_area_offset_y,
paint_area_width,
paint_area_height);
if (src_buffer)
g_object_unref (src_buffer);
}
void
gimp_paint_core_paste (GimpPaintCore *core,
PixelRegion *paint_maskPR,
GimpDrawable *drawable,
gdouble paint_opacity,
gdouble image_opacity,
GimpLayerModeEffects paint_mode,
GimpPaintApplicationMode mode)
{
TileManager *alt = NULL;
PixelRegion srcPR;
/* set undo blocks */
gimp_paint_core_validate_undo_tiles (core, drawable,
core->canvas_buf->x,
core->canvas_buf->y,
core->canvas_buf->width,
core->canvas_buf->height);
if (core->use_saved_proj)
{
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
GimpProjection *projection = gimp_image_get_projection (image);
gint off_x;
gint off_y;
gint x, y;
gint w, h;
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
if (gimp_rectangle_intersect (core->canvas_buf->x + off_x,
core->canvas_buf->y + off_y,
core->canvas_buf->width,
core->canvas_buf->height,
0, 0,
tile_manager_width (core->saved_proj_tiles),
tile_manager_height (core->saved_proj_tiles),
&x, &y, &w, &h))
{
gimp_paint_core_validate_saved_proj_tiles (core,
GIMP_PICKABLE (projection),
x, y, w, h);
}
}
/* If the mode is CONSTANT:
* combine the canvas buf, the paint mask to the canvas tiles
*/
if (mode == GIMP_PAINT_CONSTANT)
{
/* Some tools (ink) paint the mask to paint_core->canvas_tiles
* directly. Don't need to copy it in this case.
*/
if (paint_maskPR->tiles != core->canvas_tiles)
{
/* initialize any invalid canvas tiles */
gimp_paint_core_validate_canvas_tiles (core,
core->canvas_buf->x,
core->canvas_buf->y,
core->canvas_buf->width,
core->canvas_buf->height);
paint_mask_to_canvas_tiles (core, paint_maskPR, paint_opacity);
}
canvas_tiles_to_canvas_buf (core);
alt = core->undo_tiles;
}
/* Otherwise:
* combine the canvas buf and the paint mask to the canvas buf
*/
else
{
paint_mask_to_canvas_buf (core, paint_maskPR, paint_opacity);
}
/* intialize canvas buf source pixel regions */
pixel_region_init_temp_buf (&srcPR, core->canvas_buf,
0, 0,
core->canvas_buf->width,
core->canvas_buf->height);
/* apply the paint area to the image */
gimp_drawable_apply_region (drawable, &srcPR,
FALSE, NULL,
image_opacity, paint_mode,
alt, /* specify an alternative src1 */
NULL,
core->canvas_buf->x,
core->canvas_buf->y);
/* Update the undo extents */
core->x1 = MIN (core->x1, core->canvas_buf->x);
core->y1 = MIN (core->y1, core->canvas_buf->y);
core->x2 = MAX (core->x2, core->canvas_buf->x + core->canvas_buf->width);
core->y2 = MAX (core->y2, core->canvas_buf->y + core->canvas_buf->height);
/* Update the drawable */
gimp_drawable_update (drawable,
core->canvas_buf->x,
core->canvas_buf->y,
core->canvas_buf->width,
core->canvas_buf->height);
}
gboolean
gimp_paint_core_start (GimpPaintCore *core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
const GimpCoords *coords,
GError **error)
{
GimpImage *image;
GimpItem *item;
GimpChannel *mask;
g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), FALSE);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE);
g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), FALSE);
g_return_val_if_fail (coords != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
item = GIMP_ITEM (drawable);
image = gimp_item_get_image (item);
if (core->stroke_buffer)
{
g_array_free (core->stroke_buffer, TRUE);
core->stroke_buffer = NULL;
}
core->stroke_buffer = g_array_sized_new (TRUE, TRUE,
sizeof (GimpCoords),
STROKE_BUFFER_INIT_SIZE);
/* remember the last stroke's endpoint for later undo */
core->start_coords = core->last_coords;
core->cur_coords = *coords;
if (! GIMP_PAINT_CORE_GET_CLASS (core)->start (core, drawable,
paint_options,
coords, error))
{
return FALSE;
}
/* Allocate the undo structure */
if (core->undo_buffer)
g_object_unref (core->undo_buffer);
core->undo_buffer = gegl_buffer_dup (gimp_drawable_get_buffer (drawable));
/* Allocate the saved proj structure */
if (core->saved_proj_buffer)
{
g_object_unref (core->saved_proj_buffer);
core->saved_proj_buffer = NULL;
}
if (core->use_saved_proj)
{
GimpPickable *pickable = GIMP_PICKABLE (gimp_image_get_projection (image));
GeglBuffer *buffer = gimp_pickable_get_buffer (pickable);
core->saved_proj_buffer = gegl_buffer_dup (buffer);
}
/* Allocate the canvas blocks structure */
if (core->canvas_buffer)
g_object_unref (core->canvas_buffer);
core->canvas_buffer =
gegl_buffer_new (GEGL_RECTANGLE (0, 0,
gimp_item_get_width (item),
gimp_item_get_height (item)),
babl_format ("Y float"));
/* Get the initial undo extents */
core->x1 = core->x2 = core->cur_coords.x;
core->y1 = core->y2 = core->cur_coords.y;
core->last_paint.x = -1e6;
core->last_paint.y = -1e6;
mask = gimp_image_get_mask (image);
/* don't apply the mask to itself and don't apply an empty mask */
if (GIMP_DRAWABLE (mask) != drawable && ! gimp_channel_is_empty (mask))
{
GeglBuffer *mask_buffer;
gint offset_x;
gint offset_y;
mask_buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask));
gimp_item_get_offset (item, &offset_x, &offset_y);
core->mask_buffer = g_object_ref (mask_buffer);
core->mask_x_offset = -offset_x;
core->mask_y_offset = -offset_y;
}
else
{
core->mask_buffer = NULL;
}
core->linear_mode = gimp_drawable_get_linear (drawable);
if (paint_options->use_applicator)
{
core->applicator = gimp_applicator_new (NULL, core->linear_mode);
if (core->mask_buffer)
{
gimp_applicator_set_mask_buffer (core->applicator,
core->mask_buffer);
gimp_applicator_set_mask_offset (core->applicator,
core->mask_x_offset,
core->mask_y_offset);
}
gimp_applicator_set_affect (core->applicator,
gimp_drawable_get_active_mask (drawable));
gimp_applicator_set_dest_buffer (core->applicator,
gimp_drawable_get_buffer (drawable));
}
else
{
if (core->comp_buffer)
{
g_object_unref (core->comp_buffer);
core->comp_buffer = NULL;
}
/* Allocate the scratch buffer if there's a component mask */
if (gimp_drawable_get_active_mask (drawable) != GIMP_COMPONENT_ALL)
{
const Babl *format;
if (core->linear_mode)
format = babl_format ("RGBA float");
else
format = babl_format ("R'G'B'A float");
core->comp_buffer =
gegl_buffer_new (GEGL_RECTANGLE (0, 0,
gimp_item_get_width (item),
gimp_item_get_height (item)),
format);
}
}
/* Freeze the drawable preview so that it isn't constantly updated. */
gimp_viewable_preview_freeze (GIMP_VIEWABLE (drawable));
return TRUE;
}
GeglBuffer *
gimp_image_contiguous_region_by_color (GimpImage *image,
GimpDrawable *drawable,
gboolean sample_merged,
gboolean antialias,
gfloat threshold,
gboolean select_transparent,
GimpSelectCriterion select_criterion,
const GimpRGB *color)
{
/* Scan over the image's active layer, finding pixels within the
* specified threshold from the given R, G, & B values. If
* antialiasing is on, use the same antialiasing scheme as in
* fuzzy_select. Modify the image's mask to reflect the
* additional selection
*/
GeglBufferIterator *iter;
GimpPickable *pickable;
GeglBuffer *src_buffer;
GeglBuffer *mask_buffer;
const Babl *format;
gint n_components;
gboolean has_alpha;
gfloat start_col[MAX_CHANNELS];
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 (color != NULL, NULL);
if (sample_merged)
pickable = GIMP_PICKABLE (gimp_image_get_projection (image));
else
pickable = GIMP_PICKABLE (drawable);
gimp_pickable_flush (pickable);
src_buffer = gimp_pickable_get_buffer (pickable);
format = choose_format (src_buffer, select_criterion,
&n_components, &has_alpha);
gimp_rgba_get_pixel (color, format, start_col);
if (has_alpha)
{
if (select_transparent)
{
/* don't select transparancy if "color" isn't fully transparent
*/
if (start_col[n_components - 1] > 0.0)
select_transparent = FALSE;
}
}
else
{
select_transparent = FALSE;
}
mask_buffer = gegl_buffer_new (gegl_buffer_get_extent (src_buffer),
babl_format ("Y float"));
iter = gegl_buffer_iterator_new (src_buffer,
NULL, 0, format,
GEGL_BUFFER_READ, GEGL_ABYSS_NONE);
gegl_buffer_iterator_add (iter, mask_buffer,
NULL, 0, babl_format ("Y float"),
GEGL_BUFFER_WRITE, GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (iter))
{
const gfloat *src = iter->data[0];
gfloat *dest = iter->data[1];
while (iter->length--)
{
/* Find how closely the colors match */
*dest = pixel_difference (start_col, src,
antialias,
threshold,
n_components,
has_alpha,
select_transparent,
select_criterion);
src += n_components;
dest += 1;
}
}
return mask_buffer;
}
gboolean
gimp_image_crop_auto_shrink (GimpImage *image,
gint x1,
gint y1,
gint x2,
gint y2,
gboolean active_drawable_only,
gint *shrunk_x1,
gint *shrunk_y1,
gint *shrunk_x2,
gint *shrunk_y2)
{
GimpDrawable *active_drawable = NULL;
GimpPickable *pickable;
ColorsEqualFunc colors_equal_func;
guchar bgcolor[MAX_CHANNELS] = { 0, 0, 0, 0 };
gboolean has_alpha;
PixelRegion PR;
guchar *buffer = NULL;
gint width, height;
GimpImageType type;
gint bytes;
gint x, y, abort;
gboolean retval = FALSE;
g_return_val_if_fail (image != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (shrunk_x1 != NULL, FALSE);
g_return_val_if_fail (shrunk_y1 != NULL, FALSE);
g_return_val_if_fail (shrunk_x2 != NULL, FALSE);
g_return_val_if_fail (shrunk_y2 != NULL, FALSE);
gimp_set_busy (image->gimp);
/* You should always keep in mind that crop->tx2 and crop->ty2 are
the NOT the coordinates of the bottomright corner of the area to
be cropped. They point at the pixel located one to the right and
one to the bottom.
*/
if (active_drawable_only)
{
active_drawable = gimp_image_get_active_drawable (image);
if (! active_drawable)
goto FINISH;
pickable = GIMP_PICKABLE (active_drawable);
}
else
{
pickable = GIMP_PICKABLE (gimp_image_get_projection (image));
}
gimp_pickable_flush (pickable);
type = gimp_pickable_get_image_type (pickable);
bytes = GIMP_IMAGE_TYPE_BYTES (type);
has_alpha = GIMP_IMAGE_TYPE_HAS_ALPHA (type);
switch (gimp_image_crop_guess_bgcolor (pickable,
bytes, has_alpha, bgcolor,
x1, x2-1, y1, y2-1))
{
case AUTO_CROP_ALPHA:
colors_equal_func = (ColorsEqualFunc) gimp_image_crop_colors_alpha;
break;
case AUTO_CROP_COLOR:
colors_equal_func = (ColorsEqualFunc) gimp_image_crop_colors_equal;
break;
default:
goto FINISH;
break;
}
width = x2 - x1;
height = y2 - y1;
pixel_region_init (&PR, gimp_pickable_get_tiles (pickable),
x1, y1, width, height, FALSE);
/* The following could be optimized further by processing
* the smaller side first instead of defaulting to width --Sven
*/
buffer = g_malloc ((width > height ? width : height) * bytes);
/* Check how many of the top lines are uniform/transparent. */
abort = FALSE;
for (y = y1; y < y2 && !abort; y++)
{
pixel_region_get_row (&PR, x1, y, width, buffer, 1);
for (x = 0; x < width && !abort; x++)
abort = !(colors_equal_func) (bgcolor, buffer + x * bytes, bytes);
}
if (y == y2 && !abort)
goto FINISH;
y1 = y - 1;
/* Check how many of the bottom lines are uniform/transparent. */
abort = FALSE;
for (y = y2; y > y1 && !abort; y--)
{
pixel_region_get_row (&PR, x1, y-1 , width, buffer, 1);
for (x = 0; x < width && !abort; x++)
abort = !(colors_equal_func) (bgcolor, buffer + x * bytes, bytes);
}
y2 = y + 1;
/* compute a new height for the next operations */
height = y2 - y1;
/* Check how many of the left lines are uniform/transparent. */
abort = FALSE;
for (x = x1; x < x2 && !abort; x++)
{
pixel_region_get_col (&PR, x, y1, height, buffer, 1);
for (y = 0; y < height && !abort; y++)
abort = !(colors_equal_func) (bgcolor, buffer + y * bytes, bytes);
}
x1 = x - 1;
/* Check how many of the right lines are uniform/transparent. */
abort = FALSE;
for (x = x2; x > x1 && !abort; x--)
{
pixel_region_get_col (&PR, x-1, y1, height, buffer, 1);
for (y = 0; y < height && !abort; y++)
abort = !(colors_equal_func) (bgcolor, buffer + y * bytes, bytes);
}
x2 = x + 1;
*shrunk_x1 = x1;
*shrunk_y1 = y1;
*shrunk_x2 = x2;
*shrunk_y2 = y2;
retval = TRUE;
FINISH:
g_free (buffer);
gimp_unset_busy (image->gimp);
return retval;
}
GeglBuffer *
gimp_image_contiguous_region_by_seed (GimpImage *image,
GimpDrawable *drawable,
gboolean sample_merged,
gboolean antialias,
gfloat threshold,
gboolean select_transparent,
GimpSelectCriterion select_criterion,
gint x,
gint y)
{
GimpPickable *pickable;
GeglBuffer *src_buffer;
GeglBuffer *mask_buffer;
const Babl *format;
gint n_components;
gboolean has_alpha;
gfloat start_col[MAX_CHANNELS];
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
if (sample_merged)
pickable = GIMP_PICKABLE (gimp_image_get_projection (image));
else
pickable = GIMP_PICKABLE (drawable);
gimp_pickable_flush (pickable);
src_buffer = gimp_pickable_get_buffer (pickable);
format = choose_format (src_buffer, select_criterion,
&n_components, &has_alpha);
gegl_buffer_sample (src_buffer, x, y, NULL, start_col, format,
GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
if (has_alpha)
{
if (select_transparent)
{
/* don't select transparent regions if the start pixel isn't
* fully transparent
*/
if (start_col[n_components - 1] > 0)
select_transparent = FALSE;
}
}
else
{
select_transparent = FALSE;
}
mask_buffer = gegl_buffer_new (gegl_buffer_get_extent (src_buffer),
babl_format ("Y float"));
find_contiguous_region_helper (src_buffer, mask_buffer,
format, n_components, has_alpha,
select_transparent, select_criterion,
antialias, threshold,
x, y, start_col);
return mask_buffer;
}
void
view_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpDisplay *display = action_data_get_display (data);
GimpImage *image = NULL;
GimpDisplayShell *shell = NULL;
GimpDisplayOptions *options = NULL;
gchar *label = NULL;
gboolean fullscreen = FALSE;
gboolean revert_enabled = FALSE; /* able to revert zoom? */
gboolean use_gegl = FALSE;
if (display)
{
GimpImageWindow *window;
image = gimp_display_get_image (display);
shell = gimp_display_get_shell (display);
window = gimp_display_shell_get_window (shell);
if (window)
fullscreen = gimp_image_window_get_fullscreen (window);
options = (image ?
(fullscreen ? shell->fullscreen_options : shell->options) :
shell->no_image_options);
revert_enabled = gimp_display_shell_scale_can_revert (shell);
if (image)
use_gegl = gimp_image_get_projection (image)->use_gegl;
}
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_COLOR(action,color) \
gimp_action_group_set_action_color (group, action, color, FALSE)
SET_SENSITIVE ("view-new", image);
SET_SENSITIVE ("view-close", image);
SET_SENSITIVE ("view-dot-for-dot", image);
SET_ACTIVE ("view-dot-for-dot", display && shell->dot_for_dot);
SET_SENSITIVE ("view-zoom-revert", revert_enabled);
if (revert_enabled)
{
label = g_strdup_printf (_("Re_vert Zoom (%d%%)"),
ROUND (shell->last_scale * 100));
gimp_action_group_set_action_label (group, "view-zoom-revert", label);
g_free (label);
}
else
{
gimp_action_group_set_action_label (group, "view-zoom-revert",
_("Re_vert Zoom"));
}
SET_SENSITIVE ("view-zoom-out", image);
SET_SENSITIVE ("view-zoom-in", image);
SET_SENSITIVE ("view-zoom-fit-in", image);
SET_SENSITIVE ("view-zoom-fill", image);
SET_SENSITIVE ("view-zoom-16-1", image);
SET_SENSITIVE ("view-zoom-8-1", image);
SET_SENSITIVE ("view-zoom-4-1", image);
SET_SENSITIVE ("view-zoom-2-1", image);
SET_SENSITIVE ("view-zoom-1-1", image);
SET_SENSITIVE ("view-zoom-1-2", image);
SET_SENSITIVE ("view-zoom-1-4", image);
SET_SENSITIVE ("view-zoom-1-8", image);
SET_SENSITIVE ("view-zoom-1-16", image);
SET_SENSITIVE ("view-zoom-other", image);
if (image)
view_actions_set_zoom (group, shell);
SET_SENSITIVE ("view-navigation-window", image);
SET_SENSITIVE ("view-display-filters", image);
SET_SENSITIVE ("view-show-selection", image);
SET_ACTIVE ("view-show-selection", display && options->show_selection);
SET_SENSITIVE ("view-show-layer-boundary", image);
SET_ACTIVE ("view-show-layer-boundary", display && options->show_layer_boundary);
SET_SENSITIVE ("view-show-guides", image);
SET_ACTIVE ("view-show-guides", display && options->show_guides);
SET_SENSITIVE ("view-show-grid", image);
SET_ACTIVE ("view-show-grid", display && options->show_grid);
SET_SENSITIVE ("view-show-sample-points", image);
SET_ACTIVE ("view-show-sample-points", display && options->show_sample_points);
SET_SENSITIVE ("view-snap-to-guides", image);
SET_ACTIVE ("view-snap-to-guides", display && shell->snap_to_guides);
SET_SENSITIVE ("view-snap-to-grid", image);
SET_ACTIVE ("view-snap-to-grid", display && shell->snap_to_grid);
SET_SENSITIVE ("view-snap-to-canvas", image);
SET_ACTIVE ("view-snap-to-canvas", display && shell->snap_to_canvas);
SET_SENSITIVE ("view-snap-to-vectors", image);
SET_ACTIVE ("view-snap-to-vectors", display && shell->snap_to_vectors);
SET_SENSITIVE ("view-padding-color-theme", image);
SET_SENSITIVE ("view-padding-color-light-check", image);
SET_SENSITIVE ("view-padding-color-dark-check", image);
SET_SENSITIVE ("view-padding-color-custom", image);
SET_SENSITIVE ("view-padding-color-prefs", image);
if (display)
{
SET_COLOR ("view-padding-color-menu", &options->padding_color);
if (shell->canvas)
{
GtkStyle *style = gtk_widget_get_style (shell->canvas);
GimpRGB color;
gtk_widget_ensure_style (shell->canvas);
gimp_rgb_set_gdk_color (&color, style->bg + GTK_STATE_NORMAL);
gimp_rgb_set_alpha (&color, GIMP_OPACITY_OPAQUE);
SET_COLOR ("view-padding-color-theme", &color);
}
}
SET_SENSITIVE ("view-show-menubar", image);
SET_ACTIVE ("view-show-menubar", display && options->show_menubar);
SET_SENSITIVE ("view-show-rulers", image);
SET_ACTIVE ("view-show-rulers", display && options->show_rulers);
SET_SENSITIVE ("view-show-scrollbars", image);
SET_ACTIVE ("view-show-scrollbars", display && options->show_scrollbars);
SET_SENSITIVE ("view-show-statusbar", image);
SET_ACTIVE ("view-show-statusbar", display && options->show_statusbar);
SET_SENSITIVE ("view-shrink-wrap", image);
SET_SENSITIVE ("view-fullscreen", image);
SET_ACTIVE ("view-fullscreen", display && fullscreen);
SET_ACTIVE ("view-use-gegl", use_gegl);
if (GIMP_IS_IMAGE_WINDOW (group->user_data) ||
GIMP_IS_GIMP (group->user_data))
{
GtkWidget *window = NULL;
if (shell)
window = gtk_widget_get_toplevel (GTK_WIDGET (shell));
/* see view_actions_setup() */
if (GTK_IS_WINDOW (window))
window_actions_update (group, window);
}
#undef SET_ACTIVE
#undef SET_SENSITIVE
#undef SET_COLOR
}
static void
gimp_perspective_clone_paint (GimpPaintCore *paint_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
const GimpCoords *coords,
GimpPaintState paint_state,
guint32 time)
{
GimpSourceCore *source_core = GIMP_SOURCE_CORE (paint_core);
GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (paint_core);
GimpContext *context = GIMP_CONTEXT (paint_options);
GimpCloneOptions *clone_options = GIMP_CLONE_OPTIONS (paint_options);
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
switch (paint_state)
{
case GIMP_PAINT_STATE_INIT:
if (source_core->set_source)
{
g_object_set (source_core, "src-drawable", drawable, NULL);
source_core->src_x = coords->x;
source_core->src_y = coords->y;
/* get source coordinates in front view perspective */
gimp_matrix3_transform_point (&clone->transform_inv,
source_core->src_x,
source_core->src_y,
&clone->src_x_fv,
&clone->src_y_fv);
source_core->first_stroke = TRUE;
}
else
{
GeglBuffer *orig_buffer = NULL;
GeglNode *tile = NULL;
GeglNode *src_node;
if (options->align_mode == GIMP_SOURCE_ALIGN_NO)
{
source_core->orig_src_x = source_core->src_x;
source_core->orig_src_y = source_core->src_y;
source_core->first_stroke = TRUE;
}
clone->node = gegl_node_new ();
g_object_set (clone->node,
"dont-cache", TRUE,
NULL);
switch (clone_options->clone_type)
{
case GIMP_IMAGE_CLONE:
{
GimpPickable *src_pickable;
GimpImage *src_image;
GimpImage *dest_image;
/* If the source image is different from the
* destination, then we should copy straight from the
* source image to the canvas.
* Otherwise, we need a call to get_orig_image to make sure
* we get a copy of the unblemished (offset) image
*/
src_pickable = GIMP_PICKABLE (source_core->src_drawable);
src_image = gimp_pickable_get_image (src_pickable);
if (options->sample_merged)
src_pickable = GIMP_PICKABLE (gimp_image_get_projection (src_image));
dest_image = gimp_item_get_image (GIMP_ITEM (drawable));
if ((options->sample_merged &&
(src_image != dest_image)) ||
(! options->sample_merged &&
(source_core->src_drawable != drawable)))
{
orig_buffer = gimp_pickable_get_buffer (src_pickable);
}
else
{
if (options->sample_merged)
orig_buffer = gimp_paint_core_get_orig_proj (paint_core);
else
orig_buffer = gimp_paint_core_get_orig_image (paint_core);
}
}
break;
case GIMP_PATTERN_CLONE:
{
GimpPattern *pattern = gimp_context_get_pattern (context);
orig_buffer = gimp_pattern_create_buffer (pattern);
tile = gegl_node_new_child (clone->node,
"operation", "gegl:tile",
NULL);
clone->crop = gegl_node_new_child (clone->node,
"operation", "gegl:crop",
NULL);
}
break;
}
src_node = gegl_node_new_child (clone->node,
"operation", "gegl:buffer-source",
"buffer", orig_buffer,
NULL);
clone->transform_node =
gegl_node_new_child (clone->node,
"operation", "gegl:transform",
"sampler", GIMP_INTERPOLATION_LINEAR,
NULL);
clone->dest_node =
gegl_node_new_child (clone->node,
"operation", "gegl:write-buffer",
NULL);
if (tile)
{
gegl_node_link_many (src_node,
tile,
clone->crop,
clone->transform_node,
clone->dest_node,
NULL);
g_object_unref (orig_buffer);
}
else
{
gegl_node_link_many (src_node,
clone->transform_node,
clone->dest_node,
NULL);
}
}
break;
case GIMP_PAINT_STATE_MOTION:
if (source_core->set_source)
{
/* If the control key is down, move the src target and return */
source_core->src_x = coords->x;
source_core->src_y = coords->y;
/* get source coordinates in front view perspective */
gimp_matrix3_transform_point (&clone->transform_inv,
source_core->src_x,
source_core->src_y,
&clone->src_x_fv,
&clone->src_y_fv);
source_core->first_stroke = TRUE;
}
else
{
/* otherwise, update the target */
gint dest_x;
gint dest_y;
dest_x = coords->x;
dest_y = coords->y;
if (options->align_mode == GIMP_SOURCE_ALIGN_REGISTERED)
{
source_core->offset_x = 0;
source_core->offset_y = 0;
}
else if (options->align_mode == GIMP_SOURCE_ALIGN_FIXED)
{
source_core->offset_x = source_core->src_x - dest_x;
source_core->offset_y = source_core->src_y - dest_y;
}
else if (source_core->first_stroke)
{
source_core->offset_x = source_core->src_x - dest_x;
source_core->offset_y = source_core->src_y - dest_y;
/* get destination coordinates in front view perspective */
gimp_matrix3_transform_point (&clone->transform_inv,
dest_x,
dest_y,
&clone->dest_x_fv,
&clone->dest_y_fv);
source_core->first_stroke = FALSE;
}
gimp_source_core_motion (source_core, drawable, paint_options, coords);
}
break;
case GIMP_PAINT_STATE_FINISH:
if (clone->node)
{
g_object_unref (clone->node);
clone->node = NULL;
clone->crop = NULL;
clone->transform_node = NULL;
clone->dest_node = NULL;
}
break;
default:
break;
}
g_object_notify (G_OBJECT (clone), "src-x");
g_object_notify (G_OBJECT (clone), "src-y");
}
gboolean
gimp_paint_core_start (GimpPaintCore *core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
const GimpCoords *coords,
GError **error)
{
GimpItem *item;
g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), FALSE);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE);
g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), FALSE);
g_return_val_if_fail (coords != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
item = GIMP_ITEM (drawable);
if (core->stroke_buffer)
{
g_array_free (core->stroke_buffer, TRUE);
core->stroke_buffer = NULL;
}
core->stroke_buffer = g_array_sized_new (TRUE, TRUE,
sizeof (GimpCoords),
STROKE_BUFFER_INIT_SIZE);
core->cur_coords = *coords;
if (! GIMP_PAINT_CORE_GET_CLASS (core)->start (core, drawable,
paint_options,
coords, error))
{
return FALSE;
}
/* Allocate the undo structure */
if (core->undo_buffer)
g_object_unref (core->undo_buffer);
core->undo_buffer = gegl_buffer_dup (gimp_drawable_get_buffer (drawable));
/* Allocate the saved proj structure */
if (core->saved_proj_buffer)
{
g_object_unref (core->saved_proj_buffer);
core->saved_proj_buffer = NULL;
}
if (core->use_saved_proj)
{
GimpImage *image = gimp_item_get_image (item);
GimpPickable *pickable = GIMP_PICKABLE (gimp_image_get_projection (image));
GeglBuffer *buffer = gimp_pickable_get_buffer (pickable);
core->saved_proj_buffer = gegl_buffer_dup (buffer);
}
/* Allocate the canvas blocks structure */
if (core->canvas_buffer)
g_object_unref (core->canvas_buffer);
core->canvas_buffer =
gegl_buffer_new (GEGL_RECTANGLE (0, 0,
gimp_item_get_width (item),
gimp_item_get_height (item)),
babl_format ("Y u8"));
/* Get the initial undo extents */
core->x1 = core->x2 = core->cur_coords.x;
core->y1 = core->y2 = core->cur_coords.y;
core->last_paint.x = -1e6;
core->last_paint.y = -1e6;
{
GimpImage *image;
GimpChannel *mask;
GeglBuffer *mask_buffer = NULL;
gint offset_x = 0;
gint offset_y = 0;
image = gimp_item_get_image (item);
mask = gimp_image_get_mask (image);
/* don't apply the mask to itself and don't apply an empty mask */
if (GIMP_DRAWABLE (mask) == drawable || gimp_channel_is_empty (mask))
mask = NULL;
if (mask)
{
mask_buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask));
gimp_item_get_offset (item, &offset_x, &offset_y);
}
core->applicator =
gimp_applicator_new (gimp_drawable_get_buffer (drawable),
gimp_drawable_get_active_mask (drawable),
mask_buffer,
-offset_x, -offset_y);
}
/* Freeze the drawable preview so that it isn't constantly updated. */
gimp_viewable_preview_freeze (GIMP_VIEWABLE (drawable));
return TRUE;
}
gboolean
gimp_paint_core_start (GimpPaintCore *core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
const GimpCoords *coords,
GError **error)
{
GimpItem *item;
g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), FALSE);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE);
g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), FALSE);
g_return_val_if_fail (coords != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
item = GIMP_ITEM (drawable);
if (core->stroke_buffer)
{
g_array_free (core->stroke_buffer, TRUE);
core->stroke_buffer = NULL;
}
core->stroke_buffer = g_array_sized_new (TRUE, TRUE,
sizeof (GimpCoords),
STROKE_BUFFER_INIT_SIZE);
core->cur_coords = *coords;
if (! GIMP_PAINT_CORE_GET_CLASS (core)->start (core, drawable,
paint_options,
coords, error))
{
return FALSE;
}
/* Allocate the undo structure */
if (core->undo_tiles)
tile_manager_unref (core->undo_tiles);
core->undo_tiles = tile_manager_new (gimp_item_get_width (item),
gimp_item_get_height (item),
gimp_drawable_bytes (drawable));
/* Allocate the saved proj structure */
if (core->saved_proj_tiles)
tile_manager_unref (core->saved_proj_tiles);
core->saved_proj_tiles = NULL;
if (core->use_saved_proj)
{
GimpImage *image = gimp_item_get_image (item);
GimpPickable *pickable = GIMP_PICKABLE (gimp_image_get_projection (image));
TileManager *tiles = gimp_pickable_get_tiles (pickable);
core->saved_proj_tiles = tile_manager_new (tile_manager_width (tiles),
tile_manager_height (tiles),
tile_manager_bpp (tiles));
}
/* Allocate the canvas blocks structure */
if (core->canvas_tiles)
tile_manager_unref (core->canvas_tiles);
core->canvas_tiles = tile_manager_new (gimp_item_get_width (item),
gimp_item_get_height (item),
1);
/* Get the initial undo extents */
core->x1 = core->x2 = core->cur_coords.x;
core->y1 = core->y2 = core->cur_coords.y;
core->last_paint.x = -1e6;
core->last_paint.y = -1e6;
/* Freeze the drawable preview so that it isn't constantly updated. */
gimp_viewable_preview_freeze (GIMP_VIEWABLE (drawable));
return TRUE;
}
static void
gimp_paint_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpPaintOptions *paint_options = GIMP_PAINT_TOOL_GET_OPTIONS (tool);
GimpPaintCore *core = paint_tool->core;
GimpDisplayShell *shell = gimp_display_get_shell (display);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpCoords curr_coords;
gint off_x, off_y;
GError *error = NULL;
if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool)))
{
GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
press_type, display);
return;
}
if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
{
gimp_tool_message_literal (tool, display,
_("Cannot paint on layer groups."));
return;
}
if (gimp_item_is_content_locked (GIMP_ITEM (drawable)))
{
gimp_tool_message_literal (tool, display,
_("The active layer's pixels are locked."));
return;
}
if (! gimp_item_is_visible (GIMP_ITEM (drawable)))
{
gimp_tool_message_literal (tool, display,
_("The active layer is not visible."));
return;
}
curr_coords = *coords;
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
curr_coords.x -= off_x;
curr_coords.y -= off_y;
if (gimp_draw_tool_is_active (draw_tool))
gimp_draw_tool_stop (draw_tool);
if (tool->display &&
tool->display != display &&
gimp_display_get_image (tool->display) == image)
{
/* if this is a different display, but the same image, HACK around
* in tool internals AFTER stopping the current draw_tool, so
* straight line drawing works across different views of the
* same image.
*/
tool->display = display;
}
if (! gimp_paint_core_start (core, drawable, paint_options, &curr_coords,
&error))
{
gimp_tool_message_literal (tool, display, error->message);
g_clear_error (&error);
return;
}
if ((display != tool->display) || ! paint_tool->draw_line)
{
/* if this is a new display, resest the "last stroke's endpoint"
* because there is none
*/
if (display != tool->display)
core->start_coords = core->cur_coords;
core->last_coords = core->cur_coords;
core->distance = 0.0;
core->pixel_dist = 0.0;
}
else if (paint_tool->draw_line)
{
gboolean constrain = (state & gimp_get_constrain_behavior_mask ()) != 0;
/* If shift is down and this is not the first paint
* stroke, then draw a line from the last coords to the pointer
*/
gimp_paint_core_round_line (core, paint_options, constrain);
}
/* chain up to activate the tool */
GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
press_type, display);
/* pause the current selection */
gimp_display_shell_selection_pause (shell);
/* Let the specific painting function initialize itself */
gimp_paint_core_paint (core, drawable, paint_options,
GIMP_PAINT_STATE_INIT, time);
/* Paint to the image */
if (paint_tool->draw_line)
{
gimp_paint_core_interpolate (core, drawable, paint_options,
&core->cur_coords, time);
}
else
{
gimp_paint_core_paint (core, drawable, paint_options,
GIMP_PAINT_STATE_MOTION, time);
}
gimp_projection_flush_now (gimp_image_get_projection (image));
gimp_display_flush_now (display);
gimp_draw_tool_start (draw_tool, display);
}
void
gimp_source_core_motion (GimpSourceCore *source_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options)
{
GimpPaintCore *paint_core = GIMP_PAINT_CORE (source_core);
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
GimpPickable *src_pickable = NULL;
PixelRegion srcPR;
gint src_offset_x;
gint src_offset_y;
TempBuf *paint_area;
gint paint_area_offset_x;
gint paint_area_offset_y;
gint paint_area_width;
gint paint_area_height;
gdouble opacity;
opacity = gimp_paint_options_get_fade (paint_options, image,
paint_core->pixel_dist);
if (opacity == 0.0)
return;
src_offset_x = source_core->offset_x;
src_offset_y = source_core->offset_y;
if (options->use_source)
{
src_pickable = GIMP_PICKABLE (source_core->src_drawable);
if (options->sample_merged)
{
GimpImage *src_image = gimp_pickable_get_image (src_pickable);
gint off_x, off_y;
src_pickable = GIMP_PICKABLE (gimp_image_get_projection (src_image));
gimp_item_offsets (GIMP_ITEM (source_core->src_drawable),
&off_x, &off_y);
src_offset_x += off_x;
src_offset_y += off_y;
}
gimp_pickable_flush (src_pickable);
}
paint_area = gimp_paint_core_get_paint_area (paint_core, drawable,
paint_options);
if (! paint_area)
return;
paint_area_offset_x = 0;
paint_area_offset_y = 0;
paint_area_width = paint_area->width;
paint_area_height = paint_area->height;
if (options->use_source &&
! GIMP_SOURCE_CORE_GET_CLASS (source_core)->get_source (source_core,
drawable,
paint_options,
src_pickable,
src_offset_x,
src_offset_y,
paint_area,
&paint_area_offset_x,
&paint_area_offset_y,
&paint_area_width,
&paint_area_height,
&srcPR))
{
return;
}
/* Set the paint area to transparent */
temp_buf_data_clear (paint_area);
GIMP_SOURCE_CORE_GET_CLASS (source_core)->motion (source_core,
drawable,
paint_options,
opacity,
src_pickable,
&srcPR,
src_offset_x,
src_offset_y,
paint_area,
paint_area_offset_x,
paint_area_offset_y,
paint_area_width,
paint_area_height);
}
void
gimp_display_shell_render (GimpDisplayShell *shell,
cairo_t *cr,
gint x,
gint y,
gint w,
gint h)
{
GimpImage *image;
GimpProjection *projection;
GeglBuffer *buffer;
gdouble scale_x = 1.0;
gdouble scale_y = 1.0;
gdouble buffer_scale = 1.0;
gint viewport_offset_x;
gint viewport_offset_y;
gint viewport_width;
gint viewport_height;
gint scaled_x;
gint scaled_y;
gint scaled_width;
gint scaled_height;
cairo_surface_t *xfer;
gint xfer_src_x;
gint xfer_src_y;
gint mask_src_x = 0;
gint mask_src_y = 0;
gint stride;
guchar *data;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (cr != NULL);
g_return_if_fail (w > 0 && h > 0);
image = gimp_display_get_image (shell->display);
projection = gimp_image_get_projection (image);
buffer = gimp_pickable_get_buffer (GIMP_PICKABLE (projection));
#ifdef GIMP_DISPLAY_RENDER_ENABLE_SCALING
/* if we had this future API, things would look pretty on hires (retina) */
scale_x = gdk_window_get_scale_factor (gtk_widget_get_window (gtk_widget_get_toplevel (GTK_WIDGET (shell))));
#endif
scale_x = MIN (scale_x, GIMP_DISPLAY_RENDER_MAX_SCALE);
scale_y = scale_x;
if (shell->scale_x > shell->scale_y)
{
scale_y *= (shell->scale_x / shell->scale_y);
buffer_scale = shell->scale_y * scale_y;
}
else if (shell->scale_y > shell->scale_x)
{
scale_x *= (shell->scale_y / shell->scale_x);
buffer_scale = shell->scale_x * scale_x;
}
else
{
buffer_scale = shell->scale_x * scale_x;
}
gimp_display_shell_scroll_get_scaled_viewport (shell,
&viewport_offset_x,
&viewport_offset_y,
&viewport_width,
&viewport_height);
scaled_x = floor ((x + viewport_offset_x) * scale_x);
scaled_y = floor ((y + viewport_offset_y) * scale_y);
scaled_width = ceil (w * scale_x);
scaled_height = ceil (h * scale_y);
if (shell->rotate_transform)
{
xfer = cairo_surface_create_similar_image (cairo_get_target (cr),
CAIRO_FORMAT_ARGB32,
scaled_width,
scaled_height);
cairo_surface_mark_dirty (xfer);
xfer_src_x = 0;
xfer_src_y = 0;
}
else
{
xfer = gimp_display_xfer_get_surface (shell->xfer,
scaled_width,
scaled_height,
&xfer_src_x,
&xfer_src_y);
}
stride = cairo_image_surface_get_stride (xfer);
data = cairo_image_surface_get_data (xfer);
data += xfer_src_y * stride + xfer_src_x * 4;
/* apply filters to the rendered projection */
if (shell->filter_stack)
{
const Babl *filter_format = babl_format ("R'G'B'A float");
if (! shell->filter_buffer)
{
gint w = GIMP_DISPLAY_RENDER_BUF_WIDTH * GIMP_DISPLAY_RENDER_MAX_SCALE;
gint h = GIMP_DISPLAY_RENDER_BUF_HEIGHT * GIMP_DISPLAY_RENDER_MAX_SCALE;
shell->filter_data =
gegl_malloc (w * h * babl_format_get_bytes_per_pixel (filter_format));
shell->filter_stride = w * babl_format_get_bytes_per_pixel (filter_format);
shell->filter_buffer =
gegl_buffer_linear_new_from_data (shell->filter_data,
filter_format,
GEGL_RECTANGLE (0, 0, w, h),
GEGL_AUTO_ROWSTRIDE,
(GDestroyNotify) gegl_free,
shell->filter_data);
}
gegl_buffer_get (buffer,
GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height),
buffer_scale,
filter_format, shell->filter_data,
shell->filter_stride, GEGL_ABYSS_CLAMP);
gimp_color_display_stack_convert_buffer (shell->filter_stack,
shell->filter_buffer,
GEGL_RECTANGLE (0, 0,
scaled_width,
scaled_height));
gegl_buffer_get (shell->filter_buffer,
GEGL_RECTANGLE (0, 0,
scaled_width,
scaled_height),
1.0,
babl_format ("cairo-ARGB32"),
data, stride,
GEGL_ABYSS_CLAMP);
}
else
{
gegl_buffer_get (buffer,
GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height),
buffer_scale,
babl_format ("cairo-ARGB32"),
data, stride,
GEGL_ABYSS_CLAMP);
}
if (shell->mask)
{
gint mask_height;
if (! shell->mask_surface)
{
shell->mask_surface =
cairo_image_surface_create (CAIRO_FORMAT_A8,
GIMP_DISPLAY_RENDER_BUF_WIDTH *
GIMP_DISPLAY_RENDER_MAX_SCALE,
GIMP_DISPLAY_RENDER_BUF_HEIGHT *
GIMP_DISPLAY_RENDER_MAX_SCALE);
}
cairo_surface_mark_dirty (shell->mask_surface);
stride = cairo_image_surface_get_stride (shell->mask_surface);
data = cairo_image_surface_get_data (shell->mask_surface);
data += mask_src_y * stride + mask_src_x * 4;
gegl_buffer_get (shell->mask,
GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height),
buffer_scale,
babl_format ("Y u8"),
data, stride,
GEGL_ABYSS_CLAMP);
/* invert the mask so what is *not* the foreground object is masked */
mask_height = scaled_height;
while (mask_height--)
{
gint mask_width = scaled_width;
guchar *d = data;
while (mask_width--)
{
guchar inv = 255 - *d;
*d++ = inv;
}
data += stride;
}
}
/* put it to the screen */
cairo_save (cr);
cairo_rectangle (cr, x, y, w, h);
cairo_scale (cr, 1.0 / scale_x, 1.0 / scale_y);
cairo_set_source_surface (cr, xfer,
x * scale_x - xfer_src_x,
y * scale_y - xfer_src_y);
if (shell->rotate_transform)
{
cairo_pattern_t *pattern;
pattern = cairo_get_source (cr);
cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
cairo_set_line_width (cr, 1.0);
cairo_stroke_preserve (cr);
cairo_surface_destroy (xfer);
}
cairo_clip (cr);
cairo_paint (cr);
if (shell->mask)
{
gimp_cairo_set_source_rgba (cr, &shell->mask_color);
cairo_mask_surface (cr, shell->mask_surface,
(x - mask_src_x) * scale_x,
(y - mask_src_y) * scale_y);
}
cairo_restore (cr);
}
