Application: gvSIG desktop

import org.gvsig.labeling.dynamiclabeling.DynamicLabelingStrategy;

import java.util.ArrayList;

import java.util.List;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

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.exception.CreateGeometryException;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontext.layers.vectorial.SpatialEvaluatorsFactory;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.styling.AttrInTableLabelingStrategy;

import static org.gvsig.symbology.fmap.mapcontext.rendering.legend.styling.AttrInTableLabelingStrategy.MIN_TEXT_SIZE;

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.text.impl.SimpleTextSymbol;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

    private Feature feature;

    public  String LROTATION = "LROTATION";

    public  String LTEXT = "LTEXT";

    public  String LHEIGHT = "LHEIGHT";

    public  String LCOLOR = "LCOLOR";

    public  String LFONT = "LFONT";

    public  String LFONTSTYLE = "LFONTS";

    private MutableSymbolTable symbolTable = null;

    private FLyrVect layer;

    private List<Geometry> drawnGeometryLabels;

    private boolean printMode = false;

    private IZoomConstraints zoom = null;

    private static final Logger logger = LoggerFactory.getLogger(AttrInTableLabelingStrategy.class);

    private int referenceSystem;

    private String textField;

    public SymbolTable getFeatureSymbolTable() {

        if (symbolTable == null) {

            MutableSymbolTable s = ExpressionEvaluatorLocator.getManager().createSymbolTable();

            FeatureSymbolTable fst = DALLocator.getDataManager().createFeatureSymbolTable();

            s.addSymbolTable(fst);

            fst.setFeature(feature);

            symbolTable = s;

        }

        return symbolTable;

    private Expression getExpressionFromString(String value) {

        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();

        expression.setPhrase(value);

        return expression;

    }

    private Object getValueFromExpression(Expression exp) {

        if (exp == null) {

            return null;

        }

        Object value = exp.execute(getFeatureSymbolTable());

        return value;

    }

    public Object getComputedValue(String field) {

        Object value;

        value = feature.get(field);

        return value;

    }

    public Expression getRotation() {

        String value = feature.get(LROTATION).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    public int getComputedRotation() {

        Integer value = (Integer) getValueFromExpression(getRotation());

        return value;

    public Expression getText() {

        if (feature == null) {

            return null;

        }

        String value = feature.get(LTEXT).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    public String getComputedText() {

        String value = (String) getValueFromExpression(getText());

        return value;

    public Expression getHeight() {

        String value = feature.get(LHEIGHT).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    public int getComputedHeight() {

        int value = (int) getValueFromExpression(getHeight());

        return value;

    }

    @Override

    public Expression getColor() {

        String value = feature.get(LCOLOR).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    }

    @Override

    public Color getComputedColor() {

        int rgbcolor = (int) getColor().execute(getFeatureSymbolTable());

        Color color = new Color(rgbcolor, true);

        return color;

    }

    @Override

    public Expression getFixedSize() {

        String value = feature.get(LHEIGHT).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    }

    @Override

    public double getComputedFixedSize() {

        double value = (double) getValueFromExpression(getFixedSize());

        return value;

    }

    @Override

    public int getComputedUnit() {

        int value = (int) getValueFromExpression(getUnitExp());

        return value;

    }

    @Override

        this.LTEXT=textFieldName;

         this.LROTATION=rotationFieldName;

        this.LHEIGHT=heightFieldName;

         this.LCOLOR=colorFieldName;

        return false;

        return true;

    public Expression getFixedColor() {

        String value = feature.get(LCOLOR).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    public Color getComputedFixedColor() {

        int rgbcolor = (int) getFixedColor().execute(getFeatureSymbolTable());

        Color color = new Color(rgbcolor, true);

        return color;

    }

    @Override

    public Expression getColorFont() {

        String value = feature.get(LCOLOR).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    public Color getComputedColorFont() {

        int rgbcolor = (int) getColorFont().execute(getFeatureSymbolTable());

        Color color = new Color(rgbcolor, true);

        return color;

    }

    @Override

    public Expression getFont() {

        String value = feature.get(LFONT).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    public Font getComputedFont() {

        String value = (String) getFont().execute(getFeatureSymbolTable());

        Font font = new Font(value, getComputedFontStyle(), getComputedHeight());

        return font;

    }

    @Override

    @Override

    public Expression getFontStyle() {

        String value = feature.get(LFONTSTYLE).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    }

    @Override

    public int getComputedFontStyle() {

        int value = (int) getFontStyle().execute(getFeatureSymbolTable());

        return value;

    }

    @Override

    public void setFontStyle(int selFont) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    public void setFeature(Feature f) {

        feature = f;

    }

    @Override

    public ILabelingMethod getLabelingMethod() {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setLabelingMethod(ILabelingMethod method) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public IPlacementConstraints getPlacementConstraints() {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setPlacementConstraints(IPlacementConstraints constraints) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public IZoomConstraints getZoomConstraints() {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setZoomConstraints(IZoomConstraints constraints) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public Expression getUnitExp() {

        String value = "-1";

        Expression exp = getExpressionFromString(value);

        return exp;

    }

    public Expression getReferenceSystemExp() {

        String value = "0";

        Expression exp = getExpressionFromString(value);

        return exp;

    }

    private org.gvsig.fmap.geom.primitive.Point createLabelPoint(org.gvsig.fmap.geom.Geometry geom)

            throws CreateGeometryException {

        try {

            return geom.centroid();

        } catch (GeometryOperationNotSupportedException e) {

            return null;

        } catch (GeometryOperationException e) {

            return null;

        }

    }

    @Override

    public void draw(BufferedImage mapImage, Graphics2D mapGraphics, double scale, ViewPort viewPort, Cancellable cancel, double dpi) throws ReadException {

//        double scale = getScale(viewPort, props);

        PrintAttributes props = null;

        if (layer == null) {

            return;

        }

        if (zoom == null

                || (zoom.isUserDefined() && (scale >= zoom.getMaxScale())

                && (scale <= zoom.getMinScale()))) {

            FeatureSet set = null;

            DisposableIterator iterator = null;

            try {

//                AttrInTableLabelingStrategy.FilteredLogger logger = new AttrInTableLabelingStrategy.FilteredLogger(AttrInTableLabelingStrategy.logger, 10);

                // limit the labeling to the visible extent

                List<String> fields = new ArrayList<String>();

                FeatureStore featureStore = layer.getFeatureStore();

                ICoordTrans ct = layer.getCoordTrans();

                String geomName = featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName();

                fields.add(LCOLOR);

                fields.add(LFONT);

                fields.add(LFONTSTYLE);

                fields.add(LHEIGHT);

                fields.add(LROTATION);

                fields.add(LTEXT);

                fields.add(geomName);

                FeatureQuery featureQuery = layer.createFeatureQuery();

                if (viewPort.getAdjustedEnvelope().contains(

                        layer.getFullEnvelope())) {

                    /*

                     * viewport contains layer completely

                     */

                    set = featureStore.getFeatureSet(featureQuery);

                } else {

                    /*

                     * view port does not contain layer completely

                     */

                    Evaluator iee = null;

                    IProjection data_proj = null;

                    Envelope env_in_store_crs = null;

                    if (ct == null) {

                        env_in_store_crs = viewPort.getAdjustedEnvelope();

                        data_proj = viewPort.getProjection();

                    } else {

                        env_in_store_crs = viewPort.getAdjustedEnvelope().convert(

                                ct.getInverted());

                        data_proj = ct.getPOrig();

                    }

                    iee = SpatialEvaluatorsFactory.getInstance().intersects(

                            env_in_store_crs,

                            data_proj,

                            featureStore

                    );

                    featureQuery.setAttributeNames((String[]) fields.toArray(new String[fields.size()]));

                    featureQuery.setFilter(iee);

                    set = featureStore.getFeatureSet(featureQuery);

                }

                /*

                 * 'set' now has the features that have to be labeled

                 */

                FeatureSelection selection = this.layer.getFeatureStore().getFeatureSelection();

                iterator = set.fastIterator();

                while (iterator.hasNext()) {

                    if (cancel.isCanceled()) {

                        return;

                    }

                    try {

                        Feature feat = (Feature) iterator.next();

                        Geometry geom = feat.getDefaultGeometry();

                        if (geom == null) {

                            continue;

                        }

                        double size = 0;

                        Color color = null;

                        this.setFeature(feat);

                        if ("".equals(getComputedText())) {

                            continue;

                        } else if (getComputedText() == null) {

                            continue;

                        }

                        SimpleTextSymbol sym = new SimpleTextSymbol();

                        sym.setFont(getComputedFont());

                        sym.setUnit(getComputedUnit());

                        sym.setReferenceSystem(getComputedReferenceSystemExp());

                        if (this.usesFixedSize()) { //(useFixedSize) {

                            // uses fixed size

                            size = getComputedFixedSize();// * fontScaleFactor;

                        } else if (true) { //(getComputedHeight() ) {

                            // text size is defined in the table

                            size = getComputedHeight();

                        } else {

                            // otherwise will use the size in the symbol

                            size = sym.getFont().getSize();

                        }

                        double the_dpi = viewPort.getDPI();

                        if (props != null) {

                            int len = PrintAttributes.PRINT_QUALITY_DPI.length;

                            int priq = props.getPrintQuality();

                            if (priq < 0 || priq >= len) {

                                throw new ReadException(featureStore.getName(),

                                        new Exception("Bad print quality value: " + priq));

                            } else {

                                the_dpi = PrintAttributes.PRINT_QUALITY_DPI[priq];

                            }

                        }

                        size = CartographicSupportToolkit.getCartographicLength(this,

                                size,

                                viewPort,

                                the_dpi);

                        if (size <= MIN_TEXT_SIZE) {

                            // label is too small to be readable, will be skipped

                            // this speeds up the rendering in wider zooms

                            continue;

                        }

                        /*

                         * ym.setFontSize(int) assumes dpi = 72

                         */

                        double font_size = size * 72 / the_dpi;

                        sym.setFontSize(font_size);

//                        if (false) { //useFixedColor) {

//                            color = getComputedFixedColor();

//                        } else if (true) { //colorFieldName != null) {

//                            // text size is defined in the table

                        if (selection.isSelected(feat)) {

                            color = MapContext.getSelectionColor();

                        } else {

                            color = getComputedColorFont();

                        }

                        sym.setTextColor(color);

                        if (ct != null) {

                            /*

                             * Reproject from store CRS to view CRS

                             */

                            geom = geom.cloneGeometry();

                            geom.reProject(ct);

                        }

                        Point p = null;

                        // text rotation is defined in the table

                        double rotation = -Math.toRadians(((Number) getComputedRotation()).doubleValue());

                        p = createLabelPoint(geom);

                        sym.setText(getComputedText());

                        sym.setRotation(rotation);

                        if (p != null) {

                            if (props == null) {

                                sym.draw(mapGraphics, viewPort.getAffineTransform(), p, feat, cancel);

                            } else {

                                sym.print(mapGraphics, viewPort.getAffineTransform(), p, props);

                            }

                        }

                    } catch (Exception ex) {

                        logger.warn("", ex);

                    }

                }

            } catch (BaseException e) {

                throw new ReadException(

                        "Could not draw annotation in the layer.", e);

            } finally {

                if (iterator != null) {

                    iterator.dispose();

                }

                if (set != null) {

                    set.dispose();

                }

            }

        }

    }

    @Override

    public void print(Graphics2D g, double scale, ViewPort viewPort, Cancellable cancel, PrintAttributes properties) throws ReadException {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public String[] getUsedFields() {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setLayer(FLayer flayer) {

        layer = (FLyrVect) flayer;

    }

    @Override

    public boolean shouldDrawLabels(double scale) {

        return true;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setUnit(int unitIndex) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public int getUnit() {

        return getComputedUnitExp();

    }

    public int getComputedUnitExp() {

        int value = (int) getValueFromExpression(getUnitExp());

        return value;

    }

    public int getComputedReferenceSystemExp() {

        int value = (int) getValueFromExpression(getReferenceSystemExp());

        return value;

    }

    @Override

    public int getReferenceSystem() {

        return 0;

    }

    @Override

    public void setReferenceSystem(int referenceSystem) {

        this.referenceSystem = referenceSystem;

    }

    @Override

    public double toCartographicSize(ViewPort viewPort, double dpi, Geometry geom) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setCartographicSize(double cartographicSize, Geometry geom) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public double getCartographicSize(ViewPort viewPort, double dpi, Geometry geom) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setFontField(String fontField) {

        this.LFONT = fontField;

    }

    @Override

    public void setFontStyleField(String field) {

        this.LFONTSTYLE=field;

    }