/[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/skrueger/geotools/XMapPane.java
revision 536 by alfonx,
Fri Nov 20 15:38:34 2009 UTC
+branches/2.0-RC2/src/skrueger/geotools/XMapPane.java
revision 677 by alfonx,
Fri Feb  5 15:03:17 2010 UTC
 Line 13 
 import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.ComponentAdapter;
  import java.awt.event.ComponentEvent;
- import java.awt.event.InputEvent;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
  import java.awt.geom.AffineTransform;
-Line 26 
 import java.util.HashMap;
+Line 25 
 import java.util.HashMap;
  import java.util.Map;
  import java.util.Vector;
+ import javax.swing.JList;
  import javax.swing.Timer;
+ import javax.swing.border.Border;
  import org.apache.log4j.Logger;
+ import org.geotools.factory.GeoTools;
  import org.geotools.feature.FeatureCollection;
- import org.geotools.geometry.Envelope2D;
+ import org.geotools.geometry.DirectPosition2D;
  import org.geotools.geometry.jts.JTS;
  import org.geotools.geometry.jts.ReferencedEnvelope;
  import org.geotools.map.DefaultMapContext;
-Line 44 
 import org.geotools.referencing.CRS;
+Line 46 
 import org.geotools.referencing.CRS;
  import org.geotools.renderer.GTRenderer;
  import org.geotools.renderer.label.LabelCacheImpl;
  import org.geotools.renderer.lite.LabelCache;
+ import org.geotools.renderer.lite.RendererUtilities;
  import org.geotools.renderer.lite.StreamingRenderer;
+ import org.geotools.resources.image.ImageUtilities;
  import org.geotools.swing.JMapPane;
  import org.geotools.swing.event.MapMouseEvent;
  import org.geotools.swing.event.MapPaneEvent;
-Line 65 
 import schmitzm.geotools.map.event.MapLa
+Line 69 
 import schmitzm.geotools.map.event.MapLa
  import schmitzm.lang.LangUtil;
  import schmitzm.swing.JPanel;
  import schmitzm.swing.SwingUtil;
+ import schmitzm.swing.event.MouseInputType;
  import com.vividsolutions.jts.geom.Coordinate;
  import com.vividsolutions.jts.geom.Envelope;
-Line 95 
 import com.vividsolutions.jts.geom.Geome
+Line 100 
 import com.vividsolutions.jts.geom.Geome
   */
  public class XMapPane extends JPanel {
-         private static final int IMAGETYPE = BufferedImage.TYPE_INT_RGB;
+         /**
-         private static final int IMAGETYPE_withAlpha = BufferedImage.TYPE_INT_ARGB;
+          * If {@link #maxExtend} is <code>null</code> the following rules are used
+          * to create a default maximum.
+          * <ul>
+          * <li>Values &lt; 0 : don't grow to fit the monitors aspect ratio, no
+          * margin</li>
+          * <li>Values 0 : grow to fit the monitors aspect ratio, no margin</li>
+          * <li>Values &gt; 0 : grow to fit the monitors aspect ratio, and add a
+          * relative margin</li>
+          * </ul>
+          * **/
+         private double defaultMaxMapExtendMode = .05;
+         // private static final int IMAGETYPE = BufferedImage.TYPE_INT_RGB;
+         // private static final int IMAGETYPE_withAlpha =
+         // BufferedImage.TYPE_INT_ARGB;
+         private static final int IMAGETYPE = BufferedImage.TYPE_3BYTE_BGR;
+         public XMapPaneTool getTool() {
+                 return tool;
+         }
-         private static Logger LOGGER = Logger.getLogger(XMapPane.class);
+         private static final int IMAGETYPE_withAlpha = BufferedImage.TYPE_4BYTE_ABGR;
+         private final static Logger LOGGER = Logger.getLogger(XMapPane.class);
+         /**
+          * A flag indicating whether the {@link XMapPane} is accepting repaints from
+          * the EDT. @see {@link XMapPane#setPainting(boolean))
+          **/
          private boolean acceptsRepaintCalls = true;
          /**
-Line 124 
 public class XMapPane extends JPanel {
+Line 154 
 public class XMapPane extends JPanel {
           * regularly and {@link #repaint()}. This {@link Timer} is stopped when all
           * renderers have finished.
           *
-          * @see #INITIAL_REPAINT_DELAYAL
+          * @see INITIAL_REPAINT_DELAYAL
           * @see #REPEATING_REPAINT_DELAY
           */
          final private Timer repaintTimer;
-Line 133 
 public class XMapPane extends JPanel {
+Line 163 
 public class XMapPane extends JPanel {
           * The initial delay in milliseconds until the {@link #finalImage} is
           * updated the first time.
           */
-         public static final int INITIAL_REPAINT_DELAY = 1000;
+         public static final int INITIAL_REPAINT_DELAY = 900;
          /**
           * While the {@link #bgExecuter} and {@link #localExecuter} are rendering,
           * the {@link #repaintTimer} is regularly updating the {@link #finalImage}
           * with previews.
           */
-         public static final long REPEATING_REPAINT_DELAY = 500;
+         public static final int REPEATING_REPAINT_DELAY = 500;
          /**
           * Default delay (milliseconds) before the map will be redrawn when resizing
           * the pane. This is to avoid flickering while drag-resizing.
+          *
+          * @see #resizeTimer
           */
-         public static final int DEFAULT_RESIZING_PAINT_DELAY = 500;
+         public static final int DEFAULT_RESIZING_PAINT_DELAY = 600;
-         public static final int NONE = -123;
          /**
-          * Flag fuer Modus "Kartenausschnitt bewegen". Nicht fuer Window-Auswahl
+          * This not-repeating {@link Timer} is re-started whenever the component is
-          * moeglich!
+          * resized. That means => only if the component is not resizing for
-          *
+          * {@link #DEFAULT_RESIZING_PAINT_DELAY} milliseconds, does the
-          * @see #setState(int)
+          * {@link XMapPane} react.
           */
-         public static final int PAN = 1;
+         private final Timer resizeTimer;
          /**
-          * Flag fuer Modus "SimpleFeature-Auswahl auf allen (sichtbaren) Layern".
+          * Flag for no-tool.
-          *
-          * @see #setState(int)
-          * @see #setState(int)
           */
-         public static final int SELECT_ALL = 103;
+         public static final int NONE = -123;
+         //
+         // /**
+         // * Flag fuer Modus "Kartenausschnitt bewegen". Nicht fuer Window-Auswahl
+         // * moeglich!
+         // *
+         // * @see #setState(int)
+         // */
+         // public static final int PAN = 1;
+         //
+         // /**
+         // * Flag fuer Modus "Heran zoomen".
+         // *
+         // * @see #setState(int)
+         // * @see #setState(int)
+         // */
+         // public static final int ZOOM_IN = 2;
+         //
+         // /**
+         // * Flag fuer Modus "Heraus zoomen". Nicht fuer Window-Auswahl moeglich!
+         // *
+         // * @see #setState(int)
+         // */
+         // public static final int ZOOM_OUT = 3;
          /**
-          * Flag fuer Modus
+          * {@link Font} used to paint the wait messages into the map
-          * "Auswahl nur eines Features, das erste sichtbare von Oben".
           *
-          * @see #setState(int)
+          * @see #addGadgets(Graphics2D, boolean)
-          * @see #setState(int)
           */
-         public static final int SELECT_ONE_FROM_TOP = 104;
+         final static Font waitFont = new Font("Arial", Font.BOLD, 28);
          /**
-          * Flag fuer Modus
+          * {@link Font} used to paint error messages into the map
-          * "SimpleFeature-Auswahl auf dem obersten (sichtbaren) Layer".
           *
-          * @see #setState(int)
+          * @see #addGadgets(Graphics2D, boolean)
-          * @see #setState(int)
           */
-         public static final int SELECT_TOP = 4;
-         public static final Cursor WAIT_CURSOR = Cursor
-                         .getPredefinedCursor(Cursor.WAIT_CURSOR);
-         final static Font waitFont = new Font("Arial", Font.BOLD, 30);
-         final String waitMsg = SwingUtil.R("WaitMess");
          final static Font errorFont = new Font("Arial", Font.BOLD, 13);
          /**
-          * Flag fuer Modus "Heran zoomen".
+          * If last average last two renderings took more than that many ms, show the
-          *
+          * user a scaled preview
-          * @see #setState(int)
+          **/
-          * @see #setState(int)
+         private static final long PRESCALE_MINTIME = 230;
-          */
-         public static final int ZOOM_IN = 2;
          /**
-          * Flag fuer Modus "Heraus zoomen". Nicht fuer Window-Auswahl moeglich!
+          * The wait message painted into the map while rendering is going on on
+          * another thread.
           *
-          * @see #setState(int)
+          * @see #addGadgets(Graphics2D, boolean)
           */
-         public static final int ZOOM_OUT = 3;
+         final String waitMsg = SwingUtil.R("WaitMess");
          /**
           * Konvertiert die Maus-Koordinaten (relativ zum <code>JMapPane</code>) in
-Line 211 
 public class XMapPane extends JPanel {
+Line 251 
 public class XMapPane extends JPanel {
           * @param e
           *            Maus-Ereignis
           */
-         public static Point2D getMapCoordinatesFromEvent(final MouseEvent e) {
+         public static DirectPosition2D getMapCoordinatesFromEvent(final MouseEvent e) {
                  // aktuelle Geo-Position aus GeoMouseEvent ermitteln
                  if (e != null && e instanceof MapMouseEvent)
                          try {
-                                 return ((MapMouseEvent) e).getMapPosition().toPoint2D();
+                                 return ((MapMouseEvent) e).getMapPosition();
                          } catch (final Exception err) {
                                  LOGGER
                                                  .error(
-Line 232 
 public class XMapPane extends JPanel {
+Line 272 
 public class XMapPane extends JPanel {
                                  return null;
                          final AffineTransform at = xMapPane.getScreenToWorld();
-                         if (at != null)
+                         if (at != null) {
-                                 return at.transform(e.getPoint(), null);
+                                 Point2D transformed = at.transform(e.getPoint(), null);
+                                 return new DirectPosition2D(xMapPane.getMapContext()
+                                                 .getCoordinateReferenceSystem(), transformed.getX(),
+                                                 transformed.getY());
+                         }
                          return null;
                  }
                  throw new IllegalArgumentException(
-Line 248 
 public class XMapPane extends JPanel {
+Line 292 
 public class XMapPane extends JPanel {
                  @Override
                  public void layerAdded(final MapLayerListEvent event) {
+                         final MapLayer layer = event.getLayer();
-                         MapLayer layer = event.getLayer();
                          layer.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 layerChanged(final MapLayerListEvent event) {
-                         // mapImageInvalid = true;
-                         // repaint();
                          requestStartRendering();
                  }
                  @Override
                  public void layerMoved(final MapLayerListEvent event) {
-                         // mapImageInvalid = true;
-                         // repaint();
                          requestStartRendering();
                  }
-Line 287 
 public class XMapPane extends JPanel {
+Line 311 
 public class XMapPane extends JPanel {
                  public void layerRemoved(final MapLayerListEvent event) {
                          if (event.getLayer() != null)
                                  event.getLayer().removeMapLayerListener(bgMapLayerListener);
-                         // mapImageInvalid = true;
-                         // repaint();
                          requestStartRendering();
                  }
          };
          /**
-          * compass and icon are rendered into this image
+          * This {@link RenderingExecutor} manages the creation and cancellation of
+          * up to one {@link Thread} for rendering the {@link #localContext}.
           */
-         // protected BufferedImage gadgetsImage;
+         private final RenderingExecutor localExecuter = new RenderingExecutor(this);
+         /**
+          * This {@link RenderingExecutor} manages the creation and cancellation of
+          * up to one {@link Thread} for rendering the {@link #bgContext}.
+          */
          protected RenderingExecutor bgExecuter;
          /**
-          * The Renderer for the LocalLayers uses this Image. When set to null,
+          * The {@link #localRenderer} for the {@link #localContext} uses this
-          * please dispose this {@link Graphics2D}
+          * {@link Image}.
           */
          private BufferedImage localImage;
-         private BufferedImage finalImage;
          /**
-          * If # {@link #bgExecuter} is using {@link #bgRenderer} for the Background
+          * The {@link #bgRenderer} for the {@link #bgContext} uses this
-          * uses this Image. When set to null, please dispose the {@link Graphics2D}
+          * {@link Image}.
           */
          private BufferedImage bgImage;
          /**
+          * This {@link Image} is a merge of the {@link #bgImage},
+          * {@link #localImage} and {@link #addGadgets(Graphics2D, boolean)}. It is
+          * updated with {@link #updateFinalImage()} and used for painting in
+          * {@link #paintComponent(Graphics)}
+          */
+         private BufferedImage finalImage;
+         /**
           * Optionally a transparent image to paint over the map in the lower right
           * corner.
           *
-Line 330 
 public class XMapPane extends JPanel {
+Line 364 
 public class XMapPane extends JPanel {
                  @Override
                  public void layerChanged(final MapLayerEvent event) {
-                         // Change of SLD for example
-                         // mapImageInvalid = true;
-                         // repaint();
                          requestStartRendering();
                  }
                  @Override
                  public void layerHidden(final MapLayerEvent event) {
-                         // mapImageInvalid = true;
-                         // repaint();
                          requestStartRendering();
                  }
                  @Override
                  public void layerShown(final MapLayerEvent event) {
-                         // mapImageInvalid = true;
-                         // repaint();
                          requestStartRendering();
                  }
          };
-Line 361 
 public class XMapPane extends JPanel {
+Line 388 
 public class XMapPane extends JPanel {
           * While dragging, the {@link #updateFinalImage()} method is translating the
           * cached images while setting it together.
           **/
-         Point imageOrigin = new Point(0, 0);
+         private final Point imageOrigin = new Point(0, 0);
          /**
           * For every rendering thread started,
           * {@link GTUtil#createGTRenderer(MapContext)} is called to create a new
-Line 383 
 public class XMapPane extends JPanel {
+Line 410 
 public class XMapPane extends JPanel {
                  public void layerAdded(final MapLayerListEvent event) {
                          event.getLayer().addMapLayerListener(localMapLayerListener);
-                         localRenderer.setContext(getContext());
+                         getLocalRenderer().setContext(getMapContext());
-                         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 layerChanged(final MapLayerListEvent event) {
-                         // mapImageInvalid = true;
+                         // getLocalRenderer().setContext(getMapContext()); geht doch auch
-                         // repaint();
+                         // ohne?!?!? wow...
-                         localRenderer.setContext(getContext());
                          requestStartRendering();
                  }
                  @Override
                  public void layerMoved(final MapLayerListEvent event) {
-                         // mapImageInvalid = true;
+                         getLocalRenderer().setContext(getMapContext());
-                         // repaint();
-                         localRenderer.setContext(getContext());
                          requestStartRendering();
                  }
-Line 420 
 public class XMapPane extends JPanel {
+Line 432 
 public class XMapPane extends JPanel {
                  public void layerRemoved(final MapLayerListEvent event) {
                          if (event.getLayer() != null)
                                  event.getLayer().removeMapLayerListener(localMapLayerListener);
-                         // mapImageInvalid = true;
+                         getLocalRenderer().setContext(getMapContext());
-                         // repaint();
-                         localRenderer.setContext(getContext());
                          requestStartRendering();
                  }
          };
-         private final RenderingExecutor localExecuter = new RenderingExecutor(this);
          /**
           * Listens to each layer in the local {@link MapContext} for changes and
-          * triggers repaints.
+          * triggers repaints. We don't have to listen layerChanged, because that is
+          * already done in {@link #localContextListener}
           */
          protected MapLayerListener localMapLayerListener = new MapLayerAdapter() {
-                 @Override
+                 // @Override
-                 public void layerChanged(final MapLayerEvent event) {
+                 // public void layerChanged(final MapLayerEvent event) {
-                         localRenderer.setContext(getContext()); // betters for SLD changes?!
+                 // // getLocalRenderer().setContext(getMapContext()); // betters for SLD
-                         // Change of SLD for example
+                 // // // changes?!
-                         // mapImageInvalid = true;
+                 // // requestStartRendering();
-                         // repaint();
+                 // }
-                         requestStartRendering();
-                 }
                  @Override
                  public void layerHidden(final MapLayerEvent event) {
-                         // mapImageInvalid = true;
-                         // repaint();
                          requestStartRendering();
                  }
                  @Override
                  public void layerShown(final MapLayerEvent event) {
-                         // mapImageInvalid = true;
-                         // repaint();
                          requestStartRendering();
                  }
          };
-         private final GTRenderer localRenderer = GTUtil.createGTRenderer();
+         final private GTRenderer localRenderer = GTUtil.createGTRenderer();
          private final GTRenderer bgRenderer = GTUtil.createGTRenderer();
-Line 480 
 public class XMapPane extends JPanel {
+Line 483 
 public class XMapPane extends JPanel {
          /**
           * This color is used as the default background color when painting a map.
           */
-         private Color mapBackgroundColor = Color.WHITE;
+         private Color mapBackgroundColor = null;
          /**
           * A flag indicating that the shown image is invalid and needs to be
-Line 524 
 public class XMapPane extends JPanel {
+Line 527 
 public class XMapPane extends JPanel {
           * A flag indicating, that the image size has changed and the buffered
           * images are not big enough any more
           **/
-         protected boolean paneResized = false;
+         protected boolean paneResized = true;
          private BufferedImage preFinalImage;
-         // if null, no quick preview will be shown
+         // ** if 0, no quick preview will be shown **/
-         private int quickPreviewHint = 0;
+         // private int quickPreviewHint = 0;
          private Map<Object, Object> rendererHints = GTUtil
-                         .getDefaultGTRendererHints(localRenderer);
+                         .getDefaultGTRendererHints(getLocalRenderer());
+         /**
+          * If set to <code>true</code>, the {@link #startRenderThreadsTimer} will
+          * start rendering {@link Thread}s
+          **/
          private volatile Boolean requestStartRendering = false;
-         private final Timer resizeTimer;
-         private final int resizingPaintDelay;
          /**
           * Transformation zwischen Fenster-Koordinaten und Karten-Koordinaten
           * (lat/lon)
-Line 552 
 public class XMapPane extends JPanel {
+Line 555 
 public class XMapPane extends JPanel {
           * thread.
           */
          final private Timer startRenderThreadsTimer;
+         //
-         /**
+         // /**
-          * The default state is ZOOM_IN, hence by default the
+         // * The default state is ZOOM_IN, hence by default the
-          * {@link #zoomMapPaneMouseListener} is also enabled.
+         // * {@link #xMapPaneMouseListener} is also enabled.
-          **/
+         // **/
-         private int state = ZOOM_IN;
+         // private int state = ZOOM_IN;
+         //
-         /**
+         // /**
-          * Manuell gesetzter statischer Cursor, unabhaengig von der aktuellen
+         // * Manuell gesetzter statischer Cursor, unabhaengig von der aktuellen
-          * MapPane-Funktion
+         // * MapPane-Funktion
-          */
+         // */
-         protected Cursor staticCursor = null;
+         // protected Cursor staticCursor = null;
          private AffineTransform worldToScreen;
+         // /**
+         // * This {@link MouseListener} is managing all zoom related tasks
+         // */
+         // private final ZoomXMapPaneMouseListener zoomMapPaneMouseListener = new
+         // ZoomXMapPaneMouseListener(
+         // this);
          /**
           * This {@link MouseListener} is managing all zoom related tasks
           */
-         public final ZoomXMapPaneMouseListener zoomMapPaneMouseListener = new ZoomXMapPaneMouseListener(
+         private final XMapPaneMouseListener xMapPaneMouseListener = new XMapPaneMouseListener(
                          this);
          /** Is set if a renderer has an error **/
          protected ArrayList<Exception> renderingErrors = new ArrayList<Exception>();
-         // TODO doku
+         /**
+          * If <code>true</code>, then rendering exceptions are rendererd into the
+          * map pane
+          **/
+         private boolean showExceptions = false;
          public XMapPane() {
                  this(null, null);
          }
-Line 585 
 public class XMapPane extends JPanel {
+Line 600 
 public class XMapPane extends JPanel {
           * full constructor extending JPanel
           *
           * @param rendererHints
+          *            may be <code>null</code>. Otherwise a {@link Map<Object,
+          *            Object>} of {@link RenderingHints} to override the default
+          *            from {@link GTUtil#getDefaultGTRendererHints(GTRenderer)}
           *
-          * @param layout
-          *            - layout (probably shouldn't be set)
-          * @param isDoubleBuffered
-          *            - a Swing thing I don't really understand
-          * @param render
-          *            - what to draw the map with
           * @param localContext
-          *            - {@link MapContext} of layer to render.
+          *            The main {@link MapContext} to use. If <code>null</code>, an
+          *            empty {@link DefaultMapContext} will be created.
           */
          public XMapPane(final MapContext localContext_,
                          final Map<Object, Object> rendererHints) {
                  super(true);
+                 // A default setting
+                 RenderingHints hintsJava2d = ImageUtilities.NN_INTERPOLATION_HINT;
+                 setJava2dHints(hintsJava2d);
                  setRendererHints(rendererHints);
                  setOpaque(true);
-Line 609 
 public class XMapPane extends JPanel {
+Line 626 
 public class XMapPane extends JPanel {
                  /**
                   * Adding the #zoomMapPaneMouseListener
                   */
-                 this.addMouseListener(zoomMapPaneMouseListener);
+                 this.addMouseListener(xMapPaneMouseListener);
-                 this.addMouseMotionListener(zoomMapPaneMouseListener);
+                 this.addMouseMotionListener(xMapPaneMouseListener);
-                 this.addMouseWheelListener(zoomMapPaneMouseListener);
+                 this.addMouseWheelListener(xMapPaneMouseListener);
+                 // By default the XMapPAne uses the ZOOM_IN tool.
+                 setTool(XMapPaneTool.ZOOM_IN);
                  /*
                   * We use a Timer object to avoid rendering delays and flickering when
-Line 620 
 public class XMapPane extends JPanel {
+Line 640 
 public class XMapPane extends JPanel {
                   * Using a ComponentListener doesn't work because, unlike a JFrame, the
                   * pane receives a stream of events during drag-resizing.
                   */
-                 resizingPaintDelay = DEFAULT_RESIZING_PAINT_DELAY;
+                 resizeTimer = new Timer(DEFAULT_RESIZING_PAINT_DELAY,
-                 resizeTimer = new Timer(resizingPaintDelay, new ActionListener() {
+                                 new ActionListener() {
-                         public void actionPerformed(final ActionEvent e) {
-                                 paneResized = true;
-                                 if (!isWellDefined())
+                                         public void actionPerformed(final ActionEvent e) {
-                                         return;
+                                                 if (!isWellDefined())
+                                                         return;
-                                 final Rectangle bounds = getVisibleRect();
+                                                 // LOGGER.debug("resizeTimer performed");
-                                 final Envelope geoMapArea = tranformWindowToGeo(bounds.x,
+                                                 // final Rectangle bounds = getVisibleRect();
-                                                 bounds.y, bounds.x + bounds.width, bounds.y
+                                                 //
-                                                                 + bounds.height);
+                                                 // System.out.println("\n\ntimer performs with bounds = "
+                                                 // + bounds);
+                                                 // final Envelope geoMapArea = tranformWindowToGeo(
+                                                 // bounds.x, bounds.y, bounds.x + bounds.width,
+                                                 // bounds.y + bounds.height);
+                                                 paneResized = true;
+                                                 if (!setMapArea(getMapArea())) {
+                                                         // It's important to request new rendering here.
+                                                         // setMapArea only returns true and only calls
+                                                         // requestStartRendering if the maparea has changed.
+                                                         // But if the component is resized, the maparea
+                                                         // doesn't have to change.
+                                                         requestStartRendering();
+                                                 }
-                                 setMapArea(bestAllowedMapArea(geoMapArea));
+                                         }
-                         }
+                                 });
-                 });
                  resizeTimer.setRepeats(false);
                  this.addComponentListener(new ComponentAdapter() {
+                         private Rectangle oldVisibleRect;
                          @Override
                          public void componentResized(final ComponentEvent e) {
-                                 if (bgExecuter != null)
-                                         bgExecuter.cancelTask();
+                                 // Seems to be called twice with the same size..
-                                 if (localExecuter != null)
+                                 if (oldVisibleRect != null
-                                         localExecuter.cancelTask();
+                                                 && oldVisibleRect.equals(getVisibleRect())) {
+                                         // LOGGER.debug("skipping resize.");
+                                         return;
+                                 }
+                                 // LOGGER.debug("resized: " + getVisibleRect());
                                  resizeTimer.restart();
+                                 oldVisibleRect = getVisibleRect();
                          }
                  });
-Line 655 
 public class XMapPane extends JPanel {
+Line 696 
 public class XMapPane extends JPanel {
                  /*
                   * Setting up the repaintTimer. Not started automatically.
                   */
-                 repaintTimer = new Timer((int) REPEATING_REPAINT_DELAY,
+                 repaintTimer = new Timer(REPEATING_REPAINT_DELAY, new ActionListener() {
-                                 new ActionListener() {
+                         @Override
+                         public void actionPerformed(final ActionEvent e) {
+                                 if ((!localExecuter.isRunning())
+                                                 && (bgExecuter != null && !bgExecuter.isRunning())) {
+                                         repaintTimer.stop();
+                                 } else {
+                                         updateFinalImage();
+                                         XMapPane.this.repaint(100);
+                                 }
+                         }
+                 });
-                                         @Override
-                                         public void actionPerformed(final ActionEvent e) {
-                                                 updateFinalImage();
-                                                 XMapPane.this.repaint();
-                                         }
-                                 });
                  repaintTimer.setInitialDelay(INITIAL_REPAINT_DELAY);
                  repaintTimer.setRepeats(true);
-Line 681 
 public class XMapPane extends JPanel {
+Line 728 
 public class XMapPane extends JPanel {
                                                  if (localExecuter.isRunning()) {
                                                          localExecuter.cancelTask();
                                                  } else {
+                                                         // Stupidly, but we have to recheck the
+                                                         setMapArea(getMapArea());
                                                          requestStartRendering = false;
                                                          startRendering();
                                                  }
-Line 713 
 public class XMapPane extends JPanel {
+Line 762 
 public class XMapPane extends JPanel {
           * @author <a href="mailto:[email protected]">Stefan Alfons
           *         Kr&uuml;ger</a>
           */
-         public Envelope bestAllowedMapArea(Envelope env) {
+         public ReferencedEnvelope bestAllowedMapArea(ReferencedEnvelope env) {
                  if (getWidth() == 0)
                          return env;
                  if (env == null)
                          return null;
-Line 765 
 public class XMapPane extends JPanel {
+Line 816 
 public class XMapPane extends JPanel {
                  }
                  final Envelope maxAllowedExtend = getMaxExtend();
+                 /*
+                  * If a maxAllowedExtend is set, we have to honour that...
+                  */
+                 Envelope lastCalculatedArea = null;
                  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())) {
+                                 && !Double.isNaN(newArea.getMaxY())
-                         /*
+                                  ) // Due to Double precision problems, this may iterate for ever
-                          * If a maxExtend is set, we have to honour that...
+                 {
-                          */
+                         if (newArea.equals(lastCalculatedArea))
+                                 break;
+                         // Check that we are not iterating for ever due to double precision rounding errors
+                         lastCalculatedArea = newArea;
                          // Exceeds top? Move down and maybe cut
                          if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
                                  final double divY = newArea.getMaxY()
-Line 794 
 public class XMapPane extends JPanel {
+Line 854 
 public class XMapPane extends JPanel {
                                          // LOGGER.debug("and fix aspect ratio");
-                                         newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
+                                         newArea = JTSUtil.fixAspectRatio(getVisibleRect(),
-                                                         false);
+                                                         new ReferencedEnvelope(newArea, env
+                                                                         .getCoordinateReferenceSystem()), false);
                                  }
                          }
-Line 818 
 public class XMapPane extends JPanel {
+Line 879 
 public class XMapPane extends JPanel {
                                          // LOGGER.debug("and fix aspect ratio");
-                                         newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
+                                         newArea = JTSUtil.fixAspectRatio(getVisibleRect(),
-                                                         false);
+                                                         new ReferencedEnvelope(newArea, env
+                                                                         .getCoordinateReferenceSystem()), false);
                                  }
                          }
-Line 844 
 public class XMapPane extends JPanel {
+Line 906 
 public class XMapPane extends JPanel {
                                          // LOGGER.debug("and fix aspect ratio");
-                                         newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
+                                         newArea = JTSUtil.fixAspectRatio(getVisibleRect(),
-                                                         false);
+                                                         new ReferencedEnvelope(newArea, env
+                                                                         .getCoordinateReferenceSystem()), false);
                                  }
                          }
-Line 870 
 public class XMapPane extends JPanel {
+Line 933 
 public class XMapPane extends JPanel {
                                          // LOGGER.debug("and fix aspect ratio");
-                                         newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
+                                         newArea = JTSUtil.fixAspectRatio(getVisibleRect(),
-                                                         false);
+                                                         new ReferencedEnvelope(newArea, env
+                                                                         .getCoordinateReferenceSystem()), false);
                                  }
                          }
                  }
-                 return newArea;
+                 return new ReferencedEnvelope(newArea, env
+                                 .getCoordinateReferenceSystem());
          }
          /**
-Line 904 
 public class XMapPane extends JPanel {
+Line 971 
 public class XMapPane extends JPanel {
                          bgExecuter.dispose();
                  }
-                 if (localExecuter != null) {
+                 if (localExecuter.isRunning()) {
                          int i = 0;
                          localExecuter.cancelTask();
                          while (i++ < 10 && localExecuter.isRunning()) {
                                  try {
-                                         Thread.sleep(100);
+                                         Thread.sleep(200);
                                  } catch (final InterruptedException e) {
-                                         // TODO Auto-generated catch block
+                                         LOGGER
-                                         e.printStackTrace();
+                                                         .warn(
+                                                                         "while XMapPane we are waiting for the localExcutor to stop",
+                                                                         e);
                                  }
                          }
                          if (localExecuter.isRunning()) {
-                                 System.out
+                                 LOGGER
-                                                 .println("BAD BAD BAD... still running the thread....");
+                                                 .warn("localExecutor Thread still running after 2s! Continuing anyways...");
                          }
                          localExecuter.dispose();
                  }
-                 //
-                 // if (bgImage != null) {
-                 // bgImage = dispose(bgImage);
-                 // bgImage = null;
-                 // // LangUtil.gcTotal();
-                 // }
-                 //
-                 // if (localImage != null) {
-                 // localImage = dispose(localImage);
-                 // localImage = null;
-                 // // LangUtil.gcTotal();
-                 // }
-                 //
-                 // if (finalImage != null) {
-                 // finalImage = dispose(finalImage);
-                 // finalImage = null;
-                 // // LangUtil.gcTotal();
-                 // }
-                 //
-                 // if (preFinalImage != null) {
-                 // preFinalImage = dispose(preFinalImage);
-                 // preFinalImage = null;
-                 // }
-                 disposeImages();
-                 // LangUtil.gcTotal();
+                 disposeImages();
-                 // Alle mapPaneListener entfernen
+                 // Remove all mapPaneListeners that have registered with us
                  mapPaneListeners.clear();
-                 removeMouseMotionListener(zoomMapPaneMouseListener);
+                 removeMouseMotionListener(xMapPaneMouseListener);
-                 removeMouseListener(zoomMapPaneMouseListener);
+                 removeMouseListener(xMapPaneMouseListener);
                  if (localContext != null)
-                         getContext().clearLayerList();
+                         getMapContext().clearLayerList();
                  if (bgContext != null)
                          getBgContext().clearLayerList();
-Line 968 
 public class XMapPane extends JPanel {
+Line 1013 
 public class XMapPane extends JPanel {
           */
          protected void drawRectangle(final Graphics graphics, final Point startPos,
                          final Point e) {
+                 drawRectangle(graphics, startPos, e, Color.WHITE, false);
+         }
+         /**
+          * Draws a rectangle in XOR mode from the origin at {@link #startPos} to the
+          * given point. All in screen coordinates.
+          */
+         protected void drawRectangle(final Graphics graphics, final Point startPos,
+                         final Point e, Color color, boolean fill) {
                  if (!isWellDefined())
                          return;
-Line 983 
 public class XMapPane extends JPanel {
+Line 1037 
 public class XMapPane extends JPanel {
                  if (width == 0 && height == 0)
                          return;
-                 graphics.setXORMode(Color.WHITE);
+                 graphics.setXORMode(color);
+                 if (fill) {
+                         graphics.fillRect(left, bottom, width, height);
+                         graphics.setXORMode(Color.WHITE);
+                 }
                  graphics.drawRect(left, bottom, width, height);
          }
-Line 995 
 public class XMapPane extends JPanel {
+Line 1055 
 public class XMapPane extends JPanel {
           *
           * @param g
           *            Graphics2D to paint the preview into
-          *
-          * @param state
-          *            Max be {@link #ZOOM_IN} or {@link #ZOOM_OUT}
           */
          protected boolean drawScaledPreviewImage_Zoom(final Graphics2D graphics) {
-                 if (quickPreviewHint == 0)
+                 // if (1 == 1)return false;
-                         return false;
+                 // if (quickPreviewHint == 0)
+                 // return false;
-                 graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-                                 RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
-                 graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                                 RenderingHints.VALUE_ANTIALIAS_OFF);
-                 graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
-                                 RenderingHints.VALUE_RENDER_SPEED);
                  if (oldMapArea == null)
                          return false;
+                 if (getPreFinalImage() == null)
+                         return false;
                  final Rectangle visibleArea = getVisibleRect();
                  // Calculate the oldMapArea in the current WindowCoordinates:
                  final Envelope oldMapWindow = tranformGeoToWindow(oldMapArea.getMinX(),
                                  oldMapArea.getMinY(), oldMapArea.getMaxX(), oldMapArea
-                                                 .getMaxY(), null);
+                                                 .getMaxY());
                  final int xx1 = (int) Math.round(oldMapWindow.getMinX());
                  final int yy1 = (int) Math.round(oldMapWindow.getMinY());
                  final int xx2 = (int) Math.round(oldMapWindow.getMaxX());
                  final int yy2 = (int) Math.round(oldMapWindow.getMaxY());
+                 graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+                                 RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
+                 graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                                 RenderingHints.VALUE_ANTIALIAS_OFF);
+                 graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
+                                 RenderingHints.VALUE_RENDER_SPEED);
                  graphics.drawImage(getPreFinalImage(), xx1, yy1, xx2, yy2,
                                  (int) visibleArea.getMinX(), (int) visibleArea.getMinY(),
                                  (int) visibleArea.getMaxX(), (int) visibleArea.getMaxY(),
-Line 1034 
 public class XMapPane extends JPanel {
+Line 1095 
 public class XMapPane extends JPanel {
                  final Rectangle painedArea = new Rectangle(xx1, yy1, xx2 - xx1, yy2
                                  - yy1);
-                 SwingUtil.clearAround(graphics, painedArea, visibleArea);
+                 SwingUtil.clearAround(graphics, painedArea, visibleArea,
+                                 getMapBackgroundColor());
                  addGadgets(graphics, true);
-                 quickPreviewHint = 0;
+                 // quickPreviewHint = 0;
                  repaintTimer.restart();
-                 graphics.dispose();
                  // Something has been drawn
                  return true;
          }
-Line 1056 
 public class XMapPane extends JPanel {
+Line 1116 
 public class XMapPane extends JPanel {
           * Lazyly initializes a {@link BufferedImage} for the background renderer.
           */
          private Image getBgImage() {
-                 //
+                 if (bgImage == null) {
-                 // if (bgImage == null) {
+                         bgImage = new BufferedImage(getVisibleRect().width,
-                 // bgImage = createImage(getBounds().width, getBounds().height);
+                                         getVisibleRect().height, IMAGETYPE);
-                 // }
+                         SwingUtil.clearImage(finalImage, getMapBackgroundColor());
+                 }
                  return bgImage;
          }
-         public MapContext getContext() {
+         public MapContext getMapContext() {
                  if (localContext == null) {
                          setLocalContext(new DefaultMapContext());
                  }
-Line 1075 
 public class XMapPane extends JPanel {
+Line 1136 
 public class XMapPane extends JPanel {
                  //
                  if (finalImage == null) {
                          // Rectangle curPaintArea = getVisibleRect();
-                         finalImage = new BufferedImage(getBounds().width,
+                         finalImage = new BufferedImage(getVisibleRect().width,
-                                         getBounds().height, IMAGETYPE);
+                                         getVisibleRect().height, IMAGETYPE);
+                         SwingUtil.clearImage(finalImage, getMapBackgroundColor());
-                         requestStartRendering();
+                         // requestStartRendering();
                  }
                  return finalImage;
          }
-         public RenderingHints getJava2dHints() {
-                 return java2dHints;
-         }
          /**
           * Lazyly initializes a {@link BufferedImage} for the background renderer.
           */
          private BufferedImage getLocalImage() {
                  if (localImage == null) {
-                         localImage = new BufferedImage(getBounds().width,
+                         localImage = new BufferedImage(getVisibleRect().width,
-                                         getBounds().height, IMAGETYPE_withAlpha);
+                                         getVisibleRect().height, IMAGETYPE_withAlpha);
+                         SwingUtil.clearImage(localImage, getMapBackgroundColor());
                  }
                  return localImage;
-Line 1110 
 public class XMapPane extends JPanel {
+Line 1169 
 public class XMapPane extends JPanel {
                          ReferencedEnvelope mapArea_ = null;
                          try {
                                  mapArea_ = localContext.getLayerBounds();
-                         } catch (final IOException e) {
+                         } catch (final Exception e) {
-                                 LOGGER.warn("context.getLayerBounds()", e);
+                                 LOGGER.warn("localContext.getLayerBounds()", e);
+                         }
+                         if (mapArea_ == null && bgContext != null) {
+                                 try {
+                                         mapArea_ = bgContext.getLayerBounds();
+                                 } catch (final IOException e) {
+                                         LOGGER.warn("bgContext.getLayerBounds()", e);
+                                 }
                          }
                          if (mapArea_ != null) {
-                                 mapImageInvalid = true; /* note we need to redraw */
-                                 // setMapArea(mapArea_); // results in a loop
                                  mapArea = bestAllowedMapArea(mapArea_);
+                                 requestStartRendering();
                          }
                  }
                  if (mapArea == null)
                          return null;
+                 // TODO is needed at all, this should go to setMapArea maybe
                  if (localContext.getCoordinateReferenceSystem() == null)
                          try {
                                  localContext.setCoordinateReferenceSystem(GeoImportUtil
                                                  .getDefaultCRS());
-                         } catch (TransformException e) {
+                         } catch (final Exception e) {
-                                 // TODO Auto-generated catch block
+                                 throw new RuntimeException("setting context CRS:", e);
-                                 e.printStackTrace();
-                         } catch (FactoryException e) {
-                                 // TODO Auto-generated catch block
-                                 e.printStackTrace();
                          }
                  return new ReferencedEnvelope(mapArea, localContext
-Line 1141 
 public class XMapPane extends JPanel {
+Line 1204 
 public class XMapPane extends JPanel {
          }
          /**
-          * Returns the background {@link Color} of the map pane. Default is white.
+          * Returns the background {@link Color} of the map pane. If not set, the
+          * methods looks for a parent component and will use its background color.
+          * If no parent component is available, WHITE is returned.
           **/
          public Color getMapBackgroundColor() {
+                 if (mapBackgroundColor == null) {
+                         if (getParent() != null)
+                                 return getParent().getBackground();
+                         else
+                                 return Color.WHITE;
+                 }
                  return mapBackgroundColor;
          }
-Line 1170 
 public class XMapPane extends JPanel {
+Line 1241 
 public class XMapPane extends JPanel {
          public Envelope getMaxExtend() {
                  if (maxExtend == null) {
+                         // The next command may take long time!
+                         // long start = System.currentTimeMillis();
                          final ReferencedEnvelope layerBounds = GTUtil
                                          .getVisibleLayoutBounds(localContext);
+                         //
+                         // LOGGER.info(
+                         // (System.currentTimeMillis()-start)+"m to get maxExtend");
+                         //
                          if (layerBounds == null) {
-                                 // TODO Last fallback could be the CRS valid area
+                                 // // TODO Last fallback could be the CRS valid area
                                  return null;
                          }
-                         // Kartenbereich um 10% vergroessern
+                         return JTSUtil
-                         return JTSUtil.fixAspectRatio(this.getBounds(), JTSUtil
+                                         .fixAspectRatio(getVisibleRect(), addDefaultMargin(layerBounds), true);
-                                         .expandEnvelope(layerBounds, 0.1), true);
                  }
                  return maxExtend;
          }
-Line 1207 
 public class XMapPane extends JPanel {
+Line 1285 
 public class XMapPane extends JPanel {
          }
          private Image getPreFinalImage() {
-                 // if (preFinalImage == null) {
-                 //
-                 // // Rectangle curPaintArea = getVisibleRect();
-                 // // preFinalImage = new BufferedImage(curPaintArea.width,
-                 // // curPaintArea.height, BufferedImage.TYPE_INT_RGB);
-                 //
-                 // preFinalImage = createImage(getBounds().width, getBounds().height);
-                 //
-                 // requestStartRendering();
-                 // }
                  return preFinalImage;
          }
-Line 1244 
 public class XMapPane extends JPanel {
+Line 1312 
 public class XMapPane extends JPanel {
                  return new AffineTransform(screenToWorld);
          }
-         public int getState() {
+         // public int getState() {
-                 return state;
+         // return state;
-         }
+         // }
+         //
-         /**
+         // /**
-          * Liefert den statisch eingestellten Cursor, der unabhaengig von der
+         // * Liefert den statisch eingestellten Cursor, der unabhaengig von der
-          * eingestellten MapPane-Aktion (Zoom, Auswahl, ...) verwendet wird.
+         // * eingestellten MapPane-Aktion (Zoom, Auswahl, ...) verwendet wird.
-          *
+         // *
-          * @return {@code null}, wenn kein statischer Cursor verwendet, sondern der
+         // * @return {@code null}, wenn kein statischer Cursor verwendet, sondern
-          *         Cursor automatisch je nach MapPane-Aktion eingestellt wird.
+         // der
-          */
+         // * Cursor automatisch je nach MapPane-Aktion eingestellt wird.
-         public Cursor getStaticCursor() {
+         // */
-                 return this.staticCursor;
+         // public Cursor getStaticCursor() {
-         }
+         // return this.staticCursor;
+         // }
          public AffineTransform getWorldToScreenTransform() {
                  if (worldToScreen == null) {
-Line 1293 
 public class XMapPane extends JPanel {
+Line 1362 
 public class XMapPane extends JPanel {
           * {@link XMapPane} is visible and has bounds set.
           */
          public boolean isWellDefined() {
                  try {
+                         if (getMapContext() == null)
-                         if (getContext() == null)
-                                 return false;
-                         if (getContext().getLayerCount() <= 0)
                                  return false;
-                         if (getMapArea() == null)
+                         if (getMapContext().getLayerCount() <= 0)
                                  return false;
-                         if (getBounds().getWidth() == 0)
+                         if (getVisibleRect().getWidth() == 0)
                                  return false;
-                         if (getBounds().getHeight() == 0)
+                         if (getVisibleRect().getHeight() == 0)
                                  return false;
+                         // if (getMapArea() == null)
+                         // return false;
                  } catch (final Exception e) {
                          return false;
                  }
                  return true;
          }
-         public void mouseDragged(final Point startPos, final Point lastPos,
+         /**
-                         final MouseEvent event) {
+          * Usually called from {@link XMapPaneAction_Pan} to pan the image.
+          *
-                 if ((getState() == XMapPane.PAN)
+          * @param startPos
-                                 || ((event.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) {
+          *            in screen coordinates
+          * @param lastPos
-                         if (getCursor() != SwingUtil.PANNING_CURSOR) {
+          *            in screen coordinates
-                                 setCursor(SwingUtil.PANNING_CURSOR);
+          */
+         public void pan(final int dX, final int dY) {
-                                 // While panning, we deactivate the rendering. So the tasts are
-                                 // ready to start when the panning os done.
+                 // Panning needs a panning coursor
-                                 if (bgExecuter != null)
+                 if (getCursor() != SwingUtil.PANNING_CURSOR) {
-                                         bgExecuter.cancelTask();
+                         setCursor(SwingUtil.PANNING_CURSOR);
-                                 if (localExecuter != null)
-                                         localExecuter.cancelTask();
+                         // While panning, we deactivate the rendering. So the tasks are
-                         }
+                         // ready to start when the panning is finished.
+                         if (bgExecuter != null && bgExecuter.isRunning())
-                         if (lastPos.x > 0 && lastPos.y > 0) {
+                                 bgExecuter.cancelTask();
-                                 final int dx = event.getX() - lastPos.x;
+                         if (localExecuter.isRunning())
-                                 final int dy = event.getY() - lastPos.y;
+                                 localExecuter.cancelTask();
-                                 // TODO Stop dragging when the drag would not be valid...
-                                 // boolean dragValid = true;
-                                 // // check if this panning results in a valid mapArea
-                                 // {
-                                 // Rectangle winBounds = xMapPane.getBounds();
-                                 // winBounds.translate(xMapPane.imageOrigin.x,
-                                 // -xMapPane.imageOrigin.y);
-                                 // Envelope newMapAreaBefore = xMapPane.tranformWindowToGeo(
-                                 // winBounds.x, winBounds.y, winBounds.x
-                                 // + winBounds.width, winBounds.y
-                                 // + winBounds.height);
-                                 //
-                                 //
-                                 // winBounds = xMapPane.getBounds();
-                                 // Point testIng = new Point(xMapPane.imageOrigin);
-                                 // testIng.translate(dx, dy);
-                                 // winBounds.translate(testIng.x, -testIng.y);
-                                 // Envelope newMapAreaAfter = xMapPane.tranformWindowToGeo(
-                                 // winBounds.x, winBounds.y, winBounds.x
-                                 // + winBounds.width, winBounds.y
-                                 // + winBounds.height);
-                                 //
-                                 // // If the last drag doesn't change the MapArea anymore cancel
-                                 // it.
-                                 // if (xMapPane.bestAllowedMapArea(newMapAreaAfter).equals(
-                                 // xMapPane.bestAllowedMapArea(newMapAreaBefore))){
-                                 // dragValid = false;
-                                 // return;
-                                 // }
-                                 // }
-                                 imageOrigin.translate(dx, dy);
-                                 updateFinalImage();
-                                 repaint();
-                         }
-                 } else if ((getState() == XMapPane.ZOOM_IN)
-                                 || (getState() == XMapPane.ZOOM_OUT)
-                                 || (getState() == XMapPane.SELECT_ALL)
-                                 || (getState() == XMapPane.SELECT_TOP)
-                 // || (getState() == XMapPane.SELECT_ONE_FROM_TOP)
-                 ) {
-                         final Graphics graphics = getGraphics();
-                         drawRectangle(graphics, startPos, event.getPoint());
-                         if ((lastPos.x > 0) && (lastPos.y > 0)) {
-                                 drawRectangle(graphics, startPos, lastPos);
-                         }
-                         graphics.dispose();
                  }
+                 //
+                 // if (lastPos.x > 0 && lastPos.y > 0) {
+                 // final int dx = event.getX() - lastPos.x;
+                 // final int dy = event.getY() - lastPos.y;
+                 // TODO Stop dragging when the drag would not be valid...
+                 // boolean dragValid = true;
+                 // // check if this panning results in a valid mapArea
+                 // {
+                 // Rectangle winBounds = xMapPane.getBounds();
+                 // winBounds.translate(xMapPane.imageOrigin.x,
+                 // -xMapPane.imageOrigin.y);
+                 // Envelope newMapAreaBefore = xMapPane.tranformWindowToGeo(
+                 // winBounds.x, winBounds.y, winBounds.x
+                 // + winBounds.width, winBounds.y
+                 // + winBounds.height);
+                 //
+                 //
+                 // winBounds = xMapPane.getBounds();
+                 // Point testIng = new Point(xMapPane.imageOrigin);
+                 // testIng.translate(dx, dy);
+                 // winBounds.translate(testIng.x, -testIng.y);
+                 // Envelope newMapAreaAfter = xMapPane.tranformWindowToGeo(
+                 // winBounds.x, winBounds.y, winBounds.x
+                 // + winBounds.width, winBounds.y
+                 // + winBounds.height);
+                 //
+                 // // If the last drag doesn't change the MapArea anymore cancel
+                 // it.
+                 // if (xMapPane.bestAllowedMapArea(newMapAreaAfter).equals(
+                 // xMapPane.bestAllowedMapArea(newMapAreaBefore))){
+                 // dragValid = false;
+                 // return;
+                 // }
+                 // }
+                 getImageOrigin().translate(dX, dY);
+                 updateFinalImage();
+                 repaint();
+                 // }
+                 // } else if ((getState() == XMapPane.ZOOM_IN)
+                 // || (getState() == XMapPane.ZOOM_OUT)
+                 // || (getState() == XMapPane.SELECT_ALL)
+                 // || (getState() == XMapPane.SELECT_TOP)) {
+                 //
+                 // // Draws a rectangle
+                 // final Graphics2D graphics = (Graphics2D) getGraphics();
+                 // drawRectangle(graphics, startPos, event.getPoint());
+                 // if ((lastPos.x > 0) && (lastPos.y > 0))
+                 // drawRectangle(graphics, startPos, lastPos);
+                 // graphics.dispose();
+                 // }
          }
          /**
           * Called by the {@link RenderingExecutor} when rendering was cancelled.
           */
          public void onRenderingCancelled() {
+                 // LOGGER.debug("Rendering cancelled");
                  repaintTimer.stop();
-                 LOGGER.debug("Rendering cancelled");
          }
          /**
           * Called by the {@link RenderingExecutor} when rendering has been
           * completed.
+          *
+          * @param l
+          *            long ms the rendering took
           */
-         public void onRenderingCompleted() {
+         public void onRenderingCompleted(final long l) {
+                 lastRenderingDuration = (lastRenderingDuration + l) / 2;
+                 // LOGGER
+                 // .debug("complete rendering after " + lastRenderingDuration
+                 // + "ms");
                  repaintTimer.stop();
-                 updateFinalImage();
-                 repaint();
+                 // We "forget" about an exception every time we complete a rendering
+                 // thread successfully
                  if (renderingErrors.size() > 0)
                          renderingErrors.remove(0);
+                 updateFinalImage();
+                 repaint();
          }
          /**
-Line 1420 
 public class XMapPane extends JPanel {
+Line 1498 
 public class XMapPane extends JPanel {
           * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
           */
          public void onRenderingFailed(final Exception renderingError) {
-                 this.renderingErrors.add(renderingError);
+                 // Store the exceptions so we can show it to the user:
+                 if (!(renderingError instanceof java.lang.IllegalArgumentException && renderingError
+                                 .getMessage().equals(
+                                                 "Argument \"sourceCRS\" should not be null.")))
+                         this.renderingErrors.add(renderingError);
                  if (renderingErrors.size() > 3)
                          renderingErrors.remove(0);
                  repaintTimer.stop();
                  LOGGER.warn("Rendering failed", renderingError);
                  updateFinalImage();
                  repaint();
          }
-         public void onRenderingPending() {
-                 // LOGGER.debug("Pending rendering updates the preview...");
-                 updateFinalImage();
-                 repaint();
-         }
          @Override
          protected void paintComponent(final Graphics g) {
-                 if (!acceptsRepaintCalls)
-                         return;
                  // Maybe update the cursor and maybe stop the repainting timer
                  updateCursor();
+                 if (!acceptsRepaintCalls)
+                         return;
+                 if (!isWellDefined())
+                         return;
+                 //
+                 // if (paneResized) {
+                 // // ((Graphics2D) g).setBackground(getMapBackgroundColor());
+                 // // g.clearRect(0, 0, getVisibleRect().width,
+                 // getVisibleRect().height);
+                 // return;
+                 // }
                  // super.paintComponent(g); // candidate for removal
                  boolean paintedSomething = false;
-Line 1455 
 public class XMapPane extends JPanel {
+Line 1545 
 public class XMapPane extends JPanel {
                          // If the new mapArea and the oldMapArea intersect, we can draw some
                          // quick scaled preview to make the user feel that something is
                          // happening.
-                         if (mapAreaChanged && oldMapArea != null
+                         if (lastRenderingDuration > PRESCALE_MINTIME && mapAreaChanged
+                                         && oldMapArea != null
                                          && getMapArea().intersects(oldMapArea)
-                                         & !getMapArea().equals(oldMapArea)) {
+                                         && !getMapArea().equals(oldMapArea) && !paneResized) {
                                  mapAreaChanged = false;
-                                 if (getMapArea().covers(oldMapArea)) {
+                                 // if (getMapArea().covers(oldMapArea)) {
-                                         setQuickPreviewHint(ZOOM_OUT);
+                                 // // quickPreviewHint = ZOOM_OUT;
-                                         paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
+                                 // paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D)
-                                 } else if (oldMapArea.covers(getMapArea())) {
+                                 // g);
-                                         setQuickPreviewHint(ZOOM_IN);
+                                 // } else if (oldMapArea.covers(getMapArea())) {
-                                         paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
+                                 // quickPreviewHint = ZOOM_IN;
-                                 }
+                                 paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
+                                 // }
-                         }
-                         if (paneResized) {
-                                 paneResized = false;
-                                 disposeImages();
                          }
-                         // Start the Threads and Timers to render the image
-                         requestStartRendering();
                  }
                  if (!paintedSomething) {
                          g.drawImage(getFinalImage(), 0, 0, null);
-                         g.dispose(); // cand. for removal
                          paintedSomething = true; // cand. for removal
                  }
-Line 1535 
 public class XMapPane extends JPanel {
+Line 1615 
 public class XMapPane extends JPanel {
          }
-         /**
-          * Performs a {@value #PAN} action. During panning, the displacement is
-          * stored in {@link #imageOrigin} object. Calling {@link #performPan()} will
-          * reset the offset and call {@link #setMapArea(Envelope)}.
-          */
-         public void performPan() {
-                 final Rectangle winBounds = getBounds();
-                 winBounds.translate(-imageOrigin.x, -imageOrigin.y);
-                 final Envelope newMapArea = tranformWindowToGeo(winBounds.x,
-                                 winBounds.y, winBounds.x + winBounds.width, winBounds.y
-                                                 + winBounds.height);
-                 imageOrigin.x = 0;
-                 imageOrigin.y = 0;
-                 if (!setMapArea(newMapArea)) {
-                         /**
-                          * If setMapArea returns true, the finalImage is updated anyways.
-                          * This if-case exists to ensure that we repaint a correct image
-                          * even if the new panning area has been denied.
-                          */
-                         updateFinalImage();
-                         repaint();
-                 }
-                 if (getCursor() == SwingUtil.PANNING_CURSOR)
-                         setCursor(SwingUtil.PAN_CURSOR);
-         }
          //
          // /**
-         // * Nuetzlich wenn die Componente gedruckt (z.B. wenn ein Screenshot
+         // * Performs a {@value #PAN} action. During panning, the displacement is
-         // gemacht
+         // * stored in {@link #imageOrigin} object. Calling {@link #performPan()}
-         // * wird) wird. Dann werden wird der Hintergrund auf WEISS gesetzt.
+         // will
-         // *
+         // * reset the offset and call {@link #setMapArea(Envelope)}.
-         // * @author <a href="mailto:[email protected]">Stefan Alfons
-         // * Kr&uuml;ger</a>
          // */
-         // @Override
+         // public void performPan() {
-         // public void print(final Graphics g) {
+         //
-         // final Color orig = getBackground();
+         // final Rectangle winBounds = getVisibleRect();
-         // setBackground(Color.WHITE);
          //
-         // // wrap in try/finally so that we always restore the state
+         // winBounds.translate(-imageOrigin.x, -imageOrigin.y);
-         // try {
+         // final Envelope newMapArea = tranformWindowToGeo(winBounds.x,
-         // super.print(g);
+         // winBounds.y, winBounds.x + winBounds.width, winBounds.y
-         // } finally {
+         // + winBounds.height);
-         // setBackground(orig);
+         //
+         // imageOrigin.x = 0;
+         // imageOrigin.y = 0;
+         //
+         // if (!setMapArea(newMapArea)) {
+         // /**
+         // * If setMapArea returns true, the finalImage is updated anyways.
+         // * This if-case exists to ensure that we repaint a correct image
+         // * even if the new panning area has been denied.
+         // */
+         // updateFinalImage();
+         // repaint();
          // }
+         //
+         // if (getCursor() == SwingUtil.PANNING_CURSOR)
+         // setCursor(SwingUtil.PAN_CURSOR);
          // }
          /**
-Line 1605 
 public class XMapPane extends JPanel {
+Line 1666 
 public class XMapPane extends JPanel {
          private void requestStartRendering() {
                  if (bgExecuter != null)
                          bgExecuter.cancelTask();
-                 if (localExecuter != null)
-                         localExecuter.cancelTask();
+                 localExecuter.cancelTask();
+                 mapImageInvalid = true;
+                 if (paneResized) {
+                         paneResized = false;
+                         disposeImages();
+                 }
                  requestStartRendering = true;
          }
- //
- //      /**
+         /**
- //       * Berechnet die Transformation zwischen Fenster- und Karten-Koordinaten
+          * Calculate the affine transforms used to convert between world and pixel
- //       * neu.
+          * coordinates. The calculations here are very basic and assume a cartesian
- //       */
+          * reference system.
- //      protected void resetTransforms() {
+          * <p>
- //              if (getMapArea() == null || getWidth() == 0 || getHeight() == 0)
+          * Tne transform is calculated such that {@code envelope} will be centred in
- //                      return;
+          * the display
- //
+          *
- //              // We store the last Transform
+          * @param envelope
- //              oldScreenToWorld = screenToWorld;
+          *            the current map extent (world coordinates)
- //
+          * @param paintArea
- //              this.screenToWorld = new AffineTransform(
+          *            the current map pane extent (screen units)
- //              // Genauso wie die Fenster-Koordinaten, werden die Longitude-Koordinaten
+          */
- //                              // nach rechts (Osten) hin groesser
+         private void resetTransforms() {
- //                              // --> positive Verschiebung
+                 // System.out
- //                              getMapArea().getWidth() / getWidth(),
+                 // .println("paintArea in resetTeansofrms = " + getVisibleRect());
- //                              // keine Verzerrung
+                 if (!isWellDefined())
- //                              0.0, 0.0,
+                         return;
- //                              // Waehrend die Fenster-Koordinaten nach unten hin groesser
- //                              // werden,
+                 if (mapArea == null)
- //                              // werden Latitude-Koordinaten nach Sueden hin keiner
+                         return;
- //                              // --> negative Verschiebung
- //                              -getMapArea().getHeight() / getHeight(),
+                 final ReferencedEnvelope refMapEnv = new ReferencedEnvelope(mapArea,
- //                              // Die Longitude-Koordinaten werden nach Osten hin groesser
+                                 getMapContext().getCoordinateReferenceSystem());
- //                              // --> obere linke Ecke des Fensters hat also den Minimalwert
- //                              getMapArea().getMinX(),
+                 worldToScreen = RendererUtilities.worldToScreenTransform(refMapEnv,
- //                              // Die Latitude-Koordinaten werden nach Norden hin groesser
+                                 getVisibleRect());
- //                              // --> obere linke Ecke des Fensters hat also den Maximalwert
- //                              getMapArea().getMaxY());
+                 try {
- //
+                         screenToWorld = worldToScreen.createInverse();
- //              try {
- //                      this.worldToScreen = screenToWorld.createInverse();
+                 } catch (final NoninvertibleTransformException ex) {
- //              } catch (final NoninvertibleTransformException e) {
+                         LOGGER
- //                      LOGGER.error(e);
+                                         .error("can't invert worldToScreen to get screenToWorld!",
- //              }
+                                                         ex);
- //      }
+                 }
+         }
-     /**
-      * Calculate the affine transforms used to convert between
-      * world and pixel coordinates. The calculations here are very
-      * basic and assume a cartesian reference system.
-      * <p>
-      * Tne transform is calculated such that {@code envelope} will
-      * be centred in the display
-      *
-      * @param envelope the current map extent (world coordinates)
-      * @param paintArea the current map pane extent (screen units)
-      */
-     private void resetTransforms() {
-         ReferencedEnvelope refEnv = new ReferencedEnvelope(mapArea, getContext().getCoordinateReferenceSystem());
-         Rectangle paintArea = getBounds();
-         double xscale = paintArea.getWidth() / refEnv.getWidth();
-         double yscale = paintArea.getHeight() / refEnv.getHeight();
-         double scale = Math.min(xscale, yscale);
-         double xoff = refEnv.getMedian(0) * scale - paintArea.getCenterX();
-         double yoff = refEnv.getMedian(1) * scale + paintArea.getCenterY();
-         worldToScreen = new AffineTransform(scale, 0, 0, -scale, -xoff, yoff);
-         try {
-             screenToWorld = worldToScreen.createInverse();
-         } catch (NoninvertibleTransformException ex) {
-             ex.printStackTrace();
-         }
-     }
          public void setBgContext(final MapContext context) {
-Line 1700 
 public class XMapPane extends JPanel {
+Line 1731 
 public class XMapPane extends JPanel {
                  this.bgContext = context;
                  if (context != null) {
-                         setMapArea(bgContext.getAreaOfInterest());
+                         // setMapArea(bgContext.getAreaOfInterest());
                          this.bgContext.addMapLayerListListener(bgContextListener);
-Line 1709 
 public class XMapPane extends JPanel {
+Line 1740 
 public class XMapPane extends JPanel {
                                  mapLayer.addMapLayerListener(bgMapLayerListener);
                          }
                  }
-                 mapImageInvalid = true;
-                 repaint();
+                 requestStartRendering();
          }
          public void setJava2dHints(final RenderingHints java2dHints) {
                  this.java2dHints = java2dHints;
          }
-         /**
-          *
-          * @param context
-          */
          public void setLocalContext(final MapContext context) {
                  // Remove the default listener from the old context
                  if (this.localContext != null) {
-Line 1736 
 public class XMapPane extends JPanel {
+Line 1763 
 public class XMapPane extends JPanel {
                  if (context != null) {
-                         setMapArea(localContext.getAreaOfInterest());
+                         // setMapArea(localContext.getAreaOfInterest());
-                         localRenderer.setContext(localContext);
+                         getLocalRenderer().setContext(localContext);
                          this.localContext.addMapLayerListListener(localContextListener);
-Line 1748 
 public class XMapPane extends JPanel {
+Line 1775 
 public class XMapPane extends JPanel {
                          }
                  }
+                 requestStartRendering();
+         }
+         public void setBorder(final Border b) {
+                 super.setBorder(b);
+         }
+         /**
+          * Triggers to repaint (fast) and re-render (slow) the JMapPane.
+          */
+         public void refresh() {
                  mapImageInvalid = true;
                  repaint();
          }
+         // /**
+         // * Triggers to use new {@link GTRenderer} and refresh the map. Should be
+         // * called after {@link Style}s have been changed because GTRenderer is
+         // * otherwise not working well.
+         // */
+         // public void refreshRenderers() {
+         // localRenderer = GTUtil.createGTRenderer();
+         // setLocalContext(getMapContext());
+         // mapImageInvalid = true;
+         // repaint();
+         // }
          /**
+          * Set the new map area.
+          *
           * @param newMapArea
           * @return <code>true</code> if the mapArea has been changed and a repaint
           *         has been triggered.
           */
          public boolean setMapArea(final Envelope newMapArea) {
+                 if (newMapArea == null)
+                         return false;
+                 if (getMapContext().getCoordinateReferenceSystem() == null)
+                         return false;
+                 return setMapArea(new ReferencedEnvelope(newMapArea, getMapContext()
+                                 .getCoordinateReferenceSystem()));
+         }
+         /**
+          * Set the new map area.
+          *
+          * @param newMapArea
+          * @return <code>true</code> if the mapArea has been changed and a repaint
+          *         has been triggered.
+          */
+         public boolean setMapArea(final ReferencedEnvelope newMapArea) {
                  if (newMapArea == null
                                  || bestAllowedMapArea(newMapArea).equals(mapArea)) {
-Line 1776 
 public class XMapPane extends JPanel {
+Line 1845 
 public class XMapPane extends JPanel {
                          return false;
                  }
+                 final Envelope candNew = bestAllowedMapArea(newMapArea);
                  // Testing, whether the difference if just minimal
                  if (mapArea != null) {
-                         final Envelope candNew = bestAllowedMapArea(newMapArea);
                          final double tolX = mapArea.getWidth() / 1000.;
                          final double tolY = mapArea.getHeight() / 1000.;
                          if ((candNew.getMinX() - tolX < mapArea.getMinX())
-Line 1798 
 public class XMapPane extends JPanel {
+Line 1868 
 public class XMapPane extends JPanel {
                          }
                  }
+                 // New map are is accepted:
                  oldMapArea = mapArea;
+                 mapArea = candNew;
-                 this.mapArea = bestAllowedMapArea(newMapArea);
+                 resetTransforms();
                  if (localContext != null) {
                          localContext.setAreaOfInterest(mapArea, localContext
-Line 1810 
 public class XMapPane extends JPanel {
+Line 1881 
 public class XMapPane extends JPanel {
                          bgContext.setAreaOfInterest(mapArea, localContext
                                          .getCoordinateReferenceSystem());
                  }
-                 resetTransforms();
-                 mapImageInvalid = true;
                  mapAreaChanged = true;
-                 repaint();
-                 // LOGGER.debug("New maparea = " + mapArea);
+                 repaint(200); // Do not remove it!
+                 requestStartRendering();
                  return true;
          }
-Line 1824 
 public class XMapPane extends JPanel {
+Line 1896 
 public class XMapPane extends JPanel {
           *
           * @param if <code>null</code>, white is used.
           */
-         public void setMapBackgroundColor(Color bgColor) {
+         public void setMapBackgroundColor(final Color bgColor) {
-                 if (bgColor == null)
-                         bgColor = Color.WHITE;
                  this.mapBackgroundColor = bgColor;
          }
-Line 1884 
 public class XMapPane extends JPanel {
+Line 1954 
 public class XMapPane extends JPanel {
          }
          // /** Stored the time used for the last real rendering in ms. **/
-         // private long lastRenderingDuration = Long.MAX_VALUE;
+         private long lastRenderingDuration = 1000;
+         private XMapPaneTool tool = null;
          /**
           * Set the minimum (nearest) allowed zoom scale. This is the bigger number
-Line 1901 
 public class XMapPane extends JPanel {
+Line 1972 
 public class XMapPane extends JPanel {
          }
          /**
-          *
+          * If <code>true</code>, allow the {@link XMapPane} to process #repaint()
-          * @param b
+          * requests. Otherwise the map will not paint anything and not start any
+          * rendering {@link Thread}s.
           */
          public void setPainting(final boolean b) {
                  acceptsRepaintCalls = b;
-         }
+                 if (acceptsRepaintCalls == true)
+                         repaint();
-         // /**
-         // * 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;
-         // }
-         public void setQuickPreviewHint(final int quickPreviewHint) {
-                 this.quickPreviewHint = quickPreviewHint;
          }
          private void setRendererHints(final Map<Object, Object> rendererHints) {
-Line 1928 
 public class XMapPane extends JPanel {
+Line 1987 
 public class XMapPane extends JPanel {
                          this.rendererHints = rendererHints;
          }
-         /**
+         // @Deprecated
-          * Enables/Disables the ZOOM Mouse Listener. Upates the Cursor and stops the
+         // public void setState(final int state) {
-          * repaint Timer if
+         // this.state = state;
-          *
+         //
-          * @param state
+         // // throw new RuntimeException("Old concept.. migrate to new concept!");
-          */
+         //
-         public void setState(final int state) {
+         // // xMapPaneMouseListener.setEnabled((state == ZOOM_IN
-                 this.state = state;
+         // // || state == ZOOM_OUT || state == PAN));
+         //
-                 zoomMapPaneMouseListener.setEnabled((state == ZOOM_IN
+         // // Je nach Aktion den Cursor umsetzen
-                                 || state == ZOOM_OUT || state == PAN));
+         // updateCursor();
+         // }
-                 // Je nach Aktion den Cursor umsetzen
+         public void configureMouse(MouseInputType type, XMapPaneAction action) {
-                 updateCursor();
+                 xMapPaneMouseListener.actions.put(type, action);
          }
          /**
-          * Standardmaessig wird der Cursor automatisch je nach MapPane-Aktion (Zoom,
+          * Configure the {@link XMapPaneTool} that active on the map. Passing
-          * Auswahl, ...) gesetzt. Mit dieser Methode kann ein statischer Cursor
+          * <code>null</code> will set the NO_ACTION tool.
-          * gesetzt werden, der unabhaengig von der aktuellen MapPanes-Aktion
+          */
-          * beibehalten wird. Um diesen statischen Cursor wieder zu entfernen, kann
+         public void setTool(XMapPaneTool tool) {
-          * {@code null} als Parameter uebergeben werden
+                 if (tool == null)
-          *
+                         tool = XMapPaneTool.NO_ACTION;
-          * @param cursor
+                 this.tool = tool;
-          *            Cursor
+                 xMapPaneMouseListener.configure(tool);
-          */
+                 setCursor(tool.getCursor());
-         public void setStaticCursor(final Cursor cursor) {
-                 this.staticCursor = cursor;
-                 if (cursor != null)
-                         super.setCursor(cursor);
          }
+         // /**
+         // * Standardmaessig wird der Cursor automatisch je nach MapPane-Aktion
+         // (Zoom,
+         // * Auswahl, ...) gesetzt. Mit dieser Methode kann ein statischer Cursor
+         // * gesetzt werden, der unabhaengig von der aktuellen MapPanes-Aktion
+         // * beibehalten wird. Um diesen statischen Cursor wieder zu entfernen, kann
+         // * {@code null} als Parameter uebergeben werden
+         // *
+         // * @param cursor
+         // * Cursor
+         // */
+         // public void setStaticCursor(final Cursor cursor) {
+         // this.staticCursor = cursor;
+         // if (cursor != null)
+         // super.setCursor(cursor);
+         // }
          /**
           * Starts rendering on one or two threads
           */
          private void startRendering() {
-                 if (!isWellDefined())
+                 if (!isWellDefined() || !acceptsRepaintCalls) {
+                         // if we are not ready to start rendering, try it again the next
+                         // time the timer is chacking the flag.
+                         requestStartRendering = true;
                          return;
+                 }
                  if (bgExecuter != null) {
                          // Stop all renderers
                          bgExecuter.cancelTask();
                  }
-                 if (localExecuter != null) {
+                 localExecuter.cancelTask();
-                         localExecuter.cancelTask();
-                 }
                  final Rectangle curPaintArea = getVisibleRect();
-Line 1998 
 public class XMapPane extends JPanel {
+Line 2073 
 public class XMapPane extends JPanel {
                          // (Graphics2D) getBgImage().getGraphics(), createGTRenderer);
                  }
-                 if (getContext() != null) {
+                 if (getMapContext() != null) {
                          // localExecuter = new RenderingExecutor(this, 150l);
                          // LOGGER.debug("starting local renderer:");
-                         localRenderer.setJava2DHints(getJava2dHints());
+                         getLocalRenderer().setJava2DHints(getJava2dHints());
-                         localRenderer.setRendererHints(getRendererHints());
+                         getLocalRenderer().setRendererHints(getRendererHints());
-                         ReferencedEnvelope areaOfInterest = getMapArea();
+                         final boolean submitted = localExecuter.submit(getMapArea(),
-                         final boolean submitted = localExecuter.submit(areaOfInterest,
                                          curPaintArea, (Graphics2D) getLocalImage().getGraphics(),
-                                         localRenderer, getWorldToScreenTransform());
+                                         getLocalRenderer());
                          if (submitted)
                                  repaintTimer.restart();
                          else
-                                 requestStartRendering = true; // Try to start rendering again in
+                                 requestStartRendering = true; // Try to start rendering
+                         // again in
                          // a moment
                  }
                  updateCursor();
          }
+         private RenderingHints getJava2dHints() {
+                 return java2dHints;
+         }
          /**
           * Transformiert einen Geo-Koordinaten-Bereich in Fenster-Koordinaten.
           *
-Line 2035 
 public class XMapPane extends JPanel {
+Line 2114 
 public class XMapPane extends JPanel {
           *            {@link #getScreenToWorld()} is used.
           */
          public Envelope tranformGeoToWindow(final double ox, final double oy,
-                         final double px, final double py,
+                         final double px, final double py) {
-                         final AffineTransform winToGeotransform) {
+                 final AffineTransform at = getWorldToScreenTransform();
-                 final AffineTransform at = winToGeotransform == null ? getScreenToWorld()
-                                 : winToGeotransform;
                  Point2D geoO;
-                 try {
+                 // try {
-                         geoO = at.inverseTransform(new Point2D.Double(ox, oy), null);
+                 geoO = at.transform(new Point2D.Double(ox, oy), null);
-                         final Point2D geoP = at.inverseTransform(
+                 final Point2D geoP = at.transform(new Point2D.Double(px, py), null);
-                                         new Point2D.Double(px, py), null);
+                 return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP.getY());
-                         return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP
+                 // } catch (final NoninvertibleTransformException e) {
-                                         .getY());
+                 // LOGGER.error(e);
-                 } catch (final NoninvertibleTransformException e) {
+                 // return new Envelope(ox, oy, px, py);
-                         LOGGER.error(e);
+                 // }
-                         return new Envelope(ox, oy, px, py);
-                 }
          }
          /**
-Line 2069 
 public class XMapPane extends JPanel {
+Line 2144 
 public class XMapPane extends JPanel {
                  final AffineTransform at = getScreenToWorld();
                  final Point2D geoO = at.transform(new Point2D.Double(ox, oy), null);
                  final Point2D geoP = at.transform(new Point2D.Double(px, py), null);
-                 return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP.getY());
+                 // Mmmmm... don't really understand why its x,x,y,y
+                 // return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(),
+                 // geoP.getY());
+                 return new Envelope(new Coordinate(geoO.getX(), geoO.getY()),
+                                 new Coordinate(geoP.getX(), geoP.getY()));
          }
          /**
-Line 2081 
 public class XMapPane extends JPanel {
+Line 2161 
 public class XMapPane extends JPanel {
                  // if the renderers have stopped, also stop the timer that is updating
                  // the final image
                  if (bgExecuter != null && bgExecuter.isRunning()
-                                 || localExecuter != null && localExecuter.isRunning()) {
+                                 || localExecuter.isRunning()) {
-                         setCursor(WAIT_CURSOR);
+                         setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
                          return;
                  } else {
                          // Allow one last rendering
                          if (repaintTimer.isRunning()) {
-                                 System.out.println("one last rendering....");
+                                 // System.out.println("one last rendering....");
                                  repaintTimer.stop();
                                  updateFinalImage();
                                  repaint();
                          }
                  }
+                 //
-                 // wenn manueller Cursor gesetzt ist, dann diesen verwenden (unabhaengig
+                 // //
-                 // von der aktuellen Aktion
+                 // // wenn manueller Cursor gesetzt ist, dann diesen verwenden
-                 if (this.staticCursor != null) {
+                 // (unabhaengig
-                         setCursor(staticCursor);
+                 // // von der aktuellen Aktion
-                         return;
+                 // if (this.staticCursor != null) {
-                 }
+                 // setCursor(staticCursor);
+                 // return;
+                 // }
+                 //
                  if (getCursor() == SwingUtil.PANNING_CURSOR) {
                          // This cursor will reset itself
                          return;
                  }
-                 // Set the cursor depending on what tool is in use...
+                 setCursor(tool.getCursor());
-                 switch (state) {
-                 case SELECT_TOP:
+                 //
-                 case SELECT_ONE_FROM_TOP:
+                 // // Set the cursor depending on what tool is in use...
-                 case SELECT_ALL:
+                 // switch (state) {
-                         setCursor(SwingUtil.CROSSHAIR_CURSOR);
+                 // case SELECT_TOP:
-                         break;
+                 // case SELECT_ONE_FROM_TOP:
-                 case ZOOM_IN:
+                 // case SELECT_ALL:
-                         setCursor(SwingUtil.ZOOMIN_CURSOR);
+                 // setCursor(SwingUtil.CROSSHAIR_CURSOR);
-                         break;
+                 // break;
-                 case ZOOM_OUT:
+                 // case ZOOM_IN:
-                         setCursor(SwingUtil.ZOOMOUT_CURSOR);
+                 // setCursor(SwingUtil.ZOOMIN_CURSOR);
-                         break;
+                 // break;
-                 case PAN:
+                 // case ZOOM_OUT:
-                         setCursor(SwingUtil.PAN_CURSOR);
+                 // setCursor(SwingUtil.ZOOMOUT_CURSOR);
-                         break;
+                 // break;
-                 default:
+                 // case PAN:
-                         setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+                 // setCursor(SwingUtil.PAN_CURSOR);
-                         break;
+                 // break;
-                 }
+                 // default:
+                 // setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+                 // break;
+                 // }
          }
          /**
-Line 2154 
 public class XMapPane extends JPanel {
+Line 2240 
 public class XMapPane extends JPanel {
                  final Graphics2D finalG = getFinalImage().createGraphics();
                  finalG.setBackground(getMapBackgroundColor());
-                 finalG.drawImage(getPreFinalImage(), imageOrigin.x, imageOrigin.y,
+                 finalG.drawImage(getPreFinalImage(), getImageOrigin().x,
-                                 getMapBackgroundColor(), null);
+                                 getImageOrigin().y, getMapBackgroundColor(), null);
-                 final int finalImageHeight = getFinalImage().getHeight(null);
-                 final int finalImageWidth = getFinalImage().getWidth(null);
-                 final Rectangle painedArea = new Rectangle(imageOrigin.x,
+                 // When panning, we have to clear the area around the image
-                                 imageOrigin.y, finalImageWidth, finalImageHeight);
+                 final Rectangle painedArea = new Rectangle(getImageOrigin().x,
-                 SwingUtil.clearAround(finalG, painedArea, getVisibleRect());
+                                 getImageOrigin().y, getFinalImage().getWidth(), getFinalImage()
+                                                 .getHeight());
+                 SwingUtil.clearAround(finalG, painedArea, getVisibleRect(),
+                                 getMapBackgroundColor());
-                 addGadgets(finalG, false);
+                  addGadgets(finalG, false);
                  finalG.dispose();
-Line 2181 
 public class XMapPane extends JPanel {
+Line 2267 
 public class XMapPane extends JPanel {
           *            <code>false</code>, it will only depend on
           *            {@link #localExecuter.isRunning} and #bgExecuter.isRunning
           */
-         private void addGadgets(final Graphics2D graphics, boolean forceWait) {
+         private void addGadgets(final Graphics2D graphics, final boolean forceWait) {
                  // Paint a logo to the bottom right if available
                  if (mapImage != null) {
-                         graphics.drawImage(mapImage, getBounds().width
+                         final Rectangle visibleRect = getVisibleRect();
-                                         - mapImage.getWidth() - 10, getBounds().height
+                         graphics.drawImage(mapImage, visibleRect.width
+                                         - mapImage.getWidth() - 10, getVisibleRect().height
                                          - mapImage.getHeight() - 10, null);
                  }
                  int y = 17;
                  // If the rendering process is still running, indicate this is the image
                  if (forceWait || bgExecuter != null && bgExecuter.isRunning()
-                                 || localExecuter != null && localExecuter.isRunning()) {
+                                 || localExecuter.isRunning()) {
-                         y+=8;
+                         y += 8;
                          final Color c = graphics.getColor();
                          graphics.setFont(waitFont);
- //                      String waitStr = "Wait..."; // i8n
                          graphics.setColor(getMapBackgroundColor());
                          graphics.drawString(waitMsg, 5, y);
                          graphics.setColor(getMapBackgroundColor());
-                         graphics.drawString(waitMsg, 7, y+2);
+                         graphics.drawString(waitMsg, 7, y + 2);
                          graphics.setColor(Color.BLACK);
-                         graphics.drawString(waitMsg, 6, y+1);
+                         graphics.drawString(waitMsg, 6, y + 1);
                          graphics.setColor(c);
-                         y += 24;
+                         y += 21;
                  }
-                 if (renderingErrors != null) {
+                 if (!renderingErrors.isEmpty() && isShowExceptions()) {
                          final Color c = graphics.getColor();
                          graphics.setFont(errorFont);
-                         for (Exception ex : renderingErrors) {
+                         for (final Exception ex : renderingErrors) {
-                                 if (ex instanceof java.lang.IllegalArgumentException
-                                                 && ex.getMessage().equals(
-                                                                 "Argument \"sourceCRS\" should not be null."))
-                                         continue;
                                  String errStr = ex.getLocalizedMessage();
-                                 graphics.setColor(Color.WHITE);
+                                 if (errStr == null)
+                                         errStr = ex.getMessage();
+                                 if (errStr == null)
+                                         errStr = "unknown error: " + ex.getClass().getSimpleName();
+                                 graphics.setColor(getMapBackgroundColor());
                                  graphics.drawString(errStr, 5, y);
                                  graphics.setColor(Color.RED);
                                  graphics.drawString(errStr, 6, y + 1);
-Line 2252 
 public class XMapPane extends JPanel {
+Line 2337 
 public class XMapPane extends JPanel {
          public void zoomTo(
                          final FeatureCollection<SimpleFeatureType, SimpleFeature> features) {
-                 final CoordinateReferenceSystem mapCRS = getContext()
+                 // if (!isWellDefined()) return;
+                 final CoordinateReferenceSystem mapCRS = getMapContext()
                                  .getCoordinateReferenceSystem();
                  final CoordinateReferenceSystem fCRS = features.getSchema()
-                                 .getGeometryDescriptor().getCoordinateReferenceSystem();
+                                 .getCoordinateReferenceSystem();
-                 double width = mapArea.getWidth();
+                 ReferencedEnvelope _mapArea;
-                 double height = mapArea.getHeight();
+                 if (mapArea == null)
+                         _mapArea = features.getBounds();
+                 else
+                         _mapArea = getMapArea();
+                 double width = _mapArea.getWidth();
+                 double height = _mapArea.getHeight();
                  final double ratio = height / width;
                  if (features == null || features.size() == 0) {
-Line 2310 
 public class XMapPane extends JPanel {
+Line 2402 
 public class XMapPane extends JPanel {
                  } else {
                          final ReferencedEnvelope fBounds = features.getBounds();
-                         Envelope bounds;
+                         ReferencedEnvelope bounds;
                          if (!mapCRS.equals(fCRS)) {
-                                 bounds = JTSUtil.transformEnvelope(fBounds, fCRS, mapCRS);
+                                 bounds = JTSUtil.transformEnvelope(fBounds, mapCRS);
                          } else {
                                  bounds = fBounds;
                          }
                          // BB umrechnen von Layer-CRS in Map-CRS
                          // Expand a bit
-                         bounds.expandBy(bounds.getWidth() / 6., bounds.getHeight() / 6.);
+                         addDefaultMargin(bounds);
                          setMapArea(bounds);
                  }
          }
+         private ReferencedEnvelope addDefaultMargin(ReferencedEnvelope bounds) {
+                 return JTSUtil.expandEnvelope(bounds, Math.max(0,
+                                 defaultMaxMapExtendMode));
+         }
+         private Envelope addDefaultMargin(Envelope bounds) {
+                 return JTSUtil.expandEnvelope(bounds, Math.max(0,
+                                 defaultMaxMapExtendMode));
+         }
          /**
           * Zooms towards a point.
           *
-Line 2343 
 public class XMapPane extends JPanel {
+Line 2445 
 public class XMapPane extends JPanel {
           * @param center
           *            position in window coordinates
           * @param zoomFaktor
-          *            > 1 for zoom in, < 1 for zoom out. Default is 1.33.
+          *            > 1 for zoom out, < 1 for zoom in. Default is .5
           */
          public void zoomTo(Point center, Double zoomFaktor) {
                  if (zoomFaktor == null || zoomFaktor == 0.)
-                         zoomFaktor = 2.;
+                         zoomFaktor = .5;
                  final Point2D gcenter = getScreenToWorld().transform(center, null);
                  center = null;
-Line 2368 
 public class XMapPane extends JPanel {
+Line 2470 
 public class XMapPane extends JPanel {
                                  .getWidth()) / 2., (mapArea.getHeight() * zoomFaktor - mapArea
                                  .getHeight()) / 2.);
-                 // Move the newMapArea above the new center
+                 // // Move the newMapArea above the new center if we zoom in:
                  newMapArea.translate(gcenter.getX() - mapArea.centre().x, gcenter
                                  .getY()
                                  - mapArea.centre().y);
-Line 2376 
 public class XMapPane extends JPanel {
+Line 2478 
 public class XMapPane extends JPanel {
                  setMapArea(newMapArea);
          }
+         /**
+          * Shall non-fatal rendering exceptions be reported in the mappane or be
+          * dropped quitely.
+          */
+         public void setShowExceptions(final boolean showExceptions) {
+                 this.showExceptions = showExceptions;
+         }
+         /**
+          * Shall exceptions be reported in the mappane?
+          */
+         public boolean isShowExceptions() {
+                 return showExceptions;
+         }
+         public GTRenderer getLocalRenderer() {
+                 return localRenderer;
+         }
+         /**
+          * Setzt den Kartenausschnitt auf die Ausdehnung eines bestimmten Layers.
+          * Macht nichts, wenn {@code null} uebergeben wird.
+          *
+          * <br>
+          *
+          * @param layer
+          *            ein Layer
+          */
+         public void zoomToLayer(MapLayer layer) {
+                 if (layer == null)
+                         return;
+                 try {
+                         // BB umrechnen von Layer-CRS in Map-CRS
+                         final CoordinateReferenceSystem targetCRS = getMapContext()
+                                         .getCoordinateReferenceSystem();
+                         final CoordinateReferenceSystem sourceCRS = layer
+                                         .getFeatureSource().getSchema()
+                                         .getCoordinateReferenceSystem();
+                         Envelope mapAreaNew;
+                         if (!CRS.equalsIgnoreMetadata(sourceCRS, targetCRS)) {
+                                 mapAreaNew = JTSUtil.transformEnvelope(layer.getFeatureSource()
+                                                 .getBounds(), sourceCRS, targetCRS);
+                         } else {
+                                 try {
+                                         mapAreaNew = layer.getFeatureSource().getBounds();
+                                 } catch (java.lang.IllegalArgumentException e) {
+                                         LOGGER.error("Can't calc layers bounds...", e);
+                                         mapAreaNew = null;
+                                         /**
+                                          *
+.10.2009 11:20:50
+                                          * org.geotools.data.shapefile.shp.PolygonHandler read
+                                          * WARNUNG: only one hole in this polygon record ERROR
+                                          * JMapPane zoomToLayer Zoom to layer did not terminate
+                                          * correctly java.lang.IllegalArgumentException: Points of
+                                          * LinearRing do not form a closed linestring at
+                                          * com.vividsolutions
+                                          * .jts.geom.LinearRing.validateConstruction
+                                          * (LinearRing.java:105) at
+                                          * com.vividsolutions.jts.geom.LinearRing
+                                          * .<init>(LinearRing.java:100) at
+                                          * com.vividsolutions.jts.geom
+                                          * .GeometryFactory.createLinearRing
+                                          * (GeometryFactory.java:339) at
+                                          * org.geotools.data.shapefile.
+                                          * shp.PolygonHandler.read(PolygonHandler.java:188) at
+                                          * org.geotools
+                                          * .data.shapefile.shp.ShapefileReader$Record.shape
+                                          * (ShapefileReader.java:106) at
+                                          * org.geotools.data.shapefile.
+                                          * ShapefileAttributeReader.next(
+                                          * ShapefileAttributeReader.java:157) at
+                                          * org.geotools.data.shapefile
+                                          * .indexed.IndexedShapefileAttributeReader
+                                          * .next(IndexedShapefileAttributeReader.java:122) at
+                                          * org.geotools
+                                          * .data.FIDFeatureReader.next(FIDFeatureReader.java:96) at
+                                          * org.geotools.data.FIDFeatureReader.next(FIDFeatureReader.
+                                          * java:55) at org.geotools.data.MaxFeatureReader.next(
+                                          * MaxFeatureReader.java:61) at
+                                          * org.geotools.data.MaxFeatureReader
+                                          * .next(MaxFeatureReader.java:61)
+                                          **/
+                                 }
+                         }
+                         // Kartenbereich um 10% vergroessern, damit z.B. auch ein
+                         // Punkt-Layer,
+                         // welches nur aus 2 Punnkten besteht, sichtbar ist (Punkte liegen
+                         // sonst
+                         // genau auf dem Rand der angezeigten Flaeche)
+                         if (mapAreaNew != null) {
+                                 mapAreaNew = addDefaultMargin(mapAreaNew);
+                                 setMapArea(mapAreaNew);
+                         } else {
+                                 LOGGER
+                                                 .warn("Couldn't transformEnvelope when zooming to the layer");
+                         }
+                 } catch (Exception err) {
+                         LOGGER.error("Zoom to layer did not terminate correctly", err);
+                 }
+         }
+         /**
+          * Zooms the {@link SelectableXMapPane} to the {@link Envelope} of a layer.
+          *
+          * <br>
+          * A refresh of the map is not done automatically
+          *
+          * @param index
+          *            Index of the {@link MapLayer} in the {@link MapContext} (from
+          *            back to top)
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public void zoomToLayer(int index) {
+                 final MapContext context = getMapContext();
+                 if (context != null)
+                         zoomToLayer(context.getLayer(index));
+         }
+         /**
+          * Zooms the {@link SelectableXMapPane} to the {@link Envelope} of the
+          * selected layer. The layer is selected by the idx, counting from front to
+          * back, like humans would expect in a {@link JList}
+          *
+          * <br>
+          * A refresh of the map is not done automatically
+          *
+          *
+          *
+          * @param index
+          *            Reverse index of the {@link MapLayer} in the
+          *            {@link MapContext}
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public void zoomToLayerIdxReverse(int index) {
+                 zoomToLayer(getMapContext().getLayerCount() - 1 - index);
+         }
+         /**
+          * Aktiviert oder deaktiviert das AntiAliasing for diese
+          * {@link SelectableXMapPane}. AntiALiasing ist besonders fuer
+          * Textbeschriftung sehr schoen, verbraucht aber auch mehr Performance.
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public void setAntiAliasing(final boolean aa) {
+                 // LOGGER.info("Setting AntiAliasing for this JMapPane to " + aa);
+                 RenderingHints java2DHints = java2dHints;
+                 if (java2DHints == null) {
+                         java2DHints = GeoTools.getDefaultHints();
+                 }
+                 java2DHints.put(RenderingHints.KEY_ANTIALIASING,
+                                 aa ? RenderingHints.VALUE_ANTIALIAS_ON
+                                                 : RenderingHints.VALUE_ANTIALIAS_OFF);
+                 java2DHints.put(RenderingHints.KEY_TEXT_ANTIALIASING,
+                                 aa ? RenderingHints.VALUE_TEXT_ANTIALIAS_ON
+                                                 : RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+                 java2DHints.put(RenderingHints.KEY_RENDERING,
+                                 aa ? RenderingHints.VALUE_RENDER_QUALITY
+                                                 : RenderingHints.VALUE_RENDER_SPEED);
+         }
+         public Point getImageOrigin() {
+                 return imageOrigin;
+         }
+         /**
+          * If {@link #maxExtend} is <code>null</code> the following rules are used
+          * to create a default maximum.
+          * <ul>
+          * <li>Values &lt; 0 : don't grow to fit the monitors aspect ratio, no
+          * margin</li>
+          * <li>Values 0 : grow to fit the monitors aspect ratio, no margin</li>
+          * <li>Values &gt; 0 : grow to fit the monitors aspect ratio, and add a
+          * relative margin</li>
+          * </ul>
+          * **/
+         public void setDefaultMaxMapExtendMode(double defaultMaxMapExtendMode) {
+                 this.defaultMaxMapExtendMode = defaultMaxMapExtendMode;
+         }
+         /**
+          * If {@link #maxExtend} is <code>null</code> the following rules are used
+          * to create a default maximum.
+          * <ul>
+          * <li>Values &lt; 0 : don't grow to fit the monitors aspect ratio, no
+          * margin</li>
+          * <li>Values 0 : grow to fit the monitors aspect ratio, no margin</li>
+          * <li>Values &gt; 0 : grow to fit the monitors aspect ratio, and add a
+          * relative margin</li>
+          * </ul>
+          * **/
+         public double getDefaultMaxMapExtendMode() {
+                 return defaultMaxMapExtendMode;
+         }
  }

 Legend:



Removed from v.536
 


changed lines


 
Added in v.677
 Legend:



Removed from v.536
 


changed lines


 
Added in v.677
-Removed from v.536
+Added in v.677

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26