diff --git a/.classpath b/.classpath
index ffef93d..5f5ecec 100644
--- a/.classpath
+++ b/.classpath
@@ -1,7 +1,7 @@
-
+
diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs
index a698e59..d17b672 100644
--- a/.settings/org.eclipse.jdt.core.prefs
+++ b/.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
diff --git a/src/org/hwo/models/TableMapper/TableMapper.java b/src/org/hwo/models/TableMapper/TableMapper.java
index b932064..c84423d 100644
--- a/src/org/hwo/models/TableMapper/TableMapper.java
+++ b/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();
@@ -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;
+ }
+
+
+ }
};
diff --git a/src/org/hwo/models/TableMapper/TableMapperColorSourceInterface.java b/src/org/hwo/models/TableMapper/TableMapperColorSourceInterface.java
new file mode 100644
index 0000000..427840e
--- /dev/null
+++ b/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);
+
+}
diff --git a/src/org/hwo/models/TableMapper/TableMapperValue.java b/src/org/hwo/models/TableMapper/TableMapperValue.java
new file mode 100644
index 0000000..dd8a483
--- /dev/null
+++ b/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);
+}
diff --git a/src/org/hwo/ui/InternalFrameFix.java b/src/org/hwo/ui/InternalFrameFix.java
new file mode 100644
index 0000000..4f1a889
--- /dev/null
+++ b/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();
+
+ }
+
+ }
+
+ }
+
+ }
+
+}
diff --git a/src/org/hwo/ui/JDiagram.java b/src/org/hwo/ui/JDiagram.java
index ff5afa8..0d26ce1 100644
--- a/src/org/hwo/ui/JDiagram.java
+++ b/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();
+
+ }
}
diff --git a/src/org/hwo/ui/JInputDialog.java b/src/org/hwo/ui/JInputDialog.java
index 7aaf57c..2fafb5c 100644
--- a/src/org/hwo/ui/JInputDialog.java
+++ b/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);
diff --git a/src/org/hwo/ui/JMappedTable.java b/src/org/hwo/ui/JMappedTable.java
index 8285b6a..f232674 100644
--- a/src/org/hwo/ui/JMappedTable.java
+++ b/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();
+ }
}
diff --git a/src/org/hwo/ui/diagram/AnnotatedPlotProvider.java b/src/org/hwo/ui/diagram/AnnotatedPlotProvider.java
index 19bf4a1..817fb88 100644
--- a/src/org/hwo/ui/diagram/AnnotatedPlotProvider.java
+++ b/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 plotProviderListeners = new LinkedList();
+
+ @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);
+ }
}
diff --git a/src/org/hwo/ui/diagram/PlotProvider2.java b/src/org/hwo/ui/diagram/PlotProvider2.java
index 0da7925..223db9f 100644
--- a/src/org/hwo/ui/diagram/PlotProvider2.java
+++ b/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);
+
}
diff --git a/src/org/hwo/ui/diagram/PlotProviderListener.java b/src/org/hwo/ui/diagram/PlotProviderListener.java
new file mode 100644
index 0000000..2e86306
--- /dev/null
+++ b/src/org/hwo/ui/diagram/PlotProviderListener.java
@@ -0,0 +1,7 @@
+package org.hwo.ui.diagram;
+
+public interface PlotProviderListener {
+
+ void fundamentalsChanged(PlotProvider2 plotProvider);
+
+}
diff --git a/src/org/hwo/ui/diagram/SimplePlotLabeler.java b/src/org/hwo/ui/diagram/SimplePlotLabeler.java
index a2280ab..cb20e93 100644
--- a/src/org/hwo/ui/diagram/SimplePlotLabeler.java
+++ b/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
- );
+ );
}
}
diff --git a/src/org/hwo/ui/diagram/SimplePlotProvider.java b/src/org/hwo/ui/diagram/SimplePlotProvider.java
index e06741d..8fc0803 100644
--- a/src/org/hwo/ui/diagram/SimplePlotProvider.java
+++ b/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 plotProviderListeners = new LinkedList();
+
+ @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);
+ }
}
diff --git a/src/org/hwo/ui/jtable/ExtendedTableCellRenderer.java b/src/org/hwo/ui/jtable/ExtendedTableCellRenderer.java
new file mode 100644
index 0000000..8c9069a
--- /dev/null
+++ b/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;
+ }
+
+
+}
diff --git a/src/org/hwo/ui/tree/AutomatedTreeModel.java b/src/org/hwo/ui/tree/AutomatedTreeModel.java
new file mode 100644
index 0000000..e3dfa83
--- /dev/null
+++ b/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 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);
+ }
+
+}
diff --git a/src/org/hwo/ui/tree/AutomatedTreeNode.java b/src/org/hwo/ui/tree/AutomatedTreeNode.java
new file mode 100644
index 0000000..6e7cf86
--- /dev/null
+++ b/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, AutomatedTreeNodeListener {
+
+ AutomatedTreeNode parent;
+ LinkedList
+ automatedTreeNodeListeners;
+ SortedList children;
+
+
+
+ public AutomatedTreeNode(AutomatedTreeNode parent){
+ this.parent = parent;
+ this.automatedTreeNodeListeners = new LinkedList();
+ this.children = new SortedList();
+ }
+
+ 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 path = new LinkedList();
+ getPath( path );
+ return path.toArray(new AutomatedTreeNode[0]);
+ }
+
+ protected void getPath(List 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);
+ }
+
+}
diff --git a/src/org/hwo/ui/tree/AutomatedTreeNodeListener.java b/src/org/hwo/ui/tree/AutomatedTreeNodeListener.java
new file mode 100644
index 0000000..e2fef94
--- /dev/null
+++ b/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);
+
+}
diff --git a/src/org/hwo/ui/tree/BaseSimpleTreeElement.java b/src/org/hwo/ui/tree/BaseSimpleTreeElement.java
new file mode 100644
index 0000000..57765d4
--- /dev/null
+++ b/src/org/hwo/ui/tree/BaseSimpleTreeElement.java
@@ -0,0 +1,7 @@
+package org.hwo.ui.tree;
+
+public class BaseSimpleTreeElement {
+
+
+
+}
diff --git a/src/org/hwo/ui/tree/PooledAutomatedTreeNode.java b/src/org/hwo/ui/tree/PooledAutomatedTreeNode.java
new file mode 100644
index 0000000..738a2da
--- /dev/null
+++ b/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;
+ }
+
+}