private Dimension getContainerDimensions(Graphics g, steps.array.bucket.Container c) {
int spacingWidth =
(int) g.getFontMetrics(g.getFont()).getStringBounds(CONTAINER_VALUE_SPACING, g).getHeight();
int totalWidth = spacingWidth;
int totalHeight = 0;
for (int i = 0; i < c.theValues.length; i++) {
totalHeight =
(int) g.getFontMetrics(g.getFont()).getStringBounds("" + c.theValues[0], g).getHeight()
* 2;
totalWidth +=
(int) g.getFontMetrics(g.getFont()).getStringBounds("" + c.theValues[i], g).getWidth();
totalWidth += spacingWidth;
}
return new Dimension(totalWidth, totalHeight);
}
/**
* Draws the specified string.
*
* @param g graphics reference
* @param s text
* @param x x coordinate
* @param y y coordinate
* @param w width
* @param fs font size
*/
public static void chopString(
final Graphics g, final byte[] s, final int x, final int y, final int w, final int fs) {
if (w < 12) return;
final int[] cw = fontWidths(g.getFont());
int j = s.length;
try {
int l = 0;
int fw = 0;
for (int k = 0; k < j; k += l) {
final int ww = width(g, cw, cp(s, k));
if (fw + ww >= w - 4) {
j = Math.max(1, k - l);
if (k > 1) fw -= width(g, cw, cp(s, k - 1));
g.drawString("..", x + fw, y + fs);
break;
}
fw += ww;
l = cl(s, k);
}
} catch (final Exception ex) {
Util.debug(ex);
}
g.drawString(string(s, 0, j), x, y + fs);
}
/**
* The function prints out key to jumpshot data.
*/
int print (Graphics g, int x, int y, int width, int height) {
Font f = g.getFont ();
FontMetrics fm = getToolkit ().getFontMetrics (f);
int charW = fm.stringWidth (" "), charH = fm.getHeight ();
int hgap1 = charW, hgap2 = 2 * charW, vgap = fm.getAscent ();
int rectW = 30, rectH = charH; //Dimensions of state rectangles
int xcord = x, ycord = y;
Enumeration enum = parent.stateDefs.elements ();
while (enum.hasMoreElements ()) {
RecDef s = (RecDef)enum.nextElement ();
if (s.stateVector.size () > 0) {
int strW = fm.stringWidth (s.description);
if ((xcord + rectW + hgap1 + strW) > (width + x)) {
xcord = x; ycord += (charH + vgap);
}
g.setColor (s.color);
g.fillRect (xcord, ycord, rectW, rectH);
g.setColor (Color.black);
g.drawRect (xcord, ycord, rectW - 1, rectH - 1);
g.drawString( s.description,
xcord + rectW + hgap1,
ycord + rectH - fm.getDescent () - 1);
xcord += (rectW + hgap1 + strW + hgap2);
}
}
return (ycord - y + (2 * charH));
}
/**
* Returns the width of the specified text. Cached font widths are used to speed up calculation.
*
* @param g graphics reference
* @param s string to be evaluated
* @return string width
*/
public static int width(final Graphics g, final byte[] s) {
final int[] cw = fontWidths(g.getFont());
final int l = s.length;
int fw = 0;
try {
// ignore faulty character sets
for (int k = 0; k < l; k += cl(s, k)) fw += width(g, cw, cp(s, k));
} catch (final Exception ex) {
Util.debug(ex);
}
return fw;
}
private void drawContainer(steps.array.bucket.Container c, Graphics g, int x, int y) {
// calculate the size of all the printed values
Dimension dims = getContainerDimensions(g, c);
int totalWidth = dims.width, totalHeight = dims.height;
String allValues = CONTAINER_VALUE_SPACING;
for (int i = 0; i < c.theValues.length; i++) {
allValues += c.theValues[i] + CONTAINER_VALUE_SPACING;
}
int textWidth =
(int) g.getFontMetrics(g.getFont()).getStringBounds("" + allValues, g).getWidth();
// draw a rectangle to fit them all
g.drawRoundRect(x, y, totalWidth, totalHeight, ARC_RADIUS, ARC_RADIUS);
// print the values in it
g.drawString(allValues, x + (totalWidth - textWidth) / 2, y + 3 * totalHeight / 4);
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D) g;
RenderingHints rh = g2d.getRenderingHints();
rh.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
g2d.setRenderingHints(rh);
// Background.
D = this.getSize();
g.setColor(backgroundColor);
g.fillRect(0, 0, D.width, D.height);
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(lineStroke);
// Axes, bounding box.
g.setColor(Color.gray);
g.drawLine(inset, D.height - inset, D.width - inset, D.height - inset);
g.drawLine(D.width - inset, inset, D.width - inset, D.height - inset);
g.drawLine(inset, inset, inset, D.height - inset);
g.drawLine(inset, inset, D.width - inset, inset);
double xDelta = (maxX - minX) / numIntervals;
// X-ticks and labels.
for (int i = 1; i <= numIntervals; i++) {
double xTickd = i * xDelta;
int xTick = (int) (xTickd / (maxX - minX) * (D.width - 2 * inset));
g.drawLine(inset + xTick, D.height - inset - 5, inset + xTick, D.height - inset + 5);
double x = minX + i * xDelta;
g.drawString(df.format(x), xTick + inset - 5, D.height - inset + 20);
}
// Y-ticks
double yDelta = (maxY - minY) / numIntervals;
for (int i = 0; i < numIntervals; i++) {
int yTick = (i + 1) * (int) ((D.height - 2 * inset) / (double) numIntervals);
g.drawLine(inset - 5, D.height - yTick - inset, inset + 5, D.height - yTick - inset);
double y = minY + (i + 1) * yDelta;
g.drawString(df.format(y), 1, D.height - yTick - inset);
}
// Zoom+move
Font savedFont = g.getFont();
g.setFont(plusFont);
g.drawString("+", D.width - 25, 20);
g.setFont(minusFont);
g.drawString("-", D.width - 25, 50);
drawArrow(g2d, D.width - 70, 20, D.width - 70, 0, 1.0f, lineStroke); // Up
drawArrow(g2d, D.width - 70, 30, D.width - 70, 50, 1.0f, lineStroke); // Down
drawArrow(g2d, D.width - 65, 25, D.width - 45, 25, 1.0f, lineStroke); // Right
drawArrow(g2d, D.width - 75, 25, D.width - 95, 25, 1.0f, lineStroke); // Left
g.setFont(savedFont);
// See if standard axes are in the middle.
g.setColor(Color.gray);
if ((minX < 0) && (maxX > 0) && (drawMiddleAxes)) {
// Draw y-axis
int x = (int) ((0 - minX) / (maxX - minX) * (D.width - 2 * inset));
g.drawLine(inset + x, D.height - inset, inset + x, inset);
}
if ((minY < 0) && (maxY > 0) && (drawMiddleAxes)) {
// Draw x-axis
int y = (int) ((0 - minY) / (maxY - minY) * (D.height - 2.0 * inset));
g.drawLine(inset, D.height - y - inset, D.width - inset, D.height - y - inset);
}
// Draw the objects.
drawObjects(g, points, lines, ovals, rectangles, images, labels, eqnLines);
if (animationMode) {
drawObjects(g, animPoints, animLines, animOvals, animRectangles, null, labels, eqnLines);
// No images in animation mode.
}
drawScribbles(g);
}
static void paintShadowTitle(
Graphics g,
String title,
int x,
int y,
Color frente,
Color shadow,
int desp,
int tipo,
int orientation) {
// Si hay que rotar la fuente, se rota
Font f = g.getFont();
if (orientation == SwingConstants.VERTICAL) {
AffineTransform rotate = AffineTransform.getRotateInstance(Math.PI / 2);
f = f.deriveFont(rotate);
}
// Si hay que pintar sombra, se hacen un monton de cosas
if (shadow != null) {
int matrix = (tipo == THIN ? MATRIX_THIN : MATRIX_FAT);
Rectangle2D rect = g.getFontMetrics().getStringBounds(title, g);
int w, h;
if (orientation == SwingConstants.HORIZONTAL) {
w = (int) rect.getWidth() + 6 * matrix; // Hay que dejar espacio para las sombras y el borde
h = (int) rect.getHeight() + 6 * matrix; // que ConvolveOp ignora por el EDGE_NO_OP
} else {
h = (int) rect.getWidth() + 6 * matrix; // Hay que dejar espacio para las sombras y el borde
w = (int) rect.getHeight() + 6 * matrix; // que ConvolveOp ignora por el EDGE_NO_OP
}
// La sombra del titulo
BufferedImage iTitulo = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
BufferedImage iSombra = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
Graphics2D g2 = iTitulo.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
g2.setFont(f);
g2.setColor(shadow);
g2.drawString(title, 3 * matrix, 3 * matrix); // La pintamos en el centro
ConvolveOp cop =
new ConvolveOp((tipo == THIN ? kernelThin : kernelFat), ConvolveOp.EDGE_NO_OP, null);
cop.filter(iTitulo, iSombra); // A ditorsionar
// Por fin, pintamos el jodio titulo
g.drawImage(
iSombra,
x - 3 * matrix + desp, // Lo llevamos a la posicion original y le sumamos 1
y - 3 * matrix + desp, // para que la sombra quede pelin desplazada
null);
}
// Si hay que pintar el frente, se pinta
if (frente != null) {
g.setFont(f);
g.setColor(frente);
g.drawString(title, x, y);
}
}
@Override
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g.setColor(Color.black);
g.fillRect(0, 0, getWidth(), getHeight());
for (Integer id : planetNames.keySet()) {
String name = planetNames.get(id);
Point p = planetCoordinates.get(id);
PartialPlanetBlock planet = getPlanet(id, -2);
g.setColor(Color.gray);
int rad = 3;
if (planet != null) {
rad = 6;
if (animatorFrame) {
Color col = colors.get(planet.owner);
if (col == null) col = Color.gray;
g.setColor(col);
} else {
if (planet.owner == settings.playerNr) g.setColor(Color.green);
else if (colorize.isSelected() && colors.get(planet.owner) != null)
g.setColor(colors.get(planet.owner));
else if (friends.contains(planet.owner)) g.setColor(Color.YELLOW);
else if (planet.owner >= 0) g.setColor(Color.red);
else rad = 3;
}
}
int x = convertX(p.x);
int y = convertY(p.y);
double virtualWidth = getWidth() * zoom / 100;
double virtualHeight = getHeight() * zoom / 100;
int xOffset = (int) (getWidth() - virtualWidth) / 2;
int yOffset = (int) (getHeight() - virtualHeight) / 2;
x = (int) (xOffset + x * zoom / 100.0 - mariginX * zoom / 100.0);
y = (int) (yOffset + y * zoom / 100.0 - mariginY * zoom / 100.0);
g.fillOval(x - rad / 2, y - rad / 2, rad, rad);
if (names.isSelected()) {
g.setFont(g.getFont().deriveFont((float) 10));
g.setColor(Color.gray);
int stringWidth = g.getFontMetrics().stringWidth(name);
g.drawString(name, x - stringWidth / 2, y + 12);
}
if (colorize.isSelected() || animatorFrame) {
int yy = 20;
g.setFont(g.getFont().deriveFont((float) 12));
for (PlayerBlock pb : GalaxyViewer.this.p.players) {
if (pb == null) continue;
Color col = colors.get(pb.playerNumber);
if (animatorFrame && col != null) ; // Ok
else if (pb.playerNumber == settings.playerNr) col = Color.green;
else if (col == null) col = Color.red;
g.setColor(col);
String n = new String(pb.nameBytes); // Does not work
n = "Player " + (pb.playerNumber + 1);
g.drawString(n, 5, yy);
// System.out.print(pb.playerNumber+": ");
// for (int t = 0; t < pb.nameBytes.length; t++){
// System.out.print((pb.nameBytes[t]&0xff)+" ");
// System.out.print((pb.nameBytes[t])+" ");
// }
// System.out.println();
yy += 14;
}
}
}
}
@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);
}
private void draw() {
Renderer renderer = ui.getRenderer();
Graphics g = renderer.getGraphics();
int fsize = g.getFont().getSize();
JPanel target = ui.getDrawTarget();
g.setColor(Color.GRAY);
g.fillRect(0, 0, target.getWidth(), target.getHeight());
Map<CabinType, Integer> xmap =
new HashMap<CabinType, Integer>() {
{
this.put(CabinType.LEFT, Floor.PIXEL_WIDTH + 10);
this.put(CabinType.RIGHT, Floor.PIXEL_WIDTH + 10 + Cabin.PIXEL_WIDTH + 30);
}
};
for (CabinType type : cabins.keySet()) {
Integer x = xmap.get(type);
Cabin cabin = cabins.get(type);
int passengers = cabin.getPassengers().size();
double cabinY = cabin.getPosition() * REAL_TO_PIXEL_RATIO,
cabinH = (double) cabin.PIXEL_HEIGHT,
cabinW = (double) cabin.PIXEL_WIDTH;
g.setColor(Color.WHITE);
g.fillRect(x, (int) cabinY, (int) cabinW, (int) cabinH);
g.setColor(Color.BLACK);
g.drawRect(x, (int) cabinY, (int) cabinW, (int) cabinH);
// cabin fullness
g.drawString(
passengers >= cabinLimitPeople ? passengers > cabinLimitPeople ? "초과" : "만원" : "",
(int) (x + cabinW / 2.0 - fsize),
(int) (cabinY + cabinH / 2.0 - fsize));
// passengers on cabin
g.drawString(
String.format("%d명", passengers),
(int) (x + cabinW / 2.0 - fsize * 2.0 / 2.0),
(int) (cabinY + cabinH / 2.0));
// cabin weight
g.drawString(String.format("%.0fkg", mass(cabin)), x, (int) (cabinY + cabinH / 2.0 + fsize));
// cabin speed
g.drawString(
String.format("%.1fm/s", Math.abs(cabin.getVelocity())),
x,
(int) (cabinY + cabinH / 2.0 + fsize * 2.0));
}
for (Floor floor : floors.values()) {
int passengers = floor.getPassengers().size();
double floorY = floor.getPosition() * REAL_TO_PIXEL_RATIO;
g.setFont(Font.getFont(Font.SANS_SERIF));
g.setColor(Color.WHITE);
g.fillRect(1, (int) floorY, Floor.PIXEL_WIDTH, Floor.PIXEL_HEIGHT);
g.setColor(Color.BLACK);
g.drawRect(1, (int) floorY, Floor.PIXEL_WIDTH, Floor.PIXEL_HEIGHT);
g.drawString(floor.getNum() + "층", 1, (int) floorY + 15);
g.drawString(
Integer.toString(passengers),
(int) (1 + (double) (Floor.PIXEL_WIDTH) / 2.0 - (double) fsize / 2.0),
(int) (floorY + (double) Floor.PIXEL_HEIGHT / 2.0));
}
if (state >> 1 == CircumstanceType.FIRE.state()) {
Floor firedFloor = (Floor) Circumstance.get(CircumstanceType.FIRE).getParameter("floor");
if (null != firedFloor)
g.drawString(
"화재",
Floor.PIXEL_WIDTH / 2 - fsize,
(int)
(firedFloor.getPosition() * REAL_TO_PIXEL_RATIO
+ (double) Floor.PIXEL_HEIGHT / 2.0
+ fsize * 2.0));
}
renderer.flush();
}
private void drawLayout(Graphics g) {
g.setColor(Color.blue);
g.drawRect(10, 10, width - 20, height - 20);
g.setColor(Color.red.brighter());
Iterator f = players.iterator();
int lifeDisplayPosition = 0;
while (f.hasNext()) {
Player h = (Player) f.next();
if (h.isActive()) {
lifeDisplayPosition++;
String lifeInformation = "Player " + lifeDisplayPosition + ": ";
for (int i = 0; i < h.getLives(); i++) {
lifeInformation += "\u2606";
}
g.drawString(lifeInformation, 20, lifeDisplayPosition * 40);
}
}
borders[2] = width - 20;
borders[3] = height - 20;
Iterator i = players.iterator();
Player p;
while (i.hasNext()) {
p = (Player) i.next();
if (p.isActive()
&& !countdownF
&& (p.getX() < borders[0]
|| p.getY() < borders[1]
|| p.getX() > borders[2]
|| p.getY() > borders[3])
&& (!p.getImmunity())) {
p.decLives(width / 2, height / 2);
p.setImmunity(true);
}
if (p.getLives() <= 0) {
if (p instanceof MouseControlledPlayer) {
MouseControlledPlayer m = (MouseControlledPlayer) p;
removeMouseListener(m);
removeMouseMotionListener(m);
} else if (p instanceof KeyboardControlledPlayer) {
KeyboardFocusManager.getCurrentKeyboardFocusManager()
.removeKeyEventDispatcher((KeyboardControlledPlayer) p);
}
i.remove();
for (int h = 0; h < 4; h++) {
if (deathLocation[h] == -1) {
deathLocation[h] = p.getX();
deathLocation[h + 1] = p.getY();
break;
}
}
}
}
if ((deathLocation[0] != -1) && (deathLocation[1] != -1)) {
g.drawLine(
deathLocation[0] - 15,
deathLocation[1] - 15,
deathLocation[0] + 15,
deathLocation[1] + 15);
g.drawLine(
deathLocation[0] + 15,
deathLocation[1] - 15,
deathLocation[0] - 15,
deathLocation[1] + 15);
}
if ((deathLocation[2] != -1) && (deathLocation[3] != -1)) {
g.drawLine(
deathLocation[2] - 15,
deathLocation[3] - 15,
deathLocation[2] + 15,
deathLocation[3] + 15);
g.drawLine(
deathLocation[2] + 15,
deathLocation[3] - 15,
deathLocation[2] - 15,
deathLocation[3] + 15);
}
if (!onePlayerAlive) {
Font old = g.getFont();
g.setFont(new Font("monospaced", Font.BOLD, 20));
g.setColor(Color.red.darker());
g.drawString("GAME OVER", width / 2 - 40, height / 2);
g.setFont(old);
g.setColor(Color.WHITE);
g.drawString("Score", width - 60, 25);
g.drawString(String.valueOf(score), width - 60, 40);
}
}
public void paint(Graphics g, JComponent comp) {
UIUtil.applyRenderingHints(g);
JMenu jMenu = (JMenu) comp;
ButtonModel buttonmodel = jMenu.getModel();
int mnemonicIndex = jMenu.getDisplayedMnemonicIndex();
Icon icon = getIcon();
Icon allowedIcon = getAllowedIcon();
Insets insets = comp.getInsets();
resetRects();
ourViewRect.setBounds(0, 0, jMenu.getWidth(), jMenu.getHeight());
ourViewRect.x += insets.left;
ourViewRect.y += insets.top;
ourViewRect.width -= insets.right + ourViewRect.x;
ourViewRect.height -= insets.bottom + ourViewRect.y;
Font font = g.getFont();
Font font1 = comp.getFont();
g.setFont(font1);
FontMetrics fontmetrics = g.getFontMetrics(font1);
String s1 =
layoutMenuItem(
fontmetrics,
jMenu.getText(),
icon,
allowedIcon,
arrowIcon,
jMenu.getVerticalAlignment(),
jMenu.getHorizontalAlignment(),
jMenu.getVerticalTextPosition(),
jMenu.getHorizontalTextPosition(),
ourViewRect,
ourIconRect,
ourTextRect,
ourAcceleratorRect,
ourCheckIconRect,
ourArrowIconRect,
jMenu.getText() != null ? defaultTextIconGap : 0,
defaultTextIconGap);
Color color2 = g.getColor();
if (comp.isOpaque()) {
g.setColor(jMenu.getBackground());
g.fillRect(0, 0, jMenu.getWidth(), jMenu.getHeight());
if (buttonmodel.isArmed() || buttonmodel.isSelected()) {
if (UIUtil.isUnderAquaLookAndFeel()) {
myAquaSelectedBackgroundPainter.paintBorder(
comp, g, 0, 0, jMenu.getWidth(), jMenu.getHeight());
} else {
g.setColor(selectionBackground);
if (allowedIcon != null) {
g.fillRect(k, 0, jMenu.getWidth() - k, jMenu.getHeight());
} else {
g.fillRect(0, 0, jMenu.getWidth(), jMenu.getHeight());
g.setColor(selectionBackground);
}
}
}
g.setColor(color2);
}
if (allowedIcon != null) {
if (buttonmodel.isArmed() || buttonmodel.isSelected()) {
g.setColor(selectionForeground);
} else {
g.setColor(jMenu.getForeground());
}
if (useCheckAndArrow()) {
allowedIcon.paintIcon(comp, g, ourCheckIconRect.x, ourCheckIconRect.y);
}
g.setColor(color2);
if (menuItem.isArmed()) {
drawIconBorder(g);
}
}
if (icon != null) {
if (!buttonmodel.isEnabled()) {
icon = jMenu.getDisabledIcon();
} else if (buttonmodel.isPressed() && buttonmodel.isArmed()) {
icon = jMenu.getPressedIcon();
if (icon == null) {
icon = jMenu.getIcon();
}
}
if (icon != null) {
icon.paintIcon(comp, g, ourIconRect.x, ourIconRect.y);
}
}
if (s1 != null && s1.length() > 0) {
if (buttonmodel.isEnabled()) {
if (buttonmodel.isArmed() || buttonmodel.isSelected()) {
g.setColor(selectionForeground);
} else {
g.setColor(jMenu.getForeground());
}
BasicGraphicsUtils.drawStringUnderlineCharAt(
g, s1, mnemonicIndex, ourTextRect.x, ourTextRect.y + fontmetrics.getAscent());
} else {
final Object disabledForeground = UIUtil.getMenuItemDisabledForeground();
if (disabledForeground instanceof Color) {
g.setColor((Color) disabledForeground);
BasicGraphicsUtils.drawStringUnderlineCharAt(
g, s1, mnemonicIndex, ourTextRect.x, ourTextRect.y + fontmetrics.getAscent());
} else {
g.setColor(jMenu.getBackground().brighter());
BasicGraphicsUtils.drawStringUnderlineCharAt(
g, s1, mnemonicIndex, ourTextRect.x, ourTextRect.y + fontmetrics.getAscent());
g.setColor(jMenu.getBackground().darker());
BasicGraphicsUtils.drawStringUnderlineCharAt(
g,
s1,
mnemonicIndex,
ourTextRect.x - 1,
(ourTextRect.y + fontmetrics.getAscent()) - 1);
}
}
}
if (arrowIcon != null) {
if (buttonmodel.isArmed() || buttonmodel.isSelected()) {
g.setColor(selectionForeground);
}
if (useCheckAndArrow()) {
try {
if (SystemInfo.isMac
&& myAquaInvertedArrowIcon != null
&& (buttonmodel.isArmed() || buttonmodel.isSelected())
&& UIUtil.isUnderAquaLookAndFeel()) {
myAquaInvertedArrowIcon.paintIcon(comp, g, ourArrowIconRect.x, ourArrowIconRect.y);
} else if (SystemInfo.isMac
&& myAquaDisabledArrowIcon != null
&& !buttonmodel.isEnabled()
&& UIUtil.isUnderAquaLookAndFeel()) {
myAquaDisabledArrowIcon.paintIcon(comp, g, ourArrowIconRect.x, ourArrowIconRect.y);
} else arrowIcon.paintIcon(comp, g, ourArrowIconRect.x, ourArrowIconRect.y);
} catch (NullPointerException npe) {
// GTKIconFactory$MenuArrowIcon.paintIcon since it doesn't expect to be given a null
// instead of SynthContext
// http://www.jetbrains.net/jira/browse/IDEADEV-22360
}
}
}
g.setColor(color2);
g.setFont(font);
}
