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

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

Parent Directory | Revision Log | View Patch Patch

-trunk/src/org/geotools/gui/swing/JMapPane.java
revision 127 by mojays,
Sat May 30 14:29:58 2009 UTC
+branches/2.0-RC2/src/skrueger/geotools/XMapPane.java
revision 660 by alfonx,
Wed Feb  3 16:10:12 2010 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 org.geotools.gui.swing;
- /**
-  * <b>Xulu:<br>
-  *    Code taken from gt-2.4.5 to make some changes (marked with {@code xulu}),
-  *    which can not be realized in a subclass:</b>
-  *    <ul>
-  *       <li>{@link #getMapArea()} declared as {@code final}<li>
-  *       <li>some variables declared as {@code protected}</li>
-  *       <li>minimal/maximal zoom scale</li>
-  *       <li>zoom in and zoom out via mouse click realized by setMapArea(..)</li>
-  *    </ul>
-  * <br><br>
-  * A simple map container that is a JPanel with a map in. provides simple
-  * pan,zoom, highlight and selection The mappane stores an image of the map
-  * (drawn from the context) and an image of the slected feature(s) to speed up
-  * rendering of the highlights. Thus the whole map is only redrawn when the bbox
-  * changes, selection is only redrawn when the selected feature changes.
-  *
-  *
-  * @author Ian Turton
-  *
-  */
  import java.awt.Color;
  import java.awt.Cursor;
+ import java.awt.Font;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
- import java.awt.LayoutManager;
+ import java.awt.Image;
+ import java.awt.Point;
  import java.awt.Rectangle;
- import java.awt.event.InputEvent;
+ import java.awt.RenderingHints;
+ import java.awt.event.ActionEvent;
+ import java.awt.event.ActionListener;
+ import java.awt.event.ComponentAdapter;
+ import java.awt.event.ComponentEvent;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
- import java.awt.event.MouseMotionListener;
+ import java.awt.geom.AffineTransform;
+ import java.awt.geom.NoninvertibleTransformException;
+ import java.awt.geom.Point2D;
  import java.awt.image.BufferedImage;
- import java.beans.PropertyChangeEvent;
- import java.beans.PropertyChangeListener;
  import java.io.IOException;
- import java.util.Date;
+ import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Map;
+ import java.util.Vector;
- import javax.swing.JPanel;
+ import javax.swing.JList;
+ import javax.swing.Timer;
+ import javax.swing.border.Border;
  import org.apache.log4j.Logger;
+ import org.geotools.factory.GeoTools;
  import org.geotools.feature.FeatureCollection;
- import org.geotools.filter.IllegalFilterException;
+ import org.geotools.geometry.DirectPosition2D;
- import org.geotools.gui.swing.event.HighlightChangeListener;
+ import org.geotools.geometry.jts.JTS;
- import org.geotools.gui.swing.event.HighlightChangedEvent;
+ import org.geotools.geometry.jts.ReferencedEnvelope;
- import org.geotools.gui.swing.event.SelectionChangeListener;
- import org.geotools.gui.swing.event.SelectionChangedEvent;
  import org.geotools.map.DefaultMapContext;
  import org.geotools.map.MapContext;
  import org.geotools.map.MapLayer;
+ import org.geotools.map.event.MapLayerEvent;
  import org.geotools.map.event.MapLayerListEvent;
  import org.geotools.map.event.MapLayerListListener;
- import org.geotools.referencing.crs.DefaultGeographicCRS;
+ import org.geotools.map.event.MapLayerListener;
+ import org.geotools.referencing.CRS;
  import org.geotools.renderer.GTRenderer;
+ import org.geotools.renderer.label.LabelCacheImpl;
  import org.geotools.renderer.lite.LabelCache;
- import org.geotools.renderer.lite.LabelCacheDefault;
+ import org.geotools.renderer.lite.RendererUtilities;
  import org.geotools.renderer.lite.StreamingRenderer;
- import org.geotools.styling.Graphic;
+ import org.geotools.swing.JMapPane;
- import org.geotools.styling.LineSymbolizer;
+ import org.geotools.swing.event.MapMouseEvent;
- import org.geotools.styling.Mark;
+ import org.geotools.swing.event.MapPaneEvent;
- import org.geotools.styling.PointSymbolizer;
+ import org.geotools.swing.event.MapPaneListener;
- import org.geotools.styling.PolygonSymbolizer;
+ import org.opengis.feature.simple.SimpleFeature;
- import org.geotools.styling.Style;
+ import org.opengis.feature.simple.SimpleFeatureType;
- import org.geotools.styling.StyleBuilder;
+ import org.opengis.referencing.FactoryException;
- import org.geotools.styling.StyleFactory;
- import org.opengis.filter.Filter;
- import org.opengis.filter.FilterFactory2;
  import org.opengis.referencing.crs.CoordinateReferenceSystem;
+ import org.opengis.referencing.operation.MathTransform;
+ import org.opengis.referencing.operation.TransformException;
+ import schmitzm.geotools.GTUtil;
+ import schmitzm.geotools.JTSUtil;
+ import schmitzm.geotools.gui.SelectableXMapPane;
+ import schmitzm.geotools.io.GeoImportUtil;
+ import schmitzm.geotools.map.event.JMapPaneListener;
+ import schmitzm.geotools.map.event.MapLayerAdapter;
+ import schmitzm.lang.LangUtil;
+ import schmitzm.swing.JPanel;
  import schmitzm.swing.SwingUtil;
+ import schmitzm.swing.event.MouseInputType;
  import com.vividsolutions.jts.geom.Coordinate;
  import com.vividsolutions.jts.geom.Envelope;
  import com.vividsolutions.jts.geom.Geometry;
- import com.vividsolutions.jts.geom.GeometryFactory;
- public class JMapPane extends JPanel implements MouseListener,
+ /**
-         MouseMotionListener, HighlightChangeListener,SelectionChangeListener, PropertyChangeListener,
+  * The {@link XMapPane} class uses a Geotools {@link GTRenderer} to paint up to
-         MapLayerListListener {
+  * two {@link MapContext}s: a "local" {@link MapContext} and a "background"
-     private static Logger LOGGER = Logger.getLogger( JMapPane.class.getName() );
+  * {@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>
-     private static final long serialVersionUID = -8647971481359690499L;
+  * <br>
+  * While the renderers are rending the map, a <br>
-     public static final int Reset = 0;
+  * The {@link XMapPane} is based on schmitzm {@link JPanel}, so
+  * {@link #print(Graphics)} will automatically set the background of components
-     public static final int ZoomIn = 1;
+  * to pure white.
+  *
-     public static final int ZoomOut = 2;
+  * The XMapPane has a {@link MouseListener} that manages zooming.<br>
+  * A logo/icon to float in the lower left corner may be set with
-     public static final int Pan = 3;
+  * {@link #setMapImage(BufferedImage)}<br>
+  *
-     public static final int Select = 4;
+  * @see SelectableXMapPane - an extension of {@link XMapPane} that supports
+  *      selecting features.
-     private static final int POLYGON = 0;
+  *
+  * @author stefan
-     private static final int LINE = 1;
+  *
+  */
-     private static final int POINT = 2;
+ public class XMapPane extends JPanel {
-     /**
+         /**
-      * what renders the map
+          * If {@link #maxExtend} is <code>null</code> the following rules are used
-      */
+          * to create a default maximum.
-     GTRenderer renderer;
+          * <ul>
+          * <li>Values &lt; 0 : don't grow to fit the monitors aspect ratio, no
-     private GTRenderer highlightRenderer, selectionRenderer;
+          * margin</li>
+          * <li>Values 0 : grow to fit the monitors aspect ratio, no margin</li>
-     /**
+          * <li>Values &gt; 0 : grow to fit the monitors aspect ratio, and add a
-      * the map context to render
+          * relative margin</li>
-      */
+          * </ul>
-     MapContext context;
+          * **/
+         private double defaultMaxMapExtendMode = .05;
-     private MapContext selectionContext;
+         // private static final int IMAGETYPE = BufferedImage.TYPE_INT_RGB;
-     /**
+         // private static final int IMAGETYPE_withAlpha =
-      * the area of the map to draw
+         // BufferedImage.TYPE_INT_ARGB;
-      */
+         private static final int IMAGETYPE = BufferedImage.TYPE_3BYTE_BGR;
- //xulu.sc
- //    Envelope mapArea;
+         public XMapPaneTool getTool() {
-     protected Envelope mapArea;
+                 return tool;
- //xulu.ec
+         }
-     /**
+         private static final int IMAGETYPE_withAlpha = BufferedImage.TYPE_4BYTE_ABGR;
-      * the size of the pane last time we drew
-      */
+         private final static Logger LOGGER = Logger.getLogger(XMapPane.class);
- //xulu.sc
- //    private Rectangle oldRect = null;
+         /**
-     protected Rectangle oldRect = null;
+          * A flag indicating whether the {@link XMapPane} is accepting repaints from
- //xulu.ec
+          * the EDT. @see {@link XMapPane#setPainting(boolean))
+          **/
-     /**
+         private boolean acceptsRepaintCalls = true;
-      * the last map area drawn.
-      */
+         /**
- //xulu.sc
+          * Main {@link MapContext} that holds all layers that are rendered into the
- //    private Envelope oldMapArea = null;
+          * {@link #localImage} by the {@link #localRenderer}
-     protected Envelope oldMapArea = null;
+          */
- //xulu.ec
+         MapContext localContext;
-     /**
+         /**
-      * the base image of the map
+          * {@link MapContext} holding the background layers. Use it for layers that
-      */
+          * CAN take very long for rendering, like layer from the Internet: WMS, WFS,
-     protected  BufferedImage baseImage, panningImage;
+          * OSM...<br>
-     // SK: private BufferedImage baseImage, panningImage;
+          * <code>null</code> by default.
+          *
-     /**
+          * @see #setBgContext(MapContext)
-      * image of selection
+          * @see #getBgContext()
-      */
+          */
-     private BufferedImage selectImage;
+         MapContext bgContext;
-     /**
+         /**
-      * style for selected items
+          * While threads are working, calls {@link XMapPane#updateFinalImage()}
-      */
+          * regularly and {@link #repaint()}. This {@link Timer} is stopped when all
-     private Style selectionStyle;
+          * renderers have finished.
+          *
-     /**
+          * @see INITIAL_REPAINT_DELAYAL
-      * layer that selection works on
+          * @see #REPEATING_REPAINT_DELAY
-      */
+          */
-     private MapLayer selectionLayer;
+         final private Timer repaintTimer;
-     /**
+         /**
-      * layer that highlight works on
+          * The initial delay in milliseconds until the {@link #finalImage} is
-      */
+          * updated the first time.
-     private MapLayer highlightLayer;
+          */
+         public static final int INITIAL_REPAINT_DELAY = 900;
-     /**
-      * the object which manages highlighting
+         /**
-      */
+          * While the {@link #bgExecuter} and {@link #localExecuter} are rendering,
-     private HighlightManager highlightManager;
+          * the {@link #repaintTimer} is regularly updating the {@link #finalImage}
+          * with previews.
-     /**
+          */
-      * is highlighting on or off
+         public static final int REPEATING_REPAINT_DELAY = 500;
-      */
-     private boolean highlight = true;
+         /**
+          * Default delay (milliseconds) before the map will be redrawn when resizing
-     /**
+          * the pane. This is to avoid flickering while drag-resizing.
-      * a factory for filters
+          *
-      */
+          * @see #resizeTimer
-     FilterFactory2 ff;
+          */
+         public static final int DEFAULT_RESIZING_PAINT_DELAY = 600;
-     /**
-      * a factory for geometries
-      */
-     GeometryFactory gf = new GeometryFactory(); // FactoryFinder.getGeometryFactory(null);
-     /**
-      * the collections of features to be selected or highlighted
-      */
-     FeatureCollection selection;
-     /**
-      * the collections of features to be selected or highlighted
-      */
-     FeatureCollection highlightFeature;
-     private int state = ZoomIn;
-     /**
-      * how far to zoom in or out
-      */
-     private double zoomFactor = 2.0;
-     Style lineHighlightStyle;
-     Style pointHighlightStyle;
-     Style polygonHighlightStyle;
-     Style polygonSelectionStyle;
-     Style pointSelectionStyle;
-     Style lineSelectionStyle;
-     boolean changed = true;
-     LabelCache labelCache = new LabelCacheDefault();
- //xulu.sc
- //    private boolean reset = false;
-     protected boolean reset = false;
- //xulu.ec
-     int startX;
-     int startY;
-     private boolean clickable;
-     int lastX;
-     int lastY;
-     private SelectionManager selectionManager;
- //xulu.sn
-     private Double maxZoomScale = Double.MIN_VALUE;
-     private Double minZoomScale = Double.MAX_VALUE;
- //xulu.en
- // sk.sn
-     /**
-      * Wenn true, dann wurde PANNING via mouseDraged-Events begonnen. Dieses Flag wird benutzt um nur einmal den passenden Cursor nur einmal zu setzen.
-      */
-         private boolean panning_started = false;
- // sk.en
-     public JMapPane() {
-         this(null, true, null, null);
-     }
-     /**
-      * create a basic JMapPane
-      *
-      * @param render -
-      *            how to draw the map
-      * @param context -
-      *            the map context to display
-      */
-     public JMapPane(GTRenderer render, MapContext context) {
-         this(null, true, render, context);
-     }
-     /**
-      * full constructor extending JPanel
-      *
-      * @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 context -
-      *            what to draw
-      */
-     public JMapPane(LayoutManager layout, boolean isDoubleBuffered,
-             GTRenderer render, MapContext context) {
-         super(layout, isDoubleBuffered);
-         ff = (FilterFactory2) org.geotools.factory.CommonFactoryFinder
-                 .getFilterFactory(null);
-         setRenderer(render);
-         setContext(context);
-         this.addMouseListener(this);
-         this.addMouseMotionListener(this);
-         setHighlightManager(new HighlightManager(highlightLayer));
-         setSelectionManager(new SelectionManager(selectionLayer));
-         lineHighlightStyle = setupStyle(LINE, Color.red);
-         pointHighlightStyle = setupStyle(POINT, Color.red);
-         polygonHighlightStyle = setupStyle(POLYGON, Color.red);
-         polygonSelectionStyle = setupStyle(POLYGON, Color.cyan);
-         pointSelectionStyle = setupStyle(POINT, Color.cyan);
-         lineSelectionStyle = setupStyle(LINE, Color.cyan);
-         setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
-     }
-     /**
-      * get the renderer
-      */
-     public GTRenderer getRenderer() {
-         return renderer;
-     }
-     public void setRenderer(GTRenderer renderer) {
-         Map hints = new HashMap();
-         if (renderer instanceof StreamingRenderer) {
-             hints = renderer.getRendererHints();
-             if (hints == null) {
-                 hints = new HashMap();
-             }
-             if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {
-                 labelCache = (LabelCache) hints
-                         .get(StreamingRenderer.LABEL_CACHE_KEY);
-             } else {
-                 hints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);
-             }
-             renderer.setRendererHints(hints);
-         }
-         this.renderer = renderer;
-         this.highlightRenderer = new StreamingRenderer();
-         this.selectionRenderer = new StreamingRenderer();
-         hints.put("memoryPreloadingEnabled", Boolean.FALSE);
-         highlightRenderer.setRendererHints(hints);
-         selectionRenderer.setRendererHints(hints);
-         if (this.context != null) {
-             this.renderer.setContext(this.context);
-         }
-     }
-     public MapContext getContext() {
-         return context;
-     }
-     public void setContext(MapContext context) {
-         if (this.context != null) {
-             this.context.removeMapLayerListListener(this);
-         }
-         this.context = context;
-         if (context != null) {
-             this.context.addMapLayerListListener(this);
-         }
-         if (renderer != null) {
-             renderer.setContext(this.context);
-         }
-     }
-     public Envelope getMapArea() {
-         return mapArea;
-     }
-     public void setMapArea(Envelope mapArea) {
-         this.mapArea = mapArea;
-     }
-     public int getState() {
-         return state;
-     }
-     public void setState(int state) {
-         this.state = state;
-         // System.out.println("State: " + state);
-     }
-     public double getZoomFactor() {
-         return zoomFactor;
-     }
-     public void setZoomFactor(double zoomFactor) {
-         this.zoomFactor = zoomFactor;
-     }
-     public MapLayer getSelectionLayer() {
-         return selectionLayer;
-     }
-     public void setSelectionLayer(MapLayer selectionLayer) {
-         this.selectionLayer = selectionLayer;
-         if(selectionManager!=null) {
-             selectionManager.setSelectionLayer(selectionLayer);
-         }
-     }
-     public boolean isHighlight() {
-         return highlight;
-     }
-     public void setHighlight(boolean highlight) {
-         this.highlight = highlight;
-     }
-     public MapLayer getHighlightLayer() {
-         return highlightLayer;
-     }
-     public void setHighlightLayer(MapLayer highlightLayer) {
-         this.highlightLayer = highlightLayer;
-         if (highlightManager != null) {
-             highlightManager.setHighlightLayer(highlightLayer);
-         }
-     }
-     public HighlightManager getHighlightManager() {
-         return highlightManager;
-     }
-     public void setHighlightManager(HighlightManager highlightManager) {
-         this.highlightManager = highlightManager;
-         this.highlightManager.addHighlightChangeListener(this);
-         this.addMouseMotionListener(this.highlightManager);
-     }
-     public Style getLineHighlightStyle() {
-         return lineHighlightStyle;
-     }
-     public void setLineHighlightStyle(Style lineHighlightStyle) {
-         this.lineHighlightStyle = lineHighlightStyle;
-     }
-     public Style getLineSelectionStyle() {
-         return lineSelectionStyle;
-     }
-     public void setLineSelectionStyle(Style lineSelectionStyle) {
-         this.lineSelectionStyle = lineSelectionStyle;
-     }
-     public Style getPointHighlightStyle() {
-         return pointHighlightStyle;
-     }
-     public void setPointHighlightStyle(Style pointHighlightStyle) {
-         this.pointHighlightStyle = pointHighlightStyle;
-     }
-     public Style getPointSelectionStyle() {
-         return pointSelectionStyle;
-     }
-     public void setPointSelectionStyle(Style pointSelectionStyle) {
-         this.pointSelectionStyle = pointSelectionStyle;
-     }
-     public Style getPolygonHighlightStyle() {
-         return polygonHighlightStyle;
-     }
-     public void setPolygonHighlightStyle(Style polygonHighlightStyle) {
-         this.polygonHighlightStyle = polygonHighlightStyle;
-     }
-     public Style getPolygonSelectionStyle() {
-         return polygonSelectionStyle;
-     }
-     public void setPolygonSelectionStyle(Style polygonSelectionStyle) {
-         this.polygonSelectionStyle = polygonSelectionStyle;
-     }
-     protected void paintComponent(Graphics g) {
-         super.paintComponent(g);
-         if ((renderer == null) || (mapArea == null)  ) {
-             return;
-         }
-         Rectangle r = getBounds();
-         Rectangle dr = new Rectangle(r.width, r.height);
-         if (!r.equals(oldRect) || reset) {
-                 if(!r.equals(oldRect) && (mapArea == null)) {
-                         try {
-                                         mapArea=context.getLayerBounds();
-                                 } catch (IOException e) {
-                                         // TODO Auto-generated catch block
-                                         e.printStackTrace();
-                                 }
-                 }
-                 if (mapArea != null){
-                         /* either the viewer size has changed or we've done a reset */
-                         changed = true; /* note we need to redraw */
-                         reset = false; /* forget about the reset */
-                         oldRect = r; /* store what the current size is */
-                         mapArea = fixAspectRatio(r, mapArea);
-                 }
-         }
-         if (!mapArea.equals(oldMapArea)) { /* did the map extent change? */
-             changed = true;
-             oldMapArea = mapArea;
- //          when we tell the context that the bounds have changed WMSLayers
-             // can refresh them selves
-             context.setAreaOfInterest(mapArea, context
-                     .getCoordinateReferenceSystem());
-         }
-         if (changed) { /* if the map changed then redraw */
-             changed = false;
-             baseImage = new BufferedImage(dr.width, dr.height,
-                     BufferedImage.TYPE_INT_ARGB);
-             Graphics2D ig = baseImage.createGraphics();
-             /* System.out.println("rendering"); */
-             renderer.setContext(context);
-             labelCache.clear(); // work around anoying labelcache bug
-             // draw the map
-             renderer.paint((Graphics2D) ig, dr, mapArea);
-             // TODO , nur machen, wenn panning beginnt
-             panningImage = new BufferedImage(dr.width, dr.height,
-                         BufferedImage.TYPE_INT_RGB);
-         }
-         ((Graphics2D) g).drawImage(baseImage, 0, 0, this);
-         if ((selection != null) && (selection.size() > 0)) {
-             // paint selection
-             String type = selectionLayer.getFeatureSource().getSchema()
-             .getDefaultGeometry().getType().getName();
-             /*String type = selection.getDefaultGeometry().getGeometryType();*/
-             /*System.out.println(type);*/
-             if (type == null)
-                 type = "polygon";
-             /* String type = "point"; */
-             if (type.toLowerCase().endsWith("polygon")) {
-                 selectionStyle = polygonSelectionStyle;
-             } else if (type.toLowerCase().endsWith("point")) {
-                 selectionStyle = pointSelectionStyle;
-             } else if (type.toLowerCase().endsWith("line")) {
-                 selectionStyle = lineSelectionStyle;
-             }
-             selectionContext = new DefaultMapContext(DefaultGeographicCRS.WGS84);
-             selectionContext.addLayer(selection, selectionStyle);
-             selectionRenderer.setContext(selectionContext);
-             selectImage = new BufferedImage(dr.width, dr.height,
-                     BufferedImage.TYPE_INT_ARGB);
-             Graphics2D ig = selectImage.createGraphics();
-             /* System.out.println("rendering selection"); */
-             selectionRenderer.paint((Graphics2D) ig, dr, mapArea);
-             ((Graphics2D) g).drawImage(selectImage, 0, 0, this);
-         }
-         if (highlight && (highlightFeature != null)
-                 && (highlightFeature.size() > 0)) {
-             /*
-              * String type = selection.getDefaultGeometry().getGeometryType();
-              * System.out.println(type); if(type==null) type="polygon";
-              */
-             String type = highlightLayer.getFeatureSource().getSchema()
-             .getDefaultGeometry().getType().getName();
-             /*String type = selection.getDefaultGeometry().getGeometryType();*/
-             //System.out.println(type);
-             if (type == null)
-                 type = "polygon";
-             /* String type = "point"; */
-             Style highlightStyle = null;
-             if (type.toLowerCase().endsWith("polygon")) {
-                 highlightStyle = polygonHighlightStyle;
-             } else if (type.toLowerCase().endsWith("point")) {
-                 highlightStyle = pointHighlightStyle;
-             } else if (type.toLowerCase().endsWith("line")) {
-                 highlightStyle = lineHighlightStyle;
-             }
-             MapContext highlightContext = new DefaultMapContext(
-                     DefaultGeographicCRS.WGS84);
-             highlightContext.addLayer(highlightFeature, highlightStyle);
-             highlightRenderer.setContext(highlightContext);
-             /* System.out.println("rendering highlight"); */
-             highlightRenderer.paint((Graphics2D) g, dr, mapArea);
-         }
-     }
-     private Envelope fixAspectRatio(Rectangle r, Envelope mapArea) {
-         double mapWidth = mapArea.getWidth(); /* get the extent of the map */
-         double mapHeight = mapArea.getHeight();
-         double scaleX = r.getWidth() / mapArea.getWidth(); /*
-                                                              * calculate the new
-                                                              * scale
-                                                              */
-         double scaleY = r.getHeight() / mapArea.getHeight();
-         double scale = 1.0; // stupid compiler!
-         if (scaleX < scaleY) { /* pick the smaller scale */
-             scale = scaleX;
-         } else {
-             scale = scaleY;
-         }
-         /* calculate the difference in width and height of the new extent */
-         double deltaX = /* Math.abs */((r.getWidth() / scale) - mapWidth);
-         double deltaY = /* Math.abs */((r.getHeight() / scale) - mapHeight);
-         /*
-          * System.out.println("delta x " + deltaX); System.out.println("delta y " +
-          * deltaY);
-          */
-         /* create the new extent */
-         Coordinate ll = new Coordinate(mapArea.getMinX() - (deltaX / 2.0),
-                 mapArea.getMinY() - (deltaY / 2.0));
-         Coordinate ur = new Coordinate(mapArea.getMaxX() + (deltaX / 2.0),
-                 mapArea.getMaxY() + (deltaY / 2.0));
-         return new Envelope(ll, ur);
-     }
-     public void doSelection(double x, double y, MapLayer layer) {
-         Geometry geometry = gf.createPoint(new Coordinate(x, y));
-         // org.opengis.geometry.Geometry geometry = new Point();
-             findFeature(geometry, layer);
-     }
-     /**
-      * @param geometry -
-      *            a geometry to construct the filter with
-      * @param i -
-      *            the index of the layer to search
-      * @throws IndexOutOfBoundsException
-      */
-     private void findFeature(Geometry geometry, MapLayer layer)
-             throws IndexOutOfBoundsException {
-         org.opengis.filter.spatial.BinarySpatialOperator f = null;
-         if ((context == null) || (layer==null)) {
-             return ;
-         }
-         try {
-             String name = layer.getFeatureSource().getSchema()
-                     .getDefaultGeometry().getName();
-             if (name == "") {
-                 name = "the_geom";
-             }
-             try {
-                 f = ff.contains(ff.property(name), ff.literal(geometry));
-                 if(selectionManager!=null) {
-                     System.out.println("selection changed");
-                     selectionManager.selectionChanged(this, f);
-                 }
-             } catch (IllegalFilterException e) {
-                 // TODO Auto-generated catch block
-                 e.printStackTrace();
-             }
-             /*// f.addLeftGeometry(ff.property(name));
-             // System.out.println("looking with " + f);
-             FeatureCollection fc = layer.getFeatureSource().getFeatures(f);
-             if (fcol == null) {
-                 fcol = fc;
-                 // here we should set the defaultgeom type
-             } else {
-                 fcol.addAll(fc);
-             }*/
-             /*
-              * GeometryAttributeType gat =
-              * layer.getFeatureSource().getSchema().getDefaultGeometry();
-              * fcol.setDefaultGeometry((Geometry)gat.createDefaultValue());
-              */
-             /*
-              * Iterator fi = fc.iterator(); while (fi.hasNext()) { Feature feat =
-              * (Feature) fi.next(); System.out.println("selected " +
-              * feat.getAttribute("STATE_NAME")); }
-              */
-         } catch (IllegalFilterException e) {
-             // TODO Auto-generated catch block
-             e.printStackTrace();
-         }
-         return ;
-     }
-     public void mouseClicked(MouseEvent e) {
-         // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"
-         // h:"+mapArea.getHeight());
-         Rectangle bounds = this.getBounds();
-         double x = (double) (e.getX());
-         double y = (double) (e.getY());
-         double width = mapArea.getWidth();
-         double height = mapArea.getHeight();
- //xulu.sc
- //        double width2 = mapArea.getWidth() / 2.0;
- //        double height2 = mapArea.getHeight() / 2.0;
-         double width2 = width / 2.0;
-         double height2 = height / 2.0;
- //xulu.ec
-         double mapX = ((x * width) / (double) bounds.width) + mapArea.getMinX();
-         double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)
-                 + mapArea.getMinY();
-         /*
-          * System.out.println(""+x+"->"+mapX);
-          * System.out.println(""+y+"->"+mapY);
-          */
-         /*
-          * Coordinate ll = new Coordinate(mapArea.getMinX(), mapArea.getMinY());
-          * Coordinate ur = new Coordinate(mapArea.getMaxX(), mapArea.getMaxY());
-          */
-         double zlevel = 1.0;
-         switch (state) {
-         case Pan:
-             zlevel = 1.0;
- //xulu.sc SK: return here.. a mouselistener is maanaging the PANNING
- //            break;
-             return;
- //xulu.ec
-         case ZoomIn:
-             zlevel = zoomFactor;
-             break;
-         case ZoomOut:
-             zlevel = 1.0 / zoomFactor;
-             break;
-         case Select:
-             doSelection(mapX, mapY, selectionLayer);
-             return;
-         default:
-             return;
-         }
-         Coordinate ll = new Coordinate(mapX - (width2 / zlevel), mapY
-                 - (height2 / zlevel));
-         Coordinate ur = new Coordinate(mapX + (width2 / zlevel), mapY
-                 + (height2 / zlevel));
- //xulu.sc SK: Check for min/max scale
- //        mapArea = new Envelope(ll, ur);
-         final Envelope newMapArea = new Envelope(ll, ur);
-         setMapArea( bestAllowedMapArea( newMapArea ) );
- //xulu.ec
-         // System.out.println("after area "+mapArea+"\nw:"+mapArea.getWidth()+"
-         // h:"+mapArea.getHeight());
-         repaint();
-     }
-     public void mouseEntered(MouseEvent e) {
-     }
-     public void mouseExited(MouseEvent e) {
-     }
-     public void mousePressed(MouseEvent e) {
-         startX = e.getX();
-         startY = e.getY();
-         lastX = 0;
-         lastY = 0;
-     }
-     public void mouseReleased(MouseEvent e) {
-         int endX = e.getX();
-         int endY = e.getY();
-         processDrag(startX, startY, endX, endY, e);
-         lastX = 0;
-         lastY = 0;
-         /**
-          * Es wird nicht (mehr) gepannt!
-          */
-         panning_started = false;
-     }
-     public void mouseDragged(MouseEvent e) {
-         Graphics graphics = this.getGraphics();
-         int x = e.getX();
-         int y = e.getY();
-         if ( (state == JMapPane.Pan) || ((e.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0))  {
-             /**
-              * SK:
-              * Der Cursor wird auf PANNING gesetzt.
-              */
-                 if (panning_started == false){
-                         panning_started = true;
-                         setCursor( SwingUtil.PANNING_CURSOR );
-                 }
-             // move the image with the mouse
-             if ((lastX > 0) && (lastY > 0)) {
-                 int dx = lastX - startX;
-                 int dy = lastY - startY;
-                 // System.out.println("translate "+dx+","+dy);
-                 final Graphics2D g2 = panningImage.createGraphics();
-                 g2.setBackground( new Color(240,240,240) ); //TODO richtige farbe? am besten vom L&F die hintergrundfarbe auslesen...
-                                 g2.clearRect(0, 0, this.getWidth(), this.getHeight());
-                                 g2.drawImage(baseImage, dx, dy, this);
-                 graphics.drawImage(panningImage, 0, 0, this);
-             }
-             lastX = x;
-             lastY = y;
-         } else
-         if ((state == JMapPane.ZoomIn) || (state == JMapPane.ZoomOut)) {
-             graphics.setXORMode(Color.WHITE);
-             if ((lastX > 0) && (lastY > 0)) {
-                 drawRectangle(graphics);
-             }
-             // draw new box
-             lastX = x;
-             lastY = y;
-             drawRectangle(graphics);
-         } else if (state == JMapPane.Select && selectionLayer != null) {
-             // construct a new bbox filter
-             Rectangle bounds = this.getBounds();
-             double mapWidth = mapArea.getWidth();
-             double mapHeight = mapArea.getHeight();
-             double x1 = ((this.startX * mapWidth) / (double) bounds.width)
-                     + mapArea.getMinX();
-             double y1 = (((bounds.getHeight() - this.startY) * mapHeight) / (double) bounds.height)
-                     + mapArea.getMinY();
-             double x2 = ((x * mapWidth) / (double) bounds.width)
-                     + mapArea.getMinX();
-             double y2 = (((bounds.getHeight() - y) * mapHeight) / (double) bounds.height)
-                     + mapArea.getMinY();
-             double left = Math.min(x1, x2);
-             double right = Math.max(x1, x2);
-             double bottom = Math.min(y1, y2);
-             double top = Math.max(y1, y2);
-             String name = selectionLayer.getFeatureSource().getSchema()
-                     .getDefaultGeometry().getName();
-             if (name == "") {
-                 name = "the_geom";
-             }
-             Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,
-                     getContext().getCoordinateReferenceSystem().toString());
-             if(selectionManager!=null) {
-                 selectionManager.selectionChanged(this, bb);
-             }
-             graphics.setXORMode(Color.green);
-             /*
-              * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }
-              */
-             // draw new box
-             lastX = x;
-             lastY = y;
-             drawRectangle(graphics);
-        }
-     }
-     // sk.cs
- //    private void processDrag(int x1, int y1, int x2, int y2) {
-     // sk.ce
-     protected void processDrag(int x1, int y1, int x2, int y2, MouseEvent e) {
-         /****
-          * If no layer is availabe we dont want a NullPointerException
-          */
-         if (mapArea == null) return;
-         // System.out.println("processing drag from " + x1 + "," + y1 + " -> "
-         // + x2 + "," + y2);
-         if ((x1 == x2) && (y1 == y2)) {
-             if (isClickable()) {
-                 mouseClicked(new MouseEvent(this, 0, new Date().getTime(), 0,
-                         x1, y1, y2, false));
-             }
-             return;
-         }
-         Rectangle bounds = this.getBounds();
-         double mapWidth = mapArea.getWidth();
-         double mapHeight = mapArea.getHeight();
-         double startX = ((x1 * mapWidth) / (double) bounds.width)
-                 + mapArea.getMinX();
-         double startY = (((bounds.getHeight() - y1) * mapHeight) / (double) bounds.height)
-                 + mapArea.getMinY();
-         double endX = ((x2 * mapWidth) / (double) bounds.width)
-                 + mapArea.getMinX();
-         double endY = (((bounds.getHeight() - y2) * mapHeight) / (double) bounds.height)
-                 + mapArea.getMinY();
-         if (  (state == JMapPane.Pan) || (e.getButton()== MouseEvent.BUTTON3)) {
-             // move the image with the mouse
-             // calculate X offsets from start point to the end Point
-             double deltaX1 = endX - startX;
-             // System.out.println("deltaX " + deltaX1);
-             // new edges
-             double left = mapArea.getMinX() - deltaX1;
-             double right = mapArea.getMaxX() - deltaX1;
-             // now for Y
-             double deltaY1 = endY - startY;
-             // System.out.println("deltaY " + deltaY1);
-             double bottom = mapArea.getMinY() - deltaY1;
-             double top = mapArea.getMaxY() - deltaY1;
-             Coordinate ll = new Coordinate(left, bottom);
-             Coordinate ur = new Coordinate(right, top);
- //xulu.sc
- //            mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
-             setMapArea( fixAspectRatio(this.getBounds(), new Envelope(ll, ur)) );
- //xulu.ec
-         } else if (state == JMapPane.ZoomIn) {
-                 // Zu kleine Flächen sollen nicht gezoomt werden.
-                 //sk.bc
-                 if ( (Math.abs(x1-x2) * Math.abs(y2-y1) )<100 ) return;
-                 // sk.ec
-                 drawRectangle(this.getGraphics());
-             // make the dragged rectangle (in map coords) the new BBOX
-             double left = Math.min(startX, endX);
-             double right = Math.max(startX, endX);
-             double bottom = Math.min(startY, endY);
-             double top = Math.max(startY, endY);
-             Coordinate ll = new Coordinate(left, bottom);
-             Coordinate ur = new Coordinate(right, top);
- //xulu.sc
- //            mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
-             setMapArea( fixAspectRatio(this.getBounds(), new Envelope(ll, ur)) );
- //xulu.ec
-         } else if (state == JMapPane.ZoomOut) {
-                 drawRectangle(this.getGraphics());
-                 // make the dragged rectangle in screen coords the new map size?
-             double left = Math.min(startX, endX);
-             double right = Math.max(startX, endX);
-             double bottom = Math.min(startY, endY);
-             double top = Math.max(startY, endY);
-             double nWidth = (mapWidth * mapWidth) / (right - left);
-             double nHeight = (mapHeight * mapHeight) / (top - bottom);
-             double deltaX1 = left - mapArea.getMinX();
-             double nDeltaX1 = (deltaX1 * nWidth) / mapWidth;
-             double deltaY1 = bottom - mapArea.getMinY();
-             double nDeltaY1 = (deltaY1 * nHeight) / mapHeight;
-             Coordinate ll = new Coordinate(mapArea.getMinX() - nDeltaX1,
-                     mapArea.getMinY() - nDeltaY1);
-             double deltaX2 = mapArea.getMaxX() - right;
-             double nDeltaX2 = (deltaX2 * nWidth) / mapWidth;
-             double deltaY2 = mapArea.getMaxY() - top;
-             double nDeltaY2 = (deltaY2 * nHeight) / mapHeight;
-             Coordinate ur = new Coordinate(mapArea.getMaxX() + nDeltaX2,
-                     mapArea.getMaxY() + nDeltaY2);
- //xulu.sc
- //            mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
-             setMapArea( fixAspectRatio(this.getBounds(), new Envelope(ll, ur)) );
- //xulu.ec
-         } else if (state == JMapPane.Select && selectionLayer !=null) {
-             double left = Math.min(startX, endX);
-             double right = Math.max(startX, endX);
-             double bottom = Math.min(startY, endY);
-             double top = Math.max(startY, endY);
-             String name = selectionLayer.getFeatureSource().getSchema()
-                     .getDefaultGeometry().getLocalName();
-             if (name == "") {
-                 name = "the_geom";
-             }
-             Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,
-                     getContext().getCoordinateReferenceSystem().toString());
-             //System.out.println(bb.toString());
-             if(selectionManager!=null) {
-                 selectionManager.selectionChanged(this, bb);
-             }
-             /*FeatureCollection fc;
-             selection = null;
-             try {
-                 fc = selectionLayer.getFeatureSource().getFeatures(bb);
-                 selection = fc;
-             } catch (IOException e) {
-                 e.printStackTrace();
-             }
- */
-         }
- //xulu.so
- //        setMapArea(mapArea);
- //xulu.eo
-         repaint();
-     }
-     private boolean isClickable() {
-         return clickable;
-     }
-     private org.geotools.styling.Style setupStyle(int type, Color color) {
-         StyleFactory sf = org.geotools.factory.CommonFactoryFinder
-                 .getStyleFactory(null);
-         StyleBuilder sb = new StyleBuilder();
-         org.geotools.styling.Style s = sf.createStyle();
-         s.setTitle("selection");
-         // TODO parameterise the color
-         PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);
-         ps.setStroke(sb.createStroke(color));
-         LineSymbolizer ls = sb.createLineSymbolizer(color);
-         Graphic h = sb.createGraphic();
-         h.setMarks(new Mark[] { sb.createMark("square", color) });
-         PointSymbolizer pts = sb.createPointSymbolizer(h);
-         // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});
-         switch (type) {
-         case POLYGON:
-             s = sb.createStyle(ps);
-             break;
-         case POINT:
-             s = sb.createStyle(pts);
-             break;
-         case LINE:
-             s = sb.createStyle(ls);
-         }
-         return s;
-     }
-     public void highlightChanged(HighlightChangedEvent e) {
-         org.opengis.filter.Filter f = e.getFilter();
-         try {
-             highlightFeature = highlightLayer.getFeatureSource().getFeatures(f);
-         } catch (IOException e1) {
-             // TODO Auto-generated catch block
-             e1.printStackTrace();
-         }
-         repaint();
-     }
-     public void propertyChange(PropertyChangeEvent evt) {
-         String prop = evt.getPropertyName();
-         if (prop.equalsIgnoreCase("crs")) {
-             context.setAreaOfInterest(context.getAreaOfInterest(),
-                     (CoordinateReferenceSystem) evt.getNewValue());
-         }
-     }
-     public boolean isReset() {
-         return reset;
-     }
-     public void setReset(boolean reset) {
-         this.reset = reset;
-     }
-     public void layerAdded(MapLayerListEvent event) {
-         changed = true;
-         if (context.getLayers().length == 1) { // the first one
-             try {
- //xulu.sc
- //            mapArea = context.getLayerBounds();
-               mapArea = context.getAreaOfInterest();
-               if ( mapArea == null )
-                 mapArea = context.getLayerBounds();
- //xulu.ec
-             } catch (IOException e) {
-                 // TODO Auto-generated catch block
-                 e.printStackTrace();
-             }
-             reset = true;
-         }
-         repaint();
-     }
-     public void layerRemoved(MapLayerListEvent event) {
-         changed = true;
-         repaint();
-     }
-     public void layerChanged(MapLayerListEvent event) {
-         changed = true;
-         // System.out.println("layer changed - repaint");
-         repaint();
-     }
-     public void layerMoved(MapLayerListEvent event) {
-         changed = true;
-         repaint();
-     }
-     protected void drawRectangle(Graphics graphics) {
-         // undraw last box/draw new box
-         int left = Math.min(startX, lastX);
-         int right = Math.max(startX, lastX);
-         int top = Math.max(startY, lastY);
-         int bottom = Math.min(startY, lastY);
-         int width = right - left;
-         int height = top - bottom;
-         // System.out.println("drawing rect("+left+","+bottom+","+ width+","+
-         // height+")");
-         graphics.drawRect(left, bottom, width, height);
-     }
-     /**
-      * if clickable is set to true then a single click on the map pane will zoom
-      * or pan the map.
-      *
-      * @param clickable
-      */
-     public void setClickable(boolean clickable) {
-         this.clickable = clickable;
-     }
-     public void mouseMoved(MouseEvent e) {
-     }
-     public FeatureCollection getSelection() {
-         return selection;
-     }
-     public void setSelection(FeatureCollection selection) {
-         this.selection = selection;
-         repaint();
-     }
-     /* (non-Javadoc)
-      * @see org.geotools.gui.swing.event.SelectionChangeListener#selectionChanged(org.geotools.gui.swing.event.SelectionChangedEvent)
-      */
-     public void selectionChanged(SelectionChangedEvent e) {
-         try {
-             selection = selectionLayer.getFeatureSource().getFeatures(e.getFilter());
-             repaint();
-         } catch (IOException e1) {
-             e1.printStackTrace();
-         }
-     }
-     public SelectionManager getSelectionManager() {
-         return selectionManager;
-     }
-     public void setSelectionManager(SelectionManager selectionManager) {
-         this.selectionManager = selectionManager;
-         this.selectionManager.addSelectionChangeListener(this);
-     }
+         /**
+          * This not-repeating {@link Timer} is re-started whenever the component is
+          * resized. That means => only if the component is not resizing for
+          * {@link #DEFAULT_RESIZING_PAINT_DELAY} milliseconds, does the
+          * {@link XMapPane} react.
+          */
+         private final Timer resizeTimer;
+         /**
+          * Flag for no-tool.
+          */
+         public static final int NONE = -123;
+         //
+         // /**
+         // * Flag fuer Modus "Kartenausschnitt bewegen". Nicht fuer Window-Auswahl
+         // * moeglich!
+         // *
+         // * @see #setState(int)
+         // */
+         // public static final int PAN = 1;
+         //
+         // /**
+         // * Flag fuer Modus "Heran zoomen".
+         // *
+         // * @see #setState(int)
+         // * @see #setState(int)
+         // */
+         // public static final int ZOOM_IN = 2;
+         //
+         // /**
+         // * Flag fuer Modus "Heraus zoomen". Nicht fuer Window-Auswahl moeglich!
+         // *
+         // * @see #setState(int)
+         // */
+         // public static final int ZOOM_OUT = 3;
+         /**
+          * {@link Font} used to paint the wait messages into the map
+          *
+          * @see #addGadgets(Graphics2D, boolean)
+          */
+         final static Font waitFont = new Font("Arial", Font.BOLD, 28);
+         /**
+          * {@link Font} used to paint error messages into the map
+          *
+          * @see #addGadgets(Graphics2D, boolean)
+          */
+         final static Font errorFont = new Font("Arial", Font.BOLD, 13);
+         /**
+          * If last average last two renderings took more than that many ms, show the
+          * user a scaled preview
+          **/
+         private static final long PRESCALE_MINTIME = 230;
+         /**
+          * The wait message painted into the map while rendering is going on on
+          * another thread.
+          *
+          * @see #addGadgets(Graphics2D, boolean)
+          */
+         final String waitMsg = SwingUtil.R("WaitMess");
+         /**
+          * Konvertiert die Maus-Koordinaten (relativ zum <code>JMapPane</code>) in
+          * Karten-Koordinaten.
+          *
+          * @param e
+          *            Maus-Ereignis
+          */
+         public static DirectPosition2D getMapCoordinatesFromEvent(final MouseEvent e) {
+                 // aktuelle Geo-Position aus GeoMouseEvent ermitteln
+                 if (e != null && e instanceof MapMouseEvent)
+                         try {
+                                 return ((MapMouseEvent) e).getMapPosition();
+                         } catch (final Exception err) {
+                                 LOGGER
+                                                 .error(
+                                                                 "return ((GeoMouseEvent) e).getMapCoordinate(null).toPoint2D();",
+                                                                 err);
+                         }
+                 // aktuelle Geo-Position ueber Transformation des JMapPane berechnen
+                 if (e != null && e.getSource() instanceof XMapPane) {
+                         final XMapPane xMapPane = (XMapPane) e.getSource();
+                         if (!xMapPane.isWellDefined())
+                                 return null;
+                         final AffineTransform at = xMapPane.getScreenToWorld();
+                         if (at != null) {
+                                 Point2D transformed = at.transform(e.getPoint(), null);
+                                 return new DirectPosition2D(xMapPane.getMapContext()
+                                                 .getCoordinateReferenceSystem(), transformed.getX(),
+                                                 transformed.getY());
+                         }
+                         return null;
+                 }
+                 throw new IllegalArgumentException(
+                                 "MouseEvent has to be of instance MapMouseEvent or come from an XMapPane");
+         }
+         /**
+          * Listens to changes of the "background" {@link MapContext} and triggers
+          * repaints where needed.
+          */
+         private final MapLayerListListener bgContextListener = new MapLayerListListener() {
+                 @Override
+                 public void layerAdded(final MapLayerListEvent event) {
+                         final 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.
+          **/
+         private final Point imageOrigin = new Point(0, 0);
+         /**
+          * For every rendering thread started,
+          * {@link GTUtil#createGTRenderer(MapContext)} is called to create a new
+          * renderer. These Java2D rendering hints are passed to the
+          * {@link GTRenderer}. The java2dHints are the same for all renderers (bg
+          * and local).
+          */
+         private RenderingHints java2dHints;
+         protected LabelCache labelCache = new LabelCacheImpl();
+         /**
+          * Listens to changes of the "local" {@link MapContext} and triggers
+          * repaints where needed.
+          */
+         private final MapLayerListListener localContextListener = new MapLayerListListener() {
+                 @Override
+                 public void layerAdded(final MapLayerListEvent event) {
+                         event.getLayer().addMapLayerListener(localMapLayerListener);
+                         getLocalRenderer().setContext(getMapContext());
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerChanged(final MapLayerListEvent event) {
+                         // getLocalRenderer().setContext(getMapContext()); geht doch auch
+                         // ohne?!?!? wow...
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerMoved(final MapLayerListEvent event) {
+                         getLocalRenderer().setContext(getMapContext());
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerRemoved(final MapLayerListEvent event) {
+                         if (event.getLayer() != null)
+                                 event.getLayer().removeMapLayerListener(localMapLayerListener);
+                         getLocalRenderer().setContext(getMapContext());
+                         requestStartRendering();
+                 }
+         };
+         /**
+          * Listens to each layer in the local {@link MapContext} for changes and
+          * triggers repaints. We don't have to listen layerChanged, because that is
+          * already done in {@link #localContextListener}
+          */
+         protected MapLayerListener localMapLayerListener = new MapLayerAdapter() {
+                 // @Override
+                 // public void layerChanged(final MapLayerEvent event) {
+                 // // getLocalRenderer().setContext(getMapContext()); // betters for SLD
+                 // // // changes?!
+                 // // requestStartRendering();
+                 // }
+                 @Override
+                 public void layerHidden(final MapLayerEvent event) {
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerShown(final MapLayerEvent event) {
+                         requestStartRendering();
+                 }
+         };
+         final private GTRenderer localRenderer = GTUtil.createGTRenderer();
+         private final GTRenderer bgRenderer = GTUtil.createGTRenderer();
+         /**
+          * the area of the map to draw
+          */
+         protected Envelope mapArea = null;
+         /**
+          * A flag set it {@link #setMapArea(Envelope)} to indicated the
+          * {@link #paintComponent(Graphics)} method, that the image on-screen is
+          * associated with {@link #oldMapArea} and may hence be scaled for a quick
+          * preview.<br>
+          * The flag is reset
+          **/
+         private boolean mapAreaChanged = false;
+         /**
+          * This color is used as the default background color when painting a map.
+          */
+         private Color mapBackgroundColor = null;
+         /**
+          * A flag indicating that the shown image is invalid and needs to be
+          * re-rendered.
+          */
+         protected boolean mapImageInvalid = true;
+         /**
+          * Holds a flag for each layer, whether it is regarded or ignored on
+          * {@link #SELECT_TOP}, {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP}
+          * actions.
+          */
+         final protected HashMap<MapLayer, Boolean> mapLayerSelectable = new HashMap<MapLayer, Boolean>();
+         /**
+          * List of listeners of this {@link XMapPane}
+          */
+         protected Vector<JMapPaneListener> mapPaneListeners = new Vector<JMapPaneListener>();
+         /**
+          * If not <code>null</code>, the {@link XMapPane} will not allow to zoom/pan
+          * out of that area
+          **/
+         private Envelope maxExtend = null;
+         private Double maxZoomScale = Double.MIN_VALUE;
+         private Double minZoomScale = Double.MAX_VALUE;
+         /**
+          * We store the old mapArea for a moment to use it for the
+          * "quick scaled preview" in case of ZoomOut
+          **/
+         protected Envelope oldMapArea = null;
+         /**
+          * We store the old transform for a moment to use it for the
+          * "quick scaled preview" in case of ZoomIn
+          **/
+         protected AffineTransform oldScreenToWorld = null;
+         /**
+          * A flag indicating, that the image size has changed and the buffered
+          * images are not big enough any more
+          **/
+         protected boolean paneResized = true;
+         private BufferedImage preFinalImage;
+         // ** if 0, no quick preview will be shown **/
+         // private int quickPreviewHint = 0;
+         private Map<Object, Object> rendererHints = GTUtil
+                         .getDefaultGTRendererHints(getLocalRenderer());
+         /**
+          * If set to <code>true</code>, the {@link #startRenderThreadsTimer} will
+          * start rendering {@link Thread}s
+          **/
+         private volatile Boolean requestStartRendering = false;
+         /**
+          * Transformation zwischen Fenster-Koordinaten und Karten-Koordinaten
+          * (lat/lon)
+          */
+         protected AffineTransform screenToWorld = null;
+         /**
+          * The flag {@link #requestStartRendering} can be set to true by events.
+          * This {@link Timer} checks the flag regularly and starts one renderer
+          * thread.
+          */
+         final private Timer startRenderThreadsTimer;
+         //
+         // /**
+         // * The default state is ZOOM_IN, hence by default the
+         // * {@link #xMapPaneMouseListener} is also enabled.
+         // **/
+         // private int state = ZOOM_IN;
+         //
+         // /**
+         // * Manuell gesetzter statischer Cursor, unabhaengig von der aktuellen
+         // * MapPane-Funktion
+         // */
+         // protected Cursor staticCursor = null;
+         private AffineTransform worldToScreen;
+         // /**
+         // * This {@link MouseListener} is managing all zoom related tasks
+         // */
+         // private final ZoomXMapPaneMouseListener zoomMapPaneMouseListener = new
+         // ZoomXMapPaneMouseListener(
+         // this);
+         /**
+          * This {@link MouseListener} is managing all zoom related tasks
+          */
+         private final XMapPaneMouseListener xMapPaneMouseListener = new XMapPaneMouseListener(
+                         this);
+         /** Is set if a renderer has an error **/
+         protected ArrayList<Exception> renderingErrors = new ArrayList<Exception>();
+         /**
+          * If <code>true</code>, then rendering exceptions are rendererd into the
+          * map pane
+          **/
+         private boolean showExceptions = false;
+         public XMapPane() {
+                 this(null, null);
+         }
+         /**
+          * full constructor extending JPanel
+          *
+          * @param rendererHints
+          *            may be <code>null</code>. Otherwise a {@link Map<Object,
+          *            Object>} of {@link RenderingHints} to override the default
+          *            from {@link GTUtil#getDefaultGTRendererHints(GTRenderer)}
+          *
+          * @param localContext
+          *            The main {@link MapContext} to use. If <code>null</code>, an
+          *            empty {@link DefaultMapContext} will be created.
+          */
+         public XMapPane(final MapContext localContext_,
+                         final Map<Object, Object> rendererHints) {
+                 super(true);
+                 setRendererHints(rendererHints);
+                 setOpaque(true);
+                 if (localContext_ != null)
+                         setLocalContext(localContext_);
+                 /**
+                  * Adding the #zoomMapPaneMouseListener
+                  */
+                 this.addMouseListener(xMapPaneMouseListener);
+                 this.addMouseMotionListener(xMapPaneMouseListener);
+                 this.addMouseWheelListener(xMapPaneMouseListener);
+                 // By default the XMapPAne uses the ZOOM_IN tool.
+                 setTool(XMapPaneTool.ZOOM_IN);
+                 /*
+                  * We use a Timer object to avoid rendering delays and flickering when
+                  * the user is drag-resizing the parent container of this map pane.
+                  *
+                  * Using a ComponentListener doesn't work because, unlike a JFrame, the
+                  * pane receives a stream of events during drag-resizing.
+                  */
+                 resizeTimer = new Timer(DEFAULT_RESIZING_PAINT_DELAY,
+                                 new ActionListener() {
+                                         public void actionPerformed(final ActionEvent e) {
+                                                 if (!isWellDefined())
+                                                         return;
+                                                 // LOGGER.debug("resizeTimer performed");
+                                                 // final Rectangle bounds = getVisibleRect();
+                                                 //
+                                                 // System.out.println("\n\ntimer performs with bounds = "
+                                                 // + bounds);
+                                                 // final Envelope geoMapArea = tranformWindowToGeo(
+                                                 // bounds.x, bounds.y, bounds.x + bounds.width,
+                                                 // bounds.y + bounds.height);
+                                                 paneResized = true;
+                                                 if (!setMapArea(getMapArea())) {
+                                                         // It's important to request new rendering here.
+                                                         // setMapArea only returns true and only calls
+                                                         // requestStartRendering if the maparea has changed.
+                                                         // But if the component is resized, the maparea
+                                                         // doesn't have to change.
+                                                         requestStartRendering();
+                                                 }
+                                         }
+                                 });
+                 resizeTimer.setRepeats(false);
+                 this.addComponentListener(new ComponentAdapter() {
+                         private Rectangle oldVisibleRect;
+                         @Override
+                         public void componentResized(final ComponentEvent e) {
+                                 // Seems to be called twice with the same size..
+                                 if (oldVisibleRect != null
+                                                 && oldVisibleRect.equals(getVisibleRect())) {
+                                         // LOGGER.debug("skipping resize.");
+                                         return;
+                                 }
+                                 // LOGGER.debug("resized: " + getVisibleRect());
+                                 resizeTimer.restart();
+                                 oldVisibleRect = getVisibleRect();
+                         }
+                 });
+                 /*
+                  * Setting up the repaintTimer. Not started automatically.
+                  */
+                 repaintTimer = new Timer(REPEATING_REPAINT_DELAY, new ActionListener() {
+                         @Override
+                         public void actionPerformed(final ActionEvent e) {
+                                 if ((!localExecuter.isRunning())
+                                                 && (bgExecuter != null && !bgExecuter.isRunning())) {
+                                         repaintTimer.stop();
+                                 } else {
+                                         updateFinalImage();
+                                         XMapPane.this.repaint(100);
+                                 }
+                         }
+                 });
+                 repaintTimer.setInitialDelay(INITIAL_REPAINT_DELAY);
+                 repaintTimer.setRepeats(true);
+                 /*
+                  * Setting up the startRenderThreadsTimer. This Timer starts
+                  * automatically.
+                  */
+                 startRenderThreadsTimer = new Timer(100, new ActionListener() {
+                         @Override
+                         public void actionPerformed(final ActionEvent e) {
+                                 synchronized (requestStartRendering) {
+                                         if (requestStartRendering && isWellDefined()) {
+                                                 if (localExecuter.isRunning()) {
+                                                         localExecuter.cancelTask();
+                                                 } else {
+                                                         // Stupidly, but we have to recheck the
+                                                         setMapArea(getMapArea());
+                                                         requestStartRendering = false;
+                                                         startRendering();
+                                                 }
+                                         }
+                                 }
+                         }
+                 });
+                 startRenderThreadsTimer.start();
+         }
+         /**
+          * Fuegt der Map einen Listener hinzu.
+          *
+          * @param l
+          *            neuer Listener
+          */
+         public void addMapPaneListener(final JMapPaneListener l) {
+                 mapPaneListeners.add(l);
+         }
- //xulu.sn
          /**
           * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste
           * erlaubte Flaeche damit die Massstabsbeschaenkungen noch eingehalten
-          * werden, FALLS der uebergeben Envelope nicht schon gueltig sein sollte.<br/>
+          * werden, FALLS der uebergeben Envelope nicht schon gueltig sein sollte.<br>
           * Since 21. April 09: Before thecalculation starts, the aspect ratio is
           * corrected. This change implies, that setMapArea() will most of the time
           * not allow setting to a wrong aspectRatio.
-Line 1251 
 public class JMapPane extends JPanel imp
+Line 757 
 public class JMapPane extends JPanel imp
           * @author <a href="mailto:[email protected]">Stefan Alfons
           *         Kr&uuml;ger</a>
           */
-         public Envelope bestAllowedMapArea(Envelope env) {
+         public ReferencedEnvelope bestAllowedMapArea(ReferencedEnvelope env) {
                  if (getWidth() == 0)
                          return env;
                  if (env == null)
-                         return env;
+                         return null;
+                 Envelope newArea = null;
                  /**
-                  * Correct the aspect Ratio before we check the rest. Otherwise we might easily fail.
+                  * Correct the aspect Ratio before we check the rest. Otherwise we might
+                  * easily fail. We allow to grow here, because we don't check against
+                  * the maxExtend
                   */
-                 env = fixAspectRatio(this.getBounds(), env);
+                 final Rectangle curPaintArea = getVisibleRect();
-                 double scale = env.getWidth() / getWidth();
+                 env = JTSUtil.fixAspectRatio(curPaintArea, env, true);
-                 double centerX = env.getMinX() + env.getWidth() / 2.;
-                 double centerY = env.getMinY() + env.getHeight() / 2.;
+                 final double scale = env.getWidth() / getWidth();
-                 double newWidth2;
+                 final double centerX = env.getMinX() + env.getWidth() / 2.;
-                 double newHeight2;
+                 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
-Line 1283 
 public class JMapPane extends JPanel imp
+Line 797 
 public class JMapPane extends JPanel imp
                          // ****************************************************************************
                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
                          // ****************************************************************************
-                         return env;
+                         newArea = env;
+                 }
+                 if (newArea == null) {
+                         final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
+                                         - newHeight2);
+                         final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
+                                         + newHeight2);
+                         newArea = new Envelope(ll, ur);
+                 }
+                 final Envelope maxAllowedExtend = getMaxExtend();
+                 while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea)
+                                 && newArea != null && !newArea.isNull()
+                                 && !Double.isNaN(newArea.getMinX())
+                                 && !Double.isNaN(newArea.getMaxX())
+                                 && !Double.isNaN(newArea.getMinY())
+                                 && !Double.isNaN(newArea.getMaxY())) {
+                         /*
+                          * If a maxExtend is set, we have to honour that...
+                          */
+                         // Exceeds top? Move down and maybe cut
+                         if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
+                                 final double divY = newArea.getMaxY()
+                                                 - maxAllowedExtend.getMaxY();
+                                 // LOGGER.debug("Moving area down by " + divY);
+                                 newArea = new Envelope(new Coordinate(newArea.getMinX(),
+                                                 newArea.getMinY() - divY), new Coordinate(newArea
+                                                 .getMaxX(), newArea.getMaxY() - divY));
+                                 if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
+                                         // LOGGER.debug("Now it exeeds the bottom border.. cut!");
+                                         // And cut the bottom if it moved out of the area
+                                         newArea = new Envelope(new Coordinate(newArea.getMinX(),
+                                                         maxAllowedExtend.getMinY()), new Coordinate(newArea
+                                                         .getMaxX(), newArea.getMaxY()));
+                                         // LOGGER.debug("and fix aspect ratio");
+                                         newArea = JTSUtil.fixAspectRatio(getVisibleRect(),
+                                                         new ReferencedEnvelope(newArea, env
+                                                                         .getCoordinateReferenceSystem()), false);
+                                 }
+                         }
+                         // Exceeds bottom? Move up and maybe cut
+                         if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
+                                 final double divY = newArea.getMinY()
+                                                 - maxAllowedExtend.getMinY();
+                                 // LOGGER.debug("Moving area up by " + divY);
+                                 newArea = new Envelope(new Coordinate(newArea.getMinX(),
+                                                 newArea.getMinY() - divY), new Coordinate(newArea
+                                                 .getMaxX(), newArea.getMaxY() - divY));
+                                 if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
+                                         // LOGGER.debug("Now it exeeds the top border.. cut!");
+                                         // And cut the bottom if it moved out of the area
+                                         newArea = new Envelope(new Coordinate(newArea.getMinX(),
+                                                         newArea.getMinY()), new Coordinate(newArea
+                                                         .getMaxX(), maxAllowedExtend.getMaxY()));
+                                         // LOGGER.debug("and fix aspect ratio");
+                                         newArea = JTSUtil.fixAspectRatio(getVisibleRect(),
+                                                         new ReferencedEnvelope(newArea, env
+                                                                         .getCoordinateReferenceSystem()), false);
+                                 }
+                         }
+                         // Exceeds to the right? move and maybe cut
+                         if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
+                                 // Move left..
+                                 final double divX = newArea.getMaxX()
+                                                 - maxAllowedExtend.getMaxX();
+                                 // LOGGER.debug("Moving area left by " + divX);
+                                 newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
+                                                 newArea.getMinY()), new Coordinate(newArea.getMaxX()
+                                                 - divX, newArea.getMaxY()));
+                                 if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
+                                         // LOGGER.debug("Now it exeeds the left border.. cut!");
+                                         // And cut the left if it moved out of the area
+                                         newArea = new Envelope(new Coordinate(maxAllowedExtend
+                                                         .getMinX(), newArea.getMinY()), new Coordinate(
+                                                         newArea.getMaxX(), newArea.getMaxY()));
+                                         // LOGGER.debug("and fix aspect ratio");
+                                         newArea = JTSUtil.fixAspectRatio(getVisibleRect(),
+                                                         new ReferencedEnvelope(newArea, env
+                                                                         .getCoordinateReferenceSystem()), false);
+                                 }
+                         }
+                         // Exceeds to the left? move and maybe cut
+                         if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
+                                 // Move right..
+                                 final double divX = newArea.getMinX()
+                                                 - maxAllowedExtend.getMinX();
+                                 // LOGGER.debug("Moving area right by " + divX);
+                                 newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
+                                                 newArea.getMinY()), new Coordinate(newArea.getMaxX()
+                                                 - divX, newArea.getMaxY()));
+                                 if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
+                                         // LOGGER.debug("Now it exeeds the right border.. cut!");
+                                         // And cut the left if it moved out of the area
+                                         newArea = new Envelope(new Coordinate(newArea.getMinX(),
+                                                         newArea.getMinY()), new Coordinate(maxAllowedExtend
+                                                         .getMaxX(), newArea.getMaxY()));
+                                         // LOGGER.debug("and fix aspect ratio");
+                                         newArea = JTSUtil.fixAspectRatio(getVisibleRect(),
+                                                         new ReferencedEnvelope(newArea, env
+                                                                         .getCoordinateReferenceSystem()), false);
+                                 }
+                         }
+                 }
+                 return new ReferencedEnvelope(newArea, env
+                                 .getCoordinateReferenceSystem());
+         }
+         /**
+          * Should be called when the {@link JMapPane} is not needed no more to help
+          * the GarbageCollector
+          *
+          * Removes all {@link JMapPaneListener}s that are registered
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public void dispose() {
+                 if (isDisposed())
+                         return;
+                 setPainting(false);
+                 resizeTimer.stop();
+                 startRenderThreadsTimer.stop();
+                 disposed = true;
+                 if (bgExecuter != null) {
+                         bgExecuter.cancelTask();
+                         bgExecuter.dispose();
+                 }
+                 if (localExecuter.isRunning()) {
+                         int i = 0;
+                         localExecuter.cancelTask();
+                         while (i++ < 10 && localExecuter.isRunning()) {
+                                 try {
+                                         Thread.sleep(200);
+                                 } catch (final InterruptedException e) {
+                                         LOGGER
+                                                         .warn(
+                                                                         "while XMapPane we are waiting for the localExcutor to stop",
+                                                                         e);
+                                 }
+                         }
+                         if (localExecuter.isRunning()) {
+                                 LOGGER
+                                                 .warn("localExecutor Thread still running after 2s! Continuing anyways...");
+                         }
+                         localExecuter.dispose();
+                 }
+                 disposeImages();
+                 // Remove all mapPaneListeners that have registered with us
+                 mapPaneListeners.clear();
+                 removeMouseMotionListener(xMapPaneMouseListener);
+                 removeMouseListener(xMapPaneMouseListener);
+                 if (localContext != null)
+                         getMapContext().clearLayerList();
+                 if (bgContext != null)
+                         getBgContext().clearLayerList();
+                 removeAll();
+         }
+         /**
+          * Draws a rectangle in XOR mode from the origin at {@link #startPos} to the
+          * given point. All in screen coordinates.
+          */
+         protected void drawRectangle(final Graphics graphics, final Point startPos,
+                         final Point e) {
+                 drawRectangle(graphics, startPos, e, Color.WHITE, false);
+         }
+         /**
+          * Draws a rectangle in XOR mode from the origin at {@link #startPos} to the
+          * given point. All in screen coordinates.
+          */
+         protected void drawRectangle(final Graphics graphics, final Point startPos,
+                         final Point e, Color color, boolean fill) {
+                 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);
+                 if (fill) {
+                         graphics.fillRect(left, bottom, width, height);
+                         graphics.setXORMode(Color.WHITE);
+                 }
+                 graphics.drawRect(left, bottom, width, height);
+         }
+         /**
+          * Diretly paints scaled preview into the {@link SelectableXMapPane}. Used
+          * to give the user something to look at while we are rendering. Method
+          * should be called after {@link #setMapArea(Envelope)} has been set to the
+          * new mapArea and transform has been reset.<br>
+          *
+          * @param g
+          *            Graphics2D to paint the preview into
+          */
+         protected boolean drawScaledPreviewImage_Zoom(final Graphics2D graphics) {
+                 // if (1 == 1)return false;
+                 // if (quickPreviewHint == 0)
+                 // return false;
+                 if (oldMapArea == null)
+                         return false;
+                 if (getPreFinalImage() == null)
+                         return false;
+                 final Rectangle visibleArea = getVisibleRect();
+                 // Calculate the oldMapArea in the current WindowCoordinates:
+                 final Envelope oldMapWindow = tranformGeoToWindow(oldMapArea.getMinX(),
+                                 oldMapArea.getMinY(), oldMapArea.getMaxX(), oldMapArea
+                                                 .getMaxY());
+                 final int xx1 = (int) Math.round(oldMapWindow.getMinX());
+                 final int yy1 = (int) Math.round(oldMapWindow.getMinY());
+                 final int xx2 = (int) Math.round(oldMapWindow.getMaxX());
+                 final int yy2 = (int) Math.round(oldMapWindow.getMaxY());
+                 graphics.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);
+                 graphics.drawImage(getPreFinalImage(), xx1, yy1, xx2, yy2,
+                                 (int) visibleArea.getMinX(), (int) visibleArea.getMinY(),
+                                 (int) visibleArea.getMaxX(), (int) visibleArea.getMaxY(),
+                                 getMapBackgroundColor(), null);
+                 final Rectangle painedArea = new Rectangle(xx1, yy1, xx2 - xx1, yy2
+                                 - yy1);
+                 SwingUtil.clearAround(graphics, painedArea, visibleArea,
+                                 getMapBackgroundColor());
+                 addGadgets(graphics, true);
+                 // quickPreviewHint = 0;
+                 repaintTimer.restart();
+                 // Something has been drawn
+                 return true;
+         }
+         public MapContext getBgContext() {
+                 return bgContext;
+         }
+         /**
+          * Lazyly initializes a {@link BufferedImage} for the background renderer.
+          */
+         private Image getBgImage() {
+                 if (bgImage == null) {
+                         bgImage = new BufferedImage(getVisibleRect().width,
+                                         getVisibleRect().height, IMAGETYPE);
+                         SwingUtil.clearImage(finalImage, getMapBackgroundColor());
+                 }
+                 return bgImage;
+         }
+         public MapContext getMapContext() {
+                 if (localContext == null) {
+                         setLocalContext(new DefaultMapContext());
+                 }
+                 return localContext;
+         }
+         private BufferedImage getFinalImage() {
+                 //
+                 if (finalImage == null) {
+                         // Rectangle curPaintArea = getVisibleRect();
+                         finalImage = new BufferedImage(getVisibleRect().width,
+                                         getVisibleRect().height, IMAGETYPE);
+                         SwingUtil.clearImage(finalImage, getMapBackgroundColor());
+                         // requestStartRendering();
+                 }
+                 return finalImage;
+         }
+         /**
+          * Lazyly initializes a {@link BufferedImage} for the background renderer.
+          */
+         private BufferedImage getLocalImage() {
+                 if (localImage == null) {
+                         localImage = new BufferedImage(getVisibleRect().width,
+                                         getVisibleRect().height, IMAGETYPE_withAlpha);
+                         SwingUtil.clearImage(localImage, getMapBackgroundColor());
+                 }
+                 return localImage;
+         }
+         /**
+          * Returns a copy of the mapArea
+          *
+          * @return
+          */
+         public ReferencedEnvelope getMapArea() {
+                 if (mapArea == null) {
+                         ReferencedEnvelope mapArea_ = null;
+                         try {
+                                 mapArea_ = localContext.getLayerBounds();
+                         } catch (final Exception e) {
+                                 LOGGER.warn("localContext.getLayerBounds()", e);
+                         }
+                         if (mapArea_ == null && bgContext != null) {
+                                 try {
+                                         mapArea_ = bgContext.getLayerBounds();
+                                 } catch (final IOException e) {
+                                         LOGGER.warn("bgContext.getLayerBounds()", e);
+                                 }
+                         }
+                         if (mapArea_ != null) {
+                                 mapArea = bestAllowedMapArea(mapArea_);
+                                 requestStartRendering();
+                         }
+                 }
+                 if (mapArea == null)
+                         return null;
+                 // TODO is needed at all, this should go to setMapArea maybe
+                 if (localContext.getCoordinateReferenceSystem() == null)
+                         try {
+                                 localContext.setCoordinateReferenceSystem(GeoImportUtil
+                                                 .getDefaultCRS());
+                         } catch (final Exception e) {
+                                 throw new RuntimeException("setting context CRS:", e);
+                         }
+                 return new ReferencedEnvelope(mapArea, localContext
+                                 .getCoordinateReferenceSystem());
+         }
+         /**
+          * Returns the background {@link Color} of the map pane. If not set, the
+          * methods looks for a parent component and will use its background color.
+          * If no parent component is available, WHITE is returned.
+          **/
+         public Color getMapBackgroundColor() {
+                 if (mapBackgroundColor == null) {
+                         if (getParent() != null)
+                                 return getParent().getBackground();
+                         else
+                                 return Color.WHITE;
+                 }
+                 return mapBackgroundColor;
+         }
+         /**
+          * Get the BufferedImage to use as a flaoting icon in the lower right
+          * corner.
+          *
+          * @return <code>null</code> if the feature is deactivated.
+          */
+         public BufferedImage getMapImage() {
+                 return mapImage;
+         }
+         /**
+          * Returns the evelope of the viewable area. The JMapPane will never show
+          * anything outside of this extend. If this has been set to
+          * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
+          * quickly the context's bounds. It it takes to long to determine the
+          * context bounds, <code>null</code> is returned.
+          *
+          * @param maxExtend
+          *            <code>null</code> to not have this restriction.
+          */
+         public Envelope getMaxExtend() {
+                 if (maxExtend == null) {
+                         // The next command may take long time!
+                         // long start = System.currentTimeMillis();
+                         final ReferencedEnvelope layerBounds = GTUtil
+                                         .getVisibleLayoutBounds(localContext);
+                         //
+                         // LOGGER.info(
+                         // (System.currentTimeMillis()-start)+"m to get maxExtend");
+                         //
+                         if (layerBounds == null) {
+                                 // // TODO Last fallback could be the CRS valid area
+                                 return null;
+                         }
+                         return JTSUtil
+                                         .fixAspectRatio(getVisibleRect(), addDefaultMargin(layerBounds), true);
                  }
+                 return maxExtend;
+         }
-                 Coordinate ll = new Coordinate(centerX - newWidth2, centerY
+         /**
-                                 - newHeight2);
+          * Retuns the maximum allowed zoom scale. This is the smaller number value
-                 Coordinate ur = new Coordinate(centerX + newWidth2, centerY
+          * of the two. Defaults to {@link Double}.MIN_VALUE
-                                 + newHeight2);
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
-                 return new Envelope(ll, ur);
+          *         Kr&uuml;ger</a>
-         }
+          */
+         public Double getMaxZoomScale() {
-   /**
+                 return maxZoomScale;
-    * Retuns the minimum allowed zoom scale. This is the bigger number value of the two.
+         }
-    * Defaults to {@link Double}.MAX_VALUE
-    *
-    * @author <a href="mailto:[email protected]">Stefan Alfons Kr&uuml;ger</a>
-    */
-   public Double getMinZoomScale() {
-     return minZoomScale;
-   }
-   /**
-    * Retuns the maximum allowed zoom scale. This is the smaller number value of the two.
-    * Defaults to {@link Double}.MIN_VALUE
-    *
-    * @author <a href="mailto:[email protected]">Stefan Alfons Kr&uuml;ger</a>
-    */
-   public Double getMaxZoomScale() {
-     return maxZoomScale;
-   }
-   /**
-    * Set the maximum allowed zoom scale. This is the smaller number value of the two.
-    *
-    * @author <a href="mailto:[email protected]">Stefan Alfons Kr&uuml;ger</a>
-    */
-   public void setMaxZoomScale(Double maxZoomScale) {
-     // System.out.println("setting max scale to "+maxZoomScale);
-     this.maxZoomScale = maxZoomScale;
-   }
-   /**
-    * Set the minimum (nearest) allowed zoom scale. This is the bigger number value of the two.
-    *
-    * @author <a href="mailto:[email protected]">Stefan Alfons Kr&uuml;ger</a>
-    */
-   public void setMinZoomScale(Double minZoomScale) {
-     this.minZoomScale = minZoomScale;
-   }
- //xulu.en
+         /**
+          * Retuns the minimum allowed zoom scale. This is the bigger number value of
+          * the two. Defaults to {@link Double}.MAX_VALUE
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public Double getMinZoomScale() {
+                 return minZoomScale;
+         }
+         private Image getPreFinalImage() {
+                 return preFinalImage;
+         }
+         public Map<Object, Object> getRendererHints() {
+                 // Clear label cache
+                 labelCache.clear();
+                 rendererHints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);
+                 return rendererHints;
+         }
+         /**
+          * Liefert eine affine Transformation, um von den Fenster-Koordinaten in die
+          * Karten-Koordinaten (Lat/Lon) umzurechnen.
+          *
+          * @return eine Kopie der aktuellen Transformation; <code>null</code> wenn
+          *         noch keine Karte angezeigt wird
+          */
+         public AffineTransform getScreenToWorld() {
+                 if (screenToWorld == null)
+                         resetTransforms();
+                 // nur Kopie der Transformation zurueckgeben!
+                 if (screenToWorld == null)
+                         return null;
+                 return new AffineTransform(screenToWorld);
+         }
+         // public int getState() {
+         // return state;
+         // }
+         //
+         // /**
+         // * Liefert den statisch eingestellten Cursor, der unabhaengig von der
+         // * eingestellten MapPane-Aktion (Zoom, Auswahl, ...) verwendet wird.
+         // *
+         // * @return {@code null}, wenn kein statischer Cursor verwendet, sondern
+         // der
+         // * Cursor automatisch je nach MapPane-Aktion eingestellt wird.
+         // */
+         // public Cursor getStaticCursor() {
+         // return this.staticCursor;
+         // }
+         public AffineTransform getWorldToScreenTransform() {
+                 if (worldToScreen == null) {
+                         resetTransforms();
+                 }
+                 // nur Kopie der Transformation zurueckgeben!
+                 return new AffineTransform(worldToScreen);
+         }
+         /**
+          * A flag indicating if dispose() has already been called. If true, then
+          * further use of this {@link SelectableXMapPane} is undefined.
+          */
+         private boolean isDisposed() {
+                 return disposed;
+         }
+         /**
+          * Returns whether a layer is regarded or ignored on {@link #SELECT_TOP},
+          * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions. Returns
+          * <code>true</code> if the selectability has not been defined.
+          *
+          * @param layer
+          *            a layer
+          */
+         public boolean isMapLayerSelectable(final MapLayer layer) {
+                 final Boolean selectable = mapLayerSelectable.get(layer);
+                 return selectable == null ? true : selectable;
+         }
+         /**
+          * Return <code>true</code> if a CRS and a {@link #mapArea} are set and the
+          * {@link XMapPane} is visible and has bounds set.
+          */
+         public boolean isWellDefined() {
+                 try {
+                         if (getMapContext() == null)
+                                 return false;
+                         if (getMapContext().getLayerCount() <= 0)
+                                 return false;
+                         if (getVisibleRect().getWidth() == 0)
+                                 return false;
+                         if (getVisibleRect().getHeight() == 0)
+                                 return false;
+                         // if (getMapArea() == null)
+                         // return false;
+                 } catch (final Exception e) {
+                         return false;
+                 }
+                 return true;
+         }
+         /**
+          * Usually called from {@link XMapPaneAction_Pan} to pan the image.
+          *
+          * @param startPos
+          *            in screen coordinates
+          * @param lastPos
+          *            in screen coordinates
+          */
+         public void pan(final int dX, final int dY) {
+                 // Panning needs a panning coursor
+                 if (getCursor() != SwingUtil.PANNING_CURSOR) {
+                         setCursor(SwingUtil.PANNING_CURSOR);
+                         // While panning, we deactivate the rendering. So the tasks are
+                         // ready to start when the panning is finished.
+                         if (bgExecuter != null && bgExecuter.isRunning())
+                                 bgExecuter.cancelTask();
+                         if (localExecuter.isRunning())
+                                 localExecuter.cancelTask();
+                 }
+                 //
+                 // if (lastPos.x > 0 && lastPos.y > 0) {
+                 // final int dx = event.getX() - lastPos.x;
+                 // final int dy = event.getY() - lastPos.y;
+                 // TODO Stop dragging when the drag would not be valid...
+                 // boolean dragValid = true;
+                 // // check if this panning results in a valid mapArea
+                 // {
+                 // Rectangle winBounds = xMapPane.getBounds();
+                 // winBounds.translate(xMapPane.imageOrigin.x,
+                 // -xMapPane.imageOrigin.y);
+                 // Envelope newMapAreaBefore = xMapPane.tranformWindowToGeo(
+                 // winBounds.x, winBounds.y, winBounds.x
+                 // + winBounds.width, winBounds.y
+                 // + winBounds.height);
+                 //
+                 //
+                 // winBounds = xMapPane.getBounds();
+                 // Point testIng = new Point(xMapPane.imageOrigin);
+                 // testIng.translate(dx, dy);
+                 // winBounds.translate(testIng.x, -testIng.y);
+                 // Envelope newMapAreaAfter = xMapPane.tranformWindowToGeo(
+                 // winBounds.x, winBounds.y, winBounds.x
+                 // + winBounds.width, winBounds.y
+                 // + winBounds.height);
+                 //
+                 // // If the last drag doesn't change the MapArea anymore cancel
+                 // it.
+                 // if (xMapPane.bestAllowedMapArea(newMapAreaAfter).equals(
+                 // xMapPane.bestAllowedMapArea(newMapAreaBefore))){
+                 // dragValid = false;
+                 // return;
+                 // }
+                 // }
+                 getImageOrigin().translate(dX, dY);
+                 updateFinalImage();
+                 repaint();
+                 // }
+                 // } else if ((getState() == XMapPane.ZOOM_IN)
+                 // || (getState() == XMapPane.ZOOM_OUT)
+                 // || (getState() == XMapPane.SELECT_ALL)
+                 // || (getState() == XMapPane.SELECT_TOP)) {
+                 //
+                 // // Draws a rectangle
+                 // final Graphics2D graphics = (Graphics2D) getGraphics();
+                 // drawRectangle(graphics, startPos, event.getPoint());
+                 // if ((lastPos.x > 0) && (lastPos.y > 0))
+                 // drawRectangle(graphics, startPos, lastPos);
+                 // graphics.dispose();
+                 // }
+         }
+         /**
+          * Called by the {@link RenderingExecutor} when rendering was cancelled.
+          */
+         public void onRenderingCancelled() {
+                 // LOGGER.debug("Rendering cancelled");
+                 repaintTimer.stop();
+         }
+         /**
+          * Called by the {@link RenderingExecutor} when rendering has been
+          * completed.
+          *
+          * @param l
+          *            long ms the rendering took
+          */
+         public void onRenderingCompleted(final long l) {
+                 lastRenderingDuration = (lastRenderingDuration + l) / 2;
+                 // LOGGER
+                 // .debug("complete rendering after " + lastRenderingDuration
+                 // + "ms");
+                 repaintTimer.stop();
+                 // We "forget" about an exception every time we complete a rendering
+                 // thread successfully
+                 if (renderingErrors.size() > 0)
+                         renderingErrors.remove(0);
+                 updateFinalImage();
+                 repaint();
+         }
+         /**
+          * Called by the {@linkplain XMapPane.RenderingTask} when rendering failed.
+          * Publishes a {@linkplain MapPaneEvent} of type {@code
+          * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
+          *
+          * @param renderingError
+          *            The error that occured during rendering
+          *
+          * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
+          */
+         public void onRenderingFailed(final Exception renderingError) {
+                 // Store the exceptions so we can show it to the user:
+                 if (!(renderingError instanceof java.lang.IllegalArgumentException && renderingError
+                                 .getMessage().equals(
+                                                 "Argument \"sourceCRS\" should not be null.")))
+                         this.renderingErrors.add(renderingError);
+                 if (renderingErrors.size() > 3)
+                         renderingErrors.remove(0);
+                 repaintTimer.stop();
+                 LOGGER.warn("Rendering failed", renderingError);
+                 updateFinalImage();
+                 repaint();
+         }
+         @Override
+         protected void paintComponent(final Graphics g) {
+                 // Maybe update the cursor and maybe stop the repainting timer
+                 updateCursor();
+                 if (!acceptsRepaintCalls)
+                         return;
+                 if (!isWellDefined())
+                         return;
+                 //
+                 // if (paneResized) {
+                 // // ((Graphics2D) g).setBackground(getMapBackgroundColor());
+                 // // g.clearRect(0, 0, getVisibleRect().width,
+                 // getVisibleRect().height);
+                 // return;
+                 // }
+                 // super.paintComponent(g); // candidate for removal
+                 boolean paintedSomething = false;
+                 if (mapImageInvalid) { /* if the map changed then redraw */
+                         mapImageInvalid = false; // Reset for next round
+                         // If the new mapArea and the oldMapArea intersect, we can draw some
+                         // quick scaled preview to make the user feel that something is
+                         // happening.
+                         if (lastRenderingDuration > PRESCALE_MINTIME && mapAreaChanged
+                                         && oldMapArea != null
+                                         && getMapArea().intersects(oldMapArea)
+                                         && !getMapArea().equals(oldMapArea) && !paneResized) {
+                                 mapAreaChanged = false;
+                                 // if (getMapArea().covers(oldMapArea)) {
+                                 // // quickPreviewHint = ZOOM_OUT;
+                                 // paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D)
+                                 // g);
+                                 // } else if (oldMapArea.covers(getMapArea())) {
+                                 // quickPreviewHint = ZOOM_IN;
+                                 paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
+                                 // }
+                         }
+                 }
+                 if (!paintedSomething) {
+                         g.drawImage(getFinalImage(), 0, 0, null);
+                         paintedSomething = true; // cand. for removal
+                 }
+         }
+         /**
+          * Heavily works on releasing all resources related to the four
+          * {@link Image}s used to cache the results of the different renderers.<br>
+          * In November 2009 i had some memory leaking problems with {@link XMapPane}
+          * . The resources of the buffered images were never released. It seem to be
+          * important to call the GC right after flushing the images.<br>
+          * Hence this method may take a while, because it calls the GC up to four
+          * times.
+          */
+         private void disposeImages() {
+                 // System.out.println("vorher = "
+                 // + new MbDecimalFormatter().format(LangUtil.gcTotal()));
+                 // bi.flush();
+                 // return bi = null;
+                 // System.out.println("nacher = "
+                 // + new MbDecimalFormatter().format(LangUtil.gcTotal()));
+                 //
+                 // System.out.println("\n");
+                 if (preFinalImage != null) {
+                         preFinalImage.flush();
+                         preFinalImage = null;
+                         LangUtil.gc();
+                 }
+                 if (finalImage != null) {
+                         finalImage.flush();
+                         finalImage = null;
+                         LangUtil.gc();
+                 }
+                 if (localImage != null) {
+                         localImage.flush();
+                         localImage = null;
+                         LangUtil.gc();
+                 }
+                 if (bgImage != null) {
+                         bgImage.flush();
+                         bgImage = null;
+                         LangUtil.gc();
+                 }
+         }
+         //
+         // /**
+         // * Performs a {@value #PAN} action. During panning, the displacement is
+         // * stored in {@link #imageOrigin} object. Calling {@link #performPan()}
+         // will
+         // * reset the offset and call {@link #setMapArea(Envelope)}.
+         // */
+         // public void performPan() {
+         //
+         // final Rectangle winBounds = getVisibleRect();
+         //
+         // winBounds.translate(-imageOrigin.x, -imageOrigin.y);
+         // final Envelope newMapArea = tranformWindowToGeo(winBounds.x,
+         // winBounds.y, winBounds.x + winBounds.width, winBounds.y
+         // + winBounds.height);
+         //
+         // imageOrigin.x = 0;
+         // imageOrigin.y = 0;
+         //
+         // if (!setMapArea(newMapArea)) {
+         // /**
+         // * If setMapArea returns true, the finalImage is updated anyways.
+         // * This if-case exists to ensure that we repaint a correct image
+         // * even if the new panning area has been denied.
+         // */
+         // updateFinalImage();
+         // repaint();
+         // }
+         //
+         // if (getCursor() == SwingUtil.PANNING_CURSOR)
+         // setCursor(SwingUtil.PAN_CURSOR);
+         // }
+         /**
+          * Entfernt einen Listener von der Map.
+          *
+          * @param l
+          *            zu entfernender Listener
+          */
+         public void removeMapPaneListener(final JMapPaneListener l) {
+                 mapPaneListeners.remove(l);
+         }
+         /**
+          * Cancels all running renderers and sets the flag to start new ones. <br>
+          *
+          * @see #startRenderThreadsTimer
+          */
+         private void requestStartRendering() {
+                 if (bgExecuter != null)
+                         bgExecuter.cancelTask();
+                 localExecuter.cancelTask();
+                 mapImageInvalid = true;
+                 if (paneResized) {
+                         paneResized = false;
+                         disposeImages();
+                 }
+                 requestStartRendering = true;
+         }
+         /**
+          * Calculate the affine transforms used to convert between world and pixel
+          * coordinates. The calculations here are very basic and assume a cartesian
+          * reference system.
+          * <p>
+          * Tne transform is calculated such that {@code envelope} will be centred in
+          * the display
+          *
+          * @param envelope
+          *            the current map extent (world coordinates)
+          * @param paintArea
+          *            the current map pane extent (screen units)
+          */
+         private void resetTransforms() {
+                 // System.out
+                 // .println("paintArea in resetTeansofrms = " + getVisibleRect());
+                 if (!isWellDefined())
+                         return;
+                 if (mapArea == null)
+                         return;
+                 final ReferencedEnvelope refMapEnv = new ReferencedEnvelope(mapArea,
+                                 getMapContext().getCoordinateReferenceSystem());
+                 worldToScreen = RendererUtilities.worldToScreenTransform(refMapEnv,
+                                 getVisibleRect());
+                 try {
+                         screenToWorld = worldToScreen.createInverse();
+                 } catch (final NoninvertibleTransformException ex) {
+                         LOGGER
+                                         .error("can't invert worldToScreen to get screenToWorld!",
+                                                         ex);
+                 }
+         }
+         public void setBgContext(final MapContext context) {
+                 // Remove the default listener from the old context
+                 if (this.bgContext != null) {
+                         this.bgContext.removeMapLayerListListener(bgContextListener);
+                         // adding listener to all layers
+                         for (final MapLayer mapLayer : bgContext.getLayers()) {
+                                 mapLayer.removeMapLayerListener(bgMapLayerListener);
+                         }
+                 }
+                 this.bgContext = context;
+                 if (context != null) {
+                         // setMapArea(bgContext.getAreaOfInterest());
+                         this.bgContext.addMapLayerListListener(bgContextListener);
+                         // adding listener to all layers
+                         for (final MapLayer mapLayer : bgContext.getLayers()) {
+                                 mapLayer.addMapLayerListener(bgMapLayerListener);
+                         }
+                 }
+                 requestStartRendering();
+         }
+         public void setJava2dHints(final RenderingHints java2dHints) {
+                 this.java2dHints = java2dHints;
+         }
+         public void setLocalContext(final MapContext context) {
+                 // Remove the default listener from the old context
+                 if (this.localContext != null) {
+                         this.localContext.removeMapLayerListListener(localContextListener);
+                         // adding listener to all layers
+                         for (final MapLayer mapLayer : localContext.getLayers()) {
+                                 mapLayer.removeMapLayerListener(localMapLayerListener);
+                         }
+                 }
+                 this.localContext = context;
+                 if (context != null) {
+                         // setMapArea(localContext.getAreaOfInterest());
+                         getLocalRenderer().setContext(localContext);
+                         this.localContext.addMapLayerListListener(localContextListener);
+                         // adding listener to all layers
+                         for (final MapLayer mapLayer : localContext.getLayers()) {
+                                 mapLayer.addMapLayerListener(localMapLayerListener);
+                         }
+                 }
+                 requestStartRendering();
+         }
+         public void setBorder(final Border b) {
+                 super.setBorder(b);
+         }
+         /**
+          * Triggers to repaint (fast) and re-render (slow) the JMapPane.
+          */
+         public void refresh() {
+                 mapImageInvalid = true;
+                 repaint();
+         }
+         // /**
+         // * Triggers to use new {@link GTRenderer} and refresh the map. Should be
+         // * called after {@link Style}s have been changed because GTRenderer is
+         // * otherwise not working well.
+         // */
+         // public void refreshRenderers() {
+         // localRenderer = GTUtil.createGTRenderer();
+         // setLocalContext(getMapContext());
+         // mapImageInvalid = true;
+         // repaint();
+         // }
+         /**
+          * Set the new map area.
+          *
+          * @param newMapArea
+          * @return <code>true</code> if the mapArea has been changed and a repaint
+          *         has been triggered.
+          */
+         public boolean setMapArea(final Envelope newMapArea) {
+                 if (newMapArea == null)
+                         return false;
+                 if (getMapContext().getCoordinateReferenceSystem() == null)
+                         return false;
+                 return setMapArea(new ReferencedEnvelope(newMapArea, getMapContext()
+                                 .getCoordinateReferenceSystem()));
+         }
+         /**
+          * Set the new map area.
+          *
+          * @param newMapArea
+          * @return <code>true</code> if the mapArea has been changed and a repaint
+          *         has been triggered.
+          */
+         public boolean setMapArea(final ReferencedEnvelope newMapArea) {
+                 if (newMapArea == null
+                                 || bestAllowedMapArea(newMapArea).equals(mapArea)) {
+                         // No change.. no need to repaint
+                         return false;
+                 }
+                 // Testing, whether NaN or Infinity are used in the newMapArea
+                 if (newMapArea.isNull() || Double.isInfinite(newMapArea.getMaxX())
+                                 || Double.isInfinite(newMapArea.getMaxY())
+                                 || Double.isInfinite(newMapArea.getMinX())
+                                 || Double.isInfinite(newMapArea.getMinY())) {
+                         // No change.. ugly new values
+                         LOGGER.warn("setMapArea has been called with newArea = "
+                                         + newMapArea);
+                         return false;
+                 }
+                 final Envelope candNew = bestAllowedMapArea(newMapArea);
+                 // Testing, whether the difference if just minimal
+                 if (mapArea != null) {
+                         final double tolX = mapArea.getWidth() / 1000.;
+                         final double tolY = mapArea.getHeight() / 1000.;
+                         if ((candNew.getMinX() - tolX < mapArea.getMinX())
+                                         && (mapArea.getMinX() < candNew.getMinX() + tolX)
+                                         && (candNew.getMaxX() - tolX < mapArea.getMaxX())
+                                         && (mapArea.getMaxX() < candNew.getMaxX() + tolX)
+                                         && (candNew.getMinY() - tolY < mapArea.getMinY())
+                                         && (mapArea.getMinY() < candNew.getMinY() + tolY)
+                                         && (candNew.getMaxY() - tolY < mapArea.getMaxY())
+                                         && (mapArea.getMaxY() < candNew.getMaxY() + tolY)
+                         ) {
+                                 // The two mapAreas only differ my 1/1000th.. ignore
+                                 return false;
+                         }
+                 }
+                 // New map are is accepted:
+                 oldMapArea = mapArea;
+                 mapArea = candNew;
+                 resetTransforms();
+                 if (localContext != null) {
+                         localContext.setAreaOfInterest(mapArea, localContext
+                                         .getCoordinateReferenceSystem());
+                 }
+                 if (bgContext != null) {
+                         bgContext.setAreaOfInterest(mapArea, localContext
+                                         .getCoordinateReferenceSystem());
+                 }
+                 mapAreaChanged = true;
+                 repaint(200); // Do not remove it!
+                 requestStartRendering();
+                 return true;
+         }
+         /**
+          * Set the background color of the map.
+          *
+          * @param if <code>null</code>, white is used.
+          */
+         public void setMapBackgroundColor(final Color bgColor) {
+                 this.mapBackgroundColor = bgColor;
+         }
+         /**
+          * Set the BufferedImage to use as a flaoting icon in the lower right corner
+          *
+          * @param mapImageIcon
+          *            <code>null</code> is allowed and deactivates this icon.
+          */
+         public void setMapImage(final BufferedImage mapImage) {
+                 this.mapImage = mapImage;
+         }
+         /**
+          * Sets whether a layer is regarded or ignored on {@link #SELECT_TOP},
+          * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions.
+          *
+          * @param layer
+          *            a layer
+          * @param selectable
+          *            if {@code false} the layer is ignored during the upper
+          *            mentioned actions. If <code>null</code>, the default (true)
+          *            will be used.
+          */
+         public void setMapLayerSelectable(final MapLayer layer,
+                         final Boolean selectable) {
+                 if (selectable == null)
+                         mapLayerSelectable.remove(layer);
+                 else
+                         mapLayerSelectable.put(layer, selectable);
+         }
+         /**
+          * Defines an evelope of the viwable area. The JMapPane will never show
+          * anything outside of this extend.
+          *
+          * @param maxExtend
+          *            <code>null</code> to not have this restriction.
+          */
+         public void setMaxExtend(final Envelope maxExtend) {
+                 this.maxExtend = maxExtend;
+         }
+         /**
+          * Set the maximum allowed zoom scale. This is the smaller number value of
+          * the two. If <code>null</code> is passed, Double.MINVALUE are used which
+          * mean there is no restriction.
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public void setMaxZoomScale(final Double maxZoomScale) {
+                 this.maxZoomScale = maxZoomScale == null ? Double.MIN_VALUE
+                                 : maxZoomScale;
+         }
+         // /** Stored the time used for the last real rendering in ms. **/
+         private long lastRenderingDuration = 1000;
+         private XMapPaneTool tool = null;
+         /**
+          * Set the minimum (nearest) allowed zoom scale. This is the bigger number
+          * value of the two. If <code>null</code> is passed, Double.MAXVALUE are
+          * used which mean there is no restriction.
+          *
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public void setMinZoomScale(final Double minZoomScale) {
+                 this.minZoomScale = minZoomScale == null ? Double.MAX_VALUE
+                                 : minZoomScale;
+         }
+         /**
+          * If <code>true</code>, allow the {@link XMapPane} to process #repaint()
+          * requests. Otherwise the map will not paint anything and not start any
+          * rendering {@link Thread}s.
+          */
+         public void setPainting(final boolean b) {
+                 acceptsRepaintCalls = b;
+                 if (acceptsRepaintCalls == true)
+                         repaint();
+         }
+         private void setRendererHints(final Map<Object, Object> rendererHints) {
+                 if (rendererHints != null)
+                         this.rendererHints = rendererHints;
+         }
+         // @Deprecated
+         // public void setState(final int state) {
+         // this.state = state;
+         //
+         // // throw new RuntimeException("Old concept.. migrate to new concept!");
+         //
+         // // xMapPaneMouseListener.setEnabled((state == ZOOM_IN
+         // // || state == ZOOM_OUT || state == PAN));
+         //
+         // // Je nach Aktion den Cursor umsetzen
+         // updateCursor();
+         // }
+         public void configureMouse(MouseInputType type, XMapPaneAction action) {
+                 xMapPaneMouseListener.actions.put(type, action);
+         }
+         /**
+          * Configure the {@link XMapPaneTool} that active on the map. Passing
+          * <code>null</code> will set the NO_ACTION tool.
+          */
+         public void setTool(XMapPaneTool tool) {
+                 if (tool == null)
+                         tool = XMapPaneTool.NO_ACTION;
+                 this.tool = tool;
+                 xMapPaneMouseListener.configure(tool);
+                 setCursor(tool.getCursor());
+         }
+         // /**
+         // * Standardmaessig wird der Cursor automatisch je nach MapPane-Aktion
+         // (Zoom,
+         // * Auswahl, ...) gesetzt. Mit dieser Methode kann ein statischer Cursor
+         // * gesetzt werden, der unabhaengig von der aktuellen MapPanes-Aktion
+         // * beibehalten wird. Um diesen statischen Cursor wieder zu entfernen, kann
+         // * {@code null} als Parameter uebergeben werden
+         // *
+         // * @param cursor
+         // * Cursor
+         // */
+         // public void setStaticCursor(final Cursor cursor) {
+         // this.staticCursor = cursor;
+         // if (cursor != null)
+         // super.setCursor(cursor);
+         // }
+         /**
+          * Starts rendering on one or two threads
+          */
+         private void startRendering() {
+                 if (!isWellDefined() || !acceptsRepaintCalls) {
+                         // if we are not ready to start rendering, try it again the next
+                         // time the timer is chacking the flag.
+                         requestStartRendering = true;
+                         return;
+                 }
+                 if (bgExecuter != null) {
+                         // Stop all renderers
+                         bgExecuter.cancelTask();
+                 }
+                 localExecuter.cancelTask();
+                 final Rectangle curPaintArea = getVisibleRect();
+                 /**
+                  * We have to set new renderer
+                  */
+                 if (getBgContext() != null) {
+                         bgRenderer.setJava2DHints(getJava2dHints());
+                         bgRenderer.setRendererHints(getRendererHints());
+                         // bgExecuter = new RenderingExecutor();
+                         // LOGGER.debug("starting bg renderer:");
+                         // // /* System.out.println("rendering"); */
+                         // final GTRenderer createGTRenderer = GTUtil.createGTRenderer(
+                         // bgContext, getRendererHints());
+                         // createGTRenderer.setJava2DHints(getJava2dHints());
+                         // bgExecuter.submit(getBgContext().getAreaOfInterest(),
+                         // curPaintArea,
+                         // (Graphics2D) getBgImage().getGraphics(), createGTRenderer);
+                 }
+                 if (getMapContext() != null) {
+                         // localExecuter = new RenderingExecutor(this, 150l);
+                         // LOGGER.debug("starting local renderer:");
+                         getLocalRenderer().setJava2DHints(getJava2dHints());
+                         getLocalRenderer().setRendererHints(getRendererHints());
+                         final boolean submitted = localExecuter.submit(getMapArea(),
+                                         curPaintArea, (Graphics2D) getLocalImage().getGraphics(),
+                                         getLocalRenderer());
+                         if (submitted)
+                                 repaintTimer.restart();
+                         else
+                                 requestStartRendering = true; // Try to start rendering
+                         // again in
+                         // a moment
+                 }
+                 updateCursor();
+         }
+         private RenderingHints getJava2dHints() {
+                 return java2dHints;
+         }
+         /**
+          * Transformiert einen Geo-Koordinaten-Bereich in Fenster-Koordinaten.
+          *
+          * @param ox
+          *            X-Koordinate der VON-Position
+          * @param oy
+          *            Y-Koordinate der VON-Position
+          * @param px
+          *            X-Koordinate der BIS-Position
+          * @param py
+          *            Y-Koordinate der BIS-Position
+          * @param winToGeotransform
+          *            Eine Window to Geo transform. If <code>null</code>,
+          *            {@link #getScreenToWorld()} is used.
+          */
+         public Envelope tranformGeoToWindow(final double ox, final double oy,
+                         final double px, final double py) {
+                 final AffineTransform at = getWorldToScreenTransform();
+                 Point2D geoO;
+                 // try {
+                 geoO = at.transform(new Point2D.Double(ox, oy), null);
+                 final Point2D geoP = at.transform(new Point2D.Double(px, py), null);
+                 return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP.getY());
+                 // } catch (final NoninvertibleTransformException e) {
+                 // LOGGER.error(e);
+                 // return new Envelope(ox, oy, px, py);
+                 // }
+         }
+         /**
+          * Transformiert einen Fenster-Koordinaten-Bereich in Geo-Koordinaten.
+          *
+          * @param ox
+          *            X-Koordinate der VON-Position
+          * @param oy
+          *            Y-Koordinate der VON-Position
+          * @param px
+          *            X-Koordinate der BIS-Position
+          * @param py
+          *            Y-Koordinate der BIS-Position
+          */
+         public Envelope tranformWindowToGeo(final int ox, final int oy,
+                         final int px, final int py) {
+                 final AffineTransform at = getScreenToWorld();
+                 final Point2D geoO = at.transform(new Point2D.Double(ox, oy), null);
+                 final Point2D geoP = at.transform(new Point2D.Double(px, py), null);
+                 // Mmmmm... don't really understand why its x,x,y,y
+                 // return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(),
+                 // geoP.getY());
+                 return new Envelope(new Coordinate(geoO.getX(), geoO.getY()),
+                                 new Coordinate(geoP.getX(), geoP.getY()));
+         }
+         /**
+          * Will update the cursor. If all rendering is finished also stops the
+          * {@link #repaintTimer}
+          */
+         public void updateCursor() {
+                 // if the renderers have stopped, also stop the timer that is updating
+                 // the final image
+                 if (bgExecuter != null && bgExecuter.isRunning()
+                                 || localExecuter.isRunning()) {
+                         setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
+                         return;
+                 } else {
+                         // Allow one last rendering
+                         if (repaintTimer.isRunning()) {
+                                 // System.out.println("one last rendering....");
+                                 repaintTimer.stop();
+                                 updateFinalImage();
+                                 repaint();
+                         }
+                 }
+                 //
+                 // //
+                 // // wenn manueller Cursor gesetzt ist, dann diesen verwenden
+                 // (unabhaengig
+                 // // von der aktuellen Aktion
+                 // if (this.staticCursor != null) {
+                 // setCursor(staticCursor);
+                 // return;
+                 // }
+                 //
+                 if (getCursor() == SwingUtil.PANNING_CURSOR) {
+                         // This cursor will reset itself
+                         return;
+                 }
+                 setCursor(tool.getCursor());
+                 //
+                 // // Set the cursor depending on what tool is in use...
+                 // switch (state) {
+                 // case SELECT_TOP:
+                 // case SELECT_ONE_FROM_TOP:
+                 // case SELECT_ALL:
+                 // setCursor(SwingUtil.CROSSHAIR_CURSOR);
+                 // break;
+                 // case ZOOM_IN:
+                 // setCursor(SwingUtil.ZOOMIN_CURSOR);
+                 // break;
+                 // case ZOOM_OUT:
+                 // setCursor(SwingUtil.ZOOMOUT_CURSOR);
+                 // break;
+                 // case PAN:
+                 // setCursor(SwingUtil.PAN_CURSOR);
+                 // break;
+                 // default:
+                 // setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+                 // break;
+                 // }
+         }
+         /**
+          * The renderers are all rendering into their own {@link Image}s. This
+          * method combines all images to one {@link #finalImage}. The
+          * {@link #repaintTimer} is calling this method regularely to update the
+          * {@link #finalImage} even if the renderers are still working.
+          */
+         synchronized protected Image updateFinalImage() {
+                 // Render the two map images first, into the preFinalImage
+                 if (bgExecuter != null) {
+                         final Graphics2D preFinalG = (Graphics2D) getPreFinalImage()
+                                         .getGraphics();
+                         preFinalG.setBackground(getMapBackgroundColor());
+                         preFinalG.drawImage(getBgImage(), 0, 0, getMapBackgroundColor(),
+                                         null);
+                         // // Draw the local layers image
+                         preFinalG.drawImage(getLocalImage(), 0, 0, null);
+                         preFinalG.dispose();
+                 } else {
+                         preFinalImage = getLocalImage();
+                 }
+                 final Graphics2D finalG = getFinalImage().createGraphics();
+                 finalG.setBackground(getMapBackgroundColor());
+                 finalG.drawImage(getPreFinalImage(), getImageOrigin().x,
+                                 getImageOrigin().y, getMapBackgroundColor(), null);
+                 // When panning, we have to clear the area around the image
+                 final Rectangle painedArea = new Rectangle(getImageOrigin().x,
+                                 getImageOrigin().y, getFinalImage().getWidth(), getFinalImage()
+                                                 .getHeight());
+                 SwingUtil.clearAround(finalG, painedArea, getVisibleRect(),
+                                 getMapBackgroundColor());
+                 // addGadgets(finalG, false);
+                 finalG.dispose();
+                 return finalImage;
+         }
+         /**
+          * Paints some optional stuff into the given {@link Graphics2D}. Usually
+          * called as the last layer when {@link #updateFinalImage()}
+          *
+          * @param forceWait
+          *            if <code>true</code>, a Wait-message will be painted even
+          *            though the rendering threads may not yet have started. If
+          *            <code>false</code>, it will only depend on
+          *            {@link #localExecuter.isRunning} and #bgExecuter.isRunning
+          */
+         private void addGadgets(final Graphics2D graphics, final boolean forceWait) {
+                 // Paint a logo to the bottom right if available
+                 if (mapImage != null) {
+                         final Rectangle visibleRect = getVisibleRect();
+                         graphics.drawImage(mapImage, visibleRect.width
+                                         - mapImage.getWidth() - 10, getVisibleRect().height
+                                         - mapImage.getHeight() - 10, null);
+                 }
+                 int y = 17;
+                 // If the rendering process is still running, indicate this is the image
+                 if (forceWait || bgExecuter != null && bgExecuter.isRunning()
+                                 || localExecuter.isRunning()) {
+                         y += 8;
+                         final Color c = graphics.getColor();
+                         graphics.setFont(waitFont);
+                         graphics.setColor(getMapBackgroundColor());
+                         graphics.drawString(waitMsg, 5, y);
+                         graphics.setColor(getMapBackgroundColor());
+                         graphics.drawString(waitMsg, 7, y + 2);
+                         graphics.setColor(Color.BLACK);
+                         graphics.drawString(waitMsg, 6, y + 1);
+                         graphics.setColor(c);
+                         y += 21;
+                 }
+                 if (!renderingErrors.isEmpty() && isShowExceptions()) {
+                         final Color c = graphics.getColor();
+                         graphics.setFont(errorFont);
+                         for (final Exception ex : renderingErrors) {
+                                 String errStr = ex.getLocalizedMessage();
+                                 if (errStr == null)
+                                         errStr = ex.getMessage();
+                                 if (errStr == null)
+                                         errStr = "unknown error: " + ex.getClass().getSimpleName();
+                                 graphics.setColor(getMapBackgroundColor());
+                                 graphics.drawString(errStr, 5, y);
+                                 graphics.setColor(Color.RED);
+                                 graphics.drawString(errStr, 6, y + 1);
+                                 y += 19;
+                         }
+                         graphics.setColor(c);
+                 }
+         }
+         /**
+          * Sets the {@link #mapArea} to best possibly present the given features. If
+          * only one single point is given, the window is moved over the point.
+          *
+          * @param features
+          *            if <code>null</code> or size==0, the function doesn nothing.
+          */
+         public void zoomTo(
+                         final FeatureCollection<SimpleFeatureType, SimpleFeature> features) {
+                 // if (!isWellDefined()) return;
+                 final CoordinateReferenceSystem mapCRS = getMapContext()
+                                 .getCoordinateReferenceSystem();
+                 final CoordinateReferenceSystem fCRS = features.getSchema()
+                                 .getCoordinateReferenceSystem();
+                 ReferencedEnvelope _mapArea;
+                 if (mapArea == null)
+                         _mapArea = features.getBounds();
+                 else
+                         _mapArea = getMapArea();
+                 double width = _mapArea.getWidth();
+                 double height = _mapArea.getHeight();
+                 final double ratio = height / width;
+                 if (features == null || features.size() == 0) {
+                         // feature count == 0 Zoom to the full extend
+                         return;
+                 } else if (features.size() == 1) {
+                         // feature count == 1 Just move the window to the point and zoom 'a
+                         // bit'
+                         final SimpleFeature singleFeature = features.iterator().next();
+                         if (((Geometry) singleFeature.getDefaultGeometry())
+                                         .getCoordinates().length > 1) {
+                                 // System.out.println("Zoomed to only pne poylgon");
+                                 // Poly
+                                 // TODO max width vs. height
+                                 width = features.getBounds().getWidth() * 3;
+                                 height = ratio * width;
+                         } else {
+                                 // System.out.println("Zoomed in a bit becasue only one point");
+                                 // width *= .9;
+                                 // height *= .9;
+                         }
+                         Coordinate centre = features.getBounds().centre();
+                         if (!mapCRS.equals(fCRS)) {
+                                 // only to calculations if the CRS differ
+                                 try {
+                                         MathTransform fToMap;
+                                         fToMap = CRS.findMathTransform(fCRS, mapCRS);
+                                         // centre is transformed to the mapCRS
+                                         centre = JTS.transform(centre, null, fToMap);
+                                 } catch (final FactoryException e) {
+                                         LOGGER.error("Looking for a Math transform", e);
+                                 } catch (final TransformException e) {
+                                         LOGGER.error("Looking for a Math transform", e);
+                                 }
+                         }
+                         final Coordinate newLeftBottom = new Coordinate(centre.x - width
+                                         / 2., centre.y - height / 2.);
+                         final Coordinate newTopRight = new Coordinate(
+                                         centre.x + width / 2., centre.y + height / 2.);
+                         final Envelope newMapArea = new Envelope(newLeftBottom, newTopRight);
+                         setMapArea(newMapArea);
+                 } else {
+                         final ReferencedEnvelope fBounds = features.getBounds();
+                         ReferencedEnvelope bounds;
+                         if (!mapCRS.equals(fCRS)) {
+                                 bounds = JTSUtil.transformEnvelope(fBounds, mapCRS);
+                         } else {
+                                 bounds = fBounds;
+                         }
+                         // BB umrechnen von Layer-CRS in Map-CRS
+                         // Expand a bit
+                         addDefaultMargin(bounds);
+                         setMapArea(bounds);
+                 }
+         }
+         private ReferencedEnvelope addDefaultMargin(ReferencedEnvelope bounds) {
+                 return JTSUtil.expandEnvelope(bounds, Math.max(0,
+                                 defaultMaxMapExtendMode));
+         }
+         private Envelope addDefaultMargin(Envelope bounds) {
+                 return JTSUtil.expandEnvelope(bounds, Math.max(0,
+                                 defaultMaxMapExtendMode));
+         }
+         /**
+          * Zooms towards a point.
+          *
+          * @param center
+          *            position in window coordinates
+          * @param zoomFactor
+          *            > 1 for zoom in, < 1 for zoom out. Default is 1.33
+          */
+         public void zoomTo(final Point center) {
+                 zoomTo(center, null);
+         }
+         /**
+          * Zooms towards a point.
+          *
+          * @param center
+          *            position in window coordinates
+          * @param zoomFaktor
+          *            > 1 for zoom out, < 1 for zoom in. Default is .5
+          */
+         public void zoomTo(Point center, Double zoomFaktor) {
+                 if (zoomFaktor == null || zoomFaktor == 0.)
+                         zoomFaktor = .5;
+                 final Point2D gcenter = getScreenToWorld().transform(center, null);
+                 center = null;
+                 if (Double.isNaN(gcenter.getX()) || Double.isNaN(gcenter.getY())
+                                 || Double.isInfinite(gcenter.getX())
+                                 || Double.isInfinite(gcenter.getY())
+                 ) {
+                         // Not inside valid CRS area! cancel
+                         return;
+                 }
+                 final Envelope mapArea = getMapArea();
+                 final Envelope newMapArea = new Envelope(mapArea);
+                 newMapArea.expandBy((mapArea.getWidth() * zoomFaktor - mapArea
+                                 .getWidth()) / 2., (mapArea.getHeight() * zoomFaktor - mapArea
+                                 .getHeight()) / 2.);
+                 // // Move the newMapArea above the new center if we zoom in:
+                 newMapArea.translate(gcenter.getX() - mapArea.centre().x, gcenter
+                                 .getY()
+                                 - mapArea.centre().y);
+                 setMapArea(newMapArea);
+         }
+         /**
+          * Shall non-fatal rendering exceptions be reported in the mappane or be
+          * dropped quitely.
+          */
+         public void setShowExceptions(final boolean showExceptions) {
+                 this.showExceptions = showExceptions;
+         }
+         /**
+          * Shall exceptions be reported in the mappane?
+          */
+         public boolean isShowExceptions() {
+                 return showExceptions;
+         }
+         public GTRenderer getLocalRenderer() {
+                 return localRenderer;
+         }
+         /**
+          * Setzt den Kartenausschnitt auf die Ausdehnung eines bestimmten Layers.
+          * Macht nichts, wenn {@code null} uebergeben wird.
+          *
+          * <br>
+          *
+          * @param layer
+          *            ein Layer
+          */
+         public void zoomToLayer(MapLayer layer) {
+                 if (layer == null)
+                         return;
+                 try {
+                         // BB umrechnen von Layer-CRS in Map-CRS
+                         final CoordinateReferenceSystem targetCRS = getMapContext()
+                                         .getCoordinateReferenceSystem();
+                         final CoordinateReferenceSystem sourceCRS = layer
+                                         .getFeatureSource().getSchema()
+                                         .getCoordinateReferenceSystem();
+                         Envelope mapAreaNew;
+                         if (!CRS.equalsIgnoreMetadata(sourceCRS, targetCRS)) {
+                                 mapAreaNew = JTSUtil.transformEnvelope(layer.getFeatureSource()
+                                                 .getBounds(), sourceCRS, targetCRS);
+                         } else {
+                                 try {
+                                         mapAreaNew = layer.getFeatureSource().getBounds();
+                                 } catch (java.lang.IllegalArgumentException e) {
+                                         LOGGER.error("Can't calc layers bounds...", e);
+                                         mapAreaNew = null;
+                                         /**
+                                          *
+.10.2009 11:20:50
+                                          * org.geotools.data.shapefile.shp.PolygonHandler read
+                                          * WARNUNG: only one hole in this polygon record ERROR
+                                          * JMapPane zoomToLayer Zoom to layer did not terminate
+                                          * correctly java.lang.IllegalArgumentException: Points of
+                                          * LinearRing do not form a closed linestring at
+                                          * com.vividsolutions
+                                          * .jts.geom.LinearRing.validateConstruction
+                                          * (LinearRing.java:105) at
+                                          * com.vividsolutions.jts.geom.LinearRing
+                                          * .<init>(LinearRing.java:100) at
+                                          * com.vividsolutions.jts.geom
+                                          * .GeometryFactory.createLinearRing
+                                          * (GeometryFactory.java:339) at
+                                          * org.geotools.data.shapefile.
+                                          * shp.PolygonHandler.read(PolygonHandler.java:188) at
+                                          * org.geotools
+                                          * .data.shapefile.shp.ShapefileReader$Record.shape
+                                          * (ShapefileReader.java:106) at
+                                          * org.geotools.data.shapefile.
+                                          * ShapefileAttributeReader.next(
+                                          * ShapefileAttributeReader.java:157) at
+                                          * org.geotools.data.shapefile
+                                          * .indexed.IndexedShapefileAttributeReader
+                                          * .next(IndexedShapefileAttributeReader.java:122) at
+                                          * org.geotools
+                                          * .data.FIDFeatureReader.next(FIDFeatureReader.java:96) at
+                                          * org.geotools.data.FIDFeatureReader.next(FIDFeatureReader.
+                                          * java:55) at org.geotools.data.MaxFeatureReader.next(
+                                          * MaxFeatureReader.java:61) at
+                                          * org.geotools.data.MaxFeatureReader
+                                          * .next(MaxFeatureReader.java:61)
+                                          **/
+                                 }
+                         }
+                         // Kartenbereich um 10% vergroessern, damit z.B. auch ein
+                         // Punkt-Layer,
+                         // welches nur aus 2 Punnkten besteht, sichtbar ist (Punkte liegen
+                         // sonst
+                         // genau auf dem Rand der angezeigten Flaeche)
+                         if (mapAreaNew != null) {
+                                 mapAreaNew = addDefaultMargin(mapAreaNew);
+                                 setMapArea(mapAreaNew);
+                         } else {
+                                 LOGGER
+                                                 .warn("Couldn't transformEnvelope when zooming to the layer");
+                         }
+                 } catch (Exception err) {
+                         LOGGER.error("Zoom to layer did not terminate correctly", err);
+                 }
+         }
+         /**
+          * Zooms the {@link SelectableXMapPane} to the {@link Envelope} of a layer.
+          *
+          * <br>
+          * A refresh of the map is not done automatically
+          *
+          * @param index
+          *            Index of the {@link MapLayer} in the {@link MapContext} (from
+          *            back to top)
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public void zoomToLayer(int index) {
+                 final MapContext context = getMapContext();
+                 if (context != null)
+                         zoomToLayer(context.getLayer(index));
+         }
+         /**
+          * Zooms the {@link SelectableXMapPane} to the {@link Envelope} of the
+          * selected layer. The layer is selected by the idx, counting from front to
+          * back, like humans would expect in a {@link JList}
+          *
+          * <br>
+          * A refresh of the map is not done automatically
+          *
+          *
+          *
+          * @param index
+          *            Reverse index of the {@link MapLayer} in the
+          *            {@link MapContext}
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public void zoomToLayerIdxReverse(int index) {
+                 zoomToLayer(getMapContext().getLayerCount() - 1 - index);
+         }
+         /**
+          * Aktiviert oder deaktiviert das AntiAliasing for diese
+          * {@link SelectableXMapPane}. AntiALiasing ist besonders fuer
+          * Textbeschriftung sehr schoen, verbraucht aber auch mehr Performance.
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public void setAntiAliasing(final boolean aa) {
+                 // LOGGER.info("Setting AntiAliasing for this JMapPane to " + aa);
+                 RenderingHints java2DHints = java2dHints;
+                 if (java2DHints == null) {
+                         java2DHints = GeoTools.getDefaultHints();
+                 }
+                 java2DHints.put(RenderingHints.KEY_ANTIALIASING,
+                                 aa ? RenderingHints.VALUE_ANTIALIAS_ON
+                                                 : RenderingHints.VALUE_ANTIALIAS_OFF);
+                 java2DHints.put(RenderingHints.KEY_TEXT_ANTIALIASING,
+                                 aa ? RenderingHints.VALUE_TEXT_ANTIALIAS_ON
+                                                 : RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+                 java2DHints.put(RenderingHints.KEY_RENDERING,
+                                 aa ? RenderingHints.VALUE_RENDER_QUALITY
+                                                 : RenderingHints.VALUE_RENDER_SPEED);
+         }
+         public Point getImageOrigin() {
+                 return imageOrigin;
+         }
+         /**
+          * If {@link #maxExtend} is <code>null</code> the following rules are used
+          * to create a default maximum.
+          * <ul>
+          * <li>Values &lt; 0 : don't grow to fit the monitors aspect ratio, no
+          * margin</li>
+          * <li>Values 0 : grow to fit the monitors aspect ratio, no margin</li>
+          * <li>Values &gt; 0 : grow to fit the monitors aspect ratio, and add a
+          * relative margin</li>
+          * </ul>
+          * **/
+         public void setDefaultMaxMapExtendMode(double defaultMaxMapExtendMode) {
+                 this.defaultMaxMapExtendMode = defaultMaxMapExtendMode;
+         }
+         /**
+          * If {@link #maxExtend} is <code>null</code> the following rules are used
+          * to create a default maximum.
+          * <ul>
+          * <li>Values &lt; 0 : don't grow to fit the monitors aspect ratio, no
+          * margin</li>
+          * <li>Values 0 : grow to fit the monitors aspect ratio, no margin</li>
+          * <li>Values &gt; 0 : grow to fit the monitors aspect ratio, and add a
+          * relative margin</li>
+          * </ul>
+          * **/
+         public double getDefaultMaxMapExtendMode() {
+                 return defaultMaxMapExtendMode;
+         }
  }

 Legend:



Removed from v.127
 


changed lines


 
Added in v.660
 Legend:



Removed from v.127
 


changed lines


 
Added in v.660
-Removed from v.127
+Added in v.660

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26