| /* |
| * Copyright (c) 1998, 2008, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| package javax.swing.text.html; |
| |
| import java.awt.Polygon; |
| import java.io.Serializable; |
| 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 |
| */ |
| class Map implements Serializable { |
| /** Name of the Map. */ |
| private String name; |
| /** An array of AttributeSets. */ |
| private Vector<AttributeSet> areaAttributes; |
| /** An array of RegionContainments, will slowly grow to match the |
| * length of areaAttributes as needed. */ |
| private Vector<RegionContainment> 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<AttributeSet>(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 (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<RegionContainment>(numAttributes); |
| } |
| for (int counter = 0; counter < numAttributes; counter++) { |
| if (counter >= numAreas) { |
| areas.addElement(createRegionContainment |
| (areaAttributes.elementAt(counter))); |
| } |
| RegionContainment rc = areas.elementAt(counter); |
| if (rc != null && rc.contains(x, y, width, height)) { |
| return 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); |
| } |
| } |
| } |