Application: gvSIG desktop

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2017 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 2

 * 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.raster.tools.swing.impl.clip;

import java.awt.Image;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import java.text.NumberFormat;

import java.util.ArrayList;

import java.util.List;

import java.util.Locale;

import javax.swing.JComponent;

import javax.swing.JFileChooser;

import javax.swing.JOptionPane;

import javax.swing.ListSelectionModel;

import javax.swing.event.AncestorEvent;

import javax.swing.event.AncestorListener;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import javax.swing.text.DefaultFormatterFactory;

import javax.swing.text.NumberFormatter;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.IconThemeHelper;

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

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

import org.gvsig.fmap.dal.raster.BandDescriptor;

import org.gvsig.fmap.dal.raster.RasterQuery;

import org.gvsig.fmap.dal.raster.RasterSet;

import org.gvsig.fmap.dal.raster.RasterStore;

import org.gvsig.fmap.geom.Geometry.DIMENSIONS;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

import org.gvsig.fmap.mapcontext.raster.api.RasterLayer;

import org.gvsig.fmap.mapcontext.raster.swing.MapContextRasterSwingLocator;

import org.gvsig.fmap.mapcontext.raster.swing.MapContextRasterSwingManager;

import org.gvsig.fmap.mapcontext.raster.swing.SelectableBandDescriptorsTableModel;

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.fmap.mapcontrol.tools.BehaviorException;

import org.gvsig.fmap.mapcontrol.tools.Behavior.RectangleBehavior;

import org.gvsig.fmap.mapcontrol.tools.Events.EnvelopeEvent;

import org.gvsig.fmap.mapcontrol.tools.Listeners.RectangleListener;

import org.gvsig.raster.lib.buffer.api.BufferDimensions;

import org.gvsig.raster.lib.buffer.api.BufferLocator;

import org.gvsig.raster.swing.buffer.RasterSwingBufferLocator;

import org.gvsig.raster.swing.buffer.RasterSwingBufferManager;

import org.gvsig.raster.tools.lib.api.RasterClip;

import org.gvsig.raster.tools.lib.api.exceptions.RasterToolCreatingPanelException;

import org.gvsig.raster.tools.swing.api.RasterToolsSwingLocator;

import org.gvsig.raster.tools.swing.api.clip.ClipPanel;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.locator.LocatorException;

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

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

import org.gvsig.tools.swing.icontheme.IconTheme;

/**

 * @author fdiaz

 *

 */

public class ClipPanelController extends ClipPanelView implements ClipPanel {

    /**

     *

     */

    private static final long serialVersionUID = 6979744092502525949L;

    private static final Logger LOG = LoggerFactory.getLogger(ClipPanelController.class);

    private static final String DEFAULT_LAYER_NAME= "Clip";

    private static final String CLIP_TOOL_NAME = "raster-clip-tool";

    // The elements are defined in the Buffer interface, the array should not be

    // changed.

    private static String[] interpolationMethods = { "_nearest_neighbour", "_bilinear", "_inverse_distance",

        "_bicubic_spline", "_bspline" };

    private RasterLayer layer;

    private Envelope layerEnvelope;

    private double layerPixelSizeX;

    private double layerPixelSizeY;

    private int layerColumns;

    private int layerRows;

    private Envelope envelope;

    private boolean updatingResolution;

    private boolean updatingEnvelope;

    private boolean updatingPixels;

    private MapControl mapControl;

    private String previousTool;

    ICoordTrans ct;

    /**

     * @throws RasterToolCreatingPanelException

     */

    public ClipPanelController() throws RasterToolCreatingPanelException {

        translate();

        initializeComponents();

    }

    public void set(FLayer layer) throws RasterToolCreatingPanelException{

        this.layer = (RasterLayer) layer;

        if(mapControl!=null){

            init();

        }

    }

    public void set(MapControl mapControl) throws RasterToolCreatingPanelException{

        this.mapControl = mapControl;

        this.previousTool = mapControl.getCurrentTool();

        if(this.layer != null){

            init();

        }

    }

    private void init() throws RasterToolCreatingPanelException{

        this.addAncestorListener(new AncestorListener() {

            @Override

            public void ancestorRemoved(AncestorEvent event) {

                returnMapControlToPreviousTool();

            }

            @Override

            public void ancestorMoved(AncestorEvent event) {

                returnMapControlToPreviousTool();

            }

            @Override

            public void ancestorAdded(AncestorEvent event) {

                // Do nothing

            }

        });

        IProjection layerProj = this.layer.getProjection();

        IProjection viewProj = mapControl.getProjection();

        ct = null;

        if(!layerProj.equals(viewProj)){

            ct = layerProj.getCT(viewProj);

        }

        // Solo cogemos de las dimensiones del store las filas y columnas porque si la capa est? reproyectada

        // su envelope y sus pixels size no se corresponden con los del raster store.

        try {

            layerEnvelope = this.layer.getFullEnvelope();

        } catch (LocatorException | DataException e1) {

            LOG.warn("Can't get the envelope of the layer", e1);

            throw new RasterToolCreatingPanelException("Can't get the envelope of the layer "+layer.getName(),e1);

        }

        RasterStore rasterStore = this.layer.getRasterStore();

        try {

            BufferDimensions rasterStoreDimensions = rasterStore.getDimensions();

            layerColumns = rasterStoreDimensions.getColumns();

            layerRows = rasterStoreDimensions.getRows();

            layerPixelSizeX = layerEnvelope.getLength(DIMENSIONS.X)/layerColumns;

            layerPixelSizeY = layerEnvelope.getLength(DIMENSIONS.Y)/layerRows;

        } catch (InitializeException e) {

            LOG.warn("Can't get dimensions of the layer's raster store.", e);

            throw new RasterToolCreatingPanelException("Can't get the raster set of the layer " + layer.getName(), e);

        }

        List<BandDescriptor> descriptors = new ArrayList<BandDescriptor>();

        for(int i=0; i<rasterStore.getBands(); i++){

            descriptors.add(rasterStore.getBandDescriptor(i));

        }

        MapContextRasterSwingManager mapContextRasterSwingManager = MapContextRasterSwingLocator.getSwingManager();

        SelectableBandDescriptorsTableModel model = mapContextRasterSwingManager.createSelectableBandDescriptorsTableModel(descriptors);

//        tblBands.setModel(model);

        RasterSwingBufferManager bufferSwingManager = RasterSwingBufferLocator.getSwingManager();

        bufferSwingManager.makeASelectableBandsTable(tblBands, model);

//        tblBands.setColumnModel(new DefaultTableColumnModel());

//        TableColumnModel columnModel = tblBands.getColumnModel();

//        columnModel.setColumnSelectionAllowed(false);

//        for (int i = 0; i < model.getColumnCount(); i++) {

//            TableColumn tableColumn = new TableColumn(i);

//            tableColumn.setIdentifier(model.getColumnName(i));

//            tableColumn.setHeaderValue(model.getColumnName(i));

//            columnModel.addColumn(tableColumn);

//        }

        setFullEnvelope();

        txtCellWidth.setValue(layerPixelSizeX);

        txtCellHeight.setValue(layerPixelSizeY);

        updateResolution(true);

        updatingResolution=false;

        File folder = BufferLocator.getBufferManager().getLastFolderUsedToSaveRaster();

        if(folder!=null){

            txtFolder.setText(folder.getAbsolutePath());

        }

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    private void initializeComponents() {

        // Tab coordinates

        IconTheme iconTheme = ToolsSwingLocator.getIconThemeManager().getCurrent();

        lblIconPix1.setIcon(iconTheme.get("upleft"));

        lblIconPix2.setIcon(iconTheme.get("downright"));

        lblIconReal1.setIcon(iconTheme.get("upleft"));

        lblIconReal2.setIcon(iconTheme.get("downright"));

        PixelCoordinatesDocumentListener pixelCoordinatesDocumentListener = new PixelCoordinatesDocumentListener();

        txtPix1X.getDocument().addDocumentListener(pixelCoordinatesDocumentListener);

        txtPix1Y.getDocument().addDocumentListener(pixelCoordinatesDocumentListener);

        txtPix2X.getDocument().addDocumentListener(pixelCoordinatesDocumentListener);

        txtPix2Y.getDocument().addDocumentListener(pixelCoordinatesDocumentListener);

        RealCoordinatesDocumentListener realCoordinatesDocumentListener = new RealCoordinatesDocumentListener();

        txtReal1X.getDocument().addDocumentListener(realCoordinatesDocumentListener);

        txtReal1Y.getDocument().addDocumentListener(realCoordinatesDocumentListener);

        txtReal2X.getDocument().addDocumentListener(realCoordinatesDocumentListener);

        txtReal2Y.getDocument().addDocumentListener(realCoordinatesDocumentListener);

        btnLoad.setIcon(iconTheme.get("loadparameters-icon"));

        btnSave.setIcon(iconTheme.get("saveparameters-icon"));

        btnPixelsRound.setIcon(iconTheme.get("round-icon"));

        btnRois.setIcon(iconTheme.get("roi"));

        btnFullLayer.setIcon(iconTheme.get("fullextent-icon"));

        btnView.setIcon(iconTheme.get("viewextent-icon"));

        btnViewSelection.setIcon(iconTheme.get("selecttool-icon"));

        btnLoad.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doLoadEnvelope();

            }

        });

        btnSave.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doSaveEnvelope();

            }

        });

        btnPixelsRound.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doPixelsRound();

            }

        });

        //FIXME: habilitarlo cuando est? implementado

        btnRois.setEnabled(false);

        btnRois.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doImportROIsEnvelope();

            }

        });

        btnFullLayer.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doImportFullLayerEnvelope();

            }

        });

        btnView.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doImportViewExtentEnvelope();

            }

        });

        btnViewSelection.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doImportViewSelection();

            }

        });

        // Tab resolution

        rbtnCellSize.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doSelectModeSize();

            }

        });

        rbtnRasterSize.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doSelectModeSize();

            }

        });

        cmbInterpolationMethod.setSelectedIndex(0);

        cmbInterpolationMethod.setEditable(false);

        txtCellWidth.getDocument().addDocumentListener(new DocumentListener() {

            @Override

            public void removeUpdate(DocumentEvent e) {

                changedUpdate(e);

            }

            @Override

            public void insertUpdate(DocumentEvent e) {

                changedUpdate(e);

            }

            @Override

            public void changedUpdate(DocumentEvent e) {

                doChangeUpdateCellWidth();

            }

        });

        txtCellHeight.getDocument().addDocumentListener(new DocumentListener() {

            @Override

            public void removeUpdate(DocumentEvent e) {

                changedUpdate(e);

            }

            @Override

            public void insertUpdate(DocumentEvent e) {

                changedUpdate(e);

            }

            @Override

            public void changedUpdate(DocumentEvent e) {

                doChangeUpdateCellHeight();

            }

        });

        txtWidth.getDocument().addDocumentListener(new DocumentListener() {

            @Override

            public void removeUpdate(DocumentEvent e) {

                changedUpdate(e);

            }

            @Override

            public void insertUpdate(DocumentEvent e) {

                changedUpdate(e);

            }

            @Override

            public void changedUpdate(DocumentEvent e) {

                doChangeUpdateWidth();

            }

        });

        txtHeight.getDocument().addDocumentListener(new DocumentListener() {

            @Override

            public void removeUpdate(DocumentEvent e) {

                changedUpdate(e);

            }

            @Override

            public void insertUpdate(DocumentEvent e) {

                changedUpdate(e);

            }

            @Override

            public void changedUpdate(DocumentEvent e) {

                doChangeUpdateHeight();

            }

        });

        btnRestore.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doRestore();

            }

        });

        btnImportCellWidthFromView.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doImportCellWidthFromView();

            }

        });

        // Tab Bands

        tblBands.setRowSelectionAllowed(true);

        tblBands.setColumnSelectionAllowed(false);

        tblBands.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

        tblBands.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

            @Override

            public void valueChanged(ListSelectionEvent e) {

                doSelectionTblBandsChanged();

            }

        });

        this.btnUpBand.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doUpBand();

            }

        });

        this.btnDownBand.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doDownBand();

            }

        });

        // Tab other options

        btnUpBand.setIcon(iconTheme.get("up"));

        btnDownBand.setIcon(iconTheme.get("down"));

        chkSaveTo.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doCheckSaveToFolder();

            }

        });

        btnFolderChooser.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doSelectFolder();

            }

        });

    }

    protected void doImportCellWidthFromView() {

        double ratio = layerPixelSizeX/layerPixelSizeY;

        double pixelSizeX = mapControl.getViewPort().getDist1pixel();

        txtCellWidth.setValue(pixelSizeX);

//        double pixelSizeY = pixelSizeX/ratio;

//        txtCellHeight.setValue(pixelSizeY);

//        txtWidth.setValue((int) Math.round(envelope.getLength(DIMENSIONS.X) / pixelSizeX));

//        txtHeight.setValue((int) Math.round(envelope.getLength(DIMENSIONS.Y) / pixelSizeY));

        updateSize();

    }

    protected void doChangeUpdateCellHeight() {

        if(updatingResolution){

            return;

        }

        updatingResolution = true;

        Double pixelSizeY = ((Number) txtCellHeight.getValue()).doubleValue();

        if (pixelSizeY != null) {

            Envelope envelope = this.envelope; //calculateEnvelope();

            double ratio = layerPixelSizeX/layerPixelSizeY;

            double pixelSizeX = pixelSizeY*ratio;

            txtCellWidth.setValue(pixelSizeX);

            txtWidth.setValue((int) Math.round(envelope.getLength(DIMENSIONS.X) / pixelSizeX));

            txtHeight.setValue((int) Math.round(envelope.getLength(DIMENSIONS.Y) / pixelSizeY));

        }

        updatingResolution = false;

    }

    protected void doChangeUpdateCellWidth() {

        if (updatingResolution) {

            return;

        }

        updatingResolution = true;

        Double pixelSizeX = ((Number) txtCellWidth.getValue()).doubleValue();

        if (pixelSizeX != null) {

            Envelope envelope = this.envelope; // calculateEnvelope();

            double ratio = layerPixelSizeX / layerPixelSizeY;

            double pixelSizeY = pixelSizeX / ratio;

            txtCellHeight.setValue(pixelSizeY);

            txtWidth.setValue((int) Math.round(envelope.getLength(DIMENSIONS.X) / pixelSizeX));

            txtHeight.setValue((int) Math.round(envelope.getLength(DIMENSIONS.Y) / pixelSizeY));

        }

        updatingResolution = false;

    }

    protected void doChangeUpdateHeight() {

        if(updatingResolution){

            return;

        }

        updatingResolution = true;

        Integer value = (Integer) txtHeight.getValue();

        Envelope envelope = this.envelope; //calculateEnvelope();

        double pixelSizeY = envelope.getLength(DIMENSIONS.Y) / value;

        double ratio = layerPixelSizeX/layerPixelSizeY;

        double pixelSizeX = pixelSizeY*ratio;

        txtCellWidth.setValue(pixelSizeX);

        txtCellHeight.setValue(pixelSizeY);

        txtWidth.setValue((int)Math.round(envelope.getLength(DIMENSIONS.X) / pixelSizeX));

        updatingResolution = false;

    }

    protected void doChangeUpdateWidth() {

        if(updatingResolution){

            return;

        }

        updatingResolution = true;

        Integer value = (Integer) txtWidth.getValue();

        Envelope envelope = this.envelope; //calculateEnvelope();

        double pixelSizeX = envelope.getLength(DIMENSIONS.X) / value;

        double ratio = layerPixelSizeX/layerPixelSizeY;

        double pixelSizeY = pixelSizeX/ratio;

        txtCellWidth.setValue(pixelSizeX);

        txtCellHeight.setValue(pixelSizeY);

        txtHeight.setValue((int)Math.round(envelope.getLength(DIMENSIONS.Y) / pixelSizeY));

        updatingResolution = false;

    }

    protected void doImportROIsEnvelope() {

        try {

            RasterStore rasterStore = this.layer.getRasterStore();

            // FIXME: Ver qu? hacemos con las ROIs y coger el envelope

            Envelope envelope = GeometryLocator.getGeometryManager().createEnvelope(SUBTYPES.GEOM2D);

            setEnvelope(envelope);

            RasterQuery query = rasterStore.createRasterQuery().setClip(envelope);

            RasterSet rasterSet = rasterStore.getRasterSet(query);

            setPixels(0, 0, rasterSet.getColumns() - 1, rasterSet.getRows() - 1);

        } catch (LocatorException | CreateEnvelopeException e1) {

            LOG.warn("Can't get the envelope of the rois of the layer", e1);

            // TODO Gestionar la excepci?n ?mostrar di?logo de advertencia?

        } catch (DataException e1) {

            LOG.warn("Can't get the raster set of the envelope of the ROIs of the layer", e1);

            // TODO Gestionar la excepci?n ?mostrar di?logo de advertencia?

        }

        updateResolution(false);

    }

    protected void doLoadEnvelope() {

        Envelope lastEnvelopeSaved = RasterToolsSwingLocator.getSwingManager().getLastClipEnvelopeSaved();

        if (lastEnvelopeSaved == null) {

            ThreadSafeDialogsManager dlgManager = ToolsSwingLocator.getThreadSafeDialogsManager();

            String message = "_there_is_no_previously_saved_envelope";

            String title = "_error_creating_clip";

            dlgManager.messageDialog(message, title, JOptionPane.WARNING_MESSAGE);

        } else {

            if (lastEnvelopeSaved.intersects(ClipPanelController.this.layerEnvelope)) {

                Envelope intersection = null;

                try {

                    intersection =

                        (lastEnvelopeSaved.getGeometry().intersection(ClipPanelController.this.layerEnvelope

                            .getGeometry())).getEnvelope();

                } catch (GeometryOperationNotSupportedException | GeometryOperationException e) {

                    LOG.warn("Can't gets intersection between last envelope saved and the layer's envelope", e);

                }

                if (intersection != null) {

                    this.setEnvelope(intersection);

                    this.updatePixelsFromEnvelope();

                }

            }

        }

    }

    protected void doSaveEnvelope() {

        try {

            RasterToolsSwingLocator.getSwingManager().setLastClipEnvelopeSaved((Envelope) this.envelope.clone());

//            this.lastEnvelopeSaved = (Envelope) this.envelope.clone();

        } catch (CloneNotSupportedException e1) {

            LOG.warn("Can't clone the envelope", e1);

        }

    }

    protected void doImportViewSelection() {

        if (!CLIP_TOOL_NAME.equalsIgnoreCase(this.mapControl.getCurrentTool())) {

            this.previousTool = this.mapControl.getCurrentTool();

        }

        RectangleBehavior behavior = new RectangleBehavior(new RectangleListener() {

            @Override

            public Image getImageCursor() {

                return IconThemeHelper.getImage("cursor-select-by-rectangle");

            }

            @Override

            public boolean cancelDrawing() {

                return false;

            }

            @Override

            public void rectangle(EnvelopeEvent event) throws BehaviorException {

                Envelope selectedEnvelope = event.getWorldCoordRect();

                if (selectedEnvelope.intersects(ClipPanelController.this.layerEnvelope)) {

                    Envelope intersection = null;

                    try {

                        intersection =

                            (selectedEnvelope.getGeometry().intersection(ClipPanelController.this.layerEnvelope

                                .getGeometry())).getEnvelope();

                    } catch (GeometryOperationNotSupportedException | GeometryOperationException e) {

                        LOG.warn("Can't gets intersection between selected envelope and the layer's envelope", e);

                    }

                    if (intersection != null) {

                        ClipPanelController.this.setEnvelope(intersection);

                        updatingPixels = true;

                        if (ClipPanelController.this.updatePixelsFromEnvelope()) {

                            updateSize();

                        }

                        ;

                        updatingPixels = false;

                    }

                }

                ClipPanelController.this.returnMapControlToPreviousTool();

            }

        });

        // if(!this.mapControl.hasTool(CLIP_TOOL_NAME)){

        this.mapControl.addBehavior(CLIP_TOOL_NAME, behavior);

        // }

        this.mapControl.setTool(CLIP_TOOL_NAME);

    }

    protected void doPixelsRound() {

        if (updateEnvelopeFromPixels()) {

            updateSize();

        }

    }

    protected void doRestore() {

        updateResolution(true);

    }

    protected void doSelectFolder() {

        // FIXME:

        JFileChooser fc = null;

        if (!txtFolder.getText().isEmpty()) {

            fc = new JFileChooser(txtFolder.getText());

        } else {

            fc = new JFileChooser();

        }

        fc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);

        fc.setMultiSelectionEnabled(false);

        int result = fc.showOpenDialog(this);

        if (result == JFileChooser.APPROVE_OPTION) {

            File folder = fc.getSelectedFile();

            txtFolder.setText(folder.getAbsolutePath());

            BufferLocator.getBufferManager().setLastFolderUsedToSaveRaster(folder);

        }

    }

    protected void doCheckSaveToFolder() {

        boolean selected = chkSaveTo.isSelected();

        txtFolder.setEnabled(selected);

        btnFolderChooser.setEnabled(selected);

        lblFolder.setEnabled(selected);

    }

    protected void doImportFullLayerEnvelope() {

        setFullEnvelope();

        updateResolution(true);

    }

    protected void doImportViewExtentEnvelope() {

        setEnvelope(mapControl.getViewPort().getAdjustedEnvelope());

        updatePixelsFromEnvelope();

        doImportCellWidthFromView();

    }

    protected void doSelectModeSize() {

        lblCellHeight.setEnabled(rbtnCellSize.isSelected());

        txtCellWidth.setEnabled(rbtnCellSize.isSelected());

        lblCellWidth.setEnabled(rbtnCellSize.isSelected());

        txtCellHeight.setEnabled(rbtnCellSize.isSelected());

        lblRasterWidth.setEnabled(rbtnRasterSize.isSelected());

        txtWidth.setEnabled(rbtnRasterSize.isSelected());

        lblRasterHeight.setEnabled(rbtnRasterSize.isSelected());

        txtHeight.setEnabled(rbtnRasterSize.isSelected());

    }

    protected void doDownBand() {

        SelectableBandDescriptorsTableModel bandsTableModel = (SelectableBandDescriptorsTableModel) tblBands.getModel();

        int selectedRow = tblBands.getSelectedRow();

        bandsTableModel.down(selectedRow);

        tblBands.getSelectionModel().setSelectionInterval(selectedRow + 1, selectedRow + 1);

    }

    protected void doUpBand() {

        SelectableBandDescriptorsTableModel bandsTableModel = (SelectableBandDescriptorsTableModel) tblBands.getModel();

        int selectedRow = tblBands.getSelectedRow();

        bandsTableModel.up(selectedRow);

        tblBands.getSelectionModel().setSelectionInterval(selectedRow - 1, selectedRow - 1);

    }

    private void translate() {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        lblPixelCoord.setText(i18nManager.getTranslation(lblPixelCoord.getText()));

        lblRealCoord.setText(i18nManager.getTranslation(lblRealCoord.getText()));

        for (int i = 0; i < tabClip.getTabCount(); i++) {

            tabClip.setTitleAt(i, i18nManager.getTranslation(tabClip.getTitleAt(i)));

        }

        lblPix1X.setText(i18nManager.getTranslation(lblPix1X.getText()));

        lblPix1Y.setText(i18nManager.getTranslation(lblPix1Y.getText()));

        lblPix2X.setText(i18nManager.getTranslation(lblPix2X.getText()));

        lblPix2Y.setText(i18nManager.getTranslation(lblPix2Y.getText()));

        btnViewSelection.setText(""); //i18nManager.getTranslation(btnViewSelection.getText()));

        btnViewSelection.setToolTipText(i18nManager.getTranslation(btnViewSelection.getToolTipText()));

        btnFullLayer.setText(""); //i18nManager.getTranslation(btnFullLayer.getText()));

        btnFullLayer.setToolTipText(i18nManager.getTranslation(btnFullLayer.getToolTipText()));

        btnView.setText(""); //i18nManager.getTranslation(btnView.getText()));

        btnView.setToolTipText(i18nManager.getTranslation(btnView.getToolTipText()));

        btnPixelsRound.setText(""); //i18nManager.getTranslation(btnPixelsRound.getText()));

        btnPixelsRound.setToolTipText(i18nManager.getTranslation(btnPixelsRound.getToolTipText()));

        btnLoad.setText(""); //i18nManager.getTranslation(btnLoad.getText()));

        btnLoad.setToolTipText(i18nManager.getTranslation(btnLoad.getToolTipText()));

        btnSave.setText(""); //i18nManager.getTranslation(btnSave.getText()));

        btnSave.setToolTipText(i18nManager.getTranslation(btnSave.getToolTipText()));

        btnRois.setText(""); //i18nManager.getTranslation(btnRois.getText()));

        btnRois.setToolTipText(i18nManager.getTranslation(btnRois.getToolTipText()));

        lblRasterWidth.setText(i18nManager.getTranslation(lblRasterWidth.getText()));

        lblCellWidth.setText(i18nManager.getTranslation(lblCellWidth.getText()));

        lblCellHeight.setText(i18nManager.getTranslation(lblCellHeight.getText()));

        lblRasterHeight.setText(i18nManager.getTranslation(lblRasterHeight.getText()));

        lblResolutionMode.setText(i18nManager.getTranslation(lblResolutionMode.getText()));

        lblInterpolation.setText(i18nManager.getTranslation(lblInterpolation.getText()));

        btnRestore.setText(i18nManager.getTranslation(btnRestore.getText()));

        btnRestore.setToolTipText(i18nManager.getTranslation(btnRestore.getToolTipText()));

        btnImportCellWidthFromView.setText(i18nManager.getTranslation(btnImportCellWidthFromView.getText()));

        btnImportCellWidthFromView.setToolTipText(i18nManager.getTranslation(btnImportCellWidthFromView.getToolTipText()));

        rbtnCellSize.setText(i18nManager.getTranslation(rbtnCellSize.getText()));

        rbtnCellSize.setToolTipText(i18nManager.getTranslation(rbtnCellSize.getToolTipText()));

        rbtnRasterSize.setText(i18nManager.getTranslation(rbtnRasterSize.getText()));

        rbtnRasterSize.setToolTipText(i18nManager.getTranslation(rbtnRasterSize.getToolTipText()));

        lblLayerNames.setText(i18nManager.getTranslation(lblLayerNames.getText()));

        txtLayerNames.setText(i18nManager.getTranslation("_newlayer"));

        chkOnePerBand.setText(i18nManager.getTranslation(chkOnePerBand.getText()));

        chkOnePerBand.setToolTipText(i18nManager.getTranslation(chkOnePerBand.getToolTipText()));

        chkSaveTo.setText(i18nManager.getTranslation(chkSaveTo.getText()));

        chkSaveTo.setToolTipText(i18nManager.getTranslation(chkSaveTo.getToolTipText()));

        lblFolder.setText(i18nManager.getTranslation(lblFolder.getText()));

        btnFolderChooser.setText(i18nManager.getTranslation(btnFolderChooser.getText()));

        btnFolderChooser.setToolTipText(i18nManager.getTranslation(btnFolderChooser.getToolTipText()));

        btnUpBand.setText(""); //i18nManager.getTranslation(btnUpBand.getText()));

        btnUpBand.setToolTipText(i18nManager.getTranslation(btnUpBand.getToolTipText()));

        btnDownBand.setText(""); //i18nManager.getTranslation(btnDownBand.getText()));

        btnDownBand.setToolTipText(i18nManager.getTranslation(btnDownBand.getToolTipText()));

        cmbInterpolationMethod.removeAllItems();

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

            cmbInterpolationMethod.addItem(i18nManager.getTranslation(interpolationMethods[i]));

        }

        NumberFormat numberInstance = NumberFormat.getNumberInstance();

        numberInstance.setGroupingUsed(false);

        numberInstance.setMaximumFractionDigits(Integer.MAX_VALUE);

        NumberFormatter numberFormatter = new NumberFormatter(numberInstance);

        DefaultFormatterFactory tf = new DefaultFormatterFactory(

            numberFormatter,

            numberFormatter,

            numberFormatter,

            numberFormatter);

        txtReal1X.setFormatterFactory(tf);

        txtReal1Y.setFormatterFactory(tf);

        txtReal2X.setFormatterFactory(tf);

        txtReal2Y.setFormatterFactory(tf);

        txtCellWidth.setFormatterFactory(tf);

        txtCellHeight.setFormatterFactory(tf);

        NumberFormat integerInstance = NumberFormat.getIntegerInstance();

        integerInstance.setGroupingUsed(false);

        numberFormatter = new NumberFormatter(integerInstance);

        numberFormatter.setMinimum(0);

        numberFormatter.setMaximum(layerColumns-1);

        tf = new DefaultFormatterFactory(

            numberFormatter,

            numberFormatter,

            numberFormatter,

            numberFormatter);

        txtPix1X.setFormatterFactory(tf);

        numberFormatter = new NumberFormatter(integerInstance);

        numberFormatter.setMinimum(0);

        numberFormatter.setMaximum(layerRows-1);

        tf = new DefaultFormatterFactory(

            numberFormatter,

            numberFormatter,

            numberFormatter,

            numberFormatter);

        txtPix1Y.setFormatterFactory(tf);

        numberFormatter = new NumberFormatter(integerInstance);

        numberFormatter.setMinimum(0);

        numberFormatter.setMaximum(layerColumns-1);

        tf = new DefaultFormatterFactory(

            numberFormatter,

            numberFormatter,

            numberFormatter,

            numberFormatter);

        txtPix2X.setFormatterFactory(tf);

        numberFormatter = new NumberFormatter(integerInstance);

        numberFormatter.setMinimum(0);

        numberFormatter.setMaximum(layerRows-1);

        tf = new DefaultFormatterFactory(

            numberFormatter,

            numberFormatter,

            numberFormatter,

            numberFormatter);

        txtPix2Y.setFormatterFactory(tf);

        numberFormatter = new NumberFormatter(integerInstance);

        numberFormatter.setMinimum(0);

        tf = new DefaultFormatterFactory(

            numberFormatter,

            numberFormatter,

            numberFormatter,

            numberFormatter);

        txtWidth.setFormatterFactory(tf);

        txtHeight.setFormatterFactory(tf);

    }

    /**

     * @param locale

     *

     */

    public void setLocate(Locale locale) {

        Locale l = super.getLocale();

        if (!l.equals(locale)) {

            translate();

        }

        super.setLocale(locale);

    }

    private void doSelectionTblBandsChanged() {

        if (tblBands.getSelectedRowCount() == 1) {

            if (tblBands.getSelectedRow() > 0) {

                btnUpBand.setEnabled(true);

            } else {

                btnUpBand.setEnabled(false);

            }

            if (tblBands.getSelectedRow() < tblBands.getRowCount() - 1) {

                btnDownBand.setEnabled(true);

            } else {

                btnDownBand.setEnabled(false);

            }

        } else {

            btnUpBand.setEnabled(false);

            btnDownBand.setEnabled(false);

        }

    }

    private void returnMapControlToPreviousTool() {

        mapControl.setTool(this.previousTool);

    }

    /**

     *

     */

    private void setFullEnvelope() {

        this.envelope = this.layerEnvelope;

        setPixels(0, 0, layerColumns - 1, layerRows - 1);

        setEnvelope(envelope);

    }

    public void fetch(RasterClip rasterClip) {

        rasterClip.setLayer(this.layer);

        rasterClip.setEnvelope(calculateEnvelope());

        rasterClip.setPixelSizeX(getCellWidth());

        rasterClip.setPixelSizeY(getCellHeight());

        rasterClip.setInterpolationMethod(getInterpolationMethod());

        rasterClip.setRows(getResolutionHeight());

        rasterClip.setColumns(getResolutionWidth());

        String layerNamePrefix = txtLayerNames.getText();

        if(layerNamePrefix.isEmpty()){

            layerNamePrefix = DEFAULT_LAYER_NAME;

        }

        rasterClip.setLayerNamePrefix(layerNamePrefix);

        rasterClip.setCreateOneLayerPerBand(chkOnePerBand.isSelected());

        rasterClip.setSaveToNewRasterFile(chkSaveTo.isSelected());

        List<Integer> bands = ((SelectableBandDescriptorsTableModel)tblBands.getModel()).getSelectedBands();

        rasterClip.setBands(bands);

        boolean saveToNewRasterFile = chkSaveTo.isSelected();

        rasterClip.setSaveToNewRasterFile(saveToNewRasterFile);

        if(saveToNewRasterFile){

            File folder = new File(txtFolder.getText());

            rasterClip.setFolder(folder);

        }

    }

    private void updateResolution(boolean updatePixelSize) {

        updatingResolution=true;

        txtWidth.setValue(calculateColumns());

        txtHeight.setValue(calculateRows());

        if(updatePixelSize){

            txtCellWidth.setValue(calculatePixelSizeX());

            txtCellHeight.setValue(calculatePixelSizeY());

        }

        updatingResolution=false;

    }

    private Integer calculateColumns() {

        Integer x1 = (Integer) txtPix1X.getValue();

        Integer x2 = (Integer) txtPix2X.getValue();

        return x2 - x1 + 1;

    }

    private Integer calculateRows() {

        Integer y1 = (Integer) txtPix1Y.getValue();

        Integer y2 = (Integer) txtPix2Y.getValue();

        return y2 - y1 + 1;

    }

    private Double calculatePixelSizeX() {

        return this.envelope.getLength(DIMENSIONS.X) / calculateColumns();

    }

    private Double calculatePixelSizeY() {

        return this.envelope.getLength(DIMENSIONS.Y) / calculateRows();

    }

    private double getCellWidth() {

        return ((Number) txtCellWidth.getValue()).doubleValue();

    }

    private double getCellHeight() {

        return ((Number) txtCellHeight.getValue()).doubleValue();

    }

    private int getResolutionWidth() {

        return ((Integer) txtWidth.getValue()).intValue();

    }

    private int getResolutionHeight() {

        return ((Integer) txtHeight.getValue()).intValue();

    }

    private void setEnvelope(Envelope envelope) {

        updatingEnvelope = true;

        this.envelope = envelope;

        txtReal1X.setValue(envelope.getMinimum(DIMENSIONS.X));

        txtReal1Y.setValue(envelope.getMaximum(DIMENSIONS.Y));

        txtReal2X.setValue(envelope.getMaximum(DIMENSIONS.X));

        txtReal2Y.setValue(envelope.getMinimum(DIMENSIONS.Y));

        updatingEnvelope = false;

    }

    private void setPixels(int x1, int y1, int x2, int y2) {

        updatingPixels = true;

        txtPix1X.setValue(new Integer(x1));

        txtPix1Y.setValue(new Integer(y1));

        txtPix2X.setValue(new Integer(x2));

        txtPix2Y.setValue(new Integer(y2));

        updatingPixels = false;

    }

    private int getInterpolationMethod() {

        return cmbInterpolationMethod.getSelectedIndex() + 1;

    }

    /*

     * Creates an envelope from the data of the corresponding text fields.

     */

    private Envelope calculateEnvelope() {

        // Coercion coercion = new CoerceToDouble();

        boolean fail = false;

        Double x1 = ((Number) txtReal1X.getValue()).doubleValue();

        Double y1 = ((Number) txtReal1Y.getValue()).doubleValue();

        Double x2 = ((Number) txtReal2X.getValue()).doubleValue();

        Double y2 = ((Number) txtReal2Y.getValue()).doubleValue();

        try {

            if (x1 != null && y1 != null && x2 != null && y2 != null && x1 != null && x2 >= x1 && y2 <= y1) {

                this.envelope = GeometryLocator.getGeometryManager().createEnvelope(x1, y2, x2, y1, SUBTYPES.GEOM2D);

            } else {

                fail = true;

            }

        } catch (Exception e2) {

            fail = true;

        }

        if (fail) {

            ThreadSafeDialogsManager dlgManager = ToolsSwingLocator.getThreadSafeDialogsManager();

            String message =

                "_cant_create_the_envelope_with_this_coordinates_XcolonX_XparenthesisX_XUL1X_XUL2X_XdashX_XDR1X_XDR2X_XparenthesisX";

            String title = "_error_updating_envelope";

            dlgManager.messageDialog(message,

                new String[] { txtReal1X.getText(), txtReal2Y.getText(), txtReal2X.getText(), txtReal1Y.getText() },

                title, JOptionPane.WARNING_MESSAGE);

            LOG.warn(message);

        }

        return this.envelope;

    }

    private void updateSize() {

        double pixelSizeX = ((Number)txtCellWidth.getValue()).doubleValue();

        double ratio = layerPixelSizeX/layerPixelSizeY;

        txtWidth.setValue((int)Math.round(this.envelope.getLength(DIMENSIONS.X) / pixelSizeX));

        txtHeight.setValue((int)Math.round(this.envelope.getLength(DIMENSIONS.Y) / (pixelSizeX/ratio)));

    }

    private boolean updatePixelsFromEnvelope() {

        updatingPixels = true;

        Double real1X = ((Number) txtReal1X.getValue()).doubleValue();

        Double real2X = ((Number) txtReal2X.getValue()).doubleValue();

        Double real1Y = ((Number) txtReal1Y.getValue()).doubleValue();

        Double real2Y = ((Number) txtReal2Y.getValue()).doubleValue();

        if (real1X == null || real2X < real1X || real1X < layerEnvelope.getMinimum(DIMENSIONS.X)) {

            real1X = layerEnvelope.getMinimum(DIMENSIONS.X);

        }

        if (real1Y == null || real2Y > real1Y || real1Y > layerEnvelope.getMaximum(DIMENSIONS.Y)) {

            real1Y = layerEnvelope.getMaximum(DIMENSIONS.Y);

        }

        if (real2X == null || real2X < real1X || real2X > layerEnvelope.getMaximum(DIMENSIONS.X)) {

            real2X = layerEnvelope.getMaximum(DIMENSIONS.X);

        }

        if (real2Y == null || real2Y > real1Y || real2Y < layerEnvelope.getMinimum(DIMENSIONS.Y)) {

            real2Y = layerEnvelope.getMinimum(DIMENSIONS.Y);

        }

        setPixels((int) Math.round((real1X - layerEnvelope.getMinimum(DIMENSIONS.X)) / layerPixelSizeX),

            (int) Math.round((layerEnvelope.getMaximum(DIMENSIONS.Y) - real1Y) / layerPixelSizeY),

            (int) Math.round((real2X - layerEnvelope.getMinimum(DIMENSIONS.X)) / layerPixelSizeX) - 1,

            (int) Math.round((layerEnvelope.getMaximum(DIMENSIONS.Y) - real2Y) / layerPixelSizeY) - 1);

        updatingPixels = false;

        return true;

    }

    private boolean updateEnvelopeFromPixels() {

        updatingEnvelope = true;

        Integer pix1X = null;

        pix1X = (Integer) txtPix1X.getValue();

        Integer pix2X = null;

        pix2X = (Integer) txtPix2X.getValue();

        Integer pix1Y = null;

        pix1Y = (Integer) txtPix1Y.getValue();

        Integer pix2Y = null;

        pix2Y = (Integer) txtPix2Y.getValue();

        if (pix1X == null || pix1X < 0 || pix2X < pix1X) {

            pix1X = 0;

        }

        if (pix1Y == null || pix1Y < 0 || pix2Y < pix1Y) {

            pix1Y = 0;

        }

        if (pix2X == null || pix2X < pix1X || pix2X >= layerColumns) {

            pix2X = layerColumns - 1;

        }

        if (pix2Y == null || pix2Y < pix1Y || pix2Y >= layerRows) {

            pix2Y = layerRows - 1;

        }

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        try {

            setEnvelope(geomManager.createEnvelope(

                pix1X * layerPixelSizeX + layerEnvelope.getMinimum(DIMENSIONS.X),

                layerEnvelope.getMaximum(DIMENSIONS.Y) - ((pix2Y + 1) * layerPixelSizeY) ,

                (pix2X + 1) * layerPixelSizeX + layerEnvelope.getMinimum(DIMENSIONS.X),

                layerEnvelope.getMaximum(DIMENSIONS.Y) - (pix1Y * layerPixelSizeY) ,

                SUBTYPES.GEOM2D));

            updatingEnvelope = false;

            return true;

        } catch (CreateEnvelopeException e) {

            LOG.debug("Can't create the envelope", e);

            updatingEnvelope = false;

            return false;

        }

    }

    private class RealCoordinatesDocumentListener implements DocumentListener {

        @Override

        public void insertUpdate(DocumentEvent e) {

            changedUpdate(e);

        }

        @Override

        public void removeUpdate(DocumentEvent e) {

            changedUpdate(e);

        }

        @Override

        public void changedUpdate(DocumentEvent e) {

            doChangedUpdateRealCoordinates(e);

        }

    }

    private void doChangedUpdateRealCoordinates(DocumentEvent e) {

        if(updatingEnvelope){

            return;

        }

        if(txtReal1X.getValue()==null || txtReal2X.getValue()==null ||  txtReal1Y.getValue()==null ||  txtReal2Y.getValue()==null){

            return;

        }

        updatingPixels = true;

        if(updatePixelsFromEnvelope()){

            updateSize();

        };

        updatingPixels = false;

    }

    private class PixelCoordinatesDocumentListener implements DocumentListener {

        @Override

        public void insertUpdate(DocumentEvent e) {

            changedUpdate(e);

        }

        @Override

        public void removeUpdate(DocumentEvent e) {

            changedUpdate(e);

        }

        @Override

        public void changedUpdate(DocumentEvent e) {

            doChangedUpdatePixelCoordinates(e);

        }

    }

    private void doChangedUpdatePixelCoordinates(DocumentEvent e) {

        if(updatingPixels){

            return;

        }

        if(txtPix1X.getValue()==null || txtPix2X.getValue()==null ||  txtPix1Y.getValue()==null ||  txtPix2Y.getValue()==null){

            return;

        }

        updatingEnvelope = true;

        if(updateEnvelopeFromPixels()){

            updateSize();

        };

        updatingEnvelope = false;

    }

}