source: java/main/src/main/java/com/framsticks/gui/tree/TreeNode.java @ 100

package com.framsticks.gui.tree;

import java.lang.ref.WeakReference;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import com.framsticks.core.Node;
import com.framsticks.core.Path;
import com.framsticks.core.Tree;
import com.framsticks.gui.Frame;
import com.framsticks.gui.ImageProvider;
import com.framsticks.gui.TreeAtFrame;
import com.framsticks.gui.TreePanel;
import com.framsticks.params.Access;
import com.framsticks.params.CompositeParam;
import com.framsticks.params.EventListener;
import com.framsticks.params.FramsClass;
import com.framsticks.params.ValueParam;
import com.framsticks.params.types.EventParam;
import com.framsticks.params.types.ObjectParam;
import com.framsticks.params.types.StringParam;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.dispatching.FutureHandler;
import com.framsticks.util.lang.Casting;
import com.framsticks.util.lang.Containers;
import com.framsticks.util.swing.TooltipConstructor;

import static com.framsticks.core.TreeOperations.*;

public class TreeNode extends AbstractNode {

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

        protected final WeakReference<Object> reference;
        protected final int hashCode;
        protected final TreeAtFrame treeAtFrame;
        protected final String textual;
        protected final CompositeParam param;
        protected TreePanel panel;

        public TreeModel getTreeModel() {
                return treeAtFrame.getFrame().getTreeModel();
        }

        /**
         * @param reference
         */
        public TreeNode(TreeAtFrame treeAtFrame, Path path) {
                path.assureResolved();

                this.reference = new WeakReference<Object>(path.getTopObject());
                this.textual = path.getTextual();
                this.treeAtFrame = treeAtFrame;
                this.param = path.getTop().getParam();
                hashCode = System.identityHashCode(path.getTopObject());

                if (getTree().getSideNote(path.getTopObject(), getTreeModel().createdTag, Object.class) == getTreeModel().createdTag) {
                        return;
                }

                // path.getTree().putSideNote(path.getTopObject(), Textual.class, path.getTextual());
                path.getTree().putSideNote(path.getTopObject(), getTreeModel().createdTag, getTreeModel().createdTag);

                /** Iterate over all EventParams and for matching ValueParams register listeners. */
                if (path.getTop().getParam() instanceof ObjectParam) {
                        Access access = bindAccess(path);
                        FramsClass framsClass = access.getFramsClass();
                        for (EventParam eventParam : Containers.filterInstanceof(framsClass.getParamEntries(), EventParam.class)) {
                                if (!eventParam.getId().endsWith("_changed")) {
                                        continue;
                                }
                                String valueId = eventParam.getId().substring(0, eventParam.getId().length() - 8);
                                final ValueParam valueParam = Casting.tryCast(ValueParam.class, framsClass.getParam(valueId));
                                if (valueParam == null) {
                                        continue;
                                }
                                getTreeModel().registerForEventParam(this, path, eventParam, valueParam);
                        }
                }
        }

        @Override
        public int hashCode() {
                return hashCode;
        }

        @Override
        public boolean equals(Object obj) {
                if (obj instanceof TreeNode) {
                        return lock() == ((TreeNode) obj).lock();
                }
                return false;
        }

        @Override
        public AbstractNode getChild(int number) {
                Object referent = lock();
                if (referent == null) {
                        throw new FramsticksException().msg("invalid state - missing referent");
                }
                Tree tree = getTree();
                Access access = bindAccessForTreeObject(referent);

                final int count = access.getCompositeParamCount();
                if (number >= count) {
                        throw new FramsticksException().msg("invalid state - no child");
                }

                /** textual path may be not valid anymore*/
                CompositeParam childParam = access.getCompositeParam(number);

                try {
                        Path path = Path.to(tree, getTextual()).appendParam(childParam).tryFindResolution();
                        if (!path.isResolved()) {
                                path = create(path);
                        }
                        return prepareTreeNodeForChild(path);
                } catch (FramsticksException e) {
                }
                return new EmptyNode(getFrame(), childParam);

        }

        public TreeNode prepareTreeNodeForChild(Path path) {
                assert path.getTree() == getTree();
                Object parent = lock();
                Iterator<Node> n = path.getNodes().iterator();
                while (n.hasNext()) {
                        if (n.next().getObject() == parent) {
                                break;
                        }
                }
                if (!n.hasNext()) {
                        return null;
                        // throw new FramsticksException().msg("tree node is not on path (or is last)").arg("path", path).arg("node", this);
                }
                return new TreeNode(treeAtFrame, path);
        }

        public Object lock() {
                return reference.get();
        }

        @Override
        public int getIndexOfChild(Object 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 Access access = bindAccessForTreeObject(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("{} not found in {}", child, this);
                return -1;
        }

        public Frame getFrame() {
                return getTreeAtFrame().getFrame();
        }

        public TreeAtFrame getTreeAtFrame() {
                return treeAtFrame;
        }

        public Tree getTree() {
                return getTreeAtFrame().getTree();
        }

        protected Path assurePath() {
                return Path.to(getTree(), getTextual()).assureResolved();
        }

        @Override
        public String toString() {
                return getTextual();
        }

        public Node tryCreateNode() {
                Object child = lock();
                if (child == null) {
                        return null;
                }
                String textual = getTextual();
                Path path = Path.tryTo(getTree(), textual);
                if (path.isResolved(textual)) {
                        return path.getTop();
                }
                return null;
        }

        @Override
        public int getChildCount() {
                Object referent = lock();
                if (referent == null) {
                        return 0;
                }
                Access access = bindAccessForTreeObject(referent);
                final int count = access.getCompositeParamCount();
                return count;
        }

        @Override
        public boolean isLeaf() {
                Object referent = lock();
                if (referent == null) {
                        return true;
                }
                return bindAccessForTreeObject(referent).getCompositeParamCount() == 0;
        }

        protected Access bindAccessForTreeObject(Object child) {
                return bindAccessFromSideNote(getTree(), child);
        }

        @Override
        public void render(TreeCellRenderer renderer) {

                Object child = lock();
                if (child == null) {
                        renderer.setToolTipText("?");
                        renderer.setText("?");
                        renderer.setIcon(ImageProvider.loadImage(ImageProvider.FOLDER_CLOSED));
                        return;
                }
                Access access = bindAccessForTreeObject(child);
                CompositeParam param = getTree().getSideNote(child, CompositeParam.class, CompositeParam.class);
                String name = param.getId();

                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("size", access.getCompositeParamCount())
                                .build());

                renderer.setIcon(ImageProvider.loadImage(TreeCellRenderer.findIconName(param)));
                renderer.setText(name);
        }

        // public static class Textual {
        // }

        public String getTextual() {
                return textual;
                // return getTree().getSideNote(lock(), Textual.class, String.class);
        }

        protected final Object listenersTag = new Object();

        public List<EventListener<?>> getListeners() {
                @SuppressWarnings("unchecked")
                List<EventListener<?>> result = getTree().getSideNote(lock(), listenersTag, List.class);
                if (result == null) {
                        result = new LinkedList<>();
                        getTree().putSideNote(lock(), listenersTag, result);
                }

                return result;
        }

        protected <A> void tryAddListener(final Path path, final EventParam eventParam, Class<A> argumentType, final EventListener<A> listener) {
                getTree().addListener(path, eventParam, listener, argumentType, new FutureHandler<Void>(getFrame()) {
                        @Override
                        protected void result(Void result) {
                                assert getFrame().isActive();
                                log.debug("registered gui listener for {} at {}", eventParam, path);
                                getListeners().add(listener);
                        }
                });
        }

        @Override
        public TreePanel getPanel() {
                if (panel != null) {
                        return panel;
                }
                panel = getTreeAtFrame().preparePanel(param);
                return panel;
        }

}