static gboolean
gimp_perspective_clone_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (tool);
if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error))
{
return FALSE;
}
if (display != tool->display)
{
GimpImage *image = gimp_display_get_image (display);
gint i;
tool->display = display;
tool->drawable = gimp_image_get_active_drawable (image);
/* Find the transform bounds initializing */
gimp_perspective_clone_tool_bounds (clone_tool, display);
gimp_perspective_clone_tool_prepare (clone_tool);
/* Recalculate the transform tool */
gimp_perspective_clone_tool_recalc_matrix (clone_tool);
/* start drawing the bounding box and handles... */
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
clone_tool->function = TRANSFORM_CREATING;
/* Save the current transformation info */
for (i = 0; i < TRANS_INFO_SIZE; i++)
clone_tool->old_trans_info[i] = clone_tool->trans_info[i];
}
return TRUE;
}
/**
* gimp_display_shell_untransform_viewport:
* @shell: a #GimpDisplayShell
* @x: returns image x coordinate of display upper left corner
* @y: returns image y coordinate of display upper left corner
* @width: returns width of display measured in image coordinates
* @height: returns height of display measured in image coordinates
*
* This function calculates the part of the image, im image coordinates,
* that corresponds to the display viewport.
**/
void
gimp_display_shell_untransform_viewport (const GimpDisplayShell *shell,
gint *x,
gint *y,
gint *width,
gint *height)
{
GimpImage *image;
gint x1, y1, x2, y2;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
gimp_display_shell_untransform_xy (shell,
0, 0,
&x1, &y1,
FALSE);
gimp_display_shell_untransform_xy (shell,
shell->disp_width, shell->disp_height,
&x2, &y2,
FALSE);
image = gimp_display_get_image (shell->display);
if (x1 < 0)
x1 = 0;
if (y1 < 0)
y1 = 0;
if (x2 > gimp_image_get_width (image))
x2 = gimp_image_get_width (image);
if (y2 > gimp_image_get_height (image))
y2 = gimp_image_get_height (image);
if (x) *x = x1;
if (y) *y = y1;
if (width) *width = x2 - x1;
if (height) *height = y2 - y1;
}
static void
gimp_bucket_fill_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpBucketFillOptions *options = GIMP_BUCKET_FILL_TOOL_GET_OPTIONS (tool);
GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_BAD;
GimpImage *image = gimp_display_get_image (display);
if (gimp_image_coords_in_active_pickable (image, coords,
options->sample_merged, TRUE))
{
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (! gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) &&
! gimp_item_is_content_locked (GIMP_ITEM (drawable)) &&
gimp_item_is_visible (GIMP_ITEM (drawable)))
{
switch (options->fill_mode)
{
case GIMP_BUCKET_FILL_FG:
modifier = GIMP_CURSOR_MODIFIER_FOREGROUND;
break;
case GIMP_BUCKET_FILL_BG:
modifier = GIMP_CURSOR_MODIFIER_BACKGROUND;
break;
case GIMP_BUCKET_FILL_PATTERN:
modifier = GIMP_CURSOR_MODIFIER_PATTERN;
break;
}
}
}
gimp_tool_control_set_cursor_modifier (tool->control, modifier);
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
}
static gboolean
gimp_levels_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpLevelsTool *l_tool = GIMP_LEVELS_TOOL (tool);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (! drawable)
return FALSE;
if (gimp_drawable_is_indexed (drawable))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("Levels does not operate on indexed layers."));
return FALSE;
}
gimp_config_reset (GIMP_CONFIG (l_tool->config));
if (l_tool->active_picker)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (l_tool->active_picker),
FALSE);
if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error))
{
return FALSE;
}
gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (l_tool->channel_menu),
levels_menu_sensitivity, drawable, NULL);
gimp_drawable_calculate_histogram (drawable, l_tool->histogram);
gimp_histogram_view_set_histogram (GIMP_HISTOGRAM_VIEW (l_tool->histogram_view),
l_tool->histogram);
return TRUE;
}
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));
}
static gboolean
gimp_warp_tool_key_press (GimpTool *tool,
GdkEventKey *kevent,
GimpDisplay *display)
{
GimpWarpTool *wt = GIMP_WARP_TOOL (tool);
switch (kevent->keyval)
{
case GDK_KEY_BackSpace:
return TRUE;
case GDK_KEY_Return:
case GDK_KEY_KP_Enter:
case GDK_KEY_ISO_Enter:
if (wt->image_map)
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_map_commit (wt->image_map, GIMP_PROGRESS (tool));
g_object_unref (wt->image_map);
wt->image_map = NULL;
gimp_tool_control_pop_preserve (tool->control);
gimp_image_flush (gimp_display_get_image (display));
}
/* fall thru */
case GDK_KEY_Escape:
gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);
return TRUE;
default:
break;
}
return FALSE;
}
/* We used to calculate the scale factor in the SCALEFACTOR_X() and
* SCALEFACTOR_Y() macros. But since these are rather frequently
* called and the values rarely change, we now store them in the
* shell and call this function whenever they need to be recalculated.
*/
void
gimp_display_shell_scale_update (GimpDisplayShell *shell)
{
GimpImage *image;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
image = gimp_display_get_image (shell->display);
if (image)
{
gimp_display_shell_calculate_scale_x_and_y (shell,
gimp_zoom_model_get_factor (shell->zoom),
&shell->scale_x,
&shell->scale_y);
}
else
{
shell->scale_x = 1.0;
shell->scale_y = 1.0;
}
}
static void
gimp_foreground_select_tool_apply (GimpForegroundSelectTool *fg_select,
GimpDisplay *display)
{
GimpTool *tool = GIMP_TOOL (fg_select);
GimpSelectionOptions *options = GIMP_SELECTION_TOOL_GET_OPTIONS (tool);
GimpImage *image = gimp_display_get_image (display);
g_return_if_fail (fg_select->mask != NULL);
gimp_channel_select_channel (gimp_image_get_mask (image),
C_("command", "Foreground Select"),
fg_select->mask, 0, 0,
options->operation,
options->feather,
options->feather_radius,
options->feather_radius);
gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);
gimp_image_flush (image);
}
static void
gimp_image_map_tool_commit (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)
{
GimpImageMapOptions *options = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (tool);
gimp_tool_control_push_preserve (tool->control, TRUE);
if (! options->preview)
gimp_image_map_apply (im_tool->image_map, NULL);
gimp_image_map_commit (im_tool->image_map, GIMP_PROGRESS (tool), TRUE);
g_object_unref (im_tool->image_map);
im_tool->image_map = NULL;
gimp_tool_control_pop_preserve (tool->control);
gimp_image_map_tool_remove_guide (im_tool);
gimp_image_flush (gimp_display_get_image (tool->display));
if (im_tool->config && im_tool->settings_box)
{
GimpGuiConfig *config = GIMP_GUI_CONFIG (tool->tool_info->gimp->config);
gimp_settings_box_add_current (GIMP_SETTINGS_BOX (im_tool->settings_box),
config->image_map_tool_max_recent);
}
}
tool->display = NULL;
tool->drawable = NULL;
}
static gboolean
gimp_color_tool_real_pick (GimpColorTool *color_tool,
gint x,
gint y,
const Babl **sample_format,
GimpRGB *color,
gint *color_index)
{
GimpTool *tool = GIMP_TOOL (color_tool);
GimpImage *image = gimp_display_get_image (tool->display);
g_return_val_if_fail (tool->display != NULL, FALSE);
g_return_val_if_fail (tool->drawable != NULL, FALSE);
return gimp_image_pick_color (image, tool->drawable, x, y,
color_tool->options->sample_merged,
color_tool->options->sample_average,
color_tool->options->average_radius,
sample_format,
color,
color_index);
}
/**
* 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 GeglBuffer *
gimp_fuzzy_select_tool_get_mask (GimpRegionSelectTool *region_select,
GimpDisplay *display)
{
GimpTool *tool = GIMP_TOOL (region_select);
GimpSelectionOptions *sel_options = GIMP_SELECTION_TOOL_GET_OPTIONS (tool);
GimpRegionSelectOptions *options = GIMP_REGION_SELECT_TOOL_GET_OPTIONS (tool);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpPickable *pickable;
gint x, y;
x = region_select->x;
y = region_select->y;
if (! options->sample_merged)
{
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);
}
else
{
pickable = GIMP_PICKABLE (image);
}
return gimp_pickable_contiguous_region_by_seed (pickable,
sel_options->antialias,
options->threshold / 255.0,
options->select_transparent,
options->select_criterion,
options->diagonal_neighbors,
x, y);
}
static void
gimp_blend_tool_halt (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 0
blend_tool->subtract_node = NULL;
blend_tool->divide_node = NULL;
#endif
blend_tool->dist_node = NULL;
}
if (blend_tool->dist_buffer)
{
g_object_unref (blend_tool->dist_buffer);
blend_tool->dist_buffer = NULL;
}
if (blend_tool->filter)
{
gimp_drawable_filter_abort (blend_tool->filter);
g_object_unref (blend_tool->filter);
blend_tool->filter = 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_rectangle_select_tool_cancel (GimpRectangleTool *rectangle)
{
GimpTool *tool;
GimpRectangleSelectTool *rect_sel_tool;
GimpRectangleSelectToolPrivate *priv;
tool = GIMP_TOOL (rectangle);
rect_sel_tool = GIMP_RECTANGLE_SELECT_TOOL (rectangle);
priv = GIMP_RECTANGLE_SELECT_TOOL_GET_PRIVATE (rect_sel_tool);
if (tool->display)
{
GimpImage *image = gimp_display_get_image (tool->display);
GimpUndoStack *undo_stack = gimp_image_get_undo_stack (image);
GimpUndo *undo = gimp_undo_stack_peek (undo_stack);
/* if we have an existing rectangle in the current display, then
* we have already "executed", and need to undo at this point,
* unless the user has done something in the meantime
*/
if (undo && priv->undo == undo)
{
/* prevent this change from halting the tool */
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_undo (image);
gimp_image_flush (image);
gimp_tool_control_pop_preserve (tool->control);
}
}
gimp_rectangle_select_tool_update_option_defaults (rect_sel_tool, TRUE);
priv->undo = NULL;
priv->redo = NULL;
}
static gboolean
gimp_hue_saturation_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpHueSaturationTool *hs_tool = GIMP_HUE_SATURATION_TOOL (tool);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (! drawable)
return FALSE;
if (! gimp_drawable_is_rgb (drawable))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("Hue-Saturation operates only on RGB color layers."));
return FALSE;
}
gimp_config_reset (GIMP_CONFIG (hs_tool->config));
return GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);
}
void
gimp_display_shell_get_screen_resolution (GimpDisplayShell *shell,
gdouble *xres,
gdouble *yres)
{
gdouble x, y;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
if (shell->dot_for_dot)
{
gimp_image_get_resolution (gimp_display_get_image (shell->display),
&x, &y);
}
else
{
x = shell->monitor_xres;
y = shell->monitor_yres;
}
if (xres) *xres = x;
if (yres) *yres = y;
}
static gboolean
gimp_color_balance_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpColorBalanceTool *cb_tool = GIMP_COLOR_BALANCE_TOOL (tool);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (! drawable)
return FALSE;
if (! gimp_drawable_is_rgb (drawable))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("Color Balance operates only on RGB color layers."));
return FALSE;
}
gimp_config_reset (GIMP_CONFIG (cb_tool->config));
return GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);
}
static gboolean
gimp_rectangle_select_tool_select (GimpRectangleTool *rectangle,
gint x,
gint y,
gint w,
gint h)
{
GimpTool *tool;
GimpRectangleSelectTool *rect_sel_tool;
GimpImage *image;
gboolean rectangle_exists;
GimpChannelOps operation;
tool = GIMP_TOOL (rectangle);
rect_sel_tool = GIMP_RECTANGLE_SELECT_TOOL (rectangle);
image = gimp_display_get_image (tool->display);
gimp_tool_pop_status (tool, tool->display);
rectangle_exists = (x <= gimp_image_get_width (image) &&
y <= gimp_image_get_height (image) &&
x + w >= 0 &&
y + h >= 0 &&
w > 0 &&
h > 0);
operation = gimp_rectangle_select_tool_get_operation (rect_sel_tool);
/* if rectangle exists, turn it into a selection */
if (rectangle_exists)
GIMP_RECTANGLE_SELECT_TOOL_GET_CLASS (rect_sel_tool)->select (rect_sel_tool,
operation,
x, y, w, h);
return rectangle_exists;
}
static void
gimp_color_tool_draw (GimpDrawTool *draw_tool)
{
GimpColorTool *color_tool = GIMP_COLOR_TOOL (draw_tool);
if (color_tool->enabled)
{
if (color_tool->sample_point)
{
GimpImage *image = gimp_display_get_image (draw_tool->display);
GimpCanvasItem *item;
gint index;
gint x;
gint y;
gimp_sample_point_get_position (color_tool->sample_point, &x, &y);
index = g_list_index (gimp_image_get_sample_points (image),
color_tool->sample_point) + 1;
item = gimp_draw_tool_add_sample_point (draw_tool, x, y, index);
gimp_canvas_item_set_highlight (item, TRUE);
}
else if (color_tool->options->sample_average &&
gimp_tool_control_is_active (GIMP_TOOL (draw_tool)->control))
{
gdouble radius = color_tool->options->average_radius;
gimp_draw_tool_add_rectangle (draw_tool,
FALSE,
color_tool->center_x - radius,
color_tool->center_y - radius,
2 * radius + 1,
2 * radius + 1);
}
}
}
static void
gui_display_changed (GimpContext *context,
GimpDisplay *display,
Gimp *gimp)
{
if (! display)
{
GimpImage *image = gimp_context_get_image (context);
if (image)
{
GList *list;
for (list = gimp_get_display_iter (gimp);
list;
list = g_list_next (list))
{
GimpDisplay *display2 = list->data;
if (gimp_display_get_image (display2) == image)
{
gimp_context_set_display (context, display2);
/* stop the emission of the original signal
* (the emission of the recursive signal is finished)
*/
g_signal_stop_emission_by_name (context, "display-changed");
return;
}
}
gimp_context_set_image (context, NULL);
}
}
gimp_ui_manager_update (image_ui_manager, display);
}
static gboolean
gimp_curves_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpCurvesTool *c_tool = GIMP_CURVES_TOOL (tool);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpHistogram *histogram;
if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error))
{
return FALSE;
}
gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (c_tool->channel_menu),
curves_menu_sensitivity, drawable, NULL);
histogram = gimp_histogram_new (TRUE);
gimp_drawable_calculate_histogram (drawable, histogram);
gimp_histogram_view_set_background (GIMP_HISTOGRAM_VIEW (c_tool->graph),
histogram);
g_object_unref (histogram);
if (gimp_drawable_get_component_type (drawable) == GIMP_COMPONENT_TYPE_U8)
{
gimp_curve_view_set_range_x (GIMP_CURVE_VIEW (c_tool->graph), 0, 255);
gimp_curve_view_set_range_y (GIMP_CURVE_VIEW (c_tool->graph), 0, 255);
}
else
{
gimp_curve_view_set_range_x (GIMP_CURVE_VIEW (c_tool->graph), 0, 100);
gimp_curve_view_set_range_y (GIMP_CURVE_VIEW (c_tool->graph), 0, 100);
}
return TRUE;
}
static void
gimp_display_shell_drop_vectors (GtkWidget *widget,
gint x,
gint y,
GimpViewable *viewable,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpImage *image = gimp_display_get_image (shell->display);
GimpItem *new_item;
GIMP_LOG (DND, NULL);
if (shell->display->gimp->busy)
return;
if (! image)
return;
new_item = gimp_item_convert (GIMP_ITEM (viewable),
image, G_TYPE_FROM_INSTANCE (viewable));
if (new_item)
{
GimpVectors *new_vectors = GIMP_VECTORS (new_item);
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,
_("Drop New Path"));
gimp_image_add_vectors (image, new_vectors,
GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
gimp_image_undo_group_end (image);
gimp_display_shell_dnd_flush (shell, image);
}
}
static void
gimp_display_shell_drop_svg (GtkWidget *widget,
gint x,
gint y,
const guchar *svg_data,
gsize svg_data_len,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpImage *image = gimp_display_get_image (shell->display);
GError *error = NULL;
GIMP_LOG (DND, NULL);
if (shell->display->gimp->busy)
return;
if (! image)
return;
if (! gimp_vectors_import_buffer (image,
(const gchar *) svg_data, svg_data_len,
TRUE, FALSE,
GIMP_IMAGE_ACTIVE_PARENT, -1,
NULL, &error))
{
gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display),
GIMP_MESSAGE_ERROR,
error->message);
g_clear_error (&error);
}
else
{
gimp_display_shell_dnd_flush (shell, image);
}
}
GimpImage *
action_data_get_image (gpointer data)
{
GimpImage *result = NULL;
static gboolean recursion = FALSE;
if (! data || recursion)
return NULL;
recursion = TRUE;
if (GIMP_IS_ITEM_TREE_VIEW (data))
result = gimp_item_tree_view_get_image ((GimpItemTreeView *) data);
else if (GIMP_IS_IMAGE_EDITOR (data))
result = ((GimpImageEditor *) data)->image;
if (! result)
{
GimpDisplay *display = action_data_get_display (data);
if (display)
result = gimp_display_get_image (display);
}
if (! result)
{
GimpContext *context = action_data_get_context (data);
if (context)
result = gimp_context_get_image (context);
}
recursion = FALSE;
return result;
}
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));
}
static gboolean
gimp_brightness_contrast_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpBrightnessContrastTool *bc_tool = GIMP_BRIGHTNESS_CONTRAST_TOOL (tool);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (! drawable)
return FALSE;
if (gimp_drawable_is_indexed (drawable))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("Brightness-Contrast does not operate "
"on indexed layers."));
return FALSE;
}
gimp_config_reset (GIMP_CONFIG (bc_tool->config));
return GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);
}
void
gimp_display_shell_rotate_update_transform (GimpDisplayShell *shell)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_free (shell->rotate_transform);
g_free (shell->rotate_untransform);
if (shell->rotate_angle != 0.0 && gimp_display_get_image (shell->display))
{
gint image_width, image_height;
gdouble cx, cy;
shell->rotate_transform = g_new (cairo_matrix_t, 1);
shell->rotate_untransform = g_new (cairo_matrix_t, 1);
gimp_display_shell_scale_get_image_size (shell,
&image_width, &image_height);
cx = -shell->offset_x + image_width / 2;
cy = -shell->offset_y + image_height / 2;
cairo_matrix_init_translate (shell->rotate_transform, cx, cy);
cairo_matrix_rotate (shell->rotate_transform,
shell->rotate_angle / 180.0 * G_PI);
cairo_matrix_translate (shell->rotate_transform, -cx, -cy);
*shell->rotate_untransform = *shell->rotate_transform;
cairo_matrix_invert (shell->rotate_untransform);
}
else
{
shell->rotate_transform = NULL;
shell->rotate_untransform = NULL;
}
}
static gboolean
gimp_gegl_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpGeglTool *g_tool = GIMP_GEGL_TOOL (tool);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (! drawable)
return FALSE;
if (gimp_drawable_is_indexed (drawable))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("GEGL operations do not operate on indexed layers."));
return FALSE;
}
if (g_tool->config)
gimp_config_reset (GIMP_CONFIG (g_tool->config));
return GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);
}
static gboolean
gimp_bucket_fill_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error))
{
return FALSE;
}
if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("Cannot modify the pixels of layer groups."));
return FALSE;
}
if (gimp_item_is_content_locked (GIMP_ITEM (drawable)))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("The active layer's pixels are locked."));
return FALSE;
}
if (! gimp_item_is_visible (GIMP_ITEM (drawable)))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("The active layer is not visible."));
return FALSE;
}
return TRUE;
}
/**
* gimp_display_shell_calculate_scale_x_and_y:
* @shell:
* @scale:
* @scale_x:
* @scale_y:
*
**/
void
gimp_display_shell_calculate_scale_x_and_y (GimpDisplayShell *shell,
gdouble scale,
gdouble *scale_x,
gdouble *scale_y)
{
GimpImage *image;
gdouble xres;
gdouble yres;
gdouble screen_xres;
gdouble screen_yres;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
image = gimp_display_get_image (shell->display);
g_return_if_fail (GIMP_IS_IMAGE (image));
gimp_image_get_resolution (image, &xres, &yres);
gimp_display_shell_get_screen_resolution (shell, &screen_xres, &screen_yres);
if (scale_x) *scale_x = scale * screen_xres / xres;
if (scale_y) *scale_y = scale * screen_yres / yres;
}
