Application: gvSIG desktop

package org.gvsig.fmap.dal.serverexplorer.filesystem.swing;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Window;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.io.File;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.prefs.Preferences;

import javax.swing.JOptionPane;

import javax.swing.event.AncestorEvent;

import javax.swing.event.AncestorListener;

import javax.swing.filechooser.FileFilter;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.Launcher;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.gui.WizardPanel;

import org.gvsig.app.prepareAction.PrepareContext;

import org.gvsig.app.prepareAction.PrepareContextView_v1;

import org.gvsig.app.project.documents.view.toc.actions.LayerErrorsPanel;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

import org.gvsig.fmap.dal.DataTypes;

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemFileFilter;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.MapContextManager.CreateLayerParameters;

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

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.identitymanagement.UnauthorizedException;

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

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

/**

 * @author fdiaz

 *

 */

public class FilesystemExplorerWizardPanel extends WizardPanel {

    /**

     *

     */

    private static final long serialVersionUID = 788115220334290212L;

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

    private static final String DEFAULT_FILTER = "All_supported";

    public static final String OPEN_LAYER_FILE_CHOOSER_ID =

        "OPEN_LAYER_FILE_CHOOSER_ID";

    protected FilesystemServerExplorer explorer;

    private ArrayList<MyFileFilter> filters;

    private static String lastPath = null;

    private FilesystemExplorerWizardPanelController panel = null;

    private boolean tabularOnly;

    /**

     *

     */

    public FilesystemExplorerWizardPanel() {

        this(false);

    }

    public FilesystemExplorerWizardPanel(boolean tabularOnly) {

        super();

        this.tabularOnly = tabularOnly;

        this.addAncestorListener(new AncestorListener() {

            @Override

            public void ancestorAdded(AncestorEvent ae) {

                initExplorer();

                initFilters();

                updatePanel();

            }

            @Override

            public void ancestorRemoved(AncestorEvent ae) {

                dispose();

            }

            public void ancestorMoved(AncestorEvent ae) {

            }

        });

    }

    protected void updatePanel() {

        this.panel.setExplorer(this.explorer);

        this.panel.setFilters(this.filters);

    }

    @Override

    public void initWizard() {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        setTabName(i18nManager.getTranslation("Fichero"));

        if (lastPath == null) {

            Preferences prefs = Preferences.userRoot().node("gvsig.foldering");

            lastPath = prefs.get("DataFolder", System.getProperty("user.home"));

        }

        initExplorer();

        initFilters();

        initUI();

    }

    private void initUI() {

        setLayout(new GridBagLayout());

        GridBagConstraints gridBagConstraints = new GridBagConstraints();

        gridBagConstraints.fill = GridBagConstraints.BOTH;

        gridBagConstraints.weightx = 1.0;

        gridBagConstraints.weighty = 1.0;

        panel = new FilesystemExplorerWizardPanelController(getMapContext(),explorer, filters);

        panel.setTabularOnly(this.tabularOnly);

        this.add(panel, gridBagConstraints);

        panel.asJComponent().addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                callStateChanged(areSettingsValid());

            }

        });

    }

    @Override

    public void execute() {

        if (this.getMapCtrl() == null) {

            throw new IllegalArgumentException("MapControl need");

        }

        String layerName;

        for (CreateLayerParameters layerParams : this.getLoadLayerParameters()) {

            IProjection proj = this.getMapCtrl().getProjection();

            // Buscamos por el parametro de la proyeccion

            // que sean obligatorios y est?n a null

            // y le ponemos la proyeccion de la vista

            DataStoreParameters params = layerParams.getDataParameters();

            DynField[] fields = params.getDynClass().getDynFields();

            int crsfields = 0;

            DynField crsfield = null;

            for (DynField field : fields) {

                if (field.getType() == DataTypes.CRS ) {

                    crsfields++;

                    crsfield = field;

                    if( field.isMandatory() ) {

                        if (params.getDynValue(field.getName()) == null) {

                            params.setDynValue(field.getName(), proj);

                        }

                    }

                }

            }

            if( crsfields == 1 && crsfield!=null ) {

                // Si solo hay un parametro CRS y esta a null, aunque no sea

                // obligatorio le asigna el CRS de la vista.

                if (params.getDynValue(crsfield.getName()) == null) {

                    params.setDynValue(crsfield.getName(), proj);

                }

            }

            layerName = ((FilesystemStoreParameters) params).getFile().getName();

            this.doAddLayer(layerName, layerParams);

        }

    }

    @Override

    public void close() {

        this.dispose();

    }

    /**

     * Dispose filters and explorer

     */

    public void dispose() {

        if (explorer != null) {

            explorer.dispose();

            explorer = null;

        }

        if (filters != null) {

            filters.clear();

            filters = null;

        }

        panel.dispose();

    }

    @Override

    public DataStoreParameters[] getParameters() {

        // TODO: Habria que ver si podemos eliminar este metodo.

        CreateLayerParameters[] layerParameters = this.panel.getCreateLayerParameters();

        DataStoreParameters[] dataParameters = new DataStoreParameters[layerParameters.length];

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

            DataStoreParameters dataParameter = layerParameters[i].getDataParameters();

        }

        return dataParameters;

    }

    public CreateLayerParameters[] getLoadLayerParameters() {

        return this.panel.getCreateLayerParameters();

    }

    /**

     * @param files

     */

    public void addFiles(List<File> files) {

        this.panel.addFiles(files);

    }

    private void initExplorer() {

        if (this.explorer == null) {

            DataManager dm = DALLocator.getDataManager();

            FilesystemServerExplorerParameters param;

            try {

                param = (FilesystemServerExplorerParameters) dm

                        .createServerExplorerParameters(FilesystemServerExplorer.NAME);

                param.setInitialpath(lastPath);

                explorer = (FilesystemServerExplorer) dm.openServerExplorer(

                                FilesystemServerExplorer.NAME, param);

            } catch (Exception e) {

                throw new RuntimeException(e);

            }

        }

    }

    private void initFilters() {

        if (this.filters == null) {

            int mode = FilesystemServerExplorer.MODE_ALL;

            this.filters = new ArrayList<>();

            if (this.getMapCtrl() == null) {

                mode = FilesystemServerExplorer.MODE_FEATURE;

            } else {

                mode = FilesystemServerExplorer.MODE_GEOMETRY

                        | FilesystemServerExplorer.MODE_RASTER;

            }

            I18nManager i18nManager = ToolsLocator.getI18nManager();

            // First filter in list will be 'All formats' filter

            this.filters.add(new MyFileFilter(explorer.getFilter(mode,

                    i18nManager.getTranslation(DEFAULT_FILTER))));

            @SuppressWarnings("unchecked")

            Iterator<FilesystemFileFilter> iter = explorer.getFilters(mode);

            while (iter.hasNext()) {

                this.filters.add(new MyFileFilter(iter.next()));

            }

        }

    }

    @Override

    protected void doAddLayer(final String layerName, final CreateLayerParameters layerParameters) {

        final boolean b_isMapControlAvail = this.isMapControlAvailable();

        final MapControl mapControl = this.getMapCtrl();

        final MapContext mapContext = this.getMapContext();

        final ApplicationManager application = ApplicationLocator.getManager();

        final MapContextManager manager = MapContextLocator.getMapContextManager();

        final DataStoreParameters parameters = layerParameters.getDataParameters();

        logger.info("addLayer('{}',...)", layerName);

        Thread task = new Thread(new Runnable() {

            @Override

            public void run() {

                FLayer layer = null;

                FLayer preparedLayer = null;

                try {

                    DataManager dataManager = DALLocator.getDataManager();

                    DataStore dataStore = dataManager.openStore(parameters.getDataStoreName(), parameters);

                    String layerName = dataStore.getName();

                    layer = manager.createLayer(

                            layerName, 

                            dataStore, 

                            layerParameters

                    );

                    DisposeUtils.disposeQuietly(dataStore);

                    preparedLayer

                            = application.prepareOpenLayer(layer,

                                    new PrepareContextView_v1() {

                                        @Override

                                        public Window getOwnerWindow() {

                                            return null;

                                        }

                                        @Override

                                        public MapControl getMapControl() {

                                            return mapControl;

                                        }

                                        @Override

                                        public IProjection getViewProjection() {

                                            return mapContext.getProjection();

                                        }

                                        @Override

                                        public MapContext getMapContext() {

                                            return mapContext;

                                        }

                                        @Override

                                        public boolean isMapControlAvailable() {

                                            return b_isMapControlAvail;

                                        }

                                    });

                    if (preparedLayer != null) {

                        mapControl.addLayer(preparedLayer);

                    }

                } catch (UnauthorizedException e) {

                    I18nManager i18nManager = ToolsLocator.getI18nManager();

                    ApplicationManager application = ApplicationLocator.getManager();

                    String resource = "";

                    if (e.getResource() instanceof FilesystemStoreParameters) {

                        resource = ((FilesystemStoreParameters) e.getResource()).getFile().getPath();

                    }

                    application.messageDialog(

                            i18nManager.getTranslation("_User_0_is_not_authorized_to_1_on_resource_2_3",

                                    new String[]{

                                        e.getIdentity().getID(),

                                        e.getActionName(),

                                        e.getResourceName(),

                                        resource

                                    }),

                            i18nManager.getTranslation("_Unauthorized_access"),

                            JOptionPane.WARNING_MESSAGE

                    );

                    logger.warn("Unauthorized access to layer '" + layerName + "'.", e);

                } catch (Exception e) {

                    LayerErrorsPanel panel = new LayerErrorsPanel(layerName, e);

                    if (preparedLayer != null) {

                        panel.setLayer(preparedLayer);

                    } else if(layer!=null){

                        panel.setLayer(layer);

                    }

                    I18nManager i18nManager = ToolsLocator.getI18nManager();

                    ToolsSwingLocator.getWindowManager().showWindow(

                        panel,

                        i18nManager.getTranslation("_Problems_loading_the_layer"),

                        WindowManager.MODE.WINDOW

                    );

                    logger.warn("Can't load layer '" + layerName + "'.", e);

                } finally {

                    if (preparedLayer != layer) {

                        DisposeUtils.disposeQuietly(preparedLayer);

                    }

                    DisposeUtils.disposeQuietly(layer);

                }

            }

        });

        task.start();

    }

    /**

     * @author fdiaz

     *

     */

    public class MyFileFilter extends FileFilter {

        private FilesystemFileFilter filter = null;

        /**

         * @param params

         */

        public MyFileFilter(FilesystemFileFilter params) {

            this.setFilter(params);

        }

        @Override

        public boolean accept(File f) {

            if (f.isDirectory()) {

                return true;

            }

            return getFilter().accept(f);

        }

        @Override

        public String getDescription() {

            return getFilter().getDescription();

        }

        /**

         * @return

         */

        public String getName() {

            return getFilter().getDataStoreProviderName();

        }

        /**

         * @return the filter

         */

        public FilesystemFileFilter getFilter() {

            return filter;

        }

        /**

         * @param filter the filter to set

         */

        public void setFilter(FilesystemFileFilter filter) {

            this.filter = filter;

        }

    }

    protected void showPropertiesDialog(DynObject parameters) {

        panel.showPropertiesDialog(parameters);

    }

    protected PrepareContext getPrepareDataStoreContext() {

        return panel.getPrepareDataStoreContext();

    }

    @Override

    public boolean areSettingsValid() {

        boolean valid = super.areSettingsValid();

        return valid && getMapCtrl()!=null;

    }

}