Application: gvSIG desktop » gvSIG legends: base legends

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

 *

 * Copyright (C) 2005 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 org.gvsig.symbology.gui.layerproperties;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.BorderFactory;

import javax.swing.DefaultComboBoxModel;

import javax.swing.ImageIcon;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.project.documents.view.legend.gui.ILegendPanel;

import org.gvsig.app.project.documents.view.legend.gui.JSymbolPreviewButton;

import org.gvsig.app.project.documents.view.legend.gui.Quantities;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

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

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

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

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

import org.gvsig.gui.beans.swing.GridBagLayoutPanel;

import org.gvsig.gui.beans.swing.JBlank;

import org.gvsig.gui.beans.swing.JNumberSpinner;

import org.gvsig.i18n.Messages;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl.MarkerFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.impl.SimpleLineSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.impl.SimpleMarkerSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.style.IMarkerFillPropertiesStyle;

import org.gvsig.symbology.fmap.rendering.ProportionalSymbolsLegend;

import org.gvsig.tools.dispose.DisposableIterator;

/**

 * Implements the panel for the legend of proportional symbols.In the interface will be

 * options to select the value field, the normalization field (if the user wants to use it) and

 * options to select the symbol an its minimum and maximum size.

 *

 * Also there will be possible to select a background symbol (only when the shapetype of the layer is

 * polygonal).

 *

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

 * @author jldominguez

 */

public class ProportionalSymbolsPanel extends JPanel implements ILegendPanel {

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

        private static final long serialVersionUID = 7394720230276170902L;

        private JPanel symbolPanel;

        private JPanel backgroundPanel;

        private JSymbolPreviewButton tmplateSymbol;

        private JSymbolPreviewButton backSymbol;

        private JComboBox cmbValue;

        private JComboBox cmbNormalization;

        private JNumberSpinner txtMinSize;

        private JNumberSpinner txtMaxSize;

        private ClassifiableVectorial myLayer;

        private ProportionalSymbolsLegend auxLegend;

        private String[] fieldNames;

        private int templateShapeType = 0;

        private String noNormalization = Messages.getText("none");

        private boolean useNormalization = true;

        /**

         * Default constructor

         */

        public ProportionalSymbolsPanel() {

                initialize();

        }

        /**

         * This method initializes this

         */

        private void initialize() {

                setLayout(new BorderLayout());

                JPanel aux = new JPanel(new BorderLayout());

                JPanel fieldsPanel = new JPanel(new FlowLayout());

                fieldsPanel.setBorder(BorderFactory.

                                createTitledBorder(null,

                                    Messages.getText("fields")

                                                ));

                fieldsPanel.setPreferredSize(new Dimension(300,60));

                cmbValue = new JComboBox();

                cmbValue.setActionCommand("VALUE_SELECTED");

                cmbNormalization = new JComboBox();

                cmbNormalization.setActionCommand("NORMALIZATION_SELECTED");

                fieldsPanel.add(new JLabel(

                    Messages.getText("value")

                    +":" ));

                fieldsPanel.add(cmbValue);

                fieldsPanel.add(new JLabel(

                    Messages.getText("normalization")

                    +":" ));

                fieldsPanel.add(cmbNormalization);

                symbolPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 3,2));

                symbolPanel.setBorder(BorderFactory.

                                createTitledBorder(null,

                                    Messages.getText("symbol")

                                                ));

                GridBagLayoutPanel aux2 = new GridBagLayoutPanel();

                aux2.addComponent(new JLabel(

                    Messages.getText("size")

                    ));

                aux2.addComponent(new JBlank(10,10));

                aux2.addComponent(

                    Messages.getText("from")

                    +":",

                                getTxtMinSize());

                aux2.addComponent(

                    Messages.getText("to")

                    +":",

                                getTxtMaxSize());

                JPanel templatePanel = new JPanel();

                templatePanel.setBorder(BorderFactory.createTitledBorder(null,

                    Messages.getText("template")

                                ));

                templatePanel.add(getTemplSymbol());

                symbolPanel.add(new JBlank(10,10));

                symbolPanel.add(aux2);

                symbolPanel.add(new JBlank(10,10));

                symbolPanel.add(templatePanel);

                aux.add(fieldsPanel, BorderLayout.NORTH);

                aux.add(symbolPanel, BorderLayout.CENTER);

                this.add(aux, BorderLayout.CENTER);

                cmbValue.addActionListener(action);

                cmbNormalization.addActionListener(action);

                tmplateSymbol.addActionListener(action);

        }

        /**

         * Creates the panel where the button for the background symbol will be placed

         *

         * @return JPanel panel

         */

        private JPanel getBackgroundPanel() {

                backgroundPanel = new JPanel();

                backgroundPanel.setBorder(BorderFactory.createTitledBorder(null,

                    Messages.getText("background")

                                ));

                backgroundPanel.add(getBtnBackground());

                return backgroundPanel;

        }

        /**

         * Creates a JNumberSpinner which is used to select the maximum size for the symbol

         *

         * @return JNumberSpinner

         */

        private JNumberSpinner getTxtMaxSize() {

                if (txtMaxSize == null) {

                        txtMaxSize = new JNumberSpinner(25.0,7,0.0,100.0,1.0,2);

                        txtMaxSize.addActionListener(action);

                }

                return txtMaxSize;

        }

        /**

         * Creates a JNumberSpinner which is used to select the minimum size for the symbol

         *

         * @return JNumberSpinner

         */

        private JNumberSpinner getTxtMinSize() {

                if (txtMinSize == null) {

                        txtMinSize = new JNumberSpinner(3.0,7,0.0,100.0,1.0,2);

                        txtMinSize.addActionListener(action);

                }

                return txtMinSize;

        }

        /**

         * Creates a JSymbolPreviewButton which is used to select the template symbol

         *

         * @return JSymbolPreviewButton

         */

        private JSymbolPreviewButton getTemplSymbol() {

                if (tmplateSymbol == null) {

                        int tst = ProportionalSymbolsLegend.isPolygonal(this.templateShapeType) ?

                            Geometry.TYPES.POINT

                            : this.templateShapeType;

                        tmplateSymbol = new JSymbolPreviewButton(tst);

                }

                tmplateSymbol.setPreferredSize(new Dimension(100, 45));

                return tmplateSymbol;

        }

        /**

         * Creates a JSymbolPreviewButton which is used to select the background symbol

         *

         * @return JSymbolPreviewButton

         */

        private JSymbolPreviewButton getBtnBackground() {

                if (backSymbol == null) {

                        backSymbol = new JSymbolPreviewButton(Geometry.TYPES.SURFACE);

                        backSymbol.setPreferredSize(new Dimension(100, 45));

            ISymbol fillsym = MapContextLocator.getSymbolManager().createSymbol(

                Geometry.TYPES.SURFACE, Color.ORANGE);

            backSymbol.setSymbol(fillsym);

                }

                return backSymbol;

        }

        /**

         * Creates a new symbol of an specific shapetype with a concrete size

         *

         * @param shapeType

         * @param size

         *

         * @return ISymbol symbol created

         */

        private ISymbol newSymbol(int shapeType, double size) {

                if (getTemplSymbol().getSymbol() == null) {

                        ISymbol templateSymbol;

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            if( geomManager.isSubtype(Geometry.TYPES.POINT, shapeType) ||

                geomManager.isSubtype(Geometry.TYPES.MULTIPOINT, shapeType) ||

                geomManager.isSubtype(Geometry.TYPES.SURFACE, shapeType) ||

                geomManager.isSubtype(Geometry.TYPES.MULTISURFACE, shapeType) ) {

                                templateSymbol = new SimpleMarkerSymbol();

                                ((SimpleMarkerSymbol) templateSymbol).setSize(size);

                                ((SimpleMarkerSymbol) templateSymbol).setColor(Color.DARK_GRAY);

            } else if( geomManager.isSubtype(Geometry.TYPES.CURVE, shapeType) ||

                geomManager.isSubtype(Geometry.TYPES.MULTICURVE, shapeType) ) {

                                templateSymbol = new SimpleLineSymbol();

                                ((SimpleLineSymbol) templateSymbol).setLineWidth(size);

                                ((SimpleLineSymbol) templateSymbol).setLineColor(Color.DARK_GRAY);

            } else {

                                throw new RuntimeException("Unknown symbol type");

            }

                        getTemplSymbol().setSymbol(templateSymbol);

                        return newSymbol(shapeType, size);

                } else {

                        // clone symbol

                        ISymbol mySymbol = getTemplSymbol().getSymbol();

                        try {

                mySymbol = (ISymbol) mySymbol.clone();

            } catch (CloneNotSupportedException e) {

                logger.info("Error while cloning symbol", e);

                ApplicationLocator.getManager().messageDialog(

                    Messages.getText("_Unable_to_clone_symbol"),

                    Messages.getText("error"),

                    JOptionPane.ERROR_MESSAGE);

            }

                        if (mySymbol instanceof ILineSymbol) {

                                ILineSymbol lSym = (ILineSymbol) mySymbol;

                                lSym.setLineWidth(size);

                        }

                        if (mySymbol instanceof IMarkerSymbol) {

                                IMarkerSymbol mSym = (IMarkerSymbol) mySymbol;

                                mSym.setSize(size);

                                if (ProportionalSymbolsLegend.isPolygonal(shapeType)) {

                                        // this is to allow using in Polygon layers

                                        MarkerFillSymbol fillSymbol = new MarkerFillSymbol();

                                        fillSymbol.setOutline(null);

                                        fillSymbol.setFillColor(null);

                                        fillSymbol.getMarkerFillProperties().

                                        setFillStyle(IMarkerFillPropertiesStyle.SINGLE_CENTERED_SYMBOL);

                                        fillSymbol.setMarker(mSym);

                                }

                        }

                        return mySymbol;

                }

        }

        /**

         * Fills the comboboxes that are placed in the panel with the classifying field names of the layer

         * which contain numerical information

         *

         */

        private void fillFieldNames() {

                // SelectableDataSource rs;

                try {

                    FeatureStore fsto = (FeatureStore) ((FLyrVect) myLayer).getDataStore();

                    FeatureType fty = fsto.getDefaultFeatureType();

                    FeatureAttributeDescriptor[] atts = fty.getAttributeDescriptors();

                        int cont = 0;

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

                            if (atts[i].getDataType().isNumeric()) {

                    cont++;

                            }

                        }

                        String[] nomFields = new String[cont];

                        cont = 0;

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

                if (atts[i].getDataType().isNumeric()) {

                    nomFields[cont] = atts[i].getName();

                    cont++;

                }

            }

                        this.fieldNames = nomFields;

                        DefaultComboBoxModel cMValue = new DefaultComboBoxModel(this.fieldNames);

                        DefaultComboBoxModel cMNormalization = new DefaultComboBoxModel(this.fieldNames);

                        cmbValue.setModel(cMValue);

                        cmbNormalization.setModel(cMNormalization);

                        cmbNormalization.addItem(noNormalization);

                } catch (DataException e) {

                    logger.info("Error while getting fields", e);

                    ApplicationLocator.getManager().messageDialog(

                        Messages.getText("_Error_while_getting_fields"),

                Messages.getText("error"),

                        JOptionPane.ERROR_MESSAGE);

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

                }

        }

        public void setData(FLayer lyr, ILegend legend) {

                this.myLayer = (ClassifiableVectorial) lyr;

                fillFieldNames();

            int myt = Geometry.TYPES.GEOMETRY;

            try {

                myt = this.myLayer.getGeometryType().getType();

            } catch (ReadException re) {

                logger.info("Error while getting geometry type", re);

                ApplicationLocator.getManager().message(

                    "Error getting geometry type",

                    JOptionPane.ERROR_MESSAGE);

            }

                templateShapeType =

                    ProportionalSymbolsLegend.isPolygonal(myt) ?

                    Geometry.TYPES.POINT : myt;

                getTemplSymbol().setShapeType(templateShapeType);

                if (ProportionalSymbolsLegend.isPolygonal(myt) && backgroundPanel == null) {

                    symbolPanel.add(getBackgroundPanel());

                }

                if (ProportionalSymbolsLegend.class.equals(legend.getClass())) {

            auxLegend = (ProportionalSymbolsLegend) legend.cloneLegend();

                        cmbValue.setSelectedItem(auxLegend.getClassifyingFieldNames()[0]);

                        ISymbol defSymbol = auxLegend.getDefaultSymbol();

                        if(((ProportionalSymbolsLegend) auxLegend).getUseNormalization())

                                cmbNormalization.setSelectedItem(auxLegend.getClassifyingFieldNames()[1]);

                        else cmbNormalization.setSelectedItem(noNormalization);

                        txtMaxSize.setDouble(auxLegend.getMaxSize());

                        txtMinSize.setDouble(auxLegend.getMinSize());

                        if (ProportionalSymbolsLegend.isLinear(templateShapeType)) {

                            ((ILineSymbol)defSymbol).setLineWidth(2);

                        } else {

                ((IMarkerSymbol)defSymbol).setSize(15);

                        }

                        getTemplSymbol().setSymbol(defSymbol);

                        if(((ProportionalSymbolsLegend) auxLegend).getBackgroundSymbol() != null)

                                getBtnBackground().setSymbol(((ProportionalSymbolsLegend) auxLegend).getBackgroundSymbol());

                } else {

                        auxLegend = new ProportionalSymbolsLegend();

                        auxLegend.setTemplateShapeType(templateShapeType);

                        if (ProportionalSymbolsLegend.isLinear(templateShapeType)) {

                    auxLegend.setDefaultSymbol(newSymbol(templateShapeType, 2));

                        } else {

                    auxLegend.setDefaultSymbol(newSymbol(templateShapeType, 15));

                        }

                        getTemplSymbol().setSymbol(auxLegend.getDefaultSymbol());

                        if (ProportionalSymbolsLegend.isLinear(templateShapeType)) {

                txtMinSize.setDouble(3);

                txtMaxSize.setDouble(3);

                        } else {

                txtMinSize.setDouble(10);

                txtMaxSize.setDouble(10);

                        }

                }

        }

        public ILegend getLegend() {

                ProportionalSymbolsLegend theLegend = new ProportionalSymbolsLegend();

                String[] fieldNames = new String[2];

                fieldNames[0]= cmbValue.getSelectedItem().toString();

                if(!useNormalization)

                        fieldNames[1]= fieldNames[0];

                else fieldNames[1]= cmbNormalization.getSelectedItem().toString();

                auxLegend.setTemplateShapeType(templateShapeType);

                auxLegend.setValueField(cmbValue.getSelectedItem().toString());

                auxLegend.setNormalizationField(cmbNormalization.getSelectedItem().toString());

                auxLegend.setUseNormalization(useNormalization);

                auxLegend.setMinSize(txtMinSize.getDouble());

                auxLegend.setMaxSize(txtMaxSize.getDouble());

                ISymbol symbol = getTemplSymbol().getSymbol();

                symbol.setDescription(getSymbolDescription());

                auxLegend.setDefaultSymbol(symbol);

        auxLegend.clear();

                auxLegend.addSymbol("defaultSymbol", symbol);

                auxLegend.setBackgroundSymbol(getBtnBackground().getSymbol());

                auxLegend.setClassifyingFieldNames(fieldNames);

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

                FLyrVect vect = (FLyrVect) myLayer;

                FeatureStore fsto = null;

                FeatureType fty = null;

                FeatureAttributeDescriptor[] atts = null;

                try {

                    fsto = (FeatureStore) vect.getDataStore();

                    fty = fsto.getDefaultFeatureType();

                    int[] fieldTyp = new int[2];

                    fieldTyp[0] = fty.getAttributeDescriptor(fieldNames[0]).getType();

            fieldTyp[1] = fty.getAttributeDescriptor(fieldNames[1]).getType();

            auxLegend.setClassifyingFieldTypes(fieldTyp);

                    FeatureSet fset = fsto.getFeatureSet();

                    DisposableIterator diter = fset.fastIterator();

                    Feature fitem = null;

                    double[] maxs = new double[fieldNames.length];

            double[] mins = new double[fieldNames.length];

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

                // init to worst values

                maxs[i] = -Double.MAX_VALUE;

                mins[i] = Double.MAX_VALUE;

            }

            double aux_dob = 0;

                    while (diter.hasNext()) {

                        fitem = (Feature) diter.next();

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

                            aux_dob = fitem.getDouble(fieldNames[i]);

                            if (aux_dob > maxs[i]) {

                                maxs[i] = aux_dob;

                            }

                    if (aux_dob < mins[i]) {

                        mins[i] = aux_dob;

                    }

                        }

                    }

            auxLegend.setMinFeature(mins[0]);

            auxLegend.setMaxFeature(maxs[0]);

                } catch (DataException e) {

                    logger.info("Error while creating ProportionalSymbols legend", e);

                    ApplicationLocator.getManager().message(

                        Messages.getText("_Error_while_creating_legend"),

                        JOptionPane.ERROR_MESSAGE);

                }

        theLegend = (ProportionalSymbolsLegend) auxLegend.cloneLegend();

        // theLegend.addSymbol("defaultSymbol", symbol);

                return theLegend;

        }

        /**

         * Creates the String which will be the description of the symbol. If the selected normalization field

         * is not "None", then the String created will have this structure ValueField/NormalizationField. Else,

         * if the user select "None" for the normalization field,the string will show the ValueField only.

         *

         * @return String        description for the symbol

         */

        private String getSymbolDescription() {

                String description = "";

                if (cmbValue.getSelectedItem() != null)

                        description += cmbValue.getSelectedItem().toString();

                if (cmbNormalization.getSelectedItem().toString().compareTo(noNormalization) != 0 )

                        description += " / "+cmbNormalization.getSelectedItem().toString();

                return description;

        }

        public String getDescription() {

                return Messages.getText(

                    "draw_quantities_using_symbol_size_to_show_exact_values");

        }

        public ImageIcon getIcon() {

            return IconThemeHelper.getImageIcon(

                "legend-overview-proportional-symbols");

        }

        public Class getParentClass() {

                return Quantities.class;

        }

        public String getTitle() {

            return Messages.getText("proportional_symbols");

        }

        public Class getLegendClass() {

                return ProportionalSymbolsLegend.class;

        }

        public boolean isSuitableFor(FLayer layer) {

                if (layer instanceof FLyrVect) {

                        FLyrVect lyr = (FLyrVect) layer;

                        try {

                                if (lyr.getShapeType() == Geometry.TYPES.GEOMETRY)

                                        return false;

                                FeatureStore fsto = (FeatureStore) lyr.getDataStore();

                                FeatureType fty = fsto.getDefaultFeatureType();

                                FeatureAttributeDescriptor[] atts = fty.getAttributeDescriptors();

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

                                        if (atts[i].getDataType().isNumeric()) {

                                                return true;

                                        }

                                }

                        } catch (DataException e) {

                            logger.info("Error in isSuitableFor", e);

                            ApplicationLocator.getManager().message(

                                Messages.getText("_Error_while_checking_suitability"),

                                JOptionPane.ERROR_MESSAGE);

                                return false;

                        }

                }

                return false;

        }

        public JPanel getPanel() {

                return this;

        }

        private ActionListener action = new ActionListener() {

                public void actionPerformed(ActionEvent e) {

                        if (e.getSource().equals(cmbValue)) {

                                JComboBox cb = (JComboBox) e.getSource();

                                auxLegend.setValueField(cb.getSelectedItem().toString());

                        }

                        if (e.getSource().equals(cmbNormalization)) {

                                JComboBox cb = (JComboBox) e.getSource();

                                if(cb.getSelectedItem().toString().compareTo(noNormalization) == 0) {

                                        useNormalization = false;

                                        auxLegend.setNormalizationField(cmbValue.getSelectedItem().toString());

                                }

                                else {

                                        useNormalization = true;

                                        auxLegend.setNormalizationField(cb.getSelectedItem().toString());

                                }

                                auxLegend.setUseNormalization(useNormalization);

                        }

                        if (e.getSource().equals(txtMinSize)) {

//                                ISymbol sym = tmplateSymbol.getSymbol();

//                                if(sym != null) {

//                                        if(sym instanceof ILineSymbol) {

//                                                ILineSymbol line = (ILineSymbol)sym;

//                                                line.setLineWidth(txtMinSize.getDouble());

//                                                tmplateSymbol.setSymbol(line);

//                                        }

//

//                                        if(sym instanceof IMarkerSymbol) {

//                                                IMarkerSymbol point = (IMarkerSymbol)sym;

//                                                point.setSize(txtMinSize.getDouble());

//                                                tmplateSymbol.setSymbol(point);

//                                        }

//                                        tmplateSymbol.repaint();

//                                }

                                if(txtMaxSize.getDouble() < txtMinSize.getDouble())

                                        txtMaxSize.setDouble(txtMinSize.getDouble());

                        }

                        if(e.getSource().equals(txtMaxSize)) {

                                if(txtMaxSize.getDouble() < txtMinSize.getDouble())

                                        txtMinSize.setDouble(txtMaxSize.getDouble());

                        }

//                        if(e.getSource().equals(tmplateSymbol)) {

//                                ISymbol sym = tmplateSymbol.getSymbol();

//                                if(sym != null) {

//                                        if(sym instanceof ILineSymbol) {

//                                                ILineSymbol line = (ILineSymbol)sym;

//                                                txtMinSize.setDouble(((int)line.getLineWidth()));

//                                                txtMaxSize.setDouble(((int)line.getLineWidth()));

//                                        }

//

//                                        if(sym instanceof IMarkerSymbol) {

//                                                IMarkerSymbol point = (IMarkerSymbol)sym;

//                                                txtMinSize.setDouble(((int)point.getSize()));

//                                                txtMaxSize.setDouble(((int)point.getSize()));

//

//                                        }

//                                }

//                        }

                }

        };

}