Application: gvSIG desktop

package org.gvsig.app.project;

import java.io.File;

import java.io.FileInputStream;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Properties;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.Range;

import org.cresques.cts.IProjection;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.ViewManager;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

import org.gvsig.fmap.crs.CRSFactory;

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.Envelope;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.layers.FLayer;

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

import org.gvsig.fmap.mapcontrol.AreaAndPerimeterCalculator;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class ProjectSymbolTable extends AbstractSymbolTable {

    private abstract class CachedValue<T> {

        T value = null;

        long lastAccess = 0;

        protected abstract void reload();

        public boolean isExpired() {

            long now = System.currentTimeMillis();

            return now - lastAccess > 3000;

        }

        public T get() {

            if (isExpired()) {

                reload();

            }

            lastAccess = System.currentTimeMillis();

            return value;

        }

    }

    private class ProjectValue extends CachedValue<Project> {

        @Override

        protected void reload() {

            value = ProjectManager.getInstance().getCurrentProject();

        }

    }

    private class CurrentViewValue extends CachedValue<ViewDocument> {

        @Override

        protected void reload() {

            ApplicationManager application = ApplicationLocator.getManager();

            ViewDocument viewdoc = (ViewDocument) application.getActiveDocument(ViewManager.TYPENAME);

            value = viewdoc;

        }

    }

    private class CurrentViewEnvelopeValue extends CachedValue<Geometry> {

        @Override

        protected void reload() {

            ApplicationManager application = ApplicationLocator.getManager();

            ViewDocument viewdoc = (ViewDocument) application.getActiveDocument(ViewManager.TYPENAME);

            if( viewdoc == null ) {

                value = null;

                return;

            }

            value = viewdoc.getMapContext().getViewPort().getEnvelope().getGeometry();

        }

    }

    private class PropertiesValue extends CachedValue<Map<File, Properties>> {

        @Override

        protected void reload() {

            value = new HashMap<>();

        }

    }

    private class CurrentProjectFunction extends AbstractFunction {

        public CurrentProjectFunction() {

            super(

                    "Project",

                    "project",

                    Range.is(0),

                    "Access to the current project loaded in gvSIG desktop.\n",

                    "project()",

                    null,

                    "Project"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            return currentProject.get();

        }

    }

    private class FirstSelectedFeatureFunction extends AbstractFunction {

        public FirstSelectedFeatureFunction() {

            super(

                    "Project",

                    "firstSelectedFeature",

                    Range.between(3, 4),

                    "Access to the first selected feature of the layer, and "

                    + "return the value of the attribute.",

                    "firstSelectedFeature({{view}}, layer, attribute, defaulValue)",

                    new String[]{

                        "view - String value with the name of a view",

                        "layer - String value with the name of a layer in the indicated view",

                        "attribute - String value with the name of the attribute in the indicated layer",

                        "defaultValue - Optional. Value to use if the indicated "

                        + "attribute can not be accessed. For example, if the "

                        + "view or layer does not exist, or it does not have "

                        + "selected elements."

                    },

                    "Object"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            Object defaultValue = null;

            String viewName = getStr(args, 0);

            String layerName = getStr(args, 1);

            String attrName = getStr(args, 2);

            if (args.length == 4) {

                defaultValue = getObject(args, 3);

            }

            try {

                Project project = currentProject.get();

                ViewDocument view = (ViewDocument) project.getDocument(viewName, ViewManager.TYPENAME);

                if (view == null) {

                    return defaultValue;

                }

                FLayer layer = view.getLayer(layerName);

                if (!(layer instanceof FLyrVect)) {

                    return defaultValue;

                }

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

                if (selection == null || selection.isEmpty()) {

                    return defaultValue;

                }

                Feature feature = selection.first();

                if (feature == null) {

                    return defaultValue;

                }

                return feature.get(attrName);

            } catch (Exception ex) {

                return defaultValue;

            }

        }

    }

    private class FirstFeatureFunction extends AbstractFunction {

        public FirstFeatureFunction() {

            super(

                    "Project",

                    "firstFeature",

                    Range.between(3, 6),

                    "Access to the first feature of the layer, and "

                    + "return the value of the attribute.",

                    "firstFeature({{view}}, layer, attribute, filter, order, defaulValue)",

                    new String[]{

                        "view - String value with the name of a view",

                        "layer - String value with the name of a layer in the indicated view",

                        "attribute - String value with the name of the attribute in the indicated layer",

                        "filter - Optional. String value with a filter expression",

                        "order - Optional. String value with the order. must be a string with the names of separate fields with commas",

                        "defaultValue - Optional. Value to use if the indicated "

                        + "attribute can not be accessed. For example, if the "

                        + "view or layer does not exist."

                    },

                    "Object"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            Object defaultValue = null;

            String filter = null;

            String order = null;

            String viewName = getStr(args, 0);

            String layerName = getStr(args, 1);

            String attrName = getStr(args, 2);

            switch (args.length) {

                case 4:

                    filter = getStr(args, 3);

                    break;

                case 5:

                    filter = getStr(args, 3);

                    order = getStr(args, 4);

                    break;

                case 6:

                    filter = getStr(args, 3);

                    order = getStr(args, 4);

                    defaultValue = getObject(args, 6);

                    break;

            }

            try {

                Project project = currentProject.get();

                ViewDocument view = (ViewDocument) project.getDocument(viewName, ViewManager.TYPENAME);

                if (view == null) {

                    return defaultValue;

                }

                FLayer layer = view.getLayer(layerName);

                if (!(layer instanceof FLyrVect)) {

                    return defaultValue;

                }

                FeatureStore store = ((FLyrVect) layer).getFeatureStore();

                FeatureSet set;

                if (filter == null && order == null) {

                    set = store.getFeatureSet();

                } else {

                    FeatureQuery query = store.createFeatureQuery();

                    if (filter != null) {

                        query.addFilter(filter);

                    }

                    if (order != null) {

                        query.getOrder().add(order);

                    }

                    set = store.getFeatureSet(query);

                }

                Feature feature = set.first();

                if (feature == null) {

                    return defaultValue;

                }

                return feature.get(attrName);

            } catch (Exception ex) {

                return defaultValue;

            }

        }

    }

    private class ViewFunction extends AbstractFunction {

        public ViewFunction() {

            super(

                    "Project",

                    "view",

                    Range.is(1),

                    "Access to the indicated view",

                    "view({{viewName}})",

                    new String[]{

                        "view - String value with the name of a view"

                    },

                    "DocumentView"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            String viewName = getStr(args, 0);

            Project project = currentProject.get();

            ViewDocument view = (ViewDocument) project.getDocument(viewName, ViewManager.TYPENAME);

            return view;

        }

    }

    private class ViewBBoxFunction extends AbstractFunction {

        public ViewBBoxFunction() {

            super(

                    "Project",

                    "viewbbox",

                    Range.is(0),

                    "Return the BBox of the active view.",

                    "viewbbox()",

                    null,

                    "Geometry"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            return currentViewEnvelope.get();

        }

    }

    private class AreaFunction extends AbstractFunction {

        public AreaFunction() {

            super(

                    "Project",

                    "Area",

                    Range.between(2,3),

                    "Calculate the area of the geometry in the indicated units",

                    "Area({{geometry}}, \"m\")",

                    new String[]{

                        "geometry - Geometry",

                        "Projection - Optional. Projection of the geometry or a string with the projection name",

                        "units - String value with the name the units to use"

                    },

                    "Double"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            int units = 0;

            IProjection proj = null;

            Geometry geom = getGeom(args, 0);

            switch( args.length ) {

                case 2:

                    units = getUnits(args, 1);

                    break;

                case 3:

                    proj = getProjection(args, 1);

                    units = getUnits(args, 2);

                    break;

            }

            if (proj == null) {

                proj = geom.getProjection();

            }

            AreaAndPerimeterCalculator calculator = new AreaAndPerimeterCalculator();

            double area = calculator.area(geom, proj, units);

            return area;

        }

    }

    private class PerimeterFunction extends AbstractFunction {

        public PerimeterFunction() {

            super(

                    "Project",

                    "Perimeter",

                    Range.between(2,3),

                    "Calculate the perimeter of the geometry in the indicated units",

                    "Perimeter({{geometry}}, \"m\")",

                    new String[]{

                        "geometry - Geometry",

                        "Projection - Optional. Projection of the geometry or a string with the projection name",

                        "units - String value with the name the units to use"

                    },

                    "Double"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            int units = 0;

            IProjection proj = null;

            Geometry geom = getGeom(args, 0);

            switch( args.length ) {

                case 2:

                    units = getUnits(args, 1);

                    break;

                case 3:

                    proj = getProjection(args, 1);

                    units = getUnits(args, 2);

                    break;

            }

            if (proj == null) {

                proj = geom.getProjection();

            }

            AreaAndPerimeterCalculator calculator = new AreaAndPerimeterCalculator();

            double area = calculator.perimeter(geom, proj, units);

            return area;

        }

    }

    private class PropertyFunction extends AbstractFunction {

        public PropertyFunction() {

            super(

                    "Project",

                    "property",

                    Range.between(2, 3),

                    "Access to a property value in a properties file. If the"

                    + "indicated filename is not absolute, access it relative"

                    + "to the project.",

                    "property({{filename}}, name, defaultValue)",

                    new String[]{

                        "filename - String value with the name of the properties file",

                        "name - String value with the name of the property to retrieve from the file",

                        "defaultValue - Optional. Default value if can't access the file or the property",},

                    "String"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            String filename = getStr(args, 0);

            String name = getStr(args, 1);

            String defaultValue = null;

            if (args.length == 3) {

                defaultValue = getStr(args, 2);

            }

            File file = new File(filename);

            if (!file.isAbsolute()) {

                Project project = currentProject.get();

                if (project.getFile() == null) {

                    return defaultValue;

                }

                file = new File(project.getFile().getParent(), filename);

            }

            Map<File, Properties> x = propertiesFiles.get();

            Properties properties = x.get(file);

            if (properties == null) {

                properties = new Properties();

                FileInputStream in = null;

                try {

                    in = new FileInputStream(file);

                    properties.load(in);

                } catch (Exception ex) {

                    return defaultValue;

                } finally {

                    IOUtils.closeQuietly(in);

                }

                x.put(file, properties);

            }

            String value = properties.getProperty(name, defaultValue);

            return value;

        }

    }

    ProjectValue currentProject = new ProjectValue();

    CurrentViewValue currentView = new CurrentViewValue();

    CurrentViewEnvelopeValue currentViewEnvelope = new CurrentViewEnvelopeValue();

    PropertiesValue propertiesFiles = new PropertiesValue();

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public ProjectSymbolTable() {

        super("Project");

        this.addFunction(new CurrentProjectFunction());

        this.addFunction(new FirstSelectedFeatureFunction());

        this.addFunction(new FirstFeatureFunction());

        this.addFunction(new ViewFunction());

        this.addFunction(new ViewBBoxFunction());

        this.addFunction(new PropertyFunction());

        this.addFunction(new AreaFunction());

        this.addFunction(new PerimeterFunction());

    }

    private MapContext getMapContext(Feature feature) {

        FeatureStore store = feature.getStore();

        Project project = ProjectManager.getInstance().getCurrentProject();

        project.getDocuments(ViewManager.TYPENAME);

        for (Document document : project.getDocuments(ViewManager.TYPENAME)) {

            ViewDocument view = (ViewDocument) document;

            MapContext mapContext = view.getMapContext();

            FLayer layer = getLayer(mapContext, store);

            if (layer != null) {

                return mapContext;

            }

        }

        return null;

    }

    private FLayer getLayer(MapContext mapContext, FeatureStore store) {

        Iterator<FLayer> it = mapContext.deepiterator();

        while (it.hasNext()) {

            FLayer layer = it.next();

            if (layer instanceof FLyrVect) {

                FeatureStore layer_store = ((FLyrVect) layer).getFeatureStore();

                if (layer_store == store) {

                    return layer;

                }

            }

        }

        return null;

    }

    private IProjection getProjection(Object[] args, int i) {

        Object value = args[i];

        if (value == null) {

            return null;

        }

        if (value instanceof IProjection) {

            return (IProjection) value;

        }

        String code = value.toString();

        return CRSFactory.getCRS(code);

    }

    private int getUnits(Object[] args, int i) {

        Object value = args[i];

        if (value == null) {

            throw new IllegalArgumentException("Illegal unit value 'null'");

        }

        if (value instanceof Number) {

            return ((Number) value).intValue();

        }

        String name = value.toString();

        String[] names = MapContext.getAreaAbbr();

        for (int j = 0; j < names.length; j++) {

            if (name.equalsIgnoreCase(names[j])) {

                return j;

            }

        }

        names = MapContext.getAreaNames();

        for (int j = 0; j < names.length; j++) {

            if (name.equalsIgnoreCase(names[j])) {

                return j;

            }

        }

        throw new IllegalArgumentException("Illegal unit name '" + name + "'");

    }

    public static void selfRegister() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        manager.registerSymbolTable(new ProjectSymbolTable(), true);

    }

}