static void
gimp_image_map_tool_create_map (GimpImageMapTool *tool)
{
GimpImageMapOptions *options = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (tool);
GimpToolInfo *tool_info = GIMP_TOOL (tool)->tool_info;
if (tool->image_map)
{
gimp_image_map_abort (tool->image_map);
g_object_unref (tool->image_map);
}
g_assert (tool->operation);
tool->image_map = gimp_image_map_new (tool->drawable,
tool->undo_desc,
tool->operation,
gimp_viewable_get_icon_name (GIMP_VIEWABLE (tool_info)));
gimp_image_map_set_region (tool->image_map, options->region);
g_signal_connect (tool->image_map, "flush",
G_CALLBACK (gimp_image_map_tool_flush),
tool);
}
static void
gimp_blend_tool_halt_preview (GimpBlendTool *blend_tool)
{
GimpTool *tool = GIMP_TOOL (blend_tool);
if (blend_tool->graph)
{
g_object_unref (blend_tool->graph);
blend_tool->graph = NULL;
blend_tool->render_node = NULL;
}
if (blend_tool->image_map)
{
gimp_image_map_abort (blend_tool->image_map);
g_object_unref (blend_tool->image_map);
blend_tool->image_map = NULL;
gimp_image_flush (gimp_display_get_image (tool->display));
}
tool->display = NULL;
tool->drawable = NULL;
if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (blend_tool)))
gimp_draw_tool_stop (GIMP_DRAW_TOOL (blend_tool));
}
static void
gimp_image_map_tool_options_notify (GimpTool *tool,
GimpToolOptions *options,
const GParamSpec *pspec)
{
GimpImageMapTool *image_map_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpImageMapOptions *im_options = GIMP_IMAGE_MAP_OPTIONS (options);
if (! strcmp (pspec->name, "preview") &&
image_map_tool->image_map)
{
if (im_options->preview)
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_map_tool_map (image_map_tool);
gimp_tool_control_pop_preserve (tool->control);
}
else
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_map_abort (image_map_tool->image_map);
gimp_tool_control_pop_preserve (tool->control);
}
}
else if (! strcmp (pspec->name, "region") &&
image_map_tool->image_map)
{
gimp_image_map_set_region (image_map_tool->image_map, im_options->region);
gimp_image_map_tool_preview (image_map_tool);
}
}
static void
gimp_cage_tool_start (GimpCageTool *ct,
GimpDisplay *display)
{
GimpTool *tool = GIMP_TOOL (ct);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
gint off_x;
gint off_y;
gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);
tool->display = display;
if (ct->config)
{
g_object_unref (ct->config);
ct->config = NULL;
}
if (ct->coef)
{
g_object_unref (ct->coef);
ct->dirty_coef = TRUE;
ct->coef = NULL;
}
if (ct->image_map)
{
gimp_image_map_abort (ct->image_map);
g_object_unref (ct->image_map);
ct->image_map = NULL;
}
if (ct->render_node)
{
g_object_unref (ct->render_node);
ct->render_node = NULL;
ct->coef_node = NULL;
ct->cage_node = NULL;
}
ct->config = g_object_new (GIMP_TYPE_CAGE_CONFIG, NULL);
ct->hovering_handle = -1;
ct->hovering_edge = -1;
ct->cage_complete = FALSE;
ct->tool_state = CAGE_STATE_INIT;
/* Setting up cage offset to convert the cage point coords to
* drawable coords
*/
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
ct->offset_x = off_x;
ct->offset_y = off_y;
gimp_draw_tool_start (GIMP_DRAW_TOOL (ct), display);
}
static void
gimp_cage_tool_control (GimpTool *tool,
GimpToolAction action,
GimpDisplay *display)
{
GimpCageTool *ct = GIMP_CAGE_TOOL (tool);
switch (action)
{
case GIMP_TOOL_ACTION_PAUSE:
case GIMP_TOOL_ACTION_RESUME:
break;
case GIMP_TOOL_ACTION_HALT:
if (ct->config)
{
g_object_unref (ct->config);
ct->config = NULL;
}
if (ct->coef)
{
g_object_unref (ct->coef);
ct->coef = NULL;
}
if (ct->render_node)
{
g_object_unref (ct->render_node);
ct->render_node = NULL;
ct->coef_node = NULL;
ct->cage_node = NULL;
}
if (ct->image_map)
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_map_abort (ct->image_map);
g_object_unref (ct->image_map);
ct->image_map = NULL;
gimp_tool_control_pop_preserve (tool->control);
gimp_image_flush (gimp_display_get_image (tool->display));
}
tool->display = NULL;
g_object_set (gimp_tool_get_options (tool),
"cage-mode", GIMP_CAGE_MODE_CAGE_CHANGE,
NULL);
break;
}
GIMP_TOOL_CLASS (parent_class)->control (tool, action, display);
}
static void
gimp_warp_tool_halt (GimpWarpTool *wt)
{
GimpTool *tool = GIMP_TOOL (wt);
GimpWarpOptions *options = GIMP_WARP_TOOL_GET_OPTIONS (wt);
if (wt->coords_buffer)
{
g_object_unref (wt->coords_buffer);
wt->coords_buffer = NULL;
}
if (wt->graph)
{
g_object_unref (wt->graph);
wt->graph = NULL;
wt->render_node = NULL;
}
if (wt->image_map)
{
gimp_image_map_abort (wt->image_map);
g_object_unref (wt->image_map);
wt->image_map = NULL;
gimp_image_flush (gimp_display_get_image (tool->display));
}
if (wt->redo_stack)
{
g_list_free_full (wt->redo_stack, (GDestroyNotify) g_object_unref);
wt->redo_stack = NULL;
}
tool->display = NULL;
tool->drawable = NULL;
if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (wt)))
gimp_draw_tool_stop (GIMP_DRAW_TOOL (wt));
if (options->animate_button)
{
gtk_widget_set_sensitive (options->animate_button, FALSE);
g_signal_handlers_disconnect_by_func (options->animate_button,
gimp_warp_tool_animate,
wt);
}
}
static void
gimp_cage_tool_halt (GimpCageTool *ct)
{
GimpTool *tool = GIMP_TOOL (ct);
if (ct->config)
{
g_object_unref (ct->config);
ct->config = NULL;
}
if (ct->coef)
{
g_object_unref (ct->coef);
ct->coef = NULL;
}
if (ct->render_node)
{
g_object_unref (ct->render_node);
ct->render_node = NULL;
ct->coef_node = NULL;
ct->cage_node = NULL;
}
if (ct->image_map)
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_map_abort (ct->image_map);
g_object_unref (ct->image_map);
ct->image_map = NULL;
gimp_tool_control_pop_preserve (tool->control);
gimp_image_flush (gimp_display_get_image (tool->display));
}
tool->display = NULL;
g_object_set (gimp_tool_get_options (tool),
"cage-mode", GIMP_CAGE_MODE_CAGE_CHANGE,
NULL);
}
static void
gimp_image_map_tool_halt (GimpImageMapTool *im_tool)
{
GimpTool *tool = GIMP_TOOL (im_tool);
if (im_tool->gui)
gimp_tool_gui_hide (im_tool->gui);
if (im_tool->image_map)
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_map_abort (im_tool->image_map);
g_object_unref (im_tool->image_map);
im_tool->image_map = NULL;
gimp_tool_control_pop_preserve (tool->control);
}
tool->drawable = NULL;
}
static void
gimp_warp_tool_halt (GimpWarpTool *wt)
{
GimpTool *tool = GIMP_TOOL (wt);
if (wt->coords_buffer)
{
g_object_unref (wt->coords_buffer);
wt->coords_buffer = NULL;
}
if (wt->graph)
{
g_object_unref (wt->graph);
wt->graph = NULL;
wt->render_node = NULL;
}
if (wt->image_map)
{
gimp_image_map_abort (wt->image_map);
g_object_unref (wt->image_map);
wt->image_map = NULL;
gimp_image_flush (gimp_display_get_image (tool->display));
}
if (wt->redo_stack)
{
g_list_free_full (wt->redo_stack, (GDestroyNotify) g_object_unref);
wt->redo_stack = NULL;
}
tool->display = NULL;
tool->drawable = NULL;
if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (wt)))
gimp_draw_tool_stop (GIMP_DRAW_TOOL (wt));
}
/**
* gimp_seamless_clone_tool_stop:
* @sc: The seamless clone tool whose resources should be freed
* @display_change_only: Mark that the only reason for this call was a
* switch of the working display.
*
* This function frees any resources associated with the seamless clone
* tool, including caches, gegl graphs, and anything the tool created.
* Afterwards, it initializes all the relevant pointers to some initial
* value (usually NULL) like the init function does.
*
* Note that for seamless cloning, no change needs to be done when
* switching to a different display, except for clearing the image map.
* So for that, we provide a boolean parameter to specify that the only
* change was one of the display
*/
static void
gimp_seamless_clone_tool_stop (GimpSeamlessCloneTool *sc,
gboolean display_change_only)
{
/* See if we actually have any reason to stop */
if (sc->tool_state == SC_STATE_INIT)
return;
if (! display_change_only)
{
sc->tool_state = SC_STATE_INIT;
if (sc->paste)
{
g_object_unref (sc->paste);
sc->paste = NULL;
}
if (sc->render_node)
{
g_object_unref (sc->render_node);
sc->render_node = NULL;
sc->sc_node = NULL;
}
}
/* This should always happen, even when we just switch a display */
if (sc->image_map)
{
gimp_image_map_abort (sc->image_map);
g_object_unref (sc->image_map);
sc->image_map = NULL;
if (GIMP_TOOL (sc)->display)
gimp_image_flush (gimp_display_get_image (GIMP_TOOL (sc)->display));
}
gimp_draw_tool_stop (GIMP_DRAW_TOOL (sc));
}
static void
gimp_image_map_tool_create_map (GimpImageMapTool *im_tool)
{
GimpImageMapOptions *options = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (im_tool);
if (im_tool->image_map)
{
gimp_image_map_abort (im_tool->image_map);
g_object_unref (im_tool->image_map);
}
g_assert (im_tool->operation);
im_tool->image_map = gimp_image_map_new (im_tool->drawable,
im_tool->undo_desc,
im_tool->operation,
im_tool->icon_name);
gimp_image_map_set_region (im_tool->image_map, options->region);
g_signal_connect (im_tool->image_map, "flush",
G_CALLBACK (gimp_image_map_tool_flush),
im_tool);
}
static void
gimp_cage_tool_options_notify (GimpTool *tool,
GimpToolOptions *options,
const GParamSpec *pspec)
{
GimpCageTool *ct = GIMP_CAGE_TOOL (tool);
GIMP_TOOL_CLASS (parent_class)->options_notify (tool, options, pspec);
if (! tool->display)
return;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
if (strcmp (pspec->name, "cage-mode") == 0)
{
GimpCageMode mode;
g_object_get (options,
"cage-mode", &mode,
NULL);
if (mode == GIMP_CAGE_MODE_DEFORM)
{
/* switch to deform mode */
gimp_cage_config_reset_displacement (ct->config);
gimp_cage_config_reverse_cage_if_needed (ct->config);
gimp_tool_push_status (tool, tool->display,
_("Press ENTER to commit the transform"));
ct->tool_state = DEFORM_STATE_WAIT;
if (! ct->render_node)
{
gimp_cage_tool_create_render_node (ct);
}
if (ct->dirty_coef)
{
gimp_cage_tool_compute_coef (ct);
gimp_cage_tool_render_node_update (ct);
}
if (! ct->image_map)
{
GimpImage *image = gimp_display_get_image (tool->display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
gimp_cage_tool_create_image_map (ct, drawable);
}
gimp_cage_tool_image_map_update (ct);
}
else
{
/* switch to edit mode */
gimp_image_map_abort (ct->image_map);
gimp_tool_pop_status (tool, tool->display);
ct->tool_state = CAGE_STATE_WAIT;
}
}
else if (strcmp (pspec->name, "fill-plain-color") == 0)
{
gimp_cage_tool_render_node_update (ct);
gimp_cage_tool_image_map_update (ct);
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_image_map_tool_options_notify (GimpTool *tool,
GimpToolOptions *options,
const GParamSpec *pspec)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpImageMapOptions *im_options = GIMP_IMAGE_MAP_OPTIONS (options);
if (! strcmp (pspec->name, "preview") &&
im_tool->image_map)
{
if (im_options->preview)
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_map_apply (im_tool->image_map, NULL);
gimp_tool_control_pop_preserve (tool->control);
if (im_options->preview_split)
gimp_image_map_tool_add_guide (im_tool);
}
else
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_map_abort (im_tool->image_map);
gimp_tool_control_pop_preserve (tool->control);
if (im_options->preview_split)
gimp_image_map_tool_remove_guide (im_tool);
}
}
else if (! strcmp (pspec->name, "preview-split") &&
im_tool->image_map)
{
if (im_options->preview_split)
{
GimpDisplayShell *shell = gimp_display_get_shell (tool->display);
GimpItem *item = GIMP_ITEM (im_tool->drawable);
gint x, y, width, height;
gimp_display_shell_untransform_viewport (shell,
&x, &y, &width, &height);
if (gimp_rectangle_intersect (gimp_item_get_offset_x (item),
gimp_item_get_offset_y (item),
gimp_item_get_width (item),
gimp_item_get_height (item),
x, y, width, height,
&x, &y, &width, &height))
{
gdouble position;
if (im_options->preview_alignment == GIMP_ALIGN_LEFT ||
im_options->preview_alignment == GIMP_ALIGN_RIGHT)
{
position = ((gdouble) ((x + width / 2) -
gimp_item_get_offset_x (item)) /
(gdouble) gimp_item_get_width (item));
}
else
{
position = ((gdouble) ((y + height / 2) -
gimp_item_get_offset_y (item)) /
(gdouble) gimp_item_get_height (item));
}
g_object_set (options,
"preview-position", CLAMP (position, 0.0, 1.0),
NULL);
}
}
gimp_image_map_set_preview (im_tool->image_map,
im_options->preview_split,
im_options->preview_alignment,
im_options->preview_position);
if (im_options->preview_split)
gimp_image_map_tool_add_guide (im_tool);
else
gimp_image_map_tool_remove_guide (im_tool);
}
else if (! strcmp (pspec->name, "preview-alignment") &&
im_tool->image_map)
{
gimp_image_map_set_preview (im_tool->image_map,
im_options->preview_split,
im_options->preview_alignment,
im_options->preview_position);
if (im_options->preview_split)
gimp_image_map_tool_move_guide (im_tool);
}
else if (! strcmp (pspec->name, "preview-position") &&
im_tool->image_map)
{
gimp_image_map_set_preview (im_tool->image_map,
im_options->preview_split,
im_options->preview_alignment,
im_options->preview_position);
if (im_options->preview_split)
gimp_image_map_tool_move_guide (im_tool);
}
else if (! strcmp (pspec->name, "region") &&
im_tool->image_map)
{
gimp_image_map_set_region (im_tool->image_map, im_options->region);
gimp_image_map_tool_preview (im_tool);
}
}
static void
gimp_warp_tool_animate (GimpWarpTool *wt)
{
GimpTool *tool = GIMP_TOOL (wt);
GimpWarpOptions *options = GIMP_WARP_TOOL_GET_OPTIONS (wt);
GimpImage *orig_image;
GimpImage *image;
GimpLayer *layer;
GimpLayer *first_layer;
GeglNode *scale_node;
GimpProgress *progress;
GtkWidget *widget;
gint i;
if (! gimp_warp_tool_get_undo_desc (tool, tool->display))
{
gimp_tool_message_literal (tool, tool->display,
_("Please add some warp strokes first."));
return;
}
/* get rid of the image map so we can use wt->graph */
if (wt->image_map)
{
gimp_image_map_abort (wt->image_map);
g_object_unref (wt->image_map);
wt->image_map = NULL;
}
gimp_progress_start (GIMP_PROGRESS (tool), FALSE,
_("Rendering Frame %d"), 1);
orig_image = gimp_item_get_image (GIMP_ITEM (tool->drawable));
image = gimp_create_image (orig_image->gimp,
gimp_item_get_width (GIMP_ITEM (tool->drawable)),
gimp_item_get_height (GIMP_ITEM (tool->drawable)),
gimp_drawable_get_base_type (tool->drawable),
gimp_drawable_get_precision (tool->drawable),
TRUE);
/* the first frame is always the unwarped image */
layer = GIMP_LAYER (gimp_item_convert (GIMP_ITEM (tool->drawable), image,
GIMP_TYPE_LAYER));
gimp_object_take_name (GIMP_OBJECT (layer),
g_strdup_printf (_("Frame %d"), 1));
gimp_item_set_offset (GIMP_ITEM (layer), 0, 0);
gimp_item_set_visible (GIMP_ITEM (layer), TRUE, FALSE);
gimp_layer_set_mode (layer, GIMP_NORMAL_MODE, FALSE);
gimp_layer_set_opacity (layer, GIMP_OPACITY_OPAQUE, FALSE);
gimp_image_add_layer (image, layer, NULL, 0, FALSE);
first_layer = layer;
scale_node = gegl_node_new_child (NULL,
"operation", "gimp:scalar-multiply",
"n-components", 2,
NULL);
gimp_warp_tool_add_op (wt, scale_node);
progress = gimp_sub_progress_new (GIMP_PROGRESS (tool));
for (i = 1; i < options->n_animation_frames; i++)
{
gimp_progress_set_text (GIMP_PROGRESS (tool),
_("Rendering Frame %d"), i + 1);
gimp_sub_progress_set_step (GIMP_SUB_PROGRESS (progress),
i, options->n_animation_frames);
layer = GIMP_LAYER (gimp_item_duplicate (GIMP_ITEM (first_layer),
GIMP_TYPE_LAYER));
gimp_object_take_name (GIMP_OBJECT (layer),
g_strdup_printf (_("Frame %d"), i + 1));
gegl_node_set (scale_node,
"factor", (gdouble) i /
(gdouble) (options->n_animation_frames - 1),
NULL);
gimp_gegl_apply_operation (gimp_drawable_get_buffer (GIMP_DRAWABLE (first_layer)),
progress,
_("Frame"),
wt->graph,
gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)),
NULL);
gimp_image_add_layer (image, layer, NULL, 0, FALSE);
}
g_object_unref (progress);
gimp_warp_tool_remove_op (wt, scale_node);
gimp_progress_end (GIMP_PROGRESS (tool));
/* recreate the image map */
gimp_warp_tool_create_image_map (wt, tool->drawable);
gimp_image_map_apply (wt->image_map, NULL);
widget = GTK_WIDGET (gimp_display_get_shell (tool->display));
gimp_create_display (orig_image->gimp, image, GIMP_UNIT_PIXEL, 1.0,
G_OBJECT (gtk_widget_get_screen (widget)),
gimp_widget_get_monitor (widget));
g_object_unref (image);
}
void
gimp_image_map_tool_get_operation (GimpImageMapTool *image_map_tool)
{
GimpImageMapToolClass *klass;
gchar *operation_name;
g_return_if_fail (GIMP_IS_IMAGE_MAP_TOOL (image_map_tool));
klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (image_map_tool);
if (image_map_tool->image_map)
{
gimp_image_map_abort (image_map_tool->image_map);
g_object_unref (image_map_tool->image_map);
image_map_tool->image_map = NULL;
}
if (image_map_tool->operation)
{
g_object_unref (image_map_tool->operation);
image_map_tool->operation = NULL;
}
if (image_map_tool->config)
{
g_signal_handlers_disconnect_by_func (image_map_tool->config,
gimp_image_map_tool_config_notify,
image_map_tool);
g_object_unref (image_map_tool->config);
image_map_tool->config = NULL;
}
if (image_map_tool->undo_desc)
{
g_free (image_map_tool->undo_desc);
image_map_tool->undo_desc = NULL;
}
image_map_tool->operation = klass->get_operation (image_map_tool,
&image_map_tool->config,
&image_map_tool->undo_desc);
if (! image_map_tool->undo_desc)
image_map_tool->undo_desc =
g_strdup (GIMP_TOOL (image_map_tool)->tool_info->blurb);
gegl_node_get (image_map_tool->operation,
"operation", &operation_name,
NULL);
if (operation_name &&
gegl_operation_get_key (operation_name, "position-dependent"))
{
if (image_map_tool->region_combo)
gtk_widget_show (image_map_tool->region_combo);
}
else
{
if (image_map_tool->region_combo)
gtk_widget_show (image_map_tool->region_combo);
g_object_set (GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (image_map_tool),
"region", GIMP_IMAGE_MAP_REGION_SELECTION,
NULL);
}
g_free (operation_name);
if (image_map_tool->config)
g_signal_connect_object (image_map_tool->config, "notify",
G_CALLBACK (gimp_image_map_tool_config_notify),
G_OBJECT (image_map_tool), 0);
if (GIMP_TOOL (image_map_tool)->drawable)
gimp_image_map_tool_create_map (image_map_tool);
}
static void
gimp_image_map_tool_response (GtkWidget *widget,
gint response_id,
GimpImageMapTool *image_map_tool)
{
GimpTool *tool = GIMP_TOOL (image_map_tool);
switch (response_id)
{
case RESPONSE_RESET:
gimp_image_map_tool_reset (image_map_tool);
gimp_image_map_tool_preview (image_map_tool);
break;
case GTK_RESPONSE_OK:
gimp_dialog_factory_hide_dialog (image_map_tool->shell);
if (image_map_tool->image_map)
{
GimpImageMapOptions *options = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (tool);
gimp_tool_control_set_preserve (tool->control, TRUE);
if (! options->preview)
gimp_image_map_tool_map (image_map_tool);
gimp_image_map_commit (image_map_tool->image_map);
g_object_unref (image_map_tool->image_map);
image_map_tool->image_map = NULL;
gimp_tool_control_set_preserve (tool->control, FALSE);
gimp_image_flush (tool->display->image);
if (image_map_tool->config)
gimp_settings_box_add_current (GIMP_SETTINGS_BOX (image_map_tool->settings_box));
}
tool->display = NULL;
tool->drawable = NULL;
break;
default:
gimp_dialog_factory_hide_dialog (image_map_tool->shell);
if (image_map_tool->image_map)
{
gimp_tool_control_set_preserve (tool->control, TRUE);
gimp_image_map_abort (image_map_tool->image_map);
g_object_unref (image_map_tool->image_map);
image_map_tool->image_map = NULL;
gimp_tool_control_set_preserve (tool->control, FALSE);
gimp_image_flush (tool->display->image);
}
tool->display = NULL;
tool->drawable = NULL;
break;
}
}
void
gimp_image_map_tool_get_operation (GimpImageMapTool *im_tool)
{
GimpImageMapToolClass *klass;
GimpToolInfo *tool_info;
gchar *operation_name;
g_return_if_fail (GIMP_IS_IMAGE_MAP_TOOL (im_tool));
klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (im_tool);
tool_info = GIMP_TOOL (im_tool)->tool_info;
if (im_tool->image_map)
{
gimp_image_map_abort (im_tool->image_map);
g_object_unref (im_tool->image_map);
im_tool->image_map = NULL;
}
if (im_tool->operation)
{
g_object_unref (im_tool->operation);
im_tool->operation = NULL;
}
if (im_tool->config)
{
g_signal_handlers_disconnect_by_func (im_tool->config,
gimp_image_map_tool_config_notify,
im_tool);
g_object_unref (im_tool->config);
im_tool->config = NULL;
}
if (im_tool->default_config)
{
g_object_unref (im_tool->default_config);
im_tool->default_config = NULL;
}
if (im_tool->title)
{
g_free (im_tool->title);
im_tool->title = NULL;
}
if (im_tool->description)
{
g_free (im_tool->description);
im_tool->description = NULL;
}
if (im_tool->undo_desc)
{
g_free (im_tool->undo_desc);
im_tool->undo_desc = NULL;
}
if (im_tool->icon_name)
{
g_free (im_tool->icon_name);
im_tool->icon_name = NULL;
}
if (im_tool->help_id)
{
g_free (im_tool->help_id);
im_tool->help_id = NULL;
}
operation_name = klass->get_operation (im_tool,
&im_tool->title,
&im_tool->description,
&im_tool->undo_desc,
&im_tool->icon_name,
&im_tool->help_id);
if (! operation_name)
operation_name = g_strdup ("gegl:nop");
if (! im_tool->title)
im_tool->title = g_strdup (tool_info->blurb);
if (! im_tool->description)
im_tool->description = g_strdup (im_tool->title);
if (! im_tool->undo_desc)
im_tool->undo_desc = g_strdup (tool_info->blurb);
if (! im_tool->icon_name)
im_tool->icon_name =
g_strdup (gimp_viewable_get_icon_name (GIMP_VIEWABLE (tool_info)));
if (! im_tool->help_id)
im_tool->help_id = g_strdup (tool_info->help_id);
im_tool->operation = gegl_node_new_child (NULL,
"operation", operation_name,
NULL);
im_tool->config = G_OBJECT (gimp_gegl_config_new (operation_name,
im_tool->icon_name,
GIMP_TYPE_SETTINGS));
gimp_gegl_config_sync_node (GIMP_OBJECT (im_tool->config),
im_tool->operation);
gimp_gegl_config_connect_node (GIMP_OBJECT (im_tool->config),
im_tool->operation);
if (im_tool->gui)
{
gimp_tool_gui_set_title (im_tool->gui, im_tool->title);
gimp_tool_gui_set_description (im_tool->gui, im_tool->description);
gimp_tool_gui_set_icon_name (im_tool->gui, im_tool->icon_name);
gimp_tool_gui_set_help_id (im_tool->gui, im_tool->help_id);
}
if (gegl_operation_get_key (operation_name, "position-dependent"))
{
if (im_tool->gui)
gtk_widget_show (im_tool->region_combo);
}
else
{
if (im_tool->gui)
gtk_widget_hide (im_tool->region_combo);
g_object_set (GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (im_tool),
"region", GIMP_IMAGE_MAP_REGION_SELECTION,
NULL);
}
g_free (operation_name);
g_object_set (GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (im_tool),
"preview-split", FALSE,
"preview-position", 0.5,
NULL);
if (im_tool->config)
g_signal_connect_object (im_tool->config, "notify",
G_CALLBACK (gimp_image_map_tool_config_notify),
G_OBJECT (im_tool), 0);
if (GIMP_TOOL (im_tool)->drawable)
gimp_image_map_tool_create_map (im_tool);
}
