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;
}
gboolean
gimp_warp_tool_undo (GimpTool *tool,
GimpDisplay *display)
{
GimpWarpTool *wt = GIMP_WARP_TOOL (tool);
GeglNode *to_delete;
GeglNode *previous;
const gchar *type;
if (! wt->render_node)
return FALSE;
to_delete = gegl_node_get_producer (wt->render_node, "aux", NULL);
type = gegl_node_get_operation (to_delete);
if (strcmp (type, "gegl:warp"))
return FALSE;
previous = gegl_node_get_producer (to_delete, "input", NULL);
gegl_node_disconnect (to_delete, "input");
gegl_node_connect_to (previous, "output",
wt->render_node, "aux");
wt->redo_stack = g_list_prepend (wt->redo_stack, g_object_ref (to_delete));
gegl_node_remove_child (wt->graph, to_delete);
gimp_warp_tool_update_stroke (wt, to_delete);
return TRUE;
}
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
gegl_node_disconnect_all_pads(GeglNode* node)
{
GSList* list;
for(list = gegl_node_get_pads(node); list != NULL; list = list->next)
{
if(gegl_pad_is_input(list->data)) //disconnect inputs
{
gegl_node_disconnect(node, (gchar*)gegl_pad_get_name(list->data));
}
else if(gegl_pad_is_output(list->data)) //disconnect outputs
{
GeglNode** nodes;
const gchar** pads;
gint num_consumers = gegl_node_get_consumers(node, gegl_pad_get_name(list->data), &nodes, &pads);
gint i;
for(i = 0; i < num_consumers; i++)
{
gegl_node_disconnect(nodes[i], pads[i]);
}
}
}
}
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;
}
}
}
static void
gimp_warp_tool_remove_op (GimpWarpTool *wt,
GeglNode *op)
{
GeglNode *previous;
g_return_if_fail (GEGL_IS_NODE (wt->render_node));
previous = gegl_node_get_producer (op, "input", NULL);
gegl_node_disconnect (op, "input");
gegl_node_connect_to (previous, "output",
wt->render_node, "aux");
gegl_node_remove_child (wt->graph, op);
}
static void
gimp_warp_tool_add_op (GimpWarpTool *wt,
GeglNode *new_op)
{
GeglNode *last_op;
g_return_if_fail (GEGL_IS_NODE (wt->render_node));
gegl_node_add_child (wt->graph, new_op);
last_op = gegl_node_get_producer (wt->render_node, "aux", NULL);
gegl_node_disconnect (wt->render_node, "aux");
gegl_node_connect_to (last_op, "output",
new_op, "input");
gegl_node_connect_to (new_op, "output",
wt->render_node, "aux");
}
static void
gimp_filter_stack_remove_node (GimpFilterStack *stack,
GimpFilter *filter)
{
GimpFilter *filter_below;
GeglNode *node_above;
GeglNode *node_below;
GeglNode *node;
gint index;
node = gimp_filter_get_node (filter);
gegl_node_disconnect (node, "input");
index = gimp_container_get_child_index (GIMP_CONTAINER (stack),
GIMP_OBJECT (filter));
if (index == 0)
{
node_above = gegl_node_get_output_proxy (stack->graph, "output");
}
else
{
GimpFilter *filter_above = (GimpFilter *)
gimp_container_get_child_by_index (GIMP_CONTAINER (stack), index - 1);
node_above = gimp_filter_get_node (filter_above);
}
filter_below = (GimpFilter *)
gimp_container_get_child_by_index (GIMP_CONTAINER (stack), index + 1);
if (filter_below)
{
node_below = gimp_filter_get_node (filter_below);
}
else
{
node_below = gegl_node_get_input_proxy (stack->graph, "input");
}
gegl_node_connect_to (node_below, "output",
node_above, "input");
}
GeglBuffer *
gimp_applicator_dup_apply_buffer (GimpApplicator *applicator,
const GeglRectangle *rect)
{
GeglBuffer *buffer;
GeglNode *offset;
GeglNode *dest;
buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, rect->width, rect->height),
babl_format ("RGBA float"));
offset = gegl_node_new_child (applicator->node,
"operation", "gegl:translate",
"x",
(gdouble) - applicator->apply_offset_x - rect->x,
"y",
(gdouble) - applicator->apply_offset_y - rect->y,
NULL);
dest = gegl_node_new_child (applicator->node,
"operation", "gegl:write-buffer",
"buffer", buffer,
NULL);
gegl_node_link_many (applicator->apply_offset_node,
offset,
dest,
NULL);
gegl_node_blit (dest, 1.0, GEGL_RECTANGLE (0, 0, rect->width, rect->height),
NULL, NULL, 0, GEGL_BLIT_DEFAULT);
gegl_node_disconnect (offset, "input");
gegl_node_remove_child (applicator->node, offset);
gegl_node_remove_child (applicator->node, dest);
return buffer;
}
void
gimp_applicator_set_mask_buffer (GimpApplicator *applicator,
GeglBuffer *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;
}
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;
}
}
