Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free Software

 * Foundation; either version 3 of the License, or (at your option) any later

 * version.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more

 * details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc., 51

 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.app.project.documents.view;

import java.awt.Color;

import java.awt.Component;

import java.awt.Dimension;

import java.awt.geom.Point2D;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import org.cresques.cts.IProjection;

import org.gvsig.andami.PluginServices;

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

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

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.documents.AbstractDocument;

import org.gvsig.app.project.documents.DocumentManager;

import org.gvsig.app.project.documents.view.info.gui.HTMLInfoToolPanel;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.events.ErrorEvent;

import org.gvsig.fmap.mapcontext.events.listeners.ErrorListener;

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

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

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

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

import org.gvsig.fmap.mapcontext.layers.operations.SingleLayer;

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

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author 2005- Vicente Caballero

 * @author 2009- Joaquin del Cerro

 *

 */

public abstract class BaseViewDocument extends AbstractDocument implements ErrorListener,

        ViewDocument {

    /**

     *

     */

    private static final long serialVersionUID = -2621709089720665902L;

    protected static final Logger LOGGER = LoggerFactory.getLogger(BaseViewDocument.class);

    public static final String PERSISTENCE_DEFINITION_NAME = "BaseViewDocument";

    protected MapContext mapOverViewContext;

    protected MapContext mapContext;

    private ExtendedPropertiesHelper propertiesHelper = new ExtendedPropertiesHelper();

    public BaseViewDocument() {

        super();

    }

    public BaseViewDocument(DocumentManager factory) {

        super(factory);

    }

    @Override

    public void setProject(Project project) {

        super.setProject(project);

        if(mapContext != null) {

            mapContext.setSelectionColor(project.getSelectionColor());

        }

    }

    /**

     * Gets the MapContext of the main map in the view.

     *

     * @return the main MapContext

     */

    @Override

    public MapContext getMapContext() {

        if( this.mapContext!=null && DisposeUtils.isNullOrDisposed(this.mapContext) ) {

            try {

                throw new RuntimeException();

            } catch(Exception ex) {

                LOGGER.info("MapContext of view '"+Objects.toString(this.getName())+"' is disposed", ex);

            }        

        }

        return mapContext;

    }

    @Override

    public void setName(String name) {

        super.setName(name);

        this.mapContext.getLayers().setName(name);

    }

    /**

     * Gets the MapContext from the locator, which is the small map in the

     * left-bottom corner of the View.

     *

     * @return the locator MapContext

     */

    @Override

    public MapContext getMapOverViewContext() {

        return mapOverViewContext;

    }

    @Override

    public void setMapContext(MapContext fmap) {

        mapContext = fmap;

        Project p = this.getProject();

        if(p != null){

            mapContext.setSelectionColor(p.getSelectionColor());

        }

        fmap.addErrorListener(this);

    }

    @Override

    public void setMapOverViewContext(MapContext fmap) {

        mapOverViewContext = fmap;

        mapOverViewContext.setProjection(mapContext.getProjection());

    }

    public void showErrors() {

        if (!mapContext.getLayersError().isEmpty()) {

            String layersError = "";

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

                layersError = layersError + "\n" + (String) mapContext.getLayersError().get(i);

            }

            JOptionPane.showMessageDialog((Component) PluginServices.getMainFrame(),

                    PluginServices.getText(this, "fallo_capas") + " : \n"

                    + layersError);

        }

    }

    /**

     * Reports to the user a bundle of driver exceptions produced in the same

     * atomic MapContext transaction

     */

    @SuppressWarnings("rawtypes")

    @Override

    public void reportDriverExceptions(String introductoryText, List driverExceptions) {

        HtmlWindow htmlPanel = new HtmlWindow(570, 600, PluginServices.getText(this, "driver_error"));

        String htmlText = "";

        if (introductoryText == null) {

            htmlText += "<h2 text=\"#000080\">" + PluginServices.getText(this, "se_han_producido_los_siguientes_errores_durante_la_carga_de_las_capas") + "</h2>";

        } else {

            htmlText += introductoryText;

        }

        int numErrors = driverExceptions.size();

        for (int i = 0; i < numErrors; i++) {

            //htmlText += "<br>\n";

            BaseException exception = (BaseException) driverExceptions.get(i);

            htmlText += "<p text=\"#550080\">_________________________________________________________________________________________</p>";

            htmlText += "<h3>" + PluginServices.getText(this, exception.getMessageKey()) + "</h3>";

            htmlText += "<p>" + exception.getMessage() + "</p>";

            htmlText += "<p text=\"#550080\">_________________________________________________________________________________________</p>";

        }

        System.out.println(htmlText);

        htmlPanel.show(htmlText);

        PluginServices.getMDIManager().addCentredWindow(htmlPanel);

    }

    /**

     * HtmlInfoToolPanel that implements IWindow

     *

     * @author azabala

     *

     */

    class HtmlWindow extends JPanel implements IWindow {

        /**

         *

         */

        private static final long serialVersionUID = 1151465547277478664L;

        private HTMLInfoToolPanel htmlPanel = new HTMLInfoToolPanel();

        WindowInfo viewInfo = null;

        public HtmlWindow(int width, int height, String windowTitle) {

            htmlPanel.setBackground(Color.white);

            JScrollPane scrollPane = new JScrollPane(htmlPanel);

            scrollPane.setPreferredSize(new Dimension(width - 30, height - 30));

            this.add(scrollPane);

            viewInfo = new WindowInfo(WindowInfo.MODELESSDIALOG);

            viewInfo.setTitle(windowTitle);

            viewInfo.setWidth(width);

            viewInfo.setHeight(height);

        }

        public void show(String htmlText) {

            htmlPanel.show(htmlText);

        }

        @Override

        public WindowInfo getWindowInfo() {

            return viewInfo;

        }

        @Override

        public Object getWindowProfile() {

            return WindowInfo.PROPERTIES_PROFILE;

        }

    }

    @Override

    public IProjection getProjection() {

        if( this.mapContext == null ) {

            return null;

        }

        return mapContext.getProjection();

    }

    @Override

    public void setProjection(IProjection proj) {

        mapContext.setProjection(proj);

        mapOverViewContext.setProjection(proj);

    }

    public IProjection getOverViewProjection() {

        return mapOverViewContext.getProjection();

    }

    @Override

    public void afterRemove() {

        // FIXME: Parece que no recorre correctamente el arbol de capas

        FLayers layers = this.getMapContext().getLayers();

        for (int i = layers.getLayersCount() - 1; i >= 0; i--) {

            try {

                layers.getLayer(i).getParentLayer().removeLayer(layers.getLayer(i));

            } catch (CancelationException e1) {

                LOGGER.warn("Can't remove layer");

            }

        }

        getMapContext().dispose();

        getMapOverViewContext().dispose();

    }

    @Override

    public void afterAdd() {

        // Do nothing

    }

    @Override

    public void setBackColor(Color c) {

        getMapContext().getViewPort().setBackColor(c);

    }

    @Override

    public void errorThrown(ErrorEvent e) {

        JOptionPane.showMessageDialog((Component) PluginServices.getMainFrame(),

                PluginServices.getText(this, "fallo_capas") + " : \n"

                + e.getMessage());

    }

    @Override

    public boolean isLocked() {

        if (super.isLocked()) {

            return true;

        }

        FLayers layers = getMapContext().getLayers();

        for (int i = 0; i < layers.getLayersCount(); i++) {

            FLayer layer = layers.getLayer(i);

            if (layer.isEditing()) {

                return true;

            }

        }

        return false;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("mainMapContext", this.getMapContext());

        if (this.getMapOverViewContext() != null) {

            state.set("useMapOverview", true);

        } else {

            state.set("useMapOverview", false);

        }

        state.set("overviewMapContext", this.getMapOverViewContext());

        state.set("propertiesHelper", propertiesHelper);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        super.loadFromState(state);

        this.mapContext = (MapContext) state.get("mainMapContext");

        if (state.getBoolean("useMapOverview")) {

            this.mapOverViewContext = (MapContext) state.get("overviewMapContext");

        } else {

            this.mapOverViewContext = null;

        }

        this.propertiesHelper = (ExtendedPropertiesHelper) state.get("propertiesHelper");

        IProjection proj = ApplicationLocator.getProjectManager().getProjectPreferences().getDefaultProjection();

        if( this.mapContext!=null ) {

            if( this.mapContext.getProjection()==null ) {

                try {

                    this.mapContext.setProjection(proj);

                } catch(Throwable ex) {

                }

            }

        }

        for( FLayer layer : mapContext ) {

            if( layer.getProjection()==null ) {

                try {

                    layer.setProjection(proj);

                } catch(Throwable ex) {

                }

            }

        }

        for( FLayer layer : mapOverViewContext ) {

            if( layer.getProjection()==null ) {

                try {

                    layer.setProjection(proj);

                } catch(Throwable ex) {

                }

            }

        }

    }

    @Override

    public Object getProperty(Object key) {

        return this.propertiesHelper.getProperty(key);

    }

    @Override

    public void setProperty(Object key, Object obj) {

        this.propertiesHelper.setProperty(key, obj);

    }

    @Override

    public Map getExtendedProperties() {

        return this.propertiesHelper.getExtendedProperties();

    }

    @Override

    public FLayer getLayer(String name) {

        FLayer layer = this.getMapContext().getLayers().getLayer(name);

        return layer;            

    }

    @Override

    public Iterator<FLayer> iterator() {

        return this.mapContext.iterator();

    }

    @Override

    public Iterator<FLayer> deepiterator() {

        return this.mapContext.deepiterator();

    }

    @Override

    public Iterable<FLayer> layers() {

        return () -> deepiterator();

    }

    @Override

    public boolean contains(FLayer layer) {

        if( !(layer instanceof SingleLayer) ) {

            return false;

        }

        return this.isInLayers(this.getMapContext().getLayers(), ((SingleLayer)layer).getDataStore());

    }

    @Override

    public boolean contains(DataStore store) {

        return this.isInLayers(this.getMapContext().getLayers(), store);

    }

    private boolean isInLayers(FLayers layers, DataStore store) {

        for (int i = 0; i < layers.getLayersCount(); i++) {

            if (layers.getLayer(i) instanceof FLayers) {

                if (isInLayers((FLayers) layers.getLayer(i), store)) {

                    return true;

                }

            }

            FLayer layer = layers.getLayer(i);

            if( layer instanceof SingleLayer ) {

                if (((SingleLayer)layer).getDataStore() == store ) {

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public void center(Envelope envelope) {

        ViewPort viewPort = this.getMapContext().getViewPort();

        try {

            Envelope oldExtent = viewPort.getAdjustedEnvelope();

            double oldCenterX = oldExtent.getCenter(0);

            double oldCenterY = oldExtent.getCenter(1);

            double centerX = envelope.getCenter(0);

            double centerY = envelope.getCenter(1);

            Point2D.Double center = new Point2D.Double(centerX, centerY);

            double movX = centerX - oldCenterX;

            double movY = centerY - oldCenterY;

            double minx = oldExtent.getMinimum(0) + movX;

            double miny = oldExtent.getMinimum(1) + movY;

            double maxX = oldExtent.getMaximum(0) + movX;

            double maxY = oldExtent.getMaximum(1) + movY;

            Envelope extent = GeometryLocator.getGeometryManager().createEnvelope(

                    minx, miny,

                    maxX, maxY,

                    Geometry.SUBTYPES.GEOM2D);

            viewPort.setEnvelope(extent);

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

    }

    @Override

    public boolean contains(Object value) {

        if( value == null ) {

            return false;

        }

        DataStoreParameters params;

        if( (value instanceof FeatureStore) ) {

            params = ((FeatureStore) value).getParameters();

        } else if(value instanceof DataStoreParameters){

            params = (DataStoreParameters) value;

        } else {

            return false;

        }

        for (Iterator<FLayer> it = this.deepiterator(); it.hasNext();) {

            FLayer layer = it.next();

            if(layer instanceof FLyrVect){

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

                if( store!=null && store.getParameters().isTheSameStore(params)){

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public void refresh() {

        this.getMapContext().invalidate();

    }

}