| gvSIG desktop 1

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

import java.util.ArrayList;

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.SimpleMarkerFillPropertiesStyle;

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 IClassifiedVectorialLegend  {

        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[] getFieldNames() {

            ArrayList l = new ArrayList();

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

                        l.add(graduatedSymbol.getFieldNames()[i]);

                }

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

                        l.add(colorRamp.getFieldNames()[i]);

                }

            return (String[]) l.toArray(new String[l.size()]);

    }

    /**

     * Sets the field names required to build this legend. In this case

     * fieldNames is an array of length 2 where the first element is

     * the field name for the embedded GraduatedSymbolLegend, and the

     * second is the field name for the embedded colorRamp (VectorialIntervalLegend)

     * legend.

     */

    public void setFieldNames(String[] fieldNames) {

            if (fieldNames.length!=2) {

            }

        colorRamp.setFieldNames(new String[] {fieldNames[1]});

        graduatedSymbol.setFieldNames(new String[] {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 ILegend cloneLegend() throws XMLException {

            return (ILegend)LegendFactory.createFromXML(getXMLEntity());

    }

        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);

                        SimpleMarkerFillPropertiesStyle p = new SimpleMarkerFillPropertiesStyle();

                        p.setFillStyle(SimpleMarkerFillPropertiesStyle.SINGLE_CENTERED_SYMBOL);

                        aux.setMarkerFillProperties(p);

                        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) {

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

                ISymbol sym2 = colorRamp.getSymbolByFeature(feat);

                IMultiLayerSymbol multiSym = null;

                switch (shapeType) {

                case FShape.POLYGON:

                        multiSym = SymbologyFactory.

                        createEmptyMultiLayerSymbol(FShape.POLYGON);

                        multiSym.addLayer(sym2);

                        multiSym.addLayer(sym1);

                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 {

                if (s == null) throw new NullPointerException("Default symbol cannot be null");

                this.defaultSymbol = s;

        }

        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(ILegend legend) {

                this.graduatedSymbol = (GraduatedSymbolLegend) legend;

        }

        public void setColorRampLegend(ILegend legend) {

                this.colorRamp = (VectorialIntervalLegend) legend;

        }

        public ZSort getZSort() {

                // TODO Implement it

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

        }

        public void setZSort(ZSort zSort) {

                // TODO Implement it

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

        }

        public String getClassName() {

                return getClass().getName();

        }

        public void replace(ISymbol oldSymbol, ISymbol newSymbol) {

                ISymbol[] symbols;

                // look first in the graduated symbol legend

                symbols = graduatedSymbol.getSymbols();

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

                        if (symbols[i].equals(oldSymbol)) {

                                graduatedSymbol.replace(oldSymbol, newSymbol);

                                return;

                        }

                }

                // if the symbol wasn't found yet, proceed with color ramp

                symbols = colorRamp.getSymbols();

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

                        if (symbols[i].equals(oldSymbol)) {

                                colorRamp.replace(oldSymbol, newSymbol);

                                return;

                        }

                }

        }

}