Application: gvSIG desktop

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

import org.gvsig.fmap.dal.swing.dataStoreParameters.DataStoreParametersPanelManager;

import org.gvsig.fmap.dal.swing.dataStoreParameters.DataStoreParametersPanel;

import java.awt.Component;

import java.awt.Window;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import javax.swing.DefaultListSelectionModel;

import javax.swing.ListSelectionModel;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.prepareAction.PrepareContext;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.swing.FilesystemExplorerWizardPanel.MyFileFilter;

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.gui.beans.swing.JFileChooser;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.i18n.I18nManager;

/**

 * @author fdiaz

 *

 */

public class FilesystemExplorerWizardPanelController extends FilesystemExplorerWizardPanelView {

    /**

     *

     */

    private static final long serialVersionUID = -2351856603294610783L;

    @SuppressWarnings("unused")

    private static final Logger LOG = LoggerFactory

        .getLogger(FilesystemExplorerWizardPanelController.class);

    /**

     *

     */

    public static final String OPEN_LAYER_FILE_CHOOSER_ID = "OPEN_LAYER_FILE_CHOOSER_ID";

    private static final String DEFAULT_FILTER = "All_supported";

    protected FilesystemServerExplorer explorer;

    private ArrayList<MyFileFilter> filters;

    protected MapContext mapContext;

    protected int selectedIndex;

    private static MyFileFilter lastFilter = null;

    /**

     * @param mapContext

     * @param explorer

     * @param filters

     */

    public FilesystemExplorerWizardPanelController(MapContext mapContext, FilesystemServerExplorer explorer, ArrayList<MyFileFilter> filters) {

        this.mapContext = mapContext;

        this.explorer = explorer;

        this.filters = filters;

        this.selectedIndex = -1;

        initComponents();

        translate();

    }

    private void translate() {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        btnAdd.setText(i18nManager.getTranslation("Anadir"));

        btnProperties.setText(i18nManager.getTranslation("Properties"));

        btnRemove.setText(i18nManager.getTranslation("Eliminar"));

        btnUp.setText(i18nManager.getTranslation("arriba"));

        btnDown.setText(i18nManager.getTranslation("abajo"));

    }

    /**

     * @param locale

    *

    */

    public void setLocate(Locale locale) {

        Locale l = super.getLocale();

        if (!l.equals(locale)) {

            translate();

        }

        super.setLocale(locale);

    }

    private void initComponents() {

        this.btnAdd.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                doAdd();

            }

        });

        this.btnProperties.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                doOpenProperties();

            }

        });

        this.btnRemove.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                doRemove();

            }

        });

        this.btnUp.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                doUp();

            }

        });

        this.btnDown.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                doDown();

            }

        });

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        this.tableFiles.setModel(new FilesystemExplorerWizardTableModel());

        this.tableFiles.getColumn(

            i18nManager.getTranslation(FilesystemExplorerWizardTableModel.COLUMN_STORE_PARAMETERS_NAME))

            .setCellRenderer(new FilesystemStoreParameteresCellRenderer(mapContext));

        this.tableFiles.getColumn(

            i18nManager.getTranslation(FilesystemExplorerWizardTableModel.COLUMN_TILED_NAME)).setMaxWidth(80);

        this.tableFiles.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

        this.tableFiles.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

            public void valueChanged(ListSelectionEvent e) {

                handleSelectionEvent(e);

            }

        });

    }

    protected void updateComponents() {

        btnUp.setEnabled(selectedIndex > 0 && selectedIndex < tableFiles.getRowCount());

        btnDown.setEnabled(selectedIndex >= 0 && selectedIndex < (tableFiles.getRowCount() - 1));

        btnProperties.setEnabled(selectedIndex >= 0 && selectedIndex < tableFiles.getRowCount());

        btnRemove.setEnabled(selectedIndex >= 0 && selectedIndex < tableFiles.getRowCount());

    }

    protected void handleSelectionEvent(ListSelectionEvent e){

        if (e.getValueIsAdjusting())

            return;

        final DefaultListSelectionModel target = (DefaultListSelectionModel)e.getSource();

        selectedIndex = target.getAnchorSelectionIndex();

        updateComponents();

    }

    protected void doAdd() {

        List<FilesystemStoreParameters> list = chooseFilesParameters();

        FilesystemExplorerWizardTableModel model = (FilesystemExplorerWizardTableModel) this.tableFiles.getModel();

        for (FilesystemStoreParameters filesystemStoreParameters : list) {

            model.add(filesystemStoreParameters, false);

            updateTable();

            int index = model.getRowCount()-1;

            this.tableFiles.getSelectionModel().setSelectionInterval(index, index);

        }

    }

    protected void doRemove() {

        FilesystemExplorerWizardTableModel model = (FilesystemExplorerWizardTableModel)this.tableFiles.getModel();

        if(selectedIndex>=0 && selectedIndex<model.getRowCount()){

            int index = selectedIndex;

            model.remove(index);

            updateTable();

            if(index>(model.getRowCount()-1)) {

                index = model.getRowCount()-1;

            };

            this.tableFiles.getSelectionModel().setSelectionInterval(index, index);

        }

    }

    protected void doOpenProperties() {

        FilesystemExplorerWizardTableModel model = (FilesystemExplorerWizardTableModel) this.tableFiles.getModel();

        if (selectedIndex >= 0 && selectedIndex < model.getRowCount()) {

            int index = selectedIndex;

            FilesystemStoreParameters parameters = model.getParams(index);

            showPropertiesDialog((DynObject) parameters);

            updateTable();

            this.tableFiles.getSelectionModel().setSelectionInterval(index, index);

        }

    }

    protected void doUp() {

        FilesystemExplorerWizardTableModel model = (FilesystemExplorerWizardTableModel)this.tableFiles.getModel();

        if(selectedIndex>0 && selectedIndex<model.getRowCount()){

            int index = selectedIndex;

            model.up(index);

            updateTable();

            this.tableFiles.getSelectionModel().setSelectionInterval(index-1, index-1);

        }

    }

    protected void doDown() {

        FilesystemExplorerWizardTableModel model = (FilesystemExplorerWizardTableModel)this.tableFiles.getModel();

        if(selectedIndex>=0 && selectedIndex<model.getRowCount()-1){

            int index = selectedIndex;

            model.down(index);

            updateTable();

            this.tableFiles.getSelectionModel().setSelectionInterval(index+1, index+1);

        }

    }

    protected void showPropertiesDialog(final DynObject parameters) {

        DataStoreParametersPanelManager manager = DALSwingLocator.getDataStoreParametersPanelManager();

        DataStoreParametersPanel panel = manager.createDataStoreParametersPanel(parameters);

        panel.setExcludeGeometryOptions(false);

        manager.showPropertiesDialog(parameters, panel);

    }

    private void updateTable(){

        ((FilesystemExplorerWizardTableModel)this.tableFiles.getModel()).fireTableDataChanged();

        updateRowHeights();

    }

    private void updateRowHeights() {

        /*

         * Auto adjust the height of rows in a JTable.

         * The only way to know the row height for sure is to render each cell

         * to determine the rendered height. After your table is populated with

         * data you can do:

         *

         */

        for (int row = 0; row < this.tableFiles.getRowCount(); row++) {

            int rowHeight = this.tableFiles.getRowHeight();

            for (int column = 0; column < this.tableFiles.getColumnCount(); column++)

            {

                Component comp = this.tableFiles.prepareRenderer(this.tableFiles.getCellRenderer(row, column), row, column);

                rowHeight = Math.max(rowHeight, comp.getPreferredSize().height);

            }

            this.tableFiles.setRowHeight(row, rowHeight);

        }

    }

     private List<FilesystemStoreParameters> chooseFilesParameters() {

        JFileChooser fileChooser =

            new JFileChooser(OPEN_LAYER_FILE_CHOOSER_ID,

                explorer.getCurrentPath());

        fileChooser.setMultiSelectionEnabled(true);

        fileChooser.setAcceptAllFileFilterUsed(false);

        Iterator<MyFileFilter> iter = this.filters.iterator();

        while (iter.hasNext()) {

            fileChooser.addChoosableFileFilter(iter.next());

        }

        if (filters.size() > 0) {

            MyFileFilter firstf = filters.get(0);

            // Set first filter

            fileChooser.setFileFilter(firstf);

        }

        // If there is a last filter, use it

        if (lastFilter != null && filters.contains(lastFilter)) {

            fileChooser.setFileFilter(lastFilter);

        }

        int result = fileChooser.showOpenDialog(this);

        List<FilesystemStoreParameters> toAdd =

            new ArrayList<FilesystemStoreParameters>();

        if (result == JFileChooser.APPROVE_OPTION) {

            lastFilter = (MyFileFilter) fileChooser.getFileFilter();

            JFileChooser.setLastPath(OPEN_LAYER_FILE_CHOOSER_ID, fileChooser.getCurrentDirectory());

            String providerName = null;

            if( lastFilter!=null ) {

                if( !DEFAULT_FILTER.equalsIgnoreCase(lastFilter.getDescription()) ) {

                    providerName = lastFilter.getName();

                }

            }

            toAdd = this.getParametersList(

                    fileChooser.getCurrentDirectory(),

                    fileChooser.getSelectedFiles(),

                    providerName

            );

        }

        return toAdd;

    }

    private List<FilesystemStoreParameters> getParametersList(File folder, File[] files, String providerName) {

        ApplicationManager application = ApplicationLocator.getManager();

        PrepareContext context = this.getPrepareDataStoreContext();

        List<DataStoreParameters> params = new ArrayList<DataStoreParameters>();

        List<DataStoreParameters> preparedParams = null;

        List<FilesystemStoreParameters> returnParams = new ArrayList<FilesystemStoreParameters>();

        for ( File aFile : files ) {

            String currentProvider = providerName;

            DataStoreParameters param;

            try {

                if( folder == null) {

                    explorer.setCurrentPath(aFile.getParentFile());

                } else {

                    explorer.setCurrentPath(folder);

                }

                if( currentProvider == null ) {

                    for( int i=1; i<this.filters.size(); i++) {

                        MyFileFilter filter = this.filters.get(i);

                        if( filter.accept(aFile)) {

                            currentProvider = filter.getName();

                            break;

                        }

                    }

                }

                if( currentProvider == null ) {

                    // TODO: ask user

                    continue;

                }

                param = explorer.createStoreParameters(aFile, currentProvider);

                if ( param == null ) {

                    // TODO show warning

                    continue;

                }

                params.add(param);

            } catch (DataException e) {

                NotificationManager.addError(e);

                return null;

            }

        }

        try {

            preparedParams

                    = application.prepareOpenDataStoreParameters(params, context);

        } catch (Exception e) {

            NotificationManager.addError(e);

        }

        if ( preparedParams != null ) {

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

                returnParams.add((FilesystemStoreParameters) preparedParams.get(i));

            }

        }

        return returnParams;

    }

    /**

     * @return

     */

    protected PrepareContext getPrepareDataStoreContext() {

        return new PrepareContext() {

            @Override

            public IProjection getViewProjection() {

                return FilesystemExplorerWizardPanelController.this.mapContext.getProjection();

            }

            @Override

            public Window getOwnerWindow() {

                return null;

            }

        };

    }

    /**

     * @return DataStoreParameters[]

     */

    public DataStoreParameters[] getParameters() {

        return ((FilesystemExplorerWizardTableModel)this.tableFiles.getModel()).getParameters();

    }

    /**

     * @param files

     */

    public void addFiles(List<File> files) {

        File[] filesArray = files.toArray(new File[files.size()]);

        this.addFilesFromParameters(this.getParametersList(null, filesArray, null));

    }

    private void addFilesFromParameters(List<FilesystemStoreParameters> filesParams) {

        if ( filesParams.isEmpty() ) {

            return;

        }

        FilesystemExplorerWizardTableModel model = (FilesystemExplorerWizardTableModel)this.tableFiles.getModel();

        model.add(filesParams, false);

    }

    /**

     * @param parameters

     * @return boolean

     */

    public boolean isTiled(DataStoreParameters parameters) {

        return ((FilesystemExplorerWizardTableModel)this.tableFiles.getModel()).isTiled(parameters);

    }

    /**

     * @param explorer

     */

    public void setExplorer(FilesystemServerExplorer explorer) {

        this.explorer = explorer;

    }

    /**

     * @param filters

     */

    public void setFilters(ArrayList<MyFileFilter> filters) {

        this.filters=filters;

    }

    /**

     * Dispose filters and explorer.

     *

     */

    public void dispose() {

        if (explorer != null) {

            explorer.dispose();

            explorer = null;

        }

        if (filters != null) {

            filters.clear();

            filters = null;

        }

    }

}