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; + } + +}