Imported GNU Classpath 0.90

Imported GNU Classpath 0.90
       * scripts/makemake.tcl: LocaleData.java moved to gnu/java/locale.

       * sources.am: Regenerated.
       * gcj/javaprims.h: Regenerated.
       * Makefile.in: Regenerated.
       * gcj/Makefile.in: Regenerated.
       * include/Makefile.in: Regenerated.
       * testsuite/Makefile.in: Regenerated.

       * gnu/java/lang/VMInstrumentationImpl.java: New override.
       * gnu/java/net/local/LocalSocketImpl.java: Likewise.
       * gnu/classpath/jdwp/VMMethod.java: Likewise.
       * gnu/classpath/jdwp/VMVirtualMachine.java: Update to latest
       interface.
       * java/lang/Thread.java: Add UncaughtExceptionHandler.
       * java/lang/reflect/Method.java: Implements GenericDeclaration and
       isSynthetic(),
       * java/lang/reflect/Field.java: Likewise.
       * java/lang/reflect/Constructor.java
       * java/lang/Class.java: Implements Type, GenericDeclaration,
       getSimpleName() and getEnclosing*() methods.
       * java/lang/Class.h: Add new public methods.
       * java/lang/Math.java: Add signum(), ulp() and log10().
       * java/lang/natMath.cc (log10): New function.
       * java/security/VMSecureRandom.java: New override.
       * java/util/logging/Logger.java: Updated to latest classpath
       version.
       * java/util/logging/LogManager.java: New override.

From-SVN: r113887
This commit is contained in:
Mark Wielaard 2006-05-18 17:29:21 +00:00
parent eaec4980e1
commit 4f9533c772
1640 changed files with 126485 additions and 104808 deletions

View file

@ -1,5 +1,5 @@
/* FixedHeightLayoutCache.java --
Copyright (C) 2002, 2004 Free Software Foundation, Inc.
/* FixedHeightLayoutCache.java -- Fixed cell height tree layout cache
Copyright (C) 2002, 2004, 2006, Free Software Foundation, Inc.
This file is part of GNU Classpath.
@ -37,208 +37,592 @@ exception statement from your version. */
package javax.swing.tree;
import gnu.javax.swing.tree.GnuPath;
import java.awt.Rectangle;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.Set;
import java.util.Vector;
import javax.swing.event.TreeModelEvent;
/**
* FixedHeightLayoutCache
* The fixed height tree layout. This class assumes that all cells in the tree
* have the same fixed height. This may be not the case, for instance, if leaves
* and branches have different height, of if the tree rows may have arbitrary
* variable height. This class will also work if the NodeDimensions are not
* set.
*
* @author Andrew Selkirk
* @author Audrius Meskauskas
* @author Andrew Selkirk
*/
public class FixedHeightLayoutCache
extends AbstractLayoutCache
extends VariableHeightLayoutCache
{
/**
* The cached node record.
*/
class NodeRecord
{
NodeRecord(int aRow, int aDepth, Object aNode, Object aParent)
{
row = aRow;
depth = aDepth;
parent = aParent;
node = aNode;
isExpanded = expanded.contains(aNode);
}
/**
* The row, where the tree node is displayed.
*/
final int row;
/**
* The nesting depth
*/
final int depth;
/**
* The parent of the given node, null for the root node.
*/
final Object parent;
/**
* This node.
*/
final Object node;
/**
* True for the expanded nodes. The value is calculated in constructor.
* Using this field saves one hashtable access operation.
*/
final boolean isExpanded;
/**
* The cached bounds of the tree row.
*/
Rectangle bounds;
/**
* The path from the tree top to the given node (computed under first
* demand)
*/
private TreePath path;
/**
* Get the path for this node. The derived class is returned,
* making check for the last child of some parent easier.
*/
TreePath getPath()
{
if (path == null)
{
boolean lastChild = false;
if (parent != null)
{
int nc = treeModel.getChildCount(parent);
if (nc > 0)
{
int n = treeModel.getIndexOfChild(parent, node);
if (n == nc - 1)
lastChild = true;
}
}
// -------------------------------------------------------------
// Variables --------------------------------------------------
// -------------------------------------------------------------
LinkedList lpath = new LinkedList();
NodeRecord rp = this;
while (rp != null)
{
lpath.addFirst(rp.node);
if (rp.parent != null)
{
Object parent = rp.parent;
rp = (NodeRecord) nodes.get(parent);
// Add the root node, even if it is not visible.
if (rp == null)
lpath.addFirst(parent);
}
else
rp = null;
}
path = new GnuPath(lpath.toArray(), lastChild);
}
return path;
}
/**
* Get the rectangle bounds (compute, if required).
*/
Rectangle getBounds()
{
// This method may be called in the context when the tree rectangle is
// not known. To work around this, it is assumed near infinitely large.
if (bounds==null)
bounds = getNodeDimensions(node, row, depth, isExpanded,
new Rectangle());
return bounds;
}
}
/**
* The set of all expanded tree nodes.
*/
Set expanded = new HashSet();
/**
* Maps nodes to the row numbers.
*/
Hashtable nodes = new Hashtable();
/**
* Maps row numbers to nodes.
*/
Hashtable row2node = new Hashtable();
/**
* If true, the row map must be recomputed before using.
*/
boolean dirty;
/**
* The cumulative height of all rows.
*/
int totalHeight;
/**
* The maximal width.
*/
int maximalWidth;
// -------------------------------------------------------------
// Initialization ---------------------------------------------
// -------------------------------------------------------------
/**
* Creates the unitialised instance. Before using the class, the row height
* must be set with the {@link #setRowHeight(int)} and the model must be set
* with {@link #setModel(TreeModel)}. The node dimensions may not be set.
*/
public FixedHeightLayoutCache()
{
// Nothing to do here.
}
/**
* Constructor FixedHeightLayoutCache
*/
public FixedHeightLayoutCache()
{
// TODO
} // FixedHeightLayoutCache()
/**
* Get the total number of rows in the tree. Every displayed node occupies the
* single row. The root node row is included if the root node is set as
* visible (false by default).
*
* @return int the number of the displayed rows.
*/
public int getRowCount()
{
if (dirty) update();
return row2node.size();
}
/**
* Refresh the row map.
*/
private final void update()
{
nodes.clear();
row2node.clear();
totalHeight = maximalWidth = 0;
// -------------------------------------------------------------
// Methods ----------------------------------------------------
// -------------------------------------------------------------
Object root = treeModel.getRoot();
/**
* getRowCount
*
* @returns int
*/
public int getRowCount()
{
return 0; // TODO
} // getRowCount()
if (rootVisible)
{
countRows(root, null, 0);
}
else
{
int sc = treeModel.getChildCount(root);
for (int i = 0; i < sc; i++)
{
Object child = treeModel.getChild(root, i);
countRows(child, root, 0);
}
}
dirty = false;
}
/**
* Recursively counts all rows in the tree.
*/
private final void countRows(Object node, Object parent, int depth)
{
Integer n = new Integer(row2node.size());
row2node.put(n, node);
NodeRecord nr = new NodeRecord(n.intValue(), depth, node, parent);
nodes.put(node, nr);
// For expanded nodes and for the root node.
if (expanded.contains(node))
{
int sc = treeModel.getChildCount(node);
int deeper = depth+1;
for (int i = 0; i < sc; i++)
{
Object child = treeModel.getChild(node, i);
countRows(child, node, deeper);
}
}
}
/**
* invalidatePathBounds
*
* @param value0 TODO
*/
public void invalidatePathBounds(TreePath value0)
{
// TODO
} // invalidatePathBounds()
/**
* Discard the bound information for the given path.
*
* @param path the path, for that the bound information must be recomputed.
*/
public void invalidatePathBounds(TreePath path)
{
NodeRecord r = (NodeRecord) nodes.get(path.getLastPathComponent());
if (r!=null)
r.bounds = null;
}
/**
* invalidateSizes
*/
public void invalidateSizes()
{
// TODO
} // invalidateSizes()
/**
* Mark all cached information as invalid.
*/
public void invalidateSizes()
{
dirty = true;
}
/**
* isExpanded
*
* @param value0 TODO
* @returns boolean
*/
public boolean isExpanded(TreePath value0)
{
return false; // TODO
} // isExpanded()
/**
* Set the expanded state of the given path. The expansion states must be
* always updated when expanding and colapsing the tree nodes. Otherwise
* other methods will not work correctly after the nodes are collapsed or
* expanded.
*
* @param path the tree path, for that the state is being set.
* @param isExpanded the expanded state of the given path.
*/
public void setExpandedState(TreePath path, boolean isExpanded)
{
if (isExpanded)
expanded.add(path.getLastPathComponent());
else
expanded.remove(path.getLastPathComponent());
dirty = true;
}
/**
* Get the expanded state for the given tree path.
*
* @return true if the given path is expanded, false otherwise.
*/
public boolean isExpanded(TreePath path)
{
return expanded.contains(path.getLastPathComponent());
}
/**
* getBounds
*
* @param value0 TODO
* @param value1 TODO
* @returns Rectangle
*/
public Rectangle getBounds(TreePath value0, Rectangle value1)
{
return null; // TODO
} // getBounds()
/**
* Get bounds for the given tree path.
*
* @param path the tree path
* @param rect the rectangle that will be reused to return the result.
* @return Rectangle the bounds of the last line, defined by the given path.
*/
public Rectangle getBounds(TreePath path, Rectangle rect)
{
if (path == null)
return null;
if (dirty)
update();
Object last = path.getLastPathComponent();
NodeRecord r = (NodeRecord) nodes.get(last);
if (r == null)
// This node is not visible.
{
rect.x = rect.y = rect.width = rect.height = 0;
}
else
{
if (r.bounds == null)
{
Rectangle dim = getNodeDimensions(last, r.row, r.depth,
r.isExpanded, rect);
r.bounds = dim;
}
/**
* getPathForRow
*
* @param row TODO
* @returns TreePath
*/
public TreePath getPathForRow(int row)
{
//TODO
return null;
} // getPathForRow()
rect.setRect(r.bounds);
}
return rect;
}
/**
* getRowForPath
*
* @param value0 TODO
* @returns int
*/
public int getRowForPath(TreePath value0)
{
return 0;
} // getRowForPath()
/**
* Get the path, the last element of that is displayed in the given row.
*
* @param row the row
* @return TreePath the path
*/
public TreePath getPathForRow(int row)
{
if (dirty)
update();
Object last = row2node.get(new Integer(row));
if (last == null)
return null;
else
{
NodeRecord r = (NodeRecord) nodes.get(last);
return r.getPath();
}
}
/**
* getPathClosestTo
*
* @param value0 TODO
* @param value1 TODO
* @returns TreePath
*/
public TreePath getPathClosestTo(int value0, int value1)
{
return null; // TODO
} // getPathClosestTo()
/**
* Get the row, displaying the last node of the given path.
*
* @param path the path
* @return int the row number or -1 if the end of the path is not visible.
*/
public int getRowForPath(TreePath path)
{
if (path == null)
return -1;
if (dirty) update();
/**
* getVisibleChildCount
*
* @param value0 TODO
* @returns int
*/
public int getVisibleChildCount(TreePath value0)
{
return 0; // TODO
} // getVisibleChildCount()
NodeRecord r = (NodeRecord) nodes.get(path.getLastPathComponent());
if (r == null)
return - 1;
else
return r.row;
}
/**
* getVisiblePathsFrom
*
* @param value0 TODO
* @returns Enumeration
*/
public Enumeration getVisiblePathsFrom(TreePath value0)
{
return null; // TODO
} // getVisiblePathsFrom()
/**
* Get the path, closest to the given point.
*
* @param x the point x coordinate
* @param y the point y coordinate
* @return the tree path, closest to the the given point
*/
public TreePath getPathClosestTo(int x, int y)
{
if (dirty)
update();
/**
* setExpandedState
*
* @param value0 TODO
* @param value1 TODO
*/
public void setExpandedState(TreePath value0, boolean value1)
{
// TODO
} // setExpandedState()
// As the rows have arbitrary height, we need to iterate.
NodeRecord best = null;
NodeRecord r;
Enumeration en = nodes.elements();
int dist = Integer.MAX_VALUE;
/**
* getExpandedState
*
* @param value0 TODO
* @returns boolean
*/
public boolean getExpandedState(TreePath value0)
{
return false; // TODO
} // getExpandedState()
while (en.hasMoreElements() && dist > 0)
{
r = (NodeRecord) en.nextElement();
if (best == null)
{
best = r;
dist = distance(r.getBounds(), x, y);
}
else
{
int rr = distance(r.getBounds(), x, y);
if (rr < dist)
{
best = r;
dist = rr;
}
}
}
/**
* treeNodesChanged
*
* @param value0 TODO
*/
public void treeNodesChanged(TreeModelEvent value0)
{
// TODO
} // treeNodesChanged()
if (best == null)
return null;
else
return best.getPath();
}
/**
* Get the closest distance from this point till the given rectangle. Only
* vertical distance is taken into consideration.
*/
int distance(Rectangle r, int x, int y)
{
if (y < r.y)
return r.y - y;
else if (y > r.y + r.height)
return y - (r.y + r.height);
else
return 0;
}
/**
* treeNodesInserted
*
* @param value0 TODO
*/
public void treeNodesInserted(TreeModelEvent value0)
{
// TODO
} // treeNodesInserted()
/**
* Get the number of the visible childs for the given tree path. If the node
* is not expanded, 0 is returned. Otherwise, the number of children is
* obtained from the model as the number of children for the last path
* component.
*
* @param path the tree path
* @return int the number of the visible childs (for row).
*/
public int getVisibleChildCount(TreePath path)
{
if (isExpanded(path))
return 0;
else
return treeModel.getChildCount(path.getLastPathComponent());
}
/**
* treeNodesRemoved
*
* @param value0 TODO
*/
public void treeNodesRemoved(TreeModelEvent value0)
{
// TODO
} // treeNodesRemoved()
/**
* Get the enumeration over all visible pathes that start from the given
* parent path.
*
* @param parentPath the parent path
* @return the enumeration over pathes
*/
public Enumeration getVisiblePathsFrom(TreePath parentPath)
{
if (dirty)
update();
Vector p = new Vector(parentPath.getPathCount());
Object node;
NodeRecord nr;
/**
* treeStructureChanged
*
* @param value0 TODO
*/
public void treeStructureChanged(TreeModelEvent value0)
{
// TODO
} // treeStructureChanged()
for (int i = 0; i < parentPath.getPathCount(); i++)
{
node = parentPath.getPathComponent(i);
nr = (NodeRecord) nodes.get(node);
if (nr.row >= 0)
p.add(node);
}
return p.elements();
}
} // FixedHeightLayoutCache
/**
* Return the expansion state of the given tree path. The expansion state
* must be previously set with the
* {@link #setExpandedState(TreePath, boolean)}
*
* @param path the path being checked
* @return true if the last node of the path is expanded, false otherwise.
*/
public boolean getExpandedState(TreePath path)
{
return expanded.contains(path.getLastPathComponent());
}
/**
* The listener method, called when the tree nodes are changed.
*
* @param event the change event
*/
public void treeNodesChanged(TreeModelEvent event)
{
dirty = true;
}
/**
* The listener method, called when the tree nodes are inserted.
*
* @param event the change event
*/
public void treeNodesInserted(TreeModelEvent event)
{
dirty = true;
}
/**
* The listener method, called when the tree nodes are removed.
*
* @param event the change event
*/
public void treeNodesRemoved(TreeModelEvent event)
{
dirty = true;
}
/**
* Called when the tree structure has been changed.
*
* @param event the change event
*/
public void treeStructureChanged(TreeModelEvent event)
{
dirty = true;
}
/**
* Set the tree model that will provide the data.
*/
public void setModel(TreeModel newModel)
{
treeModel = newModel;
// The root node is expanded by default.
expanded.add(treeModel.getRoot());
dirty = true;
}
/**
* Inform the instance if the tree root node is visible. If this method
* is not called, it is assumed that the tree root node is not visible.
*
* @param visible true if the tree root node is visible, false
* otherwise.
*/
public void setRootVisible(boolean visible)
{
rootVisible = visible;
dirty = true;
}
/**
* Get the sum of heights for all rows.
*/
public int getPreferredHeight()
{
if (dirty)
update();
totalHeight = 0;
Enumeration en = nodes.elements();
while (en.hasMoreElements())
{
NodeRecord nr = (NodeRecord) en.nextElement();
Rectangle r = nr.getBounds();
totalHeight += r.height;
}
return totalHeight;
}
/**
* Get the maximal width.
*/
public int getPreferredWidth(Rectangle value)
{
if (dirty)
update();
maximalWidth = 0;
Enumeration en = nodes.elements();
while (en.hasMoreElements())
{
NodeRecord nr = (NodeRecord) en.nextElement();
Rectangle r = nr.getBounds();
if (r.x + r.width > maximalWidth)
maximalWidth = r.x + r.width;
}
return maximalWidth;
}
/**
* Returns true if this layout supposes that all rows have the fixed
* height.
*
* @return boolean true if all rows in the tree must have the fixed
* height (true by default).
*/
protected boolean isFixedRowHeight()
{
return true;
}
}