source: java/main/src/main/java/com/framsticks/gui/EndpointAtFrame.java @ 87

package com.framsticks.gui;

import org.apache.log4j.Logger;

import com.framsticks.core.Instance;
import com.framsticks.core.InstanceListener;
import com.framsticks.core.ListChange;
import com.framsticks.core.Node;
import com.framsticks.core.Path;
import com.framsticks.params.CompositeParam;
import com.framsticks.params.FramsClass;

import java.util.*;

import javax.swing.tree.TreePath;
import com.framsticks.util.dispatching.RunAt;

/**
 * @author Piotr Sniegowski
 */
public class EndpointAtFrame implements InstanceListener {

        private static final Logger log = Logger.getLogger(EndpointAtFrame.class);

        protected final BrowserEndpoint endpoint;
        protected final Frame frame;
        protected final Instance instance;
        protected final Map<String, Panel> knownPanels = new HashMap<String, Panel>();
        protected TreeNode rootTreeNode;

        public EndpointAtFrame(BrowserEndpoint endpoint, Frame frame) {
                this.endpoint = endpoint;
                this.frame = frame;
                this.instance = endpoint.getInstance();
        }

        public BrowserEndpoint getEndpoint() {
                return endpoint;
        }

        public Frame getFrame() {
                return frame;
        }

        public void registerPanel(Panel panel) {
        }

        public Panel findPanel(String accessId) {
                assert frame.isActive();
                return (knownPanels.containsKey(accessId) ? knownPanels.get(accessId) : null);
        }

        public final String getName() {
                return endpoint.getName();
        }

        public Panel preparePanel(CompositeParam param, FramsClass framsClass) {
                assert frame.isActive();
                Panel panel = preparePanelImpl(param, framsClass);
                assert panel != null;
                String accessId = param.computeAccessId();
                panel.uniqueName = accessId + "@" + endpoint.getName();
                knownPanels.put(accessId, panel);
                frame.cardPanel.add(panel, panel.uniqueName);
                log.debug("prepared panel for " + panel);
                return panel;
        }

        protected Panel preparePanelImpl(CompositeParam param, FramsClass framsClass) {
                assert frame.isActive();
                List<Panel> panels = new ArrayList<Panel>();

                Panel.Parameters parameters = new Panel.Parameters(this, param,
                                framsClass);
                for (PanelProvider pp : frame.browser.panelProviders) {
                        Panel p = pp.providePanel(parameters);
                        if (p != null) {
                                panels.add(p);
                        }
                }

                if (panels.isEmpty()) {
                        return new EmptyPanel(parameters);
                }
                if (panels.size() == 1) {
                        return panels.get(0);
                }
                return new MultiPanel(parameters, panels);

        }

        @Override
        public void onListChange(Path path, ListChange change) {

        }

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

                // 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.paramId.equals(n.getParam().getId())) {
                                        r = c;
                                        break;
                                }
                        }
                        if (r == null) {
                                log.debug("missing " + n.getParam().getId() + " in " + t);
                                if (!create) {
                                        return result;
                                }
                                Path p = Path.build().instance(path.getInstance()).buildUpTo(nodes, n).finish();


                                log.debug("forced resolution: creating treenode for " + p);
                                TreeNode childNode = new TreeNode(EndpointAtFrame.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 instance.isActive();
                log.trace("fetched " + path);

                frame.invokeLater(new RunAt<Frame>() {
                        @Override
                        public void run() {

                                TreePath treePath = getTreePath(path, true);
                                assert treePath.getPathCount() == path.size() + 1;

                                final TreeNode result = (TreeNode) treePath.getLastPathComponent();
                                // log.trace("found " + result + " == " + path);
                                instance.invokeLater(new RunAt<Instance>() {
                                        @Override
                                        public void run() {
                                                result.reactForFetchResult(path, null);
                                        }
                                });
                        }
                });
        }

        @Override
        public void onRun(Exception e) {

        }

        @Override
        public void onStop(Exception e) {

        }
}