public void paintText(Graphics2D g, ButtonInfo info) { ButtonModel model = info.button.getModel(); FontMetrics fm = info.button.getFontMetrics(info.button.getFont()); int mnemonicIndex = info.button.getDisplayedMnemonicIndex(); String text = info.button.getText(); int textShiftOffset = 0; g.setComposite(AlphaComposite.SrcOver); /* Draw the Text */ if (isEnabled(info.button)) { /** * paint the text normally */ g.setColor(info.button.getForeground()); BasicGraphicsUtils.drawStringUnderlineCharAt( g, text, mnemonicIndex, info.textRect.x + textShiftOffset, info.textRect.y + fm.getAscent() + textShiftOffset); } else { /** * paint the text disabled ** */ g.setColor(info.button.getBackground().brighter()); BasicGraphicsUtils.drawStringUnderlineCharAt( g, text, mnemonicIndex, info.textRect.x, info.textRect.y + fm.getAscent()); g.setColor(info.button.getBackground().darker()); BasicGraphicsUtils.drawStringUnderlineCharAt( g, text, mnemonicIndex, info.textRect.x - 1, info.textRect.y + fm.getAscent() - 1); } }
@Override public void setBounds(int x, int y, int width, int height) { super.setBounds(x, y, width, height); int w = getWidth() - (SHADOW_SIZE - 2) * 2; int h = getHeight() - (SHADOW_SIZE - 2) * 2; int arc = 15; int shadowSize = SHADOW_SIZE; shadow = GraphicsUtilities.createCompatibleTranslucentImage(w, h); Graphics2D g2 = shadow.createGraphics(); if (active) { g2.setColor(new Color(243, 238, 39, 150)); } else { g2.setColor(Color.WHITE); } g2.setColor(Color.WHITE); g2.fillOval(0, 0, w, h); g2.dispose(); ShadowRenderer renderer = new ShadowRenderer(shadowSize, 0.5f, Color.BLACK); shadow = renderer.createShadow(shadow); g2 = shadow.createGraphics(); g2.setColor(Color.GRAY); g2.setComposite(AlphaComposite.Clear); g2.fillOval(shadowSize, shadowSize, w, h); g2.dispose(); }
/** * Erases a given shape's outline on the screen. * * @param shape the shape object to be erased */ public void eraseOutline(Shape shape) { Color original = graphic.getColor(); graphic.setColor(backgroundColour); graphic.draw(shape); // erase by drawing background colour graphic.setColor(original); canvas.repaint(); }
/** Erase the whole canvas. (Does not repaint.) */ private void erase() { Color original = graphic.getColor(); graphic.setColor(backgroundColor); Dimension size = canvas.getSize(); graphic.fill(new Rectangle(0, 0, size.width, size.height)); graphic.setColor(original); }
public void drawFunctionToGraphic(Graphics2D g, int x, int y, int UNITYX, int UNITYY) { int _x, _y; g.setColor(Color.red); g.drawString("f(x) = " + F.toString(), 15, 20); g.setColor(Color.blue); for (double i = 0; ; i += EPSILON) { _x = (int) (i * UNITYX) + x / 2; _y = -(int) (F.evaluate(i) * UNITYY) + y / 2; g.drawLine( _x, _y, (int) ((i + EPSILON) * UNITYX) + x / 2, -(int) (F.evaluate(i + EPSILON) * UNITYY) + y / 2); if (_x < 0 || _x > x || _y < 0 || _y > y) break; } for (double i = 0; ; i -= EPSILON) { _x = (int) (i * UNITYX) + x / 2; _y = -(int) (F.evaluate(i) * UNITYY) + y / 2; g.drawLine( _x, _y, (int) ((i + EPSILON) * UNITYX) + x / 2, -(int) (F.evaluate(i + EPSILON) * UNITYY) + y / 2); if (_x < 0 || _x > x || _y < 0 || _y > y) break; } }
@Override public void paint(Graphics g) { super.paint(g); if (g instanceof Graphics2D) { Graphics2D g2d = (Graphics2D) g; if (blackOutEnabled) { // background g2d.setColor(Color.BLACK); g2d.fillRect(0, 0, this.getWidth(), this.getHeight()); } else if (whiteOutEnabled) { // background g2d.setColor(Color.WHITE); g2d.fillRect(0, 0, this.getWidth(), this.getHeight()); } else { // background g2d.setColor(backgroundColor); g2d.fillRect(0, 0, this.getWidth(), this.getHeight()); // text if (font == null) font = GuiHelper.maxFontSize(frame.getWidth(), frame.getHeight(), fontName, timeFormat); if (textY == -1) textY = GuiHelper.getTextYForCenter(timeFormat, font, frame.getHeight()); g2d.setRenderingHint( RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON); g2d.setFont(font); g2d.setColor(textColor); g2d.drawString(timeToString(time), 0, textY); } } }
// draw on screen public synchronized void draw(Graphics2D g) { Window w = s.getFullScreenWindow(); g.setColor(w.getBackground()); g.fillRect(0, 0, s.getWidth(), s.getHeight()); g.setColor(w.getForeground()); g.drawString(mess, 100, 100); }
/** * icon is painted with correct number of stones in the pit/mancala * * @param c properties for painting * @param g graphics object * @param x x location of icon * @param y y location of icon */ public void paintIcon(Component c, Graphics g, int x, int y) { int iterateNum = data[pitNum]; if (iterateNum > 5) { iterateNum = 5; } Graphics2D g2 = (Graphics2D) g; if (pitNum == 6 || pitNum == 13) { pitShape = s.getMancalaShape(); g2.setColor(s.getPitColor()); g2.fill(pitShape); for (int i = 0; i < data[pitNum]; i++) { RectangularShape temp = s.getStoneShape(i, data[pitNum], true); g2.setColor(s.getStoneColor()); g2.draw(temp); g2.fill(temp); } } else { pitShape = s.getPitShape(); g2.setColor(s.getPitColor()); g2.fill(pitShape); for (int i = 0; i < data[pitNum]; i++) { RectangularShape temp = s.getStoneShape(i, data[pitNum], false); g2.setColor(s.getStoneColor()); g2.draw(temp); g2.fill(temp); } } }
public void paintComponent(Graphics g) { Graphics2D g2d = (Graphics2D) g.create(); g2d.setStroke(new BasicStroke(1.0f)); if (isOpaque()) { g2d.setColor(getBackground()); g2d.fillRect(0, 0, getWidth(), getHeight()); } g2d.setColor(Color.black); g2d.drawLine(0, frameHeight / 2, frameWidth, frameHeight / 2); g2d.drawLine(frameWidth / 2, 0, frameWidth / 2, frameHeight); for (int i = unityX; i < frameWidth / 2; i += unityX) { g2d.drawLine( frameWidth / 2 + i, frameHeight / 2 - 3, frameWidth / 2 + i, frameHeight / 2 + 3); g2d.drawLine( frameWidth / 2 - i, frameHeight / 2 - 3, frameWidth / 2 - i, frameHeight / 2 + 3); } for (int i = unityY; i < frameHeight / 2; i += unityY) { g2d.drawLine( frameWidth / 2 - 3, frameHeight / 2 + i, frameWidth / 2 + 3, frameHeight / 2 + i); g2d.drawLine( frameWidth / 2 - 3, frameHeight / 2 - i, frameWidth / 2 + 3, frameHeight / 2 - i); } g2d.setColor(Color.blue); function.drawFunctionToGraphic(g2d, frameWidth, frameHeight, unityX, unityY); paintCurrentMethodState(g2d); g2d.dispose(); }
public void paint(Graphics g) { gRef = (Graphics2D) g; // change size of font gRef.setFont(gRef.getFont().deriveFont(9.0f)); fmRef = g.getFontMetrics(); // Clear background if (Preferences.monochrome) { gRef.setColor(Preferences.whiteColor); } else { gRef.setColor(Preferences.backgroundColor); } gRef.fillRect(0, 0, getWidth(), getHeight()); // set colour to correct drawing colour if (Preferences.monochrome) { gRef.setColor(Preferences.blackColor); } else { gRef.setColor(Preferences.penColor); } gRef.translate(0, margin); // Call c code to draw tree gRef.scale(scale, scale); nativeDrawTree(); }
@Override protected void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D gfx = (Graphics2D) g; gfx.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); // Clear screen gfx.setColor(Constants.BACKGROUND_COLOR); gfx.fillRect(0, 0, getWidth(), getHeight()); // Render next frame grid.draw(gfx); // Trace path line if (tracing) { gfx.setColor(Constants.PATH_COLOR); gfx.setStroke(new BasicStroke(2)); for (int i = 1; i < pathLine.size(); i++) { Coordinate p = pathLine.get(i - 1); Coordinate n = pathLine.get(i); gfx.drawLine( (Constants.TILESIZE + Constants.MARGIN) * p.x + (Constants.TILESIZE / 2) + Constants.MARGIN, (Constants.TILESIZE + Constants.MARGIN) * p.y + (Constants.TILESIZE / 2) + Constants.MARGIN, (Constants.TILESIZE + Constants.MARGIN) * n.x + (Constants.TILESIZE / 2) + Constants.MARGIN, (Constants.TILESIZE + Constants.MARGIN) * n.y + (Constants.TILESIZE / 2) + Constants.MARGIN); } } }
/** Paints selection for the specified <code>component</code>. */ public static void paintSelectionDecoration( @NotNull RadComponent component, Graphics g, boolean focused) { if (component.isSelected()) { if (focused) { g.setColor(PlatformColors.BLUE); } else { g.setColor(Color.GRAY); } final Point[] points = getPoints(component.getWidth(), component.getHeight()); for (final Point point : points) { g.fillRect(point.x - R, point.y - R, 2 * R + 1, 2 * R + 1); } } else if (component.getWidth() < FormEditingUtil.EMPTY_COMPONENT_SIZE || component.getHeight() < FormEditingUtil.EMPTY_COMPONENT_SIZE) { Graphics2D g2d = (Graphics2D) g; Composite oldComposite = g2d.getComposite(); Stroke oldStroke = g2d.getStroke(); Color oldColor = g2d.getColor(); g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, 0.5f)); g2d.setStroke(new BasicStroke(0.7f)); g2d.setColor(Color.black); g2d.drawRect( 0, 0, Math.max(component.getWidth(), FormEditingUtil.EMPTY_COMPONENT_SIZE), Math.max(component.getHeight(), FormEditingUtil.EMPTY_COMPONENT_SIZE)); g2d.setComposite(oldComposite); g2d.setStroke(oldStroke); g2d.setColor(oldColor); } }
@Override protected void paintWidget() { Graphics2D g = getGraphics(); g.setStroke(Util.STROKE_2); g.setFont(getFont()); Rectangle bounds = getBounds(); String text = Util.node(this).toString(); if (text.length() == 0) { g.setColor((Color) getBackground()); g.fillOval(bounds.x, bounds.y, bounds.width - 1, bounds.height - 1); g.setColor(getForeground()); g.drawOval(bounds.x, bounds.y, bounds.width - 1, bounds.height - 1); } else { g.setColor((Color) getBackground()); int arc = (bounds.height - 1); g.fillRoundRect(bounds.x, bounds.y, bounds.width - 1, bounds.height - 1, arc, arc); g.setColor(getForeground()); g.drawString( text, bounds.x + (bounds.height - 1) / 2, bounds.y + bounds.height - vborder - 1 - g.getFontMetrics().getMaxDescent()); g.drawRoundRect(bounds.x, bounds.y, bounds.width - 1, bounds.height - 1, arc, arc); } }
@Override // TODO Auto-generated method stub public void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2 = (Graphics2D) g; // Draws the two initial two YinYang symbols on the frame g2.setColor(color1); if (timeLeft < 6000) { g2.rotate(degrees, yin1X + (yin1Width / 2), yin1Y + (yin1Height / 2)); } g2.fill(new MyYinYang(yin1X, yin1Y, yin1Width, yin1Height)); if (timeLeft < 6000) { g2.rotate(-degrees, yin1X + (yin1Width / 2), yin1Y + (yin1Height / 2)); } g2.setColor(color2); if (timeLeft < 6000) { g2.rotate(degrees, yin2X + (yin2Width / 2), yin2Y + (yin2Height / 2)); } g2.fill(new MyYinYang(yin2X, yin2Y, yin2Width, yin2Height)); if (timeLeft < 6000) { g2.rotate(-degrees, yin2X + (yin2Width / 2), yin2Y + (yin2Height / 2)); } // Alters and prints the text on the screen g2.setColor(Color.BLACK); g2.setFont(font); g2.drawString("Score", 700, 25); g2.drawString(Integer.toString(points), 700, 75); g2.drawString("Misses", 800, 25); g2.drawString(Integer.toString(misses), 800, 75); g2.drawString("Time Left", 700, 110); timeDisplay = timeLeft / 100.0; g2.drawString(timeDisplay.toString(), 700, 160); }
/** {@inheritDoc} */ @Override public void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2d = (Graphics2D) g.create(); g2d.setBackground(Color.white); int xDim = (int) (getWidth() / 56); int yDim = (int) (getHeight() / 66); g2d.drawLine(0, (agent[0].length) * yDim, Slope.getWidth() * xDim, (agent[0].length) * yDim); g2d.drawRect((Slope.getWidth() - 3) * xDim, 0, 15, Slope.getHeight() * yDim); for (int k = 0; k < Slope.getHeight(); k++) for (int l = 0; l < Slope.getWidth(); l++) { g2d.setColor(new Color(0, 0, 0, 1)); g2d.drawRect(k * getWidth() / 56, l * getHeight() / 66, 30, 30); } for (int i = 0; i < agent.length; i++) { for (int j = 0; j < agent[0].length; j++) { g2d.setColor(Color.blue); if (agent[i][j]) { // g2d.drawString("*", i*getWidth()/56, j*getHeight()/66); g2d.drawImage(image, i * getWidth() / 56, j * getHeight() / 66, null); } } } }
private void placerPostes(Graphics2D g) { g.setStroke(new BasicStroke()); for (PlanSalle.Poste poste : modele.listerPostes()) { g.setColor(Color.gray); int xPoste = Parametres.posteX(poste.getPosition().getTravee(), poste.getOrientation()); int yPoste = Parametres.posteY(poste.getPosition().getRangee(), poste.getOrientation()); int xPersonne = Parametres.personneX(poste.getPosition().getTravee(), poste.getOrientation()); int yPersonne = Parametres.personneY(poste.getPosition().getRangee(), poste.getOrientation()); if (poste.getOrientation() == Orientation.NORD || poste.getOrientation() == Orientation.SUD) { g.fill3DRect(xPoste, yPoste, Parametres.LONGUEUR_POSTE, Parametres.LARGEUR_POSTE, true); } else { g.fill3DRect(xPoste, yPoste, Parametres.LARGEUR_POSTE, Parametres.LONGUEUR_POSTE, true); } g.drawOval(xPersonne, yPersonne, Parametres.LARGEUR_PERSONNE, Parametres.LARGEUR_PERSONNE); if (poste.peutVoir()) { g.setColor(Color.red); } else { g.setColor(Color.blue); } g.fillOval(xPersonne, yPersonne, 20, 20); } }
/** [Internal] */ private void paintBackground(Graphics2D g2, Color theBackground) { Color color1 = g2.getColor(); if (theBackground == null) theBackground = Color.white; g2.setColor(theBackground); g2.fillRect(0, 0, 30000, 30000); g2.setColor(color1); }
/** * Erases a String on the Canvas. * * @param text the String to be displayed * @param x x co-ordinate for text placement * @param y y co-ordinate for text placement */ public void eraseString(String text, int x, int y) { Color original = graphic.getColor(); graphic.setColor(backgroundColour); graphic.drawString(text, x, y); graphic.setColor(original); canvas.repaint(); }
@Override public void paint(Graphics g) { Graphics2D g2d = (Graphics2D) g; Color old = g2d.getColor(); // Draw box g2d.setColor( clicked ? this.clickedBackColor : (hovering ? this.hoverBackColor : this.unclickedBackColor)); g2d.fillRect(0, 0, getWidth(), getHeight()); // Draw label g2d.setColor( clicked ? this.clickedForeColor : (hovering ? this.hoverForeColor : this.unclickedForeColor)); g2d.setFont(getFont()); int width = g2d.getFontMetrics().stringWidth(getText()); int textHeight = getFont().getSize(); int otherTextHeight = getFontMetrics(getFont()).getHeight(); textHeight = textHeight - (otherTextHeight - textHeight); int height = textHeight + (getHeight() - textHeight) / 2; g2d.drawString(getText(), (getWidth() - width) / 2, height); g2d.setColor(old); }
public void paint(java.awt.Graphics g) { if (element != null) { Rectangle bounds = element.jGetBounds(); Graphics2D g2 = (Graphics2D) g; g2.setFont(font); int mitteX = bounds.x + (bounds.width) / 2; int mitteY = bounds.y + (bounds.height) / 2; int distanceY = 10; g2.setColor(new Color(204, 204, 255)); g2.fillRect(bounds.x, mitteY - distanceY, bounds.width, 2 * distanceY); g2.setColor(Color.BLACK); g2.drawRect(bounds.x, mitteY - distanceY, bounds.width, 2 * distanceY); String caption = "dec(" + variable.getValue() + ")"; FontMetrics fm = g2.getFontMetrics(); Rectangle2D r = fm.getStringBounds(caption, g2); g2.setColor(Color.BLACK); g.drawString( caption, mitteX - (int) (r.getWidth() / 2), (int) (mitteY + fm.getHeight() / 2) - 3); } super.paint(g); }
public void paintComponent(Graphics g) { super.paintComponent(g); int centerX = getWidth() / 2; int centerY = getHeight() / 2; Graphics2D g2d = (Graphics2D) g.create(); g2d.translate(centerX, centerY); // Set Graphics2D transform origin to center of panel g2d.setColor(fgColor); bar.setFrame(-barWidth / 2, -barHeight / 2 + barHeight * barPosition, barWidth, barHeight); g2d.fill(bar); g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); for (Spike spike : spikes) { if (spike != null) { double opacity = 255; if (spike.getDirection() == 0) { opacity = getWidth() * 0.5 - 70 - spike.getPosition().getX(); } else { opacity = spike.getPosition().getX() + getWidth() * 0.5 - 70; } g2d.setColor(new Color(0, 0, 0, (int) clamp(opacity * 10, 0, 255))); g2d.fill(spike); } } g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF); g2d.setColor(Color.BLACK); g2d.draw(barCross); g2d.setStroke(new BasicStroke(2)); g2d.draw(barFrame); g2d.dispose(); }
public VolatileImage renderBackgroundLayer(int LayerNumber) { // create hardware accellerated background layer (Volatile Image) backgroundLayer[LayerNumber] = this.getGraphicsConfiguration() .createCompatibleVolatileImage( loadedLevel.getWidth() * 16, loadedLevel.getHeight() * 16, Transparency.TRANSLUCENT); Graphics2D g2d = backgroundLayer[LayerNumber].createGraphics(); g2d.setComposite(AlphaComposite.Src); // Clear the image. g2d.setColor(new Color(0, 0, 0, 0)); g2d.fillRect( 0, 0, backgroundLayer[LayerNumber].getWidth(), backgroundLayer[LayerNumber].getHeight()); g2d.setBackground(new Color(0, 0, 0, 0)); g2d.setColor(new Color(1f, 1f, 1f, 1f)); for (int i = 0; i < backgroundLayer[LayerNumber].getWidth(this) / backgroundImage[LayerNumber].getWidth(this); i++) { g2d.drawImage( backgroundImage[LayerNumber], i * backgroundImage[LayerNumber].getWidth(this), 0, this); } return backgroundLayer[LayerNumber]; }
private void paintString( Graphics g, int x, int y, int width, int height, int fillStart, int amountFull, Insets b) { if (!(g instanceof Graphics2D)) { return; } Graphics2D g2D = (Graphics2D) g; String progressString = progressBar.getString(); g2D.setFont(progressBar.getFont()); Point renderLocation = getStringPlacement(g2D, progressString, x, y, width, height); Rectangle savedClip = g2D.getClipBounds(); if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) { g2D.setColor(getSelectionBackground()); Utilities.drawString(progressBar, g2D, progressString, renderLocation.x, renderLocation.y); g2D.setColor(getSelectionForeground()); g2D.clipRect(fillStart, y, amountFull, height); Utilities.drawString(progressBar, g2D, progressString, renderLocation.x, renderLocation.y); } else { // VERTICAL g2D.setColor(getSelectionBackground()); AffineTransform rotate = AffineTransform.getRotateInstance(Math.PI / 2); g2D.setFont(progressBar.getFont().deriveFont(rotate)); renderLocation = getStringPlacement(g2D, progressString, x, y, width, height); Utilities.drawString(progressBar, g2D, progressString, renderLocation.x, renderLocation.y); g2D.setColor(getSelectionForeground()); g2D.clipRect(x, fillStart, width, amountFull); Utilities.drawString(progressBar, g2D, progressString, renderLocation.x, renderLocation.y); } g2D.setClip(savedClip); }
public void StaticObjNew(StaticObj so) { Graphics2D g = radarArea.backImage.createGraphics(); g.setColor(so_color); if (so instanceof Beacon) { g.drawOval( convPos(so.pos.x) - grid_size / 6, convPos(so.pos.y) - grid_size / 6, grid_size / 3, grid_size / 3); JLabel sol = new JLabel(Integer.toString(so.id)); sol.setForeground(so_text_color); sol.setBounds( convPos(so.pos.x) + grid_size / 6, convPos(so.pos.y), grid_size / 3, grid_size / 2); radarArea.add(sol, new Integer(1)); } if (so instanceof Airfield) { int xa[] = new int[3], ya[] = new int[3]; int l1 = grid_size / 2, l2 = grid_size / 6; xa[0] = convPos(so.pos.x); ya[0] = convPos(so.pos.y); xa[1] = convPos(so.pos.x) - l1 * so.dir.x - l2 * so.dir.y; ya[1] = convPos(so.pos.y) - l1 * so.dir.y + l2 * so.dir.x; xa[2] = convPos(so.pos.x) - l1 * so.dir.x + l2 * so.dir.y; ya[2] = convPos(so.pos.y) - l1 * so.dir.y - l2 * so.dir.x; g.drawPolygon(xa, ya, 3); JLabel sol = new JLabel(Integer.toString(so.id)); sol.setForeground(so_text_color); sol.setBounds( convPos(so.pos.x) + grid_size / 6, convPos(so.pos.y), grid_size / 3, grid_size / 2); radarArea.add(sol, new Integer(1)); } if (so instanceof Exit) { g.drawRect( convPos(so.pos.x) - grid_size / 6, convPos(so.pos.y) - grid_size / 6, grid_size / 3, grid_size / 3); JLabel sol = new JLabel(Integer.toString(so.id)); sol.setForeground(so_text_color); sol.setBounds( convPos(so.pos.x) + grid_size / 6, convPos(so.pos.y), grid_size / 3, grid_size / 2); radarArea.add(sol, new Integer(1)); } if (so instanceof Line) { g.setColor(line_color); g.drawLine( convPos(((Line) so).pos.x), convPos(((Line) so).pos.y), convPos(((Line) so).second_end.x), convPos(((Line) so).second_end.y)); } radarArea.backIcon = new ImageIcon(radarArea.backImage); radarArea.back.setIcon(radarArea.backIcon); }
@Override public void draw(Graphics2D g2) { int w = toolInterface.getStrokeWidth() * 4; Color c = g2.getColor(); g2.setColor(Color.GRAY); g2.drawRect(mouseX - w / 2, mouseY - w / 2, w, w); g2.setColor(c); }
/** 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!"); } }
private void paintFirms(Graphics2D g2d) { Rectangle2D rec = new Rectangle2D.Double(); ArrayList<Firm> firms = SleepStoneTest.firms; Stroke normalStroke = new BasicStroke(); Stroke boldStroke = new BasicStroke(4f); g2d.setStroke(boldStroke); for (Firm x : firms) { rec.setRect(firmsPlace.get(x)); FirmStatus status = x.getStatus(); g2d.setColor(Color.black); g2d.drawString(x.getFirmName(), Math.round(rec.getMinX()), Math.round(rec.getMaxY() + 15d)); g2d.drawString( Integer.toString(x.getWorkers().size()), Math.round(rec.getMinX()), Math.round(rec.getMinY() - 15d)); // g2d.setColor(Color.RED); g2d.drawImage( firmIcon.getImage(), (int) rec.getX(), (int) rec.getY(), (int) rec.getWidth(), (int) rec.getHeight(), FirmStatus.getStatusColor(status), null); // draw the jobs done indicator if (status == FirmStatus.PRODUCING) { g2d.setColor(Color.black); g2d.setStroke(boldStroke); Rectangle jobsIndicator = new Rectangle( (int) rec.getMaxX() + 5, (int) rec.getMinY(), (int) (firmSpacing / 2d), (int) rec.getHeight()); g2d.draw(jobsIndicator); float jobsToDo = x.getJobsToDo(); float jobsDone = x.getJobsDone().availablePermits(); float percentComplete = jobsDone / jobsToDo; g2d.setColor(Color.BLUE); jobsIndicator.setBounds( (int) rec.getMaxX() + 5, (int) rec.getMinY(), (int) (firmSpacing / 2d), (int) (((float) (rec.getHeight())) * percentComplete)); g2d.fill(jobsIndicator); g2d.setStroke(normalStroke); } // index++; } }
// initialize default image private BufferedImage getDefaultImage(int w, int h) { BufferedImage defaultImage = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); Graphics2D graphics2D = defaultImage.createGraphics(); graphics2D.setColor(new Color(200, 200, 200)); graphics2D.fillRect(0, 0, w, h); graphics2D.setColor(new Color(130, 130, 130)); graphics2D.drawRect(0, 0, w - 1, h - 1); return defaultImage; }
private void paintCaret(Graphics2D g_) { EditorImpl.CaretRectangle[] locations = myEditor.getCaretLocations(true); if (locations == null) return; Graphics2D g = IdeBackgroundUtil.getOriginalGraphics(g_); int lineHeight = myView.getLineHeight(); EditorSettings settings = myEditor.getSettings(); Color caretColor = myEditor.getColorsScheme().getColor(EditorColors.CARET_COLOR); if (caretColor == null) caretColor = new JBColor(CARET_DARK, CARET_LIGHT); g.setColor(caretColor); for (EditorImpl.CaretRectangle location : locations) { int x = location.myPoint.x; int y = location.myPoint.y; Caret caret = location.myCaret; boolean isRtl = location.myIsRtl; if (myEditor.isInsertMode() != settings.isBlockCursor()) { int lineWidth = JBUI.scale(settings.getLineCursorWidth()); g.fillRect(x, y, lineWidth, lineHeight); if (myDocument.getTextLength() > 0 && caret != null && !myView.getLineLayout(caret.getLogicalPosition().line).isLtr()) { g.fillPolygon( new int[] { isRtl ? x + lineWidth : x, isRtl ? x + lineWidth - CARET_DIRECTION_MARK_SIZE : x + CARET_DIRECTION_MARK_SIZE, isRtl ? x + lineWidth : x }, new int[] {y, y, y + CARET_DIRECTION_MARK_SIZE}, 3); } } else { int width = location.myWidth; int startX = Math.max(0, isRtl ? x - width : x); g.fillRect(startX, y, width, lineHeight - 1); if (myDocument.getTextLength() > 0 && caret != null) { int targetVisualColumn = caret.getVisualPosition().column; for (VisualLineFragmentsIterator.Fragment fragment : VisualLineFragmentsIterator.create(myView, caret.getVisualLineStart(), false)) { int startVisualColumn = fragment.getStartVisualColumn(); int endVisualColumn = fragment.getEndVisualColumn(); if (startVisualColumn < targetVisualColumn && endVisualColumn > targetVisualColumn || startVisualColumn == targetVisualColumn && !isRtl || endVisualColumn == targetVisualColumn && isRtl) { g.setColor(ColorUtil.isDark(caretColor) ? CARET_LIGHT : CARET_DARK); fragment.draw( g, startX, y + myView.getAscent(), targetVisualColumn - startVisualColumn - (isRtl ? 1 : 0), targetVisualColumn - startVisualColumn + (isRtl ? 0 : 1)); break; } } } } } }
@Override public void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2d = ((Graphics2D) g); g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED); g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF); g2d.setRenderingHint( RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF); g2d.setRenderingHint( RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_OFF); g2d.setRenderingHint( RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_SPEED); g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE); g2d.setColor(Color.BLACK); g2d.fillRect(0, 0, getWidth(), getHeight()); if (bufferedImage != null) { synchronized (LOCKER) { g2d.drawImage(bufferedImage, transformCells, null); } } // draw struct preview if (structurePreview != null) { Composite composite = g2d.getComposite(); g2d.setComposite(compositeStructPreview); g2d.drawImage(structurePreview, previewTransform, null); g2d.setComposite(composite); } // draw grid if (transformCells.getScaleX() > SHOW_GRID_MIN_SCALE) { Composite composite = g2d.getComposite(); g2d.setComposite(compositeGrid); g2d.drawImage(bufferedImageGrid, transformGrid, null); g2d.setComposite(composite); } // draw border for preview if (structurePreview != null && Math.abs(transformCells.getScaleX()) >= 0.95) { Shape shape = new Rectangle(0, 0, structurePreview.getWidth(), structurePreview.getHeight()); shape = previewTransform.createTransformedShape(shape); g2d.setColor(Color.RED); g2d.draw(shape); } // draw border double x = transformCells.getTranslateX(); double y = transformCells.getTranslateY(); g2d.setColor(BORDER_COLOR); g2d.setStroke(new BasicStroke(BORDER_WIDTH)); g2d.drawRect( round(x - BORDER_WIDTH), round(y - BORDER_WIDTH), round(getAutomatonWidth() * transformCells.getScaleX() + 2 * BORDER_WIDTH), round(getAutomatonHeight() * transformCells.getScaleY() + 2 * BORDER_WIDTH)); }