org.eclipse.jface.util.Geometry Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.eclipse.jface Show documentation
Show all versions of org.eclipse.jface Show documentation
This is org.eclipse.jface jar used by Scout SDK
The newest version!
/*******************************************************************************
* Copyright (c) 2004, 2015 IBM Corporation 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
*******************************************************************************/
package org.eclipse.jface.util;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;
/**
* Contains static methods for performing simple geometric operations
* on the SWT geometry classes.
*
* @since 3.0
*/
public class Geometry {
/**
* Prevent this class from being instantiated.
*
* @since 3.0
*/
private Geometry() {
//This is not instantiated
}
/**
* Returns the square of the distance between two points.
* This is preferred over the real distance when searching
* for the closest point, since it avoids square roots.
*
* @param p1 first endpoint
* @param p2 second endpoint
* @return the square of the distance between the two points
*
* @since 3.0
*/
public static int distanceSquared(Point p1, Point p2) {
int term1 = p1.x - p2.x;
int term2 = p1.y - p2.y;
return term1 * term1 + term2 * term2;
}
/**
* Returns the magnitude of the given 2d vector (represented as a Point)
*
* @param p point representing the 2d vector whose magnitude is being computed
* @return the magnitude of the given 2d vector
* @since 3.0
*/
public static double magnitude(Point p) {
return Math.sqrt(magnitudeSquared(p));
}
/**
* Returns the square of the magnitude of the given 2-space vector (represented
* using a point)
*
* @param p the point whose magnitude is being computed
* @return the square of the magnitude of the given vector
* @since 3.0
*/
public static int magnitudeSquared(Point p) {
return p.x * p.x + p.y * p.y;
}
/**
* Returns the dot product of the given vectors (expressed as Points)
*
* @param p1 the first vector
* @param p2 the second vector
* @return the dot product of the two vectors
* @since 3.0
*/
public static int dotProduct(Point p1, Point p2) {
return p1.x * p2.x + p1.y * p2.y;
}
/**
* Returns a new point whose coordinates are the minimum of the coordinates of the
* given points
*
* @param p1 a Point
* @param p2 a Point
* @return a new point whose coordinates are the minimum of the coordinates of the
* given points
* @since 3.0
*/
public static Point min(Point p1, Point p2) {
return new Point(Math.min(p1.x, p2.x), Math.min(p1.y, p2.y));
}
/**
* Returns a new point whose coordinates are the maximum of the coordinates
* of the given points
* @param p1 a Point
* @param p2 a Point
* @return point a new point whose coordinates are the maximum of the coordinates
* @since 3.0
*/
public static Point max(Point p1, Point p2) {
return new Point(Math.max(p1.x, p2.x), Math.max(p1.y, p2.y));
}
/**
* Returns a vector in the given direction with the given
* magnitude. Directions are given using SWT direction constants, and
* the resulting vector is in the screen's coordinate system. That is,
* the vector (0, 1) is down and the vector (1, 0) is right.
*
* @param distance magnitude of the vector
* @param direction one of SWT.TOP, SWT.BOTTOM, SWT.LEFT, or SWT.RIGHT
* @return a point representing a vector in the given direction with the given magnitude
* @since 3.0
*/
public static Point getDirectionVector(int distance, int direction) {
switch (direction) {
case SWT.TOP:
return new Point(0, -distance);
case SWT.BOTTOM:
return new Point(0, distance);
case SWT.LEFT:
return new Point(-distance, 0);
case SWT.RIGHT:
return new Point(distance, 0);
}
return new Point(0, 0);
}
/**
* Returns the point in the center of the given rectangle.
*
* @param rect rectangle being computed
* @return a Point at the center of the given rectangle.
* @since 3.0
*/
public static Point centerPoint(Rectangle rect) {
return new Point(rect.x + rect.width / 2, rect.y + rect.height / 2);
}
/**
* Returns a copy of the given point
*
* @param toCopy point to copy
* @return a copy of the given point
*/
public static Point copy(Point toCopy) {
return new Point(toCopy.x, toCopy.y);
}
/**
* Sets result equal to toCopy
*
* @param result object that will be modified
* @param toCopy object that will be copied
* @since 3.1
*/
public static void set(Point result, Point toCopy) {
result.x = toCopy.x;
result.y = toCopy.y;
}
/**
* Sets result equal to toCopy
*
* @param result object that will be modified
* @param toCopy object that will be copied
* @since 3.1
*/
public static void set(Rectangle result, Rectangle toCopy) {
result.x = toCopy.x;
result.y = toCopy.y;
result.width = toCopy.width;
result.height = toCopy.height;
}
/**
* Returns a new difference Rectangle whose x, y, width, and height are equal to the difference of the corresponding
* attributes from the given rectangles
*
*
* Example: Compute the margins for a given Composite, and apply those same margins to a new GridLayout
*
*
* // Compute the client area, in the coordinate system of the input composite's parent
* Rectangle clientArea = Display.getCurrent().map(inputComposite,
* inputComposite.getParent(), inputComposite.getClientArea());
*
* // Compute the margins for a given Composite by subtracting the client area from the composite's bounds
* Rectangle margins = Geometry.subtract(inputComposite.getBounds(), clientArea);
*
* // Now apply these margins to a new GridLayout
* GridLayout layout = GridLayoutFactory.fillDefaults().margins(margins).create();
* Returns a new Rectangle whose x, y, width, and height is the sum of the x, y, width, and height values of
* both rectangles respectively.
*
* @param rect1 first rectangle to add
* @param rect2 second rectangle to add
* @return a new rectangle whose x, y, height, and width attributes are the sum of the corresponding attributes from
* the arguments.
* @since 3.3
*/
public static Rectangle add(Rectangle rect1, Rectangle rect2) {
return new Rectangle(rect1.x + rect2.x, rect1.y + rect2.y,
rect1.width + rect2.width, rect1.height + rect2.height);
}
/**
* Adds two points as 2d vectors. Returns a new point whose coordinates are
* the sum of the original two points.
*
* @param point1 the first point (not null)
* @param point2 the second point (not null)
* @return a new point whose coordinates are the sum of the given points
* @since 3.0
*/
public static Point add(Point point1, Point point2) {
return new Point(point1.x + point2.x, point1.y + point2.y);
}
/**
* Divides both coordinates of the given point by the given scalar.
*
* @since 3.1
*
* @param toDivide point to divide
* @param scalar denominator
* @return a new Point whose coordinates are equal to the original point divided by the scalar
*/
public static Point divide(Point toDivide, int scalar) {
return new Point(toDivide.x / scalar, toDivide.y / scalar);
}
/**
* Performs vector subtraction on two points. Returns a new point equal to
* (point1 - point2).
*
* @param point1 initial point
* @param point2 vector to subtract
* @return the difference (point1 - point2)
* @since 3.0
*/
public static Point subtract(Point point1, Point point2) {
return new Point(point1.x - point2.x, point1.y - point2.y);
}
/**
* Swaps the X and Y coordinates of the given point.
*
* @param toFlip modifies this point
* @since 3.1
*/
public static void flipXY(Point toFlip) {
int temp = toFlip.x;
toFlip.x = toFlip.y;
toFlip.y = temp;
}
/**
* Swaps the X and Y coordinates of the given rectangle, along with the height and width.
*
* @param toFlip modifies this rectangle
* @since 3.1
*/
public static void flipXY(Rectangle toFlip) {
int temp = toFlip.x;
toFlip.x = toFlip.y;
toFlip.y = temp;
temp = toFlip.width;
toFlip.width = toFlip.height;
toFlip.height = temp;
}
/**
* Returns the height or width of the given rectangle.
*
* @param toMeasure rectangle to measure
* @param width returns the width if true, and the height if false
* @return the width or height of the given rectangle
* @since 3.0
*/
public static int getDimension(Rectangle toMeasure, boolean width) {
if (width) {
return toMeasure.width;
}
return toMeasure.height;
}
/**
* Returns the x or y coordinates of the given point.
*
* @param toMeasure point being measured
* @param width if true, returns x. Otherwise, returns y.
* @return the x or y coordinate
* @since 3.1
*/
public static int getCoordinate(Point toMeasure, boolean width) {
return width ? toMeasure.x : toMeasure.y;
}
/**
* Returns the x or y coordinates of the given rectangle.
*
* @param toMeasure rectangle being measured
* @param width if true, returns x. Otherwise, returns y.
* @return the x or y coordinate
* @since 3.1
*/
public static int getCoordinate(Rectangle toMeasure, boolean width) {
return width ? toMeasure.x : toMeasure.y;
}
/**
* Sets one dimension of the given rectangle. Modifies the given rectangle.
*
* @param toSet rectangle to modify
* @param width if true, the width is modified. If false, the height is modified.
* @param newCoordinate new value of the width or height
* @since 3.1
*/
public static void setDimension(Rectangle toSet, boolean width, int newCoordinate) {
if (width) {
toSet.width = newCoordinate;
} else {
toSet.height = newCoordinate;
}
}
/**
* Sets one coordinate of the given rectangle. Modifies the given rectangle.
*
* @param toSet rectangle to modify
* @param width if true, the x coordinate is modified. If false, the y coordinate is modified.
* @param newCoordinate new value of the x or y coordinates
* @since 3.1
*/
public static void setCoordinate(Rectangle toSet, boolean width, int newCoordinate) {
if (width) {
toSet.x = newCoordinate;
} else {
toSet.y = newCoordinate;
}
}
/**
* Sets one coordinate of the given point. Modifies the given point.
*
* @param toSet point to modify
* @param width if true, the x coordinate is modified. If false, the y coordinate is modified.
* @param newCoordinate new value of the x or y coordinates
* @since 3.1
*/
public static void setCoordinate(Point toSet, boolean width, int newCoordinate) {
if (width) {
toSet.x = newCoordinate;
} else {
toSet.y = newCoordinate;
}
}
/**
* Returns the distance of the given point from a particular side of the given rectangle.
* Returns negative values for points outside the rectangle.
*
* @param rectangle a bounding rectangle
* @param testPoint a point to test
* @param edgeOfInterest side of the rectangle to test against
* @return the distance of the given point from the given edge of the rectangle
* @since 3.0
*/
public static int getDistanceFromEdge(Rectangle rectangle, Point testPoint,
int edgeOfInterest) {
switch (edgeOfInterest) {
case SWT.TOP:
return testPoint.y - rectangle.y;
case SWT.BOTTOM:
return rectangle.y + rectangle.height - testPoint.y;
case SWT.LEFT:
return testPoint.x - rectangle.x;
case SWT.RIGHT:
return rectangle.x + rectangle.width - testPoint.x;
}
return 0;
}
/**
* Extrudes the given edge inward by the given distance. That is, if one side of the rectangle
* was sliced off with a given thickness, this returns the rectangle that forms the slice. Note
* that the returned rectangle will be inside the given rectangle if size > 0.
*
* @param toExtrude the rectangle to extrude. The resulting rectangle will share three sides
* with this rectangle.
* @param size distance to extrude. A negative size will extrude outwards (that is, the resulting
* rectangle will overlap the original iff this is positive).
* @param orientation the side to extrude. One of SWT.LEFT, SWT.RIGHT, SWT.TOP, or SWT.BOTTOM. The
* resulting rectangle will always share this side with the original rectangle.
* @return a rectangle formed by extruding the given side of the rectangle by the given distance.
* @since 3.0
*/
public static Rectangle getExtrudedEdge(Rectangle toExtrude, int size,
int orientation) {
Rectangle bounds = new Rectangle(toExtrude.x, toExtrude.y,
toExtrude.width, toExtrude.height);
if (!isHorizontal(orientation)) {
bounds.width = size;
} else {
bounds.height = size;
}
switch (orientation) {
case SWT.RIGHT:
bounds.x = toExtrude.x + toExtrude.width - bounds.width;
break;
case SWT.BOTTOM:
bounds.y = toExtrude.y + toExtrude.height - bounds.height;
break;
}
normalize(bounds);
return bounds;
}
/**
* Returns the opposite of the given direction. That is, returns SWT.LEFT if
* given SWT.RIGHT and visa-versa.
*
* @param swtDirectionConstant one of SWT.LEFT, SWT.RIGHT, SWT.TOP, or SWT.BOTTOM
* @return one of SWT.LEFT, SWT.RIGHT, SWT.TOP, or SWT.BOTTOM
* @since 3.0
*/
public static int getOppositeSide(int swtDirectionConstant) {
switch (swtDirectionConstant) {
case SWT.TOP:
return SWT.BOTTOM;
case SWT.BOTTOM:
return SWT.TOP;
case SWT.LEFT:
return SWT.RIGHT;
case SWT.RIGHT:
return SWT.LEFT;
}
return swtDirectionConstant;
}
/**
* Converts the given boolean into an SWT orientation constant.
*
* @param horizontal if true, returns SWT.HORIZONTAL. If false, returns SWT.VERTICAL
* @return SWT.HORIZONTAL or SWT.VERTICAL.
* @since 3.0
*/
public static int getSwtHorizontalOrVerticalConstant(boolean horizontal) {
if (horizontal) {
return SWT.HORIZONTAL;
}
return SWT.VERTICAL;
}
/**
* Returns true iff the given SWT side constant corresponds to a horizontal side
* of a rectangle. That is, returns true for the top and bottom but false for the
* left and right.
*
* @param swtSideConstant one of SWT.TOP, SWT.BOTTOM, SWT.LEFT, or SWT.RIGHT
* @return true iff the given side is horizontal.
* @since 3.0
*/
public static boolean isHorizontal(int swtSideConstant) {
return !(swtSideConstant == SWT.LEFT || swtSideConstant == SWT.RIGHT);
}
/**
* Moves the given rectangle by the given delta.
*
* @param rect rectangle to move (will be modified)
* @param delta direction vector to move the rectangle by
* @since 3.0
*/
public static void moveRectangle(Rectangle rect, Point delta) {
rect.x += delta.x;
rect.y += delta.y;
}
/**
* Moves each edge of the given rectangle outward by the given amount. Negative values
* cause the rectangle to contract. Does not allow the rectangle's width or height to be
* reduced below zero.
*
* @param rect normalized rectangle to modify
* @param differenceRect difference rectangle to be added to rect
* @since 3.3
*/
public static void expand(Rectangle rect, Rectangle differenceRect) {
rect.x += differenceRect.x;
rect.y += differenceRect.y;
rect.height = Math.max(0, rect.height + differenceRect.height);
rect.width = Math.max(0, rect.width + differenceRect.width);
}
/**
* Returns a rectangle which, when added to another rectangle, will expand each side
* by the given number of units.
*
* This is commonly used to store margin sizes. For example:
*
*
* // Expands the left, right, top, and bottom
* // of the given control by 10, 5, 1, and 15 units respectively
*
* Rectangle margins = Geometry.createDifferenceRect(10,5,1,15);
* Rectangle bounds = someControl.getBounds();
* someControl.setBounds(Geometry.add(bounds, margins));
*