| gvSIG desktop 1

package com.iver.cit.gvsig.fmap;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ComponentEvent;

import java.awt.event.ComponentListener;

import java.awt.image.BufferedImage;

import java.util.HashMap;

import javax.swing.JComponent;

import javax.swing.Timer;

import com.iver.cit.gvsig.fmap.drivers.DriverIOException;

import com.iver.cit.gvsig.fmap.operations.Cancellable;

import com.iver.cit.gvsig.fmap.tools.Behavior.MapTool;

import com.iver.cit.gvsig.fmap.tools.Listeners.ToolListener;

/**

 * DOCUMENT ME!

 *

 * @author Fernando Gonz?lez Cort?s

 */

public class NewMapControl extends JComponent implements ComponentListener {

    /** DOCUMENT ME! */

    public static final int ACTUALIZADO = 0;

    /** DOCUMENT ME! */

    public static final int DESACTUALIZADO = 1;

    private FMap mapContext = null;

    private HashMap namesMapTools = new HashMap();

    private HashMap namesMapToolsNames = new HashMap();

    private MapTool currentMapTool = null;

    private int status = ACTUALIZADO;

    private BufferedImage image = null;

    private String currentTool;

    private CancelDraw canceldraw;

    private boolean isCancelled = true;

    private Timer timer;

    private ViewPort vp;

    private Color backColor = Color.WHITE;

    /**

     * Crea un nuevo NewMapControl.

     */

    public NewMapControl() {

        setDoubleBuffered(true);

        //Clase usada para cancelar el dibujado

        canceldraw = new CancelDraw();

        //Modelo de datos y ventana del mismo

        vp = new ViewPort();

        mapContext = new FMap(vp);

        //eventos

        this.addComponentListener(this);

        //Timer para mostrar el redibujado mientras se dibuja

        timer = new Timer(300, new ActionListener() {

                        public void actionPerformed(ActionEvent e) {

                                NewMapControl.this.repaint();

                        }

                });

    }

    /**

     * DOCUMENT ME!

     *

     * @param model DOCUMENT ME!

     */

    public void setMapContext(FMap model) {

        mapContext = model;

        mapContext.setViewPort(vp);

    }

    /**

     * DOCUMENT ME!

     *

     * @return

     */

    public FMap getMapContext() {

        return mapContext;

    }

    /**

     * Registra una herramienta (tool).

     *

     * @param name DOCUMENT ME!

     * @param tool

     */

    public void addMapTool(String name, MapTool tool) {

        namesMapTools.put(name, tool);

        tool.setMapControl(this);

    }

    /**

     * DOCUMENT ME!

     *

     * @param toolName DOCUMENT ME!

     * @param mapToolName DOCUMENT ME!

     * @param tl DOCUMENT ME!

     */

    public void addTool(String toolName, String mapToolName, ToolListener tl) {

        namesMapToolsNames.put(toolName, mapToolName);

        MapTool mt = (MapTool) namesMapTools.get(mapToolName);

        mt.setListener(tl);

    }

    /**

     * DOCUMENT ME!

     *

     * @param toolName DOCUMENT ME!

     */

    public void setTool(String toolName) {

        if (currentMapTool != null) {

            this.removeMouseListener(currentMapTool);

            this.removeMouseMotionListener(currentMapTool);

            this.removeMouseWheelListener(currentMapTool);

        }

        String mapToolName = (String) namesMapToolsNames.get(toolName);

        MapTool mapTool = (MapTool) namesMapTools.get(mapToolName);

        currentMapTool = mapTool;

        currentTool = toolName;

        this.addMouseListener(currentMapTool);

        this.addMouseMotionListener(currentMapTool);

        this.addMouseWheelListener(currentMapTool);

    }

    /**

     * DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     */

    public String getTool() {

        return currentTool;

    }

    /**

     * Cancelar el dibujado.

     */

    public void cancelDrawing() {

        //TODO Implementar el cancelado bien

        canceldraw.setCancel(true);

    }

    /**

     * @see javax.swing.JComponent#paintComponent(java.awt.Graphics)

     */

    protected void paintComponent(Graphics g) {

        if (status == ACTUALIZADO) {

            if (currentMapTool != null) {

                currentMapTool.paintComponent(g);

            }

        } else if (status == DESACTUALIZADO) {

            image = new BufferedImage(this.getWidth(), this.getHeight(),

                    BufferedImage.TYPE_INT_ARGB);

            image.getGraphics().setColor(backColor);

            image.getGraphics().fillRect(0,0,image.getWidth(), image.getHeight());

            g.setColor(backColor);

            g.fillRect(0,0,image.getWidth(), image.getHeight());

            cancelDrawing();

            while (!isCancelled) {

            }

            isCancelled = false;

            Drawer drawer = new Drawer(image, (Graphics2D) image.getGraphics(),

                    canceldraw);

            drawer.start();

            timer.start();

            status = ACTUALIZADO;

        }

    }

    /**

     * DOCUMENT ME!

     *

     * @return

     */

    public BufferedImage getImage() {

        return image;

    }

    /**

     * DOCUMENT ME!

     */

    public void drawMap() {

        status = DESACTUALIZADO;

        repaint();

    }

    /**

     * @see java.awt.event.ComponentListener#componentHidden(java.awt.event.ComponentEvent)

     */

    public void componentHidden(ComponentEvent e) {

    }

    /**

     * @see java.awt.event.ComponentListener#componentMoved(java.awt.event.ComponentEvent)

     */

    public void componentMoved(ComponentEvent e) {

    }

    /**

     * @see java.awt.event.ComponentListener#componentResized(java.awt.event.ComponentEvent)

     */

    public void componentResized(ComponentEvent e) {

        getMapContext().getViewPort().setImageSize(new Dimension(getWidth(),

                getHeight()));

        drawMap();

    }

    /**

     * @see java.awt.event.ComponentListener#componentShown(java.awt.event.ComponentEvent)

     */

    public void componentShown(ComponentEvent e) {

    }

    /**

     * DOCUMENT ME!

     *

     * @author Vicente Caballero Navarro

     */

    public class Drawer extends Thread {

        private Graphics g;

        private BufferedImage image;

        private CancelDraw cancel;

        private boolean threadCancel = false;

        /**

         * Crea un nuevo Drawer.

         *

         * @param image DOCUMENT ME!

         * @param g DOCUMENT ME!

         * @param cancel DOCUMENT ME!

         */

        public Drawer(BufferedImage image, Graphics g, CancelDraw cancel) {

            this.g = g;

            this.image = image;

            this.cancel = cancel;

        }

        /**

         * @see java.lang.Runnable#run()

         */

        public void run() {

            try {

                synchronized (Drawer.class) {

                    mapContext.draw(image, (Graphics2D) image.getGraphics(),

                        cancel);

                    timer.stop();

                    isCancelled = true;

                    repaint();

                }

            } catch (DriverIOException e) {

            } finally {

            }

        }

    }

    /**

     * DOCUMENT ME!

     *

     * @author Fernando Gonz?lez Cort?s

     */

    public class CancelDraw implements Cancellable {

        private boolean isCanceled = false;

        /**

         * Crea un nuevo CancelDraw.

         */

        public CancelDraw() {

        }

        /**

         * DOCUMENT ME!

         *

         * @param b DOCUMENT ME!

         */

        public void setCancel(boolean b) {

            isCanceled = b;

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.Cancellable#isCanceled()

         */

        public boolean isCanceled() {

            return false;

        }

    }

        public Color getBackColor() {

                return backColor;

        }

        public void setBackColor(Color backColor) {

                this.backColor = backColor;

        }

}