public void paint(Graphics g) {
MetalBumps usedBumps;
if (splitPane.hasFocus()) {
usedBumps = focusBumps;
g.setColor(primaryControlColor);
} else {
usedBumps = bumps;
g.setColor(controlColor);
}
Rectangle clip = g.getClipBounds();
Insets insets = getInsets();
g.fillRect(clip.x, clip.y, clip.width, clip.height);
Dimension size = getSize();
size.width -= inset * 2;
size.height -= inset * 2;
int drawX = inset;
int drawY = inset;
if (insets != null) {
size.width -= (insets.left + insets.right);
size.height -= (insets.top + insets.bottom);
drawX += insets.left;
drawY += insets.top;
}
usedBumps.setBumpArea(size);
usedBumps.paintIcon(this, g, drawX, drawY);
super.paint(g);
}
protected void paintText(Graphics g, JComponent com, Rectangle rect, String s) {
JButtonLinkA bn = (JButtonLinkA) com;
ButtonModel bnModel = bn.getModel();
Color color = bn.getForeground();
Object obj = null;
if (bnModel.isEnabled()) {
if (bnModel.isPressed()) bn.setForeground(bn.getActiveLinkColor());
else if (bn.isLinkVisited()) bn.setForeground(bn.getVisitedLinkColor());
else bn.setForeground(bn.getLinkColor());
} else {
if (bn.getDisabledLinkColor() != null) bn.setForeground(bn.getDisabledLinkColor());
}
super.paintText(g, com, rect, s);
int behaviour = bn.getLinkBehavior();
boolean drawLine = false;
if (behaviour == JButtonLinkA.HOVER_UNDERLINE) {
if (bnModel.isRollover()) drawLine = true;
} else if (behaviour == JButtonLinkA.ALWAYS_UNDERLINE
|| behaviour == JButtonLinkA.SYSTEM_DEFAULT) drawLine = true;
if (!drawLine) return;
FontMetrics fm = g.getFontMetrics();
int x = rect.x + getTextShiftOffset();
int y = (rect.y + fm.getAscent() + fm.getDescent() + getTextShiftOffset()) - 1;
if (bnModel.isEnabled()) {
g.setColor(bn.getForeground());
g.drawLine(x, y, (x + rect.width) - 1, y);
} else {
g.setColor(bn.getBackground().brighter());
g.drawLine(x, y, (x + rect.width) - 1, y);
}
}
private void drawYTicks(Graphics g) {
int hPos = 0;
int pPos = 0;
for (int i = 0; i < yTicks; i++) {
int drawPos = yVal(hPos, maxH) + r;
if (hPos % hInc == 0) {
// draw line
g.setColor(Color.BLACK);
g.drawLine(padding - 10, drawPos, padding, drawPos);
// draw tick values for herbivores
g.setColor(Color.BLUE);
g.drawString("" + hPos, padding - 50, drawPos + r);
// draw tick values for predators
g.setColor(Color.RED);
g.drawString("" + pPos, padding - 50, drawPos + r + 20);
}
hPos += hInc;
pPos += pInc;
}
}
/** Overrides <code>Graphics.drawChars</code>. */
public void drawChars(char data[], int offset, int length, int x, int y) {
DebugGraphicsInfo info = info();
Font font = graphics.getFont();
if (debugLog()) {
info().log(toShortString() + " Drawing chars at " + new Point(x, y));
}
if (isDrawingBuffer()) {
if (debugBuffered()) {
Graphics debugGraphics = debugGraphics();
debugGraphics.drawChars(data, offset, length, x, y);
debugGraphics.dispose();
}
} else if (debugFlash()) {
Color oldColor = getColor();
int i, count = (info.flashCount * 2) - 1;
for (i = 0; i < count; i++) {
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
graphics.drawChars(data, offset, length, x, y);
Toolkit.getDefaultToolkit().sync();
sleep(info.flashTime);
}
graphics.setColor(oldColor);
}
graphics.drawChars(data, offset, length, x, y);
}
@Override
public void draw(Graphics g, GamePanel parent) {
int width = parent.getWidth() * 3 / 5;
tgs.getOPS().draw(g, parent);
g.setColor(new Color(255, 255, 255));
g.setFont(new Font("Rockwell", 0, 32));
g.fillRect(parent.getWidth() / 5, parent.getHeight() / 5, width, parent.getHeight() * 3 / 5);
g.setColor(Color.BLACK);
g.drawString(
name,
parent.getWidth() / 5 + width / 2 - g.getFontMetrics().stringWidth(name),
parent.getHeight() / 5 + g.getFontMetrics().getHeight());
for (int i = 0; i < abilities.length; i++) {
if (abilities[i] != null) {
g.drawString(
abilities[i],
parent.getWidth() / 5,
parent.getHeight() / 5 + g.getFontMetrics().getHeight() * (8 + i));
}
}
for (int i = 0; i < traits.length; i++) {
if (i == currentIndex) {
g.setColor(Color.RED);
} else {
g.setColor(Color.BLACK);
}
g.drawString(
traits[i],
parent.getWidth() / 5,
parent.getHeight() / 5 + g.getFontMetrics().getHeight() * (2 + i));
}
}
/** Overrides <code>Graphics.fill3DRect</code>. */
public void fill3DRect(int x, int y, int width, int height, boolean raised) {
DebugGraphicsInfo info = info();
if (debugLog()) {
info()
.log(
toShortString()
+ " Filling 3D rect: "
+ new Rectangle(x, y, width, height)
+ " Raised bezel: "
+ raised);
}
if (isDrawingBuffer()) {
if (debugBuffered()) {
Graphics debugGraphics = debugGraphics();
debugGraphics.fill3DRect(x, y, width, height, raised);
debugGraphics.dispose();
}
} else if (debugFlash()) {
Color oldColor = getColor();
int i, count = (info.flashCount * 2) - 1;
for (i = 0; i < count; i++) {
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
graphics.fill3DRect(x, y, width, height, raised);
Toolkit.getDefaultToolkit().sync();
sleep(info.flashTime);
}
graphics.setColor(oldColor);
}
graphics.fill3DRect(x, y, width, height, raised);
}
/** Overrides <code>Graphics.fillArc</code>. */
public void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
DebugGraphicsInfo info = info();
if (debugLog()) {
info()
.log(
toShortString()
+ " Filling arc: "
+ new Rectangle(x, y, width, height)
+ " startAngle: "
+ startAngle
+ " arcAngle: "
+ arcAngle);
}
if (isDrawingBuffer()) {
if (debugBuffered()) {
Graphics debugGraphics = debugGraphics();
debugGraphics.fillArc(x, y, width, height, startAngle, arcAngle);
debugGraphics.dispose();
}
} else if (debugFlash()) {
Color oldColor = getColor();
int i, count = (info.flashCount * 2) - 1;
for (i = 0; i < count; i++) {
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
graphics.fillArc(x, y, width, height, startAngle, arcAngle);
Toolkit.getDefaultToolkit().sync();
sleep(info.flashTime);
}
graphics.setColor(oldColor);
}
graphics.fillArc(x, y, width, height, startAngle, arcAngle);
}
public void render() {
BufferStrategy bs = getBufferStrategy();
if (bs == null) {
createBufferStrategy(3);
return;
}
Graphics g = bs.getDrawGraphics();
g.drawImage(image, 0, 0, getWidth(), getHeight(), this);
level.renderLevel(g);
getPlayer().render(g);
getInv().render(g);
if (showDebug) debug.render(g);
g.setColor(Color.WHITE);
g.fillRect(103, 0, 160, 33);
g.drawImage(getRes().toolMap, 103, 0, this);
g.setColor(Color.BLACK);
g.drawRect((Player.toolSelected * 32) + 71, 0, 32, 32);
// Draw tool selected at mouse location
g.drawImage(getRes().tools[Player.toolSelected - 1], mouseP.x, mouseP.y, this);
g.dispose();
bs.show();
}
// draws the button, based on the type of button (ImageIcon, Image, or String)
public void draw(Graphics g) {
if (visible) {
// if its image/imageicon, draw it
g.setColor(new Color(50, 200, 50));
g.fillRect(x - 1, y - 1, width + 2, height + 2);
if (mode.equals("Image") || mode.equals("ImageIcon")) {
if (enabled) {
g.drawImage(image, x, y, null);
} else {
g.drawImage(BWimage, x, y, null);
}
// if its string, draw the string
} else {
g.setFont(new Font("Arial", Font.PLAIN, 20));
if (enabled) {
g.setColor(Color.black);
g.drawString(message, x + 20, y + 20);
} else {
g.setColor(new Color(255, 255, 255));
g.fillRect(x - 1, y - 1, width + 2, height + 2);
g.setColor(Color.black);
g.drawString(message, x + 20, y + 20);
}
}
}
}
public void paint(Graphics g, int x, int y) {
if (tick > (TOTAL_SHOW - SHOW_BLINK)) {
if ((tick & 4) == 0) {
// Hide circle
} else {
int index = FADE_COUNT - tick - 1;
if (index < 0) {
index = 0;
}
final int d = 8;
g.setColor(OTHER_COLOR[index]);
g.fillOval(x - d, y - d, d * 2 + 1, d * 2 + 1);
}
}
if (tick < (TOTAL_SHOW - SHOW_BLINK) && tick > 0) {
g.setColor(Color.red);
int height = 13 * tick / TOTAL_SHOW;
g.fillRect(x - 6, 5 + y - height, 2, height);
}
g.setColor(Color.black);
final int od = 3;
g.drawString(node.getID(), x + od * 2 + 3, y + 4);
g.fillOval(x - od, y - od, od * 2 + 1, od * 2 + 1);
}
@Override
protected void paintComponent(Graphics g) {
g.setColor(getBackground());
g.fillRect(0, 0, getWidth(), getHeight());
final String text = getText();
final int len = text.length();
int x;
if (centerText) {
x = (getWidth() - widthOfW * len) / 2 + 1;
} else {
x = 5;
}
int y = (getHeight() - fontHeight) / 2 + fontAscent;
Graphics2D g2d = (Graphics2D) g;
Object oldHints = null;
if (desktopAAHints != null) {
oldHints = g2d.getRenderingHints();
g2d.addRenderingHints(desktopAAHints);
}
g.setColor(getForeground());
g2d.drawString(text, x, y);
// Restore rendering hints appropriately.
if (desktopAAHints != null) {
g2d.addRenderingHints((Map) oldHints);
}
// separator
g.setColor(Color.GRAY);
g.drawLine(0, 0, 0, getHeight());
}
/**
* Draws a simple 3d border for the given component.
*
* @param c The component to draw its border.
* @param g The graphics context.
* @param x The x coordinate of the top left corner.
* @param y The y coordinate of the top left corner.
* @param w The width.
* @param h The height.
*/
public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
g.setColor(MetouiaLookAndFeel.getControlHighlight());
g.drawLine(0, 0, 0, h - 1);
g.setColor(MetouiaLookAndFeel.getControlShadow());
g.drawLine(0, h - 1, w - 1, h - 1);
}
/** Draw the rectangle at the specified location in the current color. */
public void paintIcon(Component c, Graphics g, int x, int y) {
g.setColor(color == null ? c.getBackground() : color);
g.fillRect(x, y, width, height);
g.setColor(Color.black);
// NB: This draws a rectangle width+1 by height+1:
g.drawRect(x, y, width, height);
}
/**
* Draw the LineSelection at its current location. It is the responsibility of the
* applet/application to draw the LineSelection at the appropriate times, e.g., inside the
* component's update() and/or paint() method. This gives maximum flexibility for double
* buffering, etc.
*
* @param g The Graphics context to use for drawing.
*/
public void draw(Graphics g) {
if (!isVisible()) {
return;
}
Color saveColor = g.getColor();
g.setColor(color);
if (thickness > 1) {
double ratio = ((double) thickness) / ((double) length());
double txdb = ratio * ((double) height) / 2.0;
int tx = txdb > 0 ? ((int) Math.ceil(txdb)) : ((int) Math.floor(txdb));
double tydb = -ratio * ((double) width) / 2.0;
int ty = tydb > 0 ? ((int) Math.ceil(tydb)) : ((int) Math.floor(tydb));
Point[] poly = new Point[4];
for (int i = 0; i < 4; i++) poly[i] = new Point(x, y);
poly[0].translate(tx, ty);
poly[1].translate(-tx, -ty);
poly[2].translate(width, height);
poly[2].translate(-tx, -ty);
poly[3].translate(width, height);
poly[3].translate(tx, ty);
Polygon polygon = new Polygon();
for (int i = 0; i < 4; i++) polygon.addPoint(poly[i].x, poly[i].y);
g.fillPolygon(polygon);
} else g.drawLine(x, y, x + width, y + height);
g.setColor(saveColor);
} // end draw
private void drawColorBar(Graphics g) {
int minimum, maximum, height;
minimum = 100;
maximum = 500;
height = 1;
int finalI = 0;
for (int i = 0; i < (maximum - minimum); i++) {
float f = 0.75f * i / (float) (maximum - minimum);
g.setColor(Color.getHSBColor(0.75f - f, 1.0f, 1.0f));
g.fillRect(getWidth() - 40, height * i + 50, 20, height);
finalI = i;
}
g.setColor(Color.BLACK);
g.drawString(
String.valueOf(this.opticalReturnPowerController.getMaxValue()),
getWidth() - 60,
48); // Max Value
g.drawString(
String.valueOf(this.opticalReturnPowerController.getMinValue()),
getWidth() - 60,
finalI + 63); // Min Value
}
public void paintPalette(Graphics g) {
boolean leftToRight = MetalUtils.isLeftToRight(frame);
int width = getWidth();
int height = getHeight();
if (paletteBumps == null) {
paletteBumps =
new MetalBumps(
0,
0,
MetalLookAndFeel.getPrimaryControlHighlight(),
MetalLookAndFeel.getPrimaryControlInfo(),
MetalLookAndFeel.getPrimaryControlShadow());
}
Color background = MetalLookAndFeel.getPrimaryControlShadow();
Color darkShadow = MetalLookAndFeel.getPrimaryControlDarkShadow();
g.setColor(background);
g.fillRect(0, 0, width, height);
g.setColor(darkShadow);
g.drawLine(0, height - 1, width, height - 1);
int xOffset = leftToRight ? 4 : buttonsWidth + 4;
int bumpLength = width - buttonsWidth - 2 * 4;
int bumpHeight = getHeight() - 4;
paletteBumps.setBumpArea(bumpLength, bumpHeight);
paletteBumps.paintIcon(this, g, xOffset, 2);
}
/** Overrides <code>Graphics.drawLine</code>. */
public void drawLine(int x1, int y1, int x2, int y2) {
DebugGraphicsInfo info = info();
if (debugLog()) {
info()
.log(
toShortString()
+ " Drawing line: from "
+ pointToString(x1, y1)
+ " to "
+ pointToString(x2, y2));
}
if (isDrawingBuffer()) {
if (debugBuffered()) {
Graphics debugGraphics = debugGraphics();
debugGraphics.drawLine(x1, y1, x2, y2);
debugGraphics.dispose();
}
} else if (debugFlash()) {
Color oldColor = getColor();
int i, count = (info.flashCount * 2) - 1;
for (i = 0; i < count; i++) {
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
graphics.drawLine(x1, y1, x2, y2);
Toolkit.getDefaultToolkit().sync();
sleep(info.flashTime);
}
graphics.setColor(oldColor);
}
graphics.drawLine(x1, y1, x2, y2);
}
public void paintComponent(Graphics g) {
g.setColor(new Color(0x8090ff));
g.fillRect(0, 0, level.length * 16, level.height * 16);
levelRenderer.render(g, 0);
g.setColor(Color.BLACK);
g.drawRect(xTile * 16 - 1, yTile * 16 - 1, 17, 17);
}
/** Overrides <code>Graphics.drawOval</code>. */
public void drawOval(int x, int y, int width, int height) {
DebugGraphicsInfo info = info();
if (debugLog()) {
info().log(toShortString() + " Drawing oval: " + new Rectangle(x, y, width, height));
}
if (isDrawingBuffer()) {
if (debugBuffered()) {
Graphics debugGraphics = debugGraphics();
debugGraphics.drawOval(x, y, width, height);
debugGraphics.dispose();
}
} else if (debugFlash()) {
Color oldColor = getColor();
int i, count = (info.flashCount * 2) - 1;
for (i = 0; i < count; i++) {
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
graphics.drawOval(x, y, width, height);
Toolkit.getDefaultToolkit().sync();
sleep(info.flashTime);
}
graphics.setColor(oldColor);
}
graphics.drawOval(x, y, width, height);
}
@Override
public void paintDeterminate(Graphics g, JComponent c) {
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;
}
// int cellLength = getCellLength();
// int cellSpacing = getCellSpacing();
// amount of progress to draw
int amountFull = getAmountFull(b, barRectWidth, barRectHeight);
// draw the cells
if (progressBar.getOrientation() == SwingConstants.HORIZONTAL) {
float x = amountFull / (float) barRectWidth;
g.setColor(getColorFromPallet(pallet, x));
g.fillRect(b.left, b.top, amountFull, barRectHeight);
} else { // VERTICAL
float y = amountFull / (float) barRectHeight;
g.setColor(getColorFromPallet(pallet, y));
g.fillRect(b.left, barRectHeight + b.bottom - amountFull, barRectWidth, amountFull);
}
// Deal with possible text painting
if (progressBar.isStringPainted()) {
paintString(g, b.left, b.top, barRectWidth, barRectHeight, amountFull, b);
}
}
/** Overrides <code>Graphics.drawString</code>. */
public void drawString(AttributedCharacterIterator iterator, int x, int y) {
DebugGraphicsInfo info = info();
if (debugLog()) {
info().log(toShortString() + " Drawing text: \"" + iterator + "\" at: " + new Point(x, y));
}
if (isDrawingBuffer()) {
if (debugBuffered()) {
Graphics debugGraphics = debugGraphics();
debugGraphics.drawString(iterator, x, y);
debugGraphics.dispose();
}
} else if (debugFlash()) {
Color oldColor = getColor();
int i, count = (info.flashCount * 2) - 1;
for (i = 0; i < count; i++) {
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
graphics.drawString(iterator, x, y);
Toolkit.getDefaultToolkit().sync();
sleep(info.flashTime);
}
graphics.setColor(oldColor);
}
graphics.drawString(iterator, x, y);
}
@Test
public void testTranslatedImage() {
BufferedImage image = new BufferedImage(256, 256, BufferedImage.TYPE_BYTE_GRAY);
Graphics g = image.createGraphics();
g.setColor(Color.WHITE);
g.fillRect(236, 236, 20, 20);
g.setColor(new Color(80, 80, 80)); // A dark gray
g.fillRect(216, 216, 20, 20);
g.setColor(new Color(200, 200, 200)); // A light gray
g.fillRect(216, 236, 20, 20);
g.dispose();
image = image.getSubimage(128, 128, 128, 128);
CustomPaletteBuilder builder = new CustomPaletteBuilder(image, 256, 1, 1, 1);
RenderedImage indexed = builder.buildPalette().getIndexedImage();
assertTrue(indexed.getColorModel() instanceof IndexColorModel);
IndexColorModel icm = (IndexColorModel) indexed.getColorModel();
assertEquals(
4,
icm
.getMapSize()); // Black background, white fill, light gray fill, dark gray fill = 4
// colors
// check image not black
ImageWorker iw = new ImageWorker(indexed).forceComponentColorModel().intensity();
double[] mins = iw.getMinimums();
double[] maxs = iw.getMaximums();
boolean result = true;
for (int i = 0; i < mins.length; i++) {
result = mins[i] == maxs[i] ? false : result;
}
assertTrue(result);
}
protected void drawHistogram(Graphics g, MBinSummary binCnt) {
// ********************************
// * Draw the histogram
// ********************************
MClusterSummary[] bins;
int value;
int height;
int y;
Color color;
Font f = g.getFont();
Font newFont = new Font(UIManager.getFont("Label.font").getName(), Font.PLAIN, 14);
g.setFont(newFont);
bins = binCnt.GetBins();
// _maxBinsIndex
// ***********************
// draw the outliner even it is zero
// ***********************
value = bins[0].getCount();
height = (int) ((double) value * _pixel_per_unit);
y = _abs_line_height - height;
g.setColor(MColorMgr.GetInstance().GetColor(0, MGlobal.FADE_IDX_MAX));
g.fillRect(_bin_cur_x, y, (int) _bin_width, height);
g.setColor(Color.BLACK);
g.drawString(value + "", (int) _bin_cur_x, y - LABEL_HEIGHT);
g.drawString("0", (int) _bin_cur_x, _abs_axis_height);
_bin_cur_x += (int) _bin_width_two;
// ***********************
// * draw the rest
// ***********************
for (int idx = 1; idx <= binCnt.GetMaxBinIndex(); idx++) {
value = bins[idx].getCount();
if (value > 0) {
height = (int) ((double) value * _pixel_per_unit);
y = _abs_line_height - height;
g.setColor(MColorMgr.GetInstance().GetColor(idx, MGlobal.FADE_IDX_MAX));
g.fillRect(_bin_cur_x, y, (int) _bin_width, height);
g.setColor(Color.BLACK);
g.drawString(value + "", (int) _bin_cur_x, y - LABEL_HEIGHT);
g.drawString(idx + "", (int) _bin_cur_x, _abs_axis_height);
_bin_cur_x += (int) _bin_width_two;
}
}
g.setFont(f);
bins = null;
}
private Image createAuctionIcon(int width, int height) {
Image buffer = createImage(width, height);
Graphics canvas = buffer.getGraphics();
ArrayList<Integer> auctionColours = ((CTWorld) Simulator.pworld).getAuctionColours();
if ((auctionColours != null) && !auctionColours.isEmpty()) {
int blockWidth = width / auctionColours.size();
int offset = 0;
Iterator<Integer> iterator = auctionColours.iterator();
while (iterator.hasNext()) {
Integer auctionColour = iterator.next();
Color color = getColor(auctionColour);
canvas.setColor(color);
canvas.fillRect(offset, 0, blockWidth, height);
offset = offset + blockWidth;
}
} else {
canvas.setColor(getColor(CTWorld.NEUTRAL));
canvas.fillRect(0, 0, width, height);
}
return buffer;
}
// Show a message over frozen image in the display
public void showMessage(String message) {
Graphics g = getGraphics();
g.setColor(Color.black);
g.fillRect(30, (getHeight() / 2) - 16, message.length() * 10, 25);
g.setColor(Color.white);
g.drawString(message, 40, getHeight() / 2);
}
public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
JMenuItem b = (JMenuItem) c;
ButtonModel model = b.getModel();
Color borderColorLo = AbstractLookAndFeel.getFrameColor();
Color borderColorHi =
ColorHelper.brighter(AbstractLookAndFeel.getMenuSelectionBackgroundColor(), 40);
if (c.getParent() instanceof JMenuBar) {
if (model.isArmed() || model.isSelected()) {
g.setColor(borderColorLo);
g.drawLine(x, y, x + w - 1, y);
g.drawLine(x, y, x, y + h - 1);
g.drawLine(x + w - 1, y + 1, x + w - 1, y + h - 1);
g.setColor(borderColorHi);
g.drawLine(x + 1, y + 1, x + w - 2, y + 1);
g.drawLine(x + 1, y + 1, x + 1, y + h - 1);
}
} else {
if (model.isArmed() || (c instanceof JMenu && model.isSelected())) {
g.setColor(borderColorLo);
g.drawLine(x, y, x + w - 1, y);
g.drawLine(x, y + h - 1, x + w - 1, y + h - 1);
g.setColor(borderColorHi);
g.drawLine(x, y + 1, x + w - 2, y + 1);
}
}
}
public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
Color shadow = UIManager.getColor("controlShadow");
if (shadow == null) {
shadow = Color.GRAY;
}
Color lightShadow = new Color(shadow.getRed(), shadow.getGreen(), shadow.getBlue(), 170);
Color lighterShadow = new Color(shadow.getRed(), shadow.getGreen(), shadow.getBlue(), 70);
g.translate(x, y);
g.setColor(shadow);
g.fillRect(0, 0, w - 3, 1);
g.fillRect(0, 0, 1, h - 3);
g.fillRect(w - 3, 1, 1, h - 3);
g.fillRect(1, h - 3, w - 3, 1);
// Shadow line 1
g.setColor(lightShadow);
g.fillRect(w - 3, 0, 1, 1);
g.fillRect(0, h - 3, 1, 1);
g.fillRect(w - 2, 1, 1, h - 3);
g.fillRect(1, h - 2, w - 3, 1);
// Shadow line2
g.setColor(lighterShadow);
g.fillRect(w - 2, 0, 1, 1);
g.fillRect(0, h - 2, 1, 1);
g.fillRect(w - 2, h - 2, 1, 1);
g.fillRect(w - 1, 1, 1, h - 2);
g.fillRect(1, h - 1, w - 2, 1);
g.translate(-x, -y);
}
public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
if (((JToolBar) c).isFloatable()) {
Graphics2D g2D = (Graphics2D) g;
Composite savedComposite = g2D.getComposite();
AlphaComposite alpha = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f);
g2D.setComposite(alpha);
if (((JToolBar) c).getOrientation() == HORIZONTAL) {
if (!JTattooUtilities.isLeftToRight(c)) {
x += w - 15;
}
g.setColor(Color.white);
g.drawLine(x + 3, y + 4, x + 3, h - 5);
g.drawLine(x + 6, y + 3, x + 6, h - 4);
g.drawLine(x + 9, y + 4, x + 9, h - 5);
g.setColor(shadow);
g.drawLine(x + 4, y + 4, x + 4, h - 5);
g.drawLine(x + 7, y + 3, x + 7, h - 4);
g.drawLine(x + 10, y + 4, x + 10, h - 5);
} else {
// vertical
g.setColor(Color.white);
g.drawLine(x + 3, y + 3, w - 4, y + 3);
g.drawLine(x + 3, y + 6, w - 4, y + 6);
g.drawLine(x + 3, y + 9, w - 4, y + 9);
g.setColor(shadow);
g.drawLine(x + 3, y + 4, w - 4, y + 4);
g.drawLine(x + 3, y + 7, w - 4, y + 7);
g.drawLine(x + 3, y + 10, w - 4, y + 10);
}
g2D.setComposite(savedComposite);
}
}
/** Draws the lines and ball. */
public void drawScreen() {
BufferStrategy bf = this.getBufferStrategy();
Graphics g = null;
try {
g = bf.getDrawGraphics();
g.setColor(Color.black);
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(Color.GREEN);
g.drawOval(ballX, ballY, Ball.RADIUS * 2, Ball.RADIUS * 2);
for (int i = 0; i < lines.size(); i++) {
Line x = lines.get(i);
g.drawLine(x.x1, x.y1, x.x2, x.y2);
}
} finally {
g.dispose();
}
bf.show();
Toolkit.getDefaultToolkit().sync();
}
public void draw(Graphics g) {
animate();
g.setColor(Color.black);
g.fillRect(0, 0, dim.width, dim.height);
g.setColor(Color.white);
numpaint++;
DebugPrinter dbg = new DebugPrinter(g, 50, 60);
dbg.print(
"Spring-mass demo by yigal irani, drag balls or create new ones by clicking inside box");
dbg.print("frame", numpaint);
dbg.print("fps", 1 / timer.time_diff);
Point top_left = point_by_vec(new Vec(-1, 1));
g.draw3DRect(top_left.x, top_left.y, screen_dist(2), screen_dist(2), true);
for (int i = 0; i < springs.size(); i++) {
Spring spring = springs.get2(i);
Point p1 = point_by_vec(balls.get2(spring.start).pos);
Point p2 = point_by_vec(balls.get2(spring.end).pos);
g.drawLine(p1.x, p1.y, p2.x, p2.y);
}
for (int i = 0; i < balls.size(); i++) {
Ball ball = balls.get2(i);
Point p = point_by_vec(ball.pos);
int screen_radius = screen_dist(RADIUS);
g.setColor(Color.blue);
g.fillOval(p.x - screen_radius, p.y - screen_radius, screen_radius * 2, screen_radius * 2);
g.setColor(Color.white);
g.drawOval(p.x - screen_radius, p.y - screen_radius, screen_radius * 2, screen_radius * 2);
g.drawString("" + i, p.x, p.y);
}
}