Application: gvSIG desktop » gvSIG geoprocess

package org.gvsig.sextante.app.extension;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Component;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.text.Collator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Set;

import javax.swing.Icon;

import javax.swing.ImageIcon;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTree;

import javax.swing.tree.DefaultMutableTreeNode;

import javax.swing.tree.DefaultTreeModel;

import javax.swing.tree.TreeCellRenderer;

import javax.swing.tree.TreePath;

import org.gvsig.andami.PluginServices;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.gui.core.SextanteGUI;

import es.unex.sextante.gui.modeler.ModelAlgorithmIO;

import es.unex.sextante.modeler.ModelAlgorithm;

public class AlgorithmsTreePanel extends JPanel{

        private JTree jTree;

        private JScrollPane jScrollPane;

        private ButtonDefinitionDialog m_Dialog;

        public AlgorithmsTreePanel(ButtonDefinitionDialog dialog) {

                super();

                m_Dialog = dialog;

                initGUI();

        }

        private void initGUI() {

                BorderLayout thisLayout = new BorderLayout();

                this.setLayout(thisLayout);

                jTree = new JTree();

                jTree.setCellRenderer(new MyCellRenderer());

                MouseListener ml = new MouseAdapter() {

                        public void mousePressed(MouseEvent e) {

                        TreePath path = jTree.getPathForLocation(e.getX(), e.getY());

                             if (path!=null){

                                    try{

                                            DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();

                                            GeoAlgorithm alg = ((GeoAlgorithm)node.getUserObject());

                                            m_Dialog.setCommand(alg);

                            }

                            catch(Exception ex){

                                    //

                            }

                             }

                 }

             };

             jTree.addMouseListener(ml);

                fillTree();

                jScrollPane = new JScrollPane(jTree,JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,

                                                                                JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);

                this.add(jScrollPane, BorderLayout.CENTER);

        }

        private void fillTree(){

                DefaultMutableTreeNode node;

                DefaultMutableTreeNode mainNode = new DefaultMutableTreeNode(

                                Sextante.getText( "Procedures"));

                DefaultMutableTreeNode toolsNode = new DefaultMutableTreeNode(

                                PluginServices.getText(this, "Algorithms"));

            DefaultMutableTreeNode child;

            HashMap map = new HashMap();

            String sGroup;

            String sKey;

                HashMap algs = Sextante.getAlgorithms();

                Set set = algs.keySet();

                Iterator iter = set.iterator();

                while (iter.hasNext()) {

                        sKey = (String) iter.next();

                        GeoAlgorithm alg = (GeoAlgorithm) algs.get(sKey);

                        child = new DefaultMutableTreeNode(alg);

                        sGroup = (alg.getGroup());

                        if (map.containsKey(sGroup)){

                                node = (DefaultMutableTreeNode)map.get(sGroup);

                        }

                        else{

                                node = new DefaultMutableTreeNode(sGroup);

                                map.put(sGroup, node);

                        }

                        addNodeInSortedOrder(node, child);

                }

                set= map.keySet();

                iter = set.iterator();

            while(iter.hasNext()){

                    sKey = (String) iter.next();

                    node = (DefaultMutableTreeNode) map.get(sKey);

                    addNodeInSortedOrder(toolsNode, node);

            }

            mainNode.add(toolsNode);

                DefaultMutableTreeNode modelsNode = new DefaultMutableTreeNode(

                                PluginServices.getText(this, "Models"));

                GeoAlgorithm[] models = ModelAlgorithmIO.loadModelsAsAlgorithms(

                                SextanteGUI.getModelsFolder());

                if (models != null && models.length != 0){

                        for (int i = 0; i < models.length; i++){

                                if (models[i].isSuitableForModelling()){

                                        sGroup = models[i].getGroup();

                                        node = (DefaultMutableTreeNode) map.get(sGroup);

                                        if (node == null){

                                                node = new DefaultMutableTreeNode(sGroup);

                                                map.put(sGroup, node);

                                                addNodeInSortedOrder(toolsNode,node);

                                        }

                                        child = new DefaultMutableTreeNode(models[i]);

                                        addNodeInSortedOrder(node, child);

                                }

                        }

                }

                jTree.setModel(new DefaultTreeModel(mainNode));

        }

        private void addNodeInSortedOrder(DefaultMutableTreeNode parent,

                                                                          DefaultMutableTreeNode child){

                int n = parent.getChildCount();

                if(n==0){

                        parent.add(child);

                        return;

                }

                Collator collator = Collator.getInstance();

                collator.setStrength(Collator.PRIMARY);

                DefaultMutableTreeNode node=null;

                for(int i=0;i<n;i++){

                        node = (DefaultMutableTreeNode)parent.getChildAt(i);

                        try{

                                if(collator.compare(node.toString(),child.toString())>0){

                                        parent.insert(child, i);

                                        return;

                                }

                        }catch(Exception e){}

                }

                parent.add(child);

        }

        static class MyCellRenderer extends JLabel implements TreeCellRenderer {

                ImageIcon m_AlgorithmIcon = new ImageIcon(SextanteGUI.class.getClassLoader()

                                                                        .getResource("images/module2.png"));

                ImageIcon m_ModelIcon = new ImageIcon(getClass().getClassLoader()

                                                                        .getResource("images/model.png"));

                protected Icon getCustomIcon(Object value) {

                        Object obj = ((DefaultMutableTreeNode)value).getUserObject();

                        if (obj instanceof GeoAlgorithm){

                                if (obj instanceof ModelAlgorithm){

                                        return m_ModelIcon;

                                }

                                else{

                                        return m_AlgorithmIcon;

                                }

                        }

                        else{

                                return null;

                        }

                }

            public Component getTreeCellRendererComponent(JTree tree,

                                                                                Object value,

                                                                                boolean sel,

                                                                                boolean expanded,

                                                                                boolean leaf,

                                                                                int row,

                                                                                boolean hasFocus) {

                String sName;

                setFont(tree.getFont());

                this.setIcon(getCustomIcon(value));

                        sName = tree.convertValueToText(value, sel, expanded,

                                                                                        leaf, row, hasFocus);

                        setEnabled(tree.isEnabled());

                        setText(sName);

                        if (!leaf){

                                setFont(new java.awt.Font("Tahoma",1,11));

                                setForeground(Color.black);

                        }

                        else{

                                if (sel){

                                        setForeground(Color.blue);

                                }

                                else{

                                        setForeground(Color.black);

                                }

                        }

                return this;

            }

        }

}