/* shamelessly copied from PlugInManager */
private static Class toClass(ZipEntry entry, ClassLoader classLoader) {
if (entry.isDirectory()) {
return null;
}
if (!entry.getName().endsWith(".class")) {
return null;
}
if (entry.getName().indexOf("$") != -1) {
// I assume it's not necessary to load inner classes explicitly.
// [Jon Aquino]
return null;
}
String className = entry.getName();
className = className.substring(0, className.length() - ".class".length());
className = StringUtil.replaceAll(className, "/", ".");
Class candidate;
try {
candidate = classLoader.loadClass(className);
} catch (ClassNotFoundException e) {
Assert.shouldNeverReachHere(
"Class not found: " + className + ". Refine class name algorithm.");
return null;
} catch (Throwable t) {
LOG.error("Throwable encountered loading " + className + ":");
// e.g. java.lang.VerifyError: class
// org.apache.xml.serialize.XML11Serializer
// overrides final method [Jon Aquino]
t.printStackTrace(System.out);
return null;
}
return candidate;
}
/**
* Extract the coordinate arrays for a geometry into a List.
*
* @param g the Geometry to extract from
* @param coordArrayList the List to add the coordinate arrays to
* @param orientPolygons whether or not the arrays in the List should be oriented (clockwise for
* the shell, counterclockwise for the holes)
*/
public static void addCoordinateArrays(Geometry g, boolean orientPolygons, List coordArrayList) {
if (g.getDimension() <= 0) {
return;
} else if (g instanceof LineString) {
LineString l = (LineString) g;
coordArrayList.add(l.getCoordinates());
} else if (g instanceof Polygon) {
Polygon poly = (Polygon) g;
Coordinate[] shell = poly.getExteriorRing().getCoordinates();
if (orientPolygons) {
shell = ensureOrientation(shell, CGAlgorithms.CLOCKWISE);
}
coordArrayList.add(shell);
for (int i = 0; i < poly.getNumInteriorRing(); i++) {
Coordinate[] hole = poly.getInteriorRingN(i).getCoordinates();
if (orientPolygons) {
hole = ensureOrientation(hole, CGAlgorithms.COUNTERCLOCKWISE);
}
coordArrayList.add(hole);
}
} else if (g instanceof GeometryCollection) {
GeometryCollection gc = (GeometryCollection) g;
for (int i = 0; i < gc.getNumGeometries(); i++) {
addCoordinateArrays(gc.getGeometryN(i), orientPolygons, coordArrayList);
}
} else {
Assert.shouldNeverReachHere("Geometry of type " + g.getClass().getName() + " not handled");
}
}
public TestCase(
String name,
String description,
String wkta,
String wktb,
String expectedIM,
String expectedConvexHull,
String expectedIntersection,
String expectedUnion,
String expectedDifference,
String expectedSymDifference,
String expectedBoundary) {
try {
init(
name,
description,
wkta,
wktb,
expectedIM,
toNullOrGeometry(expectedConvexHull),
toNullOrGeometry(expectedIntersection),
toNullOrGeometry(expectedUnion),
toNullOrGeometry(expectedDifference),
toNullOrGeometry(expectedSymDifference),
toNullOrGeometry(expectedBoundary));
} catch (ParseException e) {
Assert.shouldNeverReachHere();
}
}
public TestCase setExpectedBoundary(String wkt) {
try {
this.expectedBoundary = toNullOrGeometry(wkt);
} catch (ParseException e) {
Assert.shouldNeverReachHere();
}
return this;
}
public static Object newInstance(Class c) {
try {
return c.newInstance();
} catch (Exception e) {
Assert.shouldNeverReachHere(e.toString());
return null;
}
}
/**
* Devuelve las extensiones que reconoce la clase ReaderWriter especificada (que no es mas que un
* wrapper de 1 JumpReader y 1 JumpWriter)
*
* @param readerWriterDataSourceClass
* @return extensiones que reconoce
*/
public static String[] extensions(Class readerWriterDataSourceClass) {
try {
return ((StandardReaderWriterFileDataSource) readerWriterDataSourceClass.newInstance())
.getExtensions();
} catch (Exception e) {
Assert.shouldNeverReachHere(e.toString());
return null;
}
}
/* shamelessly copied from PlugInManager */
private static URL[] toURLs(File[] files) {
URL[] urls = new URL[files.length];
for (int i = 0; i < files.length; i++) {
try {
System.out.println("path: " + files[i].getPath());
urls[i] = new URL("jar:file:" + files[i].getPath() + "!/");
} catch (MalformedURLException e) {
Assert.shouldNeverReachHere(e.toString());
}
}
return urls;
}
public String getTestXML(Testable testable) {
if (testable instanceof TestCase) {
return getTestXML((TestCase) testable);
}
if (testable instanceof TestCaseEdit) {
return getTestXML(((TestCaseEdit) testable).getTestable());
}
if (testable instanceof TestRunnerTestCaseAdapter) {
return getTestXML((TestRunnerTestCaseAdapter) testable);
}
Assert.shouldNeverReachHere();
return null;
}
private int row(Object attributeValue) {
for (int i = 0; i < stylePanel.tableModel().getRowCount(); i++) {
Object otherAttributeValue =
stylePanel.tableModel().getValueAt(i, ColorThemingTableModel.ATTRIBUTE_COLUMN);
if (attributeValue == null && otherAttributeValue == null) {
return i;
}
if (attributeValue != null && attributeValue.equals(otherAttributeValue)) {
return i;
}
}
Assert.shouldNeverReachHere();
return -1;
}
public ConstraintsOptionsPanel(WorkbenchContext workbenchContext) {
this.workbenchContext = workbenchContext;
try {
this.jbInit();
this.init();
} catch (Exception e) {
Assert.shouldNeverReachHere(e.toString());
}
relativeAngleRadioButton.addItemListener(
new ItemListener() {
@Override
public void itemStateChanged(ItemEvent e) {
if (start) {
SettingOptionsDialog.page.fireButtonEvent(
ButtonEvent.ENABLE_BUTTON, ButtonNames.APPLY);
}
}
});
lengthCheckBox.addItemListener(
new ItemListener() {
@Override
public void itemStateChanged(ItemEvent e) {
updateEnabled();
}
});
constrainIncrementalAngleCheckBox.addItemListener(
new ItemListener() {
public void itemStateChanged(ItemEvent e) {
updateEnabled();
}
});
constrainAngleCheckBox.addItemListener(
new ItemListener() {
public void itemStateChanged(ItemEvent e) {
updateEnabled();
}
});
numPartsTextField.addFocusListener(
new myFocusListener() {
public void focusLost(FocusEvent e) {
double newAngle = 360.0 / Double.parseDouble(numPartsTextField.getText());
// constrainIncrementalAngleCheckBox.setText("Constrain angle to " + newAngle + " degree
// increments");
// [sstein: 16.10.2005]
constrainIncrementalAngleCheckBox.setText(
constrainAngleByStepsOf + " " + newAngle + " " + degree);
}
});
}
private void query(Object searchBounds, AbstractNode node, ItemVisitor visitor) {
List childBoundables = node.getChildBoundables();
for (int i = 0; i < childBoundables.size(); i++) {
Boundable childBoundable = (Boundable) childBoundables.get(i);
if (!getIntersectsOp().intersects(childBoundable.getBounds(), searchBounds)) {
continue;
}
if (childBoundable instanceof AbstractNode) {
query(searchBounds, (AbstractNode) childBoundable, visitor);
} else if (childBoundable instanceof ItemBoundable) {
visitor.visitItem(((ItemBoundable) childBoundable).getItem());
} else {
Assert.shouldNeverReachHere();
}
}
}
private List itemsTree(AbstractNode node) {
List valuesTreeForNode = new ArrayList();
for (Iterator i = node.getChildBoundables().iterator(); i.hasNext(); ) {
Boundable childBoundable = (Boundable) i.next();
if (childBoundable instanceof AbstractNode) {
List valuesTreeForChild = itemsTree((AbstractNode) childBoundable);
// only add if not null (which indicates an item somewhere in this tree
if (valuesTreeForChild != null) valuesTreeForNode.add(valuesTreeForChild);
} else if (childBoundable instanceof ItemBoundable) {
valuesTreeForNode.add(((ItemBoundable) childBoundable).getItem());
} else {
Assert.shouldNeverReachHere();
}
}
if (valuesTreeForNode.size() <= 0) return null;
return valuesTreeForNode;
}
private URL[] toURLs(Collection<File> files) {
URL[] urls = new URL[files.size()];
int i = 0;
for (File file : files) {
try {
// TODO: if "jar:file:" not explicitely defined VertexSymbols Extensions die with
// "java.lang.SecurityException: sealing violation: can't seal package <>: already
// loaded"
// [ede 05.2012]
urls[i++] =
file.isFile() ? new URL("jar:file:" + file.getPath() + "!/") : file.toURI().toURL();
} catch (MalformedURLException e) {
Assert.shouldNeverReachHere(e.toString());
}
}
return urls;
}
public SnapOptionsPanel(Blackboard blackboard) {
this.blackboard = blackboard;
try {
jbInit();
} catch (Exception e) {
Assert.shouldNeverReachHere(e.toString());
}
buttonGroup.add(showGridDotsRadioButton);
buttonGroup.add(showGridLinesRadioButton);
snapToFeaturesCheckBox.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
updateEnabled();
}
});
}
/**
* Build an appropriate <code>Geometry</code>, <code>MultiGeometry</code>, or <code>
* GeometryCollection</code> to contain the <code>Geometry</code>s in it. For example:<br>
*
* <ul>
* <li>If <code>geomList</code> contains a single <code>Polygon</code>, the <code>Polygon</code>
* is returned.
* <li>If <code>geomList</code> contains several <code>Polygon</code>s, a <code>MultiPolygon
* </code> is returned.
* <li>If <code>geomList</code> contains some <code>Polygon</code>s and some <code>LineString
* </code>s, a <code>GeometryCollection</code> is returned.
* <li>If <code>geomList</code> is empty, an empty <code>GeometryCollection</code> is returned
* </ul>
*
* Note that this method does not "flatten" Geometries in the input, and hence if any
* MultiGeometries are contained in the input a GeometryCollection containing them will be
* returned.
*
* @param geomList the <code>Geometry</code>s to combine
* @return a <code>Geometry</code> of the "smallest", "most type-specific" class that can contain
* the elements of <code>geomList</code> .
*/
public Geometry buildGeometry(Collection geomList) {
/** Determine some facts about the geometries in the list */
Class geomClass = null;
boolean isHeterogeneous = false;
boolean hasGeometryCollection = false;
for (Iterator i = geomList.iterator(); i.hasNext(); ) {
Geometry geom = (Geometry) i.next();
Class partClass = geom.getClass();
if (geomClass == null) {
geomClass = partClass;
}
if (partClass != geomClass) {
isHeterogeneous = true;
}
if (geom instanceof GeometryCollection) hasGeometryCollection = true;
}
/** Now construct an appropriate geometry to return */
// for the empty geometry, return an empty GeometryCollection
if (geomClass == null) {
return createGeometryCollection(null);
}
if (isHeterogeneous || hasGeometryCollection) {
return createGeometryCollection(toGeometryArray(geomList));
}
// at this point we know the collection is hetereogenous.
// Determine the type of the result from the first Geometry in the list
// this should always return a geometry, since otherwise an empty collection would have already
// been returned
Geometry geom0 = (Geometry) geomList.iterator().next();
boolean isCollection = geomList.size() > 1;
if (isCollection) {
if (geom0 instanceof Polygon) {
return createMultiPolygon(toPolygonArray(geomList));
} else if (geom0 instanceof LineString) {
return createMultiLineString(toLineStringArray(geomList));
} else if (geom0 instanceof Point) {
return createMultiPoint(toPointArray(geomList));
}
Assert.shouldNeverReachHere("Unhandled class: " + geom0.getClass().getName());
}
return geom0;
}
private Class toClass(ZipEntry entry, ClassLoader classLoader) {
String className = entry.getName();
className = className.substring(0, className.length() - ".class".length());
className = StringUtil.replaceAll(className, "/", ".");
Class candidate;
try {
candidate = classLoader.loadClass(className);
} catch (ClassNotFoundException e) {
Assert.shouldNeverReachHere(
"Class not found: " + className + ". Refine class name algorithm.");
return null;
} catch (Throwable t) {
LOG.error(LOADING_ERROR + " " + className + ":");
// e.g. java.lang.VerifyError: class
// org.apache.xml.serialize.XML11Serializer
// overrides final method [Jon Aquino]
t.printStackTrace(System.out);
return null;
}
return candidate;
}