Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2006 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 */

package org.gvsig.georeferencing.gui.panels;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Component;

import java.awt.Cursor;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Image;

import java.awt.Point;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.awt.event.MouseMotionListener;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import org.cresques.px.Extent;

import org.gvsig.georeferencing.gui.dialog.GeoreferencingDialog;

import org.gvsig.georeferencing.utils.GeoUtils;

import com.iver.andami.PluginServices;

import com.iver.cit.gvsig.fmap.DriverException;

import com.iver.cit.gvsig.fmap.ViewPort;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLayers;

import com.iver.cit.gvsig.fmap.layers.FLyrGeoRaster;

import com.iver.cit.gvsig.fmap.layers.FLyrPoints;

import com.iver.cit.gvsig.gui.View;

import com.iver.utiles.swing.threads.Cancellable;

/**

 * Panel que contiene los controles de zoom de la vista para

 * afinar en la georreferenciaci?n.

 *

 * @author Nacho Brodin (brodin_ign@gva.es)

 *

 */

public class ZoomControlPanel extends JPanel implements ActionListener{

        //**********************Vars**********************************

        public static final int                        WIDTH_MINIMG = 140;

        public static final int                        HEIGHT_MINIMG = 140;

        private JPanel                                         pImage = null;

        private JPanel                                         pControls = null;

        private JButton                                 bZoomMas = null;

        private JButton                                 bZoomMenos = null;

        private CanvasZone                                 canvas = null;

        private ViewPort                                 viewPort = null;

    public FLyrPoints                                 lyrPoints = null;

    public FLyrGeoRaster                         lyrGeoRaster = null;

    public GeoreferencingDialog         dialog = null;

    private boolean                                 rightControl = false;

    /**

         * Estado de los botones cuando se ejecuta disableAllControls

         */

        private boolean[]                                 buttonsState = new boolean[2];

        /**

         * DisableAllControls ha sido ejecutada si est? a true esta variabled

         */

        private boolean                                 disableAllControls = false;

        /**

         * Factor multiplicador cuando hacemos zoom mas

         */

        private double                                        zoomMas = 0.6;

        /**

         * Factor multiplicador cuando hacemos zoom menos

         */

        private double                                        zoomMenos = 1.8;

        //**********************End Vars******************************

        //**********************Methods*******************************

        /**

         * This is the default constructor

         */

        public ZoomControlPanel(boolean rightControl, GeoreferencingDialog dialog) {

                super();

                this.rightControl = rightControl;

                this.dialog = dialog;

                initialize(rightControl);

        }

        /**

         * This method initializes this

         *

         * @return void

         */

        private void initialize(boolean rightControl) {

        GridBagConstraints gridBagConstraints1 = new GridBagConstraints();

        if(rightControl)

                gridBagConstraints1.gridx = 1;

        else

                gridBagConstraints1.gridx = 0;

        gridBagConstraints1.gridy = 0;

        GridBagConstraints gridBagConstraints = new GridBagConstraints();

        if(rightControl)

                gridBagConstraints.gridx = 0;

        else

                gridBagConstraints.gridx = 1;

        gridBagConstraints.gridy = 0;

        this.setLayout(new GridBagLayout());

        this.setPreferredSize(new java.awt.Dimension(175,142));

        this.setSize(new java.awt.Dimension(175,142));

        this.setLocation(new java.awt.Point(0,0));

        this.add(getPImage(), gridBagConstraints);

        this.add(getPControls(), gridBagConstraints1);

        //Desactivamos el control en la inicializaci?n

        this.setEnabled(false);

        }

        /**

         * Carga las capas de puntos y de raster georreferenciado

         *

         */

        public void loadLayer() throws InstantiationException{

                //Cargamos las capas

                this.lyrGeoRaster = dialog.getLyrGeoRaster();

                this.lyrPoints = dialog.getLyrPoints();

                if(lyrGeoRaster == null || lyrPoints == null)

                        throw new InstantiationException("No se ha podido instanciar la capa de puntos o georreferenciada");

        }

        /**

         *Llama a la funci?n de pintado del canvas con los par?metros que tenga en ese momento

         */

        public void draw(){

                if(!getDialog().isEnlarge())

                        getCanvas().loadBuffer();

                canvas.draw = true;

                getCanvas().repaint();

        }

        /**

         * Manejo de los controles zoom m?s y zoom menos

         */

        public void actionPerformed(ActionEvent e) {

                double zoom = zoomMas;

                if(e.getSource() == bZoomMas)

                        canvas.calcZoom(zoomMas);

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

                        canvas.calcZoom(zoomMenos);

                        zoom = zoomMenos;

                }

                canvas.draw = true;

                canvas.repaint();

                if(isRightControl())

                        lyrPoints.getPoint(dialog.getSelectedPoint()).zoomLeft *= zoom;

                else

                        lyrPoints.getPoint(dialog.getSelectedPoint()).zoomRight *= zoom;

        }

    /**

     *Limpia el canvas

     */

    public void clear(){

            canvas.setCleanCanvas(true);

            canvas.repaint();

    }

    /**

         * Esta funci?n deshabilita todos los controles y guarda sus valores

         * de habilitado o deshabilitado para que cuando se ejecute restoreControlsValue

         * se vuelvan a quedar como estaba

         */

        public void disableAllControls(){

                if(!disableAllControls){

                        disableAllControls = true;

                        //Salvamos los estados

                        buttonsState[0] = getBZoomMas().isEnabled();

                        buttonsState[1] = getBZoomMenos().isEnabled();

                        //Desactivamos controles

                        getBZoomMas().setEnabled(false);

                        getBZoomMenos().setEnabled(false);

                }

        }

        /**

         * Esta funci?n deja los controles como estaban al ejecutar la funci?n

         * disableAllControls

         */

        public void restoreControlsValue(){

                if(disableAllControls){

                        disableAllControls = false;

                        getBZoomMas().setEnabled(buttonsState[0]);

                        getBZoomMenos().setEnabled(buttonsState[1]);

                }

        }

        //**********************End Methods***************************

    //**********************Setters & Getters*********************

    /**

         * @param viewPort The viewPort to set.

         */

        public void setViewPort(ViewPort viewPort, double zoom) {

                this.viewPort = viewPort;

                getCanvas().setViewPort(this.viewPort, zoom);

        }

        /**

         * This method initializes jPanel

         *

         * @return javax.swing.JPanel

         */

        private JPanel getPImage() {

                if (pImage == null) {

                        pImage = new JPanel();

                        BorderLayout borderLayout = new BorderLayout();

                        pImage.setLayout(borderLayout);

                        pImage.setPreferredSize(new java.awt.Dimension(140,140));

                        pImage.setBorder(javax.swing.BorderFactory.createBevelBorder(javax.swing.border.BevelBorder.LOWERED));

                        pImage.add(getCanvas(), BorderLayout.CENTER);

                }

                return pImage;

        }

        /**

         * This method initilizes canvas

         * @return        CanvasZone

         */

        public CanvasZone getCanvas(){

                if(canvas == null){

                        canvas = new CanvasZone(ZoomControlPanel.WIDTH_MINIMG, ZoomControlPanel.HEIGHT_MINIMG, this);

                        canvas.setVisible(false);

                        canvas.addMouseListener(canvas);

                        canvas.addMouseMotionListener(canvas);

                }

                return canvas;

        }

        /**

         * This method initializes jPanel1

         *

         * @return javax.swing.JPanel

         */

        private JPanel getPControls() {

                if (pControls == null) {

                        GridBagConstraints gridBagConstraints3 = new GridBagConstraints();

                        gridBagConstraints3.gridx = 0;

                        gridBagConstraints3.insets = new java.awt.Insets(5,0,0,0);

                        gridBagConstraints3.gridy = 1;

                        GridBagConstraints gridBagConstraints2 = new GridBagConstraints();

                        gridBagConstraints2.gridx = 0;

                        gridBagConstraints2.gridy = 0;

                        pControls = new JPanel();

                        pControls.setLayout(new GridBagLayout());

                        pControls.setPreferredSize(new java.awt.Dimension(33,140));

                        pControls.add(getBZoomMas(), gridBagConstraints2);

                        pControls.add(getBZoomMenos(), gridBagConstraints3);

                }

                return pControls;

        }

        /**

         * This method initializes jButton

         *

         * @return javax.swing.JButton

         */

        public JButton getBZoomMas() {

                if (bZoomMas == null) {

                        bZoomMas = new JButton();

                        bZoomMas.setPreferredSize(new java.awt.Dimension(25,25));

                        try{

                                bZoomMas.setIcon(new ImageIcon(getClass().getClassLoader().getResource("images/aumentar.png")));

                        }catch(NullPointerException e){

                                //Sin icono

                        }

                        bZoomMas.addActionListener(this);

                }

                return bZoomMas;

        }

        /**

         * This method initializes jButton

         *

         * @return javax.swing.JButton

         */

        public JButton getBZoomMenos() {

                if (bZoomMenos == null) {

                        bZoomMenos = new JButton();

                        bZoomMenos.setPreferredSize(new java.awt.Dimension(25,25));

                        try{

                                bZoomMenos.setIcon(new ImageIcon(getClass().getClassLoader().getResource("images/disminuir.png")));

                        }catch(NullPointerException e){

                                //Sin icono

                        }

                        bZoomMenos.addActionListener(this);

                }

                return bZoomMenos;

        }

        /**

         * Obtiene true si se trata de un control con los botones de zoom

         * a la derecha y false si los tiene a la izquierda.

         * @return Returns the rightControl.

         */

        public boolean isRightControl() {

                return rightControl;

        }

        /**

         * Obtiene la capa de imagen georreferenciada.

         * @return Returns the lyrGeoRaster.

         */

        public FLyrGeoRaster getLyrGeoRaster() {

                return lyrGeoRaster;

        }

        /**

         * Obtiene la capa de puntos.

         * @return Returns the lyrPoints.

         */

        public FLyrPoints getLyrPoints() {

                try{

                if(lyrPoints == null)

                        this.loadLayer();

                }catch(InstantiationException e){

                        JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),

                                        PluginServices.getText(this, "error_capa_puntos"));

                }

                return lyrPoints;

        }

        /**

         * @return Returns the dialog.

         */

        public GeoreferencingDialog getDialog() {

                try{

                        if(dialog == null)

                                this.loadLayer();

                }catch(InstantiationException e){

                        JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),

                                        PluginServices.getText(this, "error_capa_puntos"));

                }

                return dialog;

        }

    /**

     * Asigna el viewPort recalculado

     * @param vp ViewPort

     */

    public void setNewViewPort(ViewPort vp){

            canvas.setNewViewPort(vp);

    }

    /**

     * Obtiene el viewPort recalculado

     * @return vp ViewPort

     */

    public ViewPort getNewViewPort(){

            return canvas.getNewViewPort();

    }

        /**

         * Asigna al canvas la propiedad de visibilidad a verdadero o falso.

         * @param visible true para mostrar el canvas y false para ocultarlo

         */

        public void setVisible(boolean visible){

                canvas.setVisible(visible);

                canvas.draw = true;

                canvas.repaint();

        }

        /**

         * Asigna el punto sobre el que se centrar? el zoom de la minimagen

         * @param pto

         */

        public void setCenterPoint(Point2D pto){

                getCanvas().setCenterPoint(pto);

        }

        /**

         * Recupera el n?mero de punto que se est? tratando

         * @param n

         */

        public int getNumberPoint(){

                try{

                        if(getDialog().getConectorPanel().getDataPointsTabPanel().getTbPoints().getSelectedIndex() == 0)

                                return Integer.valueOf(getDialog().getConectorPanel().getDataPointsTabPanel().getSelectPointsPanel().getTableControlerPanel().getCPoint().getSelectedItem().toString()).intValue() - 1;

                        else

                                return Integer.valueOf(getDialog().getConectorPanel().getDataPointsTabPanel().getTablePointsPanel().getTableControlerPanel().getCPoint().getSelectedItem().toString()).intValue() - 1;

                }catch(NullPointerException exc){

                        return -1;

                }

        }

        /**

     * Activa o desactiva este panel y todos los que lo componen

     * @param enabled variable booleana para la activaci?n y/o desactivaci?n

     */

    public void setEnabled(boolean enabled){

            this.getBZoomMas().setEnabled(enabled);

            this.getBZoomMenos().setEnabled(enabled);

            this.getCanvas().setEnableEvent(enabled);

    }

    /**

     * Obtiene el modificador de escala aplicado a zoom m?s

     * @return

     */

    public double getZoomMas() {

                return zoomMas;

        }

    /**

     * Obtiene el modificador de escala aplicado a zoom m?s

     * @return

     */

    public double getZoomMenos() {

                return zoomMenos;

        }

        //**********************End Setters & Getters*****************

        /**

         * Control que representa la zona de dibujado de la ventana. Este se encarga de

         * repintar el contenido sobre el Graphics2D a partir del viewPort que se le pase

         * @author Nacho Brodin (brodin_ign@gva.es)

         */

        public class CanvasZone extends JPanel implements MouseListener, MouseMotionListener{

                //**********************Params********************************

                /**

                 * Zoom inicial de la miniimagen

                 */

                private int                                 initZoom = 20;

                //**********************End Params****************************

                //**********************Vars**********************************

                private ZoomControlPanel         zoomControl = null;

            private int                                 ancho;

            private int                                 alto;

            private FLayers                         flayers = null;

            private ViewPort                         newViewPort = null;

            private Point2D                         centerPoint = null;

            private Image                                 dobleBuffer = null;

            private BufferedImage                 imgTmp = null;

            private Graphics                         dbGraphics = null;

            /**

             * Variable que estar? a true cuando queremos limpiar el canvas y a false cuando queremos

             * dibujar las capas.

             */

            private boolean                         cleanCanvas = false;

            /**

             * Cuando el control est? desactivado necesitamos controlar con esta variable que

             * aunque se pinche sobre el canvas no se capture el evento

             */

            private boolean                                enableEvent = true;

            private Point2D                         initCrux = null;

            /**

             * Variable que esta a true si estamos arrastrando la cruz por el canvas.

             */

            private boolean                         dragged = false;

            private Image                                 redCursor = null;

            private Image                                 blueCursor = null;

            /**

             * Esta variable se usa para informar cuando debe recargarse el buffer de las miniimagenes. Si siempre

             * est? a true no para de llamar al draw de FLyers para que pinte sobre el minicanvas.

             */

            public boolean                                draw = true;

            /**

             * Esta variable estar? a false si no queremos que no se pinte la capa de puntos rojos sobre

             * la miniimagenes

             */

            private boolean                         drawRedCrux = true;

            /**

             * Esta variable estar? a false si no queremos que no se pinte la capa de puntos azules sobre

             * la miniimagenes

             */

            private boolean                         drawBlueCrux = true;

                //**********************End Vars******************************

            //**********************Classes*******************************

            class CancellableClass implements Cancellable{

                    private boolean cancel = false;

                       public void setCanceled(boolean canceled) {

                               this.cancel = canceled;

                       }

                        public boolean isCanceled() {

                                return this.cancel;

                        }

               }

            //**********************End Classes***************************

            //**********************Methods*******************************

            /**

             *

             */

            public CanvasZone( int anc,int alt, ZoomControlPanel zc) {

                    zoomControl = zc;

                ancho = anc;

                alto = alt;

                if(redCursor == null){

                        try{

                                redCursor = new ImageIcon(getClass().getClassLoader().getResource("images/icoRed.png")).getImage();

                        }catch(NullPointerException e){

                                        //Sin icono

                                }

                }

                if(blueCursor == null){

                        try{

                                blueCursor = new ImageIcon(getClass().getClassLoader().getResource("images/icoBlue.png")).getImage();

                        }catch(NullPointerException e){

                                        //Sin icono

                                }

                }

                this.setSize(ancho, alto);

                this.setBackground(Color.WHITE);

                imgTmp = new BufferedImage(this.ancho, this.alto, BufferedImage.TYPE_INT_ARGB);

                dobleBuffer = new BufferedImage(this.ancho, this.alto, BufferedImage.TYPE_INT_ARGB);

                dbGraphics = dobleBuffer.getGraphics();

            }

            /**

             * Calcula el zoom dependiendo del factor de escala pasado por

             * par?metro.

             */

            public void calcZoom(double factor){

                    Rectangle2D.Double r = new Rectangle2D.Double();

                        double nuevoX = centerPoint.getX() -

                                ((newViewPort.getExtent().getWidth() * factor) / 2.0);

                        double nuevoY = centerPoint.getY() -

                                ((newViewPort.getExtent().getHeight() * factor) / 2.0);

                        r.x = nuevoX;

                        r.y = nuevoY;

                        r.width = newViewPort.getExtent().getWidth() * factor;

                        r.height = newViewPort.getExtent().getHeight() * factor;

                        newViewPort.setExtent(r);

                        newViewPort.refreshExtent();

                }

            /**

             * Calculamos el viewPort para el zoom de la minimagen

             * @param vp                ViewPort inicial

             * @param center        Centro del ViewPort a calcular.

             * @param vpDest        ViewPort de destino. Si este es null se crear? un nuevo ViewPort sino se asignar?n los cambios a este.

             * @return

             */

            public ViewPort initViewPort(ViewPort vp, Point2D center, ViewPort vpDest, double zoom){

                    if(center != null){

                        //Hallamos la relaci?n entre el pixel y las WC a partir de la imagen de la capa

                                double relacionPixelWcWidth =  ((vp.getExtent().getMaxX() - vp.getExtent().getMinX()) / initZoom) / ancho;

                                double relacionPixelWcHeight = ((vp.getExtent().getMaxY() - vp.getExtent().getMinY()) / initZoom) / alto;

                                double wcOriginX = center.getX() - ((vp.getImageWidth() * relacionPixelWcWidth) / 2);

                                double wcOriginY = center.getY() - ((vp.getImageHeight() * relacionPixelWcHeight) / 2);

                                double wcDstMinX = wcOriginX;

                                double wcDstMinY = wcOriginY;

                                double wcDstMaxX = wcDstMinX + (vp.getImageWidth()*relacionPixelWcWidth);

                                double wcDstMaxY = wcDstMinY + (vp.getImageHeight()*relacionPixelWcHeight);

                                double wcDstWidth = wcDstMaxX - wcDstMinX;

                                double wcDstHeight = wcDstMaxY - wcDstMinY;

                        Rectangle2D ext = new Rectangle2D.Double(wcDstMinX, wcDstMinY, wcDstWidth, wcDstHeight);

                        if(vpDest == null){

                                    newViewPort = vp.cloneViewPort();

                                newViewPort.setExtent(ext);

                                newViewPort.setImageSize(new java.awt.Dimension(ancho, alto));

                                newViewPort.refreshExtent();

                                if(zoom != 1 && zoom != 0)

                                        newViewPort = GeoUtils.calcZoom(newViewPort, zoom);

                                return newViewPort;

                            }else{

                                    vpDest.setExtent(ext);

                                    vpDest.refreshExtent();

                                    if(zoom != 1 && zoom != 0)

                                        vpDest = GeoUtils.calcZoom(vpDest, zoom);

                                    return vpDest;

                            }

                    }

                    return null;

            }

            /**

             * Dibuja sobre el graphics de la mini imagen la imagen

             * definida en el newViewPort.

             */

            public void loadBuffer(){

                    Graphics2D gTmp = (Graphics2D)imgTmp.getGraphics();

                    dbGraphics.setColor( Color.WHITE );

                    dbGraphics.fillRect( 0,0,ancho,alto );

                    gTmp.setColor( Color.WHITE );

                        gTmp.fillRect( 0,0,ancho,alto );

                    try{

                             if(newViewPort != null){

                                       //Si no tenemos las capas las cargamos

                                       if(flayers == null){

                                               View  theView = null;

                                    try{

                                            theView = (View)PluginServices.getMDIManager().getActiveWindow();

                                    }catch(ClassCastException exc){

                                            return;

                                    }

                                         flayers = theView.getMapControl().getMapContext().getLayers();

                                }

                                /*Dibujamos sobre las miniimagenes

                                       Forzamos un draw de las capas para dibujar la vista sobre el control de las miniimagenes.

                                       Como la capa gr?fica est? en FMap esta no aparece en el dibujado de FLayers por los que

                                       forzaremos el pintado tambi?n de la capa de puntos sobre nuestro control*/

                                       Cancellable cancellable = new CancellableClass();

                                if(zoomControl.getDialog().isEnlarge()){

                                        if(zoomControl.getNumberPoint() != -1){

                                                       draw(new BufferedImage(newViewPort.getImageWidth(), newViewPort.getImageHeight(), BufferedImage.TYPE_INT_ARGB),

                                                                (Graphics2D) dbGraphics,

                                                                newViewPort,

                                                                cancellable ,

                                                                flayers.getMapContext().getScaleView());

                                                       if(zoomControl.isRightControl()){

                                                               if(drawRedCrux)

                                                                       zoomControl.getLyrPoints().drawPixelCrux((Graphics2D) dbGraphics, newViewPort, cancellable);

                                                       }else{

                                                            if(drawBlueCrux)

                                                                       zoomControl.getLyrPoints().drawMapCrux((Graphics2D) dbGraphics, newViewPort, cancellable);

                                                       }

                                        }

                                }

                                draw(new BufferedImage(newViewPort.getImageWidth(), newViewPort.getImageHeight(), BufferedImage.TYPE_INT_ARGB),

                                         gTmp,

                                         newViewPort,

                                         cancellable,

                                         flayers.getMapContext().getScaleView());

                                            if(zoomControl.isRightControl()){

                                                    if(drawRedCrux)

                                                            zoomControl.getLyrPoints().drawPixelCrux(gTmp, newViewPort, cancellable);

                                            }else{

                                                    if(drawBlueCrux)

                                                            zoomControl.getLyrPoints().drawMapCrux(gTmp, newViewPort, cancellable);

                                            }

                               }

                     }catch (DriverException e) {

                                e.printStackTrace();

                     }

            }

            /**

             * Esta funci?n es una copia de la de Flyers modificada para para dibujar sobre las miniimagenes. En

             * la miniimagen con los controles a la derecha solo dibujar? el raster a georreferenciar. En la miniimagen

             * con los controles a la izquierda dibujar? la cartograf?a de base.

             * @param image

             * @param g

             * @param viewPort

             * @param cancel

             * @param scale

             * @throws DriverException

             */

            public void draw(BufferedImage image, Graphics2D g, ViewPort viewPort,

                            Cancellable cancel,double scale) throws DriverException {

                    for(int i=0;i<flayers.getLayersCount();i++){

                            if (cancel.isCanceled())

                                    break;

                            FLayer lyr = flayers.getLayer(i);

                                    try{

                                            if(zoomControl.isRightControl()){

                                                    if(lyr instanceof FLyrGeoRaster)

                                                            lyr.draw(image, g, viewPort, cancel,scale);

                                            }else{

                                                    if (lyr.isVisible()){

                                                            if(!(lyr instanceof FLyrGeoRaster))

                                                                    lyr.draw(image, g, viewPort, cancel,scale);

                                                    }

                                            }

                                    } catch (DriverException e){

                                    }

                    }

            }

            /**

             *

             */

            public void update(Graphics g){

                    draw = true;

                    this.paint(g);

            }

            /**

             * Dibuja sobre el Graphics2D pasado el viewPort solicitado a

             * la lista de capas.

             * @param g

             */

            public void paint( Graphics g ) {

                    if(!cleanCanvas){

                            if(draw){

                                    loadBuffer();

                                    draw = false;

                            }

                            g.drawImage(dobleBuffer, 0, 0, null);

                            this.invalidate();

                            AdjustGeorefPanel p = zoomControl.getDialog().getConectorPanel().getAdjustGeorefPanel();

                            try{

                                    if(!this.zoomControl.isRightControl())

                                            p.setLZoomLeft("1:"+((int)newViewPort.getScale()));

                                    else

                                            p.setLZoomRight("1:"+((int)newViewPort.getScale()));

                            }catch(NullPointerException exc){

                                    //No ponemos la escala

                            }

                    }else{

                            dbGraphics.setColor( Color.WHITE );

                            dbGraphics.fillRect( 0,0,ancho,alto );

                            g.setColor( Color.WHITE );

                            g.fillRect( 0,0,ancho,alto );

                            cleanCanvas = false;

                    }

            }

                /* (non-Javadoc)

                 * @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)

                 */

                public void mouseClicked(MouseEvent ev) {

                }

                /**

                 * Cuando el rat?n entra dentro del control fijamos el valor de las coordenadas

                 * que tiene el punto seleccionado. De esta forma cuando salga del control podr?

                 * volver a restaurarlo en caso de que no haya sido cambiado.

                 */

                public void mouseEntered(MouseEvent arg0) {

                        if(isEnableEvent()){

                                if(!zoomControl.rightControl)

                                        zoomControl.getDialog().getPointManager().setCurrentWC();

                                else

                                        zoomControl.getDialog().getPointManager().setCurrentPixelCoord();

                        }

                }

                /**

                 * Al sacar el rat?n de la zona de dibujado de la miniimagen restauramos los valores

                 * de los JTextField.

                 *

                 * Se actualizaran los correspondientes a las coordenadas del mundo real

                 * en el caso de que el control tenga botones a la izquierda.

                 *

                 * Se actualizaran los correspondientes a las coordenadas en pixels cuando se trata del control con

                 * botones a la derecha.

                 */

                public void mouseExited(MouseEvent arg0) {

                        if(isEnableEvent()){

                                if(!zoomControl.rightControl)

                                        zoomControl.getDialog().getPointManager().replaceWC();

                                else

                                        zoomControl.getDialog().getPointManager().replacePixelCoord();

                                drawRedCrux = drawBlueCrux = true;

                                repaint();

                        }

                }

                /**

                 * Controla la actualizaci?n del valor de un punto en los JTextDialog. Cuando se mueve sobre

                 * el panel con controles a la izquierda actualizamos las coordenadas del mapa. Cuando se mueve sobre

                 * el panel con controles a la derecha actualizamos las coordenadas de la imagen.

                 */

                public void mouseMoved(MouseEvent arg0) {

                        if(        isEnableEvent() &&

                                zoomControl.getLyrPoints() != null &&

                                zoomControl.getLyrPoints().getCountPoints() > 0 &&

                                this.newViewPort != null &&

                                this.newViewPort.getExtent() != null){

                                double newWCPointX = this.newViewPort.getExtent().getMinX() + ((arg0.getX() * this.newViewPort.getExtent().getWidth()) / this.getWidth());

                                int ptoSelectY = (int)(this.getHeight() - arg0.getY());

                                double newWCPointY = this.newViewPort.getExtent().getMinY() + ((ptoSelectY * this.newViewPort.getExtent().getHeight()) / this.getHeight());

                                if(!zoomControl.rightControl){

                                        zoomControl.getDialog().getPointManager().setTempWC(newWCPointX, newWCPointY);

                                }else{

                                        Point2D pixelImg = zoomControl.getLyrGeoRaster().world2Img(newWCPointX, newWCPointY);

                                        if(pixelImg != null)

                                                zoomControl.getDialog().getPointManager().setTempPixelCoord(pixelImg.getX(), pixelImg.getY());

                                        else

                                                //Si pixelImg es null es que nos hemos salido de la imagen por lo que reponemos los valores originales hasta que vuelva a entrar.

                                                zoomControl.getDialog().getPointManager().replacePixelCoord();

                                }

                        }

                }

                /**

                 * Al pulsar el rat?n sobre la minimagen permitimos que se pueda desplazar la cruz

                 *

                 */

                public void mousePressed(MouseEvent ev) {

                        int cte = 10;

                        if( (ev.getX() > ((getWidth() >> 1) - cte)) && (ev.getX() < ((getWidth() >> 1) + cte)) &&

                                (ev.getY() > ((getHeight() >> 1) - cte)) && (ev.getY() < ((getHeight() >> 1) + cte))){

                                this.dragged = true;

                                try{

                                        if(zoomControl.isRightControl()){

                                                drawRedCrux = false;

                                                setCursor(Toolkit.getDefaultToolkit().createCustomCursor(redCursor, new Point(16, 16), ""));

                                        }else{

                                                drawBlueCrux = false;

                                                setCursor(Toolkit.getDefaultToolkit().createCustomCursor(blueCursor, new Point(16, 16), ""));

                                        }

                                        zoomControl.loadLayer();

                                        initCrux = new Point2D.Double();

                                        initCrux.setLocation(this.getWidth() / 2, this.getHeight() / 2);

                                    draw = true;

                                        repaint();

                                }catch(InstantiationException e){

                                        JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),

                                                        PluginServices.getText(this, "error_capa_puntos"));

                                }

                        }

                }

                /* (non-Javadoc)

                 * @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)

                 */

                public void mouseReleased(MouseEvent ev) {

                        if(!dragged)

                                return;

                        dragged = false;

                        View  theView = null;

                        try{

                                theView = (View) PluginServices.getMDIManager().getActiveWindow();

                        }catch(ClassCastException exc){

                                return;

                        }

                        ViewPort viewPort = theView.getMapControl().getMapContext().getViewPort();

                        setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

                        Point2D point = newViewPort.toMapPoint(ev.getX(), ev.getY());

                        int nPoint = Integer.valueOf(zoomControl.getDialog().getSelectPointsPanel().getTableControlerPanel().getCPoint().getSelectedItem().toString()).intValue();

                        FLyrPoints lp = zoomControl.getLyrPoints();//(FLyrPoints)lyr;

                if(zoomControl.isRightControl()){ //Control de actualizaci?n de pixel de imagen

                        Point2D pixelImg = zoomControl.getLyrGeoRaster().world2Img(point);

                        //Point2D pixelImg = zoomControl.getLyrGeoRaster().world2Img(newWCPointX, newWCPointY);

                        if(pixelImg == null){

                                JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),

                                                                     PluginServices.getText(this, "fuera_de_extent"));

                                     return;

                             }

                        zoomControl.getDialog().getPointManager().updateData(        nPoint, pixelImg, null,

                                                                                                                                         zoomControl.getDialog(), null);

                        setCenterPoint(point);

                        newViewPort = GeoUtils.shiftExtent(lyrPoints.getCenterPoint(dialog.getSelectedPoint(), false), point, lyrPoints.getMiniExtent(dialog.getSelectedPoint(), false));

                        lyrPoints.setMiniExtent(nPoint - 1, point, newViewPort, false);

                        calcZoom(lyrPoints.getZoomLeft(dialog.getSelectedPoint()));

                        zoomControl.getDialog().getPointManager().setCurrentPixelCoord();

                }else{ //Control de actualizaci?n de coordenadas del mundo

                                zoomControl.getDialog().getPointManager().updateData(        nPoint, null, point,

                                                                                                                                                        zoomControl.getDialog(), null);

                                setCenterPoint(point);

                                newViewPort = GeoUtils.shiftExtent(lyrPoints.getCenterPoint(dialog.getSelectedPoint(), true), point, lyrPoints.getMiniExtent(dialog.getSelectedPoint(), true));

                                lyrPoints.setMiniExtent(nPoint - 1, point, newViewPort, true);

                                calcZoom(lyrPoints.getZoomRight(dialog.getSelectedPoint()));

                                zoomControl.getDialog().getPointManager().setCurrentWC();

                 }

                dialog.getConectorPanel().getAdjustGeorefPanel().getZoomLeft().draw();

                dialog.getConectorPanel().getAdjustGeorefPanel().getZoomRight().draw();

                    draw = true;

                    drawRedCrux = drawBlueCrux = true;

                        repaint();

                        theView.getMapControl().getMapContext().invalidate();

                }

                /* (non-Javadoc)

                 * @see java.awt.event.MouseMotionListener#mouseDragged(java.awt.event.MouseEvent)

                 */

                public void mouseDragged(MouseEvent ev) {

                        this.mouseMoved(ev);

                }

            //**********************End Methods***************************

                //**********************Setters & Getters*********************

                /**

                 * @param cleanCanvas The cleanCanvas to set.

                 */

                public void setCleanCanvas(boolean cleanCanvas) {

                        this.cleanCanvas = cleanCanvas;

                }