Java Code Examples for java.awt.Graphics2D#drawArc()

The following examples show how to use java.awt.Graphics2D#drawArc() . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may want to check out the right sidebar which shows the related API usage.
Example 1
public void draw(Graphics2D g2, float x, float y) {
    AffineTransform oldAt = g2.getTransform();
    Color oldC = g2.getColor();
    Stroke oldS = g2.getStroke();
    g2.translate(x + 0.25f * height / 2.15f, y - 1.75f / 2.15f * height);
    g2.setColor(gray);
    g2.setStroke(st);
    g2.scale(0.05f * height / 2.15f, 0.05f * height / 2.15f);
    g2.rotate(-26 * Math.PI / 180, 20.5, 17.5);
    g2.drawArc(0, 0, 43, 32, 0, 360);
    g2.rotate(26 * Math.PI / 180, 20.5, 17.5);
    g2.setStroke(oldS);
    drawCircle(g2, 16f, -5f);
    drawCircle(g2, -1f, 7f);
    drawCircle(g2, 5f, 28f);
    drawCircle(g2, 27f, 24f);
    drawCircle(g2, 36f, 3f);
    g2.setStroke(oldS);
    g2.setTransform(oldAt);
    g2.setColor(oldC);
}
 
Example 2
/**
 * @param g2d The graphic context
 * @param x The x-position of the upperleft of the oval
 * @param y The y-position of the upperleft of the oval
 * @param width The widht of the oval
 * @param height The height of the oval
 * @param color The base color of the oval, shadow still needs to be applied
 * @param reversed Whether the bottom part, or the upper part should be dark (true is upper part)
 * @param light
 */
private void drawShadedOval(final Graphics2D g2d, final int x, final int y, final int width, final int height, final Color color, final boolean reversed, final boolean light) {

	// Calculate how much darker the ring must be made (depends on the boolean 'light')
	float multi1;
	float multi2;
	if (light) {
		multi1 = reversed ? 1f : 0.8f;
		multi2 = reversed ? 0.8f : 1f;
	} else {
		multi1 = reversed ? 0.24f : 0.39f;
		multi2 = reversed ? 0.39f : 0.24f;
	}

	// Darken the colors by the given multiplier
	Color color1 = new Color((int) (color.getRed() * multi1), (int) (color.getGreen() * multi1), (int) (color.getBlue() * multi1));
	Color color2 = new Color((int) (color.getRed() * multi2), (int) (color.getGreen() * multi2), (int) (color.getBlue() * multi2));

	// Draw with two arcs a oval
	g2d.setColor(color1);
	g2d.drawArc(x, y, width, height, 0, 180);
	g2d.setColor(color2);
	g2d.drawArc(x, y, width, height, 180, 180);
}
 
Example 3
private void renderSmiley(Graphics g, int x, int y) {
Graphics2D g2d = (Graphics2D)g.create();
       
// Yellow face
g2d.setColor(Color.yellow);
g2d.fillOval(x, y, SMILEY_SIZE, SMILEY_SIZE);
       
// Black eyes
g2d.setColor(Color.black);
g2d.fillOval(x + 30, y + 30, 8, 8);
g2d.fillOval(x + 62, y + 30, 8, 8);
       
// Black outline
g2d.drawOval(x, y, SMILEY_SIZE, SMILEY_SIZE);
       
// Black smile
g2d.setStroke(new BasicStroke(3.0f));
g2d.drawArc(x + 20, y + 20, 60, 60, 190, 160);
       
       g2d.dispose();
   }
 
Example 4
@Override
public void paint(Graphics g) {
	Graphics2D g2 = (Graphics2D) g;
	if (g2 == null) {
		return;
	}
	g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
			RenderingHints.VALUE_ANTIALIAS_ON);
	// g2.setRenderingHint(RenderingHints.KEY_RENDERING,
	// RenderingHints.VALUE_RENDER_QUALITY);

	int sweep_angle = (int)(((float)value * 360) / 100);
	g2.setColor(Color.GRAY);
	g2.setStroke(stroke);
	g2.drawArc(padding, padding, getWidth() - 2 * padding, getHeight() - 2
			* padding, getScaledInt(90), -360);
	// g2.drawArc(2, 2, getWidth() - 12, getHeight() - 12, 90, -360);
	if (value > 0) {
		g2.setColor(foreColor);
		// g2.drawArc(2, 2, getWidth() - 12, getHeight() - 12, 90,
		// -sweep_angle);
		g2.drawArc(padding, padding, getWidth() - 2 * padding, getHeight()
				- 2 * padding, getScaledInt(90), -sweep_angle);
	}

	g2.setFont(FontResource.getItemFont());
	FontMetrics fm = g2.getFontMetrics();
	String str = value + "%";
	int w = (int) fm.getStringBounds(str, g2).getWidth();// fm.stringWidth(str);
	LineMetrics lm = fm.getLineMetrics(str, g2);
	int h = (int) (lm.getAscent() + lm.getDescent());
	g2.drawString(str, (getWidth()  - w) / 2,
			((getHeight()   + h) / 2) - lm.getDescent());
}
 
Example 5
private static void drawCircle(Graphics2D g2, float x, float y) {
    g2.setColor(blue);
    g2.translate(x, y);
    g2.fillArc(0, 0, 8, 8, 0, 360);
    g2.setColor(Color.BLACK);
    g2.drawArc(0, 0, 8, 8, 0, 360);
    g2.translate(-x, -y);
}
 
Example 6
Source Project: pumpernickel   File: VectorImageTest.java    License: MIT License 5 votes vote down vote up
/**
 * This tests clipping different Graphics2Ds, drawing arcs, a SrcOut
 * composite to clear pixels.
 */
public void testContext1() throws Exception {
	RenderTest t = new RenderTest() {

		@Override
		public void paint(Graphics2D g) {
			g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
					RenderingHints.VALUE_ANTIALIAS_ON);
			g.setStroke(new BasicStroke(15));

			g.clipRect(20, 20, 160, 160);
			g.setColor(Color.cyan);
			g.fillRect(0, 0, 200, 200);

			Graphics2D g2 = (Graphics2D) g.create(40, 40, 100, 100);
			g2.setColor(Color.pink);
			g2.drawArc(20, 20, 120, 120, 0, 190);

			Graphics2D g3 = (Graphics2D) g.create(60, 0, 100, 100);
			g3.setComposite(AlphaComposite.SrcOut);
			g3.setColor(Color.magenta);
			g3.drawArc(10, 10, 120, 120, 180, 340);
		}

	};
	t.test();
}
 
Example 7
@Override
public void draw(Graphics2D graphics) {
	Graphics2D g2 = (Graphics2D) graphics.create();
	int currentProgress = progressProvider.getProgress();
	if (currentProgress == 0) {
		indeterminateAnimation.draw(g2);
	} else {
		lastDrawnProgress = currentProgress;

		// draw arc
		g2.setColor(ANIMATION_COLOR);
		g2.setStroke(STROKE);
		// rendering hint that prevents arc from wobbling
		g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
		g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
		g2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
		g2.drawArc(-CIRCLE_DIAMETER / 2, -CIRCLE_DIAMETER / 2, CIRCLE_DIAMETER, CIRCLE_DIAMETER, START_ANGLE,
				-FULL_ANGLE * currentProgress / 100);

		// print progress if not 100
		if (currentProgress < 100) {
			g2.setFont(platformSpecificFont);
			final String text = "" + currentProgress;
			double textX = -textWidth / 2;
			if (currentProgress < 10) {
				textX = textX / 2;
			}
			g2.drawString(text, (int) textX, (int) textHeight / 2);
		}

		g2.dispose();
	}
}
 
Example 8
@Override
public void paintComponent(Graphics g) {
  super.paintComponent(g);
  this.removeAll();
  this.updateUI();
  g.setColor(Color.BLACK);
  g.drawLine(100, 500, 100, 100);
  g.drawLine(100, 500, 500, 500);
  Graphics2D g2d = (Graphics2D) g;
  g2d.setStroke(DASHED_STROKE);
  g2d.drawLine(500, 500, 100, 100);
  
  int radius = (int) (Math.sqrt(DogOnCurve.RADIUS_SQUARED) * 400);
  g2d.drawArc(100 - radius, 500 - radius, 2 * radius, 2 * radius, 0, 90);
  
  g.setFont(new Font("Serif", Font.BOLD, 36));
  g.setColor(Color.ORANGE);
  if (foodAtX) {
    g.drawString("HUNT", 500, 500);
  } else {
    g.drawString("BEG", 100, 100);
  }
  
  g.setColor(Color.RED);
  g.drawString(Integer.toString(dogOnLine.foodWon),
      (int) (100 + 400 * dogOnLine.currentPointX), 
      (int) (500 - 400 * dogOnLine.currentPointY));
  
  g.setColor(Color.GREEN);
  g.drawString(Integer.toString(dogOnCurve.foodWon),
      (int) (100 + 400 * dogOnCurve.currentPointX), 
      (int) (500 - 400 * dogOnCurve.currentPointY));
}
 
Example 9
protected void paintBase(InstancePainter painter, boolean drawname, boolean ghost) {
	Direction dir = painter.getAttributeValue(StdAttr.FACING);
	Graphics2D g = (Graphics2D) painter.getGraphics();
	Bounds bds = painter.getBounds();
	int x = bds.getX();
	int y = bds.getY();
	int xp = x, yp = y;
	int width = bds.getWidth();
	int height = bds.getHeight();
	for (byte i = 0; i < this.pinnumber; i++) {
		if (i < this.pinnumber / 2) {
			if (dir == Direction.WEST || dir == Direction.EAST)
				xp = i * 20 + (10 - pinwidth / 2) + x;
			else
				yp = i * 20 + (10 - pinwidth / 2) + y;
		} else {
			if (dir == Direction.WEST || dir == Direction.EAST) {
				xp = (i - this.pinnumber / 2) * 20 + (10 - pinwidth / 2) + x;
				yp = height + y - pinheight;
			} else {
				yp = (i - this.pinnumber / 2) * 20 + (10 - pinwidth / 2) + y;
				xp = width + x - pinheight;
			}
		}
		if (dir == Direction.WEST || dir == Direction.EAST) {
			// fill the background of white if selected from preferences
			if (!ghost && AppPreferences.FILL_COMPONENT_BACKGROUND.getBoolean()) {
				g.setColor(Color.WHITE);
				g.fillRect(xp, yp, pinwidth, pinheight);
				g.setColor(Color.BLACK);
			}
			g.drawRect(xp, yp, pinwidth, pinheight);
		} else {
			// fill the background of white if selected from preferences
			if (!ghost && AppPreferences.FILL_COMPONENT_BACKGROUND.getBoolean()) {
				g.setColor(Color.WHITE);
				g.fillRect(xp, yp, pinheight, pinwidth);
				g.setColor(Color.BLACK);
			}
			g.drawRect(xp, yp, pinheight, pinwidth);
		}
	}
	if (dir == Direction.SOUTH) {
		// fill the background of white if selected from preferences
		if (!ghost && AppPreferences.FILL_COMPONENT_BACKGROUND.getBoolean()) {
			g.setColor(Color.WHITE);
			g.fillRoundRect(x + pinheight, y, bds.getWidth() - pinheight * 2, bds.getHeight(), 10, 10);
			g.setColor(Color.BLACK);
		}
		g.drawRoundRect(x + pinheight, y, bds.getWidth() - pinheight * 2, bds.getHeight(), 10, 10);
		g.drawArc(x + width / 2 - 7, y - 7, 14, 14, 180, 180);
	} else if (dir == Direction.WEST) {
		// fill the background of white if selected from preferences
		if (!ghost && AppPreferences.FILL_COMPONENT_BACKGROUND.getBoolean()) {
			g.setColor(Color.WHITE);
			g.fillRoundRect(x, y + pinheight, bds.getWidth(), bds.getHeight() - pinheight * 2, 10, 10);
			g.setColor(Color.BLACK);
		}
		g.drawRoundRect(x, y + pinheight, bds.getWidth(), bds.getHeight() - pinheight * 2, 10, 10);
		g.drawArc(x + width - 7, y + height / 2 - 7, 14, 14, 90, 180);
	} else if (dir == Direction.NORTH) {
		// fill the background of white if selected from preferences
		if (!ghost && AppPreferences.FILL_COMPONENT_BACKGROUND.getBoolean()) {
			g.setColor(Color.WHITE);
			g.fillRoundRect(x + pinheight, y, bds.getWidth() - pinheight * 2, bds.getHeight(), 10, 10);
			g.setColor(Color.BLACK);
		}
		g.drawRoundRect(x + pinheight, y, bds.getWidth() - pinheight * 2, bds.getHeight(), 10, 10);
		g.drawArc(x + width / 2 - 7, y + height - 7, 14, 14, 0, 180);
	} else {// east
		// fill the background of white if selected from preferences
		if (!ghost && AppPreferences.FILL_COMPONENT_BACKGROUND.getBoolean()) {
			g.setColor(Color.WHITE);
			g.fillRoundRect(x, y + pinheight, bds.getWidth(), bds.getHeight() - pinheight * 2, 10, 10);
			g.setColor(Color.BLACK);
		}
		g.drawRoundRect(x, y + pinheight, bds.getWidth(), bds.getHeight() - pinheight * 2, 10, 10);
		g.drawArc(x - 7, y + height / 2 - 7, 14, 14, 270, 180);
	}
	g.rotate(Math.toRadians(-dir.toDegrees()), x + width / 2, y + height / 2);
	if (drawname) {
		g.setFont(new Font(Font.DIALOG_INPUT, Font.BOLD, 14));
		GraphicsUtil.drawCenteredText(g, this.name, x + bds.getWidth() / 2, y + bds.getHeight() / 2 - 4);
	}
	if (dir == Direction.WEST || dir == Direction.EAST) {
		xp = x;
		yp = y;
	} else {
		xp = x + (width - height) / 2;
		yp = y + (height - width) / 2;
		width = bds.getHeight();
		height = bds.getWidth();
	}
	g.setFont(new Font(Font.DIALOG_INPUT, Font.BOLD, 7));
	GraphicsUtil.drawCenteredText(g, "Vcc", xp + 10, yp + pinheight + 4);
	GraphicsUtil.drawCenteredText(g, "GND", xp + width - 10, yp + height - pinheight - 7);
}
 
Example 10
Source Project: android-classyshark   File: RingChart.java    License: Apache License 2.0 4 votes vote down vote up
private void renderNode(int width, int height, int radius, int startAngle, int endAngle,
                        ClassNode rootNode, Graphics2D g2d, int depth, Color[] pallete) {
    if (rootNode.getChildNodes().isEmpty()) {
        return;
    }

    int nodeStartAngle;
    int nodeEndAngle = startAngle;
    int angleSize = endAngle - startAngle;
    int r = (radius / maxDepth) * depth;
    int x = (width - r) / 2;
    int y = (height - r) / 2;
    int currentNode = 0;
    int currentColor = 0;

    List<ClassNode> nodes = new ArrayList<>(rootNode.getChildNodes().values());
    Collections.sort(nodes, new Comparator<ClassNode>() {
        @Override
        public int compare(ClassNode o1, ClassNode o2) {
            return Integer.compare(o2.getMethodCount(), o1.getMethodCount());
        }
    });

    while (nodeEndAngle < endAngle) {
        ClassNode node = nodes.get(currentNode);
        nodeStartAngle = nodeEndAngle;
        String title = node.getKey();
        Color color = pallete[currentColor];

        nodeEndAngle = (int) ((double) node.getMethodCount()
                / rootNode.getMethodCount() * angleSize + nodeEndAngle);

        if (currentNode == nodes.size() - 1) {
            nodeEndAngle = endAngle;
        } else if (currentColor == pallete.length - 1 || 360 - nodeEndAngle < 5) {
            currentColor = pallete.length - 1;
            nodeEndAngle = endAngle;
            title = "Others";
            color = OTHERS_COLOR;
        }

        if (selectedNode != null && node == selectedNode) {
            color = getHighlightColor(color);
        }

        if (color != OTHERS_COLOR) {
            colorClassNodeMap.put(color.getRGB(), node);
        }

        if (depth < maxDepth && currentColor != pallete.length - 1) {
            Color[] newpallete = L2_PALLETES[currentColor];
            renderNode(
                    width, height, radius, nodeStartAngle, nodeEndAngle, node, g2d, depth + 1, newpallete);
        }

        g2d.setColor(color);

        g2d.fillArc(x, y, r, r, nodeStartAngle, nodeEndAngle - nodeStartAngle);
        g2d.setColor(Color.BLACK);
        g2d.drawArc(x, y, r, r, nodeStartAngle, nodeEndAngle - nodeStartAngle);

        //Render Lines between angles
        AffineTransform saved = g2d.getTransform();
        int cx = width / 2;
        int cy = height / 2;
        g2d.translate(cx, cy);

        double rads = Math.toRadians(nodeEndAngle);
        int py = (int)Math.round(Math.sin(rads) * (r / 2)) * -1;
        int px = (int)Math.round(Math.cos(rads) * (r / 2));

        g2d.drawLine(0, 0, px, py);

        //Render text
        int r2 = (radius / maxDepth) * (depth - 1);
        r2 = r + (r2 - r)/2;
        rads = Math.toRadians(nodeStartAngle + (nodeEndAngle - nodeStartAngle) / 2);
        py = (int)Math.round(Math.sin(rads) * (r2 / 2))* -1;
        px = (int)Math.round(Math.cos(rads) * (r2 / 2));
        g2d.drawString(title, px, py);

        g2d.setTransform(saved);

        currentNode++;
        currentColor++;
    }
}
 
Example 11
public cfData execute( cfSession _session, cfArgStructData argStruct ) throws cfmRunTimeException{
	cfImageData im	= getImage( _session, argStruct );
	
	int x	= getNamedIntParam(argStruct, "x", -1 );
	int y	= getNamedIntParam(argStruct, "y", -1 );
	int w	= getNamedIntParam(argStruct, "width", -1 );
	int h	= getNamedIntParam(argStruct, "height", -1 );

	int sa	= getNamedIntParam(argStruct, "startangle", Integer.MIN_VALUE );
	int ar	= getNamedIntParam(argStruct, "arcangle", Integer.MIN_VALUE );
	
	boolean bFilled	= getNamedBooleanParam(argStruct, "filled", false );
	
	//Check boundaries
	BufferedImage	bim	= im.getImage();
	
	if ( x < 0 || x > bim.getWidth() )
		throwException(_session, "x (" + x + ") is outside the image" );
	
	if ( y < 0 || y > bim.getHeight() )
		throwException(_session, "y (" + y + ") is outside the image" );

	if ( (x+w) < 0 || (x+w) > bim.getWidth() )
		throwException(_session, "w (" + w + ") is outside the image" );

	if ( (y+w) < 0 || (y+w) > bim.getHeight() )
		throwException(_session, "w (" + w + ") is outside the image" );

	if ( sa == Integer.MIN_VALUE )
		throwException(_session, "startangle was not specified" );
	
	if ( ar == Integer.MIN_VALUE )
		throwException(_session, "arcangle  was not specified" );


	// Perform the operation
	Graphics2D g2 = im.createGraphics();
	
	if ( bFilled ){
		g2.fillArc( x, y, w, h, sa, ar );	
	}else{
		g2.drawArc(x, y, w, h, sa, ar );	
	}
	
	im.dispose(g2);
	return cfBooleanData.TRUE;
}
 
Example 12
Source Project: whyline   File: DrawArcEvent.java    License: MIT License 2 votes vote down vote up
public void paint(Graphics2D g) {

	g.drawArc(getX(), getY(), getWidth(), getHeight(), getStartAngle(), getArcAngle());		

}