Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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.

 *

 */

package org.gvsig.editing;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.ScrollPane;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.logging.Logger;

import javax.swing.JPanel;

import javax.swing.SwingUtilities;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.andami.ui.mdiManager.IWindow;

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

import org.gvsig.editing.layers.FactoryLayerEdited;

import org.gvsig.editing.layers.ILayerEdited;

import org.gvsig.editing.layers.VectorialLayerEdited;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.gui.beans.buttonspanel.ButtonsPanel;

import org.gvsig.gui.beans.buttonspanel.ButtonsPanelEvent;

import org.gvsig.gui.beans.buttonspanel.ButtonsPanelListener;

import org.gvsig.tools.service.ServiceException;

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

import org.gvsig.tools.swing.api.dynobject.DynObjectSwingManager;

import org.gvsig.tools.swing.api.dynobject.JDynObjectComponent;

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

/**

 * 

 * El prop?sito de esta clase es centralizar el manejo de la

 * edici?n. Aqu? podemos encontrar una lista con todas

 * los temas en edici?n, y las propiedades que sean globales

 * e interesantes a la hora de ponerse a editar.

 * Por ejemplo, podemos poner aqu? el Grid que vamos a usar,

 * el MapControl que tenemos asociado, etc, etc.

 * Tambi?n ser? el responsable de mantener una lista de

 * listeners interesados en los eventos de edici?n, y

 * de lanzar los eventos que necesitemos.

 * Lo principal es una colecci?n de LayerEdited, y cada

 * LayerEdited es un wrapper alrededor de un tema que guarda

 * las propiedades de la edici?n.

 * 

 * Nuevo: Llevar aqu? el control de las tablas en edici?n tambi?n

 * y centralizar los listeners interesados en los eventos de edici?n.

 * 

 * TODO: Poner todo lo referente al EditionManager dentro de una vista.

 * para permitir tener varias vistas con temas en edici?n

 * 

 * @author fjp

 */

public class EditionManager implements LayerListener, LayerCollectionListener {

    private List<ILayerEdited> editedLayers = new ArrayList<ILayerEdited>();

    // private ArrayList activeLayerEdited = new ArrayList();

    private MapControl mapCtrl = null;

    private ILayerEdited ile = null;

    // private int idActiveLayer=0;

    /**

     * @param lyr

     * @return

     */

    public ILayerEdited getLayerEdited(FLayer lyr) {

        ILayerEdited aux = null;

        for (int i = 0; i < editedLayers.size(); i++) {

            aux = editedLayers.get(i);

            if (aux.getLayer() == lyr)

                return aux;

        }

        return null;

    }

    public void visibilityChanged(LayerEvent e) {

    }

    public void activationChanged(LayerEvent e) {

        if (e.getSource().isActive()) {

            ile = getLayerEdited(e.getSource());

        }

        if (ile == null || ile.getLayer().equals(e.getSource())) {

            if (ile != null && !ile.getLayer().isActive()) {

                VectorialLayerEdited lastVLE = (VectorialLayerEdited) ile;

                lastVLE.activationLost(e);

            }

            if (e.getSource() instanceof FLyrVect) {

                VectorialLayerEdited vle = null;

                vle = (VectorialLayerEdited) getLayerEdited(e.getSource());

                ile = vle;

                if (getMapControl() != null && vle != null

                    && vle.getLayer().isActive()) {

                    getMapControl().setTool("cadtooladapter");

                    vle.activationGained(e);

                    return;

                }

            }

            if (getMapControl() != null) {

                getMapControl().setTool("zoomIn");

                PluginServices.getMainFrame().setSelectedTool("ZOOM_IN");

            }

        }

    }

    public void nameChanged(LayerEvent e) {

    }

    public void editionChanged(LayerEvent e) {

        Logger.global.info(e.toString());

        ILayerEdited lyrEdit = getLayerEdited(e.getSource());

        // Si no est? en la lista, comprobamos que est? en edici?n

        // y lo a?adimos

        if ((lyrEdit == null) && e.getSource().isEditing()) {

            lyrEdit =

                FactoryLayerEdited.createLayerEdited(e.getSource(), mapCtrl);

            editedLayers.add(lyrEdit);

            if (getMapControl() != null) {

                getMapControl().setTool("cadtooladapter");

                CADExtension.setCADTool("_selection", true);

            }

            PluginServices.getMainFrame().setSelectedTool("_selection");

            // idActiveLayer = editedLayers.size() - 1;

            ile = getLayerEdited(e.getSource());

            System.out.println("NUEVA CAPA EN EDICION: "

                + lyrEdit.getLayer().getName());

            // Ponemos el resto de temas desactivados

            if (mapCtrl != null)

                mapCtrl.getMapContext().getLayers().setActive(false);

            // y activamos el nuevo.

            e.getSource().setActive(true);

            if (e.getSource() instanceof FLyrVect) {

                FLyrVect fLyrVect = (FLyrVect) e.getSource();

                ((VectorialLayerEdited) lyrEdit)

                    .setEditionChangeManager(new EditionChangeManager(fLyrVect));

                addCheckRules(fLyrVect);

            }

        } else {

            for (int i = 0; i < editedLayers.size(); i++) {

                VectorialLayerEdited vle =

                    (VectorialLayerEdited) editedLayers.get(i);

                if (vle.equals(lyrEdit)) {

                    editedLayers.remove(i);

                    ile = null;

                    return;

                }

            }

        }

    }

    /**

     * @return Returns the activeLayerEdited. Null if there isn't any active AND

     *         edited

     */

    public ILayerEdited getActiveLayerEdited() {

        return ile;

    }

    /**

     * @return Returns the mapCtrl.

     */

    public MapControl getMapControl() {

        return mapCtrl;

    }

    /**

     * @param mapCtrl

     *            The mapCtrl to set.

     */

    public void setMapControl(MapControl mapCtrl) {

        if (mapCtrl != null) {

            this.mapCtrl = mapCtrl;

            mapCtrl.getMapContext().getLayers().addLayerListener(this);

            mapCtrl.getMapContext().getLayers()

                .addLayerCollectionListener(this);

        }

    }

    public void layerAdded(LayerCollectionEvent e) {

        // Nothing to do

    }

    public void layerMoved(LayerPositionEvent e) {

        // Nothing to do

    }

    public void layerRemoved(LayerCollectionEvent e) {

        VectorialLayerEdited vle =

            (VectorialLayerEdited) getActiveLayerEdited();

        if (vle != null && vle.getLayer().isActive()) {

            try {

                vle.clearSelection();

            } catch (DataException e1) {

                NotificationManager.addError(e1);

            }

            editedLayers.remove(vle);

            getMapControl().setTool("zoomIn");

            FLyrVect lv = (FLyrVect) vle.getLayer();

            if (e.getAffectedLayer().equals(lv)) {

                IWindow window =

                    PluginServices.getMDIManager().getActiveWindow();

                if (window instanceof DefaultViewPanel) {

                    DefaultViewPanel view = (DefaultViewPanel) window;

                    view.hideConsole();

                    view.validate();

                    view.repaint();

                }

            }

        }

        PluginServices.getMainFrame().enableControls();

    }

    public void layerAdding(LayerCollectionEvent e) throws CancelationException {

        // Nothing to do

    }

    public void layerMoving(LayerPositionEvent e) throws CancelationException {

        // Nothing to do

    }

    public void layerRemoving(LayerCollectionEvent e)

        throws CancelationException {

        // Nothing to do

    }

    public void activationChanged(LayerCollectionEvent e)

        throws CancelationException {

        // Nothing to do

    }

    public void visibilityChanged(LayerCollectionEvent e)

        throws CancelationException {

        // Nothing to do

    }

    public void drawValueChanged(LayerEvent e) {

        // Nothing to do

    }

    class CheckMandatoryAttributtes extends AbstractFeatureRule {

        protected CheckMandatoryAttributtes() {

            super("CheckMandatoryAttributtes", "CheckMandatoryAttributtes");

        }

        public void validate(Feature feature, FeatureStore featureStore)

            throws DataException {

            // Comprobar si hay campos obligatorios y presentar formulario

            FeatureType featureType = feature.getType();

            FeatureAttributeDescriptor[] attributeDescriptors =

                featureType.getAttributeDescriptors();

            boolean showForm = false;

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

                FeatureAttributeDescriptor attrDesc = attributeDescriptors[i];

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

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

                    showForm = true;

                    break;

                }

            }

            if (showForm) {

                askRequiredAttributtes((EditableFeature) feature, featureStore);

            }

        }

    }

    private void askRequiredAttributtes(final EditableFeature feature,

        final FeatureStore store)

        throws FeatureRuleMandatoryAttributesException {

        // Comprobar que estamos en el thread de swing y si no excepcion

        if (!SwingUtilities.isEventDispatchThread()) {

            try {

                SwingUtilities.invokeAndWait(new Runnable() {

                    public void run() {

                        askRequiredAttributtes(feature, store);

                    }

                });

            } catch (Exception e1) {

                throw new FeatureRuleMandatoryAttributesException(e1,

                    store.getFullName());

            }

            return;

        }

        DynObjectSwingManager dynObjectSwinManager =

            ToolsSwingLocator.getDynObjectSwingManager();

        final JDynObjectComponent dynObjectComponent;

        try {

            dynObjectComponent =

                dynObjectSwinManager.createJDynObjectComponent(

                    feature.getAsDynObject(), true);

        } catch (ServiceException e) {

            throw new FeatureRuleMandatoryAttributesException(e,

                store.getFullName());

        }

        final JPanel panel = new JPanel();

        ButtonsPanel buttonsPanel =

            new ButtonsPanel(ButtonsPanel.BUTTONS_ACCEPTCANCEL);

        buttonsPanel.addButtonPressedListener(new ButtonsPanelListener() {

            public void actionButtonPressed(ButtonsPanelEvent e) {

                if (e.getButton() == ButtonsPanel.BUTTON_ACCEPT) {

                    dynObjectComponent.saveStatus();

                    panel.setVisible(false);

                }

                if (e.getButton() == ButtonsPanel.BUTTON_CANCEL) {

                    panel.setVisible(false);

                    throw new FeatureRuleMandatoryAttributesException(store

                        .getFullName());

                }

            }

        });

        panel.setLayout(new BorderLayout());

        ScrollPane scrollPanel = new ScrollPane();

        scrollPanel.add(dynObjectComponent.asJComponent(), BorderLayout.CENTER);

        panel.add(scrollPanel);

        panel.add(buttonsPanel, BorderLayout.SOUTH);

        panel.setPreferredSize(new Dimension(800, 600));

        WindowManager wm = ToolsSwingLocator.getWindowManager();

        wm.showWindow(panel, "Fill mandatory fields", WindowManager.MODE.DIALOG);

    }

    private void addCheckRules(FLyrVect layer) {

        try {

            FeatureType featureType =

                layer.getFeatureStore().getDefaultFeatureType();

            FeatureRules featureRules = featureType.getRules();

            for (Iterator it = featureRules.iterator(); it.hasNext();) {

                FeatureRule rule = (FeatureRule) it.next();

                if (rule instanceof CheckMandatoryAttributtes) {

                    return;

                }

            }

            featureRules.add(new CheckMandatoryAttributtes());

        } catch (DataException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

    public class FeatureRuleMandatoryAttributesException extends

        DataRuntimeException {

        private static final long serialVersionUID = -7965533441336164612L;

        private final static String MESSAGE_FORMAT =

            "Can't apply rule in store %(store)s.";

        private final static String MESSAGE_KEY =

            "_FeatureRuleMandatoryAttributesException";

        public FeatureRuleMandatoryAttributesException(Throwable cause,

            String store) {

            super(MESSAGE_FORMAT, cause, MESSAGE_KEY, serialVersionUID);

            this.setValue("store", store);

        }

        public FeatureRuleMandatoryAttributesException(String store) {

            super(MESSAGE_FORMAT, MESSAGE_KEY, serialVersionUID);

            this.setValue("store", store);

        }

    }

}