Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.tools.swing.impl.viewclip;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.awt.image.BufferedImage;

import java.io.IOException;

import java.text.NumberFormat;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.event.AncestorEvent;

import javax.swing.event.AncestorListener;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.text.DefaultFormatterFactory;

import javax.swing.text.NumberFormatter;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.IconThemeHelper;

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

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.primitive.Envelope;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextDrawer;

import org.gvsig.fmap.mapcontext.MapContextException;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.events.ColorEvent;

import org.gvsig.fmap.mapcontext.events.ExtentEvent;

import org.gvsig.fmap.mapcontext.events.ProjectionEvent;

import org.gvsig.fmap.mapcontext.events.listeners.ViewPortListener;

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.Buffer;

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

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

import org.gvsig.raster.lib.buffer.api.exceptions.BufferException;

import org.gvsig.raster.swing.buffer.save.SaveBufferDialog;

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

import org.gvsig.raster.tools.swing.api.viewclip.ViewClipPanel;

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.ToolsSwingManager;

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

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

import org.gvsig.tools.task.Cancellable;

/**

 * @author fdiaz

 *

 */

public class ViewClipPanelController extends ViewClipPanelView implements ViewClipPanel {

    /**

     *

     */

    private static final long serialVersionUID = 3796048566550997832L;

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

    private static final int BANDS = 4;

    private static int METERS_TO_CENTIMETERS = 100;

    private static double INCHES_TO_CENTIMETERS = 2.54;

    private static int[] RESOLUTIONS = new int[] { 72, 96, 160, 300, 600, 2540, 4000 };;

    private MapControl mapControl;

    private String previousTool;

    private ViewPortListener viewPortListener;

    private Envelope envelope;

    private boolean updatingEnvelope;

    private boolean updatingPixelSection;

    private boolean updatingPrintSection;

    private RectangleBehavior behavior;

    /**

     *

     */

    public ViewClipPanelController() {

        translate();

        initializeComponents();

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    @Override

    public void set(MapControl mapControl) throws RasterToolCreatingPanelException {

        if (this.mapControl != null) {

            if (mapControl != this.mapControl) {

                returnMapControlToPreviousTool();

                this.mapControl = mapControl;

                this.previousTool = mapControl.getCurrentTool();

            }

        } else {

            this.mapControl = mapControl;

            this.previousTool = mapControl.getCurrentTool();

        }

        init();

    }

    private void init() {

        this.addAncestorListener(new AncestorListener() {

            @Override

            public void ancestorRemoved(AncestorEvent event) {

                returnMapControlToPreviousTool();

            }

            @Override

            public void ancestorMoved(AncestorEvent event) {

            }

            @Override

            public void ancestorAdded(AncestorEvent event) {

                doAddRectangularSelectionTool();

            }

        });

        doUpdatePixelSize();

        doUpdateScaleDenominator();

        doAddRectangularSelectionTool();

        this.mapControl.getViewPort().addViewPortListener(this.getViewPortListener());

    }

    private ViewPortListener getViewPortListener() {

        if (this.viewPortListener == null) {

            viewPortListener = new ViewPortListener() {

                @Override

                public void projectionChanged(ProjectionEvent e) {

                    // FIXME: ??

                    doUpdatePixelSize();

                    doUpdateScaleDenominator();

                }

                @Override

                public void extentChanged(ExtentEvent e) {

                    doUpdatePixelSize();

                    doUpdateScaleDenominator();

                }

                @Override

                public void backColorChanged(ColorEvent e) {

                    // Do nothing

                }

            };

        }

        return this.viewPortListener;

    }

    protected void doUpdatePixelSize() {

        if (updatingPixelSection) {

            return;

        }

        updatingPixelSection = true;

        double pixelSize = this.mapControl.getViewPort().getDist1pixel();

        this.txtPixelSize.setValue(pixelSize);

        if (this.envelope != null) {

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

            txtHeight.setValue(Math.round(this.envelope.getLength(DIMENSIONS.Y) / pixelSize));

            updatePrintSectionFromPixelSection();

            updateResultSize();

        }

        updatingPixelSection = false;

    }

    protected void doUpdateScaleDenominator() {

        if (updatingPrintSection) {

            return;

        }

        updatingPrintSection = true;

        MapContext mapContext = this.mapControl.getMapContext();

        long scaleView = mapContext.getScaleView();

        txtScaleDenominator.setValue(scaleView);

        ViewPort viewPort = this.mapControl.getViewPort();

        double distanceTransToMeter = mapContext.getDistanceTrans2Meter()[viewPort.getMapUnits()];

        if (this.envelope != null && rdbPrintSelection.isSelected()) {

            double width = (distanceTransToMeter * METERS_TO_CENTIMETERS * this.envelope.getLength(DIMENSIONS.X) / scaleView);

            double height = (distanceTransToMeter * METERS_TO_CENTIMETERS * this.envelope.getLength(DIMENSIONS.Y) / scaleView);

            txtPrintWidth.setValue(width);

            txtPrintHeight.setValue(height);

            updatePixelSectionFromPrintSection();

            updateResultSize();

        }

        updatingPrintSection = false;

    }

    private void returnMapControlToPreviousTool() {

        mapControl.setTool(this.previousTool);

        mapControl.removeCombinedTool(this.getBehavior());

    }

    private void translate() {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

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

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

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

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

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

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

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

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

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

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

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

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

        // btnTool.setText(i18nManager.getTranslation(btnTool.getText()));

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

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

        txtPixelSize.setFormatterFactory(tf);

        txtPrintWidth.setFormatterFactory(tf);

        txtPrintHeight.setFormatterFactory(tf);

        txtScaleDenominator.setFormatterFactory(tf);

        NumberFormat integerInstance = NumberFormat.getIntegerInstance();

        integerInstance.setGroupingUsed(false);

        numberFormatter = new NumberFormatter(integerInstance);

        numberFormatter.setMinimum(0);

        numberFormatter.setMaximum(Integer.MAX_VALUE);

        tf = new DefaultFormatterFactory(numberFormatter, numberFormatter, numberFormatter, numberFormatter);

        txtWidth.setFormatterFactory(tf);

        txtHeight.setFormatterFactory(tf);

        txtResultSize.setFormatterFactory(tf);

    }

    private void initializeComponents() {

        // Tab coordinates

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

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

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

        RealCoordinatesDocumentListener realCoordinatesDocumentListener = new RealCoordinatesDocumentListener();

        txtReal1X.getDocument().addDocumentListener(realCoordinatesDocumentListener);

        txtReal1Y.getDocument().addDocumentListener(realCoordinatesDocumentListener);

        txtReal2X.getDocument().addDocumentListener(realCoordinatesDocumentListener);

        txtReal2Y.getDocument().addDocumentListener(realCoordinatesDocumentListener);

        rdbPixelSelection.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doSelectByPixel();

            }

        });

        rdbPrintSelection.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doSelectForPrint();

            }

        });

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

            @Override

            public void removeUpdate(DocumentEvent e) {

                // Do nothing

            }

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

                // Do nothing

            }

            @Override

            public void insertUpdate(DocumentEvent e) {

                changedUpdate(e);

            }

            @Override

            public void changedUpdate(DocumentEvent e) {

                doChangeUpdateHeight();

            }

        });

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

            @Override

            public void removeUpdate(DocumentEvent e) {

                // Do nothing

            }

            @Override

            public void insertUpdate(DocumentEvent e) {

                changedUpdate(e);

            }

            @Override

            public void changedUpdate(DocumentEvent e) {

                doChangedUpdatePixelSize();

            }

        });

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

            @Override

            public void removeUpdate(DocumentEvent e) {

                // Do nothing

            }

            @Override

            public void insertUpdate(DocumentEvent e) {

                changedUpdate(e);

            }

            @Override

            public void changedUpdate(DocumentEvent e) {

                doChangeUpdatePrintWidth();

            }

        });

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

            @Override

            public void removeUpdate(DocumentEvent e) {

                // Do nothing

            }

            @Override

            public void insertUpdate(DocumentEvent e) {

                changedUpdate(e);

            }

            @Override

            public void changedUpdate(DocumentEvent e) {

                doChangeUpdatePrintHeight();

            }

        });

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

            @Override

            public void removeUpdate(DocumentEvent e) {

                // Do nothing

            }

            @Override

            public void insertUpdate(DocumentEvent e) {

                changedUpdate(e);

            }

            @Override

            public void changedUpdate(DocumentEvent e) {

                doChangeUpdateScaleDenominator();

            }

        });

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

            cmbResolution.addItem(RESOLUTIONS[i]);

        }

        cmbResolution.addItemListener(new ItemListener() {

            @Override

            public void itemStateChanged(ItemEvent e) {

                doChangeStateCmbResolution();

            }

        });

        cmbResolution.setSelectedIndex(0);

        cmbResolution.setEditable(false);

        btnTool.setIcon(iconTheme.get("view-clip-icon"));

        btnTool.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doAddRectangularSelectionTool();

            }

        });

    }

    protected void doChangeUpdateWidth() {

        if (updatingPixelSection) {

            return;

        }

        updatingPixelSection = true;

        double pixelSize = this.envelope.getLength(DIMENSIONS.X) / ((Number) txtWidth.getValue()).intValue();

        txtPixelSize.setValue(pixelSize);

        txtHeight.setValue(Math.round(this.envelope.getLength(DIMENSIONS.Y) / pixelSize));

        updatePrintSectionFromPixelSection();

        updateResultSize();

        updatingPixelSection = false;

    }

    protected void doChangeUpdateHeight() {

        if (updatingPixelSection) {

            return;

        }

        updatingPixelSection = true;

        double pixelSize = this.envelope.getLength(DIMENSIONS.Y) / ((Number) txtHeight.getValue()).intValue();

        txtPixelSize.setValue(pixelSize);

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

        updatePrintSectionFromPixelSection();

        updateResultSize();

        updatingPixelSection = false;

    }

    protected void doChangeUpdatePrintWidth() {

        if (updatingPrintSection) {

            return;

        }

        updatingPrintSection = true;

        double scaleDenominator =

            this.envelope.getLength(DIMENSIONS.X) / ((Number) txtPrintWidth.getValue()).doubleValue();

        txtScaleDenominator.setValue(scaleDenominator);

        txtPrintHeight.setValue(this.envelope.getLength(DIMENSIONS.Y) / scaleDenominator);

        updatePixelSectionFromPrintSection();

        updateResultSize();

        updatingPrintSection = false;

    }

    protected void doChangeUpdatePrintHeight() {

        if (updatingPrintSection) {

            return;

        }

        updatingPrintSection = true;

        double scaleDenominator =

            this.envelope.getLength(DIMENSIONS.Y) / ((Number) txtPrintHeight.getValue()).doubleValue();

        txtScaleDenominator.setValue(scaleDenominator);

        txtPrintWidth.setValue(this.envelope.getLength(DIMENSIONS.X) / scaleDenominator);

        updatePixelSectionFromPrintSection();

        updateResultSize();

        updatingPrintSection = false;

    }

    protected void doChangeUpdateScaleDenominator() {

        if (updatingPrintSection) {

            return;

        }

        updatingPrintSection = true;

        double scaleDenominator = ((Number) txtScaleDenominator.getValue()).doubleValue();

        txtPrintWidth.setValue(this.envelope.getLength(DIMENSIONS.X) / scaleDenominator);

        txtPrintHeight.setValue(this.envelope.getLength(DIMENSIONS.Y) / scaleDenominator);

        updatePixelSectionFromPrintSection();

        updateResultSize();

        updatingPrintSection = false;

    }

    protected void doChangeStateCmbResolution() {

        updatePixelSectionFromPrintSection();

        updateResultSize();

    }

    protected void doSelectForPrint() {

        enableComponents();

    }

    protected void doSelectByPixel() {

        enableComponents();

    }

    private void enableComponents() {

        // PixelSelection

        lblWidth.setEnabled(rdbPixelSelection.isSelected());

        txtWidth.setEnabled(rdbPixelSelection.isSelected());

        lblHeight.setEnabled(rdbPixelSelection.isSelected());

        txtHeight.setEnabled(rdbPixelSelection.isSelected());

        lblPixelSize.setEnabled(rdbPixelSelection.isSelected());

        txtPixelSize.setEnabled(rdbPixelSelection.isSelected());

        // PrintSelection

        lblPrintWidth.setEnabled(rdbPrintSelection.isSelected());

        txtPrintWidth.setEnabled(rdbPrintSelection.isSelected());

        lblPrintHeight.setEnabled(rdbPrintSelection.isSelected());

        txtPrintHeight.setEnabled(rdbPrintSelection.isSelected());

        lblScaleDenominator.setEnabled(rdbPrintSelection.isSelected());

        txtScaleDenominator.setEnabled(rdbPrintSelection.isSelected());

        lblResolution.setEnabled(rdbPrintSelection.isSelected());

        cmbResolution.setEnabled(rdbPrintSelection.isSelected());

    }

    protected void doAddRectangularSelectionTool() {

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

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

        }

        this.mapControl.addBehavior(VIEW_CLIP_TOOL_NAME, this.getBehavior());

        this.mapControl.setTool(VIEW_CLIP_TOOL_NAME);

    }

    private RectangleBehavior getBehavior() {

        if (this.behavior == null) {

            this.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 {

                    setEnvelope(event.getWorldCoordRect());

                }

            });

        }

        return this.behavior;

    }

    protected 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;

        updatePixelsSectionFromEnvelope();

    }

    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;

        }

        if (rdbPixelSelection.isSelected()) {

            updatePixelsSectionFromEnvelope();

        } else if (rdbPrintSelection.isSelected()) {

            updatePrintSectionFromEnvelope();

        }

    }

    protected void doChangedUpdatePixelSize() {

        if (updatingPixelSection) {

            return;

        }

        updatingPixelSection = true;

        double pixelSize = ((Number) this.txtPixelSize.getValue()).doubleValue();

        if (this.envelope != null) {

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

            txtHeight.setValue(Math.round(this.envelope.getLength(DIMENSIONS.Y) / pixelSize));

            updatePrintSectionFromPixelSection();

            updateResultSize();

        }

        updatingPixelSection = false;

    }

    private boolean updatePixelsSectionFromEnvelope() {

        this.envelope = calculateEnvelope();

        if (updatingPixelSection) {

            return false;

        }

        updatingPixelSection = true;

        double pixelSize = ((Number) txtPixelSize.getValue()).doubleValue();

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

        txtHeight.setValue(Math.round(this.envelope.getLength(DIMENSIONS.Y) / pixelSize));

        updatePrintSectionFromPixelSection();

        updateResultSize();

        updatingPixelSection = false;

        return true;

    }

    private boolean updatePrintSectionFromEnvelope() {

        this.envelope = calculateEnvelope();

        if (updatingPrintSection) {

            return false;

        }

        updatingPrintSection = true;

        double scaleDenominator = ((Number) txtScaleDenominator.getValue()).doubleValue();

        double printWidth = this.envelope.getLength(DIMENSIONS.X) / scaleDenominator;

        double printHeight = this.envelope.getLength(DIMENSIONS.Y) / scaleDenominator;

        txtPrintWidth.setValue(printWidth);

        txtPrintHeight.setValue(printHeight);

        updatePixelSectionFromPrintSection();

        updateResultSize();

        updatingPrintSection = false;

        return true;

    }

    /*

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

     */

    private Envelope calculateEnvelope() {

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

        if (rdbPixelSelection.isSelected()) {

            int width = ((Number) txtWidth.getValue()).intValue();

            int height = ((Number) txtHeight.getValue()).intValue();

            this.txtResultSize.setValue(width * height * BANDS);

        } else if (rdbPrintSelection.isSelected()) {

            int dpi = ((Integer) cmbResolution.getSelectedItem()).intValue();

            double dpcms = dpi / INCHES_TO_CENTIMETERS;

            double printWidth = ((Number) txtPrintWidth.getValue()).doubleValue();

            double printHeight = ((Number) txtPrintHeight.getValue()).doubleValue();

            this.txtResultSize.setValue(printWidth * dpcms * printHeight * dpcms * BANDS);

        }

    }

    private void updatePrintSectionFromPixelSection() {

        if (updatingPrintSection) {

            return;

        }

        updatingPrintSection = true;

        int width = ((Number) txtWidth.getValue()).intValue();

        int height = ((Number) txtHeight.getValue()).intValue();

        int dpi = ((Number) cmbResolution.getSelectedItem()).intValue();

        double dpcms = dpi / INCHES_TO_CENTIMETERS;

        double printWidth = width / dpcms;

        double printHeight = height / dpcms;

        double scaleDenominator = this.envelope.getLength(DIMENSIONS.X) / printWidth;

        txtPrintWidth.setValue(printWidth);

        txtPrintHeight.setValue(printHeight);

        txtScaleDenominator.setValue(scaleDenominator);

        updatingPrintSection = false;

    }

    private void updatePixelSectionFromPrintSection() {

        if (updatingPixelSection) {

            return;

        }

        updatingPixelSection = true;

        int dpi = ((Integer) cmbResolution.getSelectedItem()).intValue();

        double dpcms = dpi / INCHES_TO_CENTIMETERS;

        double printWidth = ((Number) txtPrintWidth.getValue()).doubleValue();

        double printHeight = ((Number) txtPrintHeight.getValue()).doubleValue();

        double width = printWidth * dpcms;

        double height = printHeight * dpcms;

        double pixelSize = this.envelope.getLength(DIMENSIONS.X) / width;

        txtPixelSize.setValue(pixelSize);

        txtWidth.setValue(width);

        txtHeight.setValue(height);

        updatingPixelSection = false;

    }

    @Override

    public void fetch(SaveBufferDialog saveBufferDialog) throws BufferException {

        envelope = calculateEnvelope();

        int width = ((Number) txtWidth.getValue()).intValue();

        int height = ((Number) txtHeight.getValue()).intValue();

        double pixelSize = ((Number) txtPixelSize.getValue()).intValue();

        double scaleDenominator = ((Number) txtScaleDenominator.getValue()).doubleValue();

        double scale = 1 / scaleDenominator;

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        BufferedImage image;

        image = toolsSwingManager.createBufferedImage(width, height, BufferedImage.TYPE_4BYTE_ABGR);

        Graphics2D g = image.createGraphics();

        MapContext mapContext = this.mapControl.getMapContext();

        MapContextManager mapContextManager = MapContextLocator.getMapContextManager();

        MapContextDrawer drawer;

        try {

            drawer = mapContextManager.createMapContextDrawerInstance(mapContext.getMapContextDrawer().getClass());

        } catch (ReadException | MapContextException e) {

            throw new BufferException(e);

        }

        drawer.setMapContext(mapContext);

        ViewPort viewPort;

        try {

            viewPort = (ViewPort) mapContext.getViewPort().clone();

        } catch (CloneNotSupportedException e) {

            throw new BufferException(e);

        }

        viewPort.setDist1pixel(pixelSize);

        viewPort.setImageSize(new Dimension(width, height));

        viewPort.setEnvelope(envelope);

        drawer.setViewPort(viewPort);

        try {

            drawer.draw(mapContext.getLayers(), image, g, new Cancellable() {

                /**

                 * @see org.gvsig.utils.swing.threads.Cancellable#isCanceled()

                 */

                public boolean isCanceled() {

                    return false;

                }

                public void setCanceled(boolean canceled) {

                    // Do nothing

                }

            }, scale);

        } catch (ReadException e) {

            throw new BufferException(e);

        }

        BufferManager bufferManager = BufferLocator.getBufferManager();

        Buffer buffer = null;

        try {

            buffer = bufferManager.createBufferFromAwtRaster(image.getRaster(), viewPort.getProjection(), envelope);

        } catch (IOException e1) {

            LOG.warn("Can't create buffer from view's image.", e1);

            return;

        }

        saveBufferDialog.setBuffer(buffer);

    }

}