@Override
protected void drawFill(Graphics2D g) {
if (isClosed() || get(UNCLOSED_PATH_FILLED)) {
double grow = AttributeKeys.getPerpendicularFillGrowth(this);
if (grow == 0d) {
g.fill(path);
} else {
GrowStroke gs =
new GrowStroke(grow, AttributeKeys.getStrokeTotalWidth(this) * get(STROKE_MITER_LIMIT));
g.fill(gs.createStrokedShape(path));
}
}
}
// public void savePDF(){
// Rectangle suggestedPageSize = getITextPageSize(page1.getPageSize());
// Rectangle pageSize = rotatePageIfNecessary(suggestedPageSize);
// //rotate if we need landscape
// Document document = new Document(pageSize);
//
// PdfWriter writer = PdfWriter.getInstance(document, new FileOutputStream(outputFile));
// document.open();
// Graphics2D graphics = cb.createGraphics(pageSize.getWidth(), pageSize.getHeight());
//
// // call your GTRenderer here
// GTRenderer draw = new StreamingRenderer();
// draw.setMapContent(mapContent);
//
// draw.paint(graphics, outputArea, mapContent.getLayerBounds() );
//
// // cleanup
// graphics.dispose();
//
// //cleanup
// document.close();
// writer.close();
// }
public void saveImage(final MapContent map, final String file, final int imageWidth) {
GTRenderer renderer = new StreamingRenderer();
renderer.setMapContent(map);
Rectangle imageBounds = null;
ReferencedEnvelope mapBounds = null;
try {
mapBounds = map.getMaxBounds();
double heightToWidth = mapBounds.getSpan(1) / mapBounds.getSpan(0);
imageBounds = new Rectangle(0, 0, imageWidth, (int) Math.round(imageWidth * heightToWidth));
} catch (Exception e) {
// failed to access mapContent layers
throw new RuntimeException(e);
}
BufferedImage image =
new BufferedImage(imageBounds.width, imageBounds.height, BufferedImage.TYPE_INT_RGB);
Graphics2D gr = image.createGraphics();
gr.setPaint(Color.WHITE);
gr.fill(imageBounds);
try {
renderer.paint(gr, imageBounds, mapBounds);
File fileToSave = new File(file);
ImageIO.write(image, "jpeg", fileToSave);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public BufferedImage makeIcon(
final int width, final int height, final Path2D iconShape, final boolean allowAlpha) {
final BufferedImage result = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
final Graphics2D g = result.createGraphics();
g.setStroke(new BasicStroke(0.05f));
final Color c;
if (allowAlpha) {
c =
new Color(
this.color.getRed(),
this.color.getGreen(),
this.color.getBlue(),
this.color.getAlpha());
} else {
c = new Color(this.color.getRGB());
}
if (iconShape != null) {
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g.setRenderingHint(
RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
g.setColor(c);
final Shape path = makeTransformedPathForSize(width, height, iconShape);
g.fill(path);
} else {
g.setColor(c);
g.fillRect(0, 0, width, height);
}
g.dispose();
return result;
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setPaint(BACKGROUND);
g2.fill(
new Rectangle2D.Float(
0f, 0f, (float) g2.getClipBounds().width, (float) g2.getClipBounds().height));
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
canvas.paint(g2);
}
/**
* Draw a filled polygon with the given (x[i], y[i]) coordinates.
*
* @param x an array of all the x-coordindates of the polygon
* @param y an array of all the y-coordindates of the polygon
*/
public static void filledPolygon(double[] x, double[] y) {
int N = x.length;
GeneralPath path = new GeneralPath();
path.moveTo((float) scaleX(x[0]), (float) scaleY(y[0]));
for (int i = 0; i < N; i++) path.lineTo((float) scaleX(x[i]), (float) scaleY(y[i]));
path.closePath();
offscreen.fill(path);
draw();
}
/**
* Draw filled circle of radius r, centered on (x, y).
*
* @param x the x-coordinate of the center of the circle
* @param y the y-coordinate of the center of the circle
* @param r the radius of the circle
* @throws RuntimeException if the radius of the circle is negative
*/
public static void filledCircle(double x, double y, double r) {
if (r < 0) throw new RuntimeException("circle radius can't be negative");
double xs = scaleX(x);
double ys = scaleY(y);
double ws = factorX(2 * r);
double hs = factorY(2 * r);
if (ws <= 1 && hs <= 1) pixel(x, y);
else offscreen.fill(new Ellipse2D.Double(xs - ws / 2, ys - hs / 2, ws, hs));
draw();
}
/**
* Draw a filled square of side length 2r, centered on (x, y).
*
* @param x the x-coordinate of the center of the square
* @param y the y-coordinate of the center of the square
* @param r radius is half the length of any side of the square
* @throws RuntimeException if r is negative
*/
public static void filledSquare(double x, double y, double r) {
if (r < 0) throw new RuntimeException("square side length can't be negative");
double xs = scaleX(x);
double ys = scaleY(y);
double ws = factorX(2 * r);
double hs = factorY(2 * r);
if (ws <= 1 && hs <= 1) pixel(x, y);
else offscreen.fill(new Rectangle2D.Double(xs - ws / 2, ys - hs / 2, ws, hs));
draw();
}
/**
* Draw a filled rectangle of given half width and half height, centered on (x, y).
*
* @param x the x-coordinate of the center of the rectangle
* @param y the y-coordinate of the center of the rectangle
* @param halfWidth is half the width of the rectangle
* @param halfHeight is half the height of the rectangle
* @throws RuntimeException if halfWidth or halfHeight is negative
*/
public static void filledRectangle(double x, double y, double halfWidth, double halfHeight) {
if (halfWidth < 0) throw new RuntimeException("half width can't be negative");
if (halfHeight < 0) throw new RuntimeException("half height can't be negative");
double xs = scaleX(x);
double ys = scaleY(y);
double ws = factorX(2 * halfWidth);
double hs = factorY(2 * halfHeight);
if (ws <= 1 && hs <= 1) pixel(x, y);
else offscreen.fill(new Rectangle2D.Double(xs - ws / 2, ys - hs / 2, ws, hs));
draw();
}
/**
* Draw an ellipse with given semimajor and semiminor axes, centered on (x, y).
*
* @param x the x-coordinate of the center of the ellipse
* @param y the y-coordinate of the center of the ellipse
* @param semiMajorAxis is the semimajor axis of the ellipse
* @param semiMinorAxis is the semiminor axis of the ellipse
* @throws RuntimeException if either of the axes are negative
*/
public static void filledEllipse(double x, double y, double semiMajorAxis, double semiMinorAxis) {
if (semiMajorAxis < 0) throw new RuntimeException("ellipse semimajor axis can't be negative");
if (semiMinorAxis < 0) throw new RuntimeException("ellipse semiminor axis can't be negative");
double xs = scaleX(x);
double ys = scaleY(y);
double ws = factorX(2 * semiMajorAxis);
double hs = factorY(2 * semiMinorAxis);
if (ws <= 1 && hs <= 1) pixel(x, y);
else offscreen.fill(new Ellipse2D.Double(xs - ws / 2, ys - hs / 2, ws, hs));
draw();
}
/**
* Draw a point at (x, y).
*
* @param x the x-coordinate of the point
* @param y the y-coordinate of the point
*/
public static void point(double x, double y) {
double xs = scaleX(x);
double ys = scaleY(y);
double r = penRadius;
// double ws = factorX(2*r);
// double hs = factorY(2*r);
// if (ws <= 1 && hs <= 1) pixel(x, y);
if (r <= 1) pixel(x, y);
else offscreen.fill(new Ellipse2D.Double(xs - r / 2, ys - r / 2, r, r));
draw();
}
/**
* Esta funcion se usa para pintar la barra de seleccion de los menus. Esta aqui para no repetirla
* en todas partes...
*/
static void pintaBarraMenu(Graphics g, JMenuItem menuItem, Color bgColor) {
ButtonModel model = menuItem.getModel();
Color oldColor = g.getColor();
int menuWidth = menuItem.getWidth();
int menuHeight = menuItem.getHeight();
if (menuItem.isOpaque()) {
g.setColor(menuItem.getBackground());
g.fillRect(0, 0, menuWidth, menuHeight);
}
if ((menuItem instanceof JMenu && !(((JMenu) menuItem).isTopLevelMenu()) && model.isSelected())
|| model.isArmed()) {
RoundRectangle2D.Float boton = new RoundRectangle2D.Float();
boton.x = 1;
boton.y = 0;
boton.width = menuWidth - 3;
boton.height = menuHeight - 1;
boton.arcwidth = 8;
boton.archeight = 8;
GradientPaint grad = new GradientPaint(1, 1, getBrilloMenu(), 0, menuHeight, getSombraMenu());
Graphics2D g2D = (Graphics2D) g;
g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g.setColor(bgColor);
g2D.fill(boton);
g.setColor(bgColor.darker());
g2D.draw(boton);
g2D.setPaint(grad);
g2D.fill(boton);
g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_DEFAULT);
}
g.setColor(oldColor);
}
@Override
public void prerasterizeIcon(final Shape shape) {
final Rectangle r = shape.getBounds();
final BufferedImage prerasterized =
new BufferedImage(r.width, r.height, BufferedImage.TYPE_INT_ARGB);
final Graphics2D g = prerasterized.createGraphics();
g.setStroke(new BasicStroke(0.05f));
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g.setRenderingHint(
RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
g.setColor(this.color);
g.fill(shape);
g.dispose();
this.prerasterizedImage = prerasterized;
}
protected float drawBoxedString(Graphics2D g2, String s, Color c1, Color c2, double x) {
// Calculate the width of the string.
FontRenderContext frc = g2.getFontRenderContext();
TextLayout subLayout = new TextLayout(s, mFont, frc);
float advance = subLayout.getAdvance();
// Fill the background rectangle with a gradient.
GradientPaint gradient = new GradientPaint((float) x, 0, c1, (float) (x + advance), 0, c2);
g2.setPaint(gradient);
Rectangle2D bounds = mLayout.getBounds();
Rectangle2D back = new Rectangle2D.Double(x, 0, advance, bounds.getHeight());
g2.fill(back);
// Draw the string over the gradient rectangle.
g2.setPaint(Color.white);
g2.setFont(mFont);
g2.drawString(s, (float) x, (float) -bounds.getY());
return advance;
}
protected void drawBackground(Graphics2D g2) {
// Draw circles of different colors.
int side = 45;
int width = getSize().width;
int height = getSize().height;
Color[] colors = {
Color.yellow, Color.cyan, Color.orange, Color.pink, Color.magenta, Color.lightGray
};
for (int y = 0; y < height; y += side) {
for (int x = 0; x < width; x += side) {
Ellipse2D ellipse = new Ellipse2D.Float(x, y, side, side);
int index = (x + y) / side % colors.length;
g2.setPaint(colors[index]);
g2.fill(ellipse);
}
}
}
/**
* Draw a point at (x, y).
*
* @param x the x-coordinate of the point
* @param y the y-coordinate of the point
*/
public static void point(double x, double y) {
double xs = scaleX(x);
double ys = scaleY(y);
double r = penRadius;
float scaledPenRadius = (float) (r * DEFAULT_SIZE);
// double ws = factorX(2*r);
// double hs = factorY(2*r);
// if (ws <= 1 && hs <= 1) pixel(x, y);
if (scaledPenRadius <= 1) pixel(x, y);
else
offscreen.fill(
new Ellipse2D.Double(
xs - scaledPenRadius / 2,
ys - scaledPenRadius / 2,
scaledPenRadius,
scaledPenRadius));
draw();
}
/**
* Draws a single arrow head
*
* @param aG the canvas to draw on;
* @param aXpos the X position of the arrow head;
* @param aYpos the (center) Y position of the arrow head;
* @param aFactor +1 to have a left-facing arrow head, -1 to have a right-facing arrow head;
* @param aArrowWidth the total width of the arrow head;
* @param aArrowHeight the total height of the arrow head.
*/
public static final void drawArrowHead(
final Graphics2D aG,
final int aXpos,
final int aYpos,
final int aFactor,
final int aArrowWidth,
final int aArrowHeight) {
final double halfHeight = aArrowHeight / 2.0;
final int x1 = aXpos + (aFactor * aArrowWidth);
final int y1 = (int) Math.ceil(aYpos - halfHeight);
final int y2 = (int) Math.floor(aYpos + halfHeight);
final Polygon arrowHead = new Polygon();
arrowHead.addPoint(aXpos, aYpos);
arrowHead.addPoint(x1, y1);
arrowHead.addPoint(x1, y2);
aG.fill(arrowHead);
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D) g;
g2d.setPaint(Color.black);
g2d.setStroke(new BasicStroke());
g2d.setFont(new Font("Century Schoolbook", Font.PLAIN, 12));
if (d.isInitialized() && display_plot) {
d.refreshData();
Float xLower = d.getXLower();
Float xUpper = d.getXUpper();
Float xInterval = d.getXInterval();
Float yLower = d.getYLower();
Float yUpper = d.getYUpper();
Float yInterval = d.getYInterval();
Float dx = xUpper - xLower;
Float dy = yUpper - yLower;
drawCenteredString(g2d, d.getTitle(), 250, 25, (float) 0.);
drawCenteredString(g2d, d.getXTitle(), 250, 475, (float) 0.);
drawCenteredString(g2d, d.getYTitle(), 25, 250, (float) -Math.PI / 2);
drawCenteredString(g2d, xLower.toString(), 50, 475, (float) 0);
drawCenteredString(g2d, xUpper.toString(), 450, 475, (float) 0);
drawCenteredString(g2d, yLower.toString(), 25, 450, (float) 0);
drawCenteredString(g2d, yUpper.toString(), 25, 50, (float) 0);
g2d.setPaint(Color.gray);
for (Float x = new Float(50); x <= 450; x += 400 * xInterval / dx)
g2d.draw(new Line2D.Float(x, 450, x, 50));
for (Float y = new Float(50); y <= 450; y += 400 * yInterval / dy)
g2d.draw(new Line2D.Float(45, y, 450, y));
g2d.setPaint(Color.red);
Float diam = new Float(8);
int num_points = d.getNumberOfPoints();
for (int i = 0; i < num_points; i++) {
Float ex = 400 * (d.getPoint(i).x - xLower) / dx + 50;
ex -= diam / 2;
Float ey = -400 * (d.getPoint(i).y - yLower) / dy + 450;
ey -= diam / 2;
g2d.fill(new Ellipse2D.Float(ex, ey, diam, diam));
}
}
}
public void draw(Graphics2D g) {
g.setColor(fillColor);
g.fill(gp);
g.setColor(Color.black);
g.draw(gp);
for (int i = 0; i < points.size(); i++) {
GlyphPoint p = points.get(i);
g.setColor(Color.red);
g.draw(p.gp);
g.setColor(Color.blue);
g.setFont(gfont);
g.drawString(String.valueOf(i), p.x + 3, p.y + 3);
}
g.setColor(Color.black);
// System.out.println("Advance: "+advance);
g.draw(advp);
if (name != null) {
g.setFont(gfont);
g.drawString(name, 0, -40);
}
}
public void saveNewImage(MapContent map, String file) {
GTRenderer renderer = new StreamingRenderer();
renderer.setMapContent(map);
System.out.println("line 139");
Rectangle imageBounds = null;
try {
ReferencedEnvelope mapBounds = map.getMaxBounds();
double heightToWidth = mapBounds.getSpan(1) / mapBounds.getSpan(0);
int imageWidth = 600;
imageBounds = new Rectangle(0, 0, imageWidth, (int) Math.round(imageWidth * heightToWidth));
} catch (Exception e) {
}
System.out.println("line 151");
// Rectangle imageSize = new Rectangle(600,600);
BufferedImage image =
new BufferedImage(
imageBounds.width, imageBounds.height, BufferedImage.TYPE_INT_RGB); // darker red fill
Graphics2D gr = image.createGraphics();
gr.setPaint(Color.WHITE);
gr.fill(imageBounds);
try {
System.out.println("line 161");
renderer.paint(gr, imageBounds, map.getMaxBounds());
System.out.println("line 163");
File fileToSave = new File(file);
System.out.println("line 166");
ImageIO.write(image, "jpeg", fileToSave);
System.out.println("line 168");
} catch (IOException e) {
}
}
@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();
}
public void draw(
Graphics2D g,
Color stringColor,
Color foreground,
Color background,
String info,
double x,
double y) {
FontMetrics fm = g.getFontMetrics();
int h = fm.getHeight();
int w = fm.stringWidth(info);
r1.setRect(
x - w / 2 - in.left, y - in.top - h / 2, w + in.right + in.left, h + in.bottom + in.top);
g.setColor(background);
g.fill(r1);
g.setColor(stringColor);
g.draw(r1);
g.setColor(foreground);
r2.setRect(r1.getX() + 1, r1.getY() + 1, r1.getWidth() - 2, r1.getHeight() - 2);
g.draw(r2);
g.setColor(stringColor);
g.drawString(
info, (float) (r2.getX() + in.left), (float) (r2.getY() + h - (r2.getHeight() - h) / 2));
}
protected void drawFill(Graphics2D g) {
g.fill(getTextShape());
}
/**
* Creates new frame image from current data (and previous frames as specified by their
* disposition codes).
*/
protected void setPixels() {
// expose destination image's pixels as int array
int[] dest = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
// fill in starting image contents based on last image's dispose code
if (lastDispose > 0) {
if (lastDispose == 3) {
// use image before last
int n = frameCount - 2;
if (n > 0) {
lastImage = getFrame(n - 1);
} else {
lastImage = null;
}
}
if (lastImage != null) {
int[] prev = ((DataBufferInt) lastImage.getRaster().getDataBuffer()).getData();
System.arraycopy(prev, 0, dest, 0, width * height);
// copy pixels
if (lastDispose == 2) {
// fill last image rect area with background color
Graphics2D g = image.createGraphics();
Color c = null;
if (transparency) {
c = new Color(0, 0, 0, 0); // assume background is transparent
} else {
c = new Color(lastBgColor); // use given background color
}
g.setColor(c);
g.setComposite(AlphaComposite.Src); // replace area
g.fill(lastRect);
g.dispose();
}
}
}
// copy each source line to the appropriate place in the destination
int pass = 1;
int inc = 8;
int iline = 0;
for (int i = 0; i < ih; i++) {
int line = i;
if (interlace) {
if (iline >= ih) {
pass++;
switch (pass) {
case 2:
iline = 4;
break;
case 3:
iline = 2;
inc = 4;
break;
case 4:
iline = 1;
inc = 2;
}
}
line = iline;
iline += inc;
}
line += iy;
if (line < height) {
int k = line * width;
int dx = k + ix; // start of line in dest
int dlim = dx + iw; // end of dest line
if ((k + width) < dlim) {
dlim = k + width; // past dest edge
}
int sx = i * iw; // start of line in source
while (dx < dlim) {
// map color and insert in destination
int index = ((int) pixels[sx++]) & 0xff;
int c = act[index];
if (c != 0) {
dest[dx] = c;
}
dx++;
}
}
}
}
// also clip, transform, composite,
// public boolean isOpaque(){return false;}//theOpaque!=null&&theOpaque;}
// ---------------------------------------------------------
private void doPaint(Graphics2D g, int s, Object o) {
// process an operation from the buffer
// System.out.println(s);
Object o1 = null,
o2 = null,
o3 = null,
o4 = null,
o5 = null,
o6 = null,
o7 = null,
o8 = null,
o9 = null,
o10 = null,
o11 = null;
if (o instanceof Object[]) {
Object[] a = (Object[]) o;
if (a.length > 0) o1 = a[0];
if (a.length > 1) o2 = a[1];
if (a.length > 2) o3 = a[2];
if (a.length > 3) o4 = a[3];
if (a.length > 4) o5 = a[4];
if (a.length > 5) o6 = a[5];
if (a.length > 6) o7 = a[6];
if (a.length > 7) o8 = a[7];
if (a.length > 8) o9 = a[8];
if (a.length > 9) o10 = a[9];
if (a.length > 10) o11 = a[10];
}
switch (s) {
case clear:
paintBackground(g, theBackground);
break;
// public void addRenderingHints(Map<?,?> hints)
// {toBuffer("addRenderingHints",hints );}
case addRenderingHints:
g.addRenderingHints((Map<?, ?>) o);
break;
case clip1:
g.clip((Shape) o);
break;
case draw1:
g.draw((Shape) o);
break;
case draw3DRect:
g.draw3DRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Boolean) o5);
break;
case drawGlyphVector:
g.drawGlyphVector((GlyphVector) o1, (Float) o2, (Float) o3);
break;
case drawImage1:
g.drawImage((BufferedImage) o1, (BufferedImageOp) o2, (Integer) o3, (Integer) o4);
break;
case drawImage2:
g.drawImage((Image) o1, (AffineTransform) o2, (ImageObserver) o3);
break;
case drawRenderableImage:
g.drawRenderableImage((RenderableImage) o1, (AffineTransform) o2);
break;
case drawRenderedImage:
g.drawRenderedImage((RenderedImage) o1, (AffineTransform) o2);
break;
case drawString1:
g.drawString((AttributedCharacterIterator) o1, (Float) o2, (Float) o3);
break;
case drawString2:
g.drawString((AttributedCharacterIterator) o1, (Integer) o2, (Integer) o3);
break;
case drawString3:
g.drawString((String) o1, (Float) o2, (Float) o3);
break;
case drawString4:
g.drawString((String) o1, (Integer) o2, (Integer) o3);
break;
case fill:
g.fill((Shape) o);
break;
case fill3DRect:
g.fill3DRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Boolean) o5);
break;
case rotate1:
g.rotate((Double) o);
break;
case rotate2:
g.rotate((Double) o1, (Double) o2, (Double) o3);
break;
case scale1:
g.scale((Double) o1, (Double) o2);
break;
case setBackground:
g.setBackground(
(Color) o); // paintBackground(g,(Color)o); /*super.setBackground((Color)o) ;*/
break;
case setComposite:
g.setComposite((Composite) o);
break;
case setPaint:
g.setPaint((Paint) o);
break;
case setRenderingHint:
g.setRenderingHint((RenderingHints.Key) o1, o2);
break;
case setRenderingHints:
g.setRenderingHints((Map<?, ?>) o);
break;
case setStroke:
g.setStroke((Stroke) o);
break;
case setTransform:
g.setTransform(makeTransform(o));
break;
case shear:
g.shear((Double) o1, (Double) o2);
break;
case transform1:
g.transform(makeTransform(o));
break;
case translate1:
g.translate((Double) o1, (Double) o2);
break;
case translate2:
g.translate((Integer) o1, (Integer) o2);
break;
case clearRect:
g.clearRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
break;
case copyArea:
g.copyArea(
(Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
break;
case drawArc:
g.drawArc(
(Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
break;
case drawBytes:
g.drawBytes((byte[]) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5);
break;
case drawChars:
g.drawChars((char[]) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5);
break;
case drawImage4:
g.drawImage((Image) o1, (Integer) o2, (Integer) o3, (Color) o4, (ImageObserver) o5);
break;
case drawImage5:
g.drawImage((Image) o1, (Integer) o2, (Integer) o3, (ImageObserver) o4);
break;
case drawImage6:
g.drawImage(
(Image) o1,
(Integer) o2,
(Integer) o3,
(Integer) o4,
(Integer) o5,
(Color) o6,
(ImageObserver) o7);
break;
case drawImage7:
g.drawImage(
(Image) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (ImageObserver) o6);
break;
case drawImage8:
g.drawImage(
(Image) o1,
(Integer) o2,
(Integer) o3,
(Integer) o4,
(Integer) o5,
(Integer) o6,
(Integer) o7,
(Integer) o8,
(Integer) o9,
(Color) o10,
(ImageObserver) o11);
break;
case drawImage9:
g.drawImage(
(Image) o1,
(Integer) o2,
(Integer) o3,
(Integer) o4,
(Integer) o5,
(Integer) o6,
(Integer) o7,
(Integer) o8,
(Integer) o9,
(ImageObserver) o10);
break;
case drawLine:
g.drawLine((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
break;
case drawOval:
g.drawOval((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
break;
case drawPolygon1:
g.drawPolygon((int[]) o1, (int[]) o2, (Integer) o3);
break;
case drawPolygon2:
g.drawPolygon((Polygon) o);
break;
case drawPolyline:
g.drawPolyline((int[]) o1, (int[]) o2, (Integer) o3);
break;
case drawRect:
g.drawRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
break;
case drawRoundRect:
g.drawRoundRect(
(Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
break;
case fillArc:
g.fillArc(
(Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
break;
case fillOval:
g.fillOval((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
break;
// {toBuffer("fillPolygon",mkArg(xPoints, yPoints, nPoints) );}
case fillPolygon1:
g.fillPolygon((int[]) o1, (int[]) o2, (Integer) o3);
break;
case fillPolygon2:
g.fillPolygon((Polygon) o);
break;
case fillRect:
g.fillRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
break;
case fillRoundRect:
g.fillRoundRect(
(Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
break;
case setClip1:
g.setClip((Shape) o);
break;
case setColor:
g.setColor((Color) o);
break;
case setFont:
g.setFont((Font) o);
break;
case setPaintMode:
g.setPaintMode();
break;
case setXORMode:
g.setXORMode((Color) o);
break;
case opaque:
super.setOpaque((Boolean) o);
break;
case drawOutline: // g.drawString((String)o1, (Integer)o2, (Integer)o3) ;break;
{
FontRenderContext frc = g.getFontRenderContext();
TextLayout tl = new TextLayout((String) o1, g.getFont(), frc);
Shape s1 = tl.getOutline(null);
AffineTransform af = g.getTransform();
g.translate((Integer) o2, (Integer) o3);
g.draw(s1);
g.setTransform(af);
}
;
break;
default:
System.out.println("Unknown image operation " + s);
}
}
// 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 /*synchronized*/ boolean execute(int sAt) {
// The commented-out variables below are remnants from legacy
// code -- they appear to be no longer needed.
// String urlTemp="";
// int z=0;
// int idx;
// int urlid;
// boolean showURL=false;
animation_done =
true; // May be re-set in paintComponent via indirect paintImmediately call at end
// Was used in abored attempted to
// introduce animated primitives. Now
// it's probably excess baggage that
// remains because I still have hopes
// of eventually having animated
// primitives
SnapAt = sAt;
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;
}
BufferedImage buff = new BufferedImage(my_width, my_height, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = (Graphics2D) buff.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){
// if(first_paint_call){
// // horizoff = (my_width - (int)(0.25 * my_width) -
// // GaigsAV.preferred_width) / 2;
// horizoff = (my_width - GaigsAV.preferred_width) / 2;
// first_paint_call = false;
// }else{
// horizoff = (my_width - GaigsAV.preferred_width) / 2;
// no_mouse_drag = false;
// }
// }
if (no_mouse_drag) {
horizoff = (my_width - GaigsAV.preferred_width) / 2;
vertoff = (my_height - GaigsAV.preferred_height) / 2;
}
int x;
list_of_snapshots.reset();
x = 0;
LinkedList 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");
}
Shape mask = createMask(buff.getWidth(), buff.getHeight());
g2.setColor(Color.BLACK);
g2.fill(mask);
my_image = buff;
repaint();
return animation_done;
}
// 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;
}