| gvSIG desktop 1

/*

 * Created on 08-feb-2005

 *

 * gvSIG. Sistema de Informaci�n Geogr�fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib��ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package com.iver.cit.gvsig.project.documents.view.legend.gui;

import java.awt.BorderLayout;

import java.awt.Component;

import java.awt.Dimension;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.Hashtable;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JSplitPane;

import javax.swing.JTextArea;

import javax.swing.JTree;

import javax.swing.tree.DefaultMutableTreeNode;

import javax.swing.tree.DefaultTreeCellRenderer;

import javax.swing.tree.DefaultTreeModel;

import javax.swing.tree.TreePath;

import javax.swing.tree.TreeSelectionModel;

import com.iver.andami.PluginServices;

import com.iver.andami.messages.NotificationManager;

import com.iver.cit.gvsig.exceptions.layers.LegendLayerException;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLayers;

import com.iver.cit.gvsig.fmap.layers.layerOperations.AlphanumericData;

import com.iver.cit.gvsig.fmap.layers.layerOperations.Classifiable;

import com.iver.cit.gvsig.fmap.layers.layerOperations.ClassifiableVectorial;

import com.iver.cit.gvsig.fmap.rendering.IClassifiedVectorialLegend;

import com.iver.cit.gvsig.fmap.rendering.ILegend;

import com.iver.cit.gvsig.fmap.rendering.IVectorialLegend;

import com.iver.cit.gvsig.fmap.rendering.SingleSymbolLegend;

import com.iver.cit.gvsig.gui.styling.SymbolPreviewer;

/**

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 */

public class LegendManager extends AbstractThemeManagerPage {

        private static ArrayList legendPool = new ArrayList();

    private FLayer layer;

    private ILegend legend; // Le asignaremos la leyenda del primer tema activo.

    private Hashtable pages = new Hashtable();

    private JPanel topPanel = null;

    private JLabel jLabel = null;

    private JComboBox jComboBox = null;

    private JButton jButton = null;

    private JButton jButton1 = null;

    private JCheckBox jCheckBox = null;

    private JTextArea titleArea = null;

    private SymbolPreviewer preview = null;

    private JScrollPane jTitleScrollPane = null;

    private JTree jTreeLegends;

    private ILegendPanel activePanel;

    private JScrollPane legendTreeScrollPane;

    private boolean dirtyTree;

    private DefaultMutableTreeNode root = new DefaultMutableTreeNode();

    private DefaultTreeModel treeModel;

    private JScrollPane jPanelContainer;

        private JPanel jCentralPanel;

        private JSplitPane jSplitPane;

        private boolean isTreeListenerDisabled;

    public LegendManager() {

        initialize();

    }

    private void initialize() {

        setLayout(new BorderLayout());

        add(getTopPanel(), BorderLayout.NORTH);

        add(getSplitPane(), BorderLayout.CENTER);

        setSize(500, 360);

        treeModel = new DefaultTreeModel(root);

    }

    private JSplitPane getSplitPane() {

            if (jSplitPane == null) {

                    jSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);

                    JPanel aux = new JPanel(new BorderLayout(0, 5));

            aux.add(getLegendTreeScrollPane(), BorderLayout.CENTER);

            aux.add(getPreviewPanel(), BorderLayout.SOUTH);

                    jSplitPane.setLeftComponent(aux);

                    jSplitPane.setRightComponent(getCentralPanel());

                       jSplitPane.setDividerLocation(150);

            }

            return jSplitPane;

    }

    private JPanel getCentralPanel() {

        if (jCentralPanel == null) {

                jCentralPanel = new JPanel(new BorderLayout(0,10));

                jCentralPanel.add(getTitleScroll(), BorderLayout.NORTH);

                jCentralPanel.add(getJPanelContainer(), BorderLayout.CENTER);

        }

        return jCentralPanel;

    }

    private JScrollPane getJPanelContainer() {

        if (jPanelContainer == null) {

            jPanelContainer = new JScrollPane();

        }

        return jPanelContainer;

    }

    /**

     * This method initializes jPanel

     *

     * @return javax.swing.JPanel

     */

    private JPanel getTopPanel() {

        if (topPanel == null) {

            jLabel = new JLabel();

            topPanel = new JPanel();

            topPanel.setLayout(null);

            topPanel.setPreferredSize(new Dimension(638, 31));

            topPanel.setBorder(javax.swing.BorderFactory.createTitledBorder(null, "", javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION, null, null));

            jLabel.setBounds(6, 4, 68, 22);

            jLabel.setText(PluginServices.getText(this,"Leyenda") + ":");

            topPanel.add(jLabel, null);

            topPanel.add(getJComboBox(), null);

            topPanel.add(getJButton(), null);

            topPanel.add(getJButton1(), null);

            topPanel.add(getJCheckBox(), null);

        }

        return topPanel;

    }

    /**

     * This method initializes jComboBox

     *

     * @return javax.swing.JComboBox

     */

    private JComboBox getJComboBox() {

        if (jComboBox == null) {

            jComboBox = new JComboBox();

            jComboBox.setBounds(78, 5, 250, 22);

        }

        return jComboBox;

    }

    /**

     * This method initializes jButton

     *

     * @return javax.swing.JButton

     */

    private JButton getJButton() {

        if (jButton == null) {

            jButton = new JButton();

            jButton.setBounds(345, 4, 22, 22);

            jButton.setEnabled(false);

        }

        return jButton;

    }

    /**

     * This method initializes jButton1

     *

     * @return javax.swing.JButton

     */

    private JButton getJButton1() {

        if (jButton1 == null) {

            jButton1 = new JButton();

            jButton1.setBounds(371, 4, 22, 22);

            jButton1.setEnabled(false);

        }

        return jButton1;

    }

    /**

     * This method initializes jCheckBox

     *

     * @return javax.swing.JCheckBox

     */

    private JCheckBox getJCheckBox() {

        if (jCheckBox == null) {

            jCheckBox = new JCheckBox();

            jCheckBox.setBounds(417, 4, 202, 22);

            jCheckBox.setText(PluginServices.getText(this,"Leyenda_Por_Defecto"));

            jCheckBox.setEnabled(false);

        }

        return jCheckBox;

    }

    /**

     * This method initializes jTextArea

     *

     * @return javax.swing.JTextArea

     */

    private JTextArea getTitleArea() {

        if (titleArea == null) {

            titleArea = new JTextArea();

            titleArea.setBackground(java.awt.SystemColor.control);

            titleArea.setLineWrap(true);

            titleArea.setRows(0);

            titleArea.setWrapStyleWord(false);

            titleArea.setEditable(false);

            titleArea.setPreferredSize(new java.awt.Dimension(495,40));

        }

        return titleArea;

    }

    /**

     * This method initializes jPanel1

     *

     * @return javax.swing.JPanel

     */

    private SymbolPreviewer getPreviewPanel() {

        if (preview == null) {

            preview = new SymbolPreviewer();

            preview.setBorder(javax.swing.BorderFactory.createBevelBorder(javax.swing.border.BevelBorder.LOWERED));

            preview.setBackground(java.awt.SystemColor.text);

            preview.setPreferredSize(new Dimension(getSplitPane().getDividerLocation(), 100));

        }

        return preview;

    }

    /**

     * @return Returns the renderer.

     */

    public ILegend getRenderer() {

        return activePanel.getLegend();

    }

    /**

     * This method initializes jScrollPane

     *

     * @return javax.swing.JScrollPane

     */

    private JScrollPane getLegendTreeScrollPane() {

        if (legendTreeScrollPane == null) {

            legendTreeScrollPane = new JScrollPane();

            legendTreeScrollPane.setViewportView(getJTreeLegends());

        }

        return legendTreeScrollPane;

    }

    /**

     * <p>Adds a new fully-featured legend panel to the LegendManager.<br></p>

     *

     * <p><b>CAUTION:</b> Trying to add a child page whose parent hasn't been added yet

     * causes the application to fall in an infinite loop. This is a known

     * bug, sorry. Just avoid this case or try to fix it (lol).<br></p>

     *

     * <p><b>Notice</b> that there is no type check so if you add a non-ILegendPanel class,

     * you'll have a runtime error later.</p>

     * @param page, Class of type ILegendPanel

     */

    public static void addLegendPage(Class iLegendPanelClass) {

            if (!legendPool.contains(iLegendPanelClass)) {

                    legendPool.add(iLegendPanelClass);

            }

    }

    /**

     * Causes the component to be autofilled with the legend pages that

     * were added through the static method addLegendPage(ILegendPanel page)

     */

    private void fillDialog() {

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

                    Class pageClass = (Class) legendPool.get(i);

                    ILegendPanel page;

                    try {

                            page = (ILegendPanel) pageClass.newInstance();

                            if (page.isSuitableFor(layer)) {

                                    // this legend can be applied to this layer

                                    pages.put(page.getClass(), page);

                                    if (dirtyTree) {

                                            // rebuild page tree

                                            dirtyTree = false;

                                            ArrayList legList = new ArrayList(pages.values());

                                            ArrayList alreadyAdded = new ArrayList();

                                            DefaultTreeModel model = new DefaultTreeModel(root);

                                            while (legList.size()>0) {

                                                    ILegendPanel legend = (ILegendPanel) legList.get(0);

                                                    Class parent = legend.getParentClass();

                                                    while (parent != null &&

                                                                    !alreadyAdded.contains(pages.get(parent))) {

                                                            legend = (ILegendPanel) pages.get(parent);

                                                    }

                                                    doInsertNode(model, legend);

                                                    legList.remove(legend);

                                                    alreadyAdded.add(legend);

                                            }

                                            treeModel = model;

                                            jTreeLegends.setModel(model);

                                    }

                                    doInsertNode(treeModel, page);

                            }

                            getJTreeLegends().setModel(treeModel);

                    } catch (InstantiationException e) {

                            NotificationManager.addError("Trying to instantiate an interface" +

                                            " or abstract class + "+pageClass.getName(), e);

                    } catch (IllegalAccessException e) {

                            NotificationManager.addError("IllegalAccessException: does " +

                                            pageClass.getName()        + " class have an anonymous" +

                                            " constructor?", e);

                    }

            }

            getJTreeLegends().repaint();

    }

    private DefaultMutableTreeNode findNode(Class searchID) {

            String title;

            try {

                    title = ((ILegendPanel) Class.forName(searchID.getName()).newInstance()).getTitle();

            } catch (Exception e) {

                    // this should be impossible, but anyway this case will be treat as the node does not

                    // exist.

                    return null;

            }

        Enumeration e = root.breadthFirstEnumeration();

        while (e.hasMoreElements()) {

            DefaultMutableTreeNode nodeAux = (DefaultMutableTreeNode) e.nextElement();

            if (nodeAux != null) {

                ILegendPanel legend = (ILegendPanel) nodeAux.getUserObject();

                if (legend == null) continue; // Root node

                if (legend.getTitle().equals(title)) {

                    return nodeAux;

                }

            }

        }

        return null;

    }

    private void doInsertNode(DefaultTreeModel treeModel, ILegendPanel page) {

        dirtyTree = ((page.getParentClass() != null) && (findNode(page.getParentClass())==null));

        if (findNode(page.getClass()) != null) // It is already added

            return;

        if (page.getParentClass() != null) {

            if (pages.containsKey(page.getParentClass())) {

                ILegendPanel parent = (ILegendPanel) pages.get(page.getParentClass());

                DefaultMutableTreeNode nodeParent = findNode(parent.getClass());

                if (nodeParent == null) {

                        // the parent is empty

                    // Recursively add it

                    doInsertNode(treeModel, parent);

                } else {

                    DefaultMutableTreeNode nodeValue = new DefaultMutableTreeNode(page);

                    int children = nodeParent.getChildCount();

                    int pos=0;

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

                        DefaultMutableTreeNode node = (DefaultMutableTreeNode) treeModel.getChild(nodeParent, i);

                        if (node.getUserObject() instanceof ILegendPanel) {

                            String pageTitle = ((ILegendPanel) node.getUserObject()).getTitle();

                            if (pageTitle.compareTo(page.getTitle()) < 0) ++pos;

                        }

                    }

                    treeModel.insertNodeInto(nodeValue, nodeParent, pos);

                }

            }

        } else {

                // First level node

            DefaultMutableTreeNode nodeValue = new DefaultMutableTreeNode(page);

            int children = root.getChildCount();

            int pos=0;

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

                DefaultMutableTreeNode node = (DefaultMutableTreeNode) treeModel.getChild(root, i);

                if (node.getUserObject() instanceof ILegendPanel) {

                    String pageTitle = ((ILegendPanel) node.getUserObject()).getTitle();

                    if (pageTitle.compareTo(page.getTitle()) < 0) ++pos;

                }

            }

            treeModel.insertNodeInto(nodeValue, root, pos);

        }

    }

    private JScrollPane getTitleScroll() {

        if (jTitleScrollPane == null) {

            jTitleScrollPane = new JScrollPane();

            jTitleScrollPane.setBounds(2, 2, 498, 42);

            jTitleScrollPane.setViewportView(getTitleArea());

        }

        return jTitleScrollPane;

    }

    private JTree getJTreeLegends() {

        if (jTreeLegends == null) {

            jTreeLegends = new JTree();

            jTreeLegends.setRootVisible(false);

            MyTreeCellRenderer treeCellRenderer = new MyTreeCellRenderer();

            treeCellRenderer.setOpenIcon(null);

            treeCellRenderer.setClosedIcon(null);

            treeCellRenderer.setLeafIcon(null);

            jTreeLegends.setCellRenderer(treeCellRenderer);

            jTreeLegends.setShowsRootHandles(true);

            jTreeLegends.addTreeSelectionListener(new javax.swing.event.TreeSelectionListener() {

                    public void valueChanged(javax.swing.event.TreeSelectionEvent e) {

                            if (isTreeListenerDisabled) return;

                            DefaultMutableTreeNode node = (DefaultMutableTreeNode)

                            jTreeLegends.getLastSelectedPathComponent();

                            if (node == null) return;

                            setActivePage((ILegendPanel) node.getUserObject());

                    }

            });

            jTreeLegends.putClientProperty("JTree.linestyle", "Angled");

            jTreeLegends.getSelectionModel().

                    setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);

        }

        return jTreeLegends;

    }

    private void setActivePage(ILegendPanel page) {

        if (page.getPanel() == null) {

                // this is what happens when the user clicked in a parent node

                // which only acts as a folder, and does not manage any legend

                // then it expands and selects the first child

            DefaultMutableTreeNode node = findNode(page.getClass());

            if (treeModel.getChildCount(node)>0) {

                DefaultMutableTreeNode dmn = (DefaultMutableTreeNode) treeModel.getChild(node, 0);

                page = (ILegendPanel) dmn.getUserObject();

                setActivePage(page);

                expandAndSelect(page);

            }

        } else {

                // show the page

            activePanel = page;

            activePanel.setData(layer, legend);

            getTitleArea().setText(activePanel.getDescription());

            getPreviewPanel().setSymbol(activePanel.getPreviewSymbol());

            jPanelContainer.setViewportView(activePanel.getPanel());

        }

    }

    private class MyTreeCellRenderer extends DefaultTreeCellRenderer

    {

        public MyTreeCellRenderer() {

        }

        public Component getTreeCellRendererComponent(

                            JTree tree,

                            Object value,

                            boolean sel,

                            boolean expanded,

                            boolean leaf,

                            int row,

                            boolean hasFocus) {

            super.getTreeCellRendererComponent(

                            tree, value, sel,

                            expanded, leaf, row,

                            hasFocus);

            if (value instanceof DefaultMutableTreeNode)

            {

                DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;

                if (node.getUserObject() instanceof ILegendPanel)

                {

                    ILegendPanel legend = (ILegendPanel) node.getUserObject();

                    this.setText(

                            legend.getPanel() == null ? "<html><b>"+legend.getTitle()+"</b></html>":legend.getTitle());

                }

            }

            return this;

        }

    }

        private void expandAndSelect(Object node) {

                isTreeListenerDisabled = true;

            // will expand the tree and select the node

            int i = 0;

            boolean exit = false;

            TreePath tp = null;

            // find the page in the tree

            while (i<jTreeLegends.getRowCount() && !exit) {

                    //see if this row is the node that we are looking for

                    tp = jTreeLegends.getPathForRow(i);

                    Object[] obj = tp.getPath();

                    for (int j = 0; j < obj.length && !exit ; j++) {

                                Object o = ((DefaultMutableTreeNode) obj[j]).getUserObject();

                                if (o!=null        && o.getClass().equals(node.getClass())        && o.equals(node)) {

                                // found it! collapse the tree

                                while (i>=0) {

                                        jTreeLegends.collapseRow(i);

                                        i--;

                                }

                                exit = true;

                        }

                        }

                    jTreeLegends.expandRow(i);

                    i++;

            }

            // expand the tree and set the selection

            if (tp != null) {

                    jTreeLegends.expandPath(tp);

                    jTreeLegends.setSelectionPath(tp);

            }

            isTreeListenerDisabled = false;

        }

        public String getName() {

                return PluginServices.getText(this,"Simbologia");

        }

        public void acceptAction() {

        }

        public void cancelAction() {

                // does nothing

        }

        public void applyAction() {

                legend = activePanel.getLegend();

                /* try to apply the legend to all the active layers that

                 can accept it */

                FLayer[] activeLyrs = layer.getMapContext().getLayers().getActives();

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

                        FLayer laux=activeLyrs[i];

                        if (activeLyrs[i] instanceof FLayers){

                                laux=getFirstActiveLayerVect((FLayers)activeLyrs[i]);

                        }

                        if (laux instanceof ClassifiableVectorial) {

                                ClassifiableVectorial aux2 = (ClassifiableVectorial) laux;

                                try {

                                        if (legend instanceof IClassifiedVectorialLegend) {

                                                // Es una leyenda que necesita un recordset con un

                                                // nombre de campo. Comprobamos que ese recordset

                                                // tiene ese nombre de campo y es del tipo esperado

                                                IClassifiedVectorialLegend cl = (IClassifiedVectorialLegend) legend;

                                                if (aux2 instanceof AlphanumericData) {

//                                                        DataSource rs;

//                                                        rs = ((AlphanumericData) aux2).getRecordset();

                                                        if (cl.getValues().length==0) {

                                                                JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),PluginServices.getText(this,"no_es_posible_aplicar_leyenda_vacia"));

                                                                return;

                                                        }

//                                                        int idField = rs.getFieldIndexByName(cl.getFieldNames());

//                                                        if (idField != -1) {

                                                                //TODO: Aqu� deber�amos comprobar si el tipo de campo

                                                                // es el tipo de campo esperado.

                                                                /*if (renderer instanceof VectorialUniqueValueLegend){

                                                                 ((VectorialUniqueValueLegend)renderer).setLabelHeightField(null);

                                                                 ((VectorialUniqueValueLegend)renderer).setLabelRotationField(null);

                                                                 }

                                                                 */

                                                                aux2.setLegend((IVectorialLegend) legend);

//                                                        }

                                                }

                                        }

                                        else if (legend instanceof SingleSymbolLegend)

                                                aux2.setLegend((IVectorialLegend) legend);

//                                } catch (ReadDriverException e) {

//                                        NotificationManager.addError(PluginServices.getText(this, "driver_exception")+":"

//                                                        +e.getMessage(), e);

                                } catch (LegendLayerException e) {

                                        NotificationManager.addError(PluginServices.getText(this, "legend_exception"), e);

                                }

                        }

                }

        }

        public void setModel(FLayer layer) {

                this.layer = layer;

                this.legend = ((Classifiable) layer).getLegend();

                fillDialog();

        Enumeration en = pages.keys();

        while (en.hasMoreElements()) {

                ILegendPanel page = (ILegendPanel) pages.get(en.nextElement());

//                page.setData(layer, legend);

                if (legend.getClass().equals(page.getLegendClass())) {

                        setActivePage(page);

                        expandAndSelect(page);

                }

        }

        }

}