Application: gvSIG desktop

     *

        Color mcolor = SymbolUtils.getColor(simb.getColor(), 1);

        int pointWidth = Integer.parseInt(simb.getWidth());

        int pointStyle = getPointType(simb.getType());

        ISymbol mSimb = new FSymbol(FConstant.SYMBOL_TYPE_POINT, mcolor);

        mSimb.setSizeInPixels(true);

        mSimb.setSize(pointWidth);

        mSimb.setStyle(pointStyle);

        logger.info("Getting ArcIMS simple point symbol");

        return mSimb;

        String surl = symb.getUrl();

        // Get the icon size

        float size = 0;

        if (symb.getSize() != null) {

            String[] tams = symb.getSize().split(",");

            int ntams = tams.length;

            if (ntams != 0) {

                for (int i = 0; i < ntams; i++)

                    size += Float.parseFloat(tams[i]); // Sums different sizes

                size = size / ntams; // Get the mean

            }

        } else {

            size = 15; // Default size

        }

        // Get the icon file

        File img = getIconFile(surl);

        // If is an image, we build the symbol

        ImageFilter filter = new ImageFilter();

        if (filter.accept(img)) {

            ISymbol mSimb = new FSymbol(FConstant.SYMBOL_TYPE_POINT);

            mSimb.setStyle(FStyle2D.SYMBOL_STYLE_MARKER_IMAGEN);

            URI theUri = img.toURI();

            mSimb.setIconURI(theUri);

            mSimb.setSizeInPixels(true);

            mSimb.setSize((int) size);

            logger.info("Getting ArcIMS raster marker point symbol");

            return mSimb;

        } else {

            logger.info("Getting random point symbol");

            return getDefaultFSymbol(FConstant.SYMBOL_TYPE_POINT);

        }

        String sTrans = simb.getTransparency();

        if (ds != '.') {

            sTrans = sTrans.replace(ds, '.');

        }

        float trans = Float.parseFloat(sTrans);

        Color mcolor = SymbolUtils.getColor(simb.getColor(), trans);

        int lineWidth = Integer.parseInt(simb.getWidth());

        int intCapType = getCapType(simb.getCaptype());

        int intJoin = getJoinType(simb.getJointype());

        String linePattern = getLinePattern(simb.getType());

        BasicStroke bStroke = new BasicStroke(lineWidth, intCapType, intJoin,

                1.0f, ISymbol.toArray(linePattern, lineWidth), 0);

        ISymbol theSymbol = new FSymbol(FConstant.SYMBOL_TYPE_LINE, mcolor);

        theSymbol.setSizeInPixels(true);

        theSymbol.setSize(Integer.parseInt(simb.getWidth()));

        theSymbol.setSizeInPixels(true);

        theSymbol.setStroke(bStroke);

        logger.info("Getting ArcIMS simple line symbol");

        return theSymbol;

        SimpleLineSymbol line = new SimpleLineSymbol();

        line.setColor(symbol.getColor());

        line.setWidth(symbol.getLinethickness());

        line.setType(SymbolUtils.LINE_TYPE_SOLID);

        logger.info("Getting ArcIMS hashline as a simple line symbol");

        return line.getFSymbol();

        String sTrans = simb.getFilltransparency();

        if (ds != '.') {

            sTrans = sTrans.replace(ds, '.');

        }

        float trans = Float.parseFloat(sTrans);

        Color fColor = SymbolUtils.getColor(simb.getFillcolor(), trans);

        ISymbol mSimb = new FSymbol(FConstant.SYMBOL_TYPE_FILL, fColor);

        //Set the type of fill

        int type = getFillStyle(simb.getFilltype());

        switch (type) {

        case FConstant.SYMBOL_STYLE_FILL_GRAYFILL:

            mSimb.setColor(getGray(fColor));

            break;

        case FConstant.SYMBOL_STYLE_FILL_LIGHTGRAYFILL:

            mSimb.setColor(getLightGray(fColor));

            break;

        case FConstant.SYMBOL_STYLE_FILL_DARKGRAYFILL:

            mSimb.setColor(getDarkGray(fColor));

            break;

        default:

            Paint fill = createPatternFill(type, fColor);

            mSimb.setFill(fill);

        }

        if (simb.isHasBoundary()) {

            ISymbol bSimb = simb.getBoundary().getFSymbol();

            mSimb.setOutlined(true);

            mSimb.setOutlineColor(bSimb.getColor());

            mSimb.setStroke(bSimb.getStroke());

            int mStyle = getFillStyle(simb.getFilltype());

            mSimb.setStyle(mStyle);

        }

        logger.info("Getting ArcIMS simple polygon symbol");

        return mSimb;

        String sTrans = simb.getTransparency();

        if (ds != '.') {

            sTrans = sTrans.replace(ds, '.');

        }

        float trans = Float.parseFloat(sTrans);

        Color startColor = SymbolUtils.getColor(simb.getStartcolor(), trans);

        Color finishColor = SymbolUtils.getColor(simb.getFinishcolor(), trans);

        Color avgColor = mixColors(startColor, finishColor);

        ISymbol mSimb = new FSymbol(FConstant.SYMBOL_TYPE_FILL, avgColor);

        mSimb.setOutlineColor(avgColor.darker());

        //Until gvSIG supports gradients, this code is useless

        /*

        int type = getFillStyle(simb.getType());

        Point2D startP2D = null;

        Point2D finishP2D = null;

        double ratio = 150;

        switch (type) {

        case FConstant.SYMBOL_STYLE_FILL_UPWARD_DIAGONAL:

                startP2D = new Point2D.Double(0.0*ratio,0.0*ratio);

                finishP2D = new Point2D.Double(1.0*ratio,1.0*ratio);

                break;

        case FConstant.SYMBOL_STYLE_FILL_DOWNWARD_DIAGONAL:

                startP2D = new Point2D.Double(0.0*ratio,1.0*ratio);

                finishP2D = new Point2D.Double(1.0*ratio,0.0*ratio);

                break;

        case FConstant.SYMBOL_STYLE_FILL_VERTICAL:

                startP2D = new Point2D.Double(0.5*ratio,0.0*ratio);

                finishP2D = new Point2D.Double(0.5*ratio,1.0*ratio);

                break;

        case FConstant.SYMBOL_STYLE_FILL_HORIZONTAL:

                startP2D = new Point2D.Double(0.0*ratio,0.5*ratio);

                finishP2D = new Point2D.Double(1.0*ratio,0.5*ratio);

                break;

        }

        //Set the paint

        mSimb.setFill((Paint) new GradientPaint(startP2D,startColor,finishP2D,finishColor));

        //Remove the outline

        mSimb.setOutlined(false);

        */

        logger.info("Getting ArcIMS gradient fill as a simple polygon symbol");

        return mSimb;

        String surl = simb.getUrl();

        File img = getIconFile(surl);

        //Get the transparency

        String sTrans = simb.getTransparency();

        if (ds != '.') {

            sTrans = sTrans.replace(ds, '.');

        }

        float trans = Float.parseFloat(sTrans);

        Color fColor = new Color(1.0f, 1.0f, 1.0f, trans);

        ISymbol mSimb = new FSymbol(FConstant.SYMBOL_TYPE_FILL, fColor);

        // If is an image, we build the paint

        ImageFilter filter = new ImageFilter();

        if (filter.accept(img)) {

            //Creates the BufferedImage object

            BufferedImage bi;

            ImageIcon icon = new ImageIcon(img.getAbsolutePath());

            int w = icon.getIconWidth();

            int h = icon.getIconHeight();

            bi = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);

            // Draw the image in the BufferedImage object

            Graphics2D big = createG2(fColor, bi);

            big.drawImage(icon.getImage(), 0, 0, null);

            Rectangle2D rProv = new Rectangle();

            rProv.setFrame(0, 0, w, h);

            mSimb.setFill(new TexturePaint(bi, rProv));

            mSimb.setOutlined(false);

        }

        logger.info("Getting ArcIMS raster fill symbol");

        return mSimb;

        ISymbol mSimb = new FSymbol(FConstant.SYMBOL_TYPE_POINT);

        String font = symb.getFont();

        int fontSize = Integer.parseInt(symb.getFontSize());

        Color fontColor = SymbolUtils.getColor(symb.getFontColor(), 1);

        int fontStyle = SymbolUtils.getFontStyle(symb.getFontStyle());

        mSimb.setFont(new Font(font, fontStyle, fontSize));

        mSimb.setFontColor(fontColor);

        mSimb.setFontSize(fontSize);

        logger.info(

            "Getting ArcIMS TextSymbol as  point symbol with Font properties");

        return mSimb;

        return getDefaultFSymbol(FConstant.SYMBOL_TYPE_POINT);

        return getDefaultFSymbol(FConstant.SYMBOL_TYPE_POINT);

    public static ISymbol getDefaultFSymbol(int featType) {

        ISymbol mSimb = null;

        int colorind = (int) (System.currentTimeMillis() % ((long) initialColors.size()));

        Color randomColor = (Color) initialColors.get(colorind);

        mSimb = new FSymbol(featType, randomColor);

        mSimb.setFont(new Font("Arial", Font.PLAIN, 10));

        mSimb.setFontColor(Color.BLACK);

        mSimb.setSize(10);

        mSimb.setSizeInPixels(true);

        return mSimb;

    }

    /*

     * Supporting private methods

     */

    /**

     * Gets the correct constant for a ArcIMS point type

     * @param type

     * @return

     */

    private static int getPointType(String type) {

        //Default symbol, as gvsig doesn't paints stars

        int mtype = FConstant.SYMBOL_STYLE_MARKER_CIRCLE;

        if (type.equals(SymbolUtils.POINT_TYPE_CIRCLE)) {

            mtype = FConstant.SYMBOL_STYLE_MARKER_CIRCLE;

        } else if (type.equals(SymbolUtils.POINT_TYPE_CROSS)) {

            mtype = FConstant.SYMBOL_STYLE_MARKER_CROSS;

        } else if (type.equals(SymbolUtils.POINT_TYPE_SQUARE)) {

            mtype = FConstant.SYMBOL_STYLE_MARKER_SQUARE;

        } else if (type.equals(SymbolUtils.POINT_TYPE_TRIANGLE)) {

            mtype = FConstant.SYMBOL_STYLE_MARKER_TRIANGLE;

        }

        return mtype;

    }

    /**

     * Method to translate from ArcIMS type to a string of values that will be parsed

     * @return a correct string for the line type definition as "1,3" for dots

     */

    private static String getLinePattern(String type) {

        return (String) SymbolUtils.LINE_TYPES.get(type);

    }

    /**

     * Translates ArcIMS line end style into BasicStroke line end constants

     * @see java.awt.BasicStroke#getEndCap()

     * @param captype

     * @return

     */

    private static int getCapType(String captype) {

        int resp = BasicStroke.CAP_BUTT;

        if (captype.equals(SymbolUtils.CAP_TYPE_BUTT)) {

            resp = BasicStroke.CAP_BUTT;

        } else if (captype.equals(SymbolUtils.CAP_TYPE_ROUND)) {

            resp = BasicStroke.CAP_ROUND;

        } else if (captype.equals(SymbolUtils.CAP_TYPE_SQUARE)) {

            resp = BasicStroke.CAP_SQUARE;

        }

        return resp;

    }

    /**

     * Translate ArcIMS joining line types into BasicStroke join line constants

     * @see java.awt.BasicStroke#getLineJoin()

     * @param jointype

     * @return

     */

    private static int getJoinType(String jointype) {

        int resp = BasicStroke.CAP_BUTT;

        if (jointype.equals(SymbolUtils.JOIN_TYPE_ROUND)) {

            resp = BasicStroke.JOIN_ROUND;

        } else if (jointype.equals(SymbolUtils.JOIN_TYPE_MITER)) {

            resp = BasicStroke.JOIN_MITER;

        } else if (jointype.equals(SymbolUtils.JOIN_TYPE_BEVEL)) {

            resp = BasicStroke.JOIN_BEVEL;

        }

        return resp;

    }

    /**

     * Gets a valid FConstant integer to translate an ArcIMS fill style

     * @param filltype

     * @return

     */

    private static int getFillStyle(String filltype) {

        int style = FConstant.SYMBOL_STYLE_FILL_SOLID;

        if (filltype.equals(SymbolUtils.FILL_TYPE_SOLID)) {

            style = FConstant.SYMBOL_STYLE_FILL_SOLID;

        } else if (filltype.equals(SymbolUtils.FILL_TYPE_BDIAG)) {

            style = FConstant.SYMBOL_STYLE_FILL_UPWARD_DIAGONAL;

        } else if (filltype.equals(SymbolUtils.FILL_TYPE_FDIAG)) {

            style = FConstant.SYMBOL_STYLE_FILL_DOWNWARD_DIAGONAL;

        } else if (filltype.equals(SymbolUtils.FILL_TYPE_CROSS)) {

            style = FConstant.SYMBOL_STYLE_FILL_CROSS;

        } else if (filltype.equals(SymbolUtils.FILL_TYPE_DIAGC)) {

            style = FConstant.SYMBOL_STYLE_FILL_CROSS_DIAGONAL;

        } else if (filltype.equals(SymbolUtils.FILL_TYPE_HORIZ)) {

            style = FConstant.SYMBOL_STYLE_FILL_HORIZONTAL;

        } else if (filltype.equals(SymbolUtils.FILL_TYPE_VERT)) {

            style = FConstant.SYMBOL_STYLE_FILL_VERTICAL;

        } else if (filltype.equals(SymbolUtils.FILL_TYPE_GRAYFILL)) {

            style = FConstant.SYMBOL_STYLE_FILL_GRAYFILL;

        } else if (filltype.equals(SymbolUtils.FILL_TYPE_LIGHTGRAYFILL)) {

            style = FConstant.SYMBOL_STYLE_FILL_LIGHTGRAYFILL;

        } else if (filltype.equals(SymbolUtils.FILL_TYPE_DARKGRAYFILL)) {

            style = FConstant.SYMBOL_STYLE_FILL_DARKGRAYFILL;

        }

        return style;

    }

    /**

     * @see com.iver.cit.gvsig.fmap.core.v02.FSymbolFactory

     * @param cRef

     * @param bi

     * @return

     */

    static private Graphics2D createG2(Color cRef, BufferedImage bi) {

        Graphics2D big = bi.createGraphics();

        Color color = new Color(0, 0, 0, 0);

        big.setBackground(color);

        big.clearRect(0, 0, w, h);

        big.setColor(new Color(cRef.getRed(), cRef.getGreen(), cRef.getBlue(),

                cRef.getAlpha()));

        big.setStroke(new BasicStroke());

        return big;

    }

    /**

     * @see com.iver.cit.gvsig.fmap.core.v02.FSymbolFactory

     * @param style

     * @param cRef

     * @return

     */

    private static Paint createPatternFill(int style, Color cRef) {

        w = 7;

        h = 7;

        BufferedImage bi = null;

        Graphics2D big = null;

        Rectangle2D rProv = new Rectangle();

        rProv.setFrame(0, 0, w, h);

        Paint resulPatternFill = null;

        bi = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);

        big = createG2(cRef, bi);

        switch (style) {

        case FConstant.SYMBOL_STYLE_FILL_SOLID:

            return null;

        case FConstant.SYMBOL_STYLE_FILL_TRANSPARENT:

            return null;

        case FConstant.SYMBOL_STYLE_FILL_UPWARD_DIAGONAL:

            big.drawLine(0, 0, w, h);

            break;

        case FConstant.SYMBOL_STYLE_FILL_CROSS:

            big.drawLine(w / 2, 0, w / 2, h);

            big.drawLine(0, h / 2, w, h / 2);

            break;

        case FConstant.SYMBOL_STYLE_FILL_CROSS_DIAGONAL:

            big.drawLine(0, 0, w, h);

            big.drawLine(0, h, w, 0);

            break;

        case FConstant.SYMBOL_STYLE_FILL_VERTICAL:

            big.drawLine(w / 2, 0, w / 2, h);

            break;

        case FConstant.SYMBOL_STYLE_FILL_HORIZONTAL:

            big.drawLine(0, h / 2, w, h / 2);

            break;

        case FConstant.SYMBOL_STYLE_FILL_DOWNWARD_DIAGONAL:

            big.drawLine(0, h, w, 0);

            break;

        }

        resulPatternFill = new TexturePaint(bi, rProv);

        return resulPatternFill;

    }

    /**

     * Gets the hue of a color and returns the color

     * with 75% of saturation and 50% of brightness

     * @param cRef

     * @return

     */

    private static Color getGray(Color cRef) {

        float[] hsbvals = new float[3];

        Color.RGBtoHSB(cRef.getRed(), cRef.getGreen(), cRef.getBlue(), hsbvals);

        return new Color(Color.HSBtoRGB(hsbvals[0], 0.75f, 0.5f));

    }

    /**

     * Gets the hue of a color and returns the color

     * with 75% of saturation and 25% of brightness

     * @param cRef

     * @return

     */

    private static Color getLightGray(Color cRef) {

        float[] hsbvals = new float[3];

        Color.RGBtoHSB(cRef.getRed(), cRef.getGreen(), cRef.getBlue(), hsbvals);

        return new Color(Color.HSBtoRGB(hsbvals[0], 0.25f, 0.75f));

    }

    /**

     * Gets the hue of a color and returns the color

     * with 75% of saturation and 75% of brightness

     * @param cRef

     * @return

     */

    private static Color getDarkGray(Color cRef) {

        float[] hsbvals = new float[3];

        Color.RGBtoHSB(cRef.getRed(), cRef.getGreen(), cRef.getBlue(), hsbvals);

        return new Color(Color.HSBtoRGB(hsbvals[0], 0.25f, 0.25f));

    }

    /**

     * Get the average of two colours

     * @param a Color to mix

     * @param b Color to mix

     * @return (a+b)/2

     */

    private static Color mixColors(Color a, Color b) {

        return new Color((a.getRed() + b.getRed()) / 2,

            (a.getGreen() + b.getGreen()) / 2, (a.getBlue() + b.getBlue()) / 2);

    }

    /**

     * Gets from an URL a File with the icon stored in a temporary directory

     * @param surl

     * @return

     */

    private static File getIconFile(String surl) {

        File img = null;

        try {

            URL url;

            url = new URL(surl);

            String[] partes = surl.split("/");

            String realFilename = partes[partes.length - 1];

            String[] realsplit = realFilename.split("\\.");

            String downFileName = realsplit[0] +

                Long.toString(System.currentTimeMillis()) + "." + realsplit[1];

            img = ArcImsDownloadUtils.downloadFile(url, downFileName);

        } catch (MalformedURLException e) {

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

        } catch (ConnectException e) {

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

        } catch (UnknownHostException e) {

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

        } catch (IOException e) {

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

        }

        return img;

    }

import com.hardcode.gdbms.engine.values.Value;

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

import com.iver.cit.gvsig.fmap.core.v02.FConstant;

import com.iver.cit.gvsig.fmap.core.v02.FSymbol;

import com.iver.cit.gvsig.fmap.rendering.ClassifiedLegend;

import com.iver.cit.gvsig.fmap.rendering.FInterval;

import com.iver.cit.gvsig.fmap.rendering.Legend;

import com.iver.cit.gvsig.fmap.rendering.LegendFactory;

import com.iver.cit.gvsig.fmap.rendering.NullIntervalValue;

import com.iver.cit.gvsig.fmap.rendering.NullUniqueValue;

import com.iver.cit.gvsig.fmap.rendering.SingleSymbolLegend;

import com.iver.cit.gvsig.fmap.rendering.VectorialIntervalLegend;

import com.iver.cit.gvsig.fmap.rendering.VectorialLegend;

import com.iver.cit.gvsig.fmap.rendering.VectorialUniqueValueLegend;

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

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

    private VectorialLegend auxLabelsOuter = null;

    //	private String PATRON = ArcXML.PATRON;

    //	DecimalFormat formatter;

    private int featType;

    /**

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

        //		formatter = new DecimalFormat(PATRON,dfs);

    }

    /**

     * 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 VectorialLegend getLegend(Renderer render, boolean isMainRender)

        throws ArcImsException {

        VectorialLegend 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

        else if (isMainRender &&  (render instanceof GroupRenderer)) {

                GroupRenderer groupRender = (GroupRenderer) render;

                leg = getLegend(groupRender);

        }

        // Otherwise, we will use their proper method

        else if (!isMainRender && (render instanceof GroupRenderer)) {

                if (render instanceof ScaleDependentRenderer) {

                        ScaleDependentRenderer sdRender = (ScaleDependentRenderer) render;

                        leg = getLegend(sdRender);

                }

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

                // treated in the same way

                else if (render instanceof GroupRenderer) {

                        GroupRenderer groupRender = (GroupRenderer) render;

                        leg = getLegend(groupRender);

                }

        }

        else

                leg = getDefaultLegend();

        */

        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 VectorialLegend 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 VectorialLegend getLegend(SimpleRenderer renderer) {

        //Get the ArcIMS Simbol

        IArcIMSSymbol imsSimb = renderer.getSymbol();

        //Get the FSymbol of the renderer

        FSymbol simb = imsSimb.getFSymbol();

        //Creates the legend

        SingleSymbolLegend leg = new SingleSymbolLegend();

        leg.setDefaultSymbol(simb);

        leg.setShapeType(this.featType);

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

        return (VectorialLegend) leg;

    }

    /**

     * Gets a Legend based on intervals

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

     * @param renderer

     * @return

     * @throws ArcImsException

     */

    private VectorialLegend getLegend(ValueMapRenderer renderer)

        throws ArcImsException {

        //Get the proper Field Information object

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

        //Gets the array of ranges

        ArrayList values = renderer.getValues();

        Iterator 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

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

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

                    Value val = ArcImsValueFactory.createValueByType(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)

         */

        VectorialLegend leg = null;

        ClassifiedLegend 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

        cleg.setFieldName(ArcXML.replaceUnwantedCharacters(fi.getName()));

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