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

package com.framsticks.gui;

import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.IdentityHashMap;
import java.util.Map;

import javax.swing.AbstractAction;
import javax.swing.BorderFactory;
import javax.swing.JComponent;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTree;
import javax.swing.KeyStroke;
import javax.swing.ToolTipManager;
import javax.swing.UIManager;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultTreeSelectionModel;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

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.params.AccessInterface;
import com.framsticks.util.dispatching.Dispatching;
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.swing.KeyboardModifier;
import com.framsticks.util.swing.MenuConstructor;

/**
 * @author Piotr Sniegowski
 */
@SuppressWarnings("serial")
public class Frame extends FrameJoinable implements JoinableParent {

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

        protected final Browser browser;

        protected final Dimension screenDimension = Toolkit.getDefaultToolkit().getScreenSize();

        protected CardLayout cardPanelLayout;
        protected JPanel cardPanel;

        protected JScrollPane treeScrollPane;
        protected JTree jtree;
        protected TreeModel treeModel;

        protected MetaNode rootNode;

        protected JPanel treePanel;
        protected JPopupMenu treePopupMenu;
        protected JMenuItem treePopupMenuHeader;

        protected JPanel mainPanel;
        protected JPanel leftPanel;
        protected JPanel normalWorkPanel;
        protected CardLayout mainPanelLayout;

        protected JMenuBar menuBar;
        protected JMenu fileMenu;
        protected JMenu editMenu;
        protected JMenu viewMenu;
        protected JMenu windowMenu;
        protected JMenu helpMenu;

        protected final Map<Tree, TreeAtFrame> treeAtFrames = new IdentityHashMap<>();
        protected JoinableCollection<Tree> trees = new JoinableCollection<>();

        public Frame(Browser browser) {
                this.browser = browser;
        }

        protected void initializeGui() {
                super.initializeGui();
                /** this is done to remove the current value label from above the slider,
                 * because it cannot put to work properly with floating-point value sliders,
                 * nor it can be removed in normal way through JSlider methods  */
                UIManager.put("Slider.paintValue", false);
                log.debug("creating " + this);

                Container contentPane = getSwing().getContentPane();
                treePopupMenu = new JPopupMenu("title");
                treePopupMenu.setName("popup");

                treePanel = new JPanel();
                treePanel.setLayout(new BorderLayout());

                rootNode = new MetaNode();
                rootNode.setName("root");
                treeModel = new TreeModel(this);

                jtree = new JTree(treeModel);
                jtree.setName("tree");
                jtree.setRootVisible(false);
                jtree.setExpandsSelectedPaths(true);
                jtree.setSelectionModel(new DefaultTreeSelectionModel());
                ToolTipManager.sharedInstance().registerComponent(jtree);

                jtree.addTreeSelectionListener(new TreeSelectionListener() {
                        @Override
                        public void valueChanged(TreeSelectionEvent e) {
                                chooseTreeNode(e.getNewLeadSelectionPath());
                        }
                });

                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.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
                jtree.setShowsRootHandles(true);
                jtree.setRowHeight(26);
                jtree.setDoubleBuffered(true);
                jtree.addMouseListener(new MouseAdapter() {
                        @Override
                        public void mousePressed(MouseEvent e) {
                                assert isActive();
                                showPopup(e);
                        }

                        @Override
                        public void mouseReleased(MouseEvent e) {
                                assert isActive();
                                showPopup(e);
                        }
                });

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

                treeScrollPane = new JScrollPane(jtree);
                treeScrollPane.setBorder(BorderFactory.createEmptyBorder());

                treePanel.add(treeScrollPane);


                normalWorkPanel = new JPanel();
                normalWorkPanel.setLayout(new BorderLayout());
                normalWorkPanel.setName("browser");

                mainPanel = new JPanel();
                mainPanel.setName("main");
                mainPanelLayout = new CardLayout();
                mainPanel.setLayout(mainPanelLayout);
                mainPanel.add(normalWorkPanel, "browser");

                menuBar = new JMenuBar();

                fileMenu = menuBar.add(new JMenu("File"));
                editMenu = menuBar.add(new JMenu("Edit"));
                viewMenu = menuBar.add(new JMenu("View"));
                windowMenu = menuBar.add(new JMenu("Window"));
                helpMenu = menuBar.add(new JMenu("Help"));

                contentPane.add(menuBar, BorderLayout.NORTH);
                contentPane.add(mainPanel, BorderLayout.CENTER);

                leftPanel = new JPanel();
                leftPanel.setLayout(new BorderLayout());
                //leftPanel.add(new ViewerTest(), BorderLayout.PAGE_START);
                //        JPanel leftTopPanel = createLeftTopPanel();
                //        if (leftTopPanel != null) {
                //            leftPanel.add(leftTopPanel, BorderLayout.PAGE_START);
                //        }
                leftPanel.add(treePanel, BorderLayout.CENTER);
                leftPanel.setBackground(Color.WHITE);
                leftPanel.setForeground(Color.WHITE);

                cardPanel = new JPanel();
                cardPanel.setName("card");
                JSplitPane split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftPanel, cardPanel);
                split.setPreferredSize(browser.defaultFrameDimension);
                split.setMaximumSize(screenDimension);
                split.setOneTouchExpandable(true);
                split.setDividerLocation(250);
                split.setDividerSize(5);
                split.setName("split");

                normalWorkPanel.add(split);

                //this.setVisible(true);
                mainPanelLayout.show(mainPanel, "browser");

                cardPanelLayout = new CardLayout();
                cardPanel.setLayout(cardPanelLayout);

                getSwing().pack();
                jtree.requestFocusInWindow();

                log.debug("frame configured: " + this);

                new MenuConstructor(fileMenu).add(KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK), new AbstractAction("Close") {
                        @Override
                        public void actionPerformed(ActionEvent actionEvent) {
                                interrupt();
                        }
                });

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

        }

        protected JPanel createLeftTopPanel() {
                return null;
        }

        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);
                treeAtFrames.put(tree, e);

                rootNode.getChildren().add(new TreeNode(tree.getAssignedRoot()));
                e.rootNode = tree.getAssignedRoot();
                treeModel.nodeStructureChanged(new TreePath(rootNode));
                // jtree.expandPath(new TreePath(rootNode));
        }


        public void showPanel(Panel panel) {
                assert isActive();
                assert panel != null;
                cardPanelLayout.show(cardPanel, panel.getUniqueName());
        }


        private void showPopup(MouseEvent e) {
                assert isActive();
                if (!e.isPopupTrigger()) {
                        return;
                }
                TreePath treePath = jtree.getPathForLocation(e.getX(), e.getY());

                Path path = treeModel.convertToPath(treePath);
                treePopupMenu.removeAll();

                for (PopupMenuEntryProvider provider : browser.popupMenuEntryProviders) {
                        provider.provide(treePopupMenu, path);
                }
                treePopupMenu.show(e.getComponent(), e.getX(), e.getY());
        }

        public void clear() {
                cardPanel.removeAll();
                cardPanel.updateUI();
                jtree.setEnabled(false);
        }

        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;
                }
                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
        public String toString() {
                return title + "@" + browser.getName();
        }

        @Override
        protected void joinableStart() {
                super.joinableStart();
                Dispatching.use(trees, this);
        }

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

        @Override
        protected void joinableFinish() {
                super.joinableFinish();
        }

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

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

        /**
         * @return the treeModel
         */
        public TreeModel getTreeModel() {
                return treeModel;
        }

}