Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3 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.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.app.project.documents.view.toc.gui;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.FontMetrics;

import java.awt.Image;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.event.ComponentEvent;

import java.awt.event.ComponentListener;

import java.awt.event.InputEvent;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.swing.BorderFactory;

import javax.swing.JColorChooser;

import javax.swing.JComponent;

import javax.swing.JDialog;

import javax.swing.JScrollPane;

import javax.swing.JTree;

import javax.swing.SwingUtilities;

import javax.swing.event.TreeExpansionEvent;

import javax.swing.event.TreeExpansionListener;

import javax.swing.tree.DefaultMutableTreeNode;

import javax.swing.tree.DefaultTreeModel;

import javax.swing.tree.TreeNode;

import javax.swing.tree.TreePath;

import javax.swing.tree.TreeSelectionModel;

import org.apache.commons.lang.BooleanUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.project.ProjectPreferences;

import org.gvsig.app.project.documents.view.IContextMenuAction;

import org.gvsig.app.project.documents.view.toc.DnDJTree;

import org.gvsig.app.project.documents.view.toc.ITocItem;

import org.gvsig.app.project.documents.view.toc.ITocOrderListener;

import org.gvsig.app.project.documents.view.toc.TocItemBranch;

import org.gvsig.app.project.documents.view.toc.TocItemLeaf;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.events.AtomicEvent;

import org.gvsig.fmap.mapcontext.events.listeners.AtomicEventListener;

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

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

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

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

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.legend.events.LegendChangedEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.listeners.LegendListener;

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

/**

 *

 * @author fjp

 */

public class TOC extends JComponent {

    /**

     *

     */

    private static final long serialVersionUID = 5689047685537359038L;

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

    private static class ItemsExpandeds {

        private final Map<Object, Boolean> itemsExpanded = new HashMap<>();

        private boolean expandingNodes = false;

        public boolean isMarked(ITocItem item) {

            Object key = item.getLabel();

            boolean isItemExpanded = BooleanUtils.isTrue(this.itemsExpanded.get(key));

            return isItemExpanded;

        }

        public void setMark(ITocItem item, boolean expanded) {

            Object key = item.getLabel();

            this.itemsExpanded.put(key, expanded);

        }

        public void removeLayer(FLayer layer) {

            Object key = layer.getName();

            this.itemsExpanded.remove(key);

        }

        public void update(JTree tree, TreeNode node) {

            if (expandingNodes) {

                return;

            }

            try {

                expandingNodes = true;

                DefaultTreeModel treeModel = (DefaultTreeModel) tree.getModel();

                Enumeration<TreeNode> nodes = (Enumeration<TreeNode>)(node.children());

                while (nodes.hasMoreElements()) {

                    DefaultMutableTreeNode curNode = (DefaultMutableTreeNode) nodes.nextElement();

                    if (curNode.getChildCount() > 0) {

                        update(tree, curNode);

                    }

                    TreePath path = new TreePath(treeModel.getPathToRoot(curNode));

                    ITocItem item = (ITocItem) curNode.getUserObject();

                    if (this.isMarked(item)) {

                        tree.expandPath(path);

                    } else {

                        tree.collapsePath(path);

                    }

                }

            } finally {

                expandingNodes = false;

            }

        }

    }

    private MapContext mapContext;

    private final DnDJTree m_Tree;

    private final DefaultTreeModel m_TreeModel;

    private final DefaultMutableTreeNode m_Root;

    private final TOCRenderer m_TocRenderer;

    private final JScrollPane m_Scroller;

    private final ItemsExpandeds itemsExpandeds = new ItemsExpandeds();

    private NodeSelectionListener nodeSelectionListener = null;

    /**

     * Crea un nuevo TOC.

     */

    public TOC() {

        this.setName("TOC");

        this.setLayout(new BorderLayout());

        this.setMinimumSize(new Dimension(100, 80));

        this.setPreferredSize(new Dimension(100, 80));

        m_Root = new DefaultMutableTreeNode(java.lang.Object.class);

        m_TreeModel = new DefaultTreeModel(m_Root);

        m_Tree = new DnDJTree(m_TreeModel);

        m_TocRenderer = new TOCRenderer(m_Tree.getBackground());

        m_Tree.setCellRenderer(m_TocRenderer);

        m_Tree.setRootVisible(false);

        m_Tree.setShowsRootHandles(true);

        m_Tree.getSelectionModel().setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);

        nodeSelectionListener = new NodeSelectionListener(m_Tree);

        m_Tree.addMouseListener(nodeSelectionListener);

        this.addComponentListener(new ComponentListener() {

            @Override

            public void componentResized(ComponentEvent e) {

                tocResized();

            }

            @Override

            public void componentMoved(ComponentEvent e) {

            }

            @Override

            public void componentShown(ComponentEvent e) {

            }

            @Override

            public void componentHidden(ComponentEvent e) {

            }

        });

        m_Tree.addOrderListener(new ITocOrderListener() {

            @Override

            public void orderChanged(int oldPos, int newPos, FLayers layers) {

                try {

                    layers.moveTo(oldPos, newPos);

                } catch (Exception e) {

                    logger.warn("Can't change order of layers in TOC", e);

                }

                mapContext.invalidate();

            }

            @Override

            public void parentChanged(FLayers source, FLayers targer, FLayer layer) {

                try {

                    source.move(layer, targer);

                } catch (Exception e) {

                    logger.warn("Can't move layers in TOC", e);

                }

                mapContext.invalidate();

            }

        });

        m_Tree.addTreeExpansionListener(new TreeExpansionListener() {

            @Override

            public void treeCollapsed(TreeExpansionEvent event) {

                TreePath path = event.getPath();

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

                if (node.getUserObject() instanceof ITocItem) {

                    itemsExpandeds.setMark((ITocItem) node.getUserObject(), false);

                }

            }

            @Override

            public void treeExpanded(TreeExpansionEvent event) {

                TreePath path = event.getPath();

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

                if (node.getUserObject() instanceof ITocItem) {

                    itemsExpandeds.setMark((ITocItem) node.getUserObject(), true);

                }

            }

        });

        m_Tree.setRowHeight(0); // Para que lo determine el renderer

        m_Scroller = new JScrollPane(m_Tree);

        m_Scroller.setBorder(BorderFactory.createEmptyBorder());

        add(m_Scroller);

    }

    /**

     * Elimina los listeners que actuan sobre el TOC, lo ?nico que deja hacer es

     * desplegar la leyenda de las capas.

     */

    public void removeListeners() {

        m_Tree.removeMouseListener(nodeSelectionListener);

        m_Tree.invalidateListeners();

    }

    /**

     * @param mc

     */

    public void setMapContext(MapContext mc) {

        this.mapContext = mc;

        this.mapContext.addAtomicEventListener(new AtomicEventListener() {

            @Override

            public void atomicEvent(final AtomicEvent e) {

                if (!SwingUtilities.isEventDispatchThread()) {

                    SwingUtilities.invokeLater(new Runnable() {

                        @Override

                        public void run() {

                            atomicEvent(e);

                        }

                    });

                    return;

                }

                if ((e.getLayerCollectionEvents().length > 0) || (e.getLegendEvents().length > 0)) {

                    reloadLayers();

                }

                if (e.getLayerEvents().length > 0) {

                    repaint();

                }

                if (e.getExtentEvents().length > 0) {

                    repaint();

                }

                LayerCollectionEvent[] events = e.getLayerCollectionEvents();

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

                    if (events[i].getEventType() == LayerCollectionEvent.LAYER_ADDED) {

                        if (PluginServices.getMainFrame() != null) {

                            PluginServices.getMainFrame().enableControls();

                        }

                    }

                    // ===================================================

                    // Change visibility of layer before adding, according to app preferences

                    if (events[i].getEventType() == LayerCollectionEvent.LAYER_ADDING) {

                        if (haveToAddNewLayersInInvisibleMode()) {

                            events[i].getAffectedLayer().setVisible(false);

                        }

                    }

                }

            }

        });

        this.mapContext.getLayers().addLegendListener(new LegendListener() {

            @Override

            public void legendChanged(LegendChangedEvent e) {

                reloadLayers();

            }

        });

        reloadLayers();

    }

    /**

     *

     */

    public void refresh() {

        reloadLayers();

    }

    /**

     *

     */

    public void reloadLayers() {

        if (!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(new Runnable() {

                @Override

                public void run() {

                    reloadLayers();

                }

            });

            return;

        }

        LayerCollection theLayers = mapContext.getLayers();

        m_Root.removeAllChildren();

        m_Root.setAllowsChildren(true);

        reloadLayers(theLayers, m_Root);

        m_TreeModel.reload();

        itemsExpandeds.update(m_Tree, m_Root);

    }

    private void reloadLayers(LayerCollection theLayers, DefaultMutableTreeNode parentNode) {

        int width = m_Tree.getWidth();

        if (width == 0) {

            width = 300;

        }

        // Get the tree font height

        Font font = m_Tree.getFont();

        FontMetrics metrics = this.getFontMetrics(font);

        Dimension sizeBranch = new Dimension(width, metrics.getHeight() + 4);

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

            FLayer lyr = theLayers.getLayer(i);

            if (!lyr.isInTOC()) {

                continue;

            }

            TocItemBranch elTema = new TocItemBranch(lyr);

            elTema.setSize(sizeBranch);

            DefaultMutableTreeNode nodeLayer = new DefaultMutableTreeNode(elTema);

            m_TreeModel.insertNodeInto(nodeLayer, parentNode, parentNode.getChildCount());

            if (lyr instanceof LayerCollection) {

                LayerCollection group = (LayerCollection) lyr;

                reloadLayers(group, nodeLayer);

            } else if (haveToShowLeyendOfLayer(lyr)) {

                this.addLegend(nodeLayer, lyr);

            }

        }

    }

    private void addLegend(final DefaultMutableTreeNode nodeLayer, FLayer lyr) {

        int width = m_Tree.getWidth();

        if (width == 0) {

            width = 300;

        }

        Dimension sizeLeaf = new Dimension(width, 15);

        if (lyr instanceof Classifiable) {

            Classifiable classifiable = (Classifiable) lyr;

            ILegend legendInfo = classifiable.getLegend();

            try {

                if (legendInfo instanceof IClassifiedLegend) {

                    IClassifiedLegend cl = (IClassifiedLegend) legendInfo;

                    String[] descriptions = cl.getDescriptions();

                    ISymbol[] symbols = cl.getSymbols();

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

                        TocItemLeaf itemLeaf;

                        itemLeaf = new TocItemLeaf(symbols[j], descriptions[j], classifiable.getShapeType());

                        itemLeaf.setSize(sizeLeaf);

                        DefaultMutableTreeNode nodeValue = new DefaultMutableTreeNode(itemLeaf);

                        m_TreeModel.insertNodeInto(nodeValue, nodeLayer, nodeLayer.getChildCount());

                    }

                }

                if (legendInfo instanceof ISingleSymbolLegend && (legendInfo.getDefaultSymbol() != null)) {

                    TocItemLeaf itemLeaf;

                    itemLeaf =

                        new TocItemLeaf(legendInfo.getDefaultSymbol(), legendInfo.getDefaultSymbol().getDescription(),

                            classifiable.getShapeType());

                    itemLeaf.setSize(sizeLeaf);

                    DefaultMutableTreeNode nodeValue = new DefaultMutableTreeNode(itemLeaf);

                    m_TreeModel.insertNodeInto(nodeValue, nodeLayer, nodeLayer.getChildCount());

                }

                if (legendInfo instanceof IHasImageLegend) {

                    final IHasImageLegend imageLegend = (IHasImageLegend) legendInfo;

                    // Las imagenes de la leyenda que vienen de servicios

                    // remotos pueden

                    // ser lentas de pintar y relentizan todo gvSIG, asi que

                    // mejor si

                    // podemos hacerlo en segundo plano.

                    Thread thread = new Thread(new Runnable() {

                        @Override

                        public void run() {

                            final Image image = imageLegend.getImageLegend();

                            // Una vez obtenida la imagen, la actualizacion del

                            // ToC

                            // la hacemos en el thread de Swing para evitar

                            // problemas.

                            SwingUtilities.invokeLater(new Runnable() {

                                @Override

                                public void run() {

                                    int w = 0;

                                    int h = 0;

                                    if (image != null) {

                                        w = image.getWidth(null);

                                        h = image.getHeight(null);

                                    }

                                    if (image != null && w > 0 && h > 0) {

                                        TocItemLeaf itemLeaf = new TocItemLeaf();

                                        itemLeaf.setImageLegend(image, "", new Dimension(w, h));

                                        DefaultMutableTreeNode nodeValue = new DefaultMutableTreeNode(itemLeaf);

                                        m_TreeModel.insertNodeInto(nodeValue, nodeLayer, nodeLayer.getChildCount());

                                    }

                                    // Aqui habria que forzar a refrescar el

                                    // nodo nodeLayer

                                }

                            });

                        }

                    }, "ToCImageLegendUpdate");

                    thread.start();

                }

            } catch (Throwable e) {

                logger.warn(MessageFormat.format("Can't add leyend of layer {0} to the TOC.", lyr), e);

            }

        }

    }

    private void tocResized() {

        DefaultMutableTreeNode n;

        Enumeration<TreeNode> enumeration = m_Root.children();

        while (enumeration.hasMoreElements()) {

            n = (DefaultMutableTreeNode) enumeration.nextElement();

            if (n.getUserObject() instanceof TocItemBranch) {

                ITocItem item = (ITocItem) n.getUserObject();

                Dimension szAnt = item.getSize();

                item.setSize(new Dimension(this.getWidth() - 40, szAnt.height));

            }

        }

    }

    /**

     * Obtiene el JScrollPane que contiene el TOC

     *

     * @return JScrollPane que contiene el TOC

     */

    public JScrollPane getJScrollPane() {

        return this.m_Scroller;

    }

    /**

     * @return

     */

    public DnDJTree getTree() {

        return m_Tree;

    }

    /**

     * Clase Listener que reacciona al pulsar sobre el checkbox de un nodo y

     * crea un popupmenu al pulsar el bot?n derecho.

     */

    class NodeSelectionListener extends MouseAdapter { // implements

                                                       // ActionListener {

        JTree tree;

        JDialog dlg;

        JColorChooser colorChooser;

        FPopupMenu popmenu = null;

        DefaultMutableTreeNode node;

        /**

         * Crea un nuevo NodeSelectionListener.

         *

         * @param tree

         *            !

         */

        NodeSelectionListener(JTree tree) {

            this.tree = tree;

        }

        @Override

        public void mouseClicked(MouseEvent e) {

            int x = e.getX();

            int y = e.getY();

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

            TreePath path = tree.getPathForRow(row);

            final FLayers layers = mapContext.getLayers();

            List<FLayer> plainListLayers = toPlainList(layers);

            plainListLayers.remove(plainListLayers.size() - 1);

            int countDeepActiveLayers = countDeepActiveLayers(plainListLayers);

            if (path != null) {

                if (e.getClickCount() == 1) {

                    // this fixes a bug when double-clicking. JTree by default

                    // expands the tree when double-clicking, so we capture a

                    // different node in the second click than in the first

                    node = (DefaultMutableTreeNode) path.getLastPathComponent();

                }

                if (node != null && node.getUserObject() instanceof TocItemBranch) {

                    // double click with left button ON A BRANCH/NODE (layer)

                    if (e.getClickCount() >= 2 && e.getButton() == MouseEvent.BUTTON1) {

                        e.consume();

                        PluginServices.getMDIManager().setWaitCursor();

                        try {

                            TocItemBranch leaf = (TocItemBranch) node.getUserObject();

                            IContextMenuAction action = leaf.getDoubleClickAction();

                            if (action != null) {

                                /*

                                 * if there is an action associated with the

                                 * double-clicked element it will be fired for

                                 * it and FOR ALL OTHER COMPATIBLES THAT HAVE

                                 * BEEN ACTIVATED.

                                 */

                                ArrayList<FLayer> targetLayers = new ArrayList<>();

                                TocItemBranch owner = (TocItemBranch) node.getUserObject();

                                FLayer masterLayer = owner.getLayer();

                                targetLayers.add(masterLayer);

                                FLayer[] actives = mapContext.getLayers().getActives();

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

                                    if (actives[i].getClass().equals(masterLayer.getClass())) {

                                        if (actives[i] instanceof FLyrVect) {

                                            FLyrVect vectorLayer = (FLyrVect) actives[i];

                                            FLyrVect vectorMaster = (FLyrVect) masterLayer;

                                            if (vectorLayer.getShapeType() == vectorMaster.getShapeType()) {

                                                targetLayers.add(vectorLayer);

                                                vectorLayer.setActive(true);

                                            } else {

                                                vectorLayer.setActive(false);

                                            }

                                        }

                                        // TODO for the rest of layer types

                                        // (i.e. FLyrRaster)

                                    } else {

                                        actives[i].setActive(false);

                                    }

                                }

                                // Do nothing if there is a non-available layer

                                for (int k = 0; k < targetLayers.size(); k++) {

                                    if (!targetLayers.get(k).isAvailable()) {

                                        return;

                                    }

                                    targetLayers.get(k).setActive(true);

                                }

                                action.execute(leaf, targetLayers.toArray(new FLayer[0]));

                            }

                        } catch (Exception ex) {

                            NotificationManager.addError(ex);

                        } finally {

                            PluginServices.getMDIManager().restoreCursor();

                        }

                        return;

                    }

                    TocItemBranch elTema = (TocItemBranch) node.getUserObject();

                    FLayer lyr = elTema.getLayer();

                    if( lyr.isAvailable() ) {

                        lyr.getMapContext().beginAtomicEvent();

                    }

                    // Si est? pulsado SHIFT

                    if (((e.getModifiers() & InputEvent.SHIFT_MASK) != 0)

                        && (e.getButton() == MouseEvent.BUTTON1 || e.getButton() == MouseEvent.BUTTON3)) {

                        if (countDeepActiveLayers > 0) {

                            selectInterval(plainListLayers, lyr);

                        } else {

                            lyr.setActive(!lyr.isActive());

                        }

                    } else { // Si no est? pulsado SHIFT

                        // Si no est? pulsado CTRL

                        if (!((e.getModifiers() & InputEvent.CTRL_MASK) != 0)) {

                            if (e.getButton() == MouseEvent.BUTTON1) {

                                if (countDeepActiveLayers > 1) {

                                    layers.setAllActives(false);

                                    lyr.setActive(true);

                                } else {

                                    boolean active = lyr.isActive();

                                    layers.setAllActives(false);

                                    lyr.setActive(!active);

                                }

                            }

                            if (e.getButton() == MouseEvent.BUTTON3) {

                                if (lyr.isActive()) {

                                    // No modificamos la selecci?n porque lo que

                                    // se va a hacer m?s abajo es abrir el men?

                                    // contextual

                                } else {

                                    boolean active = lyr.isActive();

                                    layers.setAllActives(false);

                                    lyr.setActive(!active);

                                }

                            }

                        } else { // Si s? est? pulsado CTRL

                            if (e.getButton() == MouseEvent.BUTTON1) {

                                // BUTTON1 cambiamos la activaci?n de la lyr

                                // seleccionada

                                lyr.setActive(!lyr.isActive());

                            }

                            if (e.getButton() == MouseEvent.BUTTON3) {

                                if (lyr.isActive()) {

                                    // No modificamos la selecci?n porque lo que

                                    // se va a hacer m?s abajo es abrir el men?

                                    // contextual

                                } else {

                                    lyr.setActive(true);

                                }

                            }

                        }

                    }

                    Point layerNodeLocation = tree.getUI().getPathBounds(tree, path).getLocation();

                    // Rect?ngulo que representa el checkbox

                    Rectangle checkBoxBounds = m_TocRenderer.getCheckBoxBounds();

                    checkBoxBounds.translate((int) layerNodeLocation.getX(), (int) layerNodeLocation.getY());

                    if (checkBoxBounds.contains(e.getPoint())) {

                        updateVisible(lyr);

                        // si node no tiene leyenda llamar a addLegend

                    }

                    if (e.getButton() == MouseEvent.BUTTON3) {

                        popmenu = new FPopupMenu(mapContext, node);

                        tree.add(popmenu);

                        popmenu.show(e.getComponent(), e.getX(), e.getY());

                    }

                    if( lyr.isAvailable() ) {

                        lyr.getMapContext().endAtomicEvent();

                    }

                }

                if (node != null && node.getUserObject() instanceof TocItemLeaf) {

                    TocItemBranch owner = (TocItemBranch) ((DefaultMutableTreeNode) node.getParent()).getUserObject();

                    FLayer masterLayer = owner.getLayer();

                    // double click with left button ON A LEAF (ISymbol)

                    if (e.getClickCount() >= 2 && e.getButton() == MouseEvent.BUTTON1) {

                        e.consume();

                        PluginServices.getMDIManager().setWaitCursor();

                        try {

                            TocItemLeaf leaf = (TocItemLeaf) node.getUserObject();

                            IContextMenuAction action = leaf.getDoubleClickAction();

                            if (action != null) {

                                /*

                                 * if there is an action associated with the

                                 * double-clicked element it will be fired for

                                 * it and FOR ALL OTHER COMPATIBLES THAT HAVE

                                 * BEEN ACTIVATED.

                                 */

                                /*

                                 * #3035: Symbology is applied to active layers

                                 * too

                                 * Now it will be done only on the

                                 * double-clicked one

                                 */

                                action.execute(leaf, new FLayer[] { masterLayer });

                            }

                        } catch (Exception ex) {

                            logger.warn("Problems executing action in the ToC.", ex);

                        } finally {

                            PluginServices.getMDIManager().restoreCursor();

                        }

                        return;

                    }

                }

                ((DefaultTreeModel) tree.getModel()).nodeChanged(node);

                if (row == 0) {

                    tree.revalidate();

                    tree.repaint();

                }

                // FIXME Is it really necessary?

                if (PluginServices.getMainFrame() != null) {

                    PluginServices.getMainFrame().enableControls();

                }

            } else {

                if (e.getButton() == MouseEvent.BUTTON3) {

                    popmenu = new FPopupMenu(mapContext, null);

                    tree.add(popmenu);

                    popmenu.show(e.getComponent(), e.getX(), e.getY());

                }

            }

        }

        private void selectInterval(List<FLayer> layers, FLayer lyr) {

            // FLayer[] activeLayers = layers.getActives();

            int firstActive = Integer.MAX_VALUE;

            int lastActive = -1;

            int myLayer = -1;

            for (int j = 0; j < layers.size(); j++) {

                FLayer layerAux = layers.get(j);

                if (layerAux.isActive()) {

                    if (firstActive > j) {

                        firstActive = j;

                    }

                    if (lastActive < j) {

                        lastActive = j;

                    }

                    if (layerAux.equals(lyr)) {

                        myLayer = j;

                    }

                }

                if (myLayer < 0 && layerAux.equals(lyr)) {

                    myLayer = j;

                }

            }

            if (firstActive < Integer.MAX_VALUE && myLayer >= 0) {

                for (int pasada = 0; pasada < 2; pasada++) {

                    if (myLayer < firstActive) {

                        for (int j = 0; j < myLayer; j++) {

                            FLayer layerAux = layers.get(j);

                            if (pasada == 0) {

                                if (layerAux instanceof FLayers) {

                                    layerAux.setActive(false);

                                }

                            } else {

                                if (!(layerAux instanceof FLayers)) {

                                    layerAux.setActive(false);

                                }

                            }

                        }

                        for (int j = myLayer; j <= lastActive; j++) {

                            FLayer layerAux = layers.get(j);

                            if (pasada == 0) {

                                if (layerAux instanceof FLayers) {

                                    layerAux.setActive(true);

                                }

                            } else {

                                if (!(layerAux instanceof FLayers)) {

                                    layerAux.setActive(true);

                                }

                            }

                        }

                        for (int j = lastActive + 1; j < layers.size(); j++) {

                            FLayer layerAux = layers.get(j);

                            if (pasada == 0) {

                                if (layerAux instanceof FLayers) {

                                    layerAux.setActive(false);

                                }

                            } else {

                                if (!(layerAux instanceof FLayers)) {

                                    layerAux.setActive(false);

                                }

                            }

                        }

                    } else {

                        if (myLayer > lastActive) {

                            for (int j = 0; j < firstActive; j++) {

                                FLayer layerAux = layers.get(j);

                                if (pasada == 0) {

                                    if (layerAux instanceof FLayers) {

                                        layerAux.setActive(false);

                                    }

                                } else {

                                    if (!(layerAux instanceof FLayers)) {

                                        layerAux.setActive(false);

                                    }

                                }

                            }

                            for (int j = firstActive; j <= myLayer; j++) {

                                FLayer layerAux = layers.get(j);

                                if (pasada == 0) {

                                    if (layerAux instanceof FLayers) {

                                        layerAux.setActive(true);

                                    }

                                } else {

                                    if (!(layerAux instanceof FLayers)) {

                                        layerAux.setActive(true);

                                    }

                                }

                            }

                            for (int j = myLayer + 1; j < layers.size(); j++) {

                                FLayer layerAux = layers.get(j);

                                if (pasada == 0) {

                                    if (layerAux instanceof FLayers) {

                                        layerAux.setActive(false);

                                    }

                                } else {

                                    if (!(layerAux instanceof FLayers)) {

                                        layerAux.setActive(false);

                                    }

                                }

                            }

                        } else { // Si myLayer est? entre firstActive y lastActive

                                 // seleccionamos desde myLayer hasta lastLayer

                            for (int j = 0; j < myLayer; j++) {

                                FLayer layerAux = layers.get(j);

                                if (pasada == 0) {

                                    if (layerAux instanceof FLayers) {

                                        layerAux.setActive(false);

                                    }

                                } else {

                                    if (!(layerAux instanceof FLayers)) {

                                        layerAux.setActive(false);

                                    }

                                }

                            }

                            for (int j = myLayer; j <= lastActive; j++) {

                                FLayer layerAux = layers.get(j);

                                if (pasada == 0) {

                                    if (layerAux instanceof FLayers) {

                                        layerAux.setActive(true);

                                    }

                                } else {

                                    if (!(layerAux instanceof FLayers)) {

                                        layerAux.setActive(true);

                                    }

                                }

                            }

                            for (int j = lastActive + 1; j < layers.size(); j++) {

                                FLayer layerAux = layers.get(j);

                                if (pasada == 0) {

                                    if (layerAux instanceof FLayers) {

                                        layerAux.setActive(false);

                                    }

                                } else {

                                    if (!(layerAux instanceof FLayers)) {

                                        layerAux.setActive(false);

                                    }

                                }

                            }

                        }

                    }

                }

            }

        }

        private List<FLayer> toPlainList(FLayer layer) {

            return toPlainList(layer, new ArrayList<FLayer>());

        }

        private List<FLayer> toPlainList(FLayer layer, List<FLayer> result) {

            if (layer instanceof FLayers) {

                FLayers layerGroup = (FLayers) layer;

                for (int i = 0; i < layerGroup.getLayersCount(); i++) {

                    toPlainList(layerGroup.getLayer(i), result);

                }

            }

            result.add(layer);

            return result;

        }

        private int countDeepActiveLayers(List<FLayer> layers) {

            int count = 0;

            for (FLayer fLayer : layers) {

                if (fLayer.isActive()) {

                    count++;

                }

            }

            return count;

        }

        /**

         * Actualiza la visibilidad de la capas.

         *

         * @param lyr

         *            Capa sobre la que se est? clickando.

         */

        private void updateVisible(FLayer lyr) {

            if (lyr.isAvailable()) {

                lyr.setVisible(!lyr.visibleRequired());

                updateVisibleChild(lyr);

                updateVisibleParent(lyr);

                if (node != null && !(lyr instanceof FLayers)) {

                    if (haveToShowLeyendOfLayer(lyr)) {

                        if (node.getChildCount() == 0) {

                            addLegend(node, lyr);

                        }

                    } else {

                        this.node.removeAllChildren();

                        m_TreeModel.reload(node);

                    }

                }

            }

        }

        /**

         * Actualiza de forma recursiva la visibilidad de los hijos de la capa

         * que se pasa como par?metro.

         *

         * @param lyr

         *            Capa a actualizar.

         */

        private void updateVisibleChild(FLayer lyr) {

            if (lyr instanceof FLayers) { // Es la raiz de una rama o

                // cualquier nodo intermedio.

                FLayers layergroup = (FLayers) lyr;

                for (int i = 0; i < layergroup.getLayersCount(); i++) {