JDK8/Java8源码在线阅读
/*
* 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;
}
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java