You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@wicket.apache.org by iv...@apache.org on 2007/01/01 03:10:29 UTC
svn commit: r491522 [2/2] - in /incubator/wicket/trunk/wicket: ./
src/main/java/wicket/ src/main/java/wicket/ajax/
src/main/java/wicket/markup/html/form/
src/main/java/wicket/markup/html/form/upload/
src/main/java/wicket/markup/html/link/ src/main/java...
Modified: incubator/wicket/trunk/wicket/src/main/java/wicket/markup/html/tree/AbstractTree.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/main/java/wicket/markup/html/tree/AbstractTree.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/main/java/wicket/markup/html/tree/AbstractTree.java (original)
+++ incubator/wicket/trunk/wicket/src/main/java/wicket/markup/html/tree/AbstractTree.java Sun Dec 31 18:10:28 2006
@@ -14,8 +14,8 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package wicket.markup.html.tree;
-
+package wicket.markup.html.tree;
+
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
@@ -41,1343 +41,1343 @@
import wicket.model.IModel;
import wicket.model.Model;
import wicket.util.string.AppendingStringBuffer;
-
-/**
- * This class encapsulates the logic for displaying and (partial) updating the
- * tree. Actual presentation is out of scope of this class. User should derive
- * they own tree (if needed) from {@link DefaultAbstractTree} or {@link Tree}
- * (recommended).
- *
- * @author Matej Knopp
- */
-public abstract class AbstractTree extends Panel<TreeModel>
- implements
- ITreeStateListener,
- TreeModelListener
-{
-
- /**
- * Interface for visiting individual tree items.
- */
- private static interface IItemCallback
- {
- /**
- * Visits the tree item.
- *
- * @param item
- * the item to visit
- */
- void visitItem(TreeItem item);
- }
-
- /**
- * This class represents one row in rendered tree (TreeNode). Only TreeNodes
- * that are visible (all their parent are expanded) have TreeItem created
- * for them.
- */
- private final class TreeItem extends WebMarkupContainer<TreeNode>
- {
- /**
- * whether this tree item should also render it's children to response.
- * this is set if we need the whole subtree rendered as one component in
- * ajax response, so that we can replace it in one step (replacing
- * individual rows is very slow in javascript, therefore we replace the
- * whole subtree)
- */
- private final static int FLAG_RENDER_CHILDREN = FLAG_RESERVED8;
-
- private static final long serialVersionUID = 1L;
-
- /**
- * tree item children - we need this to traverse items in correct order
- * when rendering
- */
- private List<TreeItem> children = null;
-
- /** tree item level - how deep is this item in tree */
- private int level;
-
- /**
- * Construct.
- *
- * @param parent
- * The parent
- * @param id
- * The component id
- * @param node
- * tree node
- * @param level
- * current level
- */
- public TreeItem(MarkupContainer parent, String id, final TreeNode node, int level)
- {
- super(parent, id, new Model<TreeNode>(node));
-
- nodeToItemMap.put(node, this);
- this.level = level;
- setOutputMarkupId(true);
-
- if (level != -1)
- {
- populateTreeItem(this, level);
- }
- }
-
- /**
- * @return The children
- */
- public List<TreeItem> getChildren()
- {
- return children;
- }
-
- /**
- * @return The current level
- */
- public int getLevel()
- {
- return level;
- }
-
- @Override
- public String getMarkupId()
- {
- // this is overriden to produce id that begins with id of tree
- // if the tree has set (shorter) id in markup, we can use it to
- // shorten the id of individual TreeItems
- return AbstractTree.this.getMarkupId() + "_" + getId();
- }
-
- /**
- * @return parent item
- */
- public TreeItem getParentItem()
- {
- return nodeToItemMap.get(getModelObject().getParent());
- }
-
- /**
- * Sets the children.
- *
- * @param children
- * The children
- */
- public void setChildren(List<TreeItem> children)
- {
- this.children = children;
- }
-
- /**
- * Whether to render children.
- *
- * @return whether to render children
- */
- protected final boolean isRenderChildren()
- {
- return getFlag(FLAG_RENDER_CHILDREN);
- }
-
- /**
- * @see wicket.MarkupContainer#onRender(wicket.markup.MarkupStream)
- */
- @Override
- protected void onRender(final MarkupStream markupStream)
- {
- // is this root and tree is in rootless mode?
- if (this == rootItem && isRootLess() == true)
- {
- // yes, write empty div with id
- // this is necesary for createElement js to work correctly
- getResponse().write(
- "<div style=\"display:none\" id=\"" + getMarkupId() + "\"></div>");
- markupStream.skipComponent();
- }
- else
- {
- // remember current index
- final int index = markupStream.getCurrentIndex();
-
- // render the item
- super.onRender(markupStream);
-
- // should we also render children (ajax response)
- if (isRenderChildren())
- {
- // visit every child
- visitItemChildren(this, new IItemCallback()
- {
- public void visitItem(TreeItem item)
- {
- // rewind markupStream
- markupStream.setCurrentIndex(index);
- // render child
- item.onRender(markupStream);
- }
- });
- // children are rendered, clear the flag
- setRenderChildren(false);
- }
- }
- }
-
- protected final void setRenderChildren(boolean value)
- {
- setFlag(FLAG_RENDER_CHILDREN, value);
- }
-
- @Override
- protected void onDetach()
- {
- super.onDetach();
- TreeNode node = getModelObject();
- if (node instanceof IDetachable)
- {
- ((IDetachable)node).detach();
- }
- }
- }
-
- /**
- * Components that holds tree items. This is similiar to ListView, but it
- * renders tree items in the right order.
- */
- private class TreeItemContainer extends WebMarkupContainer
- {
- private static final long serialVersionUID = 1L;
-
- /**
- * Construct.
- *
- * @param parent
- * The parent component
- * @param id
- * The component id
- */
- public TreeItemContainer(MarkupContainer parent, String id)
- {
- super(parent, id);
- }
-
- @Override
- public void remove(Component component)
- {
- // when a treeItem is removed, remove reference to it from
- // nodeToItemMAp
- if (component instanceof TreeItem)
- {
- nodeToItemMap.remove(((TreeItem)component).getModelObject());
- }
- super.remove(component);
- }
-
- /**
- * renders the tree items, making sure that items are rendered in the
- * order they should be
- */
- @Override
- protected void onRender(final MarkupStream markupStream)
- {
- // Save position in markup stream
- final int markupStart = markupStream.getCurrentIndex();
-
- // have we rendered at least one item?
- class Rendered
- {
- boolean rendered = false;
- }
- ;
- final Rendered rendered = new Rendered();
-
- // is there a root item? (non-empty tree)
- if (rootItem != null)
- {
- IItemCallback callback = new IItemCallback()
- {
- public void visitItem(TreeItem item)
- {
- // rewind markup stream
- markupStream.setCurrentIndex(markupStart);
-
- // render component
- item.render(markupStream);
-
- rendered.rendered = true;
- }
- };
-
- // visit item and it's children
- visitItemAndChildren(rootItem, callback);
- }
-
- if (rendered.rendered == false)
- {
- // tree is empty, just move the markupStream
- markupStream.skipComponent();
- }
- }
-
- /**
- *
- * @see wicket.MarkupContainer#getMarkupFragment(java.lang.String)
- */
- @Override
- public final MarkupFragment getMarkupFragment(final String subPath)
- {
- /*
- * we need to cut out the path of direct children because they
- * inherit the markup so their markup path must look as if they are
- * the listview themselves
- *
- * page:listview:1:label -> page:listview:label
- *
- * where 1 was the id of the listitem
- */
- return getMarkupFragment();
- }
- }
-
- /**
- * Returns the enumeration as iterable interface.
- *
- * @param enumeration
- * @param <T>
- * The type
- * @return iterable
- */
- private static final <T> Iterable<T> toIterable(final Enumeration enumeration)
- {
- return new Iterable<T>()
- {
- public Iterator<T> iterator()
- {
- return toIterator(enumeration);
- }
- };
- }
-
- /**
- * Returns an iterator that iterates trough the enumeration.
- *
- * @param enumeration
- * The enumeration to iterate through
- * @param <T>
- * The type
- * @return The iterator
- */
- private static final <T> Iterator<T> toIterator(final Enumeration enumeration)
- {
- return new Iterator<T>()
- {
- @SuppressWarnings("unchecked")
- private Enumeration<T> e = enumeration;
-
- public boolean hasNext()
- {
- return e.hasMoreElements();
- }
-
- public T next()
- {
- return e.nextElement();
- }
-
- public void remove()
- {
- throw new UnsupportedOperationException("Remove is not supported on enumeration.");
- }
- };
- }
-
- private boolean attached = false;
-
- /** comma separated list of ids of elements to be deleted. */
- private final AppendingStringBuffer deleteIds = new AppendingStringBuffer();
-
- /**
- * whether the whole tree is dirty (so the whole tree needs to be
- * refreshed).
- */
- private boolean dirtyAll = false;
-
- /**
- * list of dirty items. if children property of these items is null, the
- * chilren will be rebuild.
- */
- private final List<TreeItem> dirtyItems = new ArrayList<TreeItem>();
-
- /**
- * list of dirty items which need the DOM structure to be created for them
- * (added items)
- */
- private final List<TreeItem> dirtyItemsCreateDOM = new ArrayList<TreeItem>();
-
- /** counter for generating unique ids of every tree item. */
- private int idCounter = 0;
-
- /** Component whose children are tree items. */
- private TreeItemContainer itemContainer;
-
- /**
- * map that maps TreeNode to TreeItem. TreeItems only exists for TreeNodes,
- * that are visibled (their parents are not collapsed).
- */
- private final Map<TreeNode, TreeItem> nodeToItemMap = new HashMap<TreeNode, TreeItem>();
-
- /**
- * we need to track previous model. if the model changes, we unregister the
- * tree from listeners of old model and register the tree as litener of new
- * model.
- */
- private TreeModel previousModel = null;
-
- /** root item of the tree. */
- private TreeItem rootItem = null;
-
- /** whether the tree root is shown. */
- private boolean rootLess = false;
-
- /** stores reference to tree state. */
- private ITreeState state;
-
- /**
- * Tree constructor
- *
- * @param parent
- * The parent component
- * @param id
- * The component id
- */
- public AbstractTree(MarkupContainer parent, String id)
- {
- super(parent, id);
- init();
- }
-
- /**
- * Tree constructor
- *
- * @param parent
- * The parent component
- * @param id
- * The component id
- * @param model
- * The tree model
- */
- public AbstractTree(MarkupContainer parent, String id, IModel<TreeModel> model)
- {
- super(parent, id, model);
- init();
- }
-
- /** called when all nodes are collapsed. */
- public final void allNodesCollapsed()
- {
- invalidateAll();
- }
-
- /** called when all nodes are expaned. */
- public final void allNodesExpanded()
- {
- invalidateAll();
- }
-
- /**
- * Returns the TreeState of this tree.
- *
- * @return Tree state instance
- */
- public ITreeState getTreeState()
- {
- if (state == null)
- {
- state = newTreeState();
-
- // add this object as listener of the state
- state.addTreeStateListener(this);
- // FIXME: Where should we remove the listener?
- }
- return state;
- }
-
- /**
- * This method is called before the onAttach is called. Code here gets
- * executed before the items have been populated.
- */
- protected void onBeforeAttach()
- {
- }
-
- /**
- * Called at the beginning of the request (not ajax request, unless we are
- * rendering the entire component)
- */
- @Override
- public void internalAttach()
- {
- if (attached == false)
- {
- onBeforeAttach();
-
- checkModel();
-
- // Do we have to rebuld the whole tree?
- if (dirtyAll && rootItem != null)
- {
- clearAllItem();
- }
- else
- {
- // rebuild chilren of dirty nodes that need it
- rebuildDirty();
- }
-
- // is root item created? (root item is null if the items have not
- // been created yet, or the whole tree was dirty and clearAllITem
- // has been called
- if (rootItem == null)
- {
- TreeNode rootNode = (TreeNode)getModelObject().getRoot();
- if (rootNode != null)
- {
- if (isRootLess())
- {
- rootItem = newTreeItem(rootNode, -1);
- }
- else
- {
- rootItem = newTreeItem(rootNode, 0);
- }
- buildItemChildren(rootItem);
- }
- }
-
- attached = true;
- }
- super.internalAttach();
- }
-
- /**
- * @see wicket.MarkupContainer#internalDetach()
- */
- @Override
- public void internalDetach()
- {
- super.internalDetach();
- attached = false;
- }
-
- /**
- * Call to refresh the whole tree. This should only be called when the
- * roodNode has been replaced or the entiry tree model changed.
- */
- public final void invalidateAll()
- {
- updated();
- this.dirtyAll = true;
- }
-
- /**
- * @return whether the tree root is shown
- */
- public final boolean isRootLess()
- {
- return rootLess;
- };
-
- /**
- * @see wicket.markup.html.tree.ITreeStateListener#nodeCollapsed(javax.swing.tree.TreeNode)
- */
- public final void nodeCollapsed(TreeNode node)
- {
- if (isNodeVisible(node) == true)
- {
- invalidateNodeWithChildren(node);
- }
- }
-
- /**
- * @see wicket.markup.html.tree.ITreeStateListener#nodeExpanded(javax.swing.tree.TreeNode)
- */
- public final void nodeExpanded(TreeNode node)
- {
- if (isNodeVisible(node) == true)
- {
- invalidateNodeWithChildren(node);
- }
- }
-
- /**
- * @see wicket.markup.html.tree.ITreeStateListener#nodeSelected(javax.swing.tree.TreeNode)
- */
- public final void nodeSelected(TreeNode node)
- {
- if (isNodeVisible(node))
- {
- invalidateNode(node, true);
- }
- }
-
- /**
- * @see wicket.markup.html.tree.ITreeStateListener#nodeUnselected(javax.swing.tree.TreeNode)
- */
- public final void nodeUnselected(TreeNode node)
- {
- if (isNodeVisible(node))
- {
- invalidateNode(node, true);
- }
- }
-
- /**
- * Sets whether the root of the tree should be visible.
- *
- * @param rootLess
- * whether the root should be visible
- */
- public void setRootLess(boolean rootLess)
- {
- if (this.rootLess != rootLess)
- {
- this.rootLess = rootLess;
- invalidateAll();
-
- // if the tree is in rootless mode, make sure the root node is
- // expanded
- if (rootLess == true && getModelObject() != null)
- {
- getTreeState().expandNode((TreeNode)getModelObject().getRoot());
- }
- }
- }
-
- /**
- * @see javax.swing.event.TreeModelListener#treeNodesChanged(javax.swing.event.TreeModelEvent)
- */
- public final void treeNodesChanged(TreeModelEvent e)
- {
- // has root node changed?
- if (e.getChildren() == null)
- {
- if (rootItem != null)
- {
- invalidateNode(rootItem.getModelObject(), true);
- }
- }
- else
- {
- // go through all changed nodes
- for (Object child : e.getChildren())
- {
- TreeNode node = (TreeNode)child;
- if (isNodeVisible(node))
- {
- // if the nodes is visible invalidate it
- invalidateNode(node, true);
- }
- }
- }
- };
-
- /**
- * Marks the last but one visible child node of the given item as dirty, if
- * give child is the last item of parent.
- *
- * We need this to refresh the previous visible item in case the inserted /
- * deleteditem was last. The reason is that the line shape of previous item
- * chages from L to |- .
- *
- * @param parent
- * @param child
- */
- private void markTheLastButOneChildDirty(TreeItem parent, TreeItem child)
- {
- if (parent.getChildren().indexOf(child) == parent.getChildren().size() - 1)
- {
- // go through the childrend backwards, start at the last but one
- // item
- for (int i = parent.getChildren().size() - 2; i >= 0; --i)
- {
- TreeItem item = (TreeItem)parent.getChildren().get(i);
-
- // invalidate the node and it's children, so that they are redrawn
- invalidateNodeWithChildren((TreeNode)item.getModelObject());
- }
- }
- }
-
- /**
- * @see javax.swing.event.TreeModelListener#treeNodesInserted(javax.swing.event.TreeModelEvent)
- */
- public final void treeNodesInserted(TreeModelEvent e)
- {
- // get the parent node of inserted nodes
- TreeNode parent = (TreeNode)e.getTreePath().getLastPathComponent();
-
- if (isNodeVisible(parent) && isNodeExpanded(parent))
- {
- TreeItem parentItem = nodeToItemMap.get(parent);
- for (int i = 0; i < e.getChildren().length; ++i)
- {
- TreeNode node = (TreeNode)e.getChildren()[i];
- int index = e.getChildIndices()[i];
- TreeItem item = newTreeItem(node, parentItem.getLevel() + 1);
- parentItem.getChildren().add(index, item);
-
- markTheLastButOneChildDirty(parentItem, item);
-
- dirtyItems.add(item);
- dirtyItemsCreateDOM.add(item);
- }
- }
- }
-
- /**
- * @see javax.swing.event.TreeModelListener#treeNodesRemoved(javax.swing.event.TreeModelEvent)
- */
- public final void treeNodesRemoved(TreeModelEvent e)
- {
- // get the parent node of inserted nodes
- TreeNode parent = (TreeNode)e.getTreePath().getLastPathComponent();
- TreeItem parentItem = nodeToItemMap.get(parent);
-
- if (isNodeVisible(parent) && isNodeExpanded(parent))
- {
-
- for (int i = 0; i < e.getChildren().length; ++i)
- {
- TreeNode node = (TreeNode)e.getChildren()[i];
-
- TreeItem item = nodeToItemMap.get(node);
- if (item != null)
- {
- markTheLastButOneChildDirty(parentItem, item);
-
- parentItem.getChildren().remove(item);
-
- // go though item children and remove every one of them
- visitItemChildren(item, new IItemCallback()
- {
- public void visitItem(TreeItem item)
- {
- removeItem(item);
- // unselect the node
- getTreeState().selectNode(item.getModelObject(), false);
- }
- });
-
- removeItem(item);
- }
- }
- }
- }
-
- /**
- * @see javax.swing.event.TreeModelListener#treeStructureChanged(javax.swing.event.TreeModelEvent)
- */
- public final void treeStructureChanged(TreeModelEvent e)
- {
- // get the parent node of changed nodes
- TreeNode node = (TreeNode)e.getTreePath().getLastPathComponent();
-
- // has the tree root changed?
- if (e.getTreePath().getPathCount() == 1 && node.equals(rootItem.getModelObject()))
- {
- invalidateAll();
- }
- else
- {
- invalidateNodeWithChildren(node);
- }
- }
-
- /**
- * Updates the changed portions of the tree using given AjaxRequestTarget.
- * Call this method if you modified the tree model during an ajax request
- * target and you want to partially update the component on page. Make sure
- * that the tree model has fired the proper listener functions.
- *
- * @param target
- * Ajax request target used to send the update to the page
- */
- public final void updateTree(final AjaxRequestTarget target)
- {
- if (target == null)
- {
- return;
- }
-
- // check whether the model hasn't changed
- checkModel();
-
- // is the whole tree dirty
- if (dirtyAll)
- {
- // render entire tree component
- target.addComponent(this);
- }
- else
- {
- // remove DOM elements that need to be removed
- if (deleteIds.length() != 0)
- {
- String js = getElementsDeleteJavascript();
-
- // add the javascript to target
- target.prependJavascript(js);
- }
-
- // We have to repeat this as long as there are any dirty items to be
- // created. The reason why we can't do this in one pass is that some
- // of the items may need to be inserted after items that has not been
- // inserted yet, so we have to detect those and wait until the items
- // they depend on are inserted.
- while (dirtyItemsCreateDOM.isEmpty() == false)
- {
- for (Iterator<TreeItem> i = dirtyItemsCreateDOM.iterator(); i.hasNext();)
- {
- TreeItem item = i.next();
- TreeItem parent = item.getParentItem();
- int index = parent.getChildren().indexOf(item);
- TreeItem previous;
- // we need item before this (in dom structure)
- if (index == 0)
- {
- previous = parent;
- }
- else
- {
- previous = (TreeItem)parent.getChildren().get(index - 1);
- // get the last item of previous item subtree
- while (previous.getChildren() != null && previous.getChildren().size() > 0)
- {
- previous = (TreeItem)previous.getChildren().get(
- previous.getChildren().size() - 1);
- }
- }
- // check if the previous item isn't waiting to be inserted
- if (dirtyItemsCreateDOM.contains(previous) == false)
- {
- // it's already in dom, so we can use it as point of
- // insertion
- target.prependJavascript("Wicket.Tree.createElement(\""
- + item.getMarkupId() + "\"," + "\"" + previous.getMarkupId()
- + "\")");
-
- // remove the item so we don't process it again
- i.remove();
- }
- else
- {
- // we don't do anything here, inserting this item will
- // have to wait until the previous item gets inserted
- }
- }
- }
-
- // iterate through dirty items
- for (TreeItem item : dirtyItems)
- {
- // does the item need to rebuild children?
- if (item.getChildren() == null)
- {
- // rebuld the children
- buildItemChildren(item);
-
- // set flag on item so that it renders itself together with
- // it's children
- item.setRenderChildren(true);
- }
-
- // add the component to target
- target.addComponent(item);
- }
-
- // clear dirty flags
- updated();
- }
- }
-
- /**
- * Returns whether the given node is expanded.
- *
- * @param node
- * The node to inspect
- * @return true if the node is expanded, false otherwise
- */
- protected final boolean isNodeExpanded(TreeNode node)
- {
- // In root less mode the root node is always expanded
- if (isRootLess() && rootItem != null && rootItem.getModelObject().equals(node))
- {
- return true;
- }
-
- return getTreeState().isNodeExpanded(node);
- }
-
- /**
- * Creates the TreeState, which is an object where the current state of tree
- * (which nodes are expanded / collapsed, selected, ...) is stored.
- *
- * @return Tree state instance
- */
- protected ITreeState newTreeState()
- {
- return new DefaultTreeState();
- }
-
- /**
- * Called after the rendering of tree is complete. Here we clear the dirty
- * flags.
- */
- @Override
- protected void onAfterRender()
- {
- // rendering is complete, clear all dirty flags and items
- updated();
- }
-
- /**
- * This method is called after creating every TreeItem. This is the place
- * for adding components on item (junction links, labels, icons...)
- *
- * @param item
- * newly created tree item. The node can be obtained as
- * item.getModelObject()
- *
- * @param level
- * how deep the component is in tree hierarchy (0 for root item)
- */
- protected abstract void populateTreeItem(WebMarkupContainer<TreeNode> item, int level);
-
- /**
- * Builds the children for given TreeItem. It recursively traverses children
- * of it's TreeNode and creates TreeItem for every visible TreeNode.
- *
- * @param item
- * The parent tree item
- */
- private final void buildItemChildren(TreeItem item)
- {
- List<TreeItem> items;
-
- // if the node is expanded
- if (isNodeExpanded(item.getModelObject()))
- {
- // build the items for children of the items' treenode.
- items = buildTreeItems(nodeChildren(item.getModelObject()), item.getLevel() + 1);
- }
- else
- {
- // it's not expanded, just set children to an empty list
- items = Collections.emptyList();
- }
-
- item.setChildren(items);
- }
-
- /**
- * Builds (recursively) TreeItems for the given Iterable of TreeNodes.
- *
- * @param nodes
- * The nodes to build tree items for
- * @param level
- * The current level
- * @return List with new tree items
- */
- private final List<TreeItem> buildTreeItems(Iterable<TreeNode> nodes, int level)
- {
- List<TreeItem> result = new ArrayList<TreeItem>();
-
- // for each node
- for (TreeNode node : nodes)
- {
- // create tree item
- TreeItem item = newTreeItem(node, level);
-
- // builds it children (recursively)
- buildItemChildren(item);
-
- // add item to result
- result.add(item);
- }
-
- return result;
- }
-
- /**
- * Checks whether the model has been chaned, and if so unregister and
- * register listeners.
- */
- private final void checkModel()
- {
- // find out whether the model object (the TreeModel) has been changed
- TreeModel model = getModelObject();
- if (model != previousModel)
- {
- if (previousModel != null)
- {
- previousModel.removeTreeModelListener(this);
- }
-
- previousModel = model;
-
- if (model != null)
- {
- model.addTreeModelListener(this);
- }
- // model has been changed, redraw whole tree
- invalidateAll();
- }
- }
-
- /**
- * Removes all TreeItem components.
- */
- private final void clearAllItem()
- {
- visitItemAndChildren(rootItem, new IItemCallback()
- {
- public void visitItem(TreeItem item)
- {
- item.remove();
- }
- });
- rootItem = null;
- }
-
- /**
- * Returns the javascript used to delete removed elements.
- *
- * @return The javascript
- */
- private String getElementsDeleteJavascript()
- {
- // build the javascript call
- final AppendingStringBuffer buffer = new AppendingStringBuffer(100);
-
- buffer.append("Wicket.Tree.removeNodes(\"");
-
- // first parameter is the markup id of tree (will be used as prefix to
- // build ids of child items
- buffer.append(getMarkupId() + "_\",[");
-
- // append the ids of elements to be deleted
- buffer.append(deleteIds);
-
- // does the buffer end if ','?
- if (buffer.endsWith(","))
- {
- // it does, trim it
- buffer.setLength(buffer.length() - 1);
- }
-
- buffer.append("]);");
-
- return buffer.toString();
- }
-
- //
- // State and Model's callbacks
- //
-
- /**
- * returns the short version of item id (just the number part).
- *
- * @param item
- * The tree item
- * @return The id
- */
- private String getShortItemId(TreeItem item)
- {
- // show much of component id can we skip? (to minimize the length of
- // javascript being sent)
- final int skip = getMarkupId().length() + 1; // the length of id of
- // tree and '_'.
- return item.getMarkupId().substring(skip);
- }
-
- /**
- * Initialize the component.
- */
- private final void init()
- {
- // disable versioning for the tree
- setVersioned(false);
-
- // we need id when we are replacing the whole tree
- setOutputMarkupId(true);
-
- // create container for tree items
- itemContainer = new TreeItemContainer(this, "i");
-
- add(HeaderContributor.forJavaScript(AbstractTree.class, "res/tree.js"));
- }
-
- /**
- * Invalidates single node (without children). On the next render, this node
- * will be updated. Node will not be rebuilt, unless forceRebuild is true.
- *
- * @param node
- * The node to invalidate
- * @param forceRebuild
- */
- private final void invalidateNode(TreeNode node, boolean forceRebuild)
- {
- if (dirtyAll == false)
- {
- // get item for this node
- TreeItem item = nodeToItemMap.get(node);
-
- if (item != null)
- {
- boolean createDOM = false;
-
- if (forceRebuild)
- {
- // recreate the item
- int level = item.getLevel();
- List<TreeItem> children = item.getChildren();
- String id = item.getId();
-
- // store the parent of old item
- TreeItem parent = item.getParentItem();
-
- // if the old item has a parent, store it's index
- int index = parent != null ? parent.getChildren().indexOf(item) : -1;
-
- createDOM = dirtyItemsCreateDOM.contains(item);
-
- dirtyItems.remove(item);
- dirtyItemsCreateDOM.remove(item);
-
- item.remove();
-
- item = newTreeItem(node, level, id);
- item.setChildren(children);
-
- // was the item an root item?
- if (parent == null)
- {
- rootItem = item;
- }
- else
- {
- parent.getChildren().set(index, item);
- }
- }
-
- dirtyItems.add(item);
- if (createDOM)
- dirtyItemsCreateDOM.add(item);
- }
- }
- }
-
- /**
- * Invalidates node and it's children. On the next render, the node and
- * children will be updated. Node children will be rebuilt.
- *
- * @param node
- * The node to invalidate
- */
- private final void invalidateNodeWithChildren(TreeNode node)
- {
- if (dirtyAll == false)
- {
- // get item for this node
- TreeItem item = nodeToItemMap.get(node);
-
- // is the item visible?
- if (item != null)
- {
- // go though item children and remove every one of them
- visitItemChildren(item, new IItemCallback()
- {
- public void visitItem(TreeItem item)
- {
- removeItem(item);
- }
- });
-
- // set children to null so that they get rebuild
- item.setChildren(null);
-
- // add item to dirty items
- dirtyItems.add(item);
- }
- }
- }
-
- /**
- * Returns whether the given node is visibled, e.g. all it's parents are
- * expanded.
- *
- * @param node
- * The node to inspect
- * @return true if the node is visible, false otherwise
- */
- private final boolean isNodeVisible(TreeNode node)
- {
- while (node.getParent() != null)
- {
- if (isNodeExpanded(node.getParent()) == false)
- {
- return false;
- }
- node = node.getParent();
- }
- return true;
- }
-
- /**
- * Creates a tree item for given node.
- *
- * @param node
- * The tree node
- * @param level
- * The level
- * @return The new tree item
- */
- private final TreeItem newTreeItem(TreeNode node, int level)
- {
- return new TreeItem(itemContainer, "" + idCounter++, node, level);
- }
-
- /**
- * Creates a tree item for given node with specified id.
- *
- * @param node
- * The tree node
- * @param level
- * The level
- * @param id
- * the component id
- * @return The new tree item
- */
- private final TreeItem newTreeItem(TreeNode node, int level, String id)
- {
- return new TreeItem(itemContainer, id, node, level);
- }
-
- /**
- * Return the representation of node children as Iterable interface.
- *
- * @param node
- * The tree node
- * @return iterable presentation of node children
- */
- private final Iterable<TreeNode> nodeChildren(TreeNode node)
- {
- return toIterable(node.children());
- }
-
- /**
- * Rebuilds children of every item in dirtyItems that needs it. This method
- * is called for non-partial update.
- */
- private final void rebuildDirty()
- {
- // go through dirty items
- for (TreeItem item : dirtyItems)
- {
- // item chilren need to be rebuilt
- if (item.getChildren() == null)
- {
- buildItemChildren(item);
- }
- }
- }
-
- /**
- * Removes the item, appends it's id to deleteIds. This is called when a
- * items parent is being deleted or rebuilt.
- *
- * @param item
- * The item to remove
- */
- private void removeItem(TreeItem item)
- {
- // even if the item is dirty it's no longer necessary to update id
- dirtyItems.remove(item);
-
- // if the item was about to be created
- if (dirtyItemsCreateDOM.contains(item))
- {
- // we needed to create DOM element, we no longer do
- dirtyItemsCreateDOM.remove(item);
- }
- else
- {
- // add items id (it's short version) to ids of DOM elements that
- // will be
- // removed
- deleteIds.append(getShortItemId(item));
- deleteIds.append(",");
- }
-
- // remove the id
- // note that this doesn't update item's parent's children list
- item.remove();
- }
-
- /**
- * Calls after the tree has been rendered. Clears all dirty flags.
- */
- private final void updated()
- {
- this.dirtyAll = false;
- this.dirtyItems.clear();
- this.dirtyItemsCreateDOM.clear();
- deleteIds.clear(); // FIXME: Recreate it to save some space?
- }
-
- /**
- * Call the callback#visitItem method for the given item and all it's
- * chilren.
- *
- * @param item
- * The tree item
- * @param callback
- * item call back
- */
- private final void visitItemAndChildren(TreeItem item, IItemCallback callback)
- {
- callback.visitItem(item);
- visitItemChildren(item, callback);
- }
-
- /**
- * Call the callback#visitItem method for every child of given item.
- *
- * @param item
- * The tree item
- * @param callback
- * The callback
- */
- private final void visitItemChildren(TreeItem item, IItemCallback callback)
- {
- if (item.getChildren() != null)
- {
- for (TreeItem i : item.getChildren())
- {
- visitItemAndChildren(i, callback);
- }
- }
- }
-
- /**
- * Returns the component associated with given node, or null, if node is not
- * visible. This is useful in situations when you want to touch the node
- * element in html.
- *
- * @param node
- * Tree node
- * @return Component associated with given node, or null if node is not
- * visible.
- */
- public Component getNodeComponent(TreeNode node)
- {
- return (Component)nodeToItemMap.get(node);
- }
-}
+
+/**
+ * This class encapsulates the logic for displaying and (partial) updating the
+ * tree. Actual presentation is out of scope of this class. User should derive
+ * they own tree (if needed) from {@link DefaultAbstractTree} or {@link Tree}
+ * (recommended).
+ *
+ * @author Matej Knopp
+ */
+public abstract class AbstractTree extends Panel<TreeModel>
+ implements
+ ITreeStateListener,
+ TreeModelListener
+{
+
+ /**
+ * Interface for visiting individual tree items.
+ */
+ private static interface IItemCallback
+ {
+ /**
+ * Visits the tree item.
+ *
+ * @param item
+ * the item to visit
+ */
+ void visitItem(TreeItem item);
+ }
+
+ /**
+ * This class represents one row in rendered tree (TreeNode). Only TreeNodes
+ * that are visible (all their parent are expanded) have TreeItem created
+ * for them.
+ */
+ private final class TreeItem extends WebMarkupContainer<TreeNode>
+ {
+ /**
+ * whether this tree item should also render it's children to response.
+ * this is set if we need the whole subtree rendered as one component in
+ * ajax response, so that we can replace it in one step (replacing
+ * individual rows is very slow in javascript, therefore we replace the
+ * whole subtree)
+ */
+ private final static int FLAG_RENDER_CHILDREN = FLAG_RESERVED8;
+
+ private static final long serialVersionUID = 1L;
+
+ /**
+ * tree item children - we need this to traverse items in correct order
+ * when rendering
+ */
+ private List<TreeItem> children = null;
+
+ /** tree item level - how deep is this item in tree */
+ private int level;
+
+ /**
+ * Construct.
+ *
+ * @param parent
+ * The parent
+ * @param id
+ * The component id
+ * @param node
+ * tree node
+ * @param level
+ * current level
+ */
+ public TreeItem(MarkupContainer parent, String id, final TreeNode node, int level)
+ {
+ super(parent, id, new Model<TreeNode>(node));
+
+ nodeToItemMap.put(node, this);
+ this.level = level;
+ setOutputMarkupId(true);
+
+ if (level != -1)
+ {
+ populateTreeItem(this, level);
+ }
+ }
+
+ /**
+ * @return The children
+ */
+ public List<TreeItem> getChildren()
+ {
+ return children;
+ }
+
+ /**
+ * @return The current level
+ */
+ public int getLevel()
+ {
+ return level;
+ }
+
+ @Override
+ public String getMarkupId()
+ {
+ // this is overriden to produce id that begins with id of tree
+ // if the tree has set (shorter) id in markup, we can use it to
+ // shorten the id of individual TreeItems
+ return AbstractTree.this.getMarkupId() + "_" + getId();
+ }
+
+ /**
+ * @return parent item
+ */
+ public TreeItem getParentItem()
+ {
+ return nodeToItemMap.get(getModelObject().getParent());
+ }
+
+ /**
+ * Sets the children.
+ *
+ * @param children
+ * The children
+ */
+ public void setChildren(List<TreeItem> children)
+ {
+ this.children = children;
+ }
+
+ /**
+ * Whether to render children.
+ *
+ * @return whether to render children
+ */
+ protected final boolean isRenderChildren()
+ {
+ return getFlag(FLAG_RENDER_CHILDREN);
+ }
+
+ /**
+ * @see wicket.MarkupContainer#onRender(wicket.markup.MarkupStream)
+ */
+ @Override
+ protected void onRender(final MarkupStream markupStream)
+ {
+ // is this root and tree is in rootless mode?
+ if (this == rootItem && isRootLess() == true)
+ {
+ // yes, write empty div with id
+ // this is necesary for createElement js to work correctly
+ getResponse().write(
+ "<div style=\"display:none\" id=\"" + getMarkupId() + "\"></div>");
+ markupStream.skipComponent();
+ }
+ else
+ {
+ // remember current index
+ final int index = markupStream.getCurrentIndex();
+
+ // render the item
+ super.onRender(markupStream);
+
+ // should we also render children (ajax response)
+ if (isRenderChildren())
+ {
+ // visit every child
+ visitItemChildren(this, new IItemCallback()
+ {
+ public void visitItem(TreeItem item)
+ {
+ // rewind markupStream
+ markupStream.setCurrentIndex(index);
+ // render child
+ item.onRender(markupStream);
+ }
+ });
+ // children are rendered, clear the flag
+ setRenderChildren(false);
+ }
+ }
+ }
+
+ protected final void setRenderChildren(boolean value)
+ {
+ setFlag(FLAG_RENDER_CHILDREN, value);
+ }
+
+ @Override
+ protected void onDetach()
+ {
+ TreeNode node = getModelObject();
+ if (node instanceof IDetachable)
+ {
+ ((IDetachable)node).detach();
+ }
+ super.onDetach();
+ }
+ }
+
+ /**
+ * Components that holds tree items. This is similiar to ListView, but it
+ * renders tree items in the right order.
+ */
+ private class TreeItemContainer extends WebMarkupContainer
+ {
+ private static final long serialVersionUID = 1L;
+
+ /**
+ * Construct.
+ *
+ * @param parent
+ * The parent component
+ * @param id
+ * The component id
+ */
+ public TreeItemContainer(MarkupContainer parent, String id)
+ {
+ super(parent, id);
+ }
+
+ @Override
+ public void remove(Component component)
+ {
+ // when a treeItem is removed, remove reference to it from
+ // nodeToItemMAp
+ if (component instanceof TreeItem)
+ {
+ nodeToItemMap.remove(((TreeItem)component).getModelObject());
+ }
+ super.remove(component);
+ }
+
+ /**
+ * renders the tree items, making sure that items are rendered in the
+ * order they should be
+ */
+ @Override
+ protected void onRender(final MarkupStream markupStream)
+ {
+ // Save position in markup stream
+ final int markupStart = markupStream.getCurrentIndex();
+
+ // have we rendered at least one item?
+ class Rendered
+ {
+ boolean rendered = false;
+ }
+ ;
+ final Rendered rendered = new Rendered();
+
+ // is there a root item? (non-empty tree)
+ if (rootItem != null)
+ {
+ IItemCallback callback = new IItemCallback()
+ {
+ public void visitItem(TreeItem item)
+ {
+ // rewind markup stream
+ markupStream.setCurrentIndex(markupStart);
+
+ // render component
+ item.render(markupStream);
+
+ rendered.rendered = true;
+ }
+ };
+
+ // visit item and it's children
+ visitItemAndChildren(rootItem, callback);
+ }
+
+ if (rendered.rendered == false)
+ {
+ // tree is empty, just move the markupStream
+ markupStream.skipComponent();
+ }
+ }
+
+ /**
+ *
+ * @see wicket.MarkupContainer#getMarkupFragment(java.lang.String)
+ */
+ @Override
+ public final MarkupFragment getMarkupFragment(final String subPath)
+ {
+ /*
+ * we need to cut out the path of direct children because they
+ * inherit the markup so their markup path must look as if they are
+ * the listview themselves
+ *
+ * page:listview:1:label -> page:listview:label
+ *
+ * where 1 was the id of the listitem
+ */
+ return getMarkupFragment();
+ }
+ }
+
+ /**
+ * Returns the enumeration as iterable interface.
+ *
+ * @param enumeration
+ * @param <T>
+ * The type
+ * @return iterable
+ */
+ private static final <T> Iterable<T> toIterable(final Enumeration enumeration)
+ {
+ return new Iterable<T>()
+ {
+ public Iterator<T> iterator()
+ {
+ return toIterator(enumeration);
+ }
+ };
+ }
+
+ /**
+ * Returns an iterator that iterates trough the enumeration.
+ *
+ * @param enumeration
+ * The enumeration to iterate through
+ * @param <T>
+ * The type
+ * @return The iterator
+ */
+ private static final <T> Iterator<T> toIterator(final Enumeration enumeration)
+ {
+ return new Iterator<T>()
+ {
+ @SuppressWarnings("unchecked")
+ private Enumeration<T> e = enumeration;
+
+ public boolean hasNext()
+ {
+ return e.hasMoreElements();
+ }
+
+ public T next()
+ {
+ return e.nextElement();
+ }
+
+ public void remove()
+ {
+ throw new UnsupportedOperationException("Remove is not supported on enumeration.");
+ }
+ };
+ }
+
+ private boolean attached = false;
+
+ /** comma separated list of ids of elements to be deleted. */
+ private final AppendingStringBuffer deleteIds = new AppendingStringBuffer();
+
+ /**
+ * whether the whole tree is dirty (so the whole tree needs to be
+ * refreshed).
+ */
+ private boolean dirtyAll = false;
+
+ /**
+ * list of dirty items. if children property of these items is null, the
+ * chilren will be rebuild.
+ */
+ private final List<TreeItem> dirtyItems = new ArrayList<TreeItem>();
+
+ /**
+ * list of dirty items which need the DOM structure to be created for them
+ * (added items)
+ */
+ private final List<TreeItem> dirtyItemsCreateDOM = new ArrayList<TreeItem>();
+
+ /** counter for generating unique ids of every tree item. */
+ private int idCounter = 0;
+
+ /** Component whose children are tree items. */
+ private TreeItemContainer itemContainer;
+
+ /**
+ * map that maps TreeNode to TreeItem. TreeItems only exists for TreeNodes,
+ * that are visibled (their parents are not collapsed).
+ */
+ private final Map<TreeNode, TreeItem> nodeToItemMap = new HashMap<TreeNode, TreeItem>();
+
+ /**
+ * we need to track previous model. if the model changes, we unregister the
+ * tree from listeners of old model and register the tree as litener of new
+ * model.
+ */
+ private TreeModel previousModel = null;
+
+ /** root item of the tree. */
+ private TreeItem rootItem = null;
+
+ /** whether the tree root is shown. */
+ private boolean rootLess = false;
+
+ /** stores reference to tree state. */
+ private ITreeState state;
+
+ /**
+ * Tree constructor
+ *
+ * @param parent
+ * The parent component
+ * @param id
+ * The component id
+ */
+ public AbstractTree(MarkupContainer parent, String id)
+ {
+ super(parent, id);
+ init();
+ }
+
+ /**
+ * Tree constructor
+ *
+ * @param parent
+ * The parent component
+ * @param id
+ * The component id
+ * @param model
+ * The tree model
+ */
+ public AbstractTree(MarkupContainer parent, String id, IModel<TreeModel> model)
+ {
+ super(parent, id, model);
+ init();
+ }
+
+ /** called when all nodes are collapsed. */
+ public final void allNodesCollapsed()
+ {
+ invalidateAll();
+ }
+
+ /** called when all nodes are expaned. */
+ public final void allNodesExpanded()
+ {
+ invalidateAll();
+ }
+
+ /**
+ * Returns the TreeState of this tree.
+ *
+ * @return Tree state instance
+ */
+ public ITreeState getTreeState()
+ {
+ if (state == null)
+ {
+ state = newTreeState();
+
+ // add this object as listener of the state
+ state.addTreeStateListener(this);
+ // FIXME: Where should we remove the listener?
+ }
+ return state;
+ }
+
+ /**
+ * This method is called before the onAttach is called. Code here gets
+ * executed before the items have been populated.
+ */
+ protected void onBeforeAttach()
+ {
+ }
+
+ /**
+ * @see wicket.MarkupContainer#onAttach()
+ */
+ @Override
+ protected void onAttach()
+ {
+ super.onAttach();
+
+ if (attached == false)
+ {
+ onBeforeAttach();
+
+ checkModel();
+
+ // Do we have to rebuld the whole tree?
+ if (dirtyAll && rootItem != null)
+ {
+ clearAllItem();
+ }
+ else
+ {
+ // rebuild chilren of dirty nodes that need it
+ rebuildDirty();
+ }
+
+ // is root item created? (root item is null if the items have not
+ // been created yet, or the whole tree was dirty and clearAllITem
+ // has been called
+ if (rootItem == null)
+ {
+ TreeNode rootNode = (TreeNode)getModelObject().getRoot();
+ if (rootNode != null)
+ {
+ if (isRootLess())
+ {
+ rootItem = newTreeItem(rootNode, -1);
+ }
+ else
+ {
+ rootItem = newTreeItem(rootNode, 0);
+ }
+ buildItemChildren(rootItem);
+ }
+ }
+
+ attached = true;
+ }
+ super.attach();
+ }
+
+ @Override
+ protected void onDetach()
+ {
+ attached = false;
+ super.onDetach();
+ }
+
+ /**
+ * Call to refresh the whole tree. This should only be called when the
+ * roodNode has been replaced or the entiry tree model changed.
+ */
+ public final void invalidateAll()
+ {
+ updated();
+ this.dirtyAll = true;
+ }
+
+ /**
+ * @return whether the tree root is shown
+ */
+ public final boolean isRootLess()
+ {
+ return rootLess;
+ };
+
+ /**
+ * @see wicket.markup.html.tree.ITreeStateListener#nodeCollapsed(javax.swing.tree.TreeNode)
+ */
+ public final void nodeCollapsed(TreeNode node)
+ {
+ if (isNodeVisible(node) == true)
+ {
+ invalidateNodeWithChildren(node);
+ }
+ }
+
+ /**
+ * @see wicket.markup.html.tree.ITreeStateListener#nodeExpanded(javax.swing.tree.TreeNode)
+ */
+ public final void nodeExpanded(TreeNode node)
+ {
+ if (isNodeVisible(node) == true)
+ {
+ invalidateNodeWithChildren(node);
+ }
+ }
+
+ /**
+ * @see wicket.markup.html.tree.ITreeStateListener#nodeSelected(javax.swing.tree.TreeNode)
+ */
+ public final void nodeSelected(TreeNode node)
+ {
+ if (isNodeVisible(node))
+ {
+ invalidateNode(node, true);
+ }
+ }
+
+ /**
+ * @see wicket.markup.html.tree.ITreeStateListener#nodeUnselected(javax.swing.tree.TreeNode)
+ */
+ public final void nodeUnselected(TreeNode node)
+ {
+ if (isNodeVisible(node))
+ {
+ invalidateNode(node, true);
+ }
+ }
+
+ /**
+ * Sets whether the root of the tree should be visible.
+ *
+ * @param rootLess
+ * whether the root should be visible
+ */
+ public void setRootLess(boolean rootLess)
+ {
+ if (this.rootLess != rootLess)
+ {
+ this.rootLess = rootLess;
+ invalidateAll();
+
+ // if the tree is in rootless mode, make sure the root node is
+ // expanded
+ if (rootLess == true && getModelObject() != null)
+ {
+ getTreeState().expandNode((TreeNode)getModelObject().getRoot());
+ }
+ }
+ }
+
+ /**
+ * @see javax.swing.event.TreeModelListener#treeNodesChanged(javax.swing.event.TreeModelEvent)
+ */
+ public final void treeNodesChanged(TreeModelEvent e)
+ {
+ // has root node changed?
+ if (e.getChildren() == null)
+ {
+ if (rootItem != null)
+ {
+ invalidateNode(rootItem.getModelObject(), true);
+ }
+ }
+ else
+ {
+ // go through all changed nodes
+ for (Object child : e.getChildren())
+ {
+ TreeNode node = (TreeNode)child;
+ if (isNodeVisible(node))
+ {
+ // if the nodes is visible invalidate it
+ invalidateNode(node, true);
+ }
+ }
+ }
+ };
+
+ /**
+ * Marks the last but one visible child node of the given item as dirty, if
+ * give child is the last item of parent.
+ *
+ * We need this to refresh the previous visible item in case the inserted /
+ * deleteditem was last. The reason is that the line shape of previous item
+ * chages from L to |- .
+ *
+ * @param parent
+ * @param child
+ */
+ private void markTheLastButOneChildDirty(TreeItem parent, TreeItem child)
+ {
+ if (parent.getChildren().indexOf(child) == parent.getChildren().size() - 1)
+ {
+ // go through the childrend backwards, start at the last but one
+ // item
+ for (int i = parent.getChildren().size() - 2; i >= 0; --i)
+ {
+ TreeItem item = (TreeItem)parent.getChildren().get(i);
+
+ // invalidate the node and it's children, so that they are
+ // redrawn
+ invalidateNodeWithChildren((TreeNode)item.getModelObject());
+ }
+ }
+ }
+
+ /**
+ * @see javax.swing.event.TreeModelListener#treeNodesInserted(javax.swing.event.TreeModelEvent)
+ */
+ public final void treeNodesInserted(TreeModelEvent e)
+ {
+ // get the parent node of inserted nodes
+ TreeNode parent = (TreeNode)e.getTreePath().getLastPathComponent();
+
+ if (isNodeVisible(parent) && isNodeExpanded(parent))
+ {
+ TreeItem parentItem = nodeToItemMap.get(parent);
+ for (int i = 0; i < e.getChildren().length; ++i)
+ {
+ TreeNode node = (TreeNode)e.getChildren()[i];
+ int index = e.getChildIndices()[i];
+ TreeItem item = newTreeItem(node, parentItem.getLevel() + 1);
+ parentItem.getChildren().add(index, item);
+
+ markTheLastButOneChildDirty(parentItem, item);
+
+ dirtyItems.add(item);
+ dirtyItemsCreateDOM.add(item);
+ }
+ }
+ }
+
+ /**
+ * @see javax.swing.event.TreeModelListener#treeNodesRemoved(javax.swing.event.TreeModelEvent)
+ */
+ public final void treeNodesRemoved(TreeModelEvent e)
+ {
+ // get the parent node of inserted nodes
+ TreeNode parent = (TreeNode)e.getTreePath().getLastPathComponent();
+ TreeItem parentItem = nodeToItemMap.get(parent);
+
+ if (isNodeVisible(parent) && isNodeExpanded(parent))
+ {
+
+ for (int i = 0; i < e.getChildren().length; ++i)
+ {
+ TreeNode node = (TreeNode)e.getChildren()[i];
+
+ TreeItem item = nodeToItemMap.get(node);
+ if (item != null)
+ {
+ markTheLastButOneChildDirty(parentItem, item);
+
+ parentItem.getChildren().remove(item);
+
+ // go though item children and remove every one of them
+ visitItemChildren(item, new IItemCallback()
+ {
+ public void visitItem(TreeItem item)
+ {
+ removeItem(item);
+ // unselect the node
+ getTreeState().selectNode(item.getModelObject(), false);
+ }
+ });
+
+ removeItem(item);
+ }
+ }
+ }
+ }
+
+ /**
+ * @see javax.swing.event.TreeModelListener#treeStructureChanged(javax.swing.event.TreeModelEvent)
+ */
+ public final void treeStructureChanged(TreeModelEvent e)
+ {
+ // get the parent node of changed nodes
+ TreeNode node = (TreeNode)e.getTreePath().getLastPathComponent();
+
+ // has the tree root changed?
+ if (e.getTreePath().getPathCount() == 1 && node.equals(rootItem.getModelObject()))
+ {
+ invalidateAll();
+ }
+ else
+ {
+ invalidateNodeWithChildren(node);
+ }
+ }
+
+ /**
+ * Updates the changed portions of the tree using given AjaxRequestTarget.
+ * Call this method if you modified the tree model during an ajax request
+ * target and you want to partially update the component on page. Make sure
+ * that the tree model has fired the proper listener functions.
+ *
+ * @param target
+ * Ajax request target used to send the update to the page
+ */
+ public final void updateTree(final AjaxRequestTarget target)
+ {
+ if (target == null)
+ {
+ return;
+ }
+
+ // check whether the model hasn't changed
+ checkModel();
+
+ // is the whole tree dirty
+ if (dirtyAll)
+ {
+ // render entire tree component
+ target.addComponent(this);
+ }
+ else
+ {
+ // remove DOM elements that need to be removed
+ if (deleteIds.length() != 0)
+ {
+ String js = getElementsDeleteJavascript();
+
+ // add the javascript to target
+ target.prependJavascript(js);
+ }
+
+ // We have to repeat this as long as there are any dirty items to be
+ // created. The reason why we can't do this in one pass is that some
+ // of the items may need to be inserted after items that has not
+ // been
+ // inserted yet, so we have to detect those and wait until the items
+ // they depend on are inserted.
+ while (dirtyItemsCreateDOM.isEmpty() == false)
+ {
+ for (Iterator<TreeItem> i = dirtyItemsCreateDOM.iterator(); i.hasNext();)
+ {
+ TreeItem item = i.next();
+ TreeItem parent = item.getParentItem();
+ int index = parent.getChildren().indexOf(item);
+ TreeItem previous;
+ // we need item before this (in dom structure)
+ if (index == 0)
+ {
+ previous = parent;
+ }
+ else
+ {
+ previous = (TreeItem)parent.getChildren().get(index - 1);
+ // get the last item of previous item subtree
+ while (previous.getChildren() != null && previous.getChildren().size() > 0)
+ {
+ previous = (TreeItem)previous.getChildren().get(
+ previous.getChildren().size() - 1);
+ }
+ }
+ // check if the previous item isn't waiting to be inserted
+ if (dirtyItemsCreateDOM.contains(previous) == false)
+ {
+ // it's already in dom, so we can use it as point of
+ // insertion
+ target.prependJavascript("Wicket.Tree.createElement(\""
+ + item.getMarkupId() + "\"," + "\"" + previous.getMarkupId()
+ + "\")");
+
+ // remove the item so we don't process it again
+ i.remove();
+ }
+ else
+ {
+ // we don't do anything here, inserting this item will
+ // have to wait until the previous item gets inserted
+ }
+ }
+ }
+
+ // iterate through dirty items
+ for (TreeItem item : dirtyItems)
+ {
+ // does the item need to rebuild children?
+ if (item.getChildren() == null)
+ {
+ // rebuld the children
+ buildItemChildren(item);
+
+ // set flag on item so that it renders itself together with
+ // it's children
+ item.setRenderChildren(true);
+ }
+
+ // add the component to target
+ target.addComponent(item);
+ }
+
+ // clear dirty flags
+ updated();
+ }
+ }
+
+ /**
+ * Returns whether the given node is expanded.
+ *
+ * @param node
+ * The node to inspect
+ * @return true if the node is expanded, false otherwise
+ */
+ protected final boolean isNodeExpanded(TreeNode node)
+ {
+ // In root less mode the root node is always expanded
+ if (isRootLess() && rootItem != null && rootItem.getModelObject().equals(node))
+ {
+ return true;
+ }
+
+ return getTreeState().isNodeExpanded(node);
+ }
+
+ /**
+ * Creates the TreeState, which is an object where the current state of tree
+ * (which nodes are expanded / collapsed, selected, ...) is stored.
+ *
+ * @return Tree state instance
+ */
+ protected ITreeState newTreeState()
+ {
+ return new DefaultTreeState();
+ }
+
+ /**
+ * Called after the rendering of tree is complete. Here we clear the dirty
+ * flags.
+ */
+ @Override
+ protected void onAfterRender()
+ {
+ // rendering is complete, clear all dirty flags and items
+ updated();
+ }
+
+ /**
+ * This method is called after creating every TreeItem. This is the place
+ * for adding components on item (junction links, labels, icons...)
+ *
+ * @param item
+ * newly created tree item. The node can be obtained as
+ * item.getModelObject()
+ *
+ * @param level
+ * how deep the component is in tree hierarchy (0 for root item)
+ */
+ protected abstract void populateTreeItem(WebMarkupContainer<TreeNode> item, int level);
+
+ /**
+ * Builds the children for given TreeItem. It recursively traverses children
+ * of it's TreeNode and creates TreeItem for every visible TreeNode.
+ *
+ * @param item
+ * The parent tree item
+ */
+ private final void buildItemChildren(TreeItem item)
+ {
+ List<TreeItem> items;
+
+ // if the node is expanded
+ if (isNodeExpanded(item.getModelObject()))
+ {
+ // build the items for children of the items' treenode.
+ items = buildTreeItems(nodeChildren(item.getModelObject()), item.getLevel() + 1);
+ }
+ else
+ {
+ // it's not expanded, just set children to an empty list
+ items = Collections.emptyList();
+ }
+
+ item.setChildren(items);
+ }
+
+ /**
+ * Builds (recursively) TreeItems for the given Iterable of TreeNodes.
+ *
+ * @param nodes
+ * The nodes to build tree items for
+ * @param level
+ * The current level
+ * @return List with new tree items
+ */
+ private final List<TreeItem> buildTreeItems(Iterable<TreeNode> nodes, int level)
+ {
+ List<TreeItem> result = new ArrayList<TreeItem>();
+
+ // for each node
+ for (TreeNode node : nodes)
+ {
+ // create tree item
+ TreeItem item = newTreeItem(node, level);
+
+ // builds it children (recursively)
+ buildItemChildren(item);
+
+ // add item to result
+ result.add(item);
+ }
+
+ return result;
+ }
+
+ /**
+ * Checks whether the model has been chaned, and if so unregister and
+ * register listeners.
+ */
+ private final void checkModel()
+ {
+ // find out whether the model object (the TreeModel) has been changed
+ TreeModel model = getModelObject();
+ if (model != previousModel)
+ {
+ if (previousModel != null)
+ {
+ previousModel.removeTreeModelListener(this);
+ }
+
+ previousModel = model;
+
+ if (model != null)
+ {
+ model.addTreeModelListener(this);
+ }
+ // model has been changed, redraw whole tree
+ invalidateAll();
+ }
+ }
+
+ /**
+ * Removes all TreeItem components.
+ */
+ private final void clearAllItem()
+ {
+ visitItemAndChildren(rootItem, new IItemCallback()
+ {
+ public void visitItem(TreeItem item)
+ {
+ item.remove();
+ }
+ });
+ rootItem = null;
+ }
+
+ /**
+ * Returns the javascript used to delete removed elements.
+ *
+ * @return The javascript
+ */
+ private String getElementsDeleteJavascript()
+ {
+ // build the javascript call
+ final AppendingStringBuffer buffer = new AppendingStringBuffer(100);
+
+ buffer.append("Wicket.Tree.removeNodes(\"");
+
+ // first parameter is the markup id of tree (will be used as prefix to
+ // build ids of child items
+ buffer.append(getMarkupId() + "_\",[");
+
+ // append the ids of elements to be deleted
+ buffer.append(deleteIds);
+
+ // does the buffer end if ','?
+ if (buffer.endsWith(","))
+ {
+ // it does, trim it
+ buffer.setLength(buffer.length() - 1);
+ }
+
+ buffer.append("]);");
+
+ return buffer.toString();
+ }
+
+ //
+ // State and Model's callbacks
+ //
+
+ /**
+ * returns the short version of item id (just the number part).
+ *
+ * @param item
+ * The tree item
+ * @return The id
+ */
+ private String getShortItemId(TreeItem item)
+ {
+ // show much of component id can we skip? (to minimize the length of
+ // javascript being sent)
+ final int skip = getMarkupId().length() + 1; // the length of id of
+ // tree and '_'.
+ return item.getMarkupId().substring(skip);
+ }
+
+ /**
+ * Initialize the component.
+ */
+ private final void init()
+ {
+ // disable versioning for the tree
+ setVersioned(false);
+
+ // we need id when we are replacing the whole tree
+ setOutputMarkupId(true);
+
+ // create container for tree items
+ itemContainer = new TreeItemContainer(this, "i");
+
+ add(HeaderContributor.forJavaScript(AbstractTree.class, "res/tree.js"));
+ }
+
+ /**
+ * Invalidates single node (without children). On the next render, this node
+ * will be updated. Node will not be rebuilt, unless forceRebuild is true.
+ *
+ * @param node
+ * The node to invalidate
+ * @param forceRebuild
+ */
+ private final void invalidateNode(TreeNode node, boolean forceRebuild)
+ {
+ if (dirtyAll == false)
+ {
+ // get item for this node
+ TreeItem item = nodeToItemMap.get(node);
+
+ if (item != null)
+ {
+ boolean createDOM = false;
+
+ if (forceRebuild)
+ {
+ // recreate the item
+ int level = item.getLevel();
+ List<TreeItem> children = item.getChildren();
+ String id = item.getId();
+
+ // store the parent of old item
+ TreeItem parent = item.getParentItem();
+
+ // if the old item has a parent, store it's index
+ int index = parent != null ? parent.getChildren().indexOf(item) : -1;
+
+ createDOM = dirtyItemsCreateDOM.contains(item);
+
+ dirtyItems.remove(item);
+ dirtyItemsCreateDOM.remove(item);
+
+ item.remove();
+
+ item = newTreeItem(node, level, id);
+ item.setChildren(children);
+
+ // was the item an root item?
+ if (parent == null)
+ {
+ rootItem = item;
+ }
+ else
+ {
+ parent.getChildren().set(index, item);
+ }
+ }
+
+ dirtyItems.add(item);
+ if (createDOM)
+ dirtyItemsCreateDOM.add(item);
+ }
+ }
+ }
+
+ /**
+ * Invalidates node and it's children. On the next render, the node and
+ * children will be updated. Node children will be rebuilt.
+ *
+ * @param node
+ * The node to invalidate
+ */
+ private final void invalidateNodeWithChildren(TreeNode node)
+ {
+ if (dirtyAll == false)
+ {
+ // get item for this node
+ TreeItem item = nodeToItemMap.get(node);
+
+ // is the item visible?
+ if (item != null)
+ {
+ // go though item children and remove every one of them
+ visitItemChildren(item, new IItemCallback()
+ {
+ public void visitItem(TreeItem item)
+ {
+ removeItem(item);
+ }
+ });
+
+ // set children to null so that they get rebuild
+ item.setChildren(null);
+
+ // add item to dirty items
+ dirtyItems.add(item);
+ }
+ }
+ }
+
+ /**
+ * Returns whether the given node is visibled, e.g. all it's parents are
+ * expanded.
+ *
+ * @param node
+ * The node to inspect
+ * @return true if the node is visible, false otherwise
+ */
+ private final boolean isNodeVisible(TreeNode node)
+ {
+ while (node.getParent() != null)
+ {
+ if (isNodeExpanded(node.getParent()) == false)
+ {
+ return false;
+ }
+ node = node.getParent();
+ }
+ return true;
+ }
+
+ /**
+ * Creates a tree item for given node.
+ *
+ * @param node
+ * The tree node
+ * @param level
+ * The level
+ * @return The new tree item
+ */
+ private final TreeItem newTreeItem(TreeNode node, int level)
+ {
+ return new TreeItem(itemContainer, "" + idCounter++, node, level);
+ }
+
+ /**
+ * Creates a tree item for given node with specified id.
+ *
+ * @param node
+ * The tree node
+ * @param level
+ * The level
+ * @param id
+ * the component id
+ * @return The new tree item
+ */
+ private final TreeItem newTreeItem(TreeNode node, int level, String id)
+ {
+ return new TreeItem(itemContainer, id, node, level);
+ }
+
+ /**
+ * Return the representation of node children as Iterable interface.
+ *
+ * @param node
+ * The tree node
+ * @return iterable presentation of node children
+ */
+ private final Iterable<TreeNode> nodeChildren(TreeNode node)
+ {
+ return toIterable(node.children());
+ }
+
+ /**
+ * Rebuilds children of every item in dirtyItems that needs it. This method
+ * is called for non-partial update.
+ */
+ private final void rebuildDirty()
+ {
+ // go through dirty items
+ for (TreeItem item : dirtyItems)
+ {
+ // item chilren need to be rebuilt
+ if (item.getChildren() == null)
+ {
+ buildItemChildren(item);
+ }
+ }
+ }
+
+ /**
+ * Removes the item, appends it's id to deleteIds. This is called when a
+ * items parent is being deleted or rebuilt.
+ *
+ * @param item
+ * The item to remove
+ */
+ private void removeItem(TreeItem item)
+ {
+ // even if the item is dirty it's no longer necessary to update id
+ dirtyItems.remove(item);
+
+ // if the item was about to be created
+ if (dirtyItemsCreateDOM.contains(item))
+ {
+ // we needed to create DOM element, we no longer do
+ dirtyItemsCreateDOM.remove(item);
+ }
+ else
+ {
+ // add items id (it's short version) to ids of DOM elements that
+ // will be
+ // removed
+ deleteIds.append(getShortItemId(item));
+ deleteIds.append(",");
+ }
+
+ // remove the id
+ // note that this doesn't update item's parent's children list
+ item.remove();
+ }
+
+ /**
+ * Calls after the tree has been rendered. Clears all dirty flags.
+ */
+ private final void updated()
+ {
+ this.dirtyAll = false;
+ this.dirtyItems.clear();
+ this.dirtyItemsCreateDOM.clear();
+ deleteIds.clear(); // FIXME: Recreate it to save some space?
+ }
+
+ /**
+ * Call the callback#visitItem method for the given item and all it's
+ * chilren.
+ *
+ * @param item
+ * The tree item
+ * @param callback
+ * item call back
+ */
+ private final void visitItemAndChildren(TreeItem item, IItemCallback callback)
+ {
+ callback.visitItem(item);
+ visitItemChildren(item, callback);
+ }
+
+ /**
+ * Call the callback#visitItem method for every child of given item.
+ *
+ * @param item
+ * The tree item
+ * @param callback
+ * The callback
+ */
+ private final void visitItemChildren(TreeItem item, IItemCallback callback)
+ {
+ if (item.getChildren() != null)
+ {
+ for (TreeItem i : item.getChildren())
+ {
+ visitItemAndChildren(i, callback);
+ }
+ }
+ }
+
+ /**
+ * Returns the component associated with given node, or null, if node is not
+ * visible. This is useful in situations when you want to touch the node
+ * element in html.
+ *
+ * @param node
+ * Tree node
+ * @return Component associated with given node, or null if node is not
+ * visible.
+ */
+ public Component getNodeComponent(TreeNode node)
+ {
+ return (Component)nodeToItemMap.get(node);
+ }
+}
Modified: incubator/wicket/trunk/wicket/src/main/java/wicket/markup/repeater/PageableRefreshingView.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/main/java/wicket/markup/repeater/PageableRefreshingView.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/main/java/wicket/markup/repeater/PageableRefreshingView.java (original)
+++ incubator/wicket/trunk/wicket/src/main/java/wicket/markup/repeater/PageableRefreshingView.java Sun Dec 31 18:10:28 2006
@@ -44,8 +44,8 @@
*
* @author Igor Vaynberg (ivaynberg)
*
- * @param <T>
- * Type of model object this component holds
+ * @param <T>
+ * Type of model object this component holds
*/
public abstract class PageableRefreshingView<T> extends RefreshingView<T> implements IPageable
{
@@ -106,10 +106,10 @@
@Override
- protected void internalOnDetach()
+ protected void onDetach()
{
- super.internalOnDetach();
clearCachedItemCount();
+ super.onDetach();
}
/**
@@ -343,7 +343,7 @@
* Iterator adapter that makes sure only the specified max number of items
* can be accessed from its delegate.
*
- * @param <T>
+ * @param <T>
*/
private static class CappedIteratorAdapter<T> implements Iterator<IModel<T>>
{
Modified: incubator/wicket/trunk/wicket/src/main/java/wicket/markup/repeater/RefreshingView.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/main/java/wicket/markup/repeater/RefreshingView.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/main/java/wicket/markup/repeater/RefreshingView.java (original)
+++ incubator/wicket/trunk/wicket/src/main/java/wicket/markup/repeater/RefreshingView.java Sun Dec 31 18:10:28 2006
@@ -33,8 +33,8 @@
* and {@link RefreshingView#populateItem(Item) } methods. RefreshingView builds
* the items that will be rendered by looping over the models retrieved from
* {@link RefreshingView#getItemModels() } and calling the
- * {@link RefreshingView#newItem(MarkupContainer, String, int, IModel) } to generate the child
- * item container followed by a call to
+ * {@link RefreshingView#newItem(MarkupContainer, String, int, IModel) } to
+ * generate the child item container followed by a call to
* {@link RefreshingView#populateItem(Item) } to let the user populate the newly
* created item container with custom components.
* </p>
@@ -49,8 +49,8 @@
*
* @author Igor Vaynberg (ivaynberg)
*
- * @param <T>
- * Type of model object this component holds
+ * @param <T>
+ * Type of model object this component holds
*
*/
public abstract class RefreshingView<T> extends RepeatingView<T>
@@ -86,9 +86,9 @@
* selected item reuse strategy
*/
@Override
- protected void internalOnAttach()
+ protected void onAttach()
{
- super.internalOnAttach();
+ super.onAttach();
if (isVisibleInHierarchy())
{
@@ -101,13 +101,15 @@
String id = RefreshingView.this.newChildId();
Item<T> item = RefreshingView.this.newItem(parent, id, index, model);
RefreshingView.this.populateItem(item);
+ item.attach();
return item;
}
};
Iterator<IModel<T>> models = getItemModels();
- Iterator<Item<T>> items = getItemReuseStrategy().getItems(RefreshingView.this, itemFactory, models, getItems());
+ Iterator<Item<T>> items = getItemReuseStrategy().getItems(RefreshingView.this,
+ itemFactory, models, getItems());
removeAll();
addItems(items);
}
@@ -148,7 +150,8 @@
* Factory method for Item container. Item containers are simple
* MarkupContainer used to aggregate the user added components for a row
* inside the view.
- * @param parent
+ *
+ * @param parent
*
* @see Item
* @param id
@@ -160,7 +163,8 @@
*
* @return DataItem created DataItem
*/
- protected Item<T> newItem(MarkupContainer<?> parent, final String id, int index, final IModel<T> model)
+ protected Item<T> newItem(MarkupContainer<?> parent, final String id, int index,
+ final IModel<T> model)
{
return new Item<T>(parent, id, index, model);
}
Modified: incubator/wicket/trunk/wicket/src/main/java/wicket/markup/repeater/data/DataViewBase.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/main/java/wicket/markup/repeater/data/DataViewBase.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/main/java/wicket/markup/repeater/data/DataViewBase.java (original)
+++ incubator/wicket/trunk/wicket/src/main/java/wicket/markup/repeater/data/DataViewBase.java Sun Dec 31 18:10:28 2006
@@ -146,7 +146,7 @@
@Override
protected void onDetach()
{
- super.onDetach();
dataProvider.detach();
+ super.onDetach();
}
}
Modified: incubator/wicket/trunk/wicket/src/main/java/wicket/protocol/http/FilePageStore.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/main/java/wicket/protocol/http/FilePageStore.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/main/java/wicket/protocol/http/FilePageStore.java (original)
+++ incubator/wicket/trunk/wicket/src/main/java/wicket/protocol/http/FilePageStore.java Sun Dec 31 18:10:28 2006
@@ -165,7 +165,7 @@
File pageFile = getPageFile(page.getNumericId(), page.getCurrentVersionNumber(), sessionDir);
// TODO check can this be called everytime at this place? Putting should
// be called after the rendering so it should be ok.
- page.internalDetach();
+ page.detach();
byte[] bytes = Objects.objectToByteArray(page);
FileOutputStream fos = null;
try
Modified: incubator/wicket/trunk/wicket/src/main/java/wicket/protocol/http/HttpSessionStore.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/main/java/wicket/protocol/http/HttpSessionStore.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/main/java/wicket/protocol/http/HttpSessionStore.java (original)
+++ incubator/wicket/trunk/wicket/src/main/java/wicket/protocol/http/HttpSessionStore.java Sun Dec 31 18:10:28 2006
@@ -54,7 +54,7 @@
{
if (value instanceof Page)
{
- ((Page)value).internalDetach();
+ ((Page)value).detach();
}
String valueTypeName = (value != null ? value.getClass().getName() : "null");
try
Modified: incubator/wicket/trunk/wicket/src/main/java/wicket/protocol/http/WebRequestCycle.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/main/java/wicket/protocol/http/WebRequestCycle.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/main/java/wicket/protocol/http/WebRequestCycle.java (original)
+++ incubator/wicket/trunk/wicket/src/main/java/wicket/protocol/http/WebRequestCycle.java Sun Dec 31 18:10:28 2006
@@ -222,7 +222,7 @@
// Redirect page can touch its models already (via for example the
// constructors)
- page.internalDetach();
+ page.detach();
}
if (redirectUrl == null)
Modified: incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/component/BookmarkablePageRequestTarget.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/component/BookmarkablePageRequestTarget.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/component/BookmarkablePageRequestTarget.java (original)
+++ incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/component/BookmarkablePageRequestTarget.java Sun Dec 31 18:10:28 2006
@@ -119,7 +119,7 @@
{
if (page != null)
{
- page.internalDetach();
+ page.detach();
}
}
Modified: incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/component/ComponentRequestTarget.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/component/ComponentRequestTarget.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/component/ComponentRequestTarget.java (original)
+++ incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/component/ComponentRequestTarget.java Sun Dec 31 18:10:28 2006
@@ -97,14 +97,14 @@
}
// attach
- component.internalAttach();
+ component.attach();
// Render the component
component.renderComponent();
}
finally
{
- component.getPage().internalDetach();
+ component.getPage().detach();
}
Modified: incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/component/PageRequestTarget.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/component/PageRequestTarget.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/component/PageRequestTarget.java (original)
+++ incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/component/PageRequestTarget.java Sun Dec 31 18:10:28 2006
@@ -82,7 +82,7 @@
*/
public void detach(RequestCycle requestCycle)
{
- page.internalDetach();
+ page.detach();
}
/**
Modified: incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/resource/ComponentResourceRequestTarget.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/resource/ComponentResourceRequestTarget.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/resource/ComponentResourceRequestTarget.java (original)
+++ incubator/wicket/trunk/wicket/src/main/java/wicket/request/target/resource/ComponentResourceRequestTarget.java Sun Dec 31 18:10:28 2006
@@ -102,7 +102,7 @@
*/
public void detach(RequestCycle requestCycle)
{
- page.internalDetach();
+ page.detach();
}
/**
Modified: incubator/wicket/trunk/wicket/src/test/java/wicket/ComponentTest.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/test/java/wicket/ComponentTest.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/test/java/wicket/ComponentTest.java (original)
+++ incubator/wicket/trunk/wicket/src/test/java/wicket/ComponentTest.java Sun Dec 31 18:10:28 2006
@@ -16,6 +16,11 @@
*/
package wicket;
+import wicket.markup.IMarkupResourceStreamProvider;
+import wicket.markup.html.WebPage;
+import wicket.util.resource.IResourceStream;
+import wicket.util.resource.StringResourceStream;
+
/**
* Test for ajax handler.
@@ -41,4 +46,85 @@
{
executeTest(TestPage_1.class, "TestPageExpectedResult_1.html");
}
+
+ /**
+ * Tests traps for bad onattach/ondetach overrides
+ */
+ public void testAttachDetachTraps()
+ {
+ try
+ {
+ tester.setupRequestAndResponse();
+ Page page = new BadOnAttachPage();
+ page.attach();
+ fail("bad onAttach() override did not trigger an exception");
+ }
+ catch (IllegalStateException e)
+ {
+ // noop
+ }
+ try
+ {
+ tester.setupRequestAndResponse();
+ Page page = new BadOnDetachPage();
+ page.attach();
+ page.detach();
+ fail("bad onDetach() override did not trigger an exception");
+ }
+ catch (IllegalStateException e)
+ {
+ // noop
+ }
+ }
+
+
+ /**
+ * @author ivaynberg
+ */
+ public static class BaseTestPage extends WebPage implements IMarkupResourceStreamProvider
+ {
+ private static final long serialVersionUID = 1L;
+
+ public IResourceStream getMarkupResourceStream(MarkupContainer container,
+ Class<? extends MarkupContainer> containerClass)
+ {
+ return new StringResourceStream("helloworld");
+ }
+
+ }
+
+ /**
+ * Page with a bad onattach() override
+ *
+ * @author ivaynberg
+ */
+ public static class BadOnAttachPage extends BaseTestPage
+ {
+
+ private static final long serialVersionUID = 1L;
+
+ @Override
+ protected void onAttach()
+ {
+ // super.onAttach();
+ }
+ }
+
+ /**
+ * Page with a bad ondetach() override
+ *
+ * @author ivaynberg
+ */
+ public static class BadOnDetachPage extends BaseTestPage
+ {
+
+ private static final long serialVersionUID = 1L;
+
+ @Override
+ protected void onDetach()
+ {
+ // super.onDetach();
+ }
+ }
+
}
Modified: incubator/wicket/trunk/wicket/src/test/java/wicket/markup/html/form/upload/FileUploadFieldTest.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/test/java/wicket/markup/html/form/upload/FileUploadFieldTest.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/test/java/wicket/markup/html/form/upload/FileUploadFieldTest.java (original)
+++ incubator/wicket/trunk/wicket/src/test/java/wicket/markup/html/form/upload/FileUploadFieldTest.java Sun Dec 31 18:10:28 2006
@@ -88,7 +88,7 @@
// We should be able to read a byte
assertTrue(is.read() != -1);
- field.internalOnDetach();
+ field.onDetach();
// The input stream should be closed so we shouldn't be able to read any more bytes
try
Modified: incubator/wicket/trunk/wicket/src/test/java/wicket/versioning/ReattachVersioningTest.java
URL: http://svn.apache.org/viewvc/incubator/wicket/trunk/wicket/src/test/java/wicket/versioning/ReattachVersioningTest.java?view=diff&rev=491522&r1=491521&r2=491522
==============================================================================
--- incubator/wicket/trunk/wicket/src/test/java/wicket/versioning/ReattachVersioningTest.java (original)
+++ incubator/wicket/trunk/wicket/src/test/java/wicket/versioning/ReattachVersioningTest.java Sun Dec 31 18:10:28 2006
@@ -30,9 +30,9 @@
{
executeTest(ReattachTestPage.class, "ReattachTestPage_result.html");
ReattachTestPage testPage = (ReattachTestPage)tester.getLastRenderedPage();
- testPage.internalAttach();
+ testPage.attach();
testPage.reattachLabel1();
- testPage.internalDetach();
+ testPage.detach();
assertEquals(testPage.getVersions(), 2);
testPage = (ReattachTestPage)testPage.getVersion(0);
assertNotNull(testPage.get("label"));