void displayCharacterMap(Graphics g) {
if (currentChars != null) {
g.setColor(0xffffff);
g.fillRect(0, getHeight() - inputHeight - 2, getWidth(), inputHeight + 2);
g.setColor(0x000000);
g.drawLine(0, getHeight() - inputHeight - 2, getWidth(), getHeight() - inputHeight - 2);
for (int i = 0; i < currentChars.length; i++) {
char ch = currentChars[i];
if (isUppercase) {
ch = String.valueOf(currentChars[i]).toUpperCase().charAt(0);
}
// TODO: if i*12 > getWidth() ?
g.drawChar(ch, i * 12, getHeight() - inputHeight, Graphics.LEFT | Graphics.TOP);
if (currentChars[currentKeyStep] == currentChars[i]) {
g.drawRect(
i * 12 - 2,
getHeight() - inputHeight - 2,
inputFont.charWidth(ch) + 4,
inputHeight + 4);
}
}
}
}
/**
* Draw the vectors at the data points. If this data has been attached to an Axis then scale the
* data based on the axis maximum/minimum otherwise scale using the data's maximum/minimum
*
* @param g Graphics state
* @param bounds The data window to draw into
*/
public void draw_data(Graphics g, Rectangle bounds) {
Color c;
if (xaxis != null) {
xmax = xaxis.maximum;
xmin = xaxis.minimum;
}
if (yaxis != null) {
ymax = yaxis.maximum;
ymin = yaxis.minimum;
}
xrange = xmax - xmin;
yrange = ymax - ymin;
/*
** draw the legend before we clip the data window
*/
draw_legend(g, bounds);
/*
** Clip the data window
*/
if (clipping) g.clipRect(bounds.x, bounds.y, bounds.width, bounds.height);
c = g.getColor();
if (linecolor != null) g.setColor(linecolor);
else g.setColor(c);
drawVectors(g, bounds);
g.setColor(c);
}
public void paintIcon(Component c, Graphics g, int x, int y) {
Color color = c == null ? Color.GRAY : c.getBackground();
// In a compound sort, make each succesive triangle 20%
// smaller than the previous one.
int dx = (int) (size / 2 * Math.pow(0.8, priority));
int dy = descending ? dx : -dx;
// Align icon (roughly) with font baseline.
y = y + 5 * size / 6 + (descending ? -dy : 0);
int shift = descending ? 1 : -1;
g.translate(x, y);
// Right diagonal.
g.setColor(color.darker());
g.drawLine(dx / 2, dy, 0, 0);
g.drawLine(dx / 2, dy + shift, 0, shift);
// Left diagonal.
g.setColor(color.brighter());
g.drawLine(dx / 2, dy, dx, 0);
g.drawLine(dx / 2, dy + shift, dx, shift);
// Horizontal line.
if (descending) {
g.setColor(color.darker().darker());
} else {
g.setColor(color.brighter().brighter());
}
g.drawLine(dx, 0, 0, 0);
g.setColor(color);
g.translate(-x, -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;
}
}
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);
}
private void paintBell(Graphics g) {
P9TermPreferences preferences = P9Term.getPreferences();
if (preferences.getBoolean(P9TermPreferences.VISUAL_BELL) == false) {
return;
}
Color foreground = preferences.getColor(P9TermPreferences.FOREGROUND_COLOR);
if (preferences.getBoolean(P9TermPreferences.FANCY_BELL)) {
// On decent hardware, we can produce a really tasteful effect by compositing a
// semi-transparent rectangle over the terminal.
// We need to choose a color that will show up against the background.
// A reasonable assumption is that the user has already chosen such a color for the
// foreground.
Color color =
new Color(foreground.getRed(), foreground.getGreen(), foreground.getBlue(), 100);
g.setColor(color);
g.fillRect(0, 0, getWidth(), getHeight());
} else {
// On a remote X11 display (or really rubbish hardware) the compositing effect is
// prohibitively expensive, so we offer XOR instead.
Color background = preferences.getColor(P9TermPreferences.BACKGROUND_COLOR);
;
final int R = blend(background.getRed(), foreground.getRed());
final int G = blend(background.getGreen(), foreground.getGreen());
final int B = blend(background.getBlue(), foreground.getBlue());
g.setColor(background);
g.setXORMode(new Color(R, G, B));
g.fillRect(0, 0, getWidth(), getHeight());
g.setPaintMode();
}
}
/**
* Draw character in minimap
*
* @param g Graphics
* @param Dx X Displacement
* @param Dy Y Displacement
*/
public void MapDraw(Graphics g, int Dx, int Dy, double Scale, Color col) {
// Color
g.setColor(col.darker().darker().darker());
g.drawOval((int) (X * Scale + Dx), (int) (Y * Scale + Dy), 7, 7);
g.setColor(col);
g.fillOval((int) (X * Scale + Dx), (int) (Y * Scale + Dy), 7, 7);
}
private void drawSquare(Graphics g, int x, int y, Tetrominoes shape) {
int squareWidth = (int) getSize().getWidth() / model.getWidth();
int squareHeight = (int) getSize().getHeight() / model.getHeight();
Color colors[] = {
new Color(0, 0, 0),
new Color(204, 102, 102),
new Color(102, 204, 102),
new Color(102, 102, 204),
new Color(204, 204, 102),
new Color(204, 102, 204),
new Color(102, 204, 204),
new Color(218, 170, 0)
};
Color color = colors[shape.ordinal()];
g.setColor(color);
g.fillRect(x + 1, y + 1, squareWidth - 2, squareHeight - 2);
g.setColor(color.brighter());
g.drawLine(x, y + squareHeight - 1, x, y);
g.drawLine(x, y, x + squareWidth - 1, y);
g.setColor(color.darker());
g.drawLine(x + 1, y + squareHeight - 1, x + squareWidth - 1, y + squareHeight - 1);
g.drawLine(x + squareWidth - 1, y + squareHeight - 1, x + squareWidth - 1, y + 1);
}
private void displayTree(Graphics g, AVLTree.TreeNode root, int x, int y, int gap) {
if (root != null) {
// Display root
if (setOfHighlightedNodes.contains(root)) {
g.setColor(Color.GREEN);
g.fillOval(x - radius, y - radius, 2 * radius, 2 * radius);
g.setColor(Color.BLACK);
} else {
g.drawOval(x - radius, y - radius, 2 * radius, 2 * radius);
}
g.drawString(root.element + "", x - 6, y + 4);
// Draw a line to the left node
if (root.left != null) connectLeftChild(g, x - gap, y + virticalGap, x, y);
// Draw left subtree
displayTree(g, root.left, x - gap, y + virticalGap, gap / 2);
// Draw a line to the right node
if (root.right != null) connectRightChild(g, x + gap, y + virticalGap, x, y);
// Draw right subtree
displayTree(g, root.right, x + gap, y + virticalGap, gap / 2);
}
}
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);
}
}
// 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 paintComponent(Graphics graphics) {
Rectangle bounds = getBounds();
GraphicsUtility graphicsUtility = new GraphicsUtility(graphics);
graphicsUtility.setStroke(GraphicsUtility.STROKE_BOLD);
if (isSelected()) {
graphics.setColor(GraphicsUtility.getSelectedColor());
graphics.fillRect(0, 0, bounds.width, SELECT_BORDER_SIZE);
graphics.fillRect(0, 0, SELECT_BORDER_SIZE, bounds.height);
graphics.fillRect(0, bounds.height - SELECT_BORDER_SIZE, bounds.width, SELECT_BORDER_SIZE);
graphics.fillRect(bounds.width - SELECT_BORDER_SIZE, 0, SELECT_BORDER_SIZE, bounds.height);
graphics.setColor(Color.BLACK);
}
graphics.drawString(getCaption(), 10, 10);
graphicsUtility.drawArrow(
8, BORDER_INSET, BORDER_INSET, BORDER_INSET, bounds.height - BORDER_INSET);
graphicsUtility.drawArrow(
8,
BORDER_INSET,
bounds.height - BORDER_INSET,
bounds.width - BORDER_INSET,
bounds.height - BORDER_INSET);
graphicsUtility.drawArrow(
8,
bounds.width - BORDER_INSET,
bounds.height - BORDER_INSET,
bounds.width - BORDER_INSET,
BORDER_INSET);
graphicsUtility.drawArrow(
8, bounds.width - BORDER_INSET, BORDER_INSET, bounds.width - 50, BORDER_INSET);
graphicsUtility.setStroke(GraphicsUtility.STROKE_NORMAL);
}
public void paint(Graphics g) {
g.setColor(Color.red);
g.fillRect(xpos1, ypos1, width, length);
g.setColor(Color.blue);
g.fillRect(xpos2, ypos2, width, length);
g.setColor(Color.green);
g.fillOval(x_pos - radius, y_pos - radius, 2 * radius, 2 * radius);
Font text = new Font("Arial", Font.BOLD, 16);
setFont(text);
g.setColor(Color.white);
g.drawString("Pong v. 1.0", 200, 25);
message1 = "Player 1 Score: " + score1;
message2 = "Player 2 Score: " + score2;
g.drawString(message1, 10, 30);
g.drawString(message2, 325, 30);
if ((score1 == 10) || (score2 == 10)) {
g.drawString(gameover, 175, 250);
}
}
public void paint(Graphics g) {
m_fm = g.getFontMetrics();
g.setColor(getBackground());
g.fillRect(0, 0, getWidth(), getHeight());
getBorder().paintBorder(this, g, 0, 0, getWidth(), getHeight());
g.setColor(getForeground());
g.setFont(getFont());
m_insets = getInsets();
int x = m_insets.left;
int y = m_insets.top + m_fm.getAscent();
StringTokenizer st = new StringTokenizer(getText(), "\t");
while (st.hasMoreTokens()) {
String sNext = st.nextToken();
g.drawString(sNext, x, y);
x += m_fm.stringWidth(sNext);
if (!st.hasMoreTokens()) break;
int index = 0;
while (x >= getTab(index)) index++;
x = getTab(index);
}
}
/** Affichage du logo */
protected void drawLogo(Graphics g) {
int x = 5;
int y = 2;
g.setColor(getBackground());
g.fillRect(0, 0, W, H);
// Remplissage
fillBG(g, x, y, Color.white);
// Dessin
drawGrid(
g,
x,
y,
!isAvailable()
? Aladin.MYGRAY
: isActive() ? Aladin.GREEN : isMouseIn() ? Color.blue : Color.black);
// Label
g.setColor(isAvailable() ? Color.black : Aladin.MYGRAY);
g.setFont(Aladin.SPLAIN);
g.drawString(LABEL, W / 2 - g.getFontMetrics().stringWidth(LABEL) / 2, H - 2);
}
public void paint(Graphics g) {
super.paint(g);
Dimension size = getSize();
double w = size.getWidth() - 50;
double h = size.getHeight() + 20;
try {
readFile();
} catch (IOException e) {
System.err.println("IO issue");
}
barWidth = ((int) (w / numBars)) - 20;
pos = 5;
int xPos[] = {pos, pos, pos, pos};
int yPos[] = {pos, pos, pos, pos};
maxVal = maxValue(values);
double barH, ratio;
for (int i = 0; i < numBars - 1; i++) {
Color col[] = new Color[numBars];
for (int j = 0; j < numBars - 1; j++) {
col[j] = new Color((int) (Math.random() * 0x1000000));
}
ratio = (double) values[i] / (double) maxVal;
barH = ((h) * ratio) - 10;
xPos[0] = pos;
xPos[2] = pos + barWidth;
xPos[1] = xPos[0];
xPos[3] = xPos[2];
yPos[0] = (int) h;
yPos[1] = (int) barH;
yPos[2] = yPos[1];
yPos[3] = yPos[0];
System.out.println(
"xPos:" + xPos[1] + " yPos:" + yPos[0] + " h:" + h + " barH:" + barH + " ratio:" + ratio
+ " pos:" + pos);
int stringPtsY[] = {
((i + 1) * 20) + 180, ((i + 1) * 20) + 200, ((i + 1) * 20) + 200, ((i + 1) * 20) + 180
};
int stringPtsX[] = {600, 600, 580, 580};
g.setColor(col[i]);
g.fillPolygon(xPos, yPos, xPos.length);
g.fillPolygon(stringPtsX, stringPtsY, 4);
g.setColor(Color.black);
g.drawString(labels[i], 610, ((i + 1) * 20) + 195);
pos = pos + barWidth + 10;
}
}
void displayStatus(Graphics g) {
if (statusString != null) {
g.setColor(0xffffff);
g.fillRect(0, getHeight() - inputHeight - 2, getWidth(), inputHeight + 2);
g.setColor(0x000000);
g.drawLine(0, getHeight() - inputHeight - 2, getWidth(), getHeight() - inputHeight - 2);
g.drawString(statusString, 0, getHeight() - inputHeight - 2, Graphics.LEFT | Graphics.TOP);
}
}
static void drawActiveButtonBorder(Graphics g, int x, int y, int w, int h) {
drawFlush3DBorder(g, x, y, w, h);
g.setColor(MetalLookAndFeel.getPrimaryControl());
g.drawLine(x + 1, y + 1, x + 1, h - 3);
g.drawLine(x + 1, y + 1, w - 3, x + 1);
g.setColor(MetalLookAndFeel.getPrimaryControlDarkShadow());
g.drawLine(x + 2, h - 2, w - 2, h - 2);
g.drawLine(w - 2, y + 2, w - 2, h - 2);
}
public void paint(Graphics g) {
g.setFont(getFont());
Color boxColor = getBackgroundBoxColor();
Color hatchColor = getHatchColor();
Color backgroundLineColor = getBackgroundLineColor();
// Color textColor = getForeground();
int outlineType = getOutlineType();
Color outlineColor = getOutlineColor();
if (backgroundLineColor != null) {
g.setColor(backgroundLineColor);
g.fillRect(0, getSize().height / 2 - 1, getSize().width, 2);
}
if (boxColor != null) {
g.setColor(boxColor);
g.fillRect(0, 0, getSize().width, getSize().height);
}
if (hatchColor != null) {
g.setColor(hatchColor);
// Bev thinks the cross-hatching makes it too hard to read the base.
// For a single diagonal line, replace the following three lines with
// g.drawLine(0,getSize().height, getSize().width,0);
// For an underline, replace with
// g.drawLine(0,getSize().height, getSize().width,getSize().height);
// Draw three cross-hatch lines
// g.drawLine(0,0,getSize().width,getSize().height);
// g.drawLine(getSize().width/2,0,getSize().width,getSize().height/2);
// g.drawLine(0,getSize().height/2,getSize().width/2,getSize().height);
// Draw a line at top and bottom of matching base
g.drawLine(0, getSize().height, getSize().width, getSize().height); // bottom
g.drawLine(0, 0, getSize().width, 0); // top
// g.drawLine(0,0, 0,getSize().height); // left side
// g.drawLine(getSize().width,0, getSize().width,getSize().height); // right side
}
if (outlineType != NO_OUTLINE && outlineColor != null) {
g.setColor(outlineColor);
g.drawLine(0, 0, getSize().width - 1, 0);
g.drawLine(0, getSize().height - 1, getSize().width - 1, getSize().height - 1);
if (outlineType == LEFT_OUTLINE) g.drawLine(0, 0, 0, getSize().height - 1);
else if (outlineType == RIGHT_OUTLINE) {
g.drawLine(getSize().width - 1, 0, getSize().width - 1, getSize().height - 1);
}
}
if (getTextColor() != null) {
int leadDistance = (getSize().width - metrics.charWidth(c)) / 2;
g.setColor(getTextColor());
g.drawString(c + "", leadDistance, getSize().height - 2);
}
}
/*
* Draws a frame around the data area.
*/
protected void drawFrame(Graphics g, int x, int y, int width, int height) {
Color c = g.getColor();
if (framecolor != null) g.setColor(framecolor);
g.drawRect(x, y, width, height);
g.setColor(c);
}
/**
* Draws a visualization tooltip.
*
* @param g graphics reference
* @param tt tooltip label
* @param x horizontal position
* @param y vertical position
* @param w width
* @param c color color depth
*/
public static void drawTooltip(
final Graphics g, final String tt, final int x, final int y, final int w, final int c) {
final int tw = width(g, tt);
final int th = g.getFontMetrics().getHeight();
final int xx = Math.min(w - tw - 8, x);
g.setColor(color(c));
g.fillRect(xx - 1, y - th, tw + 4, th);
g.setColor(BACK);
g.drawString(tt, xx, y - 4);
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
if (myCurrentWindow == null || myCurrentWindow.getFiles().length == 0) {
g.setColor(UIUtil.isUnderDarcula() ? UIUtil.getBorderColor() : new Color(0, 0, 0, 50));
g.drawLine(0, 0, getWidth(), 0);
}
if (showEmptyText()) {
UIUtil.applyRenderingHints(g);
g.setColor(new JBColor(Gray._100, Gray._160));
g.setFont(UIUtil.getLabelFont().deriveFont(UIUtil.isUnderDarcula() ? 24f : 18f));
final UIUtil.TextPainter painter =
new UIUtil.TextPainter().withShadow(true).withLineSpacing(1.4f);
painter.appendLine("No files are open").underlined(new JBColor(Gray._150, Gray._100));
if (!isProjectViewVisible()) {
painter
.appendLine(
"Open Project View with "
+ KeymapUtil.getShortcutText(
new KeyboardShortcut(
KeyStroke.getKeyStroke((SystemInfo.isMac ? "meta" : "alt") + " 1"),
null)))
.smaller()
.withBullet();
}
painter
.appendLine("Open a file by name with " + getActionShortcutText("GotoFile"))
.smaller()
.withBullet()
.appendLine(
"Open Recent files with " + getActionShortcutText(IdeActions.ACTION_RECENT_FILES))
.smaller()
.withBullet()
.appendLine("Open Navigation Bar with " + getActionShortcutText("ShowNavBar"))
.smaller()
.withBullet()
.appendLine("Drag'n'Drop file(s) here from " + ShowFilePathAction.getFileManagerName())
.smaller()
.withBullet()
.draw(
g,
new PairFunction<Integer, Integer, Pair<Integer, Integer>>() {
@Override
public Pair<Integer, Integer> fun(Integer width, Integer height) {
final Dimension s = getSize();
return Pair.create((s.width - width) / 2, (s.height - height) / 2);
}
});
}
}
void displayCurrentCommand(Graphics g) {
g.setColor(0xffffff);
g.fillRect(0, getHeight() - inputHeight - 2, getWidth(), inputHeight + 2);
g.setColor(0x000000);
g.drawLine(0, getHeight() - inputHeight - 2, getWidth(), getHeight() - inputHeight - 2);
g.drawString(
"Ctrl" + " + " + currentCharCommand,
0,
getHeight() - inputHeight,
Graphics.LEFT | Graphics.TOP);
}
public void paint(Graphics canvas) {
m_bClash = false;
DrawSquares(canvas);
canvas.setColor(Color.RED);
CheckColumns(canvas);
CheckRows(canvas);
CheckDiagonal1(canvas);
CheckDiagonal2(canvas);
canvas.setColor(Color.BLUE);
canvas.drawString(m_strStatus, BOARDLEFT, BOARDTOP + SQUAREHEIGHT * 8 + 20);
}
@Override
protected void paintContentBorderBottomEdge(
Graphics g, int tabPlacement, int selectedIndex, int x, int y, int w, int h) {
if (tabPane.getTabCount() < 1) return;
g.setColor(shadow);
g.drawLine(x + 1, y + h - 3, x + w - 2, y + h - 3);
g.drawLine(x + 1, y + h - 2, x + w - 2, y + h - 2);
g.setColor(shadow.brighter());
g.drawLine(x + 2, y + h - 1, x + w - 1, y + h - 1);
}
/** This draws the "Flush 3D Border" which is used throughout the Metal L&F */
static void drawFlush3DBorder(Graphics g, int x, int y, int w, int h) {
g.translate(x, y);
g.setColor(MetalLookAndFeel.getControlDarkShadow());
g.drawRect(0, 0, w - 2, h - 2);
g.setColor(MetalLookAndFeel.getControlHighlight());
g.drawRect(1, 1, w - 2, h - 2);
g.setColor(MetalLookAndFeel.getControl());
g.drawLine(0, h - 1, 1, h - 2);
g.drawLine(w - 1, 0, w - 2, 1);
g.translate(-x, -y);
}
/**
* This paints the entire plot. It calls the draw methods of all the attached axis and data sets.
* The order of drawing is - Axis first, data legends next, data last.
*
* @params g Graphics state.
*/
public void paint(Graphics g) {
int i;
Graphics lg = g.create();
Rectangle r = bounds();
/* The r.x and r.y returned from bounds is relative to the
** parents space so set them equal to zero.
*/
r.x = 0;
r.y = 0;
if (DefaultBackground == null) DefaultBackground = this.getBackground();
if (DataBackground == null) DataBackground = this.getBackground();
// System.out.println("Graph2D paint method called!");
if (!paintAll) return;
r.x += borderLeft;
r.y += borderTop;
r.width -= borderLeft + borderRight;
r.height -= borderBottom + borderTop;
paintFirst(lg, r);
if (!axis.isEmpty()) r = drawAxis(lg, r);
else {
if (clearAll) {
Color c = g.getColor();
g.setColor(DataBackground);
g.fillRect(r.x, r.y, r.width, r.height);
g.setColor(c);
}
drawFrame(lg, r.x, r.y, r.width, r.height);
}
paintBeforeData(lg, r);
if (!dataset.isEmpty()) {
datarect.x = r.x;
datarect.y = r.y;
datarect.width = r.width;
datarect.height = r.height;
for (i = 0; i < dataset.size(); i++) {
((DataSet) dataset.elementAt(i)).draw_data(lg, r);
}
}
paintLast(lg, r);
lg.dispose();
}
public void paint(Graphics g) {
super.paint(g);
if (!isEditing) return;
Dimension psize = getPreferredSize();
if (isFocused) g.setColor(Color.yellow);
else g.setColor(Color.green);
g.drawLine(0, 0, psize.width, 0);
g.drawLine(0, 0, 0, psize.height);
g.drawLine(0, psize.height - 1, psize.width - 1, psize.height - 1);
g.drawLine(psize.width - 1, 0, psize.width - 1, psize.height - 1);
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(BACKGROUND);
g.fillRect(0, 0, width, height);
g.setColor(FOREGROUND);
for (int i = 0; i < NUMBOXES; i++) {
g.fillRect(boxXs[i], boxYs[i], BOXWIDTH, BOXHEIGHT);
g.drawLine(lineXs[i], lineYs[i], lineXXs[i], lineYYs[i]);
}
}
public void draw(Graphics g) {
g.setColor(Color.BLACK);
g.drawString("Points: " + points, 10, 20);
g.drawString("Lives: " + lives, 10, 30);
if (lives <= 0) {
g.setColor(Color.RED);
g.drawString("You Lose", WIDTH / 2 - 20, HEIGHT / 2);
}
for (int i = 0; i < balls.size(); i++) balls.get(i).draw(g);
bucket.draw(g);
}
