static void
gimp_perspective_clone_tool_bounds (GimpPerspectiveCloneTool *tool,
GimpDisplay *display)
{
GimpImage *image = gimp_display_get_image (display);
tool->x1 = 0;
tool->y1 = 0;
tool->x2 = gimp_image_get_width (image);
tool->y2 = gimp_image_get_height (image);
}
static void
gimp_vectors_convert (GimpItem *item,
GimpImage *dest_image,
GType old_type)
{
gimp_item_set_size (item,
gimp_image_get_width (dest_image),
gimp_image_get_height (dest_image));
GIMP_ITEM_CLASS (parent_class)->convert (item, dest_image, old_type);
}
static void
gimp_image_rotate_sample_points (GimpImage *image,
GimpRotationType rotate_type)
{
GList *list;
/* Rotate all sample points */
for (list = gimp_image_get_sample_points (image);
list;
list = g_list_next (list))
{
GimpSamplePoint *sample_point = list->data;
gint old_x;
gint old_y;
gimp_image_undo_push_sample_point (image, NULL, sample_point);
gimp_sample_point_get_position (sample_point, &old_x, &old_y);
switch (rotate_type)
{
case GIMP_ROTATE_90:
gimp_sample_point_set_position (sample_point,
gimp_image_get_height (image) - old_y,
old_x);
break;
case GIMP_ROTATE_180:
gimp_sample_point_set_position (sample_point,
gimp_image_get_width (image) - old_x,
gimp_image_get_height (image) - old_y);
break;
case GIMP_ROTATE_270:
gimp_sample_point_set_position (sample_point,
old_y,
gimp_image_get_width (image) - old_x);
break;
}
}
}
/**
* 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_image_rotate_sample_points (GimpImage *image,
GimpRotationType rotate_type)
{
GList *list;
/* Rotate all sample points */
for (list = gimp_image_get_sample_points (image);
list;
list = g_list_next (list))
{
GimpSamplePoint *sample_point = list->data;
gint old_x;
gint old_y;
gimp_image_undo_push_sample_point (image, NULL, sample_point);
old_x = sample_point->x;
old_y = sample_point->y;
switch (rotate_type)
{
case GIMP_ROTATE_90:
sample_point->x = old_y;
sample_point->y = gimp_image_get_height (image) - old_x;
break;
case GIMP_ROTATE_180:
sample_point->x = gimp_image_get_height (image) - old_x;
sample_point->y = gimp_image_get_width (image) - old_y;
break;
case GIMP_ROTATE_270:
sample_point->x = gimp_image_get_width (image) - old_y;
sample_point->y = old_x;
break;
}
}
}
static void
gimp_display_shell_size_changed_detailed_handler (GimpImage *image,
gint previous_origin_x,
gint previous_origin_y,
gint previous_width,
gint previous_height,
GimpDisplayShell *shell)
{
if (shell->display->config->resize_windows_on_resize)
{
GimpImageWindow *window = gimp_display_shell_get_window (shell);
if (window && gimp_image_window_get_active_shell (window) == shell)
{
/* If the window is resized just center the image in it when it
* has change size
*/
gimp_image_window_shrink_wrap (window, FALSE);
}
}
else
{
GimpImage *image = gimp_display_get_image (shell->display);
gint new_width = gimp_image_get_width (image);
gint new_height = gimp_image_get_height (image);
gint scaled_previous_origin_x = SCALEX (shell, previous_origin_x);
gint scaled_previous_origin_y = SCALEY (shell, previous_origin_y);
gboolean horizontally;
gboolean vertically;
horizontally = (SCALEX (shell, previous_width) > shell->disp_width &&
SCALEX (shell, new_width) <= shell->disp_width);
vertically = (SCALEY (shell, previous_height) > shell->disp_height &&
SCALEY (shell, new_height) <= shell->disp_height);
gimp_display_shell_scroll_set_offset (shell,
shell->offset_x + scaled_previous_origin_x,
shell->offset_y + scaled_previous_origin_y);
gimp_display_shell_scroll_center_image (shell, horizontally, vertically);
/* The above calls might not lead to a call to
* gimp_display_shell_scroll_clamp_and_update() in all cases we
* need it to be called, so simply call it explicitly here at
* the end
*/
gimp_display_shell_scroll_clamp_and_update (shell);
gimp_display_shell_expose_full (shell);
}
}
static void
gimp_image_undo_constructed (GObject *object)
{
GimpImageUndo *image_undo = GIMP_IMAGE_UNDO (object);
GimpImage *image;
if (G_OBJECT_CLASS (parent_class)->constructed)
G_OBJECT_CLASS (parent_class)->constructed (object);
image = GIMP_UNDO (object)->image;
switch (GIMP_UNDO (object)->undo_type)
{
case GIMP_UNDO_IMAGE_TYPE:
image_undo->base_type = gimp_image_base_type (image);
break;
case GIMP_UNDO_IMAGE_SIZE:
image_undo->width = gimp_image_get_width (image);
image_undo->height = gimp_image_get_height (image);
break;
case GIMP_UNDO_IMAGE_RESOLUTION:
gimp_image_get_resolution (image,
&image_undo->xresolution,
&image_undo->yresolution);
image_undo->resolution_unit = gimp_image_get_unit (image);
break;
case GIMP_UNDO_IMAGE_GRID:
g_assert (GIMP_IS_GRID (image_undo->grid));
break;
case GIMP_UNDO_IMAGE_COLORMAP:
image_undo->num_colors = gimp_image_get_colormap_size (image);
image_undo->colormap = g_memdup (gimp_image_get_colormap (image),
GIMP_IMAGE_COLORMAP_SIZE);
break;
case GIMP_UNDO_PARASITE_ATTACH:
case GIMP_UNDO_PARASITE_REMOVE:
g_assert (image_undo->parasite_name != NULL);
image_undo->parasite = gimp_parasite_copy
(gimp_image_parasite_find (image, image_undo->parasite_name));
break;
default:
g_assert_not_reached ();
}
}
static void
gimp_mandala_image_size_changed_cb (GimpImage *image,
gint previous_origin_x,
gint previous_origin_y,
gint previous_width,
gint previous_height,
GimpSymmetry *sym)
{
if (previous_width != gimp_image_get_width (image) ||
previous_height != gimp_image_get_height (image))
{
g_signal_emit_by_name (sym, "gui-param-changed", sym->image);
}
}
static GimpValueArray *
image_crop_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
gint32 new_width;
gint32 new_height;
gint32 offx;
gint32 offy;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
new_width = g_value_get_int (gimp_value_array_index (args, 1));
new_height = g_value_get_int (gimp_value_array_index (args, 2));
offx = g_value_get_int (gimp_value_array_index (args, 3));
offy = g_value_get_int (gimp_value_array_index (args, 4));
if (success)
{
if (new_width > gimp_image_get_width (image) ||
new_height > gimp_image_get_height (image) ||
offx > (gimp_image_get_width (image) - new_width) ||
offy > (gimp_image_get_height (image) - new_height))
success = FALSE;
else
gimp_image_crop (image, context,
offx, offy, offx + new_width, offy + new_height,
TRUE);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static void
gimp_rotate_tool_prepare (GimpTransformTool *tr_tool)
{
GimpRotateTool *rotate = GIMP_ROTATE_TOOL (tr_tool);
GimpDisplay *display = GIMP_TOOL (tr_tool)->display;
GimpImage *image = gimp_display_get_image (display);
gdouble xres;
gdouble yres;
tr_tool->px = (gdouble) (tr_tool->x1 + tr_tool->x2) / 2.0;
tr_tool->py = (gdouble) (tr_tool->y1 + tr_tool->y2) / 2.0;
tr_tool->trans_info[ANGLE] = 0.0;
tr_tool->trans_info[REAL_ANGLE] = 0.0;
tr_tool->trans_info[PIVOT_X] = tr_tool->px;
tr_tool->trans_info[PIVOT_Y] = tr_tool->py;
gimp_image_get_resolution (image, &xres, &yres);
g_signal_handlers_block_by_func (rotate->sizeentry,
rotate_center_changed,
tr_tool);
gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (rotate->sizeentry),
gimp_display_get_shell (display)->unit);
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (rotate->sizeentry), 0,
xres, FALSE);
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (rotate->sizeentry), 1,
yres, FALSE);
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (rotate->sizeentry), 0,
-65536,
65536 +
gimp_image_get_width (image));
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (rotate->sizeentry), 1,
-65536,
65536 +
gimp_image_get_height (image));
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (rotate->sizeentry), 0,
tr_tool->x1, tr_tool->x2);
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (rotate->sizeentry), 1,
tr_tool->y1, tr_tool->y2);
g_signal_handlers_unblock_by_func (rotate->sizeentry,
rotate_center_changed,
tr_tool);
}
/**
* gimp_display_shell_scale_get_image_size_for_scale:
* @shell:
* @scale:
* @w:
* @h:
*
**/
static void
gimp_display_shell_scale_get_image_size_for_scale (GimpDisplayShell *shell,
gdouble scale,
gint *w,
gint *h)
{
GimpImage *image = gimp_display_get_image (shell->display);
gdouble scale_x;
gdouble scale_y;
gimp_display_shell_calculate_scale_x_and_y (shell, scale, &scale_x, &scale_y);
if (w) *w = scale_x * gimp_image_get_width (image);
if (h) *h = scale_y * gimp_image_get_height (image);
}
void
gimp_item_get_preview_size (GimpViewable *viewable,
gint size,
gboolean is_popup,
gboolean dot_for_dot,
gint *width,
gint *height)
{
GimpItem *item = GIMP_ITEM (viewable);
GimpImage *image = gimp_item_get_image (item);
if (image && ! image->gimp->config->layer_previews && ! is_popup)
{
*width = size;
*height = size;
return;
}
if (image && ! is_popup)
{
gdouble xres;
gdouble yres;
gimp_image_get_resolution (image, &xres, &yres);
gimp_viewable_calc_preview_size (gimp_image_get_width (image),
gimp_image_get_height (image),
size,
size,
dot_for_dot,
xres,
yres,
width,
height,
NULL);
}
else
{
gimp_viewable_calc_preview_size (gimp_item_get_width (item),
gimp_item_get_height (item),
size,
size,
dot_for_dot, 1.0, 1.0,
width,
height,
NULL);
}
}
static void
image_resize_callback (GtkWidget *dialog,
GimpViewable *viewable,
gint width,
gint height,
GimpUnit unit,
gint offset_x,
gint offset_y,
GimpItemSet layer_set,
gpointer data)
{
ImageResizeOptions *options = data;
image_resize_unit = unit;
if (width > 0 && height > 0)
{
GimpImage *image = GIMP_IMAGE (viewable);
GimpDisplay *display = options->display;
GimpContext *context = options->context;
GimpProgress *progress;
gtk_widget_destroy (dialog);
if (width == gimp_image_get_width (image) &&
height == gimp_image_get_height (image))
return;
progress = gimp_progress_start (GIMP_PROGRESS (display),
_("Resizing"), FALSE);
gimp_image_resize_with_layers (image,
context,
width, height, offset_x, offset_y,
layer_set,
progress);
if (progress)
gimp_progress_end (progress);
gimp_image_flush (image);
}
else
{
g_warning ("Resize Error: "
"Both width and height must be greater than zero.");
}
}
static void
gimp_mandala_add_guide (GimpMandala *mandala,
GimpOrientationType orientation)
{
GimpSymmetry *sym = GIMP_SYMMETRY (mandala);
GimpImage *image;
Gimp *gimp;
GimpGuide *guide;
gint position;
image = sym->image;
gimp = image->gimp;
guide = gimp_guide_custom_new (orientation,
gimp->next_guide_ID++,
GIMP_GUIDE_STYLE_MANDALA);
if (orientation == GIMP_ORIENTATION_HORIZONTAL)
{
mandala->horizontal_guide = guide;
/* Mandala guide position at first activation is at canvas middle. */
if (mandala->center_y < 1.0)
mandala->center_y = (gdouble) gimp_image_get_height (image) / 2.0;
position = (gint) mandala->center_y;
}
else
{
mandala->vertical_guide = guide;
/* Mandala guide position at first activation is at canvas middle. */
if (mandala->center_x < 1.0)
mandala->center_x = (gdouble) gimp_image_get_width (image) / 2.0;
position = (gint) mandala->center_x;
}
g_signal_connect (guide, "removed",
G_CALLBACK (gimp_mandala_guide_removed_cb),
mandala);
gimp_image_add_guide (image, guide, position);
g_signal_connect (guide, "notify::position",
G_CALLBACK (gimp_mandala_guide_position_cb),
mandala);
}
GimpVectors *
gimp_vectors_new (GimpImage *image,
const gchar *name)
{
GimpVectors *vectors;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
vectors = GIMP_VECTORS (gimp_item_new (GIMP_TYPE_VECTORS,
image, name,
0, 0,
gimp_image_get_width (image),
gimp_image_get_height (image)));
return vectors;
}
static gboolean
file_open_dialog_open_layers (GtkWidget *open_dialog,
GimpImage *image,
const gchar *uri,
const gchar *entered_filename,
GimpPlugInProcedure *load_proc)
{
GList *new_layers;
GimpPDBStatusType status;
GError *error = NULL;
new_layers = file_open_layers (image->gimp,
gimp_get_user_context (image->gimp),
GIMP_PROGRESS (open_dialog),
image, FALSE,
uri, GIMP_RUN_INTERACTIVE, load_proc,
&status, &error);
if (new_layers)
{
gimp_image_add_layers (image, new_layers,
GIMP_IMAGE_ACTIVE_PARENT, -1,
0, 0,
gimp_image_get_width (image),
gimp_image_get_height (image),
_("Open layers"));
g_list_free (new_layers);
return TRUE;
}
else if (status != GIMP_PDB_CANCEL)
{
gchar *filename = file_utils_uri_display_name (uri);
gimp_message (image->gimp, G_OBJECT (open_dialog), GIMP_MESSAGE_ERROR,
_("Opening '%s' failed:\n\n%s"), filename, error->message);
g_clear_error (&error);
g_free (filename);
}
return FALSE;
}
/**
* gimp_display_shell_scale_fit_or_fill:
* @shell: the #GimpDisplayShell
* @fill: whether to scale the image to fill the viewport,
* or fit inside the viewport
*
* A common implementation for gimp_display_shell_scale_{fit_in,fill}().
**/
static void
gimp_display_shell_scale_fit_or_fill (GimpDisplayShell *shell,
gboolean fill)
{
GimpImage *image;
gdouble image_x;
gdouble image_y;
gdouble image_width;
gdouble image_height;
gdouble current_scale;
gdouble zoom_factor;
image = gimp_display_get_image (shell->display);
gimp_display_shell_transform_bounds (shell,
0, 0,
gimp_image_get_width (image),
gimp_image_get_height (image),
&image_x, &image_y,
&image_width, &image_height);
image_width -= image_x;
image_height -= image_y;
current_scale = gimp_zoom_model_get_factor (shell->zoom);
if (fill)
{
zoom_factor = MAX (shell->disp_width / image_width,
shell->disp_height / image_height);
}
else
{
zoom_factor = MIN (shell->disp_width / image_width,
shell->disp_height / image_height);
}
gimp_display_shell_scale (shell,
GIMP_ZOOM_TO,
zoom_factor * current_scale,
GIMP_ZOOM_FOCUS_BEST_GUESS);
gimp_display_shell_scroll_center_image (shell, TRUE, TRUE);
}
static GString *
gimp_vectors_export (const GimpImage *image,
const GimpVectors *vectors)
{
GString *str = g_string_new (NULL);
g_string_append_printf (str,
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"
"<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 20010904//EN\"\n"
" \"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\">\n"
"\n"
"<svg xmlns=\"http://www.w3.org/2000/svg\"\n");
g_string_append (str, " ");
gimp_vectors_export_image_size (image, str);
g_string_append_c (str, '\n');
g_string_append_printf (str,
" viewBox=\"0 0 %d %d\">\n",
gimp_image_get_width (image),
gimp_image_get_height (image));
if (vectors)
{
gimp_vectors_export_path (vectors, str);
}
else
{
GList *list;
for (list = gimp_image_get_vectors_iter (image);
list;
list = list->next)
{
gimp_vectors_export_path (GIMP_VECTORS (list->data), str);
}
}
g_string_append (str, "</svg>\n");
return str;
}
static void
gimp_foreground_select_tool_select (GimpFreeSelectTool *free_sel,
GimpDisplay *display)
{
GimpForegroundSelectTool *fg_select;
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable;
GimpScanConvert *scan_convert;
const GimpVector2 *points;
gint n_points;
drawable = gimp_image_get_active_drawable (image);
fg_select = GIMP_FOREGROUND_SELECT_TOOL (free_sel);
if (! drawable)
return;
if (fg_select->state == MATTING_STATE_FREE_SELECT)
{
scan_convert = gimp_scan_convert_new ();
gimp_free_select_tool_get_points (free_sel,
&points,
&n_points);
gimp_scan_convert_add_polyline (scan_convert,
n_points,
points,
TRUE);
fg_select->trimap = gegl_buffer_new (GEGL_RECTANGLE (0, 0,
gimp_image_get_width (image),
gimp_image_get_height (image)),
gimp_image_get_mask_format (image));
gimp_scan_convert_render_value (scan_convert, fg_select->trimap,
0, 0, 1.0);
gimp_scan_convert_free (scan_convert);
gimp_foreground_select_tool_set_trimap (fg_select, display);
}
}
static GimpValueArray *
image_add_sample_point_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint32 position_x;
gint32 position_y;
gint32 sample_point = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
position_x = g_value_get_int (gimp_value_array_index (args, 1));
position_y = g_value_get_int (gimp_value_array_index (args, 2));
if (success)
{
if (position_x <= gimp_image_get_width (image) &&
position_y <= gimp_image_get_height (image))
{
GimpSamplePoint *sp;
sp = gimp_image_add_sample_point_at_pos (image, position_x, position_y,
TRUE);
sample_point = gimp_sample_point_get_ID (sp);
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_set_uint (gimp_value_array_index (return_vals, 1), sample_point);
return return_vals;
}
static void
gimp_vectors_export_image_size (const GimpImage *image,
GString *str)
{
GimpUnit unit;
const gchar *abbrev;
gchar wbuf[G_ASCII_DTOSTR_BUF_SIZE];
gchar hbuf[G_ASCII_DTOSTR_BUF_SIZE];
gdouble xres;
gdouble yres;
gdouble w, h;
gimp_image_get_resolution (image, &xres, &yres);
w = (gdouble) gimp_image_get_width (image) / xres;
h = (gdouble) gimp_image_get_height (image) / yres;
/* FIXME: should probably use the display unit here */
unit = gimp_image_get_unit (image);
switch (unit)
{
case GIMP_UNIT_INCH: abbrev = "in"; break;
case GIMP_UNIT_MM: abbrev = "mm"; break;
case GIMP_UNIT_POINT: abbrev = "pt"; break;
case GIMP_UNIT_PICA: abbrev = "pc"; break;
default: abbrev = "cm";
unit = GIMP_UNIT_MM;
w /= 10.0;
h /= 10.0;
break;
}
g_ascii_formatd (wbuf, sizeof (wbuf),
"%g", w * _gimp_unit_get_factor (image->gimp, unit));
g_ascii_formatd (hbuf, sizeof (hbuf),
"%g", h * _gimp_unit_get_factor (image->gimp, unit));
g_string_append_printf (str,
"width=\"%s%s\" height=\"%s%s\"",
wbuf, abbrev, hbuf, abbrev);
}
static void
gimp_mandala_constructed (GObject *object)
{
GimpSymmetry *sym;
GParamSpecDouble *dspec;
sym = GIMP_SYMMETRY (object);
/* Update property values to actual image size. */
dspec = G_PARAM_SPEC_DOUBLE (g_object_class_find_property (G_OBJECT_GET_CLASS (object),
"center-x"));
dspec->maximum = gimp_image_get_width (sym->image);
dspec = G_PARAM_SPEC_DOUBLE (g_object_class_find_property (G_OBJECT_GET_CLASS (object),
"center-y"));
dspec->maximum = gimp_image_get_height (sym->image);
g_signal_connect (sym->image, "size-changed-detailed",
G_CALLBACK (gimp_mandala_image_size_changed_cb),
sym);
}
GimpSamplePoint *
gimp_image_find_sample_point (GimpImage *image,
gdouble x,
gdouble y,
gdouble epsilon_x,
gdouble epsilon_y)
{
GList *list;
GimpSamplePoint *ret = NULL;
gdouble mindist = G_MAXDOUBLE;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (epsilon_x > 0 && epsilon_y > 0, NULL);
if (x < 0 || x >= gimp_image_get_width (image) ||
y < 0 || y >= gimp_image_get_height (image))
{
return NULL;
}
for (list = image->sample_points; list; list = g_list_next (list))
{
GimpSamplePoint *sample_point = list->data;
gdouble dist;
if (sample_point->x < 0 || sample_point->y < 0)
continue;
dist = hypot ((sample_point->x + 0.5) - x,
(sample_point->y + 0.5) - y);
if (dist < MIN (epsilon_y, mindist))
{
mindist = dist;
ret = sample_point;
}
}
return ret;
}
void
gimp_image_add_sample_point (GimpImage *image,
GimpSamplePoint *sample_point,
gint x,
gint y)
{
g_return_if_fail (GIMP_IS_IMAGE (image));
g_return_if_fail (sample_point != NULL);
g_return_if_fail (x >= 0);
g_return_if_fail (y >= 0);
g_return_if_fail (x < gimp_image_get_width (image));
g_return_if_fail (y < gimp_image_get_height (image));
image->sample_points = g_list_append (image->sample_points, sample_point);
sample_point->x = x;
sample_point->y = y;
gimp_sample_point_ref (sample_point);
gimp_image_sample_point_added (image, sample_point);
gimp_image_update_sample_point (image, sample_point);
}
static GimpValueArray *
image_add_vguide_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint32 xposition;
gint32 guide = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
xposition = g_value_get_int (gimp_value_array_index (args, 1));
if (success)
{
if (xposition <= gimp_image_get_width (image))
{
GimpGuide *g;
g = gimp_image_add_vguide (image, xposition, TRUE);
guide = gimp_guide_get_ID (g);
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_set_uint (gimp_value_array_index (return_vals, 1), guide);
return return_vals;
}
GimpSamplePoint *
gimp_image_add_sample_point_at_pos (GimpImage *image,
gint x,
gint y,
gboolean push_undo)
{
GimpSamplePoint *sample_point;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (x >= 0 && x < gimp_image_get_width (image), NULL);
g_return_val_if_fail (y >= 0 && y < gimp_image_get_height (image), NULL);
sample_point = gimp_sample_point_new (image->gimp->next_sample_point_ID++);
if (push_undo)
gimp_image_undo_push_sample_point (image, _("Add Sample Point"),
sample_point);
gimp_image_add_sample_point (image, sample_point, x, y);
gimp_sample_point_unref (sample_point);
return sample_point;
}
void
gimp_image_move_sample_point (GimpImage *image,
GimpSamplePoint *sample_point,
gint x,
gint y,
gboolean push_undo)
{
g_return_if_fail (GIMP_IS_IMAGE (image));
g_return_if_fail (sample_point != NULL);
g_return_if_fail (x >= 0);
g_return_if_fail (y >= 0);
g_return_if_fail (x < gimp_image_get_width (image));
g_return_if_fail (y < gimp_image_get_height (image));
if (push_undo)
gimp_image_undo_push_sample_point (image, _("Move Sample Point"),
sample_point);
gimp_image_update_sample_point (image, sample_point);
sample_point->x = x;
sample_point->y = y;
gimp_image_update_sample_point (image, sample_point);
}
GimpGuide *
gimp_image_add_vguide (GimpImage *image,
gint position,
gboolean push_undo)
{
GimpGuide *guide;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (position >= 0 &&
position <= gimp_image_get_width (image), NULL);
guide = gimp_guide_new (GIMP_ORIENTATION_VERTICAL,
image->gimp->next_guide_ID++);
if (push_undo)
gimp_image_undo_push_guide (image,
C_("undo-type", "Add Vertical Guide"), guide);
gimp_image_add_guide (image, guide, position);
g_object_unref (guide);
return guide;
}
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
file_open_sanitize_image (GimpImage *image,
gboolean as_new)
{
if (as_new)
gimp_image_set_file (image, NULL);
/* clear all undo steps */
gimp_image_undo_free (image);
/* make sure that undo is enabled */
while (! gimp_image_undo_is_enabled (image))
gimp_image_undo_thaw (image);
/* Set the image to clean. Note that export dirtiness is not set to
* clean here; we can only consider export clean after the first
* export
*/
gimp_image_clean_all (image);
#if 0
/* XXX this is not needed any longer, remove it when sure */
/* make sure the entire projection is properly constructed, because
* load plug-ins are not required to call gimp_drawable_update() or
* anything.
*/
gimp_image_invalidate (image,
0, 0,
gimp_image_get_width (image),
gimp_image_get_height (image));
gimp_image_flush (image);
/* same for drawable previews */
gimp_image_invalidate_previews (image);
#endif
}
