/*
 * 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.datatransfer;
import java.awt.*;
import java.awt.geom.*;
import java.awt.datatransfer.*;
import java.io.Serializable;
import java.util.StringTokenizer;

/**
 * This class represents a scribble composed of any number of "polylines".
 * Each "polyline" is set of connected line segments.  A scribble is created
 * through a series of calls to the moveto() and lineto() methods.  moveto()
 * specifies the starting point of a new polyline, and lineto() adds a new
 * point to the end of the current polyline().  
 *
 * This class implements the Shape interface which means that it can be drawn
 * using the Java2D graphics API
 *
 * It also implements the Transferable interface, which means that it can 
 * easily be used with cut-and-paste and drag-and-drop.  It defines a custom
 * DataFlavor, scribbleDataFlavor, which transfers Scribble objects as Java
 * objects.  However, it also supports cut-and-paste and drag-and-drop based
 * on a portable string representation of the scribble.  The toString()
 * and parse() methods write and read this string format
 **/
public class Scribble implements Shape, Transferable, Serializable, Cloneable {
    protected double[] points = new double[64]; // The scribble data
    protected int numPoints = 0;                // The current number of points
    double maxX = Double.NEGATIVE_INFINITY;     // The bounding box 
    double maxY = Double.NEGATIVE_INFINITY;
    double minX = Double.POSITIVE_INFINITY;
    double minY = Double.POSITIVE_INFINITY;

    /** 
     * Begin a new polyline at (x,y).  Note the use of Double.NaN in the
     * points array to mark the beginning of a new polyline
     **/
    public void moveto(double x, double y) {
	if (numPoints + 3 > points.length) reallocate();
	// Mark this as the beginning of a new line
	points[numPoints++] = Double.NaN;
	// The rest of this method is just like lineto();
	lineto(x, y);
    }

    /**
     * Add the point (x,y) to the end of the current polyline 
     **/
    public void lineto(double x, double y) {
	if (numPoints + 2 > points.length) reallocate();
	points[numPoints++] = x;
	points[numPoints++] = y;

	// See if the point enlarges our bounding box
	if (x > maxX) maxX = x;
	if (x < minX) minX = x;
	if (y > maxY) maxY = y;
	if (y < minY) minY = y;
    }

    /**
     * Append the Scribble s to this Scribble
     **/
    public void append(Scribble s) {
	int n = numPoints + s.numPoints;
	double[] newpoints = new double[n];
	System.arraycopy(points, 0, newpoints, 0, numPoints);
	System.arraycopy(s.points, 0, newpoints, numPoints, s.numPoints);
	points = newpoints;
	numPoints = n;
	minX = Math.min(minX, s.minX);
	maxX = Math.max(maxX, s.maxX);
	minY = Math.min(minY, s.minY);
	maxY = Math.max(maxY, s.maxY);
    }

    /**
     * Translate the coordinates of all points in the Scribble by x,y
     **/
    public void translate(double x, double y) {
	for(int i = 0; i < numPoints; i++) {
	    if (Double.isNaN(points[i])) continue;
	    points[i++] += x;
	    points[i] += y;
	}
	minX += x; maxX += x;
	minY += y; maxY += y;
    }

    /** An internal method to make more room in the data array */
    protected void reallocate() {
	double[] newpoints = new double[points.length * 2];
	System.arraycopy(points, 0, newpoints, 0, numPoints);
	points = newpoints;
    }

    /** Clone a Scribble object and its internal array of data */
    public Object clone() {
	try {
	    Scribble s = (Scribble) super.clone(); // make a copy of all fields
	    s.points = (double[]) points.clone();  // copy the entire array
	    return s;
	}
	catch (CloneNotSupportedException e) {  // This should never happen
	    return this;
	}
    }
 
    /** Convert the scribble data to a textual format */
    public String toString() {
	StringBuffer b = new StringBuffer();
	for(int i = 0; i < numPoints; i++) {
	    if (Double.isNaN(points[i])) {
		b.append("m ");
	    }
	    else {
		b.append(points[i]);
		b.append(' ');
	    }
	}
	return b.toString();
    }

    /** 
     * Create a new Scribble object and initialize it by parsing a string of
     * coordinate data in the format produced by toString()
     **/
    public static Scribble parse(String s) throws NumberFormatException {
	StringTokenizer st = new StringTokenizer(s);
	Scribble scribble = new Scribble();
	while(st.hasMoreTokens()) {
	    String t = st.nextToken();
	    if (t.charAt(0) == 'm') {
		scribble.moveto(Double.parseDouble(st.nextToken()),
				Double.parseDouble(st.nextToken()));
	    }
	    else {
		scribble.lineto(Double.parseDouble(t),
				Double.parseDouble(st.nextToken()));
	    }
	}
	return scribble;
    }

    // ========= The following methods implement the Shape interface ======== 
    
    /** Return the bounding box of the Shape */
    public Rectangle getBounds() {
	return new Rectangle((int)(minX-0.5f), (int)(minY-0.5f),
			     (int)(maxX-minX+0.5f), (int)(maxY-minY+0.5f));
    }
                                                               
    /** Return the bounding box of the Shape */
    public Rectangle2D getBounds2D() {
	return new Rectangle2D.Double(minX, minY, maxX-minX, maxY-minY);
    }
                                                               
    /** Our shape is an open curve, so it never contains anything */
    public boolean contains(Point2D p) { return false; }
    public boolean contains(Rectangle2D r) { return false; }
    public boolean contains(double x, double y) { return false; } 
    public boolean contains(double x, double y, double w, double h) {
	return false;
    }

    /**
     * Determine if the scribble intersects the specified rectangle by testing
     * each line segment individually 
     **/
    public boolean intersects(Rectangle2D r) {
	if (numPoints < 4) return false;
	int i = 0;
	double x1, y1, x2 = 0.0, y2 = 0.0;
	while(i < numPoints) {
	    if (Double.isNaN(points[i])) { // If we're beginning a new line
		i++;               // Skip the NaN
		x2 = points[i++];
		y2 = points[i++];
	    }
	    else {
		x1 = x2;
		y1 = y2;
		x2 = points[i++];
		y2 = points[i++];
		if (r.intersectsLine(x1, y1, x2, y2)) return true;
	    }
	}

	return false;
    }

    /** Test for intersection by invoking the method above */
    public boolean intersects(double x, double y, double w, double h){
	return intersects(new Rectangle2D.Double(x,y,w,h));
    }

    /**
     * Return a PathIterator object that tells Java2D how to draw this scribble
     **/
    public PathIterator getPathIterator(AffineTransform at) {
	return new ScribbleIterator(at);
    }
                                                               
    /**
     * Return a PathIterator that doesn't include curves.  Ours never does.
     **/
    public PathIterator getPathIterator(AffineTransform at, double flatness) {
	return getPathIterator(at);
    }

    /**
     * This inner class implements the PathIterator interface to describe
     * the shape of a scribble.  Since a Scribble is composed of arbitrary
     * movetos and linetos, we simply return their coordinates
     **/
    public class ScribbleIterator implements PathIterator {
	protected int i = 0;                 // Position in array
	protected AffineTransform transform;

	public ScribbleIterator(AffineTransform transform) {
	    this.transform = transform;
	}

	/** How to determine insideness and outsideness for this shape */
	public int getWindingRule() { return PathIterator.WIND_NON_ZERO; }

	/** Have we reached the end of the scribble path yet? */
	public boolean isDone() { return i >= numPoints; }

	/** Move on to the next segment of the path */
	public void next() {
	    if (Double.isNaN(points[i])) i += 3;
	    else i += 2;
	}

	/** 
	 * Get the coordinates of the current moveto or lineto as floats
	 **/
	public int currentSegment(float[] coords) {
	    int retval;
	    if (Double.isNaN(points[i])) {       // If its a moveto
		coords[0] = (float)points[i+1];
		coords[1] = (float)points[i+2];
		retval = SEG_MOVETO;
	    }
	    else {
		coords[0] = (float)points[i];
		coords[1] = (float)points[i+1];
		retval = SEG_LINETO;
	    }

	    // If a transform was specified, use it on the coordinates
	    if (transform != null) transform.transform(coords, 0, coords, 0,1);

	    return retval;
	}

	/** 
	 * Get the coordinates of the current moveto or lineto as doubles
	 **/
	public int currentSegment(double[] coords) {
	    int retval;
	    if (Double.isNaN(points[i])) {
		coords[0] = points[i+1];
		coords[1] = points[i+2];
		retval = SEG_MOVETO;
	    }
	    else {
		coords[0] = points[i];
		coords[1] = points[i+1];
		retval = SEG_LINETO;
	    }
	    if (transform != null) transform.transform(coords, 0, coords, 0,1);
	    return retval;
	}
    }
    
    //====== The following methods implement the Transferable interface =====

    // This is the custom DataFlavor for Scribble objects 
    public static DataFlavor scribbleDataFlavor =
	new DataFlavor(Scribble.class, "Scribble");

    // This is a list of the flavors we know how to work with
    public static DataFlavor[] supportedFlavors = {
	scribbleDataFlavor,
	DataFlavor.stringFlavor
    };

    /** Return the data formats or "flavors" we know how to transfer */
    public DataFlavor[] getTransferDataFlavors() {
	return (DataFlavor[]) supportedFlavors.clone();
    }

    /** Check whether we support a given flavor */
    public boolean isDataFlavorSupported(DataFlavor flavor) {
	return (flavor.equals(scribbleDataFlavor) ||
		flavor.equals(DataFlavor.stringFlavor));
    }

    /**
     * Return the scribble data in the requested format, or throw an exception
     * if we don't support the requested format
     **/
    public Object getTransferData(DataFlavor flavor)
	throws UnsupportedFlavorException
    {
	if (flavor.equals(scribbleDataFlavor)) { return this; }
	else if (flavor.equals(DataFlavor.stringFlavor)) { return toString(); }
	else throw new UnsupportedFlavorException(flavor);
    }
}