Application: gvSIG desktop

/* 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.featureform.swing.impl;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ComponentAdapter;

import java.awt.event.ComponentEvent;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

import java.util.Map;

import javax.swing.AbstractAction;

import javax.swing.Action;

import static javax.swing.Action.ACTION_COMMAND_KEY;

import static javax.swing.Action.NAME;

import static javax.swing.Action.SHORT_DESCRIPTION;

import static javax.swing.Action.SMALL_ICON;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluator;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.featureform.swing.JFeaturesForm;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.EditingNotification;

import static org.gvsig.fmap.dal.EditingNotification.AFTER_REMOVE_FEATURE;

import static org.gvsig.fmap.dal.EditingNotification.AFTER_UPDATE_FEATURE;

import static org.gvsig.fmap.dal.EditingNotification.AFTER_INSERT_FEATURE;

import static org.gvsig.fmap.dal.EditingNotification.AFTER_ENTER_EDITING_STORE;

import static org.gvsig.fmap.dal.EditingNotification.AFTER_EXIT_EDITING_STORE;

import static org.gvsig.fmap.dal.EditingNotification.BEFORE_REMOVE_FEATURE;

import static org.gvsig.fmap.dal.EditingNotification.BEFORE_UPDATE_FEATURE;

import static org.gvsig.fmap.dal.EditingNotification.BEFORE_INSERT_FEATURE;

import static org.gvsig.fmap.dal.EditingNotification.BEFORE_ENTER_EDITING_STORE;

import static org.gvsig.fmap.dal.EditingNotification.BEFORE_EXIT_EDITING_STORE;

import org.gvsig.fmap.dal.EditingNotificationManager;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.FeatureIndexException;

import org.gvsig.fmap.dal.feature.paging.FeaturePagingHelper;

import org.gvsig.fmap.dal.swing.AbstractDALActionFactory.AbstractDALActionContext;

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

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

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

import org.gvsig.fmap.dal.swing.impl.DefaultDataSwingManager;

import org.gvsig.fmap.dal.swing.impl.actions.ShowFormAction.ShowFormActionFactory;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynform.AbortActionException;

import org.gvsig.tools.dynform.DynFormDefinition;

import org.gvsig.tools.dynform.DynFormLocator;

import org.gvsig.tools.dynform.DynFormManager;

import org.gvsig.tools.dynform.JDynForm;

import org.gvsig.tools.dynform.JDynFormField;

import org.gvsig.tools.dynform.JDynFormSet;

import static org.gvsig.tools.dynform.JDynFormSet.ACTION_CANCEL_NEW;

import static org.gvsig.tools.dynform.JDynFormSet.ACTION_DELETE;

import static org.gvsig.tools.dynform.JDynFormSet.ACTION_NAVIGATION;

import static org.gvsig.tools.dynform.JDynFormSet.ACTION_NEW;

import static org.gvsig.tools.dynform.JDynFormSet.ACTION_SAVE;

import static org.gvsig.tools.dynform.JDynFormSet.ACTION_SEARCH;

import org.gvsig.tools.dynform.JDynFormSet.JDynFormSetListener;

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

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

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

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

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

import org.gvsig.tools.swing.icontheme.IconTheme;

import org.gvsig.tools.util.PropertiesSupport;

import org.gvsig.tools.util.PropertiesSupportHelper;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author fdiaz

 *

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultJFeaturesForm implements JFeaturesForm, Disposable {

    private class JFeaturesFormPanel extends JPanel implements PropertiesSupport {

        private final PropertiesSupport properties;

        private JFeaturesFormPanel(PropertiesSupport properties, BorderLayout layout) {

            super(layout);

            this.properties = properties;

        }

        @Override

        public Object getProperty(String name) {

            return this.properties.getProperty(name);

        }

        @Override

        public void setProperty(String name, Object value) {

            this.properties.setProperty(name, value);

        }

        @Override

        public Map<String, Object> getProperties() {

            return this.properties.getProperties();

        }

    }

    private class FormActionContext extends AbstractDALActionContext {

        public FormActionContext() {

            super(ACTION_CONTEXT_NAME);

        }

        @Override

        public DataStore getStore() {

            return store;

        }

        @Override

        public FeatureQuery getQuery() {

            return currentQuery;

        }

        @Override

        public int getSelectedsCount() {

            return 0;

        }

        @Override

        public Expression getFilterForSelecteds() {

            return null;

        }

        @Override

        public FeatureSelection getSelecteds() {

            try {

                FeatureSelection selection = getFeatureStore().createFeatureSelection();

                selection.select(getCurrentFeature());

                return selection;

            } catch (DataException ex) {

                return null;

            }

        }

        @Override

        public JComponent getActionButton(String actionName) {

            if (formset == null) {

                return null;

            }

            return formset.getActionButton(actionName);

        }

    }

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

    private static final int PAGE_SIZE = 10;

    private JFeaturesFormPanel panel;

    private JDynFormSet formset;

    private FeatureStore store;

    private boolean needrefresh;

    private FeaturePagingHelper features;

    private DynFormDefinition definition = null;

    private FeatureQuery currentQuery;

    private List<Action> otherActions;

    private final ActionListenerSupport actionListeners;

    private final PropertiesSupportHelper propertiesHelper;

    private boolean terminateEditingOnClose = true;

    private boolean ignoreTerminateEditingOnClose = false;

    @SuppressWarnings("LeakingThisInConstructor")

    public DefaultJFeaturesForm() {

        this.otherActions = new ArrayList<>();

        this.propertiesHelper = new PropertiesSupportHelper();

        this.propertiesHelper.setProperty("FeaturesForm", this);

        this.panel = new JFeaturesFormPanel(this.propertiesHelper, new BorderLayout());

        this.panel.addComponentListener(new ComponentAdapter() {

            @Override

            public void componentHidden(ComponentEvent e) {

                onClose();

                dispose();

            }

        });

        this.actionListeners = ToolsSwingLocator.getToolsSwingManager().createActionListenerSupport();

    }

    public static void selfRegister() {

    }

    @Override

    public void setPreferredSize(Dimension dimension) {

        panel.setPreferredSize(dimension);

    }

    private void updateForm() {

        if (this.formset == null) {

            this.getFormset();

        }

        try {

            if (this.currentQuery != null) {

                this.currentQuery.retrievesAllAttributes();

            }

            this.features = DALLocator.getDataManager().createFeaturePagingHelper(store, this.currentQuery, PAGE_SIZE);

            callUserEvent("form_beforeReload", this.formset.getForm());

            this.formset.setValues(features.asListOfDynObjects());

            callUserEvent("form_afterReload", this.formset.getForm());

        } catch (Exception ex) {

            throw new RuntimeException("Can't update form", ex);

        }

        this.needrefresh = false;

        updateButtonEnabledStatus();

    }

    @Override

    public JComponent asJComponent() {

        if (this.features == null) {

            try {

                updateForm();

            } catch (Exception ex) {

                throw new RuntimeException(ex);

            }

        }

        return this.panel;

    }

    @Override

    public void bind(FeatureStore store) {

        this.bind(store, null, null);

    }

    public void bind(FeatureStore store, DynClass definition) {

        this.bind(store, definition, null);

    }

    public void bind(FeatureStore store, DynClass definition, FeatureQuery query) {

        if (store == null) {

            throw new IllegalArgumentException("bind need a store as parameter, not a null.");

        }

        if (this.store == store) {

            return;

        }

        try {

            if(store.isEditing()){

                this.ignoreTerminateEditingOnClose = true;

            }

            if (definition == null) {

                DefaultDataSwingManager manager = (DefaultDataSwingManager) DALSwingLocator.getSwingManager();

                definition = manager.featureType2DynClass(store, store.getDefaultFeatureType());

            }

            DynFormManager formManager = DynFormLocator.getDynFormManager();

            this.definition = formManager.getDefinition(definition);

            if (formset != null) {

                this.panel.remove(formset.asJComponent());

                this.panel.revalidate();

                this.formset = null;

            }

            this.store = store;

            DisposeUtils.bind(store);

            this.currentQuery = query;

            if (features != null) {

                this.features = null;

                updateForm();

            }            

        } catch (Exception ex) {

            throw new RuntimeException("Can't bind store '" + store.getName() + "' to form", ex);

        }

    }

    @Override

    public void dispose() {

        if( this.formset!=null ) {

            Action action = this.formset.getAction(FINISHEDITING_ACTION);

            if( action!=null ) {

                DisposeUtils.disposeQuietly(action);

            }

            action = this.formset.getAction(STARTEDITING_ACTION);

            if( action!=null ) {

                DisposeUtils.disposeQuietly(action);

            }

        }

        if( this.panel!=null ) {

            this.panel.setVisible(false);

        }

        DisposeUtils.disposeQuietly(store);

        this.store = null;

        this.panel = null;

        this.formset = null;

        this.features = null;

        this.definition = null;

        this.currentQuery = null;

        this.otherActions = null;

    }

    public static class MyFeaturesFormContext extends DefaultFeaturesFormContext {

        private final DefaultJFeaturesForm featuresForm;

        public MyFeaturesFormContext(DefaultJFeaturesForm featuresForm) {

            super(featuresForm.store);

            this.featuresForm = featuresForm;

        }

        @Override

        public JFeaturesForm getFeaturesForm() {

            return this.featuresForm;

        }

        @Override

        public Feature getCurrentFeature() {    

            return this.featuresForm.getCurrentFeature();

        }

    }

    @Override

    public JDynFormSet getFormset() {

        if (this.formset == null) {

            DynFormManager formManager = DynFormLocator.getDynFormManager();

            this.formset = formManager.createJDynFormSet(

                    new MyFeaturesFormContext(this),

                    this.definition,

                    null

            );

            if(!this.definition.getTags().has(DynFormSPIManager.TAG_DYNFORM_LAYOUTMODE)){

                this.formset.setLayoutMode(JDynForm.USE_TABS);

            }

            List<String> groups = this.definition.getGroups();

            if ((this.formset.getLayoutMode() == JDynForm.USE_TABS || this.formset.getLayoutMode() == JDynForm.USE_SEPARATORS) && groups.size() == 1 && groups.get(0) == null) {

                this.formset.setLayoutMode(JDynForm.USE_PLAIN);

            }

            JComponent component = this.formset.getActionButton(JDynFormSet.ACTION_SET_CURRENT_RECORD);

            if( component!=null ) {

                I18nManager i18n = ToolsLocator.getI18nManager();

                component.setToolTipText(

                    "<html>" +

                    i18n.getTranslation("_Table") + ": " + this.store.getName() +"<br>\n"+

                    "( "+this.store.getFullName() + " )" +

                    "</html>"

                );

            }

            this.formset.setAllowNew(true);

            this.formset.setAllowDelete(true);

            this.formset.setAllowUpdate(true);

            this.formset.setAllowClose(true);

            this.formset.setAllowSearch(true);

            this.formset.setAutosave(true);

            this.formset.addAction(new StartEditingAction());

            this.formset.addAction(new FinishEditingAction());

            this.formset.addAction(new RefreshAction());

            FormActionContext actionContext = new FormActionContext();

            actionContext.set("featuresform", this);

            try {

                Collection<DALActionFactory> factories = DALSwingLocator.getSwingManager().getApplicableStoreActions(actionContext);

                for (DALActionFactory factory : factories) {

                    if (StringUtils.equalsIgnoreCase(factory.getName(), ShowFormActionFactory.ACTION_NAME)) {

                        continue;

                    }

                    try {

                        Action action = factory.createAction(actionContext);

                        this.formset.addAction(action);

                    } catch (Exception ex) {

                        LOGGER.warn("Can't add action " + factory.getName(), ex);

                    }

                }

            } catch (Exception ex) {

                LOGGER.warn("Can't add actions", ex);

            }

            for (Action action : this.otherActions) {

                this.formset.addAction(action);

            }

            this.formset.addListener(new FormSetListener());

            this.formset.getForm().addListener(new JDynForm.JDynFormListener() {

                @Override

                public void message(String string) {

                }

                @Override

                public void fieldChanged(JDynFormField jdff) {

                    updateButtonEnabledStatus();

                }

            });

            ToolsSwingLocator.getToolsSwingManager().removeBorder(this.formset.asJComponent());

            this.panel.add(this.formset.asJComponent(), BorderLayout.CENTER);

            this.panel.revalidate();

            Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

            ToolsSwingUtils.ensureHeightWitdh(this.panel, 256, 400, screenSize.height-100, screenSize.width-60);

        }

        updateButtonEnabledStatus();

        return this.formset;

    }

    @Override

    public void addAction(Action action) {

        this.otherActions.add(action);

        if (this.formset != null) {

            this.formset.addAction(action);

        }

    }

    @Override

    public long getCurrentIndex() {

        if (this.formset == null) {

            return -1;

        }

        return this.formset.getCurrentIndex();

    }

    @Override

    public Feature get(long index) {

        if (this.formset == null || this.features == null) {

            return null;

        }

        try {

            return this.features.getFeatureAt(index);

        } catch (BaseException ex) {

            return null;

        }

    }

    private class RefreshAction extends AbstractAction {

        @SuppressWarnings({"OverridableMethodCallInConstructor", "LeakingThisInConstructor"})

        public RefreshAction() {

            I18nManager i18nManager = ToolsLocator.getI18nManager();

            IconTheme iconTheme = ToolsSwingLocator.getIconThemeManager().getDefault();

            this.putValue(NAME, null);

            this.putValue(SHORT_DESCRIPTION, i18nManager.getTranslation("_Reload_data"));

            this.putValue(SMALL_ICON, iconTheme.get("common-form-refresh"));

            this.putValue(ACTION_COMMAND_KEY, REFRESHFORM_ACTION);

            this.setEnabled(!formset.isInNewState());

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            try {

                I18nManager i18n = ToolsLocator.getI18nManager();

                formset.message(i18n.getTranslation("_Form_reloaded"));

                int x=formset.getCurrentIndex();

                updateForm();

                formset.setCurrentIndex(x);

            } catch (Exception ex) {

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

            }

        }

    }

    private class FinishEditingAction extends AbstractAction implements Observer, Disposable {

        @SuppressWarnings({"OverridableMethodCallInConstructor", "LeakingThisInConstructor"})

        public FinishEditingAction() {

            I18nManager i18nManager = ToolsLocator.getI18nManager();

            IconTheme iconTheme = ToolsSwingLocator.getIconThemeManager().getDefault();

            this.putValue(NAME, null);

            this.putValue(SHORT_DESCRIPTION, i18nManager.getTranslation("_Stop_editing"));

            this.putValue(SMALL_ICON, iconTheme.get("table-stop-editing"));

            this.putValue(ACTION_COMMAND_KEY, FINISHEDITING_ACTION);

            this.setEnabled(store.isEditing());

            store.addObserver(this);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            if (store == null || formset == null) {

                return;

            }

            if (store.isEditing()) {

                EditingNotificationManager editingManager = DALSwingLocator.getEditingNotificationManager();

                DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

                ThreadSafeDialogsManager dialogManager = ToolsSwingLocator.getThreadSafeDialogsManager();

                I18nManager i18nManager = ToolsLocator.getI18nManager();

                try {

                    int index;

                    int x = dataSwingManager.askUserStopEditing(formset.asJComponent(), store, true);

                    switch (x) {

                        case DataSwingManager.STOP_EDITING_SAVE:

                            EditingNotification notification = editingManager.notifyObservers(this, BEFORE_EXIT_EDITING_STORE, null, store);

                            if( notification.isCanceled() || notification.isAborted()) {

                                I18nManager i18n = ToolsLocator.getI18nManager();

                                formset.message(i18n.getTranslation("Finish editing has been cancelled."));

                                return;

                            }                

                            store.finishEditing();

                            editingManager.notifyObservers(this, AFTER_EXIT_EDITING_STORE, null, store);

                            index = formset.getCurrentIndex();

                            try {

                                updateForm();

                                formset.setCurrentIndex(index);

                            } catch (Exception ex) {

                                LOGGER.warn("Can't reload form data after edit.", ex);

                            }

                            break;

                        case DataSwingManager.STOP_EDITING_CONTINUE:

                            break;

                        case DataSwingManager.STOP_EDITING_DISCARD:

                            store.cancelEditing();

                            index = formset.getCurrentIndex();

                            try {

                                updateForm();

                                formset.setCurrentIndex(index);                                

                            } catch (IndexOutOfBoundsException ex) {

                                LOGGER.debug("Can't reload form data after discard edit.",ex);

                            } catch (Exception ex) {

                                LOGGER.warn("Can't reload form data after discard edit.", ex);

                            }

                            break;

                        case DataSwingManager.STOP_EDITING_EXPORT:

                            if( !((DefaultDataSwingManager)dataSwingManager).exportStore(store, MODE.DIALOG) ) {

                                // Mensaje de operacion no soportada

                            }

                    }

                } catch (Exception ex) {

                    LOGGER.warn("Can't finish editing in FeatureForm (" + store.getName() + ").", ex);

                    dialogManager.messageDialog(

                            i18nManager.getTranslation("_Problems_finish_table_editing") + "\n\n"

                            + i18nManager.getTranslation("_see_error_log_for_more_information"),

                            i18nManager.getTranslation("_Stop_editing"),

                            JOptionPane.ERROR_MESSAGE

                    );

                }

            }

            updateButtonEnabledStatus();

        }

        @Override

        public void update(Observable observable, Object notification) {

            if (store == null || formset == null) {

                return;

            }

            if (notification instanceof FeatureStoreNotification) {

                FeatureStoreNotification n = (FeatureStoreNotification) notification;

                switch (n.getType()) {

                    case FeatureStoreNotification.AFTER_CANCELEDITING:

                        needrefresh = true;

                    case FeatureStoreNotification.AFTER_STARTEDITING:

                    case FeatureStoreNotification.AFTER_FINISHEDITING:

                        updateButtonEnabledStatus();

                        break;

                }

            }

        }

        @Override

        public void dispose() {

            store.deleteObserver(this);

        }

    }

    private class StartEditingAction extends AbstractAction implements Observer, Disposable {

        @SuppressWarnings({"OverridableMethodCallInConstructor", "LeakingThisInConstructor"})

        public StartEditingAction() {

            I18nManager i18nManager = ToolsLocator.getI18nManager();

            IconTheme iconTheme = ToolsSwingLocator.getIconThemeManager().getDefault();

            this.putValue(NAME, null);

            this.putValue(SHORT_DESCRIPTION, i18nManager.getTranslation("_Start_editing"));

            this.putValue(SMALL_ICON, iconTheme.get("table-start-editing"));

            this.putValue(ACTION_COMMAND_KEY, STARTEDITING_ACTION);

            this.setEnabled(!store.isEditing());

            store.addObserver(this);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            if (store == null || formset == null) {

                return;

            }

            if (!store.isEditing()) {

                try {

                    EditingNotificationManager editingManager = DALSwingLocator.getEditingNotificationManager();

                    EditingNotification notification = editingManager.notifyObservers(this, BEFORE_ENTER_EDITING_STORE, null, store);

                    if( notification.isCanceled() || notification.isAborted() ) {

                        I18nManager i18n = ToolsLocator.getI18nManager();

                        formset.message(i18n.getTranslation("Enter editing has been cancelled."));

                        return;

                    }                

                    store.edit();

                    editingManager.notifyObservers(this, AFTER_ENTER_EDITING_STORE, null, store);

                } catch (DataException ex) {

                    LOGGER.warn("Can't finish editing in FeatureForm (" + store.getName() + ").", ex);

                }

            }

            updateButtonEnabledStatus();

        }

        @Override

        public void update(Observable observable, Object notification) {

            if (store == null || formset == null) {

                return;

            }

            if (notification instanceof FeatureStoreNotification) {

                FeatureStoreNotification n = (FeatureStoreNotification) notification;

                switch (n.getType()) {

                    case FeatureStoreNotification.AFTER_CANCELEDITING:

                        needrefresh = true;

                    case FeatureStoreNotification.AFTER_STARTEDITING:

                    case FeatureStoreNotification.AFTER_FINISHEDITING:

                        updateButtonEnabledStatus();

                        break;

                }

            }

        }

        @Override

        public void dispose() {

            store.deleteObserver(this);

        }

    }

    @Override

    public void setQuery(FeatureQuery query) {

        if (this.features != null) {

            if (this.formset != null && !formset.isReadOnly() && this.formset.isAutosave() && this.formset.countValues() > 0) {

                if(this.formset.getForm().isModified()){

                    if (!store.isEditing()) {

                        try {

                            store.edit();

                        } catch (DataException e1) {

                            throw new RuntimeException("Can't set query", e1);

                        }

                    }

                    saveChanges(this.formset);

                }

            }

        }

        this.currentQuery = query;

        updateForm();

    }

    private FeatureQuery getCurrentQuery() {

        return this.currentQuery;

    }

    @Override

    public void showForm(MODE mode) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        String title = i18n.getTranslation("_Form") + ": "+ this.definition.getLabel();

        showForm(title, mode);

    }

    @Override

    public void showForm(String title, MODE mode) {

        WindowManager winmgr = ToolsSwingLocator.getWindowManager();

        if( StringUtils.isBlank(title) ) {

            title = this.definition.getLabel();

        }

        winmgr.showWindow(this.asJComponent(), title, mode);

    }

    @Override

    public void hideForm() {

        DisposeUtils.dispose(this);

    }

    private void saveChanges(JDynFormSet theFormSet) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        try {

            EditingNotificationManager editingManager = DALSwingLocator.getEditingNotificationManager();

            if (theFormSet.isInNewState()) {

                EditableFeature newFeature = store.createNewFeature(false);

                JDynForm form = formset.getForm();

                for (FeatureAttributeDescriptor attr : this.store.getDefaultFeatureTypeQuietly()) {

                    String name = attr.getName();

                    if( !newFeature.canSetValue(name) ) {

                        continue;

                    }

                    JDynFormField field = form.getField(name);

                    if( field==null ) {

                        // The attribute is not in form, set default value

                        newFeature.set(name, attr.getDefaultValueCoerced());

                    } else {

                        try {

                            Object value = field.getValue();

                            newFeature.set(name, value);

                        } catch (Exception ex) {

                            LOGGER.warn("Can't get value of field '" + name + "'.", ex);

                        }

                    }

                }

                EditingNotification notification = editingManager.notifyObservers(this, BEFORE_INSERT_FEATURE, null, this.store, newFeature);

                if( notification.isAborted()) {

                    theFormSet.message(i18n.getTranslation("Problems occurred while saving the data."));

                    return;

                }                

                if( notification.isCanceled() ) {

                    theFormSet.message(i18n.getTranslation("Data saving has been cancelled."));

                    return;

                }                

                if (!editingManager.canWriteFeature(newFeature)) {

                    theFormSet.message(i18n.getTranslation("The data cannot be saved. Check that all the required fields are filled out.."));

                    return;

                }

                features.insert(newFeature);

                editingManager.notifyObservers(this, AFTER_INSERT_FEATURE, null, this.store, newFeature);

                this.formset.message(i18n.getTranslation("_Record_saved"));

                try {

                    this.formset.setValues(features.asListOfDynObjects());

                    this.formset.setCurrentIndex((int) (features.getTotalSize()) - 1);

                } catch (Exception ex) {

                    LOGGER.warn("Can't reload form data after insert.", ex);

                }

            } else {

                int index = theFormSet.getCurrentIndex();

                DynObject currentElement = theFormSet.get(index);

                theFormSet.getFormValues(currentElement);

                EditableFeature feature = ((FacadeOfAFeature) currentElement).getEditableFeature();

                EditingNotification notification = editingManager.notifyObservers(this, BEFORE_UPDATE_FEATURE, null, this.store, feature);

                if( notification.isAborted()) {

                    theFormSet.message(i18n.getTranslation("Problems occurred while saving the data."));

                    return;

                }                

                if( notification.isCanceled() ) {

                    theFormSet.message(i18n.getTranslation("Data saving has been cancelled."));

                    return;

                }                

                if (!editingManager.canWriteFeature(feature)) {

                    theFormSet.message(i18n.getTranslation("The data cannot be saved. Check that all the required fields are filled out.."));

                    return;

                }

                features.update(feature);

                editingManager.notifyObservers(this, AFTER_UPDATE_FEATURE, null, this.store, feature);

                this.formset.message(i18n.getTranslation("_Record_saved"));

                try {

                    this.formset.setCurrentIndex(index);

                } catch (Exception ex) {

                    LOGGER.warn("Can't reload form data after insert.", ex);

                }

            }

        } catch (Exception ex) {

            theFormSet.message(i18n.getTranslation("error_saving_data_will_not_save"));

            throw new RuntimeException("Can't save values", ex);

        } finally {

            updateButtonEnabledStatus();

        }

    }

    private void deleteCurrentElement(JDynFormSet theFormSet) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        try {

            EditingNotificationManager editingManager = DALSwingLocator.getEditingNotificationManager();

            int index = theFormSet.getCurrentIndex();

            DynObject currentElement = theFormSet.get(index);

            theFormSet.getFormValues(currentElement);

            Feature feature = ((FacadeOfAFeature) currentElement).getFeature();

            if (feature instanceof EditableFeature) {

                feature = ((EditableFeature) feature).getNotEditableCopy();

            }

            if( editingManager.notifyObservers(this, BEFORE_REMOVE_FEATURE, null, this.store, feature).isCanceled() ) {

                theFormSet.message(i18n.getTranslation("The delete operation has been cancelled."));

                return;

            }                

            features.delete(feature);

            editingManager.notifyObservers(this, AFTER_REMOVE_FEATURE, null, this.store, feature);

            this.formset.message(i18n.getTranslation("_Record_removed"));

            this.formset.setValues(features.asListOfDynObjects());

            if (features.getTotalSize() - 1 < index) {

                index = index - 1;

            }

            this.formset.setCurrentIndex(index);

        } catch (Exception ex) {

            theFormSet.message(i18n.getTranslation("error_removing_data_will_not_remove"));

            throw new RuntimeException("Can't remove values", ex);

        } finally {

            updateButtonEnabledStatus();

        }

    }

    @Override

    public void saveChanges() {

        if (this.formset != null && this.formset.countValues() > 0) {

            if (store != null && !store.isEditing()) {

                try {

                    store.edit();

                } catch (DataException e1) {

                    LOGGER.warn("Can't edit the store " + store.getName());

                    throw new RuntimeException("Can't save changes.", e1);

                }

            }

            this.saveChanges(this.formset);

        }

    }

    private void updateButtonEnabledStatus() {

        if (this.formset == null) {

            return;

        }

        if (this.store == null || store.isBroken() || store.isAppending() || this.features == null) {

            this.formset.setReadOnly(true);

            formset.setActionVisible(STARTEDITING_ACTION, true);

            formset.setActionEnabled(STARTEDITING_ACTION, true);

            formset.setActionVisible(FINISHEDITING_ACTION, false);

            formset.setActionEnabled(FINISHEDITING_ACTION, false);

            formset.setActionEnabled(ACTION_DELETE, false);

            formset.setActionEnabled(ACTION_NEW, false);

            formset.setActionEnabled(ACTION_CANCEL_NEW, false);

            formset.setActionEnabled(ACTION_SAVE, false);

            formset.setActionEnabled(ACTION_SEARCH, false);

            formset.setActionEnabled(REFRESHFORM_ACTION, true);

            formset.setActionEnabled(ACTION_NAVIGATION, false);

            return;

        }

        if (this.needrefresh ) {

            this.formset.setReadOnly(true);

//            formset.setActionEnabled(STARTEDITING_ACTION, false);

//            formset.setActionEnabled(FINISHEDITING_ACTION, false);

            formset.setActionEnabled(ACTION_DELETE, false);

            formset.setActionEnabled(ACTION_NEW, false);

            formset.setActionEnabled(ACTION_CANCEL_NEW, false);

            formset.setActionEnabled(ACTION_SAVE, false);

            formset.setActionEnabled(ACTION_SEARCH, false);

            formset.setActionEnabled(ACTION_NAVIGATION, false);

            for (Action action : formset.getActions()) {

                formset.setActionEnabled((String) action.getValue(ACTION_COMMAND_KEY), false);

            }

            formset.setActionEnabled(REFRESHFORM_ACTION, true);

            return;

        }

        if (store.isEditing()) {

            this.formset.setReadOnly(false);

            formset.setActionVisible(STARTEDITING_ACTION, false);

            formset.setActionEnabled(STARTEDITING_ACTION, false);

            formset.setActionVisible(FINISHEDITING_ACTION, true);

            formset.setActionEnabled(FINISHEDITING_ACTION, true);

            if (formset.isInNewState()) {

                formset.setActionEnabled(ACTION_DELETE, false);

                formset.setActionEnabled(ACTION_SEARCH, false);

                formset.setActionEnabled(ACTION_NEW, false);

                formset.setActionEnabled(ACTION_CANCEL_NEW, true);

                formset.setActionEnabled(ACTION_SAVE, true);

                formset.setActionEnabled(FINISHEDITING_ACTION, false);

                formset.setActionEnabled(REFRESHFORM_ACTION, false);

//                setEnabledUniqueFields(true);

            } else if (this.features != null && this.features.isEmpty()) {

                formset.getForm().setReadOnly(true);

                formset.setActionEnabled(ACTION_DELETE, false);

                formset.setActionEnabled(ACTION_SEARCH, false);

                formset.setActionEnabled(ACTION_NEW, true);

                formset.setActionEnabled(ACTION_CANCEL_NEW, true);

                formset.setActionEnabled(ACTION_SAVE, false);

                formset.setActionEnabled(REFRESHFORM_ACTION, true);

                formset.setActionEnabled(FINISHEDITING_ACTION, true);         

                formset.setActionEnabled(ACTION_NAVIGATION, false);

            } else if (formset.getForm().isModified()) {

                formset.setActionEnabled(ACTION_DELETE, false);

                formset.setActionEnabled(ACTION_SEARCH, false);

                formset.setActionEnabled(ACTION_NEW, false);

                formset.setActionEnabled(ACTION_CANCEL_NEW, false);

                formset.setActionEnabled(ACTION_SAVE, true);

                formset.setActionEnabled(REFRESHFORM_ACTION, true);

                formset.setActionEnabled(FINISHEDITING_ACTION, false);

                formset.setActionEnabled(ACTION_NAVIGATION, false);

            } else {

                formset.setActionEnabled(ACTION_DELETE, true);

                formset.setActionEnabled(ACTION_SEARCH, true);

                formset.setActionEnabled(ACTION_NEW, true);

                formset.setActionEnabled(ACTION_CANCEL_NEW, false);

                formset.setActionEnabled(ACTION_SAVE, false);

                formset.setActionEnabled(REFRESHFORM_ACTION, true);

                formset.setActionEnabled(FINISHEDITING_ACTION, true);

                formset.setActionEnabled(ACTION_NAVIGATION, true);

            }

            return;

        }

        this.formset.setReadOnly(true);

        formset.setActionVisible(STARTEDITING_ACTION, true);

        formset.setActionEnabled(STARTEDITING_ACTION, true);

        formset.setActionVisible(FINISHEDITING_ACTION, false);

        formset.setActionEnabled(FINISHEDITING_ACTION, false);

        formset.setActionEnabled(ACTION_DELETE, false);

        formset.setActionEnabled(ACTION_NEW, false);

        formset.setActionEnabled(ACTION_CANCEL_NEW, false);

        formset.setActionEnabled(ACTION_SAVE, false);

        formset.setActionEnabled(ACTION_SEARCH, true);

        formset.setActionEnabled(REFRESHFORM_ACTION, true);

        for (Action action : formset.getActions()) {

            formset.setActionEnabled((String) action.getValue(ACTION_COMMAND_KEY), true);

        }

    }

    private void clearUniqueFields() {

        for (FeatureAttributeDescriptor attr : this.store.getDefaultFeatureTypeQuietly()) {

            if ((attr.isPrimaryKey() && !attr.isAutomatic()) || (attr.isIndexed() && !attr.allowIndexDuplicateds())) {

                JDynFormField field = formset.getForm().getField(attr.getName());

                if (field != null) {

                    field.clear();

                }

            }

        }

    }

    private void setEnabledUniqueFields(boolean enabled) {

        for (FeatureAttributeDescriptor attr : this.store.getDefaultFeatureTypeQuietly()) {

            if ((attr.isPrimaryKey() && !attr.isAutomatic()) || (attr.isIndexed() && !attr.allowIndexDuplicateds())) {

                JDynFormField field = formset.getForm().getField(attr.getName());

                if (field != null) {

                    field.setReadOnly(!enabled);

                }

            }

        }

    }

    @Override

    public long getDataSetSize() {

        if (this.features != null) {

            return features.getTotalSize();

        }

        return 0;

    }

    @Override

    public FeatureStore getFeatureStore() {

        return this.store;

    }

    public FeatureType getFeatureType() {

        if( this.store == null ) {

            return null;

        }

        return this.store.getDefaultFeatureTypeQuietly();

    }

    private class FormSetListener implements JDynFormSetListener {

        @Override

        public void formMessage(String message) {

            actionListeners.fireActionEvent(new ActionEvent(this, 1, "formMessage"));

        }

        @Override

        public void formClose() {

            panel.setVisible(false);

            actionListeners.fireActionEvent(new ActionEvent(this, 1, "formClose"));

        }

        @Override

        public void formMovedTo(int currentPosition) throws AbortActionException {

            LOGGER.trace("formMovedTo " + currentPosition);

            updateButtonEnabledStatus();

            actionListeners.fireActionEvent(new ActionEvent(this, 1, "formMovedTo"));

        }

        @Override

        public void formBeforeSave(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formBeforeSave");

            saveChanges(dynformSet);

            updateButtonEnabledStatus();

            actionListeners.fireActionEvent(new ActionEvent(this, 1, "formBeforeSave"));

        }

        @Override

        public void formBeforeNew(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formBeforeNew");

            clearUniqueFields();

            updateButtonEnabledStatus();

            actionListeners.fireActionEvent(new ActionEvent(this, 1, "formBeforeNew"));

        }

        @Override

        public void formBeforeDelete(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formBeforeDelete");

            updateButtonEnabledStatus();

            actionListeners.fireActionEvent(new ActionEvent(this, 1, "formBeforeDelete"));

        }

        @Override

        public void formAfterSave(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formAfterSave");

            updateButtonEnabledStatus();

            actionListeners.fireActionEvent(new ActionEvent(this, 1, "formAfterSave"));

        }

        @Override

        public void formAfterNew(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formAfterNew");

            updateButtonEnabledStatus();

            actionListeners.fireActionEvent(new ActionEvent(this, 1, "formAfterNew"));

        }

        @Override

        public void formAfterDelete(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formAfterDelete");

            deleteCurrentElement(dynformSet);

            updateButtonEnabledStatus();

            actionListeners.fireActionEvent(new ActionEvent(this, 1, "formAfterDelete"));

        }

        @Override

        public void formBeforeSearch(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formBeforeSearch");

            DataSwingManager dataSwingmanager = DALSwingLocator.getSwingManager();

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

            final FeatureStoreSearchPanel searchPanel = dataSwingmanager.createFeatureStoreSearchPanel(store);

            searchPanel.setShowActions(false);

            FeatureQuery currentQuery = getCurrentQuery();

            if (currentQuery != null) {

                Evaluator filter = currentQuery.getFilter();

                if (filter instanceof ExpressionEvaluator) {

                    Expression expression = ((ExpressionEvaluator) filter).toExpression();

                    searchPanel.setFilter(expression);

                    searchPanel.search();

                }

            }

            ToolsSwingUtils.ensureHeightWitdh(

                    searchPanel, 

                    ToolsSwingUtils.RELATIVE_TO_SCREEN,

                    0.75f, 0.75f, 0.85f, 0.85f

            );          

            I18nManager i18n = ToolsLocator.getI18nManager();

            Dialog dialog = winmgr.createDialog(

                    searchPanel.asJComponent(),

                    i18n.getTranslation("_Filter"),

                    i18n.getTranslation("_Creating_filter_for") + ": '" + store.getName() + "'",

                    WindowManager_v2.BUTTONS_OK_CANCEL

            );

            dialog.show(WindowManager.MODE.DIALOG);

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

                SearchParameters params = searchPanel.fetch(null);

                if (params.getQuery() != null) {

                    FeatureQuery searchQuery = params.getQuery().getCopy();

                    Expression expresion = null;

                    if (searchQuery != null) {

                        expresion = searchQuery.getExpressionFilter();

                    }

                    try {

                        FeatureQuery query = store.createFeatureQuery();

                        if (ExpressionUtils.isPhraseEmpty(expresion)) {

                            query.clearFilter();

                        } else {

                            query.setFilter(expresion);

                        }

                        setQuery(query);

                    } catch (Exception ex) {

                        LOGGER.warn("Can't apply filter '" + expresion + "'.", ex);

                    }

                } else {

                    LOGGER.warn("FeatureQuery from parameters is null. Query is not applied to the JFeaturesFrom");

                }

            }

            actionListeners.fireActionEvent(new ActionEvent(this, 1, "formBeforeSearch"));

        }

        @Override

        public void formAfterSearch(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formAfterSearch");

            actionListeners.fireActionEvent(new ActionEvent(this, 1, "formAfterSearch"));

        }

        @Override

        public void formBeforeCancelNew(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formBeforeCancelNew");

            updateButtonEnabledStatus();

            actionListeners.fireActionEvent(new ActionEvent(this, 1, "formBeforeCancelNew"));

        }

        @Override

        public void formAfterCancelNew(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formAfterCancelNew");

            try {

                int index = formset.getCurrentIndex();

                if( index<0 ) {

                    formset.getForm().clear();

                } else {

                    formset.setCurrentIndex(index);

                }

            } catch (Exception ex) {

                LOGGER.warn("Can't reload form data after cancel new.", ex);

            }            

            updateButtonEnabledStatus();

            actionListeners.fireActionEvent(new ActionEvent(this, 1, "formAfterCancelNew"));

        }

    }

    @Override

    public void addActionListener(ActionListener listener) {

        this.actionListeners.addActionListener(listener);

    }

    @Override

    public ActionListener[] getActionListeners() {

        return this.actionListeners.getActionListeners();

    }

    @Override

    public void removeActionListener(ActionListener listener) {

        this.actionListeners.removeActionListener(listener);

    }

    @Override

    public void removeAllActionListener() {

        this.actionListeners.removeAllActionListener();

    }

    @Override

    public void fireActionEvent(ActionEvent event) {

        this.actionListeners.fireActionEvent(event);

    }

    @Override

    public boolean hasActionListeners() {

        return this.actionListeners.hasActionListeners();

    }

    @Override

    public Feature getCurrentFeature() {

        // TODO: No tengo claro que esto sea correcto, ya que no tiene 

        // en cuenta si el form se esta modificando o es nuevo para coger

        // los valores del formulario.

        long index = getCurrentIndex();

        if( index<0 ) {

            return null;

        }

        Feature f = get(index);

        try {

            DynObject adapter = f.getAsDynObject();

            this.getFormset().getForm().getValues(adapter);

            f = ((FacadeOfAFeature)adapter).getFeature();

            return f;

        } catch(Exception ex) {

            return f;

        }

    }

    protected void callUserEvent(String name, Object...args) {

//        try {

            JDynForm form = this.formset.getForm();

            form.callUserEvent(name, args);

//        } catch(NoSuchMethodException ex) {

//            LOGGER.debug("Function '"+name+"' not found.", ex);

//            // Do nothing

//        } catch(Exception ex) {

//            LOGGER.warn("Error calling form event '"+name+"'.", ex);

//        }

    }

    @Override

    public void setTerminateEditingOnClose(boolean b) {

        terminateEditingOnClose = b;

    }

    @Override

    public boolean isTerminateEditingOnClose() {

        return terminateEditingOnClose;

    }

    private void onClose() {

        if (this.store == null || this.ignoreTerminateEditingOnClose) {

            return;

        }

        if (this.store.isEditing() && terminateEditingOnClose) {

            DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

            ThreadSafeDialogsManager dialogManager = ToolsSwingLocator.getThreadSafeDialogsManager();

            I18nManager i18nManager = ToolsLocator.getI18nManager();

            try {

                int x = dataSwingManager.askUserStopEditing(formset.asJComponent(), store, false);

                switch (x) {

                    case DataSwingManager.STOP_EDITING_SAVE:

                        store.finishEditing();

                        break;

                    case DataSwingManager.STOP_EDITING_CONTINUE:

                        break;

                    case DataSwingManager.STOP_EDITING_DISCARD:

                        store.cancelEditing();

                        break;