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

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.

Location:

java/main/src/main/java/com/framsticks/gui

Files:

• AbstractNode.java (added)
• Browser.java (modified) (5 diffs)
• EmptyNode.java (added)
• Frame.java (modified) (17 diffs)
• ImageProvider.java (modified) (2 diffs)
• ListPanelProvider.java (added)
• MetaNode.java (added)
• ModifiablePanel.java (modified) (2 diffs)
• MultiPanel.java (modified) (2 diffs)
• NodeAtFrame.java (added)
• ObjectPanel.java (modified) (5 diffs)
• Panel.java (modified) (5 diffs)
• StatusBar.java (modified) (3 diffs)
• SwingDispatcher.java (modified) (3 diffs)
• TreeAtFrame.java (modified) (4 diffs)
• TreeModel.java (added)
• TreeNode.java (modified) (1 diff)
• console/InteractiveConsole.java (modified) (1 diff)
• console/ManagedConsole.java (modified) (7 diffs)
• console/TrackConsole.java (modified) (3 diffs)
• controls/CheckBoxControl.java (modified) (2 diffs)
• controls/Control.java (modified) (2 diffs)
• controls/ControlOwner.java (modified) (2 diffs)
• controls/EnumControl.java (modified) (2 diffs)
• controls/EventControl.java (modified) (1 diff)
• controls/ProcedureControl.java (modified) (6 diffs)
• controls/SliderControl.java (modified) (4 diffs)
• controls/TextAreaControl.java (modified) (2 diffs)
• controls/TextFieldControl.java (modified) (2 diffs)
• controls/ValueControl.java (modified) (1 diff)
• view/NodeAction.java (deleted)
• view/TreeCellRenderer.java (modified) (3 diffs)

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

@@ -14 +14 @@
 import com.framsticks.util.dispatching.ExceptionResultHandler;
 import com.framsticks.util.dispatching.Future;
-import com.framsticks.util.dispatching.FutureHandler;
 import com.framsticks.util.dispatching.Joinable;
 import com.framsticks.util.dispatching.JoinableCollection;
@@ -46 +45 @@
 
         protected final List<PopupMenuEntryProvider> popupMenuEntryProviders = new LinkedList<>();
+        // protected final SwingDispatcher
 
         protected final MainFrame mainFrame;
@@ -63 +63 @@
 
                 mainFrame = new MainFrame(Browser.this);
+
+                // mainFrame.getStatusBar().setExceptionHandler(ThrowExceptionHandler.getInstance());
+
                 addFrame(mainFrame);
 
@@ -120 +123 @@
         public void addTree(Tree tree) {
                 log.info("adding tree: " + tree);
+                tree.setDispatcher(new SwingDispatcher<Tree>());
                 trees.add(tree);
         }
 
         public void autoResolvePath(final String path, final Future<Path> future) {
-                final Tree i = trees.get("localhost");
-                i.dispatch(new RunAt<Tree>(future) {
-                        @Override
-                        protected void runAt() {
-                                TreeOperations.resolveAndGet(i, path, new FutureHandler<Path>(future) {
-                                        @Override
-                                        protected void result(final Path p) {
-                                                future.pass(p);
-                                                mainFrame.dispatch(new RunAt<Frame>(future) {
-                                                        @Override
-                                                        protected void runAt() {
-                                                                mainFrame.goTo(p);
-                                                        }
-                                                });
-                                        }
-                                });
-                        }
-                });
+                // final Tree i = trees.get("localhost");
+                // i.dispatch(new RunAt<Tree>(future) {
+                //      @Override
+                //      protected void runAt() {
+                //              TreeOperations.tryGet(i, path, new FutureHandler<Path>(future) {
+                //                      @Override
+                //                      protected void result(final Path p) {
+                //                              future.pass(p);
+                //                              mainFrame.dispatch(new RunAt<Frame>(future) {
+                //                                      @Override
+                //                                      protected void runAt() {
+                //                                              mainFrame.goTo(p);
+                //                                      }
+                //                              });
+                //                      }
+                //              });
+                //      }
+                // });
         }
 
@@ -284 +288 @@
         }
 
-        // @Override
-        // public boolean isDone() {
-        //      return frames.isDone() && trees.isDone();
+        // final protected Map<EventParam, Subscription<?>> userSubscriptions = new HashMap<>();
+        // public boolean hasSubscribed(EventParam param) {
+        //      assert frame.isActive();
+        //      return userSubscriptions.containsKey(param);
         // }
+
+        // public void unsubscribe(EventParam eventParam) {
+        //      assert frame.isActive();
+        //      if (!hasSubscribed(eventParam)) {
+        //              log.error("could not unsubscribe from " + eventParam);
+        //              return;
+        //      }
+        //      userSubscriptions.get(eventParam).unsubscribe(new LoggingStateCallback(log, "unsubscribed " + eventParam));
+        //      userSubscriptions.remove(eventParam);
+        // }
+
+
+
+
 }

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

@@ -11 +11 @@
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
-import java.util.HashMap;
+import java.util.IdentityHashMap;
 import java.util.Map;
 
@@ -28 +28 @@
 import javax.swing.ToolTipManager;
 import javax.swing.UIManager;
-import javax.swing.event.TreeModelEvent;
-import javax.swing.event.TreeModelListener;
+import javax.swing.event.TreeExpansionEvent;
+import javax.swing.event.TreeExpansionListener;
 import javax.swing.event.TreeSelectionEvent;
 import javax.swing.event.TreeSelectionListener;
-import javax.swing.tree.DefaultMutableTreeNode;
-import javax.swing.tree.DefaultTreeModel;
 import javax.swing.tree.DefaultTreeSelectionModel;
 import javax.swing.tree.TreePath;
@@ -40 +38 @@
 import org.apache.log4j.Logger;
 
+import com.framsticks.core.Mode;
 import com.framsticks.core.Path;
 import com.framsticks.core.Tree;
+import com.framsticks.core.TreeOperations;
 import com.framsticks.gui.view.TreeCellRenderer;
-import com.framsticks.util.FramsticksException;
+import com.framsticks.params.AccessInterface;
 import com.framsticks.util.dispatching.Dispatching;
-import com.framsticks.util.dispatching.ExceptionResultHandler;
+import com.framsticks.util.dispatching.FutureHandler;
 import com.framsticks.util.dispatching.Joinable;
 import com.framsticks.util.dispatching.JoinableCollection;
 import com.framsticks.util.dispatching.JoinableParent;
 import com.framsticks.util.dispatching.JoinableState;
-import com.framsticks.util.dispatching.RunAt;
-import com.framsticks.util.lang.ScopeEnd;
 import com.framsticks.util.swing.KeyboardModifier;
 import com.framsticks.util.swing.MenuConstructor;
@@ -72 +70 @@
         protected JScrollPane treeScrollPane;
         protected JTree jtree;
-        protected DefaultTreeModel treeModel;
-        protected javax.swing.tree.MutableTreeNode rootNode;
+        protected TreeModel treeModel;
+
+        protected MetaNode rootNode;
+
         protected JPanel treePanel;
         protected JPopupMenu treePopupMenu;
         protected JMenuItem treePopupMenuHeader;
 
-        TreeNode currentlyPoppedTreeNode;
         protected JPanel mainPanel;
         protected JPanel leftPanel;
@@ -91 +90 @@
         protected JMenu helpMenu;
 
-        protected final Map<Tree, TreeAtFrame> treeAtFrames = new HashMap<Tree, TreeAtFrame>();
-        protected JoinableCollection<Tree> trees = new JoinableCollection<Tree>();
+        protected final Map<Tree, TreeAtFrame> treeAtFrames = new IdentityHashMap<>();
+        protected JoinableCollection<Tree> trees = new JoinableCollection<>();
 
         public Frame(Browser browser) {
@@ -106 +105 @@
                 log.debug("creating " + this);
 
-
                 Container contentPane = getSwing().getContentPane();
                 treePopupMenu = new JPopupMenu("title");
@@ -114 +112 @@
                 treePanel.setLayout(new BorderLayout());
 
-                treeModel = new DefaultTreeModel(null);
-                treeModel.addTreeModelListener(new TreeModelListener() {
-
-                        @Override
-                        public void treeNodesChanged(TreeModelEvent arg0) {
-                                log.trace("treeNodesChanged: " + arg0);
-                        }
-
-                        @Override
-                        public void treeNodesInserted(TreeModelEvent arg0) {
-                                // log.trace("treeNodesInserted: " + arg0);
-                        }
-
-                        @Override
-                        public void treeNodesRemoved(TreeModelEvent arg0) {
-                                log.trace("treeNodesRemoved: " + arg0);
-                        }
-
-                        @Override
-                        public void treeStructureChanged(TreeModelEvent arg0) {
-                                log.trace("treeStructureChanged: " + arg0);
-                        }
-                });
+                rootNode = new MetaNode();
+                rootNode.setName("root");
+                treeModel = new TreeModel(this);
 
                 jtree = new JTree(treeModel);
@@ -152 +130 @@
                 });
 
+                jtree.addTreeExpansionListener(new TreeExpansionListener() {
+
+                        @Override
+                        public void treeCollapsed(TreeExpansionEvent e) {
+
+                        }
+
+                        @Override
+                        public void treeExpanded(TreeExpansionEvent e) {
+                                loadChildren(treeModel.convertToPath(e.getPath()), false);
+                        }
+                });
+
                 jtree.setExpandsSelectedPaths(true);
                 jtree.setEditable(false);
-                jtree.setDoubleBuffered(true);
                 jtree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
                 jtree.setShowsRootHandles(true);
@@ -173 +163 @@
                 });
 
-                new KeyboardModifier(jtree, JComponent.WHEN_FOCUSED).join(KeyStroke.getKeyStroke('h'), KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0)).join(KeyStroke.getKeyStroke('j'), KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0)).join(KeyStroke.getKeyStroke('k'), KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0)).join(KeyStroke.getKeyStroke('l'), KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0));
+                new KeyboardModifier(jtree, JComponent.WHEN_FOCUSED)
+                        .join(KeyStroke.getKeyStroke('h'), KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0))
+                        .join(KeyStroke.getKeyStroke('j'), KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0))
+                        .join(KeyStroke.getKeyStroke('k'), KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0))
+                        .join(KeyStroke.getKeyStroke('l'), KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0));
 
                 jtree.setCellRenderer(new TreeCellRenderer());
@@ -182 +176 @@
                 treePanel.add(treeScrollPane);
 
-                rootNode = new DefaultMutableTreeNode();
-                rootNode.setUserObject("root");
-                treeModel.setRoot(rootNode);
 
                 normalWorkPanel = new JPanel();
@@ -248 +239 @@
                 });
 
+                new MenuConstructor(fileMenu).add(KeyStroke.getKeyStroke(KeyEvent.VK_R, ActionEvent.CTRL_MASK), new AbstractAction("Reload current") {
+                        @Override
+                        public void actionPerformed(ActionEvent actionEvent) {
+
+                                loadPath(treeModel.convertToPath(jtree.getSelectionPath()), true);
+                        }
+                });
+
         }
 
@@ -254 +253 @@
         }
 
-        public void addRootPath(Path path) {
+        public void addRootPath(final Path path) {
                 assert isActive();
+
                 Tree tree = path.getTree();
+
+                log.info("trying mount: " + path);
+                if (!tree.getAssignedRoot().isResolved()) {
+                        tree.get(path, Mode.FETCH, new FutureHandler<Path>(this) {
+
+                                @Override
+                                protected void result(Path result) {
+                                        addRootPath(result);
+                                }
+                        });
+                        return;
+                }
+
                 assert browser.getTrees().contains(tree);
 
                 TreeAtFrame e = new TreeAtFrame(tree, this);
-                tree.addListener(e);
                 treeAtFrames.put(tree, e);
-                TreeNode node = new TreeNode(e, path);
-                e.rootTreeNode = node;
-                treeModel.insertNodeInto(node, rootNode, rootNode.getChildCount());
-                jtree.expandPath(new TreePath(rootNode));
+
+                rootNode.getChildren().add(new TreeNode(tree.getAssignedRoot()));
+                e.rootNode = tree.getAssignedRoot();
+                treeModel.nodeStructureChanged(new TreePath(rootNode));
+                // jtree.expandPath(new TreePath(rootNode));
         }
 
@@ -275 +288 @@
         }
 
+
         private void showPopup(MouseEvent e) {
                 assert isActive();
@@ -280 +294 @@
                         return;
                 }
-                currentlyPoppedTreeNode = findTreeNodeByTreePath(jtree.getPathForLocation(e.getX(), e.getY()));
-                if (currentlyPoppedTreeNode == null) {
-                        return;
-                }
-
-                Path path = currentlyPoppedTreeNode.getTreePath();
+                TreePath treePath = jtree.getPathForLocation(e.getX(), e.getY());
+
+                Path path = treeModel.convertToPath(treePath);
                 treePopupMenu.removeAll();
 
@@ -291 +302 @@
                         provider.provide(treePopupMenu, path);
                 }
-                // treePopupMenuHeader.setText(path.getTree().getName() + path.getTextual());
                 treePopupMenu.show(e.getComponent(), e.getX(), e.getY());
-                //currentlyPoppedPanel.getNode().getFramsClass().getName()
-        }
-
-        public TreeNode getCurrentlyPoppedTreeNode() {
-                assert isActive();
-                return currentlyPoppedTreeNode;
         }
 
         public void clear() {
-                treeModel.setRoot(null);
                 cardPanel.removeAll();
                 cardPanel.updateUI();
@@ -308 +311 @@
         }
 
-        public ScopeEnd startChange(final DefaultMutableTreeNode node) {
-                assert isActive();
-                final TreePath selection = jtree.getSelectionPath();
-                return new ScopeEnd() {
-                        @Override
-                        public void close() {
-                                assert isActive();
-                                treeModel.nodeChanged(node);
-                                jtree.setSelectionPath(selection);
-                        }
-                };
-        }
-
-        public void selectTreeNode(final TreeNode treeNode) {
-                assert isActive();
-                /*              final Panel panel = treeNode.getOrCreatePanel();
-                 if (panel == null) {
-                 return;
-                 }
-                 panel.setCurrentTreeNode(treeNode);
-                 treeNode.updateData();
-                 showPanel(panel);*/
-        }
-
-        public TreeNode findTreeNodeByTreePath(TreePath treePath) {
+        public void loadChildren(Path path, boolean reload) {
+                if (path == null) {
+                        return;
+                }
+                AccessInterface access = TreeOperations.bindAccess(path);
+
+                int count = access.getCompositeParamCount();
+                for (int i = 0; i < count; ++i) {
+                        Path childPath = path.appendParam(access.getCompositeParam(i)).tryFindResolution();
+                        loadPath(childPath, reload);
+                }
+
+        }
+
+        public void loadPath(Path path, boolean reload) {
+                if (path == null) {
+                        return;
+                }
+                if (path.isResolved() && !reload) {
+                        return;
+                }
+                path.getTree().get(path, Mode.FETCH, new FutureHandler<Path>(this) {
+                        @Override
+                        protected void result(Path result) {
+                                final TreePath treePath = treeModel.convertToTreePath(result);
+
+                                treeModel.nodeStructureChanged(treePath);
+                                if (treePath.equals(jtree.getSelectionPath())) {
+                                        treeAtFrames.get(result.getTree()).useOrCreatePanel(treePath);
+                                }
+                        }
+                });
+        }
+
+        public void chooseTreeNode(final TreePath treePath) {
                 assert isActive();
                 if (treePath == null) {
-                        return null;
-                }
-                if (!(treePath.getLastPathComponent() instanceof TreeNode)) {
-                        return null;
-                }
-                return (TreeNode) treePath.getLastPathComponent();
-        }
-
-        public void chooseTreeNode(TreePath treePath) {
-                assert isActive();
-                final TreeNode treeNode = findTreeNodeByTreePath(treePath);
-                if (treeNode == null) {
-                        return;
-                }
-                treeNode.select();
-        }
-
-        protected final ExceptionResultHandler dialogHandler = new ExceptionResultHandler() {
-
-                @Override
-                public void handle(FramsticksException exception) {
-                        //TODO TEH
-                        throw exception;
-
-                }
-        };
-
-        public void goTo(Path path) {
-                assert isActive();
-                final TreePath treePath = treeAtFrames.get(path.getTree()).getTreePath(path, false);
-                log.info("go to path: " + path + "(" + treePath + ")");
-
-                this.dispatch(new RunAt<Frame>(dialogHandler) {
-                        @Override
-                        protected void runAt() {
-                                log.info("executed");
-                                jtree.setSelectionPath(treePath);
-                                jtree.makeVisible(treePath);
-                                assert jtree.isVisible(treePath);
-                        }
-                });
-
-        }
-
-        public void addNode(TreeNode child, DefaultMutableTreeNode parent) {
-                assert isActive();
-
-                try (ScopeEnd e = startChange(parent)) {
-                        treeModel.insertNodeInto(child, parent, parent.getChildCount());
-                }
-        }
+                        return;
+                }
+                if (treeModel.isChanging()) {
+                        return;
+                }
+
+                Path path = treeModel.convertToPath(treePath);
+                if (path == null) {
+                        return;
+                }
+                path = path.assureResolved();
+                final Tree tree = path.getTree();
+
+                treeAtFrames.get(tree).useOrCreatePanel(treePath);
+                loadChildren(path, false);
+
+        }
+
+
+        // public void goTo(Path path) {
+        //      assert isActive();
+        //      final TreePath treePath = treeModel.convertToTreePath(path);
+        //      log.info("go to path: " + path + "(" + treePath + ")");
+
+        //      this.dispatch(new RunAt<Frame>(this) {
+        //              @Override
+        //              protected void runAt() {
+        //                      log.info("executed");
+        //                      jtree.setSelectionPath(treePath);
+        //                      jtree.makeVisible(treePath);
+        //                      assert jtree.isVisible(treePath);
+        //              }
+        //      });
+
+        // }
 
         @Override
@@ -422 +419 @@
         }
 
+        /**
+         * @return the treeModel
+         */
+        public TreeModel getTreeModel() {
+                return treeModel;
+        }
+
 }

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

@@ -7 +7 @@
 
 import javax.swing.*;
+
 import java.util.HashMap;
-import java.util.LinkedHashMap;
+import java.util.Map;
 
 /**
@@ -21 +22 @@
          * HashMap stores icons. Key is icon path, Value is icon.
          */
-        private static HashMap<String, ImageIcon> icons = new LinkedHashMap<String, ImageIcon>();
+        private static Map<String, ImageIcon> icons = new HashMap<String, ImageIcon>();
 
         public static final String IMAGE = "image.png";
         public static final String LOGO = "logo.png";
 
-        //public static final String FOLDER_OPEN = "folder_open.png";
-        //public static final String FOLDER_CLOSED = "folder_close.png";
-        //public static final String NODE = "node.png";
+        public static final String FOLDER_OPEN = "folder_open.png";
+        public static final String FOLDER_CLOSED = "folder_close.png";
+        public static final String NODE = "node.png";
 
         public static final String SERVER = "server.png";

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

@@ -2 +2 @@
 
 import org.apache.log4j.Logger;
+
 
 import javax.swing.*;
@@ -65 +66 @@
         }
 
-        @Override
-        public void setCurrentTreeNode(TreeNode node) {
-                super.setCurrentTreeNode(node);
-        }
-
         protected abstract void applyChanges();
 

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

@@ -4 +4 @@
 
 import javax.swing.*;
+import javax.swing.tree.TreePath;
+
 import java.awt.*;
 import java.util.List;
@@ -46 +48 @@
 
         @Override
-        public void setCurrentTreeNode(TreeNode currentTreeNode) {
-                super.setCurrentTreeNode(currentTreeNode);
+        public void setCurrentTreePath(TreePath currentTreePath) {
+                super.setCurrentTreePath(currentTreePath);
                 for (Panel p : panels) {
-                        p.setCurrentTreeNode(currentTreeNode);
+                        p.setCurrentTreePath(currentTreePath);
                 }
         }

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

@@ -12 +12 @@
 
 import javax.swing.*;
+import javax.swing.tree.TreePath;
 
 import java.util.Collection;
-import java.util.HashMap;
+import java.util.IdentityHashMap;
 import java.util.Map;
 import static com.framsticks.util.lang.Containers.filterInstanceof;
 
 import com.framsticks.util.FramsticksException;
-import com.framsticks.util.dispatching.RunAt;
 
 @SuppressWarnings("serial")
 public class ObjectPanel extends ModifiablePanel implements ControlOwner {
 
-        private static final Logger log = Logger.getLogger(ObjectPanel.class.getName());
+        private static final Logger log = Logger.getLogger(ObjectPanel.class);
 
-        final protected Map<Param, Control> components = new HashMap<Param, Control>();
-        final protected Map<ValueParam, ValueControl> valueControls = new HashMap<ValueParam, ValueControl>();
+        final protected Map<Param, Control> components = new IdentityHashMap<Param, Control>();
+        final protected Map<ValueParam, ValueControl> valueControls = new IdentityHashMap<ValueParam, ValueControl>();
 
         public ObjectPanel(Panel.Parameters parameters, Collection<Param> params) {
@@ -37 +37 @@
                 for (final ValueControl c : filterInstanceof(components.values(), ValueControl.class)) {
                         valueControls.put(c.getParam(), c);
+                        c.setUserEnabled(true);
                         c.setListener(new ValueControlListener() {
                                 @Override
                                 public boolean onChange(Object newValue) {
-                                        if (currentTreeNode == null) {
+                                        if (currentTreePath == null) {
                                                 return true;
                                         }
-                                        boolean result = currentTreeNode.changeValue(c, newValue);
+                                        boolean result = treeAtFrame.changeValue(currentTreePath, c, newValue);
                                         refreshControlButtons();
                                         return result;
@@ -57 +58 @@
         protected void applyChanges() {
                 assert frame.isActive();
-                assert currentTreeNode != null;
-                currentTreeNode.pushLocalChanges();
+                assert currentTreePath != null;
+                treeAtFrame.pushLocalChanges(currentTreePath);
         }
 
         protected void refreshControlButtons() {
                 assert frame.isActive();
-                applyButton.setEnabled(currentTreeNode.localChanges != null);
+                applyButton.setEnabled(treeAtFrame.hasLocalChanges(currentTreePath));
         }
 
@@ -71 +72 @@
         @Override
         public void pullValuesFromLocalToUser(AccessInterface access) {
-                assert currentTreeNode != null;
-                assert currentTreeNode.path.getTree().isActive();
+                assert currentTreePath != null;
                 log.debug("refreshing components");
 
-                final Map<ValueControl, Object> values = new HashMap<ValueControl, Object>();
+                final Map<ValueControl, Object> values = new IdentityHashMap<ValueControl, Object>();
                 for (Map.Entry<ValueParam, ValueControl> e : valueControls.entrySet()) {
                         values.put(e.getValue(), access.get(e.getKey().getId(), Object.class));
                 }
 
-                frame.dispatch(new RunAt<Frame>(frame) {
-                        @Override
-                        protected void runAt() {
-                                if (currentTreeNode.localChanges != null) {
-                                        for (Map.Entry<ValueControl, Object> e : currentTreeNode.localChanges.entrySet()) {
-                                                values.put(e.getKey(), e.getValue());
-                                        }
-                                }
-                                for (Map.Entry<ValueControl, Object> e : values.entrySet()) {
-                                        e.getKey().pushValueToUserInterface(e.getValue());
-                                }
-                                refreshControlButtons();
-                                ObjectPanel.this.revalidate();
+
+                NodeAtFrame nodeAtFrame = treeAtFrame.getLocalInfo(currentTreePath);
+                if (nodeAtFrame != null) {
+                        for (Map.Entry<ValueControl, Object> e : nodeAtFrame.localChanges.entrySet()) {
+                                values.put(e.getKey(), e.getValue());
                         }
-                });
+                }
+
+                for (Map.Entry<ValueControl, Object> e : values.entrySet()) {
+                        e.getKey().pushValueToUserInterface(e.getValue());
+                }
+                refreshControlButtons();
+                ObjectPanel.this.revalidate();
 
         }
@@ -109 +107 @@
 
         @Override
-        public TreeNode getCurrentTreeNode() {
-                return super.getCurrentTreeNode();
-        }
-
-        @Override
         public void handle(FramsticksException exception) {
                 frame.handle(exception);
         }
 
-        // public void updateValue() {
-        //      //assert panel.getFrame().isActive();
+        @Override
+        public TreePath getCurrentTreePath() {
+                return super.getCurrentTreePath();
+        }
 
-        //      final Node n = panel.getCurrentNode();
-        //      panel.getBrowser().getManager().invokeLater(new Runnable() {
-        //              @Override
-        //              public void run() {
-        //                      Object v = n.getAccess().get(param, Object.class);
-        //                      if (v == null) {
-        //                              v = param.getDef(Object.class);
-        //                      }
-        //                      final Object fv = v;
-        //                      panel.getBrowser().invokeLater(new Runnable() {
-        //                              @Override
-        //                              public void run() {
-        //                                      setValueImpl(fv);
-        //                              }
-        //                      });
-        //              }
-        //      });
-        // }
 
 }

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

@@ -4 +4 @@
 import com.framsticks.params.CompositeParam;
 import com.framsticks.params.FramsClass;
-// import org.apache.log4j.Logger;
 
 import javax.swing.*;
+import javax.swing.tree.TreePath;
+
+import org.apache.log4j.Logger;
 
 /**
@@ -13 +15 @@
 @SuppressWarnings("serial")
 public abstract class Panel extends JPanel {
+
+        private static final Logger log = Logger.getLogger(Panel.class);
+
 
         public static class Parameters {
@@ -28 +33 @@
         // private static final Logger log = Logger.getLogger(Panel.class.getName());
 
-        protected TreeNode currentTreeNode;
+        protected TreePath currentTreePath;
         protected final TreeAtFrame treeAtFrame;
         protected final Frame frame;
@@ -43 +48 @@
                 this.className = parameters.param.getContainedTypeName();
                 this.setName(parameters.param.getFramsTypeName());
+                log.debug("created panel: " + this);
         }
 
-        public void setCurrentTreeNode(TreeNode currentTreeNode) {
-                this.currentTreeNode = currentTreeNode;
-        }
 
-        public TreeNode getCurrentTreeNode() {
-                return currentTreeNode;
-        }
 
         public final Frame getFrame() {
                 return frame;
+        }
+
+        /**
+         * @return the currentTreePath
+         */
+        public TreePath getCurrentTreePath() {
+                return currentTreePath;
+        }
+
+        /**
+         * @param currentTreePath the currentTreePath to set
+         */
+        public void setCurrentTreePath(TreePath currentTreePath) {
+                this.currentTreePath = currentTreePath;
         }
 
@@ -70 +84 @@
         @Override
         public String toString() {
-                return uniqueName;
+                return param.toString() + "(" + uniqueName + ")";
         }
 

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

@@ -22 +22 @@
         protected JTextField statusBar;
         protected JPanel swing;
+        protected ExceptionResultHandler exceptionHandler;
 
         /**
@@ -35 +36 @@
                         @Override
                         protected void runAt() {
-                                log.error("error: " + exception);
+                                log.error("error: ", exception);
                                 statusBar.setText(exception.getShortMessage(new StringBuilder()).toString());
+                                if (exceptionHandler != null) {
+                                        exceptionHandler.handle(exception);
+                                }
                         }
                 });
@@ -70 +74 @@
         }
 
+        /**
+         * @return the exceptionHandler
+         */
+        public ExceptionResultHandler getExceptionHandler() {
+                return exceptionHandler;
+        }
+
+        /**
+         * @param exceptionHandler the exceptionHandler to set
+         */
+        public void setExceptionHandler(ExceptionResultHandler exceptionHandler) {
+                this.exceptionHandler = exceptionHandler;
+        }
+
 }

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

@@ -1 +1 @@
 package com.framsticks.gui;
 
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import com.framsticks.util.dispatching.AbstractJoinable;
 import com.framsticks.util.dispatching.Dispatcher;
+import com.framsticks.util.dispatching.JoinableDispatcher;
 import com.framsticks.util.dispatching.Task;
 import com.framsticks.util.dispatching.ThrowExceptionHandler;
@@ -11 +16 @@
  * @author Piotr Sniegowski
  */
-public class SwingDispatcher<C> implements Dispatcher<C> {
+public class SwingDispatcher<C> extends AbstractJoinable implements JoinableDispatcher<C> {
 
         @SuppressWarnings("rawtypes")
@@ -37 +42 @@
         @Override
         public final void dispatch(RunAt<? extends C> runnable) {
-                assert !(runnable instanceof Task);
+                if (runnable instanceof Task) {
+                        final Task<?> task = (Task<?>) runnable;
+                        Timer timer = new Timer(0, null);
+                        timer.addActionListener(new ActionListener() {
+
+                                @Override
+                                public void actionPerformed(ActionEvent event) {
+                                        task.run();
+                                }
+
+                        });
+                        timer.setInitialDelay((int) (task.getMoment() - System.currentTimeMillis()));
+                        timer.setRepeats(false);
+                        timer.start();
+                        return;
+                }
                 SwingUtilities.invokeLater(runnable);
         }
 
+        @Override
+        public String getName() {
+                return "gui";
+        }
+
+        @Override
+        protected void joinableStart() {
+
+        }
+
+        @Override
+        protected void joinableInterrupt() {
+                finish();
+        }
+
+        @Override
+        protected void joinableFinish() {
+
+        }
+
+        @Override
+        protected void joinableJoin() throws InterruptedException {
+
+        }
+
 }

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

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

@@ -1 +1 @@
 package com.framsticks.gui;
 
-import com.framsticks.communication.Subscription;
-import com.framsticks.communication.util.LoggingStateCallback;
-import com.framsticks.core.Mode;
+import java.lang.ref.WeakReference;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import javax.swing.tree.TreePath;
+
+import org.apache.log4j.Logger;
+
+import com.framsticks.core.Node;
 import com.framsticks.core.Tree;
-import com.framsticks.core.TreeOperations;
-import com.framsticks.core.ListChange;
-import com.framsticks.core.Path;
-import com.framsticks.gui.controls.ValueControl;
 import com.framsticks.gui.view.TreeCellRenderer;
 import com.framsticks.params.AccessInterface;
 import com.framsticks.params.CompositeParam;
-import com.framsticks.params.FramsClass;
-import com.framsticks.params.types.*;
-import com.framsticks.remote.*;
+import com.framsticks.params.types.StringParam;
+import com.framsticks.util.FramsticksException;
 import com.framsticks.util.lang.Casting;
-import com.framsticks.util.lang.Holder;
+import com.framsticks.util.lang.Pair;
 import com.framsticks.util.swing.TooltipConstructor;
-import com.framsticks.util.dispatching.ExceptionResultHandler;
-import com.framsticks.util.dispatching.FutureHandler;
-import com.framsticks.util.FramsticksException;
-import com.framsticks.util.Logging;
-import org.apache.log4j.Logger;
-import com.framsticks.util.dispatching.RunAt;
-
-import javax.swing.tree.DefaultMutableTreeNode;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import static com.framsticks.util.lang.Containers.filterInstanceof;
-import com.framsticks.util.swing.TreeNodeUtils;
-import static com.framsticks.core.TreeOperations.*;
-
-/**
- * @author Piotr Sniegowski
- */
-@SuppressWarnings("serial")
-public class TreeNode extends DefaultMutableTreeNode implements NodeListener, ExceptionResultHandler {
-
-        private static final Logger log = Logger.getLogger(TreeNode.class.getName());
-
-        Panel panel;
-
-        final protected Frame frame;
-        final protected TreeAtFrame treeAtFrame;
-
-        final protected Map<EventParam, Subscription<?>> userSubscriptions = new HashMap<>();
-        protected Map<ValueControl, Object> localChanges = null;
-        protected String tooltip;
-        protected String name;
+
+public class TreeNode extends AbstractNode {
+        private static final Logger log = Logger.getLogger(TreeNode.class);
+
+
+        protected static final AtomicInteger counter = new AtomicInteger();
+
+        protected final WeakReference<Object> reference;
         protected final CompositeParam param;
-        protected String iconName;
-        protected Path path;
-
-        public TreeNode(TreeAtFrame treeAtFrame, final Path path) {
-                this.frame = treeAtFrame.getFrame();
-                assert frame.isActive();
-                this.param = path.getTop().getParam();
-                this.name = this.param.getId();
-                log.debug("creating treenode " + name + ": " + path);
-                this.path = path;
-                this.treeAtFrame = treeAtFrame;
-
-                iconName = TreeCellRenderer.findIconName(name, path.getTextual());
-                tooltip = "?";
-                path.getTree().dispatch(new RunAt<Tree>(this) {
-                        @Override
-                        protected void runAt() {
-                                updateDescriptions(path);
-                        }
-                });
-        }
-
-        public void fetch(final Path p) {
-                assert p.getTree().isActive();
-                log.debug("fetching: " + p);
-                p.getTree().get(p, Mode.FETCH, new FutureHandler<Object>(this) {
-                        @Override
-                        protected void result(Object result) {
-
-                        }
-                });
-        }
-
-        protected void reactForFetchResult(final Path p, Exception e) {
-                assert p.getTree().isActive();
-                if (Logging.log(log, "fetch", TreeNode.this, e)) {
-                        frame.dispatch(new RunAt<Frame>(this) {
-                                @Override
-                                protected void runAt() {
-                                        log.debug("removing node from tree: " + p);
-                                        frame.treeModel.removeNodeFromParent(TreeNode.this);
-                                }
-                        });
-                        return;
-                }
-                updateChildren(p);
-                frame.dispatch(new RunAt<Frame>(this) {
-                        @Override
-                        protected void runAt() {
-                                //TODO maybe this should be called from some better place
-                                useOrCreatePanel();
-                        }
-                });
-        }
-
-        protected void postUpdatePath(final Path newPath) {
-                assert !frame.isActive();
-                /** TODO those two actions could be merged into single closure */
-                frame.dispatch(new RunAt<Frame>(this) {
-                        @Override
-                        protected void runAt() {
-                                updatePath(newPath);
-                        }
-                });
-                updateDescriptions(newPath);
-        }
-
-        protected void updatePath(Path newPath) {
-                assert frame.isActive();
-                if (!path.isResolved()) {
-                        path = newPath;
-                        log.debug("updated treenode's path: " + path);
-                        return;
-                }
-                if (path.matches(newPath)) {
-                        return;
-                }
-                log.debug("removing all children due to path update");
-                this.removeAllChildren();
-                frame.treeModel.nodeStructureChanged(this);
-        }
-
-        public Iterable<TreeNode> childrenIterable() {
-                return filterInstanceof(TreeNodeUtils.children(TreeNode.this, frame.treeModel), TreeNode.class);
-        }
-
-        /** Update children, by removing non existing and adding new ones.
+        protected final Tree tree;
+        protected final List<Pair<WeakReference<Object>, WeakReference<TreeNode>>> children = new LinkedList<>();
+        protected final int number;
+
+        public TreeNode(Tree tree, CompositeParam param, Object object) {
+                this.tree = tree;
+                this.param = param;
+                reference = new WeakReference<Object>(object);
+                number = counter.getAndIncrement();
+        }
+
+        public TreeNode(Node node) {
+                this(node.getTree(), node.getParam(), node.assureResolved().getObject());
+        }
+
+        public Node tryCreateNode() {
+                Object child = lock();
+                if (child == null) {
+                        return null;
+                }
+                return new Node(tree, param, child);
+        }
+
+        @Override
+        public int getChildCount() {
+                Object referent = lock();
+                if (referent == null) {
+                        return 0;
+                }
+                AccessInterface access = tree.prepareAccess(param).select(referent);
+                final int count = access.getCompositeParamCount();
+                return count;
+        }
+
+        public TreeNode getTreeNodeForChild(Object child) {
+                Iterator<Pair<WeakReference<Object>, WeakReference<TreeNode>>> i = children.iterator();
+                while (i.hasNext()) {
+                        Pair<WeakReference<Object>, WeakReference<TreeNode>> p = i.next();
+                        Object object = p.first.get();
+                        if (object == null) {
+                                i.remove();
+                                continue;
+                        }
+                        TreeNode treeNode = p.second.get();
+                        if (treeNode == null) {
+                                i.remove();
+                                continue;
+                        }
+                        if (object == child) {
+                                return treeNode;
+                        }
+                }
+                return null;
+
+                // WeakReference<GuiTreeNode> resultReference = children.get(child);
+                // if (resultReference == null) {
+                //      return null;
+                // }
+                // return resultReference.get();
+        }
+
+        @Override
+        public AbstractNode getChild(int number) {
+                Object referent = lock();
+                if (referent == null) {
+                        throw new FramsticksException().msg("invalid state - missing referent");
+                }
+                AccessInterface access = tree.prepareAccess(param).select(referent);
+
+                final int count = access.getCompositeParamCount();
+                if (number >= count) {
+                        throw new FramsticksException().msg("invalid state - no child");
+                }
+
+                CompositeParam childParam = access.getCompositeParam(number);
+                Object child = access.get(childParam, Object.class);
+                if (child == null) {
+                        log.debug("returing dummy node for " + childParam + " in " + referent);
+                        return new EmptyNode(childParam);
+                }
+
+                TreeNode result = getTreeNodeForChild(child);
+                if (result != null) {
+                        return result;
+                }
+                result = new TreeNode(tree, childParam, child);
+
+                children.add(Pair.make(new WeakReference<Object>(child), new WeakReference<TreeNode>(result)));
+
+                return result;
+
+        }
+
+        public Object lock() {
+                return reference.get();
+        }
+
+        @Override
+        public int getIndexOfChild(AbstractNode child) {
+                final TreeNode treeChild = Casting.tryCast(TreeNode.class, child);
+                if (treeChild == null) {
+                        return -1;
+                }
+                final Object childObject = treeChild.lock();
+                final Object parentObject = lock();
+                if (childObject == null || parentObject == null) {
+                        return -1;
+                }
+                final AccessInterface access = tree.prepareAccess(param).select(parentObject);
+
+                final int count = access.getCompositeParamCount();
+                for (int i = 0; i < count; ++i) {
+                        Object c = access.get(access.getCompositeParam(i), Object.class);
+                        if (c == childObject) {
+                                return i;
+                        }
+                }
+                log.debug(child + " not found in " + this);
+                return -1;
+        }
+
+        /**
+         * @return the param
          */
-        protected void updateChildren(final Path p) {
-                assert p.getTree().isActive();
-                log.debug("updating children of " + this);
-                AccessInterface access = TreeOperations.bindAccess(p.getTree(), p.getTop());
-                final List<Path> childrenPaths = new LinkedList<Path>();
-                /**Prepare path for each child.*/
-                for (CompositeParam param : filterInstanceof(access.getParams(), CompositeParam.class)) {
-                        childrenPaths.add(p.appendParam(param).tryFindResolution());
-                }
-
-                /**If some child were found, update in frame context.*/
-                if (childrenPaths.size() > 0) {
-                        frame.dispatch(new RunAt<Frame>(this) {
-                                @Override
-                                protected void runAt() {
-                                        // TreePath treePath = frame.startChange();
-                                        updatePath(p);
-                                        Map<String, TreeNode> current = new HashMap<String, TreeNode>();
-                                        for (TreeNode n : childrenIterable()) {
-                                                current.put(n.path.getLastElement(), n);
-                                        }
-                                        assert current.size() == TreeNode.this.getChildCount();
-                                        assert TreeNode.this.getChildCount() == frame.treeModel.getChildCount(TreeNode.this);
-                                        log.trace("current " + TreeNode.this.getChildCount() + " children: " + current.values());
-                                        for (Path childPath : childrenPaths) {
-                                                String e = childPath.getLastElement();
-                                                if (current.containsKey(e)) {
-                                                        current.remove(e);
-                                                        continue;
-                                                }
-                                                log.debug("update: treenode for " + p);
-                                                TreeNode childNode = new TreeNode(treeAtFrame, childPath);
-
-                                                frame.addNode(childNode, TreeNode.this);
-                                        }
-                                        for (TreeNode n : current.values()) {
-                                                frame.treeModel.removeNodeFromParent(n);
-                                        }
-                                        log.debug("updated children of " + TreeNode.this + ": " + TreeNode.this.getChildCount());
-                                }
-                        });
+        public CompositeParam getParam() {
+                return param;
+        }
+
+        /**
+         * @return the tree
+         */
+        public Tree getTree() {
+                return tree;
+        }
+
+
+        @Override
+        public String toString() {
+                return param.toString();
+        }
+
+        public static Node tryGetNode(TreePath treePath) {
+                return Casting.throwCast(TreeNode.class, treePath.getLastPathComponent()).tryCreateNode();
+        }
+
+        @Override
+        public boolean isLeaf() {
+                Object referent = lock();
+                if (referent == null) {
+                        return true;
+                }
+                AccessInterface access = tree.prepareAccess(param).select(referent);
+                return access.getCompositeParamCount() == 0;
+        }
+
+
+        @Override
+        public void render(TreeCellRenderer renderer) {
+                String name = param.getId();
+
+                Object child = lock();
+                if (child != null) {
+                        AccessInterface access = tree.prepareAccess(param).select(child);
+
+                        StringParam nameParam = Casting.tryCast(StringParam.class, access.getParam("name"));
+
+                        if (nameParam != null) {
+                                name = access.get(nameParam, String.class);
+                        }
+
+                        renderer.setToolTipText(new TooltipConstructor()
+                                .append("frams", access.getId())
+                                .append("java", child.getClass().getCanonicalName())
+                                .append("access", access.getClass().getSimpleName())
+                                .append("name", name)
+                                .append("id", param.getId())
+                                .append("object", Integer.toHexString(System.identityHashCode(child)))
+                                .append("number", number)
+                                .build());
                 } else {
-                        log.debug("no children in " + TreeNode.this);
-                }
-        }
-
-        public void select() {
-                final Path p = path;
-
-                p.getTree().dispatch(new RunAt<Tree>(this) {
-                        @Override
-                        protected void runAt() {
-                                final Path updated = (p.isResolved()) ? p : p.tryFindResolution();
-                                if (updated.isResolved()) {
-                                        Logging.log(log, "update", updated, null);
-                                        fetch(updated);
-                                        postUpdatePath(updated);
-                                        return;
-                                }
-                                p.getTree().resolve(updated, new FutureHandler<Path>(Logging.logger(log, "resolve and select", TreeNode.this)) {
-                                        @Override
-                                        protected void result(Path result) {
-                                                fetch(result);
-                                                postUpdatePath(result);
-                                        }
-                                });
-                        }
-                });
-
-        }
-
-        @Override
-        public String toString() {
-                return path.toString();
-        }
-
-        public final Panel getPanel() {
-                assert frame.isActive();
-                return panel;
-        }
-
-        protected void updateDescriptions(Path p) {
-                assert p.getTree().isActive();
-
-                if (!p.isResolved()) {
-                        return;
-                }
-                AccessInterface access = TreeOperations.bindAccess(p);
-
-                final String tooltip = new TooltipConstructor().append("frams", access.getId()).append("java", p.getTopObject().getClass().getCanonicalName()).append("access", access.getClass().getSimpleName()).append("name", name).append("id", param.getId()).append("object", Integer.toHexString(System.identityHashCode(this))).build();
-
-                StringParam nameParam = Casting.tryCast(StringParam.class, access.getParam("name"));
-                final String name = (nameParam != null ? access.get(nameParam, String.class) : path.getTop().getParam().getId());
-
-                frame.dispatch(new RunAt<Frame>(this) {
-                        @Override
-                        protected void runAt() {
-                                TreeNode.this.tooltip = tooltip;
-                                TreeNode.this.name = name;
-
-                                log.debug("updated descriptions for " + path + ": " + name);
-                        }
-                });
-        }
-
-        public void showPanel() {
-                assert frame.isActive();
-                assert panel != null;
-                frame.showPanel(panel);
-        }
-
-        public void fillPanelWithValues() {
-                assert frame.isActive();
-                if (panel == null) {
-                        return;
-                }
-                final Path p = path;
-                assert p.isResolved();
-                panel.setCurrentTreeNode(this);
-                p.getTree().dispatch(new RunAt<Tree>(this) {
-                        @Override
-                        protected void runAt() {
-                                AccessInterface access = TreeOperations.bindAccess(p);
-                                panel.pullValuesFromLocalToUser(access);
-
-                                frame.dispatch(new RunAt<Frame>(this) {
-                                        @Override
-                                        protected void runAt() {
-                                                showPanel();
-                                        }
-                                });
-                        }
-                });
-
-        }
-
-        public void useOrCreatePanel() {
-                assert frame.isActive();
-                if (panel != null) {
-                        log.trace("panel is already attached: " + path);
-                        fillPanelWithValues();
-                        return;
-                }
-                if (!path.isResolved()) {
-                        log.trace("path is not resolved: " + path);
-                        return;
-                }
-
-                CompositeParam param = path.getTop().getParam();
-                panel = treeAtFrame.findPanel(param.computeAccessId());
-                if (panel != null) {
-                        log.debug("found prepared panel for: " + path);
-                        fillPanelWithValues();
-                        return;
-                }
-                final Path p = path;
-                log.debug("preparing panel: " + p);
-                p.getTree().dispatch(new RunAt<Tree>(this) {
-                        @Override
-                        protected void runAt() {
-                                assert p.getTree().isActive();
-                                final CompositeParam param = p.getTop().getParam();
-                                final FramsClass framsClass = p.getTree().getInfoFromCache(param.getContainedTypeName());
-                                frame.dispatch(new RunAt<Frame>(this) {
-                                        @Override
-                                        protected void runAt() {
-                                                panel = treeAtFrame.preparePanel(param, framsClass);
-                                                fillPanelWithValues();
-                                        }
-                                });
-                        }
-                });
-        }
-
-        public String getTooltip() {
-                assert frame.isActive();
-                return tooltip;
-        }
-
-        /*public void subscribe(final EventParam eventParam) {
-                assert browser.isActive();
-                if (hasSubscribed(eventParam)) {
-                        log.error(eventParam + " is already subscribed for " + this);
-                        return;
-                }
-                Node node = getNode();
-                node.getConnection().subscribe(node.getPath() + "/" + eventParam.getId(), new SubscriptionCallback() {
-                        @Override
-                        public EventCallback subscribed(final Subscription subscription) {
-                                if (subscription == null) {
-                                        log.error("subscription failed");
-                                        return null;
-                                }
-                                if (hasSubscribed(eventParam)) {
-                                        //abort subscription
-                                        return null;
-                                }
-                                userSubscriptions.put(eventParam, subscription);
-                                log.debug("subscription succeeded: " + subscription);
-                                subscription.setDispatcher(browser);
-                                return new EventCallback() {
-                                        @Override
-                                        public void call(SourceInterface content) {
-                                                assert browser.isActive();
-                                                log.info("event " + subscription + " occurred");
-                                        }
-                                };
-                        }
-                });
-
-        }*/
-
-        public boolean hasSubscribed(EventParam param) {
-                assert frame.isActive();
-                return userSubscriptions.containsKey(param);
-        }
-
-        public void unsubscribe(EventParam eventParam) {
-                assert frame.isActive();
-                if (!hasSubscribed(eventParam)) {
-                        log.error("could not unsubscribe from " + eventParam);
-                        return;
-                }
-                userSubscriptions.get(eventParam).unsubscribe(new LoggingStateCallback(log, "unsubscribed " + eventParam));
-                userSubscriptions.remove(eventParam);
-        }
-
-        // @Override
-        // public void onChildChange(final Child child, ListChange.Action action) {
-        // assert browser.manager.isActive();
-
-        // switch (action) {
-        // case Remove: {
-        // Dispatching.invokeDispatch(browser, browser.manager, new Runnable() {
-        // @Override
-        // public void run() {
-        // assert browser.manager.isActive();
-        // final TreeNode treeNode = (TreeNode) child.getUserObject();
-        // if (treeNode == null) {
-        // log.error("child " + child + " had no tree node attached");
-        // return;
-        // }
-        // browser.invokeLater(new Runnable() {
-        // @Override
-        // public void run() {
-        // assert browser.isActive();
-        // TreePath path = browser.startChange();
-        // //assert treeNode.getParent() == TreeNode.this;
-        // if (treeNode.getParent() != null) {
-        // browser.treeModel.removeNodeFromParent(treeNode);
-        // }
-        // //remove(treeNode);
-        // browser.markNodeChanged(TreeNode.this, path);
-        // }
-        // });
-        // }
-        // });
-        // break;
-        // }
-        // }
-
-        // }
-
-        public String getName() {
-                return name;
-        }
-
-        public String getIconName() {
-                return iconName;
-        }
-
-        @Override
-        public void onUpgrade(Path path) {
-        }
-
-        @Override
-        public void onChange(Path path) {
-        }
-
-        @Override
-        public void onChildChange(Path path, ListChange.Action action) {
-        }
-
-        public final Frame getFrame() {
-                return frame;
-        }
-
-        public boolean changeValue(ValueControl component, Object newValue) {
-                log.debug("changing value of " + component + " to '" + newValue + "'");
-
-                if (localChanges == null) {
-                        localChanges = new HashMap<ValueControl, Object>();
-                }
-                localChanges.put(component, newValue);
-
-                return true;
-        }
-
-        public Path getTreePath() {
-                assert frame.isActive();
-                return path;
-        }
-
-        public void pushLocalChanges() {
-                assert frame.isActive();
-                if (localChanges == null) {
-                        return;
-                }
-                Map<ValueControl, Object> changes = localChanges;
-                localChanges = null;
-                final Holder<Integer> counter = new Holder<>(changes.size());
-                final Path p = path;
-
-                for (Map.Entry<ValueControl, Object> e : changes.entrySet()) {
-                        set(p, e.getKey().getParam(), e.getValue(), new FutureHandler<Integer>(this) {
-                                @Override
-                                protected void result(Integer flag) {
-                                        counter.set(counter.get() - 1);
-                                        if (counter.get() != 0) {
-                                                return;
-                                        }
-                                        log.debug("applied changes for: " + p);
-                                        frame.dispatch(new RunAt<Frame>(this) {
-                                                @Override
-                                                protected void runAt() {
-                                                        fillPanelWithValues();
-                                                }
-                                        });
-                                }
-
-                        });
-                }
-        }
-
-        @Override
-        public void handle(FramsticksException exception) {
-                frame.handle(exception);
-        }
+                        renderer.setToolTipText("?");
+                }
+                renderer.setText(name);
+                renderer.setIcon(ImageProvider.loadImage(TreeCellRenderer.findIconName(param)));
+
+        }
+
 }

java/main/src/main/java/com/framsticks/gui/console/InteractiveConsole.java

@@ -109 +109 @@
                         }
                 });
-
-
         }
 

java/main/src/main/java/com/framsticks/gui/console/ManagedConsole.java

@@ -3 +3 @@
 import java.util.LinkedList;
 import java.util.List;
-
 
 import com.framsticks.communication.ClientSideManagedConnection;
@@ -11 +10 @@
 import com.framsticks.communication.Response;
 import com.framsticks.communication.queries.ApplicationRequest;
+import com.framsticks.core.Mode;
 import com.framsticks.core.Path;
 import static com.framsticks.core.TreeOperations.*;
@@ -17 +17 @@
 import com.framsticks.params.annotations.AutoAppendAnnotation;
 import com.framsticks.params.annotations.FramsClassAnnotation;
+import com.framsticks.params.types.ListParam;
 import com.framsticks.remote.RemoteTree;
 import com.framsticks.util.FramsticksException;
+import com.framsticks.util.dispatching.Dispatching;
 import com.framsticks.util.dispatching.FutureHandler;
+import com.framsticks.util.dispatching.RunAt;
 import com.framsticks.util.lang.Casting;
 import com.framsticks.util.lang.Containers;
@@ -27 +30 @@
 @FramsClassAnnotation
 public class ManagedConsole extends InteractiveConsole {
+
 
         protected RemoteTree tree;
@@ -70 +74 @@
         }
 
+
         @Override
         protected void findCompletionPropositions(final String prefix) {
                 Pair<CharSequence, CharSequence> command = Request.takeIdentifier(prefix);
+                if (command == null) {
+                        return;
+                }
 
                 Casting.throwCast(ApplicationRequest.class, Request.createRequestByTypeString(command.first.toString()));
@@ -90 +98 @@
                 // final Iterator<String> iterator = Path.splitPath(textual);
 
-                resolve(tree, textual, new FutureHandler<Path>(this) {
+                tryGet(tree, textual, new FutureHandler<Path>(this) {
 
                         @Override
-                        protected void result(Path path) {
+                        protected void result(final Path path) {
                                 if (!textual.startsWith(path.getTextual())) {
                                         throw new FramsticksException().msg("invalid state").arg("line", prefix).arg("path", path);
                                 }
+                                assert path.getTree().isActive();
 
-                                List<String> propositions = new LinkedList<String>();
-                                String remaining = textual.substring(path.getTextual().length());
-                                remaining = Path.PathBuilder.splitPath(remaining).next();
+                                final Runnable finalizeCompletion = new Runnable() {
+                                        @Override
+                                        public void run() {
+                                                String remaining = textual.substring(path.getTextual().length());
 
-                                for (CompositeParam p : Containers.filterInstanceof(bindAccess(path).getParams(), CompositeParam.class)) {
-                                        if (p.getId().startsWith(remaining)) {
-                                                propositions.add(p.getId());
+                                                String base = prefix.substring(0, prefix.length() - (textual.length() - path.getTextual().length()));
+                                                if (path.size() > 1) {
+                                                        base = base + "/";
+                                                }
+
+                                                if (remaining.startsWith("/")) {
+                                                        remaining = remaining.substring(1);
+                                                }
+
+                                                if (remaining.indexOf('/') != -1) {
+                                                        /** It is to long. */
+                                                        return;
+                                                }
+                                                final List<String> propositions = new LinkedList<String>();
+                                                for (CompositeParam p : Containers.filterInstanceof(bindAccess(path).getParams(), CompositeParam.class)) {
+                                                        if (remaining.equals("") || p.getId().startsWith(remaining)) {
+                                                                propositions.add(base + p.getId());
+                                                        }
+                                                }
+
+                                                dispatch(new RunAt<ManagedConsole>(ManagedConsole.this) {
+
+                                                        @Override
+                                                        protected void runAt() {
+                                                                processCompletionResult(prefix, propositions);
+                                                        }
+                                                });
                                         }
+                                };
+
+                                if (path.getTop().getParam() instanceof ListParam) {
+                                        tree.get(path, Mode.FETCH, new FutureHandler<Path>(ManagedConsole.this) {
+                                                @Override
+                                                protected void result(Path result) {
+                                                        finalizeCompletion.run();
+                                                }
+                                        });
+                                        return;
                                 }
-                                processCompletionResult(prefix, propositions);
+                                finalizeCompletion.run();
+
                         }
                 });
@@ -119 +164 @@
                 connection = tree.getConnection();
         }
+
+        @Override
+        protected void joinableStart() {
+                super.joinableStart();
+                Dispatching.use(tree, this);
+        }
+
+        @Override
+        protected void joinableInterrupt() {
+                Dispatching.drop(tree, this);
+                super.joinableInterrupt();
+        }
+
+        @Override
+        protected void joinableJoin() throws InterruptedException {
+                Dispatching.join(tree);
+                super.joinableJoin();
+        }
 }

java/main/src/main/java/com/framsticks/gui/console/TrackConsole.java

@@ -1 +1 @@
 package com.framsticks.gui.console;
+
+import java.awt.BorderLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.JCheckBox;
 
 import com.framsticks.communication.Connection;
@@ -8 +16 @@
 @FramsClassAnnotation
 public class TrackConsole extends Console implements ConnectionListener {
+
+        volatile boolean writeOut = true;
+        volatile boolean writeIn = true;
 
         public TrackConsole() {
@@ -30 +41 @@
         }
 
-
         @Override
         public void connectionOutgoing(String line) {
-                dispatchWrite(line);
+                if (writeOut) {
+                        dispatchWrite(line);
+                }
         }
 
         @Override
         public void connectionIncomming(String line) {
-                dispatchWrite(line);
+                if (writeIn) {
+                        dispatchWrite(line);
+                }
+        }
+
+        @Override
+        protected void initializeGui() {
+                super.initializeGui();
+
+                final Box box = new Box(BoxLayout.LINE_AXIS);
+
+                final JCheckBox outCheckbox = new JCheckBox();
+                outCheckbox.setText("Show out");
+                outCheckbox.setSelected(true);
+                outCheckbox.addActionListener(new ActionListener() {
+                        @Override
+                        public void actionPerformed(ActionEvent arg0) {
+                                writeOut = outCheckbox.isSelected();
+                        }
+                });
+
+                final JCheckBox inCheckbox = new JCheckBox();
+                inCheckbox.setText("Show in");
+                inCheckbox.setSelected(true);
+                inCheckbox.addActionListener(new ActionListener() {
+                        @Override
+                        public void actionPerformed(ActionEvent arg0) {
+                                writeIn = inCheckbox.isSelected();
+                        }
+                });
+
+                box.add(outCheckbox);
+                box.add(Box.createHorizontalStrut(10));
+                box.add(inCheckbox);
+
+                panel.add(box, BorderLayout.PAGE_END);
         }
 

java/main/src/main/java/com/framsticks/gui/controls/CheckBoxControl.java

@@ -21 +21 @@
                 super(booleanParam);
                 checkBox = new JCheckBox();
-                checkBox.setEnabled(!isReadOnly());
                 checkBox.addActionListener(new ActionListener() {
 
@@ -52 +51 @@
         }
 
+        @Override
+        protected void updateEnabled(boolean enabled) {
+                checkBox.setEnabled(enabled);
+        }
+
 }

java/main/src/main/java/com/framsticks/gui/controls/Control.java

@@ -24 +24 @@
         protected ControlOwner owner;
 
+        protected abstract void updateEnabled(boolean enabled);
+
+        private boolean userEnabled = true;
+
         public Control(Param param) {
                 this.param = param;
                 setName(param.getId());
-
-                this.setEnabled(!param.hasFlag(Flags.READONLY));
-                // TODO: take care of textField exception: setEditable
         }
 
@@ -38 +39 @@
         public void setOwner(ControlOwner owner) {
                 this.owner = owner;
+        }
+
+        /**
+         * @return the userEnabled
+         */
+        public final boolean isUserEnabled() {
+                return userEnabled;
+        }
+
+        /**
+         * @param userEnabled the userEnabled to set
+         */
+        public final void setUserEnabled(boolean userEnabled) {
+                this.userEnabled = userEnabled;
+                updateEnabled(!isReadonly());
+        }
+
+        public final boolean isReadonly() {
+                return !userEnabled || param.hasFlag(Flags.READONLY);
         }
 

java/main/src/main/java/com/framsticks/gui/controls/ControlOwner.java

@@ -2 +2 @@
 
 import javax.swing.JPanel;
+import javax.swing.tree.TreePath;
 
-import com.framsticks.gui.TreeNode;
+import com.framsticks.gui.Frame;
 import com.framsticks.util.dispatching.ExceptionResultHandler;
 
@@ -9 +10 @@
 
         public JPanel getPanel();
-        public TreeNode getCurrentTreeNode();
+        public TreePath getCurrentTreePath();
+        public Frame getFrame();
 
 }

java/main/src/main/java/com/framsticks/gui/controls/EnumControl.java

@@ -28 +28 @@
                 }
                 list.setEditable(false);
-                list.setEnabled(!isReadOnly());
                 list.addItemListener(new ItemListener() {
                         @Override
@@ -61 +60 @@
         }
 
+        @Override
+        protected void updateEnabled(boolean enabled) {
+                list.setEnabled(enabled);
+
+        }
+
 }

java/main/src/main/java/com/framsticks/gui/controls/EventControl.java

@@ -39 +39 @@
         }
 
+        @Override
+        protected void updateEnabled(boolean enabled) {
+                button.setEnabled(enabled);
+        }
+
         /*
         @Override

java/main/src/main/java/com/framsticks/gui/controls/ProcedureControl.java

@@ -3 +3 @@
 import com.framsticks.core.Tree;
 import com.framsticks.core.Path;
+import com.framsticks.gui.Frame;
 import com.framsticks.gui.Gui;
-import com.framsticks.gui.TreeNode;
 import com.framsticks.params.Param;
 import com.framsticks.params.ValueParam;
@@ -15 +15 @@
 import javax.swing.*;
 import javax.swing.border.BevelBorder;
+import javax.swing.tree.TreePath;
 
 import org.apache.log4j.Logger;
@@ -20 +21 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
-import java.util.HashMap;
+import java.util.IdentityHashMap;
 import java.util.LinkedList;
 import java.util.List;
@@ -32 +33 @@
         protected final JButton procedureButton;
 
-        final protected Map<ValueParam, ValueControl> components = new HashMap<>();
+        final protected Map<ValueParam, ValueControl> components = new IdentityHashMap<>();
 
         public ProcedureControl(ProcedureParam procedureParam) {
@@ -54 +55 @@
                         @Override
                         public void actionPerformed(ActionEvent e) {
-                                TreeNode treeNode = owner.getCurrentTreeNode();
-                                assert treeNode != null;
 
-                                log.debug("calling " + getParam() + " on " + treeNode);
-                                final Path path = treeNode.getTreePath();
+                                final Path path = getFrame().getTreeModel().convertToPath(getCurrentTreePath());
 
                                 final List<Object> arguments = new LinkedList<Object>();
@@ -93 +91 @@
 
         @Override
-        public TreeNode getCurrentTreeNode() {
-                return owner.getCurrentTreeNode();
-        }
-
-        @Override
         public ProcedureParam getParam() {
                 return (ProcedureParam) param;
         }
 
+        @Override
+        protected void updateEnabled(boolean enabled) {
+                procedureButton.setEnabled(enabled);
+                for (ValueControl vc : components.values()) {
+                        vc.setUserEnabled(enabled);
+                }
+        }
+
+        @Override
+        public Frame getFrame() {
+                return owner.getFrame();
+        }
+
+        @Override
+        public TreePath getCurrentTreePath() {
+                return owner.getCurrentTreePath();
+        }
+
 }

java/main/src/main/java/com/framsticks/gui/controls/SliderControl.java

@@ -17 +17 @@
 import org.apache.log4j.Logger;
 
-import com.framsticks.params.Flags;
 import com.framsticks.params.types.DecimalParam;
 import com.framsticks.params.types.FloatParam;
@@ -55 +54 @@
                 slider = new JSlider();
 
-                slider.setEnabled(!isReadOnly());
                 slider.setPaintLabels(false);
                 if (param instanceof DecimalParam) {
@@ -110 +108 @@
                 text.setHorizontalAlignment(JSlider.CENTER);
 
-                text.setEnabled(!param.hasFlag(Flags.READONLY));
 
                 slider.addChangeListener(new ChangeListener() {
@@ -206 +203 @@
         }
 
+        @Override
+        protected void updateEnabled(boolean enabled) {
+                slider.setEnabled(enabled);
+                text.setEnabled(enabled);
+        }
+
 }

java/main/src/main/java/com/framsticks/gui/controls/TextAreaControl.java

@@ -18 +18 @@
                 textArea.setLineWrap(true);
                 textArea.setWrapStyleWord(true);
-                textArea.setEditable(!isReadOnly());
                 addDefaultDocumentListener(textArea);
 
@@ -47 +46 @@
         }
 
+        @Override
+        protected void updateEnabled(boolean enabled) {
+                textArea.setEditable(enabled);
+        }
+
 }

java/main/src/main/java/com/framsticks/gui/controls/TextFieldControl.java

@@ -31 +31 @@
                 this.setMaximumSize(new Dimension(Integer.MAX_VALUE, Control.LINE_HEIGHT));
 
-                textField.setEditable(!isReadOnly());
-
                 addDefaultDocumentListener(textField);
 
@@ -48 +46 @@
         }
 
+        @Override
+        protected void updateEnabled(boolean enabled) {
+                textField.setEnabled(enabled);
+        }
+
 }

java/main/src/main/java/com/framsticks/gui/controls/ValueControl.java

@@ -97 +97 @@
         }
 
-        public final boolean isReadOnly() {
-                return (param.getFlags() & Flags.READONLY) != 0;
-        }
-
-
 
 }

java/main/src/main/java/com/framsticks/gui/view/TreeCellRenderer.java

@@ -1 +1 @@
 package com.framsticks.gui.view;
 
-import com.framsticks.gui.ImageProvider;
-import com.framsticks.gui.TreeNode;
+import java.awt.Component;
 
-import javax.swing.*;
+import javax.swing.JTree;
 import javax.swing.tree.DefaultTreeCellRenderer;
 
-import org.apache.log4j.Logger;
-
-import java.awt.*;
+import com.framsticks.gui.AbstractNode;
+import com.framsticks.gui.ImageProvider;
+import com.framsticks.params.CompositeParam;
 
 /**
@@ -16 +15 @@
 @SuppressWarnings("serial")
 public class TreeCellRenderer extends DefaultTreeCellRenderer {
-        private static final Logger log =
-                Logger.getLogger(TreeCellRenderer.class);
-
 
         public TreeCellRenderer() {
-                setOpenIcon(null);
-                setClosedIcon(null);
-                setLeafIcon(null);
+
+                // setOpenIcon(ImageProvider.loadImage(ImageProvider.FOLDER_OPEN));
+                // setClosedIcon(ImageProvider.loadImage(ImageProvider.FOLDER_CLOSED));
+                // setLeafIcon(ImageProvider.loadImage(ImageProvider.NODE));
         }
 
@@ -31 +28 @@
                         boolean hasFocus) {
 
-                //super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf,
-                //              row, hasFocus);
+                super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
+
                 if (value == null) {
+                        setText("!null value");
                         return this;
                 }
-                if (!(value instanceof TreeNode)) {
+
+                if (!(value instanceof AbstractNode)) {
                         setIcon(ImageProvider.loadImage(ImageProvider.SERVER));
                         setText("framsticks");
                         return this;
                 }
-                TreeNode treeNode = (TreeNode)value;
-                assert treeNode.getFrame().isActive();
-                setToolTipText(treeNode.getTooltip());
-                setIcon(ImageProvider.loadImage(treeNode.getIconName()));
-                setText(treeNode.getName());
+                ((AbstractNode) value).render(this);
+
                 return this;
         }
 
-        public static String findIconName(String nodeName, String path) {
-                if (nodeName == null || path == null) {
-                        log.warn("given invalid parameters: " + nodeName + " " + path);
-                        // return null;
-                        return ImageProvider.SERVER;
+        public static String findIconName(CompositeParam param) {
+                switch (param.getFramsTypeName()) {
+                        case "o Server": return ImageProvider.SERVER;
+                        case "o Simulator": return ImageProvider.SIMULATOR;
+                        case "o CLI": return ImageProvider.CLI;
+                        case "o World": return ImageProvider.WORLD;
+                        case "o GenePools": return ImageProvider.GENEPOOLS;
+                        case "l GenePool": return ImageProvider.SIMULATOR; //HERE
+                        case "o GenePool": return ImageProvider.GENEPOOLS_GROUP; //HERE
+
+                        case "o Populations": return ImageProvider.POPULATIONS;
+                        case "l Population": return ImageProvider.SIMULATOR; ///HERE
+                        case "o Population": return ImageProvider.POPULATION_GROUP;
+                        case "o ExpParams": return ImageProvider.EXPERIMENT;
+                        case "o stats": return ImageProvider.STATISTIC;
+                        case "l Genotype uid": return ImageProvider.GENOTYPES_GROUP;
+                        case "o Genotype": return ImageProvider.GENOTYPES;
+
+                        case "o Part": return ImageProvider.PART;
+                        case "o Joint": return ImageProvider.JOINT;
+                        case "o NeuroDef": return ImageProvider.NEURON_DEF;
+                        case "o NeuroConn": return ImageProvider.NEURON_DEF;
+
+                        case "o MechPart": return ImageProvider.MECH_PART;
+                        case "o MechJoint": return ImageProvider.MECH_JOINT;
+                        case "o Neuro": return ImageProvider.NEURON;
+
+                        case "l Part": return ImageProvider.PART_GROUP;
+                        case "l Joint": return ImageProvider.JOINT_GROUP;
+                        case "l NeuroDef": return ImageProvider.NEURON_DEF_GROUP;
+                        case "l NeuroConn": return ImageProvider.NEURON_DEF_GROUP;
+
+                        case "l MechPart": return ImageProvider.MECH_PART_GROUP;
+                        case "l MechJoint": return ImageProvider.MECH_JOINT_GROUP;
+                        case "l Neuro": return ImageProvider.NEURON_GROUP;
+
+                        case "o Creature": return ImageProvider.CREATURE;
+                        case "l Creature uid": return ImageProvider.CREATURES_GROUP;
+                        case "l Event id": return ImageProvider.EVENT;
+                        case "o Event": return ImageProvider.EVENT;
+
                 }
-                if (path.equals("/")) {
-                        return ImageProvider.SERVER;
-                }
-                if (path.endsWith("simulator")) {
-                        return ImageProvider.SIMULATOR;
-                }
-                if (path.endsWith("cli")) {
-                        return ImageProvider.CLI;
-                }
-                if (path.endsWith("world")) {
-                        return ImageProvider.WORLD;
-                }
-                if (path.endsWith("genepools")) {
-                        return ImageProvider.GENEPOOLS;
-                }
-                if (path.endsWith("populations")) {
-                        return ImageProvider.POPULATIONS;
-                }
-                if (path.endsWith("experiment")) {
-                        return ImageProvider.EXPERIMENT;
-                }
-                if (path.endsWith("stats")) {
-                        return ImageProvider.STATISTIC;
-                }
-                if (nodeName.equals("creatures") || path.endsWith("creatures")) {
-                        return ImageProvider.CREATURES_GROUP;
-                }
-                if (nodeName.equals("Favourite Fields")) {
-                        return ImageProvider.FAVORITE_FIELDS;
-                }
-                if (nodeName.equals("genotypes") || path.endsWith("creatures")) {
-                        return ImageProvider.GENOTYPES_GROUP;
-                }
-                if (nodeName.equals("parts") || path.endsWith("parts")) {
-                        return ImageProvider.PART_GROUP;
-                }
-                if (nodeName.equals("joints") || path.endsWith("joints")) {
-                        return ImageProvider.JOINT_GROUP;
-                }
-                if (nodeName.equals("neurodefs") || path.endsWith("neurodefs")) {
-                        return ImageProvider.NEURON_DEF_GROUP;
-                }
-                if (nodeName.equals("neuroconns") || path.endsWith("neuroconns")) {
-                        return ImageProvider.NEURON_DEF_GROUP;
-                }
-                if (nodeName.equals("mechparts") || path.endsWith("mechparts")) {
-                        return ImageProvider.MECH_PART_GROUP;
-                }
-                if (nodeName.equals("mechjoints") || path.endsWith("mechjoints")) {
-                        return ImageProvider.MECH_JOINT_GROUP;
-                }
-                if (nodeName.equals("neurons") || path.endsWith("neurons")) {
-                        return ImageProvider.NEURON_GROUP;
-                }
-                if (path.matches("^.*parts/[0-9]+$")) {
-                        return ImageProvider.PART;
-                }
-                if (path.matches("^.*joints/[0-9]+$")) {
-                        return ImageProvider.JOINT;
-                }
-                if (path.matches("^.*neurodefs/[0-9]+$")) {
-                        return ImageProvider.NEURON_DEF;
-                }
-                if (path.matches("^.*neuroconns/[0-9]+$")) {
-                        return ImageProvider.NEURON_DEF;
-                }
-                if (path.matches("^.*mechparts/[0-9]+$")) {
-                        return ImageProvider.MECH_PART;
-                }
-                if (path.matches("^.*mechjoints/[0-9]+$")) {
-                        return ImageProvider.MECH_JOINT;
-                }
-                if (path.matches("^.*neurons/[0-9]+$")) {
-                        return ImageProvider.NEURON;
-                }
-                if (path.matches("^.*creatures/c[0-9]+$")) {
-                        return ImageProvider.CREATURE;
-                }
-                if (path.matches("^.*genotypes/g[0-9]+$")) {
-                        return ImageProvider.GENOTYPES;
-                }
-                if (path.matches("^.*populations/groups/[0-9]+$")) {
-                        return ImageProvider.POPULATION_GROUP;
-                }
-                if (path.matches("^.*genepools/groups/[0-9]+$")) {
-                        return ImageProvider.GENEPOOLS_GROUP;
-                }
-                if (path.matches("^.*events/e[0-9]+$")) {
-                        return ImageProvider.EVENT;
-                }
-                return ImageProvider.SIMULATOR;
+
+
+                return ImageProvider.SERVER;
         }
 
 
+
 }