Application: gvSIG desktop » gvSIG legends: base legends

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

import java.awt.Color;

import java.awt.Image;

import org.gvsig.fmap.dal.exception.DataException;

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.mapcontext.MapContextException;

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

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

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.DEFAULT_CONTINUITY_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.DEFAULT_GAP_WIDTH_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.DEFAULT_HOLES_COLOR_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.DEFAULT_HOLES_LENGTH_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.DEFAULT_PAINT_HOLES_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.DEFAULT_ROUND_VERTEX_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.DEFAULT_SEGMENT_COLOR_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.DEFAULT_SEGMENT_LENGTH_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.DEFAULT_WIDTH_VALUE;

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

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.persistence.PersistentState;

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultUrbanHorizontalSignageLegend 

        extends AbstractVectorialLegend 

        implements UrbanHorizontalSignageLegend //, IHasImageLegend 

{

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultUrbanHorizontalSignageLegend.class);

    private UrbanHorizontalSignageSymbol defaultSymbol;

    private Image imageLegend;

    private String widthFieldName;

    private String continuityFieldName;

    private String holesLengthFieldName;

    private String holesColorFieldName;

    private String paintHolesFieldName;

    private String segmentsLengthFieldName;

    private String segmentsColorFieldName;

    private String roundVertexFieldName;

    private int gapWidth;

    public DefaultUrbanHorizontalSignageLegend() {

        SymbologyManager symbologyManager = SymbologyLocator.getSymbologyManager();

        this.defaultSymbol = new UrbanHorizontalSignageSymbol();

        DefaultUrbanHorizontalSignageData data = new DefaultUrbanHorizontalSignageData();

        data.setContinuity(UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_CONT);

        this.defaultSymbol.setData(new DefaultUrbanHorizontalSignageData());

        this.gapWidth = DEFAULT_GAP_WIDTH_VALUE;

    }

//    @Override

//    protected String[] getRequiredFeatureAttributeNames(FeatureStore featureStore) throws DataException {

//        FeatureType ftype = featureStore.getDefaultFeatureType();

//        if( StringUtils.isEmpty(this.fieldName) ) {

//            return new String[]{

//                ftype.getDefaultGeometryAttributeName()

//            };

//        }

//        return new String[]{

//            ftype.getDefaultGeometryAttributeName(),

//            this.fieldName

//        };

//    }

    @Override

    public ISymbol getDefaultSymbol() {

        return this.defaultSymbol;

    }

    @Override

    public void setDefaultSymbol(ISymbol is) {

        //DO NOTHING

    }

    @Override

    public ISymbol getSymbolByFeature(Feature ftr) throws MapContextException {

        UrbanHorizontalSignageData values = getValues(ftr);

        UrbanHorizontalSignageSymbol symbol = new UrbanHorizontalSignageSymbol();

        symbol.setData(values);

        return symbol;

    }

    @Override

    public int getShapeType() {

        return Geometry.TYPES.CURVE;

    }

    @Override

    public void setShapeType(int i) {

    }

    @Override

    public boolean isUseDefaultSymbol() {

        return true;

    }

    @Override

    public void useDefaultSymbol(boolean bln) {

    }

    @Override

    public boolean isSuitableForShapeType(int shapeType) {

        return true;

    }

//    @Override

//    protected void draw(BufferedImage image, Graphics2D g, ViewPort viewPort, Cancellable cancel, double scale, Map queryParameters, ICoordTrans coordTrans, FeatureStore featureStore, FeatureQuery featureQuery, double dpi) throws LegendException {

//        int saved_distance = this.algorithm.getDistance();

//        try {

//            int distance = (int) (this.algorithm.getDistance() * (dpi / 72));

//            Geometry theROI = null;

//            if (this.roi!=null) {

//                theROI = this.roi.cloneGeometry();

//                theROI.transform(viewPort.getAffineTransform());

//            }

//            this.algorithm.setDistance(distance);

//            this.algorithm.init(image.getWidth(), image.getHeight());

//            super.draw(image, g, viewPort, cancel, scale, queryParameters, coordTrans, featureStore, featureQuery, dpi);

//            if( !cancel.isCanceled() ) {

//                this.algorithm.drawWithOpaqueColors(image, g, this.getHeatMapColorTable().getColorTable(), cancel, theROI);

//            }

//        } finally {

//            this.algorithm.setDistance(saved_distance);

//

//        }

//    }

//    @Override

//    public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel,

//            double scale, Map queryParameters, ICoordTrans coordTrans,

//            FeatureStore featureStore, FeatureQuery featureQuery, PrintAttributes properties)

//            throws LegendException {

//        int saved_distance = this.algorithm.getDistance();

//        try {

//            double dpi = viewPort.getDPI();

//            // Ver CartographicSupportToolkit.getCartographicLength

//            int distance = (int) (this.algorithm.getDistance() * (dpi / 72));

//            Geometry theROI = null;

//            if (this.roi!=null) {

//                theROI = this.roi.cloneGeometry();

//                theROI.transform(viewPort.getAffineTransform());

//            }

//            this.algorithm.setDistance(distance);

//            this.algorithm.init(viewPort.getImageWidth(), viewPort.getImageHeight());

//            BufferedImage image = new BufferedImage(viewPort.getImageWidth(), viewPort.getImageHeight(), BufferedImage.TYPE_INT_ARGB);

//            super.draw(image, g, viewPort, cancel, scale, queryParameters, coordTrans, featureStore, featureQuery, dpi);

//            if (!cancel.isCanceled()) {

//                this.algorithm.drawWithAlphaColors(image, g, this.getHeatMapColorTable().getColorTable(), cancel, theROI);

//                g.drawImage(image, 0, 0, null);

//            }

//        } finally {

//            this.algorithm.setDistance(saved_distance);

//

//        }

//    }

//    @Override

//    protected void drawFeatures(

//            BufferedImage image,

//            Graphics2D g,

//            final ViewPort viewPort,

//            final Cancellable cancel,

//            final ICoordTrans coordTrans,

//            double dpi,

//            DefaultFeatureDrawnNotification drawnNotification,

//            FeatureSet featureSet,

//            FeatureSelection selection

//    ) throws BaseException {

//

//        SymbologyManager symbologyManager = SymbologyLocator.getSymbologyManager();

//

//        UrbanHorizontalSignageManager uhsManager = UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

//

//        try {

//            featureSet.accept(new Visitor() {

//                @Override

//                public void visit(Object obj) throws VisitCanceledException,

//                        BaseException {

//                    if (cancel.isCanceled()) {

//                        throw new VisitCanceledException();

//                    }

//                    Feature feature = (Feature) obj;

//                    UrbanHorizontalSignageData values = getValues(feature);

//                    Geometry originalGeometry = feature.getDefaultGeometry();

//                    

//                    ISimpleLineSymbol lineSymbol = symbologyManager.createSimpleLineSymbol();

//                    lineSymbol.setColor(Color.YELLOW);

//                    

//                    uhsManager.calculateGeometries(originalGeometry, values);

//                    MultiPolygon geom;

//                    

//                    ISimpleFillSymbol segmentsSymbol = symbologyManager.createSimpleFillSymbol();;

//                    segmentsSymbol.setFillColor(values.getSegmentsColor());

//                    

//                    ISimpleFillSymbol holesSymbol = symbologyManager.createSimpleFillSymbol();

//                    holesSymbol.setFillColor(values.getHolesColor());

//

//                    geom = values.getSegmentsGeometry();

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

//                        segmentsSymbol.draw(g, viewPort.getAffineTransform(), geom,

//                                feature, cancel);

//                    }

//

//                    switch (values.getContinuity()) {

////                        case CONTINUITY_MODE_CONT:

////                        case CONTINUITY_MODE_CONT_CONT:

////                            geom = values.getSegmentsGeometry();

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

////                                segmentsSymbol.draw(g, viewPort.getAffineTransform(), geom,

////                                        feature, cancel);

////                            }

////                            break;

//                        case CONTINUITY_MODE_CONT_DISC:

//                        case CONTINUITY_MODE_DISC_CONT:

//                        case CONTINUITY_MODE_DISC:

//                        case CONTINUITY_MODE_DISC_DISC:

//                            if(values.isPaintHoles()){

//                                geom = values.getHolesGeometry();

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

//                                    holesSymbol.draw(g, viewPort.getAffineTransform(), geom,

//                                            feature, cancel);

//                                }

//                            }

//                    }

//

//                    //For debug purposse only

//                    lineSymbol.draw(g, viewPort.getAffineTransform(), originalGeometry,

//                            feature, cancel);

//                }

//            });

//

//        } catch (ConcurrentDataModificationException e) {

//            cancel.setCanceled(true);

//        }

//    }

//    @Override

//    public Image getImageLegend() {

//        if( this.imageLegend==null ) {

////            BufferedImage img = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);

////            ColorTablePainter painter = new DefaultColorTablePainter(this.getTargetColorTable(),"");

////            Graphics2D g = img.createGraphics();

////            g.setClip(0, 0, 80, 20);

////            g.setBackground(Color.WHITE);

////            g.fillRect(0, 0, 80, 20);

////            painter.paint(g, false);

////            this.imageLegend = img;

//        }

//        return this.imageLegend;

//    }

//

//    @Override

//    public String getPathImage() {

//        return null;

//    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

//        this.defaultSymbol = new SimpleTextSymbol();

        this.imageLegend = null;

        super.loadFromState(state);

        this.widthFieldName = state.getString("widthFieldName");

        this.continuityFieldName = state.getString("continuityFieldName");

        this.holesLengthFieldName = state.getString("holesLengthFieldName");

        this.holesColorFieldName = state.getString("holesColorFieldName");

        this.paintHolesFieldName = state.getString("paintHolesFieldName");

        this.segmentsLengthFieldName = state.getString("segmentsLengthFieldName");

        this.segmentsColorFieldName = state.getString("segmentsColorFieldName");

        this.roundVertexFieldName = state.getString("roundVertexFieldName");

        this.gapWidth = state.getInt("gapWidth", DEFAULT_GAP_WIDTH_VALUE);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("widthFieldName", this.widthFieldName);

        state.set("continuityFieldName", this.continuityFieldName);

        state.set("holesLengthFieldName", this.holesLengthFieldName);

        state.set("holesColorFieldName", this.holesColorFieldName);

        state.set("paintHolesFieldName", this.paintHolesFieldName);

        state.set("segmentsLengthFieldName", this.segmentsLengthFieldName);

        state.set("segmentsColorFieldName", this.segmentsColorFieldName);

        state.set("roundVertexFieldName", this.roundVertexFieldName);

        state.set("gapWidth", this.gapWidth);

    }

    @Override

    protected String[] getRequiredFeatureAttributeNames(FeatureStore fs) throws DataException {

        return new String[]{

            this.widthFieldName,

            this.continuityFieldName,

            this.holesLengthFieldName,

            this.holesColorFieldName,

            this.paintHolesFieldName,

            this.segmentsLengthFieldName,

            this.segmentsColorFieldName,

            this.roundVertexFieldName,

            fs.getDefaultFeatureType().getDefaultGeometryAttributeName()};

    }

    @Override

    public String getWidthFieldName() {

        return this.widthFieldName;

    }

    @Override

    public void setWidthFieldName(String fieldName) {

        this.widthFieldName = fieldName;

    }

    @Override

    public String getContinuityFieldName() {

        return this.continuityFieldName;

    }

    @Override

    public void setContinuityFieldName(String fieldName) {

        this.continuityFieldName = fieldName;

    }

    @Override

    public String getSegmentsColorFieldName() {

        return this.segmentsColorFieldName;

    }

    @Override

    public void setSegmentsColorFieldName(String fieldName) {

        this.segmentsColorFieldName = fieldName;

    }

    @Override

    public String getSegmentsLengthFieldName() {

        return this.segmentsLengthFieldName;

    }

    @Override

    public void setSegmentsLengthFieldName(String fieldName) {

        this.segmentsLengthFieldName = fieldName;

    }

    @Override

    public String getPaintHolesFieldName() {

        return this.paintHolesFieldName;

    }

    @Override

    public void setPaintHolesFieldName(String fieldName) {

        this.paintHolesFieldName = fieldName;

    }

    @Override

    public String getHolesColorFieldName() {

        return this.holesColorFieldName;

    }

    @Override

    public void setHolesColorFieldName(String fieldName) {

        this.holesColorFieldName = fieldName;

    }

    @Override

    public String getHolesLengthFieldName() {

        return this.holesLengthFieldName;

    }

    @Override

    public void setHolesLengthFieldName(String fieldName) {

        this.holesLengthFieldName = fieldName;

    }

    @Override

    public String getRoundVertexFieldName() {

        return this.roundVertexFieldName;

    }

    @Override

    public void setRoundVertexFieldName(String fieldName) {

        this.roundVertexFieldName = fieldName;

    }

    @Override

    public int getGapWidth() {

        return this.gapWidth;

    }

    @Override

    public void setGapWith(int value) {

        this.gapWidth = value;

    }

    @Override

    public UrbanHorizontalSignageData getValues(Feature feature) {

        UrbanHorizontalSignageData data = new DefaultUrbanHorizontalSignageData();

        DataTypesManager manager = ToolsLocator.getDataTypesManager();

        FeatureType ftype = feature.getType();

        double valueDouble = feature.getIntOrDefault( this.widthFieldName, (int)DEFAULT_WIDTH_VALUE*100 )/100.0;

        data.setWidth(valueDouble);

        int valueInt = feature.getIntOrDefault( this.continuityFieldName, DEFAULT_CONTINUITY_VALUE );

        data.setContinuity(valueInt);

        Color valueColor = (Color)feature.getOrDefault( this.segmentsColorFieldName, DataTypes.COLOR, DEFAULT_SEGMENT_COLOR_VALUE );

        data.setSegmentsColor(valueColor);

        valueDouble = feature.getIntOrDefault( this.segmentsLengthFieldName, (int)DEFAULT_SEGMENT_LENGTH_VALUE*100 )/100.0;

        data.setSegmentsLength(valueDouble);

        valueDouble = feature.getIntOrDefault( this.holesLengthFieldName, (int)DEFAULT_HOLES_LENGTH_VALUE*100 )/100.0;

        data.setHolesLength(valueDouble);

        boolean valueBoolean = feature.getBooleanOrDefault( this.paintHolesFieldName, DEFAULT_PAINT_HOLES_VALUE );

        data.setPaintHoles(valueBoolean);

        valueColor = (Color) feature.getOrDefault( this.holesColorFieldName, DataTypes.COLOR, DEFAULT_HOLES_COLOR_VALUE );

        data.setHolesColor(valueColor);

        valueBoolean = feature.getBooleanOrDefault( this.roundVertexFieldName, DEFAULT_ROUND_VERTEX_VALUE );

        data.setRoundVertex(valueBoolean);

        data.setGapWidth(this.getGapWidth()/100.0);

        return data;

    }

}