Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

/*

 * AUTHORS (In addition to CIT):

 * 2010 Prodevelop S.L. main development

 * http://www.prodevelop.es

 */

package org.gvsig.remoteclient.arcims.styling.renderers;

import java.text.DecimalFormatSymbols;

import java.text.ParseException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.gvsig.fmap.geom.Geometry;

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

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

import org.gvsig.remoteclient.arcims.ArcXML;

import org.gvsig.remoteclient.arcims.exceptions.ArcImsException;

import org.gvsig.remoteclient.arcims.styling.symbols.ArcImsFSymbolFactory;

import org.gvsig.remoteclient.arcims.styling.symbols.IArcIMSSymbol;

import org.gvsig.remoteclient.arcims.utils.ArcImsObjectFactory;

import org.gvsig.remoteclient.arcims.utils.FieldInformation;

import org.gvsig.remoteclient.arcims.utils.ServiceInfoTags;

import org.gvsig.remoteclient.arcims.utils.ServiceInformation;

import org.gvsig.remoteclient.arcims.utils.ServiceInformationLayerFeatures;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.AbstractClassifiedVectorLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.AbstractVectorialLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.FInterval;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.SingleSymbolLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.VectorialIntervalLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.VectorialUniqueValueLegend;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Factory class to produce FLegend's from ArcIMS Renderers defintions

 * 

 * @author jsanz

 * @author vsanjaime version 2.0

 * 

 */

public class ArcImsFLegendFactory {

        private static Logger logger = LoggerFactory

                        .getLogger(ArcImsFLegendFactory.class.getName());

        private char ds;

        private ServiceInformationLayerFeatures silf;

        private ServiceInformation si;

        // We use a class variable to overwrite every label definition

        private AbstractVectorialLegend auxLabelsOuter = null;

        // private String PATRON = ArcXML.PATRON;

        // DecimalFormat formatter;

        private int featType;

        /**

         * Constructor

         * 

         * @param ds

         *            Decimal separator char

         * @param msilf

         *            An object with all the information to build the legend of a

         *            vectorial layer

         * @see org.gvsig.remoteclient.arcims.utils.ServiceInformationLayerFeatures

         */

        public ArcImsFLegendFactory(ServiceInformation msi, String layerId) {

                si = msi;

                ds = msi.getSeparators().getDs();

                ArcImsFSymbolFactory.ds = ds;

                silf = (ServiceInformationLayerFeatures) this.si.getLayerById(layerId);

                this.featType = getSymbType(silf.getFclasstype());

                DecimalFormatSymbols dfs = new DecimalFormatSymbols();

                dfs.setDecimalSeparator(ds);

        }

        /**

         * Main method on this class. It calls proper getLegend method based on type

         * of render.

         * 

         * @param render

         * @return

         * @throws ArcImsException

         */

        public ILegend getMainLegend() throws ArcImsException {

                logger.info("======Start creating main layer Legend======");

                Renderer render = silf.getLayerMainRenderer();

                ILegend leg = getLegend(render, true);

                logger.info("======Getting main Legend ("

                                + getClassName(leg.getClass()) + ")======");

                return leg;

        }

        /**

         * Main method that calls proper getLengend methods according to the type of

         * renderer is passed.

         * 

         * @param render

         * @param isMainRender

         * @return

         * @throws ArcImsException

         */

        private AbstractVectorialLegend getLegend(Renderer render,

                        boolean isMainRender) throws ArcImsException {

                AbstractVectorialLegend leg = null;

                if (render instanceof SimpleRenderer) {

                        SimpleRenderer srender = (SimpleRenderer) render;

                        leg = getLegend(srender);

                } else if (render instanceof ValueMapRenderer) {

                        ValueMapRenderer srender = (ValueMapRenderer) render;

                        leg = getLegend(srender);

                }

                // In the main legend, a ScaleDependent and a GroupRenderer can be

                // treated in the same way (ScaleDependent inherits from GroupRenderer)

                else if (render instanceof GroupRenderer) {

                        GroupRenderer groupRender = (GroupRenderer) render;

                        leg = getLegend(groupRender);

                } else {

                        leg = getDefaultLegend();

                }

                if (leg != null) {

                        logger.info("Getting Render of type: "

                                        + getClassName(render.getClass()));

                        return leg;

                } else {

                        throw new ArcImsException("arcims_legend_error");

                }

        }

        /**

         * Method to generate a valid simple legend.

         * 

         * @return

         */

        private AbstractVectorialLegend getDefaultLegend() {

                SingleSymbolLegend leg = new SingleSymbolLegend();

                leg.setDefaultSymbol(ArcImsFSymbolFactory.getDefaultFSymbol(featType));

                leg.setShapeType(featType);

                logger.info("Getting default legend");

                return leg;

        }

        /**

         * Gets a simple Legend with only one symbol

         * 

         * @see com.iver.cit.gvsig.fmap.rendering.SingleSymbolLegend

         * @param renderer

         * @return

         */

        private AbstractVectorialLegend getLegend(SimpleRenderer renderer) {

                // Get the ArcIMS Simbol

                IArcIMSSymbol imsSimb = renderer.getSymbol();

                // Get the FSymbol of the renderer

                ISymbol simb = imsSimb.getFSymbol();

                // Creates the legend

                SingleSymbolLegend leg = new SingleSymbolLegend();

                leg.setDefaultSymbol(simb);

                leg.setShapeType(this.featType);

                logger.info("Getting a Simple Renderer");

                return (AbstractVectorialLegend) leg;

        }

        /**

         * Gets a Legend based on intervals

         * 

         * @see com.iver.cit.gvsig.fmap.rendering.VectorialIntervalLegend

         * @param renderer

         * @return

         * @throws ArcImsException

         */

        private AbstractVectorialLegend getLegend(ValueMapRenderer renderer)

                        throws ArcImsException {

                // Get the proper Field Information object

                FieldInformation fi = silf.getFieldInformation(renderer

                                .getLookupfield());

                // Gets the array of ranges

                List<TypeValueMap> values = renderer.getValues();

                Iterator<TypeValueMap> it = values.iterator();

                // Creates the two types of legends

                VectorialIntervalLegend viLeg = new VectorialIntervalLegend();

                VectorialUniqueValueLegend vuLeg = new VectorialUniqueValueLegend();

                // Initialize counters

                int nIntervals = 0;

                int nUniques = 0;

                // Create a default simbol

                ISymbol defSimb = ArcImsFSymbolFactory.getDefaultFSymbol(this.featType);

                defSimb.setDescription("Default");

                boolean hasDefSymbol = false;

                // Fills with intervals and symbols

                while (it.hasNext()) {

                        // Only RangeValueMaps are allowed

                        TypeValueMap tvm = (TypeValueMap) it.next();

                        // Gets the symbol

                        IArcIMSSymbol simb = tvm.getSymbol();

                        ISymbol fsimb = simb.getFSymbol();

                        // Set the description

                        String descr = tvm.getLabel();

                        if (descr == null) {

                                descr = "";

                        }

                        fsimb.setDescription(descr);

                        if (tvm instanceof RangeValueMap) {

                                RangeValueMap rvm = (RangeValueMap) tvm;

                                // Get the bounds of the intverval

                                String sFrom = rvm.getLower();

                                String sTo = rvm.getUpper();

                                double from = Double.parseDouble(sFrom.replace(ds, '.'));

                                double to = Double.parseDouble(sTo.replace(ds, '.'));

                                if (descr == null) {

                                        fsimb.setDescription(sFrom + "-" + sTo);

                                }

                                // Creates the Interval

                                FInterval interv = new FInterval(from, to);

                                // Adds the symbol to the legend

                                viLeg.addSymbol(interv, fsimb);

                                // viLeg.setIntervalSymbol(interv,fsimb);

                                nIntervals++;

                        } else if (tvm instanceof ExactValueMap) {

                                ExactValueMap evm = (ExactValueMap) tvm;

                                // We have to build a Value object

                                String strVal = evm.getValue();

                                try {

                                        Object val = ArcImsObjectFactory.createObjectByType(strVal, fi

                                                        .getType(), this.ds);

                                        vuLeg.addSymbol(val, fsimb);

                                } catch (ParseException e) {

                                        logger.error(e.getMessage(), e);

                                        throw new ArcImsException("arcims_legend_error");

                                }

                                nUniques++;

                        } else if (tvm instanceof OtherValueMap) {

                                hasDefSymbol = true;

                                defSimb = fsimb;

                        }

                }

                /*

                 * Determine what type of legend the method will return (Unique or

                 * Interval) The condition will be the legend with more classes

                 * (intervals, values)

                 */

                AbstractVectorialLegend leg = null;

                AbstractClassifiedVectorLegend cleg = null;

                if (nUniques >= nIntervals) {

                        leg = vuLeg;

                        cleg = vuLeg;

                } else {

                        leg = viLeg;

                        cleg = viLeg;

                }

                /*

                 * Finally we can add the field name and default symbol

                 */

                // Set the field name

                String fieldName = ArcXML.replaceUnwantedCharacters(fi.getName());

                cleg.setClassifyingFieldNames(new String[]{fieldName});

                // Set the default symbol, if it is used and asign the symbol to a

                // nullvalue

                leg.setDefaultSymbol(defSimb);

                leg.useDefaultSymbol(hasDefSymbol);

                if (hasDefSymbol) {

                        if (leg instanceof VectorialUniqueValueLegend) {

                                vuLeg.addSymbol(null, leg.getDefaultSymbol());

                        } else {

                                viLeg

                                                .addSymbol(null, leg

                                                                .getDefaultSymbol());

                        }

                }

                logger.info("Getting a Value Map Renderer");

                return leg;

        }

        // /**

        // * Gets the most detailed legend from the ScaleDependentRender

        // * @param sdrender

        // * @return

        // */

        // private VectorialLegend getLegend(ScaleDependentRenderer sdrender) throws

        // ArcImsException {

        // VectorialLegend leg = getLegend((GroupRenderer) sdrender);

        // logger.info("Getting a ScaleDependent Renderer");

        // return leg;

        // }

        private AbstractVectorialLegend getLegend(GroupRenderer groupRender)

                        throws ArcImsException {

                List<Renderer> renderers = groupRender.renderers;

                List<AbstractVectorialLegend> legends = new ArrayList<AbstractVectorialLegend>();

                AbstractVectorialLegend biggerScale = null;

                AbstractVectorialLegend leg = null;

                double[] limit = { Double.MAX_VALUE, 0 };

                Iterator<Renderer> it = renderers.iterator();

                // We use a class variable to overwrite every label definition

                AbstractVectorialLegend auxLabelsInner = null;

                while (it.hasNext()) {

                        leg = null;

                        Renderer iRender = (Renderer) it.next();

                        // If we don't have a Label renderer use the generic method

                        if (!(iRender instanceof ILabelRenderer)) {

                                leg = getLegend(iRender, false);

                        }

                        // Otherwise, use the specific method for labels

                        else {

                                auxLabelsInner = getLegend((ILabelRenderer) iRender);

                        }

                        // If renderer is Scale Dependent, we inspect their scale limits

                        if (iRender instanceof ScaleDependentRenderer) {

                                ScaleDependentRenderer iSDRender = (ScaleDependentRenderer) iRender;

                                String strLow = iSDRender.getLower();

                                String strUpp = iSDRender.getUpper();

                                double low = 0;

                                double upp = Double.MAX_VALUE;

                                if (strLow != null) {

                                        low = Double.parseDouble(strLow.replace(ds, '.'));

                                }

                                if (strUpp != null) {

                                        upp = Double.parseDouble(strUpp.replace(ds, '.'));

                                }

                                // First loop

                                if (biggerScale == null) {

                                        biggerScale = leg;

                                        limit[0] = low;

                                        limit[1] = upp;

                                }

                                /*

                                 * Next loops we allways get the minimum interval If lower

                                 * bounds are equal, we get the lower upper value

                                 */

                                else if ((low <= limit[0]) && (upp <= limit[1])) {

                                        limit[0] = low;

                                        limit[1] = upp;

                                        biggerScale = leg;

                                }

                        }

                        if (leg != null) {

                                legends.add(leg);

                        }

                }

                /*

                 * TODO At this time we will return the first (bottom) legend of the

                 * ArrayList or the most detailed legend if there are any

                 * ScaleDependentRenderers Probably I will add more "logic" into this

                 * code

                 */

                AbstractVectorialLegend finalLegend = null;

                boolean onlyLabels = false;

                /*

                 * Check if auxLabels is equal to the last element of the array Legends

                 * and if it's true, merge it with the first one (its label definition)

                 */

                if (auxLabelsOuter != null && legends.size() > 0) {

                        for (int i = 0; i < legends.size(); i++) {

                                // FSymbol simb1 = auxLabelsOuter.getDefaultSymbol();

                                // FSymbol simb2 = ((VectorialLegend)

                                // legends.get(i)).getDefaultSymbol();

                                ISymbol simb1 = (ISymbol) auxLabelsOuter.getDefaultSymbol();

                                ISymbol simb2 = (ISymbol) ((AbstractVectorialLegend) legends

                                                .get(i)).getDefaultSymbol();

                                if (simb1 == simb2) {

                                        // Null the biggerScale to force the next if statement

                                        biggerScale = null;

                                        // Merge the auxLabels object into the first legend of the

                                        // arrayList

                                        AbstractVectorialLegend legend = setLabelDefIntoSymbol(

                                                        auxLabelsOuter, (AbstractVectorialLegend) legends

                                                                        .get(0));

                                        legends.set(0, legend);

                                        // Null the auxlabelsinner to avoid the last if

                                        auxLabelsInner = null;

                                        break;

                                }

                        }

                }

                // We don't have any scaledependent

                if (((biggerScale == null) && (legends.size() > 0))) {

                        // if (!(groupRender instanceof ScaleDependentRenderer)){

                        logger.info("Getting the bottom renderer of the Group Renderer");

                        finalLegend = (AbstractVectorialLegend) legends.get(0);

                }

                // We have any scaledpendent

                else if (biggerScale != null) {

                        logger

                                        .info("Getting the most detailed ScaleDependent renderer of the Group Renderer");

                        finalLegend = biggerScale;

                }

                // We don't have any legend parsed (maybe the layer only have label

                // definitions

                else {

                        //finalLegend = new SingleSymbolLegend(this.featType);

                        finalLegend = new SingleSymbolLegend();

                        finalLegend.setShapeType(this.featType);

                        onlyLabels = true;

                }

                /*

                 * Finally if some label renderer is found, we have to pass the label

                 * properties to the final legend

                 */

                if (auxLabelsInner != null) {

                        finalLegend = setLabelDefIntoSymbol(auxLabelsInner, finalLegend);

//FIXME

//                        // finalLegend.getDefaultSymbol().setShapeVisible(!onlyLabels);

//                        ((ISymbol) finalLegend.getDefaultSymbol())

//                                        .setShapeVisible(!onlyLabels);

                        auxLabelsOuter = finalLegend;

                }

                return finalLegend;

        }

        /**

         * Method that returns a SingleSymboLegend with Font definition and field to

         * retrieve labels. These properties will be transferred to the main layer

         * legend.

         * 

         * @param renderer

         * @return

         */

        private AbstractVectorialLegend getLegend(ILabelRenderer renderer) {

                // Get the proper Field Information object

                FieldInformation fi = silf.getFieldInformation(renderer.getField());

                // Create a legend

                SingleSymbolLegend leg = new SingleSymbolLegend();

                leg.setShapeType(this.featType);

                IArcIMSSymbol arcSimb = null;

                // Get the ArcIMS Symbol with Font definition

                if (renderer instanceof SimpleLabelRenderer) {

                        SimpleLabelRenderer slrender = (SimpleLabelRenderer) renderer;

                        arcSimb = slrender.getSymbol();

                } else if (renderer instanceof ValueMapLabelRenderer) {

                        ValueMapLabelRenderer vmlrender = (ValueMapLabelRenderer) renderer;

                        arcSimb = vmlrender.getValue(0).getSymbol();

                }

                // Asign it (or a default) to the legend

                if (arcSimb != null) {

                        leg.setDefaultSymbol(arcSimb.getFSymbol());

                } else {

                        leg.setDefaultSymbol(ArcImsFSymbolFactory

                                        .getDefaultFSymbol(this.featType));

                }

                // Set the label field

        //FIXME        

//                String labelField = ArcXML.replaceUnwantedCharacters(fi.getName());

//                leg.setLabelField(labelField);

                // Return the legend

                return leg;

        }

        /**

         * @return Returns the featType.

         */

        public int getFeatType() {

                return featType;

        }

        /**

         * @param featType

         *            The featType to set.

         */

        public void setFeatType(int featType) {

                this.featType = featType;

        }

        /**

         * Gets the simple class name

         * 

         * @param mclass

         * @return

         */

        private String getClassName(Class mclass) {

                String[] classSplitted = mclass.getName().split("\\.");

                return classSplitted[classSplitted.length - 1];

        }

        /**

         * Private method to set into a legend the label definition of another

         * legend

         * 

         * @param withLabels

         * @param finalLegend

         * @return

         */

        private AbstractVectorialLegend setLabelDefIntoSymbol(

                        AbstractVectorialLegend withLabels,

                        AbstractVectorialLegend finalLegend) {

//FIXME

//                // Set the label

//                finalLegend.setLabelField(withLabels.getLabelField());

//                // Get simbol with font definition

//

//                // FSymbol simbWithFont = withLabels.getDefaultSymbol();

//                ISymbol simbWithFont = (ISymbol) withLabels.getDefaultSymbol();

//

//                // Get simbol to insert font definition

//                // FSymbol simb = finalLegend.getDefaultSymbol();

//                ISymbol simb = (ISymbol) finalLegend.getDefaultSymbol();

//

//                // Insert into simb the font properties

//                simb.setFont(simbWithFont.getFont());

//                simb.setFontColor(simbWithFont.getFontColor());

//                simb.setFontSize(simbWithFont.getFontSize());

//                simb.setFontSizeInPixels(true);

//                // Set simbol modified into final legend to return

//                finalLegend.setDefaultSymbol(simb);

                return finalLegend;

        }

        /**

         * Converts ArcIMS feature type to a constant value

         * 

         * @param fclasstype

         * @return

         */

        private int getSymbType(String fclasstype) {

                if (fclasstype.equals(ServiceInfoTags.aPOLYGON)) {

                        return Geometry.TYPES.SURFACE;

                }

                if (fclasstype.equals(ServiceInfoTags.aPOLYLINE)) {

                        return Geometry.TYPES.CURVE;

                }

                if (fclasstype.equals(ServiceInfoTags.aMULTIPOINT)) {

                        return Geometry.TYPES.MULTIPOINT;

                }

                return Geometry.TYPES.NULL;

        }

}