/** This method is invoked before the rendered image of the figure is composited. */ public void drawFigure(Graphics2D g) { AffineTransform savedTransform = null; if (get(TRANSFORM) != null) { savedTransform = g.getTransform(); g.transform(get(TRANSFORM)); } if (get(FILL_STYLE) != ODGConstants.FillStyle.NONE) { Paint paint = ODGAttributeKeys.getFillPaint(this); if (paint != null) { g.setPaint(paint); drawFill(g); } } if (get(STROKE_STYLE) != ODGConstants.StrokeStyle.NONE) { Paint paint = ODGAttributeKeys.getStrokePaint(this); if (paint != null) { g.setPaint(paint); g.setStroke(ODGAttributeKeys.getStroke(this)); drawStroke(g); } } if (get(TRANSFORM) != null) { g.setTransform(savedTransform); } }
@Test public void drawWithClipAndTransform() throws Exception { graphics.setPaint(Color.BLACK); graphics.fill(imageBounds); AffineTransform tr = AffineTransform.getRotateInstance( Math.PI / 4, image.getMinX() + image.getWidth() / 2, image.getMinY() + image.getHeight() / 2); graphics.transform(tr); graphics.clip(midRect); graphics.setPaint(Color.RED); graphics.fill(imageBounds); showImage("drawWithClipAndTransform"); // Outside transformed clip region Rectangle outer = new Rectangle(midRect); outer.grow(5, 5); Point2D[] corners = getCorners(outer); Point2D[] trPoints = new Point2D[corners.length]; tr.transform(corners, 0, trPoints, 0, corners.length); assertColor(Color.BLACK, trPoints); // Inside transformed clip region Rectangle inner = new Rectangle(midRect); inner.grow(-5, -5); corners = getCorners(inner); tr.transform(corners, 0, trPoints, 0, corners.length); assertColor(Color.RED, trPoints); }
@Override protected void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2d = (Graphics2D) g; g2d.setBackground(Color.LIGHT_GRAY); g2d.clearRect(0, 0, getParent().getWidth(), getParent().getHeight()); // Red line g2d.setPaint(Color.RED); // 5 visible, 5 invisible final float dash[] = {5, 5}; // 10 thick, end lines with no cap, // any joins make round, miter limit, // dash array, dash phase final BasicStroke dashed = new BasicStroke(10, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 0, dash, 0); g2d.setStroke(dashed); g2d.drawLine(100, 10, 10, 110); // White line g2d.setPaint(Color.WHITE); g2d.setStroke(new BasicStroke(10.0f)); g2d.draw(new Line2D.Float(150, 10, 10, 160)); // Blue line g2d.setPaint(Color.BLUE); Stroke solidStroke = new BasicStroke(10, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND); g2d.setStroke(solidStroke); g2d.draw(new Line2D.Float(new Point2D.Float(200, 10), new Point2D.Double(10, 210))); }
/** * Draws the textured background on the side panel * * @param g */ private void drawBackground(Graphics g, int width, int height) { Graphics2D g2d = (Graphics2D) g; Color color1 = new Color(210, 230, 220, 50); Color color2 = new Color(40, 65, 45, 200); GradientPaint gp = new GradientPaint(0, 0, color1, 0, height, color2); TexturePaint tp = new TexturePaint( backTexture, new Rectangle2D.Double(0, 0, backTexture.getWidth(), backTexture.getHeight())); // Draw the texture g2d.setPaint(tp); g2d.fillRect(0, 0, width, height); // Draw the gradient g2d.setPaint(gp); g2d.fillRect(0, 0, width, height); // Draw the bevel g2d.setColor(new Color(255, 255, 255, 50)); g2d.fillRect(0, 0, 5, height); g2d.setColor(new Color(0, 0, 0, 100)); g2d.fillRect(width - 5, 0, 5, height); }
public void drawConditionalSequenceFlowIndicator(Line2D.Double line) { int horizontal = (int) (CONDITIONAL_INDICATOR_WIDTH * 0.7); int halfOfHorizontal = horizontal / 2; int halfOfVertical = CONDITIONAL_INDICATOR_WIDTH / 2; Polygon conditionalIndicator = new Polygon(); conditionalIndicator.addPoint(0, 0); conditionalIndicator.addPoint(-halfOfHorizontal, halfOfVertical); conditionalIndicator.addPoint(0, CONDITIONAL_INDICATOR_WIDTH); conditionalIndicator.addPoint(halfOfHorizontal, halfOfVertical); AffineTransform transformation = new AffineTransform(); transformation.setToIdentity(); double angle = Math.atan2(line.y2 - line.y1, line.x2 - line.x1); transformation.translate(line.x1, line.y1); transformation.rotate((angle - Math.PI / 2d)); AffineTransform originalTransformation = g.getTransform(); g.setTransform(transformation); g.draw(conditionalIndicator); Paint originalPaint = g.getPaint(); g.setPaint(CONDITIONAL_INDICATOR_COLOR); g.fill(conditionalIndicator); g.setPaint(originalPaint); g.setTransform(originalTransformation); }
@Override protected void paintIcon( java.awt.Component c, java.awt.Graphics2D g2, int width, int height, java.awt.Paint fillPaint, java.awt.Paint drawPaint) { java.awt.Font prevFont = g2.getFont(); g2.setFont(font); String text = "A"; java.awt.FontMetrics fm = g2.getFontMetrics(); int messageWidth = fm.stringWidth(text); int ascent = fm.getMaxAscent(); int descent = fm.getMaxDescent(); int x = (width / 2) - (messageWidth / 2); int y = ((height / 2) + (ascent / 2)) - (descent / 2); java.awt.font.GlyphVector glyphVector = font.createGlyphVector(g2.getFontRenderContext(), text); java.awt.Shape outline = glyphVector.getOutline(x, y); g2.setPaint(drawPaint); g2.draw(outline); g2.setPaint(fillPaint); g2.fill(outline); // g2.drawString( text, x, y ); g2.setFont(prevFont); }
/** * Draws the band. * * @param g2 the graphics device. * @param plotArea the plot area. * @param dataArea the data area. * @param x the x-coordinate. * @param y the y-coordinate. */ public void draw(Graphics2D g2, Rectangle2D plotArea, Rectangle2D dataArea, double x, double y) { double h = getHeight(g2); Iterator iterator = this.markers.iterator(); while (iterator.hasNext()) { IntervalMarker marker = (IntervalMarker) iterator.next(); double start = Math.max(marker.getStartValue(), this.axis.getRange().getLowerBound()); double end = Math.min(marker.getEndValue(), this.axis.getRange().getUpperBound()); double s = this.axis.valueToJava2D(start, dataArea, RectangleEdge.BOTTOM); double e = this.axis.valueToJava2D(end, dataArea, RectangleEdge.BOTTOM); Rectangle2D r = new Rectangle2D.Double( s, y + this.topOuterGap, e - s, h - this.topOuterGap - this.bottomOuterGap); Composite originalComposite = g2.getComposite(); g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, marker.getAlpha())); g2.setPaint(marker.getPaint()); g2.fill(r); g2.setPaint(marker.getOutlinePaint()); g2.draw(r); g2.setComposite(originalComposite); g2.setPaint(Color.black); drawStringInRect(g2, r, this.font, marker.getLabel()); } }
/** * Draws the circle. * * @param g2 the graphics device. * @param area the area in which to draw. */ public void draw(Graphics2D g2, Rectangle2D area) { Ellipse2D ellipse = new Ellipse2D.Double( area.getX(), area.getY(), area.getWidth(), area.getHeight()); if (this.fillPaint != null) { g2.setPaint(this.fillPaint); g2.fill(ellipse); } if (this.outlinePaint != null && this.outlineStroke != null) { g2.setPaint(this.outlinePaint); g2.setStroke(this.outlineStroke); g2.draw(ellipse); } g2.setPaint(Color.black); g2.setStroke(new BasicStroke(1.0f)); Line2D line1 = new Line2D.Double( area.getCenterX(), area.getMinY(), area.getCenterX(), area.getMaxY()); Line2D line2 = new Line2D.Double( area.getMinX(), area.getCenterY(), area.getMaxX(), area.getCenterY()); g2.draw(line1); g2.draw(line2); }
// Actually draws the rectangle public void draw(Graphics g) { Graphics2D g2 = (Graphics2D) g; // create a Graphics2D object if (getGradient()) { GradientPaint gradientPaint = new GradientPaint( getUpperLeftX(), getUpperLeftY(), getColor(), getUpperLeftX() + getWidth(), getUpperLeftY() + getHeight(), getColor2()); g2.setPaint(gradientPaint); } else g2.setPaint(getColor()); if (getDashed()) { float dash1[] = {10.0f}; BasicStroke dashedLine = new BasicStroke( getDashLength(), BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash1, 0.0f); g2.setStroke(dashedLine); } else { g2.setStroke(new BasicStroke(getStrokeWidth())); } if (getFilledF()) g2.fill(new Rectangle2D.Double(getUpperLeftX(), getUpperLeftY(), getWidth(), getHeight())); else g2.draw(new Rectangle2D.Double(getUpperLeftX(), getUpperLeftY(), getWidth(), getHeight())); }
/** * Draws an arc. * * @param g2 the graphics device. * @param area the plot area. * @param minValue the minimum value. * @param maxValue the maximum value. * @param paint the paint. * @param stroke the stroke. */ protected void drawArc( Graphics2D g2, Rectangle2D area, double minValue, double maxValue, Paint paint, Stroke stroke) { double startAngle = valueToAngle(maxValue); double endAngle = valueToAngle(minValue); double extent = endAngle - startAngle; double x = area.getX(); double y = area.getY(); double w = area.getWidth(); double h = area.getHeight(); g2.setPaint(paint); g2.setStroke(stroke); if (paint != null && stroke != null) { Arc2D.Double arc = new Arc2D.Double(x, y, w, h, startAngle, extent, Arc2D.OPEN); g2.setPaint(paint); g2.setStroke(stroke); g2.draw(arc); } }
/** * Paint a background for all groups and a round blue border and background when a cell is * selected. * * @param g2 the <tt>Graphics2D</tt> object through which we paint */ private void internalPaintComponent(Graphics2D g2) { Color borderColor = Color.GRAY; if (isSelected) { g2.setPaint( new GradientPaint( 0, 0, Constants.SELECTED_COLOR, 0, getHeight(), Constants.SELECTED_GRADIENT_COLOR)); borderColor = Constants.SELECTED_COLOR; } else if (treeNode instanceof GroupNode) { g2.setPaint( new GradientPaint( 0, 0, Constants.CONTACT_LIST_GROUP_BG_GRADIENT_COLOR, 0, getHeight(), Constants.CONTACT_LIST_GROUP_BG_COLOR)); borderColor = Constants.CONTACT_LIST_GROUP_BG_COLOR; } g2.fillRect(0, 0, getWidth(), getHeight()); g2.setColor(borderColor); g2.drawLine(0, 0, getWidth(), 0); g2.drawLine(0, getHeight() - 1, getWidth(), getHeight() - 1); }
/** * Paint 3D effect in (lighten in upper half, darken in lowerhalf) (called from paint methods) * * @param g2D Graphics * @param c Component * @param round paint round corners * @param out paint sticking out (not pressed) */ public static void paint3Deffect(Graphics2D g2D, JComponent c, boolean round, boolean out) { // paint upper gradient GradientPaint topPaint = null; if (out) topPaint = new GradientPaint(0, 0, COL_1TOP, 0, c.getHeight() / 2, COL_1END); else topPaint = new GradientPaint(0, 0, COL_2END, 0, c.getHeight() / 2, COL_2TOP); g2D.setPaint(topPaint); // RectangularShape topRec = null; if (round) topRec = new RoundRectangle2D.Float(0, 0, c.getWidth(), c.getHeight() / 2, 15, 15); else topRec = new Rectangle(0, 0, c.getWidth(), c.getHeight() / 2); g2D.fill(topRec); // paint lower gradient GradientPaint endPaint = null; if (out) endPaint = new GradientPaint(0, c.getHeight() / 2, COL_2TOP, 0, c.getHeight(), COL_2END); else endPaint = new GradientPaint(0, c.getHeight() / 2, COL_1END, 0, c.getHeight(), COL_1TOP); g2D.setPaint(endPaint); // RectangularShape endRec = null; if (round) endRec = new RoundRectangle2D.Float(0, c.getHeight() / 2, c.getWidth(), c.getHeight() / 2, 15, 15); else endRec = new Rectangle(0, c.getHeight() / 2, c.getWidth(), c.getHeight() / 2); g2D.fill(endRec); } // paint3Deffect
/** * Paint 3D effect in (lighten in upper half, darken in lowerhalf) (called from paint methods) * * @param g2D Graphics * @param r Ractangle * @param round paint round corners * @param out paint sticking out (not pressed) */ public static void paint3Deffect(Graphics2D g2D, Rectangle r, boolean round, boolean out) { // paint upper gradient GradientPaint topPaint = null; if (out) topPaint = new GradientPaint(r.x, r.y, COL_1TOP, r.x, r.y + r.height / 2, COL_1END); else topPaint = new GradientPaint(r.x, r.y, COL_2END, r.x, r.y + r.height / 2, COL_2TOP); g2D.setPaint(topPaint); // RectangularShape topRec = null; if (round) topRec = new RoundRectangle2D.Float(r.x, r.y, r.width, r.height / 2, 15, 15); else topRec = new Rectangle(r.x, r.y, r.width, r.height / 2); g2D.fill(topRec); // paint lower gradient GradientPaint endPaint = null; // upper left corner to lower left if (out) endPaint = new GradientPaint(r.x, r.y + r.height / 2, COL_2TOP, r.x, r.y + r.height, COL_2END); else endPaint = new GradientPaint(r.x, r.y + r.height / 2, COL_1END, r.x, r.y + r.height, COL_1TOP); g2D.setPaint(endPaint); // RectangularShape endRec = null; if (round) endRec = new RoundRectangle2D.Float(r.x, r.y + r.height / 2, r.width, r.height / 2, 15, 15); else endRec = new Rectangle(r.x, r.y + r.height / 2, r.width, r.height / 2); g2D.fill(endRec); } // paint3Deffect
public void paintBorder(final Component c, Graphics g, int x, int y, int width, int height) { Graphics2D g2d = (Graphics2D) g; GradientPaint paint; Paint oldPaint = g2d.getPaint(); int textX; Font f = c.getFont(); g2d.setFont(f); x += 2; width -= 1; if (c.getComponentOrientation() == ComponentOrientation.RIGHT_TO_LEFT) { textX = x + width - 4 - g2d.getFontMetrics().stringWidth(title); paint = new GradientPaint(x, y, destinationColor, width, height, sourceColor); } else { y += 2; textX = x + 4; paint = new GradientPaint(x, y, sourceColor, width, height, destinationColor); } height = f.getSize() + 6; g2d.setPaint(paint); g2d.fillRect(x, y, width, height); g2d.setPaint(oldPaint); g2d.setColor(textColor); g2d.drawString(title, textX, y + height - 5); }
/** * Draws the graphic item within the specified area. * * @param g2 the graphics device. * @param area the area. */ public void draw(Graphics2D g2, Rectangle2D area) { area = (Rectangle2D) area.clone(); area = trimMargin(area); drawBorder(g2, area); area = trimBorder(area); area = trimPadding(area); if (this.lineVisible) { Point2D location = RectangleAnchor.coordinates(area, this.shapeLocation); Shape aLine = ShapeUtilities.createTranslatedShape( getLine(), this.shapeAnchor, location.getX(), location.getY()); g2.setPaint(this.linePaint); g2.setStroke(this.lineStroke); g2.draw(aLine); } if (this.shapeVisible) { Point2D location = RectangleAnchor.coordinates(area, this.shapeLocation); Shape s = ShapeUtilities.createTranslatedShape( this.shape, this.shapeAnchor, location.getX(), location.getY()); if (this.shapeFilled) { g2.setPaint(this.fillPaint); g2.fill(s); } if (this.shapeOutlineVisible) { g2.setPaint(this.outlinePaint); g2.setStroke(this.outlineStroke); g2.draw(s); } } }
protected void paintComponent(Graphics g) { if (isOpaque()) { g.setColor(getBackground()); g.fillRect(0, 0, getWidth(), getHeight()); } Insets insets = getInsets(); Graphics2D g2 = (Graphics2D) g.create(); g2.translate(insets.left, insets.top); float strength = getStrength(); int w = getWidth() - insets.left - insets.right; int h = getHeight() - insets.top - insets.bottom; Paint p1; Paint p2; // int p1Width = w * 5 / 8; int barHeight = (int) (strength * (float) h); int p1Width = (int) (strength * (float) h); // int barHeight = w * 5 / 8; Color[] colors; if (strength <= .5f) { colors = RED_COLORS; } else if (strength <= .8f) { colors = YELLOW_COLORS; } else { colors = GREEN_COLORS; } g2.setPaint(new GradientPaint(0, 0, colors[0], p1Width, 0, colors[1])); // g2.fillRect(0, h - barHeight, p1Width, barHeight); g2.fillRect(0, 0, p1Width, h); g2.setPaint(new GradientPaint(p1Width, 0, colors[1], w, 0, colors[2])); // g2.fillRect(p1Width, h - barHeight, w - p1Width, barHeight); g2.fillRect(p1Width, 0, w - p1Width, h); g2.dispose(); }
/** * descriptif de la m�thode (fonctionnalit� de la methode + mini algorithme si elle est * compliqu�e) * * @param g */ public void paintComponent(Graphics g) { boolean bOpaque = isOpaque(); if (bOpaque) { Graphics2D g2d = (Graphics2D) g.create(); GradientPaint gp = null; if (getOrientation() == VERTICAL) { gp = new GradientPaint(0, 0, colorStart, getWidth(), 0, colorEnd, false); } else { gp = new GradientPaint(0, 0, colorStart, 0, getHeight(), colorEnd, false); } Paint oldPaint = g2d.getPaint(); g2d.setPaint(gp); g2d.fill(new Rectangle(0, 0, getWidth(), getHeight())); g2d.setPaint(oldPaint); g2d.dispose(); } setOpaque(false); super.paintComponent(g); setOpaque(bOpaque); }
@Override protected void fillTitleBar(Graphics2D g2) { Paint oldPaint = g2.getPaint(); Stroke oldStroke = g2.getStroke(); g2.setColor(new Color(241, 241, 241)); g2.setStroke(new BasicStroke(1)); g2.drawLine(0, 0, getWidth(), 0); LinearGradientPaint p = new LinearGradientPaint( 1f, 1f, 1f, getHeight() - 1, new float[] {0.0f, 0.499f, 0.5f, 1.0f}, new Color[] { new Color(230, 230, 230), new Color(202, 202, 202), new Color(202, 202, 202), new Color(178, 178, 178) }); g2.setPaint(p); g2.fillRect(0, 0, getWidth(), this.getHeight() - 1); g2.setPaint(oldPaint); g2.setColor(new Color(104, 104, 104)); g2.setStroke(new BasicStroke(1)); g2.drawLine(getX(), getHeight() - 1, getWidth(), getHeight() - 1); g2.setStroke(oldStroke); }
public static synchronized void drawSingleGradientRect( MenuItem item, float x, float y, float width, float height, float roundOff) { Menu menu = item.menu; MenuStyle style = item.getStyle(); roundRect.setRoundRect(x, y, width, height, roundOff, roundOff); Graphics2D g2 = menu.buff.g2; /* * Set the correct fill gradient */ if (item.isOpen()) { g2.setPaint(item.getStyle().getGradient(MenuItem.DOWN, y, y + height)); } else { g2.setPaint(item.getStyle().getGradient(MenuItem.OVER, y, y + height)); } /* * Only perform the fill if the mood is right. */ if (item.getState() != MenuItem.UP || item.isOpen()) { g2.fill(roundRect); } /* * Draw the rounded rectangle outline. */ if (item.getState() != MenuItem.UP || item.isOpen()) { drawRoundOutline(item, roundRect); } }
public void paintBoard(Graphics2D g2) { double gbwidth = boardGridSize * 8d + lineLoc, gbheight = boardGridSize * 9d + lineLoc; g2.setPaint(red); g2.draw3DRect((int) lineLoc / 2, (int) lineLoc / 2, (int) gbwidth, (int) gbheight, true); g2.draw3DRect( (int) lineLoc / 2 + 3, (int) lineLoc / 2 + 3, (int) gbwidth - 6, (int) gbheight - 7, false); g2.setPaint(fg); for (int i = 0; i < 10; i++) { g2.draw( new Line2D.Double( lineLoc, lineLoc + boardGridSize * i, lineLoc + boardGridSize * 8, lineLoc + boardGridSize * i)); } for (int i = 0; i < 9; i++) { g2.draw( new Line2D.Double( lineLoc + boardGridSize * i, lineLoc, lineLoc + boardGridSize * i, lineLoc + boardGridSize * 4)); if (i == 0 || i == 8) g2.draw( new Line2D.Double( lineLoc + boardGridSize * i, lineLoc + boardGridSize * 4, lineLoc + boardGridSize * i, lineLoc + boardGridSize * 9)); else g2.draw( new Line2D.Double( lineLoc + boardGridSize * i, lineLoc + boardGridSize * 5, lineLoc + boardGridSize * i, lineLoc + boardGridSize * 9)); } drawX(lineLoc + boardGridSize * 4, lineLoc + boardGridSize, g2); drawX(lineLoc + boardGridSize * 4, lineLoc + boardGridSize * 8, g2); // black Pao drawLocation(lineLoc + boardGridSize, lineLoc + boardGridSize * 2, center, g2); drawLocation(lineLoc + boardGridSize * 7, lineLoc + boardGridSize * 2, center, g2); // red Pao drawLocation(lineLoc + boardGridSize, lineLoc + boardGridSize * 7, center, g2); drawLocation(lineLoc + boardGridSize * 7, lineLoc + boardGridSize * 7, center, g2); // black Zu drawLocation(lineLoc, lineLoc + boardGridSize * 3, right, g2); drawLocation(lineLoc + boardGridSize * 2, lineLoc + boardGridSize * 3, center, g2); drawLocation(lineLoc + boardGridSize * 4, lineLoc + boardGridSize * 3, center, g2); drawLocation(lineLoc + boardGridSize * 6, lineLoc + boardGridSize * 3, center, g2); drawLocation(lineLoc + boardGridSize * 8, lineLoc + boardGridSize * 3, left, g2); // red bin drawLocation(lineLoc, lineLoc + boardGridSize * 6, right, g2); drawLocation(lineLoc + boardGridSize * 2, lineLoc + boardGridSize * 6, center, g2); drawLocation(lineLoc + boardGridSize * 4, lineLoc + boardGridSize * 6, center, g2); drawLocation(lineLoc + boardGridSize * 6, lineLoc + boardGridSize * 6, center, g2); drawLocation(lineLoc + boardGridSize * 8, lineLoc + boardGridSize * 6, left, g2); // ---------------------------------------------------------------------- }
public static void main(String[] args) throws Exception { BufferedImage image = new BufferedImage(200, 200, BufferedImage.TYPE_INT_RGB); Graphics2D g = image.createGraphics(); g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g.setPaint(Color.WHITE); g.fill(new Rectangle(image.getWidth(), image.getHeight())); g.scale(.9, .9); g.setPaint(Color.BLACK); g.setStroke(new BasicStroke(0.5f)); g.draw(new Ellipse2D.Double(25, 25, 150, 150)); // To visually check it // ImageIO.write(image, "PNG", new File(args[0])); boolean nonWhitePixelFound = false; for (int x = 100; x < 200; ++x) { if (image.getRGB(x, 90) != Color.WHITE.getRGB()) { nonWhitePixelFound = true; break; } } if (!nonWhitePixelFound) { throw new RuntimeException("A circle is rendered like a 'C' shape."); } }
private void createImages() { int w = 16; int h = getPreferredSize().height; setTarget(new Rectangle(2, 0, 20, 18)); Graphics2D g2; open = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); g2 = open.createGraphics(); g2.setPaint(getBackground()); g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2.fillRect(0, 0, w, h); int[] x = {2, w / 2, 14}; int[] y = {4, 13, 4}; Polygon p = new Polygon(x, y, 3); g2.setPaint(new Color(204, 204, 204)); g2.fill(p); g2.draw(p); g2.dispose(); closed = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); g2 = closed.createGraphics(); g2.setPaint(getBackground()); g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2.fillRect(0, 0, w, h); x = new int[] {3, 13, 3}; y = new int[] {4, h / 2, 16}; p = new Polygon(x, y, 3); g2.setPaint(new Color(102, 102, 102)); g2.fill(p); g2.draw(p); g2.dispose(); }
private void drawShape(Shuttle shuttle) { Graphics2D g = shuttle.g; Shape oldclip = shuttle.g.getClip(); g.setClip(shuttle.clip); Composite oldcomposite = g.getComposite(); if (shuttle.opacity != 1f) { g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, shuttle.opacity)); } AffineTransform oldtr = g.getTransform(); g.setTransform(shuttle.transform); Stroke oldStroke = g.getStroke(); Stroke newStroke = new BasicStroke(shuttle.strokeWidth, shuttle.linecap.stroke(), shuttle.linejoin.stroke()); g.setStroke(newStroke); if (shuttle.fill != null) { g.setPaint(shuttle.fill); g.fill(shuttle.shape); } if (shuttle.stroke != null) { g.setPaint(shuttle.stroke); g.draw(shuttle.shape); } g.setClip(oldclip); g.setStroke(oldStroke); g.setTransform(oldtr); g.setComposite(oldcomposite); }
@Override public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) { final Graphics2D g2d = (Graphics2D) g; final Insets ins = getBorderInsets(c); final int yOff = (ins.top + ins.bottom) / 4; final boolean square = DarculaButtonUI.isSquare(c); int offset = JBUI.scale(square ? 1 : getOffset()); if (c.hasFocus()) { DarculaUIUtil.paintFocusRing(g2d, offset, yOff, width - 2 * offset, height - 2 * yOff); } else { final GraphicsConfig config = new GraphicsConfig(g); g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2d.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_DEFAULT); g2d.setPaint( UIUtil.getGradientPaint( width / 2, y + yOff + 1, Gray._80.withAlpha(90), width / 2, height - 2 * yOff, Gray._90.withAlpha(90))); // g.drawRoundRect(x + offset + 1, y + yOff + 1, width - 2 * offset, height - 2*yOff, 5, 5); ((Graphics2D) g).setPaint(Gray._100.withAlpha(180)); g.drawRoundRect( x + offset, y + yOff, width - 2 * offset, height - 2 * yOff, JBUI.scale(square ? 3 : 5), JBUI.scale(square ? 3 : 5)); config.restore(); } }
protected void drawTask(String name, int x, int y, int width, int height, boolean thickBorder) { Paint originalPaint = g.getPaint(); // Create a new gradient paint for every task box, gradient depends on x and y and is not // relative g.setPaint(new GradientPaint(x + 50, y, Color.white, x + 50, y + 50, TASK_BOX_COLOR)); // shape RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width, height, 20, 20); g.fill(rect); g.setPaint(originalPaint); if (thickBorder) { Stroke originalStroke = g.getStroke(); g.setStroke(THICK_TASK_BORDER_STROKE); g.draw(rect); g.setStroke(originalStroke); } else { g.draw(rect); } // text if (name != null) { drawMultilineText(name, x, y, width, height); } }
@Override protected void paintComponent(Graphics g) { Graphics2D gd = (Graphics2D) g.create(); shape = new RoundRectangle2D.Double(0, 0, getWidth(), getHeight(), getHeight(), getWidth()); if (isFokus()) { setForeground(Color.RED); paint = new GradientPaint(0, 0, Color.YELLOW, getWidth(), 0, Color.YELLOW); } else { setForeground(Color.BLACK); paint = new GradientPaint(0, 0, Color.white, getWidth(), 0, Color.white); } gd.setPaint(paint); gd.fill(shape); super.paintComponent(g); glass = new GradientPaint( 0, 0, new Color(1F, 1F, 1F, 0.5F), 0, getHeight(), new Color(1F, 1F, 1F, 0F)); gd.setPaint(glass); gd.fill(shape); gd.dispose(); }
/** * Draw some graphics into an Graphics2D object. * * @param image the image to draw into * @throws NoninvertibleTransformException in transform errors. */ private void draw(Graphics2D gr) throws NoninvertibleTransformException { gr.setPaint(Color.WHITE); gr.fill(new Rectangle(0, 0, tileWidth, tileHeight)); // AffineTransform[[0.318755336305853, 0.0, 420.03106689453125], // [0.0, 0.318755336305853, 245.5029296875]] AffineTransform transform = new AffineTransform( 0.318755336305853, 0.0, 0.0, 0.318755336305853, 420.03106689453125, 245.5029296875); gr.setTransform(transform); Shape s = new Rectangle(0, 0, 96, 83); // create an enbedded graphics Graphics2D grr = (Graphics2D) gr.create(); // AffineTransform[[1.0, 0.0, -343.9285583496093], // [0.0, 1.0, -502.5158386230469]] grr.clip(s.getBounds()); transform = new AffineTransform(1.0, 0.0, 0.0, 1.0, -343.9285583496093, -502.5158386230469); grr.transform(transform); AffineTransform t = transform.createInverse(); s = t.createTransformedShape(s); assertTrue(s.getBounds().intersects(grr.getClip().getBounds2D())); grr.setPaint(Color.BLUE); grr.draw(s); grr.dispose(); gr.dispose(); }
public static void smoothFillInverseHorGradient( Graphics g, Color[] colors, int x, int y, int w, int h) { if (colors != null) { Graphics2D g2D = (Graphics2D) g; Paint savedPaint = g2D.getPaint(); int steps = colors.length; double dy = (double) h / (double) steps; int y1 = y; for (int i = 0; i < steps; i++) { int y2 = y + (int) Math.round((double) i * dy); g.setColor(colors[colors.length - i - 1]); if (i == (steps - 1)) { g2D.setPaint(null); g2D.setColor(colors[colors.length - i - 1]); g.fillRect(x, y1, w, y + h - y1); } else { g2D.setPaint( new GradientPaint( 0, y1, colors[colors.length - i - 1], 0, y2, colors[colors.length - i - 2])); g.fillRect(x, y1, w, y2 - y1); } y1 = y2; } g2D.setPaint(savedPaint); } }
private void drawArrow(Graphics2D g2d, double sx, double sy, double px, double py, int pass) { if (pass == 0) { g2d.setStroke(new BasicStroke(4.0f)); g2d.setPaint(preSynapticSiteColor.brighter()); g2d.draw(new Line2D.Double(sx, sy, px, py)); return; } double dx = px - sx; double dy = py - sy; Polygon tip = new Polygon(); tip.addPoint(0, 0); tip.addPoint(-10, -20); tip.addPoint(10, -20); AffineTransform transform = new AffineTransform(); transform.concatenate(AffineTransform.getTranslateInstance(px, py)); transform.concatenate(AffineTransform.getScaleInstance(0.5, 0.5)); transform.concatenate(AffineTransform.getRotateInstance(Math.atan2(dy, dx) - Math.PI * 0.5)); Shape shape = new GeneralPath(tip).createTransformedShape(transform); g2d.setPaint(preSynapticSiteColor.darker().darker()); g2d.draw(shape); g2d.setPaint(preSynapticSiteColor.brighter().brighter()); g2d.fill(shape); }
/** * DOCUMENT ME! * * @param g DOCUMENT ME! */ public void paintComponent(Graphics g) { int step = 4; int count = 5; int size = step * count; BufferedImage image = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB); Graphics2D biGraphics = image.createGraphics(); biGraphics.setPaint(Color.black); int x = step; for (int i = 0; i < (count * 2); i++) { biGraphics.drawLine(0, x, x, 0); x += step; } Rectangle rect = new Rectangle(0, 0, size, size); TexturePaint paint = new TexturePaint(image, rect); ((Graphics2D) g).setPaint(paint); ((Graphics2D) g).setStroke(new BasicStroke(6)); g.drawRect(10, 10, this.getWidth() - 20, this.getHeight() - 20); }