/** Constructor for objects of class CoffeeCup */
public HouseWithWindows(double x, double y, double width, double height) {
// construct the basic house shell
super(x, y, width, height);
// get the GeneralPath that we are going to append stuff to
GeneralPath gp = this.get();
// Make three windows, spaced like this, where w=width/10.0;
// | +--+ +--+ +--+ |
// | | | | | | | |
// | +--+ +--+ +--+ |
// |w 2w w 2w w w2 w|
//
// The top of window will be at y + 0.5*height and the
// height of the window is 0.25height;
double w = 0.10 * width;
double winTop = y + 0.5 * height;
double winHt = 0.25 * height;
Rectangle2D.Double win1 = new Rectangle2D.Double(x + w, winTop, 2.0 * w, winHt);
Rectangle2D.Double win2 = new Rectangle2D.Double(x + 4.0 * w, winTop, 2.0 * w, winHt);
Rectangle2D.Double win3 = new Rectangle2D.Double(x + 7.0 * w, winTop, 2.0 * w, winHt);
// add the windows to the house
// Look up the meaning of the second parameter of append
// (Hint--is a method of "GeneralPath")
GeneralPath wholeHouse = this.get();
wholeHouse.append(win1, false);
wholeHouse.append(win2, false);
wholeHouse.append(win3, false);
}
/**
* Constructor
*
* @param x x coord of top left corner of the rectangle surrounding the person
* @param y y coord of top left corner of the rectangle surrounding the person
* @param width width of the rectangle surrounding the person
* @param height of the rectangle surrounding the person
*/
public Person(double x, double y, double width, double height) {
// The head takes up 25% of the
double headWidth = width * .25;
double headHeight = height * .20;
double headTop = 0f;
double headBottom = height * .25;
double armTop = height * .30;
double armBottom = height * .45;
double legTop = height * .70;
double legBottom = height;
double center = width / 2;
double armWidth = width / 3;
double legWidth = width / 4;
Ellipse2D head =
new Ellipse2D.Double(
x + center - headWidth / 2, y + headBottom - headHeight, headWidth, headHeight);
Line2D.Double body = new Line2D.Double(center + x, headBottom + y, center + x, legTop + y);
Line2D.Double leftArm =
new Line2D.Double(center + x, armTop + y, center + x - armWidth, armBottom + y);
Line2D.Double rightArm =
new Line2D.Double(center + x, armTop + y, center + x + armWidth, armBottom + y);
Line2D.Double leftLeg =
new Line2D.Double(center + x, legTop + y, center + x - legWidth, legBottom + y);
Line2D.Double rightLeg =
new Line2D.Double(center + x, legTop + y, center + x + legWidth, legBottom + y);
GeneralPath wholePerson = this.get();
wholePerson.append(head, false);
wholePerson.append(body, false);
wholePerson.append(leftArm, false);
wholePerson.append(rightArm, false);
wholePerson.append(leftLeg, false);
wholePerson.append(rightLeg, false);
}
public void drawPage(Graphics2D g2) {
FontRenderContext context = g2.getFontRenderContext();
Font f = new Font("Serif", Font.PLAIN, 72);
GeneralPath clipShape = new GeneralPath();
TextLayout layout = new TextLayout("2426打印指南", f, context);
AffineTransform transform = AffineTransform.getTranslateInstance(0, 72);
Shape outline = layout.getOutline(transform);
clipShape.append(outline, false);
layout = new TextLayout("thank you", f, context);
transform = AffineTransform.getTranslateInstance(0, 144);
outline = layout.getOutline(transform);
clipShape.append(outline, false);
g2.draw(clipShape);
g2.clip(clipShape);
final int NLINES = 50;
Point2D p = new Point2D.Double(0, 0);
for (int i = 0; i < NLINES; i++) {
double x = (2 * getWidth() * i) / NLINES;
double y = (2 * getHeight() * (NLINES - 1 - i)) / NLINES;
Point2D q = new Point2D.Double(x, y);
g2.draw(new Line2D.Double(p, q));
}
}
@Override
public void draw(Graphics2D g2d) {
final Dimension2D dimTotal = getDimension(StringBounderUtils.asStringBounder(g2d));
// Shape ellipse = new Ellipse2D.Double(0, 0, dimTotal.getWidth(),
// dimTotal.getHeight());
final GeneralPath ellipse = new GeneralPath();
final double h = dimTotal.getHeight();
final double w = dimTotal.getWidth();
ellipse.append(new QuadCurve2D.Double(0, h / 2, 0, 0, w / 2, 0), true);
ellipse.append(new QuadCurve2D.Double(w / 2, 0, w, 0, w, h / 2), true);
ellipse.append(new QuadCurve2D.Double(w, h / 2, w, h, w / 2, h), true);
ellipse.append(new QuadCurve2D.Double(w / 2, h, 0, h, 0, h / 2), true);
g2d.setColor(getYellow());
g2d.fill(ellipse);
g2d.setColor(getRed());
g2d.draw(ellipse);
final Dimension2D nameDim = name.calculateDimension(StringBounderUtils.asStringBounder(g2d));
final double posx = (w - nameDim.getWidth()) / 2;
final double posy = (h - nameDim.getHeight()) / 2;
final Shape rect = new Rectangle2D.Double(posx, posy, nameDim.getWidth(), nameDim.getHeight());
// g2d.draw(rect);
g2d.setColor(Color.BLACK);
name.drawTOBEREMOVED(g2d, posx, posy);
}
/**
* Constructor
*
* @param x x coord of lower left corner of house
* @param y y coord of lower left corner of house
* @param width width of the house
* @param height of house (including first story and second story)
*/
public House(double x, double y, double width, double height) {
// Rather than having to scale at the end, we can just
// draw things the right way to begin with, using the
// x, y, width and height. If you haven't already
// hard coded a particular drawing, this may be an easier
// way.
double firstStoryHeight = .75 * height;
double roofHeight = height - firstStoryHeight;
double firstStoryUpperLeftY = y + roofHeight;
// Make the first story
Rectangle2D.Double firstStory =
new Rectangle2D.Double(x, firstStoryUpperLeftY, width, firstStoryHeight);
// make the roof. Remember that y goes DOWN the page,
// so we ADD to y to get a "lower" value on the screen
Line2D.Double leftRoof = new Line2D.Double(x, y + roofHeight, x + width / 2.0, y);
Line2D.Double rightRoof = new Line2D.Double(x + width / 2.0, y, x + width, y + roofHeight);
// put the whole house together
GeneralPath wholeHouse = this.get();
wholeHouse.append(firstStory, false);
wholeHouse.append(leftRoof, false);
wholeHouse.append(rightRoof, false);
}
public static GeneralPath filter(GeneralPath in) {
GeneralPath out = new GeneralPath();
PathIterator it = in.getPathIterator(null);
float[] seg = new float[6];
float px = 0, py = 0;
int n = 0;
GeneralPath next = new GeneralPath();
while (!it.isDone()) {
int l = it.currentSegment(seg);
double d = Math.sqrt((px - seg[0]) * (px - seg[0]) + (py - seg[1]) * (py - seg[1]));
if (d > 20) {
l = PathIterator.SEG_MOVETO;
}
if (l == PathIterator.SEG_MOVETO) {
if (n > 50) out.append(next.getPathIterator(null), false);
next = new GeneralPath();
next.moveTo(seg[0], seg[1]);
n = 0;
} else {
next.lineTo(seg[0], seg[1]);
n++;
}
px = seg[0];
py = seg[1];
it.next();
}
if (n > 50) out.append(next.getPathIterator(null), false);
return out;
}
/**
* Build a shape for the entire subtree by joining together the shapes for each of its edges.
* Vertices included since needed for FullTextPanel.
*/
public Shape constructInternalShape(DiagramBase diagram, boolean includeVertices) {
GeneralPath shape = new GeneralPath();
Enumeration edges = m_edgeList.elements();
while (edges.hasMoreElements()) {
TreeEdge edge = (TreeEdge) edges.nextElement();
Shape edgeShape = edge.getSchemeShape(diagram);
PathIterator path = edgeShape.getPathIterator(null);
shape.append(path, false);
if (includeVertices) {
Shape vertexShape;
if (!edge.getSourceVertex().isVirtual()) {
vertexShape = edge.getSourceVertex().getShape(diagram);
path = vertexShape.getPathIterator(null);
shape.append(path, false);
}
if (!edge.getDestVertex().isVirtual()) {
vertexShape = edge.getDestVertex().getShape(diagram);
path = vertexShape.getPathIterator(null);
shape.append(path, false);
}
}
}
BasicStroke stroke =
new BasicStroke(
diagram.getSubtreeLineWidth() - DiagramBase.EDGE_OUTLINE_WIDTH + 1,
BasicStroke.CAP_ROUND,
BasicStroke.JOIN_MITER);
internalShapeTable.put(diagram, stroke.createStrokedShape(shape));
return (Shape) internalShapeTable.get(diagram);
}
/** Constructor for objects of class CoffeeCup */
public CoffeeCup(double x, double y, double width, double height) {
// Specify the upper left corner, and the
// width and height of the original points used to
// plot the *hard-coded* coffee cup
final double ORIG_ULX = 100.0;
final double ORIG_ULY = 100.0;
final double ORIG_HEIGHT = 300.0;
final double ORIG_WIDTH = 400.0;
GeneralPath leftSide = new GeneralPath();
// left side of cup
leftSide.moveTo(200, 400);
leftSide.lineTo(160, 360);
leftSide.lineTo(130, 300);
leftSide.lineTo(100, 200);
leftSide.lineTo(100, 100);
GeneralPath topAndBottom = new GeneralPath();
topAndBottom.moveTo(100, 100);
topAndBottom.lineTo(500, 100); // top of cup
topAndBottom.moveTo(200, 400);
topAndBottom.lineTo(400, 400); // bottom of cup
Shape rightSide = ShapeTransforms.horizontallyFlippedCopyOf(leftSide);
// after flipping around the upper left hand corner of the
// bounding box, we move this over to the right by 400 pixels
rightSide = ShapeTransforms.translatedCopyOf(rightSide, 400.0, 0.0);
// now we put the whole thing together ino a single path.
GeneralPath wholeCup = new GeneralPath();
wholeCup.append(topAndBottom, false);
wholeCup.append(leftSide, false);
wholeCup.append(rightSide, false);
// translate to the origin by subtracting the original upper left x and y
// then translate to (x,y) by adding x and y
Shape s = ShapeTransforms.translatedCopyOf(wholeCup, -ORIG_ULX + x, -ORIG_ULY + y);
// scale to correct height and width
s = ShapeTransforms.scaledCopyOf(s, width / ORIG_WIDTH, height / ORIG_HEIGHT);
// Use the GeneralPath constructor that takes a shape and returns
// it as a general path to set our instance variable cup
this.set(new GeneralPath(s));
}
/**
* Constructor
*
* @param x x coord of tip of mountain
* @param y y coord of tip of mountain
* @param width width of mountain
* @param height height of mountain
*/
public Mountain(double x, double y, double width, double height) {
Line2D.Double leftSlope = new Line2D.Double(x - width / 2.0, y + height, x, y);
Line2D.Double rightSlope = new Line2D.Double(x, y, x + width / 2.0, y + height);
GeneralPath wholeMountain = this.get();
wholeMountain.append(leftSlope, false);
wholeMountain.append(rightSlope, false);
}
/**
* Constructor
*
* @param x x coord of lower left corner of car (exluding wheels)
* @param y y coord of lower left corner of car (excluding wheels)
* @param width width of the car
* @param height height of car
* @param wheelRadius radius of the wheels
*/
public Car(double x, double y, double width, double height) {
double wheelDiameter = 2 * width * .125;
// Rather than having to scale at the end, we can just
Rectangle2D.Double carBody = new Rectangle2D.Double(x, y, width, height);
Ellipse2D.Double leftWheel =
new Ellipse2D.Double(x + .125 * width, y + height, wheelDiameter, wheelDiameter);
Ellipse2D.Double rightWheel =
new Ellipse2D.Double(x + .625 * width, y + height, wheelDiameter, wheelDiameter);
// put the whole car together
GeneralPath wholeCar = this.get();
wholeCar.append(carBody, false);
wholeCar.append(leftWheel, false);
wholeCar.append(rightWheel, false);
}
public void draw(Graphics p_graphics) {
if (!location_initialized) {
return;
}
Graphics2D g2 = (Graphics2D) p_graphics;
init_graphics(g2);
GeneralPath draw_path = new GeneralPath(GeneralPath.WIND_EVEN_ODD);
draw_path.append(VERTICAL_LINE, false);
draw_path.append(HORIZONTAL_LINE, false);
draw_path.append(RIGHT_DIAGONAL_LINE, false);
draw_path.append(LEFT_DIAGONAL_LINE, false);
g2.translate(this.x_coor, this.y_coor);
g2.draw(draw_path);
}
/**
* Constructor
*
* @param x x coord of lower left corner of egg carton
* @param y y coord of lower left corner of egg carton
* @param width width of the egg carton
* @param height of egg carton
*/
public EggCarton(double x, double y, double width, double height) {
Rectangle2D.Double carton = new Rectangle2D.Double(x, y, width, 0.45 * width);
GeneralPath wholeCarton = this.get();
wholeCarton.append(carton, false);
}
/**
* Returns the outline of this glyph. This will be positioned correctly and any glyph transforms
* will have been applied.
*
* @return the outline of this glyph.
*/
public Shape getOutline() {
if (outline == null) {
AffineTransform tr = AffineTransform.getTranslateInstance(position.getX(), position.getY());
if (transform != null) {
tr.concatenate(transform);
}
Shape glyphChildrenOutline = null;
if (glyphChildrenNode != null) {
glyphChildrenOutline = glyphChildrenNode.getOutline();
}
GeneralPath glyphOutline = null;
if (dShape != null && glyphChildrenOutline != null) {
glyphOutline = new GeneralPath(dShape);
glyphOutline.append(glyphChildrenOutline, false);
} else if (dShape != null && glyphChildrenOutline == null) {
glyphOutline = new GeneralPath(dShape);
} else if (dShape == null && glyphChildrenOutline != null) {
glyphOutline = new GeneralPath(glyphChildrenOutline);
} else {
// must be a whitespace glyph, return an empty shape
glyphOutline = new GeneralPath();
}
outline = tr.createTransformedShape(glyphOutline);
}
return outline;
}
/**
* Constructor for objects of class ShipwithFunnels this one asks you to input numoffunnels which
* is the number of funnels you want the ship to have
*/
public ShipwithFunnels(double x, double y, double width, double height, int numoffunnels) {
// construct the basic ship shell
super(x, y, width, height);
// get the GeneralPath that we are going to append stuff to
GeneralPath gp = this.get();
// Make a funnel;
// | +--+ +--+ |
// | | | | | |
// | +--+ +--+ |
// |5w w w w 5w |
//
// The width of funnel will be 1/11 of ship's width and the
// height of the funnel is 1*height;
double w = width / 13;
double funnelTop = y - height;
double funnelHt = height;
int margin = (13 - (numoffunnels * 2 - 1)) / 2;
GeneralPath wholeShip = this.get();
for (int i = 0; i < numoffunnels; i++) {
Rectangle2D.Double funnel1 =
new Rectangle2D.Double(x + margin * w + i * 2 * w, funnelTop, w, funnelHt);
wholeShip.append(funnel1, false);
}
}
/** Render a compound glyf */
protected GeneralPath renderCompoundGlyph(GlyfTable glyf, GlyfCompound g) {
GeneralPath gp = new GeneralPath();
for (int i = 0; i < g.getNumComponents(); i++) {
// find and render the component glyf
Glyf gl = glyf.getGlyph(g.getGlyphIndex(i));
GeneralPath path = null;
if (gl instanceof GlyfSimple) {
path = renderSimpleGlyph((GlyfSimple) gl);
} else if (gl instanceof GlyfCompound) {
path = renderCompoundGlyph(glyf, (GlyfCompound) gl);
} else {
throw new RuntimeException("Unsupported glyph type " + gl.getClass().getCanonicalName());
}
// multiply the translations by units per em
double[] matrix = g.getTransform(i);
// transform the path
path.transform(new AffineTransform(matrix));
// add it to the global path
gp.append(path, false);
}
return gp;
}
/**
* Default Constructor for objects of class ShipwithFunnels this one gives one funnel on the ship
*/
public ShipwithFunnels(double x, double y, double width, double height) {
// construct the basic ship shell
super(x, y, width, height);
// get the GeneralPath that we are going to append stuff to
GeneralPath gp = this.get();
// Make a funnel;
// | +--+ |
// | | | |
// | +--+ |
// |6w w 6w|
//
// The width of funnel will be 1/11 of ship's width and the
// height of the funnel is 1*height;
double w = width / 13;
double funnelTop = y - height;
double funnelHt = height;
Rectangle2D.Double funnel1 = new Rectangle2D.Double(x + 6 * w, funnelTop, w, funnelHt);
// add the funnel to the ship
GeneralPath wholeShip = this.get();
wholeShip.append(funnel1, false);
}
/**
* displays the tag using the renderer
*
* @param renderer EMFRenderer storing the drawing session data
* @param closePath if true the path is closed and filled
*/
protected void render(EMFRenderer renderer, boolean closePath) {
// create a GeneralPath containing GeneralPathes
GeneralPath path = new GeneralPath(renderer.getWindingRule());
// iterate the polgons
Point p;
for (int polygon = 0; polygon < numberOfPoints.length; polygon++) {
// create a new member of path
GeneralPath gp = new GeneralPath(renderer.getWindingRule());
for (int point = 0; point < numberOfPoints[polygon]; point++) {
// add a point to gp
p = points[polygon][point];
if (point > 0) {
gp.lineTo((float) p.getX(), (float) p.getY());
} else {
gp.moveTo((float) p.getX(), (float) p.getY());
}
}
// close the member, add it to path
if (closePath) {
gp.closePath();
}
path.append(gp, false);
}
// draw the complete path
if (closePath) {
renderer.fillAndDrawOrAppend(path);
} else {
renderer.drawOrAppend(path);
}
}
/**
* Constructor
*
* @param x - x coord of the center of the cookie
* @param y - y coord of the center of the cookie
* @param radius - radius of cookie
*/
public Cookie(double x, double y, double r) {
// Rather than having to scale at the end, we can just
// draw things the right way to begin with, using the
// x, y, and radius. If you haven't already
// hard coded a particular drawing, this may be an easier
// way.
GeneralPath cookie = this.get();
cookie.append(new Circle(x, y, r), false);
}
public void ellipse(double x, double y, double w, double h) {
currentPath = new GeneralPath();
currentPath.append(
new Ellipse2D.Double(
(state.dx + x) * state.scale,
(state.dy + y) * state.scale,
w * state.scale,
h * state.scale),
false);
}
private GeneralPath subdivide(Point b0, Point b1, Point b2, Point b3) {
double cutDistance = getTargetAnchorShape().getCutDistance();
double minDistance = cutDistance - ENDPOINT_DEVIATION;
/**
* if the cutDistance is valid the last segment of the curve gets reduced by subdivision until
* the distance of the endpoint(epDistance) satisfys the condition (cutDistance > epDistance >
* (cutDistance - ENDPOINT-DEVIATION)
*/
if (cutDistance > minDistance && minDistance > 0) {
GeneralPath path = new GeneralPath();
path.moveTo(b0.x, b0.y);
CubicCurve2D.Double left =
new CubicCurve2D.Double(
b0.x, b0.y,
b1.x, b1.y,
b2.x, b2.y,
b3.x, b3.y);
CubicCurve2D right = new CubicCurve2D.Double();
left.subdivide(left, right);
double distance = b3.distance(left.getP2());
// if the distance is bigger as the cutDistance the left segment is added
// and the right segment is divided again
while (distance > cutDistance) {
path.append(left, true);
right.subdivide(left, right);
distance = b3.distance(left.getP2());
// if the devision removed to much the left segment is divided
while (distance < minDistance) {
// changes the distance to ~ (distance+distance/2)
left.subdivide(left, right);
distance = b3.distance(left.getP2());
}
}
// append the last segment with (minDistance < distance < cutDistance)
// actually we should check if the a division happend, but this is very unlikly
path.append(left, true);
return path;
}
return null;
}
/**
* Constructor for objects of class Balloon
*
* @param x x coordinate of center of Balloon
* @param y y coordinate of center of Balloon
* @param r radius of Balloon
*/
public Balloon(double x, double y, double r) {
double upperLeftX = x - r;
double upperLeftY = y - r;
double width = 2 * r;
double height = 3 * r;
Ellipse2D.Double b = new Ellipse2D.Double(upperLeftX, upperLeftY, width, height);
GeneralPath balloon = this.get();
balloon.append(b, false);
}
public GeneralPath getPath(double x, double y, double width, double height) {
// Width and height have correct ratio;
GeneralPath path = new GeneralPath();
double[] points = new double[] {x, y, x + width, y, x + width, y + height, x, y + height};
double[] midpts =
new double[] {
x + width, y + height / 2., x + width / 2., y, x, y + height / 2., x + width / 2., y
};
int d = direction;
path.moveTo(points[d % 8], points[d % 8]);
// path.curveTo(points[d++ % 8], points[d++ % 8], points[d++ % 8], points[d++ % 8], points[d++
// % 8],
// points[d++ % 8]);
QuadCurve2D curve =
new QuadCurve2D.Double(
points[d++ % 8],
points[d++ % 8],
points[d++ % 8],
points[d++ % 8],
midpts[direction],
midpts[direction + 1]);
path.append(curve, true);
curve =
new QuadCurve2D.Double(
midpts[direction],
midpts[direction + 1],
points[d++ % 8],
points[d++ % 8],
points[d++ % 8],
points[d++ % 8]);
path.append(curve, true);
path.lineTo(points[d++ % 8], points[d++ % 8]);
return path;
}
/** Constructor for objects of class Stopsign, sticks a hexagon on top of pole */
public Stopsign(double x, double y, double width, double height) {
// construct the pole
super(x, y, width, height);
// get the GeneralPath that we are going to append stuff to
GeneralPath gp = this.get();
// side 3 _
// side 2 / \ side 4
// side 1 \_/ side 5 No need to draw the bottomside because it will be attached to the top
// of the pole
//
Line2D.Double side =
new Line2D.Double(x, y, x - width * Math.sin(120), y - width * Math.sin(120));
Line2D.Double side2 =
new Line2D.Double(
x - width * Math.sin(120), y - width * Math.sin(120), x, y - 2 * width * Math.sin(120));
Line2D.Double side3 =
new Line2D.Double(
x, y - 2 * width * Math.sin(120), x + width, y - 2 * width * Math.sin(120));
Line2D.Double side4 =
new Line2D.Double(
x + width,
y - 2 * width * Math.sin(120),
x + width + width * Math.sin(120),
y - width * Math.sin(120));
Line2D.Double side5 =
new Line2D.Double(
x + width + width * Math.sin(120), y - width * Math.sin(120), x + width, y);
// add the lines to the pole
GeneralPath completeStopSign = this.get();
completeStopSign.append(side, false);
completeStopSign.append(side2, false);
completeStopSign.append(side3, false);
completeStopSign.append(side4, false);
completeStopSign.append(side5, false);
}
public void appendShape(GeneralPath gp, DrawAreaInterface da, UserFunction own)
throws MathException {
AffPoint s, e;
s = (AffPoint) ((UserFunction) startPoint).eval();
e = (AffPoint) ((UserFunction) endPoint).eval();
gp.append(
new Line2D.Double(
da.xCoordToPix(s.evalX()),
da.yCoordToPix(s.evalY()),
da.xCoordToPix(e.evalX()),
da.yCoordToPix(e.evalY())),
true);
}
/**
* Returns a shape that can be draw.
*
* <p>It is recommended to call getShape() every time a draw is needed because the shape does not
* update if the EditGeom is updated between draws. getShape is guaranteed to get a shape that is
* representative of the current state of geom.
*
* @return
*/
public Shape toShape() {
prepareToPath();
if (geom.getShell().getNumPoints() == 1) {
Shape createPoint = createPoint();
if (createPoint != null) return createPoint;
}
GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD);
path.append(this, false);
return path;
}
public void addTextSprite(TextSprite nextSprite) {
Area area = nextSprite.getGlyphOutline();
// When TJ/Tj and Other text operators are called on a font using
// modes 5-7 we don't actually craw anything but we still need to
// transform the glyph to the correct coordinate, so each
// outline is place correctly with in the total outline shape.
Area tmp = area.createTransformedArea(nextSprite.getGraphicStateTransform());
if (path == null) {
path = new GeneralPath(tmp);
} else {
path.append(tmp, false);
}
}
/** Build a shape for the entire subtree by joining together the shapes for each of its edges. */
public Shape constructFullTextShape(DiagramBase diagram) {
GeneralPath shape = new GeneralPath();
Enumeration edges = m_edgeList.elements();
while (edges.hasMoreElements()) {
TreeEdge edge = (TreeEdge) edges.nextElement();
if (!edge.visible) {
continue;
}
Shape edgeShape = edge.getSchemeShape(diagram);
PathIterator path = edgeShape.getPathIterator(null);
shape.append(path, false);
TreeVertex vertex = edge.getSourceVertex();
if (!vertex.isVirtual()) {
shape.append(vertex.getShape(diagram).getPathIterator(null), false);
}
vertex = edge.getDestVertex();
if (!vertex.isVirtual()) {
shape.append(vertex.getShape(diagram).getPathIterator(null), false);
}
}
BasicStroke stroke = new BasicStroke(20, BasicStroke.CAP_ROUND, BasicStroke.JOIN_MITER);
shapeTable.put(diagram, stroke.createStrokedShape(shape));
return (Shape) shapeTable.get(diagram);
}
// public void drawOld(Graphics2D g2d, double x, double y) {
// for (CubicCurve2D.Double bez : beziers) {
// bez = new CubicCurve2D.Double(x + bez.x1, y + bez.y1, x + bez.ctrlx1, y +
// bez.ctrly1, x + bez.ctrlx2, y
// + bez.ctrly2, x + bez.x2, y + bez.y2);
// g2d.draw(bez);
// }
// }
//
public void draw(Graphics2D g2d, double x, double y) {
final GeneralPath p = new GeneralPath();
for (CubicCurve2D.Double bez : beziers) {
bez =
new CubicCurve2D.Double(
x + bez.x1,
y + bez.y1,
x + bez.ctrlx1,
y + bez.ctrly1,
x + bez.ctrlx2,
y + bez.ctrly2,
x + bez.x2,
y + bez.y2);
p.append(bez, true);
}
g2d.draw(p);
}
public Shape getShape(Rectangle2D bounds) {
/*
* Start Width = 8 * w, Height = 8 * h
* x __
* _| |_
* _| |_
* _| _ _ |_
* | |_| |_| |
* |___ __ ___|
* _|_|__|_|_
* _|_|_|__|_|_|_
* |_| |_| |_| |_|
*
*/
int x = (int) bounds.getX();
int y = (int) bounds.getY();
int w = (int) (bounds.getWidth() / 8);
int h = (int) (bounds.getHeight() / 8);
GeneralPath path = new GeneralPath();
path.moveTo(x, y + 3 * h);
path.lineTo(x + w, y + 3 * h);
path.lineTo(x + w, y + 2 * h);
path.lineTo(x + 2 * w, y + 2 * h);
path.lineTo(x + 2 * w, y + h);
path.lineTo(x + 3 * w, y + h);
path.lineTo(x + 3 * w, y);
path.lineTo(x + 5 * w, y);
path.lineTo(x + 5 * w, y + h);
path.lineTo(x + 6 * w, y + h);
path.lineTo(x + 6 * w, y + 2 * h);
path.lineTo(x + 7 * w, y + 2 * h);
path.lineTo(x + 7 * w, y + 3 * h);
path.lineTo(x + 8 * w, y + 3 * h);
path.lineTo(x + 8 * w, y + 5 * h);
path.lineTo(x, y + 5 * h);
path.lineTo(x, y + 2 * h);
path.append(new Rectangle2D.Double(x + 2 * w, y + 5 * h, w, h), false);
path.append(new Rectangle2D.Double(x + 5 * w, y + 5 * h, w, h), false);
path.append(new Rectangle2D.Double(x + w, y + 6 * h, w, h), false);
path.append(new Rectangle2D.Double(x + 3 * w, y + 6 * h, 2 * w, h), false);
path.append(new Rectangle2D.Double(x + 6 * w, y + 6 * h, w, h), false);
path.append(new Rectangle2D.Double(x, y + 7 * h, w, h), false);
path.append(new Rectangle2D.Double(x + 2 * w, y + 7 * h, w, h), false);
path.append(new Rectangle2D.Double(x + 5 * w, y + 7 * h, w, h), false);
path.append(new Rectangle2D.Double(x + 7 * w, y + 7 * h, w, h), false);
return path;
}
/**
* converts this glyph into Shape. It could be called for root's preview mode or by include
* invoke. Pushing either this GlyphFile or DIncludeInvoke should be handled before this.
*/
public Shape toShape(AffineTransform a_trans) {
int ppem = k_defaultPixelSize;
GeneralPath retval = new GeneralPath();
Iterator i = createIterator();
while (i.hasNext()) {
GlyphObject object = (GlyphObject) i.next();
if (object instanceof EContourPoint || object instanceof EHint) {
continue;
} // if
retval.append(object.toShape(a_trans, ppem), false);
} // if
return retval;
}
