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.editing.impl;

import java.util.Arrays;

import java.util.List;

import javax.swing.SwingUtilities;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.editing.EditingNotificationManager;

import org.gvsig.editing.EditingNotification;

import org.gvsig.fmap.dal.DataStore;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.mapcontrol.swing.dynobject.DynObjectEditor;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.observer.BaseNotification;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * Acts as a hub to centralize editing notification events in a single manager.

 *

 * All objects that modify a store notify this manager to reported the actions

 * to the objects interested in knowing when start or end editing, regardless

 * of where the editing work is done.

 *

 */

public class DefaultEditingNotificationManager implements EditingNotificationManager {

    private static final Logger logger = LoggerFactory.getLogger(DefaultEditingNotificationManager.class);

    private ObservableHelper helper = null;

    private static final int SOURCE = 1;

    private static final int DOCUMENT = 2;

    private static final int LAYER = 3;

    private static final int STORE = 4;

    private static final int FEATURE = 5;

    private static final int FEATURETYPE = 6;

    private static List cancelableNotifications = null;

    public class DefaultEditingNotification extends BaseNotification implements EditingNotification {

        private boolean validateTheFeature = true;

        DefaultEditingNotification(String type) {

            super(type, 7);

        }

        public Object getSource() {

            return this.getValue(SOURCE);

        }

        public Object getDocument() {

            return this.getValue(DOCUMENT);

        }

        public FLayer getLayer() {

            return (FLayer) this.getValue(LAYER);

        }

        public DataStore getStore() {

            return (DataStore) this.getValue(STORE);

        }

        public FeatureStore getFeatureStore() {

            return (FeatureStore) this.getValue(STORE);

        }

        public Feature getFeature() {

            return (Feature) this.getValue(FEATURE);

        }

        public EditableFeatureType getFeatureType() {

            return (EditableFeatureType) this.getValue(FEATURETYPE);

        }

        public boolean isCancelable() {

            if( cancelableNotifications==null ) {

                String nn[] = new String[] {

                    BEFORE_ENTER_EDITING_STORE,

                    BEFORE_EXIT_EDITING_STORE,

                    BEFORE_INSERT_FEATURE,

                    BEFORE_REMOVE_FEATURE,

                    BEFORE_UPDATE_FEATURE,

                    BEFORE_UPDATE_FEATURE_TYPE

                };

                cancelableNotifications = Arrays.asList(nn);

            }

            return cancelableNotifications.contains(this.getType() );

        }

        public void setSkipFeatureValidation(boolean skipTheFeatureValidation) {

            this.validateTheFeature = !skipTheFeatureValidation;

        }

        public boolean shouldValidateTheFeature() {

            return !this.validateTheFeature;

        }

    }

    public DefaultEditingNotificationManager() {

        this.helper = new ObservableHelper();

    }

    public void addObserver(Observer o) {

        this.helper.addObserver(o);

    }

    public void deleteObserver(Observer o) {

        this.helper.deleteObserver(o);

    }

    public void deleteObservers() {

        this.helper.deleteObservers();

    }

    public EditingNotification notifyObservers(EditingNotification notification) {

        try {

            this.helper.notifyObservers(this, notification);

        } catch(Exception ex) {

            logger.warn("Problems notifing to observers of DefaultEditingNotificationManager.",ex);

        }

        return notification;

    }

    public EditingNotification notifyObservers(Object source, String type, Object document, FLayer layer, DataStore store, Feature feature, EditableFeatureType featureType) {

        EditingNotification notification = new DefaultEditingNotification(type);

        notification.setValue(SOURCE,source);

        notification.setValue(DOCUMENT,document);

        notification.setValue(LAYER,layer);

        notification.setValue(STORE,store);

        notification.setValue(FEATURE,feature);

        notification.setValue(FEATURETYPE,featureType);

        return this.notifyObservers(notification);

    }

    public EditingNotification notifyObservers(Object source, String type, Object document, FLayer layer, DataStore store) {

        return this.notifyObservers(source, type, document, layer, store, null, null);

    }

    public EditingNotification notifyObservers(Object source, String type, Object document, FLayer layer) {

        DataStore store = null;

        if ( layer instanceof FLyrVect ) {

            store = ((FLyrVect) layer).getDataStore();

        }

        return this.notifyObservers(source, type, document, layer, store, null, null);

    }

    public EditingNotification notifyObservers(Object source, String type, Object document, DataStore store) {

        return this.notifyObservers(source, type, document, null, store, null, null);

    }

    public EditingNotification notifyObservers(Object source, String type, Object document, DataStore store, Feature feature) {

        return this.notifyObservers(source, type, document, null, store, feature, null);

    }

    public EditingNotification notifyObservers(Object source, String type, Object document, DataStore store, EditableFeatureType featureType) {

        return this.notifyObservers(source, type, document, null, store, null, featureType);

    }

    public EditingNotification notifyObservers(Object source, String type, Object document, FLayer layer, DataStore store, Feature feature) {

        return this.notifyObservers(source, type, document, layer, store, feature, null);

    }

    public boolean validateFeature(Feature feature) {

        while( true ) {

            if( !needAskUser(feature) ) {

                // La feature se puede validar y no precisa de intervencion del

                // usuario. Retornamos true.

                return true;

            }

            // No se habia podido validar la feature, se piden al

            // usuario los datos que faltan.

            AskRequiredAttributtes ask = new AskRequiredAttributtes();

            ask.showDialog(feature);

            if( ask.userCancel() ) {

                // No se habia podido validar la feature, se le han pedido al

                // usuario los datos que faltan y este ha pulsado en cancel,

                // asi que la feature no se puede validar, y retornamos

                // false.

                return false;

            }

        }

    }

    private boolean needAskUser(Feature feature) {

        FeatureType featureType = feature.getType();

        FeatureAttributeDescriptor[] attributeDescriptors = featureType.getAttributeDescriptors();

        for ( int i = 0; i < attributeDescriptors.length; i++ ) {

            FeatureAttributeDescriptor attrDesc = attributeDescriptors[i];

            if ( attrDesc.isAutomatic() ) {

                break;

            }

            if ( (attrDesc.isPrimaryKey() || !attrDesc.allowNull())

                    && feature.get(attrDesc.getName()) == null ) {

                return true;

            }

        }

        return false;

    }

    private class AskRequiredAttributtes {

        private boolean userCancelValue = true;

        public boolean userCancel() {            

            return this.userCancelValue;

        }

        public void showDialog(final Feature feature) {

            if ( !SwingUtilities.isEventDispatchThread() ) {

                try {

                    SwingUtilities.invokeAndWait(new Runnable() {

                        public void run() {

                            showDialog(feature);

                        }

                    }

                    );

                } catch (Exception e1) {

                    message("Can't show form to fill need data.",e1);

                    this.userCancelValue = true;

                    return;

                }

            }

            try {

                DynObject data = feature.getAsDynObject();

                DynObjectEditor editor;

                editor = new DynObjectEditor(data);

                String title = data.getDynClass().getDescription();

                if( StringUtils.isEmpty(title) ) {

                        title = data.getDynClass().getName();

                } 

                editor.setTitle(

                    ToolsLocator.getI18nManager().getTranslation("_Fill_the_required_fields")+

                    " - "+ 

                    title);

                editor.editObject(true);

                if ( editor.isCanceled() ) {

                    this.userCancelValue = true;

                } else {

                    editor.getData(data);

                    this.userCancelValue = false;

                }

            } catch (Exception ex) {

                message("Can't show form to fill need data.",ex);

                this.userCancelValue = true;

            }

        }

        private void message(String msg, Throwable ex) {

            if( ex==null ) {

                logger.warn(msg);

            } else {

                logger.warn(msg,ex);

            }

//            msg = msg + "\nSee to application log for more information.";

//            ApplicationManager application = ApplicationLocator.getManager();

//            application.message(msg,JOptionPane.WARNING_MESSAGE);

        }

    }

}