protected void paintComponent(Graphics g) {
super.paintComponent(g);
Dimension d = getSize();
if (d.width != maxWidth || d.height != textHeight) recalculateDimension();
Insets insets = this.getInsets();
int y = 0;
if (verticalAlignment == TOP) {
y = insets.top + lineAscent;
} else if (verticalAlignment == CENTER) {
// These two are must musts:
y = insets.top + lineAscent;
// So far it looks like the TOP case, BUT:
int clientAreaHeight = d.height - insets.top - insets.bottom;
y = y + (clientAreaHeight - textHeight) / 2;
} else if (verticalAlignment == BOTTOM) {
int clientAreaBottom = d.height - insets.bottom;
y = clientAreaBottom - textHeight;
y += lineAscent;
}
for (int i = 0; i < numLines; i++) {
int ha = getBidiHorizontalAlignment(horizontalAlignment);
int x = 0;
if (ha == LEFT) {
ha = getBidiHorizontalAlignment(textAlignment);
if (ha == LEFT) x = insets.left;
else if (ha == RIGHT) x = maxWidth - lineWidths[i] + insets.left;
else if (ha == CENTER) x = insets.left + (maxWidth - lineWidths[i]) / 2;
} else if (ha == RIGHT) {
ha = getBidiHorizontalAlignment(textAlignment);
if (ha == LEFT) x = d.width - maxWidth - insets.right;
else if (ha == RIGHT) x = d.width - lineWidths[i] - insets.right;
else if (ha == CENTER)
x = d.width - maxWidth - insets.right + (maxWidth - lineWidths[i]) / 2;
} else if (ha == CENTER) {
ha = getBidiHorizontalAlignment(textAlignment);
// Just imagine that ha=LEFT (much easier), and follow code
int clientAreaWidth = d.width - insets.left - insets.right;
if (ha == LEFT) x = insets.left + (clientAreaWidth - maxWidth) / 2;
else if (ha == RIGHT)
x = insets.left + (clientAreaWidth - maxWidth) / 2 + (maxWidth - lineWidths[i]);
else if (ha == CENTER) x = insets.left + (clientAreaWidth - lineWidths[i]) / 2;
}
x += btnMarginWidth;
g.drawString(lines[i], x, y);
y += lineHeight;
}
}
/** Paint this component, including its image. */
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.drawImage(
this.image.getImage(),
0,
0,
this.image.getImage().getWidth(null),
this.image.getImage().getHeight(null),
null);
}
/** [Internal] */
public void paintComponent(Graphics g) {
boolean opq = true;
if (theOpaque != null) opq = theOpaque;
super.setOpaque(opq);
// if(theBackground!=null)super.setBackground(theBackground);
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
Rectangle rt = getBounds();
rt.x = 0;
rt.y = 0;
doBuffer(g2, opq, rt);
chkFPS();
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
if (!text.equals("")) {
g2.translate(0, getSize().getHeight());
g2.rotate(-Math.PI / 2);
g2.setColor(Color.black);
g2.drawString(text, 20, 14);
g2.translate(0, -getSize().getHeight());
g2.transform(AffineTransform.getQuadrantRotateInstance(1));
}
}
/** Draws the game */
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
final Graphics2D g2 = (Graphics2D) g;
/** Draw all the non-falling blocks on the board. Non-OUTSIDE blocks have rounded corners. */
for (int row = 0; row < board.getHeight(); row++) {
for (int column = 0; column < board.getWidth(); column++) {
if (board.getSquareType(row, column) != SquareType.OUTSIDE) {
Shape tetrominoBlock =
new RoundRectangle2D.Double(
column * SQUARE_WIDTH, row * SQUARE_HEIGHT, SQUARE_WIDTH, SQUARE_HEIGHT, 5, 5);
g2.setColor(SQUARE_COLOR.get(board.getSquareType(row, column)));
g2.fill(tetrominoBlock);
g2.draw(tetrominoBlock);
} else {
Shape tetrominoBlock =
new Rectangle2D.Double(
column * SQUARE_WIDTH, row * SQUARE_HEIGHT, SQUARE_WIDTH, SQUARE_HEIGHT);
g2.setColor(SQUARE_COLOR.get(board.getSquareType(row, column)));
g2.fill(tetrominoBlock);
g2.draw(tetrominoBlock);
}
}
}
Poly tempPoly = board.getFalling();
if (tempPoly != null) {
for (int row = 0; row < tempPoly.getSize(); row++) {
for (int column = 0; column < tempPoly.getSize(); column++) {
if (tempPoly.getSquareType(row, column) != SquareType.EMPTY) {
Shape tetrominoBlock =
new RoundRectangle2D.Double(
(column + board.getFallingPosX()) * SQUARE_WIDTH,
(row + board.getFallingPosY()) * SQUARE_HEIGHT,
SQUARE_WIDTH,
SQUARE_HEIGHT,
5,
5);
g2.setColor(SQUARE_COLOR.get(tempPoly.getSquareType(row, column)));
g2.fill(tetrominoBlock);
g2.draw(tetrominoBlock);
}
}
}
}
}
@Override
protected void paintComponent(Graphics g1d) {
super.paintComponent(g1d);
Graphics2D g = (Graphics2D) g1d;
// Hintergrund weiß zeichnen
g.setColor(Color.WHITE);
g.fillRect(0, 0, getWidth(), getHeight());
// SceneRenderer den Rest machen lassen
synchronized (origin) {
zoom =
(Math.min(getWidth(), getHeight()) - 2 * defborder)
/ (2 * renderer.getData().getRadius());
origin = renderer.render(g, move, getWidth(), getHeight(), zoom);
}
}
@Override
protected void paintComponent(Graphics graphics) {
super.paintComponent(graphics);
if (active) {
graphics.setColor(new Color(199, 199, 199));
graphics.fillRect(0, 0, getWidth(), getHeight());
graphics.setColor(new Color(116, 116, 116));
graphics.drawRect(0, 0, getWidth() - 1, getHeight() - 1);
}
graphics.drawImage(
image,
paddingSize,
paddingSize,
getWidth() - 2 * paddingSize,
getHeight() - 2 * paddingSize,
this);
}
/** Consults the model to paint the game matrix. If model is null, draws a default text. */
@Override
public void paintComponent(final Graphics g) {
// Check if we have a running game
super.paintComponent(g);
g.setColor(this.getBackground());
g.fillRect(0, 0, getWidth(), getHeight());
if (this.model != null) {
// Draw all tiles by going over them x-wise and y-wise.
for (int i = 0; i < this.modelSize.width; i++) {
for (int j = 0; j < this.modelSize.height; j++) {
GameTile tile = this.model.getGameboardState(i, j);
tile.draw(g, i * this.tileSize.width, j * this.tileSize.height, this.tileSize);
}
}
} else {
g.setFont(new Font("Sans", Font.BOLD, 24));
g.setColor(Color.BLACK);
final char[] message = "No model chosen.".toCharArray();
g.drawChars(message, 0, message.length, 50, 50);
}
}
/* (non-Javadoc)
* @see javax.swing.JComponent#paintComponent(java.awt.Graphics)
*/
protected void paintComponent(Graphics arg0) {
// long time1 = System.currentTimeMillis();
try {
super.paintComponent(arg0);
if (this.isOpaque()) {
Rectangle clipBounds = arg0.getClipBounds();
arg0.setColor(this.getBackground());
arg0.fillRect(clipBounds.x, clipBounds.y, clipBounds.width, clipBounds.height);
}
this.rblock.paint(arg0);
// Paint FrameContext selection
RenderablePoint start = this.startSelection;
RenderablePoint end = this.endSelection;
if (start != null && end != null && !start.equals(end)) {
this.rblock.paintSelection(arg0, false, start, end);
}
} finally {
// long time2 = System.currentTimeMillis();
// System.out.println("NonScrollableHtmlPanel.paintComponent(): numRenderables=" +
// numRenderables + ",time=" + (time2 - time1) + " ms.");
}
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
renderParticles(g);
}
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
int width = getWidth() - rightMargin - leftMargin - 10;
int height = getHeight() - topMargin - bottomMargin;
if (width <= 0 || height <= 0) {
// not enough room to paint anything
return;
}
Color oldColor = g.getColor();
Font oldFont = g.getFont();
Color fg = getForeground();
Color bg = getBackground();
boolean bgIsLight = (bg.getRed() > 200 && bg.getGreen() > 200 && bg.getBlue() > 200);
((Graphics2D) g)
.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
if (smallFont == null) {
smallFont = oldFont.deriveFont(9.0F);
}
r.x = leftMargin - 5;
r.y = topMargin - 8;
r.width = getWidth() - leftMargin - rightMargin;
r.height = getHeight() - topMargin - bottomMargin + 16;
if (border == null) {
// By setting colors here, we avoid recalculating them
// over and over.
border =
new BevelBorder(
BevelBorder.LOWERED,
getBackground().brighter().brighter(),
getBackground().brighter(),
getBackground().darker().darker(),
getBackground().darker());
}
border.paintBorder(this, g, r.x, r.y, r.width, r.height);
// Fill background color
g.setColor(bgColor);
g.fillRect(r.x + 2, r.y + 2, r.width - 4, r.height - 4);
g.setColor(oldColor);
long tMin = Long.MAX_VALUE;
long tMax = Long.MIN_VALUE;
long vMin = Long.MAX_VALUE;
long vMax = 1;
int w = getWidth() - rightMargin - leftMargin - 10;
int h = getHeight() - topMargin - bottomMargin;
if (times.size > 1) {
tMin = Math.min(tMin, times.time(0));
tMax = Math.max(tMax, times.time(times.size - 1));
}
long viewRangeMS;
if (viewRange > 0) {
viewRangeMS = viewRange * MINUTE;
} else {
// Display full time range, but no less than a minute
viewRangeMS = Math.max(tMax - tMin, 1 * MINUTE);
}
// Calculate min/max values
for (Sequence seq : seqs) {
if (seq.size > 0) {
for (int i = 0; i < seq.size; i++) {
if (seq.size == 1 || times.time(i) >= tMax - viewRangeMS) {
long val = seq.value(i);
if (val > Long.MIN_VALUE) {
vMax = Math.max(vMax, val);
vMin = Math.min(vMin, val);
}
}
}
} else {
vMin = 0L;
}
if (unit == Unit.BYTES || !seq.isPlotted) {
// We'll scale only to the first (main) value set.
// TODO: Use a separate property for this.
break;
}
}
// Normalize scale
vMax = normalizeMax(vMax);
if (vMin > 0) {
if (vMax / vMin > 4) {
vMin = 0;
} else {
vMin = normalizeMin(vMin);
}
}
g.setColor(fg);
// Axes
// Draw vertical axis
int x = leftMargin - 18;
int y = topMargin;
FontMetrics fm = g.getFontMetrics();
g.drawLine(x, y, x, y + h);
int n = 5;
if (("" + vMax).startsWith("2")) {
n = 4;
} else if (("" + vMax).startsWith("3")) {
n = 6;
} else if (("" + vMax).startsWith("4")) {
n = 4;
} else if (("" + vMax).startsWith("6")) {
n = 6;
} else if (("" + vMax).startsWith("7")) {
n = 7;
} else if (("" + vMax).startsWith("8")) {
n = 8;
} else if (("" + vMax).startsWith("9")) {
n = 3;
}
// Ticks
ArrayList<Long> tickValues = new ArrayList<Long>();
tickValues.add(vMin);
for (int i = 0; i < n; i++) {
long v = i * vMax / n;
if (v > vMin) {
tickValues.add(v);
}
}
tickValues.add(vMax);
n = tickValues.size();
String[] tickStrings = new String[n];
for (int i = 0; i < n; i++) {
long v = tickValues.get(i);
tickStrings[i] = getSizeString(v, vMax);
}
// Trim trailing decimal zeroes.
if (decimals > 0) {
boolean trimLast = true;
boolean removedDecimalPoint = false;
do {
for (String str : tickStrings) {
if (!(str.endsWith("0") || str.endsWith("."))) {
trimLast = false;
break;
}
}
if (trimLast) {
if (tickStrings[0].endsWith(".")) {
removedDecimalPoint = true;
}
for (int i = 0; i < n; i++) {
String str = tickStrings[i];
tickStrings[i] = str.substring(0, str.length() - 1);
}
}
} while (trimLast && !removedDecimalPoint);
}
// Draw ticks
int lastY = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
long v = tickValues.get(i);
y = topMargin + h - (int) (h * (v - vMin) / (vMax - vMin));
g.drawLine(x - 2, y, x + 2, y);
String s = tickStrings[i];
if (unit == Unit.PERCENT) {
s += "%";
}
int sx = x - 6 - fm.stringWidth(s);
if (y < lastY - 13) {
if (checkLeftMargin(sx)) {
// Wait for next repaint
return;
}
g.drawString(s, sx, y + 4);
}
// Draw horizontal grid line
g.setColor(Color.lightGray);
g.drawLine(r.x + 4, y, r.x + r.width - 4, y);
g.setColor(fg);
lastY = y;
}
// Draw horizontal axis
x = leftMargin;
y = topMargin + h + 15;
g.drawLine(x, y, x + w, y);
long t1 = tMax;
if (t1 <= 0L) {
// No data yet, so draw current time
t1 = System.currentTimeMillis();
}
long tz = timeDF.getTimeZone().getOffset(t1);
long tickInterval = calculateTickInterval(w, 40, viewRangeMS);
if (tickInterval > 3 * HOUR) {
tickInterval = calculateTickInterval(w, 80, viewRangeMS);
}
long t0 = tickInterval - (t1 - viewRangeMS + tz) % tickInterval;
while (t0 < viewRangeMS) {
x = leftMargin + (int) (w * t0 / viewRangeMS);
g.drawLine(x, y - 2, x, y + 2);
long t = t1 - viewRangeMS + t0;
String str = formatClockTime(t);
g.drawString(str, x, y + 16);
// if (tickInterval > (1 * HOUR) && t % (1 * DAY) == 0) {
if ((t + tz) % (1 * DAY) == 0) {
str = formatDate(t);
g.drawString(str, x, y + 27);
}
// Draw vertical grid line
g.setColor(Color.lightGray);
g.drawLine(x, topMargin, x, topMargin + h);
g.setColor(fg);
t0 += tickInterval;
}
// Plot values
int start = 0;
int nValues = 0;
int nLists = seqs.size();
if (nLists > 0) {
nValues = seqs.get(0).size;
}
if (nValues == 0) {
g.setColor(oldColor);
return;
} else {
Sequence seq = seqs.get(0);
// Find starting point
for (int p = 0; p < seq.size; p++) {
if (times.time(p) >= tMax - viewRangeMS) {
start = p;
break;
}
}
}
// Optimization: collapse plot of more than four values per pixel
int pointsPerPixel = (nValues - start) / w;
if (pointsPerPixel < 4) {
pointsPerPixel = 1;
}
// Draw graphs
// Loop backwards over sequences because the first needs to be painted on top
for (int i = nLists - 1; i >= 0; i--) {
int x0 = leftMargin;
int y0 = topMargin + h + 1;
Sequence seq = seqs.get(i);
if (seq.isPlotted && seq.size > 0) {
// Paint twice, with white and with color
for (int pass = 0; pass < 2; pass++) {
g.setColor((pass == 0) ? Color.white : seq.color);
int x1 = -1;
long v1 = -1;
for (int p = start; p < nValues; p += pointsPerPixel) {
// Make sure we get the last value
if (pointsPerPixel > 1 && p >= nValues - pointsPerPixel) {
p = nValues - 1;
}
int x2 = (int) (w * (times.time(p) - (t1 - viewRangeMS)) / viewRangeMS);
long v2 = seq.value(p);
if (v2 >= vMin && v2 <= vMax) {
int y2 = (int) (h * (v2 - vMin) / (vMax - vMin));
if (x1 >= 0 && v1 >= vMin && v1 <= vMax) {
int y1 = (int) (h * (v1 - vMin) / (vMax - vMin));
if (y1 == y2) {
// fillrect is much faster
g.fillRect(x0 + x1, y0 - y1 - pass, x2 - x1, 1);
} else {
Graphics2D g2d = (Graphics2D) g;
Stroke oldStroke = null;
if (seq.transitionStroke != null) {
oldStroke = g2d.getStroke();
g2d.setStroke(seq.transitionStroke);
}
g.drawLine(x0 + x1, y0 - y1 - pass, x0 + x2, y0 - y2 - pass);
if (oldStroke != null) {
g2d.setStroke(oldStroke);
}
}
}
}
x1 = x2;
v1 = v2;
}
}
// Current value
long v = seq.value(seq.size - 1);
if (v >= vMin && v <= vMax) {
if (bgIsLight) {
g.setColor(seq.color);
} else {
g.setColor(fg);
}
x = r.x + r.width + 2;
y = topMargin + h - (int) (h * (v - vMin) / (vMax - vMin));
// a small triangle/arrow
g.fillPolygon(new int[] {x + 2, x + 6, x + 6}, new int[] {y, y + 3, y - 3}, 3);
}
g.setColor(fg);
}
}
int[] valueStringSlots = new int[nLists];
for (int i = 0; i < nLists; i++) valueStringSlots[i] = -1;
for (int i = 0; i < nLists; i++) {
Sequence seq = seqs.get(i);
if (seq.isPlotted && seq.size > 0) {
// Draw current value
// TODO: collapse values if pointsPerPixel >= 4
long v = seq.value(seq.size - 1);
if (v >= vMin && v <= vMax) {
x = r.x + r.width + 2;
y = topMargin + h - (int) (h * (v - vMin) / (vMax - vMin));
int y2 = getValueStringSlot(valueStringSlots, y, 2 * 10, i);
g.setFont(smallFont);
if (bgIsLight) {
g.setColor(seq.color);
} else {
g.setColor(fg);
}
String curValue = getFormattedValue(v, true);
if (unit == Unit.PERCENT) {
curValue += "%";
}
int valWidth = fm.stringWidth(curValue);
String legend = (displayLegend ? seq.name : "");
int legendWidth = fm.stringWidth(legend);
if (checkRightMargin(valWidth) || checkRightMargin(legendWidth)) {
// Wait for next repaint
return;
}
g.drawString(legend, x + 17, Math.min(topMargin + h, y2 + 3 - 10));
g.drawString(curValue, x + 17, Math.min(topMargin + h + 10, y2 + 3));
// Maybe draw a short line to value
if (y2 > y + 3) {
g.drawLine(x + 9, y + 2, x + 14, y2);
} else if (y2 < y - 3) {
g.drawLine(x + 9, y - 2, x + 14, y2);
}
}
g.setFont(oldFont);
g.setColor(fg);
}
}
g.setColor(oldColor);
}
/**
* If the UI delegate is non-null, call its paint method. We pass the delegate a copy of the
* Graphics object to protect the rest of the paint code from irrevocable changes (e.g.
* Graphics.translate()).
*
* @see #paint
* @see #defaultPaintComponent
*/
protected void paintComponent(Graphics g) {
super.paintComponent(g);
defaultPaintComponent((Graphics2D) g);
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
}