public void mouseDragged(MouseEvent e) {
int mods = e.getModifiersEx();
Point dragEnd = e.getPoint();
boolean shift = (mods & MouseEvent.SHIFT_DOWN_MASK) > 0;
boolean ctrl = (mods & MouseEvent.CTRL_DOWN_MASK) > 0;
boolean alt = shift & ctrl;
ctrl = ctrl & (!alt);
shift = shift & (!alt);
boolean nomods = !(shift | ctrl | alt);
if (dragBegin == null) dragBegin = dragEnd;
nodrag = false;
if ((mods & InputEvent.BUTTON3_DOWN_MASK) > 0 || true) {
double dx = dragEnd.getX() - dragBegin.getX();
double dy = dragEnd.getY() - dragBegin.getY();
synchronized (JImage.this) {
t.preConcatenate(AffineTransform.getTranslateInstance(dx, dy));
}
dragBegin = dragEnd;
repaint();
}
}
public void addGlyph(GlyphData gv, float x, float y) {
AffineTransform at = AffineTransform.getTranslateInstance(x, y);
PathIterator pi = gv.gp.getPathIterator(at);
float[] coords = new float[6];
while (!pi.isDone()) {
int type = pi.currentSegment(coords);
switch (type) {
case PathIterator.SEG_MOVETO:
moveTo(coords[0], coords[1]);
break;
case PathIterator.SEG_LINETO:
lineTo(coords[0], coords[1]);
break;
case PathIterator.SEG_CUBICTO:
curveTo(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]);
break;
case PathIterator.SEG_CLOSE:
closePath();
break;
default:
System.out.println("Unknown path type: " + type);
break;
}
pi.next();
}
}
/**
* Paints the icon.
*
* @param c the component on which it is painted
* @param _g the graphics context
* @param x the x coordinate of the icon
* @param y the y coordinate of the icon
*/
public void paintIcon(Component c, Graphics _g, int x, int y) {
Graphics2D g = (Graphics2D) _g;
AffineTransform at = AffineTransform.getTranslateInstance(x + offsetX, y + offsetY);
// save current graphics paint and clip
Paint gPaint = g.getPaint();
Shape gClip = g.getClip();
// render shape(s)
g.setPaint(color);
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g.clipRect(x, y, w, h);
// paint shape, if any
if (shape != null) {
g.fill(at.createTransformedShape(shape));
}
// paint decoration, if any
if (decoration != null) {
g.setPaint(decoColor);
g.fill(at.createTransformedShape(decoration));
}
// restore graphics paint and clip
g.setPaint(gPaint);
g.setClip(gClip);
}
void draw(Graphics2D g) {
// toX/toY is tip of arrow and fx/fy is a point on the line -
// fx/fy is used to determine direction & angle
AffineTransform at = AffineTransform.getTranslateInstance(toX, toY);
int b = 9;
double theta = Math.toRadians(20);
// The idea of using a GeneralPath is so we can
// create the (three lines that make up the) arrow
// (only) one time and then use AffineTransform to
// place it anywhere we want.
GeneralPath path = new GeneralPath();
// distance between line and the arrow mark <** not **
// Start a new line segment from the position of (0,0).
path.moveTo(0, 0);
// Create one of the two arrow head lines.
int x = (int) (-b * Math.cos(theta));
int y = (int) (b * Math.sin(theta));
path.lineTo(x, y);
// distance between line and the arrow mark <** not **
// Make the other arrow head line.
int x2 = (int) (-b * Math.cos(-theta));
int y2 = (int) (b * Math.sin(-theta));
// path.moveTo(0,0);
path.lineTo(x2, y2);
path.closePath();
// theta is in radians
double s, t;
s = toY - fy; // calculate slopes.
t = toX - fx;
if (t != 0) {
s = s / t;
theta = Math.atan(s);
if (t < 0) theta += Math.PI;
} else if (s < 0) theta = -(Math.PI / 2);
else theta = Math.PI / 2;
at.rotate(theta);
// at.rotate(theta,toX,toY);
Shape shape = at.createTransformedShape(path);
if (checkStatus == Status.UNCHECKED) g.setColor(Color.BLACK);
else if (checkStatus == Status.COMPATIBLE) g.setColor(FOREST_GREEN);
else g.setColor(ORANGE_RED);
g.fill(shape);
g.draw(shape);
}
public void drawPage(Graphics2D g2, PageFormat pf, int page) {
if (message.equals("")) return;
page--; // account for cover page
drawCropMarks(g2, pf);
g2.clip(new Rectangle2D.Double(0, 0, pf.getImageableWidth(), pf.getImageableHeight()));
g2.translate(-page * pf.getImageableWidth(), 0);
g2.scale(scale, scale);
FontRenderContext context = g2.getFontRenderContext();
Font f = new Font("Serif", Font.PLAIN, 72);
TextLayout layout = new TextLayout(message, f, context);
AffineTransform transform = AffineTransform.getTranslateInstance(0, layout.getAscent());
Shape outline = layout.getOutline(transform);
g2.draw(outline);
}
public BufferedImage filter(BufferedImage src, BufferedImage dst) {
int w = src.getWidth();
int h = src.getHeight();
if (dst == null) {
ColorModel dstCM = src.getColorModel();
dst =
new BufferedImage(
dstCM,
dstCM.createCompatibleWritableRaster(width, height),
dstCM.isAlphaPremultiplied(),
null);
}
Graphics2D g = dst.createGraphics();
g.drawRenderedImage(src, AffineTransform.getTranslateInstance(-x, -y));
g.dispose();
return dst;
}
public synchronized void paint(Graphics gin) {
Graphics2D g = (Graphics2D) gin;
if (im == null) return;
int height = getHeight();
int width = getWidth();
if (fit) {
t = new AffineTransform();
double scale = Math.min(((double) width) / im.getWidth(), ((double) height) / im.getHeight());
// we'll re-center the transform in a moment.
t.scale(scale, scale);
}
// if the image (in either X or Y) is smaller than the view port, then center
// the image with respect to that axis.
double mwidth = im.getWidth() * t.getScaleX();
double mheight = im.getHeight() * t.getScaleY();
if (mwidth < width)
t.preConcatenate(
AffineTransform.getTranslateInstance((width - mwidth) / 2.0 - t.getTranslateX(), 0));
if (mheight < height)
t.preConcatenate(
AffineTransform.getTranslateInstance(0, (height - mheight) / 2.0 - t.getTranslateY()));
// if we're allowing panning (because only a portion of the image is visible),
// don't allow translations that show less information that is possible.
Point2D topleft = t.transform(new Point2D.Double(0, 0), null);
Point2D bottomright = t.transform(new Point2D.Double(im.getWidth(), im.getHeight()), null);
if (mwidth > width) {
if (topleft.getX() > 0)
t.preConcatenate(AffineTransform.getTranslateInstance(-topleft.getX(), 0));
if (bottomright.getX() < width)
t.preConcatenate(AffineTransform.getTranslateInstance(width - bottomright.getX(), 0));
// t.translate(width-bottomright.getX(), 0);
}
if (mheight > height) {
if (topleft.getY() > 0)
t.preConcatenate(AffineTransform.getTranslateInstance(0, -topleft.getY()));
if (bottomright.getY() < height)
t.preConcatenate(AffineTransform.getTranslateInstance(0, height - bottomright.getY()));
}
g.drawImage(im, t, null);
}
public BufferedImage filter(BufferedImage src, BufferedImage dst) {
int width = src.getWidth();
int height = src.getHeight();
if (dst == null)
dst =
new BufferedImage(
width + leftBorder + rightBorder, height + topBorder + bottomBorder, src.getType());
Graphics2D g = dst.createGraphics();
if (borderPaint != null) {
g.setPaint(borderPaint);
if (leftBorder > 0) g.fillRect(0, 0, leftBorder, height);
if (rightBorder > 0) g.fillRect(width - rightBorder, 0, rightBorder, height);
if (topBorder > 0) g.fillRect(leftBorder, 0, width - leftBorder - rightBorder, topBorder);
if (bottomBorder > 0)
g.fillRect(
leftBorder, height - bottomBorder, width - leftBorder - rightBorder, bottomBorder);
}
g.drawRenderedImage(src, AffineTransform.getTranslateInstance(leftBorder, rightBorder));
g.dispose();
return dst;
}
@Override
public void paintIcon(Component c, Graphics g, int x, int y) {
Graphics2D g2 = (Graphics2D) g.create();
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.translate(x, y);
g2.setStroke(new BasicStroke(BORDER_WIDTH));
g2.setPaint(LINE_COLOR);
g2.draw(BORDER);
g2.setStroke(new BasicStroke(SLIT_WIDTH));
g2.setColor(UIManager.getColor("Panel.background"));
int n = SLIT_NUM + 1;
int v = ICON_SIZE / n;
int m = n * v;
for (int i = 1; i < n; i++) {
int a = i * v;
g2.drawLine(a, 0, a, m);
g2.drawLine(0, a, m, a);
}
// g2.drawLine(1 * v, 0 * v, 1 * v, 4 * v);
// g2.drawLine(2 * v, 0 * v, 2 * v, 4 * v);
// g2.drawLine(3 * v, 0 * v, 3 * v, 4 * v);
// g2.drawLine(0 * v, 1 * v, 4 * v, 1 * v);
// g2.drawLine(0 * v, 2 * v, 4 * v, 2 * v);
// g2.drawLine(0 * v, 3 * v, 4 * v, 3 * v);
g2.setPaint(LINE_COLOR);
Rectangle2D b = ARROW.getBounds();
Point2D p = new Point2D.Double(b.getX() + b.getWidth() / 2d, b.getY() + b.getHeight() / 2d);
AffineTransform toCenterAT =
AffineTransform.getTranslateInstance(ICON_SIZE / 2d - p.getX(), ICON_SIZE / 2d - p.getY());
g2.fill(toCenterAT.createTransformedShape(ARROW));
g2.dispose();
}
/**
* Paint the image onto a Graphics object. The painting is performed tile-by-tile, and includes a
* grey region covering the unused portion of image tiles as well as the general background. At
* this point the image must be byte data.
*/
public synchronized void paintComponent(Graphics g) {
Graphics2D g2D = null;
if (g instanceof Graphics2D) {
g2D = (Graphics2D) g;
} else {
return;
}
// if source is null, it's just a component
if (source == null) {
g2D.setColor(getBackground());
g2D.fillRect(0, 0, componentWidth, componentHeight);
return;
}
int transX = -originX;
int transY = -originY;
// Get the clipping rectangle and translate it into image coordinates.
Rectangle clipBounds = g.getClipBounds();
if (clipBounds == null) {
clipBounds = new Rectangle(0, 0, componentWidth, componentHeight);
}
// clear the background (clip it) [minimal optimization here]
if (transX > 0
|| transY > 0
|| transX < (componentWidth - source.getWidth())
|| transY < (componentHeight - source.getHeight())) {
g2D.setColor(getBackground());
g2D.fillRect(0, 0, componentWidth, componentHeight);
}
clipBounds.translate(-transX, -transY);
// Determine the extent of the clipping region in tile coordinates.
int txmin, txmax, tymin, tymax;
int ti, tj;
txmin = XtoTileX(clipBounds.x);
txmin = Math.max(txmin, minTileX);
txmin = Math.min(txmin, maxTileX);
txmax = XtoTileX(clipBounds.x + clipBounds.width - 1);
txmax = Math.max(txmax, minTileX);
txmax = Math.min(txmax, maxTileX);
tymin = YtoTileY(clipBounds.y);
tymin = Math.max(tymin, minTileY);
tymin = Math.min(tymin, maxTileY);
tymax = YtoTileY(clipBounds.y + clipBounds.height - 1);
tymax = Math.max(tymax, minTileY);
tymax = Math.min(tymax, maxTileY);
Insets insets = getInsets();
// Loop over tiles within the clipping region
for (tj = tymin; tj <= tymax; tj++) {
for (ti = txmin; ti <= txmax; ti++) {
int tx = TileXtoX(ti);
int ty = TileYtoY(tj);
Raster tile = source.getTile(ti, tj);
if (tile != null) {
DataBuffer dataBuffer = tile.getDataBuffer();
WritableRaster wr = tile.createWritableRaster(sampleModel, dataBuffer, null);
BufferedImage bi =
new BufferedImage(colorModel, wr, colorModel.isAlphaPremultiplied(), null);
// correctly handles band offsets
if (brightnessEnabled == true) {
SampleModel sm =
sampleModel.createCompatibleSampleModel(tile.getWidth(), tile.getHeight());
WritableRaster raster = RasterFactory.createWritableRaster(sm, null);
BufferedImage bimg =
new BufferedImage(colorModel, raster, colorModel.isAlphaPremultiplied(), null);
// don't move this code
ByteLookupTable lutTable = new ByteLookupTable(0, lutData);
LookupOp lookup = new LookupOp(lutTable, null);
lookup.filter(bi, bimg);
g2D.drawImage(bimg, biop, tx + transX + insets.left, ty + transY + insets.top);
} else {
AffineTransform transform;
transform =
AffineTransform.getTranslateInstance(
tx + transX + insets.left, ty + transY + insets.top);
g2D.drawRenderedImage(bi, transform);
}
}
}
}
}
// Although it presently returns a boolean, that was only needed
// during my aborted attempted at animated graphics primitives.
// Until those become a reality the boolean value returned by this
// routine is unnecessary
public boolean animate(int sAt, boolean forward) {
int x;
LinkedList lt = null;
animation_done =
true; // May be re-set in paintComponent via indirect paintImmediately call at end
// Was used in aborted attempted to
// introduce animated primitives. Now
// it's probably excess baggage that
// remains because I still have hopes
// of eventually having animated
// primitives
if (getSize().width != 0 && getSize().height != 0) {
my_width = getSize().width; // set dimensions
my_height = getSize().height;
} else {
my_width = GaigsAV.preferred_width; // set dimensions
my_height = GaigsAV.preferred_height;
}
// First capture the new image in a buffer called image2
SnapAt = sAt;
BufferedImage image2 = new BufferedImage(my_width, my_height, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = (Graphics2D) image2.getGraphics(); // need a separate object each time?
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.setColor(Color.WHITE);
g2.fillRect(0, 0, my_width, my_height);
// Set horizoff and vertoff to properly center the visualization in the
// viewing window. This is not quite perfect because visualizations
// that are not properly centered within their [0,1] localized
// coordinates will not be perfectly centered, but it is much better
// than it was previously.
if (no_mouse_drag) {
horizoff = (my_width - GaigsAV.preferred_width) / 2;
vertoff = (my_height - GaigsAV.preferred_height) / 2;
}
list_of_snapshots.reset();
x = 0;
lt = new LinkedList();
while (x < SnapAt && list_of_snapshots.hasMoreElements()) {
lt = (LinkedList) list_of_snapshots.nextElement();
x++;
}
lt.reset();
animation_done = true;
// System.out.println("before loop " + horizoff);
while (lt.hasMoreElements()) {
obj tempObj = (obj) lt.nextElement();
animation_done =
animation_done && (tempObj.execute(g2 /*offscreen*/, zoom, vertoff, horizoff));
// System.out.println("in loop");
}
// Next capture the image we are coming from in a buffer called image1
SnapAt = (forward ? sAt - 1 : sAt + 1);
BufferedImage image1 = new BufferedImage(my_width, my_height, BufferedImage.TYPE_INT_RGB);
Graphics2D g1 = (Graphics2D) image1.getGraphics(); // need a separate object each time?
g1.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g1.setColor(Color.WHITE);
g1.fillRect(0, 0, my_width, my_height);
// Set horizoff and vertoff to properly center the visualization in the
// viewing window. This is not quite perfect because visualizations
// that are not properly centered within their [0,1] localized
// coordinates will not be perfectly centered, but it is much better
// than it was previously.
if (no_mouse_drag) {
horizoff = (my_width - GaigsAV.preferred_width) / 2;
vertoff = (my_height - GaigsAV.preferred_height) / 2;
}
list_of_snapshots.reset();
x = 0;
lt = new LinkedList();
while (x < SnapAt && list_of_snapshots.hasMoreElements()) {
lt = (LinkedList) list_of_snapshots.nextElement();
x++;
}
lt.reset();
animation_done = true;
// System.out.println("before loop " + horizoff);
while (lt.hasMoreElements()) {
obj tempObj = (obj) lt.nextElement();
animation_done =
animation_done && (tempObj.execute(g1 /*offscreen*/, zoom, vertoff, horizoff));
// System.out.println("in loop");
}
// Now slide from image1 to image2
// From the gaff Visualizer by Chris Gaffney
// double step = 4; // Adjust this for more/less granularity between images
double step = 40; // Adjust this for more/less granularity between images
Image buffer = getGraphicsConfiguration().createCompatibleVolatileImage(my_width, my_height);
Graphics2D g2d = (Graphics2D) buffer.getGraphics();
AffineTransform trans = AffineTransform.getTranslateInstance(step * (forward ? -1 : 1), 0);
// AffineTransform orig = g2d.getTransform();
Shape mask = createMask(my_width, my_height);
for (double i = 0; i < my_width; i += step) {
if (i + step > my_width) // last time through loop, so adjust transform
trans =
AffineTransform.getTranslateInstance(((double) (my_width - i)) * (forward ? -1 : 1), 0);
g2d.transform(trans);
g2d.drawImage(image1, 0, 0, this);
g2d.setColor(Color.BLACK);
g2d.fill(mask);
AffineTransform last = g2d.getTransform();
g2d.transform(AffineTransform.getTranslateInstance(my_width * (-1 * (forward ? -1 : 1)), 0));
g2d.drawImage(image2, 0, 0, this);
g2d.setColor(Color.BLACK);
g2d.fill(mask);
g2d.setTransform(last);
this.my_image = buffer;
repaint();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
}
}
Image b = getGraphicsConfiguration().createCompatibleImage(my_width, my_height);
b.getGraphics().drawImage(buffer, 0, 0, null);
this.my_image = b;
return animation_done;
}
protected void paintBackground(
Graphics g, int x, int y, int w, int h, boolean horizontal, JComponent component) {
Graphics2D g2d = (Graphics2D) g.create();
CEclipseBorder ec = null;
Insets ins = getOutsideInsets();
x = ins.left;
y = ins.top;
if (getOrientation().isHorizontal()) {
w -= ins.left + ins.right;
h -= ins.top + ins.bottom;
} else {
w -= ins.top + ins.bottom;
h -= ins.left + ins.right;
}
if (component.getBorder() instanceof CompoundBorder) {
CompoundBorder cb = (CompoundBorder) component.getBorder();
CompoundBorder bb = (CompoundBorder) cb.getInsideBorder();
ec = (CEclipseBorder) bb.getOutsideBorder();
}
if (w > 0 && h > 0) {
if (glassStrip != null) {
BufferedImage im = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
Graphics2D gg = im.createGraphics();
gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
gg.setColor(component.getBackground());
if (ec != null) {
gg.fill(ec.createShape(0, 0, w, h, ec.getCornerRadius()));
} else {
gg.fillRect(0, 0, w, h);
}
if (!isSelected()) {
gg.setComposite(AlphaComposite.SrcIn);
} else {
gg.setComposite(AlphaComposite.SrcAtop);
}
try {
glass.Render2Graphics(new Dimension(w, h), gg, glassStrip, true);
} catch (Exception e) {
glass.Render2Graphics(new Dimension(w, h), gg, CGlassFactory.VALUE_STEEL, true);
}
gg.dispose();
if (!getOrientation().isHorizontal()) {
AffineTransform atTrans = AffineTransform.getTranslateInstance(x /* + h */, y + w);
atTrans.concatenate(COutlineHelper.tRot90CCW);
g2d.drawImage(im, atTrans, null);
} else {
g2d.drawImage(im, x, y, null);
}
}
g2d.dispose();
}
}
public Shape getShape() {
int R = Integer.parseInt(hexcolor.substring(0, 2), 16);
int G = Integer.parseInt(hexcolor.substring(2, 4), 16);
int B = Integer.parseInt(hexcolor.substring(4, 6), 16);
color = new Color(R, G, B);
Shape geom;
if (shape.equals("circle")) {
geom = new Ellipse2D.Float(-0.05f * size, -0.05f * size, 1.1f * size, 1.1f * size);
center = new Point2D.Float(size / 2, size / 2);
} else if (shape.equals("square")) {
geom = new Rectangle2D.Float(0, 0, size, size);
center = new Point2D.Float(size / 2, size / 2);
} else if (shape.equals("roundsquare")) {
geom = new RoundRectangle2D.Float(0, 0, size, size, size / 2, size / 2);
center = new Point2D.Float(size / 2, size / 2);
} else if (shape.equals("triangle")) {
GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 2);
float height = (float) (Math.sqrt(3) * size / 2);
path.moveTo(size / 2, size - height);
path.lineTo(size, size);
path.lineTo(0, size);
path.closePath();
geom = path;
center = new Point2D.Float(size / 2, size - height / 2);
} else if (shape.equals("star")) {
GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 2);
path.moveTo(size / 2, 0);
path.lineTo(7 * size / 10, 3 * size / 10);
path.lineTo(size, size / 2);
path.lineTo(7 * size / 10, 7 * size / 10);
path.lineTo(size / 2, size);
path.lineTo(3 * size / 10, 7 * size / 10);
path.lineTo(0, size / 2);
path.lineTo(3 * size / 10, 3 * size / 10);
path.closePath();
AffineTransform trans = AffineTransform.getRotateInstance(Math.PI / 4, size / 2, size / 2);
Shape shape = trans.createTransformedShape(path);
Area area = new Area(path);
area.add(new Area(shape));
trans = AffineTransform.getScaleInstance(1.2, 1.2);
shape = trans.createTransformedShape(area);
trans = AffineTransform.getTranslateInstance(-0.1 * size, -0.1 * size);
shape = trans.createTransformedShape(shape);
geom = shape;
center = new Point2D.Float(size / 2, size / 2);
} else if (shape.equals("octagon")) {
GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 2);
path.moveTo(size / 4, 0);
path.lineTo(3 * size / 4, 0);
path.lineTo(size, size / 4);
path.lineTo(size, 3 * size / 4);
path.lineTo(3 * size / 4, size);
path.lineTo(size / 4, size);
path.lineTo(0, 3 * size / 4);
path.lineTo(0, size / 4);
path.closePath();
geom = path;
path.closePath();
geom = path;
center = new Point2D.Float(size / 2, size / 2);
} else if (shape.equals("ellipse")) {
geom = new Ellipse2D.Float(0, 0, 3 * size / 4, size);
center = new Point2D.Float(3 * size / 8, size / 2);
} else if (shape.equals("cross")) {
GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 2);
path.moveTo(size / 4, 0);
path.lineTo(3 * size / 4, 0);
path.lineTo(3 * size / 4, size / 4);
path.lineTo(size, size / 4);
path.lineTo(size, 3 * size / 4);
path.lineTo(3 * size / 4, 3 * size / 4);
path.lineTo(3 * size / 4, size);
path.lineTo(size / 4, size);
path.lineTo(size / 4, 3 * size / 4);
path.lineTo(0, 3 * size / 4);
path.lineTo(0, size / 4);
path.lineTo(size / 4, size / 4);
path.closePath();
geom = path;
center = new Point2D.Float(size / 2, size / 2);
} else if (shape.equals("pentagon")) {
GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 2);
path.moveTo(size / 2, size);
float x, y, a;
for (int i = 1; i < 5; i++) {
a = (float) ((2 * Math.PI / 5) * i);
x = (float) (size / 2 + size / 2 * Math.sin(a));
y = (float) (size / 2 + size / 2 * Math.cos(a));
path.lineTo(x, y);
}
path.closePath();
AffineTransform trans = AffineTransform.getScaleInstance(1.1, 1.1);
Shape shape = trans.createTransformedShape(path);
trans = AffineTransform.getTranslateInstance(-0.05 * size, -0.05 * size);
shape = trans.createTransformedShape(shape);
geom = shape;
center = new Point2D.Float(size / 2, size / 2);
} else if (shape.equals("hexagon")) {
GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 2);
path.moveTo(size / 2, size);
float x, y, a;
for (int i = 1; i < 6; i++) {
a = (float) ((2 * Math.PI / 6) * i);
x = (float) (size / 2 + size / 2 * Math.sin(a));
y = (float) (size / 2 + size / 2 * Math.cos(a));
path.lineTo(x, y);
}
path.closePath();
geom = path;
center = new Point2D.Float(size / 2, size / 2);
} else {
geom = new Ellipse2D.Float(0, 0, size, size);
center = new Point2D.Float(size / 2, size / 2);
}
return geom;
}
