skrueger/geotools/XMapPane.java

package skrueger.geotools;

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.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

import javax.swing.Timer;
import javax.swing.border.Border;

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.renderer.lite.RendererUtilities;
import org.geotools.renderer.lite.StreamingRenderer;
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.io.GeoImportUtil;
import schmitzm.geotools.map.event.JMapPaneListener;
import schmitzm.geotools.map.event.MapLayerAdapter;
import schmitzm.lang.LangUtil;
import schmitzm.swing.JPanel;
import schmitzm.swing.SwingUtil;

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

/**
 * The {@link XMapPane} class uses a Geotools {@link GTRenderer} to paint up to
 * two {@link MapContext}s: a "local" {@link MapContext} and a "background"
 * {@link MapContext}. The idea is, that rendering a background layer made up of
 * e.g. OSM data, may take much longer than rendering local data.<br>
 * Every {@link MapContext} is rendered on a {@link Thread} of it's own.
 * Starting/ cancelling these threads is done by the {@link RenderingExecutor}.<br>
 * <br>
 * While the renderers are rending the map, a <br>
 * The {@link XMapPane} is based on schmitzm {@link JPanel}, so
 * {@link #print(Graphics)} will automatically set the background of components
 * to pure white.
 * 
 * The XMapPane has a {@link MouseListener} that manages zooming.<br>
 * A logo/icon to float in the lower left corner may be set with
 * {@link #setMapImage(BufferedImage)}<br>
 * 
 * @see SelectableXMapPane - an extension of {@link XMapPane} that supports
 *      selecting features.
 * 
 * @author stefan
 * 
 */
public class XMapPane extends JPanel {

        // private static final int IMAGETYPE = BufferedImage.TYPE_INT_RGB;
        // private static final int IMAGETYPE_withAlpha =
        // BufferedImage.TYPE_INT_ARGB;
        private static final int IMAGETYPE = BufferedImage.TYPE_3BYTE_BGR;
        private static final int IMAGETYPE_withAlpha = BufferedImage.TYPE_4BYTE_ABGR;

        private final static Logger LOGGER = Logger.getLogger(XMapPane.class);

        private boolean acceptsRepaintCalls = true;

        /**
         * Main {@link MapContext} that holds all layers that are rendered into the
         * {@link #localImage} by the {@link #localRenderer}
         */
        MapContext localContext;

        /**
         * {@link MapContext} holding the background layers. Use it for layers that
         * CAN take very long for rendering, like layer from the Internet: WMS, WFS,
         * OSM...<br>
         * <code>null</code> by default.
         * 
         * @see #setBgContext(MapContext)
         * @see #getBgContext()
         */
        MapContext bgContext;

        /**
         * While threads are working, calls {@link XMapPane#updateFinalImage()}
         * regularly and {@link #repaint()}. This {@link Timer} is stopped when all
         * renderers have finished.
         * 
         * @see INITIAL_REPAINT_DELAYAL
         * @see #REPEATING_REPAINT_DELAY
         */
        final private Timer repaintTimer;

        /**
         * The initial delay in milliseconds until the {@link #finalImage} is
         * updated the first time.
         */
        public static final int INITIAL_REPAINT_DELAY = 900;

        /**
         * While the {@link #bgExecuter} and {@link #localExecuter} are rendering,
         * the {@link #repaintTimer} is regularly updating the {@link #finalImage}
         * with previews.
         */
        public static final int REPEATING_REPAINT_DELAY = 500;

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

        /**
         * This not-repeating {@link Timer} is re-started whenever the component is
         * resized. That means => only if the component is not resizing for
         * {@link #DEFAULT_RESIZING_PAINT_DELAY} milliseconds, does the
         * {@link XMapPane} react.
         */
        private final Timer resizeTimer;

        /**
         * Flag for no-tool.
         */
        public static final int NONE = -123;

        /**
         * 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 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;
        /**
         * Flag fuer Modus
         * "SimpleFeature-Auswahl auf dem obersten (sichtbaren) Layer".
         * 
         * @see #setState(int)
         * @see #setState(int)
         */
        public static final int SELECT_TOP = 4;

        /**
         * {@link Font} used to paint the wait messages into the map
         * 
         * @see #addGadgets(Graphics2D, boolean)
         */
        final static Font waitFont = new Font("Arial", Font.BOLD, 28);

        /**
         * {@link Font} used to paint error messages into the map
         * 
         * @see #addGadgets(Graphics2D, boolean)
         */
        final static Font errorFont = new Font("Arial", Font.BOLD, 13);

        /**
         * If last average last two renderings took more than that many ms, show the
         * user a scaled preview
         **/
        private static final long PRESCALE_MINTIME = 1000;

        /**
         * The wait message painted into the map while rendering is going on on
         * another thread.
         * 
         * @see #addGadgets(Graphics2D, boolean)
         */
        final String waitMsg = SwingUtil.R("WaitMess");

        /**
         * Konvertiert die Maus-Koordinaten (relativ zum <code>JMapPane</code>) in
         * Karten-Koordinaten.
         * 
         * @param e
         *            Maus-Ereignis
         */
        public static Point2D getMapCoordinatesFromEvent(final MouseEvent e) {
                // aktuelle Geo-Position aus GeoMouseEvent ermitteln
                if (e != null && e instanceof MapMouseEvent)
                        try {
                                return ((MapMouseEvent) e).getMapPosition().toPoint2D();
                        } catch (final 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;

                        final 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");
        }

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

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

                }

                @Override
                public void layerChanged(final MapLayerListEvent event) {
                        requestStartRendering();
                }

                @Override
                public void layerMoved(final MapLayerListEvent event) {
                        requestStartRendering();
                }

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

        /**
         * This {@link RenderingExecutor} manages the creation and cancellation of
         * up to one {@link Thread} for rendering the {@link #localContext}.
         */
        private final RenderingExecutor localExecuter = new RenderingExecutor(this);

        /**
         * This {@link RenderingExecutor} manages the creation and cancellation of
         * up to one {@link Thread} for rendering the {@link #bgContext}.
         */
        protected RenderingExecutor bgExecuter;

        /**
         * The {@link #localRenderer} for the {@link #localContext} uses this
         * {@link Image}.
         */
        private BufferedImage localImage;

        /**
         * The {@link #bgRenderer} for the {@link #bgContext} uses this
         * {@link Image}.
         */
        private BufferedImage bgImage;

        /**
         * This {@link Image} is a merge of the {@link #bgImage},
         * {@link #localImage} and {@link #addGadgets(Graphics2D, boolean)}. It is
         * updated with {@link #updateFinalImage()} and used for painting in
         * {@link #paintComponent(Graphics)}
         */
        private BufferedImage finalImage;

        /**
         * Optionally a transparent image to paint over the map in the lower right
         * corner.
         * 
         * @see #addGadgets(Graphics2D)
         * @see #setMapImage(BufferedImage)
         **/
        private BufferedImage mapImage = null;

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

                @Override
                public void layerChanged(final MapLayerEvent event) {
                        requestStartRendering();
                }

                @Override
                public void layerHidden(final MapLayerEvent event) {
                        requestStartRendering();
                }

                @Override
                public void layerShown(final MapLayerEvent event) {
                        requestStartRendering();
                }
        };

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

        /**
         * While dragging, the {@link #updateFinalImage()} method is translating the
         * cached images while setting it together.
         **/
        Point imageOrigin = new Point(0, 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;

        protected LabelCache labelCache = new LabelCacheImpl();

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

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

                        getLocalRenderer().setContext(getMapContext());
                        requestStartRendering();

                }

                @Override
                public void layerChanged(final MapLayerListEvent event) {
                        // localRenderer = GTUtil.createGTRenderer();
                        getLocalRenderer().setContext(getMapContext());
                        requestStartRendering();
                }

                @Override
                public void layerMoved(final MapLayerListEvent event) {
                        getLocalRenderer().setContext(getMapContext());
                        requestStartRendering();
                }

                @Override
                public void layerRemoved(final MapLayerListEvent event) {
                        if (event.getLayer() != null)
                                event.getLayer().removeMapLayerListener(localMapLayerListener);
                        getLocalRenderer().setContext(getMapContext());
                        requestStartRendering();
                }
        };

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

                @Override
                public void layerChanged(final MapLayerEvent event) {
                        getLocalRenderer().setContext(getMapContext()); // betters for SLD
                        // changes?!
                        requestStartRendering();
                }

                @Override
                public void layerHidden(final MapLayerEvent event) {
                        requestStartRendering();
                }

                @Override
                public void layerShown(final MapLayerEvent event) {
                        requestStartRendering();
                }
        };

        final private GTRenderer localRenderer = GTUtil.createGTRenderer();

        private final GTRenderer bgRenderer = GTUtil.createGTRenderer();

        /**
         * the area of the map to draw
         */
        protected Envelope mapArea = null;

        /**
         * 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;

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

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

        /**
         * 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>();

        /**
         * List of listeners of this {@link XMapPane}
         */
        protected Vector<JMapPaneListener> mapPaneListeners = new Vector<JMapPaneListener>();
        /**
         * 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;

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

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

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

        private BufferedImage preFinalImage;

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

        private Map<Object, Object> rendererHints = GTUtil
                        .getDefaultGTRendererHints(getLocalRenderer());

        /**
         * If set to <code>true</code>, the {@link #startRenderThreadsTimer} will
         * start rendering {@link Thread}s
         **/
        private volatile Boolean requestStartRendering = false;

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

        /**
         * 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;

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

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

        private AffineTransform worldToScreen;

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

        /** Is set if a renderer has an error **/
        protected ArrayList<Exception> renderingErrors = new ArrayList<Exception>();

        /**
         * If <code>true</code>, then rendering exceptions are rendererd into the
         * map pane
         **/
        private boolean showExceptions = false;

        public XMapPane() {
                this(null, null);
        }

        /**
         * full constructor extending JPanel
         * 
         * @param rendererHints
         *            may be <code>null</code>. Otherwise a {@link Map<Object,
         *            Object>} of {@link RenderingHints} to override the default
         *            from {@link GTUtil#getDefaultGTRendererHints(GTRenderer)}
         * 
         * @param localContext
         *            The main {@link MapContext} to use. If <code>null</code>, an
         *            empty {@link DefaultMapContext} will be created.
         */
        public XMapPane(final MapContext localContext_,
                        final Map<Object, Object> rendererHints) {
                super(true);

                setRendererHints(rendererHints);

                setOpaque(true);

                if (localContext_ != null)
                        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.
                 */
                resizeTimer = new Timer(DEFAULT_RESIZING_PAINT_DELAY,
                                new ActionListener() {

                                        public void actionPerformed(final ActionEvent e) {
                                                if (!isWellDefined())
                                                        return;

                                                // LOGGER.debug("resizeTimer performed");

                                                // final Rectangle bounds = getVisibleRect();
                                                //
                                                // System.out.println("\n\ntimer performs with bounds = "
                                                // + bounds);

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

                                                paneResized = true;

                                                if (setMapArea(getMapArea())) {

                                                }
                                        }
                                });
                resizeTimer.setRepeats(false);

                this.addComponentListener(new ComponentAdapter() {

                        private Rectangle oldVisibleRect;

                        @Override
                        public void componentResized(final ComponentEvent e) {

                                // Seems to be called twice with the same size..
                                if (oldVisibleRect != null
                                                && oldVisibleRect.equals(getVisibleRect())) {
                                        // LOGGER.debug("skipping resize.");
                                        return;
                                }

                                // LOGGER.debug("resized: " + getVisibleRect());
                                resizeTimer.restart();
                                oldVisibleRect = getVisibleRect();
                        }

                });

                /*
                 * Setting up the repaintTimer. Not started automatically.
                 */
                repaintTimer = new Timer(REPEATING_REPAINT_DELAY, new ActionListener() {

                        @Override
                        public void actionPerformed(final ActionEvent e) {
                                if ((!localExecuter.isRunning())
                                                && (bgExecuter != null && !bgExecuter.isRunning())) {
                                        repaintTimer.stop();
                                } else {
                                        updateFinalImage();
                                        XMapPane.this.repaint(100);

                                }
                        }
                });

                repaintTimer.setInitialDelay(INITIAL_REPAINT_DELAY);
                repaintTimer.setRepeats(true);

                /*
                 * Setting up the startRenderThreadsTimer. This Timer starts
                 * automatically.
                 */
                startRenderThreadsTimer = new Timer(100, new ActionListener() {

                        @Override
                        public void actionPerformed(final ActionEvent e) {
                                synchronized (requestStartRendering) {
                                        if (requestStartRendering && isWellDefined()) {

                                                if (localExecuter.isRunning()) {
                                                        localExecuter.cancelTask();
                                                } else {
                                                        // Stupidly, but we have to recheck the
                                                        setMapArea(getMapArea());
                                                        requestStartRendering = false;
                                                        startRendering();
                                                }
                                        }
                                }
                        }
                });
                startRenderThreadsTimer.start();

        }

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

        /**
         * 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 ReferencedEnvelope bestAllowedMapArea(ReferencedEnvelope 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
                 */
                final 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);
                }

                final 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()) {
                                final 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(getVisibleRect(),
                                                        new ReferencedEnvelope(newArea, env
                                                                        .getCoordinateReferenceSystem()), false);
                                }
                        }

                        // Exceeds bottom? Move up and maybe cut
                        if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
                                final 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(getVisibleRect(),
                                                        new ReferencedEnvelope(newArea, env
                                                                        .getCoordinateReferenceSystem()), false);
                                }
                        }

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

                                // Move left..
                                final 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(getVisibleRect(),
                                                        new ReferencedEnvelope(newArea, env
                                                                        .getCoordinateReferenceSystem()), false);
                                }
                        }

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

                                // Move right..
                                final 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(getVisibleRect(),
                                                        new ReferencedEnvelope(newArea, env
                                                                        .getCoordinateReferenceSystem()), false);
                                }
                        }
                }

                return new ReferencedEnvelope(newArea, env
                                .getCoordinateReferenceSystem());
        }

        /**
         * 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;

                setPainting(false);

                resizeTimer.stop();
                startRenderThreadsTimer.stop();

                disposed = true;

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

                if (localExecuter.isRunning()) {
                        int i = 0;
                        localExecuter.cancelTask();
                        while (i++ < 10 && localExecuter.isRunning()) {
                                try {
                                        Thread.sleep(200);
                                } catch (final InterruptedException e) {
                                        LOGGER
                                                        .warn(
                                                                        "while XMapPane we are waiting for the localExcutor to stop",
                                                                        e);
                                }
                        }
                        if (localExecuter.isRunning()) {
                                LOGGER
                                                .warn("localExecutor Thread still running after 2s! Continuing anyways...");
                        }
                        localExecuter.dispose();
                }

                disposeImages();

                // Remove all mapPaneListeners that have registered with us
                mapPaneListeners.clear();

                removeMouseMotionListener(zoomMapPaneMouseListener);
                removeMouseListener(zoomMapPaneMouseListener);

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

                removeAll();
        }

        /**
         * 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, final Point startPos,
                        final Point e) {

                if (!isWellDefined())
                        return;

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

        /**
         * 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>
         * 
         * @param g
         *            Graphics2D to paint the preview into
         * 
         * @param state
         *            Max be {@link #ZOOM_IN} or {@link #ZOOM_OUT}
         */
        protected boolean drawScaledPreviewImage_Zoom(final Graphics2D graphics) {

                // if (1 == 1)return false;

                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;

                final Rectangle visibleArea = getVisibleRect();

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

                final int xx1 = (int) Math.round(oldMapWindow.getMinX());
                final int yy1 = (int) Math.round(oldMapWindow.getMinY());
                final int xx2 = (int) Math.round(oldMapWindow.getMaxX());
                final 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);

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

                SwingUtil.clearAround(graphics, painedArea, visibleArea,
                                getMapBackgroundColor());

                addGadgets(graphics, true);

                quickPreviewHint = 0;

                repaintTimer.restart();

                // Something has been drawn
                return true;
        }

        public MapContext getBgContext() {
                return bgContext;
        }

        /**
         * Lazyly initializes a {@link BufferedImage} for the background renderer.
         */
        private Image getBgImage() {
                if (bgImage == null) {
                        bgImage = new BufferedImage(getVisibleRect().width,
                                        getVisibleRect().height, IMAGETYPE);
                        SwingUtil.clearImage(finalImage, getMapBackgroundColor());
                }

                return bgImage;
        }

        public MapContext getMapContext() {
                if (localContext == null) {
                        setLocalContext(new DefaultMapContext());
                }
                return localContext;
        }

        private BufferedImage getFinalImage() {
                //
                if (finalImage == null) {
                        // Rectangle curPaintArea = getVisibleRect();
                        finalImage = new BufferedImage(getVisibleRect().width,
                                        getVisibleRect().height, IMAGETYPE);
                        SwingUtil.clearImage(finalImage, getMapBackgroundColor());

                        requestStartRendering();
                }
                return finalImage;
        }

        public RenderingHints getJava2dHints() {
                return java2dHints;
        }

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

                if (localImage == null) {
                        localImage = new BufferedImage(getVisibleRect().width,
                                        getVisibleRect().height, IMAGETYPE_withAlpha);
                        SwingUtil.clearImage(localImage, getMapBackgroundColor());
                }

                return localImage;
        }

        /**
         * Returns a copy of the mapArea
         * 
         * @return
         */
        public ReferencedEnvelope getMapArea() {
                if (mapArea == null) {
                        ReferencedEnvelope mapArea_ = null;
                        try {
                                mapArea_ = localContext.getLayerBounds();
                        } catch (final IOException e) {
                                LOGGER.warn("localContext.getLayerBounds()", e);
                        }

                        if (mapArea_ == null && bgContext != null) {
                                try {
                                        mapArea_ = bgContext.getLayerBounds();
                                } catch (final IOException e) {
                                        LOGGER.warn("bgContext.getLayerBounds()", e);
                                }
                        }

                        if (mapArea_ != null) {
                                mapArea = bestAllowedMapArea(mapArea_);
                                requestStartRendering();
                        }
                }

                if (mapArea == null)
                        return null;

                // TODO is needed at all, this should go to setMapArea maybe
                if (localContext.getCoordinateReferenceSystem() == null)
                        try {
                                localContext.setCoordinateReferenceSystem(GeoImportUtil
                                                .getDefaultCRS());
                        } catch (Exception e) {
                                throw new RuntimeException("setting context CRS:", e);
                        }

                return new ReferencedEnvelope(mapArea, localContext
                                .getCoordinateReferenceSystem());
        }

        /**
         * Returns the background {@link Color} of the map pane. If not set, the
         * methods looks for a parent component and will use its background color.
         * If no parent component is available, WHITE is returned.
         **/
        public Color getMapBackgroundColor() {
                if (mapBackgroundColor == null) {
                        if (getParent() != null)
                                return getParent().getBackground();
                        else
                                return Color.WHITE;
                }
                return mapBackgroundColor;
        }

        /**
         * 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;
        }

        /**
         * 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) {

                        // The next command may take long time!
                        // long start = System.currentTimeMillis();
                        final ReferencedEnvelope layerBounds = GTUtil
                                        .getVisibleLayoutBounds(localContext);
                        //                      
                        // LOGGER.info(
                        // (System.currentTimeMillis()-start)+"m to get maxExtend");
                        //                      
                        if (layerBounds == null) {
                                // // TODO Last fallback could be the CRS valid area
                                return null;
                        }

                        // Vergrößerung um 10% nochmal rausgenommen
                        // // // Kartenbereich um 10% vergroessern
                        // return JTSUtil.fixAspectRatio(getVisibleRect(), JTSUtil
                        // .expandEnvelope(layerBounds, 0.1), true);

                        return JTSUtil.fixAspectRatio(getVisibleRect(), layerBounds, true);
                }
                return maxExtend;
        }

        /**
         * 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;
        }

        /**
         * 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;
        }

        private Image getPreFinalImage() {
                // if (preFinalImage == null) {
                //                      
                // // Rectangle curPaintArea = getVisibleRect();
                // // preFinalImage = new BufferedImage(curPaintArea.width,
                // // curPaintArea.height, BufferedImage.TYPE_INT_RGB);
                //                      
                // preFinalImage = createImage(getBounds().width, getBounds().height);
                //
                // requestStartRendering();
                // }
                return preFinalImage;
        }

        public Map<Object, Object> getRendererHints() {
                // Clear label cache
                labelCache.clear();
                rendererHints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);

                return rendererHints;
        }

        /**
         * 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 int getState() {
                return state;
        }

        /**
         * 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;
        }

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

        /**
         * 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;
        }

        /**
         * 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(final MapLayer layer) {
                final Boolean selectable = mapLayerSelectable.get(layer);
                return selectable == null ? true : selectable;
        }

        /**
         * 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 (getMapContext() == null)
                                return false;
                        if (getMapContext().getLayerCount() <= 0)
                                return false;
                        if (getVisibleRect().getWidth() == 0)
                                return false;
                        if (getVisibleRect().getHeight() == 0)
                                return false;
                        // if (getMapArea() == null)
                        // return false;
                } catch (final Exception e) {
                        return false;
                }
                return true;
        }

        /**
         * Called from the listeners while the mouse is dragging, this method either
         * paints a translated (moved/panned) version of the image, or a rectangle.
         * 
         * @param startPos
         *            in screen coordinates
         * @param lastPos
         *            in screen coordinates
         * @param event
         *            the {@link MouseEvent} to read the mouse buttons from
         */
        public void mouseDragged(final Point startPos, final Point lastPos,
                        final MouseEvent event) {

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

                        // Panning needs a panning coursor
                        if (getCursor() != SwingUtil.PANNING_CURSOR) {
                                setCursor(SwingUtil.PANNING_CURSOR);

                                // While panning, we deactivate the rendering. So the tasks are
                                // ready to start when the panning is finished.
                                if (bgExecuter != null && bgExecuter.isRunning())
                                        bgExecuter.cancelTask();
                                if (localExecuter.isRunning())
                                        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)) {

                        // Draws a rectangle
                        final Graphics2D graphics = (Graphics2D) getGraphics();
                        drawRectangle(graphics, startPos, event.getPoint());
                        if ((lastPos.x > 0) && (lastPos.y > 0))
                                drawRectangle(graphics, startPos, lastPos);
                        graphics.dispose();
                }
        }

        /**
         * Called by the {@link RenderingExecutor} when rendering was cancelled.
         */
        public void onRenderingCancelled() {
                // LOGGER.debug("Rendering cancelled");
                repaintTimer.stop();
        }

        /**
         * Called by the {@link RenderingExecutor} when rendering has been
         * completed.
         * 
         * @param l
         *            long ms the rendering took
         */
        public void onRenderingCompleted(long l) {
                // LOGGER.debug("complete");
                lastRenderingDuration = lastRenderingDuration + l / 2;

                repaintTimer.stop();

                // We "forget" about an exception every time we complete a rendering
                // thread successfully
                if (renderingErrors.size() > 0)
                        renderingErrors.remove(0);

                updateFinalImage();
                repaint();
        }

        /**
         * 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(final Exception renderingError) {

                // Store the exceptions so we can show it to the user:
                if (!(renderingError instanceof java.lang.IllegalArgumentException && renderingError
                                .getMessage().equals(
                                                "Argument \"sourceCRS\" should not be null.")))
                        this.renderingErrors.add(renderingError);
                if (renderingErrors.size() > 3)
                        renderingErrors.remove(0);

                repaintTimer.stop();

                LOGGER.warn("Rendering failed", renderingError);
                updateFinalImage();
                repaint();

        }

        @Override
        protected void paintComponent(final Graphics g) {

                // Maybe update the cursor and maybe stop the repainting timer
                updateCursor();

                if (!acceptsRepaintCalls)
                        return;

                if (!isWellDefined())
                        return;

                if (paneResized) {
                        ((Graphics2D) g).setBackground(getMapBackgroundColor());
                        g.clearRect(0, 0, getVisibleRect().width, getVisibleRect().height);
                        return;
                }

                // super.paintComponent(g); // candidate for removal

                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 (lastRenderingDuration > PRESCALE_MINTIME && mapAreaChanged
                                        && oldMapArea != null
                                        && getMapArea().intersects(oldMapArea)
                                        & !getMapArea().equals(oldMapArea) && !paneResized) {

                                mapAreaChanged = false;

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

                if (!paintedSomething) {

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

                        paintedSomething = true; // cand. for removal
                }

        }

        /**
         * Heavily works on releasing all resources related to the four
         * {@link Image}s used to cache the results of the different renderers.<br>
         * In November 2009 i had some memory leaking problems with {@link XMapPane}
         * . The resources of the buffered images were never released. It seem to be
         * important to call the GC right after flushing the images.<br>
         * Hence this method may take a while, because it calls the GC up to four
         * times.
         */
        private void disposeImages() {

                // System.out.println("vorher = "
                // + new MbDecimalFormatter().format(LangUtil.gcTotal()));
                // bi.flush();
                // return bi = null;
                // System.out.println("nacher = "
                // + new MbDecimalFormatter().format(LangUtil.gcTotal()));
                //
                // System.out.println("\n");

                if (preFinalImage != null) {
                        preFinalImage.flush();
                        preFinalImage = null;
                        LangUtil.gc();
                }
                if (finalImage != null) {
                        finalImage.flush();
                        finalImage = null;
                        LangUtil.gc();
                }
                if (localImage != null) {
                        localImage.flush();
                        localImage = null;
                        LangUtil.gc();
                }
                if (bgImage != null) {
                        bgImage.flush();
                        bgImage = null;
                        LangUtil.gc();
                }

        }

        /**
         * Performs a {@value #PAN} action. During panning, the displacement is
         * stored in {@link #imageOrigin} object. Calling {@link #performPan()} will
         * reset the offset and call {@link #setMapArea(Envelope)}.
         */
        public void performPan() {

                Rectangle winBounds = getVisibleRect();

                winBounds.translate(-imageOrigin.x, -imageOrigin.y);
                final Envelope newMapArea = tranformWindowToGeo(winBounds.x,
                                winBounds.y, winBounds.x + winBounds.width, winBounds.y
                                                + winBounds.height);

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

                if (!setMapArea(newMapArea)) {
                        /**
                         * If setMapArea returns true, the finalImage is updated anyways.
                         * This if-case exists to ensure that we repaint a correct image
                         * even if the new panning area has been denied.
                         */
                        updateFinalImage();
                        repaint();
                }

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

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

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

                localExecuter.cancelTask();

                mapImageInvalid = true;
                if (paneResized) {
                        paneResized = false;
                        disposeImages();
                }
                requestStartRendering = true;

        }

        /**
         * Calculate the affine transforms used to convert between world and pixel
         * coordinates. The calculations here are very basic and assume a cartesian
         * reference system.
         * <p>
         * Tne transform is calculated such that {@code envelope} will be centred in
         * the display
         * 
         * @param envelope
         *            the current map extent (world coordinates)
         * @param paintArea
         *            the current map pane extent (screen units)
         */
        private void resetTransforms() {
                ReferencedEnvelope refMapEnv = new ReferencedEnvelope(mapArea,
                                getMapContext().getCoordinateReferenceSystem());

                // System.out
                // .println("paintArea in resetTeansofrms = " + getVisibleRect());
                if (!isWellDefined())
                        return;

                worldToScreen = RendererUtilities.worldToScreenTransform(refMapEnv,
                                getVisibleRect());

                try {
                        screenToWorld = worldToScreen.createInverse();

                } catch (NoninvertibleTransformException ex) {
                        LOGGER
                                        .error("can't invert worldToScreen to get screenToWorld!",
                                                        ex);
                }
        }

        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 (final 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 (final MapLayer mapLayer : bgContext.getLayers()) {
                                mapLayer.addMapLayerListener(bgMapLayerListener);
                        }
                }

                requestStartRendering();
        }

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

        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 (final MapLayer mapLayer : localContext.getLayers()) {
                                mapLayer.removeMapLayerListener(localMapLayerListener);
                        }
                }

                this.localContext = context;

                if (context != null) {

                        // setMapArea(localContext.getAreaOfInterest());

                        getLocalRenderer().setContext(localContext);

                        this.localContext.addMapLayerListListener(localContextListener);

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

                requestStartRendering();

        }

        public void setBorder(Border b) {
                super.setBorder(b);
        }

        /**
         * Triggers to repaint (fast) and re-render (slow) the JMapPane.
         */
        public void refresh() {
                mapImageInvalid = true;
                repaint();
        }

        // /**
        // * Triggers to use new {@link GTRenderer} and refresh the map. Should be
        // * called after {@link Style}s have been changed because GTRenderer is
        // * otherwise not working well.
        // */
        // public void refreshRenderers() {
        // localRenderer = GTUtil.createGTRenderer();
        // setLocalContext(getMapContext());
        // mapImageInvalid = true;
        // repaint();
        // }

        /**
         * Set the new map area.
         * 
         * @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)
                        return false;
                if (getMapContext().getCoordinateReferenceSystem() == null)
                        return false;
                return setMapArea(new ReferencedEnvelope(newMapArea, getMapContext()
                                .getCoordinateReferenceSystem()));
        }

        /**
         * Set the new map area.
         * 
         * @param newMapArea
         * @return <code>true</code> if the mapArea has been changed and a repaint
         *         has been triggered.
         */
        public boolean setMapArea(final ReferencedEnvelope 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;
                }

                final Envelope candNew = bestAllowedMapArea(newMapArea);

                // Testing, whether the difference if just minimal
                if (mapArea != null) {
                        final double tolX = mapArea.getWidth() / 1000.;
                        final 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;
                        }
                }

                // New map are is accepted:
                oldMapArea = mapArea;
                mapArea = candNew;
                resetTransforms();

                if (localContext != null) {
                        localContext.setAreaOfInterest(mapArea, localContext
                                        .getCoordinateReferenceSystem());
                }
                if (bgContext != null) {
                        bgContext.setAreaOfInterest(mapArea, localContext
                                        .getCoordinateReferenceSystem());
                }

                mapAreaChanged = true;

                repaint(200); // Do not remove it!

                requestStartRendering();

                return true;
        }

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

        /**
         * 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(final BufferedImage mapImage) {
                this.mapImage = mapImage;
        }

        /**
         * 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(final MapLayer layer,
                        final Boolean selectable) {
                if (selectable == null)
                        mapLayerSelectable.remove(layer);
                else
                        mapLayerSelectable.put(layer, selectable);
        }

        /**
         * 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(final Envelope maxExtend) {
                this.maxExtend = maxExtend;
        }

        /**
         * 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;
        }

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

        /**
         * 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;
        }

        /**
         * If <code>true</code>, allow the {@link XMapPane} to process #repaint()
         * requests. Otherwise the map will not paint anything and not start any
         * rendering {@link Thread}s.
         */
        public void setPainting(final boolean b) {
                acceptsRepaintCalls = b;
                if (acceptsRepaintCalls == true)
                        repaint();
        }

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

        /**
         * 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();
        }

        /**
         * 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(final Cursor cursor) {
                this.staticCursor = cursor;
                if (cursor != null)
                        super.setCursor(cursor);
        }

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

                if (!isWellDefined() || !acceptsRepaintCalls) {
                        // if we are not ready to start rendering, try it again the next
                        // time the timer is chacking the flag.
                        requestStartRendering = true;
                        return;
                }

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

                localExecuter.cancelTask();

                final Rectangle curPaintArea = getVisibleRect();

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

                if (getBgContext() != null) {
                        bgRenderer.setJava2DHints(getJava2dHints());
                        bgRenderer.setRendererHints(getRendererHints());

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

                if (getMapContext() != null) {
                        // localExecuter = new RenderingExecutor(this, 150l);
                        // LOGGER.debug("starting local renderer:");

                        getLocalRenderer().setJava2DHints(getJava2dHints());
                        getLocalRenderer().setRendererHints(getRendererHints());

                        final boolean submitted = localExecuter.submit(getMapArea(),
                                        curPaintArea, (Graphics2D) getLocalImage().getGraphics(),
                                        getLocalRenderer());
                        if (submitted)
                                repaintTimer.restart();
                        else
                                requestStartRendering = true; // Try to start rendering
                        // again in
                        // a moment
                }

                updateCursor();
        }

        /**
         * 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(final double ox, final double oy,
                        final double px, final double py) {
                final AffineTransform at = getWorldToScreenTransform();
                Point2D geoO;
                // try {
                geoO = at.transform(new Point2D.Double(ox, oy), null);
                final Point2D geoP = at.transform(new Point2D.Double(px, py), null);
                return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP.getY());
                // } catch (final NoninvertibleTransformException e) {
                // LOGGER.error(e);
                // return new Envelope(ox, oy, px, py);
                // }
        }

        /**
         * 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(final int ox, final int oy,
                        final int px, final int py) {
                final AffineTransform at = getScreenToWorld();
                final Point2D geoO = at.transform(new Point2D.Double(ox, oy), null);
                final Point2D geoP = at.transform(new Point2D.Double(px, py), null);

                // Mmmmm... don't really understand why its x,x,y,y
                // return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(),
                // geoP.getY());
                return new Envelope(new Coordinate(geoO.getX(), geoO.getY()),
                                new Coordinate(geoP.getX(), geoP.getY()));
        }

        /**
         * Will update the cursor. If all rendering is finished also stops the
         * {@link #repaintTimer}
         */
        public void updateCursor() {

                // if the renderers have stopped, also stop the timer that is updating
                // the final image
                if (bgExecuter != null && bgExecuter.isRunning()
                                || localExecuter.isRunning()) {
                        setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
                        return;
                } else {
                        // Allow one last rendering
                        if (repaintTimer.isRunning()) {
                                // System.out.println("one last rendering....");
                                repaintTimer.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;
                }

                // Set the cursor depending on what tool is in use...
                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(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                        break;
                }
        }

        /**
         * The renderers are all rendering into their own {@link Image}s. This
         * method combines all images to one {@link #finalImage}. The
         * {@link #repaintTimer} is calling this method regularely to update the
         * {@link #finalImage} even if the renderers are still working.
         */
        synchronized protected Image updateFinalImage() {

                // Render the two map images first, into the preFinalImage
                if (bgExecuter != null) {
                        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();

                } else {
                        preFinalImage = getLocalImage();
                }

                final Graphics2D finalG = getFinalImage().createGraphics();
                finalG.setBackground(getMapBackgroundColor());
                finalG.drawImage(getPreFinalImage(), imageOrigin.x, imageOrigin.y,
                                getMapBackgroundColor(), null);

                // What was it good for?
                // final int finalImageHeight = getFinalImage().getHeight();
                // final int finalImageWidth = getFinalImage().getWidth();
                // final Rectangle painedArea = new Rectangle(imageOrigin.x,
                // imageOrigin.y, finalImageWidth, finalImageHeight);
                // SwingUtil.clearAround(finalG, painedArea, getVisibleRect(),
                // getMapBackgroundColor());

                addGadgets(finalG, false);

                finalG.dispose();

                return finalImage;
        }

        /**
         * Paints some optional stuff into the given {@link Graphics2D}. Usually
         * called as the last layer when {@link #updateFinalImage()}
         * 
         * @param forceWait
         *            if <code>true</code>, a Wait-message will be painted even
         *            though the rendering threads may not yet have started. If
         *            <code>false</code>, it will only depend on
         *            {@link #localExecuter.isRunning} and #bgExecuter.isRunning
         */
        private void addGadgets(final Graphics2D graphics, boolean forceWait) {

                // Paint a logo to the bottom right if available
                if (mapImage != null) {
                        Rectangle visibleRect = getVisibleRect();
                        graphics.drawImage(mapImage, visibleRect.width
                                        - mapImage.getWidth() - 10, getVisibleRect().height
                                        - mapImage.getHeight() - 10, null);
                }

                int y = 17;

                // If the rendering process is still running, indicate this is the image
                if (forceWait || bgExecuter != null && bgExecuter.isRunning()
                                || localExecuter.isRunning()) {

                        y += 8;

                        final Color c = graphics.getColor();
                        graphics.setFont(waitFont);

                        graphics.setColor(getMapBackgroundColor());
                        graphics.drawString(waitMsg, 5, y);
                        graphics.setColor(getMapBackgroundColor());
                        graphics.drawString(waitMsg, 7, y + 2);
                        graphics.setColor(Color.BLACK);
                        graphics.drawString(waitMsg, 6, y + 1);

                        graphics.setColor(c);

                        y += 21;
                }

                if (!renderingErrors.isEmpty() && isShowExceptions()) {

                        final Color c = graphics.getColor();
                        graphics.setFont(errorFont);

                        for (Exception ex : renderingErrors) {

                                String errStr = ex.getLocalizedMessage();

                                if (errStr == null)
                                        errStr = ex.getMessage();
                                if (errStr == null)
                                        errStr = "unknown error: " + ex.getClass().getSimpleName();

                                graphics.setColor(getMapBackgroundColor());
                                graphics.drawString(errStr, 5, y);
                                graphics.setColor(Color.RED);
                                graphics.drawString(errStr, 6, y + 1);

                                y += 19;
                        }

                        graphics.setColor(c);
                }

        }

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

                // if (!isWellDefined()) return;

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

                ReferencedEnvelope _mapArea;
                if (mapArea == null)
                        _mapArea = features.getBounds();
                else
                        _mapArea = getMapArea();
                double width = _mapArea.getWidth();
                double height = _mapArea.getHeight();
                final 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'
                        final SimpleFeature singleFeature = 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 (final FactoryException e) {
                                        LOGGER.error("Looking for a Math transform", e);
                                } catch (final TransformException e) {
                                        LOGGER.error("Looking for a Math transform", e);
                                }
                        }

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

                        final Envelope newMapArea = new Envelope(newLeftBottom, newTopRight);

                        setMapArea(newMapArea);

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

                        ReferencedEnvelope bounds;
                        if (!mapCRS.equals(fCRS)) {
                                bounds = JTSUtil.transformEnvelope(fBounds, 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);
                }
        }

        /**
         * 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(final Point center) {
                zoomTo(center, null);
        }

        /**
         * 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.;

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

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

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

                setMapArea(newMapArea);
        }

        /**
         * Shall non-fatal rendering exceptions be reported in the mappane or be
         * dropped quitely.
         */
        public void setShowExceptions(boolean showExceptions) {
                this.showExceptions = showExceptions;
        }

        /**
         * Shall exceptions be reported in the mappane?
         */
        public boolean isShowExceptions() {
                return showExceptions;
        }

        public GTRenderer getLocalRenderer() {
                return localRenderer;
        }

}