Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.swing.impl;

import java.awt.Color;

import java.awt.Component;

import java.awt.Graphics;

import java.awt.GridLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.KeyEvent;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import javax.swing.AbstractAction;

import javax.swing.Icon;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTree;

import javax.swing.KeyStroke;

import javax.swing.UIManager;

import javax.swing.event.TreeModelEvent;

import javax.swing.event.TreeModelListener;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.event.TreeSelectionListener;

import javax.swing.tree.TreeCellRenderer;

import javax.swing.tree.TreeModel;

import javax.swing.tree.TreePath;

import javax.swing.tree.TreeSelectionModel;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.scripting.ScriptingUnit;

import org.gvsig.scripting.swing.api.JScriptingBrowser;

import org.gvsig.scripting.swing.api.ScriptingUIManager;

import org.slf4j.LoggerFactory;

import org.slf4j.Logger;

public class DefaultJScriptingBrowser extends JPanel implements JScriptingBrowser {

    private static final Logger logger = LoggerFactory.getLogger(DefaultJScriptingBrowser.class);

    private static final long serialVersionUID = 3140698910497806258L;

    protected ScriptingUIManager uimanager;

    protected ScriptingManager manager;

    protected TreeModel treeModel;

    protected JTree tree;

    protected ScriptingFolder root;

    protected ActionListener defaultActionlistener = null;

    protected ActionListener selectionActionlistener = null;

    private final boolean foldersOnly;

    public static class DefaultBrowserActionEvent extends ActionEvent implements BrowserActionEvent {

        /**

         *

         */

        private static final long serialVersionUID = -1474410768278633364L;

        private ScriptingUnit unit = null;

        public DefaultBrowserActionEvent(Object source, int id, String command,

                ScriptingUnit unit) {

            super(source, id, command);

            this.unit = unit;

        }

        @Override

        public ScriptingUnit getUnit() {

            return this.unit;

        }

    }

    class ScriptingFolderTreeModel implements TreeModel {

        protected final ScriptingFolder root;

        protected final List<TreeModelListener> listeners = new ArrayList();

        public ScriptingFolderTreeModel(ScriptingFolder root) {

            this.root = root;

        }

        @Override

        public Object getRoot() {

            return root;

        }

        @Override

        public Object getChild(Object parent, int index) {

            ScriptingFolder folder = (ScriptingFolder) parent;

            List<ScriptingUnit> children = folder.getUnits();

            return children.get(index);

        }

        @Override

        public int getChildCount(Object parent) {

            if (!(parent instanceof ScriptingFolder)) {

                return 0;

            }

            ScriptingFolder folder = (ScriptingFolder) parent;

            return folder.getUnits().size();

        }

        @Override

        public boolean isLeaf(Object node) {

            return !(node instanceof ScriptingFolder);

        }

        @Override

        public int getIndexOfChild(Object parent, Object child) {

            String childPath = ((ScriptingUnit) child).getFile().getAbsolutePath();

            ScriptingFolder folder = (ScriptingFolder) parent;

            List<ScriptingUnit> children = folder.getUnits();

            for (int i = 0; i < children.size(); i++) {

                ScriptingUnit aChild = children.get(i);

                if (aChild.getFile().getAbsolutePath().equals(childPath)) {

                    return i;

                }

            }

            return -1;

        }

        @Override

        public void valueForPathChanged(TreePath path, Object value) {

        }

        @Override

        public void addTreeModelListener(TreeModelListener listener) {

            listeners.add(listener);

        }

        @Override

        public void removeTreeModelListener(TreeModelListener listener) {

            listeners.remove(listener);

        }

        public void reload() {

            TreeModelEvent event = new TreeModelEvent(this, new TreePath(this.root));

            Iterator<TreeModelListener> iterator = listeners.iterator();

            TreeModelListener listener;

            while (iterator.hasNext()) {

                listener = iterator.next();

                listener.treeStructureChanged(event);

            }

        }

    }

    class ScriptingFolderTreeModelFoldersOnly extends ScriptingFolderTreeModel {

        public ScriptingFolderTreeModelFoldersOnly(ScriptingFolder root) {

            super(root);

        }

        @Override

        public Object getChild(Object parent, int index) {

            ScriptingFolder folder = (ScriptingFolder) parent;

            List<ScriptingFolder> children = folder.getUnitFolders();

            return children.get(index);

        }

        @Override

        public int getChildCount(Object parent) {

            if (!(parent instanceof ScriptingFolder)) {

                return 0;

            }

            ScriptingFolder folder = (ScriptingFolder) parent;

            return folder.getUnitFolders().size();

        }

        @Override

        public int getIndexOfChild(Object parent, Object child) {

            String childPath = ((ScriptingFolder) child).getFile().getAbsolutePath();

            ScriptingFolder folder = (ScriptingFolder) parent;

            List<ScriptingFolder> children = folder.getUnitFolders();

            for (int i = 0; i < children.size(); i++) {

                ScriptingUnit aChild = children.get(i);

                if (aChild.getFile().getAbsolutePath().equals(childPath)) {

                    return i;

                }

            }

            return -1;

        }

    }

    public DefaultJScriptingBrowser(ScriptingUIManager uimanager,

            ScriptingFolder root) {

        this(uimanager, root, false);

    }

    public DefaultJScriptingBrowser(ScriptingUIManager uimanager,

            ScriptingFolder root, boolean foldersOnly) {

        super(new GridLayout(1, 2));

        this.foldersOnly = foldersOnly;

        this.uimanager = uimanager;

        this.manager = uimanager.getManager();

        this.root = root;

        this.makeUI();

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    public void refresh() {

        Enumeration<TreePath> x = tree.getExpandedDescendants(new TreePath(treeModel.getRoot()));

        ((ScriptingFolderTreeModel) this.treeModel).reload();

        if (x != null) {

            while (x.hasMoreElements()) {

                try {

                    TreePath treePath = (TreePath) x.nextElement();

                    tree.expandPath(treePath);

                } catch(Throwable th) {

                }

            }

        }        

    }

    @Override

    public ScriptingManager getManager() {

        return this.manager;

    }

    @Override

    public ScriptingFolder getRoot() {

        return this.root;

    }

    @Override

    public void addDefaultActionListener(ActionListener actionlistener) {

        this.defaultActionlistener = actionlistener;

    }

    @Override

    public void addSelectionActionListener(ActionListener actionlistener) {

        this.selectionActionlistener = actionlistener;

    }

    private void makeUI() {

        if (this.foldersOnly) {

            treeModel = new ScriptingFolderTreeModelFoldersOnly(root);

        } else {

            treeModel = new ScriptingFolderTreeModel(root);

        }

        tree = new JTree(treeModel);

        tree.setCellRenderer(new IconCellRenderer());

        tree.setEditable(false);

        tree.setShowsRootHandles(true);

        tree.getSelectionModel().setSelectionMode(

                TreeSelectionModel.SINGLE_TREE_SELECTION);

        tree.addTreeSelectionListener(new TreeSelectionListener() {

            @Override

            public void valueChanged(TreeSelectionEvent e) {

                if (selectionActionlistener != null) {

                    JComponent tree = (JComponent) e.getSource();

                    ActionEvent event = new DefaultBrowserActionEvent(

                            tree.getParent(),

                            SELECTION_ACTION,

                            "select",

                            null

                    );

                    selectionActionlistener.actionPerformed(event);

                }

            }

        });

        tree.addMouseListener(new MouseListener() {

            @Override

            public void mouseClicked(MouseEvent arg0) {

                if (arg0.getClickCount() == 2) {

                    JTree tree = (JTree) arg0.getSource();

                    if (!tree.isSelectionEmpty()) {

                        fireDefaultAction(tree.getSelectionPath());

                    }

                }

            }

            @Override

            public void mouseEntered(MouseEvent arg0) {

            }

            @Override

            public void mouseExited(MouseEvent arg0) {

            }

            @Override

            public void mousePressed(MouseEvent arg0) {

            }

            @Override

            public void mouseReleased(MouseEvent arg0) {

            }

        });

        tree.getActionMap().put(

                KeyStroke.getKeyStroke("+"),

                new ExpandSelectedNodeAction()

        );

        tree.getActionMap().put(

                KeyStroke.getKeyStroke("SPACE"),

                new ExpandSelectedNodeAction()

        );

        tree.getActionMap().put(

                KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0),

                new EnterAction()

        );

        JScrollPane scrollPane = new JScrollPane(tree);

        add(scrollPane);

    }

    @Override

    public TreePath getSelectionPath() {

        return this.tree.getSelectionPath();

    }

    @Override

    public void setSelectionPath(TreePath path) {

        if( path == null ) {

            this.tree.clearSelection();

        } else {

            this.tree.setSelectionPath(path);

        }

    }

    @Override

    public ScriptingUnit getSelectedNode() {

        ScriptingUnit unit;

        if (tree.getSelectionPath() != null) {

            unit = (ScriptingUnit) tree.getSelectionPath().getLastPathComponent();

        } else {

            unit = (ScriptingUnit) this.treeModel.getRoot();

        }

        return unit;

    }

    private void fireDefaultAction(TreePath path) {

        ScriptingUnit unit = (ScriptingUnit) path.getLastPathComponent();

        //if (unit instanceof ScriptingBaseScript) {

            if (this.defaultActionlistener != null) {

                ActionEvent event = new DefaultBrowserActionEvent(

                        this,

                        DEFAULT_ACTION,

                        "default",

                        unit

                );

                this.defaultActionlistener.actionPerformed(event);

            }

        //}

    }

    private class EnterAction extends AbstractAction {

        private static final long serialVersionUID = -3673546098243190397L;

        @Override

        public void actionPerformed(ActionEvent ae) {

            TreePath selected = tree.getSelectionPath();

            fireDefaultAction(selected);

        }

    }

    private class ExpandSelectedNodeAction extends AbstractAction {

        private static final long serialVersionUID = -4121272513454221967L;

        @Override

        public void actionPerformed(ActionEvent ae) {

            try {

                TreePath selected = tree.getSelectionPath();

                if( tree.isCollapsed(selected) ) {

                    tree.expandPath(selected);

                } else {

                    tree.collapsePath(selected);

                }

            } catch(Throwable th) {

                // Do nothing, ignore errors

            }

        }

    }

    private class IconCellRenderer extends JLabel implements TreeCellRenderer {

        /**

         *

         */

        private static final long serialVersionUID = 1L;

        protected Color m_textSelectionColor;

        protected Color m_textNonSelectionColor;

        protected Color m_bkSelectionColor;

        protected Color m_bkNonSelectionColor;

        protected Color m_borderSelectionColor;

        protected boolean m_selected;

        public IconCellRenderer() {

            super();

            m_textSelectionColor = UIManager

                    .getColor("Tree.selectionForeground");

            m_textNonSelectionColor = UIManager.getColor("Tree.textForeground");

            m_bkSelectionColor = UIManager.getColor("Tree.selectionBackground");

            m_bkNonSelectionColor = UIManager.getColor("Tree.textBackground");

            m_borderSelectionColor = UIManager

                    .getColor("Tree.selectionBorderColor");

            setOpaque(false);

        }

        private final Map<String, ImageIcon> icons = new HashMap<>();

        private ImageIcon getIcon(String iconName) {

            ImageIcon img = this.icons.get(iconName);

            if (img == null) {

                img = uimanager.getIcon(iconName);

                this.icons.put(iconName, img);

            }

            return img;

        }

        private ImageIcon getExpandedIcon(ScriptingUnit unit) {

            return getIcon(unit.getIconNames()[1]);

        }

        private ImageIcon getCollapsedIcon(ScriptingUnit unit) {

            return getIcon(unit.getIconNames()[0]);

        }

        @Override

        public Component getTreeCellRendererComponent(JTree tree, Object value,

                boolean sel, boolean expanded, boolean leaf, int row,

                boolean hasFocus) {

            ScriptingUnit unit = (ScriptingUnit) value;

            setText(unit.getName());

            if (expanded) {

                setIcon(this.getExpandedIcon(unit));

            } else {

                setIcon(this.getCollapsedIcon(unit));

            }

            setFont(tree.getFont());

            setForeground(sel ? m_textSelectionColor : m_textNonSelectionColor);

            setBackground(sel ? m_bkSelectionColor : m_bkNonSelectionColor);

            m_selected = sel;

            return this;

        }

        @Override

        public void paintComponent(Graphics g) {

            Color bColor = getBackground();

            Icon icon = getIcon();

            g.setColor(bColor);

            int offset = 0;

            if (icon != null && getText() != null) {

                offset = (icon.getIconWidth() + getIconTextGap());

            }

            g.fillRect(offset, 0, getWidth() - 1 - offset, getHeight() - 1);

            if (m_selected) {

                g.setColor(m_borderSelectionColor);

                g.drawRect(offset, 0, getWidth() - 1 - offset, getHeight() - 1);

            }

            super.paintComponent(g);

        }

    }

}