Application: gvSIG desktop » gvSIG raster

/* 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.raster.wmts.swing.impl.wizard;

import java.awt.Color;

import java.awt.Component;

import java.util.ArrayList;

import java.util.List;

import java.util.Vector;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JRadioButton;

import javax.swing.JTree;

import javax.swing.event.TreeModelListener;

import javax.swing.tree.DefaultTreeCellRenderer;

import javax.swing.tree.TreeModel;

import javax.swing.tree.TreePath;

import org.gvsig.raster.wmts.ogc.struct.WMTSStyle;

import org.gvsig.raster.wmts.ogc.struct.WMTSTheme;

import org.gvsig.raster.wmts.swing.impl.wizard.WMTSParamsPanel.LayerUI;

/**

 * This class holds a visual tree that handles the selection of the styles in the

 * selected layers. It encapsulates any gui interface handling the mouse selection.

 * <p>

 * It has a method getStylesSelection that returns the current selection in a 

 * bi-dimensional string array containing the layer name and the selected style name.

 * </p>

 * <p>

 * Keep in mind that although it's similar to LayersTree it is not the same.

 * It does not use the same instances of the WMTSLayerNode that LayerTreeModel

 * because it allows to repeat layers. So, each layer is a completely new 

 * WMTSLayerNode containing same properties but not the same parent (which is always

 * the tree root) and each style is a completely new FMapStyle containing same

 * properties but its parent is one of the layers of the StylesTree and not one

 * of those of the Layers tree.

 * </p>

 * 

 * @author jaume dominguez faus

 *

 */

@SuppressWarnings("serial")

public class StyleTree extends JTree {

        private static final long serialVersionUID  = 1L;

        public boolean            showLayerNames    = false;

    public StyleTree() {

        super();

        initialize();

    }

        private void initialize() {

        setToggleClickCount(1);

        setRowHeight(22);

        setCellRenderer(new DefaultTreeCellRenderer() {

            public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {

                if (leaf) {

                    JPanel leafComponent = new JPanel();

                    leafComponent.setBackground(Color.WHITE);

                    JRadioButton leafRadioButton = new JRadioButton("", ((StyleTreeModel) getModel()).isSelected((WMTSStyle) value));//selected);

                    leafRadioButton.setBackground(Color.WHITE);

                    leafComponent.add(leafRadioButton);

                    leafComponent.add(new JLabel(((WMTSStyle) value).getIdentifier()));

                    return leafComponent;

                } else {

                        super.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);

                        if (value instanceof WMTSTheme) {

                                WMTSTheme layer = (WMTSTheme) value;

                                if (!showLayerNames) {

                                        if (layer.getIdentifier() != null || layer.getIdentifier() == "") {

                                                String text = layer.toString();

                                                text = text.substring(text.indexOf(']') + 2, text.length());

                                                setText(text);

                                        }

                                }

                        }

                            return this;

                }

            }});

        addMouseListener(new java.awt.event.MouseAdapter() { 

            public void mouseClicked(java.awt.event.MouseEvent e) {

                ((StyleTreeModel)getModel()).setSelectedLeaf(getSelectionPath());

                clearSelection();

                repaint();

            }

        });

    }

        /**

         * Expands this tree.

         *

         */

        public void expandAll() {

                int row = 0; 

                while (row < getRowCount()) {

                        expandRow(row);

                        row++;

                }

        }

        /**

         * Returns a Vector of Strings containing the style titles.

         */

        public Vector getStyleSelectionTitles() {

                if (getModel() instanceof StyleTreeModel)

                        return ((StyleTreeModel)getModel()).getStyleSelectionTitles();

                else

                        return null;

        }

    /**

     * Sets the selected styles in the StylesTree. The argument styleNames is

     * a Vector with exactly the same amount of strings than the amount of

     * themes (layers) contained by the tree. A blank or null string will

     * leave the default style for that layer, but this element <b>must exist</b>

     * in the array in any case.

     * 

     * @param styleNames, Vector containing the style names. 

     * The styles order <b>must match</b> with the layer order. 

     */

        public void initSelections(Vector styleNames){

            if (styleNames!=null) {

                    StyleTreeModel model = (StyleTreeModel) getModel();

                    model.setStylesSelection(styleNames);

            }

    }

    /**

     * Gets the style selected

     * @param layerName

     * @return

     */

    public WMTSStyle getSelectedStyle(String layerName) {

            StyleTreeModel model = (StyleTreeModel) getModel();

            LayerUI layerUI = model.getLayer(layerName);

            if(layerUI != null)

                    return layerUI.styleSelected;

            return null;

    }

}

class StyleTreeModel implements TreeModel {

        private String             root   = null;

        private ArrayList<LayerUI> layers = new ArrayList<LayerUI>();

        public StyleTreeModel(String root) {

                this.root = root;

    }

        public LayerUI getLayer(String layerName) {

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

                        if(layers.get(i).theme.getLayer().getTitle().compareTo(layerName) == 0) {

                                return layers.get(i);

                        }

                }

                return null;

        }

        /**

         * Will return true if this style is selected.

         * @param style

         * @return

         */

        public boolean isSelected(WMTSStyle style) {

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

                        LayerUI layerUI = layers.get(i);

                        if(layerUI.styleSelected == style)

                                return true;

                }

                return false;

        }

        /**

         * Gets the names of the selected styles into a Vector using the same order

         * as they was represented in the StylesTree.

         * @return

         */

        public Vector<String> getStyleSelectionTitles() {

                Vector<String> v = new Vector<String>();

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

                        LayerUI layer = (LayerUI) layers.get(i);

                        WMTSStyle sty = layer.styleSelected;

                        if (sty == null) 

                                v.add("");

                        else 

                                v.add(sty.getIdentifier());

                }

                return v;

        }

        /**

         * Sets the selected styles in the StylesTree. The argument styleNames is

         * a Vector with exactly the same amount of strings than the amount of

         * themes (layers) contained by the tree. A blank or null string will

         * leave the default style for that layer, but this element <b>must exist</b>

         * in the array in any case.

         * 

         * @param styleNames, Vector containing the style names. 

         * The styles order <b>must match</b> with the layer order. 

         */

        public void setStylesSelection(Vector styleNames) {

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

                        LayerUI layer = (LayerUI) layers.get(i);

                        for (int j = 0; j < layer.theme.getLayer().getStyle().size(); j++) {

                                WMTSStyle sty = (WMTSStyle) layer.theme.getLayer().getStyle().get(j);

                                if ( sty.getIdentifier().compareTo((String) styleNames.get(i)) == 0) {

                                        layer.styleSelected = sty;

                                }

                        }

                }

        }

        /**

         * Adds a new branch to this tree. It must be a layer node.

         * @param node

         * @return <b>True</b>, if the added branch actually defines any style.

         *         <b>False</b>, if the layer has no styles.

         */

        public boolean addLayerBranch(LayerUI node) {

                layers.add(node);

                //Si no hay ninguno seleccionado seleccionamos el primero

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

                        if(layers.get(i).styleSelected == null) {

                                List<WMTSStyle> sty = layers.get(i).theme.getLayer().getStyle();

                                if(sty != null && sty.size() > 0 && sty.get(0) != null)

                                        layers.get(i).styleSelected = sty.get(0);

                        }

                }

                if (node.theme.getLayer().getStyle() == null || node.theme.getLayer().getStyle().size() == 0) {

                        return false;

                }

                return true;

        }

        /**

     * Sets a leaf (an style) selected.

     * @param selectionPath to this leaf.

     */

        protected void setSelectedLeaf(TreePath selectionPath) {

                if (selectionPath != null) {

                        Object[] objects = selectionPath.getPath();

                        Object item = objects[objects.length - 1];

                        if (isLeaf(item)) {

                                LayerUI layer = (LayerUI)objects[objects.length - 2]; 

                                WMTSStyle style = (WMTSStyle) item;

                                for (int j = 0; j < layer.theme.getLayer().getStyle().size(); j++) {

                                        WMTSStyle sty = (WMTSStyle)layer.theme.getLayer().getStyle().get(j);

                                        if(sty.getIdentifier().equals(style.getIdentifier())) {

                                                layer.styleSelected = sty;

                                        }

                                }

                        }

                }

        }

        public int getChildCount(Object parent) {

        if (parent instanceof LayerUI)

            return ((LayerUI) parent).theme.getLayer().getStyle().size();

        if (parent instanceof WMTSStyle)

                return 0;

        return layers.size();

    }

        public boolean isLeaf(Object node) {

                return (node instanceof WMTSStyle);

        }

        public void addTreeModelListener(TreeModelListener l) {

        }

        public void removeTreeModelListener(TreeModelListener l) {

        }

        public Object getChild(Object parent, int index) {

                if (parent instanceof WMTSStyle)

            return null;

        if (parent instanceof LayerUI)

                return ((LayerUI) parent).theme.getLayer().getStyle().get(index);

        return layers.get(index);

        }

        public int getIndexOfChild(Object parent, Object child) {

                if (parent instanceof LayerUI && child instanceof WMTSStyle) {

                        List<WMTSStyle> listStyle = ((LayerUI)parent).theme.getLayer().getStyle();

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

                                WMTSStyle sty = listStyle.get(i);

                                if(sty.equals(child))

                                        return i;

                        }

                }

                if(child instanceof LayerUI) {

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

                                LayerUI layerUI = layers.get(i);

                                if(layerUI.equals(child))

                                        return i;

                        }

                }

                return -1;

        }

        public void valueForPathChanged(TreePath path, Object newValue) {

        }

        public Object getRoot() {

                return root;

        }

}