Changeset 98 for java/main/src/main/java/com/framsticks/gui/TreeAtFrame.java

Timestamp:

07/08/13 23:04:56 (11 years ago)

Author:

psniegowski

Message:

HIGHLIGHTS:

• use custom TreeModel?
  • TreeNodes? are now very thin wrappers around actual data
  • use WeakReferences? extensively to make TreeNodes? only shadow the real structure and not sustain it
• remove global Tree listeners
• use IdentityHashMap? were appropriate
• add CompositeParam? interface to AccessInterface?
  • this interface takes into account only CompositeParams? (i.e. ValueParams? that are not PrimitiveParams?)
• make UniqueLists? sort in order of uids
• RemoteTrees? referred to from GUI use SwingDispatcher?
• rework resolving of paths
• add explicit reloading (Ctrl-R)

CHANGELOG:
Get data also on tree expansion.

Use nice framstick icon for empty nodes.

Update panel after reload if it is current.

Add shallow reload procedure.

Cut Gui prefix from several tree classes.

Bring back counter of GuiTreeNode?.

Use IdentityHashMap? were it is more appriopriate.

Remove TreeListener?.

Do not use TreeListener? in GUI.

Minor change.

Done migration to GuiTreeModel?.

BrowserTest? in that version always crashes frams.linux.

Move rendering implementation into GuiAbstractNode?.

Use hand-crafted list in GuiTreeNode?.

Generally, it would be a great place for WeakIdentityHashMap?
(but there is none in Java Collection Framework).

Remove superfluous logging.

Fix bug in GuiTreeNode?.

Use IdentityHashMap? instead of HashMap?.

Improve structure update.

Filter out invalid uids in UniqueListAccess?.

Improve TreeCellRenderer?.

Add filtering in TrackConsole?.

Improve TreeModel?.

More changes.

More improvements.

More changes.

Remove TreeNode?.

Support MetaNode? in the GuiTreeModel?.

Implement more in GuiTreeModel?.

Add CompositeParam? interface to FramsClass? and AccessInterface?.

Allow access by number to UniqueList?.

Add UidComparator?.

Use TreeMap? as a default accessee in unique list.

It keeps order of keys.

Introduce classes to use with new TreeModel?.

Another step.

Migrate from TreeNode? to Node in many places.

Remove some uses of TreeNode? as DefaultMutableTreeNode?.

Remove Path from TreeNode? interface.

Remove Path from TreeNode?.

Add Path recration from node feature.

Reworking TreeCellRenderer?.

Minor change of TreeOperations? interface.

Remove last methods from TreeNode?.

Another minor step.

Do not store reference to TreeAtFrame? in TreeNode?.

Add proxy exceptionHandler to StatusBar?.

Move panels management to TreeAtFrame?.

Store localChanges in the NodeAtFrame?.

More cleanup.

Move name computing to TreeCellRenderer?.

Move tooltip and icon computations to TreeCellRenderer?.

More dispatches removed.

Remove most dispatching from TreeNode?.

TreeNode? does not actually redispatch tasks.

Make Tree embedded in Browser use SwingDispatcher?.

Make lazy binding of Tree with Dispatcher.

Minor changes.

Organizational change in AbstractTree?.

Make AbstractTree? compose from Thread instead of inherit from it.

Make SwingDispatcher? and AtOnceDispatcher? Joinable compatible.

Add ListPanelProvider?.

Improve Controls readonly and enabled handling.

Properly pass ExceptionHandlers? in more places.

Make Tree.get accept ValueParam?.

• This is to allow access number of list elements.

Remove not needed get redirection in ClientAtServer?.

Rename tryResolve to tryGet.

Unify tryResolveAndGet into tryResolve.

Remove resolveTop from Tree interface.

Make Tree.get accept Future<Path>.

Use get to implement resolveTop also in ObjectTree?.

Unify resolveTop and get in RemoteTree?.

Another minor step.

More minor changes in tree operations.

Minor organizational changes.

In RemoteTree? first fetch info for root.

Reworking resolving.

Minor changes.

Make ListAccess? return proxy iterators (instead of creating temporary collection).

Let AccessInterface? return Iterable<Param>.

Improve resolving.

More improvements.

First working completion in ManagedConsole?.

Rename resolve to resolveTop.

This reflects the actuall functionality.

Change semantic of tryResolve and tryResolveAndGet.

File:

• java/main/src/main/java/com/framsticks/gui/TreeAtFrame.java (modified) (4 diffs)

java/main/src/main/java/com/framsticks/gui/TreeAtFrame.java

@@ -4 +4 @@
 
 import com.framsticks.core.Tree;
-import com.framsticks.core.TreeListener;
-import com.framsticks.core.ListChange;
 import com.framsticks.core.Node;
 import com.framsticks.core.Path;
+import com.framsticks.core.TreeOperations;
+import com.framsticks.gui.controls.ValueControl;
 import com.framsticks.params.CompositeParam;
 import com.framsticks.params.FramsClass;
@@ -14 +14 @@
 
 import javax.swing.tree.TreePath;
-import com.framsticks.util.dispatching.RunAt;
+
+
+import com.framsticks.util.dispatching.FutureHandler;
+import com.framsticks.util.lang.Casting;
 
 /**
  * @author Piotr Sniegowski
  */
-public class TreeAtFrame implements TreeListener {
+public class TreeAtFrame {
 
         private static final Logger log = Logger.getLogger(TreeAtFrame.class);
@@ -26 +29 @@
         protected final Tree tree;
         protected final Map<String, Panel> knownPanels = new HashMap<String, Panel>();
-        protected TreeNode rootTreeNode;
+        protected Node rootNode;
+
+        protected Map<TreeNode, NodeAtFrame> nodesStorage = new WeakHashMap<>();
 
         public TreeAtFrame(Tree tree, Frame frame) {
@@ -90 +95 @@
         }
 
-        @Override
-        public void onListChange(Path path, ListChange change) {
+        public boolean hasLocalChanges(TreePath treePath) {
+                NodeAtFrame nodeAtFrame = nodesStorage.get(treePath.getLastPathComponent());
+                if (nodeAtFrame == null) {
+                        return false;
+                }
+                return !nodeAtFrame.localChanges.isEmpty();
+        }
+
+        public NodeAtFrame assureLocalInfo(TreePath treePath) {
+                assert frame.isActive();
+                NodeAtFrame nodeAtFrame = nodesStorage.get(treePath.getLastPathComponent());
+
+                if (nodeAtFrame == null) {
+                        nodeAtFrame = new NodeAtFrame();
+                        nodesStorage.put(Casting.throwCast(TreeNode.class, treePath.getLastPathComponent()), nodeAtFrame);
+                }
+                return nodeAtFrame;
+        }
+
+        public NodeAtFrame getLocalInfo(TreePath treePath) {
+                return nodesStorage.get(treePath.getLastPathComponent());
+        }
+
+        public boolean changeValue(TreePath treePath, ValueControl component, Object newValue) {
+                log.debug("changing value of " + component + " to '" + newValue + "'");
+
+                assureLocalInfo(treePath).localChanges.put(component, newValue);
+
+                return true;
+        }
+
+        public void pushLocalChanges(TreePath treePath) {
+                assert frame.isActive();
+
+                NodeAtFrame nodeAtFrame = nodesStorage.get(treePath.getLastPathComponent());
+                if (nodeAtFrame == null) {
+                        return;
+                }
+                Path path = frame.treeModel.convertToPath(treePath);
+
+                for (Map.Entry<ValueControl, Object> e : nodeAtFrame.localChanges.entrySet()) {
+                        TreeOperations.set(path, e.getKey().getParam(), e.getValue(), new FutureHandler<Integer>(frame) {
+                                @Override
+                                protected void result(Integer flag) {
+                                }
+                        });
+                }
+        }
+
+        public void fillPanelWithValues(TreePath treePath) {
+                NodeAtFrame nodeAtFrame = assureLocalInfo(treePath);
+                if (nodeAtFrame == null) {
+                        return;
+                }
+
+                if (nodeAtFrame.panel == null) {
+                        return;
+                }
+                Node node = TreeNode.tryGetNode(treePath);
+                if (node == null) {
+                        return;
+                }
+                nodeAtFrame.panel.setCurrentTreePath(treePath);
+                nodeAtFrame.panel.pullValuesFromLocalToUser(TreeOperations.bindAccess(node));
+
+                frame.showPanel(nodeAtFrame.panel);
 
         }
 
-        public TreePath getTreePath(Path path, boolean create) {
-                assert frame.isActive();
-                TreeNode t = rootTreeNode;
-                TreePath result = new TreePath(frame.rootNode).pathByAddingChild(rootTreeNode);
-                List<Node> nodes = path.getNodes();
-                Iterator<Node> i = nodes.iterator();
-                i.next();
-                // Node first = i.next();
+        public void useOrCreatePanel(TreePath treePath) {
+                // node.assureResolved();
+                Node node = TreeNode.tryGetNode(treePath);
 
-                // if (!t.path.isResolved()) {
-                //      t.path = new Path(path.getInstance(), nodes, first);
-                // }
-                while (i.hasNext()) {
-                        Node n = i.next();
-                        TreeNode r = null;
-                        for (TreeNode c : t.childrenIterable()) {
-                                if (c.param.getId().equals(n.getParam().getId())) {
-                                        r = c;
-                                        break;
-                                }
+                NodeAtFrame nodeAtFrame = assureLocalInfo(treePath);
+
+                if (nodeAtFrame.panel == null) {
+                        CompositeParam param = node.getParam();
+                        nodeAtFrame.panel = findPanel(param.computeAccessId());
+                        if (nodeAtFrame.panel == null) {
+                                FramsClass framsClass = node.getTree().getInfoFromCache(param.getContainedTypeName());
+                                nodeAtFrame.panel = preparePanel(param, framsClass);
                         }
-                        if (r == null) {
-                                log.debug("missing " + n.getParam().getId() + " in " + t);
-                                if (!create) {
-                                        return result;
-                                }
-                                Path p = Path.build().tree(path.getTree()).buildUpTo(nodes, n).finish();
-
-
-                                log.debug("forced resolution: creating treenode for " + p);
-                                TreeNode childNode = new TreeNode(TreeAtFrame.this, p);
-
-                                frame.addNode(childNode, t);
-                                // frame.treeModel.reload();
-                                // t.add(childNode);
-                                // frame.treeModel.nodeStructureChanged(t);
-
-                                r = childNode;
-                        } else {
-                                // if (!r.path.isResolved()) {
-                                //      r.path = new Path(path.getInstance(), nodes, n);
-                                // }
-                        }
-                        result = result.pathByAddingChild(r);
-                        t = r;
                 }
-                return result;
-        }
-
-        @Override
-        public void onFetch(final Path path) {
-                assert tree.isActive();
-                log.trace("fetched " + path);
-
-                frame.dispatch(new RunAt<Frame>(frame) {
-                        @Override
-                        protected void runAt() {
-
-                                TreePath treePath = getTreePath(path, true);
-                                assert treePath.getPathCount() == path.size() + 1;
-
-                                final TreeNode result = (TreeNode) treePath.getLastPathComponent();
-                                // log.trace("found " + result + " == " + path);
-                                tree.dispatch(new RunAt<Tree>(frame) {
-                                        @Override
-                                        protected void runAt() {
-                                                result.reactForFetchResult(path, null);
-                                        }
-                                });
-                        }
-                });
-        }
-
-        @Override
-        public void onRun(Exception e) {
-
-        }
-
-        @Override
-        public void onStop(Exception e) {
-
+                fillPanelWithValues(treePath);
         }
 }