RELEASE_2_1_13/src/blocks/forms/java/org/apache/cocoon/forms/formmodel/tree/Tree.java - cocoon - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.cocoon.forms.formmodel.tree;

 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Set;

 import org.apache.cocoon.environment.Request;
 import org.apache.cocoon.forms.FormContext;
 import org.apache.cocoon.forms.event.WidgetEvent;
 import org.apache.cocoon.forms.event.WidgetEventMulticaster;
 import org.apache.cocoon.forms.formmodel.AbstractWidget;
 import org.apache.cocoon.forms.formmodel.Widget;
 import org.apache.cocoon.forms.formmodel.WidgetDefinition;
 import org.xml.sax.ContentHandler;
 import org.xml.sax.SAXException;

 /**
  * A tree widget, heavily inspired by Swing's <code>JTree</code>.
  *
  * @version $Id$
  */
 public class Tree extends AbstractWidget {

     public static final int SINGLE_SELECTION = 0;
     public static final int MULTIPLE_SELECTION = 1;

     public interface ActionHandler {
         public void act(Tree tree, FormContext context);
     }

     private TreeDefinition treeDef;

     private TreeModel treeModel;

     private Set expandedPaths = new HashSet();

     private Set selectedPaths = new HashSet();

     private Set changedPaths = new HashSet();

     private HashMap pathWidgets = new HashMap();

     private boolean rootVisible = true;

     private boolean expandSelectedPath = false;

     private TreeSelectionListener selectionListener;

     private int selectionModel = MULTIPLE_SELECTION;

     private TreeModelListener modelListener = new TreeModelListener() {
         public void treeStructureChanged(TreeModelEvent event) {
             markForRefresh(event.getPath());
         }
     };

     protected Tree(TreeDefinition definition) {
         super(definition);
         this.treeDef = definition;
         this.rootVisible = definition.isRootVisible();
         if (!this.rootVisible) {
             // Expand it so that first-level children are visible
             this.expandedPaths.add(TreePath.ROOT_PATH);
         }
         this.treeModel = definition.createModel();
         this.treeModel.addTreeModelListener(modelListener);
         this.selectionListener = definition.getSelectionListener();
         this.selectionModel = definition.getSelectionModel();
     }

     public WidgetDefinition getDefinition() {
         return this.treeDef;
     }

     protected String getXMLElementName() {
         return "tree";
     }

     protected void generateItemSaxFragment(ContentHandler contentHandler, Locale locale) throws SAXException {
         throw new UnsupportedOperationException(this + " cannot be rendered using <ft:widget>. Please use <ft:tree>.");
     }

     public void readFromRequest(FormContext formContext) {
         //TODO: crawl open nodes, calling their widget's readFromRequest

         Request req = formContext.getRequest();
         String paramName = getRequestParameterName();

         //---------------------------------------------------------------------
         // Handle node selection using checkboxes named <id>$select
         //---------------------------------------------------------------------
         String[] selectValues = req.getParameterValues(paramName + ":select");
         if (selectValues != null) {
             // Create the set of paths given by the request
             Set newSelection = new HashSet();
             for (int i = 0; i < selectValues.length; i++) {
                 newSelection.add(TreePath.valueOf(selectValues[i]));
             }

             // Check if all visible selections are in the new selection
             TreePath[] currentSelection = (TreePath[])this.selectedPaths.toArray(new TreePath[this.selectedPaths.size()]);
             for (int i = 0; i < currentSelection.length; i++) {
                 TreePath p = currentSelection[i];
                 if (!newSelection.contains(p) && isVisible(p)) {
                     removeSelectionPath(p);
                 }
             }

             // Now add the currently selected items (may be selected already)
             Iterator iter = newSelection.iterator();
             while(iter.hasNext()) {
                 addSelectionPath((TreePath)iter.next());
             }
         }

         //---------------------------------------------------------------------
         // Handle tree actions:
         // - action is in <name>$action
         // - path is in <name>$path
         //---------------------------------------------------------------------
         String action = req.getParameter(paramName + ":action");

         if (action == null || action.length() == 0) {
             // Nothing more to do here
             return;
         }

         getForm().setSubmitWidget(this);
         String pathValue = req.getParameter(paramName + ":path");

         if (pathValue == null || pathValue.length() == 0) {
             //this.treeDef.getLogger().warn("No tree path given");
             return;
         }

         // Parse the path
         TreePath path = TreePath.valueOf(pathValue);

         if ("expand".equals(action)) {
             this.expandPath(path);
         } else if ("collapse".equals(action)) {
             this.collapsePath(path);
         } else if ("toggle-collapse".equals(action)) {
             if (this.isExpanded(path)) {
                 this.collapsePath(path);
             } else {
                 this.expandPath(path);
             }
         } else if ("select".equals(action)) {
             this.addSelectionPath(path);
         } else if ("unselect".equals(action)) {
             this.removeSelectionPath(path);
         } else if ("toggle-select".equals(action)) {
             if (this.isPathSelected(path)) {
                 this.removeSelectionPath(path);
             } else {
                 this.addSelectionPath(path);
             }
         } else {
             // Unknown action
             //this.treeDef.getLogger().warn("Unknown action " + action);
         }
     }

     public TreeModel getModel() {
         return this.treeModel;
     }

     public void setModel(TreeModel model) {
         if (model == null) {
             model = DefaultTreeModel.UNSPECIFIED_MODEL;
         }
         this.treeModel.removeTreeModelListener(this.modelListener);
         this.treeModel = model;
         model.addTreeModelListener(this.modelListener);
     }

     private void markForRefresh(TreePath path) {
         this.changedPaths.add(path);
         getForm().addWidgetUpdate(this);
     }

     private void markForRefresh(List paths) {
         this.changedPaths.addAll(paths);
         getForm().addWidgetUpdate(this);
     }

     //---------------------------------------------------------------------------------------------
     // Selection
     //---------------------------------------------------------------------------------------------

     public void setSelectionModel(int model) {
         if (model < 0 || model > MULTIPLE_SELECTION) {
             throw new IllegalArgumentException("Illegal selection model " + model);
         }

         if (model == this.selectionModel) {
             return;
         }

         this.selectionModel = model;
         if (model == SINGLE_SELECTION && getSelectionCount() > 1) {
             clearSelection();
         }
     }

     public int getSelectionCount() {
         return this.selectedPaths.size();
     }

     public TreePath getSelectionPath() {
         if (this.selectedPaths.isEmpty()) {
             return null;
         } else {
             return (TreePath)this.selectedPaths.iterator().next();
         }
     }

     public TreePath[] getSelectionPaths() {
         return (TreePath[])this.selectedPaths.toArray(new TreePath[this.selectedPaths.size()]);
     }

     public boolean isPathSelected(TreePath path) {
         return this.selectedPaths.contains(path);
     }

     public boolean isSelectionEmpty() {
         return this.selectedPaths.isEmpty();
     }

     public void setSelectionPath(TreePath path) {
         clearSelection();
         addSelectionPath(path);
     }

     public void setSelectionPaths(TreePath paths[]) {
         clearSelection();
         addSelectionPaths(paths);
     }

     public void addSelectionPath(TreePath path) {
         if (this.selectionModel == SINGLE_SELECTION) {
             clearSelection();
         }

         if (this.selectedPaths.add(path)) {
             markForRefresh(path);
             if (this.expandSelectedPath) {
                 expandPath(path);
             }
             this.getForm().addWidgetEvent(new TreeSelectionEvent(this, path, true));
         }
     }

     public void addSelectionPaths(TreePath paths[]) {
         if (this.selectionModel == SINGLE_SELECTION) {
             setSelectionPath(paths[0]);
         } else {
             List pathsList = Arrays.asList(paths);
             if (this.selectedPaths.addAll(pathsList)) {
                 markForRefresh(pathsList);
                 if (this.expandSelectedPath) {
                     this.expandedPaths.addAll(pathsList);
                 }
                 this.getForm().addWidgetEvent(new TreeSelectionEvent(this, paths, true));
             }
         }
     }

     public void removeSelectionPath(TreePath path) {
         if (this.selectedPaths.remove(path)) {
             // Need to redisplay the parent
             markForRefresh(path.getParentPath());
             this.getForm().addWidgetEvent(new TreeSelectionEvent(this, path, false));
         }
     }

     public void removeSelectionPaths(TreePath paths[]) {
         List pathsList = Arrays.asList(paths);
         if (this.selectedPaths.removeAll(pathsList)) {
             markForRefresh(pathsList);
             this.getForm().addWidgetEvent(new TreeSelectionEvent(this, paths, false));
         }
     }

     public void clearSelection() {
         if (this.isSelectionEmpty()) {
             return;
         }

         TreePath[] paths = (TreePath[])this.selectedPaths.toArray(new TreePath[this.selectedPaths.size()]);
         for (int i = 0; i < paths.length; i++) {
             // Need to redisplay the parent
             markForRefresh(paths[i].getParentPath());
         }
         this.selectedPaths.clear();
         this.getForm().addWidgetEvent(new TreeSelectionEvent(this, paths, false));
     }

     public void addTreeSelectionListener(TreeSelectionListener listener) {
         this.selectionListener = WidgetEventMulticaster.add(this.selectionListener, listener);
     }

     public void removeTreeSelectionListener(TreeSelectionListener listener) {
         this.selectionListener = WidgetEventMulticaster.remove(this.selectionListener, listener);
     }

     //---------------------------------------------------------------------------------------------
     // Visibility, expand & collapse
     //---------------------------------------------------------------------------------------------

     public boolean isCollapsed(TreePath path) {
         return !isExpanded(path);
     }

     public boolean isExpanded(TreePath path) {
         if (this.expandedPaths.contains(path)) {
             // Ensure all parents are expanded
             TreePath parent = path.getParentPath();
             return parent == null ? true : isExpanded(parent);
         } else {
             return false;
         }
     }

     /**
      * Returns true if the value identified by path is currently viewable,
      * which means it is either the root or all of its parents are expanded.
      * Otherwise, this method returns false.
      *
      * @return true if the node is viewable, otherwise false
      */
     public boolean isVisible(TreePath path) {
         if (path == TreePath.ROOT_PATH) {
             return true;
         }
         if (path != null) {
             TreePath parent = path.getParentPath();
             if (parent != null) {
                 return isExpanded(parent);
             } else {
                 // root node
                 return true;
             }
         } else {
             return false;
         }
     }

     public void makeVisible(TreePath path) {
         if (path != null) {
             TreePath parent = path.getParentPath();
             if (parent != null) {
                 expandPath(parent);
                 // Make visible also all parent paths
                 makeVisible(parent);
             }
         }
     }

     public boolean isRootVisible() {
         return this.rootVisible;
     }

     public void setRootVisible(boolean visible) {
         if (this.rootVisible != visible) {
             this.markForRefresh(TreePath.ROOT_PATH);
             this.rootVisible = visible;
             if (!visible) {
                 // Expand it so that first-level children are visible
                 this.expandPath(TreePath.ROOT_PATH);
             }
         }
     }

     public void collapsePath(TreePath path) {
         if (path != null) {
             if (this.expandedPaths.remove(path)) {
                 markForRefresh(path);
             }
         }
     }

     public void expandPath(TreePath path) {
         if (path != null) {
             if (this.expandedPaths.add(path)) {
                 markForRefresh(path);
             }
         }
     }

     public void collapseAll() {
     	this.expandedPaths.clear();
         if (!this.rootVisible) {
             this.expandedPaths.add(TreePath.ROOT_PATH);
         }
     }

     public void expandAll() {
     	collapseAll();
         this.expandedPaths.add(TreePath.ROOT_PATH);
     	TreeWalker tw = new TreeWalker(this);
     	tw.enterChildren();
     	while (tw.hasNext()) {
     		tw.next();
     		if (!tw.isLeaf()) {
     			expandPath(tw.getPath());
     			tw.enterChildren();
     		}
     		if (!tw.hasNext()) {
     			tw.leave();
     		}
     	}
     }


     public void setExpandsSelectedPath(boolean value) {
         this.expandSelectedPath  = value;
     }

     //---------------------------------------------------------------------------------------------
     // Widget management
     //---------------------------------------------------------------------------------------------

     public Widget getWidgetForPath(TreePath path) {
         Widget result = (Widget)this.pathWidgets.get(path);
         if (result == null && !this.pathWidgets.containsKey(path)) {
             result = createWidgetForPath(path);
             if (result != null) {
                 result.setAttribute("TreePath", path);
             }
             this.pathWidgets.put(path, result);
         }

         return result;
     }

     private Widget createWidgetForPath(TreePath path) {
         //TODO
         return null;
     }

     public void broadcastEvent(WidgetEvent event) {
        if (event instanceof TreeSelectionEvent) {
            if (this.selectionListener != null) {
                this.selectionListener.selectionChanged((TreeSelectionEvent)event);
            }
        } else {
            super.broadcastEvent(event);
        }
    }
     //---------------------------------------------------------------------------------------------
     // TreeNode widget, which is the actual parent of widgets contained in a node
     //---------------------------------------------------------------------------------------------
     // TODO
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package org.apache.cocoon.forms.formmodel.tree;

	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Locale;
	import java.util.Set;

	import org.apache.cocoon.environment.Request;
	import org.apache.cocoon.forms.FormContext;
	import org.apache.cocoon.forms.event.WidgetEvent;
	import org.apache.cocoon.forms.event.WidgetEventMulticaster;
	import org.apache.cocoon.forms.formmodel.AbstractWidget;
	import org.apache.cocoon.forms.formmodel.Widget;
	import org.apache.cocoon.forms.formmodel.WidgetDefinition;
	import org.xml.sax.ContentHandler;
	import org.xml.sax.SAXException;

	/**
	* A tree widget, heavily inspired by Swing's <code>JTree</code>.
	*
	* @version $Id$
	*/
	public class Tree extends AbstractWidget {

	public static final int SINGLE_SELECTION = 0;
	public static final int MULTIPLE_SELECTION = 1;

	public interface ActionHandler {
	public void act(Tree tree, FormContext context);
	}

	private TreeDefinition treeDef;

	private TreeModel treeModel;

	private Set expandedPaths = new HashSet();

	private Set selectedPaths = new HashSet();

	private Set changedPaths = new HashSet();

	private HashMap pathWidgets = new HashMap();

	private boolean rootVisible = true;

	private boolean expandSelectedPath = false;

	private TreeSelectionListener selectionListener;

	private int selectionModel = MULTIPLE_SELECTION;

	private TreeModelListener modelListener = new TreeModelListener() {
	public void treeStructureChanged(TreeModelEvent event) {
	markForRefresh(event.getPath());
	}
	};

	protected Tree(TreeDefinition definition) {
	super(definition);
	this.treeDef = definition;
	this.rootVisible = definition.isRootVisible();
	if (!this.rootVisible) {
	// Expand it so that first-level children are visible
	this.expandedPaths.add(TreePath.ROOT_PATH);
	}
	this.treeModel = definition.createModel();
	this.treeModel.addTreeModelListener(modelListener);
	this.selectionListener = definition.getSelectionListener();
	this.selectionModel = definition.getSelectionModel();
	}

	public WidgetDefinition getDefinition() {
	return this.treeDef;
	}

	protected String getXMLElementName() {
	return "tree";
	}

	protected void generateItemSaxFragment(ContentHandler contentHandler, Locale locale) throws SAXException {
	throw new UnsupportedOperationException(this + " cannot be rendered using <ft:widget>. Please use <ft:tree>.");
	}

	public void readFromRequest(FormContext formContext) {
	//TODO: crawl open nodes, calling their widget's readFromRequest

	Request req = formContext.getRequest();
	String paramName = getRequestParameterName();

	//---------------------------------------------------------------------
	// Handle node selection using checkboxes named <id>$select
	//---------------------------------------------------------------------
	String[] selectValues = req.getParameterValues(paramName + ":select");
	if (selectValues != null) {
	// Create the set of paths given by the request
	Set newSelection = new HashSet();
	for (int i = 0; i < selectValues.length; i++) {
	newSelection.add(TreePath.valueOf(selectValues[i]));
	}

	// Check if all visible selections are in the new selection
	TreePath[] currentSelection = (TreePath[])this.selectedPaths.toArray(new TreePath[this.selectedPaths.size()]);
	for (int i = 0; i < currentSelection.length; i++) {
	TreePath p = currentSelection[i];
	if (!newSelection.contains(p) && isVisible(p)) {
	removeSelectionPath(p);
	}
	}

	// Now add the currently selected items (may be selected already)
	Iterator iter = newSelection.iterator();
	while(iter.hasNext()) {
	addSelectionPath((TreePath)iter.next());
	}
	}

	//---------------------------------------------------------------------
	// Handle tree actions:
	// - action is in <name>$action
	// - path is in <name>$path
	//---------------------------------------------------------------------
	String action = req.getParameter(paramName + ":action");

	if (action == null \|\| action.length() == 0) {
	// Nothing more to do here
	return;
	}

	getForm().setSubmitWidget(this);
	String pathValue = req.getParameter(paramName + ":path");

	if (pathValue == null \|\| pathValue.length() == 0) {
	//this.treeDef.getLogger().warn("No tree path given");
	return;
	}

	// Parse the path
	TreePath path = TreePath.valueOf(pathValue);

	if ("expand".equals(action)) {
	this.expandPath(path);
	} else if ("collapse".equals(action)) {
	this.collapsePath(path);
	} else if ("toggle-collapse".equals(action)) {
	if (this.isExpanded(path)) {
	this.collapsePath(path);
	} else {
	this.expandPath(path);
	}
	} else if ("select".equals(action)) {
	this.addSelectionPath(path);
	} else if ("unselect".equals(action)) {
	this.removeSelectionPath(path);
	} else if ("toggle-select".equals(action)) {
	if (this.isPathSelected(path)) {
	this.removeSelectionPath(path);
	} else {
	this.addSelectionPath(path);
	}
	} else {
	// Unknown action
	//this.treeDef.getLogger().warn("Unknown action " + action);
	}
	}

	public TreeModel getModel() {
	return this.treeModel;
	}

	public void setModel(TreeModel model) {
	if (model == null) {
	model = DefaultTreeModel.UNSPECIFIED_MODEL;
	}
	this.treeModel.removeTreeModelListener(this.modelListener);
	this.treeModel = model;
	model.addTreeModelListener(this.modelListener);
	}

	private void markForRefresh(TreePath path) {
	this.changedPaths.add(path);
	getForm().addWidgetUpdate(this);
	}

	private void markForRefresh(List paths) {
	this.changedPaths.addAll(paths);
	getForm().addWidgetUpdate(this);
	}

	//---------------------------------------------------------------------------------------------
	// Selection
	//---------------------------------------------------------------------------------------------

	public void setSelectionModel(int model) {
	if (model < 0 \|\| model > MULTIPLE_SELECTION) {
	throw new IllegalArgumentException("Illegal selection model " + model);
	}

	if (model == this.selectionModel) {
	return;
	}

	this.selectionModel = model;
	if (model == SINGLE_SELECTION && getSelectionCount() > 1) {
	clearSelection();
	}
	}

	public int getSelectionCount() {
	return this.selectedPaths.size();
	}

	public TreePath getSelectionPath() {
	if (this.selectedPaths.isEmpty()) {
	return null;
	} else {
	return (TreePath)this.selectedPaths.iterator().next();
	}
	}

	public TreePath[] getSelectionPaths() {
	return (TreePath[])this.selectedPaths.toArray(new TreePath[this.selectedPaths.size()]);
	}

	public boolean isPathSelected(TreePath path) {
	return this.selectedPaths.contains(path);
	}

	public boolean isSelectionEmpty() {
	return this.selectedPaths.isEmpty();
	}

	public void setSelectionPath(TreePath path) {
	clearSelection();
	addSelectionPath(path);
	}

	public void setSelectionPaths(TreePath paths[]) {
	clearSelection();
	addSelectionPaths(paths);
	}

	public void addSelectionPath(TreePath path) {
	if (this.selectionModel == SINGLE_SELECTION) {
	clearSelection();
	}

	if (this.selectedPaths.add(path)) {
	markForRefresh(path);
	if (this.expandSelectedPath) {
	expandPath(path);
	}
	this.getForm().addWidgetEvent(new TreeSelectionEvent(this, path, true));
	}
	}

	public void addSelectionPaths(TreePath paths[]) {
	if (this.selectionModel == SINGLE_SELECTION) {
	setSelectionPath(paths[0]);
	} else {
	List pathsList = Arrays.asList(paths);
	if (this.selectedPaths.addAll(pathsList)) {
	markForRefresh(pathsList);
	if (this.expandSelectedPath) {
	this.expandedPaths.addAll(pathsList);
	}
	this.getForm().addWidgetEvent(new TreeSelectionEvent(this, paths, true));
	}
	}
	}

	public void removeSelectionPath(TreePath path) {
	if (this.selectedPaths.remove(path)) {
	// Need to redisplay the parent
	markForRefresh(path.getParentPath());
	this.getForm().addWidgetEvent(new TreeSelectionEvent(this, path, false));
	}
	}

	public void removeSelectionPaths(TreePath paths[]) {
	List pathsList = Arrays.asList(paths);
	if (this.selectedPaths.removeAll(pathsList)) {
	markForRefresh(pathsList);
	this.getForm().addWidgetEvent(new TreeSelectionEvent(this, paths, false));
	}
	}

	public void clearSelection() {
	if (this.isSelectionEmpty()) {
	return;
	}

	TreePath[] paths = (TreePath[])this.selectedPaths.toArray(new TreePath[this.selectedPaths.size()]);
	for (int i = 0; i < paths.length; i++) {
	// Need to redisplay the parent
	markForRefresh(paths[i].getParentPath());
	}
	this.selectedPaths.clear();
	this.getForm().addWidgetEvent(new TreeSelectionEvent(this, paths, false));
	}

	public void addTreeSelectionListener(TreeSelectionListener listener) {
	this.selectionListener = WidgetEventMulticaster.add(this.selectionListener, listener);
	}

	public void removeTreeSelectionListener(TreeSelectionListener listener) {
	this.selectionListener = WidgetEventMulticaster.remove(this.selectionListener, listener);
	}

	//---------------------------------------------------------------------------------------------
	// Visibility, expand & collapse
	//---------------------------------------------------------------------------------------------

	public boolean isCollapsed(TreePath path) {
	return !isExpanded(path);
	}

	public boolean isExpanded(TreePath path) {
	if (this.expandedPaths.contains(path)) {
	// Ensure all parents are expanded
	TreePath parent = path.getParentPath();
	return parent == null ? true : isExpanded(parent);
	} else {
	return false;
	}
	}

	/**
	* Returns true if the value identified by path is currently viewable,
	* which means it is either the root or all of its parents are expanded.
	* Otherwise, this method returns false.
	*
	* @return true if the node is viewable, otherwise false
	*/
	public boolean isVisible(TreePath path) {
	if (path == TreePath.ROOT_PATH) {
	return true;
	}
	if (path != null) {
	TreePath parent = path.getParentPath();
	if (parent != null) {
	return isExpanded(parent);
	} else {
	// root node
	return true;
	}
	} else {
	return false;
	}
	}

	public void makeVisible(TreePath path) {
	if (path != null) {
	TreePath parent = path.getParentPath();
	if (parent != null) {
	expandPath(parent);
	// Make visible also all parent paths
	makeVisible(parent);
	}
	}
	}

	public boolean isRootVisible() {
	return this.rootVisible;
	}

	public void setRootVisible(boolean visible) {
	if (this.rootVisible != visible) {
	this.markForRefresh(TreePath.ROOT_PATH);
	this.rootVisible = visible;
	if (!visible) {
	// Expand it so that first-level children are visible
	this.expandPath(TreePath.ROOT_PATH);
	}
	}
	}

	public void collapsePath(TreePath path) {
	if (path != null) {
	if (this.expandedPaths.remove(path)) {
	markForRefresh(path);
	}
	}
	}

	public void expandPath(TreePath path) {
	if (path != null) {
	if (this.expandedPaths.add(path)) {
	markForRefresh(path);
	}
	}
	}

	public void collapseAll() {
	this.expandedPaths.clear();
	if (!this.rootVisible) {
	this.expandedPaths.add(TreePath.ROOT_PATH);
	}
	}

	public void expandAll() {
	collapseAll();
	this.expandedPaths.add(TreePath.ROOT_PATH);
	TreeWalker tw = new TreeWalker(this);
	tw.enterChildren();
	while (tw.hasNext()) {
	tw.next();
	if (!tw.isLeaf()) {
	expandPath(tw.getPath());
	tw.enterChildren();
	}
	if (!tw.hasNext()) {
	tw.leave();
	}
	}
	}


	public void setExpandsSelectedPath(boolean value) {
	this.expandSelectedPath = value;
	}

	//---------------------------------------------------------------------------------------------
	// Widget management
	//---------------------------------------------------------------------------------------------

	public Widget getWidgetForPath(TreePath path) {
	Widget result = (Widget)this.pathWidgets.get(path);
	if (result == null && !this.pathWidgets.containsKey(path)) {
	result = createWidgetForPath(path);
	if (result != null) {
	result.setAttribute("TreePath", path);
	}
	this.pathWidgets.put(path, result);
	}

	return result;
	}

	private Widget createWidgetForPath(TreePath path) {
	//TODO
	return null;
	}

	public void broadcastEvent(WidgetEvent event) {
	if (event instanceof TreeSelectionEvent) {
	if (this.selectionListener != null) {
	this.selectionListener.selectionChanged((TreeSelectionEvent)event);
	}
	} else {
	super.broadcastEvent(event);
	}
	}
	//---------------------------------------------------------------------------------------------
	// TreeNode widget, which is the actual parent of widgets contained in a node
	//---------------------------------------------------------------------------------------------
	// TODO
	}