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

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.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

import com.framsticks.core.Path;
import com.framsticks.core.Tree;
import com.framsticks.gui.tree.AbstractNode;
import com.framsticks.gui.tree.MetaNode;
import com.framsticks.gui.tree.TreeCellRenderer;
import com.framsticks.gui.tree.TreeModel;
import com.framsticks.gui.tree.TreeNode;
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.lang.Casting;
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 = LogManager.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 EmptyPanel emptyPanel;

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

                cardPanel = new JPanel();
                cardPanel.setName("card");

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

                emptyPanel = new EmptyPanel(this);

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

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

                rootNode = new MetaNode(this);
                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) {
                                treeModel.chooseTreeNode(e.getNewLeadSelectionPath());
                        }
                });

                jtree.addTreeExpansionListener(new TreeExpansionListener() {

                        @Override
                        public void treeCollapsed(TreeExpansionEvent e) {

                        }

                        @Override
                        public void treeExpanded(TreeExpansionEvent e) {
                                treeModel.expandTreeNode(e.getPath());
                        }
                });

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

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

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


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

                                treeModel.loadPath(treeModel.convertToPath(jtree.getSelectionPath()), true);
                        }
                });

        }

        protected JPanel createLeftTopPanel() {
                return null;
        }

        public void addRootPath(final Path path) {
                assert isActive();

                Tree tree = path.getTree();

                log.debug("trying mount: {}", path);
                if (!tree.getAssignedRoot().isResolved()) {
                        tree.get(path, 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);
                Path rootPath = Path.to(tree, "/");

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


        public void showPanel(AbstractPanel panel) {
                assert isActive();
                assert panel != null;
                log.debug("showing panel: {}", panel);
                cardPanelLayout.show(cardPanel, panel.getUniqueName());

                // cardPanel.revalidate();
        }


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

                Path path = treeModel.convertToPath(treePath);
                if (path == null) {
                        return;
                }
                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 updatePanelIfIsLeadSelection(Path path) {
                assert isActive();
                TreePath treePath = treeModel.convertToTreePath(path, true);
                if (treePath == null) {
                        return;
                }
                if (treePath.equals(jtree.getSelectionPath())) {
                        log.debug("updating: {} -> {}", treePath, path);
                        showPanelForTreePath(treePath);
                }
        }

        public void showPanelForTreePath(TreePath treePath) {
                assert isActive();
                AbstractNode node = Casting.assertCast(AbstractNode.class, treePath.getLastPathComponent());

                AbstractPanel panel = node.getPanel();
                if (panel == null) {
                        log.error("no panel for {} found", treePath);
                        return;
                }
                panel.fillPanelWith(node);
                showPanel(panel);
                // cardPanel.revalidate();
        }



        // public void goTo(Path path) {
        //      assert isActive();
        //      final TreePath treePath = treeModel.convertToTreePath(path);

        //      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 jtree
         */
        public JTree getJtree() {
                return jtree;
        }

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

        /**
         * @return the rootNode
         */
        public MetaNode getRootNode() {
                return rootNode;
        }

        /**
         * @return the emptyPanel
         */
        public EmptyPanel getEmptyPanel() {
                return emptyPanel;
        }

        /**
         * @return the treeAtFrames
         */
        public Map<Tree, TreeAtFrame> getTreeAtFrames() {
                return treeAtFrames;
        }

}