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

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.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 SwingDispatcher

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

                // mainFrame.getStatusBar().setExceptionHandler(ThrowExceptionHandler.getInstance());

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

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

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




}