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

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

Parent Directory | Revision Log | View Patch Patch

-branches/1.0-gt2-2.6/src/org/geotools/gui/swing/JMapPane.java
revision 341 by alfonx,
Mon Aug 31 10:16:40 2009 UTC
+branches/1.0-gt2-2.6/src/gtmig/org/geotools/swing/XMapPane.java
revision 521 by alfonx,
Tue Nov 17 12:51:37 2009 UTC
 Line 13
   *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   *    Lesser General Public License for more details.
   */
- package org.geotools.gui.swing;
+ package gtmig.org.geotools.swing;
  /**
-  * <b>Xulu:<br>
+  * This class is 50% copied from GeoTools 2.6.x JMapPane. GeoTools is LGPL, SCHMITZM also.<br/>
-  *    Code taken from gt-2.4.5 to make some changes (marked with {@code xulu}),
+  * In addition to
-  *    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.AlphaComposite;
  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.RenderingHints;
+ import java.awt.event.ActionEvent;
+ import java.awt.event.ActionListener;
+ import java.awt.event.ComponentAdapter;
+ import java.awt.event.ComponentEvent;
  import java.awt.event.InputEvent;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
- import java.awt.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.HashMap;
  import java.util.Map;
+ import java.util.Vector;
+ import javax.swing.JFrame;
  import javax.swing.JPanel;
+ import javax.swing.Timer;
  import org.apache.log4j.Logger;
+ import org.geotools.feature.FeatureCollection;
+ import org.geotools.geometry.jts.JTS;
+ import org.geotools.geometry.jts.ReferencedEnvelope;
+ import org.geotools.map.DefaultMapContext;
  import org.geotools.map.MapContext;
+ import org.geotools.map.MapLayer;
+ import org.geotools.map.event.MapLayerEvent;
  import org.geotools.map.event.MapLayerListEvent;
  import org.geotools.map.event.MapLayerListListener;
+ import org.geotools.map.event.MapLayerListener;
+ import org.geotools.referencing.CRS;
  import org.geotools.renderer.GTRenderer;
  import org.geotools.renderer.label.LabelCacheImpl;
  import org.geotools.renderer.lite.LabelCache;
- import org.geotools.renderer.lite.StreamingRenderer;
+ import org.geotools.swing.JMapPane;
- import org.geotools.renderer.shape.TransitionShapefileRenderer;
+ import org.geotools.swing.event.MapMouseEvent;
- import org.geotools.styling.Graphic;
+ import org.geotools.swing.event.MapPaneEvent;
- import org.geotools.styling.LineSymbolizer;
+ import org.geotools.swing.event.MapPaneListener;
- import org.geotools.styling.Mark;
+ import org.opengis.feature.simple.SimpleFeature;
- import org.geotools.styling.PointSymbolizer;
+ import org.opengis.feature.simple.SimpleFeatureType;
- import org.geotools.styling.PolygonSymbolizer;
+ import org.opengis.referencing.FactoryException;
- import org.geotools.styling.StyleBuilder;
- import org.geotools.styling.StyleFactory;
- 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.map.event.JMapPaneListener;
+ import schmitzm.geotools.map.event.MapLayerAdapter;
  import schmitzm.swing.SwingUtil;
+ import skrueger.geotools.RenderingExecutor;
  import com.vividsolutions.jts.geom.Coordinate;
  import com.vividsolutions.jts.geom.Envelope;
- import com.vividsolutions.jts.geom.GeometryFactory;
+ import com.vividsolutions.jts.geom.Geometry;
- public class JMapPane extends JPanel implements MouseListener,
+ public class XMapPane extends JPanel implements PropertyChangeListener {
-                 MouseMotionListener, PropertyChangeListener, MapLayerListListener {
+         private static Logger LOGGER = Logger.getLogger(XMapPane.class);
-         private static Logger LOGGER = Logger.getLogger(JMapPane.class.getName());
-         private static final long serialVersionUID = -8647971481359690499L;
+         /**
+          * Sets whether a layer is regarded or ignored on {@link #SELECT_TOP},
-         public static final int Reset = 0;
+          * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions.
+          *
-         public static final int ZoomIn = 1;
+          * @param layer
+          *            a layer
-         public static final int ZoomOut = 2;
+          * @param selectable
+          *            if {@code false} the layer is ignored during the upper
-         public static final int Pan = 3;
+          *            mentioned actions. If <code>null</code>, the default (true)
+          *            will be used.
-         public static final int Select = 4;
+          */
+         public void setMapLayerSelectable(MapLayer layer, Boolean selectable) {
-         private static final int POLYGON = 0;
+                 if (selectable == null)
+                         mapLayerSelectable.remove(layer);
+                 else
+                         mapLayerSelectable.put(layer, selectable);
+         }
-         private static final int LINE = 1;
+         /**
+          * 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>();
-         private static final int POINT = 2;
+         /**
+          * Returns whether a layer is regarded or ignored on {@link #SELECT_TOP},
+          * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions. Returns
+          * <code>true</code> if the selectability has not been defined.
+          *
+          * @param layer
+          *            a layer
+          */
+         public boolean isMapLayerSelectable(MapLayer layer) {
+                 Boolean selectable = mapLayerSelectable.get(layer);
+                 return selectable == null ? true : selectable;
+         }
          /**
-          * what renders the map
+          * Flag fuer Modus "Kartenausschnitt bewegen". Nicht fuer Window-Auswahl
+          * moeglich!
+          *
+          * @see #setState(int)
+          */
+         public static final int PAN = 1;
+         /**
+          * Flag fuer Modus "Heran zoomen".
+          *
+          * @see #setState(int)
+          * @see #setState(int)
+          */
+         public static final int ZOOM_IN = 2;
+         /**
+          * Flag fuer Modus "Heraus zoomen". Nicht fuer Window-Auswahl moeglich!
+          *
+          * @see #setState(int)
+          */
+         public static final int ZOOM_OUT = 3;
+         /**
+          * Flag fuer Modus
+          * "SimpleFeature-Auswahl auf dem obersten (sichtbaren) Layer".
+          *
+          * @see #setState(int)
+          * @see #setState(int)
+          */
+         public static final int SELECT_TOP = 4;
+         /**
+          * Flag fuer Modus "SimpleFeature-Auswahl auf allen (sichtbaren) Layern".
+          *
+          * @see #setState(int)
+          * @see #setState(int)
+          */
+         public static final int SELECT_ALL = 103;
+         /**
+          * Flag fuer Modus
+          * "Auswahl nur eines Features, das erste sichtbare von Oben".
+          *
+          * @see #setState(int)
+          * @see #setState(int)
           */
-         GTRenderer renderer;
+         public static final int SELECT_ONE_FROM_TOP = 104;
+ //
+ //      /**
+ //       * While threads are working, we call {@link XMapPane#updateFinalImage()}
+ //       * regularly and repaint(). This {@link Timer} is stopped when all renderers
+ //       * have finished.
+ //       */
+ //      final private Timer repainterTimer;
+ //
+ //      /**
+ //       * While the {@link #bgExecuter} and {@link #localExecuter} are rendering,
+ //       * the {@link #repainterTimer} is regularly updating the {@link #finalImage}
+ //       * with previews.
+ //       */
+ //      public static final long REPEATING_REPAINT_DELAY = 500;
+ //
+ //      /**
+ //       * The initial delay in milliseconds until the {@link #finalImage} is updated the first time.
+ //       */
+ //      public static final long INITIAL_REPAINT_DELAY = 333;
-         private GTRenderer highlightRenderer, selectionRenderer;
+         protected RenderingExecutor bgExecuter;
          /**
           * the map context to render
           */
-         MapContext context;
+         MapContext localContext;
+         /**
-         private MapContext selectionContext;
+          * the map context to render
+          */
+         MapContext bgContext;
          /**
           * the area of the map to draw
           */
-         // xulu.sc
+         protected Envelope mapArea = null;
-         // Envelope mapArea;
+         /**
-         protected Envelope mapArea;
+          * We store the old mapArea for a moment to use it for the
-         // xulu.ec
+          * "quick scaled preview" in case of ZoomOut
+          **/
+         protected Envelope oldMapArea = null;
          /**
           * the size of the pane last time we drew
           */
-         // xulu.sc
-         // private Rectangle oldRect = null;
          protected Rectangle oldRect = null;
-         // xulu.ec
          /**
-          * the last map area drawn.
+          * The Renderer for the Background uses this Image. When set to null, please
+          * dispose the {@link Graphics2D}
           */
-         // xulu.sc
+         protected BufferedImage bgImage;
-         // private Envelope oldMapArea = null;
-         protected Envelope oldMapArea = null;
-         // xulu.ec
          /**
-          * the base image of the map
+          * The Renderer for the LocalLayers uses this Image. When set to null,
+          * please dispose this {@link Graphics2D}
           */
-         protected BufferedImage baseImage, panningImage;
+         volatile protected BufferedImage localImage;
-         // SK: private BufferedImage baseImage, panningImage;
          /**
-          * a factory for filters
+          * compass and icon are rendered into this image
           */
-         FilterFactory2 ff;
+         // protected BufferedImage gadgetsImage;
          /**
-          * a factory for geometries
+          * The default state is ZOOM_IN, hence by default the
-          */
+          * {@link #zoomMapPaneMouseListener} is also enabled.
-         GeometryFactory gf = new GeometryFactory(); // FactoryFinder.getGeometryFactory(null);
+          **/
+         private int state = ZOOM_IN;
-         private int state = ZoomIn;
          /**
-          * how far to zoom in or out
+          * Konvertiert die Maus-Koordinaten (relativ zum <code>JMapPane</code>) in
+          * Karten-Koordinaten.
+          *
+          * @param e
+          *            Maus-Ereignis
           */
-         private double zoomFactor = 2.0;
+         public static Point2D getMapCoordinatesFromEvent(MouseEvent e) {
+                 // aktuelle Geo-Position aus GeoMouseEvent ermitteln
-         boolean changed = true;
+                 if (e != null && e instanceof MapMouseEvent)
+                         try {
+                                 return ((MapMouseEvent) e).getMapPosition().toPoint2D();
+                         } catch (Exception err) {
+                                 LOGGER
+                                                 .error(
+                                                                 "return ((GeoMouseEvent) e).getMapCoordinate(null).toPoint2D();",
+                                                                 err);
+                         }
-         LabelCache labelCache = new LabelCacheImpl();
+                 // aktuelle Geo-Position ueber Transformation des JMapPane berechnen
+                 if (e != null && e.getSource() instanceof XMapPane) {
-         // xulu.sc
+                         final XMapPane xMapPane = (XMapPane) e.getSource();
-         // private boolean reset = false;
-         protected boolean reset = false;
-         // xulu.ec
-         int startX;
+                         if (!xMapPane.isWellDefined())
+                                 return null;
-         int startY;
+                         AffineTransform at = xMapPane.getScreenToWorld();
+                         if (at != null)
+                                 return at.transform(e.getPoint(), null);
+                         return null;
+                 }
+                 throw new IllegalArgumentException(
+                                 "MouseEvent has to be of instance MapMouseEvent or come from an XMapPane");
+         }
-         private boolean clickable;
+         /**
+          * A flag indicating that the shown image is invalid and needs to be
+          * re-rendered.
+          */
+         protected boolean mapImageInvalid = true;
-         int lastX;
+         protected LabelCache labelCache = new LabelCacheImpl();
-         int lastY;
+         /**
+          * If not <code>null</code>, the {@link XMapPane} will not allow to zoom/pan
+          * out of that area
+          **/
+         private Envelope maxExtend = null;
-         // 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
+          * This color is used as the default background color when painting a map.
-          * Flag wird benutzt um nur einmal den passenden Cursor nur einmal zu
+          */
-          * setzen.
+         private Color mapBackgroundColor = Color.WHITE;
+         /**
+          * This {@link MouseListener} is managing all zoom related tasks
+          */
+         public final ZoomXMapPaneMouseListener zoomMapPaneMouseListener = new ZoomXMapPaneMouseListener(
+                         this);
+         /**
+          * A flag indicating, that the image size has changed and the buffered
+          * images are not big enough any more
+          **/
+         protected boolean paneResized = false;
+         /**
+          * The flag {@link #requestStartRendering} can be set to true by events.
+          * This {@link Timer} checks the flag regularly and starts one renderer
+          * thread.
           */
-         private boolean panning_started = false;
+         final private Timer startRenderThreadsTimer;
-         // sk.en
+         private Map<Object, Object> rendererHints;
-         public JMapPane() {
+         public Map<Object, Object> getRendererHints() {
-                 this(null, true, null, null);
+                 return rendererHints;
          }
          /**
-          * create a basic JMapPane
+          * Nuetzlich wenn die Componente gedruckt (z.B. wenn ein Screenshot gemacht
+          * wird) wird. Dann werden wird der Hintergrund auf WEISS gesetzt.
           *
-          * @param render
+          * @author <a href="mailto:[email protected]">Stefan Alfons
-          *            - how to draw the map
+          *         Kr&uuml;ger</a>
-          * @param context
-          *            - the map context to display
           */
-         public JMapPane(final GTRenderer render, final MapContext context) {
+         @Override
-                 this(null, true, render, context);
+         public void print(Graphics g) {
+                 Color orig = getBackground();
+                 setBackground(Color.WHITE);
+                 // wrap in try/finally so that we always restore the state
+                 try {
+                         super.print(g);
+                 } finally {
+                         setBackground(orig);
+                 }
          }
          /**
           * full constructor extending JPanel
           *
+          * @param rendererHints
+          *
           * @param layout
           *            - layout (probably shouldn't be set)
           * @param isDoubleBuffered
           *            - a Swing thing I don't really understand
           * @param render
           *            - what to draw the map with
-          * @param context
+          * @param localContext
-          *            - what to draw
+          *            - {@link MapContext} of layer to render.
           */
-         public JMapPane(final LayoutManager layout, final boolean isDoubleBuffered,
+         public XMapPane(final MapContext localContext,
-                         final GTRenderer render, final MapContext context) {
+                         Map<Object, Object> rendererHints) {
-                 super(layout, isDoubleBuffered);
+                 super(true);
+                 setRendererHints(rendererHints);
+                 setOpaque(true);
-                 ff = (FilterFactory2) org.geotools.factory.CommonFactoryFinder
+                 setLocalContext(localContext);
-                                 .getFilterFactory(null);
-                 setRenderer(render);
-                 setContext(context);
+                 /**
+                  * Adding the #zoomMapPaneMouseListener
+                  */
+                 this.addMouseListener(zoomMapPaneMouseListener);
+                 this.addMouseMotionListener(zoomMapPaneMouseListener);
+                 this.addMouseWheelListener(zoomMapPaneMouseListener);
+                 /*
+                  * We use a Timer object to avoid rendering delays and flickering when
+                  * the user is drag-resizing the parent container of this map pane.
+                  *
+                  * Using a ComponentListener doesn't work because, unlike a JFrame, the
+                  * pane receives a stream of events during drag-resizing.
+                  */
+                 resizingPaintDelay = DEFAULT_RESIZING_PAINT_DELAY;
+                 resizeTimer = new Timer(resizingPaintDelay, new ActionListener() {
+                         public void actionPerformed(ActionEvent e) {
+                                 paneResized = true;
+                                 if (!isWellDefined())
+                                         return;
+                                 Rectangle bounds = getVisibleRect();
+                                 Envelope geoMapArea = tranformWindowToGeo(bounds.x, bounds.y,
+                                                 bounds.x + bounds.width, bounds.y + bounds.height);
+                                 setMapArea(bestAllowedMapArea(geoMapArea));
+                         }
+                 });
+                 resizeTimer.setRepeats(false);
+                 this.addComponentListener(new ComponentAdapter() {
+                         @Override
+                         public void componentResized(ComponentEvent e) {
+                                 if (bgExecuter != null)
+                                         bgExecuter.cancelTask();
+                                 if (localExecuter != null)
+                                         localExecuter.cancelTask();
+                                 resizeTimer.restart();
+                         }
+                 });
+ //              repainterTimer = new Timer((int) REPEATING_REPAINT_DELAY,
+ //                              new ActionListener() {
+ //
+ //                                      @Override
+ //                                      public void actionPerformed(ActionEvent e) {
+ //                                              updateFinalImage();
+ //                                              XMapPane.this.repaint();
+ //                                      }
+ //                              });
+ //              repainterTimer.setInitialDelay(300);
+ //              repainterTimer.setRepeats(true);
+                 startRenderThreadsTimer = new Timer(200, new ActionListener() {
+                         @Override
+                         public void actionPerformed(ActionEvent e) {
+                                 synchronized (requestStartRendering) {
+                                         if (requestStartRendering && isValid())
+                                                 startRendering();
+                                         requestStartRendering = false;
+                                 }
+                         }
+                 });
+                 startRenderThreadsTimer.start();
-                 this.addMouseListener(this);
+         }
-                 this.addMouseMotionListener(this);
-                 setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
+         // TODO doku
+         public XMapPane() {
+                 this(null, null);
          }
          /**
-          * get the renderer
+          * Sets the mapArea to best possibly present the given features. If only one
+          * single point is given, the window is moved over the point.
+          *
+          * Note: The method does not call {@link #repaint()} on the
+          * {@link SelectableXMapPane} .
+          *
+          * @param features
+          *            if <code>null</code> or size==0, the function doesn nothing.
           */
-         public GTRenderer getRenderer() {
+         public void zoomTo(
-                 return renderer;
+                         FeatureCollection<SimpleFeatureType, SimpleFeature> features) {
-         }
-         public void setRenderer(final GTRenderer renderer) {
+                 CoordinateReferenceSystem mapCRS = getContext()
-                 Map hints = new HashMap();
+                                 .getCoordinateReferenceSystem();
+                 CoordinateReferenceSystem fCRS = features.getSchema()
-                 this.renderer = renderer;
+                                 .getGeometryDescriptor().getCoordinateReferenceSystem();
-                 if (renderer instanceof StreamingRenderer || renderer instanceof TransitionShapefileRenderer) {
+                 double width = mapArea.getWidth();
-                         hints = renderer.getRendererHints();
+                 double height = mapArea.getHeight();
-                         if (hints == null) {
+                 double ratio = height / width;
-                                 hints = new HashMap();
-                         }
+                 if (features == null || features.size() == 0) {
-                         if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {
+                         // feature count == 0 Zoom to the full extend
-                                 labelCache = (LabelCache) hints
+                         return;
-                                                 .get(StreamingRenderer.LABEL_CACHE_KEY);
+                 } else if (features.size() == 1) {
+                         // feature count == 1 Just move the window to the point and zoom 'a
+                         // bit'
+                         SimpleFeature singleFeature = (SimpleFeature) features.iterator()
+                                         .next();
+                         if (((Geometry) singleFeature.getDefaultGeometry())
+                                         .getCoordinates().length > 1) {
+                                 // System.out.println("Zoomed to only pne poylgon");
+                                 // Poly
+                                 // TODO max width vs. height
+                                 width = features.getBounds().getWidth() * 3;
+                                 height = ratio * width;
                          } else {
-                                 hints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);
+                                 // System.out.println("Zoomed in a bit becasue only one point");
+                                 // width *= .9;
+                                 // height *= .9;
                          }
-                         hints.put("memoryPreloadingEnabled", Boolean.TRUE);
+                         Coordinate centre = features.getBounds().centre();
+                         if (!mapCRS.equals(fCRS)) {
-                         renderer.setRendererHints(hints);
+                                 // only to calculations if the CRS differ
-                 }
+                                 try {
+                                         MathTransform fToMap;
+                                         fToMap = CRS.findMathTransform(fCRS, mapCRS);
+                                         // centre is transformed to the mapCRS
+                                         centre = JTS.transform(centre, null, fToMap);
+                                 } catch (FactoryException e) {
+                                         LOGGER.error("Looking for a Math transform", e);
+                                 } catch (TransformException e) {
+                                         LOGGER.error("Looking for a Math transform", e);
+                                 }
+                         }
- //              this.highlightRenderer = new StreamingRenderer();
+                         Coordinate newLeftBottom = new Coordinate(centre.x - width / 2.,
- //              this.selectionRenderer = new StreamingRenderer();
+                                         centre.y - height / 2.);
+                         Coordinate newTopRight = new Coordinate(centre.x + width / 2.,
+                                         centre.y + height / 2.);
- //              highlightRenderer.setRendererHints(hints);
+                         Envelope newMapArea = new Envelope(newLeftBottom, newTopRight);
- //              selectionRenderer.setRendererHints(hints);
+                         setMapArea(newMapArea);
- //              renderer.setRendererHints(hints);
+                 } else {
+                         ReferencedEnvelope fBounds = features.getBounds();
+                         Envelope bounds;
+                         if (!mapCRS.equals(fCRS)) {
+                                 bounds = JTSUtil.transformEnvelope(fBounds, fCRS, mapCRS);
+                         } else {
+                                 bounds = fBounds;
+                         }
+                         // BB umrechnen von Layer-CRS in Map-CRS
+                         // Expand a bit
+                         bounds.expandBy(bounds.getWidth() / 6., bounds.getHeight() / 6.);
-                 if (this.context != null) {
+                         setMapArea(bounds);
-                         this.renderer.setContext(this.context);
                  }
          }
-         public MapContext getContext() {
+         private void setRendererHints(Map<Object, Object> rendererHints) {
-                 return context;
+                 this.rendererHints = rendererHints;
          }
-         public void setContext(final MapContext context) {
+         /**
-                 if (this.context != null) {
+          * Return <code>true</code> if a CRS and a {@link #mapArea} are set and the
-                         this.context.removeMapLayerListListener(this);
+          * {@link XMapPane} is visible and has bounds set.
+          */
+         public boolean isWellDefined() {
+                 try {
+                         if (getContext() == null)
+                                 return false;
+                         if (getContext().getLayerCount() <= 0)
+                                 return false;
+                         if (getMapArea() == null)
+                                 return false;
+                         if (getBounds().getWidth() == 0)
+                                 return false;
+                         if (getBounds().getHeight() == 0)
+                                 return false;
+                 } catch (Exception e) {
+                         return false;
                  }
+                 return true;
+         }
-                 this.context = context;
+         /**
+          * Default delay (milliseconds) before the map will be redrawn when resizing
+          * the pane. This is to avoid flickering while drag-resizing.
+          */
+         public static final int DEFAULT_RESIZING_PAINT_DELAY = 500; // delay in
+         // milliseconds
-                 if (context != null) {
+         private Timer resizeTimer;
-                         this.context.addMapLayerListListener(this);
+         private int resizingPaintDelay;
+         /**
+          * We store the old transform for a moment to use it for the
+          * "quick scaled preview" in case of ZoomIn
+          **/
+         protected AffineTransform oldScreenToWorld = null;
+         /**
+          * Manuell gesetzter statischer Cursor, unabhaengig von der aktuellen
+          * MapPane-Funktion
+          */
+         protected Cursor staticCursor = null;
+         /**
+          * Standardmaessig wird der Cursor automatisch je nach MapPane-Aktion (Zoom,
+          * Auswahl, ...) gesetzt. Mit dieser Methode kann ein statischer Cursor
+          * gesetzt werden, der unabhaengig von der aktuellen MapPanes-Aktion
+          * beibehalten wird. Um diesen statischen Cursor wieder zu entfernen, kann
+          * {@code null} als Parameter uebergeben werden
+          *
+          * @param cursor
+          *            Cursor
+          */
+         public void setStaticCursor(Cursor cursor) {
+                 this.staticCursor = cursor;
+                 if (cursor != null)
+                         super.setCursor(cursor);
+         }
+         /**
+          * Liefert den statisch eingestellten Cursor, der unabhaengig von der
+          * eingestellten MapPane-Aktion (Zoom, Auswahl, ...) verwendet wird.
+          *
+          * @return {@code null}, wenn kein statischer Cursor verwendet, sondern der
+          *         Cursor automatisch je nach MapPane-Aktion eingestellt wird.
+          */
+         public Cursor getStaticCursor() {
+                 return this.staticCursor;
+         }
+         /**
+          * Abhaengig von selState wird der Cursor gesetzt
+          */
+         public void updateCursor() {
+                 if (bgExecuter != null && bgExecuter.isRunning()
+                                 || localExecuter != null && localExecuter.isRunning()) {
+                         setCursor(WAIT_CURSOR);
+                         return;
+                 } else {
+ //                      // Allow one last rendering
+ //                      if (repainterTimer.isRunning()) {
+ //                              repainterTimer.stop();
+ //                              updateFinalImage();
+ //                              repaint();
+ //                      }
                  }
-                 if (renderer != null) {
+                 // wenn manueller Cursor gesetzt ist, dann diesen verwenden (unabhaengig
-                         renderer.setContext(this.context);
+                 // von der aktuellen Aktion
+                 if (this.staticCursor != null) {
+                         setCursor(staticCursor);
+                         return;
+                 }
+                 if (getCursor() == SwingUtil.PANNING_CURSOR) {
+                         // This cursor will reset itself
+                         return;
                  }
-         }
-         public Envelope getMapArea() {
+                 // Je nach Aktion den Cursor umsetzen
-                 return mapArea;
+                 switch (state) {
+                 case SELECT_TOP:
+                 case SELECT_ONE_FROM_TOP:
+                 case SELECT_ALL:
+                         setCursor(SwingUtil.CROSSHAIR_CURSOR);
+                         break;
+                 case ZOOM_IN:
+                         setCursor(SwingUtil.ZOOMIN_CURSOR);
+                         break;
+                 case ZOOM_OUT:
+                         setCursor(SwingUtil.ZOOMOUT_CURSOR);
+                         break;
+                 case PAN:
+                         setCursor(SwingUtil.PAN_CURSOR);
+                         break;
+                 default:
+                         setCursor(normalCursor);
+                         break;
+                 }
          }
-         public void setMapArea(final Envelope mapArea) {
+         //
-                 this.mapArea = mapArea;
+         // /**
+         // * Gibt den "normalen" Cursor zurueck. Dieser kann neben dem "pointer"
+         // auch
+         // * ein Sanduhr-Wartecursor sein.
+         // *
+         // * @author <a href="mailto:[email protected]">Stefan Alfons
+         // * Kr&uuml;ger</a>
+         // */
+         // public Cursor getNormalCursor() {
+         // return normalCursor;
+         // }
+         //
+         // /**
+         // * Setzt den "normalen" Cursor. Dieser kann neben dem default "pointer"
+         // z.B.
+         // * auch ein Sanduhr-Wartecursor sein.
+         // *
+         // * @author <a href="mailto:[email protected]">Stefan Alfons
+         // * Kr&uuml;ger</a>
+         // */
+         // public void setNormalCursor(Cursor normalCursor) {
+         // this.normalCursor = normalCursor;
+         // }
+         /**
+          * Berechnet die Transformation zwischen Fenster- und Karten-Koordinaten
+          * neu.
+          */
+         protected void resetTransforms() {
+                 if (getMapArea() == null || getWidth() == 0 || getHeight() == 0)
+                         return;
+                 // We store the last Transform
+                 oldScreenToWorld = screenToWorld;
+                 this.screenToWorld = new AffineTransform(
+                 // Genauso wie die Fenster-Koordinaten, werden die Longitude-Koordinaten
+                                 // nach rechts (Osten) hin groesser
+                                 // --> positive Verschiebung
+                                 getMapArea().getWidth() / getWidth(),
+                                 // keine Verzerrung
+.0, 0.0,
+                                 // Waehrend die Fenster-Koordinaten nach unten hin groesser
+                                 // werden,
+                                 // werden Latitude-Koordinaten nach Sueden hin keiner
+                                 // --> negative Verschiebung
+                                 -getMapArea().getHeight() / getHeight(),
+                                 // Die Longitude-Koordinaten werden nach Osten hin groesser
+                                 // --> obere linke Ecke des Fensters hat also den Minimalwert
+                                 getMapArea().getMinX(),
+                                 // Die Latitude-Koordinaten werden nach Norden hin groesser
+                                 // --> obere linke Ecke des Fensters hat also den Maximalwert
+                                 getMapArea().getMaxY());
+                 try {
+                         this.worldToScreen = screenToWorld.createInverse();
+                 } catch (NoninvertibleTransformException e) {
+                         LOGGER.error(e);
+                 }
          }
-         public int getState() {
+         /**
-                 return state;
+          * Transformation zwischen Fenster-Koordinaten und Karten-Koordinaten
+          * (lat/lon)
+          */
+         protected AffineTransform screenToWorld = null;
+         private AffineTransform worldToScreen;
+         /**
+          * Listens to changes of the "local" {@link MapContext} and triggers
+          * repaints where needed.
+          */
+         private MapLayerListListener localContextListener = new MapLayerListListener() {
+                 @Override
+                 public void layerAdded(final MapLayerListEvent event) {
+                         event.getLayer().addMapLayerListener(localMapLayerListener);
+                         if (localContext.getLayers().length == 1) { // the first one
+                                 // if the Area of Interest is unset, the LayerBounds are used
+                                 if (!setMapArea(localContext.getAreaOfInterest()))
+                                         repaint();
+                                 return;
+                         }
+                         // We need to redraw, even in case that the mapArea didn't change
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerRemoved(final MapLayerListEvent event) {
+                         if (event.getLayer() != null)
+                                 event.getLayer().removeMapLayerListener(localMapLayerListener);
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerChanged(final MapLayerListEvent event) {
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerMoved(final MapLayerListEvent event) {
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+         };
+         /**
+          * Listens to changes of the "background" {@link MapContext} and triggers
+          * repaints where needed.
+          */
+         private MapLayerListListener bgContextListener = new MapLayerListListener() {
+                 @Override
+                 public void layerAdded(final MapLayerListEvent event) {
+                         event.getLayer().addMapLayerListener(bgMapLayerListener);
+                         if (localContext.getLayers().length == 0
+                                         && bgContext.getLayers().length == 1) { // the first one and
+                                 // localContext is
+                                 // empty
+                                 if (!setMapArea(localContext.getAreaOfInterest()))
+                                         requestStartRendering();
+                                 return;
+                         }
+                         // We need to redraw, even in case that the mapArea didn't change
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerRemoved(final MapLayerListEvent event) {
+                         if (event.getLayer() != null)
+                                 event.getLayer().removeMapLayerListener(bgMapLayerListener);
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerChanged(final MapLayerListEvent event) {
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerMoved(final MapLayerListEvent event) {
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+         };
+         /**
+          * Listens to each layer in the local {@link MapContext} for changes and
+          * triggers repaints.
+          */
+         protected MapLayerListener localMapLayerListener = new MapLayerAdapter() {
+                 @Override
+                 public void layerShown(MapLayerEvent event) {
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerHidden(MapLayerEvent event) {
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerChanged(MapLayerEvent event) {
+                         // Change of SLD for example
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+         };
+         /**
+          * Listens to each layer in the local {@link MapContext} for changes and
+          * triggers repaints.
+          */
+         protected MapLayerListener bgMapLayerListener = new MapLayerAdapter() {
+                 @Override
+                 public void layerShown(MapLayerEvent event) {
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerHidden(MapLayerEvent event) {
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+                 @Override
+                 public void layerChanged(MapLayerEvent event) {
+                         // Change of SLD for example
+                         // mapImageInvalid = true;
+                         // repaint();
+                         requestStartRendering();
+                 }
+         };
+         /**
+          * Liefert eine affine Transformation, um von den Fenster-Koordinaten in die
+          * Karten-Koordinaten (Lat/Lon) umzurechnen.
+          *
+          * @return eine Kopie der aktuellen Transformation; <code>null</code> wenn
+          *         noch keine Karte angezeigt wird
+          */
+         public AffineTransform getScreenToWorld() {
+                 if (screenToWorld == null)
+                         resetTransforms();
+                 // nur Kopie der Transformation zurueckgeben!
+                 if (screenToWorld == null)
+                         return null;
+                 return new AffineTransform(screenToWorld);
          }
-         public void setState(final int state) {
+         public AffineTransform getWorldToScreenTransform() {
-                 this.state = state;
+                 if (worldToScreen == null) {
+                         resetTransforms();
+                 }
+                 // nur Kopie der Transformation zurueckgeben!
+                 return new AffineTransform(worldToScreen);
+         }
-                 // System.out.println("State: " + state);
+         public MapContext getContext() {
+                 if (localContext == null) {
+                         this.localContext = new DefaultMapContext();
+                         this.localContext.addMapLayerListListener(localContextListener);
+                 }
+                 return localContext;
          }
-         public double getZoomFactor() {
+         public MapContext getBgContext() {
-                 return zoomFactor;
+                 return bgContext;
          }
-         public void setZoomFactor(final double zoomFactor) {
+         /**
-                 this.zoomFactor = zoomFactor;
+          *
+          * @param context
+          */
+         public void setLocalContext(final MapContext context) {
+                 // Remove the default listener from the old context
+                 if (this.localContext != null) {
+                         this.localContext.removeMapLayerListListener(localContextListener);
+                         // adding listener to all layers
+                         for (MapLayer mapLayer : localContext.getLayers()) {
+                                 mapLayer.removeMapLayerListener(localMapLayerListener);
+                         }
+                 }
+                 this.localContext = context;
+                 if (context != null) {
+                         setMapArea(localContext.getAreaOfInterest());
+                         this.localContext.addMapLayerListListener(localContextListener);
+                         // adding listener to all layers
+                         for (MapLayer mapLayer : localContext.getLayers()) {
+                                 mapLayer.addMapLayerListener(localMapLayerListener);
+                         }
+                 }
+                 mapImageInvalid = true;
+                 repaint();
          }
+         public void setBgContext(final MapContext context) {
-         protected void paintComponent(final Graphics g) {
+                 // Remove the default listener from the old context
-                 super.paintComponent(g);
+                 if (this.bgContext != null) {
+                         this.bgContext.removeMapLayerListListener(bgContextListener);
+                         // adding listener to all layers
+                         for (MapLayer mapLayer : bgContext.getLayers()) {
+                                 mapLayer.removeMapLayerListener(bgMapLayerListener);
+                         }
+                 }
-                 if ((renderer == null) || (mapArea == null)) {
+                 this.bgContext = context;
-                         return;
+                 if (context != null) {
+                         setMapArea(bgContext.getAreaOfInterest());
+                         this.bgContext.addMapLayerListListener(bgContextListener);
+                         // adding listener to all layers
+                         for (MapLayer mapLayer : bgContext.getLayers()) {
+                                 mapLayer.addMapLayerListener(bgMapLayerListener);
+                         }
                  }
+                 mapImageInvalid = true;
+                 repaint();
+         }
-                 final Rectangle r = getBounds();
+         /**
-                 final Rectangle dr = new Rectangle(r.width, r.height);
+          * Returns a copy of the mapArea
+          *
+          * @return
+          */
+         public Envelope getMapArea() {
+                 if (mapArea == null) {
+                         final Rectangle paneBounds = getBounds();
-                 if (!r.equals(oldRect) || reset) {
+                         try {
-                         if (!r.equals(oldRect) && (mapArea == null)) {
+                                 mapArea = localContext.getLayerBounds();
-                                 try {
+                         } catch (final IOException e) {
-                                         mapArea = context.getLayerBounds();
+                                 LOGGER.warn("context.getLayerBounds()", e);
-                                 } catch (final IOException e) {
-                                         LOGGER.warn("context.getLayerBounds()", e);
-                                 }
                          }
                          if (mapArea != null) {
                                  /* either the viewer size has changed or we've done a reset */
-                                 changed = true; /* note we need to redraw */
+                                 mapImageInvalid = true; /* note we need to redraw */
-                                 reset = false; /* forget about the reset */
+                                 oldRect = paneBounds; /* store what the current size is */
-                                 oldRect = r; /* store what the current size is */
+                                 mapArea = bestAllowedMapArea(mapArea);
-                                 mapArea = fixAspectRatio(r, mapArea);
                          }
                  }
-                 if (!mapArea.equals(oldMapArea)) { /* did the map extent change? */
+                 if (mapArea == null)
-                         changed = true;
+                         return null;
-                         oldMapArea = mapArea;
-                         // when we tell the context that the bounds have changed WMSLayers
+                 return new Envelope(mapArea);
-                         // can refresh them selves
+         }
-                         context.setAreaOfInterest(mapArea, context
-                                         .getCoordinateReferenceSystem());
+         /**
+          * @param newMapArea
+          * @return <code>true</code> if the mapArea has been changed and a repaint
+          *         has been triggered.
+          */
+         public boolean setMapArea(final Envelope newMapArea) {
+                 if (newMapArea == null
+                                 || bestAllowedMapArea(newMapArea).equals(mapArea)) {
+                         // No change.. no need to repaint
+                         return false;
+                 }
+                 // Testing, whether NaN or Infinity are used in the newMapArea
+                 if (newMapArea.isNull() || Double.isInfinite(newMapArea.getMaxX())
+                                 || Double.isInfinite(newMapArea.getMaxY())
+                                 || Double.isInfinite(newMapArea.getMinX())
+                                 || Double.isInfinite(newMapArea.getMinY())) {
+                         // No change.. ugly new values
+                         LOGGER.warn("setMapArea has been called with newArea = "
+                                         + newMapArea);
+                         return false;
                  }
-                 if (changed ) { /* if the map changed then redraw */
+                 // Testing, whether the difference if just minimal
-                         changed = false;
+                 if (mapArea != null) {
-                         baseImage = new BufferedImage(dr.width, dr.height,
+                         Envelope candNew = bestAllowedMapArea(newMapArea);
-                                         BufferedImage.TYPE_INT_ARGB);
+                         double tolX = mapArea.getWidth() / 1000.;
+                         double tolY = mapArea.getHeight() / 1000.;
+                         if ((candNew.getMinX() - tolX < mapArea.getMinX())
+                                         && (mapArea.getMinX() < candNew.getMinX() + tolX)
+                                         && (candNew.getMaxX() - tolX < mapArea.getMaxX())
+                                         && (mapArea.getMaxX() < candNew.getMaxX() + tolX)
+                                         && (candNew.getMinY() - tolY < mapArea.getMinY())
+                                         && (mapArea.getMinY() < candNew.getMinY() + tolY)
+                                         && (candNew.getMaxY() - tolY < mapArea.getMaxY())
+                                         && (mapArea.getMaxY() < candNew.getMaxY() + tolY)
-                         final Graphics2D ig = baseImage.createGraphics();
+                         ) {
-                         /* System.out.println("rendering"); */
+                                 // The two mapAreas only differ my 1/1000th.. ignore
-                         if (renderer.getContext() != null)
-                                 renderer.setContext(context);
-                         labelCache.clear(); // work around anoying labelcache bug
-                         // draw the map
+                                 return false;
-                         renderer.paint((Graphics2D) ig, dr, mapArea);
+                         }
+                 }
-                         // TODO nur machen, wenn panning beginnt
+                 oldMapArea = mapArea;
-                         panningImage = new BufferedImage(dr.width, dr.height,
-                                         BufferedImage.TYPE_INT_RGB);
+                 this.mapArea = bestAllowedMapArea(newMapArea);
+                 if (localContext != null) {
+                         localContext.setAreaOfInterest(mapArea, localContext
+                                         .getCoordinateReferenceSystem());
                  }
+                 if (bgContext != null) {
+                         bgContext.setAreaOfInterest(mapArea, localContext
+                                         .getCoordinateReferenceSystem());
+                 }
+                 resetTransforms();
+                 mapImageInvalid = true;
+                 mapAreaChanged = true;
+                 repaint();
-                 ((Graphics2D) g).drawImage(baseImage, 0, 0, this);
+ //              LOGGER.debug("New maparea = " + mapArea);
+                 return true;
          }
-         private Envelope fixAspectRatio(final Rectangle r, final Envelope mapArea) {
+         public int getState() {
+                 return state;
+         }
-                 final double mapWidth = mapArea.getWidth(); /* get the extent of the map */
+         /**
-                 final double mapHeight = mapArea.getHeight();
+          * Enables/Disables the ZOOM Mouse Listener. Upates the Cursor and stops the
-                 final double scaleX = r.getWidth() / mapArea.getWidth(); /*
+          * repaint Timer if
-                                                                                                                          * calculate the new
+          *
-                                                                                                                          * scale
+          * @param state
-                                                                                                                          */
+          */
+         public void setState(final int state) {
+                 this.state = state;
-                 final double scaleY = r.getHeight() / mapArea.getHeight();
+                 zoomMapPaneMouseListener.setEnabled((state == ZOOM_IN
-                 double scale = 1.0; // stupid compiler!
+                                 || state == ZOOM_OUT || state == PAN));
-                 if (scaleX < scaleY) { /* pick the smaller scale */
+                 // Je nach Aktion den Cursor umsetzen
-                         scale = scaleX;
+                 updateCursor();
-                 } else {
+         }
-                         scale = scaleY;
-                 }
-                 /* calculate the difference in width and height of the new extent */
+         /** Cursor wenn kein Mausbutton gedrueckt wird. default oder SwingUtil.PAN **/
-                 final double deltaX = /* Math.abs */((r.getWidth() / scale) - mapWidth);
+         protected static Cursor normalCursor = Cursor
-                 final double deltaY = /* Math.abs */((r.getHeight() / scale) - mapHeight);
+                         .getPredefinedCursor(Cursor.DEFAULT_CURSOR);
-                 /*
+         public static final Cursor WAIT_CURSOR = Cursor
-                  * System.out.println("delta x " + deltaX);
+                         .getPredefinedCursor(Cursor.WAIT_CURSOR);
-                  * System.out.println("delta y " + deltaY);
-                  */
-                 /* create the new extent */
+         public static final int NONE = -123;
-                 final Coordinate ll = new Coordinate(mapArea.getMinX() - (deltaX / 2.0),
-                                 mapArea.getMinY() - (deltaY / 2.0));
-                 final Coordinate ur = new Coordinate(mapArea.getMaxX() + (deltaX / 2.0),
-                                 mapArea.getMaxY() + (deltaY / 2.0));
-                 return new Envelope(ll, ur);
+         private RenderingExecutor localExecuter;
-         }
- //      public void doSelection(final double x, final double y, final MapLayer layer) {
+         private BufferedImage finalImage;
- //
- //              final 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(final Geometry geometry, final MapLayer layer)
- //                      throws IndexOutOfBoundsException {
- //              org.opengis.filter.spatial.BinarySpatialOperator f = null;
- //
- //              if ((context == null) || (layer == null)) {
- //                      return;
- //              }
- //
- //              try {
- //                      String name = layer.getFeatureSource().getSchema()
- //                                      .getDefaultGeometry().getLocalName();
- //
- //                      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 (final 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()) { SimpleFeature feat
- //                       * = (SimpleFeature) fi.next(); System.out.println("selected " +
- //                       * feat.getAttribute("STATE_NAME")); }
- //                       */
- //              } catch (final IllegalFilterException e) {
- //                      // TODO Auto-generated catch block
- //                      e.printStackTrace();
- //              }
- //              return;
- //      }
-         public void mouseClicked(final MouseEvent e) {
-                 if (mapArea == null) return;
-                 // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"
-                 // h:"+mapArea.getHeight());
-                 final Rectangle bounds = this.getBounds();
-                 final double x = (double) (e.getX());
-                 final double y = (double) (e.getY());
-                 final double width = mapArea.getWidth();
-                 final double height = mapArea.getHeight();
-                 // xulu.sc
-                 // double width2 = mapArea.getWidth() / 2.0;
-                 // double height2 = mapArea.getHeight() / 2.0;
-                 final double width2 = width / 2.0;
-                 final double height2 = height / 2.0;
-                 // xulu.ec
-                 final double mapX = ((x * width) / (double) bounds.width) + mapArea.getMinX();
-                 final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)
-                                 + mapArea.getMinY();
-                 /*
+         /**
-                  * System.out.println(""+x+"->"+mapX);
+          * A flag set it {@link #setMapArea(Envelope)} to indicated the
-                  * System.out.println(""+y+"->"+mapY);
+          * {@link #paintComponent(Graphics)} method, that the image on-screen is
-                  */
+          * associated with {@link #oldMapArea} and may hence be scaled for a quick
+          * preview.<br/>
+          * The flag is reset
+          **/
+         private boolean mapAreaChanged = false;
-                 /*
+         private JFrame finalImageFrame;
-                  * Coordinate ll = new Coordinate(mapArea.getMinX(), mapArea.getMinY());
-                  * Coordinate ur = new Coordinate(mapArea.getMaxX(), mapArea.getMaxY());
-                  */
-                 double zlevel = 1.0;
-                 switch (state) {
+         private volatile Boolean requestStartRendering = false;
-                 case Pan:
+         private BufferedImage preFinalImage;
-                         zlevel = 1.0;
-                         // xulu.sc SK: return here.. a mouselistener is managing the PANNING
+         protected void paintComponent(final Graphics g) {
-                         // break;
+                 // Maybe update the cursor
+                 updateCursor();
+                 if (!acceptsRepaintCalls)
                          return;
-                         // xulu.ec
-                 case ZoomIn:
-                         zlevel = zoomFactor;
-                         break;
+                 boolean paintedSomething = false;
-                 case ZoomOut:
+                 if (mapImageInvalid) { /* if the map changed then redraw */
-                         zlevel = 1.0 / zoomFactor;
-                         break;
+                         mapImageInvalid = false; // Reset for next round
- //
- //              case Select:
+                         // If the new mapArea and the oldMapArea intersect, we can draw some
- //                      doSelection(mapX, mapY, selectionLayer);
+                         // quick scaled preview to make the user feel that something is
- //
+                         // happening.
- //                      return;
+                         if (mapAreaChanged && oldMapArea != null
+                                         && getMapArea().intersects(oldMapArea)
+                                         & !getMapArea().equals(oldMapArea)) {
+                                 mapAreaChanged = false;
+                                 if (getMapArea().covers(oldMapArea)) {
+                                         setQuickPreviewHint(ZOOM_OUT);
+                                         paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
+                                 } else if (oldMapArea.covers(getMapArea())) {
+                                         setQuickPreviewHint(ZOOM_IN);
+                                         paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
+                                 }
+                         }
+                         if (paneResized) {
+                                 paneResized = false;
+                                 preFinalImage = null;
+                                 finalImage = null;
+                                 localImage = null;
+                                 bgImage = null;
+                                 // gadgetsImage = null;
+                         }
+                         // Start the Threads and Timers to render the image
+                         requestStartRendering();
-                 default:
-                         return;
                  }
-                 final Coordinate ll = new Coordinate(mapX - (width2 / zlevel), mapY
+                 if (!paintedSomething) {
-                                 - (height2 / zlevel));
-                 final 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
-                 // sk.ec
+                         // TODO Should just paint the getFinalImage(). Update should be
+                         // called by timer every 300ms, and the repaint() until all threads
+                         // are done.
+                         g.drawImage(getFinalImage(), 0, 0, this);
+                         paintedSomething = true;
+                 }
-                 // System.out.println("after area "+mapArea+"\nw:"+mapArea.getWidth()+"
-                 // h:"+mapArea.getHeight());
-                 repaint();
          }
-         public void mouseEntered(final MouseEvent e) {
+         /**
+          * Cancels all running renderers and sets the flag to start new ones. <br/>
+          *
+          * @see #startRenderThreadsTimer
+          */
+         private void requestStartRendering() {
+                 if (bgExecuter != null)
+                         bgExecuter.cancelTask();
+                 if (localExecuter != null)
+                         localExecuter.cancelTask();
+                 requestStartRendering = true;
          }
-         public void mouseExited(final MouseEvent e) {
+         /**
+          * Transformiert einen Fenster-Koordinaten-Bereich in Geo-Koordinaten.
+          *
+          * @param ox
+          *            X-Koordinate der VON-Position
+          * @param oy
+          *            Y-Koordinate der VON-Position
+          * @param px
+          *            X-Koordinate der BIS-Position
+          * @param py
+          *            Y-Koordinate der BIS-Position
+          */
+         public Envelope tranformWindowToGeo(int ox, int oy, int px, int py) {
+                 AffineTransform at = getScreenToWorld();
+                 Point2D geoO = at.transform(new Point2D.Double(ox, oy), null);
+                 Point2D geoP = at.transform(new Point2D.Double(px, py), null);
+                 return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP.getY());
          }
-         public void mousePressed(final MouseEvent e) {
+         /**
-                 startX = e.getX();
+          * Transformiert einen Geo-Koordinaten-Bereich in Fenster-Koordinaten.
-                 startY = e.getY();
+          *
-                 lastX = 0;
+          * @param ox
-                 lastY = 0;
+          *            X-Koordinate der VON-Position
+          * @param oy
+          *            Y-Koordinate der VON-Position
+          * @param px
+          *            X-Koordinate der BIS-Position
+          * @param py
+          *            Y-Koordinate der BIS-Position
+          * @param winToGeotransform
+          *            Eine Window to Geo transform. If <code>null</code>,
+          *            {@link #getScreenToWorld()} is used.
+          */
+         public Envelope tranformGeoToWindow(double ox, double oy, double px,
+                         double py, AffineTransform winToGeotransform) {
+                 AffineTransform at = winToGeotransform == null ? getScreenToWorld()
+                                 : winToGeotransform;
+                 Point2D geoO;
+                 try {
+                         geoO = at.inverseTransform(new Point2D.Double(ox, oy), null);
+                         Point2D geoP = at
+                                         .inverseTransform(new Point2D.Double(px, py), null);
+                         return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP
+                                         .getY());
+                 } catch (NoninvertibleTransformException e) {
+                         LOGGER.error(e);
+                         return new Envelope(ox, oy, px, py);
+                 }
          }
-         public void mouseReleased(final MouseEvent e) {
+         /**
-                 final int endX = e.getX();
+          * Diretly paints scaled preview into the {@link SelectableXMapPane}. Used
-                 final int endY = e.getY();
+          * to give the user something to look at while we are rendering. Method
+          * should be called after {@link #setMapArea(Envelope)} has been set to the
+          * new mapArea and transform has been reset.<br/>
+          * This method does nothing if the {@link #lastRenderingDuration} is smaller
+          * then a trashhold.
+          *
+          * @param g
+          *            Graphics2D to paint the preview into
+          *
+          * @param state
+          *            Max be {@link #ZOOM_IN} or {@link #ZOOM_OUT}
+          */
+         protected boolean drawScaledPreviewImage_Zoom(Graphics2D graphics) {
-                 processDrag(startX, startY, endX, endY, e);
+                 if (quickPreviewHint == 0)
-                 lastX = 0;
+                         return false;
-                 lastY = 0;
-                 /**
+                 graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-                  * Es wird nicht (mehr) gepannt!
+                                 RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
-                  */
+                 graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                 panning_started = false;
+                                 RenderingHints.VALUE_ANTIALIAS_OFF);
+                 graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
+                                 RenderingHints.VALUE_RENDER_SPEED);
+                 if (oldMapArea == null)
+                         return false;
+                 Rectangle visibleArea = getVisibleRect();
+                 // Calculate the oldMapArea in the current WindowCoordinates:
+                 Envelope oldMapWindow = tranformGeoToWindow(oldMapArea.getMinX(),
+                                 oldMapArea.getMinY(), oldMapArea.getMaxX(), oldMapArea
+                                                 .getMaxY(), null);
+                 int xx1 = (int) Math.round(oldMapWindow.getMinX());
+                 int yy1 = (int) Math.round(oldMapWindow.getMinY());
+                 int xx2 = (int) Math.round(oldMapWindow.getMaxX());
+                 int yy2 = (int) Math.round(oldMapWindow.getMaxY());
+                 graphics.drawImage(getPreFinalImage(), xx1, yy1, xx2, yy2,
+                                 (int) visibleArea.getMinX(), (int) visibleArea.getMinY(),
+                                 (int) visibleArea.getMaxX(), (int) visibleArea.getMaxY(),
+                                 getMapBackgroundColor(), null);
+                 Rectangle painedArea = new Rectangle(xx1, yy1, xx2 - xx1, yy2 - yy1);
+                 SwingUtil.clearAround(graphics, painedArea, visibleArea);
+                 addGadgets(graphics);
+                 quickPreviewHint = 0;
+                 graphics.dispose();
+                 // Something has been drawn
+                 return true;
          }
-         public void mouseDragged(final MouseEvent e) {
+         final static Font waitFont = new Font("Arial", Font.BOLD, 30);
-                 final Graphics graphics = this.getGraphics();
-                 final int x = e.getX();
-                 final 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)) {
+          * Paints some optinal stuff into the given {@link Graphics2D}. Usually
-                                 final int dx = lastX - startX;
+          * called as the last paint on the mapImage.
-                                 final int dy = lastY - startY;
+          */
-                                 // System.out.println("translate "+dx+","+dy);
+         private void addGadgets(Graphics2D graphics) {
-                                 final Graphics2D g2 = panningImage.createGraphics();
-                                 g2.setBackground(new Color(240, 240, 240)); // TODO richtige
+                 if (mapImage != null)
-                                                                                                                         // farbe? am besten
+                         graphics.drawImage(mapImage, getBounds().width
-                                                                                                                         // vom L&F die
+                                         - mapImage.getWidth() - 10, getBounds().height
-                                                                                                                         // hintergrundfarbe
+                                         - mapImage.getHeight() - 10, this);
-                                                                                                                         // auslesen...
+                 // If still rendering, paint a gray shadow or so...
-                                 g2.clearRect(0, 0, this.getWidth(), this.getHeight());
+                 if (bgExecuter != null && bgExecuter.isRunning()
-                                 g2.drawImage(baseImage, dx, dy, this);
+                                 || localExecuter != null && localExecuter.isRunning()) {
-                                 graphics.drawImage(panningImage, 0, 0, this);
+                         graphics.setColor(Color.BLACK);
-                         }
+                         graphics.setFont(waitFont);
-                         lastX = x;
+                         graphics.drawString("Wait...", 40, 70); //i8n
-                         lastY = y;
-                 } else
+                         graphics.setColor(getMapBackgroundColor());
+                 }
-                 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
- //                      final Rectangle bounds = this.getBounds();
- //
- //                      final double mapWidth = mapArea.getWidth();
- //                      final double mapHeight = mapArea.getHeight();
- //
- //                      final double x1 = ((this.startX * mapWidth) / (double) bounds.width)
- //                                      + mapArea.getMinX();
- //                      final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) / (double) bounds.height)
- //                                      + mapArea.getMinY();
- //                      final double x2 = ((x * mapWidth) / (double) bounds.width)
- //                                      + mapArea.getMinX();
- //                      final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double) bounds.height)
- //                                      + mapArea.getMinY();
- //                      final double left = Math.min(x1, x2);
- //                      final double right = Math.max(x1, x2);
- //                      final double bottom = Math.min(y1, y2);
- //                      final double top = Math.max(y1, y2);
- //
- //                      String name = selectionLayer.getFeatureSource().getSchema()
- //                                      .getDefaultGeometry().getName();
- //
- //                      if (name == "") {
- //                              name = "the_geom";
- //                      }
- //                      final 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) {
+          * Accumulates all three images
-         // sk.ce
+          *
-         protected void processDrag(final int x1, final int y1, final int x2,
+          * @return
-                         final int y2, final MouseEvent e) {
+          */
+         synchronized protected BufferedImage updateFinalImage() {
-                 /****
+                 final Graphics2D finalG = (Graphics2D) getFinalImage().getGraphics();
-                  * If no layer is availabe we dont want a NullPointerException
+                 finalG.setBackground(getMapBackgroundColor());
-                  */
-                 if (mapArea == null)
-                         return;
-                 // System.out.println("processing drag from " + x1 + "," + y1 + " -> "
+                 // Render the two map images first, into the preFinalImage
-                 // + x2 + "," + y2);
+                 {
-                 if ((x1 == x2) && (y1 == y2)) {
+                         final Graphics2D preFinalG = (Graphics2D) getPreFinalImage()
-                         if (isClickable()) {
+                                         .getGraphics();
-                                 mouseClicked(new MouseEvent(this, 0, new Date().getTime(), 0,
+                         preFinalG.setBackground(getMapBackgroundColor());
-                                                 x1, y1, y2, false));
-                         }
-                         return;
+                         preFinalG.drawImage(getBgImage(), 0, 0, getMapBackgroundColor(),
+                                         null);
+                         // // Draw the local layers image
+                         preFinalG.drawImage(getLocalImage(), 0, 0, null);
+                         preFinalG.dispose();
                  }
-                 final Rectangle bounds = this.getBounds();
+                 finalG.drawImage(getPreFinalImage(), imageOrigin.x, imageOrigin.y,
+                                 getMapBackgroundColor(), null);
-                 final double mapWidth = mapArea.getWidth();
+                 final int finalImageHeight = getFinalImage().getHeight(null);
-                 final double mapHeight = mapArea.getHeight();
+                 final int finalImageWidth = getFinalImage().getWidth(null);
-                 final double startX = ((x1 * mapWidth) / (double) bounds.width)
+                 Rectangle painedArea = new Rectangle(imageOrigin.x, imageOrigin.y,
-                                 + mapArea.getMinX();
+                                 finalImageWidth, finalImageHeight);
-                 final double startY = (((bounds.getHeight() - y1) * mapHeight) / (double) bounds.height)
+                 SwingUtil.clearAround(finalG, painedArea, getVisibleRect());
-                                 + mapArea.getMinY();
-                 final double endX = ((x2 * mapWidth) / (double) bounds.width)
-                                 + mapArea.getMinX();
-                 final 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
-                         final double deltaX1 = endX - startX;
-                         // System.out.println("deltaX " + deltaX1);
-                         // new edges
-                         final double left = mapArea.getMinX() - deltaX1;
-                         final double right = mapArea.getMaxX() - deltaX1;
-                         // now for Y
-                         final double deltaY1 = endY - startY;
-                         // System.out.println("deltaY " + deltaY1);
-                         final double bottom = mapArea.getMinY() - deltaY1;
-                         final double top = mapArea.getMaxY() - deltaY1;
-                         final Coordinate ll = new Coordinate(left, bottom);
-                         final 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)) < 150)
-                                 return;
-                         // sk.ec
-                         drawRectangle(this.getGraphics());
+                 addGadgets(finalG);
-                         // make the dragged rectangle (in map coords) the new BBOX
-                         final double left = Math.min(startX, endX);
+                 finalG.dispose();
-                         final double right = Math.max(startX, endX);
-                         final double bottom = Math.min(startY, endY);
+                 return finalImage;
-                         final double top = Math.max(startY, endY);
-                         final Coordinate ll = new Coordinate(left, bottom);
-                         final Coordinate ur = new Coordinate(right, top);
-                         // xulu.sc
-                         // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
-                         setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
-                         // sk.sc
- //                      {
- //                      // SK tries to paint a preview of the zoom ;-9 aha.... well
- //                      Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();
- //                      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(baseImage, 0, 0, JMapPane.this.getWidth(),
- //                                      JMapPane.this.getHeight(), x1, y1, x2, y2, null);
- //                      }
-                         // xulu.ec
-                 } else if (state == JMapPane.ZoomOut) {
-                         drawRectangle(this.getGraphics());
-                         // make the dragged rectangle in screen coords the new map size?
-                         final double left = Math.min(startX, endX);
-                         final double right = Math.max(startX, endX);
-                         final double bottom = Math.min(startY, endY);
-                         final double top = Math.max(startY, endY);
-                         final double nWidth = (mapWidth * mapWidth) / (right - left);
-                         final double nHeight = (mapHeight * mapHeight) / (top - bottom);
-                         final double deltaX1 = left - mapArea.getMinX();
-                         final double nDeltaX1 = (deltaX1 * nWidth) / mapWidth;
-                         final double deltaY1 = bottom - mapArea.getMinY();
-                         final double nDeltaY1 = (deltaY1 * nHeight) / mapHeight;
-                         final Coordinate ll = new Coordinate(mapArea.getMinX() - nDeltaX1,
-                                         mapArea.getMinY() - nDeltaY1);
-                         final double deltaX2 = mapArea.getMaxX() - right;
-                         final double nDeltaX2 = (deltaX2 * nWidth) / mapWidth;
-                         final double deltaY2 = mapArea.getMaxY() - top;
-                         final double nDeltaY2 = (deltaY2 * nHeight) / mapHeight;
-                         final Coordinate ur = new Coordinate(mapArea.getMaxX() + nDeltaX2,
-                                         mapArea.getMaxY() + nDeltaY2);
-                         // xulu.sc
-                         // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
-                         setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
-                         // xulu.ec
-                 }
- //              else if (state == JMapPane.Select && selectionLayer != null) {
- //                      final double left = Math.min(startX, endX);
- //                      final double right = Math.max(startX, endX);
- //                      final double bottom = Math.min(startY, endY);
- //                      final double top = Math.max(startY, endY);
- //
- //                      String name = selectionLayer.getFeatureSource().getSchema()
- //                                      .getDefaultGeometry().getLocalName();
- //
- //                      if (name == "") {
- //                              name = "the_geom";
- //                      }
- //                      final 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() {
+         private Image getFinalImage() {
-                 return clickable;
+                 if (finalImage == null) {
+                         finalImage = null;
+                         Rectangle curPaintArea = getVisibleRect();
+                         finalImage = new BufferedImage(curPaintArea.width,
+                                         curPaintArea.height, BufferedImage.TYPE_INT_RGB);
+                         requestStartRendering();
+                 }
+                 return finalImage;
          }
-         private org.geotools.styling.Style setupStyle(final int type, final Color color) {
+         private Image getPreFinalImage() {
-                 final StyleFactory sf = org.geotools.factory.CommonFactoryFinder
+                 if (preFinalImage == null) {
-                                 .getStyleFactory(null);
+                         preFinalImage = null;
-                 final StyleBuilder sb = new StyleBuilder();
+                         Rectangle curPaintArea = getVisibleRect();
-                 org.geotools.styling.Style s = sf.createStyle();
+                         preFinalImage = new BufferedImage(curPaintArea.width,
-                 s.setTitle("selection");
+                                         curPaintArea.height, BufferedImage.TYPE_INT_RGB);
+                         requestStartRendering();
+                 }
+                 return preFinalImage;
+         }
-                 // TODO parameterise the color
+         /**
-                 final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);
+          * While dragging, the {@link #updateFinalImage()} method is translating the
-                 ps.setStroke(sb.createStroke(color));
+          * cached images while setting it together.
+          **/
+         Point imageOrigin = new Point(0, 0);
-                 final LineSymbolizer ls = sb.createLineSymbolizer(color);
+         /**
-                 final Graphic h = sb.createGraphic();
+          * Starts rendering on one or two threads
-                 h.setMarks(new Mark[] { sb.createMark("square", color) });
+          */
+         private void startRendering() {
-                 final PointSymbolizer pts = sb.createPointSymbolizer(h);
+                 if (!isWellDefined())
+                         return;
-                 // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});
+                 if (bgExecuter != null)
-                 switch (type) {
+                         // Stop all renderers
-                 case POLYGON:
+                         bgExecuter.cancelTask();
-                         s = sb.createStyle(ps);
+                 if (localExecuter != null)
+                         localExecuter.cancelTask();
+                 Rectangle curPaintArea = getVisibleRect();
-                         break;
+                 labelCache.clear();
-                 case POINT:
+                 /**
-                         s = sb.createStyle(pts);
+                  * We have to set new renderer
+                  */
-                         break;
+                 if (getBgContext() != null) {
+                         bgExecuter = new RenderingExecutor(this, 333l);
+                         LOGGER.debug("starting bg renderer:");
+                         // /* System.out.println("rendering"); */
+                         final GTRenderer createGTRenderer = GTUtil.createGTRenderer(
+                                         localContext, getRendererHints());
+                         createGTRenderer.setJava2DHints(getJava2dHints());
+                         bgExecuter.submit(getBgContext().getAreaOfInterest(), curPaintArea,
+                                         (Graphics2D) getBgImage().getGraphics(), createGTRenderer);
+                 }
-                 case LINE:
+                 if (getContext() != null) {
-                         s = sb.createStyle(ls);
+                         localExecuter = new RenderingExecutor(this, 150l);
+                         LOGGER.debug("starting local renderer:");
+                         final GTRenderer createGTRenderer = GTUtil.createGTRenderer(
+                                         localContext, getRendererHints());
+                         createGTRenderer.setJava2DHints(getJava2dHints());
+                         localExecuter.submit(getContext().getAreaOfInterest(),
+                                         curPaintArea, (Graphics2D) getLocalImage().getGraphics(),
+                                         createGTRenderer);
                  }
-                 return s;
+                 updateCursor();
          }
+         /**
+          * Lazyly initializes a {@link BufferedImage} for the background renderer.
+          */
+         private BufferedImage getBgImage() {
-         public void propertyChange(final PropertyChangeEvent evt) {
+                 if (bgImage == null) {
-                 final String prop = evt.getPropertyName();
+                         Rectangle curPaintArea = getVisibleRect();
-                 if (prop.equalsIgnoreCase("crs")) {
+                         bgImage = new BufferedImage(curPaintArea.width + 1,
-                         context.setAreaOfInterest(context.getAreaOfInterest(),
+                                         curPaintArea.height + 1, BufferedImage.TYPE_INT_ARGB);
-                                         (CoordinateReferenceSystem) evt.getNewValue());
                  }
+                 return bgImage;
          }
-         public boolean isReset() {
+         /** An (transparent) image to paint over the map in the lower right corner **/
-                 return reset;
+         private BufferedImage mapImage = null;
+         private boolean acceptsRepaintCalls = true;
+         /**
+          * Get the BufferedImage to use as a flaoting icon in the lower right
+          * corner.
+          *
+          * @return <code>null</code> if the feature is deactivated.
+          */
+         public BufferedImage getMapImage() {
+                 return mapImage;
          }
-         public void setReset(final boolean reset) {
+         /**
-                 this.reset = reset;
+          * Set the BufferedImage to use as a flaoting icon in the lower right corner
+          *
+          * @param mapImageIcon
+          *            <code>null</code> is allowed and deactivates this icon.
+          */
+         public void setMapImage(BufferedImage mapImage) {
+                 this.mapImage = mapImage;
          }
-         public void layerAdded(final MapLayerListEvent event) {
+         /**
-                 changed = true;
+          * Lazyly initializes a {@link BufferedImage} for the background renderer.
+          */
+         private BufferedImage getLocalImage() {
-                 if (context.getLayers().length == 1) { // the first one
+                 if (localImage == null) {
-                         try {
+                         Rectangle curPaintArea = getVisibleRect();
-                                 // xulu.sc
-                                 // mapArea = context.getLayerBounds();
-                                 mapArea = context.getAreaOfInterest();
-                                 if (mapArea == null)
-                                         mapArea = context.getLayerBounds();
-                                 // xulu.ec
-                         } catch (final IOException e) {
-                                 // TODO Auto-generated catch block
-                                 e.printStackTrace();
-                         }
-                         reset = true;
+                         localImage = new BufferedImage(curPaintArea.width + 1,
+                                         curPaintArea.height + 1, BufferedImage.TYPE_INT_ARGB);
                  }
-                 repaint();
+                 return localImage;
-         }
-         public void layerRemoved(final MapLayerListEvent event) {
-                 changed = true;
-                 repaint();
          }
-         public void layerChanged(final MapLayerListEvent event) {
-                 changed = true;
-                 // System.out.println("layer changed - repaint");
-                 repaint();
-         }
-         public void layerMoved(final MapLayerListEvent event) {
+         /**
-                 changed = true;
+          * Called by the {@linkplain XMapPane.RenderingTask} when rendering has been
+          * completed Publishes a {@linkplain MapPaneEvent} of type {@code
+          * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
+          *
+          * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
+          */
+         public void onRenderingCompleted() {
+                 updateFinalImage();
                  repaint();
          }
-         protected void drawRectangle(final Graphics graphics) {
+         /**
-                 // undraw last box/draw new box
+          * Called by the {@linkplain XMapPane.RenderingTask} when rendering was
-                 final int left = Math.min(startX, lastX);
+          * cancelled. Publishes a {@linkplain MapPaneEvent} of type {@code
-                 final int right = Math.max(startX, lastX);
+          * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
-                 final int top = Math.max(startY, lastY);
+          *
-                 final int bottom = Math.min(startY, lastY);
+          * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
-                 final int width = right - left;
+          */
-                 final int height = top - bottom;
+         public void onRenderingCancelled() {
-                 // System.out.println("drawing rect("+left+","+bottom+","+ width+","+
+                 LOGGER.debug("Rendering cancelled");
-                 // height+")");
-                 graphics.drawRect(left, bottom, width, height);
          }
          /**
-          * if clickable is set to true then a single click on the map pane will zoom
+          * Called by the {@linkplain XMapPane.RenderingTask} when rendering failed.
-          * or pan the map.
+          * Publishes a {@linkplain MapPaneEvent} of type {@code
+          * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
+          *
+          * @param renderingError
+          *            The error that occured during rendering
           *
-          * @param clickable
+          * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
           */
-         public void setClickable(final boolean clickable) {
+         public void onRenderingFailed(Exception renderingError) {
-                 this.clickable = clickable;
+                 LOGGER.warn("Rendering failed", renderingError);
+                 updateFinalImage();
+                 repaint();
          }
-         public void mouseMoved(final MouseEvent e) {
+         /**
+          * Called when a rendering request has been rejected. This will be common,
+          * such as when the user pauses during drag-resizing fo the map pane. The
+          * base implementation does nothing. It is provided for sub-classes to
+          * override if required.
+          */
+         public void onRenderingRejected() {
+                 LOGGER.warn("Rendering rejected");
+                 repaint();
          }
+         @Override
+         public void propertyChange(final PropertyChangeEvent evt) {
+                 final String prop = evt.getPropertyName();
+                 if (prop.equalsIgnoreCase("crs")) {
+                         localContext.setAreaOfInterest(localContext.getAreaOfInterest(),
+                                         (CoordinateReferenceSystem) evt.getNewValue());
+                 }
+         }
-         // xulu.sn
          /**
           * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste
           * erlaubte Flaeche damit die Massstabsbeschaenkungen noch eingehalten
-Line 995 
 public class JMapPane extends JPanel imp
+Line 1590 
 public class JMapPane extends JPanel imp
                  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.
+                  * easily fail. We allow to grow here, because we don't check against
+                  * the maxExtend
                   */
-                 env = fixAspectRatio(this.getBounds(), env);
+                 Rectangle curPaintArea = getVisibleRect();
+                 env = JTSUtil.fixAspectRatio(curPaintArea, env, true);
                  final double scale = env.getWidth() / getWidth();
                  final double centerX = env.getMinX() + env.getWidth() / 2.;
                  final double centerY = env.getMinY() + env.getHeight() / 2.;
-                 double newWidth2;
+                 double newWidth2 = 0;
-                 double newHeight2;
+                 double newHeight2 = 0;
                  if (scale < getMaxZoomScale()) {
                          // ****************************************************************************
                          // Wir zoomen weiter rein als erlaubt => Anpassen des envelope
-Line 1024 
 public class JMapPane extends JPanel imp
+Line 1624 
 public class JMapPane extends JPanel imp
                          // ****************************************************************************
                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
                          // ****************************************************************************
-                         return env;
+                         newArea = env;
                  }
-                 final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
+                 if (newArea == null) {
-                                 - newHeight2);
-                 final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
+                         final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
-                                 + newHeight2);
+                                         - newHeight2);
+                         final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
+                                         + newHeight2);
+                         newArea = new Envelope(ll, ur);
+                 }
+                 Envelope maxAllowedExtend = getMaxExtend();
+                 while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea)
+                                 && newArea != null && !newArea.isNull()
+                                 && !Double.isNaN(newArea.getMinX())
+                                 && !Double.isNaN(newArea.getMaxX())
+                                 && !Double.isNaN(newArea.getMinY())
+                                 && !Double.isNaN(newArea.getMaxY())) {
+                         /*
+                          * If a maxExtend is set, we have to honour that...
+                          */
+                         // Exceeds top? Move down and maybe cut
+                         if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
+                                 double divY = newArea.getMaxY() - maxAllowedExtend.getMaxY();
+                                 // LOGGER.debug("Moving area down by " + divY);
+                                 newArea = new Envelope(new Coordinate(newArea.getMinX(),
+                                                 newArea.getMinY() - divY), new Coordinate(newArea
+                                                 .getMaxX(), newArea.getMaxY() - divY));
+                                 if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
+                                         // LOGGER.debug("Now it exeeds the bottom border.. cut!");
+                                         // And cut the bottom if it moved out of the area
+                                         newArea = new Envelope(new Coordinate(newArea.getMinX(),
+                                                         maxAllowedExtend.getMinY()), new Coordinate(newArea
+                                                         .getMaxX(), newArea.getMaxY()));
-                 return new Envelope(ll, ur);
+                                         // LOGGER.debug("and fix aspect ratio");
+                                         newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
+                                                         false);
+                                 }
+                         }
+                         // Exceeds bottom? Move up and maybe cut
+                         if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
+                                 double divY = newArea.getMinY() - maxAllowedExtend.getMinY();
+                                 // LOGGER.debug("Moving area up by " + divY);
+                                 newArea = new Envelope(new Coordinate(newArea.getMinX(),
+                                                 newArea.getMinY() - divY), new Coordinate(newArea
+                                                 .getMaxX(), newArea.getMaxY() - divY));
+                                 if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
+                                         // LOGGER.debug("Now it exeeds the top border.. cut!");
+                                         // And cut the bottom if it moved out of the area
+                                         newArea = new Envelope(new Coordinate(newArea.getMinX(),
+                                                         newArea.getMinY()), new Coordinate(newArea
+                                                         .getMaxX(), maxAllowedExtend.getMaxY()));
+                                         // LOGGER.debug("and fix aspect ratio");
+                                         newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
+                                                         false);
+                                 }
+                         }
+                         // Exceeds to the right? move and maybe cut
+                         if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
+                                 // Move left..
+                                 double divX = newArea.getMaxX() - maxAllowedExtend.getMaxX();
+                                 // LOGGER.debug("Moving area left by " + divX);
+                                 newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
+                                                 newArea.getMinY()), new Coordinate(newArea.getMaxX()
+                                                 - divX, newArea.getMaxY()));
+                                 if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
+                                         // LOGGER.debug("Now it exeeds the left border.. cut!");
+                                         // And cut the left if it moved out of the area
+                                         newArea = new Envelope(new Coordinate(maxAllowedExtend
+                                                         .getMinX(), newArea.getMinY()), new Coordinate(
+                                                         newArea.getMaxX(), newArea.getMaxY()));
+                                         // LOGGER.debug("and fix aspect ratio");
+                                         newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
+                                                         false);
+                                 }
+                         }
+                         // Exceeds to the left? move and maybe cut
+                         if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
+                                 // Move right..
+                                 double divX = newArea.getMinX() - maxAllowedExtend.getMinX();
+                                 // LOGGER.debug("Moving area right by " + divX);
+                                 newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
+                                                 newArea.getMinY()), new Coordinate(newArea.getMaxX()
+                                                 - divX, newArea.getMaxY()));
+                                 if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
+                                         // LOGGER.debug("Now it exeeds the right border.. cut!");
+                                         // And cut the left if it moved out of the area
+                                         newArea = new Envelope(new Coordinate(newArea.getMinX(),
+                                                         newArea.getMinY()), new Coordinate(maxAllowedExtend
+                                                         .getMaxX(), newArea.getMaxY()));
+                                         // LOGGER.debug("and fix aspect ratio");
+                                         newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
+                                                         false);
+                                 }
+                         }
+                 }
+                 return newArea;
          }
          /**
-Line 1059 
 public class JMapPane extends JPanel imp
+Line 1772 
 public class JMapPane extends JPanel imp
          /**
           * Set the maximum allowed zoom scale. This is the smaller number value of
-          * the two.
+          * 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) {
-                 // System.out.println("setting max scale to "+maxZoomScale);
+                 this.maxZoomScale = maxZoomScale == null ? Double.MIN_VALUE
-                 this.maxZoomScale = maxZoomScale;
+                                 : maxZoomScale;
          }
          /**
           * Set the minimum (nearest) allowed zoom scale. This is the bigger number
-          * value of the two.
+          * 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;
+                 this.minZoomScale = minZoomScale == null ? Double.MAX_VALUE
+                                 : minZoomScale;
+         }
+         /**
+          * Defines an evelope of the viwable area. The JMapPane will never show
+          * anything outside of this extend.
+          *
+          * @param maxExtend
+          *            <code>null</code> to not have this restriction.
+          */
+         public void setMaxExtend(Envelope maxExtend) {
+                 this.maxExtend = maxExtend;
+         }
+         /**
+          * Returns the evelope of the viewable area. The JMapPane will never show
+          * anything outside of this extend. If this has been set to
+          * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
+          * quickly the context's bounds. It it takes to long to determine the
+          * context bounds, <code>null</code> is returned.
+          *
+          * @param maxExtend
+          *            <code>null</code> to not have this restriction.
+          */
+         public Envelope getMaxExtend() {
+                 if (maxExtend == null) {
+                         final ReferencedEnvelope layerBounds = GTUtil
+                                         .getVisibleLayoutBounds(localContext);
+                         if (layerBounds == null) {
+                                 // TODO Last fallback could be the CRS valid area
+                                 return null;
+                         }
+                         // Kartenbereich um 10% vergroessern
+                         return JTSUtil.fixAspectRatio(this.getBounds(), JTSUtil
+                                         .expandEnvelope(layerBounds, 0.1), true);
+                 }
+                 return maxExtend;
+         }
+         /**
+          * Set the background color of the map.
+          *
+          * @param if <code>null</code>, white is used.
+          */
+         public void setMapBackgroundColor(Color bgColor) {
+                 if (bgColor == null)
+                         bgColor = Color.WHITE;
+                 this.mapBackgroundColor = bgColor;
+         }
+         /**
+          * Returns the background {@link Color} of the map pane. Default is white.
+          **/
+         public Color getMapBackgroundColor() {
+                 return mapBackgroundColor;
+         }
+         /**
+          *
+          * @param b
+          */
+         public void setPainting(boolean b) {
+                 acceptsRepaintCalls = b;
+         }
+         /**
+          * Fuegt der Map einen Listener hinzu.
+          *
+          * @param l
+          *            neuer Listener
+          */
+         public void addMapPaneListener(JMapPaneListener l) {
+                 mapPaneListeners.add(l);
+         }
+         /**
+          * Liste der angeschlossenen Listener, die auf Aktionen des MapPanes
+          * lauschen.
+          */
+         protected Vector<JMapPaneListener> mapPaneListeners = new Vector<JMapPaneListener>();
+         /**
+          * A flag indicating if dispose() was already called. If true, then further
+          * use of this {@link SelectableXMapPane} is undefined.
+          */
+         private boolean disposed = false;
+         /**
+          * Entfernt einen Listener von der Map.
+          *
+          * @param l
+          *            zu entfernender Listener
+          */
+         public void removeMapPaneListener(JMapPaneListener l) {
+                 mapPaneListeners.remove(l);
+         }
+         /** Stored the time used for the last real rendering in ms. **/
+         private long lastRenderingDuration = Long.MAX_VALUE;
+         // if null, no quick preview will be shown
+         private int quickPreviewHint = 0;
+         /**
+          * For every rendering thread started,
+          * {@link GTUtil#createGTRenderer(MapContext)} is called to create a new
+          * renderer. These Java2D rendering hints are passed to the
+          * {@link GTRenderer}. The java2dHints are the same for all renderers (bg
+          * and local).
+          */
+         private RenderingHints java2dHints;
+         /**
+          * Returns in milli seconds the time the last rending of the
+          * {@link SelectableXMapPane} took. #Long.MAX_VALUE if the JMapPane has not
+          * been rendered yet.
+          */
+         public long getLastRenderingDuration() {
+                 return lastRenderingDuration;
+         }
+         /**
+          * Should be called when the {@link JMapPane} is not needed no more to help
+          * the GarbageCollector
+          *
+          * Removes all {@link JMapPaneListener}s that are registered
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public void dispose() {
+                 if (isDisposed())
+                         return;
+                 setPainting(false);
+                 disposed = true;
+                 if (bgExecuter != null) {
+                         bgExecuter.cancelTask();
+                 }
+                 if (localExecuter != null) {
+                         localExecuter.cancelTask();
+                 }
+                 startRenderThreadsTimer.stop();
+                 if (bgImage != null)
+                         bgImage.flush();
+                 if (localImage != null)
+                         localImage.flush();
+                 if (finalImage != null)
+                         finalImage.flush();
+                 if (preFinalImage != null)
+                         preFinalImage.flush();
+                 // Alle mapPaneListener entfernen
+                 mapPaneListeners.clear();
+                 removeMouseMotionListener(zoomMapPaneMouseListener);
+                 removeMouseListener(zoomMapPaneMouseListener);
+                 if (localContext != null)
+                         getContext().clearLayerList();
+                 if (bgContext != null)
+                         getBgContext().clearLayerList();
+                 removeAll();
+         }
+         /**
+          * A flag indicating if dispose() has already been called. If true, then
+          * further use of this {@link SelectableXMapPane} is undefined.
+          */
+         private boolean isDisposed() {
+                 return disposed;
+         }
+         public void setQuickPreviewHint(int quickPreviewHint) {
+                 this.quickPreviewHint = quickPreviewHint;
+         }
+         public void setJava2dHints(RenderingHints java2dHints) {
+                 this.java2dHints = java2dHints;
+         }
+         public RenderingHints getJava2dHints() {
+                 return java2dHints;
+         }
+         /**
+          * Zooms towards a point.
+          *
+          * @param center
+          *            position in window coordinates
+          * @param zoomFaktor
+          *            > 1 for zoom in, < 1 for zoom out. Default is 1.33.
+          */
+         public void zoomTo(Point center, Double zoomFaktor) {
+                 if (zoomFaktor == null || zoomFaktor == 0.)
+                         zoomFaktor = 2.;
+                 Point2D gcenter = getScreenToWorld().transform(center, null);
+                 center = null;
+                 if (Double.isNaN(gcenter.getX()) || Double.isNaN(gcenter.getY())
+                                 || Double.isInfinite(gcenter.getX())
+                                 || Double.isInfinite(gcenter.getY())
+                 ) {
+                         // Not inside valid CRS area! cancel
+                         return;
+                 }
+                 final Envelope mapArea = getMapArea();
+                 Envelope newMapArea = new Envelope(mapArea);
+                 newMapArea.expandBy((mapArea.getWidth() * zoomFaktor - mapArea
+                                 .getWidth()) / 2., (mapArea.getHeight() * zoomFaktor - mapArea
+                                 .getHeight()) / 2.);
+                 // Move the newMapArea above the new center
+                 newMapArea.translate(gcenter.getX() - mapArea.centre().x, gcenter
+                                 .getY()
+                                 - mapArea.centre().y);
+                 setMapArea(newMapArea);
+         }
+         /**
+          * Zooms towards a point.
+          *
+          * @param center
+          *            position in window coordinates
+          * @param zoomFactor
+          *            > 1 for zoom in, < 1 for zoom out. Default is 1.33
+          */
+         public void zoomTo(Point center) {
+                 zoomTo(center, null);
+         }
+         public void mouseDragged(Point startPos, Point lastPos, MouseEvent event) {
+                 if ((getState() == XMapPane.PAN)
+                                 || ((event.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) {
+                         if (getCursor() != SwingUtil.PANNING_CURSOR) {
+                                 setCursor(SwingUtil.PANNING_CURSOR);
+                                 // While panning, we deactivate the rendering. So the tasts are
+                                 // ready to start when the panning os done.
+                                 if (bgExecuter != null)
+                                         bgExecuter.cancelTask();
+                                 if (localExecuter != null)
+                                         localExecuter.cancelTask();
+                         }
+                         if (lastPos.x > 0 && lastPos.y > 0) {
+                                 final int dx = event.getX() - lastPos.x;
+                                 final int dy = event.getY() - lastPos.y;
+                                 // TODO Stop dragging when the drag would not be valid...
+                                 // boolean dragValid = true;
+                                 // // check if this panning results in a valid mapArea
+                                 // {
+                                 // Rectangle winBounds = xMapPane.getBounds();
+                                 // winBounds.translate(xMapPane.imageOrigin.x,
+                                 // -xMapPane.imageOrigin.y);
+                                 // Envelope newMapAreaBefore = xMapPane.tranformWindowToGeo(
+                                 // winBounds.x, winBounds.y, winBounds.x
+                                 // + winBounds.width, winBounds.y
+                                 // + winBounds.height);
+                                 //
+                                 //
+                                 // winBounds = xMapPane.getBounds();
+                                 // Point testIng = new Point(xMapPane.imageOrigin);
+                                 // testIng.translate(dx, dy);
+                                 // winBounds.translate(testIng.x, -testIng.y);
+                                 // Envelope newMapAreaAfter = xMapPane.tranformWindowToGeo(
+                                 // winBounds.x, winBounds.y, winBounds.x
+                                 // + winBounds.width, winBounds.y
+                                 // + winBounds.height);
+                                 //
+                                 // // If the last drag doesn't change the MapArea anymore cancel
+                                 // it.
+                                 // if (xMapPane.bestAllowedMapArea(newMapAreaAfter).equals(
+                                 // xMapPane.bestAllowedMapArea(newMapAreaBefore))){
+                                 // dragValid = false;
+                                 // return;
+                                 // }
+                                 // }
+                                 imageOrigin.translate(dx, dy);
+                                 updateFinalImage();
+                                 repaint();
+                         }
+                 } else if ((getState() == XMapPane.ZOOM_IN)
+                                 || (getState() == XMapPane.ZOOM_OUT)
+                                 || (getState() == XMapPane.SELECT_ALL)
+                                 || (getState() == XMapPane.SELECT_TOP)
+                 // || (getState() == XMapPane.SELECT_ONE_FROM_TOP)
+                 ) {
+                         final Graphics graphics = getGraphics();
+                         drawRectangle(graphics, startPos, event.getPoint());
+                         if ((lastPos.x > 0) && (lastPos.y > 0)) {
+                                 drawRectangle(graphics, startPos, lastPos);
+                         }
+                 }
+         }
+         /**
+          * Draws a rectangle in XOR mode from the origin at {@link #startPos} to the
+          * given point. All in screen coordinates.
+          */
+         protected void drawRectangle(final Graphics graphics, Point startPos,
+                         Point e) {
+                 if (!isWellDefined()) return;
+                 // undraw last box/draw new box
+                 final int left = Math.min(startPos.x, e.x);
+                 final int right = Math.max(startPos.x, e.x);
+                 final int top = Math.max(startPos.y, e.y);
+                 final int bottom = Math.min(startPos.y, e.y);
+                 final int width = right - left;
+                 final int height = top - bottom;
+                 if (width == 0 && height == 0)
+                         return;
+                 graphics.setXORMode(Color.WHITE);
+                 graphics.drawRect(left, bottom, width, height);
+         }
+         /**
+          * Finalizes a PAN action
+          */
+         public void performPan() {
+                 Rectangle winBounds = getBounds();
+                 winBounds.translate(-imageOrigin.x, -imageOrigin.y);
+                 Envelope newMapArea = tranformWindowToGeo(winBounds.x, winBounds.y,
+                                 winBounds.x + winBounds.width, winBounds.y + winBounds.height);
+                 imageOrigin.x = 0;
+                 imageOrigin.y = 0;
+                 if (!setMapArea(newMapArea)) {
+                         updateFinalImage();
+                         repaint();
+                 }
+                 if (getCursor() == SwingUtil.PANNING_CURSOR)
+                         setCursor(SwingUtil.PAN_CURSOR);
+         }
+         public void onRenderingPending() {
+ //              LOGGER.debug("Pending rendering updates the preview...");
+                 updateFinalImage();
+                 repaint();
          }
-         // xulu.en
  }

 Legend:



Removed from v.341
 


changed lines


 
Added in v.521
 Legend:



Removed from v.341
 


changed lines


 
Added in v.521
-Removed from v.341
+Added in v.521

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26