InspectorNavigator.java

package net.squiz.matrix.inspector;

import net.squiz.matrix.matrixtree.*;
import net.squiz.matrix.core.*;
import net.squiz.matrix.ui.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.tree.*;
import java.util.List;
import java.util.ArrayList;

class InspectorNavigator extends JPanel {

    private JButton backBtn;
    private JButton forwardBtn;
    private ButtonMenu showPathBtn;
    private InspectorGadget inspector;
    private TreePath current;
    private List backPath = new ArrayList();
    private List forwardPath = new ArrayList();

    //{{{ Public Methods

    public InspectorNavigator(InspectorGadget inspector/*, TreePath current*/) {
        this.inspector = inspector;
        setBackground(UIManager.getColor("InspectorNavigator.background"));
        setLayout(new FlowLayout(FlowLayout.LEADING));
        init();
    }

    public void setCurrentPath(TreePath currentPath) {
        current = currentPath;
    }

    public void setBackPath(TreePath path) {
        if (current != null) backPath.add(current);
        current = path;
        forwardPath.clear();
        updateBackForward();
    }

    public void updateBackForward() {
        if (backPath.size() == 0) backBtn.setEnabled(false);
        else backBtn.setEnabled(true);
        if (forwardPath.size() == 0) forwardBtn.setEnabled(false);
        else forwardBtn.setEnabled(true);
        if (current.getPathCount() < 2)
            showPathBtn.setEnabled(false);
        else showPathBtn.setEnabled(true);

        Object[] treePathObjects = new Object[current.getPathCount() - 1];
        for (int k = 1; k < current.getPathCount(); k++) {
        treePathObjects[k-1] = current.getPathComponent(k);
        }

        showPathBtn.setToolTipText(convertPathToString(new TreePath(treePathObjects)));
    }

    public void disablePanel() {
        forwardBtn.setEnabled(false);
        backBtn.setEnabled(false);
        showPathBtn.setEnabled(false);
    }

    //}}}

    //{{{ Protected Methods
    //}}}

    //{{{ Package Private Methods
    //}}}

    //{{{ Private Methods

    private void init() {
        setSize(240, 40);
        setBackground(UIManager.getColor("InspectorNavigator.background"));

        ActionListener btnListener = new ButtonActionListener();

        backBtn     = (JButton) createButton("back", btnListener, "Back", false);
        forwardBtn  = (JButton) createButton("forward", btnListener, "Forward", false);
        showPathBtn = (ButtonMenu) createButton("show_path", btnListener, "Show Path", true);

        add(backBtn);
        add(forwardBtn);
        add(showPathBtn);

        disablePanel();
    }

    private AbstractButton createButton(
            String iconName,
            ActionListener listener,
            String toolTipText,
            boolean buttonMenu) {

        Icon icon = GUIUtilities.getAssetMapIcon(iconName + ".png");
        Icon disabledIcon = GUIUtilities.getAssetMapIcon(iconName + "_disabled.png");
        Icon pressedIcon = GUIUtilities.getAssetMapIcon(iconName + "_on.png");

        AbstractButton button = null;
        if (buttonMenu)
            button = new ButtonMenu(icon, pressedIcon);
        else
            button = new JButton(icon);

        button.setDisabledIcon(disabledIcon);
        button.setPressedIcon(pressedIcon);
        button.setBorderPainted(false);

        button.setPreferredSize(new Dimension(icon.getIconWidth(), icon.getIconHeight()));

        button.addActionListener(listener);
        button.setToolTipText(toolTipText);

        return button;
    }

    private void navigateBack() {
        int backLastIndex = backPath.size() - 1;
        TreePath oldPath = (TreePath) backPath.get(backLastIndex);
        inspector.populateInspector(oldPath);
        forwardPath.add(current);
        current = oldPath;
        backPath.remove(backLastIndex);
        updateBackForward();
    }

    private void navigateNext() {
        int forwardLastIndex = forwardPath.size() - 1;
        TreePath oldPath = (TreePath) forwardPath.get(forwardLastIndex);
        inspector.populateInspector(oldPath);
        backPath.add(current);
        current = oldPath;
        forwardPath.remove(forwardLastIndex);
        updateBackForward();
    }

    private String convertPathToString(TreePath path) {
        return convertPathToString(path.getPath());
    }

    private String convertPathToString(Object[] nodes) {
        String pathStr = "";

        for (int i = 0; i < nodes.length; i++) {
            pathStr = pathStr + ((MatrixTreeNode) nodes[i]).getName();
            if (i != nodes.length - 1)
                pathStr = pathStr + " > ";
        }
        return pathStr;
    }

    //}}}

    //{{{ Protected Inner Classes
    //}}}

    //{{{ Inner Classes

    class ButtonActionListener implements ActionListener {

        private boolean isVisible = false;
        private JPopupMenu menu;
        public void actionPerformed(ActionEvent evt) {
            Object source = evt.getSource();

            if (source == backBtn) navigateBack();
            else if (source == forwardBtn) navigateNext();
            else if (source == showPathBtn) {
                showPathBtn.setPopupMenu(getMenu());
            }
        }

        private JPopupMenu getMenu() {
            JPopupMenu menu = new JPopupMenu();

            ActionListener matrixListener = new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    MatrixTreeNode rootNode
                        = (MatrixTreeNode) AssetManager.getRootFolderNode();
                    TreePath rootPath = inspector.getTree().getPathToRoot(rootNode);
                    inspector.populateInspector(rootPath);
                    setBackPath(rootPath);
                }
            };

            JMenuItem matrixItem = new JMenuItem("My Matrix System");
            matrixItem.addActionListener(matrixListener);
            menu.add(matrixItem);

            if (current.getPathCount() > 1) menu.addSeparator();

            for (int i = 1; i < current.getPathCount(); i++) {
                final TreePath path = inspector.getTree().getPathToRoot(
                    (MatrixTreeNode) current.getPathComponent(i));

                Object[] treePathObjects = new Object[path.getPathCount() - 1];
                for (int k = 1; k < path.getPathCount(); k++)
                    treePathObjects[k - 1] = path.getPathComponent(k);

                String pathStr = convertPathToString(treePathObjects);
                ActionListener pathListener = new ActionListener() {
                    public void actionPerformed(ActionEvent evt) {
                        inspector.populateInspector(path);
                        setBackPath(path);
                    }
                };

                MatrixTreeNode node = (MatrixTreeNode) path.getLastPathComponent();
                Icon icon = node.getAsset().getType().getIcon();
                JMenuItem pathItem = new JMenuItem(pathStr);
                pathItem.addActionListener(pathListener);
                pathItem.setIcon(icon);

                menu.add(pathItem);
            }

            return menu;
        }

    }//end class ButtonActionListener

    //}}}

}//end class InspectorNavigator