+ * SwingLayoutNode layoutNode = new SwingLayoutNode();
+ * layoutNode.setLayout( new BoxLayout( layoutNode.getContainer(), BoxLayout.Y_AXIS ) );
+ *
+ *
+ * @return container in which children will logically be laid out in
+ */
+ public Container getContainer() {
+ return container;
+ }
+
+ /**
+ * Sets the layout manager.
+ * + * It's recommended that you avoid using this method, it's a can of worms. + * Like Swing, if you call this after adding nodes, the results may be + * unpredictable. You'll also have problems if the constraints that you + * specified to addChild aren't compatible with the new layout manager, or + * if the new layout manager requires constraints. + * + * @param layoutManager + */ + public void setLayout(final LayoutManager layoutManager) { + container.setLayout(layoutManager); + updateContainerLayout(); + } + + /** + * Adds a child at the specified index. Like Swing, bad things can happen if + * the type of the constraints isn't compatible with the layout manager. + * + * @param index 0 based index at which to add the child + * @param child child to be added + * @param constraints constraints the layout manager uses when laying out + * the child + * @param anchor specifies the location from which layout takes place + */ + public void addChild(final int index, final PNode child, final Object constraints, final Anchor anchor) { + /* + * NOTE: This must be the only super.addChild call that we make in our + * entire implementation, because all PNode.addChild methods are + * implemented in terms of this one. Calling other variants of + * super.addChild will incorrectly invoke our overrides, resulting in + * StackOverflowException. + */ + super.addChild(index, child); + addProxyComponent(child, constraints, anchor); + } + + /** {@inheritDoc} */ + public void addChild(final int index, final PNode child) { + addChild(index, child, null, anchor); + } + + /** + * Adds a child at the specified index. Like Swing, bad things can happen if + * the type of the constraints isn't compatible with the layout manager. + * + * @param index 0 based index at which to add the child + * @param child child to be added + * @param constraints constraints the layout manager uses when laying out + * the child + */ + public void addChild(final int index, final PNode child, final Object constraints) { + addChild(index, child, constraints, anchor); + } + + /** + * Adds a child at the specified index. + * + * @param index 0 based index at which to add the child + * @param child child to be added + * @param anchor specifies the location from which layout takes place + */ + public void addChild(final int index, final PNode child, final Anchor anchor) { + addChild(index, child, null, anchor); + } + + /** + * Adds a child to the end of the node list. + * + * @param child child to be added + * @param constraints constraints the layout manager uses when laying out + * the child + * @param anchor specifies the location from which layout takes place + */ + public void addChild(final PNode child, final Object constraints, final Anchor anchor) { + // NOTE: since PNode.addChild(PNode) is implemented in terms of + // PNode.addChild(int index), we must do the same. + int index = getChildrenCount(); + // workaround a flaw in PNode.addChild(PNode), they should have handled + // this in PNode.addChild(int index). + if (child.getParent() == this) { + index--; + } + addChild(index, child, constraints, anchor); + } + + /** + * Adds a child to the end of the node list. + * + * @param child child to be added + */ + public void addChild(final PNode child) { + addChild(child, null, anchor); + } + + /** + * Adds a child to the end of the node list and specifies the given + * constraints. + * + * @param child child to be added + * @param constraints constraints the layout manager uses when laying out + * the child + */ + public void addChild(final PNode child, final Object constraints) { + addChild(child, constraints, anchor); + } + + /** + * Adds a child to the end of the node list. + * + * @param child child to be added + * @param anchor specifies the location from which layout takes place + */ + public void addChild(final PNode child, final Anchor anchor) { + addChild(child, null, anchor); + } + + /** + * Adds a collection of nodes to the end of the list. + * + * @param nodes nodes to add to the end of the list + * @param constraints constraints the layout manager uses when laying out + * the child + * @param anchor specifies the location from which layout takes place + */ + public void addChildren(final Collection nodes, final Object constraints, final Anchor anchor) { + final Iterator i = nodes.iterator(); + while (i.hasNext()) { + final PNode each = (PNode) i.next(); + addChild(each, constraints, anchor); + } + } + + /** {@inheritDoc} */ + public void addChildren(final Collection nodes) { + addChildren(nodes, null, anchor); + } + + /** + * Adds a collection of nodes to the end of the list. + * + * @param nodes nodes to add to the end of the list + * @param constraints constraints the layout manager uses when laying out + * the child + */ + public void addChildren(final Collection nodes, final Object constraints) { + addChildren(nodes, constraints, anchor); + } + + /** + * Adds a collection of nodes to the end of the list. + * + * @param nodes nodes to add to the end of the list + * @param anchor specifies the location from which layout takes place + */ + public void addChildren(final Collection nodes, final Anchor anchor) { + addChildren(nodes, null, anchor); + } + + /** + * Removes a node at a specified index. + * + * @param index 0 based index of the child to be removed + */ + public PNode removeChild(final int index) { + /* + * NOTE: This must be the only super.removeChild call that we make in + * our entire implementation, because all PNode.removeChild methods are + * implemented in terms of this one. Calling other variants of + * super.removeChild will incorrectly invoke our overrides, resulting in + * StackOverflowException. + */ + final PNode node = super.removeChild(index); + removeProxyComponent(node); + return node; + } + + /* + * NOTE We don't need to override removeChild(PNode) or removeChildren, + * because they call removeChild(int index). If their implementation ever + * changes, then we'll need to override them. + */ + + /** + * PNode.removeAllChildren does not call removeChild, it manipulates an + * internal data structure. So we must override this in a more careful (and + * less efficient) manner. + */ + public void removeAllChildren() { + final Iterator i = getChildrenIterator(); + while (i.hasNext()) { + removeChild((PNode) i.next()); + } + } + + /** + * Adds a proxy component for a node. + * + * @param node node for which to add the proxy component + * @param constraints Constraints to apply when laying out the component + * @param anchor relative anchor point of the underyling proxy component on + * its container + */ + private void addProxyComponent(final PNode node, final Object constraints, final Anchor anchor) { + final ProxyComponent component = new ProxyComponent(node, anchor); + container.add(component, constraints); + node.addPropertyChangeListener(propertyChangeListener); + updateContainerLayout(); + } + + /** + * Removes a proxy component for a node. Does nothing if the node is not a + * child of the layout. + * + * @param node node from which the proxy container should be removed from. + */ + private void removeProxyComponent(final PNode node) { + if (node != null) { + final ProxyComponent component = getComponentForNode(node); + if (component != null) { + container.remove(component); + node.removePropertyChangeListener(propertyChangeListener); + updateContainerLayout(); + } + } + } + + /** + * Finds the component that is serving as the proxy for a specific node. + * Returns null if not found. + */ + private ProxyComponent getComponentForNode(final PNode node) { + ProxyComponent nodeComponent = null; + final Component[] components = container.getComponents(); + if (components != null) { + for (int i = 0; i < components.length && nodeComponent == null; i++) { + if (components[i] instanceof ProxyComponent) { + final ProxyComponent n = (ProxyComponent) components[i]; + if (n.getNode() == node) { + nodeComponent = n; + } + } + } + } + return nodeComponent; + } + + /** + * Helper to figure out if the given property name relates to layout. + * + * @param propertyName name of property being tested + * + * @return true property name relates to layout. + */ + private boolean isLayoutProperty(final String propertyName) { + return propertyName.equals(PNode.PROPERTY_VISIBLE) || propertyName.equals(PNode.PROPERTY_FULL_BOUNDS) || + propertyName.equals(PNode.PROPERTY_BOUNDS) || propertyName.equals(PNode.PROPERTY_TRANSFORM); + } + + /** + * Updates the Proxy Container's layout. + */ + private void updateContainerLayout() { + container.invalidate(); // necessary for layouts like BoxLayout that + // would otherwise use stale state + container.setSize(container.getPreferredSize()); + container.doLayout(); + } + + /** + * JComponent that acts as a proxy for a PNode. Provides the PNode's bounds + * info for all bounds-related requests. + */ + private static class ProxyComponent extends JComponent { + private static final long serialVersionUID = 1L; + private final PNode node; + private final Anchor anchor; + + public ProxyComponent(final PNode node, final Anchor anchor) { + this.node = node; + this.anchor = anchor; + } + + /** + * Returns the associated PNode. + * + * @return associated PNode + */ + public PNode getNode() { + return node; + } + + /** + * Report the node's dimensions as the ProxyComponent's preferred size. + */ + public Dimension getPreferredSize() { + // Round up fractional part instead of rounding down; better to + // include the whole node than to chop off part. + final double w = node.getFullBoundsReference().getWidth(); + final double h = node.getFullBoundsReference().getHeight(); + return new Dimension(roundUp(w), roundUp(h)); + } + + private int roundUp(final double val) { + return (int) Math.ceil(val); + } + + /** + * Return the PNode size as the minimum dimension; required by layouts + * such as BoxLayout. + * + * @return the minimum size for this component + */ + public Dimension getMinimumSize() { + return getPreferredSize(); + } + + /** + * Sets the bounds of the ProxyComponent and positions the node in the + * area (x,y,w,h) allocated by the layout manager. + */ + public void setBounds(final int x, final int y, final int w, final int h) { + // important to check that the bounds have really changed, or we'll + // cause StackOverflowException + if (x != getX() || y != getY() || w != getWidth() || h != getHeight()) { + super.setBounds(x, y, w, h); + anchor.positionNode(node, x, y, w, h); + } + } + } + + /** + * Determines where nodes are anchored in the area allocated by the Swing + * layout manager. Predefined anchor names are similar to GridBagConstraint + * anchors and have the same semantics. + */ + public interface Anchor { + + /** + * Positions the node in the bounds defined. + * + * @param node node to be laid out + * @param x left of bounds + * @param y top of bounds + * @param width width of bounds + * @param height height of bounds + */ + void positionNode(PNode node, double x, double y, double width, double height); + + /** + * Base class that provides utilities for computing common anchor + * points. + */ + + /** Anchors the node's center as the point used when laying it out. */ + public static final Anchor CENTER = new AbstractAnchor() { + /** {@inheritDoc} */ + public void positionNode(final PNode node, final double x, final double y, final double w, final double h) { + node.setOffset(centerX(node, x, w), centerY(node, y, h)); + } + }; + + /** Anchors the node's top center as the point used when laying it out. */ + public static final Anchor NORTH = new AbstractAnchor() { + /** {@inheritDoc} */ + public void positionNode(final PNode node, final double x, final double y, final double w, final double h) { + node.setOffset(centerX(node, x, w), north(node, y, h)); + } + }; + + /** Anchors the node's top right as the point used when laying it out. */ + public static final Anchor NORTHEAST = new AbstractAnchor() { + /** {@inheritDoc} */ + public void positionNode(final PNode node, final double x, final double y, final double w, final double h) { + node.setOffset(east(node, x, w), north(node, y, h)); + } + }; + + /** + * Anchors the node's middle right as the point used when laying it out. + */ + public static final Anchor EAST = new AbstractAnchor() { + /** {@inheritDoc} */ + public void positionNode(final PNode node, final double x, final double y, final double w, final double h) { + node.setOffset(east(node, x, w), centerY(node, y, h)); + } + }; + + /** + * Anchors the node's bottom right as the point used when laying it out. + */ + public static final Anchor SOUTHEAST = new AbstractAnchor() { + /** {@inheritDoc} */ + public void positionNode(final PNode node, final double x, final double y, final double w, final double h) { + node.setOffset(east(node, x, w), south(node, y, h)); + } + }; + + /** + * Anchors the node's center bottom as the point used when laying it + * out. + */ + public static final Anchor SOUTH = new AbstractAnchor() { + /** {@inheritDoc} */ + public void positionNode(final PNode node, final double x, final double y, final double w, final double h) { + node.setOffset(centerX(node, x, w), south(node, y, h)); + } + }; + + /** Anchors the node's bottom left as the point used when laying it out. */ + public static final Anchor SOUTHWEST = new AbstractAnchor() { + /** {@inheritDoc} */ + public void positionNode(final PNode node, final double x, final double y, final double w, final double h) { + node.setOffset(west(node, x, w), south(node, y, h)); + } + }; + + /** Anchors the node's middle left as the point used when laying it out. */ + public static final Anchor WEST = new AbstractAnchor() { + /** {@inheritDoc} */ + public void positionNode(final PNode node, final double x, final double y, final double w, final double h) { + node.setOffset(west(node, x, w), centerY(node, y, h)); + } + }; + + /** Anchors the node's top left as the point used when laying it out. */ + public static final Anchor NORTHWEST = new AbstractAnchor() { + /** {@inheritDoc} */ + public void positionNode(final PNode node, final double x, final double y, final double w, final double h) { + node.setOffset(west(node, x, w), north(node, y, h)); + } + }; + + public static abstract class AbstractAnchor implements Anchor { + /** + * Returns the x at which the given node would need to be placed so + * that its center was in the middle of the horizontal segment + * defined by x and width. + * + * @param node node which is being analyzed + * @param x x component of horizontal line segment + * @param width width of horizontal line segment + * @return x at which node would need to be placed so that its + * center matched the center of the line segment + */ + protected static double centerX(final PNode node, final double x, final double width) { + return x + (width - node.getFullBoundsReference().getWidth()) / 2; + } + + /** + * Returns the y at which the given node would need to be placed so + * that its center was in the middle of the vertical segment defined + * by y and h. + * + * @param node node which is being analyzed + * @param y y component of horizontal line segment + * @param height height of vertical line segment + * @return y at which node would need to be placed so that its + * center matched the center of the line segment + */ + protected static double centerY(final PNode node, final double y, final double height) { + return y + (height - node.getFullBoundsReference().getHeight()) / 2; + } + + /** + * Returns the y at which the given node would need to be placed so + * that its top was against the top of the vertical segment defined. + * + * @param node node which is being analyzed + * @param y y component of horizontal line segment + * @param height height of vertical line segment + * @return y at which node would need to be placed so that its top + * matched the start of the line segment (y) + */ + protected static double north(final PNode node, final double y, final double height) { + return y; + } + + /** + * Returns the y at which the given node would need to be placed so + * that its bottom was against the bottom of the vertical range + * defined. + * + * @param node node which is being analyzed + * @param y y component of vertical range + * @param height height of vertical range + * @return y at which node would need to be placed so that its + * bottom matched the bottom of the range + */ + protected static double south(final PNode node, final double y, final double height) { + return y + height - node.getFullBoundsReference().getHeight(); + } + + /** + * Returns the x at which the given node would need to be placed so + * that its right side was against the right side of the horizontal + * range defined. + * + * @param node node which is being analyzed + * @param x x component of horizontal range + * @param width width of horizontal range + * @return x at which node would need to be placed so that its right + * side touched the right side of the range defined. + */ + protected static double east(final PNode node, final double x, final double w) { + return x + w - node.getFullBoundsReference().getWidth(); + } + + /** + * Returns the x at which the given node would need to be placed so + * that its left side was against the left side of the horizontal + * range defined. + * + * @param node node which is being analyzed + * @param x x component of horizontal range + * @param width width of horizontal range + * @return x at which node would need to be placed so that its left + * side touched the left side of the range defined (x) + */ + protected static double west(final PNode node, final double x, final double w) { + return x; + } + }; + } +} \ No newline at end of file