Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.mosaic.swing.impl.main;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Insets;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.JTextField;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.TableColumnModel;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreProvider;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

import org.gvsig.fmap.dal.coverage.exception.NotSupportedExtensionException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.parameter.TileDataParameters;

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

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

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

import org.gvsig.fmap.dal.raster.spi.CoverageStoreProvider;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

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

import org.gvsig.i18n.Messages;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.mosaic.io.MosaicDataParameters;

import org.gvsig.raster.mosaic.io.MosaicProvider;

import org.gvsig.raster.mosaic.io.MosaicRasterFormat;

import org.gvsig.raster.mosaic.swing.main.AddFilesEvent;

import org.gvsig.raster.mosaic.swing.main.AddFilesListener;

import org.gvsig.raster.mosaic.swing.main.AddFilesPanel;

import org.gvsig.tools.locator.LocatorException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Main panel to add files in a mosaic

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class AddFilesPanelImpl extends JPanel implements ActionListener, AddFilesPanel {

        private static final long            serialVersionUID       = 1L;

        private String                       pathToImagesForTest    = "/src/main/resources/images/";

        private String                       lastFolder             = System.getProperty("user.home");

        private Logger                       log                    = LoggerFactory.getLogger(AddFilesPanelImpl.class);

        private final String                 BYTE                   = "Byte";

        private final String                 SHORT                  = "Short";

        private final String                 INTEGER                = "Integer";

        private final String                 FLOAT                  = "Float";

        private final String                 DOUBLE                 = "Double";

        private JPanel                       arrowButtonsPanel      = null;

        private JButton                      downArrowButton        = null;

        private JButton                      upArrowButton          = null;

        private JButton                      addAllButton           = null;

        private JButton                      removeAllButton        = null;

        private String[]                     columnNames            = null;

        private JScrollPane                  scrollPanelSrc         = null;

        //private PagedTable                   pagedSrcTable          = null;

        private JTable                       tableSrc               = null;

        private DefaultTableModel            modelSrc               = null;

        private JScrollPane                  scrollPanelDst         = null;

        //private PagedTable                   pagedDstTable          = null;

        private JTable                       tableDst               = null;

        private DefaultTableModel            modelDst               = null;

        private JPanel                       buttonsPanel           = null;

        private JButton                      addDirButton           = null;

        private JButton                      addFilesButton         = null;

        private JButton                      optionsButton          = null;

        private JPanel                       optionsPanel           = null;

        private JComboBox                    nbandsCombo            = null;

        private JTextField                   datatypeTextField      = null;

        private JComboBox                    rgbTypeCombo           = null;

        private JCheckBox                    rgbCheckBox            = null;

        private List<TableEntry>             entriesSrc             = null;

        private List<TableEntry>             entriesDst             = null;

        private AddFilesListener             listener               = null;

        private List<String>                 suffixList             = null;

        private String                       file                   = null;

        private String                       folder                 = null;

        public AddFilesPanelImpl(String file, String folder, List<String> suffixList) {

                columnNames = new String[]{ Messages.getText("bands"), Messages.getText("file")};

                entriesSrc = new ArrayList<TableEntry>();

                entriesDst = new ArrayList<TableEntry>();

                this.suffixList = suffixList;

                this.file = file;

                this.folder = folder;

                initialize();

        }

        public AddFilesPanelImpl(String file, String folder, String[] suffixList) {

                columnNames = new String[]{ Messages.getText("bands"), Messages.getText("file")};

                entriesSrc = new ArrayList<TableEntry>();

                entriesDst = new ArrayList<TableEntry>();

                this.suffixList = Arrays.asList(suffixList);

                this.file = file;

                this.folder = folder;

                initialize();

        }

        class TableEntry {

                Object obj   = null;

                String text  = null;

                int bandCount = 0;

                int dataType = 0;

                double cellsize = 0;

                double nodata = 0;

                public TableEntry(String text, Object obj, int bandCount, int dataType, double cellsize, double nodata) {

                        this.obj = obj;

                        this.text = text;

                        this.bandCount = bandCount;

                        this.dataType = dataType;

                        this.cellsize = cellsize;

                        this.nodata = nodata;

                }

                public String toString() {

                        return text;

                }

        }

        //*******************************************************

        //***************API Implementation**********************

        public void addSrcFile(Object data, String text, int nBands, int datatype, double cellsize, double nodata) {

                TableEntry entry = new TableEntry(text, data, nBands, datatype, cellsize, nodata);

                entriesSrc.add(entry);

                updateUISrcTable();

        }

        public void addDstFile(Object data, String text, int nBands, int datatype, double cellsize, double nodata) {

                TableEntry entry = new TableEntry(text, data, nBands, datatype, cellsize, nodata);

                entriesDst.add(entry);

                updateUIDstTable();

        }

        public void addListener(AddFilesListener filesListener) {

                this.listener = filesListener;

        }

        public JComponent getJComponent() {

                return this;

        }

        //*****************************************************

        private void updateUISrcTable() {

                modelSrc = new DefaultTableModel(columnNames, entriesSrc.size());

                getFileListSrc().setModel(modelSrc);

                getFileListSrc().getColumnModel().getColumn(0).setMaxWidth(55);

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

                        getFileListSrc().getModel().setValueAt(entriesSrc.get(i).bandCount, i, 0);

                        getFileListSrc().getModel().setValueAt(entriesSrc.get(i), i, 1);

                }

        }

        private void updateUIDstTable() {

                modelDst = new DefaultTableModel(columnNames, entriesDst.size());

                getFileListDst().setModel(modelDst);

                getFileListDst().getColumnModel().getColumn(0).setMaxWidth(55);

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

                        getFileListDst().getModel().setValueAt(entriesDst.get(i).bandCount, i, 0);

                        getFileListDst().getModel().setValueAt(entriesDst.get(i), i, 1);

                }

                updateOutputDataTypes();

                updateOutputNumBands();

        }

        private void updateOutputNumBands() {

                setUIOutputNumBands(0);

                if(entriesDst.size() <= 0)

                        return;

                int currentOutputBands = entriesDst.get(0).bandCount;

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

                        int bandCount = entriesDst.get(i).bandCount;

                        if(bandCount > currentOutputBands) 

                                currentOutputBands = bandCount;

                }

                setUIOutputNumBands(currentOutputBands);

                enableUIRGBOutput();

        }

        /**

         * Update output data types depending on the layer type.

         */

        private void updateOutputDataTypes() {

                if(entriesDst.size() == 0) {

                        getDatatypeJTextField().setText("");

                        return;

                }

                if(getDatatypeJTextField().getText().compareTo("") == 0)

                        getDatatypeJTextField().setText(BYTE);

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

                        int currentDatatype = getDataTypeFromText(getDatatypeJTextField().getText());

                        int dataType = entriesDst.get(i).dataType;

                        switch (dataType) {

                        case Buffer.TYPE_DOUBLE:

                                setDataType(Buffer.TYPE_DOUBLE);

                                return;

                        case Buffer.TYPE_FLOAT:

                                if(currentDatatype == Buffer.TYPE_BYTE || currentDatatype == Buffer.TYPE_FLOAT)

                                        setDataType(Buffer.TYPE_FLOAT);

                                else

                                        setDataType(Buffer.TYPE_DOUBLE);

                                break;

                        case Buffer.TYPE_BYTE:

                                if(currentDatatype == Buffer.TYPE_BYTE)

                                        setDataType(Buffer.TYPE_BYTE);

                                break;

                        case Buffer.TYPE_SHORT:

                                if(currentDatatype < Buffer.TYPE_SHORT)

                                        setDataType(Buffer.TYPE_SHORT);

                                break;

                        case Buffer.TYPE_INT:

                                if(currentDatatype < Buffer.TYPE_INT)

                                        setDataType(Buffer.TYPE_INT);

                                break;

                        }

                }

        }

        private int getDataTypeFromText(String text) {

                if(text.compareTo(BYTE) == 0) 

                        return Buffer.TYPE_BYTE;

                if(text.compareTo(SHORT) == 0) 

                        return Buffer.TYPE_SHORT;

                if(text.compareTo(INTEGER) == 0) 

                        return Buffer.TYPE_INT;

                if(text.compareTo(FLOAT) == 0) 

                        return Buffer.TYPE_FLOAT;

                if(text.compareTo(DOUBLE) == 0) 

                        return Buffer.TYPE_DOUBLE;

                return -1;

        }

        private void setDataType(int datatype) {

                switch (datatype) {

                case Buffer.TYPE_BYTE:

                        getDatatypeJTextField().setText(BYTE);

                        break;

                case Buffer.TYPE_SHORT:

                        getDatatypeJTextField().setText(SHORT);

                        break;

                case Buffer.TYPE_INT:

                        getDatatypeJTextField().setText(INTEGER);

                        break;

                case Buffer.TYPE_FLOAT:

                        getDatatypeJTextField().setText(FLOAT);

                        break;

                case Buffer.TYPE_DOUBLE:

                        getDatatypeJTextField().setText(DOUBLE);

                        break;

                }

        }

        private void setUIOutputNumBands(int numBands) {

                getNbandsJComboBox().removeAllItems();

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

                        getNbandsJComboBox().addItem((i + 1) + "");

                }

                getNbandsJComboBox().setSelectedIndex(getNbandsJComboBox().getItemCount() - 1);

        }

        private int getUIOutputNumBands() {

                String value = (String)getNbandsJComboBox().getSelectedItem();

                try {

                        return Integer.valueOf(value);

                } catch (NumberFormatException e) {

                        return -1;

                }

        }

        private void enableUIRGBOutput() {

                int outputNumBands = getUIOutputNumBands();

                boolean enable = outputNumBands >= 3;

                getRGBOutputCheckBox().setEnabled(enable);

                if(!enable) {

                        getRGBTypeComboBox().setSelectedIndex(0);

                        getRGBTypeComboBox().setEnabled(enable);

                } else {

                        if(getRGBOutputCheckBox().isSelected()) {

                                //solo con 4 bandas o m?s se puede elegir el tipo de interpretaci?n de color

                                if(outputNumBands >= 4) { 

                                        if(getRGBTypeComboBox().getSelectedIndex() == 0)

                                                getRGBTypeComboBox().setSelectedIndex(1);

                                        getRGBTypeComboBox().setEnabled(true);

                                } else { 

                                        getRGBTypeComboBox().setSelectedIndex(2);

                                        getRGBTypeComboBox().setEnabled(false);

                                }

                        } else {

                                getRGBTypeComboBox().setSelectedIndex(0);

                                getRGBTypeComboBox().setEnabled(false);

                        }

                }

        }

        protected void initialize() {

                enableUIRGBOutput();

                setLayout(new GridBagLayout());

                GridBagConstraints gbc = new GridBagConstraints();

                gbc.insets = new Insets(2, 2, 2, 2);

                gbc.fill = GridBagConstraints.BOTH;

                gbc.weightx = 1.0;

                gbc.weighty = 1.0;

                gbc.gridwidth = 2;

                add(getScrollTableSrc(), gbc);

                gbc.gridy = 2;

                add(getScrollTableDst(), gbc);

                gbc.fill = GridBagConstraints.HORIZONTAL;

                gbc.weighty = 0.0;

                gbc.gridy = 1;

                add(getIconsPanel(), gbc);

                gbc.gridy = 3;

                add(getButtonsPanel(), gbc);

                gbc.gridwidth = 1;

                gbc.gridx = 0;

                gbc.gridy = 4;

                add(new JPanel(), gbc);

                gbc.fill = GridBagConstraints.NONE;

                gbc.weightx = 0.0;

                gbc.gridx = 1;

                gbc.gridy = 4;

                add(getOptionsPanel(), gbc);

        }

        //******************************************************

        public JPanel getOptionsPanel() {

                if(optionsPanel == null) {

                        optionsPanel = new JPanel(new GridBagLayout());

                        //optionsPanel.setBorder(BorderFactory.createLineBorder(Color.red));

                        JLabel l1 = new JLabel(Messages.getText("n_output_bands"));

                        JLabel l2 = new JLabel(Messages.getText("output_datatype"));

                        GridBagConstraints gbc = new GridBagConstraints();

                        gbc.insets = new Insets(0, 0, 2, 20);

                        gbc.fill = GridBagConstraints.HORIZONTAL;

                        gbc.gridx = 0;

                        gbc.gridy = 0;

                        optionsPanel.add(l1, gbc);

                        gbc.gridx = 1;

                        gbc.gridy = 0;

                        optionsPanel.add(getNbandsJComboBox(), gbc);

                        gbc.gridx = 0;

                        gbc.gridy = 1;

                        optionsPanel.add(l2, gbc);

                        gbc.gridx = 1;

                        gbc.gridy = 1;

                        optionsPanel.add(getDatatypeJTextField(), gbc);

                        gbc.gridx = 0;

                        gbc.gridy = 2;

                        optionsPanel.add(getRGBOutputCheckBox(), gbc);

                        gbc.gridx = 1;

                        gbc.gridy = 2;

                        optionsPanel.add(getRGBTypeComboBox(), gbc);

                }

                return optionsPanel;

        }

        public JComboBox getNbandsJComboBox() {

                if(nbandsCombo == null) {

                        nbandsCombo = new JComboBox();

                        nbandsCombo.addItem("0");

                        nbandsCombo.addActionListener(this);

                }

                return nbandsCombo;

        }

        public JTextField getDatatypeJTextField() {

                if(datatypeTextField == null) {

                        datatypeTextField = new JTextField();

                        datatypeTextField.setEditable(false);

                        datatypeTextField.setPreferredSize(new Dimension(30, 30));

                }

                return datatypeTextField;

        }

        public JComboBox getRGBTypeComboBox() {

                if(rgbTypeCombo == null) {

                        rgbTypeCombo = new JComboBox();

                        rgbTypeCombo.addItem("------");

                        rgbTypeCombo.addItem("ARGB");

                        rgbTypeCombo.addItem("RGB");

                        rgbTypeCombo.addItem("BGR IR");

                }

                return rgbTypeCombo;

        }

        public JCheckBox getRGBOutputCheckBox() {

                if(rgbCheckBox == null) {

                        rgbCheckBox = new JCheckBox(Messages.getText("rgb_output"));

                        rgbCheckBox.addActionListener(this);

                }

                return rgbCheckBox;

        }

        //******************************************************

        public JPanel getButtonsPanel() {

                if(buttonsPanel == null) {

                        FlowLayout fl = new FlowLayout();

                        fl.setAlignment(FlowLayout.LEFT);

                        buttonsPanel = new JPanel(fl);

                        //iconsPanel.setBorder(BorderFactory.createLineBorder(Color.gray));

                        buttonsPanel.add(getAddDirButton());

                        buttonsPanel.add(getAddFilesButton());

                        buttonsPanel.add(getOptionsButton());

                }

                return buttonsPanel;

        }

        public JButton getAddDirButton() {

                if(addDirButton == null) {

                        addDirButton = new JButton(Messages.getText("add_dir"));

                        addDirButton.addActionListener(this);

                }

                return addDirButton;

        }

        public JButton getAddFilesButton() {

                if(addFilesButton == null) {

                        addFilesButton = new JButton(Messages.getText("add_files"));

                        addFilesButton.addActionListener(this);

                }

                return addFilesButton;

        }

        public JButton getOptionsButton() {

                if(optionsButton == null) {

                        optionsButton = new JButton(Messages.getText("options"));

                }

                return optionsButton;

        }

        //******************************************************

        public JScrollPane getScrollTableDst() {

                if(scrollPanelDst == null) {

                        scrollPanelDst = new JScrollPane();

                        scrollPanelDst.setViewportView(getFileListDst());

                }

                return scrollPanelDst;

        }

        public JTable getFileListDst() {

                if(tableDst == null) {

                        tableDst = new JTable(getModelDst());

                        TableColumnModel columnModel = tableDst.getColumnModel();

                        columnModel.getColumn(0).setMaxWidth(55);

                }

                return tableDst;

        }

        public DefaultTableModel getModelDst() {

                if(modelDst == null)

                        modelDst = new DefaultTableModel(columnNames, 0);

                return modelDst;

        }

        //******************************************************

        public JScrollPane getScrollTableSrc() {

                if(scrollPanelSrc == null) {

                        scrollPanelSrc = new JScrollPane();

                        scrollPanelSrc.setViewportView(getFileListSrc());

                }

                return scrollPanelSrc;

        }

        public JTable getFileListSrc() {

                if(tableSrc == null) {

                        tableSrc = new JTable(getModelSrc());

                        TableColumnModel columnModel = tableSrc.getColumnModel();

                        columnModel.getColumn(0).setMaxWidth(55);

                }

                return tableSrc;

        }

        public DefaultTableModel getModelSrc() {

                if(modelSrc == null)

                        modelSrc = new DefaultTableModel(columnNames, 0);

                return modelSrc;

        }

        //******************************************************

        public JPanel getIconsPanel() {

                if(arrowButtonsPanel == null) {

                        FlowLayout fl = new FlowLayout();

                        fl.setAlignment(FlowLayout.CENTER);

                        arrowButtonsPanel = new JPanel(fl);

                        //iconsPanel.setBorder(BorderFactory.createLineBorder(Color.gray));

                        fl.setHgap(2);

                        arrowButtonsPanel.add(getUpArrowButton());

                        arrowButtonsPanel.add(getDownArrowButton());

                        arrowButtonsPanel.add(getAddAllButton());

                        arrowButtonsPanel.add(getRemoveAllButton());

                }

                return arrowButtonsPanel;

        }

        public JButton getUpArrowButton() {

                if(upArrowButton == null) {

                        upArrowButton = new JButton(loadIcon("up-16x16-icon"));

                        upArrowButton.addActionListener(this);

                }

                return upArrowButton;

        }

        public JButton getDownArrowButton() {

                if(downArrowButton == null) {

                        downArrowButton = new JButton(loadIcon("down-16x16-icon"));

                        downArrowButton.addActionListener(this);

                }

                return downArrowButton;

        }

        public JButton getAddAllButton() {

                if(addAllButton == null) {

                        addAllButton = new JButton(loadIcon("downred-16x16-icon"));

                        addAllButton.addActionListener(this);

                }

                return addAllButton;

        }

        public JButton getRemoveAllButton() {

                if(removeAllButton == null) {

                        removeAllButton = new JButton(loadIcon("upred-16x16-icon"));

                        removeAllButton.addActionListener(this);

                }

                return removeAllButton;

        }

        //******************************************************

        private ImageIcon loadIcon(String iconName) {

                ImageIcon icon = null;

                try {

                        icon = IconThemeHelper.getImageIcon(iconName);

                } catch(NullPointerException e) {}

                String path = System.getProperty("user.dir") + pathToImagesForTest + iconName + ".png"; 

                if(new File(path).exists())

                        icon = new ImageIcon(path, "");

                if(icon == null) 

                        icon = new ImageIcon(System.getProperty("user.dir") + pathToImagesForTest + iconName + ".gif", "");

                return icon;

        }

        public void actionPerformed(ActionEvent e) {

                //Cambio del n?mero de bandas de las salida

                if(e.getSource() == getNbandsJComboBox()) {

                        enableUIRGBOutput();

                }

                //Activar/desactivar el check de RGB

                if(e.getSource() == getRGBOutputCheckBox()) {

                        enableUIRGBOutput();

                }

                //Eliminar todas de las capas de salida

                if(e.getSource() == getRemoveAllButton()) {

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

                                entriesSrc.add(entriesDst.get(i));

                        }

                        entriesDst.clear();

                        updateUISrcTable();

                        updateUIDstTable();

                }

                //A?adir todas de las capas de salida

                if(e.getSource() == getAddAllButton()) {

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

                                entriesDst.add(entriesSrc.get(i));

                        }

                        entriesSrc.clear();

                        updateUISrcTable();

                        updateUIDstTable();

                }

                //A?adir la seleccionada a la salida

                if(e.getSource() == getDownArrowButton()) {

                        int[] rows = getFileListSrc().getSelectedRows();

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

                                TableEntry entry = entriesSrc.remove(rows[i]);

                                entriesDst.add(entry);

                        }

                        updateUISrcTable();

                        updateUIDstTable();

                }

                //Eliminar la seleccionada de la salida

                if(e.getSource() == getUpArrowButton()) {

                        int[] rows = getFileListDst().getSelectedRows();

                        for (int i = rows.length - 1; i >= 0; i--) {

                                TableEntry entry = entriesDst.remove(rows[i]);

                                entriesSrc.add(entry);

                        }

                        updateUISrcTable();

                        updateUIDstTable();

                }

                //A?ade ficheros desde disco

                if(e.getSource() == getAddFilesButton()) {

                        if(listener != null) {

                                JFileChooser fileChooser = createJFileChooser(false);

                                int result = fileChooser.showOpenDialog(this);

                                if (result == JFileChooser.APPROVE_OPTION) {

                                        File[] files = fileChooser.getSelectedFiles();

                                        listener.actionAddFiles(new AddFilesEvent(getAddFilesButton(), files));

                                }

                        }

                }

                //Elimina ficheros desde disco

                if(e.getSource() == getAddDirButton()) {

                        if(listener != null) {

                                JFileChooser fileChooser = createJFileChooser(true);

                                int result = fileChooser.showOpenDialog(this);

                                if (result == JFileChooser.APPROVE_OPTION) {

                                        File folder = fileChooser.getSelectedFile();

                                        String[] list = folder.list();

                                        File[] files = filterFileList(list, folder);

                                        listener.actionAddFolder(new AddFilesEvent(getAddFilesButton(), files));

                                }

                        }

                }

        }

        private File[] filterFileList(String[] f, File folder) {

                List<File> list = new ArrayList<File>();

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

                        if(isInList(f[i]))

                                list.add(new File(folder.getAbsolutePath() + File.separator + f[i]));

                }

                return list.toArray(new File[list.size()]);

        }

        private boolean isInList(String name) {

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

                        String suffix = suffixList.get(i);

                        if(name.endsWith("." + suffix))

                                return true;

                }

                return false;

        }

        protected JFileChooser createJFileChooser(boolean folder) {

                JFileChooser fileChooser = new JFileChooser(lastFolder, JFileChooser.getLastPath(lastFolder, null));

                fileChooser.setMultiSelectionEnabled(true);

                fileChooser.setAcceptAllFileFilterUsed(false);

                fileChooser.setDialogType(JFileChooser.OPEN_DIALOG);

                if(folder) {

                        fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);

                        fileChooser.addChoosableFileFilter(new RasterFormatFileFilter());

                } else {

                        fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);

                        fileChooser.addChoosableFileFilter(new RasterFormatFileFilter(suffixList));

                }

                return fileChooser;

        }

        private boolean cache = true;

        public Object getResult() {

                try {

                        DataManagerProviderServices dataManager = (DataManagerProviderServices)DALLocator.getDataManager();

                        DataServerExplorerParameters explParams = dataManager.createServerExplorerParameters(MosaicProvider.NAME);

                        DataServerExplorer explorer = dataManager.openServerExplorer(MosaicProvider.NAME, explParams);

                        MosaicDataParameters newParamsMosaic = (MosaicDataParameters)dataManager.createStoreParameters(explorer.getProviderName());

                        newParamsMosaic.setURI(folder + File.separator + file + MosaicRasterFormat.getSuffix());

                        newParamsMosaic.setPixelSize(getMinPixelSize());

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

                                RasterDataStore store = (RasterDataStore)entriesDst.get(i).obj;

                                RasterProvider prov = (RasterProvider)store.getProvider();

                                if(prov != null)

                                        newParamsMosaic.addProvider(prov);

                        }

                        if(cache) {

                                DataManager manager = DALLocator.getDataManager();

                                TileDataParameters tileParams = null;

                                try {

                                        tileParams = (TileDataParameters) manager.createStoreParameters("Tile Store");

                                } catch (ProviderNotRegisteredException e) {

                                        throw new InitializeException(e.getMessage(), e);

                                }

                                tileParams.setDataParameters(newParamsMosaic);

                                CoverageStoreProvider provider = (CoverageStoreProvider)dataManager.createProvider(null, tileParams);

                                RasterDataStore store = RasterLocator.getManager().getProviderServices().open(provider, tileParams);

                                return store;

                        } else {

                                MosaicProvider provider = (MosaicProvider)dataManager.createProvider(null, newParamsMosaic);

                                RasterDataStore store = RasterLocator.getManager().getProviderServices().open(provider, newParamsMosaic);

                                return store;

                        }

                } catch(ValidateDataParametersException e) {

                        log.debug("Error validating parameters", e);

                } catch (InitializeException e) {

                        log.debug("Error initializating Mosaic Store", e);

                } catch (ProviderNotRegisteredException e) {

                        log.debug("Error looking for the provider", e);

                } catch (RasterDriverException e) {

                        log.debug("Error creating the Store", e);

                } catch (LocatorException e) {

                        log.debug("Error creating the Store", e);

                } catch (NotSupportedExtensionException e) {

                        log.debug("Error creating the Store", e);

                } 

                return null;

        }

        private double getMinPixelSize() {

                double cellsize = Integer.MAX_VALUE;

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

                        if(entriesDst.get(i).cellsize < cellsize)

                                cellsize = entriesDst.get(i).cellsize;

                }

                return cellsize;

        }

}