Changeset 100 for java/main/src/main/java/com/framsticks/gui/tree/TreeModel.java

Timestamp:

07/12/13 23:41:06 (11 years ago)

Author:

psniegowski

Message:

HIGHLIGHTS:

• add <include/> to configuration
• add side notes to tree
  • used to store arbitrary information alongside the tree structure
• migrate to log4j2
  • supports lazy string evaluation of passed arguments
• improve GUI tree
  • it stays in synchronization with actual state (even in high load test scenario)
• improve panel management in GUI
• make loading objects in GUI more lazy
• offload parsing to connection receiver thread
  • info parsing
  • first step of objects parsing
• fix connection parsing bug (eof in long values)
• support zero-arguments procedure in table view

CHANGELOG:
Implement procedure calls from table view.

Refactorization around procedures in tables.

Add table editor for buttons.

Render buttons in the the list view.

Further improve Columns.

Add Column class for TableModel?.

Accept also non-arguments ProcedureParams? in tableView.

Increase maximal TextAreaControl? size.

Add tooltip to ProcedureControl?.

Fix bug of interpreting eofs in long values by connection reader.

Further rework connection parsing.

Simplify client connection processing.

Test ListChange? modification.

Test ListChange? events with java server.

Add TestChild?.

Fix bug with fast deregistering when connecting to running server.

Another minor refactorization in TreeOperations?.

Fix bug in SimpleAbstractAccess? loading routine.

Another minor improvement.

Minor change.

Make reading of List objects two-phase.

Another minor change.

Dispatch parsing into receiver thread.

Another step.

Enclose passing value in ObjectParam? case in closure.

Minor step.

Minor change on way to offload parsing.

Temporarily comment out single ValueParam? get.

It will be generalized to multi ValueParam?.

Process info in receiver thread.

Add DispatchingExceptionHandler?.

Make waits in browser test longer.

Use FETCHED_MARK.

It is honored in GUI, where it used to decide whether to get values

after user action.

It is set in standard algorithm for processing fetched values.

Add remove operation to side notes.

Make loading more lazy.

Improve loading policy.

On node choose load itself, on node expansion, load children.

Minor improvement.

Fix bug with panel interleaving.

Minor improvements.

Improve panel management.

More cleaning around panels.

Reorganize panels.

Further improve tree.

Fix bug in TreeModel?.

Remove children from TreeNode?.

Implement TreeNode? hashCode and equals.

Make TreeNode? delegate equals and hashcode to internal reference.

Move listeners from TreeNode? to side notes.

Store path.textual as a side note.

Side note params instead of accesses for objects.

More refactorizations.

In TreeNode? bindAccess based on side notes.

Minor step.

Hide createAccess.

Rename AccessInterface? to Access.

Minor changes.

Several improvements in high load scenarios.

Change semantics of ArrayListAccess?.set(index, null);

It now removes the element, making list shorter
(it was set to null before).

Add path remove handler.

Handle exceptions in Connection.

Update .gitignore

Configure logging to file.

Move registration to TreeModel?.

Further refactorization.

Minor refactorization.

Minor improvements.

Use specialized event also for Modify action of ListChange?.

Use remove events.

Use the insertion events for tree.

Further improve tree refreshing.

Further improve reacting on events in GUI.

Fix problem with not adding objects on addition list change.

Migrate to log4j lazy String construction interface.

Migrate imports to log4j2.

Drop dependency on adapter to version 1.2.

Switch log4j implementation to log4j2.

Add dirty mark to the NodeAtFrame?.

Make selecting in AccessInterfaces? type safe.

Ignore containers size settings in Model and Genotype.

Use tree side notes to remember local changes and panels.

Add sideNotes to tree.

They will be used to store various accompanying information
right in the tree.

Use ReferenceIdentityMap? from apache in TreeNode?.

It suits the need perfectly (weak semantics on both key and value).

Make ArrayListParam? do not react size changes.

Guard in TableModel? before not yet loaded objects.

Add <include/> clause and AutoInjector?.

Extract common columns configuration to separate xml,
that can be included by other configurations.

File:

• java/main/src/main/java/com/framsticks/gui/tree/TreeModel.java (modified) (16 diffs)

java/main/src/main/java/com/framsticks/gui/tree/TreeModel.java

@@ -1 +1 @@
 package com.framsticks.gui.tree;
 
-// import java.util.Enumeration;
+import java.util.Enumeration;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 
+import javax.annotation.Nullable;
 import javax.swing.event.TreeModelEvent;
 import javax.swing.event.TreeModelListener;
 import javax.swing.tree.TreePath;
 
-import org.apache.log4j.Logger;
-
-
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+
+import com.framsticks.core.ListChange;
 import com.framsticks.core.Node;
 import com.framsticks.core.Path;
-import com.framsticks.core.Tree;
 import com.framsticks.core.TreeOperations;
 import com.framsticks.gui.Frame;
-import com.framsticks.params.AccessInterface;
+import com.framsticks.params.Access;
+import com.framsticks.params.CompositeParam;
+import com.framsticks.params.EventListener;
+import com.framsticks.params.ListAccess;
+import com.framsticks.params.PrimitiveParam;
+import com.framsticks.params.Util;
+import com.framsticks.params.ValueParam;
+import com.framsticks.params.types.EventParam;
 import com.framsticks.util.FramsticksException;
+import com.framsticks.util.Misc;
 import com.framsticks.util.UnsupportedOperationException;
 import com.framsticks.util.dispatching.FutureHandler;
 import com.framsticks.util.lang.Casting;
 
+import static com.framsticks.core.TreeOperations.*;
+
 public class TreeModel implements javax.swing.tree.TreeModel {
-        private static final Logger log = Logger.getLogger(TreeModel.class);
+        private static final Logger log = LogManager.getLogger(TreeModel.class);
 
 
         protected List<TreeModelListener> listeners = new LinkedList<>();
+
 
         protected final Frame frame;
@@ -45 +57 @@
 
         @Override
-        public AbstractNode getChild(Object parent, int number) {
-                return Casting.assertCast(AbstractNode.class, parent).getChild(number);
+        public Object getChild(Object parent, int number) {
+                return Casting.throwCast(AbstractNode.class, parent).getChild(number);
         }
 
         @Override
         public int getChildCount(Object parent) {
-                return Casting.assertCast(AbstractNode.class, parent).getChildCount();
+                return Casting.throwCast(AbstractNode.class, parent).getChildCount();
         }
 
@@ -59 +71 @@
                         return -1;
                 }
-                return Casting.assertCast(AbstractNode.class, parent).getIndexOfChild(Casting.assertCast(AbstractNode.class, child));
+                return Casting.throwCast(AbstractNode.class, parent).getIndexOfChild(child);
         }
 
@@ -69 +81 @@
         @Override
         public boolean isLeaf(Object node) {
-                return Casting.assertCast(AbstractNode.class, node).isLeaf();
+                return Casting.throwCast(AbstractNode.class, node).isLeaf();
         }
 
@@ -85 +97 @@
         protected boolean changing = false;
 
-        public void nodeStructureChanged(TreePath treePath) {
+        public void treeNodesInserted(TreeModelEvent event) {
+                assert frame.isActive();
+                try {
+                        for (TreeModelListener listener : listeners) {
+                                listener.treeNodesInserted(event);
+                        }
+                } catch (ArrayIndexOutOfBoundsException e) {
+                }
+        }
+
+        public void treeNodesRemoved(TreeModelEvent event) {
+                assert frame.isActive();
+                try {
+                        for (TreeModelListener listener : listeners) {
+                                listener.treeNodesRemoved(event);
+                        }
+                } catch (ArrayIndexOutOfBoundsException e) {
+                }
+        }
+
+        public void treeNodesChanged(TreeModelEvent event) {
+                try {
+                        for (TreeModelListener listener : listeners) {
+                                listener.treeNodesChanged(event);
+                        }
+                } catch (ArrayIndexOutOfBoundsException e) {
+                }
+        }
+
+        public TreeModelEvent prepareModelEvent(TreePath treePath, int number, TreeNode node) {
+                return new TreeModelEvent(this, treePath, new int[] {number}, new Object[] { node });
+        }
+
+
+        public TreeModelEvent prepareModelEventRegarding(Access access, String id, TreePath treeListPath) {
+
+                int number = Util.getNumberOfCompositeParamChild(access, access.get(id, Object.class));
+                if (number == -1) {
+                        log.debug("encountered minor tree inconsistency in {}", treeListPath);
+                        return null;
+                }
+                TreeNode node = Casting.throwCast(TreeNode.class, Casting.throwCast(TreeNode.class, treeListPath.getLastPathComponent()).getChild(number));
+                return prepareModelEvent(treeListPath, number, node);
+        }
+
+        public void treeStructureChanged(TreePath treePath) {
+
                 if (treePath == null) {
                         return;
@@ -92 +150 @@
 
                 changing = true;
-                log.debug("changing: " + treePath);
-                // Enumeration<TreePath> expanded = frame.jtree.getExpandedDescendants(treePath);
+                log.debug("changing structure: {}", treePath);
+                Enumeration<TreePath> expanded = frame.getJtree().getExpandedDescendants(treePath);
                 TreePath selection = frame.getJtree().getSelectionPath();
 
-                for (TreeModelListener listener : listeners) {
-                        listener.treeStructureChanged(new TreeModelEvent(this, treePath));
-                }
-                // if (expanded != null) {
-                //      while (expanded.hasMoreElements()) {
-                //              TreePath expansion = expanded.nextElement();
-                //              // log.info("reexpanding: " + expansion);
-                //              frame.jtree.expandPath(expansion);
-                //      }
-                // }
+                try {
+                        for (TreeModelListener listener : listeners) {
+                                listener.treeStructureChanged(new TreeModelEvent(this, treePath));
+                        }
+                } catch (ArrayIndexOutOfBoundsException e) {
+                }
+
+
+                if (expanded != null) {
+                        while (expanded.hasMoreElements()) {
+                                TreePath expansion = expanded.nextElement();
+                                // log.info("reexpanding: {}", expansion);
+                                frame.getJtree().expandPath(expansion);
+                        }
+                }
+
                 if (selection != null) {
                         frame.getJtree().setSelectionPath(selection);
@@ -112 +176 @@
         }
 
-        public Path convertToPath(TreePath treePath) {
+        /**
+         *
+         * This method may return null on conversion failure, which may happen in highload situations.
+         */
+        public @Nullable Path convertToPath(TreePath treePath) {
                 final Object[] components = treePath.getPath();
                 assert components[0] == frame.getRootNode();
@@ -128 +196 @@
                         Node node = treeNode.tryCreateNode();
                         if (node == null) {
-                                throw new FramsticksException().msg("failed to recreate path").arg("treePath", treePath);
+                                return null;
+                                // throw new FramsticksException().msg("failed to recreate path").arg("treePath", treePath);
                         }
                         nodes.add(node);
@@ -137 +206 @@
         }
 
-        public TreePath convertToTreePath(Path path) {
+        public TreePath convertToTreePath(Path path, boolean forceComplete) {
                 assert frame.isActive();
 
@@ -143 +212 @@
                 accumulator.add(getRoot());
 
-                for (AbstractNode r : getRoot().getChildren()) {
+                for (Object r : getRoot().getChildren()) {
                         if (r instanceof TreeNode) {
                                 TreeNode root = (TreeNode) r;
                                 if (root.getTree() == path.getTree()) {
+                                        Iterator<Node> n = path.getNodes().iterator();
+                                        TreeNode treeNode = root;
                                         accumulator.add(root);
-
-                                        Iterator<Node> i = path.getNodes().iterator();
-                                        i.next();
-                                        TreeNode treeNode = root;
-
-                                        while (i.hasNext()) {
-                                                Node node = i.next();
-                                                treeNode = treeNode.getTreeNodeForChild(node.getObject());
+                                        n.next();
+                                        while (n.hasNext()) {
+                                                Node node = n.next();
+                                                treeNode = treeNode.prepareTreeNodeForChild(Path.build().tree(path.getTree()).buildUpTo(path.getNodes(), node).finish());
                                                 if (treeNode == null) {
                                                         break;
@@ -161 +228 @@
                                                 accumulator.add(treeNode);
                                         }
-
                                         break;
                                 }
@@ -167 +233 @@
                 }
                 return new TreePath(accumulator.toArray());
+        }
+
+        /**
+         * @return the listeners
+         */
+        public List<TreeModelListener> getListeners() {
+                return listeners;
         }
 
@@ -180 +253 @@
                         return;
                 }
-                AccessInterface access = TreeOperations.bindAccess(path);
+                Access access = TreeOperations.bindAccess(path);
 
                 int count = access.getCompositeParamCount();
@@ -193 +266 @@
                         return;
                 }
-                if (path.isResolved() && !reload) {
+                if (!reload && path.isResolved() && isMarked(path.getTree(), path.getTopObject(), FETCHED_MARK, false)) {
                         return;
                 }
@@ -199 +272 @@
                         @Override
                         protected void result(Path result) {
-                                final TreePath treePath = convertToTreePath(result);
-
-                                nodeStructureChanged(treePath);
-                                frame.updatePanelIfIsLeadSelection(treePath, result);
+                                final TreePath treePath = convertToTreePath(result, true);
+
+
+                                if (treePath != null) {
+                                        treeStructureChanged(treePath);
+                                        frame.updatePanelIfIsLeadSelection(result);
+                                }
                         }
                 });
         }
 
-        public void chooseTreeNode(final TreePath treePath) {
+        public void expandTreeNode(TreePath treePath) {
                 assert frame.isActive();
                 if (treePath == null) {
@@ -215 +291 @@
                         return;
                 }
-
                 Path path = convertToPath(treePath);
                 if (path == null) {
                         return;
                 }
+                loadChildren(path.assureResolved(), false);
+        }
+
+        public void chooseTreeNode(final TreePath treePath) {
+                assert frame.isActive();
+                if (treePath == null) {
+                        return;
+                }
+                if (isChanging()) {
+                        return;
+                }
+
+                Path path = convertToPath(treePath);
+                if (path == null) {
+                        return;
+                }
                 path = path.assureResolved();
-                final Tree tree = path.getTree();
-
-                frame.getTreeAtFrames().get(tree).useOrCreatePanel(treePath);
-                loadChildren(path, false);
-
-        }
+
+                log.debug("choosing {}", path);
+                frame.showPanelForTreePath(treePath);
+                loadPath(path, false);
+
+        }
+
+
+        protected void registerForEventParam(final TreeNode treeNode, Path path, final EventParam eventParam, ValueParam valueParam) {
+                /** TODO make this listener not bind hold the reference to this TreeNode, maybe hold WeakReference internally */
+                if (valueParam instanceof PrimitiveParam) {
+
+                        treeNode.tryAddListener(path, eventParam, Object.class, new EventListener<Object>() {
+                                @Override
+                                public void action(Object argument) {
+                                        loadPath(treeNode.assurePath(), true);
+                                }
+                        });
+
+                } else if (valueParam instanceof CompositeParam) {
+
+                        final CompositeParam compositeParam = (CompositeParam) valueParam;
+
+                        treeNode.tryAddListener(path, eventParam, ListChange.class, new EventListener<ListChange>() {
+                                @Override
+                                public void action(ListChange listChange) {
+                                        assert treeNode.getTree().isActive();
+
+                                        Path parentPath = treeNode.assurePath();
+                                        final Path listPath = parentPath.appendParam(compositeParam).tryFindResolution();
+                                        if (!listPath.isResolved()) {
+                                                /** that situation is quietly ignored - it may happen if first event comes before the container was resolved */
+                                                return;
+                                        }
+
+                                        log.debug("reacting to change {} in {}", listChange, listPath);
+                                        final TreePath treeListPath = convertToTreePath(listPath, true);
+                                        if (treeListPath == null) {
+                                                throw new FramsticksException().msg("path was not fully converted").arg("path", listPath);
+                                        }
+
+                                        if ((listChange.getAction().equals(ListChange.Action.Modify)) && (listChange.getPosition() == -1)) {
+                                                // get(listPath, future);
+                                                // treeModel.nodeStructureChanged(treePath);
+                                                // frame.updatePanelIfIsLeadSelection(treePath, result);
+                                                return;
+                                        }
+                                        final String id = listChange.getBestIdentifier();
+
+                                        final ListAccess access = (ListAccess) bindAccess(listPath);
+                                        switch (listChange.getAction()) {
+                                                case Add: {
+                                                        Path childPath = listPath.appendParam(access.prepareParamFor(id)).tryFindResolution();
+                                                        if (!childPath.isResolved()) {
+                                                                childPath = create(childPath);
+
+                                                                TreeModelEvent event = prepareModelEventRegarding(access, id, treeListPath);
+                                                                if (event != null) {
+                                                                        treeNodesInserted(event);
+                                                                } else {
+                                                                        treeStructureChanged(treeListPath);
+                                                                }
+                                                                frame.updatePanelIfIsLeadSelection(listPath);
+                                                        }
+
+                                                        listPath.getTree().get(childPath, new FutureHandler<Path>(frame) {
+                                                                @Override
+                                                                protected void result(Path result) {
+                                                                        if (!result.isResolved()) {
+                                                                                log.warn("inconsistency after addition list change: {}", result);
+                                                                        }
+                                                                        assert frame.isActive();
+                                                                        final TreePath treePath = Misc.throwIfNull(frame.getTreeModel().convertToTreePath(result, true));
+
+                                                                        // treeModel.nodeStructureChanged(treePath);
+                                                                        frame.updatePanelIfIsLeadSelection(result);
+
+                                                                        log.debug("added {}({}) updated {}", id, result, treePath);
+                                                                }
+                                                        });
+                                                        break;
+                                                }
+                                                case Remove: {
+
+                                                        TreeModelEvent event = prepareModelEventRegarding(access, id, treeListPath);
+                                                        access.set(id, null);
+                                                        if (event != null) {
+                                                                treeNodesRemoved(event);
+                                                        } else {
+                                                                treeStructureChanged(treeListPath);
+                                                        }
+
+                                                        frame.updatePanelIfIsLeadSelection(listPath);
+
+                                                        break;
+                                                }
+                                                case Modify: {
+                                                        Path childPath = listPath.appendParam(access.prepareParamFor(id)).tryResolveIfNeeded();
+                                                        listPath.getTree().get(childPath, new FutureHandler<Path>(frame) {
+                                                                @Override
+                                                                protected void result(Path result) {
+                                                                        assert frame.isActive();
+                                                                        // final TreePath treePath = frame.getTreeModel().convertToTreePath(result, true);
+
+                                                                        TreeModelEvent event = prepareModelEventRegarding(access, id, treeListPath);
+                                                                        if (event != null) {
+                                                                                treeNodesChanged(event);
+                                                                        } else {
+                                                                                treeStructureChanged(treeListPath);
+                                                                        }
+
+                                                                        frame.updatePanelIfIsLeadSelection(listPath);
+                                                                        frame.updatePanelIfIsLeadSelection(result);
+                                                                }
+                                                        });
+                                                        break;
+                                                }
+                                        }
+                                }
+                        });
+                }
+
+        }
+
+
+
+        protected final Object createdTag = new Object();
+
+
+
 }