public void paint(Graphics g) {
if (!gameComplete) {
if (!initialPaintComplete) {
g.setColor(Color.WHITE);
g.fillRect(0, 0, MaxX, MaxY);
initialPaintComplete = true;
}
Graphics blockGraphics = blockBuffer.getGraphics();
Graphics padGraphics = padBuffer.getGraphics();
Graphics ballGraphics = ballBuffer.getGraphics();
Graphics ballPreviousGraphics = ballBufferPrevious.getGraphics();
ballPreviousGraphics.setColor(Color.WHITE);
ballPreviousGraphics.fillRect(0, 0, ballDiameter, ballDiameter);
g.drawImage(ballBufferPrevious, ballPreviousX, ballPreviousY, null);
ballGraphics.setColor(Color.BLUE);
ballGraphics.fillOval(0, 0, ballDiameter, ballDiameter); // whole line white
g.drawImage(ballBuffer, ballX, ballY, null);
ballGraphics.setColor(Color.RED);
ballGraphics.fillOval(4, 4, ballDiameter - 8, ballDiameter - 8); // whole line white
g.drawImage(ballBuffer, ballX, ballY, null);
padGraphics.setColor(Color.WHITE);
padGraphics.fillRect(0, 0, MaxX, blockHeight); // whole line white
padGraphics.setColor(Color.BLACK);
padLeft = padx - padLength / 2;
if (padLeft >= 0 && padx + padLength / 2 < MaxX) {
padGraphics.fillRoundRect(padLeft, 0, padLength, padHeight, padHeight, padHeight);
}
if (padLeft < 0) {
padGraphics.fillRoundRect(0, 0, padLength, padHeight, padHeight, padHeight);
} else if (padx + padLength / 2 >= MaxX) {
padGraphics.fillRoundRect(MaxX - padLength, 0, padLength, padHeight, padHeight, padHeight);
}
g.drawImage(padBuffer, 0, padTop, null);
// g.drawString(msg, 50, 50);
// Drawing Blocks
Iterator<Entry<String, Color>> it = blockMap.entrySet().iterator();
blockGraphics.setColor(Color.WHITE);
blockGraphics.fillRect(0, 0, blockSetWidth, blockSetHeight); // whole line white
while (it.hasNext()) {
Map.Entry<String, Color> pairs = (Map.Entry<String, Color>) it.next();
String coordinate = pairs.getKey();
blockGraphics.setColor(pairs.getValue());
blockGraphics.fillRect(
new Pair(coordinate).first, new Pair(coordinate).second, blockLength, blockHeight);
}
if (repaintBlocks) {
g.drawImage(blockBuffer, blockStartX, blockStartY, null);
if (--count < 0) repaintBlocks = false;
}
}
}
/** PaintComponent to draw everything. */
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
setBackground(Color.WHITE);
// If using images, use cool dragon background
if (useImages) g.drawImage(background, 0, 0, 310, 300, null);
// Use light gray to not overpower the background image
g.setColor(Color.LIGHT_GRAY);
for (int y = 1; y < ROWS; ++y)
g.fillRoundRect(0, cellSize * y - 4, (cellSize * COLS) - 1, 8, 8, 8);
for (int x = 1; x < COLS; ++x)
g.fillRoundRect(cellSize * x - 4, 0, 8, (cellSize * ROWS) - 1, 8, 8);
// Use graphics2d for when not using the images
Graphics2D g2d = (Graphics2D) g;
g2d.setStroke(new BasicStroke(4, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
for (int y = 0; y < ROWS; ++y) {
for (int x = 0; x < COLS; ++x) {
int x1 = x * cellSize + 16;
int y1 = y * cellSize + 16;
if (board[y][x] == Symbol.X) {
// use image if set to true, otherwise use g2d
// for thicker, better looking X's and O's
if (useImages) g.drawImage(imageX, x1, y1, 75, 75, null);
else {
g2d.setColor(PURPLE);
int x2 = (x + 1) * cellSize - 16;
int y2 = (y + 1) * cellSize - 16;
g2d.drawLine(x1, y1, x2, y2);
g2d.drawLine(x2, y1, x1, y2);
}
} else if (board[y][x] == Symbol.O) {
if (useImages) g.drawImage(imageO, x1, y1, 75, 75, null);
else {
g2d.setColor(Color.BLUE);
g2d.drawOval(x1, y1, 70, 70);
}
}
} // end for
}
// Set status bar based on gamestate. If CONTINUE, show whose turn it is
if (gameStatus == GameStatus.CONTINUE) {
statusBar.setForeground(Color.BLACK);
if (currentPlayer == Symbol.X) statusBar.setText("X's Turn");
else statusBar.setText("O's Turn");
} else if (gameStatus == GameStatus.DRAW) {
statusBar.setForeground(Color.RED);
statusBar.setText("Draw! Click to play again!");
} else if (gameStatus == GameStatus.X_WIN) {
statusBar.setForeground(Color.RED);
statusBar.setText("X has won! Click to play again!");
} else if (gameStatus == GameStatus.O_WIN) {
statusBar.setForeground(Color.RED);
statusBar.setText("O has won! Click to play again!");
}
}
public void Text(Graphics g) {
g.setColor(Color.black);
g.fillRoundRect(49, 69, 502, 512, 30, 30);
g.setColor(Color.white);
g.fillRoundRect(50, 70, 500, 510, 30, 30);
g.setColor(Color.black);
g.setFont(Ueberschrift);
g.drawString("Nicht invertierender Verstärker", 180, 100);
}
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
if (drawOverlay) {
g = g.create();
AntialiasingManager.activateAntialiasing(g);
try {
// Paint a roll over fade out.
FadeTracker fadeTracker = FadeTracker.getInstance();
float visibility = 0.0f;
if (fadeTracker.isTracked(this, FadeKind.ROLLOVER)) {
visibility = fadeTracker.getFade(this, FadeKind.ROLLOVER);
visibility /= 4;
} else visibility = 0.5f;
// Draw black overlay
g.setColor(new Color(0.0f, 0.0f, 0.0f, visibility));
g.fillRoundRect(1, 1, width - 2, height - 2, 10, 10);
// Draw arrow
g.setColor(Color.WHITE);
int[] arrowX = new int[] {width - 17, width - 7, width - 12};
int[] arrowY = new int[] {height - 12, height - 12, height - 7};
g.fillPolygon(arrowX, arrowY, arrowX.length);
} finally {
g.dispose();
}
}
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(kleur);
g.fillRoundRect(5, 5, 70, 70, 10, 10);
g.setColor(Color.black);
if (waarde == 1) {
g.fillOval(34, 34, 10, 10);
} else if (waarde == 2) {
g.fillOval(10, 10, 10, 10);
g.fillOval(60, 60, 10, 10);
} else if (waarde == 3) {
g.fillOval(10, 10, 10, 10);
g.fillOval(34, 34, 10, 10);
g.fillOval(60, 60, 10, 10);
} else if (waarde == 4) {
g.fillOval(10, 10, 10, 10);
g.fillOval(10, 60, 10, 10);
g.fillOval(60, 10, 10, 10);
g.fillOval(60, 60, 10, 10);
} else if (waarde == 5) {
g.fillOval(10, 10, 10, 10);
g.fillOval(10, 60, 10, 10);
g.fillOval(60, 10, 10, 10);
g.fillOval(60, 60, 10, 10);
g.fillOval(34, 34, 10, 10);
} else if (waarde == 6) {
g.fillOval(10, 10, 10, 10);
g.fillOval(10, 60, 10, 10);
g.fillOval(60, 10, 10, 10);
g.fillOval(60, 60, 10, 10);
g.fillOval(10, 34, 10, 10);
g.fillOval(60, 34, 10, 10);
} else ; // meer waarden zijn er niet
}
void drawRoiLabel(Graphics g, int index, Roi roi) {
Rectangle r = roi.getBounds();
int x = screenX(r.x);
int y = screenY(r.y);
double mag = getMagnification();
int width = (int) (r.width * mag);
int height = (int) (r.height * mag);
int size = width > 40 && height > 40 ? 12 : 9;
if (font != null) {
g.setFont(font);
size = font.getSize();
} else if (size == 12) g.setFont(largeFont);
else g.setFont(smallFont);
boolean drawingList = index >= LIST_OFFSET;
if (drawingList) index -= LIST_OFFSET;
String label = "" + (index + 1);
if (drawNames && roi.getName() != null) label = roi.getName();
FontMetrics metrics = g.getFontMetrics();
int w = metrics.stringWidth(label);
x = x + width / 2 - w / 2;
y = y + height / 2 + Math.max(size / 2, 6);
int h = metrics.getAscent() + metrics.getDescent();
if (bgColor != null) {
g.setColor(bgColor);
g.fillRoundRect(x - 1, y - h + 2, w + 1, h - 3, 5, 5);
}
if (!drawingList && labelRects != null && index < labelRects.length)
labelRects[index] = new Rectangle(x - 1, y - h + 2, w + 1, h);
g.setColor(labelColor);
g.drawString(label, x, y - 2);
g.setColor(defaultColor);
}
public void drawScorpion() {
buf.setColor(Color.red.darker());
buf.fillRoundRect(scorpX, scorpY, 10, 20, 7, 5);
if (scorpX >= 300) {
scorpX = 0;
scorp = false;
}
}
@Override
public void paintComponent(Graphics g) {
if (selected) {
g.setColor(selColor);
g.fillRoundRect(0, 0, getWidth(), getHeight(), getWidth() / 10, getHeight() / 10);
label.setForeground(Color.YELLOW);
} else label.setForeground(Color.WHITE);
super.paintComponent(g);
}
/** @{inheritDoc} */
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
g = g.create();
try {
AntialiasingManager.activateAntialiasing(g);
g.setColor(Color.DARK_GRAY);
g.fillRoundRect(0, 0, this.getWidth(), this.getHeight(), 10, 10);
} finally {
g.dispose();
}
}
/**
* Draw one die including the letter centered in the middle of the die. If highlight is true,
* we reverse the background and letter colors to highlight the die.
*/
public void paintComponent(Graphics g) {
super.paintComponent(g);
int centeredXOffset, centeredYOffset;
// Draw the blank die
g.setColor((isHighlighted) ? FACECOLOR : DIECOLOR);
g.fillRoundRect(0, 0, DIESIZE, DIESIZE, DIESIZE / 2, DIESIZE / 2);
// Outline the die with black
g.setColor(Color.black);
g.drawRoundRect(0, 0, DIESIZE, DIESIZE, DIESIZE / 2, DIESIZE / 2);
Graphics faceGraphics = faceLabel.getGraphics();
faceGraphics.setColor(isHighlighted ? DIECOLOR : FACECOLOR);
Color myColor = isHighlighted ? DIECOLOR : FACECOLOR;
faceLabel.setForeground(myColor);
faceLabel.setFont(FACEFONT);
faceLabel.setText(face);
}
public void paint(Graphics g) {
setBackground(Color.white);
g.setColor(Color.blue);
g.fillRoundRect(50, 50, 100, 200, 50, 50);
g.fillRoundRect(200, 50, 100, 100, 50, 50);
g.fillRoundRect(350, 50, 200, 100, 50, 50);
g.fillRoundRect(50, 300, 100, 200, 41, 97);
g.fillRoundRect(200, 300, 100, 100, 41, 97);
g.fillRoundRect(350, 300, 200, 100, 41, 97);
g.fillRoundRect(50, 550, 100, 200, 97, 41);
g.fillRoundRect(200, 550, 100, 100, 97, 41);
g.fillRoundRect(350, 550, 200, 100, 97, 41);
}
public void paint(Graphics g) {
Rectangle r = g.getClipBounds();
showStatus("x: " + r.x + " y: " + r.y + " w: " + r.width + " h: " + r.height);
for (int i = 0; i < numRects; i++) {
Point lhc = randomPoint(); // left hand corner
Dimension size = randomDimension();
g.setColor(colors[(int) (Math.random() * 10)]);
if (round) {
if (fill)
g.fillRoundRect(
lhc.x,
lhc.y,
size.width,
size.height,
(int) (Math.random() * 250),
(int) (Math.random() * 250));
else
g.drawRoundRect(
lhc.x,
lhc.y,
size.width,
size.height,
(int) (Math.random() * 250),
(int) (Math.random() * 250));
} else if (threeD) {
g.setColor(Color.lightGray);
if (fill) g.fill3DRect(lhc.x, lhc.y, size.width, size.height, raise);
else g.draw3DRect(lhc.x, lhc.y, size.width, size.height, raise);
} else {
if (fill) g.fillRect(lhc.x, lhc.y, size.width, size.height);
else g.drawRect(lhc.x, lhc.y, size.width, size.height);
}
raise = raise ? false : true;
}
}
// This class represents rectangle shapes with rounded corners.
// (Note that it uses the inherited version of the
// containsPoint(x,y) method, even though that is not perfectly
// accurate when (x,y) is near one of the corners.)
void draw(Graphics g) {
g.setColor(color);
g.fillRoundRect(left, top, width, height, width / 3, height / 3);
g.setColor(Color.black);
g.drawRoundRect(left, top, width, height, width / 3, height / 3);
}
