GeglBuffer *
gimp_applicator_get_cache_buffer (GimpApplicator *applicator,
GeglRectangle **rectangles,
gint *n_rectangles)
{
g_return_val_if_fail (GIMP_IS_APPLICATOR (applicator), NULL);
g_return_val_if_fail (rectangles != NULL, NULL);
g_return_val_if_fail (n_rectangles != NULL, NULL);
if (applicator->output_cache_node)
{
GeglBuffer *cache;
gegl_node_get (applicator->output_cache_node,
"cache", &cache,
NULL);
if (cache)
{
if (gegl_buffer_list_valid_rectangles (cache, rectangles, n_rectangles))
return cache;
g_object_unref (cache);
}
}
return NULL;
}
void
gimp_applicator_set_mask_buffer (GimpApplicator *applicator,
GeglBuffer *mask_buffer)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
g_return_if_fail (mask_buffer == NULL || GEGL_IS_BUFFER (mask_buffer));
if (applicator->mask_buffer == mask_buffer)
return;
gegl_node_set (applicator->mask_node,
"buffer", mask_buffer,
NULL);
if (mask_buffer)
{
gegl_node_connect_to (applicator->mask_offset_node, "output",
applicator->mode_node, "aux2");
}
else
{
gegl_node_disconnect (applicator->mode_node, "aux2");
}
applicator->mask_buffer = mask_buffer;
}
GeglBuffer *
gimp_applicator_dup_apply_buffer (GimpApplicator *applicator,
const GeglRectangle *rect)
{
GeglBuffer *buffer;
GeglBuffer *shifted;
g_return_val_if_fail (GIMP_IS_APPLICATOR (applicator), NULL);
g_return_val_if_fail (rect != NULL, NULL);
buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, rect->width, rect->height),
babl_format ("RGBA float"));
shifted = g_object_new (GEGL_TYPE_BUFFER,
"source", buffer,
"shift-x", -rect->x,
"shift-y", -rect->y,
NULL);
gegl_node_set (applicator->dup_apply_buffer_node,
"buffer", shifted,
NULL);
g_object_unref (shifted);
return buffer;
}
void
gimp_applicator_set_output_format (GimpApplicator *applicator,
const Babl *format)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
if (applicator->output_format != format)
{
if (format)
{
if (! applicator->output_format)
{
gegl_node_set (applicator->convert_format_node,
"operation", "gegl:convert-format",
"format", format,
NULL);
}
else
{
gegl_node_set (applicator->convert_format_node,
"format", format,
NULL);
}
}
else
{
gegl_node_set (applicator->convert_format_node,
"operation", "gegl:nop",
NULL);
}
applicator->output_format = format;
}
}
void
gimp_applicator_blit (GimpApplicator *applicator,
const GeglRectangle *rect)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
gegl_node_blit (applicator->dest_node, 1.0, rect,
NULL, NULL, 0, GEGL_BLIT_DEFAULT);
}
const GeglRectangle *
gimp_applicator_get_crop (GimpApplicator *applicator)
{
g_return_val_if_fail (GIMP_IS_APPLICATOR (applicator), NULL);
if (applicator->crop_enabled)
return &applicator->crop_rect;
return NULL;
}
void
gimp_applicator_set_mode (GimpApplicator *applicator,
GimpLayerModeEffects paint_mode)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
if (applicator->paint_mode != paint_mode)
{
applicator->paint_mode = paint_mode;
gimp_gegl_mode_node_set_mode (applicator->mode_node,
paint_mode, applicator->linear);
}
}
void
gimp_applicator_set_opacity (GimpApplicator *applicator,
gdouble opacity)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
if (applicator->opacity != opacity)
{
applicator->opacity = opacity;
gimp_gegl_mode_node_set_opacity (applicator->mode_node,
opacity);
}
}
void
gimp_applicator_set_affect (GimpApplicator *applicator,
GimpComponentMask affect)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
if (applicator->affect != affect)
{
applicator->affect = affect;
gegl_node_set (applicator->affect_node,
"mask", affect,
NULL);
}
}
void
gimp_applicator_set_crop (GimpApplicator *applicator,
const GeglRectangle *rect)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
if (applicator->crop_enabled != (rect != NULL) ||
(rect && ! gegl_rectangle_equal (&applicator->crop_rect, rect)))
{
if (rect)
{
if (! applicator->crop_enabled)
{
gegl_node_set (applicator->crop_node,
"operation", "gimp:compose-crop",
"x", rect->x,
"y", rect->y,
"width", rect->width,
"height", rect->height,
NULL);
gegl_node_connect_to (applicator->input_node, "output",
applicator->crop_node, "aux");
}
else
{
gegl_node_set (applicator->crop_node,
"x", rect->x,
"y", rect->y,
"width", rect->width,
"height", rect->height,
NULL);
}
applicator->crop_enabled = TRUE;
applicator->crop_rect = *rect;
}
else
{
gegl_node_disconnect (applicator->crop_node, "aux");
gegl_node_set (applicator->crop_node,
"operation", "gegl:nop",
NULL);
applicator->crop_enabled = FALSE;
}
}
}
void
gimp_applicator_set_dest_buffer (GimpApplicator *applicator,
GeglBuffer *dest_buffer)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
g_return_if_fail (dest_buffer == NULL || GEGL_IS_BUFFER (dest_buffer));
if (dest_buffer == applicator->dest_buffer)
return;
if (dest_buffer)
{
if (! applicator->dest_node)
{
applicator->dest_node =
gegl_node_new_child (applicator->node,
"operation", "gegl:write-buffer",
"buffer", dest_buffer,
NULL);
}
else
{
gegl_node_set (applicator->dest_node,
"buffer", dest_buffer,
NULL);
}
if (! applicator->dest_buffer)
{
gegl_node_disconnect (applicator->output_node, "input");
gegl_node_connect_to (applicator->affect_node, "output",
applicator->dest_node, "input");
}
}
else if (applicator->dest_buffer)
{
gegl_node_disconnect (applicator->dest_node, "input");
gegl_node_connect_to (applicator->affect_node, "output",
applicator->output_node, "input");
}
applicator->dest_buffer = dest_buffer;
}
void
gimp_applicator_set_src_buffer (GimpApplicator *applicator,
GeglBuffer *src_buffer)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
g_return_if_fail (src_buffer == NULL || GEGL_IS_BUFFER (src_buffer));
if (src_buffer == applicator->src_buffer)
return;
if (src_buffer)
{
if (! applicator->src_node)
{
applicator->src_node =
gegl_node_new_child (applicator->node,
"operation", "gegl:buffer-source",
"buffer", src_buffer,
NULL);
}
else
{
gegl_node_set (applicator->src_node,
"buffer", src_buffer,
NULL);
}
if (! applicator->src_buffer)
{
gegl_node_connect_to (applicator->src_node, "output",
applicator->mode_node, "input");
gegl_node_connect_to (applicator->src_node, "output",
applicator->affect_node, "input");
}
}
else if (applicator->src_buffer)
{
gegl_node_connect_to (applicator->input_node, "output",
applicator->mode_node, "input");
gegl_node_connect_to (applicator->input_node, "output",
applicator->affect_node, "input");
}
applicator->src_buffer = src_buffer;
}
void
gimp_applicator_set_apply_offset (GimpApplicator *applicator,
gint apply_offset_x,
gint apply_offset_y)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
if (applicator->apply_offset_x != apply_offset_x ||
applicator->apply_offset_y != apply_offset_y)
{
applicator->apply_offset_x = apply_offset_x;
applicator->apply_offset_y = apply_offset_y;
gegl_node_set (applicator->apply_offset_node,
"x", (gdouble) apply_offset_x,
"y", (gdouble) apply_offset_y,
NULL);
}
}
void
gimp_applicator_set_cache (GimpApplicator *applicator,
gboolean enable)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
if (applicator->cache_enabled != enable)
{
if (enable)
{
gegl_node_set (applicator->cache_node,
"operation", "gegl:cache",
NULL);
}
else
{
gegl_node_set (applicator->cache_node,
"operation", "gegl:nop",
NULL);
}
applicator->cache_enabled = enable;
}
}
void
gimp_applicator_set_mode (GimpApplicator *applicator,
GimpLayerMode paint_mode,
GimpLayerColorSpace blend_space,
GimpLayerColorSpace composite_space,
GimpLayerCompositeMode composite_mode)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
if (applicator->paint_mode != paint_mode ||
applicator->blend_space != blend_space ||
applicator->composite_space != composite_space ||
applicator->composite_mode != composite_mode)
{
applicator->paint_mode = paint_mode;
applicator->blend_space = blend_space;
applicator->composite_space = composite_space;
applicator->composite_mode = composite_mode;
gimp_gegl_mode_node_set_mode (applicator->mode_node,
paint_mode, blend_space,
composite_space, composite_mode);
}
}
void
gimp_applicator_set_preview (GimpApplicator *applicator,
gboolean enable,
const GeglRectangle *rect)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
g_return_if_fail (rect != NULL);
if (! applicator->preview_cache_node)
return;
if (applicator->preview_enabled != enable ||
applicator->preview_rect.x != rect->x ||
applicator->preview_rect.y != rect->y ||
applicator->preview_rect.width != rect->width ||
applicator->preview_rect.height != rect->height)
{
if (enable)
{
if (! applicator->preview_enabled)
{
gegl_node_set (applicator->preview_crop_node,
"operation", "gimp:compose-crop",
"x", rect->x,
"y", rect->y,
"width", rect->width,
"height", rect->height,
NULL);
gegl_node_connect_to (applicator->input_node, "output",
applicator->preview_crop_node, "aux");
}
else
{
gegl_node_set (applicator->preview_crop_node,
"x", rect->x,
"y", rect->y,
"width", rect->width,
"height", rect->height,
NULL);
}
}
else if (applicator->preview_enabled)
{
GeglBuffer *cache;
gegl_node_disconnect (applicator->preview_crop_node, "aux");
gegl_node_set (applicator->preview_crop_node,
"operation", "gegl:nop",
NULL);
/* when disabling the preview, preserve the cached result
* by processing it into the output cache, which only
* involves the mode and affect nodes.
*/
gegl_node_get (applicator->preview_cache_node,
"cache", &cache,
NULL);
if (cache)
{
GeglRectangle *rectangles;
gint n_rectangles;
if (gegl_buffer_list_valid_rectangles (cache, &rectangles,
&n_rectangles))
{
gint i;
for (i = 0; i < n_rectangles; i++)
gegl_node_blit (applicator->output_cache_node, 1.0,
&rectangles[i],
NULL, NULL, 0, GEGL_BLIT_DEFAULT);
g_free (rectangles);
}
g_object_unref (cache);
}
}
applicator->preview_enabled = enable;
applicator->preview_rect = *rect;
}
}
