Application: gvSIG desktop » gvSIG legends: base legends

import org.gvsig.andami.IconThemeHelper;

        IconThemeHelper.registerIcon("legend", "legend-overview-vectorial-aggregated", this);

_Aggregate_legend_description=Leyenda de agrupaci\u00f3n de marcadores

_Aggregate_legend=Agrupaci\u00f3n de marcadores

_Use_basic_cluster_mark=Usar estilo b\u00e1sico para la agrupaci\u00f3n de marcadores

_Use_styled_cluster_mark=Usar un estilo avanzado para la agrupaci\u00f3n de marcadores

_Symbol_size=Tama\u00f1o de simbolo

_Outline_color=Color del contorno

_Fill_color=Color de relleno

_Text_color=Color de texto

_Text_font=Fuente del texto

_Show_bounds=Mostrar l\u00edmites

_Style=Estilo

_Operation=Operaci\u00f3n

_Attribute=Atributo

_Aditional_value=Valor adicional

Alpha=Alpha

_Average=Media

_Calculate_the_average_of_the_selected_attribute_for_the_grouped_features=Calcula la media del atributo seleccionado para las features agrupadas

_Count=Cuenta

_Count_of_grouped_features=Cuenta de las features agrupadas

_Maximum=M\u00e1ximo

_Calculate_the_maximum_of_the_selected_attribute_for_the_grouped_features=Calcula el maximo del atributo seleccionado para las features agrupadas

_Minimun=Minimo

_Calculate_the_minimun_of_the_selected_attribute_for_the_grouped_features=Calcula el minimo del atributo seleccionado para las features agrupadas

_Select_style=Seleccion de estilo

_Sum=Suma

_Calculate_the_sum_of_the_selected_attribute_for_the_grouped_features=Calcula la suma del atributo seleccionado para las features agrupadas

_Aggregate_legend_description=Marker clustering legend

_Aggregate_legend=Marker clustering

_Use_basic_cluster_mark=Use basic style cluster mark

_Use_styled_cluster_mark=Use advanced style cluster mark

_Symbol_size=Symbol size

_Outline_color=Outline color

_Fill_color=Fill color

_Text_color=Text color

_Text_font=Text font

_Show_bounds=Show bounds

_Style=Style

_Operation=Operation

_Attribute=Attribute

_Aditional_value=Aditional value

Alpha=Alpha

_Average=Average

_Calculate_the_average_of_the_selected_attribute_for_the_grouped_features=Calculate the average of the selected attribute for the grouped features

_Count=Count

_Count_of_grouped_features=Count of grouped features

_Maximum=Maximum

_Calculate_the_maximum_of_the_selected_attribute_for_the_grouped_features=Calculate the maximum of the selected attribute for the grouped features

_Minimun=Minimun

_Calculate_the_minimun_of_the_selected_attribute_for_the_grouped_features=Calculate the minimun of the selected attribute for the grouped features

_Select_style=Select style

_Calculate_the_sum_of_the_selected_attribute_for_the_grouped_features=Calculate the sum of the selected attribute for the grouped features

_Sum=Sum

package org.gvsig.legend.aggregate.lib.impl.operation;

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

import org.gvsig.legend.aggregate.lib.api.AbstractOperation;

public class CountOperation extends AbstractOperation {

    int count = 0;

    public CountOperation() {

        super("_Count", "_Count_of_grouped_features");

    }

    @Override

    public void reset() {

        count = 0;

    }

    @Override

    public void perform(Feature feature) {

        count++;

    }

    @Override

    public Object getValue() {

        return count;

    }

}

package org.gvsig.legend.aggregate.lib.impl.operation;

import java.text.MessageFormat;

import org.apache.commons.lang3.StringUtils;

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

import org.gvsig.legend.aggregate.lib.api.AbstractOperation;

public class AvgOperation extends AbstractOperation {

    private double avg = 0;

    private int count = 0;

    public AvgOperation() {

        super(

            "_Average", 

            "_Calculate_the_average_of_the_selected_attribute_for_the_grouped_features"

        );

    }

    @Override

    public boolean isAttributeRequiered() {

        return true;

    }

    @Override

    public boolean isAditionalValueRequiered() {

        return true;

    }

    @Override

    public void reset() {

        avg = 0;

        count = 0;

    }

    @Override

    public void perform(Feature feature) {

            try {

                double value = feature.getDouble(this.getAttributeName());

                avg = ( avg * count + value ) / (count+1);

                count++;

            } catch(Exception ex) {

            }

    }

    @Override

    public Object getValue() {

        return this.avg;

    }

    @Override

    public String format() {

        if( StringUtils.isEmpty(this.getAditionalValue()) ) {

            return super.format(); 

        }

        try {

            return MessageFormat.format("{0,number,"+this.getAditionalValue()+"}", this.getValue());

        } catch(Exception ex) {

            return super.format(); 

        }

    }

}

package org.gvsig.legend.aggregate.lib.impl.operation;

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

import org.gvsig.legend.aggregate.lib.api.AbstractOperation;

public class MinOperation extends AbstractOperation {

    private int min = 0;

    public MinOperation() {

        super("_Minimun", "_Calculate_the_minimum_of_the_selected_attribute_for_the_grouped_features");

    }

    @Override

    public boolean isAttributeRequiered() {

        return true;

    }

    @Override

    public void reset() {

        min = 0;

    }

    @Override

    public void perform(Feature feature) {

        try {

            int x = feature.getInt(this.getAttributeName());

            if( x > min ) {

                min = x;

            }

        } catch (Exception ex) {

        }

    }

    @Override

    public Object getValue() {

        return this.min;

    }

}

package org.gvsig.legend.aggregate.lib.impl.operation;

import java.text.MessageFormat;

import org.apache.commons.lang3.StringUtils;

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

import org.gvsig.legend.aggregate.lib.api.AbstractOperation;

public class SumOperation extends AbstractOperation {

    int sum = 0;

    public SumOperation() {

        super("_Sum", "_Calculate_the_sum_of_the_selected_attribute_for_the_grouped_features");

    }

    @Override

    public boolean isAttributeRequiered() {

        return true;

    }

    @Override

    public boolean isAditionalValueRequiered() {

        return true;

    }

    @Override

    public void reset() {

        sum = 0;

    }

    @Override

    public void perform(Feature feature) {

        try {

            double x = feature.getDouble(this.getAttributeName());

            sum += x;

        } catch (Exception ex) {

        }

    }

    @Override

    public Object getValue() {

        return sum;

    }

    @Override

    public String format() {

        if( StringUtils.isEmpty(this.getAditionalValue()) ) {

            return super.format(); 

        }

        try {

            return MessageFormat.format("{0,number,"+this.getAditionalValue().trim()+"}", this.getValue());

        } catch(Exception ex) {

            return super.format(); 

        }

    }    

}

package org.gvsig.legend.aggregate.lib.impl.operation;

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

import org.gvsig.legend.aggregate.lib.api.AbstractOperation;

public class MaxOperation extends AbstractOperation {

    private int max = 0;

    public MaxOperation() {

        super("_Maximum", "_Calculate_the_maximum_of_the_selected_attribute_for_the_grouped_features");

    }

    @Override

    public boolean isAttributeRequiered() {

        return true;

    }

    @Override

    public void reset() {

        max = 0;

    }

    @Override

    public void perform(Feature feature) {

        try {

            int x = feature.getInt(this.getAttributeName());

            if( x > max ) {

                max = x;

            }

        } catch (Exception ex) {

        }

    }

    @Override

    public Object getValue() {

        return this.max;

    }

}

import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import org.gvsig.legend.aggregate.lib.api.Operation;

import org.gvsig.legend.aggregate.lib.impl.operation.AvgOperation;

import org.gvsig.legend.aggregate.lib.impl.operation.CountOperation;

import org.gvsig.legend.aggregate.lib.impl.operation.MaxOperation;

import org.gvsig.legend.aggregate.lib.impl.operation.MinOperation;

import org.gvsig.legend.aggregate.lib.impl.operation.SumOperation;

    private Map<String,Operation> operations;

    private Operation defaultOperation = null;

        this.addOperation(new CountOperation());

        this.addOperation(new MinOperation());

        this.addOperation(new MaxOperation());

        this.addOperation(new AvgOperation());

        this.addOperation(new SumOperation());

    @Override

    public void addOperation(Operation operation) {

        if( this.operations == null ) {

            this.operations = new HashMap<>();

        }

        if( this.operations.isEmpty() ) {

            this.defaultOperation = operation;

        }

        this.operations.put(operation.getName(),operation);

    }

    @Override

    public Collection<Operation> getOperations() {

        if( this.operations == null ) {

            this.operations = new HashMap<>();

        }

        return this.operations.values();

    }

    @Override

    public Operation getDefaultOperation() {

        return this.defaultOperation;

    }

import java.awt.Font;

import java.util.logging.Level;

import javax.swing.UIManager;

import org.gvsig.fmap.mapcontext.rendering.legend.events.SymbolLegendEvent;

import org.gvsig.legend.aggregate.lib.api.AggregateLegendLocator;

import org.gvsig.legend.aggregate.lib.api.Operation;

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

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

//        private final Point pointGeo;

//        private final Rectangle2D rectangle;

        private Operation op;

        public Group(Point pointGeo, Point pointPixels, double size, Operation op) {

            this.op = op;

            this.op.reset();

//            this.pointGeo = pointGeo;

            double d2 = size * 2;

//            this.rectangle = new Rectangle2D.Double(pointPixels.getX() - distance, pointPixels.getY() - distance, d2, d2);

            this.circle = new Ellipse2D.Double(pointPixels.getX() - size, pointPixels.getY() - size, d2, d2);

            op.perform(feature);

        public Operation getOperation() {

            return this.op;

        }

    private int symbolSize; // Pixels

    private Color fillColor;

    private Color outlineColor;

    private Color textColor;

    private boolean showBounds;

    private Font font;

    private boolean useStyle;

    private Operation operation;

    private SimpleFillSymbol defaultSymbol;

        this.useStyle = false;

        this.symbolSize = 30;

        this.fillColor = new Color(0xd0ffcccc, true); // Un rojo

        this.outlineColor = new Color(0xff5f60de, true); // un azul

        this.textColor = new Color(0xff000000, true); // negro

        this.showBounds = false;

        this.labelStyle = null;        

        this.font = UIManager.getFont("Label.font");

        this.operation = AggregateLegendLocator.getAggregateLegendManager().getDefaultOperation().clone();

        this.defaultSymbol = new SimpleFillSymbol();

        this.defaultSymbol.setOutline(new SimpleLineSymbol());

        this.defaultSymbol.getOutline().setLineColor(this.outlineColor);

        this.defaultSymbol.setFillColor(this.fillColor);

        if( this.operation.isAttributeRequiered() && this.operation.getAttributeName()!=null ) {

            return new String[]{

                this.operation.getAttributeName(),

                featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName()

            };

        }

            featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName()

        };

        return this.defaultSymbol;

        return this.getDefaultSymbol();

        this.drawGroups(image, g, cancel, viewPort.getAffineTransform());

                        groups.add(new Group(pointGeo, pointPixels, getSymbolSize(), getOperation().clone()));

    private void drawGroups(BufferedImage image, Graphics2D g, Cancellable cancel, AffineTransform affineTransform) {

        g.setFont(this.font);

        FontMetrics fm = g.getFontMetrics();

        int fontAscent = fm.getAscent();

        int fontAscentAddDescentDiv2 = ((fm.getAscent() + fm.getDescent())) / 2;        

                String txt = group.getOperation().format();

                if( this.useStyle && this.labelStyle != null ) {

                    this.labelStyle.setTextFields(new String[]{txt});

                    int r = symbolSize/2;

                    g.setColor(this.fillColor);

                    g.setColor(this.outlineColor);

                    if( this.showBounds ) {

                        g.drawRect( x-r, y-r, 2*r, 2*r);

                    }

                    g.setColor(this.textColor);

                    int txtY = fontAscent + y - fontAscentAddDescentDiv2; //((fm.getAscent() + fm.getDescent())) / 2;

    public ILabelStyle getLabelStyle() {

        return this.labelStyle;

    public void setLabelStyle(ILabelStyle labelStyle) {

        this.labelStyle = labelStyle;

    public int getSymbolSize() {

        return this.symbolSize;

    public void setSymbolSize(int simbolSize) {

        boolean changed = (this.symbolSize == simbolSize);

        this.symbolSize = simbolSize;

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    public Operation getOperation() {

        return this.operation;

    @Override

    public void setOperation(Operation operation) {

        boolean changed = (this.operation.getName().equalsIgnoreCase(operation.getName()));

        this.operation = operation;

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    }

    public Color getFillColor() {

        return fillColor;

    @Override

    public void setFillColor(Color fillColor) {

        boolean changed = (this.fillColor.equals(fillColor));

        this.fillColor = fillColor;

        this.defaultSymbol.setFillColor(this.fillColor);

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    }

    @Override

    public Color getOutlineColor() {

        return outlineColor;

    }

    @Override

    public void setOutlineColor(Color outlineColor) {

        boolean changed = (this.outlineColor.equals(outlineColor));

        this.outlineColor = outlineColor;

        this.defaultSymbol.getOutline().setLineColor(this.outlineColor);

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    }

    @Override

    public boolean isShowBounds() {

        return showBounds;

    }

    @Override

    public void setShowBounds(boolean showBounds) {

        boolean changed = (this.showBounds == showBounds);

        this.showBounds = showBounds;

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    }

    @Override

    public Font getFont() {

        return font;

    }

    @Override

    public void setFont(Font font) {

        this.font = font;

        this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

    }

    @Override

    public boolean isUseStyle() {

        return useStyle;

    }

    @Override

    public void setUseStyle(boolean useStyle) {

        boolean changed = (this.useStyle == useStyle);

        this.useStyle = useStyle;

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    }

    @Override

    public Color getTextColor() {

        return this.textColor;

    }

    @Override

    public void setTextColor(Color textColor) {

        boolean changed = (this.textColor.equals(textColor));

        this.textColor = textColor;

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    }

package org.gvsig.legend.aggregate.lib.api;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

public abstract class AbstractOperation implements Operation {

    private final String name;

    private final String description;

    private String attrName;

    private String aditionalValue;

    protected AbstractOperation(String name, String description) {

        this.name = name;

        this.description = description;

        reset();

    }

    @Override

    public String getName() {

        return this.name;

    }

    @Override

    public String getDescription() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        return i18n.getTranslation(this.description);

    }

    @Override

    public boolean isAttributeRequiered() {

        return false;

    }

    @Override

    public boolean isAditionalValueRequiered() {

        return false;

    }

    @Override

    public String getAttributeName() {

        return attrName;

    }

    @Override

    public void setAttributeName(String attributeName) {

        this.attrName = attributeName;

    }

    @Override

    public String getAditionalValue() {

        return aditionalValue;

    }

    @Override

    public void setAditionalValue(String aditionalValue) {

        this.aditionalValue = aditionalValue;

    }

    @Override

    public String format() {

        return String.valueOf(getValue());

    }

    @Override

    public String toString() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        return i18n.getTranslation(this.getName());

    }

    @Override

    public Operation clone() {

        try {

            return (Operation) super.clone();

        } catch (CloneNotSupportedException ex) {

            return null;

        }

    }

}

import java.awt.Color;

import java.awt.Font;

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

    public int getSymbolSize();

    public void setSymbolSize(int simbolSize);

    Color getFillColor();

    void setFillColor(Color fillColor);

    Color getTextColor();

    void setTextColor(Color textColor);

    Font getFont();

    void setFont(Font font);

    Operation getOperation();

    void setOperation(Operation operation);

    Color getOutlineColor();

    void setOutlineColor(Color outlineColor);

    boolean isShowBounds();

    void setShowBounds(boolean showBounds);

    boolean isUseStyle();

    void setUseStyle(boolean useStyle);

import java.util.Collection;

    public Operation getDefaultOperation();

    void addOperation(Operation operation);

    public Collection<Operation> getOperations();

package org.gvsig.legend.aggregate.lib.api;

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

public interface Operation extends org.gvsig.tools.lang.Cloneable {

    public String getName();

    public String getDescription();

    public boolean isAttributeRequiered();

    public boolean isAditionalValueRequiered();

    public void reset();

    public void perform(Feature feature);

    public Object getValue();

    public String format();

    public String getAttributeName();

    public void setAttributeName(String attributeName);

    public String getAditionalValue();

    public void setAditionalValue(String constant);

    @Override

    public Operation clone();

}

import java.awt.Dimension;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.util.Collection;

import javax.swing.AbstractButton;

import javax.swing.DefaultComboBoxModel;

import javax.swing.JLabel;

import javax.swing.SwingUtilities;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

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

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

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

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

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

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

import org.gvsig.legend.aggregate.lib.api.Operation;

import org.gvsig.tools.swing.api.ColorChooserController;

import org.gvsig.tools.swing.icontheme.IconTheme;

    private final ColorChooserController outlineColor;

    private final ColorChooserController fillColor;

    private final ColorChooserController textColor;

        this.outlineColor = ToolsSwingLocator.getToolsSwingManager().createColorChooserController(

            txtOutlineColor, btnOutlineColor, sldOutlineColorAlpha

        );

        this.fillColor = ToolsSwingLocator.getToolsSwingManager().createColorChooserController(

            txtFillColor, btnFillColor, sldFillColorAlpha

        );

        this.textColor = ToolsSwingLocator.getToolsSwingManager().createColorChooserController(

            txtTextColor, btnTextColor, sldTextColorAlpha

        );

        Collection<Operation> operations = AggregateLegendLocator.getAggregateLegendManager().getOperations();

        DefaultComboBoxModel<Operation> operationsModel = new DefaultComboBoxModel<>();

        for( Operation operation : operations ) {

            operationsModel.addElement(operation);

        }        

        this.cboOperation.setModel(operationsModel);

        this.rdbBasic.addChangeListener(new ChangeListener() {

            @Override

            public void stateChanged(ChangeEvent e) {

                doChangeMode();

            }

        });

        this.rdbStyled.addChangeListener(new ChangeListener() {

            @Override

            public void stateChanged(ChangeEvent e) {

                doChangeMode();

            }

        });

        this.btnTextFont.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                showFontChooser();

            }

        });

        this.cboOperation.addItemListener(new ItemListener() {

            @Override

            public void itemStateChanged(ItemEvent e) {

                // Para evitar cuelgues en depuracion

                SwingUtilities.invokeLater(new Runnable() {

                    @Override

                    public void run() {

                        doOperationChanged();

                    }

                });

            }

        });

        this.translateAll();

    private void translate(AbstractButton component) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        component.setText(i18n.getTranslation(component.getText()));

    }

    private void translate(JLabel component) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        component.setText(i18n.getTranslation(component.getText()));

    }

    private void translateAll() {

        this.translate(this.rdbBasic);

        this.translate(this.lblSymbolSize);        

        this.translate(this.lblFillColor);

        this.translate(this.lblFillColorAlpha);

        this.translate(this.lblOutlineColor);

        this.translate(this.lblOutlineColorAlpha);

        this.translate(this.lblTextColor);

        this.translate(this.lblTextColorAlpha);

        this.translate(this.lblTextFont);

        this.translate(this.lblShowBounds);

        this.translate(this.rdbStyled);

        this.translate(this.lblStyle);

        this.translate(this.lblOperation);

        this.translate(this.lblOperationAttribute);

        this.translate(this.lblOperationValue);

    }

        this.spnSymbolSize.setValue(this.legend.getSymbolSize());

        this.outlineColor.set(this.legend.getOutlineColor());

        this.fillColor.set(this.legend.getFillColor());

        this.textColor.set(this.legend.getTextColor());

        this.chkShowBounds.setSelected(this.legend.isShowBounds());

        this.txtTextFont.setText(this.legend.getFont().getFontName());

        Operation operation = this.legend.getOperation();

        this.txtOutlineColor.setText(operation.getAditionalValue()==null? "":operation.getAditionalValue());

        if( this.layer instanceof FLyrVect ) {

            FeatureStore store = ((FLyrVect)this.layer).getFeatureStore();

            try {

                FeatureType type = store.getDefaultFeatureType();

                DefaultComboBoxModel<String> model = new DefaultComboBoxModel<>();

                for( FeatureAttributeDescriptor attr : type ) {

                    model.addElement(attr.getName());

                }

                this.cboOperationAttribute.setModel(model);

            } catch (DataException ex) {

                this.cboOperationAttribute.removeAllItems();

            }

            this.cboOperationAttribute.setSelectedIndex(0);

            this.cboOperationAttribute.setSelectedItem(operation.getAttributeName());

        }

        for( int i=0; i<this.cboOperation.getItemCount(); i++ ) {

            Operation x = (Operation) this.cboOperation.getItemAt(i);

            if( x.getName().equalsIgnoreCase(this.legend.getOperation().getName()) ) {

                this.cboOperation.setSelectedIndex(i);

                doOperationChanged();

                break;

            }

        }

        this.rdbBasic.setSelected(!this.legend.isUseStyle());

        this.rdbStyled.setSelected(this.legend.isUseStyle());

        legend.setUseStyle(this.rdbStyled.isSelected());

        legend.setSymbolSize((int) this.spnSymbolSize.getValue());

        legend.setOutlineColor(this.outlineColor.get());

        legend.setFillColor(this.fillColor.get());

        legend.setTextColor(this.textColor.get());

        legend.setShowBounds(this.chkShowBounds.isSelected());

        legend.setLabelStyle(this.style);

        Operation operation = (Operation) this.cboOperation.getSelectedItem();

        if( operation!=null ) {

            operation = operation.clone();

            if( operation.isAditionalValueRequiered() ) {

                operation.setAditionalValue(this.txtOperationValue.getText());

            }

            if( operation.isAttributeRequiered() ) {

                operation.setAttributeName((String) this.cboOperationAttribute.getSelectedItem());

            }

            this.legend.setOperation(operation);

    private void doChangeMode() {

        if( this.rdbBasic.isSelected() ) {

            this.spnSymbolSize.setEnabled(true);

            this.fillColor.setEnabled(true);

            this.outlineColor.setEnabled(true);

            this.textColor.setEnabled(true);

            this.txtTextFont.setEnabled(true);

            this.chkShowBounds.setEnabled(true);

            this.btnStyle.setEnabled(false);

        } else {

            this.spnSymbolSize.setEnabled(false);

            this.fillColor.setEnabled(false);

            this.outlineColor.setEnabled(false);

            this.textColor.setEnabled(false);

            this.txtTextFont.setEnabled(false);

            this.chkShowBounds.setEnabled(false);

            this.btnStyle.setEnabled(true);

        }

    }

    private void doOperationChanged() {

        Operation operation = (Operation) this.cboOperation.getSelectedItem();

        if( operation==null ) {

            this.cboOperationAttribute.setEnabled(false);

            this.txtOperationValue.setEnabled(false);

            this.lblOperationDescription.setText("");

            return;

        }

        this.txtOperationValue.setEnabled(operation.isAditionalValueRequiered());

        this.cboOperationAttribute.setEnabled(operation.isAttributeRequiered());

        if( operation.isAttributeRequiered() && this.cboOperationAttribute.getSelectedIndex()<0 ) {

            this.cboOperationAttribute.setSelectedIndex(0);

        }

        //this.lblOperationDescription.setText(operation.getDescription());

        this.cboOperation.setToolTipText(operation.getDescription());

    }

    private void showFontChooser() {

    }

        return i18n.getTranslation( "_Aggregate_legend_description");

        IconTheme theme = ToolsSwingLocator.getIconThemeManager().getCurrent();

        return theme.get("legend-overview-vectorial-aggregated");

	public Class getParentClass() {

		return Features.class;

	}

        I18nManager i18n = ToolsLocator.getI18nManager();

        styleSelector.setPreferredSize(new Dimension(600, 350));

            i18n.getTranslation("_Select_style"),

   <at name="rowspecs">CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE</at>

   <at name="colspecs">FILL:4DLU:NONE,FILL:8DLU:NONE,FILL:DEFAULT:NONE,FILL:DEFAULT:GROW(1.0),FILL:4DLU:NONE</at>

           <at name="colspan">3</at>

        <at name="beanclass">javax.swing.JRadioButton</at>

          <at name="classname">javax.swing.JRadioButton</at>

            <at name="actionCommand">Basic</at>

            <at name="buttonGroup">

             <object classname="com.jeta.forms.store.properties.ButtonGroupProperty">

              <at name="name">buttonGroup</at>

              <at name="groupname">1</at>

            <at name="name">rdbBasic</at>

            <at name="width">516</at>

            <at name="text">_Use_basic_cluster_mark</at>

            <at name="height">16</at>

           <at name="column">2</at>

           <at name="row">6</at>

        <at name="beanclass">javax.swing.JRadioButton</at>

          <at name="classname">javax.swing.JRadioButton</at>

            <at name="actionCommand">Styled</at>

            <at name="buttonGroup">

             <object classname="com.jeta.forms.store.properties.ButtonGroupProperty">

              <at name="name">buttonGroup</at>

              <at name="groupname">1</at>

             </object>

            </at>

            <at name="name">rdbStyled</at>

            <at name="width">516</at>

            <at name="text">_Use_styled_cluster_mark</at>

            <at name="height">16</at>

       <object classname="com.jeta.forms.store.memento.FormMemento">

           <at name="column">3</at>

           <at name="colspan">2</at>

         <at name="componentclass">com.jeta.forms.gui.form.FormComponent</at>

        <at name="id">embedded.329209227</at>

        <at name="rowspecs">CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE</at>

        <at name="colspecs">FILL:DEFAULT:NONE,FILL:DEFAULT:NONE,FILL:DEFAULT:GROW(1.0)</at>

        <at name="components">

         <object classname="java.util.LinkedList">

          <item >

           <at name="value">

            <object classname="com.jeta.forms.store.memento.BeanMemento">

             <super classname="com.jeta.forms.store.memento.ComponentMemento">

              <at name="cellconstraints">

               <object classname="com.jeta.forms.store.memento.CellConstraintsMemento">

                <at name="column">1</at>

                <at name="row">3</at>

                <at name="colspan">1</at>

                <at name="rowspan">1</at>

                <at name="halign">default</at>

                <at name="valign">default</at>

                <at name="insets" object="insets">0,0,0,0</at>

               </object>

              </at>

              <at name="componentclass">com.jeta.forms.gui.form.StandardComponent</at>

             </super>

             <at name="jetabeanclass">com.jeta.forms.gui.beans.JETABean</at>

             <at name="beanclass">com.jeta.forms.components.label.JETALabel</at>

             <at name="beanproperties">

              <object classname="com.jeta.forms.store.memento.PropertiesMemento">

               <at name="classname">com.jeta.forms.components.label.JETALabel</at>

               <at name="properties">

                <object classname="com.jeta.forms.store.support.PropertyMap">

                 <at name="border">

                  <object classname="com.jeta.forms.store.properties.CompoundBorderProperty">

                   <super classname="com.jeta.forms.store.properties.BorderProperty">

                    <at name="name">border</at>

                   </super>

                   <at name="borders">

                    <object classname="java.util.LinkedList">

                     <item >

                      <at name="value">

                       <object classname="com.jeta.forms.store.properties.DefaultBorderProperty">

                        <super classname="com.jeta.forms.store.properties.BorderProperty">

                         <at name="name">border</at>

                        </super>

                       </object>