/* * Copyright (c) 2000 David Flanagan.  All rights reserved. * This code is from the book Java Examples in a Nutshell, 2nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book (recommended), * visit http://www.davidflanagan.com/javaexamples2. */package com.davidflanagan.examples.graphics;import java.awt.*;import java.awt.geom.*;import java.awt.font.*;/** A demonstration of writing custom Stroke classes */public class CustomStrokes implements GraphicsExample {    static final int WIDTH = 750, HEIGHT = 200;        // Size of our example    public String getName() {return "Custom Strokes";} // From GraphicsExample    public int getWidth() { return WIDTH; }            // From GraphicsExample    public int getHeight() { return HEIGHT; }          // From GraphicsExample    // These are the various stroke objects we'll demonstrate    Stroke[] strokes = new Stroke[] {	new BasicStroke(4.0f),          // The standard, predefined stroke	new NullStroke(),               // A Stroke that does nothing	new DoubleStroke(8.0f, 2.0f),   // A Stroke that strokes twice	new ControlPointsStroke(2.0f),  // Shows the vertices & control points	new SloppyStroke(2.0f, 3.0f)    // Perturbs the shape before stroking    };    /** Draw the example */    public void draw(Graphics2D g, Component c) {	// Get a shape to work with.  Here we'll use the letter B	Font f = new Font("Serif", Font.BOLD, 200);	GlyphVector gv = f.createGlyphVector(g.getFontRenderContext(), "B");	Shape shape = gv.getOutline();	// Set drawing attributes and starting position	g.setColor(Color.black);	g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 			   RenderingHints.VALUE_ANTIALIAS_ON);	g.translate(10, 175);	// Draw the shape once with each stroke	for(int i = 0; i < strokes.length; i++) {	    g.setStroke(strokes[i]);   // set the stroke	    g.draw(shape);             // draw the shape	    g.translate(140,0);        // move to the right	}    }}/** * This Stroke implementation does nothing.  Its createStrokedShape() * method returns an unmodified shape.  Thus, drawing a shape with * this Stroke is the same as filling that shape! **/class NullStroke implements Stroke {    public Shape createStrokedShape(Shape s) { return s; }}/** * This Stroke implementation applies a BasicStroke to a shape twice. * If you draw with this Stroke, then instead of outlining the shape, * you're outlining the outline of the shape. **/class DoubleStroke implements Stroke {    BasicStroke stroke1, stroke2;   // the two strokes to use    public DoubleStroke(float width1, float width2) {	stroke1 = new BasicStroke(width1);  // Constructor arguments specify	stroke2 = new BasicStroke(width2);  // the line widths for the strokes    }    public Shape createStrokedShape(Shape s) {	// Use the first stroke to create an outline of the shape	Shape outline = stroke1.createStrokedShape(s);  	// Use the second stroke to create an outline of that outline.	// It is this outline of the outline that will be filled in	return stroke2.createStrokedShape(outline);    }}/** * This Stroke implementation strokes the shape using a thin line, and * also displays the end points and Bezier curve control points of all * the line and curve segments that make up the shape.  The radius * argument to the constructor specifies the size of the control point * markers. Note the use of PathIterator to break the shape down into * its segments, and of GeneralPath to build up the stroked shape. **/class ControlPointsStroke implements Stroke {    float radius;  // how big the control point markers should be    public ControlPointsStroke(float radius) { this.radius = radius; }    public Shape createStrokedShape(Shape shape) {	// Start off by stroking the shape with a thin line.  Store the	// resulting shape in a GeneralPath object so we can add to it.	GeneralPath strokedShape = 	    new GeneralPath(new BasicStroke(1.0f).createStrokedShape(shape));		// Use a PathIterator object to iterate through each of the line and	// curve segments of the shape.  For each one, mark the endpoint and	// control points (if any) by adding a rectangle to the GeneralPath	float[] coords = new float[6];	for(PathIterator i=shape.getPathIterator(null); !i.isDone();i.next()) {	    int type = i.currentSegment(coords);	    Shape s = null, s2 = null, s3 = null;	    switch(type) {	    case PathIterator.SEG_CUBICTO:		markPoint(strokedShape, coords[4], coords[5]); // falls through	    case PathIterator.SEG_QUADTO:		markPoint(strokedShape, coords[2], coords[3]); // falls through	    case PathIterator.SEG_MOVETO:	    case PathIterator.SEG_LINETO:		markPoint(strokedShape, coords[0], coords[1]); // falls through	    case PathIterator.SEG_CLOSE:		break;	    }	}	return strokedShape;    }    /** Add a small square centered at (x,y) to the specified path */    void markPoint(GeneralPath path, float x, float y) {	path.moveTo(x-radius, y-radius);  // Begin a new sub-path	path.lineTo(x+radius, y-radius);  // Add a line segment to it	path.lineTo(x+radius, y+radius);  // Add a second line segment	path.lineTo(x-radius, y+radius);  // And a third	path.closePath();                 // Go back to last moveTo position    }}/** * This Stroke implementation randomly perturbs the line and curve segments * that make up a Shape, and then strokes that perturbed shape.  It uses * PathIterator to loop through the Shape and GeneralPath to build up the * modified shape.  Finally, it uses a BasicStroke to stroke the modified * shape.  The result is a "sloppy" looking shape. **/class SloppyStroke implements Stroke {    BasicStroke stroke;    float sloppiness;    public SloppyStroke(float width, float sloppiness) {	this.stroke = new BasicStroke(width); // Used to stroke modified shape	this.sloppiness = sloppiness;         // How sloppy should we be?    }        public Shape createStrokedShape(Shape shape) {	GeneralPath newshape = new GeneralPath();  // Start with an empty shape		// Iterate through the specified shape, perturb its coordinates, and	// use them to build up the new shape.	float[] coords = new float[6];	for(PathIterator i=shape.getPathIterator(null); !i.isDone();i.next()) {	    int type = i.currentSegment(coords);	    switch(type) {	    case PathIterator.SEG_MOVETO:		perturb(coords, 2);		newshape.moveTo(coords[0], coords[1]);		break;	    case PathIterator.SEG_LINETO:		perturb(coords, 2);		newshape.lineTo(coords[0], coords[1]);		break;	    case PathIterator.SEG_QUADTO:		perturb(coords, 4);		newshape.quadTo(coords[0], coords[1], coords[2], coords[3]);		break;	    case PathIterator.SEG_CUBICTO:		perturb(coords, 6);		newshape.curveTo(coords[0], coords[1], coords[2], coords[3],				 coords[4], coords[5]);		break;	    case PathIterator.SEG_CLOSE:		newshape.closePath();		break;	    }	}	// Finally, stroke the perturbed shape and return the result	return stroke.createStrokedShape(newshape);    }    // Randomly modify the specified number of coordinates, by an amount    // specified by the sloppiness field.    void perturb(float[] coords, int numCoords) {	for(int i = 0; i < numCoords; i++)	    coords[i] += (float)((Math.random()*2-1.0)*sloppiness);    }}