| gvSIG desktop 1

package com.iver.cit.gvsig.fmap.rendering;

import java.util.logging.Logger;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.engine.data.DataSource;

import com.hardcode.gdbms.engine.instruction.FieldNotFoundException;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.gvsig.fmap.core.IFeature;

import com.iver.cit.gvsig.fmap.core.SymbologyFactory;

import com.iver.cit.gvsig.fmap.core.styles.MarkerFillProperties;

import com.iver.cit.gvsig.fmap.core.symbols.IMarkerSymbol;

import com.iver.cit.gvsig.fmap.core.symbols.IMultiLayerSymbol;

import com.iver.cit.gvsig.fmap.core.symbols.ISymbol;

import com.iver.cit.gvsig.fmap.core.symbols.MarkerFillSymbol;

import com.iver.cit.gvsig.fmap.layers.XMLException;

import com.iver.utiles.XMLEntity;

/**

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

 */

public class QuantityByCategoryLegend implements ClassifiedLegend, VectorialLegend  {

        private GraduatedSymbolLegend graduatedSymbol = new GraduatedSymbolLegend();

        private VectorialIntervalLegend colorRamp = new VectorialIntervalLegend();

        private ISymbol defaultSymbol;

        private int shapeType;

        private boolean isUseDefaultSymbol;

    public void clear() {

        colorRamp.clear();

        graduatedSymbol.clear();

    }

    public String getFieldName() {

            String field1 = graduatedSymbol.getFieldName();

        String field2 = colorRamp.getFieldName();

        return field1 + "&&" + field2;

    }

    public void setFieldName(String i) {

        String[] fieldNames = i.split("&&");

        colorRamp.setFieldName(fieldNames[1]);

        graduatedSymbol.setFieldName(fieldNames[0]);

    }

    public void addSymbol(Object key, ISymbol symbol) {

            System.out.println("adding "+key+"["+symbol+"]");

//        // TODO Implement it

//        throw new Error("Not yet implemented!");

    }

    public void delSymbol(Object key) {

            colorRamp.delSymbol(key);

            graduatedSymbol.delSymbol(key);

    }

    public String[] getDescriptions() {

            String[] desc1 = colorRamp.getDescriptions();

            String[] desc2 = graduatedSymbol.getDescriptions();

            String[] descriptions = new String[desc1.length + desc2.length];

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

                    descriptions[i] = (i <desc1.length) ? desc1[i] : desc2[i % desc1.length];

                }

            return descriptions;

    }

    public ISymbol[] getSymbols() {

            ISymbol[] symbols1 = colorRamp.getSymbols();

            ISymbol[] symbols2 = graduatedSymbol.getSymbols();

            ISymbol[] symbols = new ISymbol[symbols1.length + symbols2.length];

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

                    symbols[i] = (i < symbols1.length) ? symbols1[i] : symbols2[i % symbols1.length];

                }

            return symbols;

    }

    public Object[] getValues() {

            Object[] objects1 = colorRamp.getValues();

            Object[] objects2 = graduatedSymbol.getValues();

            Object[] objects = new FInterval[objects1.length + objects2.length];

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

                    objects[i] = (i < objects1.length) ? objects1[i] : objects2[i % objects1.length];

                }

            return objects;

    }

    public ISymbol getDefaultSymbol() {

            return defaultSymbol;

    }

    public XMLEntity getXMLEntity() {

        XMLEntity xml = new XMLEntity();

        xml.putProperty("className", getClass().getName());

        xml.putProperty("shapeType", shapeType);

        xml.putProperty("isUseDefaultSymbol", isUseDefaultSymbol);

        xml.addChild(graduatedSymbol.getXMLEntity());

        xml.addChild(colorRamp.getXMLEntity());

        if (defaultSymbol != null)

                xml.addChild(defaultSymbol.getXMLEntity());

        return xml;

    }

    public String getSLDString(String layerName) {

        // TODO Implement it

        throw new Error("Not yet implemented!");

    }

    public Legend cloneLegend() throws XMLException {

        // TODO Implement it

        throw new Error("Not yet implemented!");

    }

        public GraduatedSymbolLegend getGraduatedSymbolLegend() {

                return graduatedSymbol;

        }

        public VectorialIntervalLegend getColorRampLegend() {

                return colorRamp;

        }

        public void setDataSource(DataSource ds) throws FieldNotFoundException, ReadDriverException {

                graduatedSymbol.setDataSource(ds);

                colorRamp.setDataSource(ds);

        }

        public ISymbol getSymbol(int i) throws ReadDriverException {

                IMarkerSymbol sym1 = (IMarkerSymbol) graduatedSymbol.getSymbol(i);

                ISymbol sym2 =  colorRamp.getSymbol(i);

                IMultiLayerSymbol multiSym = null;

                switch (shapeType) {

                case FShape.POLYGON:

                        /*

                         * symbol from the GraduatedSymbolLegend is a marker, but

                         * what we need is a fill symbol. Will use a MarkerFillSymbol

                         * to enable support for Polygons

                         */

                        MarkerFillSymbol aux = new MarkerFillSymbol();

                        // tell the fill style to draw the IMarkerSymbol

                        // as a IFillSymbol centering it in the shape polygon

                        // centroid and applying offset (if any).

                        aux.setMarker(sym1);

                        aux.setFillStyle(MarkerFillProperties.SINGLE_CENTERED_SYMBOL);

                        multiSym = SymbologyFactory.

                                createEmptyMultiLayerSymbol(FShape.POLYGON);

                        multiSym.addLayer(sym2);

                        multiSym.addLayer(aux);

                break;

                case FShape.LINE:

                        throw new Error("Shape type not yet supported");

                default:

                        throw new Error("Unsupported shape type");

                }

                return multiSym;

        }

        public ISymbol getSymbolByFeature(IFeature feat) {

                IMarkerSymbol sym1 = (IMarkerSymbol) graduatedSymbol.getSymbolByFeature(feat);

                ISymbol sym2 = colorRamp.getSymbolByFeature(feat);

                IMultiLayerSymbol multiSym = null;

                switch (shapeType) {

                case FShape.POLYGON:

                        /*

                         * symbol from the GraduatedSymbolLegend is a marker, but

                         * what we need is a fill symbol. Will use a MarkerFillSymbol

                         * to enable support for Polygons

                         */

                        MarkerFillSymbol aux = new MarkerFillSymbol();

                        // tell the fill style to draw the IMarkerSymbol

                        // as a IFillSymbol centering it in the shape polygon

                        // centroid and applying offset (if any).

                        aux.setMarker(sym1);

                        aux.setFillStyle(MarkerFillProperties.SINGLE_CENTERED_SYMBOL);

                        multiSym = SymbologyFactory.

                        createEmptyMultiLayerSymbol(FShape.POLYGON);

                        multiSym.addLayer(sym2);

                        multiSym.addLayer(aux);

                break;

                case FShape.LINE:

                        throw new Error("Shape type not yet supported");

                default:

                        throw new Error("Unsupported shape type");

                }

                return multiSym;

        }

        public int getShapeType() {

                return shapeType;

        }

        public void setShapeType(int shapeType) {

                this.shapeType = shapeType;

                graduatedSymbol.setShapeType(FShape.POINT);

                colorRamp.setShapeType(shapeType);

        }

        public void setDefaultSymbol(ISymbol s) throws IllegalArgumentException {

                this.defaultSymbol = s;

        }

        /**

         * @deprecated

         */

        public void setLabelField(String fieldName) {

                // TODO Implement it

                throw new Error("Not yet implemented!");

        }

        /**

         * @deprecated

         */

        public void setLabelHeightField(String fieldName) {

                throw new Error("deprecated method");

        }

        /**

         * @deprecated

         */

        public void setLabelRotationField(String fieldName) {

                throw new Error("deprecated method");

        }

        /**

         * @deprecated

         */

        public String getLabelField() {

                return null;

        }

        /**

         * @deprecated

         */

        public String getLabelHeightField() {

                return null;

        }

        /**

         * @deprecated

         */

        public String getLabelRotationField() {

                return null;

        }

        public void setXMLEntity(XMLEntity xml) {

                shapeType = xml.getIntProperty("shapeType");

        isUseDefaultSymbol = xml.getBooleanProperty("isUseDefaultSymbol");

        try {

                        graduatedSymbol = (GraduatedSymbolLegend) LegendFactory.createFromXML(xml.getChild(0));

                        colorRamp = (VectorialIntervalLegend) LegendFactory.createFromXML(xml.getChild(1));

        } catch (XMLException e) {

                        // TODO Auto-generated catch block

                Logger.getAnonymousLogger().severe(e.getFormatString());

                }

        if (defaultSymbol != null)

                xml.addChild(defaultSymbol.getXMLEntity());

        }

        public void setXMLEntity03(XMLEntity xml) {

                // nothing to do here

        }

        public boolean isUseDefaultSymbol() {

                return isUseDefaultSymbol;

        }

        public void useDefaultSymbol(boolean b) {

                this.isUseDefaultSymbol = b;

        }

        public String[] getUsedFields() {

                // TODO Implement it

                throw new Error("Not yet implemented!");

        }

        public void setGraduateSymbolLegend(Legend legend) {

                this.graduatedSymbol = (GraduatedSymbolLegend) legend;

        }

        public void setColorRampLegend(Legend legend) {

                this.colorRamp = (VectorialIntervalLegend) legend;

        }

}