Application: gvSIG desktop » gvSIG legends: base legends

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3

 * 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.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.legend.urbanhorizontalsignage.lib.impl.linelegend;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.Shape;

import java.awt.geom.AffineTransform;

import java.util.concurrent.Callable;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.geom.aggregate.MultiPolygon;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.Line;

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

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

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

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLocator;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageManager;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.CONTINUITY_MODE_CONT_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_CONT;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_DISC;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.impl.AbstractSymbol;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.swing.api.TransparencySupport;

import org.gvsig.tools.task.Cancellable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class UrbanHorizontalSignageSymbol extends AbstractSymbol implements ISymbol_v2, TransparencySupport {

    private static final Logger LOG = LoggerFactory.getLogger(UrbanHorizontalSignageSymbol.class);

    private static final String SYMBOL_NAME = "UrbanHorizontalSignageSymbol";

    private static final String URBAN_HORIZONTAL_SIGNAGE_SYMBOL_PERSISTENCE_DEFINITION_NAME = "UrbanHorizontalSignageSymbol";

    private static final String FIELD_WIDTH = "width";

    private static final String FIELD_CONTINUITY = "continuity";

    private static final String FIELD_SEGMENTS_COLOR = "segmentsColor";

    private static final String FIELD_SEGMENTS_LENGTH = "segmentsLength";

    private static final String FIELD_HOLES_COLOR = "holesColor";

    private static final String FIELD_HOLES_LENGTH = "holesLength";

    private static final String FIELD_PAINT_HOLES = "paintHoles";

    private static final String FIELD_GAP_WIDTH = "gapWidth";

    private static final String FIELD_ROUND_VERTEX = "roundVertex";

    private static final String FIELD_SEGMENTS_GEOMETRY = "segmentsGeometry";

    private static final String FIELD_HOLES_GEOMETRY = "holesGeometry";

    private static final String FIELD_TRANSPARENCY = "transparency";

    private static final String FIELD_MUST_DRAW_ORIGINAL_GEOMETRY = "mustDrawOriginalGeometry";

    private static final String FIELD_COLOR_FOR_ORIGINAL_GEOMETRY = "colorForOriginalGeometry";

//    private static final String FIELD_SYMBOL_FOR_SELECTION = "symbolForSelection";

    private UrbanHorizontalSignageData data;

    transient private UrbanHorizontalSignageSymbol symbolForSelection;

    private boolean mustDrawOriginalGeometry;

    private Color colorForOriginalGeometry;

    private double cartographicSize;

    private double transparency; //[0.0, 1.0]

    public UrbanHorizontalSignageSymbol() {

        super();

        this.mustDrawOriginalGeometry = false;

        this.transparency = 1.0;

    }

    public void setData(UrbanHorizontalSignageData data) {

        this.data = data;

    }

    public UrbanHorizontalSignageData getData() {

        return data;

    }

    /**

     * Sets the transparency for symbol. The valid values are in [0.0, 1.0]

     * 

     * @param transparency 

     */

    @Override

    public void setTransparency(double transparency) {

        if(transparency < 0 || transparency > 1.0){

            throw new IllegalArgumentException("Transparency value must be in [0.0, 1.0] ("+transparency+")");

        }

        this.transparency = transparency;

    }

    @Override

    public double getTransparency() {

        return transparency;

    }

    @Override

    public ISymbol getSymbolForSelection() {

        if (symbolForSelection == null) {

            symbolForSelection = (UrbanHorizontalSignageSymbol) cloneForSelection();

            symbolForSelection.mustDrawOriginalGeometry = true;

        } else {

            symbolForSelection.setColor(MapContext.getSelectionColor());

        }

        return symbolForSelection;

    }

    protected Geometry getSampleGeometry(Rectangle r) {

        final int hGap = (int) (r.getWidth() * 0.1); // the left and right margins

        final int vPos = 1;                                                  // the top and bottom margins

        final int splitCount = 3;                                          // number of lines

        final int splitHSize = (r.width - hGap - hGap) / splitCount;

        int hPos = hGap;

        boolean swap = false;

        Line geom = GeometryUtils.createLine(Geometry.SUBTYPES.GEOM2D);

        geom.addVertex(r.x + hPos, r.y + r.height - vPos);

        for (int i = 0; i < splitCount; i++) {

            swap = !swap;

            geom.addVertex(r.x + hPos + splitHSize, (swap ? vPos : r.height - vPos) + r.y);

            hPos += splitHSize;

        }

        return geom;

    }

    @Override

    public void draw(Graphics2D g, AffineTransform affineTransform,

            Geometry originalGeometry, Feature feature, Cancellable cancel, Rectangle r) {

        if(r != null){

            originalGeometry = getSampleGeometry(r);

        }

        if (true) {

            // Esto deberia ser para optimizar el pintado de 

            // geometrias grandes.

            try {

                Geometry env = originalGeometry.getEnvelope().getGeometry();

                env.transform(affineTransform);

                Envelope env2 = env.getEnvelope();

                if (env2.getLength(0) < 1.5 && env2.getLength(1) < 1.5) {

                    Color color = data.getSegmentsColor();

                    Color transparentColor = new Color(color.getRed(), color.getGreen(), color.getBlue(), (int)(transparency*color.getAlpha()));

                    g.setColor(transparentColor);

                    Point upperCorner = env2.getUpperCorner();

                    int x = (int) upperCorner.getX();

                    int y = (int) upperCorner.getY();

                    g.drawLine(x, y, x, y);

                    return;

                }

            } catch (Exception ex) {

                LOG.warn("Error optimizing the drawing of the geometry. Continues with normal drawing.", ex);

                // Do nothing, continue with the draw of the original geometry

            }

        }

        UrbanHorizontalSignageManager uhsManager = UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

        uhsManager.calculateGeometries(originalGeometry, data);

        MultiPolygon geom = data.getSegmentsGeometry();

        if (geom != null && geom.getPrimitivesNumber() > 0) {

            Color color = data.getSegmentsColor();

            Shape shape = geom.getShape(affineTransform);

            Color transparentColor = new Color(color.getRed(), color.getGreen(), color.getBlue(), (int)(transparency*color.getAlpha()));

            g.setColor(transparentColor);

            g.fill(shape);

            g.setColor(color.darker());

            g.draw(shape);

        }

        switch (data.getContinuity()) {

            case CONTINUITY_MODE_CONT_DISC:

            case CONTINUITY_MODE_DISC_CONT:

            case CONTINUITY_MODE_DISC:

            case CONTINUITY_MODE_DISC_DISC:

                if (data.isPaintHoles()) {

                    geom = data.getHolesGeometry();

                    if (geom != null && geom.getPrimitivesNumber() > 0) {

                        Color color = data.getHolesColor();

                        Color transparentColor = new Color(color.getRed(), color.getGreen(), color.getBlue(), (int)(transparency*color.getAlpha()));

                        g.setColor(transparentColor);

                        g.fill(geom.getShape(affineTransform));

                    }

                }

        }

        //For debug purposse only

        if(mustDrawOriginalGeometry){

            g.setColor(getColor());

            g.draw(originalGeometry.getShape(affineTransform));

        }

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        UrbanHorizontalSignageSymbol copy = (UrbanHorizontalSignageSymbol) super.clone();

        if (symbolForSelection != null) {

            copy.symbolForSelection = (UrbanHorizontalSignageSymbol) symbolForSelection

                    .clone();

        }

        return copy;

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        // Set parent style properties

        super.loadFromState(state);

        UrbanHorizontalSignageData theData = new DefaultUrbanHorizontalSignageData();

        theData.setWidth(state.getDouble(FIELD_WIDTH, UrbanHorizontalSignageData.DEFAULT_WIDTH_VALUE));

        theData.setContinuity(state.getInt(FIELD_CONTINUITY, UrbanHorizontalSignageData.DEFAULT_CONTINUITY_VALUE));

        Color color = (Color) state.get(FIELD_SEGMENTS_COLOR);

        theData.setSegmentsColor(color != null ? color : UrbanHorizontalSignageData.DEFAULT_SEGMENT_COLOR_VALUE);

        theData.setSegmentsLength(state.getDouble(FIELD_SEGMENTS_LENGTH, UrbanHorizontalSignageData.DEFAULT_SEGMENT_LENGTH_VALUE));

        color = (Color) state.get(FIELD_HOLES_COLOR);

        theData.setHolesColor(color != null ? color : UrbanHorizontalSignageData.DEFAULT_HOLES_COLOR_VALUE);

        theData.setHolesLength(state.getDouble(FIELD_HOLES_LENGTH, UrbanHorizontalSignageData.DEFAULT_HOLES_LENGTH_VALUE));

        theData.setGapWidth(state.getDouble(FIELD_GAP_WIDTH, UrbanHorizontalSignageData.DEFAULT_GAP_WIDTH_VALUE));

        theData.setRoundVertex(state.getBoolean(FIELD_ROUND_VERTEX, UrbanHorizontalSignageData.DEFAULT_ROUND_VERTEX_VALUE));

        this.transparency = state.getDouble(FIELD_TRANSPARENCY, 1.0);

        this.mustDrawOriginalGeometry = state.getBoolean(FIELD_MUST_DRAW_ORIGINAL_GEOMETRY, false);

        color = (Color) state.get(FIELD_COLOR_FOR_ORIGINAL_GEOMETRY);

        this.colorForOriginalGeometry = color != null ? color : MapContext.getSelectionColor();

        this.data = theData;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        // Save parent fill symbol properties

        super.saveToState(state);

        // Save own properties

        if(data != null){

            state.set(FIELD_WIDTH, data.getWidth());

            state.set(FIELD_CONTINUITY, data.getContinuity());

            state.set(FIELD_SEGMENTS_COLOR, data.getSegmentsColor());

            state.set(FIELD_SEGMENTS_LENGTH, data.getSegmentsLength());

            state.set(FIELD_HOLES_COLOR, data.getHolesColor());

            state.set(FIELD_HOLES_LENGTH, data.getHolesLength());

            state.set(FIELD_PAINT_HOLES, data.isPaintHoles());

            state.set(FIELD_GAP_WIDTH, data.getGapWidth());

            state.set(FIELD_ROUND_VERTEX, data.isRoundVertex());

        }

        state.set(FIELD_MUST_DRAW_ORIGINAL_GEOMETRY, mustDrawOriginalGeometry);

        state.set(FIELD_COLOR_FOR_ORIGINAL_GEOMETRY, colorForOriginalGeometry);

        state.set(FIELD_TRANSPARENCY, this.getTransparency());

    }

    @Override

    public int getSymbolType() {

        return Geometry.TYPES.CURVE;

    }

    @Override

    public boolean isSuitableFor(Geometry geom) {

        return geom.getGeometryType().isTypeOf(Geometry.TYPES.CURVE);

    }

    @Override

    public Color getColor() {

        return this.colorForOriginalGeometry;

    }

    @Override

    public void setColor(Color color) {

        this.colorForOriginalGeometry = color;

    }

//    public static class RegisterPersistence implements Callable {

//

//        @Override

//        public Object call() throws Exception {

//            PersistenceManager manager = ToolsLocator.getPersistenceManager();

//            if (manager.getDefinition(URBAN_HORIZONTAL_SIGNAGE_SYMBOL_PERSISTENCE_DEFINITION_NAME) == null) {

//                DynStruct definition = manager.addDefinition(

//                        UrbanHorizontalSignageSymbol.class,

//                        URBAN_HORIZONTAL_SIGNAGE_SYMBOL_PERSISTENCE_DEFINITION_NAME,

//                        URBAN_HORIZONTAL_SIGNAGE_SYMBOL_PERSISTENCE_DEFINITION_NAME + " Persistence definition",

//                        null,

//                        null

//                );

//                // Extend the LineSymbol base definition

//                definition.extend(manager.getDefinition(AbstractSymbol.SYMBOL_PERSISTENCE_DEFINITION_NAME));

//                

//                definition.addDynFieldDouble(FIELD_WIDTH).setMandatory(false);

//                definition.addDynFieldInt(FIELD_CONTINUITY).setMandatory(false);

//                definition.addDynFieldObject(FIELD_SEGMENTS_COLOR).setClassOfValue(Color.class).setMandatory(false);

//                definition.addDynFieldDouble(FIELD_SEGMENTS_LENGTH).setMandatory(false);

//                definition.addDynFieldObject(FIELD_HOLES_COLOR).setClassOfValue(Color.class).setMandatory(false);

//                definition.addDynFieldDouble(FIELD_HOLES_LENGTH).setMandatory(false);

//                definition.addDynFieldBoolean(FIELD_PAINT_HOLES).setMandatory(false);

//                definition.addDynFieldDouble(FIELD_GAP_WIDTH).setMandatory(false);

//                definition.addDynFieldBoolean(FIELD_ROUND_VERTEX).setMandatory(false);

//                definition.addDynFieldDouble(FIELD_TRANSPARENCY).setMandatory(false);

//                definition.addDynFieldBoolean(FIELD_MUST_DRAW_ORIGINAL_GEOMETRY).setMandatory(false);

//                definition.addDynFieldObject(FIELD_COLOR_FOR_ORIGINAL_GEOMETRY).setClassOfValue(Color.class).setMandatory(false);

//            }

//            return Boolean.TRUE;

//        }

//

//    }

    public static class RegisterSymbol implements Callable {

        @Override

        public Object call() throws Exception {

            int[] shapeTypes;

            SymbolManager manager = MapContextLocator.getSymbolManager();

            shapeTypes = new int[]{Geometry.TYPES.CURVE, Geometry.TYPES.ARC,

                Geometry.TYPES.MULTICURVE, Geometry.TYPES.CIRCUMFERENCE,

                Geometry.TYPES.PERIELLIPSE, Geometry.TYPES.SPLINE,

                Geometry.TYPES.LINE, Geometry.TYPES.MULTILINE};

            manager.registerSymbol(SYMBOL_NAME,

                    shapeTypes,

                    UrbanHorizontalSignageSymbol.class);

            return Boolean.TRUE;

        }

    }

}