/**
* Writes the <code>shape</code>, <code>coords</code>, <code>href</code>,
* <code>nohref</code> Attribute for the specified figure and ellipse.
*
* @return Returns true, if the circle is inside of the image bounds.
*/
private boolean writeCircleAttributes(IXMLElement elem, SVGFigure f, Ellipse2D.Double ellipse) {
AffineTransform t = TRANSFORM.getClone(f);
if (t == null) {
t = drawingTransform;
} else {
t.preConcatenate(drawingTransform);
}
if ((t.getType() &
(AffineTransform.TYPE_UNIFORM_SCALE | AffineTransform.TYPE_TRANSLATION)) ==
t.getType() &&
ellipse.width == ellipse.height
) {
Point2D.Double start = new Point2D.Double(ellipse.x, ellipse.y);
Point2D.Double end = new Point2D.Double(ellipse.x + ellipse.width, ellipse.y + ellipse.height);
t.transform(start, start);
t.transform(end, end);
ellipse.x = Math.min(start.x, end.x);
ellipse.y = Math.min(start.y, end.y);
ellipse.width = Math.abs(start.x - end.x);
ellipse.height = Math.abs(start.y - end.y);
elem.setAttribute("shape", "circle");
elem.setAttribute("coords",
(int) (ellipse.x + ellipse.width / 2d)+","+
(int) (ellipse.y + ellipse.height / 2d)+","+
(int) (ellipse.width / 2d)
);
writeHrefAttribute(elem, f);
return bounds.intersects(ellipse.getBounds());
} else {
return writePolyAttributes(elem, f, (Shape) ellipse);
}
}
/**
* Returns a path which is cappedPath at the ends, to prevent it from drawing under the end caps.
*/
protected BezierPath getCappedPath() {
if (cappedPath == null) {
cappedPath = path.clone();
if (isClosed()) {
cappedPath.setClosed(true);
} else {
if (cappedPath.size() > 1) {
if (get(START_DECORATION) != null) {
BezierPath.Node p0 = cappedPath.get(0);
BezierPath.Node p1 = cappedPath.get(1);
Point2D.Double pp;
if ((p0.getMask() & BezierPath.C2_MASK) != 0) {
pp = p0.getControlPoint(2);
} else if ((p1.getMask() & BezierPath.C1_MASK) != 0) {
pp = p1.getControlPoint(1);
} else {
pp = p1.getControlPoint(0);
}
double radius = get(START_DECORATION).getDecorationRadius(this);
double lineLength = Geom.length(p0.getControlPoint(0), pp);
cappedPath.set(
0, 0, Geom.cap(pp, p0.getControlPoint(0), -Math.min(radius, lineLength)));
}
if (get(END_DECORATION) != null) {
BezierPath.Node p0 = cappedPath.get(cappedPath.size() - 1);
BezierPath.Node p1 = cappedPath.get(cappedPath.size() - 2);
Point2D.Double pp;
if ((p0.getMask() & BezierPath.C1_MASK) != 0) {
pp = p0.getControlPoint(1);
} else if ((p1.getMask() & BezierPath.C2_MASK) != 0) {
pp = p1.getControlPoint(2);
} else {
pp = p1.getControlPoint(0);
}
double radius = get(END_DECORATION).getDecorationRadius(this);
double lineLength = Geom.length(p0.getControlPoint(0), pp);
cappedPath.set(
cappedPath.size() - 1,
0,
Geom.cap(pp, p0.getControlPoint(0), -Math.min(radius, lineLength)));
}
cappedPath.invalidatePath();
}
}
}
return cappedPath;
}
/**
* All other write methods delegate their work to here.
*/
public void write(OutputStream out, java.util.List<Figure> figures) throws IOException {
Rectangle2D.Double drawingRect = null;
for (Figure f : figures) {
if (drawingRect == null) {
drawingRect = f.getBounds();
} else {
drawingRect.add(f.getBounds());
}
}
AffineTransform drawingTransform = new AffineTransform();
drawingTransform.translate(
-Math.min(0, drawingRect.x),
-Math.min(0, drawingRect.y)
);
write(out, figures, drawingTransform,
new Dimension(
(int) (Math.abs(drawingRect.x) + drawingRect.width),
(int) (Math.abs(drawingRect.y) + drawingRect.height))
);
}
/**
* Writes the <code>shape</code>, <code>coords</code>, <code>href</code>,
* <code>nohref</code> Attribute for the specified figure and rectangle.
*
* @return Returns true, if the rect is inside of the image bounds.
*/
private boolean writeRectAttributes(IXMLElement elem, SVGFigure f, Rectangle2D.Double rect) {
AffineTransform t = TRANSFORM.getClone(f);
if (t == null) {
t = drawingTransform;
} else {
t.preConcatenate(drawingTransform);
}
if ((t.getType() &
(AffineTransform.TYPE_UNIFORM_SCALE | AffineTransform.TYPE_TRANSLATION)) ==
t.getType()
) {
Point2D.Double start = new Point2D.Double(rect.x, rect.y);
Point2D.Double end = new Point2D.Double(rect.x + rect.width, rect.y + rect.height);
t.transform(start, start);
t.transform(end, end);
Rectangle r = new Rectangle(
(int) Math.min(start.x, end.x),
(int) Math.min(start.y, end.y),
(int) Math.abs(start.x - end.x),
(int) Math.abs(start.y - end.y)
);
elem.setAttribute("shape", "rect");
elem.setAttribute("coords",
r.x + ","+
r.y + ","+
(r.x + r.width) + ","+
(r.y + r.height)
);
writeHrefAttribute(elem, f);
return bounds.intersects(r);
} else {
return writePolyAttributes(elem, f, (Shape) rect);
}
}
public void setFontSize(float size) {
// FONT_SIZE.basicSet(this, new Double(size));
Point2D.Double p = new Point2D.Double(0, size);
AffineTransform tx = TRANSFORM.get(this);
if (tx != null) {
try {
tx.inverseTransform(p, p);
Point2D.Double p0 = new Point2D.Double(0, 0);
tx.inverseTransform(p0, p0);
p.y -= p0.y;
} catch (NoninvertibleTransformException ex) {
ex.printStackTrace();
}
}
FONT_SIZE.set(this, Math.abs(p.y));
}
public float getFontSize() {
// return FONT_SIZE.get(this).floatValue();
Point2D.Double p = new Point2D.Double(0, FONT_SIZE.get(this));
AffineTransform tx = TRANSFORM.get(this);
if (tx != null) {
tx.transform(p, p);
Point2D.Double p0 = new Point2D.Double(0, 0);
tx.transform(p0, p0);
p.y -= p0.y;
/*
try {
tx.inverseTransform(p, p);
} catch (NoninvertibleTransformException ex) {
ex.printStackTrace();
}*/
}
return (float) Math.abs(p.y);
}
@Override
public boolean contains(Point2D.Double p) {
double tolerance = Math.max(2f, AttributeKeys.getStrokeTotalWidth(this) / 2d);
if (isClosed() || get(FILL_COLOR) != null && get(UNCLOSED_PATH_FILLED)) {
if (path.contains(p)) {
return true;
}
double grow = AttributeKeys.getPerpendicularHitGrowth(this) * 2d;
GrowStroke gs =
new GrowStroke(grow, AttributeKeys.getStrokeTotalWidth(this) * get(STROKE_MITER_LIMIT));
if (gs.createStrokedShape(path).contains(p)) {
return true;
} else {
if (isClosed()) {
return false;
}
}
}
if (!isClosed()) {
if (getCappedPath().outlineContains(p, tolerance)) {
return true;
}
if (get(START_DECORATION) != null) {
BezierPath cp = getCappedPath();
Point2D.Double p1 = path.get(0, 0);
Point2D.Double p2 = cp.get(0, 0);
// FIXME - Check here, if caps path contains the point
if (Geom.lineContainsPoint(p1.x, p1.y, p2.x, p2.y, p.x, p.y, tolerance)) {
return true;
}
}
if (get(END_DECORATION) != null) {
BezierPath cp = getCappedPath();
Point2D.Double p1 = path.get(path.size() - 1, 0);
Point2D.Double p2 = cp.get(path.size() - 1, 0);
// FIXME - Check here, if caps path contains the point
if (Geom.lineContainsPoint(p1.x, p1.y, p2.x, p2.y, p.x, p.y, tolerance)) {
return true;
}
}
}
return false;
}
/** Reads the attributes from the specified DOMInput and assigns them to the figure. */
public static void readAttributes(Figure f, DOMInput in) throws IOException {
// FIXME - This method is not working, when "style" and individual attributes
// are both used in an SVG document.
List<Map<String, String>> styles = new ArrayList<Map<String, String>>();
List<String> values = in.getInheritedAttribute("style");
for (String v : values) {
styles.add(getStyles(v));
}
String value;
// Fill color
value = getInheritedAttribute("fill", in, styles);
if (value != null) {
Color color = getColor(value);
if (color != INHERIT_COLOR && color != CURRENT_COLOR) {
FILL_COLOR.set(f, color);
}
}
value = getInheritedAttribute("fill-rule", in, styles);
if (value != null) {
WINDING_RULE.set(
f, value.toUpperCase().equals("NONZERO") ? WindingRule.NON_ZERO : WindingRule.EVEN_ODD);
} else {
WINDING_RULE.set(f, WindingRule.NON_ZERO);
}
// Stroke color
value = getInheritedAttribute("stroke", in, styles);
if (value != null) {
Color color = getColor(value);
if (color != INHERIT_COLOR && color != CURRENT_COLOR) {
STROKE_COLOR.set(f, color);
}
}
value = getInheritedAttribute("stroke-width", in, styles);
if (value != null) {
STROKE_WIDTH.set(f, Double.valueOf(value));
}
value = getInheritedAttribute("stroke-miterlimit", in, styles);
if (value != null) {
STROKE_MITER_LIMIT_FACTOR.set(f, Double.valueOf(value));
}
value = getInheritedAttribute("stroke-dasharray", in, styles);
if (value != null) {
StringTokenizer tt = new StringTokenizer(value, " ,");
double[] dashes = new double[tt.countTokens()];
for (int i = 0, n = dashes.length; i < n; i++) {
dashes[i] = Double.valueOf(tt.nextToken());
}
STROKE_DASHES.set(f, dashes);
}
value = getInheritedAttribute("stroke-dashoffset", in, styles);
if (value != null) {
STROKE_DASH_PHASE.set(f, Math.abs(Double.valueOf(value)));
}
value = getInheritedAttribute("font-size", in, styles);
if (value != null) {
FONT_SIZE.set(f, getDimensionValue(in, value));
}
value = getInheritedAttribute("text-anchor", in, styles);
if (value != null) {
SVGText.TEXT_ANCHOR.set(f, Enum.valueOf(SVGText.TextAnchor.class, value.toUpperCase()));
}
}
public static AffineTransform getTransform(String str) throws IOException {
AffineTransform t = new AffineTransform();
if (str != null) {
StreamTokenizer tt = new StreamTokenizer(new StringReader(str));
tt.resetSyntax();
tt.wordChars('a', 'z');
tt.wordChars('A', 'Z');
tt.wordChars(128 + 32, 255);
tt.whitespaceChars(0, ' ');
tt.whitespaceChars(',', ',');
tt.parseNumbers();
while (tt.nextToken() != StreamTokenizer.TT_EOF) {
if (tt.ttype != StreamTokenizer.TT_WORD) {
throw new IOException("Illegal transform " + str);
}
String type = tt.sval;
if (tt.nextToken() != '(') {
throw new IOException("'(' not found in transform " + str);
}
if (type.equals("matrix")) {
double[] m = new double[6];
for (int i = 0; i < 6; i++) {
if (tt.nextToken() != StreamTokenizer.TT_NUMBER) {
throw new IOException(
"Matrix value "
+ i
+ " not found in transform "
+ str
+ " token:"
+ tt.ttype
+ " "
+ tt.sval);
}
if (tt.nextToken() == StreamTokenizer.TT_WORD && tt.sval.startsWith("E")) {
double mantissa = tt.nval;
tt.nval = Double.valueOf(tt.nval + tt.sval);
} else {
tt.pushBack();
}
m[i] = tt.nval;
}
t.concatenate(new AffineTransform(m));
} else if (type.equals("translate")) {
double tx, ty;
if (tt.nextToken() != StreamTokenizer.TT_NUMBER) {
throw new IOException("X-translation value not found in transform " + str);
}
tx = tt.nval;
if (tt.nextToken() == StreamTokenizer.TT_NUMBER) {
ty = tt.nval;
} else {
tt.pushBack();
ty = 0;
}
t.translate(tx, ty);
} else if (type.equals("scale")) {
double sx, sy;
if (tt.nextToken() != StreamTokenizer.TT_NUMBER) {
throw new IOException("X-scale value not found in transform " + str);
}
sx = tt.nval;
if (tt.nextToken() == StreamTokenizer.TT_NUMBER) {
sy = tt.nval;
} else {
tt.pushBack();
sy = sx;
}
t.scale(sx, sy);
} else if (type.equals("rotate")) {
double angle, cx, cy;
if (tt.nextToken() != StreamTokenizer.TT_NUMBER) {
throw new IOException("Angle value not found in transform " + str);
}
angle = tt.nval;
if (tt.nextToken() == StreamTokenizer.TT_NUMBER) {
cx = tt.nval;
if (tt.nextToken() != StreamTokenizer.TT_NUMBER) {
throw new IOException("Y-center value not found in transform " + str);
}
cy = tt.nval;
} else {
tt.pushBack();
cx = cy = 0;
}
t.rotate(angle * Math.PI / 180d, cx * Math.PI / 180d, cy * Math.PI / 180d);
} else if (type.equals("skewX")) {
double angle;
if (tt.nextToken() != StreamTokenizer.TT_NUMBER) {
throw new IOException("Skew angle not found in transform " + str);
}
angle = tt.nval;
t.concatenate(new AffineTransform(1, 0, Math.tan(angle * Math.PI / 180), 1, 0, 0));
} else if (type.equals("skewY")) {
double angle;
if (tt.nextToken() != StreamTokenizer.TT_NUMBER) {
throw new IOException("Skew angle not found in transform " + str);
}
angle = tt.nval;
t.concatenate(new AffineTransform(1, Math.tan(angle * Math.PI / 180), 0, 1, 0, 0));
} else {
throw new IOException("Unknown transform " + type + " in " + str);
}
if (tt.nextToken() != ')') {
throw new IOException("')' not found in transform " + str);
}
}
}
return t;
}
