/* * @(#)Map.java	1.8 03/12/19 * * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */package javax.swing.text.html;import java.awt.Polygon;import java.awt.Rectangle;import java.util.StringTokenizer;import java.util.Vector;import javax.swing.text.AttributeSet;/** * Map is used to represent a map element that is part of an HTML document. * Once a Map has been created, and any number of areas have been added, * you can test if a point falls inside the map via the contains method. * * @author  Scott Violet * @version 1.8 12/19/03 */class Map {    /** Name of the Map. */    private String           name;    /** An array of AttributeSets. */    private Vector           areaAttributes;    /** An array of RegionContainments, will slowly grow to match the     * length of areaAttributes as needed. */    private Vector           areas;    public Map() {    }    public Map(String name) {	this.name = name;    }    /**     * Returns the name of the Map.     */    public String getName() {	return name;    }    /**     * Defines a region of the Map, based on the passed in AttributeSet.     */    public void addArea(AttributeSet as) {	if (as == null) {	    return;	}	if (areaAttributes == null) {	    areaAttributes = new Vector(2);	}	areaAttributes.addElement(as.copyAttributes());    }    /**     * Removes the previously created area.     */    public void removeArea(AttributeSet as) {	if (as != null && areaAttributes != null) {	    int numAreas = (areas != null) ? areas.size() : 0;	    for (int counter = areaAttributes.size() - 1; counter >= 0;		 counter--) {		if (((AttributeSet)areaAttributes.elementAt(counter)).		    isEqual(as)){		    areaAttributes.removeElementAt(counter);		    if (counter < numAreas) {			areas.removeElementAt(counter);		    }		}	    }	}    }    /**     * Returns the AttributeSets representing the differet areas of the Map.     */    public AttributeSet[] getAreas() {	int numAttributes = (areaAttributes != null) ? areaAttributes.size() :	                    0;	if (numAttributes != 0) {	    AttributeSet[]    retValue = new AttributeSet[numAttributes];	    areaAttributes.copyInto(retValue);	    return retValue;	}	return null;    }    /**     * Returns the AttributeSet that contains the passed in location,     * <code>x</code>, <code>y</code>. <code>width</code>, <code>height</code>     * gives the size of the region the map is defined over. If a matching     * area is found, the AttribueSet for it is returned.     */    public AttributeSet getArea(int x, int y, int width, int height) {	int      numAttributes = (areaAttributes != null) ?	                         areaAttributes.size() : 0;	if (numAttributes > 0) {	    int      numAreas = (areas != null) ? areas.size() : 0;	    if (areas == null) {		areas = new Vector(numAttributes);	    }	    for (int counter = 0; counter < numAttributes; counter++) {		if (counter >= numAreas) {		    areas.addElement(createRegionContainment			    ((AttributeSet)areaAttributes.elementAt(counter)));		}		RegionContainment       rc = (RegionContainment)areas.                                             elementAt(counter);		if (rc != null && rc.contains(x, y, width, height)) {		    return (AttributeSet)areaAttributes.elementAt(counter);		}	    }	}	return null;    }    /**     * Creates and returns an instance of RegionContainment that can be     * used to test if a particular point lies inside a region.     */    protected RegionContainment createRegionContainment	                          (AttributeSet attributes) {	Object     shape = attributes.getAttribute(HTML.Attribute.SHAPE);	if (shape == null) {	    shape = "rect";	}	if (shape instanceof String) {	    String                shapeString = ((String)shape).toLowerCase();	    RegionContainment     rc = null;	    try {		if (shapeString.equals("rect")) {		    rc = new RectangleRegionContainment(attributes);		}		else if (shapeString.equals("circle")) {		    rc = new CircleRegionContainment(attributes);		}		else if (shapeString.equals("poly")) {		    rc = new PolygonRegionContainment(attributes);		}		else if (shapeString.equals("default")) {		    rc = DefaultRegionContainment.sharedInstance();		}	    } catch (RuntimeException re) {		// Something wrong with attributes.		rc = null;	    }	    return rc;	}	return null;    }    /**     * Creates and returns an array of integers from the String     * <code>stringCoords</code>. If one of the values represents a     * % the returned value with be negative. If a parse error results     * from trying to parse one of the numbers null is returned.     */    static protected int[] extractCoords(Object stringCoords) {	if (stringCoords == null || !(stringCoords instanceof String)) {	    return null;	}	StringTokenizer    st = new StringTokenizer((String)stringCoords,						    ", \t\n\r");	int[]              retValue = null;	int                numCoords = 0;	while(st.hasMoreElements()) {	    String         token = st.nextToken();	    int            scale;	    if (token.endsWith("%")) {		scale = -1;		token = token.substring(0, token.length() - 1);	    }	    else {		scale = 1;	    }	    try {		int       intValue = Integer.parseInt(token);		if (retValue == null) {		    retValue = new int[4];		}		else if(numCoords == retValue.length) {		    int[]    temp = new int[retValue.length * 2];		    System.arraycopy(retValue, 0, temp, 0, retValue.length);		    retValue = temp;		}		retValue[numCoords++] = intValue * scale;	    } catch (NumberFormatException nfe) {		return null;	    }	}	if (numCoords > 0 && numCoords != retValue.length) {	    int[]    temp = new int[numCoords];	    System.arraycopy(retValue, 0, temp, 0, numCoords);	    retValue = temp;	}	return retValue;    }    /**     * Defines the interface used for to check if a point is inside a     * region.     */    interface RegionContainment {	/**	 * Returns true if the location <code>x</code>, <code>y</code>	 * falls inside the region defined in the receiver.	 * <code>width</code>, <code>height</code> is the size of	 * the enclosing region.	 */	public boolean contains(int x, int y, int width, int height);    }    /**     * Used to test for containment in a rectangular region.     */    static class RectangleRegionContainment implements RegionContainment {	/** Will be non-null if one of the values is a percent, and any value	 * that is non null indicates it is a percent	 * (order is x, y, width, height). */	float[]       percents;	/** Last value of width passed in. */	int           lastWidth;	/** Last value of height passed in. */	int           lastHeight;        /** Top left. */        int           x0;        int           y0;        /** Bottom right. */        int           x1;        int           y1;	public RectangleRegionContainment(AttributeSet as) {	    int[]    coords = Map.extractCoords(as.getAttribute(HTML.							   Attribute.COORDS));	    percents = null;	    if (coords == null || coords.length != 4) {		throw new RuntimeException("Unable to parse rectangular area");	    }	    else {		x0 = coords[0];		y0 = coords[1];		x1 = coords[2];		y1 = coords[3];		if (x0 < 0 || y0 < 0 || x1 < 0 || y1 < 0) {		    percents = new float[4];		    lastWidth = lastHeight = -1;		    for (int counter = 0; counter < 4; counter++) {			if (coords[counter] < 0) {			    percents[counter] = Math.abs				        (coords[counter]) / 100.0f;			}			else {			    percents[counter] = -1.0f;			}		    }		}	    }	}	public boolean contains(int x, int y, int width, int height) {	    if (percents == null) {		return contains(x, y);	    }	    if (lastWidth != width || lastHeight != height) {		lastWidth = width;		lastHeight = height;		if (percents[0] != -1.0f) {		    x0 = (int)(percents[0] * width);		}		if (percents[1] != -1.0f) {		    y0 = (int)(percents[1] * height);		}		if (percents[2] != -1.0f) {		    x1 = (int)(percents[2] * width);		}		if (percents[3] != -1.0f) {		    y1 = (int)(percents[3] * height);		}	    }	    return contains(x, y);	}        public boolean contains(int x, int y) {            return ((x >= x0 && x <= x1) &&                    (y >= y0 && y <= y1));        }    }    /**     * Used to test for containment in a polygon region.     */    static class PolygonRegionContainment extends Polygon implements	         RegionContainment {	/** If any value is a percent there will be an entry here for the	 * percent value. Use percentIndex to find out the index for it. */	float[]           percentValues;	int[]             percentIndexs;	/** Last value of width passed in. */	int               lastWidth;	/** Last value of height passed in. */	int               lastHeight;	public PolygonRegionContainment(AttributeSet as) {	    int[]    coords = Map.extractCoords(as.getAttribute(HTML.Attribute.								COORDS));	    if (coords == null || coords.length == 0 ||		coords.length % 2 != 0) {		throw new RuntimeException("Unable to parse polygon area");	    }	    else {		int        numPercents = 0;		lastWidth = lastHeight = -1;		for (int counter = coords.length - 1; counter >= 0;		     counter--) {		    if (coords[counter] < 0) {			numPercents++;		    }		}		if (numPercents > 0) {		    percentIndexs = new int[numPercents];		    percentValues = new float[numPercents];		    for (int counter = coords.length - 1, pCounter = 0;			 counter >= 0; counter--) {			if (coords[counter] < 0) {			    percentValues[pCounter] = coords[counter] /				                      -100.0f;			    percentIndexs[pCounter] = counter;			    pCounter++;			}		    }		}		else {		    percentIndexs = null;		    percentValues = null;		}		npoints = coords.length / 2;		xpoints = new int[npoints];		ypoints = new int[npoints];				for (int counter = 0; counter < npoints; counter++) {		    xpoints[counter] = coords[counter + counter];		    ypoints[counter] = coords[counter + counter + 1];		}	    }	}	public boolean contains(int x, int y, int width, int height) {	    if (percentValues == null || (lastWidth == width &&					  lastHeight == height)) {		return contains(x, y);	    }	    // Force the bounding box to be recalced.	    bounds = null;	    lastWidth = width;	    lastHeight = height;	    float fWidth = (float)width;	    float fHeight = (float)height;	    for (int counter = percentValues.length - 1; counter >= 0;		 counter--) {		if (percentIndexs[counter] % 2 == 0) {		    // x		    xpoints[percentIndexs[counter] / 2] = 			    (int)(percentValues[counter] * fWidth);		}		else {		    // y		    ypoints[percentIndexs[counter] / 2] = 			    (int)(percentValues[counter] * fHeight);		}	    }	    return contains(x, y);	}    }    /**     * Used to test for containment in a circular region.     */    static class CircleRegionContainment implements RegionContainment {	/** X origin of the circle. */	int           x;	/** Y origin of the circle. */	int           y;	/** Radius of the circle. */	int           radiusSquared;	/** Non-null indicates one of the values represents a percent. */	float[]       percentValues;	/** Last value of width passed in. */	int           lastWidth;	/** Last value of height passed in. */	int           lastHeight;	public CircleRegionContainment(AttributeSet as) {	    int[]    coords = Map.extractCoords(as.getAttribute(HTML.Attribute.								COORDS));	    if (coords == null || coords.length != 3) {		throw new RuntimeException("Unable to parse circular area");	    }	    x = coords[0];	    y = coords[1];	    radiusSquared = coords[2] * coords[2];	    if (coords[0] < 0 || coords[1] < 0 || coords[2] < 0) {		lastWidth = lastHeight = -1;		percentValues = new float[3];		for (int counter = 0; counter < 3; counter++) {		    if (coords[counter] < 0) {			percentValues[counter] = coords[counter] /			                         -100.0f;		    }		    else {			percentValues[counter] = -1.0f;		    }		}	    }	    else {		percentValues = null;	    }	}	public boolean contains(int x, int y, int width, int height) {	    if (percentValues != null && (lastWidth != width ||					  lastHeight != height)) {		int      newRad = Math.min(width, height) / 2;		lastWidth = width;		lastHeight = height;		if (percentValues[0] != -1.0f) {		    this.x = (int)(percentValues[0] * width);		}		if (percentValues[1] != -1.0f) {		    this.y = (int)(percentValues[1] * height);		}		if (percentValues[2] != -1.0f) {		    radiusSquared = (int)(percentValues[2] * 				   Math.min(width, height));		    radiusSquared *= radiusSquared;		}	    }	    return (((x - this.x) * (x - this.x) +		     (y - this.y) * (y - this.y)) <= radiusSquared);	}    }    /**     * An implementation that will return true if the x, y location is     * inside a rectangle defined by origin 0, 0, and width equal to     * width passed in, and height equal to height passed in.     */    static class DefaultRegionContainment implements RegionContainment {	/** A global shared instance. */	static DefaultRegionContainment  si = null;	public static DefaultRegionContainment sharedInstance() {	    if (si == null) {		si = new DefaultRegionContainment();	    }	    return si;	}	public boolean contains(int x, int y, int width, int height) {	    return (x <= width && x >= 0 && y >= 0 && y <= width);	}    }}