Application: gvSIG desktop » gvSIG legends: base legends

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

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.FontMetrics;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.Ellipse2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.logging.Level;

import javax.swing.UIManager;

import org.cresques.cts.ICoordTrans;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.mapcontext.MapContextException;

import org.gvsig.fmap.mapcontext.ViewPort;

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

import org.gvsig.fmap.mapcontext.rendering.legend.events.SymbolLegendEvent;

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

import org.gvsig.fmap.mapcontext.rendering.symbols.styles.ILabelStyle;

import org.gvsig.legend.aggregate.lib.api.AggregateLegend;

import org.gvsig.legend.aggregate.lib.api.AggregateLegendLocator;

import org.gvsig.legend.aggregate.lib.api.Operation;

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

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl.SimpleFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.impl.SimpleLineSymbol;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.logger.FilteredLogger;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

public class DefaultAggregateLegend extends AbstractVectorialLegend implements AggregateLegend {

    private static class Group {

//        private final Point pointGeo;

//        private final Rectangle2D rectangle;

        private Operation op;

        private final Point pointPixels;

        private final Ellipse2D circle;

        public Group(Point pointGeo, Point pointPixels, double size, Operation op) {

            this.op = op;

            this.op.reset();

//            this.pointGeo = pointGeo;

            this.pointPixels = pointPixels;

            double d2 = size * 2;

//            this.rectangle = new Rectangle2D.Double(pointPixels.getX() - distance, pointPixels.getY() - distance, d2, d2);

            this.circle = new Ellipse2D.Double(pointPixels.getX() - size, pointPixels.getY() - size, d2, d2);

        }

        public boolean contains(Point pointPixels) {

//            return this.rectangle.contains(pointPixels.getX(), pointPixels.getY());

          return this.circle.contains(pointPixels.getX(), pointPixels.getY());

        }

        public void add(Feature feature) {

            op.perform(feature);

        }

        public Operation getOperation() {

            return this.op;

        }

    }

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

    private List<Group> groups;

    private int symbolSize; // Pixels

    private Color fillColor;

    private Color outlineColor;

    private Color textColor;

    private boolean showBounds;

    private Font font;

    private boolean useStyle;

    private ILabelStyle labelStyle;

    private Operation operation;

    private SimpleFillSymbol defaultSymbol;

    public DefaultAggregateLegend() {

        this.groups = null;

        this.useStyle = false;

        this.symbolSize = 30;

        this.fillColor = new Color(0xd0ffcccc, true); // Un rojo

        this.outlineColor = new Color(0xff5f60de, true); // un azul

        this.textColor = new Color(0xff000000, true); // negro

        this.showBounds = false;

        this.labelStyle = null;        

        this.font = UIManager.getFont("Label.font");

        this.operation = AggregateLegendLocator.getAggregateLegendManager().getDefaultOperation().clone();

        this.defaultSymbol = new SimpleFillSymbol();

        this.defaultSymbol.setOutline(new SimpleLineSymbol());

        this.defaultSymbol.getOutline().setLineColor(this.outlineColor);

        this.defaultSymbol.setFillColor(this.fillColor);

    }

    @Override

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

        if( this.operation.isAttributeRequiered() && this.operation.getAttributeName()!=null ) {

            return new String[]{

                this.operation.getAttributeName(),

                featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName()

            };

        }

        return new String[]{

            featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName()

        };

    }

    @Override

    public ISymbol getDefaultSymbol() {

        return this.defaultSymbol;

    }

    @Override

    public void setDefaultSymbol(ISymbol is) {

    }

    @Override

    public ISymbol getSymbolByFeature(Feature ftr) throws MapContextException {

        return this.getDefaultSymbol();

    }

    @Override

    public int getShapeType() {

        return Geometry.TYPES.GEOMETRY;

    }

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

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

        this.drawGroups(image, g, cancel, viewPort.getAffineTransform());

    }

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

        this.groups = new ArrayList<>();

        featureSet.accept(new Visitor() {

            @Override

            public void visit(Object o) throws VisitCanceledException, BaseException {

                if( cancel.isCanceled() ) {

                    throw new VisitCanceledException();

                }

                Feature feature = (Feature) o;

                Geometry geom = feature.getDefaultGeometry();

                if( geom != null ) {

                    Point pointGeo = geom.centroid();

                    if( coordTrans != null ) {

                        pointGeo.reProject(coordTrans);

                    }

                    Point pointPixels = (Point) pointGeo.cloneGeometry();

                    pointPixels.transform(viewPort.getAffineTransform());

                    boolean inGroup = false;

                    for( Group group : groups ) {

                        if( group.contains(pointPixels) ) {

                            group.add(feature);

                            inGroup = true;

                            break;

                        }

                    }

                    if( !inGroup ) {

                        groups.add(new Group(pointGeo, pointPixels, getSymbolSize(), getOperation().clone()));

                    }

                }

            }

        });

    }

    private void drawGroups(BufferedImage image, Graphics2D g, Cancellable cancel, AffineTransform affineTransform) {

        FilteredLogger logger = new FilteredLogger(LOG, "", 10);

        AffineTransform identity = new AffineTransform();

        g.setFont(this.font);

        FontMetrics fm = g.getFontMetrics();

        int fontAscent = fm.getAscent();

        int fontAscentAddDescentDiv2 = ((fm.getAscent() + fm.getDescent())) / 2;        

        for( Group group : groups ) {

            if( cancel.isCanceled() ) {

                return;

            }

            try {

                int x = (int) group.pointPixels.getX();

                int y = (int) group.pointPixels.getY();

                String txt = group.getOperation().format();

                if( this.useStyle && this.labelStyle != null ) {

                    Dimension size = this.labelStyle.getSize();

                    this.labelStyle.setTextFields(new String[]{txt});

                    g.setTransform(identity);

                    g.translate(x-size.getWidth()/2, y-size.getHeight()/2);

                    Rectangle rect = new Rectangle(

                        0,

                        0,

                        (int)size.getWidth(),

                        (int)size.getHeight());

                    this.labelStyle.drawInsideRectangle(g, rect);

                    Rectangle2D[] bounds = this.labelStyle.getTextBounds();

                    if(bounds.length>0){

                        Rectangle2D bound = bounds[0];

                        Rectangle2D expandedBound = new Rectangle2D.Double(

                            bound.getMinX()*size.getWidth(),

                            bound.getMinY()*size.getHeight(),

                            bound.getWidth()*size.getWidth(),

                            bound.getHeight()*size.getHeight());

                        drawCenteredString(txt, expandedBound, g);

                    }

                    g.translate(-(x-size.getWidth()/2), -(y-size.getHeight()/2));

                } else {

                    int r = symbolSize/2;

                    g.setColor(this.fillColor);

                    g.fillOval( x-r, y-r, 2*r, 2*r);

                    g.setColor(this.outlineColor);

                    g.drawOval( x-r, y-r, 2*r, 2*r);

                    if( this.showBounds ) {

                        g.drawRect( x-r, y-r, 2*r, 2*r);

                    }

                    g.setColor(this.textColor);

                    int txtX = x - (fm.stringWidth(txt) / 2);

                    int txtY = fontAscent + y - fontAscentAddDescentDiv2; //((fm.getAscent() + fm.getDescent())) / 2;

                    g.drawString(txt, txtX, txtY);

                }

            } catch (Exception ex) {

                logger.warn("Can't draw group",ex);

            }

        }

    }

    private void drawCenteredString(String s, Rectangle2D rect, Graphics2D g) {

        double x = rect.getMinX();

        double y = rect.getMinY();

        double w = rect.getWidth();

        double h = rect.getHeight();

        FontMetrics fm = g.getFontMetrics();

        int auxX = (int)(x+((w - fm.stringWidth(s)) / 2));

        int auxY = (int)(y+((fm.getAscent() + (h - (fm.getAscent() + fm.getDescent())) / 2)));

        g.setColor(Color.BLACK);

        g.drawString(s, auxX, auxY);

      }

    @Override

    public ILabelStyle getLabelStyle() {

        return this.labelStyle;

    }

    @Override

    public void setLabelStyle(ILabelStyle labelStyle) {

        this.labelStyle = labelStyle;

    }

    @Override

    public int getSymbolSize() {

        return this.symbolSize;

    }

    @Override

    public void setSymbolSize(int simbolSize) {

        boolean changed = (this.symbolSize == simbolSize);

        this.symbolSize = simbolSize;

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    }

    @Override

    public Operation getOperation() {

        return this.operation;

    }

    @Override

    public void setOperation(Operation operation) {

        boolean changed = (this.operation.getName().equalsIgnoreCase(operation.getName()));

        this.operation = operation;

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    }

    @Override

    public Color getFillColor() {

        return fillColor;

    }

    @Override

    public void setFillColor(Color fillColor) {

        boolean changed = (this.fillColor.equals(fillColor));

        this.fillColor = fillColor;

        this.defaultSymbol.setFillColor(this.fillColor);

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    }

    @Override

    public Color getOutlineColor() {

        return outlineColor;

    }

    @Override

    public void setOutlineColor(Color outlineColor) {

        boolean changed = (this.outlineColor.equals(outlineColor));

        this.outlineColor = outlineColor;

        this.defaultSymbol.getOutline().setLineColor(this.outlineColor);

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    }

    @Override

    public boolean isShowBounds() {

        return showBounds;

    }

    @Override

    public void setShowBounds(boolean showBounds) {

        boolean changed = (this.showBounds == showBounds);

        this.showBounds = showBounds;

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    }

    @Override

    public Font getFont() {

        return font;

    }

    @Override

    public void setFont(Font font) {

        this.font = font;

        this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

    }

    @Override

    public boolean isUseStyle() {

        return useStyle;

    }

    @Override

    public void setUseStyle(boolean useStyle) {

        boolean changed = (this.useStyle == useStyle);

        this.useStyle = useStyle;

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    }

    @Override

    public Color getTextColor() {

        return this.textColor;

    }

    @Override

    public void setTextColor(Color textColor) {

        boolean changed = (this.textColor.equals(textColor));

        this.textColor = textColor;

        if( changed ) {

            this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

        }

    }

}