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"));