Application: gvSIG desktop

package org.gvsig.fmap.mapcontrol.swing.pickercontroller.impl;

import org.gvsig.tools.swing.api.documentfilters.DoubleDocumentFilter;

import java.awt.Dimension;

import java.awt.Image;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.net.URL;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JTextField;

import javax.swing.JToggleButton;

import javax.swing.SwingConstants;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

import org.gvsig.fmap.mapcontrol.MapControl;

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

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

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

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

import org.gvsig.tools.IllegalValueException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

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

import org.gvsig.tools.swing.api.pickercontroller.AbstractPickerController;

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

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

/**

 *

 * @author jjdelcerro

 */

public class EnvelopePickerControllerImpl extends AbstractPickerController<Envelope>{

        public static void selfRegister() {

            IconThemeManager iconThemeManager = ToolsSwingLocator.getIconThemeManager();

            IconTheme theme = iconThemeManager.getCurrent();

            URL url = ScalePickerControllerImpl.class.getClassLoader().getResource("images/picker-envelope-cursor-capture.png");

            if( url != null ) {

                ImageIcon icon = new ImageIcon(url);

                theme.registerDefault("mapcontrol", "picker", "picker-envelope-cursor-capture", icon, url);

            }

            url = ScalePickerControllerImpl.class.getClassLoader().getResource("images/picker-envelope-capture.png");

            if( url != null ) {

                ImageIcon icon = new ImageIcon(url);

                theme.registerDefault("mapcontrol", "picker", "picker-envelope-capture", icon, url);

            }

            url = ScalePickerControllerImpl.class.getClassLoader().getResource("images/picker-envelope-from-mapcontrol.png");

            if( url != null ) {

                ImageIcon icon = new ImageIcon(url);

                theme.registerDefault("mapcontrol", "picker", "picker-envelope-from-mapcontrol", icon, url);

            }

    }

    private class CaptureEnvelopeListener implements RectangleListener  {

        @Override

        public void rectangle(EnvelopeEvent event) throws BehaviorException {

            set(event.getWorldCoordRect());

        }

        @Override

        public Image getImageCursor() {

            return captureCursor.getImage();

        }

        @Override

        public boolean cancelDrawing() {

            return false;

        }

    }

    private final MapControl mapControl;

    private final JTextField txtUpperLeftX;

    private final JTextField txtUpperLeftY;

    private final JTextField txtLowerRightX;

    private final JTextField txtLowerRightY;

    private final JTextField txtEnvelope;

    private final JButton btnMapControlEnvelope;

    private final JToggleButton btnCapture;

    private ImageIcon captureCursor;    

    private RectangleBehavior captureTool;

    private String previosTool;

    private Envelope envelope;

    public EnvelopePickerControllerImpl(

            MapControl mapControl,

            JTextField txtUpperLeftX, 

            JTextField txtUpperLeftY, 

            JTextField txtLowerRightX, 

            JTextField txtLowerRightY, 

            JButton btnMapControlEnvelope, 

            final JToggleButton btnCapture

        ) {

        this.mapControl = mapControl;

        this.txtEnvelope = null;

        this.txtUpperLeftX = txtUpperLeftX;

        this.txtUpperLeftY = txtUpperLeftY;

        this.txtLowerRightX = txtLowerRightX;

        this.txtLowerRightY = txtLowerRightY;

        this.btnMapControlEnvelope = btnMapControlEnvelope;

        this.btnCapture = btnCapture;

        this.initComponents();      

    }

    public EnvelopePickerControllerImpl(

            MapControl mapControl,

            JTextField txtEnvelope, 

            JButton btnMapControlEnvelope, 

            final JToggleButton btnCapture

        ) {

        this.mapControl = mapControl;

        this.txtEnvelope = txtEnvelope;

        this.txtUpperLeftX = null;

        this.txtUpperLeftY = null;

        this.txtLowerRightX = null;

        this.txtLowerRightY = null;

        this.btnMapControlEnvelope = btnMapControlEnvelope;

        this.btnCapture = btnCapture;

        this.initComponents();

    }

    private void initComponents() {

        this.captureCursor.setImage(this.getIcon("picker-envelope-cursor-capture").getImage());

        this.btnCapture.setIcon(this.getIcon("picker-envelope-cursor-capture"));

        this.btnMapControlEnvelope.setIcon(this.getIcon("picker-envelope-cursor-capture"));

        this.txtUpperLeftX.setHorizontalAlignment(SwingConstants.RIGHT);

        this.txtUpperLeftY.setHorizontalAlignment(SwingConstants.RIGHT);

        this.txtLowerRightX.setHorizontalAlignment(SwingConstants.RIGHT);

        this.txtLowerRightY.setHorizontalAlignment(SwingConstants.RIGHT);

        if( this.btnMapControlEnvelope!=null ) {

            this.btnMapControlEnvelope.addActionListener(new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent e) {

                    doSetEnvelopeToMapControlEnvelope();

                }

            });

        }

        this.btnCapture.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doCaptureEnvelope(btnCapture.isSelected());

            }

        });

        this.captureTool = new RectangleBehavior(new CaptureEnvelopeListener());

        this.mapControl.addBehavior("picker-envelope-capture", captureTool);

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

        if( this.txtEnvelope==null ) {

            this.txtUpperLeftX.setText("#########,00000");

            Dimension dim = this.txtUpperLeftX.getPreferredSize();

            this.txtUpperLeftX.setText("");

            this.txtUpperLeftX.setPreferredSize(dim);

            this.txtUpperLeftY.setPreferredSize(dim);

            this.txtLowerRightX.setPreferredSize(dim);

            this.txtLowerRightY.setPreferredSize(dim);

            DoubleDocumentFilter.install(this.txtUpperLeftX);

            DoubleDocumentFilter.install(this.txtUpperLeftY);

            DoubleDocumentFilter.install(this.txtLowerRightX);

            DoubleDocumentFilter.install(this.txtLowerRightY);

        } else {

            this.txtEnvelope.setEditable(false);

        }

    }

    protected void doSetEnvelopeToMapControlEnvelope() {

        if( !this.isEditable() ) {

            return;

        }

        try {

            Envelope theEnvelope = (Envelope) this.mapControl.getViewPort().getEnvelope().clone();

            this.set(theEnvelope);

        } catch (Exception ex) {

            LOG.warn("Can't get envelope from mapcontrol.", ex);

        }

    }

    protected void doCaptureEnvelope(boolean enabled) {

        if( !this.isEditable() ) {

            return;

        }

        if( enabled ) {

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

            this.mapControl.setTool("picker-envelope-capture");

        } else {

            this.mapControl.setTool(this.previosTool);

        }

    }

    protected String getEnvelopeAsString(Envelope value) {

        String s = String.format(

            "%+f, %+f, %+f, %+f",

            value.getMinimum(Geometry.DIMENSIONS.X), 

            value.getMaximum(Geometry.DIMENSIONS.Y),

            value.getMaximum(Geometry.DIMENSIONS.X), 

            value.getMinimum(Geometry.DIMENSIONS.Y)

        );

        return s;

    }

    @Override

    public boolean isValid() {

        if( this.txtEnvelope==null ) {

            if( !DoubleDocumentFilter.isValid(this.txtUpperLeftX) ) {

                return false;

            }

            if( !DoubleDocumentFilter.isValid(this.txtUpperLeftY) ) {

                return false;

            }

            if( !DoubleDocumentFilter.isValid(this.txtLowerRightX) ) {

                return false;

            }

            if( !DoubleDocumentFilter.isValid(this.txtLowerRightY) ) {

                return false;

            }

            return true;

        } else {

            return true;

        }

    }

    @Override

    public boolean isEmpty() {

        if( this.txtEnvelope==null ) {

            if( DoubleDocumentFilter.isEmpty(this.txtUpperLeftX) ) {

                return true;

            }

            if( DoubleDocumentFilter.isEmpty(this.txtUpperLeftY) ) {

                return true;

            }

            if( DoubleDocumentFilter.isEmpty(this.txtLowerRightX) ) {

                return true;

            }

            if( DoubleDocumentFilter.isEmpty(this.txtLowerRightY) ) {

                return true;

            }

            return false;

        } else {

            return this.envelope==null;

        }

    }

    @Override

    public Envelope get() {

        if( !this.isValid() ) {

            throw new IllegalValueException();

        }

        if( this.isEmpty() ) {

            return null;

        }

        if( this.txtEnvelope==null ) {

            try {

                double upperLeftX = DoubleDocumentFilter.getValue(this.txtUpperLeftX);

                double upperLeftY = DoubleDocumentFilter.getValue(this.txtUpperLeftY);

                double lowerRightX = DoubleDocumentFilter.getValue(this.txtLowerRightX);

                double lowerRightY = DoubleDocumentFilter.getValue(this.txtLowerRightY);

                GeometryManager geomManager = GeometryLocator.getGeometryManager();

                Point upperLeft = geomManager.createPoint(upperLeftX, upperLeftY, Geometry.SUBTYPES.GEOM2D);

                Point lowerRight = geomManager.createPoint(lowerRightX, lowerRightY, Geometry.SUBTYPES.GEOM2D);

                this.envelope.setUpperCorner(upperLeft);

                this.envelope.setLowerCorner(lowerRight);

            } catch (CreateGeometryException ex) {

                throw new GeometryRuntimeException("Can't create envelope", ex);

            }

        }

        return this.envelope;

    }

    @Override

    public void set(Envelope envelope) {

        try {

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

        } catch (CloneNotSupportedException ex) {

            throw new IllegalArgumentException("Can't use the envelope.", ex);

        }

        if( this.txtEnvelope==null ) {

            this.txtUpperLeftX.setText(String.format("%+f", envelope.getMinimum(DIMENSIONS.X)));

            this.txtUpperLeftY.setText(String.format("%+f", envelope.getMaximum(DIMENSIONS.Y)));

            this.txtLowerRightX.setText(String.format("%+f", envelope.getMaximum(DIMENSIONS.X)));

            this.txtLowerRightY.setText(String.format("%+f", envelope.getMinimum(DIMENSIONS.Y)));

        } else {

            this.txtEnvelope.setText(getEnvelopeAsString(this.envelope));

        }

    }

    @Override

    public void coerceAndSet(Object value) {

        DataType dataType = ToolsLocator.getDataTypesManager()

                .get(DataTypes.ENVELOPE);

        try {

            this.set((Envelope) dataType.coerce(value));

        } catch (CoercionException ex) {

            LOG.warn("Can't set value.", ex);

        }

    }

    @Override

    public void setEnabled(boolean enabled) {

        if( this.txtEnvelope==null ) {

            this.txtUpperLeftX.setEnabled(enabled);

            this.txtUpperLeftY.setEnabled(enabled);

            this.txtLowerRightX.setEnabled(enabled);

            this.txtLowerRightY.setEnabled(enabled);

        } else {

            this.txtEnvelope.setEnabled(enabled);

        }

        this.btnCapture.setEnabled(enabled);

        this.btnMapControlEnvelope.setEnabled(enabled);

    }

    @Override

    public boolean isEnabled() {

        if( this.txtEnvelope!=null ) {

            return this.txtEnvelope.isEnabled();

        }

        return true;

    }

    @Override

    public void setEditable(boolean editable) {

        super.setEditable(editable);

        if( this.txtEnvelope==null ) {

            this.txtUpperLeftX.setEditable(editable);

            this.txtUpperLeftY.setEditable(editable);

            this.txtLowerRightX.setEditable(editable);

            this.txtLowerRightY.setEditable(editable);

        } else {

            this.txtEnvelope.setEditable(editable);

        }

    }

}