Application: gvSIG desktop » gvSIG tools: Attribute editor

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright © 2007-2014 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 2

 * 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, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * 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.fmap.mapcontrol.tools.Listeners;

import java.awt.event.ActionEvent;

import java.awt.event.ComponentAdapter;

import java.awt.event.ComponentEvent;

import java.awt.event.InputEvent;

import java.awt.event.MouseEvent;

import java.util.List;

import java.util.function.Predicate;

import javax.swing.Action;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.expressionevaluator.GeometryExpressionUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.featureform.swing.CreateJFeatureFormException;

import org.gvsig.featureform.swing.JFeaturesForm;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

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

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

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.dal.feature.FeatureStoreNotification;

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

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

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.dal.swing.DataSwingManager;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

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

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

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

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.fmap.mapcontrol.tools.BehaviorException;

import org.gvsig.fmap.mapcontrol.tools.Events.EnvelopeEvent;

import org.gvsig.fmap.mapcontrol.tools.Events.PointEvent;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.service.ServiceException;

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

import org.gvsig.tools.swing.api.windowmanager.WindowManager.MODE;

/**

 * @author gvSIG Team

 *

 */

@SuppressWarnings("UseSpecificCatch")

public class AttributeEditorPointListener 

        extends AbstractToolListener  

        implements RectangleListener

    {

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

    public static final String ATTRIBUTE_EDITOR_TOOL_NAME = "attributeEditorTool";

    private static final String ATTRIBUTE_EDITOR_FORM_NAME = "attributeEditorForm";

    private final MapControl mapControl;

    private JFeaturesForm form;

    private Predicate<FeatureStore> refreshCallback;

    private Observer refreshFormObserver;

    public AttributeEditorPointListener(MapControl mapControl, JFeaturesForm form) {

        super();

        this.mapControl = mapControl;

        this.form = form;

        this.refreshFormObserver = (Observable o, Object o1) -> {

            doRefreshFormObserver(o, o1);

        };

    }

    public AttributeEditorPointListener(MapControl mapControl) {

        super();

        this.mapControl = mapControl;

        this.refreshFormObserver = (Observable o, Object o1) -> {

            doRefreshFormObserver(o, o1);

        };

    }

    private FLyrVect getLayer() {

        FLayer[] layers = mapControl.getMapContext().getLayers().getActives();

        if (layers == null || layers.length != 1) {

            return null;

        }

        return (FLyrVect) layers[0];

    }

//    @Override

//    public void point(PointEvent e) throws BehaviorException {

//        MouseEvent mouseEvent = e.getEvent();

//        if (((mouseEvent.getModifiersEx() & (InputEvent.CTRL_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK

//            | InputEvent.ALT_DOWN_MASK | InputEvent.ALT_GRAPH_DOWN_MASK | InputEvent.META_DOWN_MASK)) != 0)

//            || !SwingUtilities.isLeftMouseButton(mouseEvent)) {

//            return;

//        }

//        String layerName = "";

//        I18nManager i18nManager = ToolsLocator.getI18nManager();

//        try {

//            FLyrVect layer = getLayer();

//            if (layer == null) {

//                String msg = i18nManager.getTranslation("There_is_no_one_and_only_one_active_layer");

//                ToolsSwingLocator.getThreadSafeDialogsManager().messageDialog(msg,

//                    i18nManager.getTranslation("attribute_editor"), JOptionPane.INFORMATION_MESSAGE);

//                return;

//            }

//            layerName = layer.getName();

//            ViewPort vp = this.mapControl.getViewPort();

//            Point point = vp.convertToMapPoint(e.getPoint());

//            double tolerance = vp.toMapDistance(layer.getDefaultTolerance());

//            FeatureQuery query = queryByPoint(point, tolerance);

//            showOrUpdateForm(layer, query);

//        } catch (Exception ex) {

//            LOGGER.warn("Can't show attribute information from point on the layer " + layerName, ex);

//            String msg =

//                i18nManager.getTranslation("Cant_show_attribute_information_for_layer_%1_on_point",

//                    new String[] { layerName });

//            ToolsSwingLocator.getThreadSafeDialogsManager().messageDialog(msg,

//                i18nManager.getTranslation("attribute_editor"), JOptionPane.WARNING_MESSAGE);

//        }

//    }

    public void showOrUpdateForm() {

        String layerName = "";

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        try {

            FLyrVect layer = getLayer();

            if (layer == null) {

                return;

            }

            layerName = layer.getName();

            FeatureQuery query;

            FeatureStore store = layer.getFeatureStore();

            if(store.isFeatureSelectionEmpty()){

                return;

            }

            FeatureSelection selection = store.getFeatureSelectionQuietly();

            Expression filter = selection.makeFilter(100);

            if(filter == null){

                String msg =

                    i18nManager.getTranslation("_Unable_to_get_filter_for_XlayernameX_layer_selection",

                        new String[] { layerName });

                ToolsSwingLocator.getThreadSafeDialogsManager().message(msg, JOptionPane.WARNING_MESSAGE);

                return;

            }

            if(selection.size()>100){

                String msg =

                    i18nManager.getTranslation("_Too_many_items_selected_Only_the_first_100_will_be_displayed",

                        new String[] { layerName });

                ToolsSwingLocator.getThreadSafeDialogsManager().message(msg, JOptionPane.WARNING_MESSAGE);

            }

            query = store.createFeatureQuery(filter);

            showOrUpdateForm(layer, query);

        } catch (Exception ex) {

            LOGGER.warn("Can't show attribute information from selection on the layer " + layerName, ex);

            String msg =

                i18nManager.getTranslation("_Cant_show_attribute_information_for_layer_XlayernameX_on_selection",

                    new String[] { layerName });

            ToolsSwingLocator.getThreadSafeDialogsManager().messageDialog(msg,

                i18nManager.getTranslation("attribute_editor"), JOptionPane.WARNING_MESSAGE);

        }

    }

    private void showOrUpdateForm(FLyrVect layer, FeatureQuery query) {

        if( layer == null || query==null ) {

            return;

        }

        String layerName = layer.getName();

        if( layerName == null ) {

            layerName = "";

        }

        showOrUpdateForm(layerName, layer.getFeatureStore(), query);

    }

    public void showOrUpdateForm(String storeName, FeatureStore featureStore, FeatureQuery query) {

        if( featureStore == null || query==null ) {

            return;

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        try {

            synchronized (featureStore) {

            boolean needshow = true;

            if( StringUtils.isBlank(storeName) ) {

                storeName = featureStore.getLabel();

            }

            if (this.form == null) {

                this.form = getForm(featureStore, query);

                needshow = true;

//                this.form.showForm(makeTitle("attribute_editor", storeName, featureStore.getName()), MODE.TOOL);

            } else if( this.form.getFeatureStore()!=featureStore ) {

//            } else if( !featureStore.getParameters().isTheSameStore(this.form.getFeatureStore().getParameters())) {

//                Dimension size = this.form.asJComponent().getPreferredSize();

                disposeForm();

                this.form = getForm(featureStore, query);

//                this.form.asJComponent().setPreferredSize(size);

//                this.form.showForm(makeTitle("attribute_editor", storeName, featureStore.getName()), MODE.TOOL);

                needshow = true;

            } else {

                this.form.setQuery(query);

                needshow = false;

            }

            List<Feature> values = this.form.getFormset().getValues();

            FeatureSelection selection = (FeatureSelection) featureStore.getSelection();

            selection.deselectAll();

            FeatureSelection selectionTmp = featureStore.createFeatureSelection();

            for (Feature fof : values) {

               selectionTmp.select(fof);

            }

            selection.select(selectionTmp);

//            try {

//                synchronized (featureStore) {

//                    FeatureSet featSet = featureStore.getFeatureSet(query);

//                    if( featSet.isEmpty() ) {

//                        return;

//                    }

//                    FeatureSelection selection = (FeatureSelection) featureStore.getSelection();

//                    selection.deselectAll();

//                    selection.select(featSet);

//                }

//            } catch (DataException ex) {

//                LOGGER.warn("Can't query layer " + storeName+", query: "+query, ex);

//                return;

//            }

            if( needshow ) {

                this.form.showForm(makeTitle("attribute_editor", storeName, featureStore.getName()), MODE.TOOL);

            }

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't show attribute information from point on the layer " + storeName, ex);

            String msg =

                i18n.getTranslation("Cant_show_attribute_information_for_layer_%1_on_point",

                    new String[] { storeName });

            ToolsSwingLocator.getThreadSafeDialogsManager().messageDialog(msg,

                i18n.getTranslation("attribute_editor"), JOptionPane.WARNING_MESSAGE);

            disposeForm();

        }

    }

    private void disposeForm() {

        if( this.form != null ) {

            FeatureStore store = this.form.getFeatureStore();

            if( store!=null ) {

                store.deleteObserver(this.refreshFormObserver);

            }

        }

        DisposeUtils.disposeQuietly(this.form);

        this.form = null;

    }

    public void setRefreshCallback(Predicate<FeatureStore> refreshCallback) {

        this.refreshCallback = refreshCallback;

    }

    private JFeaturesForm getForm(FeatureStore store, FeatureQuery query) throws CreateJFeatureFormException, ServiceException, DataException {

        if (this.form == null) {

            DataSwingManager swingManager = DALSwingLocator.getSwingManager();

            JFeaturesForm theForm = swingManager.createJFeaturesForm(store, query);

            this.form = theForm;

            this.form.setTerminateEditingOnClose(false);

            this.form.asJComponent().setName(ATTRIBUTE_EDITOR_FORM_NAME);

            this.form.asJComponent().addComponentListener(new ComponentAdapter() {

                @Override

                public void componentHidden(ComponentEvent e) {

                    DisposeUtils.disposeQuietly(theForm);

                }

            });

            this.form.addActionListener((ActionEvent e) -> {

                switch (e.getActionCommand()) {

                    case "formAfterSave":

                    case "formAfterDelete":

                        if( this.refreshCallback!=null ) {

                            this.refreshCallback.test(store);

                        }

                        break;

                }

            });

            store.addObserver(this.refreshFormObserver);

        }

        return this.form;

    }

    private void doRefreshFormObserver(Observable o, Object o1) {

        if( this.form == null || 

                !(o instanceof FeatureStore && o1 instanceof FeatureStoreNotification ) ) {

            return;

        }

        try {

            FeatureStoreNotification n = (FeatureStoreNotification) o1;

            if( n.getType().equalsIgnoreCase(FeatureStoreNotification.AFTER_REFRESH) ) {

                Action refreshAction = this.form.getFormset().getAction(JFeaturesForm.REFRESHFORM_ACTION);

                if( refreshAction!=null ) {

                    refreshAction.actionPerformed(null);

                }

            }

        } catch(Exception ex) {

            LOGGER.warn("Can't refresh attribute editor",ex);

        }

    }

    private FeatureQuery queryByPoint(Point point, double tol) throws CreateGeometryException, DataException {

        GeometryManager manager = GeometryLocator.getGeometryManager();

        Circle circle = (Circle) manager.create(TYPES.CIRCLE, SUBTYPES.GEOM2D);

        circle.setPoints(point, tol);

        FLyrVect currentLayer = this.getLayer();

        if( currentLayer==null ) {

            return null;

        }

        FeatureStore featureStore = currentLayer.getFeatureStore();

        FeatureQuery featureQuery = featureStore.createFeatureQuery();

        FeatureType featureType = featureStore.getDefaultFeatureType();

        featureQuery.setFeatureType(featureType);

        Geometry query_geo = currentLayer.transformToSourceCRS(circle, true);

        IProjection query_proj = currentLayer.getMapContext().getProjection();

        if (currentLayer.getCoordTrans() != null) {

            query_proj = currentLayer.getCoordTrans().getPOrig();

        }

        Evaluator iee = SpatialEvaluatorsFactory.getInstance().intersects(

                query_geo, 

                query_proj, 

                featureStore

        );

        featureQuery.setFilter(iee);

        featureQuery.retrievesAllAttributes();

        return featureQuery;

    }

    @Override

    public void rectangle(EnvelopeEvent e) throws BehaviorException {

        MouseEvent mouseEvent = e.getEvent();

        if (((mouseEvent.getModifiersEx() & (InputEvent.CTRL_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK

            | InputEvent.ALT_DOWN_MASK | InputEvent.ALT_GRAPH_DOWN_MASK | InputEvent.META_DOWN_MASK)) != 0)

            || !SwingUtilities.isLeftMouseButton(mouseEvent)) {

            return;

        }

        String layerName = "";

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        try {

            FLyrVect layer = getLayer();

            if (layer == null) {

                String msg = i18nManager.getTranslation("There_is_no_one_and_only_one_active_layer");

                ToolsSwingLocator.getThreadSafeDialogsManager().messageDialog(msg,

                    i18nManager.getTranslation("attribute_editor"), JOptionPane.INFORMATION_MESSAGE);

                return;

            }

            layerName = layer.getName();

            FeatureQuery query;

            Geometry geom = e.getWorldCoordRect().getGeometry();            

            if( geom instanceof Point ) {

                ViewPort vp = this.mapControl.getViewPort();

                double tolerance = vp.toMapDistance(layer.getDefaultTolerance());

                query = queryByPoint((Point) geom, tolerance);

            } else {

                FeatureStore store = layer.getFeatureStore();

                FeatureType featureType = store.getDefaultFeatureTypeQuietly();

                GeometryExpressionBuilder builder = GeometryExpressionUtils.createExpressionBuilder();

                String filter = builder.ST_Intersects(

                        builder.column(featureType.getDefaultGeometryAttributeName()), 

                        builder.geometry(e.getWorldCoordRect().getGeometry())

                ).toString();

                query = store.createFeatureQuery(filter);

            }

            showOrUpdateForm(layer, query);

        } catch (Exception ex) {

            LOGGER.warn("Can't show attribute information from point on the layer " + layerName, ex);

            String msg =

                i18nManager.getTranslation("Cant_show_attribute_information_for_layer_%1_on_point",

                    new String[] { layerName });

            ToolsSwingLocator.getThreadSafeDialogsManager().messageDialog(msg,

                i18nManager.getTranslation("attribute_editor"), JOptionPane.WARNING_MESSAGE);

        }

    }

    public String makeTitle(String base, String docname, String docname2) {

        I18nManager i18n = ToolsLocator.getI18nManager();

//        if( StringUtils.startsWith(base, "_") ) {

            base = i18n.getTranslation(base);

//        }

        String title = base + ": " + docname;

        if( StringUtils.isNotBlank(docname2) && !StringUtils.equals(docname, docname2)) {

            title = title + " ("+docname2+")";

        }

        return title;

    }

}