Application: gvSIG desktop

import org.apache.commons.lang3.mutable.MutableObject;

import org.gvsig.app.gui.styling.AbstractTypeSymbolEditor;

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

        private FeatureStore featureStore;

        private transient MutableObject<Feature> sampleFeature;

                    this.setFeatureStore(((FLyrVect) lyr).getFeatureStore());

			symbolPreviewComponent = new SymbolPreviewer(this.getSampleFeature());

        public void setFeatureStore(FeatureStore store) {

            this.featureStore = store;

            if( this.featureStore!=null ) {

                this.sampleFeature.setValue(this.featureStore.getSampleFeature());

            }

        }

        public MutableObject<Feature> getSampleFeature() {

            if( this.sampleFeature == null ) {

                this.sampleFeature = new MutableObject();

                if( this.featureStore!=null ) {

                    this.sampleFeature.setValue(this.featureStore.getSampleFeature());

                }

            }

            return this.sampleFeature;

        }

import java.net.MalformedURLException;

import java.net.URL;

    public void testURL() throws Exception {

        SymbolTable symbolTable = createSymbolTable();

        URL source = new URL("file://tmp/gvsig/<%='nombre-'||precio||'.txt'%>");

        URL target = ExpressionUtils.evaluateURL(symbolTable,source);

        assertEquals("file://tmp/gvsig/nombre-200.txt", target.toString());

    }

import java.net.MalformedURLException;

import java.net.URL;

    public static URL evaluateURL(URL source) {

        return evaluateURL(null, source);

    }

    public static boolean isDynamicURL(URL source) {

        if( source == null ) {

            return false;

        }

        return isDynamicText(source.toString());

    }

        String src =  source.getPath();

        if( !isDynamicText(src) ) {

            return source;

        }

    @SuppressWarnings("StringEquality")

    public static URL evaluateURL(SymbolTable symbolTable, URL source) {

        String src =  source.toString();

        if( !isDynamicText(src) ) {

            return source;

        }

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        String r = manager.evaluateDynamicText(symbolTable, src);

        if( r == src ) { // !!! I compare that it is the same pointer, it is what I want.

            return source;

        }

        try {

            URL url = new URL(r);

            return url;

        } catch (MalformedURLException ex) {

            return source;

        }

    }

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

    @Override

    public Action createUniqueTemporalFileAction(JTextComponent jtext, String filename, String fileExtension) {

        return this.createUniqueTemporalFileAction(jtext, new ImmutablePair(filename, fileExtension));

    }

    @Override

    public Action createUniqueTemporalFileAction(JTextComponent jtext, Pair<String, String> nameAndExtension) {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        Action uniqueTemporalFileAction = new AbstractAction(

                i18nManager.getTranslation("_Temporal_file_path")) {

                @Override

                public void actionPerformed(ActionEvent e) {

                    String fileExtension = nameAndExtension.getRight();

                    if( !StringUtils.startsWith(fileExtension, ".") ) {

                        fileExtension = "."+fileExtension;

                    }

                    if (jtext.isEditable() && jtext.isEnabled()) {

                        jtext.setText("<%=UNIQUETEMPORARYFILE('" + nameAndExtension.getLeft() + fileExtension + "')%>");

                    }

                }

            };

        return uniqueTemporalFileAction;

    }

import org.apache.commons.lang3.tuple.Pair;

    public interface FileNameAndExtension {

    }

    public Action createUniqueTemporalFileAction(JTextComponent jtext, String filename, String fileExtension);

    public Action createUniqueTemporalFileAction(JTextComponent jtext, Pair<String,String> nameAndExtension);

public interface IPictureMarkerSymbol extends IMarkerSymbol_v2 {

     * @param imageUrl

     * @param imageFileUrl

/*

 * gvSIG. Desktop Geographic Information System.

 * 

 * Copyright (C) 2007-2020 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, see <https://www.gnu.org/licenses/>. 

 * 

 * 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.symbology.fmap.mapcontext.rendering.symbol.marker;

import java.awt.Color;

import java.awt.geom.Point2D;

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

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

/**

 *

 * @author gvSIG Team

 */

public interface IMarkerSymbol_v2 extends IMarkerSymbol, ISymbol_v2 {

    Color getEfectiveLineToOffsetColor(Feature f);

    Point2D getEfectiveOffset(Feature f);

    double getEfectiveRotationInDegres(Feature f);

    double getEfectiveRotationInRadians(Feature f);

    double getEfectiveSize(Feature f);

    Color getLineToOffsetColor();

    String getLineToOffsetColorExpression();

    String getOffsetXExpression();

    String getOffsetYExpression();

    String getRotationExpression();

    String getSizeExpression();

    public boolean isDrawLineToOffset();

    void setDrawLineToOffset(boolean drawLineToOffset);

    void setLineToOffsetColor(Color color);

    void setLineToOffsetColorExpression(String lineToOffsetColorExpression);

    void setOffsetXExpression(String offsetXExpression);

    void setOffsetYExpression(String offsetYExpression);

    void setRotationExpression(String rotationExpression);

    void setSizeExpression(String sizeExpression);

}

import org.gvsig.expressionevaluator.SymbolTable;

    protected SymbolTable symbolTable;

    @Override

    public void setSymbolTable(SymbolTable symbolTable) {

        this.symbolTable = symbolTable;

    }

import java.util.Objects;

import org.apache.commons.collections4.map.LRUMap;

import org.gvsig.expressionevaluator.ExpressionUtils;

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

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

    private static  BufferedImage imageNotFound = null;

    private static LRUMap<URL, BufferedImage> cachedImages = null;

    private URL getEfectiveURL() {

        if( !ExpressionUtils.isDynamicURL(source) ) {

            return source;

        }

        try {

            return ExpressionUtils.evaluateURL(this.symbolTable, this.source);

        } catch(Exception ex) {

            return null;

        }

    }

    private BufferedImage getEfectiveImage() {

        if (!ExpressionUtils.isDynamicURL(this.source)) {

            if (this.img == null) {

                try {

                    this.img = ImageIO.read(this.source);

                } catch (IOException ex) {

                    LOGGER.warn("Can't load image from url (" + Objects.toString(this.source) + ")", ex);

                }

            }

            return this.img;

        }

        URL url = this.getEfectiveURL();

        if( url == null ) {

            return null;

        }

        if (cachedImages == null) {

            cachedImages = new LRUMap<>(20);

        }

        BufferedImage theImage = cachedImages.get(url);

        if (theImage == null) {

            try {

                theImage = ImageIO.read(url);

                cachedImages.put(url, theImage);

            } catch (IOException ex) {

                theImage = this.getImageNotFound();

            }

        }

        return theImage;

    }

    private BufferedImage getImageNotFound() {

        if( imageNotFound==null ) {

            URL url = this.getClass().getResource("imageStyle-filenotfound.png");

            if( url == null ) {

                return null;

            }

            try {

                imageNotFound = ImageIO.read(url);

            } catch (IOException ex) {

                imageNotFound = null;

            }

        } 

        return imageNotFound;

    }

     * Defines the source (file) from where the buffered image will be taken.

     *

     * @param url

     */

    @Override

    public void setSource(URL url) throws IOException {

        this.source = url;

        this.img = null;

    }

    /**

        if (getEfectiveImage() == null) {

        BufferedImage theImage = getEfectiveImage();

        if (theImage != null) {

                if (theImage.getWidth() > theImage.getHeight()) {

                    scale = r.getWidth() / theImage.getWidth();

                    yOffset = 0.5 * (r.getHeight() - theImage.getHeight() * scale);

                    scale = r.getHeight() / theImage.getHeight();

                    xOffset = 0.5 * (r.getWidth() - theImage.getWidth() * scale);

                xScale = r.getWidth() / theImage.getWidth();

                yScale = r.getHeight() / theImage.getHeight();

                yOffset = theImage.getHeight() * 0.5 * yScale;

            g.drawRenderedImage(theImage, at);

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

    protected static final Logger LOGGER = LoggerFactory.getLogger(AbstractStyle.class);

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

 *

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

    public static final String SYMBOL_PERSISTENCE_DEFINITION_NAME = "Symbol";

    private static final String FIELD_UNIT = "unit";

    private static final String FIELD_REFERENCE_SYSTEM = "referenceSystem";

    private static final String FIELD_IS_SHAPE_VISIBLE = "isShapeVisible";

    private static final String FIELD_DESCRIPTION = "description";

    private String desc;

    private String id;

    private int unit;

    private int referenceSystem;

    private boolean isShapeVisible = true;

    private transient Feature feature;

    public AbstractSymbol() {

        super();

        SymbolPreferences preferences

                = MapContextLocator.getSymbolManager().getSymbolPreferences();

        unit

                = preferences.getDefaultCartographicSupportMeasureUnit();

        referenceSystem

                = preferences.getDefaultCartographicSupportReferenceSystem();

    }

    @Override

    public Feature getFeature() {

        return this.feature;

    }

    @Override

    public void setFeature(Feature feature) {

        this.feature = feature;

    }

    @Override

    public final void setDescription(String desc) {

        this.desc = desc;

    }

    @Override

    public final String getDescription() {

        return desc;

    }

    @Override

    public final void setID(String id) {

        this.id = id;

    }

    @Override

    public final String getID() {

        return id;

    }

    @Override

    public final boolean isShapeVisible() {

        return isShapeVisible;

    }

    /**

     * Sets this symbol to visible

     *

     * @param isShapeVisible

     */

    public final void setIsShapeVisible(boolean isShapeVisible) {

        this.isShapeVisible = isShapeVisible;

    }

    @Override

    public void setUnit(int unitIndex) {

        this.unit = unitIndex;

    }

    @Override

    public int getUnit() {

        return this.unit;

    }

    @Override

    public int getReferenceSystem() {

        return this.referenceSystem;

    }

    @Override

    public void setReferenceSystem(int system) {

        this.referenceSystem = system;

    }

    private boolean areEquals(Object a, Object b) {

        if (a == null) {

            if (b == null) {

                return true;

            }

            return false;

        } else {

            if (b == null) {

                return false;

            }

        }

        return a.equals(b);

    }

    @Override

    @SuppressWarnings("UnusedAssignment")

    public boolean equals(Object obj) {

        ISymbol other = null;

        if (obj == null) {

            return false;

        }

        if (!areEquals(obj.getClass(), this.getClass())) {

            // El try/catch y la salida al log es una medida

            // temporal hasta que averiguemos quien causa que

            // pase por aqui, ya que no parece razonable que 

            // desde gvSIG se invoque con algo que no sea un ISymbol.

            try {

                other = (ISymbol) obj;

            } catch (Exception ex) {

                LOG.warn("Suspicious comparison between ISymbol and '" + obj.getClass().getName() + "'.", ex);

            }

            return false;

        }

        other = (ISymbol) obj;

        if (!areEquals(other.getColor(), this.getColor())) {

            return false;

        }

        if (other.getOnePointRgb() != this.getOnePointRgb()) {

            return false;

        }

        if (!areEquals(other.getDescription(), this.getDescription())) {

            return false;

        }

        return true;

    }

    @Override

    public boolean isOneDotOrPixel(Geometry geom,

            double[] positionOfDotOrPixel, ViewPort viewPort, int dpi) {

        int type = geom.getType();

        switch (type) {

            case Geometry.TYPES.NULL:

            case Geometry.TYPES.POINT:

            case Geometry.TYPES.MULTIPOINT:

                return false;

            default:

                org.gvsig.fmap.geom.primitive.Envelope geomBounds = geom

                        .getEnvelope();

                double dist1Pixel = viewPort.getDist1pixel();

                float[] distances = new float[2];

                this.getPixExtentPlus(geom, distances, viewPort, dpi);

                boolean onePoint

                        = (geomBounds.getLength(0) + distances[0] <= dist1Pixel && geomBounds

                        .getLength(1)

                        + distances[1] <= dist1Pixel);

                if (onePoint) {

                    Rectangle bounds = geom.getShape().getBounds();

                    positionOfDotOrPixel[0] = bounds.x;

                    positionOfDotOrPixel[1] = bounds.y;

                }

                return onePoint;

        }

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        return super.clone();

    }

    protected ISymbol cloneForSelection() {

        try {

            ISymbol selectionSymbol = (ISymbol) clone();

            selectionSymbol.setColor(MapContext.getSelectionColor());

            if (getDescription() != null) {

                selectionSymbol.setDescription(getDescription().concat(

                        " version for selection"));

            } else {

                selectionSymbol.setDescription("version for selection");

            }

            return selectionSymbol;

        } catch (CloneNotSupportedException e) {

            LOG.error(

                    "Error creating the selection symbol for the symbol "

                    + this, e);

        return null;

    }

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        setDescription(state.getString(FIELD_DESCRIPTION));

        setIsShapeVisible(state.getBoolean(FIELD_IS_SHAPE_VISIBLE));

        setReferenceSystem(state.getInt(FIELD_REFERENCE_SYSTEM));

        setUnit(state.getInt(FIELD_UNIT));

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set(FIELD_DESCRIPTION, getDescription());

        state.set(FIELD_IS_SHAPE_VISIBLE, isShapeVisible());

        state.set(FIELD_REFERENCE_SYSTEM, getReferenceSystem());

        state.set(FIELD_UNIT, getUnit());

    }

    public static class RegisterPersistence implements Callable {

        @Override

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager.getDefinition(SYMBOL_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition = manager.addDefinition(

                        AbstractSymbol.class,

                        SYMBOL_PERSISTENCE_DEFINITION_NAME,

                        SYMBOL_PERSISTENCE_DEFINITION_NAME + " persistence definition",

                        null,

                        null

                );

                // Description

                definition.addDynFieldString(FIELD_DESCRIPTION);

                // Is Shape Visible

                definition.addDynFieldBoolean(FIELD_IS_SHAPE_VISIBLE).setMandatory(true);

                // Reference system

                definition.addDynFieldInt(FIELD_REFERENCE_SYSTEM).setMandatory(true);

                // Unit

                definition.addDynFieldInt(FIELD_UNIT).setMandatory(true);

            }

            return Boolean.TRUE;

        }

    }

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

        // By default only need the default Geometry

        return new String[]{featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName()};

    }

}

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol_v2;

public abstract class AbstractMarkerSymbol extends AbstractSymbol implements IMarkerSymbol_v2 {

    private static final String FIELD_LINETOOFFSETCOLOR = "lineToOffsetColor";

    private static final String FIELD_DRAWLINETOOFFSET = "drawLineToOffset";

    private static final String FIELD_SIZE_EXPRESSION = "sizeExpression";

    private Color lineToOffsetColor;

    private String sizeExpression;

    private transient org.gvsig.fmap.geom.primitive.Point point;

        this.lineToOffsetColor = Color.BLACK;

        try {

            this.point = GEOMETRY_MANAGER.createPoint(0, 0, SUBTYPES.GEOM2D);

        } catch (CreateGeometryException ex) {

        }

    protected org.gvsig.fmap.geom.primitive.Point getPoint(double x, double y) {

        this.point.setX(x);

        this.point.setY(y);

        return this.point;

    }

    protected SymbolTable getSymbolTable(Feature f) {

    @Override

    public Color getLineToOffsetColor() {

        return this.lineToOffsetColor;

    }

    @Override

    public void setLineToOffsetColor(Color color) {

        this.lineToOffsetColor = color;

    }

    @Override

    public boolean isDrawLineToOffset() {

        return this.drawLineToOffset;

    }

    @Override

    public void setDrawLineToOffset(boolean drawLineToOffset) {

        this.drawLineToOffset = drawLineToOffset;

    }

    @Override

    @Override

    @Override

    @Override

    @Override

    @Override

    @Override

    public String getSizeExpression() {

        return sizeExpression;

    @Override

    public void setSizeExpression(String sizeExpression) {

        this.sizeExpression = StringUtils.trimToNull(sizeExpression);

    @Override

    @Override

    @Override

        if( f == null ) {

            f = this.getFeature();

        }

        int offsetX = ExpressionUtils.parseInt(

                this.getSymbolTable(f), 

                offsetXExpression, 

                (int) this.getOffset().getX()

        );

        int offsetY = ExpressionUtils.parseInt(

                this.getSymbolTable(f), 

                offsetYExpression, 

                (int) this.getOffset().getY()

        );

    @Override

    public double getEfectiveRotationInDegres(Feature f) {

        // Por defecto vedra en grados.

        if( f == null ) {

            f = this.getFeature();

        }

        double r = ExpressionUtils.parseDouble(

                this.getSymbolTable(f), 

                rotationExpression, 

                this.getRotation()

        );

    public double getEfectiveRotationInRadians(Feature f) {

        // Pillamos el valor por defecto que es en grados y lo transformamos a radianes.

        double r = this.getEfectiveRotationInDegres(f);

        if( r == 0 ) {

            return 0;

        }

        r = Math.toRadians(r);

        return r;

    }

    @Override

    public Color getEfectiveLineToOffsetColor(Feature f) {

        if( f == null ) {

            f = this.getFeature();

        }

        if( f==null || StringUtils.isBlank(this.lineToOffsetColorExpression) ) {

            return this.getLineToOffsetColor();

        }

        Color theColor = ExpressionUtils.parseColor(

                this.getSymbolTable(f), 

                this.lineToOffsetColorExpression, 

                this.getLineToOffsetColor()

        );

        return theColor;

    }

    @Override

    public double getEfectiveSize(Feature f) {

        if( f == null ) {

            f = this.getFeature();

        }

        if( f==null || StringUtils.isBlank(this.sizeExpression) ) {

            return this.getSize();

        }

        double sz = ExpressionUtils.parseDouble(

                this.getSymbolTable(f), 

                this.sizeExpression, 

                this.getSize()

        );

        return sz;

    }

    @Override

        double originalSize = getEfectiveSize(getFeature());

        draw(g, at, geom, getFeature(), null);

                draw(

                        g, 

                        scaleInstance, 

                        this.getPoint(r.getCenterX(), r.getCenterY()),

//                        GEOMETRY_MANAGER.createPoint(r.getCenterX(), r.getCenterY(), SUBTYPES.GEOM2D), 

                        this.getFeature(), 

                        null

                );

                double originalSize = getEfectiveSize(getFeature());

                print(

                        g, 

                        scaleInstance, 

                        this.getPoint(r.getCenterX(), r.getCenterY()),

//                        GEOMETRY_MANAGER.createPoint(r.getCenterX(), r.getCenterY(), SUBTYPES.GEOM2D), 

                        properties

                );

        } catch (Exception e) {

        double oldSize = getEfectiveSize(getFeature());

        setLineToOffsetColor((Color) state.get(FIELD_LINETOOFFSETCOLOR));

        setSizeExpression(state.getString(FIELD_SIZE_EXPRESSION));

        state.set(FIELD_LINETOOFFSETCOLOR, getLineToOffsetColor());

        state.set(FIELD_DRAWLINETOOFFSET, isDrawLineToOffset());

        state.set(FIELD_SIZE_EXPRESSION, getSizeExpression());