| /******************************************************************************* |
| * Copyright (c) 2011, 2021 THALES GLOBAL SERVICES and others. |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Obeo - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.sirius.ext.gmf.runtime.editparts; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Objects; |
| import java.util.Optional; |
| |
| import org.eclipse.draw2d.FigureCanvas; |
| import org.eclipse.draw2d.FreeformViewport; |
| import org.eclipse.draw2d.IFigure; |
| import org.eclipse.draw2d.geometry.Dimension; |
| import org.eclipse.draw2d.geometry.Point; |
| import org.eclipse.draw2d.geometry.PointList; |
| import org.eclipse.draw2d.geometry.PrecisionPoint; |
| import org.eclipse.draw2d.geometry.PrecisionRectangle; |
| import org.eclipse.draw2d.geometry.Rectangle; |
| import org.eclipse.gef.EditPart; |
| import org.eclipse.gef.GraphicalEditPart; |
| import org.eclipse.gef.RootEditPart; |
| import org.eclipse.gef.SnapToGrid; |
| import org.eclipse.gef.handles.HandleBounds; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramRootEditPart; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; |
| import org.eclipse.gmf.runtime.draw2d.ui.figures.BaseSlidableAnchor; |
| import org.eclipse.gmf.runtime.draw2d.ui.geometry.LineSeg; |
| import org.eclipse.gmf.runtime.draw2d.ui.geometry.PointListUtilities; |
| import org.eclipse.gmf.runtime.notation.Anchor; |
| import org.eclipse.gmf.runtime.notation.IdentityAnchor; |
| import org.eclipse.sirius.ext.draw2d.figure.FigureUtilities; |
| import org.eclipse.sirius.ext.gmf.runtime.gef.ui.figures.IFigureWithoutLabels; |
| |
| /** |
| * Utility class to collect helper methods which deal with GraphicalOrdering but which are not part of its API. |
| * |
| * @author nlepine |
| */ |
| public final class GraphicalHelper { |
| private GraphicalHelper() { |
| // Prevent instantiation. |
| } |
| |
| /** |
| * Get the zoom factor. |
| * |
| * @param part |
| * the current part |
| * @return the zoom factor |
| */ |
| public static double getZoom(EditPart part) { |
| Objects.requireNonNull(part); |
| double scale = 1.0; |
| RootEditPart root = part.getRoot(); |
| if (root instanceof DiagramRootEditPart) { |
| DiagramRootEditPart rootEditPart = (DiagramRootEditPart) root; |
| scale = rootEditPart.getZoomManager().getZoom(); |
| } |
| return scale; |
| } |
| |
| /** |
| * Applied zoom on relative point.<BR> |
| * For example: |
| * <UL> |
| * <LI>For a zoom of 200%, the result of this method for the point (100, 100) is (200, 200)</LI> |
| * <LI>For a zoom of 50%, the result of this method for the point (100, 100) is (50, 50)</LI> |
| * </UL> |
| * |
| * @param part |
| * the current part |
| * @param relativePoint |
| * relative point |
| * @deprecated Use {@link #applyInverseZoomOnPoint(IGraphicalEditPart, Point)} instead |
| */ |
| @Deprecated |
| public static void appliedZoomOnRelativePoint(IGraphicalEditPart part, Point relativePoint) { |
| double zoom = getZoom(part); |
| if (relativePoint instanceof PrecisionPoint) { |
| ((PrecisionPoint) relativePoint).setPreciseLocation(relativePoint.preciseX() / zoom, relativePoint.preciseY() / zoom); |
| } else { |
| relativePoint.setLocation((int) (relativePoint.x * zoom), (int) (relativePoint.y * zoom)); |
| } |
| } |
| |
| /** |
| * Applies zoom on a point and returns this point for convenience.<BR> |
| * For example: |
| * <UL> |
| * <LI>For a zoom of 200%, the result of this method for the point (100, 100) is (200, 200)</LI> |
| * <LI>For a zoom of 50%, the result of this method for the point (100, 100) is (50, 50)</LI> |
| * </UL> |
| * |
| * @param part |
| * the current part |
| * @param point |
| * a point |
| * @return <code>point</code> for convenience |
| */ |
| public static Point applyZoomOnPoint(IGraphicalEditPart part, Point point) { |
| double zoom = getZoom(part); |
| if (point instanceof PrecisionPoint) { |
| ((PrecisionPoint) point).setPreciseLocation(point.preciseX() * zoom, point.preciseY() * zoom); |
| } else { |
| point.setLocation((int) (point.x * zoom), (int) (point.y * zoom)); |
| } |
| return point; |
| } |
| |
| /** |
| * Applies inverse zoom on a point and returns this point for convenience. <BR> |
| * For example: |
| * <UL> |
| * <LI>For a zoom of 200%, the result of this method for the point (100, 100) is (50, 50)</LI> |
| * <LI>For a zoom of 50%, the result of this method for the point (100, 100) is (200, 200)</LI> |
| * </UL> |
| * |
| * @param part |
| * the current part |
| * @param point |
| * a point |
| * @return <code>point</code> for convenience |
| */ |
| public static Point applyInverseZoomOnPoint(IGraphicalEditPart part, Point point) { |
| double zoom = getZoom(part); |
| if (point instanceof PrecisionPoint) { |
| ((PrecisionPoint) point).setPreciseLocation(point.preciseX() / zoom, point.preciseY() / zoom); |
| } else { |
| point.setLocation((int) (point.x / zoom), (int) (point.y / zoom)); |
| } |
| return point; |
| } |
| |
| /** |
| * Set the zoom factor. |
| * |
| * @param part |
| * the current part |
| * @param scale |
| * the zoom factor |
| */ |
| public static void setZoom(IGraphicalEditPart part, double scale) { |
| Objects.requireNonNull(part); |
| RootEditPart root = part.getRoot(); |
| if (root instanceof DiagramRootEditPart) { |
| DiagramRootEditPart rootEditPart = (DiagramRootEditPart) root; |
| rootEditPart.getZoomManager().setZoom(scale); |
| } |
| } |
| |
| /** |
| * Returns the difference between the logical origin (0, 0) and the top-left point actually visible. This |
| * corresponds to how much the scrollbars "shift" the diagram. |
| * |
| * @param part |
| * an edit part on the view |
| * @return the scroll size |
| */ |
| public static Point getScrollSize(GraphicalEditPart part) { |
| Objects.requireNonNull(part); |
| FreeformViewport viewport = FigureUtilities.getRootFreeformViewport(part.getFigure()); |
| if (viewport != null) { |
| return viewport.getViewLocation(); |
| } else { |
| return new Point(0, 0); |
| } |
| } |
| |
| /** |
| * Returns the difference between the logical origin (0, 0) and the top-left point actually visible. This |
| * corresponds to how much the scrollbars "shift" the successive containers. |
| * |
| * @param part |
| * an edit part on the view |
| * @return the scroll size |
| */ |
| protected static Point getContainerScrollSize(GraphicalEditPart part) { |
| Objects.requireNonNull(part); |
| Point result = new Point(0, 0); |
| Point diagramScrollSize = new Point(0, 0); |
| |
| IFigure current = part.getFigure(); |
| FreeformViewport rootFreeformViewport = null; |
| while (current != null) { |
| if (current instanceof FreeformViewport) { |
| rootFreeformViewport = (FreeformViewport) current; |
| diagramScrollSize = rootFreeformViewport.getViewLocation(); |
| result.translate(diagramScrollSize); |
| } |
| current = current.getParent(); |
| } |
| result.translate(diagramScrollSize.negate()); |
| return result; |
| } |
| |
| /** |
| * . |
| * |
| * @param part |
| * an edit part on the view |
| * @param scrollPosition |
| * the scroll size |
| */ |
| public static void setScrollSize(IGraphicalEditPart part, Point scrollPosition) { |
| Objects.requireNonNull(part); |
| // FreeformViewport viewport = |
| // FigureUtilities.getFreeformViewport(part.getFigure()); |
| // if (viewport != null) { |
| // viewport.setLocation(scrollPosition); |
| // } |
| if (part.getViewer().getControl() instanceof FigureCanvas) { |
| // UIThreadRunnable.syncExec(new VoidResult() { |
| // public void run() { |
| ((FigureCanvas) part.getViewer().getControl()).scrollTo(scrollPosition.x, scrollPosition.y); |
| // } |
| // }); |
| } |
| } |
| |
| /** |
| * Converts a point from screen coordinates to logical coordinates. |
| * |
| * @param point |
| * the point to convert. |
| * @param part |
| * a part from the diagram. |
| */ |
| public static void screen2logical(Point point, GraphicalEditPart part) { |
| point.translate(GraphicalHelper.getScrollSize(part)); |
| point.performScale(1.0d / GraphicalHelper.getZoom(part)); |
| } |
| |
| /** |
| * Converts a rectangle from screen coordinates to logical coordinates. |
| * |
| * @param rect |
| * the rectangle to convert. |
| * @param part |
| * a part from the diagram. |
| */ |
| public static void screen2logical(Rectangle rect, GraphicalEditPart part) { |
| screen2logical(rect, part, false); |
| } |
| |
| /** |
| * Converts a rectangle from screen coordinates to logical coordinates. |
| * |
| * @param rect |
| * the rectangle to convert. |
| * @param part |
| * a part from the diagram. |
| * @param considerAllScroll |
| * In all cases, the scroll of the diagram is used, but the scroll of containers are considered only if |
| * this parameter is true. |
| */ |
| protected static void screen2logical(Rectangle rect, GraphicalEditPart part, boolean considerAllScroll) { |
| double zoom = GraphicalHelper.getZoom(part); |
| if (considerAllScroll) { |
| rect.translate(GraphicalHelper.getContainerScrollSize(part).scale(zoom)); |
| } |
| rect.translate(GraphicalHelper.getScrollSize(part)); |
| rect.performScale(1.0d / zoom); |
| } |
| |
| /** |
| * Converts a dimension from screen coordinates to logical coordinates. Dimensions have no defined position, so only |
| * the current zoom level is take into account, not the scroll state. |
| * |
| * @param dim |
| * the dimension to convert. |
| * @param part |
| * a part from the diagram. |
| */ |
| public static void screen2logical(Dimension dim, IGraphicalEditPart part) { |
| dim.performScale(1.0d / GraphicalHelper.getZoom(part)); |
| } |
| |
| /** |
| * Converts a point from logical coordinates to screen coordinates. |
| * |
| * @param point |
| * the point to convert. |
| * @param part |
| * a part from the diagram. |
| */ |
| public static void logical2screen(Point point, IGraphicalEditPart part) { |
| point.performScale(GraphicalHelper.getZoom(part)); |
| point.translate(GraphicalHelper.getScrollSize(part).negate()); |
| } |
| |
| /** |
| * Converts a rectangle from logical coordinates to screen coordinates. |
| * |
| * @param rect |
| * the rectangle to convert. |
| * @param part |
| * a part from the diagram. |
| */ |
| public static void logical2screen(Rectangle rect, IGraphicalEditPart part) { |
| rect.performScale(GraphicalHelper.getZoom(part)); |
| rect.translate(GraphicalHelper.getScrollSize(part).negate()); |
| } |
| |
| /** |
| * Converts a dimension from logical coordinates to screen coordinates. Dimensions have no defined position, so only |
| * the current zoom level is take into account, not the scroll state. |
| * |
| * @param dim |
| * the dimension to convert. |
| * @param part |
| * a part from the diagram. |
| */ |
| public static void logical2Screen(Dimension dim, IGraphicalEditPart part) { |
| dim.performScale(GraphicalHelper.getZoom(part)); |
| } |
| |
| /** |
| * Return the Point (absolute draw2d coordinates) corresponding to this Anchor. If anchor is not an IdentityAnchor, |
| * the center of <code>parent</code> is returned. |
| * |
| * @param parent |
| * The parent node |
| * @param anchor |
| * The anchor |
| * @return The corresponding point to this anchor |
| */ |
| public static Point getAnchorPoint(GraphicalEditPart parent, Anchor anchor) { |
| if (anchor instanceof IdentityAnchor) { |
| return getAnchorPoint(parent, (IdentityAnchor) anchor); |
| } else { |
| return getAnchorPoint(parent, null); |
| } |
| } |
| |
| /** |
| * Return the Point (absolute draw2d coordinates) corresponding to this Anchor. If anchor is null, the center of |
| * <code>parent</code> is returned. |
| * |
| * @param parent |
| * The parent node |
| * @param anchor |
| * The anchor |
| * @return The corresponding point to this anchor |
| */ |
| public static Point getAnchorPoint(GraphicalEditPart parent, IdentityAnchor anchor) { |
| PrecisionRectangle bounds; |
| if (parent.getFigure() instanceof HandleBounds) { |
| bounds = new PrecisionRectangle(((HandleBounds) parent.getFigure()).getHandleBounds()); |
| } else { |
| bounds = new PrecisionRectangle(parent.getFigure().getBounds()); |
| } |
| parent.getFigure().translateToAbsolute(bounds); |
| screen2logical(bounds, parent); |
| |
| PrecisionPoint rel; |
| if (anchor != null) { |
| rel = BaseSlidableAnchor.parseTerminalString(anchor.getId()); |
| } else { |
| // If anchor is null, the default value is (0.5, 0.5) |
| rel = new PrecisionPoint(0.5, 0.5); |
| } |
| Point location = new PrecisionPoint(bounds.preciseX() + bounds.preciseWidth() * rel.preciseX(), bounds.preciseY() + bounds.preciseHeight() * rel.preciseY()); |
| return location; |
| } |
| |
| /** |
| * Get intersection between a line between lineOrigin and lineTerminus, and the rectangle bounds of the part. If |
| * there are several intersections, the shortest is returned. |
| * |
| * @param lineOrigin |
| * Origin of the line |
| * @param lineTerminus |
| * Terminus of the line |
| * @param part |
| * Part to detect intersection. |
| * @param minimalDistancefromLineOrigin |
| * true if the shortest distance is between the line origin and the part, false otherwise. |
| * @return Intersection between a line and a rectangle. |
| */ |
| public static Optional<Point> getIntersection(Point lineOrigin, Point lineTerminus, IGraphicalEditPart part, boolean minimalDistancefromLineOrigin) { |
| return getIntersection(lineOrigin, lineTerminus, part, minimalDistancefromLineOrigin, false); |
| } |
| |
| /** |
| * Get intersection between a line between lineOrigin and lineTerminus, and the rectangle bounds of the part. If |
| * there are several intersections, the shortest is returned. |
| * |
| * @param lineOrigin |
| * Origin of the line |
| * @param lineTerminus |
| * Terminus of the line |
| * @param part |
| * Part to detect intersection. |
| * @param minimalDistancefromLineOrigin |
| * true if the shortest distance is between the line origin and the part, false otherwise. |
| * @param useNearestPoint |
| * If true, if there is no intersection, the nearest point on the rectangle is returned. |
| * @return Intersection between a line and a rectangle. |
| */ |
| public static Optional<Point> getIntersection(Point lineOrigin, Point lineTerminus, IGraphicalEditPart part, boolean minimalDistancefromLineOrigin, boolean useNearestPoint) { |
| // Get the bounds of the part |
| Rectangle bounds = getAbsoluteBoundsIn100Percent(part); |
| return getIntersection(lineOrigin, lineTerminus, bounds, minimalDistancefromLineOrigin, useNearestPoint); |
| } |
| |
| /** |
| * Get intersection between a line between lineOrigin and lineTerminus, and a rectangle. If there are several |
| * intersections, the shortest is returned. |
| * |
| * @param lineOrigin |
| * Origin of the line |
| * @param lineTerminus |
| * Terminus of the line |
| * @param rectangle |
| * rectangle to detect intersection. |
| * @param minimalDistancefromLineOrigin |
| * true if the shortest distance is between the line origin and the part, false otherwise. |
| * @return Intersection between a line and a rectangle. |
| */ |
| public static Optional<Point> getIntersection(Point lineOrigin, Point lineTerminus, Rectangle rectangle, boolean minimalDistancefromLineOrigin) { |
| return getIntersection(lineOrigin, lineTerminus, rectangle, minimalDistancefromLineOrigin, false); |
| } |
| |
| /** |
| * Get intersection between a line between lineOrigin and lineTerminus, and a rectangle. If there are several |
| * intersections, the shortest is returned. |
| * |
| * @param lineOrigin |
| * Origin of the line |
| * @param lineTerminus |
| * Terminus of the line |
| * @param rectangle |
| * rectangle to detect intersection. |
| * @param minimalDistancefromLineOrigin |
| * true if the shortest distance is between the line origin and the part, false otherwise. |
| * @param useNearestPoint |
| * If true, if there is no intersection, the nearest point on the rectangle is returned. |
| * @return Intersection between a line and a rectangle. |
| */ |
| public static Optional<Point> getIntersection(Point lineOrigin, Point lineTerminus, Rectangle rectangle, boolean minimalDistancefromLineOrigin, boolean useNearestPoint) { |
| Optional<Point> result = Optional.empty(); |
| // Create the line segment |
| PointList line = new PointList(); |
| line.addPoint(lineOrigin); |
| line.addPoint(lineTerminus); |
| // Get the intersection |
| PointList partBoundsPointList = PointListUtilities.createPointsFromRect(rectangle); |
| PointList distances = new PointList(); |
| PointList intersections = new PointList(); |
| PointListUtilities.findIntersections(line, partBoundsPointList, intersections, distances); |
| |
| Point oppositePoint; |
| if (minimalDistancefromLineOrigin) { |
| oppositePoint = lineOrigin; |
| } else { |
| oppositePoint = lineTerminus; |
| } |
| if (intersections.size() > 0) { |
| Point shortestPoint = intersections.getFirstPoint(); |
| double minimalDistance = shortestPoint.getDistance(oppositePoint); |
| for (int i = 1; i < intersections.size(); i++) { |
| Point intersectionPoint = intersections.getPoint(i); |
| double currentDistance = intersectionPoint.getDistance(oppositePoint); |
| if (currentDistance < minimalDistance) { |
| minimalDistance = currentDistance; |
| shortestPoint = intersectionPoint; |
| } |
| } |
| result = Optional.of(shortestPoint); |
| } else if (!lineOrigin.equals(lineTerminus) && useNearestPoint) { |
| // If no intersection is found and the origin is not the terminus, |
| // the origin (or the terminus) is outside the rectangle, probably |
| // because of the snap, so we search the nearest point on the figure |
| // respecting one of the x or y coordinate. |
| Point linePointToConsider; |
| if (minimalDistancefromLineOrigin) { |
| linePointToConsider = lineTerminus; |
| } else { |
| linePointToConsider = lineOrigin; |
| } |
| |
| List<Point> nearestPoints = findNearestPoints(partBoundsPointList, linePointToConsider); |
| if (nearestPoints.size() > 0) { |
| double minimalDistance = -1; |
| Point resultPoint = null; |
| // Search the closest intersection |
| for (Point nearestPoint : nearestPoints) { |
| double distance = nearestPoint.getDistance(oppositePoint); |
| if (minimalDistance == -1 || distance < minimalDistance) { |
| minimalDistance = distance; |
| resultPoint = nearestPoint; |
| } |
| } |
| result = Optional.ofNullable(resultPoint); |
| } |
| |
| } |
| return result; |
| } |
| |
| private static List<Point> findNearestPoints(PointList partBoundsPointList, Point linePointToConsider) { |
| List<Point> nearestPoints = new ArrayList<>(); |
| List<?> rectangleBorders = PointListUtilities.getLineSegments(partBoundsPointList); |
| for (Object rectangleBorder : rectangleBorders) { |
| if (rectangleBorder instanceof LineSeg) { |
| LineSeg lineSeg = (LineSeg) rectangleBorder; |
| Point potentialNearestPoint; |
| if (lineSeg.getOrigin().x == lineSeg.getTerminus().x) { |
| potentialNearestPoint = new Point(lineSeg.getOrigin().x, linePointToConsider.y); |
| } else { |
| potentialNearestPoint = new Point(linePointToConsider.x, lineSeg.getOrigin().y); |
| } |
| if (lineSeg.containsPoint(potentialNearestPoint, 0)) { |
| nearestPoints.add(potentialNearestPoint); |
| } |
| } |
| } |
| return nearestPoints; |
| } |
| |
| /** |
| * Get the intersection point list between the segment formed by the start and end points and the given figure |
| * bounds. |
| * |
| * @param start |
| * start point |
| * @param end |
| * end point |
| * @param figureBounds |
| * the figure bounds. |
| * @return the intersection point list. |
| */ |
| public static PointList getIntersectionPoints(Point start, Point end, Rectangle figureBounds) { |
| PointList intersection = new PointList(); |
| final PointList polygon = PointListUtilities.createPointsFromRect(figureBounds); |
| LineSeg lineSeg = new LineSeg(start, end); |
| PointList intersectionTemp = lineSeg.getLineIntersectionsWithLineSegs(polygon); |
| for (int i = 0; i < intersectionTemp.size(); i++) { |
| Point currentPoint = intersectionTemp.getPoint(i); |
| if (lineSeg.containsPoint(currentPoint, 1)) { |
| intersection.addPoint(currentPoint); |
| } |
| } |
| return intersection; |
| } |
| |
| /** |
| * Get the absolute bounds of this <code>part</code>.<BR> |
| * Detail: If the zoom is set to 200%, the location and the size are multiplied by two with respect to the real |
| * location and size. |
| * |
| * @param part |
| * The part to consider. |
| * @return The absolute bounds. |
| */ |
| public static Rectangle getAbsoluteBounds(IGraphicalEditPart part) { |
| PrecisionRectangle bounds; |
| if (part.getFigure() instanceof HandleBounds) { |
| bounds = new PrecisionRectangle(((HandleBounds) part.getFigure()).getHandleBounds()); |
| } else { |
| bounds = new PrecisionRectangle(part.getFigure().getBounds()); |
| } |
| part.getFigure().translateToAbsolute(bounds); |
| return bounds; |
| } |
| |
| /** |
| * Get the absolute bounds of this <code>part</code>. In case of zoom or/and a scrollbar, the bounds are converted |
| * from screen to logical.<BR> |
| * |
| * @param part |
| * The part to consider. |
| * @return The absolute bounds. |
| */ |
| public static Rectangle getAbsoluteBoundsIn100Percent(GraphicalEditPart part) { |
| return getAbsoluteBoundsIn100Percent(part, false); |
| } |
| |
| /** |
| * Get the absolute bounds of this <code>part</code>. In case of zoom or/and scrollbars, the bounds are converted |
| * from screen to logical.<BR> |
| * |
| * @param part |
| * The part to consider. |
| * @param considerAllScroll |
| * In all cases, the scroll of the diagram is used, but the scroll of containers are considered only if |
| * this parameter is true. |
| * @return The absolute bounds. |
| */ |
| public static Rectangle getAbsoluteBoundsIn100Percent(GraphicalEditPart part, boolean considerAllScroll) { |
| PrecisionRectangle bounds; |
| if (part.getFigure() instanceof HandleBounds) { |
| bounds = new PrecisionRectangle(((HandleBounds) part.getFigure()).getHandleBounds()); |
| } else { |
| bounds = new PrecisionRectangle(part.getFigure().getBounds()); |
| } |
| part.getFigure().translateToAbsolute(bounds); |
| screen2logical(bounds, part, considerAllScroll); |
| return bounds; |
| } |
| |
| /** |
| * Get the absolute bounds of this <code>part</code> by excluding labels from the bounds.<br/> |
| * In case of zoom or/and scrollbars, the bounds are converted from screen to logical.<BR> |
| * |
| * @param part |
| * The part to consider. |
| * @return The absolute bounds. |
| */ |
| public static Rectangle getAbsoluteBoundsWithoutLabelsIn100Percent(GraphicalEditPart part) { |
| PrecisionRectangle bounds; |
| if (part.getFigure() instanceof IFigureWithoutLabels) { |
| bounds = new PrecisionRectangle(((IFigureWithoutLabels) part.getFigure()).getBoundsWithoutLabels()); |
| part.getFigure().translateToAbsolute(bounds); |
| screen2logical(bounds, part, false); |
| } else { |
| bounds = new PrecisionRectangle(getAbsoluteBoundsIn100Percent(part)); |
| } |
| return bounds; |
| } |
| |
| /** |
| * Return true if the snapToGrid is enabled for the diagram containing this edit part, false otherwise. |
| * |
| * @param editPart |
| * The edit part to use. |
| * @return true if the snapToGrid is enabled for the diagram containing this edit part, false otherwise. |
| */ |
| public static boolean isSnapToGridEnabled(EditPart editPart) { |
| return (Boolean) editPart.getViewer().getProperty(SnapToGrid.PROPERTY_GRID_ENABLED); |
| } |
| |
| /** |
| * Return the grid spacing in pixels for the diagram containing this edit part. |
| * |
| * @param editPart |
| * The edit part to use. |
| * @return the grid spacing in pixels. |
| */ |
| public static int getGridSpacing(EditPart editPart) { |
| return ((Dimension) editPart.getViewer().getProperty(SnapToGrid.PROPERTY_GRID_SPACING)).width; |
| } |
| } |
