/** * Draws as much as possible of a given string into a 2d square region in a graphical space. * * @param g component onto which to draw * @param f font to use in drawing the string * @param s string to be drawn * @param xPos * @param yPos * @param width * @param height */ public static void drawStringMultiline( Graphics2D g, Font f, String s, double xPos, double yPos, double width, double height) { FontMetrics fm = g.getFontMetrics(f); int w = fm.stringWidth(s); int h = fm.getAscent(); // g.setColor(Color.LIGHT_GRAY); g.setColor(Color.BLACK); g.setFont(f); Scanner lineSplitter = new Scanner(s); // draw as much as can fit in each item // read all content from scanner, storing in string lists (where each string == 1 line), each // string should be as long as possible without overflowing the space int maxRows = (int) height / h; List<String> textRows = new ArrayList<>(); while (lineSplitter.hasNextLine() && textRows.size() < maxRows) { String line = lineSplitter.nextLine(); // if line is blank, insert to maintain paragraph seps if (line.trim().equals("")) { textRows.add(""); } // else, pass to inner loop StringBuilder currentBuilder = new StringBuilder(); int currentStrWidth = 0; Scanner splitter = new Scanner(line); while (splitter.hasNext() && textRows.size() < maxRows) { String token = splitter.next() + " "; // TODO incorporate weight detection, formatting for token? currentStrWidth += fm.stringWidth(token); if (currentStrWidth >= width) { // if string length >= glyph width, build row textRows.add(currentBuilder.toString()); currentBuilder = new StringBuilder(); currentBuilder.append(token); currentStrWidth = fm.stringWidth(token); } else { // if not yet at end of row, append to builder currentBuilder.append(token); } } // if we've still space and still have things to write, add them here if (textRows.size() < maxRows) { textRows.add(currentBuilder.toString()); currentBuilder = new StringBuilder(); currentStrWidth = 0; } } // write each line to object for (int t = 0; t < textRows.size(); t++) { String line = textRows.get(t); if (fm.stringWidth(line) <= width) { // ensure that string doesn't overflow the box // g.drawString(line, (float) (xPos-(width/2.)), (float) (yPos-(height/2.) + // h * (t+1))); g.drawString(line, (float) xPos, (float) (yPos + h * (t + 1))); } } }
public void backgroundImpl() { if (backgroundAlpha) { // Create a small array that can be used to set the pixels several times. // Using a single-pixel line of length 'width' is a tradeoff between // speed (setting each pixel individually is too slow) and memory // (an array for width*height would waste lots of memory if it stayed // resident, and would terrify the gc if it were re-created on each trip // to background(). WritableRaster raster = ((BufferedImage) image).getRaster(); if ((clearPixels == null) || (clearPixels.length < width)) { clearPixels = new int[width]; } java.util.Arrays.fill(clearPixels, backgroundColor); for (int i = 0; i < height; i++) { raster.setDataElements(0, i, width, 1, clearPixels); } } else { // new Exception().printStackTrace(System.out); // in case people do transformations before background(), // need to handle this with a push/reset/pop pushMatrix(); resetMatrix(); g2.setColor(new Color(backgroundColor)); // , backgroundAlpha)); g2.fillRect(0, 0, width, height); popMatrix(); } }
@Override protected void paintBackground(Graphics g, JComponent component) { getGlassParameters(); Graphics2D g2d = (Graphics2D) g.create(); if (getOrientation().isHorizontal()) { paintBackground( g2d, 0, 0, component.getWidth(), component.getHeight(), getOrientation().isHorizontal(), component); } else { paintBackground( g2d, 0, 0, component.getHeight(), component.getWidth(), getOrientation().isHorizontal(), component); } g2d.dispose(); }
// From: http://forum.java.sun.com/thread.jspa?threadID=378460&tstart=135 void drawArrow( Graphics2D g2d, int xCenter, int yCenter, int x, int y, float stroke, BasicStroke drawStroke) { double aDir = Math.atan2(xCenter - x, yCenter - y); // Line can be dashed. g2d.setStroke(drawStroke); g2d.drawLine(x, y, xCenter, yCenter); // make the arrow head solid even if dash pattern has been specified g2d.setStroke(lineStroke); Polygon tmpPoly = new Polygon(); int i1 = 12 + (int) (stroke * 2); // make the arrow head the same size regardless of the length length int i2 = 6 + (int) stroke; tmpPoly.addPoint(x, y); tmpPoly.addPoint(x + xCor(i1, aDir + .5), y + yCor(i1, aDir + .5)); tmpPoly.addPoint(x + xCor(i2, aDir), y + yCor(i2, aDir)); tmpPoly.addPoint(x + xCor(i1, aDir - .5), y + yCor(i1, aDir - .5)); tmpPoly.addPoint(x, y); // arrow tip g2d.drawPolygon(tmpPoly); // Remove this line to leave arrow head unpainted: g2d.fillPolygon(tmpPoly); }
/** * Override the pain method do draw the axis lines * * @param g The graphics to paint to */ public void paint(Graphics g) { Rectangle b = getBounds(); g.setColor(canvasBg); g.fillRect(0, 0, b.width, b.height); paintGrid(g); Point center = getCenter(); if (g instanceof Graphics2D) { ((Graphics2D) g).translate(center.x, center.y); } super.paint(g); if (g instanceof Graphics2D) { ((Graphics2D) g).scale(1.0, 1.0); } g.setColor(Color.gray); g.drawLine(0, -10 * b.height, 0, 10 * b.height); g.drawLine(-10 * b.width, 0, 10 * b.width, 0); MetSymbol tmp = highlightedMetSymbol; if (tmp != null) { Rectangle tb = tmp.getBounds(); g.setColor(Color.red); g.drawRect(tb.x - 2, tb.y - 2, tb.width + 4, tb.height + 4); } }
protected void drawImageMosaic(Graphics2D g2) { // Break the image up into tiles. Draw each // tile with its own transparency, allowing // the background to show through to varying // degrees. int side = 36; int width = mImage.getWidth(); int height = mImage.getHeight(); for (int y = 0; y < height; y += side) { for (int x = 0; x < width; x += side) { // Calculate an appropriate transparency value. float xBias = (float) x / (float) width; float yBias = (float) y / (float) height; float alpha = 1.0f - Math.abs(xBias - yBias); g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha)); // Draw the subimage. int w = Math.min(side, width - x); int h = Math.min(side, height - y); BufferedImage tile = mImage.getSubimage(x, y, w, h); g2.drawImage(tile, x, y, null); } } // Reset the composite. g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER)); }
public BufferedImage createCrystalCase(Image cover) { BufferedImage crystal = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_ARGB); Graphics2D g2 = crystal.createGraphics(); g2.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); int width = cover.getWidth(null); int height = cover.getHeight(null); float scale; if (width > height) { scale = (float) IMAGE_WIDTH / (float) width; } else { scale = (float) IMAGE_HEIGHT / (float) height; } int scaledWidth = (int) ((float) width * scale); int scaledHeight = (int) ((float) height * scale); int x = (IMAGE_WIDTH - scaledWidth) / 2; int y = (IMAGE_HEIGHT - scaledHeight) / 2; g2.drawImage(cover, x, y, scaledWidth, scaledHeight, null); g2.dispose(); return crystal; }
private static BufferedImage makeBufferedImage(Icon icon, int w, int h) { BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); Graphics2D g = image.createGraphics(); icon.paintIcon(null, g, (w - icon.getIconWidth()) / 2, (h - icon.getIconWidth()) / 2); g.dispose(); return image; }
/** * Write the given text string in the current font, centered on (x, y) and rotated by the * specified number of degrees * * @param x the center x-coordinate of the text * @param y the center y-coordinate of the text * @param s the text * @param degrees is the number of degrees to rotate counterclockwise */ public static void text(double x, double y, String s, double degrees) { double xs = scaleX(x); double ys = scaleY(y); offscreen.rotate(Math.toRadians(-degrees), xs, ys); text(x, y, s); offscreen.rotate(Math.toRadians(+degrees), xs, ys); }
/** [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); }
/** paint the canvas into a image file of given width and height */ public void writeToImage(String s, int w, int h) { String ext; File f; try { ext = s.substring(s.lastIndexOf(".") + 1); f = new File(s); } catch (Exception e) { System.out.println(e); return; } if (!ext.equals("jpg") && !ext.equals("png")) { System.out.println("Cannot write to file: Illegal extension " + ext); return; } boolean opq = true; if (theOpaque != null) opq = theOpaque; BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); Graphics2D g2 = image.createGraphics(); g2.setBackground(Color.white); g2.setPaint(Color.black); g2.setStroke(new BasicStroke(1)); g2.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC); doBuffer(g2, true, new Rectangle(0, 0, w, h)); try { ImageIO.write(image, ext, f); } catch (Exception e) { System.out.println(e); } }
public void paint(Graphics g) { super.paint(g); Graphics2D g2d = (Graphics2D) g; g2d.draw( new Ellipse2D.Double( centerx - (centery - 500), centery - (centery - 500), 2 * (centery - 500), 2 * (centery - 500))); try { g2d.draw( new Ellipse2D.Double( player.x - player.size / 2, player.y - player.size / 2, player.size, player.size)); } catch (NullPointerException e) { } k = 1; while (k <= ballCount) { g2d.draw( new Ellipse2D.Double( ball[k].x - ball[k].size / 2, ball[k].y - ball[k].size / 2, ball[k].size, ball[k].size)); k++; } }
/** * Method to paint this path segment * * @param g the graphics context */ public void paintComponent(Graphics g) { Graphics2D g2 = (Graphics2D) g; BasicStroke penStroke = new BasicStroke(this.width); g2.setStroke(penStroke); g2.setColor(this.color); g2.draw(this.line); }
/** * Draw method * * @param g2 Graphics element * @param select Selected node */ public void draw(Graphics2D g2, boolean select) { Point pinit = new Point(centre.x - 25, centre.y - 25); Point pfin = new Point(centre.x + 25, centre.y + 25); figure = new RoundRectangle2D.Float( pinit.x, pinit.y, Math.abs(pfin.x - pinit.x), Math.abs(pfin.y - pinit.y), 20, 20); g2.setColor(Color.black); if (select) { Stroke s = g2.getStroke(); g2.setStroke( new BasicStroke( 5, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0, new float[] {1, 1}, 0)); g2.draw(figure); g2.setStroke(s); } else { g2.draw(figure); } g2.drawImage(image, centre.x - 25, centre.y - 25, 50, 50, pd); g2.setFont(new Font("Courier", Font.BOLD + Font.ITALIC, 12)); FontMetrics metrics = g2.getFontMetrics(); int width = metrics.stringWidth(dsc.getName()); int height = metrics.getHeight(); g2.drawString(dsc.getName(), centre.x - width / 2, centre.y + 40); }
void drawLine(Graphics g, DrawObject L) { if (L == null) { return; } if ((sequencingOn) && (L.sequenceNum != currentSequenceNumDisplay)) { return; } Graphics2D g2 = (Graphics2D) g; g2.setStroke(L.drawStroke); int x1 = (int) ((L.x - minX) / (maxX - minX) * (D.width - 2 * inset)); int y1 = (int) ((L.y - minY) / (maxY - minY) * (D.height - 2.0 * inset)); int x2 = (int) ((L.x2 - minX) / (maxX - minX) * (D.width - 2 * inset)); int y2 = (int) ((L.y2 - minY) / (maxY - minY) * (D.height - 2.0 * inset)); if (L.isArrow) { drawArrow( (Graphics2D) g, inset + x1, D.height - y1 - inset, inset + x2, D.height - y2 - inset, 1.0f, L.drawStroke); } else { g.drawLine(inset + x1, D.height - y1 - inset, inset + x2, D.height - y2 - inset); } }
public void paint(Graphics g) { Graphics2D g_2d = (Graphics2D) g; Ellipse2D ellipse = new Ellipse2D.Double(0, 2, 80, 80); Rectangle2D rect = new Rectangle2D.Double(40, 2, 80, 80); Area a1 = new Area(ellipse); Area a2 = new Area(rect); a1.intersect(a2); // "Óë" g_2d.fill(a1); ellipse.setFrame(130, 2, 80, 80); rect.setFrame(170, 2, 80, 80); a1 = new Area(ellipse); a2 = new Area(rect); a1.add(a2); // "»ò" g_2d.draw(a1); ellipse.setFrame(0, 90, 80, 80); rect.setFrame(40, 90, 80, 80); a1 = new Area(ellipse); a2 = new Area(rect); a1.subtract(a2); // "²î" g_2d.draw(a1); ellipse.setFrame(130, 90, 80, 80); rect.setFrame(170, 90, 80, 80); a1 = new Area(ellipse); a2 = new Area(rect); a1.exclusiveOr(a2); // "Òì»ò" g_2d.fill(a1); }
/** * Erases the ball. * * @param ballGraphic The graphics object to use. */ public void erase(Graphics2D ballGraphic) { double upperLeftX = _position.x - (_pixelWidth / 2); double upperLeftY = _position.y - (_pixelHeight / 2); ballGraphic.setPaint(Color.WHITE); ballGraphic.fillOval((int) upperLeftX, (int) upperLeftY, _pixelWidth, _pixelHeight); }
protected void paintComponent(Graphics g2) { super.paintComponent(g2); Graphics2D g = (Graphics2D) g2; test.draw(g2, 0, 0); // Shape triangle = new Polygon(new int[] {15, 20, 10}, new int[] {0, 10, 10}, 3); Shape square = new Rectangle2D.Double(0, 0, 30, 30); g.setColor(Color.white); g.translate(20, 20); // g.rotate(theta, 10, 10); // g.fill(star); // g.setColor(new Color(0, 86, 141)); // g.fill(square); if (star2 != null) g.fill(star2); // Graphics2D g3 = (Graphics2D) g; // 3.fill(star); // g.setStroke(new BasicStroke(1)); // g.translate(x, y); // g.draw(line); // g.draw(line2); }
/** Draws the edge structure of the tree */ public void drawEdges(Graphics2D gg) { gg.setPaint(Color.black); Enumeration nodeList = argument.getBreadthFirstTraversal().elements(); // For each vertex... while (nodeList.hasMoreElements()) { // Get its edge list... TreeVertex vertex = (TreeVertex) nodeList.nextElement(); Enumeration edges = vertex.getEdgeList().elements(); // For each edge in the list... while (edges.hasMoreElements()) { TreeEdge edge = (TreeEdge) edges.nextElement(); // If we have several vertices on layer 0, only draw // edges for layers below that if (!(argument.isMultiRoots() && vertex.getLayer() == 0)) { // If the edge has been selected with the mouse, // use a thick line if (edge.isSelected()) { gg.setStroke(selectStroke); } gg.draw(edge.getShape(this)); // If we used a thick line, reset the stroke to normal // line for next edge. if (edge.isSelected()) { gg.setStroke(solidStroke); } TreeVertex edgeSource = edge.getDestVertex(); } } } }
public void draw(Graphics2D g2, boolean shouldFlip) { Font font = new Font("Sans_Serif", Font.PLAIN, 30); g2.setColor(Color.orange); g2.fillOval((int) x - 10, (int) (FieldConstants.FIELD_HEIGHT - y - 10), 20, 20); font = new Font("Sans_Serif", Font.PLAIN, 18); g2.setFont(font); g2.drawString(Double.toString(confidence), x, FieldConstants.FIELD_HEIGHT - y + 60); }
public void paintComponent(Graphics g) { Graphics2D g2 = (Graphics2D) g; Rectangle2D rect = new Rectangle2D.Double(0, 0, getWidth() - 1, getHeight() - 1); g2.setPaint(Color.YELLOW); g2.fill(rect); g2.setPaint(Color.BLUE); g2.draw(rect); }
public Image getImage() { BufferedImage image = new BufferedImage(getIconWidth(), getIconHeight(), BufferedImage.TYPE_INT_ARGB); Graphics2D g = image.createGraphics(); paintIcon(null, g, 0, 0); g.dispose(); return image; }
public void smooth() { smooth = true; g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2.setRenderingHint( RenderingHints.KEY_INTERPOLATION, // RenderingHints.VALUE_INTERPOLATION_BILINEAR); RenderingHints.VALUE_INTERPOLATION_BICUBIC); }
private void drawArrow(Graphics2D g2, double theta, double x0, double y0) { double x = x0 - barb * Math.cos(theta + phi); double y = y0 - barb * Math.sin(theta + phi); g2.draw(new Line2D.Double(x0, y0, x, y)); x = x0 - barb * Math.cos(theta - phi); y = y0 - barb * Math.sin(theta - phi); g2.draw(new Line2D.Double(x0, y0, x, y)); }
public int print(Graphics g, PageFormat pf, int page) throws PrinterException { Graphics2D g2 = (Graphics2D) g; if (page > getPageCount(g2, pf)) return Printable.NO_SUCH_PAGE; g2.translate(pf.getImageableX(), pf.getImageableY()); drawPage(g2, pf, page); return Printable.PAGE_EXISTS; }
public void paintVertex(Graphics g) { Graphics2D g2 = (Graphics2D) g; g2.setColor(this.getFillColor()); g2.fill(this); g2.setColor(this.border); g2.draw(this); }
public int print(Graphics g, PageFormat pgFmt, int pgIndex) { if (pgIndex > 0) return Printable.NO_SUCH_PAGE; Graphics2D g2d = (Graphics2D) g; g2d.translate(pgFmt.getImageableX(), pgFmt.getImageableY()); doPaint(g2d); return Printable.PAGE_EXISTS; }
private void shadeExt(Graphics2D g2, int r, int g, int b, int a) { g2.setPaint(new Color(r, g, b, a)); g2.fillRect(0, 0, iw, rect.y); /* _N_ */ g2.fillRect( rect.x + rect.width + 1, rect.y, iw - rect.x - rect.width - 1, rect.height + 1); /* E */ g2.fillRect(0, rect.y, rect.x, rect.height + 1); /* W */ g2.fillRect(0, rect.y + rect.height + 1, iw, ih - rect.y - rect.height - 1); /* _S_ */ }
//////////////////////////////////////////////////////////////////////////// // Paint // public synchronized void paint(Graphics g) { Graphics2D g2 = (Graphics2D) g; // Graphics2D buffGraphics2 = (Graphics2D) buffGraphics; // g2.drawImage(bImage, 3, 3, getWidth() - 3, getHeight() - 3, // 0, 0, iWidth, iHeight, null); g2.drawImage(bImage, 0, 0, iWidth, iHeight, null); g2.drawString(String.valueOf(System.currentTimeMillis()), 10, 10); }
private void applyAlphaMask( BufferedImage buffer, BufferedImage alphaMask, int itemWidth, int itemHeight) { Graphics2D g2 = buffer.createGraphics(); g2.setComposite(AlphaComposite.DstOut); g2.drawImage(alphaMask, null, 0, itemHeight); g2.dispose(); }