Aplicación gvSIG con fines educativos

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.educa.portableview.swing.impl.viewer;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.Image;

import java.awt.Rectangle;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import javax.swing.JComponent;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTree;

import javax.swing.SwingUtilities;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.event.TreeSelectionListener;

import javax.swing.tree.DefaultMutableTreeNode;

import javax.swing.tree.DefaultTreeModel;

import javax.swing.tree.TreePath;

import javax.swing.tree.TreeSelectionModel;

import org.gvsig.educa.portableview.swing.impl.viewer.TocTreeNode.TYPE;

import org.gvsig.educa.portableview.swing.PortableViewSwingLocator;

import org.gvsig.educa.portableview.swing.PortableViewSwingManager;

import org.gvsig.educa.portableview.swing.viewer.PortableViewToc;

import org.gvsig.educa.portableview.swing.viewer.PortableViewTocImageProvider;

import org.gvsig.educa.portableview.swing.viewer.PortableViewViewer;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.FLayers;

import org.gvsig.fmap.mapcontext.layers.LayerEvent;

import org.gvsig.fmap.mapcontext.layers.LayerListener;

import org.gvsig.fmap.mapcontext.layers.operations.Classifiable;

import org.gvsig.fmap.mapcontext.layers.operations.IHasImageLegend;

import org.gvsig.fmap.mapcontext.layers.operations.LayerCollection;

import org.gvsig.fmap.mapcontext.layers.operations.SingleLayer;

import org.gvsig.fmap.mapcontext.rendering.legend.IClassifiedLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.fmap.mapcontext.rendering.legend.ISingleSymbolLegend;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.fmap.swing.toc.TOCFactory;

import org.gvsig.fmap.swing.toc.event.ActiveLayerChangeEventListener;

import org.gvsig.fmap.swing.toc.event.LayerActionEventListener;

import org.gvsig.fmap.swing.toc.event.LegendActionEventListener;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.service.Manager;

/**

 * <p>

 * Default implementation of {@link PortableViewToc}

 * </p>

 *

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class DefaultPortableViewToc extends JPanel implements PortableViewToc,

    LayerListener, TreeSelectionListener {

    /**

     *

     */

    private static final long serialVersionUID = 3761640139439674486L;

    @SuppressWarnings("unused")

    private static final org.slf4j.Logger LOG = org.slf4j.LoggerFactory

        .getLogger(DefaultPortableViewToc.class);

    private static final FLayer[] EMPTY_SELECTION = new FLayer[0];

    private PortableViewViewer viewer;

    private boolean initialized;

    private JTree tree;

    private FLayers rootLayer;

    private TocTreeNode rootNode;

    private DefaultTreeModel treeModel;

    private PortableViewTocImageProvider imageProvider;

    private TocTreeCellRenderer cellRenderer;

    private boolean internalSelectionChanging;

    private final PortableViewSwingManager swingManager;

    public DefaultPortableViewToc() {

        swingManager = PortableViewSwingLocator.getSwingManager();

        initialized = false;

        imageProvider = swingManager.getDefaultTocImageProvider();

    }

    public void setImageProvider(PortableViewTocImageProvider imageProvider) {

        this.imageProvider = imageProvider;

        if (cellRenderer != null) {

            cellRenderer.setImageProvider(imageProvider);

        }

    }

    /**

     * Load tree model from mapContext

     */

    private void loadTreeModel() {

        rootLayer = getMapContext().getLayers();

        // rootNode = new LayerTreeNode(rootLayer);

        // rootLayer.addLayerCollectionListener(this);

        loadLayerNode(rootLayer, null);

        treeModel = new DefaultTreeModel(rootNode);

        tree.setModel(treeModel);

        tree.invalidate();

        tree.getSelectionModel().addTreeSelectionListener(this);

    }

    /**

     * Load a layer Node

     *

     * @param layer

     * @param parent

     */

    private void loadLayerNode(FLayer layer, TocTreeNode parent) {

        layer.addLayerListener(this);

        TocTreeNode node;

        if (layer instanceof LayerCollection) {

            LayerCollection collection = (LayerCollection) layer;

            node = new TocTreeNode((LayerCollection) layer);

            // collection.addLayerCollectionListener(this);

            for (int i = collection.getLayersCount(); i > 0; i--) {

                loadLayerNode(collection.getLayer(i-1), node);

            }

            if (parent == null) {

                rootNode = node;

            } else {

                parent.add(node);

            }

        } else {

            loadSingleLayerNode((SingleLayer) layer, parent);

        }

    }

    private void loadSingleLayerNode(SingleLayer layer, TocTreeNode parent) {

        TocTreeNode node;

        if (layer instanceof Classifiable) {

            Classifiable classifLayer = (Classifiable) layer;

            if (classifLayer.getLegend() != null) {

                loadLayerWithLegendNode(layer, classifLayer.getLegend(), parent);

                return;

            }

        }

        if (layer instanceof IHasImageLegend) {

            Image imgLegend = ((IHasImageLegend) layer).getImageLegend();

            loadLayerWithImageLegendNode(layer, imgLegend, parent);

            return;

        }

        node = new TocTreeNode(layer);

        parent.add(node);

    }

    /**

     * @param layer

     * @param imgLegend

     * @param parent

     */

    private void loadLayerWithImageLegendNode(SingleLayer layer,

        Image imgLegend, TocTreeNode parent) {

        TocTreeNode node;

        if (imgLegend == null) {

            node = new TocTreeNode(layer);

        } else {

            node = new TocTreeNode(layer, imgLegend);

            TocTreeNode legendNode = new TocTreeNode(imgLegend, layer);

            node.add(legendNode);

        }

        parent.add(node);

    }

    /**

     * @param layer

     * @param legend

     * @param parent

     */

    private void loadLayerWithLegendNode(SingleLayer layer, ILegend legend,

        TocTreeNode parent) {

        TocTreeNode node;

        ISymbol defSymbol = legend.getDefaultSymbol();

        if (legend instanceof IClassifiedLegend) {

            node = new TocTreeNode(layer, true);

            IClassifiedLegend cl = (IClassifiedLegend) legend;

            String[] descriptions = cl.getDescriptions();

            ISymbol[] symbols = cl.getSymbols();

            TocTreeNode symNode;

            for (int j = 0; j < descriptions.length; j++) {

                symNode = new TocTreeNode(symbols[j], descriptions[j], layer);

                node.add(symNode);

            }

        } else

            if (legend instanceof ISingleSymbolLegend && defSymbol != null) {

                node = new TocTreeNode(layer, true);

                TocTreeNode symNode =

                    new TocTreeNode(defSymbol, defSymbol.getDescription(),

                        layer);

                node.add(symNode);

            } else {

                node = new TocTreeNode(layer, false);

            }

        parent.add(node);

    }

    private List<TocTreeNode> getNodesFromType(TYPE... types) {

        List<TocTreeNode> nodesFound = new ArrayList<TocTreeNode>();

        getNodesFromType(rootNode, nodesFound, types);

        return nodesFound;

    }

    private void getNodesFromType(TocTreeNode node,

        List<TocTreeNode> nodesFound, TYPE... types) {

        for (TYPE type : types) {

            if (node.getType() == type) {

                nodesFound.add(node);

            }

        }

        for (int index = 0; index < node.getChildCount(); index++) {

            getNodesFromType((TocTreeNode) node.getChildAt(index), nodesFound,

                types);

        }

    }

    /** {@inheridDoc} */

    public JComponent getSwingComponent() {

        if (viewer == null) {

            throw new IllegalStateException("Viewer not set yet");

        }

        return this;

    }

    /** {@inheridDoc} */

    public FLayer[] getSelectedLayers() {

        if (viewer == null) {

            throw new IllegalStateException("Viewer not set yet");

        }

        List<FLayer> selectedLayers = new ArrayList<FLayer>();

        TocTreeNode node;

        TreePath[] paths = tree.getSelectionPaths();

        if (paths != null && paths.length > 0) {

            for (TreePath path : paths) {

                node = (TocTreeNode) path.getLastPathComponent();

                if (node.isLayer()) {

                    selectedLayers.add(node.getLayer());

                }

            }

        } else {

            return EMPTY_SELECTION;

        }

        return selectedLayers.toArray(EMPTY_SELECTION);

    }

    /** {@inheridDoc} */

    public void attachTo(PortableViewViewer viewer) {

        if (this.viewer != null && !this.viewer.equals(viewer)) {

            throw new IllegalStateException("Viewer already attached");

        }

        this.viewer = viewer;

        initializeUI();

        loadTreeModel();

    }

    /** {@inheridDoc} */

    public PortableViewViewer getViewer() {

        return viewer;

    }

    /**

     * Initialize User Interface components

     */

    private void initializeUI() {

        if (initialized) {

            return;

        }

        setLayout(new BorderLayout());

        tree = new JTree();

        cellRenderer = new TocTreeCellRenderer();

        if (imageProvider != null) {

            cellRenderer.setImageProvider(imageProvider);

        }

        tree.setCellRenderer(cellRenderer);

        tree.setRootVisible(false);

        tree.getSelectionModel().setSelectionMode(

            TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);

        add(new JScrollPane(tree), BorderLayout.CENTER);

        tree.addMouseListener(new MouseListener() {

            public void mouseReleased(MouseEvent e) {

                processTreeMouseEvent(e);

            }

            public void mousePressed(MouseEvent e) {

                processTreeMouseEvent(e);

            }

            public void mouseExited(MouseEvent e) {

                processTreeMouseEvent(e);

            }

            public void mouseEntered(MouseEvent e) {

                processTreeMouseEvent(e);

            }

            public void mouseClicked(MouseEvent e) {

                processTreeMouseEvent(e);

            }

        });

        setMinimumSize(new Dimension(200, 100));

        initialized = true;

    }

    /**

     * Locates the layer node in all tree structure from root

     *

     * @param layer

     * @return

     */

    private DefaultMutableTreeNode findLayerNode(FLayer layer) {

        if (rootNode == null) {

            return null;

        }

        return findLayerNode(rootNode, layer);

    }

    /**

     * Locates the layer node in all tree structure from root

     *

     * @param node

     * @param layer

     * @return

     */

    private TocTreeNode findLayerNode(TocTreeNode node, FLayer layer) {

        if (node.getLayer() == layer) {

            return node;

        }

        if (node.isLeaf()) {

            return null;

        }

        TocTreeNode aNode;

        TocTreeNode result;

        for (int i = 0; i < node.getChildCount(); i++) {

            aNode = (TocTreeNode) node.getChildAt(i);

            result = findLayerNode(aNode, layer);

            if (result != null) {

                return result;

            }

        }

        return null;

    }

    public DynObject getParameters() {

        // TODO Auto-generated method stub

        return null;

    }

    public TOCFactory getFactory() {

        // TODO Auto-generated method stub

        return null;

    }

    public JComponent getComponent() {

        return getSwingComponent();

    }

    public MapContext getMapContext() {

        if (viewer == null) {

            return null;

        }

        return viewer.getPortableView().getMapContext();

    }

    public void showAll() {

        List<TocTreeNode> nodes = getNodesFromType(TYPE.values());

        for (TocTreeNode node : nodes) {

            tree.expandPath(new TreePath(node.getPath()));

        }

    }

    public void hideAll() {

        DefaultMutableTreeNode node;

        for (int i = rootNode.getChildCount(); i < rootNode.getChildCount(); i++) {

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

            tree.collapsePath(new TreePath(node.getPath()));

        }

    }

    public void showAllLegends() {

        List<TocTreeNode> nodes =

            getNodesFromType(TYPE.LAYER_WITH_LEGEND,

                TYPE.LAYER_WITH_IMAGE_LEGEND);

        for (TocTreeNode node : nodes) {

            tree.expandPath(new TreePath(node.getPath()));

        }

    }

    public void hideAllLegends() {

        List<TocTreeNode> nodes =

            getNodesFromType(TYPE.LAYER_WITH_LEGEND,

                TYPE.LAYER_WITH_IMAGE_LEGEND);

        for (TocTreeNode node : nodes) {

            tree.collapsePath(new TreePath(node.getPath()));

        }

    }

    public void show(FLayer lyr, boolean detailed) {

        DefaultMutableTreeNode node = findLayerNode(lyr);

        if (detailed && node.getChildCount() > 0) {

            node = (DefaultMutableTreeNode) node.getFirstChild();

        }

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

    }

    public void showLegend(FLayer lyr) {

        show(lyr, true);

    }

    public void hideLegend(FLayer lyr) {

        DefaultMutableTreeNode node = findLayerNode(lyr);

        tree.collapsePath(new TreePath(node.getPath()));

    }

    public void selectLayer(FLayer lyr) {

        DefaultMutableTreeNode node = findLayerNode(lyr);

        tree.getSelectionModel().addSelectionPath(new TreePath(node.getPath()));

    }

    public void unselectLayer(FLayer lyr) {

        DefaultMutableTreeNode node = findLayerNode(lyr);

        tree.getSelectionModel().removeSelectionPath(

            new TreePath(node.getPath()));

    }

    public void clearSelection() {

        tree.clearSelection();

    }

    public void setActiveLayer(FLayer lyr) {

        TocTreeNode node = (TocTreeNode) findLayerNode(lyr);

        tree.getSelectionModel().setSelectionPath(new TreePath(node.getPath()));

    }

    public FLayer getActiveLayer() {

        if (tree.getSelectionCount() < 1) {

            return null;

        }

        TocTreeNode node =

            (TocTreeNode) tree.getSelectionPath().getLastPathComponent();

        if (!node.isLayer()) {

            return null;

        }

        return node.getLayer();

    }

    public void invokeAction(FLayer lyr, String action) {

        throw new UnsupportedOperationException();

    }

    public void addLegendActionListener(LegendActionEventListener lel) {

        throw new UnsupportedOperationException();

    }

    public void removeLegendActionListener(LegendActionEventListener lel) {

        throw new UnsupportedOperationException();

    }

    public void addLayerActionListener(LayerActionEventListener lel) {

        throw new UnsupportedOperationException();

    }

    public void removeLayerActionListener(LayerActionEventListener lel) {

        throw new UnsupportedOperationException();

    }

    public void addActiveLayerChangeListener(

        ActiveLayerChangeEventListener alcel) {

        throw new UnsupportedOperationException();

    }

    public void removeActiveLayerChangeListener(

        ActiveLayerChangeEventListener alcel) {

        throw new UnsupportedOperationException();

    }

    public Manager getManager() {

        // Nothing to do

        return null;

    }

    public void visibilityChanged(LayerEvent e) {

        DefaultMutableTreeNode node = findLayerNode(e.getSource());

        treeModel.nodeChanged(node);

    }

    public void activationChanged(LayerEvent e) {

        if (internalSelectionChanging) {

            return;

        }

        FLayer layer = e.getSource();

        TocTreeNode node = (TocTreeNode) findLayerNode(layer);

        TreePath path = new TreePath(node.getPath());

        if (layer.isActive()) {

            tree.addSelectionPath(path);

        } else {

            tree.removeSelectionPath(path);

        }

    }

    public void nameChanged(LayerEvent e) {

        DefaultMutableTreeNode node = findLayerNode(e.getSource());

        treeModel.nodeChanged(node);

    }

    public void editionChanged(LayerEvent e) {

        // Nothing to do

    }

    public void drawValueChanged(LayerEvent e) {

        // Nothing to do

    }

    protected void processTreeMouseEvent(MouseEvent e) {

        if (!tree.isEnabled()) {

            return;

        }

        if (e.getID() != MouseEvent.MOUSE_CLICKED) {

            return;

        }

        int x = e.getX();

        int y = e.getY();

        int row = tree.getRowForLocation(x, y);

        if (row < 0) {

            return;

        }

        // click inside some node

        Rectangle rect = tree.getRowBounds(row);

        if (rect == null) {

            return;

        }

        // Get the node

        TreePath selPath = tree.getPathForLocation(e.getX(), e.getY());

        final TocTreeNode node = (TocTreeNode) selPath.getLastPathComponent();

        if (!node.isLayer() || !node.getLayer().isAvailable()) {

            // no layer or unavailable layer: do nothing

            return;

        }

        // click on a valid node

        TocTreeCellRenderer renderer =

            (TocTreeCellRenderer) tree.getCellRenderer();

        // adjust renderer for node and check box has been clicked

        renderer.getTreeCellRendererComponent(tree, node, false, false, false,

            row, false);

        if (!renderer.isOnCheck(x - rect.x, y - rect.y)) {

            return;

        }

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {

                swichLayerVisibilid(node);

            }

        });

    }

    /**

     * @param node

     */

    private void swichLayerVisibilid(TocTreeNode node) {

        if (!node.isLayer()) {

            return;

        }

        FLayer layer = node.getLayer();

        setLayerVisibilid(node, !layer.isVisible());

    }

    private void setLayerVisibilid(TocTreeNode node, boolean newValue) {

        if (node.isLayer()) {

            FLayer layer = node.getLayer();

            layer.setVisible(newValue);

            treeModel.nodeChanged(node);

        }

        if (node.isLeaf()) {

            return;

        }

        TocTreeNode child;

        for (int index = 0; index < node.getChildCount(); index++) {

            child = (TocTreeNode) node.getChildAt(index);

            setLayerVisibilid(child, newValue);

        }

    }

    public void valueChanged(TreeSelectionEvent e) {

        internalSelectionChanging = true;

        getMapContext().beginAtomicEvent();

        List<FLayer> prevActives =

            new ArrayList<FLayer>(Arrays.asList(rootLayer.getActives()));

        TreePath[] selectedPaths = e.getPaths();

        List<FLayer> newActives = new ArrayList<FLayer>(selectedPaths.length);

        // mark new active

        TocTreeNode node;

        FLayer layer;

        for (TreePath path : selectedPaths) {

            node = (TocTreeNode) path.getLastPathComponent();

            if (node.isLayer()) {

                layer = node.getLayer();

                if (!layer.isActive()) {

                    layer.setActive(true);

                } else {

                    prevActives.remove(layer);

                }

                newActives.add(layer);

            }

        }

        // Clear the previous

        for (FLayer aLayer : prevActives) {

            aLayer.setActive(false);

        }

        getMapContext().endAtomicEvent();

        internalSelectionChanging = false;

    }

}