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.io.File;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import javax.swing.JOptionPane;

import javax.swing.event.AncestorEvent;

import javax.swing.event.AncestorListener;

import javax.swing.event.ChangeEvent;

import javax.swing.filechooser.FileFilter;

import org.apache.commons.lang3.ArrayUtils;

import org.cresques.cts.IProjection;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

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.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.folders.FoldersManager;

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 gvSIG Team

 *

 */

@SuppressWarnings("UseSpecificCatch")

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

            }

            @Override

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

        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.addChangeListener((ChangeEvent e) -> {

            callStateChanged(this.areSettingsValid());

        });

    }

    @Override

    public void execute() {

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

            throw new IllegalArgumentException("MapControl need");

        }

        String layerName;

        for (DataStoreParameters params : this.getParameters()) {

            fixCRS(params);

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

            this.doAddLayer(layerName, params);

        }

    }

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

        return this.panel.getParameters();

    }

    /**

     * @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 {

                FoldersManager folderManager = ToolsLocator.getFoldersManager();

                param = (FilesystemServerExplorerParameters) dm

                        .createServerExplorerParameters(FilesystemServerExplorer.NAME);

                param.setInitialpath(

                        folderManager.getLastPath(

                                OPEN_LAYER_FILE_CHOOSER_ID, 

                                folderManager.getHome()

                        ).getAbsolutePath()

                );

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

            }

        }

    }

    boolean isTiled(DataStoreParameters parameters){

        return this.panel.isTiled(parameters);

    }

    @Override

    protected void doAddLayer(final String layerName, final DataStoreParameters parameters) {

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

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

        Thread task = new Thread(() -> {

            FLayer layer = null;

            FLayer preparedLayer = null;

            try {

                DataManager dataManager = DALLocator.getDataManager();

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

                DataStoreProviderFactory factory = dataStore.getProviderFactory();

                if (factory.isTiledSupported() != DataStoreProviderFactory.NO && !factory.getClass().getSimpleName().equals("TileProviderFactory")) {

                    if (isTiled(parameters)) {

                        DynObject tileParameters = dataManager.createStoreParameters("TileCache");

                        PluginsManager pluginsManager = PluginsLocator.getManager();

                        File rootFolder = new File(pluginsManager.getApplicationHomeFolder(),"gvsig_rcache");

                        if (tileParameters.getDynClass().getDynField("rootFolder") != null) {

                            tileParameters.setDynValue("rootFolder", rootFolder);

                        }

                        try {

                            dataStore.useCache("TileCache", tileParameters);

                        } catch (DataException e) {

                            LOGGER.warn("Can't cache the layer.", e);

                        }

                    }

                }

                String layerName1 = dataStore.getName();

                layer = manager.createLayer(layerName1, dataStore);

                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 application1 = ApplicationLocator.getManager();

                String resource = "";

                if (e.getResource() instanceof FilesystemStoreParameters) {

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

                }

                application1.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 panel1 = new LayerErrorsPanel(layerName, e);

                if (preparedLayer != null) {

                    panel1.setLayer(preparedLayer);

                } else if (layer!=null) {

                    panel1.setLayer(layer);

                }

                I18nManager i18nManager = ToolsLocator.getI18nManager();

                ToolsSwingLocator.getWindowManager().showWindow(panel1, 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.setName("LoadLayer"+layerName);

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

        DataStoreParameters[] params = this.getParameters();

        return !ArrayUtils.isEmpty(params);

    }

}