gvSIG tools: basic charts

    final static private Logger LOGGER = LoggerFactory.getLogger(BarsChartLegend.class);

    public static class RegisterLegend implements Callable {

        @Override

        public Object call() throws Exception {

            MapContextManager manager = MapContextLocator.getMapContextManager();

            return Boolean.TRUE;

        }

    }

    public static final String BARS_CHART_LEGEND_PERSISTENCE_DEFINITION_NAME = "BarsChartLegend";

    private static final String FIELD_NAMES = "FieldLegendNames";

    private static final String FIELD_LABEL_NAMES = "FieldLabelNames";

    private static final String FIELD_LABEL_COLOR = "FieldLabelColor";

    protected ISymbol backgroundSymbol;

    protected String[] fields;

    protected String[] labels;

    protected int size = 150;

    protected boolean is3D;

    protected boolean isOutlineShow;

    protected Color outlineColor;

    protected int outlineWidth;

    protected boolean onlySelection = false;

    protected int referenceSystem = 0;

    protected String fieldSize;

    protected String fieldNormalize = "---";

    protected int sizeFrom = 10;

    protected int sizeTo = 1000;

    protected int unit = -1;

    protected int sizeOption = IChartSymbol.SIZEFIXED;

    protected boolean isActiveLimits;

    protected double minFeature;

    protected double maxFeature;

    protected Color[] colors = null;

    protected IChartSymbol symbol;

    private double maxField;

    protected FeatureSelection featSelection;

    public BarsChartLegend() {

    }

    public BarsChartLegend(int shapeType) {

        super(shapeType);

    }

    @Override

    public void draw(BufferedImage image, Graphics2D g, ViewPort viewPort,

            Cancellable cancel, double scale, Map queryParameters,

            ICoordTrans coordTrans, FeatureStore featureStore,

            FeatureQuery featureQuery) throws LegendException {

        try {

            this.featSelection = featureStore.getFeatureSelection();

            System.out.println("CHARTLEGEND: " + featSelection.getSelectedCount() + " seleccionados.");

        } catch (DataException e) {

            e.printStackTrace();

        }

        super.draw(image, g, viewPort, cancel, scale, queryParameters, coordTrans,

                featureStore, featureQuery);

    }

    @Override

    public boolean is3D() {

        return is3D;

    }

    @Override

    public void setIs3D(boolean b) {

        is3D = b;

    }

    @Override

    public int getSize() {

        return size;

    }

    @Override

    public void setSize(int size) {

        this.size = size;

    }

    @Override

    public boolean isOutlineShow() {

        return isOutlineShow;

    }

    @Override

    public void setOutlineShow(boolean isOutlineShow) {

        this.isOutlineShow = isOutlineShow;

    }

    @Override

    public Color getOutlineColor() {

        return outlineColor;

    }

    @Override

    public void setOutlineColor(Color outlineColor) {

        this.outlineColor = outlineColor;

    }

    @Override

    public int getOutlineWidth() {

        return outlineWidth;

    }

    @Override

    public void setOutlineWidth(int outlineWidth) {

        this.outlineWidth = outlineWidth;

    }

    @Override

    public void setOnlySelection(boolean onlySelection) {

        this.onlySelection = onlySelection;

    }

    @Override

    public boolean isOnlySelection() {

        return onlySelection;

    }

    @Override

    public ISymbol getBackgroundSymbol() {

        return backgroundSymbol;

    }

    @Override

    public void setBackgroundSymbol(ISymbol backgroundSymbol) {

        this.backgroundSymbol = backgroundSymbol;

    }

    @Override

    public int getSizeOption() {

        return this.sizeOption;

    }

    @Override

    public String getFieldSize() {

        return this.fieldSize;

    }

    @Override

    public String getFieldNormalize() {

        return this.fieldNormalize;

    }

    @Override

    public int getSizeFrom() {

        return this.sizeFrom;

    }

    @Override

    public int getSizeTo() {

        return this.sizeTo;

    }

    @Override

    public int getUnit() {

        return unit;

    }

    @Override

    public void setSizeFrom(int s) {

        this.sizeFrom = s;

    }

    @Override

    public void setSizeTo(int s) {

        this.sizeTo = s;

    }

    @Override

    public void setUnit(int unit) {

        this.unit = unit;

    }

    @Override

    public void setFieldSize(String f) {

        this.fieldSize = f;

    }

    @Override

    public void setFieldNormalize(String f) {

        this.fieldNormalize = f;

    }

    @Override

    public void setSizeOption(int option) {

        this.sizeOption = option;

    }

    @Override

    public boolean isActiveLimits() {

        return isActiveLimits;

    }

    @Override

    public void setActiveLimits(boolean b) {

        this.isActiveLimits = b;

    }

    @Override

    public Color[] getColors() {

        return colors;

    }

    @Override

    public void setColors(Color[] colors) {

        this.colors = colors;

        updateSymbols();

    }

    @Override

    public int getReferenceSystem() {

        return referenceSystem;

    }

    @Override

    public void setReferenceSystem(int rs) {

        this.referenceSystem = rs;

    }

    @Override

    public void setMinFeature(double min) {

        this.minFeature = min;

    }

    @Override

    public void setMaxFeature(double max) {

        this.maxFeature = max;

    }

    @Override

    public ISymbol getSymbolByFeature(Feature feat) throws MapContextException {

        Feature feat2 = feat.getCopy();

        if (this.onlySelection) {

            if (!featSelection.isSelected(feat)) {

                return null;

            }

        }

        // TODO: AQU? PRODR?AMOS RECUPERAR VARIOS SIMBOLOS. POR AHORA, SUPONEMOS QUE EL DEFAULTSYMBOL ES EL QUE TIENE EL CHARTSYMBOL

        symbol = (IChartSymbol) getDefaultSymbol();

        if (symbol == null) {

            symbol = (IChartSymbol) MapContextLocator

                    .getSymbolManager().createSymbol(IChartSymbol.SYMBOL_NAME);

        }

        symbol.setOnlySelection(onlySelection);

        double size1 = 0d;

        ChartDataSet dataSet = ChartLocator.getServiceManager()

                .getChartManager().createChartDataSet();

        String[] names = getFieldNames();

        if (names != null) {

            ArrayList groupedBy = new ArrayList();

            ArrayList serie = new ArrayList();

            ArrayList category = new ArrayList();

            for (String name : names) {

                double val = feat2.getDouble(name);

                if (sizeOption == IChartSymbol.SIZESUM) {

                    size1 += val;

                }

                groupedBy.add(name);

                serie.add("default");

                category.add(val);

            }

            dataSet.addData("groupby", groupedBy);

            dataSet.addData("series", serie);

            dataSet.addData("categories", category);

            symbol.getChart().setChartDataSet(dataSet);

            ChartService cs = symbol.getChart();

            cs.getChartProperties().setChartDimension(this.is3D);

            List<ChartSerieEntity> lst = cs.getChartLegendItems();

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

                item.setSeriesKey(names[j]);

                ChartSerieEntity e = cs.createNewChartSerieEntity(item);

                if (e != null) {

                    lst.add(e);

                }

            }

        }

        double separation = sizeTo - sizeFrom;

        switch (sizeOption) {

            case IChartSymbol.SIZESUM:

                if (isActiveLimits()) {

                    double difFeat = maxFeature - minFeature;

                    double step = difFeat / separation;

                    size1 = sizeFrom + ((size1 - minFeature) / step);

                }

                symbol.setSize(size1);

                break;

            case IChartSymbol.SIZEFIELD:

                if (separation == 0) {

                    separation = 1;

                }

                double value = feat2.getDouble(getFieldSize());

                if (!getFieldNormalize().equals("---")) {

                    double normalize = feat2.getDouble(getFieldNormalize());

                    if (normalize != 0) {

                        value = value / normalize;

                    }

                    if (isActiveLimits()) {

                        size1 = sizeFrom + (value * separation);

                    } else {

                        size1 = value;

                    }

                } else {

                    if (isActiveLimits()) {

                        double difFeat = maxFeature - minFeature;

                        double step = difFeat / separation;

                        size1 = sizeFrom + ((value - minFeature) / step);

                    } else {

                        size1 = value;

                    }

                }

                symbol.setSize(size1);

                break;

            default:

                symbol.setSize(getSize());

                break;

        }

        return symbol;

    }

    public String[] getFieldNames() {

        return fields;

    }

    @Override

    public String[] getFieldLabels() {

        if (labels == null) {

            return new String[0];

        }

        return labels;

    }

    @Override

    public void setFields(String[] fields) {

        this.fields = fields;

        updateSymbols();

    }

    @Override

    public void setLabels(String[] fields) {

        this.labels = fields;

        updateSymbols();

    }

    @SuppressWarnings({"unchecked", "rawtypes"})

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        // Set parent properties

        super.loadFromState(state);

        this.fields = state.getStringArray(FIELD_NAMES);

        this.labels = state.getStringArray(FIELD_LABEL_NAMES);

        this.colors = (Color[]) state.getArray(FIELD_LABEL_COLOR, Color.class);

        // Set own properties

        this.backgroundSymbol = (ISymbol) state.get("backgroundSymbol");

        this.size = state.getInt("size");

        this.is3D = state.getBoolean("is3D");

        this.isOutlineShow = state.getBoolean("isOutlineShow");

        this.onlySelection = state.getBoolean("onlySelection");

        this.isActiveLimits = state.getBoolean("isActiveLimits");

        this.outlineWidth = state.getInt("outlineWidth");

        this.referenceSystem = state.getInt("referenceSystem");

        this.sizeFrom = state.getInt("sizeFrom");

        this.sizeTo = state.getInt("sizeTo");

        this.unit = state.getInt("unit");

        this.sizeOption = state.getInt("sizeOption");

        this.outlineColor = (Color) state.get("outlineColor");

        this.symbol = (IChartSymbol) state.get("symbol");

        this.featSelection = (FeatureSelection) state.get("featSelection");

        this.fieldSize = state.getString("fieldSize");

        this.fieldNormalize = state.getString("fieldNormalize");

        this.minFeature = state.getDouble("minFeature");

        this.maxFeature = state.getDouble("maxFeature");

        this.maxField = state.getDouble("maxField");

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        // Save parent properties

        super.saveToState(state);

        // Save own properties

        state.set(FIELD_NAMES, this.fields);

        state.set(FIELD_LABEL_NAMES, this.labels);

        state.set(FIELD_LABEL_COLOR, this.colors);

        state.set("backgroundSymbol", this.backgroundSymbol);

        state.set("size", this.size);

        state.set("is3D", this.is3D);

        state.set("isOutlineShow", this.isOutlineShow);

        state.set("onlySelection", this.onlySelection);

        state.set("isActiveLimits", this.isActiveLimits);

        state.set("outlineWidth", this.outlineWidth);

        state.set("referenceSystem", this.referenceSystem);

        state.set("sizeFrom", this.sizeFrom);

        state.set("sizeTo", this.sizeTo);

        state.set("unit", this.unit);

        state.set("sizeOption", this.sizeOption);

        state.set("outlineColor", this.outlineColor);

        state.set("symbol", this.symbol);

        state.set("featSelection", this.featSelection);

        state.set("fieldSize", this.fieldSize);

        state.set("fieldNormalize", this.fieldNormalize);

        state.set("minFeature", this.minFeature);

        state.set("maxFeature", this.maxFeature);

        state.set("maxField", this.maxField);

    }

    public static class RegisterPersistence implements Callable {

        @Override

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager.getDefinition(BARS_CHART_LEGEND_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition = manager.addDefinition(

                        BarsChartLegend.class,

                        BARS_CHART_LEGEND_PERSISTENCE_DEFINITION_NAME,

                        BARS_CHART_LEGEND_PERSISTENCE_DEFINITION_NAME + " Persistence definition",

                        null,

                        null

                );

                // Extend the Classified Vector Legend base definition

                definition.extend(manager.getDefinition(VECTORIAL_UNIQUE_VALUE_LEGEND_PERSISTENCE_DEFINITION_NAME));

                // Field names

                definition.addDynFieldArray(FIELD_NAMES)

                        .setClassOfItems(String.class);

                definition.addDynFieldArray(FIELD_LABEL_NAMES)

                        .setClassOfItems(String.class);

                definition.addDynFieldArray(FIELD_LABEL_COLOR)

                        .setClassOfItems(Color.class);

                definition.addDynField("backgroundSymbol").setClassOfValue(ISymbol.class);

                definition.addDynFieldInt("size");

                definition.addDynFieldBoolean("is3D");

                definition.addDynFieldBoolean("isOutlineShow");

                definition.addDynFieldBoolean("onlySelection");

                definition.addDynFieldBoolean("isActiveLimits");

                definition.addDynFieldInt("outlineWidth");

                definition.addDynFieldInt("referenceSystem");

                definition.addDynFieldInt("sizeFrom");

                definition.addDynFieldInt("sizeTo");

                definition.addDynFieldInt("unit");

                definition.addDynFieldInt("sizeOption");

                definition.addDynFieldObject("outlineColor").setClassOfValue(Color.class);

                definition.addDynFieldObject("symbol").setClassOfValue(IChartSymbol.class);

                definition.addDynFieldObject("featSelection").setClassOfValue(FeatureSelection.class);

                definition.addDynFieldString("fieldSize");

                definition.addDynFieldString("fieldNormalize");

                definition.addDynFieldDouble("minFeature");

                definition.addDynFieldDouble("maxFeature");

                definition.addDynFieldDouble("maxField");

            }

            return Boolean.TRUE;

        }

    }

        for (ISymbol symbol1 : symbols) {

            delSymbol(getSymbolKey(symbol1));

                LOGGER.warn("The length of fields and colors isn't the same: fields.length = " + fields.length

                        + " colors.length = " + colors.length);

                LOGGER.warn("The length of fields and labels isn't the same: fields.length = " + fields.length

                        + " labels.length = " + labels.length);

                ISimpleFillSymbol symbol1 = SymbologyLocator.getSymbologyManager().createSimpleFillSymbol();

                symbol1.setColor(colors[i]);

                symbol1.setDescription(labels[i]);

                addSymbol(fields[i], symbol1);