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

public class DefaultJScriptingBrowser extends JScriptingBrowser{

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

        }

        public ScriptingManager getManager(){

                return this.manager;

        }

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

        }

        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 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 = (ScriptingUnit) 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 files = this.root.getUnits();

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

                        unit = (ScriptingUnit) files.get(i);

                        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 raíz del árbol

                        this.addObject(this.rootNode,data);

                        }

                }

        }

        /** 

         * 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, Object data)

                {

                        m_icon = icon;

                        m_expandedIcon = null;

                        m_data = 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;

                }

                public Object getObject() 

                { 

                        return m_data;

                }

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

                }

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

                }

        }

}