graphics/gimp
graphics/gimp
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp synced 2024-10-22 20:41:43 +00:00
Code Issues Packages Projects Releases Wiki Activity
gimp/app/core/gimpimage-snap.c
Michael Natterer f0372cad0f Treat changes to the selection like changes to any other drawable: 
2003-10-06  Michael Natterer  <mitch@gimp.org>

	Treat changes to the selection like changes to any other drawable:

	* app/core/gimpchannel.c
	* app/core/gimpchannel-combine.c: call gimp_drawable_update() after
	changing the channel.

	* app/core/gimpimage.[ch]: added struct GimpImageFlushAccumulator
	with one member "gboolean mask_changed". Connect to "update" of
	the selection and set accum.mask_changed to TRUE in the callback.
	Added default implementation for GimpImage::flush() and emit
	"mask_changed" there.

	Unrelated:
	* app/core/gimpimage.h: removed GimpGuide struct...
	* app/core/gimpimage-guides.h: ...and added it here.

	* app/core/gimpimage-undo-push.c (undo_pop_mask)
	(undo_pop_channel_mod): don't distinguish between selection and
	non-selection channels and just call gimp_drawable_update().

	* app/core/gimpundo.h
	* app/core/gimpimage-undo.c: removed "gboolean mask_changed" from
	the GimpUndoAccumulator struct since we don't have to care about
	that signal explicitly any more.

	* app/display/gimpdisplay-foreach.[ch]: removed gimp_displays_flush().

	* tools/pdbgen/pdb/display.pdb (displays_flush_invoker): call
	gimp_image_flush() on all images so the flush accumulator is
	honored.

	This generalization enables the removal of more special purpose
	code which was needed to treat the selection different:

	* app/core/gimpimage-mask-select.[ch]: removed...

	* app/core/gimpchannel-select.[ch]: ...and added under a new name
	because it's not selection specific any more.

	* app/core/gimpimage-mask.[ch]: removed...

	* app/core/gimpselection.[ch]: ...added the two remaining
	functions here. Removed all calls to gimp_image_mask_changed().

	* app/core/Makefile.am
	* app/core/gimp-edit.c
	* app/core/gimpdrawable-transform.c
	* app/core/gimpimage-scale.c
	* app/core/gimpimage-snap.c
	* app/display/gimpdisplayshell.c
	* app/gui/channels-commands.c
	* app/gui/layers-commands.c
	* app/gui/select-commands.c
	* app/gui/vectors-commands.c
	* app/tools/gimpbycolorselecttool.c
	* app/tools/gimpeditselectiontool.c
	* app/tools/gimpellipseselecttool.c
	* app/tools/gimpfreeselecttool.c
	* app/tools/gimpfuzzyselecttool.c
	* app/tools/gimpiscissorstool.c
	* app/tools/gimprectselecttool.c
	* app/tools/gimptransformtool.c
	* app/widgets/gimpchanneltreeview.c
	* app/widgets/gimpselectioneditor.c
	* app/widgets/gimpvectorstreeview.c
	* app/xcf/xcf-save.c
	* tools/pdbgen/pdb/paths.pdb
	* tools/pdbgen/pdb/selection.pdb
	* tools/pdbgen/pdb/selection_tools.pdb: changed accordingly.

	* app/core/gimpdrawable-bucket-fill.c
	* app/core/gimpimage-colormap.c
	* app/core/gimplayer-floating-sel.c
	* app/core/gimplayer.c
	* app/gui/image-menu.c
	* app/paint/gimppaintcore.c
	* app/tools/gimpcroptool.c
	* app/tools/gimpinkoptions.c
	* app/tools/gimpvectortool.c: removed useless and/or obsolete
	#includes.

	* app/pdb/display_cmds.c
	* app/pdb/paths_cmds.c
	* app/pdb/selection_cmds.c
	* app/pdb/selection_tools_cmds.c: regenerated.
2003-10-06 12:17:11 +00:00

386 lines
9.3 KiB
C
Raw Blame History

/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <glib-object.h>
#include "core-types.h"
#include "gimp.h"
#include "gimpimage.h"
#include "gimpimage-grid.h"
#include "gimpimage-guides.h"
#include "gimpimage-snap.h"
#include "gimp-intl.h"
#define EPSILON 5
/* public functions */
gboolean
gimp_image_snap_x (GimpImage *gimage,
gdouble x,
gint *tx,
gboolean snap_to_guides,
gboolean snap_to_grid)
{
GList *list;
GimpGuide *guide;
GimpGrid *grid;
gdouble xspacing;
gdouble xoffset;
gint mindist = G_MAXINT;
gint dist;
gint i;
gboolean snapped = FALSE;
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
g_return_val_if_fail (tx != NULL, FALSE);
if (! snap_to_guides && ! snap_to_grid)
return FALSE;
*tx = ROUND (x);
if (x < 0 || x >= gimage->width)
return FALSE;
if (snap_to_guides && gimage->guides != NULL)
{
for (list = gimage->guides; list; list = g_list_next (list))
{
guide = (GimpGuide *) list->data;
if (guide->position < 0)
continue;
if (guide->orientation == GIMP_ORIENTATION_VERTICAL)
{
dist = ABS (guide->position - x);
if (dist < MIN (EPSILON, mindist))
{
mindist = dist;
*tx = guide->position;
snapped = TRUE;
}
}
}
}
if (snap_to_grid && gimage->grid != NULL)
{
grid = gimp_image_get_grid (gimage);
g_object_get (grid,
"xspacing", &xspacing,
"xoffset", &xoffset,
NULL);
for (i = xoffset; i <= gimage->width; i += xspacing)
{
if (i < 0)
continue;
dist = ABS (i - x);
if (dist < MIN (EPSILON, mindist))
{
mindist = dist;
*tx = i;
snapped = TRUE;
}
}
}
return snapped;
}
gboolean
gimp_image_snap_y (GimpImage *gimage,
gdouble y,
gint *ty,
gboolean snap_to_guides,
gboolean snap_to_grid)
{
GList *list;
GimpGuide *guide;
GimpGrid *grid;
gdouble yspacing;
gdouble yoffset;
gint mindist = G_MAXINT;
gint dist;
gint i;
gboolean snapped = FALSE;
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
g_return_val_if_fail (ty != NULL, FALSE);
if (! snap_to_guides && ! snap_to_grid)
return FALSE;
*ty = ROUND (y);
if (y < 0 || y >= gimage->height)
return FALSE;
if (snap_to_guides && gimage->guides != NULL)
{
for (list = gimage->guides; list; list = g_list_next (list))
{
guide = (GimpGuide *) list->data;
if (guide->position < 0)
continue;
if (guide->orientation == GIMP_ORIENTATION_HORIZONTAL)
{
dist = ABS (guide->position - y);
if (dist < MIN (EPSILON, mindist))
{
mindist = dist;
*ty = guide->position;
snapped = TRUE;
}
}
}
}
if (snap_to_grid && gimage->grid != NULL)
{
grid = gimp_image_get_grid (gimage);
g_object_get (grid,
"yspacing", &yspacing,
"yoffset", &yoffset,
NULL);
for (i = yoffset; i <= gimage->height; i += yspacing)
{
if (i < 0)
continue;
dist = ABS (i - y);
if (dist < MIN (EPSILON, mindist))
{
mindist = dist;
*ty = i;
snapped = TRUE;
}
}
}
return snapped;
}
gboolean
gimp_image_snap_point (GimpImage *gimage,
gdouble x,
gdouble y,
gint *tx,
gint *ty,
gboolean snap_to_guides,
gboolean snap_to_grid)
{
GList *list;
GimpGuide *guide;
GimpGrid *grid;
gdouble xspacing, yspacing;
gdouble xoffset, yoffset;
gint minxdist, minydist;
gint dist;
gint i;
gboolean snapped = FALSE;
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
g_return_val_if_fail (tx != NULL, FALSE);
g_return_val_if_fail (ty != NULL, FALSE);
if (! snap_to_guides && ! snap_to_grid)
return FALSE;
*tx = ROUND (x);
*ty = ROUND (y);
if (x < 0 || x >= gimage->width ||
y < 0 || y >= gimage->height)
{
return FALSE;
}
minxdist = G_MAXINT;
minydist = G_MAXINT;
if (snap_to_guides && gimage->guides != NULL)
{
for (list = gimage->guides; list; list = g_list_next (list))
{
guide = (GimpGuide *) list->data;
if (guide->position < 0)
continue;
switch (guide->orientation)
{
case GIMP_ORIENTATION_HORIZONTAL:
dist = ABS (guide->position - y);
if (dist < MIN (EPSILON, minydist))
{
minydist = dist;
*ty = guide->position;
snapped = TRUE;
}
break;
case GIMP_ORIENTATION_VERTICAL:
dist = ABS (guide->position - x);
if (dist < MIN (EPSILON, minxdist))
{
minxdist = dist;
*tx = guide->position;
snapped = TRUE;
}
break;
default:
break;
}
}
}
if (snap_to_grid && gimage->grid != NULL)
{
grid = gimp_image_get_grid (gimage);
g_object_get (grid,
"xspacing", &xspacing,
"yspacing", &yspacing,
"xoffset", &xoffset,
"yoffset", &yoffset,
NULL);
for (i = xoffset; i <= gimage->width; i += xspacing)
{
if (i < 0)
continue;
dist = ABS (i - x);
if (dist < MIN (EPSILON, minxdist))
{
minxdist = dist;
*tx = i;
snapped = TRUE;
}
}
for (i = yoffset; i <= gimage->height; i += yspacing)
{
if (i < 0)
continue;
dist = ABS (i - y);
if (dist < MIN (EPSILON, minydist))
{
minydist = dist;
*ty = i;
snapped = TRUE;
}
}
}
return snapped;
}
gboolean
gimp_image_snap_rectangle (GimpImage *gimage,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gint *tx1,
gint *ty1,
gboolean snap_to_guides,
gboolean snap_to_grid)
{
gint nx1, ny1;
gint nx2, ny2;
gboolean snap1, snap2, snap3, snap4;
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
g_return_val_if_fail (tx1 != NULL, FALSE);
g_return_val_if_fail (ty1 != NULL, FALSE);
if (! snap_to_guides && ! snap_to_grid)
return FALSE;
*tx1 = ROUND (x1);
*ty1 = ROUND (y1);
snap1 = gimp_image_snap_x (gimage, x1, &nx1,
snap_to_guides,
snap_to_grid);
snap2 = gimp_image_snap_x (gimage, x2, &nx2,
snap_to_guides,
snap_to_grid);
snap3 = gimp_image_snap_y (gimage, y1, &ny1,
snap_to_guides,
snap_to_grid);
snap4 = gimp_image_snap_y (gimage, y2, &ny2,
snap_to_guides,
snap_to_grid);
if (snap1 && snap2)
{
if (ABS (x1 - nx1) > ABS (x2 - nx2))
snap1 = FALSE;
else
snap2 = FALSE;
}
if (snap1)
*tx1 = nx1;
else if (snap2)
*tx1 = ROUND (x1 + (nx2 - x2));
if (snap3 && snap4)
{
if (ABS (y1 - ny1) > ABS (y2 - ny2))
snap3 = FALSE;
else
snap4 = FALSE;
}
if (snap3)
*ty1 = ny1;
else if (snap4)
*ty1 = ROUND (y1 + (ny2 - y2));
return (snap1 || snap2 || snap3 || snap4);
}
Reference in a new issue View git blame Copy permalink