Merge branch 'master' of schwann.lupus:/git/java/org.hwo.ui

Conflicts:
	src/org/hwo/models/TableMapper/TableMapper.java
	src/org/hwo/ui/diagram/SimplePlotLabeler.java

.classpath

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
 	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
 	<classpathentry combineaccessrules="false" kind="src" path="/org.hwo"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

.settings/org.eclipse.jdt.core.prefs

@@ -1,12 +1,12 @@
 eclipse.preferences.version=1
 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
 org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.compliance=1.7
 org.eclipse.jdt.core.compiler.debug.lineNumber=generate
 org.eclipse.jdt.core.compiler.debug.localVariable=generate
 org.eclipse.jdt.core.compiler.debug.sourceFile=generate
 org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
 org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.8
+org.eclipse.jdt.core.compiler.source=1.7

src/org/hwo/models/TableMapper/TableMapper.java

@@ -1,6 +1,8 @@
 package org.hwo.models.TableMapper;
 
 import java.awt.Dimension;
+import java.awt.Component;
+import java.awt.EventQueue;
 import java.awt.MouseInfo;
 import java.awt.Point;
 import java.awt.Window;
@@ -27,6 +29,8 @@ import javax.swing.JTable;
 import javax.swing.event.ListSelectionListener;
 import javax.swing.table.AbstractTableModel;
 import javax.swing.table.TableRowSorter;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.TableCellRenderer;
 
 import org.hwo.csv.CSV;
 import org.hwo.csv.CSVRecord;
@@ -38,6 +42,9 @@ import org.hwo.ui.KeyStrokeListener;
 import org.hwo.ui.KeyStrokeParameters;
 import org.w3c.dom.views.AbstractView;
 
+import static org.hwo.logging.Logging.*;
+import static org.hwo.logging.LogLevel.*;
+
 public class TableMapper extends AbstractTableModel
 {
 
@@ -328,6 +335,9 @@ public class TableMapper extends AbstractTableModel
 	
 	private KeyStrokeHelper	keyStrokeHelper;
 	
+	private TableMapperColorSourceInterface
+							colorSourceInterface;
+	
 	public TableMapper(Class<?> clazz,JTable table)
 	{
 		this.tableMapperListeners = new LinkedList<TableMapperListener>();
@@ -361,8 +371,9 @@ public class TableMapper extends AbstractTableModel
 		table.setModel(this);
 		table.setColumnModel(new TableMapperColumnModel(this));
 		
-		table.setAutoCreateRowSorter(false);
 		setSortingEnabled(true);
+		table.setAutoCreateRowSorter(true);
+		table.setDefaultRenderer(Object.class, new TableCellRenderer());
 
 		mouseAdapter = new MouseAdapter() {
 			
@@ -379,6 +390,7 @@ public class TableMapper extends AbstractTableModel
 			}
 		};
 
+		table.addMouseListener(mouseAdapter);
 		
 		if (InteractiveObjectHelper.isInteractiveObject(editorObjectClass))
 			setEditorEnabled(true);
@@ -441,6 +453,13 @@ public class TableMapper extends AbstractTableModel
 		this.sortingEnabled = sortingEnabled;
 		initializeJTable();
 	}
+
+	public TableMapperColorSourceInterface getColorSourceInterface() {
+		return colorSourceInterface;
+	}
+	public void setColorSourceInterface(TableMapperColorSourceInterface colorSourceInterface) {
+		this.colorSourceInterface = colorSourceInterface;
+	}
 	
 	public void addListSelectionListener(ListSelectionListener listener)
 	{
@@ -746,12 +765,26 @@ public class TableMapper extends AbstractTableModel
 	public void addRow(Object row)
 	{
 		addRow(row,null);
+/*
+		this.p_rows.add(row);
+		//fireTableRowsInserted(getRowCount()-1, getRowCount()-1);
+		fireTableDataChanged();
+		
+		if (TableMapperValue.class.isInstance(row)){
+			TableMapperValue tmv = (TableMapperValue)row;
+			tmv.assignTableMapper(this);
+		}
+*/
 	}
 	public void removeRow(Object row)
 	{
 		int index = this.p_rows.indexOf(row);
 		if (index != -1)
 		{
+			if (TableMapperValue.class.isInstance(row)){
+				TableMapperValue tmv = (TableMapperValue)row;
+				tmv.assignTableMapper(this);
+			}
 			this.p_rows.remove(index);
 			fireTableRowsDeleted(index, index);
 		};
@@ -924,6 +957,28 @@ public class TableMapper extends AbstractTableModel
 		this.p_editoronpointer = b;
 	}
 	
+	public void signalRowChanged(Object row){
+		if (p_rows.contains(row)){
+			fireTableRowsUpdated(p_rows.indexOf(row), p_rows.indexOf(row));
+		}
+
+	}
 	
+	class TableCellRenderer extends DefaultTableCellRenderer {
+		
+		@Override
+		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+				int row, int column) {
+			Component c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
+			
+			if (colorSourceInterface != null){
+				c.setForeground( colorSourceInterface.getColor(getRow(row), column, hasFocus, isSelected) );
+				c.setBackground( colorSourceInterface.getBackgroundColor(getRow(row), column, hasFocus, isSelected) );
+			}
+			return c;
+		}
+		
+		
+	}
 	
 };

src/org/hwo/models/TableMapper/TableMapperColorSourceInterface.java

@@ -0,0 +1,10 @@
+package org.hwo.models.TableMapper;
+
+import java.awt.Color;
+
+public interface TableMapperColorSourceInterface {
+
+	public Color getColor(Object row,int column,boolean hasFocus,boolean isSelected);	
+	public Color getBackgroundColor(Object row,int column,boolean hasFocus,boolean isSelected);	
+	
+}

src/org/hwo/models/TableMapper/TableMapperValue.java

@@ -0,0 +1,7 @@
+package org.hwo.models.TableMapper;
+
+public interface TableMapperValue {
+
+	void assignTableMapper(TableMapper tableMapper);
+	void unassignTableMapper(TableMapper tableMapper);
+}

src/org/hwo/ui/InternalFrameFix.java

@@ -0,0 +1,153 @@
+package org.hwo.ui;
+
+	import java.awt.KeyboardFocusManager;
+
+	import java.awt.Window;
+
+	import java.beans.PropertyChangeEvent;
+
+	import java.beans.PropertyChangeListener;
+
+	import javax.swing.JInternalFrame;
+
+	import javax.swing.SwingUtilities;
+
+	/*
+
+ * Copies the fix for bug 6505027 from Java 7
+
+ * http://hg.openjdk.java.net/jdk7/jdk7/jdk/rev/f727cac13697
+
+ * Some support code (private) needed to be copied as well
+
+ */
+
+public class InternalFrameFix extends JInternalFrame {
+
+    public InternalFrameFix() {
+
+        addPropertyChangeListenerIfNecessary();
+
+    }
+
+    private java.awt.Component lastFocusOwner;
+
+    private void setLastFocusOwner(java.awt.Component lastFocusOwner) {
+
+        this.lastFocusOwner = lastFocusOwner;
+
+    }
+
+    private static boolean initializedFocusPropertyChangeListener = false;
+
+    private static void addPropertyChangeListenerIfNecessary() {
+
+        if (!initializedFocusPropertyChangeListener) {
+
+            PropertyChangeListener focusListener =
+
+                    new FocusPropertyChangeListener();
+
+            initializedFocusPropertyChangeListener = true;
+
+            KeyboardFocusManager.getCurrentKeyboardFocusManager().
+
+                    addPropertyChangeListener(focusListener);
+
+        }
+
+    }
+
+    private static class FocusPropertyChangeListener implements
+
+            PropertyChangeListener {
+
+        @Override
+
+        public void propertyChange(PropertyChangeEvent e) {
+
+            if (e.getPropertyName().equals("permanentFocusOwner")) {
+
+                updateLastFocusOwner((java.awt.Component) e.getNewValue());
+
+            }
+
+        }
+
+    }
+
+    private static void updateLastFocusOwner(java.awt.Component component) {
+
+        if (component != null) {
+
+            java.awt.Component parent = component;
+
+            while (parent != null && !(parent instanceof Window)) {
+
+                if (parent instanceof InternalFrameFix) {
+
+                    // Update lastFocusOwner for parent.
+
+                    ((InternalFrameFix) parent).setLastFocusOwner(component);
+
+                }
+
+                parent = parent.getParent();
+
+            }
+
+        }
+
+    }
+
+    @Override
+
+    public void restoreSubcomponentFocus() {
+
+        if (isIcon()) {
+
+            super.restoreSubcomponentFocus(); //delegated to super implementation, because it's correct there
+
+        } else {
+
+            java.awt.Component component = KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner();
+
+            if ((component == null) || !SwingUtilities.isDescendingFrom(component, this)) {
+
+                // FocusPropertyChangeListener will eventually update
+
+                // lastFocusOwner. As focus requests are asynchronous
+
+                // lastFocusOwner may be accessed before it has been correctly
+
+                // updated. To avoid any problems, lastFocusOwner is immediately
+
+                // set, assuming the request will succeed.
+
+                setLastFocusOwner(getMostRecentFocusOwner());
+
+                if (lastFocusOwner == null) {
+
+                    // Make sure focus is restored somewhere, so that
+
+                    // we don't leave a focused component in another frame while
+
+                    // this frame is selected.
+
+                    setLastFocusOwner(getContentPane());
+
+                }
+
+                if (!lastFocusOwner.hasFocus()) {
+
+                    lastFocusOwner.requestFocus();
+
+                }
+
+            }
+
+        }
+
+    }
+
+}

src/org/hwo/ui/JDiagram.java

@@ -15,11 +15,12 @@ import org.hwo.ui.diagram.LinearScaler;
 import org.hwo.ui.diagram.PlotLabeler;
 import org.hwo.ui.diagram.PlotPainter;
 import org.hwo.ui.diagram.PlotProvider2;
+import org.hwo.ui.diagram.PlotProviderListener;
 import org.hwo.ui.diagram.Scaler;
 import org.hwo.ui.diagram.SimplePlotLabeler;
 import org.hwo.ui.diagram.SimplePlotProvider;
 
-public class JDiagram extends JComponent {
+public class JDiagram extends JComponent implements PlotProviderListener {
 	
 	private PlotProvider2
 					plotProvider;
@@ -74,6 +75,7 @@ public class JDiagram extends JComponent {
 	public JDiagram(){
 		setMinimumSize(new Dimension(80, 80));
 		setDoubleBuffered(true);
+		
 
 		defaultLabeler = new SimplePlotLabeler();
 		abszissLabeler = defaultLabeler;
@@ -93,7 +95,13 @@ public class JDiagram extends JComponent {
 	}
 	
 	public void setPlotProvider(PlotProvider2 plotProvider) {
+		if (this.plotProvider != null)
+			this.plotProvider.removePlotProviderListener(this);
+		
 		this.plotProvider = plotProvider;
+		if (this.plotProvider != null)
+			this.plotProvider.addPlotProviderListener(this);
+		
 		fundamentalsChanged();
 	}
 	public PlotProvider2 getPlotProvider() {
@@ -558,4 +566,11 @@ public class JDiagram extends JComponent {
 		}
 		
 	}
+
+
+	@Override
+	public void fundamentalsChanged(PlotProvider2 plotProvider) {
+		fundamentalsChanged();
+		
+	}
 }

src/org/hwo/ui/JInputDialog.java

@@ -5,6 +5,7 @@ import java.awt.FlowLayout;
 
 import javax.swing.JButton;
 import javax.swing.JDialog;
+import javax.swing.JFrame;
 import javax.swing.JPanel;
 import javax.swing.border.EmptyBorder;
 import java.awt.Dialog.ModalExclusionType;
@@ -13,6 +14,8 @@ import java.awt.GridBagLayout;
 import javax.swing.JLabel;
 import java.awt.GridBagConstraints;
 import javax.swing.JTextField;
+import javax.swing.JWindow;
+
 import java.awt.Insets;
 import java.awt.event.ActionListener;
 import java.awt.event.ActionEvent;
@@ -21,8 +24,14 @@ public class JInputDialog extends JDialog {
 
 	
 	public static String show(String title,String message,String preload){
+		return show(null,title,message,preload);
+	}
+	public static String show(JFrame parent,String title,String message,String preload){
 		
 		JInputDialog jid = new JInputDialog();
+		if (parent != null){
+			jid.setLocationRelativeTo(parent);
+		}
 		jid.setTitle(title);
 		jid.lMessage.setText(message);
 		jid.setInputText(preload);

src/org/hwo/ui/JMappedTable.java

@@ -24,6 +24,12 @@ public class JMappedTable extends JTable {
 		this.tableMapper.removeTableMapperListener(tableMapperListener);
 	}
 	
+	public void setEditorEnabled(boolean enabled){
+		tableMapper.setEditorEnabled(enabled);
+	}
+	public boolean isEditorEnabled(){
+		return tableMapper.isEditorEnabled();
+	}
 	
 	
 }

src/org/hwo/ui/diagram/AnnotatedPlotProvider.java

@@ -219,4 +219,20 @@ public class AnnotatedPlotProvider implements PlotProvider2{
 	public Float getPositionMaximum() {
 		return this.values.size()-1.0f;
 	}
+	
+	private LinkedList<PlotProviderListener> plotProviderListeners = new LinkedList<PlotProviderListener>();
+	
+	@Override
+	public void addPlotProviderListener(PlotProviderListener listener) {
+		plotProviderListeners.add(listener);
+	}
+	@Override
+	public void removePlotProviderListener(PlotProviderListener listener) {
+		plotProviderListeners.remove(listener);
+	}
+	
+	private void fireFundamentalsChanged(){
+		for (PlotProviderListener l: plotProviderListeners)
+			l.fundamentalsChanged(this);
+	}
 }

src/org/hwo/ui/diagram/PlotProvider2.java

@@ -18,4 +18,7 @@ public interface PlotProvider2 {
 	
 	public Color[] getColors();
 	
+	public void addPlotProviderListener(PlotProviderListener listener);
+	public void removePlotProviderListener(PlotProviderListener listener);
+	
 }

src/org/hwo/ui/diagram/PlotProviderListener.java

@@ -0,0 +1,7 @@
+package org.hwo.ui.diagram;
+
+public interface PlotProviderListener {
+
+	void fundamentalsChanged(PlotProvider2 plotProvider);
+	
+}

src/org/hwo/ui/diagram/SimplePlotLabeler.java

@@ -43,11 +43,11 @@ public class SimplePlotLabeler implements PlotLabeler {
 					);
 		} else if (digits == 0){
 			return String.format("%1.2f",value);
-		} else {
+		} else if (digits > 0){
 			return String.format(
-					String.format("%%%d.2f",-digits),
+					String.format("%%%d.2f",digits),
 					value
-					);			
+					);
 		}
 	}
 

src/org/hwo/ui/diagram/SimplePlotProvider.java

@@ -3,6 +3,7 @@ package org.hwo.ui.diagram;
 import java.awt.Color;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.LinkedList;
 
 public class SimplePlotProvider implements PlotProvider2 {
 
@@ -104,4 +105,20 @@ public class SimplePlotProvider implements PlotProvider2 {
 		return (float)0;
 	}
 	
+	
+	private LinkedList<PlotProviderListener> plotProviderListeners = new LinkedList<PlotProviderListener>();
+	
+	@Override
+	public void addPlotProviderListener(PlotProviderListener listener) {
+		plotProviderListeners.add(listener);
+	}
+	@Override
+	public void removePlotProviderListener(PlotProviderListener listener) {
+		plotProviderListeners.remove(listener);
+	}
+	
+	private void fireFundamentalsChanged(){
+		for (PlotProviderListener l: plotProviderListeners)
+			l.fundamentalsChanged(this);
+	}
 }

src/org/hwo/ui/jtable/ExtendedTableCellRenderer.java

@@ -0,0 +1,21 @@
+package org.hwo.ui.jtable;
+
+import java.awt.Component;
+
+import javax.swing.JTable;
+import javax.swing.table.DefaultTableCellRenderer;
+
+public class ExtendedTableCellRenderer extends DefaultTableCellRenderer {
+
+
+	@Override
+	public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+			int row, int column) {
+		Component c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
+		
+		
+		return c;
+	}
+	
+	
+}

src/org/hwo/ui/tree/AutomatedTreeModel.java

@@ -0,0 +1,149 @@
+package org.hwo.ui.tree;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.swing.event.TreeModelEvent;
+import javax.swing.event.TreeModelListener;
+import javax.swing.tree.TreeModel;
+import javax.swing.tree.TreePath;
+
+import org.hwo.StringHelper;
+
+public class AutomatedTreeModel implements TreeModel,AutomatedTreeNodeListener {
+
+	List<TreeModelListener>		treeModelListeners;
+	AutomatedTreeNode			root;
+	
+	public AutomatedTreeModel() {
+		treeModelListeners = new LinkedList<>();
+		this.root = new InternalRootNode();
+		this.root.addAutomatedTreeNodeListener(this);
+	}
+
+	public AutomatedTreeModel(AutomatedTreeNode root) {
+		treeModelListeners = new LinkedList<>();
+		this.root = root;
+		this.root.addAutomatedTreeNodeListener(this);
+	}
+
+	@Override
+	public Object getRoot() {
+		return this.root;
+	}
+	public void setRoot(AutomatedTreeNode root) {
+		this.root.removeAutomatedTreeNodeListener(this);
+		this.root = root;
+		this.root.addAutomatedTreeNodeListener(this);
+		fireTreeStructureChanged(new TreeModelEvent(this.root, new Object[]{ this.root }));
+	}
+
+	@Override
+	public void addTreeModelListener(TreeModelListener l) {
+		treeModelListeners.add(l);
+	}
+	@Override
+	public void removeTreeModelListener(TreeModelListener l) {
+		treeModelListeners.remove(l);		
+	}
+	
+	@Override
+	public Object getChild(Object parent, int index) {
+		AutomatedTreeNode node = (AutomatedTreeNode)parent;
+		return node.getChild(index);
+	}
+
+	@Override
+	public int getChildCount(Object parent) {
+		AutomatedTreeNode node = (AutomatedTreeNode)parent;
+		return node.getChildren().length;
+	}
+
+	@Override
+	public int getIndexOfChild(Object parent, Object child) {
+		AutomatedTreeNode node = (AutomatedTreeNode)parent;
+		return node.getIndexOfChild((AutomatedTreeNode)child);
+	}
+
+	@Override
+	public boolean isLeaf(Object parent) {
+		AutomatedTreeNode node = (AutomatedTreeNode)parent;
+		return node.getChildren().length > 0 ? false : true;
+	}
+
+
+
+	@Override
+	public void valueForPathChanged(TreePath path, Object newValue) {
+		System.err.println("valueForPathChanged(...)");
+	}
+	
+	
+	public class InternalRootNode extends AutomatedTreeNode {
+		
+		public InternalRootNode() {
+			super(null);
+		}
+		
+		@Override
+		public int compareTo(AutomatedTreeNode o) {
+			return 0;
+		}
+		
+		@Override
+		public String toString() {
+			return "ROOT NODE";
+		}
+		
+	};
+
+	@Override
+	public void childInserted(AutomatedTreeNode node, AutomatedTreeNode child) {
+		TreeModelEvent tme = new TreeModelEvent(
+											node,
+											node.getPath(),
+											new int[]{ node.getIndexOfChild( child ) },
+											new Object[]{ child }
+											);
+
+		System.err.println(String.format("childInserted: %s [ %d = %s ]",StringHelper.join(Arrays.asList(tme.getPath()), "." ),tme.getChildIndices()[0],tme.getChildren()[0] ));
+		
+		fireTreeNodesInserted(tme);
+	}
+	
+	@Override
+	public void childRemoved(AutomatedTreeNode node, AutomatedTreeNode child, int index) {
+		TreeModelEvent tme = new TreeModelEvent(
+				node,
+				node.getPath(),
+				new int[]{ index },
+				new Object[]{ child }
+				);
+
+		System.err.println(String.format("childRemoved: %s [ %d = %s ]",StringHelper.join(Arrays.asList(tme.getPath()), "." ),tme.getChildIndices()[0],tme.getChildren()[0].toString() ));
+		
+		fireTreeNodesRemoved(tme);
+	}
+	
+	private void fireTreeNodesChanged(TreeModelEvent e){
+		for (TreeModelListener l: this.treeModelListeners)
+			l.treeNodesChanged(e);
+	}
+
+	private void fireTreeNodesInserted(TreeModelEvent e){
+		for (TreeModelListener l: this.treeModelListeners)
+			l.treeNodesInserted(e);
+	}
+
+	private void fireTreeNodesRemoved(TreeModelEvent e){
+		for (TreeModelListener l: this.treeModelListeners)
+			l.treeNodesRemoved(e);
+	}
+
+	private void fireTreeStructureChanged(TreeModelEvent e){
+		for (TreeModelListener l: this.treeModelListeners)
+			l.treeStructureChanged(e);
+	}
+
+}

src/org/hwo/ui/tree/AutomatedTreeNode.java

@@ -0,0 +1,98 @@
+package org.hwo.ui.tree;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.hwo.collections.SortedList;
+
+public abstract class AutomatedTreeNode implements Comparable<AutomatedTreeNode>, AutomatedTreeNodeListener {
+	
+	AutomatedTreeNode				parent;
+	LinkedList<AutomatedTreeNodeListener>
+									automatedTreeNodeListeners;
+	SortedList<AutomatedTreeNode>	children;
+	
+	
+	
+	public AutomatedTreeNode(AutomatedTreeNode parent){
+		this.parent = parent;
+		this.automatedTreeNodeListeners = new LinkedList<AutomatedTreeNodeListener>();
+		this.children = new SortedList<AutomatedTreeNode>();
+	}
+	
+	public void addAutomatedTreeNodeListener(AutomatedTreeNodeListener listener){
+		this.automatedTreeNodeListeners.add(listener);
+	};
+	
+	public void removeAutomatedTreeNodeListener(AutomatedTreeNodeListener listener){
+		this.automatedTreeNodeListeners.remove(listener);		
+	};
+	
+	private void fireChildInserted(AutomatedTreeNode parent,AutomatedTreeNode child){
+		for (AutomatedTreeNodeListener l: automatedTreeNodeListeners){
+			l.childInserted(parent, child);
+		}
+	}
+
+	private void fireChildRemoved(AutomatedTreeNode parent,AutomatedTreeNode child, int index){
+		for (AutomatedTreeNodeListener l: automatedTreeNodeListeners){
+			l.childRemoved(parent, child, index);
+		}		
+	}
+	
+	public AutomatedTreeNode[] getChildren(){
+		return children.toArray(new AutomatedTreeNode[0]);
+	};
+	
+	public boolean	addChild(AutomatedTreeNode child){
+		if (children.add(child)){
+			child.addAutomatedTreeNodeListener(this);
+			fireChildInserted(this,child);
+			return true;
+		}
+		return false;
+	};
+	public boolean	removeChild(AutomatedTreeNode child){
+		int index = children.indexOf(child);
+		if (children.remove(child)){
+			child.removeAutomatedTreeNodeListener(this);
+			fireChildRemoved(this,child,index);
+			return true;
+		}
+		return false;
+	};
+	
+	public AutomatedTreeNode getChild(int index){
+		return children.get(index);
+	};
+	
+	public int getIndexOfChild(AutomatedTreeNode child){
+		return children.indexOf(child);
+	}
+	
+	public AutomatedTreeNode[] getPath(){
+		List<AutomatedTreeNode> path = new LinkedList<AutomatedTreeNode>();
+		getPath( path );
+		return path.toArray(new AutomatedTreeNode[0]);
+	}
+	
+	protected void getPath(List<AutomatedTreeNode> pathlist){
+		if (this.parent != null)
+			this.parent.getPath(pathlist);
+		pathlist.add(this);
+	}
+	
+	public boolean hasChild(AutomatedTreeNode child){
+		return children.contains(child);
+	}
+	
+	@Override
+	public void childInserted(AutomatedTreeNode node, AutomatedTreeNode child) {
+		fireChildInserted(node, child);		
+	}
+	@Override
+	public void childRemoved(AutomatedTreeNode node, AutomatedTreeNode child, int index) {
+		fireChildRemoved(node, child, index);
+	}
+	
+}

src/org/hwo/ui/tree/AutomatedTreeNodeListener.java

@@ -0,0 +1,8 @@
+package org.hwo.ui.tree;
+
+public interface AutomatedTreeNodeListener {
+
+	void childInserted(AutomatedTreeNode node,AutomatedTreeNode child);
+	void childRemoved(AutomatedTreeNode node,AutomatedTreeNode child,int index);
+	
+}

src/org/hwo/ui/tree/BaseSimpleTreeElement.java

@@ -0,0 +1,7 @@
+package org.hwo.ui.tree;
+
+public class BaseSimpleTreeElement {
+
+	
+	
+}

src/org/hwo/ui/tree/PooledAutomatedTreeNode.java

@@ -0,0 +1,45 @@
+package org.hwo.ui.tree;
+
+import javax.swing.plaf.basic.BasicTreeUI.SelectionModelPropertyChangeHandler;
+
+public abstract class PooledAutomatedTreeNode extends AutomatedTreeNode {
+
+	private AutomatedTreeNode[]	pool;
+	
+	public PooledAutomatedTreeNode(AutomatedTreeNode parent) {
+		super(parent);
+		this.pool = new PooledAutomatedTreeNode[0];
+	}
+
+	public PooledAutomatedTreeNode(AutomatedTreeNode parent,AutomatedTreeNode[] pool) {
+		super(parent);
+		this.pool = pool;		
+	}
+	
+	public AutomatedTreeNode[] getPool() {
+		return pool;
+	}
+	public void setPool(AutomatedTreeNode[] pool) {
+		for (AutomatedTreeNode c: getChildren()){
+			removeChild(c);
+		}
+		
+		this.pool = pool;
+	}
+	
+	public boolean show(int index){
+		if (!hasChild(pool[index])){
+			addChild(pool[index]);
+			return true;
+		}
+		return false;
+	}
+	public boolean hide(int index){
+		if (hasChild(pool[index])){
+			removeChild(pool[index]);
+			return true;
+		}
+		return false;		
+	}
+	
+}