/[schmitzm]/trunk/src/skrueger/geotools/XMapPane.java

Diff of /trunk/src/skrueger/geotools/XMapPane.java

Parent Directory | Revision Log | View Patch Patch

-branches/1.0-gt2-2.6/src/gtmig/org/geotools/swing/XMapPane.java
revision 529 by alfonx,
Wed Nov 18 20:47:00 2009 UTC
+branches/1.0-gt2-2.6/src/skrueger/geotools/XMapPane.java
revision 553 by alfonx,
Mon Nov 23 21:39:17 2009 UTC
 Line 1
- /*
+ package skrueger.geotools;
-  *    GeoTools - OpenSource mapping toolkit
-  *    http://geotools.org
-  *    (C) 2002-2006, GeoTools Project Managment Committee (PMC)
-  *
-  *    This library is free software; you can redistribute it and/or
-  *    modify it under the terms of the GNU Lesser General Public
-  *    License as published by the Free Software Foundation;
-  *    version 2.1 of the License.
-  *
-  *    This library is distributed in the hope that it will be useful,
-  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
-  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  *    Lesser General Public License for more details.
-  */
- package gtmig.org.geotools.swing;
- /**
-  * This class is 50% copied from GeoTools 2.6.x JMapPane. GeoTools is LGPL, SCHMITZM also.<br/>
-  * In addition to
-  */
  import java.awt.Color;
  import java.awt.Cursor;
-Line 41 
 import java.awt.geom.NoninvertibleTransf
+Line 21 
 import java.awt.geom.NoninvertibleTransf
  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.JPanel;
  import javax.swing.Timer;
  import org.apache.log4j.Logger;
-Line 63 
 import org.geotools.referencing.CRS;
+Line 43 
 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;
-Line 78 
 import org.opengis.referencing.operation
+Line 59 
 import org.opengis.referencing.operation
  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 skrueger.geotools.RenderingExecutor;
- import skrueger.swing.formatter.MbDecimalFormatter;
  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 Logger LOGGER = Logger.getLogger(XMapPane.class);
+         private boolean acceptsRepaintCalls = true;
          /**
-          * Sets whether a layer is regarded or ignored on {@link #SELECT_TOP},
+          * Main {@link MapContext} that holds all layers that are rendered into the
-          * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions.
+          * {@link #localImage} by the {@link #localRenderer}
-          *
-          * @param layer
-          *            a layer
-          * @param selectable
-          *            if {@code false} the layer is ignored during the upper
-          *            mentioned actions. If <code>null</code>, the default (true)
-          *            will be used.
           */
-         public void setMapLayerSelectable(MapLayer layer, Boolean selectable) {
+         MapContext localContext;
-                 if (selectable == null)
-                         mapLayerSelectable.remove(layer);
-                 else
-                         mapLayerSelectable.put(layer, selectable);
-         }
          /**
-          * Holds a flag for each layer, whether it is regarded or ignored on
+          * {@link MapContext} holding the background layers. Use it for layers that
-          * {@link #SELECT_TOP}, {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP}
+          * CAN take very long for rendering, like layer from the Internet: WMS, WFS,
-          * actions.
+          * OSM...<br>
+          * <code>null</code> by default.
+          *
+          * @see #setBgContext(MapContext)
+          * @see #getBgContext()
           */
-         final protected HashMap<MapLayer, Boolean> mapLayerSelectable = new HashMap<MapLayer, Boolean>();
+         MapContext bgContext;
          /**
-          * Returns whether a layer is regarded or ignored on {@link #SELECT_TOP},
+          * While threads are working, calls {@link XMapPane#updateFinalImage()}
-          * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions. Returns
+          * regularly and {@link #repaint()}. This {@link Timer} is stopped when all
-          * <code>true</code> if the selectability has not been defined.
+          * renderers have finished.
           *
-          * @param layer
+          * @see INITIAL_REPAINT_DELAYAL
-          *            a layer
+          * @see #REPEATING_REPAINT_DELAY
           */
-         public boolean isMapLayerSelectable(MapLayer layer) {
+         final private Timer repaintTimer;
-                 Boolean selectable = mapLayerSelectable.get(layer);
-                 return selectable == null ? true : selectable;
-         }
          /**
-          * Flag fuer Modus "Kartenausschnitt bewegen". Nicht fuer Window-Auswahl
+          * The initial delay in milliseconds until the {@link #finalImage} is
-          * moeglich!
+          * updated the first time.
-          *
-          * @see #setState(int)
           */
-         public static final int PAN = 1;
+         public static final int INITIAL_REPAINT_DELAY = 1000;
          /**
-          * Flag fuer Modus "Heran zoomen".
+          * While the {@link #bgExecuter} and {@link #localExecuter} are rendering,
-          *
+          * the {@link #repaintTimer} is regularly updating the {@link #finalImage}
-          * @see #setState(int)
+          * with previews.
-          * @see #setState(int)
           */
-         public static final int ZOOM_IN = 2;
+         public static final int REPEATING_REPAINT_DELAY = 500;
          /**
-          * Flag fuer Modus "Heraus zoomen". Nicht fuer Window-Auswahl moeglich!
+          * Default delay (milliseconds) before the map will be redrawn when resizing
+          * the pane. This is to avoid flickering while drag-resizing.
           *
-          * @see #setState(int)
+          * @see #resizeTimer
           */
-         public static final int ZOOM_OUT = 3;
+         public static final int DEFAULT_RESIZING_PAINT_DELAY = 600;
+         private final Timer resizeTimer;
+         public static final int NONE = -123;
          /**
-          * Flag fuer Modus
+          * Flag fuer Modus "Kartenausschnitt bewegen". Nicht fuer Window-Auswahl
-          * "SimpleFeature-Auswahl auf dem obersten (sichtbaren) Layer".
+          * moeglich!
           *
           * @see #setState(int)
-          * @see #setState(int)
           */
-         public static final int SELECT_TOP = 4;
+         public static final int PAN = 1;
          /**
           * Flag fuer Modus "SimpleFeature-Auswahl auf allen (sichtbaren) Layern".
           *
-Line 173 
 public class XMapPane extends JPanel {
+Line 177 
 public class XMapPane extends JPanel {
           * @see #setState(int)
           */
          public static final int SELECT_ONE_FROM_TOP = 104;
          /**
-          * While threads are working, we call {@link XMapPane#updateFinalImage()}
+          * Flag fuer Modus
-          * regularly and repaint(). This {@link Timer} is stopped when all renderers
+          * "SimpleFeature-Auswahl auf dem obersten (sichtbaren) Layer".
-          * have finished.
+          *
+          * @see #setState(int)
+          * @see #setState(int)
           */
-         final private Timer repainterTimer;
+         public static final int SELECT_TOP = 4;
-         /**
+         public static final Cursor WAIT_CURSOR = Cursor
-          * While the {@link #bgExecuter} and {@link #localExecuter} are rendering,
+                         .getPredefinedCursor(Cursor.WAIT_CURSOR);
-          * the {@link #repainterTimer} is regularly updating the {@link #finalImage}
-          * with previews.
-          */
-         public static final long REPEATING_REPAINT_DELAY = 500;
          /**
-          * The initial delay in milliseconds until the {@link #finalImage} is
+          * {@link Font} used to paint the wait messages into the map
-          * updated the first time.
+          *
+          * @see #addGadgets(Graphics2D, boolean)
           */
-         public static final long INITIAL_REPAINT_DELAY = 1000;
+         final static Font waitFont = new Font("Arial", Font.BOLD, 30);
-         protected RenderingExecutor bgExecuter;
          /**
-          * the map context to render
+          * {@link Font} used to paint error messages into the map
-          */
+          *
-         MapContext localContext;
+          * @see #addGadgets(Graphics2D, boolean)
-         /**
-          * the map context to render
           */
-         MapContext bgContext;
+         final static Font errorFont = new Font("Arial", Font.BOLD, 13);
          /**
-          * the area of the map to draw
+          * The wait message painted into the map while rendering is going on on
+          * another thread.
+          *
+          * @see #addGadgets(Graphics2D, boolean)
           */
-         protected Envelope mapArea = null;
+         final String waitMsg = SwingUtil.R("WaitMess");
-         /**
-          * We store the old mapArea for a moment to use it for the
-          * "quick scaled preview" in case of ZoomOut
-          **/
-         protected Envelope oldMapArea = null;
          /**
-          * compass and icon are rendered into this image
+          * Flag fuer Modus "Heran zoomen".
+          *
+          * @see #setState(int)
+          * @see #setState(int)
           */
-         // protected BufferedImage gadgetsImage;
+         public static final int ZOOM_IN = 2;
          /**
-          * The default state is ZOOM_IN, hence by default the
+          * Flag fuer Modus "Heraus zoomen". Nicht fuer Window-Auswahl moeglich!
-          * {@link #zoomMapPaneMouseListener} is also enabled.
+          *
-          **/
+          * @see #setState(int)
-         private int state = ZOOM_IN;
+          */
+         public static final int ZOOM_OUT = 3;
          /**
           * Konvertiert die Maus-Koordinaten (relativ zum <code>JMapPane</code>) in
 Line 233 
 public class XMapPane extends JPanel {
           * @param e
           *            Maus-Ereignis
           */
-         public static Point2D getMapCoordinatesFromEvent(MouseEvent e) {
+         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 (Exception err) {
+                         } catch (final Exception err) {
                                  LOGGER
                                                  .error(
                                                                  "return ((GeoMouseEvent) e).getMapCoordinate(null).toPoint2D();",
 Line 253 
 public class XMapPane extends JPanel {
                          if (!xMapPane.isWellDefined())
                                  return null;
-                         AffineTransform at = xMapPane.getScreenToWorld();
+                         final AffineTransform at = xMapPane.getScreenToWorld();
                          if (at != null)
                                  return at.transform(e.getPoint(), null);
                          return null;
 Line 263 
 public class XMapPane extends JPanel {
          }
          /**
+          * 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);
+                         localRenderer.setContext(getMapContext());
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerChanged(final MapLayerListEvent event) {
+                         localRenderer.setContext(getMapContext());
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerMoved(final MapLayerListEvent event) {
+                         localRenderer.setContext(getMapContext());
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerRemoved(final MapLayerListEvent event) {
+                         if (event.getLayer() != null)
+                                 event.getLayer().removeMapLayerListener(localMapLayerListener);
+                         localRenderer.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) {
+                         localRenderer.setContext(getMapContext()); // betters for SLD changes?!
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerHidden(final MapLayerEvent event) {
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerShown(final MapLayerEvent event) {
+                         requestStartRendering();
+                 }
+         };
+         private final 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 = Color.WHITE;
+         /**
           * A flag indicating that the shown image is invalid and needs to be
           * re-rendered.
           */
          protected boolean mapImageInvalid = true;
-         protected LabelCache labelCache = new LabelCacheImpl();
+         /**
+          * 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;
          /**
-          * This color is used as the default background color when painting a map.
+          * We store the old mapArea for a moment to use it for the
-          */
+          * "quick scaled preview" in case of ZoomOut
-         private Color mapBackgroundColor = Color.WHITE;
+          **/
+         protected Envelope oldMapArea = null;
          /**
-          * This {@link MouseListener} is managing all zoom related tasks
+          * We store the old transform for a moment to use it for the
-          */
+          * "quick scaled preview" in case of ZoomIn
-         public final ZoomXMapPaneMouseListener zoomMapPaneMouseListener = new ZoomXMapPaneMouseListener(
+          **/
-                         this);
+         protected AffineTransform oldScreenToWorld = null;
          /**
           * A flag indicating, that the image size has changed and the buffered
-Line 296 
 public class XMapPane extends JPanel {
+Line 505 
 public class XMapPane extends JPanel {
           **/
          protected boolean paneResized = false;
+         private BufferedImage preFinalImage;
+         // if null, no quick preview will be shown
+         private int quickPreviewHint = 0;
+         private Map<Object, Object> rendererHints = GTUtil
+                         .getDefaultGTRendererHints(localRenderer);
+         /**
+          * 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
-Line 303 
 public class XMapPane extends JPanel {
+Line 532 
 public class XMapPane extends JPanel {
           */
          final private Timer startRenderThreadsTimer;
-         private Map<Object, Object> rendererHints;
+         /**
+          * The default state is ZOOM_IN, hence by default the
+          * {@link #zoomMapPaneMouseListener} is also enabled.
+          **/
+         private int state = ZOOM_IN;
-         public Map<Object, Object> getRendererHints() {
+         /**
-                 return rendererHints;
+          * Manuell gesetzter statischer Cursor, unabhaengig von der aktuellen
-         }
+          * MapPane-Funktion
+          */
+         protected Cursor staticCursor = null;
+         private AffineTransform worldToScreen;
          /**
-          * Nuetzlich wenn die Componente gedruckt (z.B. wenn ein Screenshot gemacht
+          * This {@link MouseListener} is managing all zoom related tasks
-          * wird) wird. Dann werden wird der Hintergrund auf WEISS gesetzt.
-          *
-          * @author <a href="mailto:[email protected]">Stefan Alfons
-          *         Kr&uuml;ger</a>
           */
-         @Override
+         public final ZoomXMapPaneMouseListener zoomMapPaneMouseListener = new ZoomXMapPaneMouseListener(
-         public void print(Graphics g) {
+                         this);
-                 Color orig = getBackground();
-                 setBackground(Color.WHITE);
-                 // wrap in try/finally so that we always restore the state
+         /** Is set if a renderer has an error **/
-                 try {
+         protected ArrayList<Exception> renderingErrors = new ArrayList<Exception>();
-                         super.print(g);
-                 } finally {
+         /** If <code>true</code>, then rendering exceptions are rendererd into the map pane **/
-                         setBackground(orig);
+         private boolean showExceptions= false;
-                 }
+         // /** If {@link #getVisibleRect()} of this {@link JPanel} is not yet
+         // defined, but we are **/
+         // private Envelope mapAreaCondidate = null;
+         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 layout
-          *            - layout (probably shouldn't be set)
-          * @param isDoubleBuffered
-          *            - a Swing thing I don't really understand
-          * @param render
-          *            - what to draw the map with
           * @param localContext
-          *            - {@link MapContext} of layer to render.
+          *            The main {@link MapContext} to use. If <code>null</code>, an
+          *            empty {@link DefaultMapContext} will be created.
           */
          public XMapPane(final MapContext localContext_,
-                         Map<Object, Object> rendererHints) {
+                         final Map<Object, Object> rendererHints) {
                  super(true);
                  setRendererHints(rendererHints);
                  setOpaque(true);
-                 localRenderer = GTUtil.createGTRenderer();
-                 localRenderer.setJava2DHints(getJava2dHints());
                  if (localContext_ != null)
                          setLocalContext(localContext_);
-Line 371 
 public class XMapPane extends JPanel {
+Line 603 
 public class XMapPane extends JPanel {
                   * Using a ComponentListener doesn't work because, unlike a JFrame, the
                   * pane receives a stream of events during drag-resizing.
                   */
-                 resizingPaintDelay = DEFAULT_RESIZING_PAINT_DELAY;
+                 resizeTimer = new Timer(DEFAULT_RESIZING_PAINT_DELAY,
-                 resizeTimer = new Timer(resizingPaintDelay, new ActionListener() {
+                                 new ActionListener() {
-                         public void actionPerformed(ActionEvent e) {
-                                 paneResized = true;
-                                 if (!isWellDefined())
-                                         return;
-                                 Rectangle bounds = getVisibleRect();
-                                 Envelope geoMapArea = tranformWindowToGeo(bounds.x, bounds.y,
-                                                 bounds.x + bounds.width, bounds.y + bounds.height);
-                                 setMapArea(bestAllowedMapArea(geoMapArea));
+                                         public void actionPerformed(final ActionEvent e) {
-                         }
+                                                 if (!isWellDefined())
-                 });
+                                                         return;
+                                                 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);
+                                                 if (setMapArea(geoMapArea))
+                                                         paneResized = true;
+                                                 // else
+                                                 // syso
+                                         }
+                                 });
                  resizeTimer.setRepeats(false);
                  this.addComponentListener(new ComponentAdapter() {
                          @Override
-                         public void componentResized(ComponentEvent e) {
+                         public void componentResized(final ComponentEvent e) {
+                                 // Already cancel the tasks...
                                  if (bgExecuter != null)
                                          bgExecuter.cancelTask();
                                  if (localExecuter != null)
                                          localExecuter.cancelTask();
                                  resizeTimer.restart();
                          }
                  });
-                 repainterTimer = new Timer((int) REPEATING_REPAINT_DELAY,
+                 /*
-                                 new ActionListener() {
+                  * Setting up the repaintTimer. Not started automatically.
+                  */
+                 repaintTimer = new Timer(REPEATING_REPAINT_DELAY, new ActionListener() {
-                                         @Override
+                         @Override
-                                         public void actionPerformed(ActionEvent e) {
+                         public void actionPerformed(final ActionEvent e) {
-                                                 updateFinalImage();
+                                 if ((localExecuter != null && !localExecuter.isRunning())
-                                                 XMapPane.this.repaint();
+                                                 && (bgExecuter != null && !bgExecuter.isRunning())) {
-                                         }
+                                         repaintTimer.stop();
-                                 });
+                                 } else {
-                 repainterTimer.setInitialDelay(300);
+                                         updateFinalImage();
-                 repainterTimer.setRepeats(true);
+                                         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(ActionEvent e) {
+                         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();
                                                  }
-Line 435 
 public class XMapPane extends JPanel {
+Line 690 
 public class XMapPane extends JPanel {
          }
-         // TODO doku
+         /**
-         public XMapPane() {
+          * Fuegt der Map einen Listener hinzu.
-                 this(null, null);
+          *
+          * @param l
+          *            neuer Listener
+          */
+         public void addMapPaneListener(final JMapPaneListener l) {
+                 mapPaneListeners.add(l);
          }
          /**
-          * Sets the mapArea to best possibly present the given features. If only one
+          * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste
-          * single point is given, the window is moved over the point.
+          * erlaubte Flaeche damit die Massstabsbeschaenkungen noch eingehalten
-          *
+          * werden, FALLS der uebergeben Envelope nicht schon gueltig sein sollte.<br>
-          * Note: The method does not call {@link #repaint()} on the
+          * Since 21. April 09: Before thecalculation starts, the aspect ratio is
-          * {@link SelectableXMapPane} .
+          * corrected. This change implies, that setMapArea() will most of the time
+          * not allow setting to a wrong aspectRatio.
           *
-          * @param features
+          * @author <a href="mailto:[email protected]">Stefan Alfons
-          *            if <code>null</code> or size==0, the function doesn nothing.
+          *         Kr&uuml;ger</a>
           */
-         public void zoomTo(
+         public ReferencedEnvelope bestAllowedMapArea(ReferencedEnvelope env) {
-                         FeatureCollection<SimpleFeatureType, SimpleFeature> features) {
-                 CoordinateReferenceSystem mapCRS = getContext()
+                 if (getWidth() == 0)
-                                 .getCoordinateReferenceSystem();
+                         return env;
-                 CoordinateReferenceSystem fCRS = features.getSchema()
-                                 .getGeometryDescriptor().getCoordinateReferenceSystem();
-                 double width = mapArea.getWidth();
+                 if (env == null)
-                 double height = mapArea.getHeight();
+                         return null;
-                 double ratio = height / width;
-                 if (features == null || features.size() == 0) {
+                 Envelope newArea = null;
-                         // 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'
+                  * Correct the aspect Ratio before we check the rest. Otherwise we might
-                         SimpleFeature singleFeature = (SimpleFeature) features.iterator()
+                  * easily fail. We allow to grow here, because we don't check against
-                                         .next();
+                  * the maxExtend
+                  */
+                 final Rectangle curPaintArea = getVisibleRect();
-                         if (((Geometry) singleFeature.getDefaultGeometry())
+                 env = JTSUtil.fixAspectRatio(curPaintArea, env, true);
-                                         .getCoordinates().length > 1) {
-                                 // System.out.println("Zoomed to only pne poylgon");
+                 final double scale = env.getWidth() / getWidth();
-                                 // Poly
+                 final double centerX = env.getMinX() + env.getWidth() / 2.;
-                                 // TODO max width vs. height
+                 final double centerY = env.getMinY() + env.getHeight() / 2.;
-                                 width = features.getBounds().getWidth() * 3;
+                 double newWidth2 = 0;
-                                 height = ratio * width;
+                 double newHeight2 = 0;
-                         } else {
+                 if (scale < getMaxZoomScale()) {
-                                 // System.out.println("Zoomed in a bit becasue only one point");
+                         // ****************************************************************************
-                                 // width *= .9;
+                         // Wir zoomen weiter rein als erlaubt => Anpassen des envelope
-                                 // height *= .9;
+                         // ****************************************************************************
+                         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);
+                                 }
                          }
-                         Coordinate centre = features.getBounds().centre();
+                         // Exceeds bottom? Move up and maybe cut
-                         if (!mapCRS.equals(fCRS)) {
+                         if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
-                                 // only to calculations if the CRS differ
+                                 final double divY = newArea.getMinY()
-                                 try {
+                                                 - maxAllowedExtend.getMinY();
-                                         MathTransform fToMap;
+                                 // LOGGER.debug("Moving area up by " + divY);
-                                         fToMap = CRS.findMathTransform(fCRS, mapCRS);
-                                         // centre is transformed to the mapCRS
+                                 newArea = new Envelope(new Coordinate(newArea.getMinX(),
-                                         centre = JTS.transform(centre, null, fToMap);
+                                                 newArea.getMinY() - divY), new Coordinate(newArea
-                                 } catch (FactoryException e) {
+                                                 .getMaxX(), newArea.getMaxY() - divY));
-                                         LOGGER.error("Looking for a Math transform", e);
-                                 } catch (TransformException e) {
+                                 if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
-                                         LOGGER.error("Looking for a Math transform", e);
+                                         // 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);
                                  }
                          }
-                         Coordinate newLeftBottom = new Coordinate(centre.x - width / 2.,
+                         // Exceeds to the right? move and maybe cut
-                                         centre.y - height / 2.);
+                         if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
-                         Coordinate newTopRight = new Coordinate(centre.x + width / 2.,
-                                         centre.y + height / 2.);
-                         Envelope newMapArea = new Envelope(newLeftBottom, newTopRight);
+                                 // Move left..
+                                 final double divX = newArea.getMaxX()
+                                                 - maxAllowedExtend.getMaxX();
+                                 // LOGGER.debug("Moving area left by " + divX);
-                         setMapArea(newMapArea);
+                                 newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
+                                                 newArea.getMinY()), new Coordinate(newArea.getMaxX()
+                                                 - divX, newArea.getMaxY()));
-                 } else {
+                                 if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
-                         ReferencedEnvelope fBounds = features.getBounds();
+                                         // 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()));
-                         Envelope bounds;
+                                         // LOGGER.debug("and fix aspect ratio");
-                         if (!mapCRS.equals(fCRS)) {
-                                 bounds = JTSUtil.transformEnvelope(fBounds, fCRS, mapCRS);
+                                         newArea = JTSUtil.fixAspectRatio(getVisibleRect(),
-                         } else {
+                                                         new ReferencedEnvelope(newArea, env
-                                 bounds = fBounds;
+                                                                         .getCoordinateReferenceSystem()), false);
+                                 }
                          }
-                         // BB umrechnen von Layer-CRS in Map-CRS
-                         // Expand a bit
+                         // Exceeds to the left? move and maybe cut
-                         bounds.expandBy(bounds.getWidth() / 6., bounds.getHeight() / 6.);
+                         if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
-                         setMapArea(bounds);
+                                 // 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);
+                                 }
+                         }
                  }
-         }
-         private void setRendererHints(Map<Object, Object> rendererHints) {
+                 return new ReferencedEnvelope(newArea, env
-                 this.rendererHints = rendererHints;
+                                 .getCoordinateReferenceSystem());
          }
          /**
-          * Return <code>true</code> if a CRS and a {@link #mapArea} are set and the
+          * Should be called when the {@link JMapPane} is not needed no more to help
-          * {@link XMapPane} is visible and has bounds set.
+          * the GarbageCollector
+          *
+          * Removes all {@link JMapPaneListener}s that are registered
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
           */
-         public boolean isWellDefined() {
+         public void dispose() {
+                 if (isDisposed())
+                         return;
-                 try {
+                 setPainting(false);
-                         if (getContext() == null)
+                 resizeTimer.stop();
-                                 return false;
+                 startRenderThreadsTimer.stop();
-                         if (getContext().getLayerCount() <= 0)
-                                 return false;
+                 disposed = true;
-                         if (getMapArea() == null)
-                                 return false;
+                 if (bgExecuter != null) {
-                         if (getBounds().getWidth() == 0)
+                         bgExecuter.cancelTask();
-                                 return false;
+                         bgExecuter.dispose();
-                         if (getBounds().getHeight() == 0)
-                                 return false;
-                 } catch (Exception e) {
-                         return false;
                  }
-                 return true;
-         }
-         /**
+                 if (localExecuter != null) {
-          * Default delay (milliseconds) before the map will be redrawn when resizing
+                         int i = 0;
-          * the pane. This is to avoid flickering while drag-resizing.
+                         localExecuter.cancelTask();
-          */
+                         while (i++ < 10 && localExecuter.isRunning()) {
-         public static final int DEFAULT_RESIZING_PAINT_DELAY = 500; // delay in
+                                 try {
-         // milliseconds
+                                         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();
+                 }
-         private Timer resizeTimer;
+                 disposeImages();
-         private int resizingPaintDelay;
-         /**
-          * We store the old transform for a moment to use it for the
-          * "quick scaled preview" in case of ZoomIn
-          **/
-         protected AffineTransform oldScreenToWorld = null;
-         /**
+                 // Remove all mapPaneListeners that have registered with us
-          * Manuell gesetzter statischer Cursor, unabhaengig von der aktuellen
+                 mapPaneListeners.clear();
-          * MapPane-Funktion
-          */
-         protected Cursor staticCursor = null;
-         /**
+                 removeMouseMotionListener(zoomMapPaneMouseListener);
-          * Standardmaessig wird der Cursor automatisch je nach MapPane-Aktion (Zoom,
+                 removeMouseListener(zoomMapPaneMouseListener);
-          * Auswahl, ...) gesetzt. Mit dieser Methode kann ein statischer Cursor
-          * gesetzt werden, der unabhaengig von der aktuellen MapPanes-Aktion
-          * beibehalten wird. Um diesen statischen Cursor wieder zu entfernen, kann
-          * {@code null} als Parameter uebergeben werden
-          *
-          * @param cursor
-          *            Cursor
-          */
-         public void setStaticCursor(Cursor cursor) {
-                 this.staticCursor = cursor;
-                 if (cursor != null)
-                         super.setCursor(cursor);
-         }
-         /**
+                 if (localContext != null)
-          * Liefert den statisch eingestellten Cursor, der unabhaengig von der
+                         getMapContext().clearLayerList();
-          * eingestellten MapPane-Aktion (Zoom, Auswahl, ...) verwendet wird.
+                 if (bgContext != null)
-          *
+                         getBgContext().clearLayerList();
-          * @return {@code null}, wenn kein statischer Cursor verwendet, sondern der
-          *         Cursor automatisch je nach MapPane-Aktion eingestellt wird.
+                 removeAll();
-          */
-         public Cursor getStaticCursor() {
-                 return this.staticCursor;
          }
          /**
-          * Abhaengig von selState wird der Cursor gesetzt
+          * Draws a rectangle in XOR mode from the origin at {@link #startPos} to the
+          * given point. All in screen coordinates.
           */
-         public void updateCursor() {
+         protected void drawRectangle(final Graphics graphics, final Point startPos,
+                         final Point e) {
-                 if (bgExecuter != null && bgExecuter.isRunning()
+                 if (!isWellDefined())
-                                 || localExecuter != null && localExecuter.isRunning()) {
-                         setCursor(WAIT_CURSOR);
                          return;
-                 } else {
-                         // Allow one last rendering
-                         if (repainterTimer.isRunning()) {
-                                 repainterTimer.stop();
-                                 updateFinalImage();
-                                 repaint();
-                         }
-                 }
-                 // wenn manueller Cursor gesetzt ist, dann diesen verwenden (unabhaengig
+                 // undraw last box/draw new box
-                 // von der aktuellen Aktion
+                 final int left = Math.min(startPos.x, e.x);
-                 if (this.staticCursor != null) {
+                 final int right = Math.max(startPos.x, e.x);
-                         setCursor(staticCursor);
+                 final int top = Math.max(startPos.y, e.y);
-                         return;
+                 final int bottom = Math.min(startPos.y, e.y);
-                 }
+                 final int width = right - left;
-                 if (getCursor() == SwingUtil.PANNING_CURSOR) {
+                 final int height = top - bottom;
-                         // This cursor will reset itself
+                 if (width == 0 && height == 0)
                          return;
-                 }
-                 // Je nach Aktion den Cursor umsetzen
+                 graphics.setXORMode(Color.WHITE);
-                 switch (state) {
+                 graphics.drawRect(left, bottom, width, height);
-                 case SELECT_TOP:
-                 case SELECT_ONE_FROM_TOP:
-                 case SELECT_ALL:
-                         setCursor(SwingUtil.CROSSHAIR_CURSOR);
-                         break;
-                 case ZOOM_IN:
-                         setCursor(SwingUtil.ZOOMIN_CURSOR);
-                         break;
-                 case ZOOM_OUT:
-                         setCursor(SwingUtil.ZOOMOUT_CURSOR);
-                         break;
-                 case PAN:
-                         setCursor(SwingUtil.PAN_CURSOR);
-                         break;
-                 default:
-                         setCursor(normalCursor);
-                         break;
-                 }
          }
-         //
-         // /**
-         // * Gibt den "normalen" Cursor zurueck. Dieser kann neben dem "pointer"
-         // auch
-         // * ein Sanduhr-Wartecursor sein.
-         // *
-         // * @author <a href="mailto:[email protected]">Stefan Alfons
-         // * Kr&uuml;ger</a>
-         // */
-         // public Cursor getNormalCursor() {
-         // return normalCursor;
-         // }
-         //
-         // /**
-         // * Setzt den "normalen" Cursor. Dieser kann neben dem default "pointer"
-         // z.B.
-         // * auch ein Sanduhr-Wartecursor sein.
-         // *
-         // * @author <a href="mailto:[email protected]">Stefan Alfons
-         // * Kr&uuml;ger</a>
-         // */
-         // public void setNormalCursor(Cursor normalCursor) {
-         // this.normalCursor = normalCursor;
-         // }
          /**
-          * Berechnet die Transformation zwischen Fenster- und Karten-Koordinaten
+          * Diretly paints scaled preview into the {@link SelectableXMapPane}. Used
-          * neu.
+          * 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 void resetTransforms() {
+         protected boolean drawScaledPreviewImage_Zoom(final Graphics2D graphics) {
-                 if (getMapArea() == null || getWidth() == 0 || getHeight() == 0)
-                         return;
-                 // We store the last Transform
+                 // if (1 == 1)return false;
-                 oldScreenToWorld = screenToWorld;
-                 this.screenToWorld = new AffineTransform(
+                 if (quickPreviewHint == 0)
-                 // Genauso wie die Fenster-Koordinaten, werden die Longitude-Koordinaten
+                         return false;
-                                 // nach rechts (Osten) hin groesser
-                                 // --> positive Verschiebung
-                                 getMapArea().getWidth() / getWidth(),
-                                 // keine Verzerrung
-.0, 0.0,
-                                 // Waehrend die Fenster-Koordinaten nach unten hin groesser
-                                 // werden,
-                                 // werden Latitude-Koordinaten nach Sueden hin keiner
-                                 // --> negative Verschiebung
-                                 -getMapArea().getHeight() / getHeight(),
-                                 // Die Longitude-Koordinaten werden nach Osten hin groesser
-                                 // --> obere linke Ecke des Fensters hat also den Minimalwert
-                                 getMapArea().getMinX(),
-                                 // Die Latitude-Koordinaten werden nach Norden hin groesser
-                                 // --> obere linke Ecke des Fensters hat also den Maximalwert
-                                 getMapArea().getMaxY());
-                 try {
+                 graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-                         this.worldToScreen = screenToWorld.createInverse();
+                                 RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
-                 } catch (NoninvertibleTransformException e) {
+                 graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                         LOGGER.error(e);
+                                 RenderingHints.VALUE_ANTIALIAS_OFF);
-                 }
+                 graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
-         }
+                                 RenderingHints.VALUE_RENDER_SPEED);
-         /**
+                 if (oldMapArea == null)
-          * Transformation zwischen Fenster-Koordinaten und Karten-Koordinaten
+                         return false;
-          * (lat/lon)
-          */
-         protected AffineTransform screenToWorld = null;
-         private AffineTransform worldToScreen;
+                 final Rectangle visibleArea = getVisibleRect();
-         /**
+                 // Calculate the oldMapArea in the current WindowCoordinates:
-          * Listens to changes of the "local" {@link MapContext} and triggers
+                 final Envelope oldMapWindow = tranformGeoToWindow(oldMapArea.getMinX(),
-          * repaints where needed.
+                                 oldMapArea.getMinY(), oldMapArea.getMaxX(), oldMapArea
-          */
+                                                 .getMaxY());
-         private MapLayerListListener localContextListener = new MapLayerListListener() {
-                 @Override
+                 final int xx1 = (int) Math.round(oldMapWindow.getMinX());
-                 public void layerAdded(final MapLayerListEvent event) {
+                 final int yy1 = (int) Math.round(oldMapWindow.getMinY());
-                         event.getLayer().addMapLayerListener(localMapLayerListener);
+                 final int xx2 = (int) Math.round(oldMapWindow.getMaxX());
+                 final int yy2 = (int) Math.round(oldMapWindow.getMaxY());
- //                      System.out.println("added a layer context, now it'S "
+                 graphics.drawImage(getPreFinalImage(), xx1, yy1, xx2, yy2,
- //                                      + getContext().getLayerCount() + " layers");
+                                 (int) visibleArea.getMinX(), (int) visibleArea.getMinY(),
- //                      ;
+                                 (int) visibleArea.getMaxX(), (int) visibleArea.getMaxY(),
+                                 getMapBackgroundColor(), null);
-                         localRenderer.setContext(getContext());
+                 final Rectangle painedArea = new Rectangle(xx1, yy1, xx2 - xx1, yy2
+                                 - yy1);
-                         if (localContext.getLayers().length == 1) { // the first one
+                 SwingUtil.clearAround(graphics, painedArea, visibleArea);
-                                 // if the Area of Interest is unset, the LayerBounds are used
-                                 if (!setMapArea(localContext.getAreaOfInterest()))
-                                         repaint();
-                                 return;
+                 addGadgets(graphics, true);
-                         }
-                         // We need to redraw, even in case that the mapArea didn't change
+                 quickPreviewHint = 0;
-                         // mapImageInvalid = true;
-                         // repaint();
-                         requestStartRendering();
-                 }
+                 repaintTimer.restart();
-                 @Override
+                 graphics.dispose();
-                 public void layerRemoved(final MapLayerListEvent event) {
-                         if (event.getLayer() != null)
-                                 event.getLayer().removeMapLayerListener(localMapLayerListener);
-                         // mapImageInvalid = true;
-                         // repaint();
-                         localRenderer.setContext(getContext());
-                         requestStartRendering();
-                 }
-                 @Override
+                 // Something has been drawn
-                 public void layerChanged(final MapLayerListEvent event) {
+                 return true;
-                         // mapImageInvalid = true;
+         }
-                         // repaint();
-                         localRenderer.setContext(getContext());
+         public MapContext getBgContext() {
-                         requestStartRendering();
+                 return bgContext;
+         }
+         /**
+          * Lazyly initializes a {@link BufferedImage} for the background renderer.
+          */
+         private Image getBgImage() {
+                 //
+                 // if (bgImage == null) {
+                 // bgImage = createImage(getBounds().width, getBounds().height);
+                 // }
+                 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);
-                 @Override
-                 public void layerMoved(final MapLayerListEvent event) {
-                         // mapImageInvalid = true;
-                         // repaint();
-                         localRenderer.setContext(getContext());
                          requestStartRendering();
                  }
-         };
+                 return finalImage;
+         }
+         public RenderingHints getJava2dHints() {
+                 return java2dHints;
+         }
          /**
-          * Listens to changes of the "background" {@link MapContext} and triggers
+          * Lazyly initializes a {@link BufferedImage} for the background renderer.
-          * repaints where needed.
           */
-         private MapLayerListListener bgContextListener = new MapLayerListListener() {
+         private BufferedImage getLocalImage() {
-                 @Override
+                 if (localImage == null) {
-                 public void layerAdded(final MapLayerListEvent event) {
+                         localImage = new BufferedImage(getVisibleRect().width,
-                         event.getLayer().addMapLayerListener(bgMapLayerListener);
+                                         getVisibleRect().height, IMAGETYPE_withAlpha);
+                 }
+                 return localImage;
+         }
-                         if (localContext.getLayers().length == 0
+         /**
-                                         && bgContext.getLayers().length == 1) { // the first one and
+          * Returns a copy of the mapArea
-                                 // localContext is
+          *
-                                 // empty
+          * @return
-                                 if (!setMapArea(localContext.getAreaOfInterest()))
+          */
-                                         requestStartRendering();
+         public ReferencedEnvelope getMapArea() {
-                                 return;
+                 if (mapArea == null) {
+                         ReferencedEnvelope mapArea_ = null;
+                         try {
+                                 mapArea_ = localContext.getLayerBounds();
+                         } catch (final IOException e) {
+                                 LOGGER.warn("localContext.getLayerBounds()", e);
                          }
-                         // We need to redraw, even in case that the mapArea didn't change
+                         if (mapArea_ == null && bgContext != null) {
-                         // mapImageInvalid = true;
+                                 try {
-                         // repaint();
+                                         mapArea_ = bgContext.getLayerBounds();
-                         requestStartRendering();
+                                 } catch (final IOException e) {
+                                         LOGGER.warn("bgContext.getLayerBounds()", e);
+                                 }
+                         }
+                         if (mapArea_ != null) {
+                                 mapArea = bestAllowedMapArea(mapArea_);
+                                 requestStartRendering();
+                         }
                  }
-                 @Override
+                 if (mapArea == null)
-                 public void layerRemoved(final MapLayerListEvent event) {
+                         return null;
-                         if (event.getLayer() != null)
-                                 event.getLayer().removeMapLayerListener(bgMapLayerListener);
-                         // mapImageInvalid = true;
-                         // repaint();
-                         requestStartRendering();
-                 }
-                 @Override
+                 // TODO is needed at all, this should go to setMapArea maybe
-                 public void layerChanged(final MapLayerListEvent event) {
+                 if (localContext.getCoordinateReferenceSystem() == null)
-                         // mapImageInvalid = true;
+                         try {
-                         // repaint();
+                                 localContext.setCoordinateReferenceSystem(GeoImportUtil
-                         requestStartRendering();
+                                                 .getDefaultCRS());
-                 }
+                         } catch (Exception e) {
+                                 throw new RuntimeException("setting context CRS:", e);
+                         }
-                 @Override
+                 return new ReferencedEnvelope(mapArea, localContext
-                 public void layerMoved(final MapLayerListEvent event) {
+                                 .getCoordinateReferenceSystem());
-                         // mapImageInvalid = true;
+         }
-                         // repaint();
-                         requestStartRendering();
-                 }
-         };
          /**
-          * Listens to each layer in the local {@link MapContext} for changes and
+          * Returns the background {@link Color} of the map pane. Default is white.
-          * triggers repaints.
+          **/
+         public Color getMapBackgroundColor() {
+                 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.
           */
-         protected MapLayerListener localMapLayerListener = new MapLayerAdapter() {
+         public BufferedImage getMapImage() {
+                 return mapImage;
+         }
-                 @Override
+         /**
-                 public void layerShown(MapLayerEvent event) {
+          * Returns the evelope of the viewable area. The JMapPane will never show
-                         // mapImageInvalid = true;
+          * anything outside of this extend. If this has been set to
-                         // repaint();
+          * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
-                         requestStartRendering();
+          * 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.
+          */
-                 @Override
+         public Envelope getMaxExtend() {
-                 public void layerHidden(MapLayerEvent event) {
+                 if (maxExtend == null) {
-                         // mapImageInvalid = true;
+                         // Commented-out because it takes soo much time!
-                         // repaint();
+ //
-                         requestStartRendering();
+ //                      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;
+ //                      }
+ //
+ //                      // Kartenbereich um 10% vergroessern
+ //                      return JTSUtil.fixAspectRatio(getVisibleRect(), JTSUtil
+ //                                      .expandEnvelope(layerBounds, 0.1), true);
                  }
+                 return maxExtend;
+         }
-                 @Override
+         /**
-                 public void layerChanged(MapLayerEvent event) {
+          * Retuns the maximum allowed zoom scale. This is the smaller number value
-                         localRenderer.setContext(getContext()); // betters for SLD changes?!
+          * of the two. Defaults to {@link Double}.MIN_VALUE
-                         // Change of SLD for example
+          *
-                         // mapImageInvalid = true;
+          * @author <a href="mailto:[email protected]">Stefan Alfons
-                         // repaint();
+          *         Kr&uuml;ger</a>
-                         requestStartRendering();
+          */
-                 }
+         public Double getMaxZoomScale() {
-         };
+                 return maxZoomScale;
+         }
          /**
-          * Listens to each layer in the local {@link MapContext} for changes and
+          * Retuns the minimum allowed zoom scale. This is the bigger number value of
-          * triggers repaints.
+          * the two. Defaults to {@link Double}.MAX_VALUE
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
           */
-         protected MapLayerListener bgMapLayerListener = new MapLayerAdapter() {
+         public Double getMinZoomScale() {
+                 return minZoomScale;
+         }
-                 @Override
+         private Image getPreFinalImage() {
-                 public void layerShown(MapLayerEvent event) {
+                 // if (preFinalImage == null) {
-                         // mapImageInvalid = true;
+                 //
-                         // repaint();
+                 // // Rectangle curPaintArea = getVisibleRect();
-                         requestStartRendering();
+                 // // preFinalImage = new BufferedImage(curPaintArea.width,
-                 }
+                 // // curPaintArea.height, BufferedImage.TYPE_INT_RGB);
+                 //
+                 // preFinalImage = createImage(getBounds().width, getBounds().height);
+                 //
+                 // requestStartRendering();
+                 // }
+                 return preFinalImage;
+         }
-                 @Override
+         public Map<Object, Object> getRendererHints() {
-                 public void layerHidden(MapLayerEvent event) {
+                 // Clear label cache
-                         // mapImageInvalid = true;
+                 labelCache.clear();
-                         // repaint();
+                 rendererHints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);
-                         requestStartRendering();
-                 }
-                 @Override
+                 return rendererHints;
-                 public void layerChanged(MapLayerEvent event) {
+         }
-                         // Change of SLD for example
-                         // mapImageInvalid = true;
-                         // repaint();
-                         requestStartRendering();
-                 }
-         };
          /**
           * Liefert eine affine Transformation, um von den Fenster-Koordinaten in die
-Line 907 
 public class XMapPane extends JPanel {
+Line 1240 
 public class XMapPane extends JPanel {
                  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();
-Line 915 
 public class XMapPane extends JPanel {
+Line 1263 
 public class XMapPane extends JPanel {
                  return new AffineTransform(worldToScreen);
          }
-         public MapContext getContext() {
+         /**
-                 if (localContext == null) {
+          * A flag indicating if dispose() has already been called. If true, then
-                         setLocalContext(new DefaultMapContext());
+          * 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 localContext;
+                 return true;
          }
-         public MapContext getBgContext() {
+         public void mouseDragged(final Point startPos, final Point lastPos,
-                 return bgContext;
+                         final MouseEvent event) {
+                 if ((getState() == XMapPane.PAN)
+                                 || ((event.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) {
+                         if (getCursor() != SwingUtil.PANNING_CURSOR) {
+                                 setCursor(SwingUtil.PANNING_CURSOR);
+                                 // While panning, we deactivate the rendering. So the tasts are
+                                 // ready to start when the panning os done.
+                                 if (bgExecuter != null)
+                                         bgExecuter.cancelTask();
+                                 if (localExecuter != null)
+                                         localExecuter.cancelTask();
+                         }
+                         if (lastPos.x > 0 && lastPos.y > 0) {
+                                 final int dx = event.getX() - lastPos.x;
+                                 final int dy = event.getY() - lastPos.y;
+                                 // TODO Stop dragging when the drag would not be valid...
+                                 // boolean dragValid = true;
+                                 // // check if this panning results in a valid mapArea
+                                 // {
+                                 // Rectangle winBounds = xMapPane.getBounds();
+                                 // winBounds.translate(xMapPane.imageOrigin.x,
+                                 // -xMapPane.imageOrigin.y);
+                                 // Envelope newMapAreaBefore = xMapPane.tranformWindowToGeo(
+                                 // winBounds.x, winBounds.y, winBounds.x
+                                 // + winBounds.width, winBounds.y
+                                 // + winBounds.height);
+                                 //
+                                 //
+                                 // winBounds = xMapPane.getBounds();
+                                 // Point testIng = new Point(xMapPane.imageOrigin);
+                                 // testIng.translate(dx, dy);
+                                 // winBounds.translate(testIng.x, -testIng.y);
+                                 // Envelope newMapAreaAfter = xMapPane.tranformWindowToGeo(
+                                 // winBounds.x, winBounds.y, winBounds.x
+                                 // + winBounds.width, winBounds.y
+                                 // + winBounds.height);
+                                 //
+                                 // // If the last drag doesn't change the MapArea anymore cancel
+                                 // it.
+                                 // if (xMapPane.bestAllowedMapArea(newMapAreaAfter).equals(
+                                 // xMapPane.bestAllowedMapArea(newMapAreaBefore))){
+                                 // dragValid = false;
+                                 // return;
+                                 // }
+                                 // }
+                                 imageOrigin.translate(dx, dy);
+                                 updateFinalImage();
+                                 repaint();
+                         }
+                 } else if ((getState() == XMapPane.ZOOM_IN)
+                                 || (getState() == XMapPane.ZOOM_OUT)
+                                 || (getState() == XMapPane.SELECT_ALL)
+                                 || (getState() == XMapPane.SELECT_TOP)
+                 // || (getState() == XMapPane.SELECT_ONE_FROM_TOP)
+                 ) {
+                         final Graphics graphics = getGraphics();
+                         drawRectangle(graphics, startPos, event.getPoint());
+                         if ((lastPos.x > 0) && (lastPos.y > 0)) {
+                                 drawRectangle(graphics, startPos, lastPos);
+                         }
+                         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.
+          */
+         public void onRenderingCompleted() {
+                 repaintTimer.stop();
+                 updateFinalImage();
+                 repaint();
+                 if (renderingErrors.size() > 0)
+                         renderingErrors.remove(0);
+         }
+         /**
+          * 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
           *
-          * @param context
+          * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
           */
-         public void setLocalContext(final MapContext context) {
+         public void onRenderingFailed(final Exception renderingError) {
-                 // Remove the default listener from the old context
-                 if (this.localContext != null) {
+                 // Store the exceptions so we can show it to the user:
-                         this.localContext.removeMapLayerListListener(localContextListener);
+                 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();
+         }
+         public void onRenderingPending() {
+                 // LOGGER.debug("Pending rendering updates the preview...");
+                 updateFinalImage();
+                 repaint();
+         }
+         @Override
+         protected void paintComponent(final Graphics g) {
+                 if (!acceptsRepaintCalls)
+                         return;
+                 // Maybe update the cursor and maybe stop the repainting timer
+                 updateCursor();
+                 // 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 (mapAreaChanged && oldMapArea != null
+                                         && getMapArea().intersects(oldMapArea)
+                                         & !getMapArea().equals(oldMapArea) && !paneResized) {
+                                 mapAreaChanged = false;
+                                 if (getMapArea().covers(oldMapArea)) {
+                                         setQuickPreviewHint(ZOOM_OUT);
+                                         paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
+                                 } else if (oldMapArea.covers(getMapArea())) {
+                                         setQuickPreviewHint(ZOOM_IN);
+                                         paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
+                                 }
-                         // adding listener to all layers
-                         for (MapLayer mapLayer : localContext.getLayers()) {
-                                 mapLayer.removeMapLayerListener(localMapLayerListener);
                          }
+                         // if (paneResized) {
+                         // paneResized = false;
+                         // disposeImages();
+                         // }
+                         //
+                         // // Start the Threads and Timers to render the image
+                         // requestStartRendering();
                  }
-                 this.localContext = context;
+                 if (!paintedSomething) {
-                 if (context != null) {
+                         g.drawImage(getFinalImage(), 0, 0, null);
-                         setMapArea(localContext.getAreaOfInterest());
+                         g.dispose(); // cand. for removal
-                         localRenderer.setContext(localContext);
+                         paintedSomething = true; // cand. for removal
+                 }
-                         this.localContext.addMapLayerListListener(localContextListener);
+         }
-                         // adding listener to all layers
+         /**
-                         for (MapLayer mapLayer : localContext.getLayers()) {
+          * Heavily works on releasing all resources related to the four
-                                 mapLayer.addMapLayerListener(localMapLayerListener);
+          * {@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);
+         }
+         //
+         // /**
+         // * Nuetzlich wenn die Componente gedruckt (z.B. wenn ein Screenshot
+         // gemacht
+         // * wird) wird. Dann werden wird der Hintergrund auf WEISS gesetzt.
+         // *
+         // * @author <a href="mailto:[email protected]">Stefan Alfons
+         // * Kr&uuml;ger</a>
+         // */
+         // @Override
+         // public void print(final Graphics g) {
+         // final Color orig = getBackground();
+         // setBackground(Color.WHITE);
+         //
+         // // wrap in try/finally so that we always restore the state
+         // try {
+         // super.print(g);
+         // } finally {
+         // setBackground(orig);
+         // }
+         // }
+         /**
+          * 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();
+                 if (localExecuter != null)
+                         localExecuter.cancelTask();
                  mapImageInvalid = true;
-                 repaint();
+                 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) {
-Line 968 
 public class XMapPane extends JPanel {
+Line 1661 
 public class XMapPane extends JPanel {
                          this.bgContext.removeMapLayerListListener(bgContextListener);
                          // adding listener to all layers
-                         for (MapLayer mapLayer : bgContext.getLayers()) {
+                         for (final MapLayer mapLayer : bgContext.getLayers()) {
                                  mapLayer.removeMapLayerListener(bgMapLayerListener);
                          }
                  }
-Line 976 
 public class XMapPane extends JPanel {
+Line 1669 
 public class XMapPane extends JPanel {
                  this.bgContext = context;
                  if (context != null) {
-                         setMapArea(bgContext.getAreaOfInterest());
+                         // setMapArea(bgContext.getAreaOfInterest());
                          this.bgContext.addMapLayerListListener(bgContextListener);
                          // adding listener to all layers
-                         for (MapLayer mapLayer : bgContext.getLayers()) {
+                         for (final MapLayer mapLayer : bgContext.getLayers()) {
                                  mapLayer.addMapLayerListener(bgMapLayerListener);
                          }
                  }
-                 mapImageInvalid = true;
-                 repaint();
+                 requestStartRendering();
          }
-         /**
+         public void setJava2dHints(final RenderingHints java2dHints) {
-          * Returns a copy of the mapArea
+                 this.java2dHints = java2dHints;
-          *
+         }
-          * @return
-          */
+         public void setLocalContext(final MapContext context) {
-         public Envelope getMapArea() {
+                 // Remove the default listener from the old context
-                 if (mapArea == null) {
+                 if (this.localContext != null) {
-                         ReferencedEnvelope mapArea_ = null;
+                         this.localContext.removeMapLayerListListener(localContextListener);
-                         try {
-                                 mapArea_ = localContext.getLayerBounds();
+                         // adding listener to all layers
-                         } catch (final IOException e) {
+                         for (final MapLayer mapLayer : localContext.getLayers()) {
-                                 LOGGER.warn("context.getLayerBounds()", e);
+                                 mapLayer.removeMapLayerListener(localMapLayerListener);
                          }
+                 }
-                         if (mapArea_ != null) {
+                 this.localContext = context;
-                                 mapImageInvalid = true; /* note we need to redraw */
-                                 setMapArea(mapArea_);
+                 if (context != null) {
+                         // setMapArea(localContext.getAreaOfInterest());
+                         localRenderer.setContext(localContext);
+                         this.localContext.addMapLayerListListener(localContextListener);
+                         // adding listener to all layers
+                         for (final MapLayer mapLayer : localContext.getLayers()) {
+                                 mapLayer.addMapLayerListener(localMapLayerListener);
                          }
                  }
-                 if (mapArea == null)
+                 requestStartRendering();
-                         return null;
-                 return new Envelope(mapArea);
+         }
+         public boolean setMapArea(final Envelope newMapArea) {
+                 return setMapArea(new ReferencedEnvelope(newMapArea, getMapContext()
+                                 .getCoordinateReferenceSystem()));
          }
          /**
-Line 1020 
 public class XMapPane extends JPanel {
+Line 1727 
 public class XMapPane extends JPanel {
           * @return <code>true</code> if the mapArea has been changed and a repaint
           *         has been triggered.
           */
-         public boolean setMapArea(final Envelope newMapArea) {
+         public boolean setMapArea(final ReferencedEnvelope newMapArea) {
+                 //
+                 // if (getVisibleRect().getWidth() == 0 || (!isVisible()) ||
+                 // getVisibleRect().getHeight() == 0) {
+                 // // The window is not yet defined.. so we can not really determine the
+                 // asepect ratio for the mapPane. We store this as a candidate mappane
+                 // and handle it when the component resizes or becomes visible)
+                 // mapAreaCondidate = newMapArea;
+                 // }
                  if (newMapArea == null
                                  || bestAllowedMapArea(newMapArea).equals(mapArea)) {
-Line 1039 
 public class XMapPane extends JPanel {
+Line 1754 
 public class XMapPane extends JPanel {
                          return false;
                  }
+                 final Envelope candNew = bestAllowedMapArea(newMapArea);
                  // Testing, whether the difference if just minimal
                  if (mapArea != null) {
-                         Envelope candNew = bestAllowedMapArea(newMapArea);
+                         final double tolX = mapArea.getWidth() / 1000.;
-                         double tolX = mapArea.getWidth() / 1000.;
+                         final double tolY = mapArea.getHeight() / 1000.;
-                         double tolY = mapArea.getHeight() / 1000.;
                          if ((candNew.getMinX() - tolX < mapArea.getMinX())
                                          && (mapArea.getMinX() < candNew.getMinX() + tolX)
                                          && (candNew.getMaxX() - tolX < mapArea.getMaxX())
-Line 1061 
 public class XMapPane extends JPanel {
+Line 1777 
 public class XMapPane extends JPanel {
                          }
                  }
+                 // New map are is accepted:
                  oldMapArea = mapArea;
+                 mapArea = candNew;
-                 this.mapArea = bestAllowedMapArea(newMapArea);
+                 resetTransforms();
                  if (localContext != null) {
                          localContext.setAreaOfInterest(mapArea, localContext
-Line 1073 
 public class XMapPane extends JPanel {
+Line 1790 
 public class XMapPane extends JPanel {
                          bgContext.setAreaOfInterest(mapArea, localContext
                                          .getCoordinateReferenceSystem());
                  }
-                 resetTransforms();
-                 mapImageInvalid = true;
                  mapAreaChanged = true;
-                 repaint();
-                 // LOGGER.debug("New maparea = " + mapArea);
+                 repaint(100);
-                 return true;
-         }
-         public int getState() {
+                 requestStartRendering();
-                 return state;
+                 return true;
          }
          /**
-          * Enables/Disables the ZOOM Mouse Listener. Upates the Cursor and stops the
+          * Set the background color of the map.
-          * repaint Timer if
           *
-          * @param state
+          * @param if <code>null</code>, white is used.
           */
-         public void setState(final int state) {
+         public void setMapBackgroundColor(Color bgColor) {
-                 this.state = state;
+                 if (bgColor == null)
+                         bgColor = Color.WHITE;
-                 zoomMapPaneMouseListener.setEnabled((state == ZOOM_IN
+                 this.mapBackgroundColor = bgColor;
-                                 || state == ZOOM_OUT || state == PAN));
-                 // Je nach Aktion den Cursor umsetzen
-                 updateCursor();
          }
-         /** Cursor wenn kein Mausbutton gedrueckt wird. default oder SwingUtil.PAN **/
-         protected static Cursor normalCursor = Cursor
-                         .getPredefinedCursor(Cursor.DEFAULT_CURSOR);
-         public static final Cursor WAIT_CURSOR = Cursor
-                         .getPredefinedCursor(Cursor.WAIT_CURSOR);
-         public static final int NONE = -123;
-         private RenderingExecutor localExecuter = new RenderingExecutor(this);
-         /**
-          * A flag set it {@link #setMapArea(Envelope)} to indicated the
-          * {@link #paintComponent(Graphics)} method, that the image on-screen is
-          * associated with {@link #oldMapArea} and may hence be scaled for a quick
-          * preview.<br/>
-          * The flag is reset
-          **/
-         private boolean mapAreaChanged = false;
-         private volatile Boolean requestStartRendering = false;
          /**
-          * The Renderer for the Background uses this Image. When set to null, please
+          * Set the BufferedImage to use as a flaoting icon in the lower right corner
-          * dispose the {@link Graphics2D}
+          *
-          */
+          * @param mapImageIcon
-         private BufferedImage bgImage;// = new
+          *            <code>null</code> is allowed and deactivates this icon.
-         // BufferedImage(600,600,BufferedImage.TYPE_INT_ARGB);
-         private BufferedImage finalImage;
-         /**
-          * The Renderer for the LocalLayers uses this Image. When set to null,
-          * please dispose this {@link Graphics2D}
           */
-         private BufferedImage localImage;// = new
+         public void setMapImage(final BufferedImage mapImage) {
-         // BufferedImage(600,600,BufferedImage.TYPE_INT_ARGB);
+                 this.mapImage = mapImage;
-         private BufferedImage preFinalImage;// = new
-         // BufferedImage(600,600,BufferedImage.TYPE_INT_ARGB);
-         protected void paintComponent(final Graphics g) {
-                 if (!acceptsRepaintCalls)
-                         return;
-                 // Maybe update the cursor
-                 updateCursor();
-                 super.paintComponent(g);
-                 boolean paintedSomething = false;
-                 if (mapImageInvalid) { /* if the map changed then redraw */
-                         mapImageInvalid = false; // Reset for next round
-                         // If the new mapArea and the oldMapArea intersect, we can draw some
-                         // quick scaled preview to make the user feel that something is
-                         // happening.
-                         if (mapAreaChanged && oldMapArea != null
-                                         && getMapArea().intersects(oldMapArea)
-                                         & !getMapArea().equals(oldMapArea)) {
-                                 mapAreaChanged = false;
-                                 if (getMapArea().covers(oldMapArea)) {
-                                         setQuickPreviewHint(ZOOM_OUT);
-                                         paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
-                                 } else if (oldMapArea.covers(getMapArea())) {
-                                         setQuickPreviewHint(ZOOM_IN);
-                                         paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
-                                 }
-                         }
-                         if (paneResized) {
-                                 paneResized = false;
-                                 // if (preFinalImage != null)
-                                 // preFinalImage.flush();
-                                 // preFinalImage = null;
-                                 // if (finalImage != null) {
-                                 // finalImage.flush();
-                                 // }
-                                 // finalImage = null;
-                                 // if (localImage != null)
-                                 // localImage.flush();
-                                 // localImage = null;
-                                 // if (bgImage != null)
-                                 // bgImage.flush();
-                                 // bgImage = null;
-                                 // gadgetsImage = null;
-                         }
-                         // Start the Threads and Timers to render the image
-                         requestStartRendering();
-                 }
-                 if (!paintedSomething) {
-                         // TODO Should just paint the getFinalImage(). Update should be
-                         // called by timer every 300ms, and the repaint() until all threads
-                         // are done.
-                         g.drawImage(getFinalImage(), 0, 0, null);
-                         g.dispose();
-                         paintedSomething = true;
-                 }
          }
          /**
-          * Cancels all running renderers and sets the flag to start new ones. <br/>
+          * Sets whether a layer is regarded or ignored on {@link #SELECT_TOP},
+          * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions.
           *
-          * @see #startRenderThreadsTimer
+          * @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.
           */
-         private void requestStartRendering() {
+         public void setMapLayerSelectable(final MapLayer layer,
-                 if (bgExecuter != null)
+                         final Boolean selectable) {
-                         bgExecuter.cancelTask();
+                 if (selectable == null)
-                 if (localExecuter != null)
+                         mapLayerSelectable.remove(layer);
-                         localExecuter.cancelTask();
+                 else
-                 requestStartRendering = true;
+                         mapLayerSelectable.put(layer, selectable);
          }
          /**
-          * Transformiert einen Fenster-Koordinaten-Bereich in Geo-Koordinaten.
+          * Defines an evelope of the viwable area. The JMapPane will never show
+          * anything outside of this extend.
           *
-          * @param ox
+          * @param maxExtend
-          *            X-Koordinate der VON-Position
+          *            <code>null</code> to not have this restriction.
-          * @param oy
-          *            Y-Koordinate der VON-Position
-          * @param px
-          *            X-Koordinate der BIS-Position
-          * @param py
-          *            Y-Koordinate der BIS-Position
           */
-         public Envelope tranformWindowToGeo(int ox, int oy, int px, int py) {
+         public void setMaxExtend(final Envelope maxExtend) {
-                 AffineTransform at = getScreenToWorld();
+                 this.maxExtend = maxExtend;
-                 Point2D geoO = at.transform(new Point2D.Double(ox, oy), null);
-                 Point2D geoP = at.transform(new Point2D.Double(px, py), null);
-                 return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP.getY());
          }
          /**
-          * Transformiert einen Geo-Koordinaten-Bereich in Fenster-Koordinaten.
+          * 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.
           *
-          * @param ox
+          * @author <a href="mailto:[email protected]">Stefan Alfons
-          *            X-Koordinate der VON-Position
+          *         Kr&uuml;ger</a>
-          * @param oy
-          *            Y-Koordinate der VON-Position
-          * @param px
-          *            X-Koordinate der BIS-Position
-          * @param py
-          *            Y-Koordinate der BIS-Position
-          * @param winToGeotransform
-          *            Eine Window to Geo transform. If <code>null</code>,
-          *            {@link #getScreenToWorld()} is used.
           */
-         public Envelope tranformGeoToWindow(double ox, double oy, double px,
+         public void setMaxZoomScale(final Double maxZoomScale) {
-                         double py, AffineTransform winToGeotransform) {
+                 this.maxZoomScale = maxZoomScale == null ? Double.MIN_VALUE
-                 AffineTransform at = winToGeotransform == null ? getScreenToWorld()
+                                 : maxZoomScale;
-                                 : winToGeotransform;
-                 Point2D geoO;
-                 try {
-                         geoO = at.inverseTransform(new Point2D.Double(ox, oy), null);
-                         Point2D geoP = at
-                                         .inverseTransform(new Point2D.Double(px, py), null);
-                         return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP
-                                         .getY());
-                 } catch (NoninvertibleTransformException e) {
-                         LOGGER.error(e);
-                         return new Envelope(ox, oy, px, py);
-                 }
          }
+         // /** Stored the time used for the last real rendering in ms. **/
+         // private long lastRenderingDuration = Long.MAX_VALUE;
          /**
-          * Diretly paints scaled preview into the {@link SelectableXMapPane}. Used
+          * Set the minimum (nearest) allowed zoom scale. This is the bigger number
-          * to give the user something to look at while we are rendering. Method
+          * value of the two. If <code>null</code> is passed, Double.MAXVALUE are
-          * should be called after {@link #setMapArea(Envelope)} has been set to the
+          * used which mean there is no restriction.
-          * new mapArea and transform has been reset.<br/>
           *
-          * @param g
-          *            Graphics2D to paint the preview into
           *
-          * @param state
+          * @author <a href="mailto:[email protected]">Stefan Alfons
-          *            Max be {@link #ZOOM_IN} or {@link #ZOOM_OUT}
+          *         Kr&uuml;ger</a>
           */
-         protected boolean drawScaledPreviewImage_Zoom(Graphics2D graphics) {
+         public void setMinZoomScale(final Double minZoomScale) {
+                 this.minZoomScale = minZoomScale == null ? Double.MAX_VALUE
-                 if (quickPreviewHint == 0)
+                                 : minZoomScale;
-                         return false;
-                 graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-                                 RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
-                 graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                                 RenderingHints.VALUE_ANTIALIAS_OFF);
-                 graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
-                                 RenderingHints.VALUE_RENDER_SPEED);
-                 if (oldMapArea == null)
-                         return false;
-                 Rectangle visibleArea = getVisibleRect();
-                 // Calculate the oldMapArea in the current WindowCoordinates:
-                 Envelope oldMapWindow = tranformGeoToWindow(oldMapArea.getMinX(),
-                                 oldMapArea.getMinY(), oldMapArea.getMaxX(), oldMapArea
-                                                 .getMaxY(), null);
-                 int xx1 = (int) Math.round(oldMapWindow.getMinX());
-                 int yy1 = (int) Math.round(oldMapWindow.getMinY());
-                 int xx2 = (int) Math.round(oldMapWindow.getMaxX());
-                 int yy2 = (int) Math.round(oldMapWindow.getMaxY());
-                 graphics.drawImage(getPreFinalImage(), xx1, yy1, xx2, yy2,
-                                 (int) visibleArea.getMinX(), (int) visibleArea.getMinY(),
-                                 (int) visibleArea.getMaxX(), (int) visibleArea.getMaxY(),
-                                 getMapBackgroundColor(), null);
-                 Rectangle painedArea = new Rectangle(xx1, yy1, xx2 - xx1, yy2 - yy1);
-                 SwingUtil.clearAround(graphics, painedArea, visibleArea);
-                 addGadgets(graphics);
-                 quickPreviewHint = 0;
-                 graphics.dispose();
-                 // Something has been drawn
-                 return true;
          }
-         final static Font waitFont = new Font("Arial", Font.BOLD, 30);
          /**
-          * Paints some optinal stuff into the given {@link Graphics2D}. Usually
+          *
-          * called as the last paint on the mapImage.
+          * @param b
           */
-         private void addGadgets(Graphics2D graphics) {
+         public void setPainting(final boolean b) {
+                 acceptsRepaintCalls = b;
-                 if (mapImage != null)
+         }
-                         graphics.drawImage(mapImage, getBounds().width
-                                         - mapImage.getWidth() - 10, getBounds().height
-                                         - mapImage.getHeight() - 10, null);
-                 // If still rendering, paint a gray shadow or so...
-                 if (bgExecuter != null && bgExecuter.isRunning()
-                                 || localExecuter != null && localExecuter.isRunning()) {
-                         Color c = graphics.getColor();
+         // /**
-                         graphics.setColor(Color.BLACK);
+         // * Returns in milli seconds the time the last rending of the
+         // * {@link SelectableXMapPane} took. #Long.MAX_VALUE if the JMapPane has
+         // not
+         // * been rendered yet.
+         // */
+         // public long getLastRenderingDuration() {
+         // return lastRenderingDuration;
+         // }
-                         graphics.setFont(waitFont);
+         public void setQuickPreviewHint(final int quickPreviewHint) {
-                         graphics.drawString("Wait...", 40, 70); // i8n
+                 this.quickPreviewHint = quickPreviewHint;
-                         graphics.setColor(c);
+         }
-                 }
+         private void setRendererHints(final Map<Object, Object> rendererHints) {
+                 if (rendererHints != null)
+                         this.rendererHints = rendererHints;
          }
          /**
-          * Accumulates all three images
+          * Enables/Disables the ZOOM Mouse Listener. Upates the Cursor and stops the
+          * repaint Timer if
           *
-          * @return
+          * @param state
           */
-         synchronized protected Image updateFinalImage() {
+         public void setState(final int state) {
+                 this.state = state;
-                 // 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);
-                 final int finalImageHeight = getFinalImage().getHeight(null);
-                 final int finalImageWidth = getFinalImage().getWidth(null);
-                 Rectangle painedArea = new Rectangle(imageOrigin.x, imageOrigin.y,
-                                 finalImageWidth, finalImageHeight);
-                 SwingUtil.clearAround(finalG, painedArea, getVisibleRect());
-                 addGadgets(finalG);
-                 finalG.dispose();
-                 return finalImage;
-         }
-         private BufferedImage getFinalImage() {
-                 //
-                 if (finalImage == null) {
-                         // Rectangle curPaintArea = getVisibleRect();
-                         finalImage = new BufferedImage(getBounds().width,
-                                         getBounds().height, BufferedImage.TYPE_INT_RGB);
-                         requestStartRendering();
+                 zoomMapPaneMouseListener.setEnabled((state == ZOOM_IN
-                 }
+                                 || state == ZOOM_OUT || state == PAN));
-                 return finalImage;
-         }
-         private Image getPreFinalImage() {
+                 // Je nach Aktion den Cursor umsetzen
-                 // if (preFinalImage == null) {
+                 updateCursor();
-                 //
-                 // // Rectangle curPaintArea = getVisibleRect();
-                 // // preFinalImage = new BufferedImage(curPaintArea.width,
-                 // // curPaintArea.height, BufferedImage.TYPE_INT_RGB);
-                 //
-                 // preFinalImage = createImage(getBounds().width, getBounds().height);
-                 //
-                 // requestStartRendering();
-                 // }
-                 return preFinalImage;
          }
          /**
-          * While dragging, the {@link #updateFinalImage()} method is translating the
+          * Standardmaessig wird der Cursor automatisch je nach MapPane-Aktion (Zoom,
-          * cached images while setting it together.
+          * Auswahl, ...) gesetzt. Mit dieser Methode kann ein statischer Cursor
-          **/
+          * gesetzt werden, der unabhaengig von der aktuellen MapPanes-Aktion
-         Point imageOrigin = new Point(0, 0);
+          * beibehalten wird. Um diesen statischen Cursor wieder zu entfernen, kann
-         private final GTRenderer localRenderer;
+          * {@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())
+                 if (!isWellDefined() || !acceptsRepaintCalls) {
+                         requestStartRendering = true;
                          return;
+                 }
                  if (bgExecuter != null) {
                          // Stop all renderers
-Line 1460 
 public class XMapPane extends JPanel {
+Line 1960 
 public class XMapPane extends JPanel {
                          localExecuter.cancelTask();
                  }
-                 Rectangle curPaintArea = getVisibleRect();
+                 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"); */
-Line 1479 
 public class XMapPane extends JPanel {
+Line 1981 
 public class XMapPane extends JPanel {
                          // (Graphics2D) getBgImage().getGraphics(), createGTRenderer);
                  }
-                 if (getContext() != null) {
+                 if (getMapContext() != null) {
                          // localExecuter = new RenderingExecutor(this, 150l);
- //                      LOGGER.debug("starting local renderer:");
+                         // LOGGER.debug("starting local renderer:");
-                         // Clear label cache
-                         labelCache.clear();
-                         Map<Object, Object> rh = localRenderer.getRendererHints();
-                         rh.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);
-                         localRenderer.setRendererHints(rh);
-                         boolean submitted = localExecuter.submit(getContext().getAreaOfInterest(),
+                         localRenderer.setJava2DHints(getJava2dHints());
+                         localRenderer.setRendererHints(getRendererHints());
+                         final boolean submitted = localExecuter.submit(getMapArea(),
                                          curPaintArea, (Graphics2D) getLocalImage().getGraphics(),
-                                         localRenderer, getWorldToScreenTransform());
+                                         localRenderer
-                         if (submitted) repainterTimer.restart();
+                         // , getWorldToScreenTransform()
-                         else requestStartRendering = true; // Try to start rendering again in a moment
+                                         );
+                         if (submitted)
+                                 repaintTimer.restart();
+                         else
+                                 requestStartRendering = true; // Try to start rendering
+                         // again in
+                         // a moment
                  }
                  updateCursor();
          }
          /**
-          * Lazyly initializes a {@link BufferedImage} for the background renderer.
+          * Transformiert einen Geo-Koordinaten-Bereich in Fenster-Koordinaten.
-          */
-         private Image getBgImage() {
-                 //
-                 // if (bgImage == null) {
-                 // bgImage = createImage(getBounds().width, getBounds().height);
-                 // }
-                 return bgImage;
-         }
-         /** An (transparent) image to paint over the map in the lower right corner **/
-         private BufferedImage mapImage = null;
-         private boolean acceptsRepaintCalls = true;
-         /**
-          * Get the BufferedImage to use as a flaoting icon in the lower right
-          * corner.
           *
-          * @return <code>null</code> if the feature is deactivated.
+          * @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 BufferedImage getMapImage() {
+         public Envelope tranformGeoToWindow(final double ox, final double oy,
-                 return mapImage;
+                         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);
+                 // }
          }
          /**
-          * Set the BufferedImage to use as a flaoting icon in the lower right corner
+          * Transformiert einen Fenster-Koordinaten-Bereich in Geo-Koordinaten.
           *
-          * @param mapImageIcon
+          * @param ox
-          *            <code>null</code> is allowed and deactivates this icon.
+          *            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 void setMapImage(BufferedImage mapImage) {
+         public Envelope tranformWindowToGeo(final int ox, final int oy,
-                 this.mapImage = mapImage;
+                         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()));
          }
          /**
-          * Lazyly initializes a {@link BufferedImage} for the background renderer.
+          * Will update the cursor. If all rendering is finished also stops the
+          * {@link #repaintTimer}
           */
-         private BufferedImage getLocalImage() {
+         public void updateCursor() {
-                 if (localImage == null) {
+                 // if the renderers have stopped, also stop the timer that is updating
-                         localImage = new BufferedImage(getBounds().width,
+                 // the final image
-                                         getBounds().height, BufferedImage.TYPE_INT_ARGB);
+                 if (bgExecuter != null && bgExecuter.isRunning()
+                                 || localExecuter != null && localExecuter.isRunning()) {
+                         setCursor(WAIT_CURSOR);
+                         return;
+                 } else {
+                         // Allow one last rendering
+                         if (repaintTimer.isRunning()) {
+                                 // System.out.println("one last rendering....");
+                                 repaintTimer.stop();
+                                 updateFinalImage();
+                                 repaint();
+                         }
                  }
-                 return localImage;
+                 // wenn manueller Cursor gesetzt ist, dann diesen verwenden (unabhaengig
-         }
+                 // von der aktuellen Aktion
+                 if (this.staticCursor != null) {
-         /**
+                         setCursor(staticCursor);
-          * Called by the {@linkplain XMapPane.RenderingTask} when rendering has been
+                         return;
-          * completed Publishes a {@linkplain MapPaneEvent} of type {@code
+                 }
-          * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
+                 if (getCursor() == SwingUtil.PANNING_CURSOR) {
-          *
+                         // This cursor will reset itself
-          * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
+                         return;
-          */
+                 }
-         public void onRenderingCompleted() {
-                 repainterTimer.stop();
-                 updateFinalImage();
-                 repaint();
-         }
-         /**
-          * Called by the {@linkplain XMapPane.RenderingTask} when rendering was
-          * cancelled. Publishes a {@linkplain MapPaneEvent} of type {@code
-          * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
-          *
-          * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
-          */
-         public void onRenderingCancelled() {
-                 repainterTimer.stop();
-                 LOGGER.debug("Rendering cancelled");
-         }
-         /**
-          * Called by the {@linkplain XMapPane.RenderingTask} when rendering failed.
-          * Publishes a {@linkplain MapPaneEvent} of type {@code
-          * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
-          *
-          * @param renderingError
-          *            The error that occured during rendering
-          *
-          * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
-          */
-         public void onRenderingFailed(Exception renderingError) {
-                 repainterTimer.stop();
-                 LOGGER.warn("Rendering failed", renderingError);
-                 updateFinalImage();
-                 repaint();
+                 // 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;
+                 }
          }
          /**
-          * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste
+          * The renderers are all rendering into their own {@link Image}s. This
-          * erlaubte Flaeche damit die Massstabsbeschaenkungen noch eingehalten
+          * method combines all images to one {@link #finalImage}. The
-          * werden, FALLS der uebergeben Envelope nicht schon gueltig sein sollte.<br/>
+          * {@link #repaintTimer} is calling this method regularely to update the
-          * Since 21. April 09: Before thecalculation starts, the aspect ratio is
+          * {@link #finalImage} even if the renderers are still working.
-          * corrected. This change implies, that setMapArea() will most of the time
-          * not allow setting to a wrong aspectRatio.
-          *
-          * @author <a href="mailto:[email protected]">Stefan Alfons
-          *         Kr&uuml;ger</a>
           */
-         public Envelope bestAllowedMapArea(Envelope env) {
+         synchronized protected Image updateFinalImage() {
-                 if (getWidth() == 0)
-                         return env;
-                 if (env == null)
-                         return null;
-                 Envelope newArea = null;
+                 // 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(),
-                  * Correct the aspect Ratio before we check the rest. Otherwise we might
+                                         null);
-                  * easily fail. We allow to grow here, because we don't check against
-                  * the maxExtend
-                  */
-                 Rectangle curPaintArea = getVisibleRect();
-                 env = JTSUtil.fixAspectRatio(curPaintArea, env, true);
+                         // // Draw the local layers image
+                         preFinalG.drawImage(getLocalImage(), 0, 0, null);
+                         preFinalG.dispose();
-                 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 {
-                         // ****************************************************************************
+                         preFinalImage = getLocalImage();
-                         // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
-                         // ****************************************************************************
-                         newArea = env;
-                 }
-                 if (newArea == null) {
-                         final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
-                                         - newHeight2);
-                         final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
-                                         + newHeight2);
-                         newArea = new Envelope(ll, ur);
                  }
-                 Envelope maxAllowedExtend = getMaxExtend();
+                 final Graphics2D finalG = getFinalImage().createGraphics();
-                 while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea)
+                 finalG.setBackground(getMapBackgroundColor());
-                                 && newArea != null && !newArea.isNull()
+                 finalG.drawImage(getPreFinalImage(), imageOrigin.x, imageOrigin.y,
-                                 && !Double.isNaN(newArea.getMinX())
+                                 getMapBackgroundColor(), null);
-                                 && !Double.isNaN(newArea.getMaxX())
-                                 && !Double.isNaN(newArea.getMinY())
-                                 && !Double.isNaN(newArea.getMaxY())) {
-                         /*
-                          * If a maxExtend is set, we have to honour that...
-                          */
-                         // Exceeds top? Move down and maybe cut
-                         if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
-                                 double divY = newArea.getMaxY() - maxAllowedExtend.getMaxY();
-                                 // LOGGER.debug("Moving area down by " + divY);
-                                 newArea = new Envelope(new Coordinate(newArea.getMinX(),
-                                                 newArea.getMinY() - divY), new Coordinate(newArea
-                                                 .getMaxX(), newArea.getMaxY() - divY));
-                                 if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
-                                         // LOGGER.debug("Now it exeeds the bottom border.. cut!");
-                                         // And cut the bottom if it moved out of the area
-                                         newArea = new Envelope(new Coordinate(newArea.getMinX(),
-                                                         maxAllowedExtend.getMinY()), new Coordinate(newArea
-                                                         .getMaxX(), newArea.getMaxY()));
-                                         // LOGGER.debug("and fix aspect ratio");
-                                         newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
-                                                         false);
-                                 }
-                         }
-                         // Exceeds bottom? Move up and maybe cut
-                         if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
-                                 double divY = newArea.getMinY() - maxAllowedExtend.getMinY();
-                                 // LOGGER.debug("Moving area up by " + divY);
-                                 newArea = new Envelope(new Coordinate(newArea.getMinX(),
-                                                 newArea.getMinY() - divY), new Coordinate(newArea
-                                                 .getMaxX(), newArea.getMaxY() - divY));
-                                 if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
-                                         // LOGGER.debug("Now it exeeds the top border.. cut!");
-                                         // And cut the bottom if it moved out of the area
-                                         newArea = new Envelope(new Coordinate(newArea.getMinX(),
-                                                         newArea.getMinY()), new Coordinate(newArea
-                                                         .getMaxX(), maxAllowedExtend.getMaxY()));
-                                         // LOGGER.debug("and fix aspect ratio");
-                                         newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
+                 final int finalImageHeight = getFinalImage().getHeight(null);
-                                                         false);
+                 final int finalImageWidth = getFinalImage().getWidth(null);
-                                 }
-                         }
-                         // Exceeds to the right? move and maybe cut
+                 final Rectangle painedArea = new Rectangle(imageOrigin.x,
-                         if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
+                                 imageOrigin.y, finalImageWidth, finalImageHeight);
+                 SwingUtil.clearAround(finalG, painedArea, getVisibleRect());
-                                 // Move left..
+                 addGadgets(finalG, false);
-                                 double divX = newArea.getMaxX() - maxAllowedExtend.getMaxX();
-                                 // LOGGER.debug("Moving area left by " + divX);
-                                 newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
+                 finalG.dispose();
-                                                 newArea.getMinY()), new Coordinate(newArea.getMaxX()
-                                                 - divX, newArea.getMaxY()));
-                                 if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
+                 return finalImage;
-                                         // 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");
+         /**
+          * 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);
+                 }
-                                         newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
+                 int y = 17;
-                                                         false);
-                                 }
-                         }
-                         // Exceeds to the left? move and maybe cut
+                 // If the rendering process is still running, indicate this is the image
-                         if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
+                 if (forceWait || bgExecuter != null && bgExecuter.isRunning()
+                                 || localExecuter != null && localExecuter.isRunning()) {
-                                 // Move right..
+                         y += 8;
-                                 double divX = newArea.getMinX() - maxAllowedExtend.getMinX();
-                                 // LOGGER.debug("Moving area right by " + divX);
-                                 newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
+                         final Color c = graphics.getColor();
-                                                 newArea.getMinY()), new Coordinate(newArea.getMaxX()
+                         graphics.setFont(waitFont);
-                                                 - divX, newArea.getMaxY()));
-                                 if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
+                         graphics.setColor(getMapBackgroundColor());
-                                         // LOGGER.debug("Now it exeeds the right border.. cut!");
+                         graphics.drawString(waitMsg, 5, y);
-                                         // And cut the left if it moved out of the area
+                         graphics.setColor(getMapBackgroundColor());
-                                         newArea = new Envelope(new Coordinate(newArea.getMinX(),
+                         graphics.drawString(waitMsg, 7, y + 2);
-                                                         newArea.getMinY()), new Coordinate(maxAllowedExtend
+                         graphics.setColor(Color.BLACK);
-                                                         .getMaxX(), newArea.getMaxY()));
+                         graphics.drawString(waitMsg, 6, y + 1);
-                                         // LOGGER.debug("and fix aspect ratio");
+                         graphics.setColor(c);
-                                         newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
+                         y += 24;
-                                                         false);
-                                 }
-                         }
                  }
-                 return newArea;
+                 if (renderingErrors != null && isShowExceptions()) {
-         }
-         /**
+                         final Color c = graphics.getColor();
-          * Retuns the minimum allowed zoom scale. This is the bigger number value of
+                         graphics.setFont(errorFont);
-          * 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;
-         }
-         /**
+                         for (Exception ex : renderingErrors) {
-          * 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;
-         }
-         /**
+                                 String errStr = ex.getLocalizedMessage();
-          * 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;
-         }
-         /**
+                                 if (errStr == null)
-          * Set the minimum (nearest) allowed zoom scale. This is the bigger number
+                                         errStr = ex.getMessage();
-          * value of the two. If <code>null</code> is passed, Double.MAXVALUE are
+                                 if (errStr == null)
-          * used which mean there is no restriction.
+                                         errStr = "unknown error: " + ex.getClass().getSimpleName();
-          *
-          *
-          * @author <a href="mailto:[email protected]">Stefan Alfons
-          *         Kr&uuml;ger</a>
-          */
-         public void setMinZoomScale(final Double minZoomScale) {
-                 this.minZoomScale = minZoomScale == null ? Double.MAX_VALUE
-                                 : minZoomScale;
-         }
-         /**
-          * Defines an evelope of the viwable area. The JMapPane will never show
-          * anything outside of this extend.
-          *
-          * @param maxExtend
-          *            <code>null</code> to not have this restriction.
-          */
-         public void setMaxExtend(Envelope maxExtend) {
-                 this.maxExtend = maxExtend;
-         }
-         /**
+                                 graphics.setColor(Color.WHITE);
-          * Returns the evelope of the viewable area. The JMapPane will never show
+                                 graphics.drawString(errStr, 5, y);
-          * anything outside of this extend. If this has been set to
+                                 graphics.setColor(Color.RED);
-          * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
+                                 graphics.drawString(errStr, 6, y + 1);
-          * 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() {
+                                 y += 19;
-                 if (maxExtend == null) {
-                         final ReferencedEnvelope layerBounds = GTUtil
-                                         .getVisibleLayoutBounds(localContext);
-                         if (layerBounds == null) {
-                                 // TODO Last fallback could be the CRS valid area
-                                 return null;
                          }
-                         // Kartenbereich um 10% vergroessern
+                         graphics.setColor(c);
-                         return JTSUtil.fixAspectRatio(this.getBounds(), JTSUtil
-                                         .expandEnvelope(layerBounds, 0.1), true);
                  }
-                 return maxExtend;
-         }
-         /**
-          * Set the background color of the map.
-          *
-          * @param if <code>null</code>, white is used.
-          */
-         public void setMapBackgroundColor(Color bgColor) {
-                 if (bgColor == null)
-                         bgColor = Color.WHITE;
-                 this.mapBackgroundColor = bgColor;
-         }
-         /**
-          * Returns the background {@link Color} of the map pane. Default is white.
-          **/
-         public Color getMapBackgroundColor() {
-                 return mapBackgroundColor;
-         }
-         /**
-          *
-          * @param b
-          */
-         public void setPainting(boolean b) {
-                 acceptsRepaintCalls = b;
-         }
-         /**
-          * Fuegt der Map einen Listener hinzu.
-          *
-          * @param l
-          *            neuer Listener
-          */
-         public void addMapPaneListener(JMapPaneListener l) {
-                 mapPaneListeners.add(l);
          }
          /**
-          * Liste der angeschlossenen Listener, die auf Aktionen des MapPanes
+          * Sets the {@link #mapArea} to best possibly present the given features. If
-          * lauschen.
+          * only one single point is given, the window is moved over the point.
-          */
-         protected Vector<JMapPaneListener> mapPaneListeners = new Vector<JMapPaneListener>();
-         /**
-          * A flag indicating if dispose() was already called. If true, then further
-          * use of this {@link SelectableXMapPane} is undefined.
-          */
-         private boolean disposed = false;
-         /**
-          * Entfernt einen Listener von der Map.
           *
-          * @param l
+          * @param features
-          *            zu entfernender Listener
+          *            if <code>null</code> or size==0, the function doesn nothing.
           */
-         public void removeMapPaneListener(JMapPaneListener l) {
+         public void zoomTo(
-                 mapPaneListeners.remove(l);
+                         final FeatureCollection<SimpleFeatureType, SimpleFeature> features) {
-         }
- //      /** Stored the time used for the last real rendering in ms. **/
+                 // if (!isWellDefined()) return;
- //      private long lastRenderingDuration = Long.MAX_VALUE;
-         // if null, no quick preview will be shown
+                 final CoordinateReferenceSystem mapCRS = getMapContext()
-         private int quickPreviewHint = 0;
+                                 .getCoordinateReferenceSystem();
+                 final CoordinateReferenceSystem fCRS = features.getSchema()
-         /**
+                                 .getGeometryDescriptor().getCoordinateReferenceSystem();
-          * 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;
- //      /**
+                 ReferencedEnvelope _mapArea;
- //       * Returns in milli seconds the time the last rending of the
+                 if (mapArea == null)
- //       * {@link SelectableXMapPane} took. #Long.MAX_VALUE if the JMapPane has not
+                         _mapArea = features.getBounds();
- //       * been rendered yet.
+                 else _mapArea = getMapArea();
- //       */
+                 double width = _mapArea.getWidth();
- //      public long getLastRenderingDuration() {
+                 double height = _mapArea.getHeight();
- //              return lastRenderingDuration;
+                 final double ratio = height / width;
- //      }
-         /**
+                 if (features == null || features.size() == 0) {
-          * Should be called when the {@link JMapPane} is not needed no more to help
+                         // feature count == 0 Zoom to the full extend
-          * 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;
+                 } else if (features.size() == 1) {
-                 setPainting(false);
+                         // feature count == 1 Just move the window to the point and zoom 'a
+                         // bit'
-                 resizeTimer.stop();
+                         final SimpleFeature singleFeature = features.iterator().next();
-                 startRenderThreadsTimer.stop();
-                 disposed = true;
-                 if (bgExecuter != null) {
+                         if (((Geometry) singleFeature.getDefaultGeometry())
-                         bgExecuter.cancelTask();
+                                         .getCoordinates().length > 1) {
-                         bgExecuter.dispose();
+                                 // 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;
+                         }
-                 if (localExecuter != null) {
+                         Coordinate centre = features.getBounds().centre();
-                         int i = 0;
+                         if (!mapCRS.equals(fCRS)) {
-                         localExecuter.cancelTask();
+                                 // only to calculations if the CRS differ
-                         while (i++ < 10 && localExecuter.isRunning()){
                                  try {
-                                         Thread.sleep(200);
+                                         MathTransform fToMap;
-                                 } catch (InterruptedException e) {
+                                         fToMap = CRS.findMathTransform(fCRS, mapCRS);
-                                         // TODO Auto-generated catch block
+                                         // centre is transformed to the mapCRS
-                                         e.printStackTrace();
+                                         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);
                                  }
                          }
-                         if (localExecuter.isRunning()) {
-                                 System.out.println("BAD BAD BAD... still running the thread....");
-                         }
-                         localExecuter.dispose();
-                 }
-                 if (bgImage != null) {
-                         bgImage = dispose(bgImage);
-                         bgImage = null;
- //                      LangUtil.gcTotal();
-                 }
-                 if (localImage != null) {
-                         localImage = dispose(localImage);
-                         localImage = null;
- //                      LangUtil.gcTotal();
-                 }
-                 if (finalImage != null) {
+                         final Coordinate newLeftBottom = new Coordinate(centre.x - width
-                         finalImage = dispose(finalImage);
+                                         / 2., centre.y - height / 2.);
-                         finalImage = null;
+                         final Coordinate newTopRight = new Coordinate(
- //                      LangUtil.gcTotal();
+                                         centre.x + width / 2., centre.y + height / 2.);
-                 }
-                 if (preFinalImage != null) {
-                         preFinalImage = dispose(preFinalImage);
-                         preFinalImage=null;
-                 }
- //              LangUtil.gcTotal();
-                 // Alle mapPaneListener entfernen
+                         final Envelope newMapArea = new Envelope(newLeftBottom, newTopRight);
-                 mapPaneListeners.clear();
-                 removeMouseMotionListener(zoomMapPaneMouseListener);
+                         setMapArea(newMapArea);
-                 removeMouseListener(zoomMapPaneMouseListener);
-                 if (localContext != null)
+                 } else {
-                         getContext().clearLayerList();
+                         final ReferencedEnvelope fBounds = features.getBounds();
-                 if (bgContext != null)
-                         getBgContext().clearLayerList();
-                 removeAll();
+                         ReferencedEnvelope bounds;
-         }
+                         if (!mapCRS.equals(fCRS)) {
+                                 bounds = JTSUtil.transformEnvelope(fBounds, mapCRS);
+                         } else {
+                                 bounds = fBounds;
+                         }
+                         // BB umrechnen von Layer-CRS in Map-CRS
-         private BufferedImage dispose(BufferedImage bi) {
+                         // Expand a bit
+                         bounds.expandBy(bounds.getWidth() / 6., bounds.getHeight() / 6.);
- //              System.out.println("vorher = "
+                         setMapArea(bounds);
- //                      + new MbDecimalFormatter().format(LangUtil.gcTotal()));
+                 }
-                 bi.flush();
-                 return bi = null;
- //              System.out.println("nacher = "
- //                              + new MbDecimalFormatter().format(LangUtil.gcTotal()));
- //
- //              System.out.println("\n");
          }
          /**
-          * A flag indicating if dispose() has already been called. If true, then
+          * Zooms towards a point.
-          * further use of this {@link SelectableXMapPane} is undefined.
+          *
+          * @param center
+          *            position in window coordinates
+          * @param zoomFactor
+          *            > 1 for zoom in, < 1 for zoom out. Default is 1.33
           */
-         private boolean isDisposed() {
+         public void zoomTo(final Point center) {
-                 return disposed;
+                 zoomTo(center, null);
-         }
-         public void setQuickPreviewHint(int quickPreviewHint) {
-                 this.quickPreviewHint = quickPreviewHint;
-         }
-         public void setJava2dHints(RenderingHints java2dHints) {
-                 this.java2dHints = java2dHints;
-         }
-         public RenderingHints getJava2dHints() {
-                 return java2dHints;
          }
          /**
-Line 2062 
 public class XMapPane extends JPanel {
+Line 2340 
 public class XMapPane extends JPanel {
                  if (zoomFaktor == null || zoomFaktor == 0.)
                          zoomFaktor = 2.;
-                 Point2D gcenter = getScreenToWorld().transform(center, null);
+                 final Point2D gcenter = getScreenToWorld().transform(center, null);
                  center = null;
                  if (Double.isNaN(gcenter.getX()) || Double.isNaN(gcenter.getY())
-Line 2076 
 public class XMapPane extends JPanel {
+Line 2354 
 public class XMapPane extends JPanel {
                  final Envelope mapArea = getMapArea();
-                 Envelope newMapArea = new Envelope(mapArea);
+                 final Envelope newMapArea = new Envelope(mapArea);
                  newMapArea.expandBy((mapArea.getWidth() * zoomFaktor - mapArea
                                  .getWidth()) / 2., (mapArea.getHeight() * zoomFaktor - mapArea
                                  .getHeight()) / 2.);
-                 // Move the newMapArea above the new center
+                 // TODO we actually want that
-                 newMapArea.translate(gcenter.getX() - mapArea.centre().x, gcenter
+                 // // Move the newMapArea above the new center
-                                 .getY()
+                 // newMapArea.translate(gcenter.getX() - mapArea.centre().x, gcenter
-                                 - mapArea.centre().y);
+                 // .getY()
+                 // - mapArea.centre().y);
                  setMapArea(newMapArea);
          }
          /**
-          * Zooms towards a point.
+          * Shall non-fatal rendering exceptions be reported in the mappane or be
-          *
+          * dropped quitely.
-          * @param center
-          *            position in window coordinates
-          * @param zoomFactor
-          *            > 1 for zoom in, < 1 for zoom out. Default is 1.33
           */
-         public void zoomTo(Point center) {
+         public void setShowExceptions(boolean showExceptions) {
-                 zoomTo(center, null);
+                 this.showExceptions = showExceptions;
-         }
-         public void mouseDragged(Point startPos, Point lastPos, MouseEvent event) {
-                 if ((getState() == XMapPane.PAN)
-                                 || ((event.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) {
-                         if (getCursor() != SwingUtil.PANNING_CURSOR) {
-                                 setCursor(SwingUtil.PANNING_CURSOR);
-                                 // While panning, we deactivate the rendering. So the tasts are
-                                 // ready to start when the panning os done.
-                                 if (bgExecuter != null)
-                                         bgExecuter.cancelTask();
-                                 if (localExecuter != null)
-                                         localExecuter.cancelTask();
-                         }
-                         if (lastPos.x > 0 && lastPos.y > 0) {
-                                 final int dx = event.getX() - lastPos.x;
-                                 final int dy = event.getY() - lastPos.y;
-                                 // TODO Stop dragging when the drag would not be valid...
-                                 // boolean dragValid = true;
-                                 // // check if this panning results in a valid mapArea
-                                 // {
-                                 // Rectangle winBounds = xMapPane.getBounds();
-                                 // winBounds.translate(xMapPane.imageOrigin.x,
-                                 // -xMapPane.imageOrigin.y);
-                                 // Envelope newMapAreaBefore = xMapPane.tranformWindowToGeo(
-                                 // winBounds.x, winBounds.y, winBounds.x
-                                 // + winBounds.width, winBounds.y
-                                 // + winBounds.height);
-                                 //
-                                 //
-                                 // winBounds = xMapPane.getBounds();
-                                 // Point testIng = new Point(xMapPane.imageOrigin);
-                                 // testIng.translate(dx, dy);
-                                 // winBounds.translate(testIng.x, -testIng.y);
-                                 // Envelope newMapAreaAfter = xMapPane.tranformWindowToGeo(
-                                 // winBounds.x, winBounds.y, winBounds.x
-                                 // + winBounds.width, winBounds.y
-                                 // + winBounds.height);
-                                 //
-                                 // // If the last drag doesn't change the MapArea anymore cancel
-                                 // it.
-                                 // if (xMapPane.bestAllowedMapArea(newMapAreaAfter).equals(
-                                 // xMapPane.bestAllowedMapArea(newMapAreaBefore))){
-                                 // dragValid = false;
-                                 // return;
-                                 // }
-                                 // }
-                                 imageOrigin.translate(dx, dy);
-                                 updateFinalImage();
-                                 repaint();
-                         }
-                 } else if ((getState() == XMapPane.ZOOM_IN)
-                                 || (getState() == XMapPane.ZOOM_OUT)
-                                 || (getState() == XMapPane.SELECT_ALL)
-                                 || (getState() == XMapPane.SELECT_TOP)
-                 // || (getState() == XMapPane.SELECT_ONE_FROM_TOP)
-                 ) {
-                         final Graphics graphics = getGraphics();
-                         drawRectangle(graphics, startPos, event.getPoint());
-                         if ((lastPos.x > 0) && (lastPos.y > 0)) {
-                                 drawRectangle(graphics, startPos, lastPos);
-                         }
-                         graphics.dispose();
-                 }
-         }
-         /**
-          * Draws a rectangle in XOR mode from the origin at {@link #startPos} to the
-          * given point. All in screen coordinates.
-          */
-         protected void drawRectangle(final Graphics graphics, Point startPos,
-                         Point e) {
-                 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);
          }
          /**
-          * Finalizes a PAN action
+          * Shall exceptions be reported in the mappane?
           */
-         public void performPan() {
+         public boolean isShowExceptions() {
-                 Rectangle winBounds = getBounds();
+                 return showExceptions;
-                 winBounds.translate(-imageOrigin.x, -imageOrigin.y);
-                 Envelope newMapArea = tranformWindowToGeo(winBounds.x, winBounds.y,
-                                 winBounds.x + winBounds.width, winBounds.y + winBounds.height);
-                 imageOrigin.x = 0;
-                 imageOrigin.y = 0;
-                 if (!setMapArea(newMapArea)) {
-                         updateFinalImage();
-                         repaint();
-                 }
-                 if (getCursor() == SwingUtil.PANNING_CURSOR)
-                         setCursor(SwingUtil.PAN_CURSOR);
-         }
-         public void onRenderingPending() {
-                 // LOGGER.debug("Pending rendering updates the preview...");
-                 updateFinalImage();
-                 repaint();
          }
  }

 Legend:



Removed from v.529
 


changed lines


 
Added in v.553
 Legend:



Removed from v.529
 


changed lines


 
Added in v.553
-Removed from v.529
+Added in v.553

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26