skrueger/geotools/XMapPane.java

/*
 *    GeoTools - OpenSource mapping toolkit
 *    http://geotools.org
 *    (C) 2002-2006, GeoTools Project Managment Committee (PMC)
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation;
 *    version 2.1 of the License.
 *
 *    This library 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
 *    Lesser General Public License for more details.
 */
package gtmig.org.geotools.swing;

/**
 * This class is 50% copied from GeoTools 2.6.x JMapPane. GeoTools is LGPL, SCHMITZM also.<br/>
 * In addition to 
 */

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Cursor;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.InputEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.geom.AffineTransform;
import java.awt.geom.NoninvertibleTransformException;
import java.awt.geom.Point2D;
import java.awt.image.BufferedImage;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;

import org.apache.log4j.Logger;
import org.geotools.feature.FeatureCollection;
import org.geotools.geometry.jts.JTS;
import org.geotools.geometry.jts.ReferencedEnvelope;
import org.geotools.map.DefaultMapContext;
import org.geotools.map.MapContext;
import org.geotools.map.MapLayer;
import org.geotools.map.event.MapLayerEvent;
import org.geotools.map.event.MapLayerListEvent;
import org.geotools.map.event.MapLayerListListener;
import org.geotools.map.event.MapLayerListener;
import org.geotools.referencing.CRS;
import org.geotools.renderer.GTRenderer;
import org.geotools.renderer.label.LabelCacheImpl;
import org.geotools.renderer.lite.LabelCache;
import org.geotools.swing.JMapPane;
import org.geotools.swing.event.MapMouseEvent;
import org.geotools.swing.event.MapPaneEvent;
import org.geotools.swing.event.MapPaneListener;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;
import org.opengis.referencing.FactoryException;
import org.opengis.referencing.crs.CoordinateReferenceSystem;
import org.opengis.referencing.operation.MathTransform;
import org.opengis.referencing.operation.TransformException;

import schmitzm.geotools.GTUtil;
import schmitzm.geotools.JTSUtil;
import schmitzm.geotools.gui.SelectableXMapPane;
import schmitzm.geotools.map.event.JMapPaneListener;
import schmitzm.geotools.map.event.MapLayerAdapter;
import schmitzm.swing.SwingUtil;
import skrueger.geotools.RenderingExecutor;

import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.Envelope;
import com.vividsolutions.jts.geom.Geometry;

public class XMapPane extends JPanel implements PropertyChangeListener {
        private static Logger LOGGER = Logger.getLogger(XMapPane.class);

        /**
         * Sets whether a layer is regarded or ignored on {@link #SELECT_TOP},
         * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions.
         * 
         * @param layer
         *            a layer
         * @param selectable
         *            if {@code false} the layer is ignored during the upper
         *            mentioned actions. If <code>null</code>, the default (true)
         *            will be used.
         */
        public void setMapLayerSelectable(MapLayer layer, Boolean selectable) {
                if (selectable == null)
                        mapLayerSelectable.remove(layer);
                else
                        mapLayerSelectable.put(layer, selectable);
        }

        /**
         * Holds a flag for each layer, whether it is regarded or ignored on
         * {@link #SELECT_TOP}, {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP}
         * actions.
         */
        final protected HashMap<MapLayer, Boolean> mapLayerSelectable = new HashMap<MapLayer, Boolean>();

        /**
         * Returns whether a layer is regarded or ignored on {@link #SELECT_TOP},
         * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions. Returns
         * <code>true</code> if the selectability has not been defined.
         * 
         * @param layer
         *            a layer
         */
        public boolean isMapLayerSelectable(MapLayer layer) {
                Boolean selectable = mapLayerSelectable.get(layer);
                return selectable == null ? true : selectable;
        }

        /**
         * Flag fuer Modus "Kartenausschnitt bewegen". Nicht fuer Window-Auswahl
         * moeglich!
         * 
         * @see #setState(int)
         */
        public static final int PAN = 1;
        /**
         * Flag fuer Modus "Heran zoomen".
         * 
         * @see #setState(int)
         * @see #setState(int)
         */
        public static final int ZOOM_IN = 2;
        /**
         * Flag fuer Modus "Heraus zoomen". Nicht fuer Window-Auswahl moeglich!
         * 
         * @see #setState(int)
         */
        public static final int ZOOM_OUT = 3;
        /**
         * Flag fuer Modus
         * "SimpleFeature-Auswahl auf dem obersten (sichtbaren) Layer".
         * 
         * @see #setState(int)
         * @see #setState(int)
         */
        public static final int SELECT_TOP = 4;
        /**
         * Flag fuer Modus "SimpleFeature-Auswahl auf allen (sichtbaren) Layern".
         * 
         * @see #setState(int)
         * @see #setState(int)
         */
        public static final int SELECT_ALL = 103;
        /**
         * Flag fuer Modus
         * "Auswahl nur eines Features, das erste sichtbare von Oben".
         * 
         * @see #setState(int)
         * @see #setState(int)
         */
        public static final int SELECT_ONE_FROM_TOP = 104;
//
//      /**
//       * While threads are working, we call {@link XMapPane#updateFinalImage()}
//       * regularly and repaint(). This {@link Timer} is stopped when all renderers
//       * have finished.
//       */
//      final private Timer repainterTimer;
//
//      /**
//       * While the {@link #bgExecuter} and {@link #localExecuter} are rendering,
//       * the {@link #repainterTimer} is regularly updating the {@link #finalImage}
//       * with previews.
//       */
//      public static final long REPEATING_REPAINT_DELAY = 500;
//      
//      /**
//       * The initial delay in milliseconds until the {@link #finalImage} is updated the first time.  
//       */
//      public static final long INITIAL_REPAINT_DELAY = 333;

        protected RenderingExecutor bgExecuter;

        /**
         * the map context to render
         */
        MapContext localContext;
        /**
         * the map context to render
         */
        MapContext bgContext;

        /**
         * the area of the map to draw
         */
        protected Envelope mapArea = null;
        /**
         * We store the old mapArea for a moment to use it for the
         * "quick scaled preview" in case of ZoomOut
         **/
        protected Envelope oldMapArea = null;

        /**
         * the size of the pane last time we drew
         */
        protected Rectangle oldRect = null;

        /**
         * The Renderer for the Background uses this Image. When set to null, please
         * dispose the {@link Graphics2D}
         */
        protected BufferedImage bgImage;

        /**
         * The Renderer for the LocalLayers uses this Image. When set to null,
         * please dispose this {@link Graphics2D}
         */
        volatile protected BufferedImage localImage;

        /**
         * compass and icon are rendered into this image
         */
        // protected BufferedImage gadgetsImage;

        /**
         * The default state is ZOOM_IN, hence by default the
         * {@link #zoomMapPaneMouseListener} is also enabled.
         **/
        private int state = ZOOM_IN;

        /**
         * Konvertiert die Maus-Koordinaten (relativ zum <code>JMapPane</code>) in
         * Karten-Koordinaten.
         * 
         * @param e
         *            Maus-Ereignis
         */
        public static Point2D getMapCoordinatesFromEvent(MouseEvent e) {
                // aktuelle Geo-Position aus GeoMouseEvent ermitteln
                if (e != null && e instanceof MapMouseEvent)
                        try {
                                return ((MapMouseEvent) e).getMapPosition().toPoint2D();
                        } catch (Exception err) {
                                LOGGER
                                                .error(
                                                                "return ((GeoMouseEvent) e).getMapCoordinate(null).toPoint2D();",
                                                                err);
                        }

                // aktuelle Geo-Position ueber Transformation des JMapPane berechnen
                if (e != null && e.getSource() instanceof XMapPane) {

                        final XMapPane xMapPane = (XMapPane) e.getSource();

                        if (!xMapPane.isWellDefined())
                                return null;

                        AffineTransform at = xMapPane.getScreenToWorld();
                        if (at != null)
                                return at.transform(e.getPoint(), null);
                        return null;
                }
                throw new IllegalArgumentException(
                                "MouseEvent has to be of instance MapMouseEvent or come from an XMapPane");
        }

        /**
         * A flag indicating that the shown image is invalid and needs to be
         * re-rendered.
         */
        protected boolean mapImageInvalid = true;

        protected LabelCache labelCache = new LabelCacheImpl();

        /**
         * If not <code>null</code>, the {@link XMapPane} will not allow to zoom/pan
         * out of that area
         **/
        private Envelope maxExtend = null;

        private Double maxZoomScale = Double.MIN_VALUE;
        private Double minZoomScale = Double.MAX_VALUE;

        /**
         * This color is used as the default background color when painting a map.
         */
        private Color mapBackgroundColor = Color.WHITE;

        /**
         * This {@link MouseListener} is managing all zoom related tasks
         */
        public final ZoomXMapPaneMouseListener zoomMapPaneMouseListener = new ZoomXMapPaneMouseListener(
                        this);

        /**
         * A flag indicating, that the image size has changed and the buffered
         * images are not big enough any more
         **/
        protected boolean paneResized = false;

        /**
         * The flag {@link #requestStartRendering} can be set to true by events.
         * This {@link Timer} checks the flag regularly and starts one renderer
         * thread.
         */
        final private Timer startRenderThreadsTimer;

        private Map<Object, Object> rendererHints;

        public Map<Object, Object> getRendererHints() {
                return rendererHints;
        }

        /**
         * Nuetzlich wenn die Componente gedruckt (z.B. wenn ein Screenshot gemacht
         * wird) wird. Dann werden wird der Hintergrund auf WEISS gesetzt.
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        @Override
        public void print(Graphics g) {
                Color orig = getBackground();
                setBackground(Color.WHITE);

                // wrap in try/finally so that we always restore the state
                try {
                        super.print(g);
                } finally {
                        setBackground(orig);
                }
        }

        /**
         * full constructor extending JPanel
         * 
         * @param rendererHints
         * 
         * @param layout
         *            - layout (probably shouldn't be set)
         * @param isDoubleBuffered
         *            - a Swing thing I don't really understand
         * @param render
         *            - what to draw the map with
         * @param localContext
         *            - {@link MapContext} of layer to render.
         */
        public XMapPane(final MapContext localContext,
                        Map<Object, Object> rendererHints) {
                super(true);

                setRendererHints(rendererHints);

                setOpaque(true);

                setLocalContext(localContext);

                /**
                 * Adding the #zoomMapPaneMouseListener
                 */
                this.addMouseListener(zoomMapPaneMouseListener);
                this.addMouseMotionListener(zoomMapPaneMouseListener);
                this.addMouseWheelListener(zoomMapPaneMouseListener);

                /*
                 * We use a Timer object to avoid rendering delays and flickering when
                 * the user is drag-resizing the parent container of this map pane.
                 * 
                 * Using a ComponentListener doesn't work because, unlike a JFrame, the
                 * pane receives a stream of events during drag-resizing.
                 */
                resizingPaintDelay = DEFAULT_RESIZING_PAINT_DELAY;
                resizeTimer = new Timer(resizingPaintDelay, new ActionListener() {

                        public void actionPerformed(ActionEvent e) {
                                paneResized = true;

                                if (!isWellDefined())
                                        return;

                                Rectangle bounds = getVisibleRect();

                                Envelope geoMapArea = tranformWindowToGeo(bounds.x, bounds.y,
                                                bounds.x + bounds.width, bounds.y + bounds.height);

                                setMapArea(bestAllowedMapArea(geoMapArea));
                        }
                });
                resizeTimer.setRepeats(false);
                this.addComponentListener(new ComponentAdapter() {

                        @Override
                        public void componentResized(ComponentEvent e) {
                                if (bgExecuter != null)
                                        bgExecuter.cancelTask();
                                if (localExecuter != null)
                                        localExecuter.cancelTask();
                                resizeTimer.restart();
                        }

                });

//              repainterTimer = new Timer((int) REPEATING_REPAINT_DELAY,
//                              new ActionListener() {
//
//                                      @Override
//                                      public void actionPerformed(ActionEvent e) {
//                                              updateFinalImage();
//                                              XMapPane.this.repaint();
//                                      }
//                              });
//              repainterTimer.setInitialDelay(300);
//              repainterTimer.setRepeats(true);

                startRenderThreadsTimer = new Timer(200, new ActionListener() {

                        @Override
                        public void actionPerformed(ActionEvent e) {
                                synchronized (requestStartRendering) {
                                        if (requestStartRendering && isValid())
                                                startRendering();
                                        requestStartRendering = false;
                                }
                        }
                });
                startRenderThreadsTimer.start();

        }

        // TODO doku
        public XMapPane() {
                this(null, null);
        }

        /**
         * Sets the mapArea to best possibly present the given features. If only one
         * single point is given, the window is moved over the point.
         * 
         * Note: The method does not call {@link #repaint()} on the
         * {@link SelectableXMapPane} .
         * 
         * @param features
         *            if <code>null</code> or size==0, the function doesn nothing.
         */
        public void zoomTo(
                        FeatureCollection<SimpleFeatureType, SimpleFeature> features) {

                CoordinateReferenceSystem mapCRS = getContext()
                                .getCoordinateReferenceSystem();
                CoordinateReferenceSystem fCRS = features.getSchema()
                                .getGeometryDescriptor().getCoordinateReferenceSystem();

                double width = mapArea.getWidth();
                double height = mapArea.getHeight();
                double ratio = height / width;

                if (features == null || features.size() == 0) {
                        // feature count == 0 Zoom to the full extend
                        return;
                } else if (features.size() == 1) {

                        // feature count == 1 Just move the window to the point and zoom 'a
                        // bit'
                        SimpleFeature singleFeature = (SimpleFeature) features.iterator()
                                        .next();

                        if (((Geometry) singleFeature.getDefaultGeometry())
                                        .getCoordinates().length > 1) {
                                // System.out.println("Zoomed to only pne poylgon");
                                // Poly
                                // TODO max width vs. height
                                width = features.getBounds().getWidth() * 3;
                                height = ratio * width;
                        } else {
                                // System.out.println("Zoomed in a bit becasue only one point");
                                // width *= .9;
                                // height *= .9;
                        }

                        Coordinate centre = features.getBounds().centre();
                        if (!mapCRS.equals(fCRS)) {
                                // only to calculations if the CRS differ
                                try {
                                        MathTransform fToMap;
                                        fToMap = CRS.findMathTransform(fCRS, mapCRS);
                                        // centre is transformed to the mapCRS
                                        centre = JTS.transform(centre, null, fToMap);
                                } catch (FactoryException e) {
                                        LOGGER.error("Looking for a Math transform", e);
                                } catch (TransformException e) {
                                        LOGGER.error("Looking for a Math transform", e);
                                }
                        }

                        Coordinate newLeftBottom = new Coordinate(centre.x - width / 2.,
                                        centre.y - height / 2.);
                        Coordinate newTopRight = new Coordinate(centre.x + width / 2.,
                                        centre.y + height / 2.);

                        Envelope newMapArea = new Envelope(newLeftBottom, newTopRight);

                        setMapArea(newMapArea);

                } else {
                        ReferencedEnvelope fBounds = features.getBounds();

                        Envelope bounds;
                        if (!mapCRS.equals(fCRS)) {
                                bounds = JTSUtil.transformEnvelope(fBounds, fCRS, mapCRS);
                        } else {
                                bounds = fBounds;
                        }
                        // BB umrechnen von Layer-CRS in Map-CRS

                        // Expand a bit
                        bounds.expandBy(bounds.getWidth() / 6., bounds.getHeight() / 6.);

                        setMapArea(bounds);
                }
        }

        private void setRendererHints(Map<Object, Object> rendererHints) {
                this.rendererHints = rendererHints;
        }

        /**
         * Return <code>true</code> if a CRS and a {@link #mapArea} are set and the
         * {@link XMapPane} is visible and has bounds set.
         */
        public boolean isWellDefined() {

                try {

                        if (getContext() == null)
                                return false;
                        if (getContext().getLayerCount() <= 0)
                                return false;
                        if (getMapArea() == null)
                                return false;
                        if (getBounds().getWidth() == 0)
                                return false;
                        if (getBounds().getHeight() == 0)
                                return false;
                } catch (Exception e) {
                        return false;
                }
                return true;
        }

        /**
         * Default delay (milliseconds) before the map will be redrawn when resizing
         * the pane. This is to avoid flickering while drag-resizing.
         */
        public static final int DEFAULT_RESIZING_PAINT_DELAY = 500; // delay in
        // milliseconds

        private Timer resizeTimer;
        private int resizingPaintDelay;
        /**
         * We store the old transform for a moment to use it for the
         * "quick scaled preview" in case of ZoomIn
         **/
        protected AffineTransform oldScreenToWorld = null;

        /**
         * Manuell gesetzter statischer Cursor, unabhaengig von der aktuellen
         * MapPane-Funktion
         */
        protected Cursor staticCursor = null;

        /**
         * Standardmaessig wird der Cursor automatisch je nach MapPane-Aktion (Zoom,
         * Auswahl, ...) gesetzt. Mit dieser Methode kann ein statischer Cursor
         * gesetzt werden, der unabhaengig von der aktuellen MapPanes-Aktion
         * beibehalten wird. Um diesen statischen Cursor wieder zu entfernen, kann
         * {@code null} als Parameter uebergeben werden
         * 
         * @param cursor
         *            Cursor
         */
        public void setStaticCursor(Cursor cursor) {
                this.staticCursor = cursor;
                if (cursor != null)
                        super.setCursor(cursor);
        }

        /**
         * Liefert den statisch eingestellten Cursor, der unabhaengig von der
         * eingestellten MapPane-Aktion (Zoom, Auswahl, ...) verwendet wird.
         * 
         * @return {@code null}, wenn kein statischer Cursor verwendet, sondern der
         *         Cursor automatisch je nach MapPane-Aktion eingestellt wird.
         */
        public Cursor getStaticCursor() {
                return this.staticCursor;
        }

        /**
         * Abhaengig von selState wird der Cursor gesetzt
         */
        public void updateCursor() {

                if (bgExecuter != null && bgExecuter.isRunning()
                                || localExecuter != null && localExecuter.isRunning()) {
                        setCursor(WAIT_CURSOR);
                        return;
                } else {
//                      // Allow one last rendering
//                      if (repainterTimer.isRunning()) {
//                              repainterTimer.stop();
//                              updateFinalImage();
//                              repaint();
//                      }
                }

                // wenn manueller Cursor gesetzt ist, dann diesen verwenden (unabhaengig
                // von der aktuellen Aktion
                if (this.staticCursor != null) {
                        setCursor(staticCursor);
                        return;
                }
                if (getCursor() == SwingUtil.PANNING_CURSOR) {
                        // This cursor will reset itself
                        return;
                }

                // Je nach Aktion den Cursor umsetzen
                switch (state) {
                case SELECT_TOP:
                case SELECT_ONE_FROM_TOP:
                case SELECT_ALL:
                        setCursor(SwingUtil.CROSSHAIR_CURSOR);
                        break;
                case ZOOM_IN:
                        setCursor(SwingUtil.ZOOMIN_CURSOR);
                        break;
                case ZOOM_OUT:
                        setCursor(SwingUtil.ZOOMOUT_CURSOR);
                        break;
                case PAN:
                        setCursor(SwingUtil.PAN_CURSOR);
                        break;
                default:
                        setCursor(normalCursor);
                        break;
                }
        }

        //
        // /**
        // * Gibt den "normalen" Cursor zurueck. Dieser kann neben dem "pointer"
        // auch
        // * ein Sanduhr-Wartecursor sein.
        // *
        // * @author <a href="mailto:[email protected]">Stefan Alfons
        // * Kr&uuml;ger</a>
        // */
        // public Cursor getNormalCursor() {
        // return normalCursor;
        // }
        //
        // /**
        // * Setzt den "normalen" Cursor. Dieser kann neben dem default "pointer"
        // z.B.
        // * auch ein Sanduhr-Wartecursor sein.
        // *
        // * @author <a href="mailto:[email protected]">Stefan Alfons
        // * Kr&uuml;ger</a>
        // */
        // public void setNormalCursor(Cursor normalCursor) {
        // this.normalCursor = normalCursor;
        // }

        /**
         * Berechnet die Transformation zwischen Fenster- und Karten-Koordinaten
         * neu.
         */
        protected void resetTransforms() {
                if (getMapArea() == null || getWidth() == 0 || getHeight() == 0)
                        return;

                // We store the last Transform
                oldScreenToWorld = screenToWorld;

                this.screenToWorld = new AffineTransform(
                // Genauso wie die Fenster-Koordinaten, werden die Longitude-Koordinaten
                                // nach rechts (Osten) hin groesser
                                // --> positive Verschiebung
                                getMapArea().getWidth() / getWidth(),
                                // keine Verzerrung
                                0.0, 0.0,
                                // Waehrend die Fenster-Koordinaten nach unten hin groesser
                                // werden,
                                // werden Latitude-Koordinaten nach Sueden hin keiner
                                // --> negative Verschiebung
                                -getMapArea().getHeight() / getHeight(),
                                // Die Longitude-Koordinaten werden nach Osten hin groesser
                                // --> obere linke Ecke des Fensters hat also den Minimalwert
                                getMapArea().getMinX(),
                                // Die Latitude-Koordinaten werden nach Norden hin groesser
                                // --> obere linke Ecke des Fensters hat also den Maximalwert
                                getMapArea().getMaxY());

                try {
                        this.worldToScreen = screenToWorld.createInverse();
                } catch (NoninvertibleTransformException e) {
                        LOGGER.error(e);
                }
        }

        /**
         * Transformation zwischen Fenster-Koordinaten und Karten-Koordinaten
         * (lat/lon)
         */
        protected AffineTransform screenToWorld = null;

        private AffineTransform worldToScreen;

        /**
         * Listens to changes of the "local" {@link MapContext} and triggers
         * repaints where needed.
         */
        private MapLayerListListener localContextListener = new MapLayerListListener() {

                @Override
                public void layerAdded(final MapLayerListEvent event) {
                        event.getLayer().addMapLayerListener(localMapLayerListener);

                        if (localContext.getLayers().length == 1) { // the first one
                                // if the Area of Interest is unset, the LayerBounds are used
                                if (!setMapArea(localContext.getAreaOfInterest()))
                                        repaint();

                                return;
                        }

                        // We need to redraw, even in case that the mapArea didn't change
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();

                }

                @Override
                public void layerRemoved(final MapLayerListEvent event) {
                        if (event.getLayer() != null)
                                event.getLayer().removeMapLayerListener(localMapLayerListener);
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerChanged(final MapLayerListEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerMoved(final MapLayerListEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }
        };

        /**
         * Listens to changes of the "background" {@link MapContext} and triggers
         * repaints where needed.
         */
        private MapLayerListListener bgContextListener = new MapLayerListListener() {

                @Override
                public void layerAdded(final MapLayerListEvent event) {
                        event.getLayer().addMapLayerListener(bgMapLayerListener);

                        if (localContext.getLayers().length == 0
                                        && bgContext.getLayers().length == 1) { // the first one and
                                // localContext is
                                // empty
                                if (!setMapArea(localContext.getAreaOfInterest()))
                                        requestStartRendering();
                                return;
                        }

                        // We need to redraw, even in case that the mapArea didn't change
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();

                }

                @Override
                public void layerRemoved(final MapLayerListEvent event) {
                        if (event.getLayer() != null)
                                event.getLayer().removeMapLayerListener(bgMapLayerListener);
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerChanged(final MapLayerListEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerMoved(final MapLayerListEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }
        };

        /**
         * Listens to each layer in the local {@link MapContext} for changes and
         * triggers repaints.
         */
        protected MapLayerListener localMapLayerListener = new MapLayerAdapter() {

                @Override
                public void layerShown(MapLayerEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerHidden(MapLayerEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerChanged(MapLayerEvent event) {
                        // Change of SLD for example
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }
        };

        /**
         * Listens to each layer in the local {@link MapContext} for changes and
         * triggers repaints.
         */
        protected MapLayerListener bgMapLayerListener = new MapLayerAdapter() {

                @Override
                public void layerShown(MapLayerEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerHidden(MapLayerEvent event) {
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }

                @Override
                public void layerChanged(MapLayerEvent event) {
                        // Change of SLD for example
                        // mapImageInvalid = true;
                        // repaint();
                        requestStartRendering();
                }
        };

        /**
         * Liefert eine affine Transformation, um von den Fenster-Koordinaten in die
         * Karten-Koordinaten (Lat/Lon) umzurechnen.
         * 
         * @return eine Kopie der aktuellen Transformation; <code>null</code> wenn
         *         noch keine Karte angezeigt wird
         */
        public AffineTransform getScreenToWorld() {
                if (screenToWorld == null)
                        resetTransforms();
                // nur Kopie der Transformation zurueckgeben!
                if (screenToWorld == null)
                        return null;
                return new AffineTransform(screenToWorld);
        }

        public AffineTransform getWorldToScreenTransform() {
                if (worldToScreen == null) {
                        resetTransforms();
                }
                // nur Kopie der Transformation zurueckgeben!
                return new AffineTransform(worldToScreen);
        }

        public MapContext getContext() {
                if (localContext == null) {
                        this.localContext = new DefaultMapContext();
                        this.localContext.addMapLayerListListener(localContextListener);
                }
                return localContext;
        }

        public MapContext getBgContext() {
                return bgContext;
        }

        /**
         * 
         * @param context
         */
        public void setLocalContext(final MapContext context) {
                // Remove the default listener from the old context
                if (this.localContext != null) {
                        this.localContext.removeMapLayerListListener(localContextListener);

                        // adding listener to all layers
                        for (MapLayer mapLayer : localContext.getLayers()) {
                                mapLayer.removeMapLayerListener(localMapLayerListener);
                        }
                }

                this.localContext = context;

                if (context != null) {
                        setMapArea(localContext.getAreaOfInterest());

                        this.localContext.addMapLayerListListener(localContextListener);

                        // adding listener to all layers
                        for (MapLayer mapLayer : localContext.getLayers()) {
                                mapLayer.addMapLayerListener(localMapLayerListener);
                        }
                }

                mapImageInvalid = true;
                repaint();
        }

        public void setBgContext(final MapContext context) {

                // Remove the default listener from the old context
                if (this.bgContext != null) {
                        this.bgContext.removeMapLayerListListener(bgContextListener);

                        // adding listener to all layers
                        for (MapLayer mapLayer : bgContext.getLayers()) {
                                mapLayer.removeMapLayerListener(bgMapLayerListener);
                        }
                }

                this.bgContext = context;

                if (context != null) {
                        setMapArea(bgContext.getAreaOfInterest());

                        this.bgContext.addMapLayerListListener(bgContextListener);

                        // adding listener to all layers
                        for (MapLayer mapLayer : bgContext.getLayers()) {
                                mapLayer.addMapLayerListener(bgMapLayerListener);
                        }
                }
                mapImageInvalid = true;
                repaint();
        }

        /**
         * Returns a copy of the mapArea
         * 
         * @return
         */
        public Envelope getMapArea() {
                if (mapArea == null) {
                        final Rectangle paneBounds = getBounds();

                        try {
                                mapArea = localContext.getLayerBounds();
                        } catch (final IOException e) {
                                LOGGER.warn("context.getLayerBounds()", e);
                        }

                        if (mapArea != null) {
                                /* either the viewer size has changed or we've done a reset */
                                mapImageInvalid = true; /* note we need to redraw */
                                oldRect = paneBounds; /* store what the current size is */
                                mapArea = bestAllowedMapArea(mapArea);
                        }
                }

                if (mapArea == null)
                        return null;

                return new Envelope(mapArea);
        }

        /**
         * @param newMapArea
         * @return <code>true</code> if the mapArea has been changed and a repaint
         *         has been triggered.
         */
        public boolean setMapArea(final Envelope newMapArea) {

                if (newMapArea == null
                                || bestAllowedMapArea(newMapArea).equals(mapArea)) {
                        // No change.. no need to repaint
                        return false;
                }

                // Testing, whether NaN or Infinity are used in the newMapArea
                if (newMapArea.isNull() || Double.isInfinite(newMapArea.getMaxX())
                                || Double.isInfinite(newMapArea.getMaxY())
                                || Double.isInfinite(newMapArea.getMinX())
                                || Double.isInfinite(newMapArea.getMinY())) {
                        // No change.. ugly new values
                        LOGGER.warn("setMapArea has been called with newArea = "
                                        + newMapArea);
                        return false;
                }

                // Testing, whether the difference if just minimal
                if (mapArea != null) {
                        Envelope candNew = bestAllowedMapArea(newMapArea);
                        double tolX = mapArea.getWidth() / 1000.;
                        double tolY = mapArea.getHeight() / 1000.;
                        if ((candNew.getMinX() - tolX < mapArea.getMinX())
                                        && (mapArea.getMinX() < candNew.getMinX() + tolX)
                                        && (candNew.getMaxX() - tolX < mapArea.getMaxX())
                                        && (mapArea.getMaxX() < candNew.getMaxX() + tolX)

                                        && (candNew.getMinY() - tolY < mapArea.getMinY())
                                        && (mapArea.getMinY() < candNew.getMinY() + tolY)
                                        && (candNew.getMaxY() - tolY < mapArea.getMaxY())
                                        && (mapArea.getMaxY() < candNew.getMaxY() + tolY)

                        ) {
                                // The two mapAreas only differ my 1/1000th.. ignore

                                return false;
                        }
                }

                oldMapArea = mapArea;

                this.mapArea = bestAllowedMapArea(newMapArea);

                if (localContext != null) {
                        localContext.setAreaOfInterest(mapArea, localContext
                                        .getCoordinateReferenceSystem());
                }
                if (bgContext != null) {
                        bgContext.setAreaOfInterest(mapArea, localContext
                                        .getCoordinateReferenceSystem());
                }
                resetTransforms();
                mapImageInvalid = true;
                mapAreaChanged = true;
                repaint();

//              LOGGER.debug("New maparea = " + mapArea);
                return true;
        }

        public int getState() {
                return state;
        }

        /**
         * Enables/Disables the ZOOM Mouse Listener. Upates the Cursor and stops the
         * repaint Timer if
         * 
         * @param state
         */
        public void setState(final int state) {
                this.state = state;

                zoomMapPaneMouseListener.setEnabled((state == ZOOM_IN
                                || state == ZOOM_OUT || state == PAN));

                // Je nach Aktion den Cursor umsetzen
                updateCursor();
        }

        /** Cursor wenn kein Mausbutton gedrueckt wird. default oder SwingUtil.PAN **/
        protected static Cursor normalCursor = Cursor
                        .getPredefinedCursor(Cursor.DEFAULT_CURSOR);

        public static final Cursor WAIT_CURSOR = Cursor
                        .getPredefinedCursor(Cursor.WAIT_CURSOR);

        public static final int NONE = -123;

        private RenderingExecutor localExecuter;

        private BufferedImage finalImage;

        /**
         * A flag set it {@link #setMapArea(Envelope)} to indicated the
         * {@link #paintComponent(Graphics)} method, that the image on-screen is
         * associated with {@link #oldMapArea} and may hence be scaled for a quick
         * preview.<br/>
         * The flag is reset
         **/
        private boolean mapAreaChanged = false;

        private JFrame finalImageFrame;

        private volatile Boolean requestStartRendering = false;
        private BufferedImage preFinalImage;

        protected void paintComponent(final Graphics g) {
                // Maybe update the cursor
                updateCursor();

                if (!acceptsRepaintCalls)
                        return;

                boolean paintedSomething = false;

                if (mapImageInvalid) { /* if the map changed then redraw */

                        mapImageInvalid = false; // Reset for next round

                        // If the new mapArea and the oldMapArea intersect, we can draw some
                        // quick scaled preview to make the user feel that something is
                        // happening.
                        if (mapAreaChanged && oldMapArea != null
                                        && getMapArea().intersects(oldMapArea)
                                        & !getMapArea().equals(oldMapArea)) {

                                mapAreaChanged = false;

                                if (getMapArea().covers(oldMapArea)) {
                                        setQuickPreviewHint(ZOOM_OUT);
                                        paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
                                } else if (oldMapArea.covers(getMapArea())) {
                                        setQuickPreviewHint(ZOOM_IN);
                                        paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
                                }

                        }

                        if (paneResized) {
                                paneResized = false;
                                preFinalImage = null;
                                finalImage = null;
                                localImage = null;
                                bgImage = null;
                                // gadgetsImage = null;
                        }

                        // Start the Threads and Timers to render the image
                        requestStartRendering();

                }

                if (!paintedSomething) {

                        // TODO Should just paint the getFinalImage(). Update should be
                        // called by timer every 300ms, and the repaint() until all threads
                        // are done.
                        g.drawImage(getFinalImage(), 0, 0, this);

                        paintedSomething = true;
                }

        }

        /**
         * Cancels all running renderers and sets the flag to start new ones. <br/>
         * 
         * @see #startRenderThreadsTimer
         */
        private void requestStartRendering() {
                if (bgExecuter != null)
                        bgExecuter.cancelTask();
                if (localExecuter != null)
                        localExecuter.cancelTask();
                requestStartRendering = true;
        }

        /**
         * Transformiert einen Fenster-Koordinaten-Bereich in Geo-Koordinaten.
         * 
         * @param ox
         *            X-Koordinate der VON-Position
         * @param oy
         *            Y-Koordinate der VON-Position
         * @param px
         *            X-Koordinate der BIS-Position
         * @param py
         *            Y-Koordinate der BIS-Position
         */
        public Envelope tranformWindowToGeo(int ox, int oy, int px, int py) {
                AffineTransform at = getScreenToWorld();
                Point2D geoO = at.transform(new Point2D.Double(ox, oy), null);
                Point2D geoP = at.transform(new Point2D.Double(px, py), null);
                return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP.getY());
        }

        /**
         * Transformiert einen Geo-Koordinaten-Bereich in Fenster-Koordinaten.
         * 
         * @param ox
         *            X-Koordinate der VON-Position
         * @param oy
         *            Y-Koordinate der VON-Position
         * @param px
         *            X-Koordinate der BIS-Position
         * @param py
         *            Y-Koordinate der BIS-Position
         * @param winToGeotransform
         *            Eine Window to Geo transform. If <code>null</code>,
         *            {@link #getScreenToWorld()} is used.
         */
        public Envelope tranformGeoToWindow(double ox, double oy, double px,
                        double py, AffineTransform winToGeotransform) {
                AffineTransform at = winToGeotransform == null ? getScreenToWorld()
                                : winToGeotransform;
                Point2D geoO;
                try {
                        geoO = at.inverseTransform(new Point2D.Double(ox, oy), null);
                        Point2D geoP = at
                                        .inverseTransform(new Point2D.Double(px, py), null);
                        return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP
                                        .getY());
                } catch (NoninvertibleTransformException e) {
                        LOGGER.error(e);
                        return new Envelope(ox, oy, px, py);
                }
        }

        /**
         * Diretly paints scaled preview into the {@link SelectableXMapPane}. Used
         * to give the user something to look at while we are rendering. Method
         * should be called after {@link #setMapArea(Envelope)} has been set to the
         * new mapArea and transform has been reset.<br/>
         * This method does nothing if the {@link #lastRenderingDuration} is smaller
         * then a trashhold.
         * 
         * @param g
         *            Graphics2D to paint the preview into
         * 
         * @param state
         *            Max be {@link #ZOOM_IN} or {@link #ZOOM_OUT}
         */
        protected boolean drawScaledPreviewImage_Zoom(Graphics2D graphics) {

                if (quickPreviewHint == 0)
                        return false;

                graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                                RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
                graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                                RenderingHints.VALUE_ANTIALIAS_OFF);
                graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
                                RenderingHints.VALUE_RENDER_SPEED);

                if (oldMapArea == null)
                        return false;

                Rectangle visibleArea = getVisibleRect();

                // Calculate the oldMapArea in the current WindowCoordinates:
                Envelope oldMapWindow = tranformGeoToWindow(oldMapArea.getMinX(),
                                oldMapArea.getMinY(), oldMapArea.getMaxX(), oldMapArea
                                                .getMaxY(), null);

                int xx1 = (int) Math.round(oldMapWindow.getMinX());
                int yy1 = (int) Math.round(oldMapWindow.getMinY());
                int xx2 = (int) Math.round(oldMapWindow.getMaxX());
                int yy2 = (int) Math.round(oldMapWindow.getMaxY());

                graphics.drawImage(getPreFinalImage(), xx1, yy1, xx2, yy2,
                                (int) visibleArea.getMinX(), (int) visibleArea.getMinY(),
                                (int) visibleArea.getMaxX(), (int) visibleArea.getMaxY(),
                                getMapBackgroundColor(), null);

                Rectangle painedArea = new Rectangle(xx1, yy1, xx2 - xx1, yy2 - yy1);

                SwingUtil.clearAround(graphics, painedArea, visibleArea);

                addGadgets(graphics);
                // graphics.drawImage(getGadgetsImage(), 0,0, (int)
                // visibleArea.getMaxX(), (int) visibleArea.getMaxY(),null);

                quickPreviewHint = 0;

                graphics.dispose();
                // Something has been drawn
                return true;
        }

        final static Font waitFont = new Font("Arial", Font.BOLD, 30);

        /**
         * Paints some optinal stuff into the given {@link Graphics2D}. Usually
         * called as the last paint on the mapImage.
         */
        private void addGadgets(Graphics2D graphics) {

                if (mapImage != null)
                        graphics.drawImage(mapImage, getBounds().width
                                        - mapImage.getWidth() - 10, getBounds().height
                                        - mapImage.getHeight() - 10, this);

                // If still rendering, paint a gray shadow or so...
                if (bgExecuter != null && bgExecuter.isRunning()
                                || localExecuter != null && localExecuter.isRunning()) {
                        graphics.setColor(Color.BLACK);

                        graphics.setFont(waitFont);
                        graphics.drawString("Wait...", 40, 70);
                }

        }

        /**
         * Accumulates all three images
         * 
         * @return
         */
        synchronized protected BufferedImage updateFinalImage() {

                final Graphics2D finalG = (Graphics2D) getFinalImage().getGraphics();
                finalG.setBackground(getMapBackgroundColor());

                // Render the two map images first, into the preFinalImage
                {
                        final Graphics2D preFinalG = (Graphics2D) getPreFinalImage()
                                        .getGraphics();
                        preFinalG.setBackground(getMapBackgroundColor());

                        preFinalG.drawImage(getBgImage(), 0, 0, getMapBackgroundColor(),
                                        null);
                        // // Draw the local layers image
                        preFinalG.drawImage(getLocalImage(), 0, 0, null);
                        preFinalG.dispose();
                }

                finalG.drawImage(getPreFinalImage(), imageOrigin.x, imageOrigin.y,
                                getMapBackgroundColor(), null);

                // System.out.println(new Date().getTime() - startTime +
                // "ms for update");
                //
                // if (finalImageFrame == null) {
                // finalImageFrame = new JFrame();
                // finalImageFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
                // SwingUtil.setRelativeFramePosition(finalImageFrame, 0, 0);
                // }
                // finalImageFrame.setContentPane(new JLabel(new
                // ImageIcon(finalImage)));
                // finalImageFrame.pack();
                // finalImageFrame.setVisible(true);

                final int finalImageHeight = getFinalImage().getHeight(null);
                final int finalImageWidth = getFinalImage().getWidth(null);

                Rectangle painedArea = new Rectangle(imageOrigin.x, imageOrigin.y,
                                finalImageWidth, finalImageHeight);
                SwingUtil.clearAround(finalG, painedArea, getVisibleRect());

                addGadgets(finalG);
                // finalG.drawImage(getGadgetsImage(), 0, 0, null);

                finalG.dispose();

                return finalImage;
        }

        /*
         * Set alpha composite. For example, pass in 1.0f to have 100% opacity pass
         * in 0.25f to have 25% opacity.
         */
        private AlphaComposite makeComposite(float alpha) {
                int type = AlphaComposite.SRC_OVER;
                return (AlphaComposite.getInstance(type, alpha));
        }

        private Image getFinalImage() {

                if (finalImage == null) {
                        finalImage = null;
                        Rectangle curPaintArea = getVisibleRect();
                        finalImage = new BufferedImage(curPaintArea.width,
                                        curPaintArea.height, BufferedImage.TYPE_INT_RGB);

                        requestStartRendering();
                }
                return finalImage;
        }

        private Image getPreFinalImage() {

                if (preFinalImage == null) {
                        preFinalImage = null;
                        Rectangle curPaintArea = getVisibleRect();

                        preFinalImage = new BufferedImage(curPaintArea.width,
                                        curPaintArea.height, BufferedImage.TYPE_INT_RGB);

                        requestStartRendering();
                }
                return preFinalImage;
        }

        /**
         * While dragging, the {@link #updateFinalImage()} method is translating the
         * cached images while setting it together.
         **/
        Point imageOrigin = new Point(0, 0);

        /**
         * Starts rendering on one or two threads
         */
        private void startRendering() {

                if (!isWellDefined())
                        return;

                if (bgExecuter != null)
                        // Stop all renderers
                        bgExecuter.cancelTask();

                if (localExecuter != null)
                        localExecuter.cancelTask();
                //
                //
                // LOGGER.debug("stopping any running renderes:");
                // int count = 0;
                // while (bgExecuter.isRunning() || localExecuter.isRunning()) {
                // LOGGER.debug("waiting for threads to stop");
                //
                // bgExecuter.cancelTask();
                // localExecuter.cancelTask();
                //
                // count++;
                //
                // try {
                // Thread.sleep(100);
                // } catch (InterruptedException e) {
                // LOGGER.error(e);
                // }
                //
                // if (count > 100) {
                // throw new RuntimeException(
                // "Unable to stop rendering thread for 10secs");
                // }
                // }
                // LOGGER.debug(" threads stopped after " + count / 10. + "secs");

                Rectangle curPaintArea = getVisibleRect();

                // allow a single pixel margin at the right and bottom edges
                curPaintArea.width -= 1;
                curPaintArea.height -= 1;

                labelCache.clear();

                /**
                 */

                /**
                 * We have to set new renderer
                 */

                if (getBgContext() != null) {
                        bgExecuter = new RenderingExecutor(this, 333l);
                        LOGGER.debug("starting bg renderer:");
                        // /* System.out.println("rendering"); */
                        final GTRenderer createGTRenderer = GTUtil.createGTRenderer(
                                        localContext, getRendererHints());
                        createGTRenderer.setJava2DHints(getJava2dHints());
                        bgExecuter.submit(getBgContext().getAreaOfInterest(), curPaintArea,
                                        (Graphics2D) getBgImage().getGraphics(), createGTRenderer);
                }

                if (getContext() != null) {
                        localExecuter = new RenderingExecutor(this, 150l);
                        LOGGER.debug("starting local renderer:");
                        final GTRenderer createGTRenderer = GTUtil.createGTRenderer(
                                        localContext, getRendererHints());
                        createGTRenderer.setJava2DHints(getJava2dHints());
                        localExecuter.submit(getContext().getAreaOfInterest(),
                                        curPaintArea, (Graphics2D) getLocalImage().getGraphics(),
                                        createGTRenderer);
                }

                updateCursor();
//
//              // start regular repaints until all renderers are done.
//              repainterTimer.setRepeats(true);
//              repainterTimer.restart();

        }

        /**
         * Lazyly initializes a {@link BufferedImage} for the background renderer.
         */
        private BufferedImage getBgImage() {

                if (bgImage == null) {
                        LOGGER.debug("creating a new background image");

                        Rectangle curPaintArea = getVisibleRect();
                        // allow a single pixel margin at the right and bottom edges
                        curPaintArea.width -= 1;
                        curPaintArea.height -= 1;

                        bgImage = new BufferedImage(curPaintArea.width + 1,
                                        curPaintArea.height + 1, BufferedImage.TYPE_INT_ARGB);
                }

                return bgImage;
        }

        /** An (transparent) image to paint over the map in the lower right corner **/
        private BufferedImage mapImage = null;

        private boolean acceptsRepaintCalls = true;

        /**
         * Get the BufferedImage to use as a flaoting icon in the lower right
         * corner.
         * 
         * @return <code>null</code> if the feature is deactivated.
         */
        public BufferedImage getMapImage() {
                return mapImage;
        }

        /**
         * Set the BufferedImage to use as a flaoting icon in the lower right corner
         * 
         * @param mapImageIcon
         *            <code>null</code> is allowed and deactivates this icon.
         */
        public void setMapImage(BufferedImage mapImage) {
                this.mapImage = mapImage;
                // gadgetsImage = null;
        }

        /**
         * Lazyly initializes a {@link BufferedImage} for the background renderer.
         */
        private BufferedImage getLocalImage() {

                if (localImage == null) {
                        LOGGER.debug("creating a new local image");

                        Rectangle curPaintArea = getVisibleRect();
                        // allow a single pixel margin at the right and bottom edges
                        curPaintArea.width -= 1;
                        curPaintArea.height -= 1;

                        localImage = new BufferedImage(curPaintArea.width + 1,
                                        curPaintArea.height + 1, BufferedImage.TYPE_INT_ARGB);
                }

                return localImage;
        }

        //
        // /**
        // * Lazyly initializes a {@link BufferedImage} for the background renderer.
        // */
        // private BufferedImage getGadgetsImage() {
        //
        // if (gadgetsImage == null) {
        // LOGGER.debug("creating a new gadgets image");
        //
        // Rectangle curPaintArea = getVisibleRect();
        // // allow a single pixel margin at the right and bottom edges
        // curPaintArea.width -= 1;
        // curPaintArea.height -= 1;
        //
        // gadgetsImage = new BufferedImage(curPaintArea.width + 1,
        // curPaintArea.height + 1, BufferedImage.TYPE_INT_ARGB);
        //
        // if (mapImage != null)
        // gadgetsImage.getGraphics().drawImage(mapImage,
        // curPaintArea.width - mapImage.getWidth() - 10,
        // curPaintArea.height - mapImage.getHeight() - 10, this);
        //                      
        // }
        //
        // return gadgetsImage;
        // }

        /**
         * Called by the {@linkplain XMapPane.RenderingTask} when rendering has been
         * completed Publishes a {@linkplain MapPaneEvent} of type {@code
         * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
         * 
         * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
         */
        public void onRenderingCompleted() {
                System.out.println("onRenderingCompleted");

                updateFinalImage();

                repaint();

        }

        /**
         * Called by the {@linkplain XMapPane.RenderingTask} when rendering was
         * cancelled. Publishes a {@linkplain MapPaneEvent} of type {@code
         * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
         * 
         * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
         */
        public void onRenderingCancelled() {
                LOGGER.debug("Rendering cancelled");
        }

        /**
         * Called by the {@linkplain XMapPane.RenderingTask} when rendering failed.
         * Publishes a {@linkplain MapPaneEvent} of type {@code
         * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
         * 
         * @param renderingError
         *            The error that occured during rendering
         * 
         * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
         */
        public void onRenderingFailed(Exception renderingError) {
                // MapPaneEvent ev = new MapPaneEvent(this,
                // MapPaneEvent.Type.RENDERING_STOPPED);
                // publishEvent(ev);
                LOGGER.warn("Rendering failed", renderingError);
                updateFinalImage();
                repaint();

        }

        /**
         * Called when a rendering request has been rejected. This will be common,
         * such as when the user pauses during drag-resizing fo the map pane. The
         * base implementation does nothing. It is provided for sub-classes to
         * override if required.
         */
        public void onRenderingRejected() {
                LOGGER.warn("Rendering rejected");
                repaint();
        }

        @Override
        public void propertyChange(final PropertyChangeEvent evt) {
                final String prop = evt.getPropertyName();

                if (prop.equalsIgnoreCase("crs")) {
                        localContext.setAreaOfInterest(localContext.getAreaOfInterest(),
                                        (CoordinateReferenceSystem) evt.getNewValue());
                }
        }

        // xulu.sn
        /**
         * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste
         * erlaubte Flaeche damit die Massstabsbeschaenkungen noch eingehalten
         * werden, FALLS der uebergeben Envelope nicht schon gueltig sein sollte.<br/>
         * Since 21. April 09: Before thecalculation starts, the aspect ratio is
         * corrected. This change implies, that setMapArea() will most of the time
         * not allow setting to a wrong aspectRatio.
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        public Envelope bestAllowedMapArea(Envelope env) {
                if (getWidth() == 0)
                        return env;
                if (env == null)
                        return null;

                Envelope newArea = null;

                /**
                 * Correct the aspect Ratio before we check the rest. Otherwise we might
                 * easily fail. We allow to grow here, because we don't check against
                 * the maxExtend
                 */
                Rectangle curPaintArea = getVisibleRect();

                env = JTSUtil.fixAspectRatio(curPaintArea, env, true);

                final double scale = env.getWidth() / getWidth();
                final double centerX = env.getMinX() + env.getWidth() / 2.;
                final double centerY = env.getMinY() + env.getHeight() / 2.;
                double newWidth2 = 0;
                double newHeight2 = 0;
                if (scale < getMaxZoomScale()) {
                        // ****************************************************************************
                        // Wir zoomen weiter rein als erlaubt => Anpassen des envelope
                        // ****************************************************************************
                        newWidth2 = getMaxZoomScale() * getWidth() / 2.;
                        newHeight2 = getMaxZoomScale() * getHeight() / 2.;
                } else if (scale > getMinZoomScale()) {
                        // ****************************************************************************
                        // Wir zoomen weiter raus als erlaubt => Anpassen des envelope
                        // ****************************************************************************
                        newWidth2 = getMinZoomScale() * getWidth() / 2.;
                        newHeight2 = getMinZoomScale() * getHeight() / 2.;
                } else {
                        // ****************************************************************************
                        // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
                        // ****************************************************************************
                        newArea = env;
                }

                if (newArea == null) {

                        final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
                                        - newHeight2);
                        final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
                                        + newHeight2);

                        newArea = new Envelope(ll, ur);
                }

                Envelope maxAllowedExtend = getMaxExtend();
                while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea)
                                && newArea != null && !newArea.isNull()
                                && !Double.isNaN(newArea.getMinX())
                                && !Double.isNaN(newArea.getMaxX())
                                && !Double.isNaN(newArea.getMinY())
                                && !Double.isNaN(newArea.getMaxY())) {
                        /*
                         * If a maxExtend is set, we have to honour that...
                         */

                        // Exceeds top? Move down and maybe cut
                        if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
                                double divY = newArea.getMaxY() - maxAllowedExtend.getMaxY();
                                // LOGGER.debug("Moving area down by " + divY);

                                newArea = new Envelope(new Coordinate(newArea.getMinX(),
                                                newArea.getMinY() - divY), new Coordinate(newArea
                                                .getMaxX(), newArea.getMaxY() - divY));

                                if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
                                        // LOGGER.debug("Now it exeeds the bottom border.. cut!");
                                        // And cut the bottom if it moved out of the area
                                        newArea = new Envelope(new Coordinate(newArea.getMinX(),
                                                        maxAllowedExtend.getMinY()), new Coordinate(newArea
                                                        .getMaxX(), newArea.getMaxY()));

                                        // LOGGER.debug("and fix aspect ratio");

                                        newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
                                                        false);
                                }
                        }

                        // Exceeds bottom? Move up and maybe cut
                        if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
                                double divY = newArea.getMinY() - maxAllowedExtend.getMinY();
                                // LOGGER.debug("Moving area up by " + divY);

                                newArea = new Envelope(new Coordinate(newArea.getMinX(),
                                                newArea.getMinY() - divY), new Coordinate(newArea
                                                .getMaxX(), newArea.getMaxY() - divY));

                                if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
                                        // LOGGER.debug("Now it exeeds the top border.. cut!");
                                        // And cut the bottom if it moved out of the area
                                        newArea = new Envelope(new Coordinate(newArea.getMinX(),
                                                        newArea.getMinY()), new Coordinate(newArea
                                                        .getMaxX(), maxAllowedExtend.getMaxY()));

                                        // LOGGER.debug("and fix aspect ratio");

                                        newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
                                                        false);
                                }
                        }

                        // Exceeds to the right? move and maybe cut
                        if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {

                                // Move left..
                                double divX = newArea.getMaxX() - maxAllowedExtend.getMaxX();
                                // LOGGER.debug("Moving area left by " + divX);

                                newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
                                                newArea.getMinY()), new Coordinate(newArea.getMaxX()
                                                - divX, newArea.getMaxY()));

                                if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
                                        // LOGGER.debug("Now it exeeds the left border.. cut!");
                                        // And cut the left if it moved out of the area
                                        newArea = new Envelope(new Coordinate(maxAllowedExtend
                                                        .getMinX(), newArea.getMinY()), new Coordinate(
                                                        newArea.getMaxX(), newArea.getMaxY()));

                                        // LOGGER.debug("and fix aspect ratio");

                                        newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
                                                        false);
                                }
                        }

                        // Exceeds to the left? move and maybe cut
                        if (newArea.getMinX() < maxAllowedExtend.getMinX()) {

                                // Move right..
                                double divX = newArea.getMinX() - maxAllowedExtend.getMinX();
                                // LOGGER.debug("Moving area right by " + divX);

                                newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
                                                newArea.getMinY()), new Coordinate(newArea.getMaxX()
                                                - divX, newArea.getMaxY()));

                                if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
                                        // LOGGER.debug("Now it exeeds the right border.. cut!");
                                        // And cut the left if it moved out of the area
                                        newArea = new Envelope(new Coordinate(newArea.getMinX(),
                                                        newArea.getMinY()), new Coordinate(maxAllowedExtend
                                                        .getMaxX(), newArea.getMaxY()));

                                        // LOGGER.debug("and fix aspect ratio");

                                        newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
                                                        false);
                                }
                        }

                }

                return newArea;
        }

        /**
         * Retuns the minimum allowed zoom scale. This is the bigger number value of
         * the two. Defaults to {@link Double}.MAX_VALUE
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        public Double getMinZoomScale() {
                return minZoomScale;
        }

        /**
         * Retuns the maximum allowed zoom scale. This is the smaller number value
         * of the two. Defaults to {@link Double}.MIN_VALUE
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        public Double getMaxZoomScale() {
                return maxZoomScale;
        }

        /**
         * Set the maximum allowed zoom scale. This is the smaller number value of
         * the two. If <code>null</code> is passed, Double.MINVALUE are used which
         * mean there is no restriction.
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        public void setMaxZoomScale(final Double maxZoomScale) {
                this.maxZoomScale = maxZoomScale == null ? Double.MIN_VALUE
                                : maxZoomScale;
        }

        /**
         * Set the minimum (nearest) allowed zoom scale. This is the bigger number
         * value of the two. If <code>null</code> is passed, Double.MAXVALUE are
         * used which mean there is no restriction.
         * 
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        public void setMinZoomScale(final Double minZoomScale) {
                this.minZoomScale = minZoomScale == null ? Double.MAX_VALUE
                                : minZoomScale;
        }

        /**
         * Defines an evelope of the viwable area. The JMapPane will never show
         * anything outside of this extend.
         * 
         * @param maxExtend
         *            <code>null</code> to not have this restriction.
         */
        public void setMaxExtend(Envelope maxExtend) {
                this.maxExtend = maxExtend;
        }

        /**
         * Returns the evelope of the viewable area. The JMapPane will never show
         * anything outside of this extend. If this has been set to
         * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
         * quickly the context's bounds. It it takes to long to determine the
         * context bounds, <code>null</code> is returned.
         * 
         * @param maxExtend
         *            <code>null</code> to not have this restriction.
         */

        public Envelope getMaxExtend() {
                if (maxExtend == null) {
                        final ReferencedEnvelope layerBounds = GTUtil
                                        .getVisibleLayoutBounds(localContext);
                        if (layerBounds == null) {
                                // TODO Last fallback could be the CRS valid area
                                return null;
                        }

                        // Kartenbereich um 10% vergroessern
                        return JTSUtil.fixAspectRatio(this.getBounds(), JTSUtil
                                        .expandEnvelope(layerBounds, 0.1), true);
                }
                return maxExtend;
        }

        /**
         * Set the background color of the map.
         * 
         * @param if <code>null</code>, white is used.
         */
        public void setMapBackgroundColor(Color bgColor) {
                if (bgColor == null)
                        bgColor = Color.WHITE;
                this.mapBackgroundColor = bgColor;
        }

        /**
         * Returns the background {@link Color} of the map pane. Default is white.
         **/
        public Color getMapBackgroundColor() {
                return mapBackgroundColor;
        }

        /**
         * 
         * @param b
         */
        public void setPainting(boolean b) {
                acceptsRepaintCalls = b;
        }

        /**
         * Fuegt der Map einen Listener hinzu.
         * 
         * @param l
         *            neuer Listener
         */
        public void addMapPaneListener(JMapPaneListener l) {
                mapPaneListeners.add(l);
        }

        /**
         * Liste der angeschlossenen Listener, die auf Aktionen des MapPanes
         * lauschen.
         */
        protected Vector<JMapPaneListener> mapPaneListeners = new Vector<JMapPaneListener>();

        /**
         * A flag indicating if dispose() was already called. If true, then further
         * use of this {@link SelectableXMapPane} is undefined.
         */
        private boolean disposed = false;

        /**
         * Entfernt einen Listener von der Map.
         * 
         * @param l
         *            zu entfernender Listener
         */
        public void removeMapPaneListener(JMapPaneListener l) {
                mapPaneListeners.remove(l);
        }

        /** Stored the time used for the last real rendering in ms. **/
        private long lastRenderingDuration = Long.MAX_VALUE;

        // if null, no quick preview will be shown
        private int quickPreviewHint = 0;

        /**
         * For every rendering thread started,
         * {@link GTUtil#createGTRenderer(MapContext)} is called to create a new
         * renderer. These Java2D rendering hints are passed to the
         * {@link GTRenderer}. The java2dHints are the same for all renderers (bg
         * and local).
         */
        private RenderingHints java2dHints;

        /**
         * Returns in milli seconds the time the last rending of the
         * {@link SelectableXMapPane} took. #Long.MAX_VALUE if the JMapPane has not
         * been rendered yet.
         */
        public long getLastRenderingDuration() {
                return lastRenderingDuration;
        }

        /**
         * Should be called when the {@link JMapPane} is not needed no more to help
         * the GarbageCollector
         * 
         * Removes all {@link JMapPaneListener}s that are registered
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        public void dispose() {
                if (isDisposed())
                        return;

                disposed = true;

                if (bgExecuter != null) {
                        bgExecuter.cancelTask();
                }

                if (localExecuter != null) {
                        localExecuter.cancelTask();
                }

                startRenderThreadsTimer.stop();
//              repainterTimer.stop();

                if (bgImage != null)
                        bgImage.flush();
                if (localImage != null)
                        localImage.flush();
                // if (gadgetsImage != null)
                // gadgetsImage.flush();
                if (finalImage != null)
                        finalImage.flush();
                if (preFinalImage != null)
                        preFinalImage.flush();

                // if (dragWaitCursorListener != null)
                // this.removeMouseListener(dragWaitCursorListener);
                // if (mouseWheelZoomListener != null)
                // this.removeMouseWheelListener(mouseWheelZoomListener);

                // Alle mapPaneListener entfernen
                mapPaneListeners.clear();

                removeMouseMotionListener(zoomMapPaneMouseListener);
                removeMouseListener(zoomMapPaneMouseListener);

                if (localContext != null)
                        getContext().clearLayerList();
                if (bgContext != null)
                        getBgContext().clearLayerList();

                removeAll();
        }

        /**
         * A flag indicating if dispose() has already been called. If true, then
         * further use of this {@link SelectableXMapPane} is undefined.
         */
        private boolean isDisposed() {
                return disposed;
        }

        public void setQuickPreviewHint(int quickPreviewHint) {
                this.quickPreviewHint = quickPreviewHint;

        }

        public void setJava2dHints(RenderingHints java2dHints) {
                this.java2dHints = java2dHints;
        }

        public RenderingHints getJava2dHints() {
                return java2dHints;
        }

        /**
         * Zooms towards a point.
         * 
         * @param center
         *            position in window coordinates
         * @param zoomFaktor
         *            > 1 for zoom in, < 1 for zoom out. Default is 1.33.
         */
        public void zoomTo(Point center, Double zoomFaktor) {
                if (zoomFaktor == null || zoomFaktor == 0.)
                        zoomFaktor = 2.;

                Point2D gcenter = getScreenToWorld().transform(center, null);
                center = null;

                if (Double.isNaN(gcenter.getX()) || Double.isNaN(gcenter.getY())
                                || Double.isInfinite(gcenter.getX())
                                || Double.isInfinite(gcenter.getY())

                ) {
                        // Not inside valid CRS area! cancel
                        return;
                }

                final Envelope mapArea = getMapArea();

                Envelope newMapArea = new Envelope(mapArea);
                newMapArea.expandBy((mapArea.getWidth() * zoomFaktor - mapArea
                                .getWidth()) / 2., (mapArea.getHeight() * zoomFaktor - mapArea
                                .getHeight()) / 2.);

                // Move the newMapArea above the new center
                newMapArea.translate(gcenter.getX() - mapArea.centre().x, gcenter
                                .getY()
                                - mapArea.centre().y);

                setMapArea(newMapArea);
        }

        /**
         * Zooms towards a point.
         * 
         * @param center
         *            position in window coordinates
         * @param zoomFactor
         *            > 1 for zoom in, < 1 for zoom out. Default is 1.33
         */
        public void zoomTo(Point center) {
                zoomTo(center, null);
        }

        public void mouseDragged(Point startPos, Point lastPos, MouseEvent event) {

                if ((getState() == XMapPane.PAN)
                                || ((event.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) {

                        if (getCursor() != SwingUtil.PANNING_CURSOR) {
                                setCursor(SwingUtil.PANNING_CURSOR);

                                // While panning, we deactivate the rendering. So the tasts are
                                // ready to start when the panning os done.
                                if (bgExecuter != null)
                                        bgExecuter.cancelTask();
                                if (localExecuter != null)
                                        localExecuter.cancelTask();
                        }

                        if (lastPos.x > 0 && lastPos.y > 0) {
                                final int dx = event.getX() - lastPos.x;
                                final int dy = event.getY() - lastPos.y;

                                // TODO Stop dragging when the drag would not be valid...
                                // boolean dragValid = true;
                                // // check if this panning results in a valid mapArea
                                // {
                                // Rectangle winBounds = xMapPane.getBounds();
                                // winBounds.translate(xMapPane.imageOrigin.x,
                                // -xMapPane.imageOrigin.y);
                                // Envelope newMapAreaBefore = xMapPane.tranformWindowToGeo(
                                // winBounds.x, winBounds.y, winBounds.x
                                // + winBounds.width, winBounds.y
                                // + winBounds.height);
                                //                                      
                                //
                                // winBounds = xMapPane.getBounds();
                                // Point testIng = new Point(xMapPane.imageOrigin);
                                // testIng.translate(dx, dy);
                                // winBounds.translate(testIng.x, -testIng.y);
                                // Envelope newMapAreaAfter = xMapPane.tranformWindowToGeo(
                                // winBounds.x, winBounds.y, winBounds.x
                                // + winBounds.width, winBounds.y
                                // + winBounds.height);
                                //
                                // // If the last drag doesn't change the MapArea anymore cancel
                                // it.
                                // if (xMapPane.bestAllowedMapArea(newMapAreaAfter).equals(
                                // xMapPane.bestAllowedMapArea(newMapAreaBefore))){
                                // dragValid = false;
                                // return;
                                // }
                                // }

                                imageOrigin.translate(dx, dy);
                                updateFinalImage();
                                repaint();
                        }

                } else if ((getState() == XMapPane.ZOOM_IN)
                                || (getState() == XMapPane.ZOOM_OUT)
                                || (getState() == XMapPane.SELECT_ALL)
                                || (getState() == XMapPane.SELECT_TOP)
                // || (getState() == XMapPane.SELECT_ONE_FROM_TOP)
                ) {
                        final Graphics graphics = getGraphics();

                        drawRectangle(graphics, startPos, event.getPoint());

                        if ((lastPos.x > 0) && (lastPos.y > 0)) {
                                drawRectangle(graphics, startPos, lastPos);
                        }

                }

        }

        /**
         * Draws a rectangle in XOR mode from the origin at {@link #startPos} to the
         * given point. All in screen coordinates.
         */
        protected void drawRectangle(final Graphics graphics, Point startPos,
                        Point e) {
                // undraw last box/draw new box
                final int left = Math.min(startPos.x, e.x);
                final int right = Math.max(startPos.x, e.x);
                final int top = Math.max(startPos.y, e.y);
                final int bottom = Math.min(startPos.y, e.y);
                final int width = right - left;
                final int height = top - bottom;

                if (width == 0 && height == 0)
                        return;

                graphics.setXORMode(Color.WHITE);
                graphics.drawRect(left, bottom, width, height);
        }

        /**
         * Finalizes a PAN action
         */
        public void performPan() {
                Rectangle winBounds = getBounds();
                winBounds.translate(-imageOrigin.x, -imageOrigin.y);
                Envelope newMapArea = tranformWindowToGeo(winBounds.x, winBounds.y,
                                winBounds.x + winBounds.width, winBounds.y + winBounds.height);

                imageOrigin.x = 0;
                imageOrigin.y = 0;

                if (!setMapArea(newMapArea)) {
                        updateFinalImage();
                        repaint();
                }

                if (getCursor() == SwingUtil.PANNING_CURSOR)
                        setCursor(SwingUtil.PAN_CURSOR);
        }

        public void onRenderingPending() {
                LOGGER.debug("Pending rendering updates the preview...");
                updateFinalImage();
                XMapPane.this.repaint();
        }

}