public void paint(Graphics g) {
if (g instanceof Graphics2D) {
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
}
super.paint(g);
}
// 重画时清除屏幕
public void paint(Graphics g) {
g.setColor(new Color(0, 0, 0));
g.fillRect(0, 0, getWidth(), getHeight());
Graphics2D g2d = (Graphics2D) g;
g2d.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
g.setColor(Color.WHITE);
g.setFont(new Font("Default", 40, 40));
g.drawString(m_prompt, 220, 250);
g2d.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
}
public void paintStroke(Graphics2D g, ButtonInfo info) {
if (isStrokePainted(info.button)) {
Paint strokeColor = fill.getStroke(info.button, info.fillBounds);
g.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_NORMALIZE);
if (isStrokeAntialiased()) {
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
} else {
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
}
g.setPaint(strokeColor);
g.draw(info.stroke);
}
}
/**
* Internal utility method that creates a new icon. Called after the user selects a new color, or
* when the size of the icon changes.
*/
private void updateIcon() {
BufferedImage image = new BufferedImage(iconWidth, iconHeight, BufferedImage.TYPE_INT_RGB);
Graphics2D g2d = (Graphics2D) image.getGraphics();
g2d.setColor(this.color);
// turn antialiasing off
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
// we want fast rendering
g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
g2d.fillRect(0, 0, iconWidth, iconHeight);
ImageIcon imageIcon = new ImageIcon(image);
this.setIcon(imageIcon);
g2d.dispose();
}
private void _update(Graphics2D graphics2D, JComponent jComponent) {
GFX ctx = new Java2DGFX(graphics2D);
graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
graphics2D.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
graphics2D.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
graphics2D.setRenderingHint(
RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);
// graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
// RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB);
ctx.setPaint(backgroundFill);
ctx.fillRect(0, 0, jComponent.getWidth(), jComponent.getHeight());
// draw the scene
root.draw(ctx);
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setColor(Color.white);
g2.fillRect(0, 0, getWidth(), getHeight());
AffineTransform at = new AffineTransform(0.5, 0, 0, -0.5, 30, getHeight() * 3 / 4);
g2.transform(at);
g2.setColor(Color.black);
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
// System.out.println("Showing="+showing);
if (showing != null) {
showing.draw(g2);
}
}
// Scaling relative to the center of the screen
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
if (bufferImage == null) {
bufferImage = createImage(getWidth(), getHeight());
bufferg = (Graphics2D) bufferImage.getGraphics();
updateAffineTransform();
preSize = getSize();
}
bufferg.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
bufferg.setTransform(new AffineTransform());
bufferg.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f));
bufferg.setColor(Color.WHITE);
bufferg.fillRect(0, 0, getWidth(), getHeight());
bufferg.setTransform(affineTransform);
Graphics2D g2d = bufferg;
if (ORIPA.doc.hasModel) {
g2d.setStroke(Config.STROKE_CUT);
if (Globals.modelDispMode == Constants.ModelDispMode.FILL_ALPHA) {
g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.1f));
}
drawModel(g2d);
g.drawImage(bufferImage, 0, 0, this);
}
}
/** 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
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D gfx = (Graphics2D) g;
gfx.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
// Clear screen
gfx.setColor(Constants.BACKGROUND_COLOR);
gfx.fillRect(0, 0, getWidth(), getHeight());
// Render next frame
grid.draw(gfx);
// Trace path line
if (tracing) {
gfx.setColor(Constants.PATH_COLOR);
gfx.setStroke(new BasicStroke(2));
for (int i = 1; i < pathLine.size(); i++) {
Coordinate p = pathLine.get(i - 1);
Coordinate n = pathLine.get(i);
gfx.drawLine(
(Constants.TILESIZE + Constants.MARGIN) * p.x
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN,
(Constants.TILESIZE + Constants.MARGIN) * p.y
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN,
(Constants.TILESIZE + Constants.MARGIN) * n.x
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN,
(Constants.TILESIZE + Constants.MARGIN) * n.y
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN);
}
}
}
public void paint(Graphics gOld) {
if (image == null || xsize != getSize().width || ysize != getSize().height) {
xsize = getSize().width;
ysize = getSize().height;
image = createImage(xsize, ysize);
g = (Graphics2D) image.getGraphics();
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
}
// fill background
g.setColor(Color.cyan);
g.fillRect(0, 0, xsize, ysize);
int x[] = {getX(0), getX(getWidth2()), getX(getWidth2()), getX(0), getX(0)};
int y[] = {getY(0), getY(0), getY(getHeight2()), getY(getHeight2()), getY(0)};
// fill border
g.setColor(Color.black);
g.fillPolygon(x, y, 4);
// draw border
g.setColor(Color.red);
g.drawPolyline(x, y, 5);
if (animateFirstTime) {
gOld.drawImage(image, 0, 0, null);
return;
}
if (gameOver) return;
g.drawImage(outerSpaceImage, getX(0), getY(0), getWidth2(), getHeight2(), this);
for (int index = 0; index < missile.length; index++) {
if (missile[index].active) {
g.setColor(Color.red);
drawCircle(getX(missile[index].xPos), getYNormal(missile[index].yPos), 90, .3, 1.5);
}
}
if (rocketRight) {
drawRocket(rocketImage, getX(rocketXPos), getYNormal(rocketYPos), 0.0, 2.0, 2.0);
} else {
drawRocket(rocketImage, getX(rocketXPos), getYNormal(rocketYPos), 0.0, -2.0, 2.0);
}
for (int index = 0; index < numStars; index++) {
g.setColor(Color.yellow);
if (starActive[index])
drawCircle(getX(starXPos[index]), getYNormal(starYPos[index]), 0, 1.5, 1.5);
}
g.setColor(Color.magenta);
g.setFont(new Font("Impact", Font.BOLD, 15));
g.drawString("Score: " + score, 10, 45);
g.setColor(Color.magenta);
g.setFont(new Font("Impact", Font.BOLD, 15));
g.drawString("HighScore: " + highScore, 300, 45);
g.setColor(Color.magenta);
g.setFont(new Font("Impact", Font.BOLD, 15));
g.drawString("Lives: " + rocketLife, 150, 45);
if (rocketLife == 0) {
g.setColor(Color.red);
g.setFont(new Font("Impact", Font.BOLD, 60));
g.drawString("GAME OVER", getX(getWidth2() / 6), getYNormal(getHeight2() / 2));
}
gOld.drawImage(image, 0, 0, null);
}
public void paint(Graphics g) {
super.paint(g);
Graphics2D g2 = (Graphics2D) g;
int size =
Math.min(
MAX_SIZE,
Math.min(
getWidth() - imagePadding.left - imagePadding.right,
getHeight() - imagePadding.top - imagePadding.bottom));
g2.translate(getWidth() / 2 - size / 2, getHeight() / 2 - size / 2);
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
Shape shape;
if (mode == ColorPicker.SAT || mode == ColorPicker.BRI) {
shape = new Ellipse2D.Float(0, 0, size, size);
} else {
Rectangle r = new Rectangle(0, 0, size, size);
shape = r;
}
if (hasFocus()) {
PaintUtils.paintFocus(g2, shape, 5);
}
if (!(shape instanceof Rectangle)) {
// paint a circular shadow
g2.translate(2, 2);
g2.setColor(new Color(0, 0, 0, 20));
g2.fill(new Ellipse2D.Float(-2, -2, size + 4, size + 4));
g2.setColor(new Color(0, 0, 0, 40));
g2.fill(new Ellipse2D.Float(-1, -1, size + 2, size + 2));
g2.setColor(new Color(0, 0, 0, 80));
g2.fill(new Ellipse2D.Float(0, 0, size, size));
g2.translate(-2, -2);
}
g2.drawImage(image, 0, 0, size, size, 0, 0, size, size, null);
if (shape instanceof Rectangle) {
Rectangle r = (Rectangle) shape;
PaintUtils.drawBevel(g2, r);
} else {
g2.setColor(new Color(0, 0, 0, 120));
g2.draw(shape);
}
g2.setColor(Color.white);
g2.setStroke(new BasicStroke(1));
g2.draw(new Ellipse2D.Float(point.x - 3, point.y - 3, 6, 6));
g2.setColor(Color.black);
g2.draw(new Ellipse2D.Float(point.x - 4, point.y - 4, 8, 8));
g.translate(-imagePadding.left, -imagePadding.top);
}
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);
}
@Override
public void paintIcon(Component c, Graphics g, int x, int y) {
Graphics2D g2 = (Graphics2D) g.create();
g2.translate(x, y);
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.setPaint(Color.ORANGE);
g2.fill(star);
g2.dispose();
}
public void paintBackground(Graphics2D g, ButtonInfo info) {
if (info.button.isContentAreaFilled()) {
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
Paint fillPaint = fill.getFill(info.button, info.fillBounds);
g.setPaint(fillPaint);
g.fill(info.fill);
}
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
// Turn on antialiasing.
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
drawBackground(g2);
drawImageMosaic(g2);
drawText(g2);
}
public static BufferedImage cropImage(BufferedImage bi, int x, int y, int w, int h) {
BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2.setPaint(Color.white);
g2.fillRect(0, 0, w, h);
g2.drawImage(bi, -x, -y, null); // this);
g2.dispose();
return image;
}
public static BufferedImage scaleImage(BufferedImage bi, double scale) {
int w1 = (int) (Math.round(scale * bi.getWidth()));
int h1 = (int) (Math.round(scale * bi.getHeight()));
BufferedImage image = new BufferedImage(w1, h1, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2.setPaint(Color.white);
g2.fillRect(0, 0, w1, h1);
g2.drawImage(bi, 0, 0, w1, h1, null); // this);
g2.dispose();
return image;
}
public static BufferedImage rotateImage(BufferedImage bi) {
int w = bi.getWidth();
int h = bi.getHeight();
BufferedImage image = new BufferedImage(h, w, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2.setPaint(Color.white); // getBackground());
g2.fillRect(0, 0, h, w);
g2.rotate(90 * Math.PI / 180);
g2.drawImage(bi, 0, -h, w, h, null); // this);
g2.dispose();
return image;
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
Dimension asz = this.getSize();
if (fullRefresh) {
g2.clearRect(0, 0, asz.width, asz.height);
fullRefresh = false;
}
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
big.setColor(Color.black);
offset.x = (int) (asz.width - iw) / 2;
offset.y = (int) (asz.height - ih) / 2;
big.drawImage(img, 0, 0, this);
big.setPaint(Color.red);
if ((rect.width > 0) && (rect.height > 0)) big.draw(rect);
if (selected == 1) shadeExt(big, 0, 0, 0, 64);
else if (selected == 2) {
shadeExt(big, 0, 0, 0, 255);
selected = 1;
}
g2.drawImage(bi, offset.x, offset.y, this);
}
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = ((Graphics2D) g);
g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
g2d.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
g2d.setRenderingHint(
RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_OFF);
g2d.setRenderingHint(
RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_SPEED);
g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
g2d.setColor(Color.BLACK);
g2d.fillRect(0, 0, getWidth(), getHeight());
if (bufferedImage != null) {
synchronized (LOCKER) {
g2d.drawImage(bufferedImage, transformCells, null);
}
}
// draw struct preview
if (structurePreview != null) {
Composite composite = g2d.getComposite();
g2d.setComposite(compositeStructPreview);
g2d.drawImage(structurePreview, previewTransform, null);
g2d.setComposite(composite);
}
// draw grid
if (transformCells.getScaleX() > SHOW_GRID_MIN_SCALE) {
Composite composite = g2d.getComposite();
g2d.setComposite(compositeGrid);
g2d.drawImage(bufferedImageGrid, transformGrid, null);
g2d.setComposite(composite);
}
// draw border for preview
if (structurePreview != null && Math.abs(transformCells.getScaleX()) >= 0.95) {
Shape shape = new Rectangle(0, 0, structurePreview.getWidth(), structurePreview.getHeight());
shape = previewTransform.createTransformedShape(shape);
g2d.setColor(Color.RED);
g2d.draw(shape);
}
// draw border
double x = transformCells.getTranslateX();
double y = transformCells.getTranslateY();
g2d.setColor(BORDER_COLOR);
g2d.setStroke(new BasicStroke(BORDER_WIDTH));
g2d.drawRect(
round(x - BORDER_WIDTH),
round(y - BORDER_WIDTH),
round(getAutomatonWidth() * transformCells.getScaleX() + 2 * BORDER_WIDTH),
round(getAutomatonHeight() * transformCells.getScaleY() + 2 * BORDER_WIDTH));
}
/**
* Draws this without refreshing steps.
*
* @param panel the drawing panel requesting the drawing
* @param _g the graphics context on which to draw
*/
public void drawMe(DrawingPanel panel, Graphics _g) {
// position and show inspector if requested during loading
if (inspectorX != Integer.MIN_VALUE
&& trackerPanel != null
&& trackerPanel.getTFrame() != null) {
positionInspector();
Runnable runner =
new Runnable() {
public void run() {
showInspector = false;
inspector.setVisible(true);
}
};
if (showInspector) SwingUtilities.invokeLater(runner);
}
if (isVisible() && isTraceVisible()) {
// draw trace only if fixed coords & (non-worldview or no ref frame)
TrackerPanel tPanel = (TrackerPanel) panel;
ImageCoordSystem coords = tPanel.getCoords(); // get active coords
boolean isRefFrame = coords instanceof ReferenceFrame;
if (isRefFrame) {
coords = ((ReferenceFrame) coords).getCoords();
}
boolean fixed = coords.isFixedAngle() && coords.isFixedOrigin() && coords.isFixedScale();
if (fixed && (!(tPanel instanceof WorldTView) || !isRefFrame)) {
trace.reset();
for (int i = 0; i < traceX.length; i++) {
if (Double.isNaN(traceX[i])) continue;
tracePt.setLocation(traceX[i], traceY[i]);
java.awt.Point p = tracePt.getScreenPosition(tPanel);
if (trace.getCurrentPoint() == null) trace.moveTo((float) p.getX(), (float) p.getY());
else trace.lineTo((float) p.getX(), (float) p.getY());
}
Graphics2D g2 = (Graphics2D) _g;
Color color = g2.getColor();
Stroke stroke = g2.getStroke();
g2.setColor(getFootprint().getColor());
g2.setStroke(traceStroke);
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
g2.draw(trace);
// restore original color and stroke
g2.setColor(color);
g2.setStroke(stroke);
}
}
super.draw(panel, _g);
}
@Override
public void paintIcon(Component c, Graphics g, int x, int y) {
Graphics2D g2 = (Graphics2D) g.create();
g2.setPaint(Objects.nonNull(c) ? c.getBackground() : Color.WHITE);
g2.fillRect(x, y, getIconWidth(), getIconHeight());
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.setColor(ELLIPSE_COLOR);
g2.translate(x, y);
int size = list.size();
for (int i = 0; i < size; i++) {
float alpha = isRunning ? (i + 1) / (float) size : .5f;
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
g2.fill(list.get(i));
}
// g2.translate(-x, -y);
g2.dispose();
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
((Graphics2D) g)
.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
Dimension theSize = getSize();
if (mColorListMode == VisualizationColor.cColorListModeCategories) {
int categories = mCategoryColorList.length;
if (categories <= cMaxEditableColors) {
int fieldWidth = (theSize.width - 2 * cBorder + cSpacing) / categories - cSpacing;
mRect = new Rectangle[categories];
for (int i = 0; i < categories; i++) {
mRect[i] =
new Rectangle(
cBorder + i * (fieldWidth + cSpacing),
cBorder,
fieldWidth,
theSize.height - 2 * cBorder);
drawColorButton(g, i);
}
} else {
final String message = "<too many colors to edit>";
g.setColor(Color.GRAY);
g.setFont(new Font("Arial", Font.BOLD, 13));
FontMetrics m = g.getFontMetrics();
g.drawString(
message,
(theSize.width - m.stringWidth(message)) / 2,
(theSize.height + m.getHeight()) / 2 - m.getDescent());
}
} else {
int size = theSize.height - 2 * cBorder;
int x1 = 2 * cBorder + size;
int x2 = theSize.width - 2 * cBorder - size;
mRect = new Rectangle[3];
mRect[0] = new Rectangle(cBorder, cBorder, size, size);
mRect[1] =
new Rectangle(
theSize.width - size - cBorder, theSize.height - size - cBorder, size, size);
mRect[cColorWedgeButton] = new Rectangle(x1, cBorder, x2 - x1, size);
drawColorButton(g, 0);
drawColorButton(g, 1);
drawColorButton(g, cColorWedgeButton);
}
}
@Override
protected void paintSafely(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2d.setPaint(
new GradientPaint(
0, 0, new Color(63, 63, 63), 0, textFormattedField.getHeight(), new Color(76, 76, 76)));
g2d.fillRect(0, 0, textFormattedField.getWidth(), textFormattedField.getHeight());
g2d.setPaint(
new GradientPaint(
0, 0, new Color(21, 21, 21), 0, textFormattedField.getHeight(), new Color(24, 24, 24)));
g2d.fillRect(1, 1, textFormattedField.getWidth() - 2, textFormattedField.getHeight() - 2);
g2d.setPaint(new Color(53, 53, 53));
g2d.fillRect(2, 2, textFormattedField.getWidth() - 4, textFormattedField.getHeight() - 4);
super.paintSafely(g);
}
public void paint(Graphics g) {
// repaint the whole transformer in case the view component was repainted
Rectangle clipBounds = g.getClipBounds();
if (clipBounds != null && !clipBounds.equals(visibleRect)) {
repaint();
}
// clear the background
g.setColor(getBackground());
g.fillRect(0, 0, getWidth(), getHeight());
if (view != null && at.getDeterminant() != 0) {
Graphics2D g2 = (Graphics2D) g.create();
Insets insets = getInsets();
Rectangle bounds = getBounds();
// don't forget about insets
bounds.x += insets.left;
bounds.y += insets.top;
bounds.width -= insets.left + insets.right;
bounds.height -= insets.top + insets.bottom;
double centerX1 = bounds.getCenterX();
double centerY1 = bounds.getCenterY();
Rectangle tb = getTransformedSize();
double centerX2 = tb.getCenterX();
double centerY2 = tb.getCenterY();
// set antialiasing by default
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
if (renderingHints != null) {
g2.addRenderingHints(renderingHints);
}
// translate it to the center of the view component again
double tx = centerX1 - centerX2 - getX();
double ty = centerY1 - centerY2 - getY();
g2.translate((int) tx, (int) ty);
g2.transform(at);
view.paint(g2);
g2.dispose();
}
// paint the border
paintBorder(g);
}
@Override
public final synchronized void render() {
final Graphics graphics = buffer.getDrawGraphics();
if (smoothScale) {
((Graphics2D) graphics)
.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
}
if (inFullScreen) {
graphics.setColor(Color.BLACK);
DisplayMode dm = gd.getDisplayMode();
int scrnheight = dm.getHeight();
int scrnwidth = dm.getWidth();
// don't ask why this needs to be done every frame,
// but it does b/c the canvas keeps resizing itself
canvas.setSize(scrnwidth, scrnheight);
graphics.fillRect(0, 0, scrnwidth, scrnheight);
if (PrefsSingleton.get().getBoolean("maintainAspect", true)) {
double scalefactor = getmaxscale(scrnwidth, scrnheight);
int height = (int) (NES_HEIGHT * scalefactor);
int width = (int) (256 * scalefactor * 1.1666667);
graphics.drawImage(
frame,
((scrnwidth / 2) - (width / 2)),
((scrnheight / 2) - (height / 2)),
width,
height,
null);
} else {
graphics.drawImage(frame, 0, 0, scrnwidth, scrnheight, null);
}
graphics.setColor(Color.DARK_GRAY);
graphics.drawString(this.getTitle(), 16, 16);
} else {
graphics.drawImage(
frame, 0, 0, NES_WIDTH * screenScaleFactor, NES_HEIGHT * screenScaleFactor, null);
}
graphics.dispose();
buffer.show();
}
protected void paintComponent(Graphics graphics) {
super.paintComponent(graphics);
Graphics2D g = (Graphics2D) graphics;
// If we are disabled, we don't draw our arrow, focus, and unstick
// decorations:
if (!isEnabled()) {
return;
}
Color oldColor = g.getColor();
RenderingHints oldHints = g.getRenderingHints();
g.setColor(Color.black);
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
if (isStuck()) {
paintHorizontalLine(g);
}
g.setRenderingHints(oldHints);
g.setColor(oldColor);
knobPainter.paint(g);
}
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
if (squares == null) {
initSquares();
}
// Draw squares.
g2.setPaint(Color.blue);
int t = 0;
for (int k = 0; k < ROW; k++) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 4; j++) {
s[t++] = squares[k][i][j];
// squares[k][i][j].draw(g2);
// System.out.println("K: "+k);
}
}
}
System.out.println("T: " + t);
for (int b = 0; b < 16000; b++) s[b].draw(g2);
}
public Example(BufferedImage image) {
// copy image
int width = image.getWidth();
int height = image.getHeight();
this.image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = this.image.createGraphics();
g2.drawImage(image, 0, 0, null);
g2.dispose();
// create icon
if (Math.max(width, height) > ICON_SIZE) {
double scale = Math.min((double) ICON_SIZE / width, (double) ICON_SIZE / height);
width *= scale;
height *= scale;
}
BufferedImage buf = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
g2 = buf.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2.drawImage(image, 0, 0, width, height, null);
g2.dispose();
this.icon = new ImageIcon(buf);
}
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g.setFont(new Font("TimesRoman", Font.PLAIN, 20));
super.paintComponent(g2);
// draw grid
for (int i = 0; i < BSIZE; i++) {
for (int j = 0; j < BSIZE; j++) {
hexmech.drawHex(i, j, g2);
}
}
// fill in hexes
for (int i = 0; i < BSIZE; i++) {
for (int j = 0; j < BSIZE; j++) {
// if (boardBiArray[i][j] < 0) hexmech.fillHex(i,j,COLOURONE,-boardBiArray[i][j],g2);
// if (boardBiArray[i][j] > 0) hexmech.fillHex(i,j,COLOURTWO, boardBiArray[i][j],g2);
hexmech.fillHex(i, j, boardBiArray[i][j], g2);
}
}
// g.setColor(Color.RED);
// g.drawLine(mPt.x,mPt.y, mPt.x,mPt.y);
}
