source: java/main/src/main/java/com/framsticks/gui/Browser.java @ 97

package com.framsticks.gui;

import com.framsticks.core.*;
import com.framsticks.gui.console.Console;
import com.framsticks.gui.console.TrackConsole;
import com.framsticks.params.annotations.AutoAppendAnnotation;
import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.params.annotations.ParamAnnotation;
import com.framsticks.remote.RemoteTree;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.dispatching.AbstractJoinable;
import com.framsticks.util.dispatching.Dispatcher;
import com.framsticks.util.dispatching.Dispatching;
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;
import com.framsticks.util.dispatching.JoinableParent;
import com.framsticks.util.dispatching.JoinableState;

import javax.swing.*;

import org.apache.log4j.Logger;

import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.datatransfer.StringSelection;
import java.awt.event.ActionEvent;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import com.framsticks.util.dispatching.RunAt;

/**
 * @author Piotr Sniegowski
 */
@FramsClassAnnotation
public class Browser extends AbstractJoinable implements Dispatcher<Browser>, JoinableParent, ExceptionResultHandler {

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

        protected final JoinableCollection<Frame> frames = new JoinableCollection<Frame>().setObservableName("frames");
        protected final JoinableCollection<Tree> trees = new JoinableCollection<Tree>().setObservableName("trees");
        protected final JoinableCollection<Console> consoles = new JoinableCollection<Console>().setObservableName("consoles");

        protected final List<PopupMenuEntryProvider> popupMenuEntryProviders = new LinkedList<>();

        protected final MainFrame mainFrame;
        protected final List<PanelProvider> panelProviders = new ArrayList<PanelProvider>();
        protected Dimension defaultFrameDimension;

        String name;

        public void addFrame(Frame frame) {
                frames.add(frame);
        }

        public Browser() {
                setName("browser");
                JPopupMenu.setDefaultLightWeightPopupEnabled(false);
                addPanelProvider(new StandardPanelProvider());

                mainFrame = new MainFrame(Browser.this);
                addFrame(mainFrame);

                addPopupMenuEntryProvider(new PopupMenuEntryProvider() {
                        @Override
                        public void provide(JPopupMenu menu, Path path) {
                                menu.add(new JMenuItem(path.getFullTextual()));
                                menu.addSeparator();
                        }
                });

                addPopupMenuEntryProvider(new PopupMenuEntryProvider() {
                        @SuppressWarnings("serial")
                        @Override
                        public void provide(JPopupMenu menu, final Path path) {
                                menu.add(new AbstractAction("Copy path to clipboard") {
                                        @Override
                                        public void actionPerformed(ActionEvent e) {
                                                Toolkit.getDefaultToolkit().getSystemClipboard().setContents(new StringSelection(path.getFullTextual()), null);
                                        }
                                });
                        }
                });

                addPopupMenuEntryProvider(new PopupMenuEntryProvider() {
                        @SuppressWarnings("serial")
                        @Override
                        public void provide(JPopupMenu menu, final Path path) {
                                if (!(path.getTree() instanceof RemoteTree)) {
                                        return;
                                }
                                final RemoteTree remoteTree = (RemoteTree) path.getTree();
                                menu.add(new AbstractAction("Open tracking console") {
                                        @Override
                                        public void actionPerformed(ActionEvent e) {
                                                consoles.add(new TrackConsole().setConnection(remoteTree.getConnection()));
                                        }
                                });
                        }
                });
                // addNodeActionToTreePopupMenu("", new NodeAction() )

        }

        @AutoAppendAnnotation
        public void addPanelProvider(PanelProvider panelProvider) {
                log.debug("added panel provider of type: " + panelProvider.getClass().getCanonicalName());
                panelProviders.add(panelProvider);
        }

        @AutoAppendAnnotation
        public void addPopupMenuEntryProvider(PopupMenuEntryProvider popupMenuEntryProvider) {
                popupMenuEntryProviders.add(popupMenuEntryProvider);
        }

        @AutoAppendAnnotation
        public void addTree(Tree tree) {
                log.info("adding tree: " + 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);
                                                        }
                                                });
                                        }
                                });
                        }
                });
        }

        public void clear() {
                assert isActive();
                for (Frame f : frames) {
                        f.clear();
                }
        }

        public void createTreeNodeForChild(final Path path) {
                assert !isActive();
                //assert tree.isActive();

                /*
                 final TreeNode parentTreeNode = (TreeNode) child.getParent().getUserObject();
                 if (parentTreeNode == null) {
                 Dispatching.invokeDispatch(this, manager, new Runnable() {
                 @Override
                 public void run() {
                 createTreeNodeForChild(child);
                 }
                 });
                 return;
                 }
                 log.debug(child.getClass().getSimpleName() + " created: " + child);


                 invokeLater(new Runnable() {
                 @Override
                 public void run() {
                 parentTreeNode.getOrCreateChildTreeNodeFor(child);
                 }
                 });
                 */
        }

        @Override
        protected void joinableStart() {
                Dispatching.use(frames, this);
                Dispatching.use(trees, this);
                Dispatching.use(consoles, this);

                dispatch(new RunAt<Browser>(this) {
                        @Override
                        protected void runAt() {

                                for (final Tree i : trees) {
                                        i.dispatch(new RunAt<Tree>(this) {
                                                @Override
                                                protected void runAt() {
                                                        final Path p = Path.to(i, "/");
                                                        dispatch(new RunAt<Browser>(this) {
                                                                @Override
                                                                protected void runAt() {
                                                                        mainFrame.addRootPath(p);
                                                                }
                                                        });
                                                }
                                        });
                                }
                        }
                });
        }

        /**
         * @return the tree
         */
        public JoinableCollection<Tree> getTrees() {
                return trees;
        }

        /**
         * @return the mainFrame
         */
        public MainFrame getMainFrame() {
                return mainFrame;
        }

        /**
         * @return the name
         */
        @ParamAnnotation
        public String getName() {
                return name;
        }

        /**
         * @param name the name to set
         */
        @ParamAnnotation
        public void setName(String name) {
                this.name = name;
        }

        @Override
        public boolean isActive() {
                return SwingDispatcher.getInstance().isActive();
        }

        @Override
        public void dispatch(RunAt<? extends Browser> runnable) {
                SwingDispatcher.getInstance().dispatch(runnable);
        }

        @Override
        protected void joinableJoin() throws InterruptedException {
                Dispatching.join(frames);
                Dispatching.join(trees);
                Dispatching.join(consoles);
                // super.join();
        }

        @Override
        protected void joinableInterrupt() {
                Dispatching.drop(consoles, this);
                Dispatching.drop(frames, this);
                Dispatching.drop(trees, this);
        }

        @Override
        public void childChangedState(Joinable joinable, JoinableState state) {
                if (joinable == frames) {
                        proceedToState(state);
                }

        }

        @Override
        protected void joinableFinish() {

        }

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

        @Override
        public void handle(FramsticksException exception) {
                mainFrame.handle(exception);
        }

        // @Override
        // public boolean isDone() {
        //      return frames.isDone() && trees.isDone();
        // }
}