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.event.ActionEvent;

import java.util.ArrayList;

import java.util.List;

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.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.swing.JExpressionBuilder;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.featureform.swing.JFeaturesForm;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.StoresRepository;

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

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

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

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

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

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

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

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

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.tools.ToolsLocator;

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

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

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.service.ServiceException;

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

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;

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

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

import org.gvsig.tools.util.ResourcesStorage;

/**

 * @author fdiaz

 *

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultJFeaturesForm implements JFeaturesForm {

    public class DefaultFeaturesFormContext implements FeaturesFormContext {

        private DefaultFeaturesFormContext() {

        }

        @Override

        public ResourcesStorage getResourcesStorage() {

            return store.getResourcesStorage();

        }

        @Override

        public FeatureStore getFeatureStore(String storeName) {

            return (FeatureStore) this.getDataStore(storeName);

        }

        @Override

        public DataStore getDataStore(String storeName) {

            FeatureStore theStore = (FeatureStore) store.getChildren().get(storeName);

            if (theStore == null) {

                DataManager dataManager = DALLocator.getDataManager();

                StoresRepository repository = dataManager.getStoresRepository();

                if (repository.containsKey(storeName)) {

                    theStore = (FeatureStore) repository.get(storeName);

                }

            }

            return theStore;

        }

    }

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

    private static final int PAGE_SIZE = 500;

    private final JPanel panel;

    private JDynFormSet formset;

    private FeatureStore store;

    private FeaturePagingHelper ph;

    private DynFormDefinition definition = null;

    private FeatureQuery currentQuery;

    private final List<Action> otherActions;

    public DefaultJFeaturesForm() {

        this.panel = new JPanel(new BorderLayout());

        this.otherActions = new ArrayList<>();

    }

    @Override

    public void setPreferredSize(Dimension dimension) {

//        panel.setPreferredSize(dimension);

    }

    private void updateForm() {

        if (this.formset == null) {

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

        }

        try {

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

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

        } catch (Exception ex) {

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

        }

    }

    @Override

    public JComponent asJComponent() {

        if (this.ph == null) {

            try {

                updateForm();

            } catch (Exception ex) {

                throw new RuntimeException(ex);

            }

        }

        return this.panel;

    }

    @Override

    public void bind(FeatureStore store) {

        if (store == null) {

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

        }

        try {

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

            DynClass theDefinition = manager.featureType2DynClass(store, store.getDefaultFeatureType());

            this.bind(store, theDefinition);

        } catch (Exception ex) {

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

        }

    }

    public void bind(FeatureStore store, DynClass definition) throws ServiceException, DataException {

        if (this.store == store) {

            return;

        }

        DynFormManager formManager = DynFormLocator.getDynFormManager();

        this.definition = formManager.getDefinition(definition);

        if (formset != null) {

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

            this.formset = null;

        }

        this.store = store;

        this.ph = null;

    }

    @Override

    public JDynFormSet getFormset() {

        if (this.formset == null) {

            DynFormManager formManager = DynFormLocator.getDynFormManager();

            this.formset = formManager.createJDynFormSet(

                    new DefaultFeaturesFormContext(),

                    this.definition,

                    null

            );

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

            if( groups.size()==1 && groups.get(0)==null ) {

                this.formset.setLayoutMode(JDynForm.USE_PLAIN);

            } else {

                this.formset.setLayoutMode(JDynForm.USE_TABS);

            }

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

            for( Action action : this.otherActions ) {

                this.formset.addAction(action);

            }

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

        }

        if( this.store.isEditing() ) {

            this.formset.setReadOnly(false);

            formset.setActionVisible("startEditing", false);

            formset.setActionEnabled("startEditing", false);

            formset.setActionVisible("finishEditing", true);

            formset.setActionEnabled("finishEditing", true);

        } else {

            this.formset.setReadOnly(true);

            formset.setActionVisible("startEditing", true);

            formset.setActionEnabled("startEditing", true);

            formset.setActionVisible("finishEditing", false);

            formset.setActionEnabled("finishEditing", false);

        }

        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.ph==null ) {

            return null;

        }

        try {

            return this.ph.getFeatureAt(index);

        } catch (BaseException ex) {

            return null;

        }

    }

    private class FinishEditingAction extends AbstractAction implements Observer {

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

            this.setEnabled(store.isEditing());

            store.addObserver(this);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            if( store.isEditing() ) {

                try {

                    I18nManager i18nManager = ToolsLocator.getI18nManager();

                    ThreadSafeDialogsManager dialogManager = ToolsSwingLocator.getThreadSafeDialogsManager();

                    int x = dialogManager.confirmDialog(

                            "? Desea terminar edicion y guardar los cambios ?\n\nPulse cancelar para cancelar la edicion y los cambios.",

                            i18nManager.getTranslation("_Stop_editing"),

                            JOptionPane.YES_NO_CANCEL_OPTION,

                            JOptionPane.QUESTION_MESSAGE

                    );

                    switch(x) {

                        case JOptionPane.YES_OPTION:

                            store.finishEditing();

                            break;

                        case JOptionPane.NO_OPTION:

                            break;

                        case JOptionPane.CANCEL_OPTION:

                            store.cancelEditing();

                            break;

                    }

                } catch (DataException ex) {

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

                }

            }

        }

        @Override

        public void update(Observable observable, Object notification) {

            if( notification instanceof FeatureStoreNotification ) {

                FeatureStoreNotification n =  (FeatureStoreNotification) notification;

                switch( n.getType() )  {

                    case FeatureStoreNotification.AFTER_STARTEDITING:

                    case FeatureStoreNotification.AFTER_FINISHEDITING:

                    case FeatureStoreNotification.AFTER_CANCELEDITING:

                        if( store.isEditing() ) {

                            formset.setReadOnly(false);

                            formset.setActionVisible("finishEditing", true);

                            formset.setActionEnabled("finishEditing", true);

                        } else {

                            formset.setReadOnly(true);

                            formset.setActionVisible("finishEditing", false);

                            formset.setActionEnabled("finishEditing", false);

                        }

                        break;

                }

            }

        }

    }

    private class StartEditingAction extends AbstractAction implements Observer {

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

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

            store.addObserver(this);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            if( !store.isEditing() ) {

                try {

                    store.edit();

                } catch (DataException ex) {

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

                }

            }

        }

        @Override

        public void update(Observable observable, Object notification) {

            if( notification instanceof FeatureStoreNotification ) {

                FeatureStoreNotification n =  (FeatureStoreNotification) notification;

                switch( n.getType() )  {

                    case FeatureStoreNotification.AFTER_STARTEDITING:

                    case FeatureStoreNotification.AFTER_FINISHEDITING:

                    case FeatureStoreNotification.AFTER_CANCELEDITING:

                        if( store.isEditing() ) {

                            formset.setReadOnly(false);

                            formset.setActionVisible("startEditing", false);

                            formset.setActionEnabled("startEditing", false);

                        } else {

                            formset.setReadOnly(true);

                            formset.setActionVisible("startEditing", true);

                            formset.setActionEnabled("startEditing", true);

                        }

                        break;

                }

            }

        }

    }

    @Override

    public void setQuery(FeatureQuery query) {

        if (this.ph != null) {

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

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

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

        WindowManager winmgr = ToolsSwingLocator.getWindowManager();

        String title = this.definition.getLabel();

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

    }

    private void saveChanges(JDynFormSet dynformSet) {

        if( dynformSet.isInNewState() ) {

            Feature feat = null;

            try {

                feat = store.createNewFeature(false);

            } catch (DataException ex) {

                LOGGER.warn("Can't create new feature.",ex);

                I18nManager i18nManager = ToolsLocator.getI18nManager();

                dynformSet.message(i18nManager.getTranslation("error_saving_data_will_not_save"));

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

            }

            DynObject dynObject = feat.getAsDynObject();

            dynformSet.getFormValues(dynObject);

            try {

                ph.insert(((FacadeOfAFeature)dynObject).getEditableFeature());

            } catch (BaseException e) {

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

            }

            try {

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

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

            } catch(Exception ex) {

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

            }

        } else {

            int index = dynformSet.getCurrentIndex();

            DynObject dynObject = dynformSet.get(index);

            if ( !(dynObject instanceof FacadeOfAFeature) ) {

                LOGGER.warn("Can't get the associated feature index " + index);

                I18nManager i18nManager = ToolsLocator.getI18nManager();

                dynformSet.message(i18nManager.getTranslation("error_saving_data_will_not_save"));

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

            }

            dynformSet.getFormValues(dynObject);

            try {

                ph.update(((FacadeOfAFeature)dynObject).getEditableFeature());

            } catch (BaseException e) {

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

            }

        }

    }

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

        }

    }

    @Override

    public long getDataSetSize() {

        if (this.ph != null) {

            return ph.getTotalSize();

        }

        return 0;

    }

    @Override

    public FeatureStore getFeatureStore() {

        return this.store;

    }

    private class FormSetListener implements JDynFormSetListener {

        @Override

        public void formMessage(String message) {

        }

        @Override

        public void formClose() {

            panel.setVisible(false);

        }

        @Override

        public void formMovedTo(int currentPosition) throws AbortActionException {

            LOGGER.trace("formMovedTo " + currentPosition);

        }

        @Override

        public void formBeforeSave(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formBeforeSave");

            if (!store.isEditing()) {

                try {

                    store.edit();

                } catch (DataException e1) {

                    throw new StoreEditException(e1, store.getName());

                }

            }

        }

        @Override

        public void formBeforeNew(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formBeforeNew");

        }

        @Override

        public void formBeforeDelete(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formBeforeDelete");

        }

        @Override

        public void formAfterSave(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formAfterSave");

            saveChanges(dynformSet);

        }

        @Override

        public void formAfterNew(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formAfterNew");

        }

        @Override

        public void formAfterDelete(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formAfterDelete");

        }

        @Override

        public void formBeforeSearch(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formBeforeSearch");

            DataSwingManager dataSwingmanager = DALSwingLocator.getSwingManager();

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

            JExpressionBuilder builder = dataSwingmanager.createQueryFilterExpresion(store);

            FeatureQuery currentQuery = getCurrentQuery();

            if( currentQuery!=null ) {

                Evaluator filter = currentQuery.getFilter();

                if( filter instanceof ExpressionEvaluator ) {

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

                    builder.setExpression(expression);

                }

            }

            Dialog dialog = winmgr.createDialog(

                    builder.asJComponent(),

                    "Filtro",

                    "Creacion de filtro sobre '"+store.getName()+"'",

                    WindowManager_v2.BUTTONS_OK_CANCEL

            );

            dialog.show(WindowManager.MODE.DIALOG);

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

                Expression expresion = builder.getExpression();

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

                }

            }

        }

        @Override

        public void formAfterSearch(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formAfterSearch");

        }

        @Override

        public void formBeforeCancelNew(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formBeforeCancelNew");

        }

        @Override

        public void formAfterCancelNew(JDynFormSet dynformSet) throws AbortActionException {

            LOGGER.trace("formAfterCancelNew");

        }

    }

    private static class StoreEditException extends AbortActionException {

        /**

         *

         */

        private static final long serialVersionUID = -7682017811778577130L;

        public StoreEditException(Throwable cause, String storename) {

            super("Can't edit the store '%(storename)'", cause, "cant_edit_the store_XstorenameX", serialVersionUID);

            setValue("storename", storename);

        }

    }

}