public void drawScreen() {
Graphics2D g = (Graphics2D) this.getGraphics();
g.drawImage(buffer, 0, 0, this);
Toolkit.getDefaultToolkit().sync();
g.dispose();
}
protected void drawImageMosaic(Graphics2D g2) {
// Break the image up into tiles. Draw each
// tile with its own transparency, allowing
// the background to show through to varying
// degrees.
int side = 36;
int width = mImage.getWidth();
int height = mImage.getHeight();
for (int y = 0; y < height; y += side) {
for (int x = 0; x < width; x += side) {
// Calculate an appropriate transparency value.
float xBias = (float) x / (float) width;
float yBias = (float) y / (float) height;
float alpha = 1.0f - Math.abs(xBias - yBias);
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
// Draw the subimage.
int w = Math.min(side, width - x);
int h = Math.min(side, height - y);
BufferedImage tile = mImage.getSubimage(x, y, w, h);
g2.drawImage(tile, x, y, null);
}
}
// Reset the composite.
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
}
void draw(Graphics2D g) {
g.setColor(darkColor);
int x = (int) (center_x + distance * Math.sin(-unit * current / num));
int y = (int) (center_y + distance * Math.cos(-unit * current / num));
Area area = new Area(new Ellipse2D.Double(x, y, ball_r, ball_r));
g.fill(area);
}
/** Draws the edge structure of the tree */
public void drawEdges(Graphics2D gg) {
gg.setPaint(Color.black);
Enumeration nodeList = argument.getBreadthFirstTraversal().elements();
// For each vertex...
while (nodeList.hasMoreElements()) {
// Get its edge list...
TreeVertex vertex = (TreeVertex) nodeList.nextElement();
Enumeration edges = vertex.getEdgeList().elements();
// For each edge in the list...
while (edges.hasMoreElements()) {
TreeEdge edge = (TreeEdge) edges.nextElement();
// If we have several vertices on layer 0, only draw
// edges for layers below that
if (!(argument.isMultiRoots() && vertex.getLayer() == 0)) {
// If the edge has been selected with the mouse,
// use a thick line
if (edge.isSelected()) {
gg.setStroke(selectStroke);
}
gg.draw(edge.getShape(this));
// If we used a thick line, reset the stroke to normal
// line for next edge.
if (edge.isSelected()) {
gg.setStroke(solidStroke);
}
TreeVertex edgeSource = edge.getDestVertex();
}
}
}
}
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setColor(Color.black);
g2.fillRect(0, 0, 10, 70);
g2.fillRect(60, 0, 10, 70);
g2.fillRect(120, 0, 10, 70);
g2.fillRect(0, 0, 130, 10);
g2.fillRect(0, 60, 130, 10);
g2.fillRect(70, 30, 50, 10);
g2.fillRect(90, 10, 10, 50);
fill(g2, fullRect, RoadDirection.CENTER);
fill(g2, nw, RoadDirection.NW);
fill(g2, ne, RoadDirection.NE);
fill(g2, sw, RoadDirection.SW);
fill(g2, se, RoadDirection.SE);
g2.setFont(Font.decode("Arial-10"));
g2.setColor(Color.black);
SwingUtils.drawCenteredString(g, "CENTER", (int) fullRectStrPos.x, (int) fullRectStrPos.y);
SwingUtils.drawCenteredString(g, "NW", (int) nwStrPos.x, (int) nwStrPos.y);
SwingUtils.drawCenteredString(g, "NE", (int) neStrPos.x, (int) neStrPos.y);
SwingUtils.drawCenteredString(g, "SW", (int) swStrPos.x, (int) swStrPos.y);
SwingUtils.drawCenteredString(g, "SE", (int) seStrPos.x, (int) seStrPos.y);
}
// =========================================================== paintComponent
@Override
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g; // Downcast to Graphics2D
// ... One time initialization of in-memory, saved image.
if (_bufImage == null) {
// ... This is the first time, initialize _bufImage
int w = this.getWidth();
int h = this.getHeight();
_bufImage = (BufferedImage) this.createImage(w, h);
Graphics2D gc = _bufImage.createGraphics();
gc.setColor(COLOR_BACKGROUND);
gc.fillRect(0, 0, w, h); // fill in background
}
// ... Display the saved image.
g2.drawImage(_bufImage, null, 0, 0);
// ... Overwrite the screen display with currently dragged image.
if (_state == State.DRAGGING) {
// ... Write shape that is being dragged over the screen image,
// but not into the saved buffered image. It will be written
// on the saved image when the mouse is released.
drawCurrentShape(g2);
}
}
// 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();
}
}
public void paint(Graphics g) {
super.paint(g);
Graphics2D g2d = (Graphics2D) g;
g2d.draw(
new Ellipse2D.Double(
centerx - (centery - 500),
centery - (centery - 500),
2 * (centery - 500),
2 * (centery - 500)));
try {
g2d.draw(
new Ellipse2D.Double(
player.x - player.size / 2, player.y - player.size / 2, player.size, player.size));
} catch (NullPointerException e) {
}
k = 1;
while (k <= ballCount) {
g2d.draw(
new Ellipse2D.Double(
ball[k].x - ball[k].size / 2,
ball[k].y - ball[k].size / 2,
ball[k].size,
ball[k].size));
k++;
}
}
/** [Internal] */
private void paintBackground(Graphics2D g2, Color theBackground) {
Color color1 = g2.getColor();
if (theBackground == null) theBackground = Color.white;
g2.setColor(theBackground);
g2.fillRect(0, 0, 30000, 30000);
g2.setColor(color1);
}
public void drawFunctionToGraphic(Graphics2D g, int x, int y, int UNITYX, int UNITYY) {
int _x, _y;
g.setColor(Color.red);
g.drawString("f(x) = " + F.toString(), 15, 20);
g.setColor(Color.blue);
for (double i = 0; ; i += EPSILON) {
_x = (int) (i * UNITYX) + x / 2;
_y = -(int) (F.evaluate(i) * UNITYY) + y / 2;
g.drawLine(
_x,
_y,
(int) ((i + EPSILON) * UNITYX) + x / 2,
-(int) (F.evaluate(i + EPSILON) * UNITYY) + y / 2);
if (_x < 0 || _x > x || _y < 0 || _y > y) break;
}
for (double i = 0; ; i -= EPSILON) {
_x = (int) (i * UNITYX) + x / 2;
_y = -(int) (F.evaluate(i) * UNITYY) + y / 2;
g.drawLine(
_x,
_y,
(int) ((i + EPSILON) * UNITYX) + x / 2,
-(int) (F.evaluate(i + EPSILON) * UNITYY) + y / 2);
if (_x < 0 || _x > x || _y < 0 || _y > y) break;
}
}
/**
* Adds the componentType buttons to the Panel of Main Window.
*
* @param pkg_name whose componentType buttons will be added
* @param a needed for the addition of the ActionListener of respective buttons and calling method
* of Pad_Draw
*/
public void add_componentType_buttons(package_cls pkg_name, final counts a) {
int i;
JLabel pkg_hdng = new JLabel(pkg_name.getName());
panel.add(pkg_hdng);
for (i = 0; i < pkg_name.getComponentType_list().size(); i++) {
final componentType cmp_Types = pkg_name.getComponentType_list().get(i);
int btnHeight, btnWidth;
double scale = 0.5;
btnWidth = (int) (scale * (double) cmp_Types.getWidth());
btnHeight = (int) (scale * (double) cmp_Types.getHeight());
ImageIcon myIcon = new ImageIcon(cmp_Types.getType_Img());
BufferedImage bi = new BufferedImage(btnWidth, btnHeight, BufferedImage.TYPE_INT_ARGB);
Graphics2D g = bi.createGraphics();
g.scale(scale, scale);
myIcon.paintIcon(null, g, 0, 0);
g.dispose();
JButton strctButton = new JButton(new ImageIcon(bi));
strctButton.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
drawPad.add_componentType(cmp_Types, a);
taskbar.setText("Click to add a component");
}
});
panel.add(strctButton);
}
panel.validate(); // Updates the Panel
}
// draw method
public synchronized void draw(Graphics2D g) {
int w = s.getWidth();
int h = s.getHeight();
image.x %= w;
image.y %= h;
if (image.x < 0) {
image.x += w;
} else {
}
if (image.y < 0) {
image.y += h;
} else {
}
int x = image.x;
int y = image.y;
g.drawImage(bg, x, y, null);
g.drawImage(bg, x - w, y, null);
g.drawImage(bg, x, y - h, null);
g.drawImage(bg, x - w, y - h, null);
}
public void paintText(Graphics2D g, ButtonInfo info) {
ButtonModel model = info.button.getModel();
FontMetrics fm = info.button.getFontMetrics(info.button.getFont());
int mnemonicIndex = info.button.getDisplayedMnemonicIndex();
String text = info.button.getText();
int textShiftOffset = 0;
g.setComposite(AlphaComposite.SrcOver);
/* Draw the Text */
if (isEnabled(info.button)) {
/** * paint the text normally */
g.setColor(info.button.getForeground());
BasicGraphicsUtils.drawStringUnderlineCharAt(
g,
text,
mnemonicIndex,
info.textRect.x + textShiftOffset,
info.textRect.y + fm.getAscent() + textShiftOffset);
} else {
/** * paint the text disabled ** */
g.setColor(info.button.getBackground().brighter());
BasicGraphicsUtils.drawStringUnderlineCharAt(
g, text, mnemonicIndex, info.textRect.x, info.textRect.y + fm.getAscent());
g.setColor(info.button.getBackground().darker());
BasicGraphicsUtils.drawStringUnderlineCharAt(
g, text, mnemonicIndex, info.textRect.x - 1, info.textRect.y + fm.getAscent() - 1);
}
}
public void paint(Graphics g) {
super.paint(g);
Graphics2D g2D = (Graphics2D) g;
int x = this.getWidth();
int y = this.getHeight();
int z = 4;
if (orientation.equals(DesktopBar.WEST)) {
int[] X = {x - z, x - z, 2 * x / 5, x / 2, z, x / 2, 2 * x / 5};
int[] Y = {2 * y / 5, 3 * y / 5, 3 * y / 5, y - z, y / 2, z, 2 * y / 5};
g2D.draw(new Polygon(X, Y, 7));
}
if (orientation.equals(DesktopBar.EAST)) {
int[] X = {z, z, 2 * x / 3, x / 2, x - z, x / 2, 2 * x / 3};
int[] Y = {2 * y / 5, 3 * y / 5, 3 * y / 5, y - z, y / 2, z, 2 * y / 5};
g2D.draw(new Polygon(X, Y, 7));
}
if (orientation.equals(DesktopBar.NORTH)) {
int[] X = {2 * x / 5, 3 * x / 5, 3 * x / 5, x - z, x / 2, z, 2 * x / 5};
int[] Y = {y - z, y - z, 2 * y / 5, y / 2, z, y / 2, 2 * y / 5};
g2D.draw(new Polygon(X, Y, 7));
}
if (orientation.equals(DesktopBar.SOUTH)) {
int[] X = {2 * x / 5, 3 * x / 5, 3 * x / 5, x - z, x / 2, z, 2 * x / 5};
int[] Y = {z, z, 2 * y / 3, y / 2, y - z, y / 2, 2 * y / 3};
g2D.draw(new Polygon(X, Y, 7));
}
}
private static Image getImage(ResizableIcon icon, int size) {
icon.setDimension(new Dimension(size, size));
if (icon instanceof AsynchronousLoading) {
AsynchronousLoading async = (AsynchronousLoading) icon;
if (async.isLoading()) {
final CountDownLatch latch = new CountDownLatch(1);
final boolean[] status = new boolean[1];
AsynchronousLoadListener all =
new AsynchronousLoadListener() {
@Override
public void completed(boolean success) {
status[0] = success;
latch.countDown();
}
};
async.addAsynchronousLoadListener(all);
try {
latch.await();
} catch (InterruptedException ignored) {
}
async.removeAsynchronousLoadListener(all);
if (!status[0]) {
return null;
}
if (async.isLoading()) {
return null;
}
}
}
Image result = FlamingoUtilities.getBlankImage(size, size);
Graphics2D g2d = (Graphics2D) result.getGraphics().create();
icon.paintIcon(null, g2d, 0, 0);
g2d.dispose();
return result;
}
/** paint the canvas into a image file of given width and height */
public void writeToImage(String s, int w, int h) {
String ext;
File f;
try {
ext = s.substring(s.lastIndexOf(".") + 1);
f = new File(s);
} catch (Exception e) {
System.out.println(e);
return;
}
if (!ext.equals("jpg") && !ext.equals("png")) {
System.out.println("Cannot write to file: Illegal extension " + ext);
return;
}
boolean opq = true;
if (theOpaque != null) opq = theOpaque;
BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setBackground(Color.white);
g2.setPaint(Color.black);
g2.setStroke(new BasicStroke(1));
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
doBuffer(g2, true, new Rectangle(0, 0, w, h));
try {
ImageIO.write(image, ext, f);
} catch (Exception e) {
System.out.println(e);
}
}
/**
* Override the pain method do draw the axis lines
*
* @param g The graphics to paint to
*/
public void paint(Graphics g) {
Rectangle b = getBounds();
g.setColor(canvasBg);
g.fillRect(0, 0, b.width, b.height);
paintGrid(g);
Point center = getCenter();
if (g instanceof Graphics2D) {
((Graphics2D) g).translate(center.x, center.y);
}
super.paint(g);
if (g instanceof Graphics2D) {
((Graphics2D) g).scale(1.0, 1.0);
}
g.setColor(Color.gray);
g.drawLine(0, -10 * b.height, 0, 10 * b.height);
g.drawLine(-10 * b.width, 0, 10 * b.width, 0);
MetSymbol tmp = highlightedMetSymbol;
if (tmp != null) {
Rectangle tb = tmp.getBounds();
g.setColor(Color.red);
g.drawRect(tb.x - 2, tb.y - 2, tb.width + 4, tb.height + 4);
}
}
private static BufferedImage makeBufferedImage(Icon icon, int w, int h) {
BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
Graphics2D g = image.createGraphics();
icon.paintIcon(null, g, (w - icon.getIconWidth()) / 2, (h - icon.getIconWidth()) / 2);
g.dispose();
return image;
}
/**
* All purpose paint method that should do the right thing for all linear bouncing-box progress
* bars. Override this if you are making another kind of progress bar.
*
* @see #paintDeterminate
* @since 1.4
*/
protected void paintIndeterminate(Graphics g, JComponent c) {
if (!(g instanceof Graphics2D)) {
return;
}
Insets b = progressBar.getInsets(); // area for border
int barRectWidth = progressBar.getWidth() - (b.right + b.left);
int barRectHeight = progressBar.getHeight() - (b.top + b.bottom);
if (barRectWidth <= 0 || barRectHeight <= 0) {
return;
}
Graphics2D g2 = (Graphics2D) g;
// Paint the bouncing box.
boxRect = getBox(boxRect);
if (boxRect != null) {
g2.setColor(progressBar.getForeground());
g2.fillRect(boxRect.x, boxRect.y, boxRect.width, boxRect.height);
}
// Deal with possible text painting
if (progressBar.isStringPainted()) {
if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
paintString(g2, b.left, b.top, barRectWidth, barRectHeight, boxRect.x, boxRect.width, b);
} else {
paintString(g2, b.left, b.top, barRectWidth, barRectHeight, boxRect.y, boxRect.height, b);
}
}
}
@Override
public int print(Graphics g, PageFormat pf, int page) throws PrinterException {
if (page > 0) {
return NO_SUCH_PAGE;
}
int i = pf.getOrientation();
// get the size of the page
double pageWidth = pf.getImageableWidth();
double pageHeight = pf.getImageableHeight();
double myWidth = this.getWidth(); // - borderWidth * 2;
double myHeight = this.getHeight(); // - borderWidth * 2;
double scaleX = pageWidth / myWidth;
double scaleY = pageHeight / myHeight;
double minScale = Math.min(scaleX, scaleY);
Graphics2D g2d = (Graphics2D) g;
g2d.translate(pf.getImageableX(), pf.getImageableY());
g2d.scale(minScale, minScale);
drawPlot(g);
return PAGE_EXISTS;
}
protected void paintComponent(Graphics g2) {
super.paintComponent(g2);
Graphics2D g = (Graphics2D) g2;
test.draw(g2, 0, 0);
// Shape triangle = new Polygon(new int[] {15, 20, 10}, new int[] {0, 10, 10}, 3);
Shape square = new Rectangle2D.Double(0, 0, 30, 30);
g.setColor(Color.white);
g.translate(20, 20);
// g.rotate(theta, 10, 10);
// g.fill(star);
// g.setColor(new Color(0, 86, 141));
// g.fill(square);
if (star2 != null) g.fill(star2);
// Graphics2D g3 = (Graphics2D) g;
// 3.fill(star);
// g.setStroke(new BasicStroke(1));
// g.translate(x, y);
// g.draw(line);
// g.draw(line2);
}
public static void saveJPG(Image img, String s) {
BufferedImage bi =
new BufferedImage(img.getWidth(null), img.getHeight(null), BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = bi.createGraphics();
g2.drawImage(img, null, null);
FileOutputStream out = null;
try {
out = new FileOutputStream(s);
} catch (java.io.FileNotFoundException io) {
System.out.println("File Not Found");
}
JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(bi);
param.setQuality(0.5f, false);
encoder.setJPEGEncodeParam(param);
try {
encoder.encode(bi);
out.close();
} catch (java.io.IOException io) {
System.out.println("IOException");
}
}
// draw on screen
public synchronized void draw(Graphics2D g) {
Window w = s.getFullScreenWindow();
g.setColor(w.getBackground());
g.fillRect(0, 0, s.getWidth(), s.getHeight());
g.setColor(w.getForeground());
g.drawString(mess, 100, 100);
}
/**
* Write the given text string in the current font, centered on (x, y) and rotated by the
* specified number of degrees
*
* @param x the center x-coordinate of the text
* @param y the center y-coordinate of the text
* @param s the text
* @param degrees is the number of degrees to rotate counterclockwise
*/
public static void text(double x, double y, String s, double degrees) {
double xs = scaleX(x);
double ys = scaleY(y);
offscreen.rotate(Math.toRadians(-degrees), xs, ys);
text(x, y, s);
offscreen.rotate(Math.toRadians(+degrees), xs, ys);
}
public void drawTo(Graphics g, Line line) {
if (!calc.tileOnMap(t1) || !calc.tileOnMap(t2)) return;
if (calc.tileOnMap(line.getTile1()) && calc.tileOnMap(line.getTile2())) {
Point p1 = calc.tileToMinimap(t1);
Point p2 = calc.tileToMinimap(t2);
Point p3 = calc.tileToMinimap(line.getTile2());
Point p4 = calc.tileToMinimap(line.getTile1());
GeneralPath path = new GeneralPath();
path.moveTo(p1.x, p1.y);
path.lineTo(p2.x, p2.y);
path.lineTo(p3.x, p3.y);
path.lineTo(p4.x, p4.y);
path.closePath();
g.setColor(POLY_FILL);
((Graphics2D) g).fill(path);
((Graphics2D) g).draw(path);
}
Point last = null, p;
g.setColor(Color.ORANGE);
for (RSTile t : pathList) {
if (calc.tileOnMap(t)) {
p = calc.tileToMinimap(t);
g.fillOval(p.x - 2, p.y - 2, 5, 5);
if (last != null) g.drawLine(p.x, p.y, last.x, last.y);
last = p;
} else last = null;
}
}
// From: http://forum.java.sun.com/thread.jspa?threadID=378460&tstart=135
void drawArrow(
Graphics2D g2d,
int xCenter,
int yCenter,
int x,
int y,
float stroke,
BasicStroke drawStroke) {
double aDir = Math.atan2(xCenter - x, yCenter - y);
// Line can be dashed.
g2d.setStroke(drawStroke);
g2d.drawLine(x, y, xCenter, yCenter);
// make the arrow head solid even if dash pattern has been specified
g2d.setStroke(lineStroke);
Polygon tmpPoly = new Polygon();
int i1 = 12 + (int) (stroke * 2);
// make the arrow head the same size regardless of the length length
int i2 = 6 + (int) stroke;
tmpPoly.addPoint(x, y);
tmpPoly.addPoint(x + xCor(i1, aDir + .5), y + yCor(i1, aDir + .5));
tmpPoly.addPoint(x + xCor(i2, aDir), y + yCor(i2, aDir));
tmpPoly.addPoint(x + xCor(i1, aDir - .5), y + yCor(i1, aDir - .5));
tmpPoly.addPoint(x, y); // arrow tip
g2d.drawPolygon(tmpPoly);
// Remove this line to leave arrow head unpainted:
g2d.fillPolygon(tmpPoly);
}
void drawLine(Graphics g, DrawObject L) {
if (L == null) {
return;
}
if ((sequencingOn) && (L.sequenceNum != currentSequenceNumDisplay)) {
return;
}
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(L.drawStroke);
int x1 = (int) ((L.x - minX) / (maxX - minX) * (D.width - 2 * inset));
int y1 = (int) ((L.y - minY) / (maxY - minY) * (D.height - 2.0 * inset));
int x2 = (int) ((L.x2 - minX) / (maxX - minX) * (D.width - 2 * inset));
int y2 = (int) ((L.y2 - minY) / (maxY - minY) * (D.height - 2.0 * inset));
if (L.isArrow) {
drawArrow(
(Graphics2D) g,
inset + x1,
D.height - y1 - inset,
inset + x2,
D.height - y2 - inset,
1.0f,
L.drawStroke);
} else {
g.drawLine(inset + x1, D.height - y1 - inset, inset + x2, D.height - y2 - inset);
}
}
////////////////////////////////////////////////////////////////////////////
// Paint
//
public synchronized void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
// Graphics2D buffGraphics2 = (Graphics2D) buffGraphics;
// g2.drawImage(bImage, 3, 3, getWidth() - 3, getHeight() - 3,
// 0, 0, iWidth, iHeight, null);
g2.drawImage(bImage, 0, 0, iWidth, iHeight, null);
g2.drawString(String.valueOf(System.currentTimeMillis()), 10, 10);
}
public Image cutMeeple() {
_meeple = new ImageIcon("meeple.gif").getImage();
BufferedImage blankCanvas = new BufferedImage(80, 80, BufferedImage.TYPE_INT_ARGB);
Graphics2D g2 = (Graphics2D) blankCanvas.getGraphics();
g2.drawImage(_meeple, 0, 0, 80, 80, 130, 5, 174, 52, this);
return blankCanvas;
}
public static BufferedImage convertToARGB(BufferedImage image) {
BufferedImage newImage =
new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB);
Graphics2D g = newImage.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
return newImage;
}
