/*
* Copyright (c) 2002-@year@, University of Maryland
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided
* that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of conditions
* and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions
* and the following disclaimer in the documentation and/or other materials provided with the
* distribution.
*
* Neither the name of the University of Maryland nor the names of its contributors may be used to
* endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Piccolo was written at the Human-Computer Interaction Laboratory www.cs.umd.edu/hcil by Jesse Grosjean
* under the supervision of Ben Bederson. The Piccolo website is www.cs.umd.edu/hcil/piccolo.
*/
package edu.umd.cs.piccolox.swt;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Paint;
import java.awt.Shape;
import java.awt.geom.AffineTransform;
import java.awt.geom.Arc2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import edu.umd.cs.piccolo.PNode;
import edu.umd.cs.piccolo.nodes.PPath;
import edu.umd.cs.piccolo.util.PAffineTransform;
import edu.umd.cs.piccolo.util.PBounds;
import edu.umd.cs.piccolo.util.PPaintContext;
/**
* <b>PPath</b> is a wrapper around a java.awt.geom.GeneralPath. The
* setBounds method works by scaling the path to fit into the specified
* bounds. This normally works well, but if the specified base bounds
* get too small then it is impossible to expand the path shape again since
* all its numbers have tended to zero, so application code may need to take
* this into consideration.
* <P>
* One option that applications have is to call <code>startResizeBounds</code> before
* starting an interaction that may make the bounds very small, and calling
* <code>endResizeBounds</code> when this interaction is finished. When this is done
* PPath will use a copy of the original path to do the resizing so the numbers
* in the path wont loose resolution.
* <P>
* This class also provides methods for constructing common shapes using a
* general path.
* <P>
* @version 1.0
* @author Jesse Grosjean
*/
public class PSWTPath extends PNode {
/**
* The property name that identifies a change of this node's path.
* In any property change event the new value will be a reference to
* this node's path, but old value will always be null.
*/
public static final String PROPERTY_SHAPE = "shape";
private static final double BOUNDS_TOLERANCE = 0.01;
private static final Rectangle2D.Float TEMP_RECTANGLE = new Rectangle2D.Float();
private static final RoundRectangle2D.Float TEMP_ROUNDRECTANGLE = new RoundRectangle2D.Float();
private static final Ellipse2D.Float TEMP_ELLIPSE = new Ellipse2D.Float();
private static final PAffineTransform TEMP_TRANSFORM = new PAffineTransform();
private static final Color DEFAULT_STROKE_PAINT = Color.black;
private static final BasicStroke BASIC_STROKE = new BasicStroke();
private static final float PEN_WIDTH = 1f;
private Paint strokePaint;
boolean updatingBoundsFromPath;
Shape origShape;
Shape shape;
PAffineTransform internalXForm;
AffineTransform inverseXForm;
double[] shapePts;
public static PSWTPath createRectangle(float x, float y, float width, float height) {
TEMP_RECTANGLE.setFrame(x, y, width, height);
PSWTPath result = new PSWTPath(TEMP_RECTANGLE);
result.setPaint(Color.white);
return result;
}
public static PSWTPath createRoundRectangle(float x, float y, float width, float height, float arcWidth, float arcHeight) {
TEMP_ROUNDRECTANGLE.setRoundRect(x, y, width, height, arcWidth, arcHeight);
PSWTPath result = new PSWTPath(TEMP_ROUNDRECTANGLE);
result.setPaint(Color.white);
return result;
}
public static PSWTPath createEllipse(float x, float y, float width, float height) {
TEMP_ELLIPSE.setFrame(x, y, width, height);
PSWTPath result = new PSWTPath(TEMP_ELLIPSE);
result.setPaint(Color.white);
return result;
}
public static PSWTPath createPolyline(Point2D[] points) {
PSWTPath result = new PSWTPath();
result.setPathToPolyline(points);
result.setPaint(Color.white);
return result;
}
public static PSWTPath createPolyline(float[] xp, float[] yp) {
PSWTPath result = new PSWTPath();
result.setPathToPolyline(xp, yp);
result.setPaint(Color.white);
return result;
}
public PSWTPath() {
strokePaint = DEFAULT_STROKE_PAINT;
}
public PSWTPath(Shape aShape) {
this();
setShape(aShape);
}
//****************************************************************
// Stroke
//****************************************************************
public Paint getStrokePaint() {
return strokePaint;
}
public void setStrokeColor(Paint aPaint) {
Paint old = strokePaint;
strokePaint = aPaint;
invalidatePaint();
firePropertyChange(PPath.PROPERTY_CODE_STROKE_PAINT, PPath.PROPERTY_STROKE_PAINT, old, strokePaint);
}
/**
* Set the bounds of this path. This method works by scaling the path
* to fit into the specified bounds. This normally works well, but if
* the specified base bounds get too small then it is impossible to
* expand the path shape again since all its numbers have tended to zero,
* so application code may need to take this into consideration.
*/
protected void internalUpdateBounds(double x, double y, double width, double height) {
if (updatingBoundsFromPath) return;
if (origShape == null) return;
Rectangle2D pathBounds = origShape.getBounds2D();
if (Math.abs(x-pathBounds.getX())/x < BOUNDS_TOLERANCE &&
Math.abs(y-pathBounds.getY())/y < BOUNDS_TOLERANCE &&
Math.abs(width-pathBounds.getWidth())/width < BOUNDS_TOLERANCE &&
Math.abs(height-pathBounds.getHeight())/height < BOUNDS_TOLERANCE) {
return;
}
if (internalXForm == null) {
internalXForm = new PAffineTransform();
}
internalXForm.setToIdentity();
internalXForm.translate(x, y);
internalXForm.scale(width / pathBounds.getWidth(), height / pathBounds.getHeight());
internalXForm.translate(-pathBounds.getX(), -pathBounds.getY());
try {
inverseXForm = internalXForm.createInverse();
}
catch (Exception e) {
}
}
public boolean intersects(Rectangle2D aBounds) {
if (super.intersects(aBounds)) {
if (internalXForm != null) {
aBounds = new PBounds(aBounds);
internalXForm.inverseTransform(aBounds,aBounds);
}
if (getPaint() != null && shape.intersects(aBounds)) {
return true;
} else if (strokePaint != null) {
return BASIC_STROKE.createStrokedShape(shape).intersects(aBounds);
}
}
return false;
}
public void updateBoundsFromPath() {
updatingBoundsFromPath = true;
if (origShape == null) {
resetBounds();
} else {
Rectangle2D b = origShape.getBounds2D();
// Note that this pen width code does not really work for SWT since it assumes
// that the pen width scales - in actuality it does not. However, the fix would
// be to have volatile bounds for all shapes which isn't a nice alternative
super.setBounds(b.getX()-PEN_WIDTH,
b.getY()-PEN_WIDTH,
b.getWidth()+2*PEN_WIDTH,
b.getHeight()+2*PEN_WIDTH);
}
updatingBoundsFromPath = false;
}
//****************************************************************
// Painting
//****************************************************************
protected void paint(PPaintContext paintContext) {
Paint p = getPaint();
SWTGraphics2D g2 = (SWTGraphics2D)paintContext.getGraphics();
if (internalXForm != null) {
g2.transform(internalXForm);
}
if (p != null) {
g2.setBackground((Color)p);
double lineWidth = g2.getTransformedLineWidth();
if (shape instanceof Rectangle2D) {
g2.fillRect(shapePts[0]+lineWidth/2,shapePts[1]+lineWidth/2,shapePts[2]-lineWidth,shapePts[3]-lineWidth);
}
else if (shape instanceof Ellipse2D) {
g2.fillOval(shapePts[0]+lineWidth/2,shapePts[1]+lineWidth/2,shapePts[2]-lineWidth,shapePts[3]-lineWidth);
}
else if (shape instanceof Arc2D) {
g2.fillArc(shapePts[0]+lineWidth/2,shapePts[1]+lineWidth/2,shapePts[2]-lineWidth,shapePts[3]-lineWidth,shapePts[4],shapePts[5]);
}
else if (shape instanceof RoundRectangle2D) {
g2.fillRoundRect(shapePts[0]+lineWidth/2,shapePts[1]+lineWidth/2,shapePts[2]-lineWidth,shapePts[3]-lineWidth,shapePts[4],shapePts[5]);
}
else {
g2.fillPolygon(shapePts);
}
}
if (strokePaint != null) {
g2.setColor((Color)strokePaint);
double lineWidth = g2.getTransformedLineWidth();
if (shape instanceof Rectangle2D) {
g2.drawRect(shapePts[0]+lineWidth/2,shapePts[1]+lineWidth/2,shapePts[2]-lineWidth,shapePts[3]-lineWidth);
}
else if (shape instanceof Ellipse2D) {
g2.drawOval(shapePts[0]+lineWidth/2,shapePts[1]+lineWidth/2,shapePts[2]-lineWidth,shapePts[3]-lineWidth);
}
else if (shape instanceof Arc2D) {
g2.drawArc(shapePts[0]+lineWidth/2,shapePts[1]+lineWidth/2,shapePts[2]-lineWidth,shapePts[3]-lineWidth,shapePts[4],shapePts[5]);
}
else if (shape instanceof RoundRectangle2D) {
g2.drawRoundRect(shapePts[0]+lineWidth/2,shapePts[1]+lineWidth/2,shapePts[2]-lineWidth,shapePts[3]-lineWidth,shapePts[4],shapePts[5]);
}
else {
// TODO The bounds may be incorrect for polylines at the moment - resulting in graphics turds at some scales
g2.drawPolyline(shapePts);
}
}
if (inverseXForm != null) {
g2.transform(inverseXForm);
}
}
public void setShape(Shape aShape) {
this.shape = cloneShape(aShape);
this.origShape = shape;
updateShapePoints(aShape);
firePropertyChange(PPath.PROPERTY_CODE_PATH, PPath.PROPERTY_PATH, null, shape);
updateBoundsFromPath();
invalidatePaint();
}
public void updateShapePoints(Shape aShape) {
if (aShape instanceof Rectangle2D) {
if (shapePts == null || shapePts.length < 4) {
shapePts = new double[4];
}
shapePts[0] = ((Rectangle2D)shape).getX();
shapePts[1] = ((Rectangle2D)shape).getY();
shapePts[2] = ((Rectangle2D)shape).getWidth();
shapePts[3] = ((Rectangle2D)shape).getHeight();
}
else if (aShape instanceof Ellipse2D) {
if (shapePts == null || shapePts.length < 4) {
shapePts = new double[4];
}
shapePts[0] = ((Ellipse2D)shape).getX();
shapePts[1] = ((Ellipse2D)shape).getY();
shapePts[2] = ((Ellipse2D)shape).getWidth();
shapePts[3] = ((Ellipse2D)shape).getHeight();
}
else if (aShape instanceof Arc2D) {
if (shapePts == null || shapePts.length < 6) {
shapePts = new double[6];
}
shapePts[0] = ((Arc2D)shape).getX();
shapePts[1] = ((Arc2D)shape).getY();
shapePts[2] = ((Arc2D)shape).getWidth();
shapePts[3] = ((Arc2D)shape).getHeight();
shapePts[4] = ((Arc2D)shape).getAngleStart();
shapePts[5] = ((Arc2D)shape).getAngleExtent();
}
else if (aShape instanceof RoundRectangle2D) {
if (shapePts == null || shapePts.length < 6) {
shapePts = new double[6];
}
shapePts[0] = ((RoundRectangle2D)shape).getX();
shapePts[1] = ((RoundRectangle2D)shape).getY();
shapePts[2] = ((RoundRectangle2D)shape).getWidth();
shapePts[3] = ((RoundRectangle2D)shape).getHeight();
shapePts[4] = ((RoundRectangle2D)shape).getArcWidth();
shapePts[5] = ((RoundRectangle2D)shape).getArcHeight();
}
else {
shapePts = SWTShapeManager.shapeToPolyline(shape);
}
}
public Shape cloneShape(Shape aShape) {
if (aShape instanceof Rectangle2D) {
return new PBounds((Rectangle2D)aShape);
}
else if (aShape instanceof Ellipse2D) {
Ellipse2D e2 = (Ellipse2D)aShape;
return new Ellipse2D.Double(e2.getX(),e2.getY(),e2.getWidth(),e2.getHeight());
}
else if (aShape instanceof Arc2D) {
Arc2D a2 = (Arc2D)aShape;
return new Arc2D.Double(a2.getX(),a2.getY(),a2.getWidth(),a2.getHeight(),a2.getAngleStart(),a2.getAngleExtent(),a2.getArcType());
}
else if (aShape instanceof RoundRectangle2D) {
RoundRectangle2D r2 = (RoundRectangle2D)aShape;
return new RoundRectangle2D.Double(r2.getX(),r2.getY(),r2.getWidth(),r2.getHeight(),r2.getArcWidth(),r2.getArcHeight());
}
else if (aShape instanceof Line2D) {
Line2D l2 = (Line2D)aShape;
return new Line2D.Double(l2.getP1(),l2.getP2());
}
else {
new Exception().printStackTrace();
GeneralPath aPath = new GeneralPath();
aPath.append(aShape,false);
return aPath;
}
}
public void setPathToRectangle(float x, float y, float width, float height) {
TEMP_RECTANGLE.setFrame(x, y, width, height);
setShape(TEMP_RECTANGLE);
}
public void setPathToRoundRectangle(float x, float y, float width, float height, float arcWidth, float arcHeight){
TEMP_ROUNDRECTANGLE.setRoundRect(x, y, width, height, arcWidth, arcHeight);
setShape(TEMP_ROUNDRECTANGLE);
}
public void setPathToEllipse(float x, float y, float width, float height) {
TEMP_ELLIPSE.setFrame(x, y, width, height);
setShape(TEMP_ELLIPSE);
}
public void setPathToPolyline(Point2D[] points) {
GeneralPath path = new GeneralPath();
path.reset();
path.moveTo((float)points[0].getX(), (float)points[0].getY());
for (int i = 1; i < points.length; i++) {
path.lineTo((float)points[i].getX(), (float)points[i].getY());
}
setShape(path);
}
public void setPathToPolyline(float[] xp, float[] yp) {
GeneralPath path = new GeneralPath();
path.reset();
path.moveTo(xp[0], yp[0]);
for (int i = 1; i < xp.length; i++) {
path.lineTo(xp[i], yp[i]);
}
setShape(path);
}
//****************************************************************
// Debugging - methods for debugging
//****************************************************************
/**
* Returns a string representing the state of this node. This method is
* intended to be used only for debugging purposes, and the content and
* format of the returned string may vary between implementations. The
* returned string may be empty but may not be <code>null</code>.
*
* @return a string representation of this node's state
*/
protected String paramString() {
StringBuffer result = new StringBuffer();
result.append("path=" + (shape == null ? "null" : shape.toString()));
result.append(",strokePaint=" + (strokePaint == null ? "null" : strokePaint.toString()));
result.append(',');
result.append(super.paramString());
return result.toString();
}
}
