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.MouseEvent;

import java.awt.event.MouseListener;

import java.io.File;

import java.util.List;

import javax.swing.Icon;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JScrollPane;

import javax.swing.JTree;

import javax.swing.UIManager;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.event.TreeSelectionListener;

import javax.swing.tree.DefaultMutableTreeNode;

import javax.swing.tree.DefaultTreeModel;

import javax.swing.tree.TreeCellRenderer;

import javax.swing.tree.TreePath;

import javax.swing.tree.TreeSelectionModel;

import org.gvsig.scripting.ScriptingBaseScript;

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

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

        public static final int DEFAULT_ACTION = 1;

        public static final int SELECTION_ACTION = 2;

        public static final int DROPDOWN_ACTION = 3;

        /**

         * 

         */

        private static final long serialVersionUID = 1L;

        protected ScriptingUIManager uimanager;

        protected ScriptingManager manager;

        protected DefaultMutableTreeNode rootNode;

        protected DefaultTreeModel treeModel;

        protected JTree tree;

        protected ScriptingFolder root;

        protected ActionListener defaultActionlistener = null;

        protected ActionListener selectionActionlistener = null;

        protected ActionListener dropDownActionlistener = null;

        private final boolean foldersOnly;

        public static class BrowserActionEvent extends ActionEvent {

                /**

                 * 

                 */

                private static final long serialVersionUID = -1474410768278633364L;

                private ScriptingBaseScript script = null;

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

                                ScriptingBaseScript script) {

                        super(source, id, command);

                        this.script = script;

                }

                public ScriptingBaseScript getScript() {

                        return this.script;

                }

        }

        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 ScriptingManager getManager() {

                return this.manager;

        }

        @Override

        public ScriptingFolder getRoot() {

                return this.root;

        }

        public void addDefaultActionListener(ActionListener actionlistener) {

                this.defaultActionlistener = actionlistener;

        }

        public void addSelectionActionListener(ActionListener actionlistener) {

                this.selectionActionlistener = actionlistener;

        }

        public void addDropDownActionListener(ActionListener actionlistener) {

                this.dropDownActionlistener = actionlistener;

        }

        private void makeUI() {

                // Creamos el nodo raíz

                String[] iconNames = root.getIconNames();

                rootNode = new DefaultMutableTreeNode(new IconData(

                                this.uimanager.getIcon(iconNames[0]),

                                this.uimanager.getIcon(iconNames[1]), root));

                // Lo asignamos al modelo del árbol e iniciamos el árbol con ese

                // modelo

                treeModel = new DefaultTreeModel(rootNode);

                tree = new JTree(treeModel);

                // Cargamos la información inicial del árbol

                this.initializeTree();

                // Para asignar iconos especiales según el tipo de objeto

                TreeCellRenderer renderer = new IconCellRenderer();

                tree.setCellRenderer(renderer);

                // Para marcar que no son editables sus propiedades o nodos

                tree.setEditable(false);

                // Determina que sólo se puede seleccionar una linea

                tree.getSelectionModel().setSelectionMode(

                                TreeSelectionModel.SINGLE_TREE_SELECTION);

                // Añadimos un listener que se ejecutará cuando seleccionemos un

                // elemento del árbol

                tree.addTreeSelectionListener(new TreeSelectionListener() {

                        public void valueChanged(TreeSelectionEvent e) {

                                loadChildrenLazily(e.getPath());

                                if (selectionActionlistener != null) {

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

                                        ActionEvent event = new BrowserActionEvent(

                                                        tree.getParent(), SELECTION_ACTION, "select", null);

                                        selectionActionlistener.actionPerformed(event);

                                }

                        }

                });

                tree.addMouseListener(new MouseListener() {

                        public void mouseClicked(MouseEvent arg0) {

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

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

                                        if (!tree.isSelectionEmpty()) {

                                                startingScript(tree.getSelectionPath());

                                        }

                                }

                        }

                        public void mouseEntered(MouseEvent arg0) {

                        }

                        public void mouseExited(MouseEvent arg0) {

                        }

                        public void mousePressed(MouseEvent arg0) {

                        }

                        public void mouseReleased(MouseEvent arg0) {

                        }

                });

                // Indica si el nodo raíz actúa como un nodo más o queda desplegado

                // de manera fija

                tree.setShowsRootHandles(true);

                // Añadimos el Scroll

                JScrollPane scrollPane = new JScrollPane(tree);

                add(scrollPane);

        }

        @Override

        public ScriptingUnit getSelectedNode() {

                DefaultMutableTreeNode node;

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

                        node = (DefaultMutableTreeNode) tree.getSelectionPath()

                                        .getLastPathComponent();

                } else {

                        node = this.rootNode;

                }

                return ((ScriptingUnit) ((IconData) (node.getUserObject())).m_data);

        }

        private void startingScript(TreePath path) {

                DefaultMutableTreeNode node = (DefaultMutableTreeNode) path

                                .getLastPathComponent();

                ScriptingUnit unit = ((ScriptingUnit) ((IconData) (node.getUserObject())).m_data);

                if (unit instanceof ScriptingBaseScript) {

                        if (this.defaultActionlistener != null) {

                                ActionEvent event = new BrowserActionEvent(this,

                                                DEFAULT_ACTION, "default", (ScriptingBaseScript) unit);

                                this.defaultActionlistener.actionPerformed(event);

                        }

                }

        }

        /**

         * Función para el despliegue de los hijos de un nodo bajo demanda.

         **/

        private void loadChildrenLazily(TreePath path) {

                // Mediante el path recuperamos el último nodo, del que

                // queremos obtener sus hijos dinámicamente

                DefaultMutableTreeNode node = (DefaultMutableTreeNode) path

                                .getLastPathComponent();

                ScriptingUnit unit = ((ScriptingUnit) ((IconData) (node.getUserObject())).m_data);

                List<ScriptingUnit> files = null;

                // Si es un ScriptingFolder y no hemos obtenido previamente sus hijos

                if (unit instanceof ScriptingFolder && node.getChildCount() == 0) {

                        // Obtenemos los hijos

                        files = ((ScriptingFolder) unit).getUnits();

                        ScriptingUnit subunit = null;

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

                                subunit = files.get(i);

                                if ((this.foldersOnly && subunit instanceof ScriptingFolder)

                                                || !this.foldersOnly) {

                                        // Obtenemos los iconos específicos para ese tipo de objeto

                                        String[] iconNames = subunit.getIconNames();

                                        // Creamos el objeto IconData, con la información

                                        // del objeto y de hasta 2 iconos asociados

                                        IconData data = new IconData(

                                                        this.uimanager.getIcon(iconNames[0]),

                                                        this.uimanager.getIcon(iconNames[1]), subunit);

                                        // Insertamos en el árbol el nuevo objeto creado

                                        addObject(node, data);

                                }

                        }

                }

        }

        /**

         * Función para la inicialización de los datos del árbol.

         **/

        private void initializeTree() {

                ScriptingUnit unit = null;

                List<ScriptingUnit> files = this.root.getUnits();

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

                        unit = files.get(i);

                        String fname_unit = "(unknow)";

                        try {

                                fname_unit = unit.getFile().getAbsolutePath();

                                if ((this.foldersOnly && unit instanceof ScriptingFolder)

                                                || !this.foldersOnly) {

                                        String[] iconNames = unit.getIconNames();

                                        IconData data = new IconData(

                                                        uimanager.getIcon(iconNames[0]),

                                                        uimanager.getIcon(iconNames[1]), unit);

                                        // Insertamos en el nodo raiz del arbol

                                        this.addObject(this.rootNode, data);

                                }

                        } catch (Exception ex) {

                                logger.warn("Can't add script unit '"+fname_unit+"' to the tree.", ex);

                        }

                }

        }

        /**

         * Función para añadir un hijo al nodo actual.

         **/

        // private DefaultMutableTreeNode addObject(Object child) {

        // DefaultMutableTreeNode parentNode = rootNode;

        // return addObject(parentNode, child, true);

        // }

        private DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent,

                        Object child) {

                return addObject(parent, child, false);

        }

        private DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent,

                        Object child, boolean shouldBeVisible) {

                DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child);

                // Si no especificamos padre, lo colgará del raíz

                if (parent == null) {

                        parent = rootNode;

                }

                // Insertamos el nuevo nodo en el modelo del árbol

                treeModel.insertNodeInto(childNode, parent, parent.getChildCount());

                // Para que el usuario pueda ver el nuevo nodo

                if (shouldBeVisible) {

                        tree.scrollPathToVisible(new TreePath(childNode.getPath()));

                }

                return childNode;

        }

        /**

         * Clase IconData permite asociar hasta dos iconos (para cuando está

         * expandido y cuando no) a un objeto del árbol

         **/

        static private class IconData {

                protected Icon m_icon;

                protected Icon m_expandedIcon;

                protected Object m_data;

                public IconData(Icon icon, Icon expandedIcon, Object data) {

                        m_icon = icon;

                        m_expandedIcon = expandedIcon;

                        m_data = data;

                }

                public Icon getIcon() {

                        return m_icon;

                }

                public Icon getExpandedIcon() {

                        return m_expandedIcon != null ? m_expandedIcon : m_icon;

                }

                @Override

                public String toString() {

                        return m_data.toString();

                }

        }

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

                }

                public Component getTreeCellRendererComponent(JTree tree, Object value,

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

                                boolean hasFocus)

                {

                        DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;

                        Object obj = node.getUserObject();

                        setText(obj.toString());

                        if (obj instanceof Boolean)

                                setText(uimanager.getTranslation("Retrieving_data"));

                        if (obj instanceof IconData) {

                                IconData idata = (IconData) obj;

                                if (expanded)

                                        setIcon(idata.getExpandedIcon());

                                else

                                        setIcon(idata.getIcon());

                        } else

                                setIcon(null);

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

                }

        }

}