Java tutorial
/* * Ext GWT - Ext for GWT * Copyright(c) 2007-2009, Ext JS, LLC. * licensing@extjs.com * * http://extjs.com/license */ package com.extjs.gxt.ui.client.widget.tree; import java.util.ArrayList; import java.util.List; import com.extjs.gxt.ui.client.PartFactory; import com.extjs.gxt.ui.client.core.XDOM; import com.extjs.gxt.ui.client.event.BaseEvent; import com.extjs.gxt.ui.client.event.ComponentEvent; import com.extjs.gxt.ui.client.event.EventType; import com.extjs.gxt.ui.client.event.Events; import com.extjs.gxt.ui.client.event.TreeEvent; import com.extjs.gxt.ui.client.widget.Component; import com.extjs.gxt.ui.client.widget.tree.Tree.Joint; import com.extjs.gxt.ui.client.widget.treepanel.TreePanel; import com.google.gwt.dom.client.NodeList; import com.google.gwt.user.client.Element; /** * A item in a <code>Tree</code>. All events are bubbled to the item's parent * tree. * * <dl> * <dt><b>Events:</b></dt> * * <dd><b>BeforeAdd</b> : TreeEvent(tree, parent, item, index)<br> * <div>Fires before a item is added or inserted. Listeners can cancel the action by * calling {@link BaseEvent#setCancelled(boolean)}.</div> * <ul> * <li>tree : the source tree</li> * <li>parent : this</li> * <li>item : the item being added</li> * <li>index : the index at which the item will be added</li> * </ul> * </dd> * * <dd><b>BeforeRemove</b> : TreeEvent(tree, parent, item)<br> * <div>Fires before a item is removed. Listeners can cancel the action by * calling {@link BaseEvent#setCancelled(boolean)}.</div> * <ul> * <li>tree : the source tree</li> * <li>parent : this</li> * <li>item : the item being removed</li> * </ul> * </dd> * * <dd><b>BeforeExpand</b> : TreeEvent(tree, item)<br> * <div>Fires before a item is expanded. Listeners can cancel the action by * calling {@link BaseEvent#setCancelled(boolean)}.</div> * <ul> * <li>tree : the source tree</li> * <li>item : this</li> * </ul> * </dd> * * <dd><b>BeforeCollapse</b> : TreeEvent(tree, item)<br> * <div>Fires before a item is collapsed. Listeners can cancel the action by * calling {@link BaseEvent#setCancelled(boolean)}.</div> * <ul> * <li>tree : the source tree</li> * <li>item : this</li> * </ul> * </dd> * * <dd><b>Add</b> : TreeEvent(tree, parent, item, index)<br> * <div>Fires after a item has been added or inserted.</div> * <ul> * <li>tree : the source tree</li> * <li>parent : this</li> * <li>item : the item that was added</li> * <li>index : the index at which the item will be added</li> * </ul> * </dd> * * <dd><b>Remove</b> : TreeEvent(tree, parent, item)<br> * <div>Fires after a item has been removed.</div> * <ul> * <li>tree : the source tree</li> * <li>parent : this</li> * <li>item : the item being removed</li> * </ul> * </dd> * * <dd><b>Expand</b> : TreeEvent(tree, item)<br> * <div>Fires after a item has been expanded.</div> * <ul> * <li>tree : the source tree</li> * <li>item : this</li> * </ul> * </dd> * * <dd><b>Collapse</b> : TreeEvent(tree, item)<br> * <div>Fires after a item is collapsed.</div> * <ul> * <li>tree : the source tree</li> * <li>item : this</li> * </ul> * </dd> * * <dd><b>CheckChange</b> : TreeEvent(tree, item)<br> * <div>Fires after a check state change.</div> * <ul> * <li>tree : the source tree</li> * <li>item : this</li> * </ul> * </dd> * * <dt><b>CSS:</b></dt> * <dd>.my-tree-item (the item itself)</dd> * <dd>.my-tree-item-text span (the tree item text)</dd> * </dl> * * @deprecated see {@link TreePanel} */ public class TreeItem extends Component { protected boolean childrenRendered; protected boolean root, expanded, checked; protected Tree tree; protected TreeItemUI ui; TreeItem parentItem; String text, iconStyle, itemStyleName; private List<TreeItem> children; private boolean expandOnRender; private boolean leaf = true; private String textStyle; /** * Creates a new tree item. */ public TreeItem() { children = new ArrayList<TreeItem>(); } /** * Creates a new tree item. * * @param text the item's text */ public TreeItem(String text) { this(); setText(text); } /** * Adds a child item. * * @param item the item to be added */ public void add(TreeItem item) { add(item, getItemCount()); } public int getIndent() { return (getDepth()) * tree.getIndentWidth(); } @Override public boolean equals(Object obj) { if (obj instanceof TreeItem) { return getId().equals(((TreeItem) obj).getId()); } return false; } /** * Inserts a child item at the specified position. * * @param item the item to be added * @param index index at which the specified element is to be inserted */ public void add(TreeItem item, int index) { TreeEvent te = new TreeEvent(tree); te.setParent(this); te.setItem(item); te.setIndex(index); if (fireEvent(Events.BeforeAdd, te)) { if (item.parentItem != null && item.parentItem != this) { item.parentItem.remove(item); } else if (item.parentItem != null && item.parentItem == parentItem) { children.remove(item); if (childrenRendered) { item.el().removeFromParent(); } } item.parentItem = this; item.setTree(tree); tree.registerItem(item); children.add(index, item); leaf = false; if (childrenRendered) { Element target = root ? getContainer() : ui.getContainerElement(); if (item.isRendered()) { fly(target).insertChild(item.getElement(), index); item.getUI().onIndentChange(getDepth()); List<TreeItem> list = new ArrayList<TreeItem>(); getAllChildren(list, item); for (TreeItem ti : list) { tree.registerItem(ti); } } else { item.render(target, index); } } if (rendered && !root && children.size() == 1) { fly(ui.getContainerElement()).setVisible(true); updateJointStyle(); ui.onIconStyleChange(getIconStyle()); } fireEvent(Events.Add, te); } } /** * Returns the item's first child. * * @return the first child or <code>null</code> */ public TreeItem firstChild() { for (TreeItem child : getItems()) { if (child.isVisible()) return child; } return null; } /** * Returns the item's container element. * * @return the container */ public Element getContainer() { return root ? getElement() : ui.getContainerElement(); } /** * Returns the item's node depth. * * @return the depth */ public int getDepth() { int depth = 0; TreeItem p = getParentItem(); while (p != null) { depth++; p = p.getParentItem(); } return depth; } /** * Returns the item's icon style. * * @return the icon style */ public String getIconStyle() { return iconStyle; } /** * Returns the item at the specified index. * * @param index the index * @return the item at the index */ public TreeItem getItem(int index) { if ((index < 0) || (index >= getItemCount())) return null; return children.get(index); } /** * Returns the number of child items. * * @return the child count */ public int getItemCount() { return children.size(); } /** * Returns the item's children. * * @return the children items */ public List<TreeItem> getItems() { return new ArrayList<TreeItem>(children); } /** * Returns the item's children. * * @param deep true to retrieve all the item's children * @return the children items */ @SuppressWarnings("unchecked") public List<TreeItem> getItems(boolean deep) { if (deep) { List list = new ArrayList(); getAllChildren(list, this); return list; } else { return getItems(); } } /** * Returns the item's style name. * * @return the style name */ public String getItemStyleName() { return itemStyleName; } /** * Returns the item's parent. * * @return the parent item */ public TreeItem getParentItem() { return parentItem; } /** * Returns the path for this node. The path can be used to expand or select * this node programmatically. * * @return a comma separated list of tree item id's */ public String getPath() { StringBuffer sb = new StringBuffer(); TreeItem p = this; while (p != null) { String id = p.getId(); sb.insert(0, "," + id); p = p.getParentItem(); } return sb.toString().substring(1); } /** * Returns the item's text. * * @return the text */ public String getText() { return text; } /** * Returns the item's text style. * * @return the text style */ public String getTextStyle() { return textStyle; } /** * Returns the item's ui instance. * * @return the ui instance */ public TreeItemUI getUI() { return ui; } /** * Returns <code>true</code> if the item's has children. * * @return the children state */ public boolean hasChildren() { return getItemCount() > 0; } /** * Returns the index of the item or -1 if not found. * * @param item the child item * @return the item's index */ public int indexOf(TreeItem item) { return children.indexOf(item); } /** * Returns <code>true</code> if the item is checked. * * @return the checked state */ public boolean isChecked() { return checked; } /** * Returns <code>true</code> if the item is expanded, and <code>false</code> * otherwise. * * @return the expanded state */ public boolean isExpanded() { return expanded; } /** * Returns <code>true</code> if the item is a leaf, and <code>false</code> * otherwise. The leaf state allows a tree item to specify if it has children * before the children have been realized. * * @return the leaf state */ public boolean isLeaf() { return leaf; } /** * Returns <code>true</code> if the item is a root item. * * @return the root state */ public boolean isRoot() { return root; } /** * Returns the item's last child. * * @return the last child */ public TreeItem lastChild() { for (int i = getItemCount() - 1; i >= 0; i--) { TreeItem child = getItem(i); if (child.isVisible()) return child; } return null; } /** * Returns the item next sibling. * * @return the next sibling */ public TreeItem nextSibling() { if (parentItem == null) return null; int index = parentItem.indexOf(this); for (int i = index + 1; i < parentItem.getItemCount(); i++) { if (parentItem.getItem(i).isVisible()) return parentItem.getItem(i); } return null; } public void onComponentEvent(ComponentEvent ce) { // delegate event handling to ui if (ui != null) { ui.handleEvent((TreeEvent) ce); } } /** * Returns the item's previous sibling. * * @return the previous sibling */ public TreeItem previousSibling() { if (parentItem == null) return null; int index = parentItem.indexOf(this); for (int i = index - 1; i >= 0; i--) { if (parentItem.getItem(i).isVisible()) return parentItem.getItem(i); } return null; } /** * Removes a child from the item. * * @param item the item to be removed */ public void remove(TreeItem item) { if (!children.contains(item)) { return; } TreeEvent te = new TreeEvent(tree); te.setParent(this); te.setItem(item); if (fireEvent(Events.BeforeRemove, te)) { children.remove(item); tree.unregisterItem(item); item.tree = null; item.parentItem = null; if (rendered && item.rendered) { if (root) { item.el().removeFromParent(); } else { ui.onRemoveChild(item); } } fireEvent(Events.Remove, te); } } /** * Removes all child items. */ public void removeAll() { int count = getItemCount(); for (int i = 0; i < count; i++) { remove(getItem(0)); } leaf = true; } /** * Sets the item's checked value. * * @param checked <code>true</code> to check */ public void setChecked(boolean checked) { this.checked = checked; if (rendered) { if (fireEvent(Events.BeforeCheckChange, new TreeEvent(tree, this))) { ui.onCheckChange(checked); if (checked) { switch (tree.getCheckStyle()) { case PARENTS: TreeItem p = getParentItem(); while (p != null && !p.root) { p.setChecked(true); p = p.getParentItem(); } break; case CHILDREN: for (int i = 0; i < getItemCount(); i++) { getItem(i).setChecked(true); } break; } } else { switch (tree.getCheckStyle()) { case PARENTS: clearCheckChildren(this); break; case CHILDREN: for (int i = 0; i < getItemCount(); i++) { getItem(i).setChecked(false); } break; } } } } } @Override public void setElement(Element elem) { super.setElement(elem); if (!root) { getUI().afterRender(); rendered = true; if (expandOnRender) { boolean anim = tree.getAnimate(); tree.setAnimate(false); setExpanded(true); tree.setAnimate(anim); } } } public void setTreeTableElement(Element elem) { super.setElement(elem); } /** * Sets the item's expanded state. * * @param expanded <code>true</code> to expand */ public void setExpanded(boolean expanded) { setExpanded(expanded, false); } /** * Sets the item's expand state. * * @param expanded <code>true</code> to expand * @param deep <code>true</code> to expand all children */ public void setExpanded(boolean expanded, boolean deep) { if (!rendered) { expandOnRender = expanded; return; } if (expanded && root) { this.expanded = false; } else if (!expanded && root) { this.expanded = true; } TreeEvent te = new TreeEvent(tree, this); if (expanded) { if (!this.expanded && !isLeaf()) { if (fireEvent(Events.BeforeExpand, te)) { this.expanded = true; if (!childrenRendered) { renderChildren(); } ui.expand(); TreeItem p = parentItem; while (p != null && !p.root) { if (p.expanded == false) { p.setExpanded(true); } p = p.parentItem; } } if (deep) { expandChildren(deep); } } else { if (deep) { expandChildren(deep); } } } else if (this.expanded && !expanded) { if (fireEvent(Events.BeforeCollapse, te)) { this.expanded = false; ui.collapse(); } if (deep) { for (int i = 0; i < getItemCount(); i++) { TreeItem item = getItem(i); item.setExpanded(false, true); } } } } /** * Sets the item's icon style. The style name should match a CSS style that * specifies a background image using the following format: * * <pre><code> * .my-icon { * background: url(images/icons/my-icon.png) no-repeat center left !important; * } * </code></pre> * * @param style the icon style */ public void setIconStyle(String style) { this.iconStyle = style; if (rendered) { updateIconStyle(); } } /** * Sets a style name that will be added to the tree item's element, not the * container element. * * @param itemStyleName the style name */ public void setItemStyleName(String itemStyleName) { this.itemStyleName = itemStyleName; } /** * Sets the item's leaf state. The leaf state allows a tree item to specify if * it has children before the children have been realized. * * @param leaf the state */ public void setLeaf(boolean leaf) { this.leaf = leaf; } /** * Sets the item's text. * * @param text the new text */ public void setText(String text) { this.text = text; if (rendered) { ui.onTextChange(text); } } /** * Sets the item's text style. * * @param style the text style */ public void setTextStyle(String style) { this.textStyle = style; if (rendered) { getUI().onTextStyleChange(textStyle); } } public void setUI(TreeItemUI ui) { this.ui = ui; } /** * Toggles the item's expand state. */ public void toggle() { setExpanded(!isExpanded()); } public String toString() { return "tree: " + (text != null ? text : "" + " ") + el(); } public void updateIconStyle() { String style = calculateIconStyle(); getUI().onIconStyleChange(style); } public void updateJointStyle() { getUI().onJointChange(calculateJoint()); Element checkEl = ui.getCheckElement(); if (tree.getCheckable()) { switch (tree.getCheckNodes()) { case BOTH: fly(checkEl).setVisible(true); break; case PARENT: fly(checkEl).setVisible(!isLeaf()); break; case LEAF: fly(checkEl).setVisible(isLeaf()); break; } } } protected Joint calculateJoint() { if (root) { return Joint.NONE; } Joint joint = Joint.NONE; if (!isLeaf()) { boolean children = false; boolean binder = tree != null ? tree.getData("binder") != null : false; boolean loaded = getData("loaded") != null; if ((!binder) || (binder && !loaded) || (binder && hasChildren())) { children = true; } if (isExpanded()) { joint = children ? Joint.EXPANDED : Joint.NONE; } else { joint = children ? Joint.COLLAPSED : Joint.NONE; } } else { joint = Joint.NONE; } return joint; } protected String calculateIconStyle() { String style = null; if (iconStyle != null) { style = iconStyle; } else { TreeStyle ts = tree.getStyle(); if (!isLeaf()) { if (isExpanded() && ts.getNodeOpenIconStyle() != null) { style = ts.getNodeOpenIconStyle(); } else if (isExpanded() && ts.getNodeOpenIconStyle() != null) { style = ts.getNodeCloseIconStyle(); } else if (!isExpanded()) { style = ts.getNodeCloseIconStyle(); } } else { style = ts.getLeafIconStyle(); } } return style; } protected boolean fireEvent(EventType type, TreeEvent te) { boolean result = super.fireEvent(type, te); if (tree != null && result) { return tree.fireEvent(type, te); } return result; } protected TreeItemUI getTreeItemUI() { return ui; } protected void onRender(Element target, int index) { String s = getUI().getTemplate(getId(), getText(), calculateIconStyle(), 0, getDepth()); setElement(XDOM.create(s), target, index); if (textStyle != null) { ui.onTextStyleChange(textStyle); } if (expandOnRender) { boolean anim = tree.getAnimate(); tree.setAnimate(false); setExpanded(true); tree.setAnimate(anim); } } protected void renderChildren() { int count = getItemCount(); StringBuffer sb = new StringBuffer(); for (int i = 0; i < count; i++) { TreeItem child = getItem(i); Joint joint = child.calculateJoint(); sb.append(child.getUI().getTemplate(child.getId(), child.getText(), child.calculateIconStyle(), joint.value(), getDepth())); } getContainer().setInnerHTML(sb.toString()); NodeList<Element> elems = getContainer().getChildNodes().cast(); for (int i = 0, len = elems.getLength(); i < len; i++) { TreeItem child = getItem(i); child.setElement(elems.getItem(i)); } childrenRendered = true; } protected void setChildrenRendered(boolean rendered) { childrenRendered = rendered; } protected void setRoot(boolean isRoot) { root = isRoot; } protected void setTree(Tree tree) { this.tree = tree; ui = PartFactory.createPart(tree.getTreeItemPartId()); ui.bind(this); } boolean isFirst() { if (isRoot()) return true; return this == parentItem.getItem(0); } boolean isLast() { if (isRoot()) return true; return this == parentItem.getItem(parentItem.getItemCount() - 1); } private void clearCheckChildren(TreeItem parent) { for (int i = 0; i < parent.getItemCount(); i++) { TreeItem sub = parent.getItem(i); sub.setChecked(false); clearCheckChildren(sub); } } private void expandChildren(boolean deep) { for (int i = 0; i < getItemCount(); i++) { TreeItem item = getItem(i); item.setExpanded(true, deep); } } private void getAllChildren(List<TreeItem> list, TreeItem parent) { list.add(parent); for (TreeItem child : parent.getItems()) { list.add(child); getAllChildren(list, child); } } }