org.eclipse.gef.SnapToGrid Maven / Gradle / Ivy
/*******************************************************************************
* Copyright (c) 2003, 2010, 2012 IBM Corporation, Gerhardt Informatics Kft. and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Gerhardt Informatics Kft. - GEFGWT port
*******************************************************************************/
package org.eclipse.gef;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PrecisionRectangle;
/**
* A helper used to perform snapping to a grid, which is specified on the
* graphical viewer via the various properties defined in this class. This
* helper can be used in conjunction with the
* {@link org.eclipse.gef.tools.DragEditPartsTracker DragEditPartsTracker} when
* dragging editparts within a graphical viewer. When snapping a rectangle, the
* edges of the rectangle will snap along gridlines.
*
* This helper does not keep up with changes made to the graphical viewer's
* properties. Clients should instantiate a new helper each time one is
* requested and not hold on to instances of the helper, if the grid properties
* specified on the viewer are subject to change.
*
* @author Randy Hudson
* @author Pratik Shah
* @since 3.0
* @see org.eclipse.gef.editparts.GridLayer
*/
public class SnapToGrid extends SnapToHelper {
/**
* A viewer property indicating whether the snap function is enabled. The
* value must be a Boolean.
*/
public static final String PROPERTY_GRID_ENABLED = "SnapToGrid.isEnabled"; //$NON-NLS-1$
/**
* A viewer property indicating whether the grid should be displayed. The
* value must be a Boolean.
*/
public static final String PROPERTY_GRID_VISIBLE = "SnapToGrid.isVisible"; //$NON-NLS-1$
/**
* A viewer property indicating the grid spacing. The value must be a
* {@link Dimension}.
*/
public static final String PROPERTY_GRID_SPACING = "SnapToGrid.GridSpacing"; //$NON-NLS-1$
/**
* A viewer property indicating the grid's origin. The value must be a
* {@link Point}.
*/
public static final String PROPERTY_GRID_ORIGIN = "SnapToGrid.GridOrigin"; //$NON-NLS-1$
/**
* The default grid size if the viewer does not specify a size.
*
* @see #PROPERTY_GRID_SPACING
*/
public static final int DEFAULT_GRID_SIZE = 12;
/**
* @deprecated use DEFAULT_GRID_SIZE
*/
public static final int DEFAULT_GAP = DEFAULT_GRID_SIZE;
/**
* The graphical part whose content's figure defines the grid.
*/
protected GraphicalEditPart container;
/**
* The horizontal interval for the grid
*/
protected int gridX;
/**
* The vertical interval for the grid
*/
protected int gridY;
/**
* The origin of the grid.
*/
protected Point origin;
/**
* Constructs a gridded snap helper on the given editpart. The editpart
* should be the graphical editpart whose contentspane figure is used as the
* reference for the grid.
*
* @param container
* the editpart which the grid is on
*/
public SnapToGrid(GraphicalEditPart container) {
this.container = container;
Dimension spacing = (Dimension) container.getViewer().getProperty(
PROPERTY_GRID_SPACING);
if (spacing != null) {
gridX = spacing.width;
gridY = spacing.height;
}
if (gridX == 0)
gridX = DEFAULT_GRID_SIZE;
if (gridY == 0)
gridY = DEFAULT_GRID_SIZE;
Point loc = (Point) container.getViewer().getProperty(
PROPERTY_GRID_ORIGIN);
if (loc != null)
origin = loc;
else
origin = new Point();
}
/**
* @see SnapToHelper#snapRectangle(Request, int, PrecisionRectangle,
* PrecisionRectangle)
*/
public int snapRectangle(Request request, int snapLocations,
PrecisionRectangle rect, PrecisionRectangle result) {
rect = rect.getPreciseCopy();
makeRelative(container.getContentPane(), rect);
PrecisionRectangle correction = new PrecisionRectangle();
makeRelative(container.getContentPane(), correction);
if (gridX > 0 && (snapLocations & EAST) != 0) {
correction.setPreciseWidth(correction.preciseWidth()
- localIEEEremainder(rect.preciseRight() - origin.x - 1,
gridX));
snapLocations &= ~EAST;
}
if ((snapLocations & (WEST | HORIZONTAL)) != 0 && gridX > 0) {
double leftCorrection = localIEEEremainder(rect.preciseX()
- origin.x, gridX);
correction.setPreciseX(correction.preciseX() - leftCorrection);
if ((snapLocations & HORIZONTAL) == 0) {
correction.setPreciseWidth(correction.preciseWidth()
+ leftCorrection);
}
snapLocations &= ~(WEST | HORIZONTAL);
}
if ((snapLocations & SOUTH) != 0 && gridY > 0) {
correction.setPreciseHeight(correction.preciseHeight()
- localIEEEremainder(rect.preciseBottom() - origin.y - 1,
gridY));
snapLocations &= ~SOUTH;
}
if ((snapLocations & (NORTH | VERTICAL)) != 0 && gridY > 0) {
double topCorrection = localIEEEremainder(rect.preciseY()
- origin.y, gridY);
correction.setPreciseY(correction.preciseY() - topCorrection);
if ((snapLocations & VERTICAL) == 0) {
correction.setPreciseHeight(correction.preciseHeight()
+ topCorrection);
}
snapLocations &= ~(NORTH | VERTICAL);
}
makeAbsolute(container.getContentPane(), correction);
result.setPreciseX(result.preciseX() + correction.preciseX());
result.setPreciseY(result.preciseY() + correction.preciseY());
result.setPreciseWidth(result.preciseWidth()
+ correction.preciseWidth());
result.setPreciseHeight(result.preciseHeight()
+ correction.preciseHeight());
return snapLocations;
}
private double localIEEEremainder(double f1, double f2) {
// return Math.IEEEremainder(f1, f2);
if (Double.isNaN(f1) || Double.isNaN(f2) || Double.isInfinite(f1)
|| f2 == 0) {
return Double.NaN;
}
if (Double.isInfinite(f1) == false && Double.isInfinite(f1) == true) {
return f1;
}
double d = 2 * f1 / f2;
long n;
if (Math.floor(d) == d) {
if (Math.floor(d / 2) % 2 == 0) {
n = (long) Math.floor(d / 2);
} else {
n = (long) Math.ceil(d / 2);
}
} else {
n = Math.round(d / 2);
}
return f1 - (f2 * n);
}
}