Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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, 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.app.project.documents.view.dynformfield.linkforeingkeywgs;

import java.awt.Color;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Image;

import java.awt.event.ActionEvent;

import java.awt.event.ComponentAdapter;

import java.awt.event.ComponentEvent;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.awt.event.InputEvent;

import java.awt.event.MouseEvent;

import java.util.Objects;

import javax.swing.JButton;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JTextField;

import javax.swing.JToggleButton;

import javax.swing.SwingUtilities;

import javax.swing.event.AncestorEvent;

import javax.swing.event.AncestorListener;

import javax.swing.text.JTextComponent;

import org.apache.commons.lang.StringUtils;

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

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

import org.cresques.cts.IProjection;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

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

import org.gvsig.app.project.documents.view.gui.IView;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.expressionevaluator.GeometryExpressionUtils;

import org.gvsig.featureform.swing.JFeaturesForm;

import org.gvsig.featureform.swing.FeaturesFormContext;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.ForeingKey.ContextForeingKey;

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

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

import org.gvsig.fmap.dal.swing.searchpanel.FeatureStoreSearchPanel;

import org.gvsig.fmap.geom.Geometry;

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

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

import org.gvsig.fmap.mapcontrol.tools.Behavior.PointBehavior;

import org.gvsig.fmap.mapcontrol.tools.Behavior.RectangleBehavior;

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

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

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

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

import org.gvsig.fmap.mapcontrol.tools.Listeners.AbstractPointListener;

import org.gvsig.fmap.mapcontrol.tools.Listeners.RectangleListener;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynform.DynFormFieldDefinition;

import org.gvsig.tools.dynform.JDynForm;

import org.gvsig.tools.dynform.JDynFormField;

import org.gvsig.tools.dynform.spi.DynFormSPIManager;

import org.gvsig.tools.dynform.spi.DynFormSPIManager.ComponentsFactory;

import org.gvsig.tools.dynform.spi.dynformfield.AbstractJDynFormField;

import org.gvsig.tools.dynform.spi.dynformfield.JDynFormFieldFactory;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.i18n.I18nManager;

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

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

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

import org.gvsig.tools.swing.api.windowmanager.Dialog;

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

import org.gvsig.tools.swing.api.windowmanager.WindowManager_v2;

@SuppressWarnings("UseSpecificCatch")

public class JDynFormFieldForeingKeyWGS extends AbstractJDynFormField implements JDynFormField {

    private Object assignedValue = null;

    private Object value = null;

    private Feature relatedFeature = null;

    private JTextComponent txtDescription = null;

    private JToggleButton btnLinkGraphically = null;

    private JButton btnLink = null;

    private JButton btnUnlink = null;

    private JButton btnEdit = null;

    private MapControl mapControl;

    private String previosTool;

    private Color colorok;

    private static class ForeignkeyCaptureListener extends AbstractPointListener implements RectangleListener {

        private FLyrVect layer;

        protected MapControl mapControl;

        private JDynFormFieldForeingKeyWGS field;

        private ForeignkeyCaptureListener(MapControl mapControl) {

            this.mapControl = mapControl;

        }

        public void putValueInFormField(Feature f) throws BehaviorException {

            if (f == null) {

                return;

            }

            final ForeingKey foreingKey = field.getForeingKey();

            if (foreingKey == null) {

                return;

            }

            final ContextForeingKey context = foreingKey.createContext();

            try {

                field.setEditedValue(foreingKey.getCode(context, f));

                field.relatedFeature = f;

            } finally {

                DisposeUtils.disposeQuietly(context);

            }

            field.fireFieldChangedEvent();

        }

        public void setLayer(FLyrVect layer) {

            this.layer = layer;

        }

        public FLyrVect getLayer() {

            return this.layer;

        }

        public void setField(JDynFormFieldForeingKeyWGS field) {

            this.field = field;

        }

        @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 = "";

            try {

                @SuppressWarnings("LocalVariableHidesMemberVariable")

                FLyrVect layer = getLayer();

                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);

                search(layer, query);

            } catch (Exception ex) {

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

            }

        }

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

            GeometryManager manager = GeometryLocator.getGeometryManager();

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

            circle.setPoints(point, tol);

            FLyrVect currentLayer = 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.getEnvelope(),

                    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 = "";

            try {

                @SuppressWarnings("LocalVariableHidesMemberVariable")

                FLyrVect layer = getLayer();

                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);

                }

                search(layer, query);

            } catch (Exception ex) {

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

            }

        }

        private void search(FLyrVect layer, FeatureQuery query) {

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

                return;

            }

            String layerName = "";

            try {

                layerName = layer.getName();

                FeatureStore featureStore = layer.getFeatureStore();

                this.putValueInFormField(featureStore.findFirst(query));

            } catch (Exception ex) {

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

            }

        }

    }

    private static class ForeignkeyCaptureBehavior extends CompoundBehavior {

        ForeignkeyCaptureListener foreignkeyCaptureListener;

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public ForeignkeyCaptureBehavior(MapControl mapControl) {

            super(new Behavior[0]);

            this.foreignkeyCaptureListener = new ForeignkeyCaptureListener(mapControl);

            this.addMapBehavior(new PointBehavior(foreignkeyCaptureListener), true);

            this.addMapBehavior(new RectangleBehavior(foreignkeyCaptureListener), true);

        }

        @Override

        public Image getImageCursor() {

            return this.foreignkeyCaptureListener.getImageCursor();

        }

        @Override

        public ForeignkeyCaptureListener getListener() {

            return this.foreignkeyCaptureListener;

        }

        public void setLayer(FLyrVect layer) {

            this.foreignkeyCaptureListener.setLayer(layer);

        }

        public void setField(JDynFormFieldForeingKeyWGS field) {

            this.foreignkeyCaptureListener.setField(field);

        }

    }

    public JDynFormFieldForeingKeyWGS(

            DynFormSPIManager serviceManager,

            DynFormSPIManager.ComponentsFactory componentsFactory,

            JDynFormFieldFactory factory,

            DynFormFieldDefinition definition,

            Object value

    ) {

        super(serviceManager, componentsFactory, factory, definition, value);

        if (value != null) {

            this.assignedValue = (DynObject) value;

        }

        this.colorok = Color.white;

    }

    @Override

    public Object getAssignedValue() {

        return this.assignedValue;

    }

    public void initComponentIfNeed() {

        if (this.contents == null) {

            this.initComponent();

        }

    }

    @Override

    public void initComponent() {

        ComponentsFactory components = this.getComponentsFactory();

        FocusListener focusListener = new FocusListener() {

            @Override

            public void focusGained(FocusEvent e) {

                fireFieldEnterEvent();

            }

            @Override

            public void focusLost(FocusEvent e) {

                fireFieldExitEvent();

            }

        };

        this.txtDescription = components.getJTextField(this.getDefinition(), null);

        if (this.txtDescription == null) {

            this.txtDescription = new JTextField();

        }

        this.colorok = this.txtDescription.getBackground();

        this.btnLinkGraphically = components.getJToggleButton(this.getDefinition(), "LinkGraphical");

        if (this.btnLinkGraphically == null) {

            this.btnLinkGraphically = new JToggleButton();

        }

        this.btnLink = components.getJButton(this.getDefinition(), "Link");

        if (this.btnLink == null) {

            this.btnLink = new JButton();

        }

        this.btnUnlink = components.getJButton(this.getDefinition(), "Unlink");

        if (this.btnUnlink == null) {

            this.btnUnlink = new JButton();

        }

        this.btnEdit = components.getJButton(this.getDefinition(), "Edit");

        if (this.btnEdit == null) {

            this.btnEdit = new JButton();

        }

        ToolsSwingUtils.configurePickersButton(

                btnLinkGraphically, 

                "_Select_related_item_graphically", 

                "selection-simple-select", 

                (ActionEvent ae) -> {doLinkGraphically(this.btnLinkGraphically.isSelected());},

                focusListener

        );

        ToolsSwingUtils.configurePickersButton(

                btnLink, 

                "_Select_related_item", 

                "picker-foreingkey-link", 

                (ActionEvent ae) -> {doLink();},

                focusListener

        );

        ToolsSwingUtils.configurePickersButton(

                btnUnlink, 

                "_Remove_relation", 

                "picker-foreingkey-unlink", 

                (ActionEvent ae) -> {doUnlink();},

                focusListener

        );

        ToolsSwingUtils.configurePickersButton(

                btnEdit, 

                "_See_related_item", 

                "picker-foreingkey-showform", 

                (ActionEvent ae) -> {doEdit();},

                focusListener

        );        

//        this.initButton(this.btnLinkGraphically, "Select item to link graphically", "selection-simple-select");

//        this.initButton(this.btnLink, "Select item to link", "formfield-foreignkey-link");

//        this.initButton(this.btnUnlink, "Remove link", "formfield-foreignkey-unlink");

//        this.initButton(this.btnEdit, "View linked item", "formfield-foreignkey-edit");

//

//        this.btnLinkGraphically.addActionListener((ActionEvent ae) -> {

//            fireFieldEnterEvent();

//            doLinkGraphically(this.btnLinkGraphically.isSelected());

//        });

        this.btnLinkGraphically.addComponentListener(new ComponentAdapter() {

            @Override

            public void componentHidden(ComponentEvent e) {

                doLinkGraphically(false);

            }

        });

        this.btnLinkGraphically.addAncestorListener(new AncestorListener() {

            @Override

            public void ancestorAdded(AncestorEvent event) {

            }

            @Override

            public void ancestorRemoved(AncestorEvent event) {

                doLinkGraphically(false);

            }

            @Override

            public void ancestorMoved(AncestorEvent event) {

            }

        });

//        this.btnLink.addActionListener((ActionEvent ae) -> {

//            fireFieldEnterEvent();

//            doLink();

//        });

//        this.btnUnlink.addActionListener((ActionEvent ae) -> {

//            fireFieldEnterEvent();

//            doUnlink();

//        });

//        this.btnEdit.addActionListener((ActionEvent ae) -> {

//            fireFieldEnterEvent();

//            doEdit();

//        });

        this.txtDescription.setText("                        ");

        this.txtDescription.addFocusListener(new FocusListener() {

            @Override

            public void focusGained(FocusEvent e) {

                fireFieldEnterEvent();

            }

            @Override

            public void focusLost(FocusEvent e) {

                fireFieldExitEvent();

            }

        });

        this.txtDescription.setEditable(false);

        boolean enabled = !this.isReadOnly();

        this.btnEdit.setEnabled(enabled);

        this.btnLink.setEnabled(enabled);

        this.btnUnlink.setEnabled(enabled);

        // Habilitar solo si no hay ninguna modal visible.

        this.btnLinkGraphically.setEnabled(enabled);

        JPanel panel = new JPanel();

        if (!components.containsJTextField(this.getDefinition(), null)) {

            panel.setLayout(new GridBagLayout());

            GridBagConstraints c = new GridBagConstraints();

            c.fill = GridBagConstraints.HORIZONTAL;

            c.ipadx = 4;

            c.ipady = 1;

            c.gridx = 1;

            c.gridy = 0;

            c.weightx = 1;

            panel.add(this.txtDescription, c);

            c.fill = GridBagConstraints.NONE;

            c.ipadx = 4;

            c.ipady = 1;

            c.gridx = 2;

            c.gridy = 0;

            c.weightx = 0;

            panel.add(this.btnLinkGraphically, c);

            c.fill = GridBagConstraints.NONE;

            c.ipadx = 4;

            c.ipady = 1;

            c.gridx = 3;

            c.gridy = 0;

            c.weightx = 0;

            panel.add(this.btnLink, c);

            c.fill = GridBagConstraints.NONE;

            c.ipadx = 4;

            c.ipady = 1;

            c.gridx = 4;

            c.gridy = 0;

            c.weightx = 0;

            panel.add(this.btnUnlink, c);

            c.fill = GridBagConstraints.NONE;

            c.ipadx = 4;

            c.ipady = 1;

            c.gridx = 5;

            c.gridy = 0;

            c.weightx = 0;

            panel.add(this.btnEdit, c);

        }

        this.contents = panel;

        this.setValue(this.assignedValue);

    }

//    private AbstractButton initButton(AbstractButton button, final String tip, final String image) {

//        if (button.getIcon() == null) {

//            IconThemeManager iconThemeManager = ToolsSwingLocator.getIconThemeManager();

//            Icon icon = iconThemeManager.getCurrent().get(image);

//            if (icon == null) {

//                URL url = this.getClass().getClassLoader().getResource("org/gvsig/featureform/swing/impl/" + image + ".png");

//                if (url != null) {

//                    icon = new ImageIcon(url);

//                }

//            }

//            if (icon != null) {

//                button.setIcon(icon);

//            }

//        }

//        if (button.getText().trim().equals("...") && button.getIcon() != null) {

//            button.setText("");

//        }

//        button.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));

//        button.setBorderPainted(false);

////        button.setFocusPainted(false);

////        button.setContentAreaFilled(false);

//        button.setToolTipText(tip);

//        button.setCursor(new Cursor(Cursor.HAND_CURSOR));

//        return button;

//    }

    private ForeingKey getForeingKey() {

        JDynForm.DynFormContext context = this.getForm().getContext();

        if (!(context instanceof FeaturesFormContext)) {

            return null;

        }

        FeatureType featureType = ((FeaturesFormContext) context).getFeatureType();

        if (featureType == null) {

            return null;

        }

        FeatureAttributeDescriptor attribute = featureType.getAttributeDescriptor(this.getName());

        if (attribute == null) {

            return null;

        }

        ForeingKey foreingKey = attribute.getForeingKey();

        return foreingKey;

    }

    private void doLink() {

        final ForeingKey foreingKey = this.getForeingKey();

        if (foreingKey == null) {

            return;

        }

        final ContextForeingKey context = foreingKey.createContext();

        try {

            DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

            final FeatureStoreSearchPanel searchPanel = dataSwingManager.createFeatureStoreSearchPanel(

                    foreingKey.getFeatureStore(context)

            );

            searchPanel.setFilterOnlyMode(true);

            WindowManager_v2 winManager = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

            ToolsSwingUtils.ensureHeightWitdh(

                    searchPanel, 

                    ToolsSwingUtils.RELATIVE_TO_SCREEN,

                    0.75f, 0.75f, 0.85f, 0.85f

            );               

            final Dialog dialog = winManager.createDialog(

                    searchPanel.asJComponent(),

                    "Select",

                    "Select the '" + this.getLabel() + "'.",

                    WindowManager_v2.BUTTONS_OK_CANCEL

            );

            dialog.setButtonEnabled(WindowManager_v2.BUTTON_OK, this.btnUnlink.isEnabled());

            dialog.addActionListener((ActionEvent e) -> {

                if (dialog.getAction() == WindowManager_v2.BUTTON_OK) {

                    Feature feature = searchPanel.getLastSelectedFeature();

                    if (feature != null) {

                        setEditedValue(foreingKey.getCode(context, feature));

                        this.relatedFeature = feature;

                        fireFieldChangedEvent();

                    }

                }

            });

            dialog.show(WindowManager.MODE.DIALOG);

        } catch (Exception ex) {

            LOGGER.warn("Can't show selector", ex);

        } finally {

            DisposeUtils.disposeQuietly(context);

        }

    }

    public Feature getRelatedFeature() {

        try {

            if (this.relatedFeature != null) {

                return this.relatedFeature;

            }

            final ForeingKey foreingKey = this.getForeingKey();

            if (foreingKey == null) {

                return null;

            }

            this.relatedFeature = foreingKey.getFeature(null, value);

            return this.relatedFeature;

        } catch (Exception ex) {

            LOGGER.warn("Can't retrieve related feature from '" + value + "'.", ex);

            return null;

        }

    }

    private void doUnlink() {

        this.setEditedValue(null);

        fireFieldChangedEvent();

    }

    private void doEdit() {

        if (this.value == null) {

            return;

        }

        final ForeingKey foreingKey = this.getForeingKey();

        if (foreingKey == null) {

            return;

        }

        final ContextForeingKey context = foreingKey.createContext();

        try {

            this.btnEdit.setEnabled(false);

            DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

            FeatureQuery query = foreingKey.getQuery(context, value);

            JFeaturesForm form = dataSwingManager.createJFeaturesForm(

                    foreingKey.getFeatureStore(context)

            );

            form.setQuery(query);

            form.showForm(WindowManager.MODE.WINDOW);

        } catch (Exception ex) {

            LOGGER.warn("Can't show linked form", ex);

        } finally {

            this.btnEdit.setEnabled(true);

            DisposeUtils.disposeQuietly(context);

        }

    }

    private String getDescription() {

        if (this.value == null) {

            return null;

        }

        try {

            final ForeingKey foreingKey = this.getForeingKey();

            if (foreingKey == null) {

                return null;

            }

            String description = foreingKey.getLabel(null, value);

            return description;

        } catch (Exception ex) {

        }

        return null;

    }

    @Override

    public void setReadOnly(boolean readonly) {

        initComponentIfNeed();

        this.readOnly = readonly;

        boolean editable = !readonly;

        JComponent theJLabel = this.getJLabel();

        if( this.jlabel != null ) {

            this.jlabel.setEnabled(editable);

        } else if( theJLabel !=null ) {

            theJLabel.setEnabled(editable);

        }

        this.txtDescription.setEditable(false);

        this.btnEdit.setEnabled(true);

        this.btnLink.setEnabled(true);

        this.btnUnlink.setEnabled(editable);

        // Habilitar solo si no hay ninguna modal visible.

        this.btnLinkGraphically.setEnabled(editable);

        this.setReadOnlyButtonsOfEvents(readonly);

    }

    @Override

    public void setValue(Object value) {

        setEditedValue(value);

        this.assignedValue = value;

    }

    public void setEditedValue(Object value) {

        initComponentIfNeed();

        if (value == null) {

            this.value = null;

            this.txtDescription.setText("");

            return;

        }

        this.problemIndicator().clear();

        this.value = value;

        String description = this.getDescription();

        if( description == null ) {

            this.txtDescription.setText(Objects.toString(value, ""));

            this.txtDescription.setBackground(ToolsSwingLocator.getToolsSwingManager().getWarningBackgroundColor());

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.problemIndicator().set(i18n.getTranslation("_Related_feature_not_found"));

        } else {

            this.txtDescription.setText(Objects.toString(description));

            this.txtDescription.setBackground(this.colorok);

        }       

        this.relatedFeature = null;

    }

    @Override

    public Object getValue() {

        return this.value;

    }

    @Override

    public boolean hasValidValue() {

        return true;

    }

    @Override

    public void clear() {

        this.setValue(null);

    }

    @Override

    public boolean isModified() {

        return !Objects.equals(this.value, this.getAssignedValue());

    }

    private void doLinkGraphically(boolean isSelected) {

        final ForeingKey foreingKey = this.getForeingKey();

        if (foreingKey == null) {

            LOGGER.warn("Can't retrieve foreignkey information");

            return;

        }

        final ContextForeingKey context = foreingKey.createContext();

        try {

            if (isSelected) {

                FeatureStore store = foreingKey.getFeatureStore(context);

                Pair<MapControl, FLyrVect> mapControlAndLayer = findMapControl(store);

                if (mapControlAndLayer != null) {

                    this.mapControl = mapControlAndLayer.getLeft();

                    if (!this.mapControl.hasTool("foreingkey-capture")) {

                        Behavior captureTool = new ForeignkeyCaptureBehavior(mapControl);

                        this.mapControl.addBehavior("foreingkey-capture", captureTool);

                    }

                    String s = this.mapControl.getCurrentTool();

                    if (!StringUtils.equalsIgnoreCase(s, "foreingkey-capture")) {

                        this.previosTool = s;

                    }

                    this.mapControl.setTool("foreingkey-capture");

                    Behavior captureTool = this.mapControl.getCurrentMapTool();

                    if (captureTool instanceof ForeignkeyCaptureBehavior) {

                        ((ForeignkeyCaptureBehavior)captureTool).setField(this);

                        ((ForeignkeyCaptureBehavior)captureTool).setLayer(mapControlAndLayer.getRight());

                    }

                    this.getForm().message("Activada la seleccion grafica de '"+this.getDefinition().getLabel()+"'.");

                } else {

                    ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                    dialogs.messageDialog(

                            "No se ha encontrado la tabla '"+store.getName()+"' en la Vista activa.", 

                            "Selector grafico", 

                            JOptionPane.INFORMATION_MESSAGE

                    );

                    this.mapControl = null;

                    this.btnLinkGraphically.setSelected(false);

                }

            } else {

                if( this.mapControl!=null ) {

                    if (StringUtils.isBlank(this.previosTool)) {

                        this.mapControl.setTool("pointSelection");

                    } else {

                        this.mapControl.setTool(this.previosTool);

                    }

                }

                this.getForm().message("Desactivada la seleccion grafica.");

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't active/deactive foreingkey grafical selection", ex);

        } finally {

            DisposeUtils.disposeQuietly(context);

        }

    }

    private Pair<MapControl, FLyrVect> findMapControl(FeatureStore store) {

        ApplicationManager application = ApplicationLocator.getApplicationManager();

        IView view = (IView) application.getActiveComponent(ViewDocument.class);

        if (view == null) {

            return null;

        }

        DataStoreParameters storeParams = store.getParameters();

        MapControl theMapControl = view.getMapControl();

        MapContext mapContext = theMapControl.getMapContext();

        for (FLayer layer : mapContext.getLayers().deepiterable()) {

            if (layer instanceof FLyrVect) {

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

                if (layerStore.getParameters().isTheSameStore(storeParams)) {

                    return new ImmutablePair<>(theMapControl, ((FLyrVect) layer));

                }

            }

        }

        return null;

    }

}