Drawing Geometric Primitives

public void paint (Graphics g) {
    Graphics2D g2 = (Graphics2D) g;
    ...
}

//Create Point2D.Double
Point2D.Double point = new Point2D.Double(x, y);

// draw Line2D.Double
g2.draw(new Line2D.Double(x1, y1, x2, y2));

// create new QuadCurve2D.Float
QuadCurve2D q = new QuadCurve2D.Float();
// draw QuadCurve2D.Float with set coordinates
q.setCurve(x1, y1, ctrlx, ctrly, x2, y2);
g2.draw(q);

// create new CubicCurve2D.Double
CubicCurve2D c = new CubicCurve2D.Double();
// draw CubicCurve2D.Double with set coordinates
c.setCurve(x1, y1, ctrlx1,
		  ctrly1, ctrlx2, ctrly2, x2, y2);
g2.draw(c);

Rectangle
Classes that specify primitives represented in the following example extend the RectangularShape class, which
implements the Shape interface and adds a few methods of its own.

These methods enables you to get information about a shape’s location and size, to examine the center point of a rectangle,
and to set the bounds of the shape.

The
Rectangle2D class represents a rectangle defined by a location (x, y) and dimension (w x h).
The Rectangle2D.Float and Rectangle2D.Double subclasses specify a rectangle
in float and double precision. For example:

// draw Rectangle2D.Double
g2.draw(new Rectangle2D.Double(x, y,
                               rectwidth,
                               rectheight));


The
RoundRectangle2D class represents a rectangle with rounded
corners defined by a location (x, y), a dimension (w x h), and the width
and height of the corner arc. The RoundRectangle2D.Float and RoundRectangle2D.Double subclasses
specify a round rectangle in float and double precision.

The rounded rectangle is specified with following parameters:

Location
Width
Height
Width of the corner arc
Height of the corner arc

To set the location, size, and arcs of a RoundRectangle2D object, use the method 
setRoundRect(double a, double y, double w, double h, double arcWidth, double arcHeight). For example:

// draw RoundRectangle2D.Double
g2.draw(new RoundRectangle2D.Double(x, y,
                                   rectwidth,
                                   rectheight,
                                   10, 10));



Ellipse
The
Ellipse2D class represents an ellipse defined by a bounding rectangle.
The Ellipse2D.Float and Ellipse2D.Double subclasses
specify an ellipse in float and double precision.

Ellipse is fully defined by a location, a width and a height. For example:

// draw Ellipse2D.Double
g2.draw(new Ellipse2D.Double(x, y,
                             rectwidth,
                             rectheight));


Arc
To draw a piece of an ellipse, you use the
Arc2D class. This class represents an arc defined
by a bounding rectangle, a start angle, an angular extent, and a closure type.
The Arc2D.Float and Arc2D.Double subclasses
specify an ellipse in float and double precision.

The Arc2D class defines the following three types of arcs,
represented by corresponding constants in this class: OPEN, PIE and CHORD.


Several methods set the size and parameters of the arc:

Directly, by coordinates
By supplied Point2D and Dimension2D
By copying an existing Arc2D

Also, you can use the setArcByCenter method to specify an arc from a center point,
given by its coordinates and a radius.

// draw Arc2D.Double
g2.draw(new Arc2D.Double(x, y,
                         rectwidth,
                         rectheight,
                         90, 135,
                         Arc2D.OPEN));


The
ShapesDemo2D.java code example contains implementations off all described
geometric primitives.
For more information about classes and methods represented in this section see the
java.awt.geom specification.




        
        

            « Previous
            •
            Trail
            •
            Next »