void
gimp_plug_in_progress_end (GimpPlugIn *plug_in,
GimpPlugInProcFrame *proc_frame)
{
g_return_if_fail (GIMP_IS_PLUG_IN (plug_in));
g_return_if_fail (proc_frame != NULL);
if (proc_frame->progress)
{
if (proc_frame->progress_cancel_id)
{
g_signal_handler_disconnect (proc_frame->progress,
proc_frame->progress_cancel_id);
proc_frame->progress_cancel_id = 0;
}
if (gimp_plug_in_progress_detach (proc_frame->progress) < 1 &&
gimp_progress_is_active (proc_frame->progress))
{
gimp_progress_end (proc_frame->progress);
}
if (proc_frame->progress_created)
{
gimp_free_progress (plug_in->manager->gimp, proc_frame->progress);
g_object_unref (proc_frame->progress);
proc_frame->progress = NULL;
}
}
}
static void
gimp_gegl_progress_callback (GObject *object,
gdouble value,
GimpProgress *progress)
{
const gchar *text;
text = g_object_get_data (object, "gimp-progress-text");
if (text)
{
if (value == 0.0)
{
if (gimp_progress_is_active (progress))
gimp_progress_set_text (progress, "%s", text);
else
gimp_progress_start (progress, FALSE, "%s", text);
return;
}
else if (value == 1.0)
{
gimp_progress_end (progress);
return;
}
}
gimp_progress_set_value (progress, value);
}
static gboolean
gimp_file_dialog_progress_is_active (GimpProgress *progress)
{
GimpFileDialog *dialog = GIMP_FILE_DIALOG (progress);
return gimp_progress_is_active (GIMP_PROGRESS (dialog->progress));
}
static gboolean
gimp_display_shell_progress_is_active (GimpProgress *progress)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (progress);
GimpStatusbar *statusbar = gimp_display_shell_get_statusbar (shell);
return gimp_progress_is_active (GIMP_PROGRESS (statusbar));
}
void
gimp_plug_in_progress_pulse (GimpPlugIn *plug_in)
{
GimpPlugInProcFrame *proc_frame;
g_return_if_fail (GIMP_IS_PLUG_IN (plug_in));
proc_frame = gimp_plug_in_get_proc_frame (plug_in);
if (! proc_frame->progress ||
! gimp_progress_is_active (proc_frame->progress) ||
! proc_frame->progress_cancel_id)
{
gimp_plug_in_progress_start (plug_in, NULL, NULL);
}
if (proc_frame->progress && gimp_progress_is_active (proc_frame->progress))
gimp_progress_pulse (proc_frame->progress);
}
static gboolean
gimp_progress_dialog_progress_is_active (GimpProgress *progress)
{
GimpProgressDialog *dialog = GIMP_PROGRESS_DIALOG (progress);
if (! dialog->box)
return FALSE;
return gimp_progress_is_active (GIMP_PROGRESS (dialog->box));
}
static gboolean
gimp_sub_progress_is_active (GimpProgress *progress)
{
GimpSubProgress *sub = GIMP_SUB_PROGRESS (progress);
if (sub->progress)
return gimp_progress_is_active (sub->progress);
return FALSE;
}
static gboolean
gimp_display_progress_is_active (GimpProgress *progress)
{
GimpDisplay *display = GIMP_DISPLAY (progress);
if (display->shell)
return gimp_progress_is_active (GIMP_PROGRESS (display->shell));
return FALSE;
}
void
gimp_plug_in_progress_start (GimpPlugIn *plug_in,
const gchar *message,
GimpObject *display)
{
GimpPlugInProcFrame *proc_frame;
g_return_if_fail (GIMP_IS_PLUG_IN (plug_in));
g_return_if_fail (display == NULL || GIMP_IS_OBJECT (display));
proc_frame = gimp_plug_in_get_proc_frame (plug_in);
if (! proc_frame->progress)
{
proc_frame->progress = gimp_new_progress (plug_in->manager->gimp,
display);
if (proc_frame->progress)
{
proc_frame->progress_created = TRUE;
g_object_ref (proc_frame->progress);
gimp_plug_in_progress_attach (proc_frame->progress);
}
}
if (proc_frame->progress)
{
if (! proc_frame->progress_cancel_id)
proc_frame->progress_cancel_id =
g_signal_connect (proc_frame->progress, "cancel",
G_CALLBACK (gimp_plug_in_progress_cancel_callback),
plug_in);
if (gimp_progress_is_active (proc_frame->progress))
{
if (message)
gimp_progress_set_text (proc_frame->progress, message);
if (gimp_progress_get_value (proc_frame->progress) > 0.0)
gimp_progress_set_value (proc_frame->progress, 0.0);
}
else
{
gimp_progress_start (proc_frame->progress,
message ? message : "",
TRUE);
}
}
}
void
gimp_gegl_apply_operation (GeglBuffer *src_buffer,
GimpProgress *progress,
const gchar *undo_desc,
GeglNode *operation,
GeglBuffer *dest_buffer,
const GeglRectangle *dest_rect)
{
GeglNode *gegl;
GeglNode *dest_node;
GeglRectangle rect = { 0, };
gdouble value;
gboolean progress_active = FALSE;
g_return_if_fail (src_buffer == NULL || GEGL_IS_BUFFER (src_buffer));
g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
g_return_if_fail (GEGL_IS_NODE (operation));
g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
if (dest_rect)
{
rect = *dest_rect;
}
else
{
rect = *GEGL_RECTANGLE (0, 0, gegl_buffer_get_width (dest_buffer),
gegl_buffer_get_height (dest_buffer));
}
gegl = gegl_node_new ();
if (! gegl_node_get_parent (operation))
gegl_node_add_child (gegl, operation);
if (src_buffer && gegl_node_has_pad (operation, "input"))
{
GeglNode *src_node;
/* dup() because reading and writing the same buffer doesn't
* work with area ops when using a processor. See bug #701875.
*/
if (progress && (src_buffer == dest_buffer))
src_buffer = gegl_buffer_dup (src_buffer);
else
g_object_ref (src_buffer);
src_node = gegl_node_new_child (gegl,
"operation", "gegl:buffer-source",
"buffer", src_buffer,
NULL);
g_object_unref (src_buffer);
gegl_node_connect_to (src_node, "output",
operation, "input");
}
dest_node = gegl_node_new_child (gegl,
"operation", "gegl:write-buffer",
"buffer", dest_buffer,
NULL);
gegl_node_connect_to (operation, "output",
dest_node, "input");
if (progress)
{
GeglProcessor *processor;
processor = gegl_node_new_processor (dest_node, &rect);
progress_active = gimp_progress_is_active (progress);
if (progress_active)
{
if (undo_desc)
gimp_progress_set_text (progress, undo_desc);
}
else
{
gimp_progress_start (progress, undo_desc, FALSE);
}
while (gegl_processor_work (processor, &value))
gimp_progress_set_value (progress, value);
g_object_unref (processor);
}
else
{
gegl_node_blit (dest_node, 1.0, &rect,
NULL, NULL, 0, GEGL_BLIT_DEFAULT);
}
g_object_unref (gegl);
if (progress && ! progress_active)
gimp_progress_end (progress);
}
gboolean
gimp_gegl_apply_cached_operation (GeglBuffer *src_buffer,
GimpProgress *progress,
const gchar *undo_desc,
GeglNode *operation,
GeglBuffer *dest_buffer,
const GeglRectangle *dest_rect,
GeglBuffer *cache,
const GeglRectangle *valid_rects,
gint n_valid_rects,
gboolean cancellable)
{
GeglNode *gegl;
GeglNode *dest_node;
GeglRectangle rect = { 0, };
GeglProcessor *processor = NULL;
gboolean progress_started = FALSE;
gdouble value;
gboolean cancel = FALSE;
g_return_val_if_fail (src_buffer == NULL || GEGL_IS_BUFFER (src_buffer), FALSE);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE);
g_return_val_if_fail (GEGL_IS_NODE (operation), FALSE);
g_return_val_if_fail (GEGL_IS_BUFFER (dest_buffer), FALSE);
g_return_val_if_fail (cache == NULL || GEGL_IS_BUFFER (cache), FALSE);
g_return_val_if_fail (valid_rects == NULL || cache != NULL, FALSE);
g_return_val_if_fail (valid_rects == NULL || n_valid_rects != 0, FALSE);
if (dest_rect)
{
rect = *dest_rect;
}
else
{
rect = *GEGL_RECTANGLE (0, 0, gegl_buffer_get_width (dest_buffer),
gegl_buffer_get_height (dest_buffer));
}
gegl = gegl_node_new ();
if (! gegl_node_get_parent (operation))
gegl_node_add_child (gegl, operation);
if (src_buffer && gegl_node_has_pad (operation, "input"))
{
GeglNode *src_node;
/* dup() because reading and writing the same buffer doesn't
* work with area ops when using a processor. See bug #701875.
*/
if (progress && (src_buffer == dest_buffer))
src_buffer = gegl_buffer_dup (src_buffer);
else
g_object_ref (src_buffer);
src_node = gegl_node_new_child (gegl,
"operation", "gegl:buffer-source",
"buffer", src_buffer,
NULL);
g_object_unref (src_buffer);
gegl_node_connect_to (src_node, "output",
operation, "input");
}
dest_node = gegl_node_new_child (gegl,
"operation", "gegl:write-buffer",
"buffer", dest_buffer,
NULL);
gegl_node_connect_to (operation, "output",
dest_node, "input");
if (progress)
{
processor = gegl_node_new_processor (dest_node, &rect);
if (gimp_progress_is_active (progress))
{
if (undo_desc)
gimp_progress_set_text_literal (progress, undo_desc);
progress_started = FALSE;
cancellable = FALSE;
}
else
{
gimp_progress_start (progress, cancellable, "%s", undo_desc);
if (cancellable)
g_signal_connect (progress, "cancel",
G_CALLBACK (gimp_gegl_apply_operation_cancel),
&cancel);
progress_started = TRUE;
}
}
if (cache)
{
cairo_region_t *region;
gint all_pixels;
gint done_pixels = 0;
gint n_rects;
gint i;
region = cairo_region_create_rectangle ((cairo_rectangle_int_t *) &rect);
all_pixels = rect.width * rect.height;
for (i = 0; i < n_valid_rects; i++)
{
gegl_buffer_copy (cache, valid_rects + i, GEGL_ABYSS_NONE,
dest_buffer, valid_rects + i);
cairo_region_subtract_rectangle (region,
(cairo_rectangle_int_t *)
valid_rects + i);
done_pixels += valid_rects[i].width * valid_rects[i].height;
if (progress)
gimp_progress_set_value (progress,
(gdouble) done_pixels /
(gdouble) all_pixels);
}
n_rects = cairo_region_num_rectangles (region);
for (i = 0; ! cancel && (i < n_rects); i++)
{
cairo_rectangle_int_t render_rect;
cairo_region_get_rectangle (region, i, &render_rect);
if (progress)
{
gint rect_pixels = render_rect.width * render_rect.height;
#ifdef REUSE_PROCESSOR
gegl_processor_set_rectangle (processor,
(GeglRectangle *) &render_rect);
#else
g_object_unref (processor);
processor = gegl_node_new_processor (dest_node,
(GeglRectangle *) &render_rect);
#endif
while (! cancel && gegl_processor_work (processor, &value))
{
gimp_progress_set_value (progress,
((gdouble) done_pixels +
value * rect_pixels) /
(gdouble) all_pixels);
if (cancellable)
while (! cancel && g_main_context_pending (NULL))
g_main_context_iteration (NULL, FALSE);
}
done_pixels += rect_pixels;
}
else
{
gegl_node_blit (dest_node, 1.0, (GeglRectangle *) &render_rect,
NULL, NULL, 0, GEGL_BLIT_DEFAULT);
}
}
cairo_region_destroy (region);
}
else
{
if (progress)
{
while (! cancel && gegl_processor_work (processor, &value))
{
gimp_progress_set_value (progress, value);
if (cancellable)
while (! cancel && g_main_context_pending (NULL))
g_main_context_iteration (NULL, FALSE);
}
}
else
{
gegl_node_blit (dest_node, 1.0, &rect,
NULL, NULL, 0, GEGL_BLIT_DEFAULT);
}
}
if (processor)
g_object_unref (processor);
g_object_unref (gegl);
if (progress_started)
{
gimp_progress_end (progress);
if (cancellable)
g_signal_handlers_disconnect_by_func (progress,
gimp_gegl_apply_operation_cancel,
&cancel);
}
return ! cancel;
}
