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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

branches/1.0-gt2-2.6/src/gtmig/org/geotools/swing/JMapPane.java revision 445 by alfonx, Wed Oct 7 13:17:02 2009 UTC branches/2.0-RC1/src/skrueger/geotools/XMapPane.java revision 607 by alfonx, Wed Dec 9 15:13:42 2009 UTC
# Line 1  Line 1 
1  /*  package skrueger.geotools;
  *    GeoTools - OpenSource mapping toolkit  
  *    http://geotools.org  
  *    (C) 2002-2006, GeoTools Project Managment Committee (PMC)  
  *  
  *    This library is free software; you can redistribute it and/or  
  *    modify it under the terms of the GNU Lesser General Public  
  *    License as published by the Free Software Foundation;  
  *    version 2.1 of the License.  
  *  
  *    This library is distributed in the hope that it will be useful,  
  *    but WITHOUT ANY WARRANTY; without even the implied warranty of  
  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU  
  *    Lesser General Public License for more details.  
  */  
 package gtmig.org.geotools.swing;  
   
 /**  
  * <b>Xulu:<br>  
  *    Code taken from gt-2.4.5 to make some changes (marked with {@code xulu}),  
  *    which can not be realized in a subclass:</b>  
  *    <ul>  
  *       <li>{@link #getMapArea()} declared as {@code final}<li>  
  *       <li>some variables declared as {@code protected}</li>  
  *       <li>minimal/maximal zoom scale</li>  
  *       <li>zoom in and zoom out via mouse click realized by setMapArea(..)</li>  
  *    </ul>  
  * <br><br>  
  * A simple map container that is a JPanel with a map in. provides simple  
  * pan,zoom, highlight and selection The mappane stores an image of the map  
  * (drawn from the context) and an image of the slected feature(s) to speed up  
  * rendering of the highlights. Thus the whole map is only redrawn when the bbox  
  * changes, selection is only redrawn when the selected feature changes.  
  *  
  *  
  * @author Ian Turton  
  *  
  */  
2    
3  import java.awt.Color;  import java.awt.Color;
4  import java.awt.Cursor;  import java.awt.Cursor;
5    import java.awt.Font;
6  import java.awt.Graphics;  import java.awt.Graphics;
7  import java.awt.Graphics2D;  import java.awt.Graphics2D;
8  import java.awt.LayoutManager;  import java.awt.Image;
9    import java.awt.Point;
10  import java.awt.Rectangle;  import java.awt.Rectangle;
11    import java.awt.RenderingHints;
12    import java.awt.event.ActionEvent;
13    import java.awt.event.ActionListener;
14    import java.awt.event.ComponentAdapter;
15    import java.awt.event.ComponentEvent;
16  import java.awt.event.InputEvent;  import java.awt.event.InputEvent;
17  import java.awt.event.MouseEvent;  import java.awt.event.MouseEvent;
18  import java.awt.event.MouseListener;  import java.awt.event.MouseListener;
19  import java.awt.event.MouseMotionListener;  import java.awt.geom.AffineTransform;
20    import java.awt.geom.NoninvertibleTransformException;
21    import java.awt.geom.Point2D;
22  import java.awt.image.BufferedImage;  import java.awt.image.BufferedImage;
 import java.beans.PropertyChangeEvent;  
 import java.beans.PropertyChangeListener;  
23  import java.io.IOException;  import java.io.IOException;
24  import java.util.Date;  import java.util.ArrayList;
25  import java.util.HashMap;  import java.util.HashMap;
26  import java.util.Map;  import java.util.Map;
27    import java.util.Vector;
28    
29  import javax.swing.JPanel;  import javax.swing.JList;
30    import javax.swing.Timer;
31    import javax.swing.border.Border;
32    
33  import org.apache.log4j.Logger;  import org.apache.log4j.Logger;
34    import org.geotools.factory.GeoTools;
35    import org.geotools.feature.FeatureCollection;
36    import org.geotools.geometry.jts.JTS;
37    import org.geotools.geometry.jts.ReferencedEnvelope;
38    import org.geotools.map.DefaultMapContext;
39  import org.geotools.map.MapContext;  import org.geotools.map.MapContext;
40    import org.geotools.map.MapLayer;
41    import org.geotools.map.event.MapLayerEvent;
42  import org.geotools.map.event.MapLayerListEvent;  import org.geotools.map.event.MapLayerListEvent;
43  import org.geotools.map.event.MapLayerListListener;  import org.geotools.map.event.MapLayerListListener;
44    import org.geotools.map.event.MapLayerListener;
45    import org.geotools.referencing.CRS;
46  import org.geotools.renderer.GTRenderer;  import org.geotools.renderer.GTRenderer;
47  import org.geotools.renderer.label.LabelCacheImpl;  import org.geotools.renderer.label.LabelCacheImpl;
48  import org.geotools.renderer.lite.LabelCache;  import org.geotools.renderer.lite.LabelCache;
49    import org.geotools.renderer.lite.RendererUtilities;
50  import org.geotools.renderer.lite.StreamingRenderer;  import org.geotools.renderer.lite.StreamingRenderer;
51  import org.geotools.renderer.shape.ShapefileRenderer;  import org.geotools.swing.JMapPane;
52  import org.opengis.filter.FilterFactory2;  import org.geotools.swing.event.MapMouseEvent;
53    import org.geotools.swing.event.MapPaneEvent;
54    import org.geotools.swing.event.MapPaneListener;
55    import org.opengis.feature.simple.SimpleFeature;
56    import org.opengis.feature.simple.SimpleFeatureType;
57    import org.opengis.referencing.FactoryException;
58  import org.opengis.referencing.crs.CoordinateReferenceSystem;  import org.opengis.referencing.crs.CoordinateReferenceSystem;
59    import org.opengis.referencing.operation.MathTransform;
60    import org.opengis.referencing.operation.TransformException;
61    
62    import schmitzm.geotools.GTUtil;
63  import schmitzm.geotools.JTSUtil;  import schmitzm.geotools.JTSUtil;
64    import schmitzm.geotools.gui.SelectableXMapPane;
65    import schmitzm.geotools.io.GeoImportUtil;
66    import schmitzm.geotools.map.event.JMapPaneListener;
67    import schmitzm.geotools.map.event.MapLayerAdapter;
68    import schmitzm.lang.LangUtil;
69    import schmitzm.swing.JPanel;
70  import schmitzm.swing.SwingUtil;  import schmitzm.swing.SwingUtil;
71    
72  import com.vividsolutions.jts.geom.Coordinate;  import com.vividsolutions.jts.geom.Coordinate;
73  import com.vividsolutions.jts.geom.Envelope;  import com.vividsolutions.jts.geom.Envelope;
74  import com.vividsolutions.jts.geom.GeometryFactory;  import com.vividsolutions.jts.geom.Geometry;
   
 public class JMapPane extends JPanel implements MouseListener,  
                 MouseMotionListener, PropertyChangeListener, MapLayerListListener {  
         private static Logger LOGGER = Logger.getLogger(JMapPane.class.getName());  
   
         private static final long serialVersionUID = -8647971481359690499L;  
   
         public static final int Reset = 0;  
75    
76          public static final int ZoomIn = 1;  /**
77     * The {@link XMapPane} class uses a Geotools {@link GTRenderer} to paint up to
78     * two {@link MapContext}s: a "local" {@link MapContext} and a "background"
79     * {@link MapContext}. The idea is, that rendering a background layer made up of
80     * e.g. OSM data, may take much longer than rendering local data.<br>
81     * Every {@link MapContext} is rendered on a {@link Thread} of it's own.
82     * Starting/ cancelling these threads is done by the {@link RenderingExecutor}.<br>
83     * <br>
84     * While the renderers are rending the map, a <br>
85     * The {@link XMapPane} is based on schmitzm {@link JPanel}, so
86     * {@link #print(Graphics)} will automatically set the background of components
87     * to pure white.
88     *
89     * The XMapPane has a {@link MouseListener} that manages zooming.<br>
90     * A logo/icon to float in the lower left corner may be set with
91     * {@link #setMapImage(BufferedImage)}<br>
92     *
93     * @see SelectableXMapPane - an extension of {@link XMapPane} that supports
94     *      selecting features.
95     *
96     * @author stefan
97     *
98     */
99    public class XMapPane extends JPanel {
100    
101          public static final int ZoomOut = 2;          // private static final int IMAGETYPE = BufferedImage.TYPE_INT_RGB;
102            // private static final int IMAGETYPE_withAlpha =
103            // BufferedImage.TYPE_INT_ARGB;
104            private static final int IMAGETYPE = BufferedImage.TYPE_3BYTE_BGR;
105            private static final int IMAGETYPE_withAlpha = BufferedImage.TYPE_4BYTE_ABGR;
106    
107          public static final int Pan = 3;          private final static Logger LOGGER = Logger.getLogger(XMapPane.class);
108    
109          public static final int Select = 4;          private boolean acceptsRepaintCalls = true;
110    
111          /**          /**
112           * what renders the map           * Main {@link MapContext} that holds all layers that are rendered into the
113             * {@link #localImage} by the {@link #localRenderer}
114           */           */
115          GTRenderer renderer;          MapContext localContext;
116    
117          /**          /**
118           * the map context to render           * {@link MapContext} holding the background layers. Use it for layers that
119             * CAN take very long for rendering, like layer from the Internet: WMS, WFS,
120             * OSM...<br>
121             * <code>null</code> by default.
122             *
123             * @see #setBgContext(MapContext)
124             * @see #getBgContext()
125           */           */
126          MapContext context;          MapContext bgContext;
127    
128          /**          /**
129           * the area of the map to draw           * While threads are working, calls {@link XMapPane#updateFinalImage()}
130             * regularly and {@link #repaint()}. This {@link Timer} is stopped when all
131             * renderers have finished.
132             *
133             * @see INITIAL_REPAINT_DELAYAL
134             * @see #REPEATING_REPAINT_DELAY
135           */           */
136          protected Envelope mapArea;          final private Timer repaintTimer;
137    
138          /**          /**
139           * the size of the pane last time we drew           * The initial delay in milliseconds until the {@link #finalImage} is
140             * updated the first time.
141           */           */
142          protected Rectangle oldRect = null;          public static final int INITIAL_REPAINT_DELAY = 900;
143    
144          /**          /**
145           * the last map area drawn.           * While the {@link #bgExecuter} and {@link #localExecuter} are rendering,
146             * the {@link #repaintTimer} is regularly updating the {@link #finalImage}
147             * with previews.
148           */           */
149          protected Envelope oldMapArea = null;          public static final int REPEATING_REPAINT_DELAY = 500;
150    
151          /**          /**
152           * the base image of the map           * Default delay (milliseconds) before the map will be redrawn when resizing
153             * the pane. This is to avoid flickering while drag-resizing.
154             *
155             * @see #resizeTimer
156           */           */
157          protected BufferedImage baseImage, panningImage;          public static final int DEFAULT_RESIZING_PAINT_DELAY = 600;
158    
159          /**          /**
160           * a factory for filters           * This not-repeating {@link Timer} is re-started whenever the component is
161             * resized. That means => only if the component is not resizing for
162             * {@link #DEFAULT_RESIZING_PAINT_DELAY} milliseconds, does the
163             * {@link XMapPane} react.
164           */           */
165          FilterFactory2 ff;          private final Timer resizeTimer;
166    
167          /**          /**
168           * a factory for geometries           * Flag for no-tool.
169           */           */
170          GeometryFactory gf = new GeometryFactory(); // FactoryFinder.getGeometryFactory(null);          public static final int NONE = -123;
   
         private int state = ZoomIn;  
171    
172          /**          /**
173           * how far to zoom in or out           * Flag fuer Modus "Kartenausschnitt bewegen". Nicht fuer Window-Auswahl
174             * moeglich!
175             *
176             * @see #setState(int)
177           */           */
178          private double zoomFactor = 2.0;          public static final int PAN = 1;
   
         boolean changed = true;  
   
         LabelCache labelCache = new LabelCacheImpl();  
   
         protected boolean reset = false;  
   
         int startX;  
   
         int startY;  
179    
180          /**          /**
181           * If not <code>null</code>, the {@link JMapPane} will not allow to zoom/pan           * Flag fuer Modus "Heran zoomen".
182           * out of that area           *
183           **/           * @see #setState(int)
184          private Envelope maxExtend = null;           * @see #setState(int)
185             */
186          // /**          public static final int ZOOM_IN = 2;
         // * Is max. 1 or 0 of the 2 axised allowed to extend the maxExtend? If  
         // * <code>true</code> the extends has to be fully inside maxExtend  
         // **/  
         // boolean maxExtendForceMode = true;  
   
         private boolean clickable;  
   
         int lastX;  
   
         int lastY;  
   
         private Double maxZoomScale = Double.MIN_VALUE;  
         private Double minZoomScale = Double.MAX_VALUE;  
187    
188          /**          /**
189           * Wenn true, dann wurde PANNING via mouseDraged-Events begonnen. Dieses           * Flag fuer Modus "Heraus zoomen". Nicht fuer Window-Auswahl moeglich!
190           * Flag wird benutzt um nur einmal den passenden Cursor nur einmal zu           *
191           * setzen.           * @see #setState(int)
192           */           */
193          private boolean panning_started = false;          public static final int ZOOM_OUT = 3;
   
         public JMapPane() {  
                 this(null, true, null, null);  
         }  
194    
195          /**          /**
196           * create a basic JMapPane           * Flag fuer Modus "SimpleFeature-Auswahl auf allen (sichtbaren) Layern".
197           *           *
198           * @param render           * @see #setState(int)
199           *            - how to draw the map           * @see #setState(int)
          * @param context  
          *            - the map context to display  
200           */           */
201          public JMapPane(final GTRenderer render, final MapContext context) {          public static final int SELECT_ALL = 103;
                 this(null, true, render, context);  
         }  
   
202          /**          /**
203           * full constructor extending JPanel           * Flag fuer Modus
204             * "Auswahl nur eines Features, das erste sichtbare von Oben".
205           *           *
206           * @param layout           * @see #setState(int)
207           *            - layout (probably shouldn't be set)           * @see #setState(int)
          * @param isDoubleBuffered  
          *            - a Swing thing I don't really understand  
          * @param render  
          *            - what to draw the map with  
          * @param context  
          *            - what to draw  
208           */           */
209          public JMapPane(final LayoutManager layout, final boolean isDoubleBuffered,          public static final int SELECT_ONE_FROM_TOP = 104;
210                          final GTRenderer render, final MapContext context) {          /**
211                  super(layout, isDoubleBuffered);           * Flag fuer Modus
212             * "SimpleFeature-Auswahl auf dem obersten (sichtbaren) Layer".
213                  ff = (FilterFactory2) org.geotools.factory.CommonFactoryFinder           *
214                                  .getFilterFactory(null);           * @see #setState(int)
215                  setRenderer(render);           * @see #setState(int)
216             */
217                  setContext(context);          public static final int SELECT_TOP = 4;
218    
219                  this.addMouseListener(this);          /**
220                  this.addMouseMotionListener(this);           * {@link Font} used to paint the wait messages into the map
221                  setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));           *
222          }           * @see #addGadgets(Graphics2D, boolean)
223             */
224            final static Font waitFont = new Font("Arial", Font.BOLD, 28);
225    
226          /**          /**
227           * get the renderer           * {@link Font} used to paint error messages into the map
228             *
229             * @see #addGadgets(Graphics2D, boolean)
230           */           */
231          public GTRenderer getRenderer() {          final static Font errorFont = new Font("Arial", Font.BOLD, 13);
                 return renderer;  
         }  
232    
233          public void setRenderer(final GTRenderer renderer) {          /**
234                  Map<Object, Object> hints = new HashMap<Object, Object>();           * If last average last two renderings took more than that many ms, show the
235             * user a scaled preview
236             **/
237            private static final long PRESCALE_MINTIME = 230;
238    
239                  this.renderer = renderer;          /**
240             * The wait message painted into the map while rendering is going on on
241             * another thread.
242             *
243             * @see #addGadgets(Graphics2D, boolean)
244             */
245            final String waitMsg = SwingUtil.R("WaitMess");
246    
247                  if (renderer instanceof StreamingRenderer          /**
248                                  || renderer instanceof ShapefileRenderer) {           * Konvertiert die Maus-Koordinaten (relativ zum <code>JMapPane</code>) in
249                          hints = renderer.getRendererHints();           * Karten-Koordinaten.
250                          if (hints == null) {           *
251                                  hints = new HashMap<Object, Object>();           * @param e
252                          }           *            Maus-Ereignis
253                          if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {           */
254                                  labelCache = (LabelCache) hints          public static Point2D getMapCoordinatesFromEvent(final MouseEvent e) {
255                                                  .get(StreamingRenderer.LABEL_CACHE_KEY);                  // aktuelle Geo-Position aus GeoMouseEvent ermitteln
256                          } else {                  if (e != null && e instanceof MapMouseEvent)
257                                  hints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);                          try {
258                                    return ((MapMouseEvent) e).getMapPosition().toPoint2D();
259                            } catch (final Exception err) {
260                                    LOGGER
261                                                    .error(
262                                                                    "return ((GeoMouseEvent) e).getMapCoordinate(null).toPoint2D();",
263                                                                    err);
264                          }                          }
265    
266                          hints.put("memoryPreloadingEnabled", Boolean.TRUE);                  // aktuelle Geo-Position ueber Transformation des JMapPane berechnen
267                    if (e != null && e.getSource() instanceof XMapPane) {
268    
269                          renderer.setRendererHints(hints);                          final XMapPane xMapPane = (XMapPane) e.getSource();
                 }  
270    
271                  if (this.context != null) {                          if (!xMapPane.isWellDefined())
272                          this.renderer.setContext(this.context);                                  return null;
273    
274                            final AffineTransform at = xMapPane.getScreenToWorld();
275                            if (at != null)
276                                    return at.transform(e.getPoint(), null);
277                            return null;
278                  }                  }
279                    throw new IllegalArgumentException(
280                                    "MouseEvent has to be of instance MapMouseEvent or come from an XMapPane");
281          }          }
282    
283          public MapContext getContext() {          /**
284                  return context;           * Listens to changes of the "background" {@link MapContext} and triggers
285          }           * repaints where needed.
286             */
287            private final MapLayerListListener bgContextListener = new MapLayerListListener() {
288    
289          public void setContext(final MapContext context) {                  @Override
290                  if (this.context != null) {                  public void layerAdded(final MapLayerListEvent event) {
291                          this.context.removeMapLayerListListener(this);                          final MapLayer layer = event.getLayer();
292                  }                          layer.addMapLayerListener(bgMapLayerListener);
293                            requestStartRendering();
294    
295                  this.context = context;                  }
296    
297                  if (context != null) {                  @Override
298                          this.context.addMapLayerListListener(this);                  public void layerChanged(final MapLayerListEvent event) {
299                            requestStartRendering();
300                  }                  }
301    
302                  if (renderer != null) {                  @Override
303                          renderer.setContext(this.context);                  public void layerMoved(final MapLayerListEvent event) {
304                            requestStartRendering();
305                  }                  }
         }  
306    
307          public Envelope getMapArea() {                  @Override
308                  return mapArea;                  public void layerRemoved(final MapLayerListEvent event) {
309          }                          if (event.getLayer() != null)
310                                    event.getLayer().removeMapLayerListener(bgMapLayerListener);
311                            requestStartRendering();
312                    }
313            };
314    
315          public void setMapArea(final Envelope mapArea) {          /**
316                  this.mapArea = mapArea;           * This {@link RenderingExecutor} manages the creation and cancellation of
317          }           * up to one {@link Thread} for rendering the {@link #localContext}.
318             */
319            private final RenderingExecutor localExecuter = new RenderingExecutor(this);
320    
321          public int getState() {          /**
322                  return state;           * This {@link RenderingExecutor} manages the creation and cancellation of
323          }           * up to one {@link Thread} for rendering the {@link #bgContext}.
324             */
325            protected RenderingExecutor bgExecuter;
326    
327          public void setState(final int state) {          /**
328                  this.state = state;           * The {@link #localRenderer} for the {@link #localContext} uses this
329             * {@link Image}.
330             */
331            private BufferedImage localImage;
332    
333                  // System.out.println("State: " + state);          /**
334          }           * The {@link #bgRenderer} for the {@link #bgContext} uses this
335             * {@link Image}.
336             */
337            private BufferedImage bgImage;
338    
339          public double getZoomFactor() {          /**
340                  return zoomFactor;           * This {@link Image} is a merge of the {@link #bgImage},
341          }           * {@link #localImage} and {@link #addGadgets(Graphics2D, boolean)}. It is
342             * updated with {@link #updateFinalImage()} and used for painting in
343             * {@link #paintComponent(Graphics)}
344             */
345            private BufferedImage finalImage;
346    
347          public void setZoomFactor(final double zoomFactor) {          /**
348                  this.zoomFactor = zoomFactor;           * Optionally a transparent image to paint over the map in the lower right
349          }           * corner.
350             *
351             * @see #addGadgets(Graphics2D)
352             * @see #setMapImage(BufferedImage)
353             **/
354            private BufferedImage mapImage = null;
355    
356          protected void paintComponent(final Graphics g) {          /**
357                  super.paintComponent(g);           * Listens to each layer in the local {@link MapContext} for changes and
358             * triggers repaints.
359             */
360            protected MapLayerListener bgMapLayerListener = new MapLayerAdapter() {
361    
362                  if ((renderer == null) || (mapArea == null)) {                  @Override
363                          return;                  public void layerChanged(final MapLayerEvent event) {
364                            requestStartRendering();
365                  }                  }
366    
367                  final Rectangle r = getBounds();                  @Override
368                  final Rectangle dr = new Rectangle(r.width, r.height);                  public void layerHidden(final MapLayerEvent event) {
369                            requestStartRendering();
                 if (!r.equals(oldRect) || reset) {  
                         if (!r.equals(oldRect) && (mapArea == null)) {  
                                 try {  
                                         mapArea = context.getLayerBounds();  
                                 } catch (final IOException e) {  
                                         LOGGER.warn("context.getLayerBounds()", e);  
                                 }  
                         }  
   
                         if (mapArea != null) {  
                                 /* either the viewer size has changed or we've done a reset */  
                                 changed = true; /* note we need to redraw */  
                                 reset = false; /* forget about the reset */  
                                 oldRect = r; /* store what the current size is */  
   
                                 mapArea = fixAspectRatio(r, mapArea, false);  
                         }  
370                  }                  }
371    
372                  if (!mapArea.equals(oldMapArea)) { /* did the map extent change? */                  @Override
373                          changed = true;                  public void layerShown(final MapLayerEvent event) {
374                          oldMapArea = mapArea;                          requestStartRendering();
                         // when we tell the context that the bounds have changed WMSLayers  
                         // can refresh them selves  
                         context.setAreaOfInterest(mapArea, context  
                                         .getCoordinateReferenceSystem());  
375                  }                  }
376            };
377    
378                  if (changed) { /* if the map changed then redraw */          /**
379                          changed = false;           * A flag indicating if dispose() was already called. If true, then further
380                          baseImage = new BufferedImage(dr.width, dr.height,           * use of this {@link SelectableXMapPane} is undefined.
381                                          BufferedImage.TYPE_INT_ARGB);           */
382            private boolean disposed = false;
                         final Graphics2D ig = baseImage.createGraphics();  
                         /* System.out.println("rendering"); */  
                         if (renderer.getContext() != null)  
                                 renderer.setContext(context);  
                         labelCache.clear(); // work around anoying labelcache bug  
   
                         // draw the map  
                         renderer.paint((Graphics2D) ig, dr, mapArea);  
   
                         // TODO nur machen, wenn panning beginnt  
                         panningImage = new BufferedImage(dr.width, dr.height,  
                                         BufferedImage.TYPE_INT_RGB);  
383    
384                  }          /**
385             * While dragging, the {@link #updateFinalImage()} method is translating the
386             * cached images while setting it together.
387             **/
388            Point imageOrigin = new Point(0, 0);
389            /**
390             * For every rendering thread started,
391             * {@link GTUtil#createGTRenderer(MapContext)} is called to create a new
392             * renderer. These Java2D rendering hints are passed to the
393             * {@link GTRenderer}. The java2dHints are the same for all renderers (bg
394             * and local).
395             */
396            private RenderingHints java2dHints;
397    
398                  ((Graphics2D) g).drawImage(baseImage, 0, 0, this);          protected LabelCache labelCache = new LabelCacheImpl();
         }  
399    
400          /**          /**
401           * Returns an {@link Envelope} that has the same aspect ratio as the given rectangle           * Listens to changes of the "local" {@link MapContext} and triggers
402           * @param grow           * repaints where needed.
          *            If <code>true</code>, than the area will be enlarged to match  
          *            the aspect ratio. If <code>false</code>, it will only shrink.  
403           */           */
404          private Envelope fixAspectRatio(final Rectangle r, final Envelope mapArea,          private final MapLayerListListener localContextListener = new MapLayerListListener() {
                         boolean grow) {  
                   
                 if (mapArea == null) {  
                         LOGGER.warn("mapArea has been null in method fixAspectRatio, returning an unmodified ");  
                 }  
405    
406                  final double mapWidth = mapArea.getWidth(); /* get the extent of the map */                  @Override
407                  final double mapHeight = mapArea.getHeight();                  public void layerAdded(final MapLayerListEvent event) {
408                  final double scaleX = r.getWidth() / mapArea.getWidth(); /*                          event.getLayer().addMapLayerListener(localMapLayerListener);
                                                                                                                                  * calculate the  
                                                                                                                                  * new scale  
                                                                                                                                  */  
409    
410                  final double scaleY = r.getHeight() / mapArea.getHeight();                          getLocalRenderer().setContext(getMapContext());
411                  double scale = 1.0; // stupid compiler!                          requestStartRendering();
412    
                 if ((grow && scaleX < scaleY) || (!grow && scaleX > scaleY)) {  
                         scale = scaleX;  
                 } else {  
                         scale = scaleY;  
413                  }                  }
414    
415                  /* calculate the difference in width and height of the new extent */                  @Override
416                  final double deltaX = /* Math.abs */((r.getWidth() / scale) - mapWidth);                  public void layerChanged(final MapLayerListEvent event) {
417                  final double deltaY = /* Math.abs */((r.getHeight() / scale) - mapHeight);  //                      getLocalRenderer().setContext(getMapContext()); geht doch auch ohne?!?!? wow...
418                            requestStartRendering();
419                  /*                  }
                  * System.out.println("delta x " + deltaX);  
                  * System.out.println("delta y " + deltaY);  
                  */  
   
                 /* create the new extent */  
                 final Coordinate ll = new Coordinate(  
                                 mapArea.getMinX() - (deltaX / 2.0), mapArea.getMinY()  
                                                 - (deltaY / 2.0));  
                 final Coordinate ur = new Coordinate(  
                                 mapArea.getMaxX() + (deltaX / 2.0), mapArea.getMaxY()  
                                                 + (deltaY / 2.0));  
   
                 return new Envelope(ll, ur);  
         }  
   
         public void mouseClicked(final MouseEvent e) {  
                 if (mapArea == null)  
                         return;  
                 // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"  
                 // h:"+mapArea.getHeight());  
                 final Rectangle bounds = this.getBounds();  
                 final double x = (double) (e.getX());  
                 final double y = (double) (e.getY());  
                 final double width = mapArea.getWidth();  
                 final double height = mapArea.getHeight();  
                 // xulu.sc  
                 // double width2 = mapArea.getWidth() / 2.0;  
                 // double height2 = mapArea.getHeight() / 2.0;  
                 final double width2 = width / 2.0;  
                 final double height2 = height / 2.0;  
                 // xulu.ec  
                 final double mapX = ((x * width) / (double) bounds.width)  
                                 + mapArea.getMinX();  
                 final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)  
                                 + mapArea.getMinY();  
   
                 /*  
                  * System.out.println(""+x+"->"+mapX);  
                  * System.out.println(""+y+"->"+mapY);  
                  */  
   
                 /*  
                  * Coordinate ll = new Coordinate(mapArea.getMinX(), mapArea.getMinY());  
                  * Coordinate ur = new Coordinate(mapArea.getMaxX(), mapArea.getMaxY());  
                  */  
                 double zlevel = 1.0;  
420    
421                  switch (state) {                  @Override
422                  case Pan:                  public void layerMoved(final MapLayerListEvent event) {
423                          zlevel = 1.0;                          getLocalRenderer().setContext(getMapContext());
424                          // xulu.sc SK: return here.. a mouselistener is managing the PANNING                          requestStartRendering();
425                          // break;                  }
                         return;  
                         // xulu.ec  
                 case ZoomIn:  
                         zlevel = zoomFactor;  
426    
427                          break;                  @Override
428                    public void layerRemoved(final MapLayerListEvent event) {
429                            if (event.getLayer() != null)
430                                    event.getLayer().removeMapLayerListener(localMapLayerListener);
431                            getLocalRenderer().setContext(getMapContext());
432                            requestStartRendering();
433                    }
434            };
435    
436                  case ZoomOut:          /**
437                          zlevel = 1.0 / zoomFactor;           * Listens to each layer in the local {@link MapContext} for changes and
438             * triggers repaints. We don't have to listen layerChanged, because that is
439             * already done in {@link #localContextListener}
440             */
441            protected MapLayerListener localMapLayerListener = new MapLayerAdapter() {
442    
443                          break;                  // @Override
444                  //                  // public void layerChanged(final MapLayerEvent event) {
445                  // case Select:                  // // getLocalRenderer().setContext(getMapContext()); // betters for SLD
446                  // doSelection(mapX, mapY, selectionLayer);                  // // // changes?!
447                  //                  // // requestStartRendering();
448                  // return;                  // }
449    
450                  default:                  @Override
451                          return;                  public void layerHidden(final MapLayerEvent event) {
452                            requestStartRendering();
453                  }                  }
454    
455                  final Coordinate ll = new Coordinate(mapX - (width2 / zlevel), mapY                  @Override
456                                  - (height2 / zlevel));                  public void layerShown(final MapLayerEvent event) {
457                  final Coordinate ur = new Coordinate(mapX + (width2 / zlevel), mapY                          requestStartRendering();
458                                  + (height2 / zlevel));                  }
459                  // xulu.sc SK: Check for min/max scale          };
                 // mapArea = new Envelope(ll, ur);  
                 final Envelope newMapArea = new Envelope(ll, ur);  
                 setMapArea(bestAllowedMapArea(newMapArea));  
                 // xulu.ec  
   
                 // sk.ec  
460    
461                  // System.out.println("after area "+mapArea+"\nw:"+mapArea.getWidth()+"          final private GTRenderer localRenderer = GTUtil.createGTRenderer();
                 // h:"+mapArea.getHeight());  
                 repaint();  
         }  
462    
463          public void mouseEntered(final MouseEvent e) {          private final GTRenderer bgRenderer = GTUtil.createGTRenderer();
         }  
464    
465          public void mouseExited(final MouseEvent e) {          /**
466          }           * the area of the map to draw
467             */
468          public void mousePressed(final MouseEvent e) {          protected Envelope mapArea = null;
                 startX = e.getX();  
                 startY = e.getY();  
                 lastX = 0;  
                 lastY = 0;  
         }  
469    
470          public void mouseReleased(final MouseEvent e) {          /**
471                  final int endX = e.getX();           * A flag set it {@link #setMapArea(Envelope)} to indicated the
472                  final int endY = e.getY();           * {@link #paintComponent(Graphics)} method, that the image on-screen is
473             * associated with {@link #oldMapArea} and may hence be scaled for a quick
474             * preview.<br>
475             * The flag is reset
476             **/
477            private boolean mapAreaChanged = false;
478    
479                  processDrag(startX, startY, endX, endY, e);          /**
480                  lastX = 0;           * This color is used as the default background color when painting a map.
481                  lastY = 0;           */
482            private Color mapBackgroundColor = null;
483    
484                  /**          /**
485                   * Es wird nicht (mehr) gepannt!           * A flag indicating that the shown image is invalid and needs to be
486                   */           * re-rendered.
487                  panning_started = false;           */
488          }          protected boolean mapImageInvalid = true;
489    
490          public void mouseDragged(final MouseEvent e) {          /**
491                  final Graphics graphics = this.getGraphics();           * Holds a flag for each layer, whether it is regarded or ignored on
492                  final int x = e.getX();           * {@link #SELECT_TOP}, {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP}
493                  final int y = e.getY();           * actions.
494             */
495            final protected HashMap<MapLayer, Boolean> mapLayerSelectable = new HashMap<MapLayer, Boolean>();
496    
497                  if ((state == JMapPane.Pan)          /**
498                                  || ((e.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) {           * List of listeners of this {@link XMapPane}
499                          /**           */
500                           * SK: Der Cursor wird auf PANNING gesetzt.          protected Vector<JMapPaneListener> mapPaneListeners = new Vector<JMapPaneListener>();
501                           */          /**
502                          if (panning_started == false) {           * If not <code>null</code>, the {@link XMapPane} will not allow to zoom/pan
503                                  panning_started = true;           * out of that area
504                                  setCursor(SwingUtil.PANNING_CURSOR);           **/
505                          }          private Envelope maxExtend = null;
506            private Double maxZoomScale = Double.MIN_VALUE;
507    
508                          // move the image with the mouse          private Double minZoomScale = Double.MAX_VALUE;
                         if ((lastX > 0) && (lastY > 0)) {  
                                 final int dx = lastX - startX;  
                                 final int dy = lastY - startY;  
                                 // System.out.println("translate "+dx+","+dy);  
                                 final Graphics2D g2 = panningImage.createGraphics();  
                                 g2.setBackground(new Color(240, 240, 240)); // TODO richtige  
                                 // farbe? am besten  
                                 // vom L&F die  
                                 // hintergrundfarbe  
                                 // auslesen...  
509    
510                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());          /**
511                                  g2.drawImage(baseImage, dx, dy, this);           * We store the old mapArea for a moment to use it for the
512                                  graphics.drawImage(panningImage, 0, 0, this);           * "quick scaled preview" in case of ZoomOut
513                          }           **/
514            protected Envelope oldMapArea = null;
515    
516                          lastX = x;          /**
517                          lastY = y;           * We store the old transform for a moment to use it for the
518                  } else           * "quick scaled preview" in case of ZoomIn
519             **/
520            protected AffineTransform oldScreenToWorld = null;
521    
522                  if ((state == JMapPane.ZoomIn) || (state == JMapPane.ZoomOut)) {          /**
523             * A flag indicating, that the image size has changed and the buffered
524             * images are not big enough any more
525             **/
526            protected boolean paneResized = true;
527    
528                          graphics.setXORMode(Color.WHITE);          private BufferedImage preFinalImage;
529    
530                          if ((lastX > 0) && (lastY > 0)) {          // ** if 0, no quick preview will be shown **/
531                                  drawRectangle(graphics);          // private int quickPreviewHint = 0;
                         }  
532    
533                          // draw new box          private Map<Object, Object> rendererHints = GTUtil
534                          lastX = x;                          .getDefaultGTRendererHints(getLocalRenderer());
                         lastY = y;  
                         drawRectangle(graphics);  
                 }  
                 // else if (state == JMapPane.Select && selectionLayer != null) {  
                 //  
                 // // construct a new bbox filter  
                 // final Rectangle bounds = this.getBounds();  
                 //  
                 // final double mapWidth = mapArea.getWidth();  
                 // final double mapHeight = mapArea.getHeight();  
                 //  
                 // final double x1 = ((this.startX * mapWidth) / (double) bounds.width)  
                 // + mapArea.getMinX();  
                 // final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) /  
                 // (double) bounds.height)  
                 // + mapArea.getMinY();  
                 // final double x2 = ((x * mapWidth) / (double) bounds.width)  
                 // + mapArea.getMinX();  
                 // final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double)  
                 // bounds.height)  
                 // + mapArea.getMinY();  
                 // final double left = Math.min(x1, x2);  
                 // final double right = Math.max(x1, x2);  
                 // final double bottom = Math.min(y1, y2);  
                 // final double top = Math.max(y1, y2);  
                 //  
                 // String name = selectionLayer.getFeatureSource().getSchema()  
                 // .getDefaultGeometry().getName();  
                 //  
                 // if (name == "") {  
                 // name = "the_geom";  
                 // }  
                 // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,  
                 // top,  
                 // getContext().getCoordinateReferenceSystem().toString());  
                 // if (selectionManager != null) {  
                 // selectionManager.selectionChanged(this, bb);  
                 // }  
                 //  
                 // graphics.setXORMode(Color.green);  
                 //  
                 // /*  
                 // * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }  
                 // */  
                 //  
                 // // draw new box  
                 // lastX = x;  
                 // lastY = y;  
                 // drawRectangle(graphics);  
                 // }  
535    
536          }          /**
537             * If set to <code>true</code>, the {@link #startRenderThreadsTimer} will
538             * start rendering {@link Thread}s
539             **/
540            private volatile Boolean requestStartRendering = false;
541    
542          // sk.cs          /**
543          // private void processDrag(int x1, int y1, int x2, int y2) {           * Transformation zwischen Fenster-Koordinaten und Karten-Koordinaten
544          // sk.ce           * (lat/lon)
545          protected void processDrag(final int x1, final int y1, final int x2,           */
546                          final int y2, final MouseEvent e) {          protected AffineTransform screenToWorld = null;
547    
548            /**
549             * The flag {@link #requestStartRendering} can be set to true by events.
550             * This {@link Timer} checks the flag regularly and starts one renderer
551             * thread.
552             */
553            final private Timer startRenderThreadsTimer;
554    
555                  /****          /**
556                   * If no layers exist, we ignore the drag.           * The default state is ZOOM_IN, hence by default the
557                   */           * {@link #zoomMapPaneMouseListener} is also enabled.
558                  if (context.getLayerCount() <= 0) {           **/
559                          return;          private int state = ZOOM_IN;
                 }  
                   
                 // System.out.println("processing drag from " + x1 + "," + y1 + " -> "  
                 // + x2 + "," + y2);  
                 if ((x1 == x2) && (y1 == y2)) {  
                         if (isClickable()) {  
                                 mouseClicked(new MouseEvent(this, 0, new Date().getTime(), 0,  
                                                 x1, y1, y2, false));  
                         }  
560    
561                          return;          /**
562                  }           * Manuell gesetzter statischer Cursor, unabhaengig von der aktuellen
563             * MapPane-Funktion
564             */
565            protected Cursor staticCursor = null;
566    
567                  final Rectangle bounds = this.getBounds();          private AffineTransform worldToScreen;
568    
569                  final double mapWidth = mapArea.getWidth();          /**
570                  final double mapHeight = mapArea.getHeight();           * This {@link MouseListener} is managing all zoom related tasks
571             */
572            public final ZoomXMapPaneMouseListener zoomMapPaneMouseListener = new ZoomXMapPaneMouseListener(
573                            this);
574    
575                  final double startX = ((x1 * mapWidth) / (double) bounds.width)          /** Is set if a renderer has an error **/
576                                  + mapArea.getMinX();          protected ArrayList<Exception> renderingErrors = new ArrayList<Exception>();
                 final double startY = (((bounds.getHeight() - y1) * mapHeight) / (double) bounds.height)  
                                 + mapArea.getMinY();  
                 final double endX = ((x2 * mapWidth) / (double) bounds.width)  
                                 + mapArea.getMinX();  
                 final double endY = (((bounds.getHeight() - y2) * mapHeight) / (double) bounds.height)  
                                 + mapArea.getMinY();  
   
                 if ((state == JMapPane.Pan) || (e.getButton() == MouseEvent.BUTTON3)) {  
                         // move the image with the mouse  
                         // calculate X offsets from start point to the end Point  
                         final double deltaX1 = endX - startX;  
   
                         // System.out.println("deltaX " + deltaX1);  
                         // new edges  
                         final double left = mapArea.getMinX() - deltaX1;  
                         final double right = mapArea.getMaxX() - deltaX1;  
   
                         // now for Y  
                         final double deltaY1 = endY - startY;  
   
                         // System.out.println("deltaY " + deltaY1);  
                         final double bottom = mapArea.getMinY() - deltaY1;  
                         final double top = mapArea.getMaxY() - deltaY1;  
                         final Coordinate ll = new Coordinate(left, bottom);  
                         final Coordinate ur = new Coordinate(right, top);  
                         // xulu.sc  
                         // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));  
                           
   
                         setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));  
                         // xulu.ec  
                 } else if (state == JMapPane.ZoomIn) {  
   
                         // Zu kleine Flächen sollen nicht gezoomt werden.  
                         // sk.bc  
                         if ((Math.abs(x1 - x2) * Math.abs(y2 - y1)) < 150)  
                                 return;  
                         // sk.ec  
   
                         drawRectangle(this.getGraphics());  
                         // make the dragged rectangle (in map coords) the new BBOX  
                         final double left = Math.min(startX, endX);  
                         final double right = Math.max(startX, endX);  
                         final double bottom = Math.min(startY, endY);  
                         final double top = Math.max(startY, endY);  
                         final Coordinate ll = new Coordinate(left, bottom);  
                         final Coordinate ur = new Coordinate(right, top);  
                         // xulu.sc  
   
                         // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));  
                         setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));  
   
                         // sk.sc  
                         // {  
                         // // SK tries to paint a preview of the zoom ;-9 aha.... well  
                         // Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();  
                         // graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,  
                         // RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);  
                         // graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,  
                         // RenderingHints.VALUE_ANTIALIAS_OFF);  
                         // graphics.setRenderingHint(RenderingHints.KEY_RENDERING,  
                         // RenderingHints.VALUE_RENDER_SPEED);  
                         // graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),  
                         // JMapPane.this.getHeight(), x1, y1, x2, y2, null);  
                         // }  
                         // xulu.ec  
                 } else if (state == JMapPane.ZoomOut) {  
                         drawRectangle(this.getGraphics());  
   
                         // make the dragged rectangle in screen coords the new map size?  
                         final double left = Math.min(startX, endX);  
                         final double right = Math.max(startX, endX);  
                         final double bottom = Math.min(startY, endY);  
                         final double top = Math.max(startY, endY);  
                         final double nWidth = (mapWidth * mapWidth) / (right - left);  
                         final double nHeight = (mapHeight * mapHeight) / (top - bottom);  
                         final double deltaX1 = left - mapArea.getMinX();  
                         final double nDeltaX1 = (deltaX1 * nWidth) / mapWidth;  
                         final double deltaY1 = bottom - mapArea.getMinY();  
                         final double nDeltaY1 = (deltaY1 * nHeight) / mapHeight;  
                         final Coordinate ll = new Coordinate(mapArea.getMinX() - nDeltaX1,  
                                         mapArea.getMinY() - nDeltaY1);  
                         final double deltaX2 = mapArea.getMaxX() - right;  
                         final double nDeltaX2 = (deltaX2 * nWidth) / mapWidth;  
                         final double deltaY2 = mapArea.getMaxY() - top;  
                         final double nDeltaY2 = (deltaY2 * nHeight) / mapHeight;  
                         final Coordinate ur = new Coordinate(mapArea.getMaxX() + nDeltaX2,  
                                         mapArea.getMaxY() + nDeltaY2);  
                         // xulu.sc  
                         // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));  
                         setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));  
   
                         // xulu.ec  
                 }  
                 // else if (state == JMapPane.Select && selectionLayer != null) {  
                 // final double left = Math.min(startX, endX);  
                 // final double right = Math.max(startX, endX);  
                 // final double bottom = Math.min(startY, endY);  
                 // final double top = Math.max(startY, endY);  
                 //  
                 // String name = selectionLayer.getFeatureSource().getSchema()  
                 // .getDefaultGeometry().getLocalName();  
                 //  
                 // if (name == "") {  
                 // name = "the_geom";  
                 // }  
                 // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,  
                 // top,  
                 // getContext().getCoordinateReferenceSystem().toString());  
                 // // System.out.println(bb.toString());  
                 // if (selectionManager != null) {  
                 // selectionManager.selectionChanged(this, bb);  
                 // }  
                 // /*  
                 // * FeatureCollection fc; selection = null; try { fc =  
                 // * selectionLayer.getFeatureSource().getFeatures(bb); selection =  
                 // * fc; } catch (IOException e) { e.printStackTrace(); }  
                 // */  
                 // }  
577    
578                  // xulu.so          /**
579                  // setMapArea(mapArea);           * If <code>true</code>, then rendering exceptions are rendererd into the
580                  // xulu.eo           * map pane
581                  repaint();           **/
582          }          private boolean showExceptions = false;
583    
584          private boolean isClickable() {          public XMapPane() {
585                  return clickable;                  this(null, null);
586          }          }
587    
588          //          /**
589          // private org.geotools.styling.Style setupStyle(final int type, final Color           * full constructor extending JPanel
590          // color) {           *
591          // final StyleFactory sf = org.geotools.factory.CommonFactoryFinder           * @param rendererHints
592          // .getStyleFactory(null);           *            may be <code>null</code>. Otherwise a {@link Map<Object,
593          // final StyleBuilder sb = new StyleBuilder();           *            Object>} of {@link RenderingHints} to override the default
594          //           *            from {@link GTUtil#getDefaultGTRendererHints(GTRenderer)}
595          // org.geotools.styling.Style s = sf.createStyle();           *
596          // s.setTitle("selection");           * @param localContext
597          //           *            The main {@link MapContext} to use. If <code>null</code>, an
598          // // TODO parameterise the color           *            empty {@link DefaultMapContext} will be created.
599          // final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);           */
600          // ps.setStroke(sb.createStroke(color));          public XMapPane(final MapContext localContext_,
601          //                          final Map<Object, Object> rendererHints) {
602          // final LineSymbolizer ls = sb.createLineSymbolizer(color);                  super(true);
         // final Graphic h = sb.createGraphic();  
         // h.setMarks(new Mark[] { sb.createMark("square", color) });  
         //  
         // final PointSymbolizer pts = sb.createPointSymbolizer(h);  
         //  
         // // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});  
         // switch (type) {  
         // case POLYGON:  
         // s = sb.createStyle(ps);  
         //  
         // break;  
         //  
         // case POINT:  
         // s = sb.createStyle(pts);  
         //  
         // break;  
         //  
         // case LINE:  
         // s = sb.createStyle(ls);  
         // }  
         //  
         // return s;  
         // }  
603    
604          public void propertyChange(final PropertyChangeEvent evt) {                  setRendererHints(rendererHints);
                 final String prop = evt.getPropertyName();  
605    
606                  if (prop.equalsIgnoreCase("crs")) {                  setOpaque(true);
                         context.setAreaOfInterest(context.getAreaOfInterest(),  
                                         (CoordinateReferenceSystem) evt.getNewValue());  
                 }  
         }  
607    
608          public boolean isReset() {                  if (localContext_ != null)
609                  return reset;                          setLocalContext(localContext_);
         }  
610    
611          public void setReset(final boolean reset) {                  /**
612                  this.reset = reset;                   * Adding the #zoomMapPaneMouseListener
613          }                   */
614                    this.addMouseListener(zoomMapPaneMouseListener);
615                    this.addMouseMotionListener(zoomMapPaneMouseListener);
616                    this.addMouseWheelListener(zoomMapPaneMouseListener);
617    
618          public void layerAdded(final MapLayerListEvent event) {                  /*
619                  changed = true;                   * We use a Timer object to avoid rendering delays and flickering when
620                     * the user is drag-resizing the parent container of this map pane.
621                     *
622                     * Using a ComponentListener doesn't work because, unlike a JFrame, the
623                     * pane receives a stream of events during drag-resizing.
624                     */
625                    resizeTimer = new Timer(DEFAULT_RESIZING_PAINT_DELAY,
626                                    new ActionListener() {
627    
628                  if (context.getLayers().length == 1) { // the first one                                          public void actionPerformed(final ActionEvent e) {
629                                                    if (!isWellDefined())
630                                                            return;
631    
632                                                    // LOGGER.debug("resizeTimer performed");
633    
634                                                    // final Rectangle bounds = getVisibleRect();
635                                                    //
636                                                    // System.out.println("\n\ntimer performs with bounds = "
637                                                    // + bounds);
638    
639                                                    // final Envelope geoMapArea = tranformWindowToGeo(
640                                                    // bounds.x, bounds.y, bounds.x + bounds.width,
641                                                    // bounds.y + bounds.height);
642    
643                                                    paneResized = true;
644                                                    if (!setMapArea(getMapArea())) {
645                                                            // It's important to request new rendering here.
646                                                            // setMapArea only returns true and only calls
647                                                            // requestStartRendering if the maparea has changed.
648                                                            // But if the component is resized, the maparea
649                                                            // doesn't have to change.
650                                                            requestStartRendering();
651                                                    }
652    
653                                            }
654                                    });
655                    resizeTimer.setRepeats(false);
656    
657                    this.addComponentListener(new ComponentAdapter() {
658    
659                            private Rectangle oldVisibleRect;
660    
661                            @Override
662                            public void componentResized(final ComponentEvent e) {
663    
664                                    // Seems to be called twice with the same size..
665                                    if (oldVisibleRect != null
666                                                    && oldVisibleRect.equals(getVisibleRect())) {
667                                            // LOGGER.debug("skipping resize.");
668                                            return;
669                                    }
670    
671                          try {                                  // LOGGER.debug("resized: " + getVisibleRect());
672                                  // xulu.sc                                  resizeTimer.restart();
673                                  // mapArea = context.getLayerBounds();                                  oldVisibleRect = getVisibleRect();
                                 mapArea = context.getAreaOfInterest();  
                                 if (mapArea == null)  
                                         mapArea = context.getLayerBounds();  
                                 // xulu.ec  
                         } catch (final IOException e) {  
                                 // TODO Auto-generated catch block  
                                 e.printStackTrace();  
674                          }                          }
675    
676                          reset = true;                  });
                 }  
677    
678                  repaint();                  /*
679          }                   * Setting up the repaintTimer. Not started automatically.
680                     */
681                    repaintTimer = new Timer(REPEATING_REPAINT_DELAY, new ActionListener() {
682    
683          public void layerRemoved(final MapLayerListEvent event) {                          @Override
684                  changed = true;                          public void actionPerformed(final ActionEvent e) {
685                  repaint();                                  if ((!localExecuter.isRunning())
686          }                                                  && (bgExecuter != null && !bgExecuter.isRunning())) {
687                                            repaintTimer.stop();
688                                    } else {
689                                            updateFinalImage();
690                                            XMapPane.this.repaint(100);
691    
692          public void layerChanged(final MapLayerListEvent event) {                                  }
693                  changed = true;                          }
694                  // System.out.println("layer changed - repaint");                  });
                 repaint();  
         }  
695    
696          public void layerMoved(final MapLayerListEvent event) {                  repaintTimer.setInitialDelay(INITIAL_REPAINT_DELAY);
697                  changed = true;                  repaintTimer.setRepeats(true);
698                  repaint();  
699          }                  /*
700                     * Setting up the startRenderThreadsTimer. This Timer starts
701                     * automatically.
702                     */
703                    startRenderThreadsTimer = new Timer(100, new ActionListener() {
704    
705                            @Override
706                            public void actionPerformed(final ActionEvent e) {
707                                    synchronized (requestStartRendering) {
708                                            if (requestStartRendering && isWellDefined()) {
709    
710                                                    if (localExecuter.isRunning()) {
711                                                            localExecuter.cancelTask();
712                                                    } else {
713                                                            // Stupidly, but we have to recheck the
714                                                            setMapArea(getMapArea());
715                                                            requestStartRendering = false;
716                                                            startRendering();
717                                                    }
718                                            }
719                                    }
720                            }
721                    });
722                    startRenderThreadsTimer.start();
723    
         protected void drawRectangle(final Graphics graphics) {  
                 // undraw last box/draw new box  
                 final int left = Math.min(startX, lastX);  
                 final int right = Math.max(startX, lastX);  
                 final int top = Math.max(startY, lastY);  
                 final int bottom = Math.min(startY, lastY);  
                 final int width = right - left;  
                 final int height = top - bottom;  
                 // System.out.println("drawing rect("+left+","+bottom+","+ width+","+  
                 // height+")");  
                 graphics.drawRect(left, bottom, width, height);  
724          }          }
725    
726          /**          /**
727           * if clickable is set to true then a single click on the map pane will zoom           * Fuegt der Map einen Listener hinzu.
          * or pan the map.  
728           *           *
729           * @param clickable           * @param l
730             *            neuer Listener
731           */           */
732          public void setClickable(final boolean clickable) {          public void addMapPaneListener(final JMapPaneListener l) {
733                  this.clickable = clickable;                  mapPaneListeners.add(l);
734          }          }
735    
         public void mouseMoved(final MouseEvent e) {  
         }  
   
         // xulu.sn  
736          /**          /**
737           * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste           * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste
738           * erlaubte Flaeche damit die Massstabsbeschaenkungen noch eingehalten           * erlaubte Flaeche damit die Massstabsbeschaenkungen noch eingehalten
739           * werden, FALLS der uebergeben Envelope nicht schon gueltig sein sollte.<br/>           * werden, FALLS der uebergeben Envelope nicht schon gueltig sein sollte.<br>
740           * Since 21. April 09: Before thecalculation starts, the aspect ratio is           * Since 21. April 09: Before thecalculation starts, the aspect ratio is
741           * corrected. This change implies, that setMapArea() will most of the time           * corrected. This change implies, that setMapArea() will most of the time
742           * not allow setting to a wrong aspectRatio.           * not allow setting to a wrong aspectRatio.
# Line 907  public class JMapPane extends JPanel imp Line 744  public class JMapPane extends JPanel imp
744           * @author <a href="mailto:[email protected]">Stefan Alfons           * @author <a href="mailto:[email protected]">Stefan Alfons
745           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
746           */           */
747          public Envelope bestAllowedMapArea(Envelope env) {          public ReferencedEnvelope bestAllowedMapArea(ReferencedEnvelope env) {
748    
749                  if (getWidth() == 0)                  if (getWidth() == 0)
750                          return env;                          return env;
751    
752                  if (env == null)                  if (env == null)
753                          return env;                          return null;
754    
755                  Envelope newArea = null;                  Envelope newArea = null;
756    
757                  /**                  /**
758                   * Correct the aspect Ratio before we check the rest. Otherwise we might                   * Correct the aspect Ratio before we check the rest. Otherwise we might
759                   * easily fail.                   * easily fail. We allow to grow here, because we don't check against
760                     * the maxExtend
761                   */                   */
762                  env = fixAspectRatio(this.getBounds(), env, false);                  final Rectangle curPaintArea = getVisibleRect();
763    
764                    env = JTSUtil.fixAspectRatio(curPaintArea, env, true);
765    
766                  final double scale = env.getWidth() / getWidth();                  final double scale = env.getWidth() / getWidth();
767                  final double centerX = env.getMinX() + env.getWidth() / 2.;                  final double centerX = env.getMinX() + env.getWidth() / 2.;
# Line 955  public class JMapPane extends JPanel imp Line 797  public class JMapPane extends JPanel imp
797                          newArea = new Envelope(ll, ur);                          newArea = new Envelope(ll, ur);
798                  }                  }
799    
800                  Envelope maxAllowedExtend = getMaxExtend();                  final Envelope maxAllowedExtend = getMaxExtend();
801                  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()) ) {  
802                    while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea)
803                                    && newArea != null && !newArea.isNull()
804                                    && !Double.isNaN(newArea.getMinX())
805                                    && !Double.isNaN(newArea.getMaxX())
806                                    && !Double.isNaN(newArea.getMinY())
807                                    && !Double.isNaN(newArea.getMaxY())) {
808                          /*                          /*
809                           * If a maxExtend is set, we have to honour that...                           * If a maxExtend is set, we have to honour that...
810                           */                           */
811    
812                          // Exceeds top? Move down and maybe cut                          // Exceeds top? Move down and maybe cut
813                          if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {                          if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
814                                  double divY = newArea.getMaxY() - maxAllowedExtend.getMaxY();                                  final double divY = newArea.getMaxY()
815  //                              LOGGER.debug("Moving area down by " + divY);                                                  - maxAllowedExtend.getMaxY();
816                                    // LOGGER.debug("Moving area down by " + divY);
817    
818                                  newArea = new Envelope(new Coordinate(newArea.getMinX(),                                  newArea = new Envelope(new Coordinate(newArea.getMinX(),
819                                                  newArea.getMinY() - divY), new Coordinate(newArea                                                  newArea.getMinY() - divY), new Coordinate(newArea
820                                                  .getMaxX(), newArea.getMaxY() - divY));                                                  .getMaxX(), newArea.getMaxY() - divY));
821    
822                                  if (newArea.getMinY() < maxAllowedExtend.getMinY()) {                                  if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
823  //                                      LOGGER.debug("Now it exeeds the bottom border.. cut!");                                          // LOGGER.debug("Now it exeeds the bottom border.. cut!");
824                                          // And cut the bottom if it moved out of the area                                          // And cut the bottom if it moved out of the area
825                                          newArea = new Envelope(new Coordinate(newArea.getMinX(),                                          newArea = new Envelope(new Coordinate(newArea.getMinX(),
826                                                          maxAllowedExtend.getMinY()), new Coordinate(newArea                                                          maxAllowedExtend.getMinY()), new Coordinate(newArea
827                                                          .getMaxX(), newArea.getMaxY()));                                                          .getMaxX(), newArea.getMaxY()));
828    
829  //                                      LOGGER.debug("and fix aspect ratio");                                          // LOGGER.debug("and fix aspect ratio");
830    
831                                          newArea = fixAspectRatio(this.getBounds(), newArea, false);                                          newArea = JTSUtil.fixAspectRatio(getVisibleRect(),
832                                                            new ReferencedEnvelope(newArea, env
833                                                                            .getCoordinateReferenceSystem()), false);
834                                  }                                  }
835                          }                          }
836    
837                          // Exceeds bottom? Move up and maybe cut                          // Exceeds bottom? Move up and maybe cut
838                          if (newArea.getMinY() < maxAllowedExtend.getMinY()) {                          if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
839                                  double divY = newArea.getMinY() - maxAllowedExtend.getMinY();                                  final double divY = newArea.getMinY()
840  //                              LOGGER.debug("Moving area up by " + divY);                                                  - maxAllowedExtend.getMinY();
841                                    // LOGGER.debug("Moving area up by " + divY);
842    
843                                  newArea = new Envelope(new Coordinate(newArea.getMinX(),                                  newArea = new Envelope(new Coordinate(newArea.getMinX(),
844                                                  newArea.getMinY() - divY), new Coordinate(newArea                                                  newArea.getMinY() - divY), new Coordinate(newArea
845                                                  .getMaxX(), newArea.getMaxY() - divY));                                                  .getMaxX(), newArea.getMaxY() - divY));
846    
847                                  if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {                                  if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
848  //                                      LOGGER.debug("Now it exeeds the top border.. cut!");                                          // LOGGER.debug("Now it exeeds the top border.. cut!");
849                                          // And cut the bottom if it moved out of the area                                          // And cut the bottom if it moved out of the area
850                                          newArea = new Envelope(new Coordinate(newArea.getMinX(),                                          newArea = new Envelope(new Coordinate(newArea.getMinX(),
851                                                          newArea.getMinY()), new Coordinate(newArea                                                          newArea.getMinY()), new Coordinate(newArea
852                                                          .getMaxX(), maxAllowedExtend.getMaxY()));                                                          .getMaxX(), maxAllowedExtend.getMaxY()));
853    
854  //                                      LOGGER.debug("and fix aspect ratio");                                          // LOGGER.debug("and fix aspect ratio");
855    
856                                          newArea = fixAspectRatio(this.getBounds(), newArea, false);                                          newArea = JTSUtil.fixAspectRatio(getVisibleRect(),
857                                                            new ReferencedEnvelope(newArea, env
858                                                                            .getCoordinateReferenceSystem()), false);
859                                  }                                  }
860                          }                          }
861    
# Line 1009  public class JMapPane extends JPanel imp Line 863  public class JMapPane extends JPanel imp
863                          if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {                          if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
864    
865                                  // Move left..                                  // Move left..
866                                  double divX = newArea.getMaxX() - maxAllowedExtend.getMaxX();                                  final double divX = newArea.getMaxX()
867  //                              LOGGER.debug("Moving area left by " + divX);                                                  - maxAllowedExtend.getMaxX();
868                                    // LOGGER.debug("Moving area left by " + divX);
869    
870                                  newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,                                  newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
871                                                  newArea.getMinY()), new Coordinate(newArea.getMaxX()                                                  newArea.getMinY()), new Coordinate(newArea.getMaxX()
872                                                  - divX, newArea.getMaxY()));                                                  - divX, newArea.getMaxY()));
873    
874                                  if (newArea.getMinX() < maxAllowedExtend.getMinX()) {                                  if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
875  //                                      LOGGER.debug("Now it exeeds the left border.. cut!");                                          // LOGGER.debug("Now it exeeds the left border.. cut!");
876                                          // And cut the left if it moved out of the area                                          // And cut the left if it moved out of the area
877                                          newArea = new Envelope(new Coordinate(maxAllowedExtend.getMinX(),                                          newArea = new Envelope(new Coordinate(maxAllowedExtend
878                                                          newArea.getMinY()), new Coordinate(newArea                                                          .getMinX(), newArea.getMinY()), new Coordinate(
879                                                          .getMaxX(), newArea.getMaxY()));                                                          newArea.getMaxX(), newArea.getMaxY()));
880    
881  //                                      LOGGER.debug("and fix aspect ratio");                                          // LOGGER.debug("and fix aspect ratio");
882    
883                                          newArea = fixAspectRatio(this.getBounds(), newArea, false);                                          newArea = JTSUtil.fixAspectRatio(getVisibleRect(),
884                                                            new ReferencedEnvelope(newArea, env
885                                                                            .getCoordinateReferenceSystem()), false);
886                                  }                                  }
887                          }                          }
888    
# Line 1033  public class JMapPane extends JPanel imp Line 890  public class JMapPane extends JPanel imp
890                          if (newArea.getMinX() < maxAllowedExtend.getMinX()) {                          if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
891    
892                                  // Move right..                                  // Move right..
893                                  double divX = newArea.getMinX() - maxAllowedExtend.getMinX();                                  final double divX = newArea.getMinX()
894  //                              LOGGER.debug("Moving area right by " + divX);                                                  - maxAllowedExtend.getMinX();
895                                    // LOGGER.debug("Moving area right by " + divX);
896    
897                                  newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,                                  newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
898                                                  newArea.getMinY()), new Coordinate(newArea.getMaxX()                                                  newArea.getMinY()), new Coordinate(newArea.getMaxX()
899                                                  - divX, newArea.getMaxY()));                                                  - divX, newArea.getMaxY()));
900    
901                                  if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {                                  if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
902  //                                      LOGGER.debug("Now it exeeds the right border.. cut!");                                          // LOGGER.debug("Now it exeeds the right border.. cut!");
903                                          // And cut the left if it moved out of the area                                          // And cut the left if it moved out of the area
904                                          newArea = new Envelope(new Coordinate(newArea.getMinX(),                                          newArea = new Envelope(new Coordinate(newArea.getMinX(),
905                                                          newArea.getMinY()), new Coordinate(maxAllowedExtend                                                          newArea.getMinY()), new Coordinate(maxAllowedExtend
906                                                          .getMaxX(), newArea.getMaxY()));                                                          .getMaxX(), newArea.getMaxY()));
907    
908  //                                      LOGGER.debug("and fix aspect ratio");                                          // LOGGER.debug("and fix aspect ratio");
909    
910                                          newArea = fixAspectRatio(this.getBounds(), newArea, false);                                          newArea = JTSUtil.fixAspectRatio(getVisibleRect(),
911                                                            new ReferencedEnvelope(newArea, env
912                                                                            .getCoordinateReferenceSystem()), false);
913                                  }                                  }
914                          }                          }
   
915                  }                  }
916    
917                  return newArea;                  return new ReferencedEnvelope(newArea, env
918                                    .getCoordinateReferenceSystem());
919          }          }
920    
921          /**          /**
922           * Retuns the minimum allowed zoom scale. This is the bigger number value of           * Should be called when the {@link JMapPane} is not needed no more to help
923           * the two. Defaults to {@link Double}.MAX_VALUE           * the GarbageCollector
924             *
925             * Removes all {@link JMapPaneListener}s that are registered
926           *           *
927           * @author <a href="mailto:[email protected]">Stefan Alfons           * @author <a href="mailto:[email protected]">Stefan Alfons
928           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
929           */           */
930          public Double getMinZoomScale() {          public void dispose() {
931                  return minZoomScale;                  if (isDisposed())
932                            return;
933    
934                    setPainting(false);
935    
936                    resizeTimer.stop();
937                    startRenderThreadsTimer.stop();
938    
939                    disposed = true;
940    
941                    if (bgExecuter != null) {
942                            bgExecuter.cancelTask();
943                            bgExecuter.dispose();
944                    }
945    
946                    if (localExecuter.isRunning()) {
947                            int i = 0;
948                            localExecuter.cancelTask();
949                            while (i++ < 10 && localExecuter.isRunning()) {
950                                    try {
951                                            Thread.sleep(200);
952                                    } catch (final InterruptedException e) {
953                                            LOGGER
954                                                            .warn(
955                                                                            "while XMapPane we are waiting for the localExcutor to stop",
956                                                                            e);
957                                    }
958                            }
959                            if (localExecuter.isRunning()) {
960                                    LOGGER
961                                                    .warn("localExecutor Thread still running after 2s! Continuing anyways...");
962                            }
963                            localExecuter.dispose();
964                    }
965    
966                    disposeImages();
967    
968                    // Remove all mapPaneListeners that have registered with us
969                    mapPaneListeners.clear();
970    
971                    removeMouseMotionListener(zoomMapPaneMouseListener);
972                    removeMouseListener(zoomMapPaneMouseListener);
973    
974                    if (localContext != null)
975                            getMapContext().clearLayerList();
976                    if (bgContext != null)
977                            getBgContext().clearLayerList();
978    
979                    removeAll();
980            }
981    
982            /**
983             * Draws a rectangle in XOR mode from the origin at {@link #startPos} to the
984             * given point. All in screen coordinates.
985             */
986            protected void drawRectangle(final Graphics graphics, final Point startPos,
987                            final Point e) {
988    
989                    if (!isWellDefined())
990                            return;
991    
992                    // undraw last box/draw new box
993                    final int left = Math.min(startPos.x, e.x);
994                    final int right = Math.max(startPos.x, e.x);
995                    final int top = Math.max(startPos.y, e.y);
996                    final int bottom = Math.min(startPos.y, e.y);
997                    final int width = right - left;
998                    final int height = top - bottom;
999    
1000                    if (width == 0 && height == 0)
1001                            return;
1002    
1003                    graphics.setXORMode(Color.WHITE);
1004                    graphics.drawRect(left, bottom, width, height);
1005            }
1006    
1007            /**
1008             * Diretly paints scaled preview into the {@link SelectableXMapPane}. Used
1009             * to give the user something to look at while we are rendering. Method
1010             * should be called after {@link #setMapArea(Envelope)} has been set to the
1011             * new mapArea and transform has been reset.<br>
1012             *
1013             * @param g
1014             *            Graphics2D to paint the preview into
1015             */
1016            protected boolean drawScaledPreviewImage_Zoom(final Graphics2D graphics) {
1017    
1018                    // if (1 == 1)return false;
1019                    // if (quickPreviewHint == 0)
1020                    // return false;
1021    
1022                    if (oldMapArea == null)
1023                            return false;
1024    
1025                    if (getPreFinalImage() == null)
1026                            return false;
1027    
1028                    final Rectangle visibleArea = getVisibleRect();
1029    
1030                    // Calculate the oldMapArea in the current WindowCoordinates:
1031                    final Envelope oldMapWindow = tranformGeoToWindow(oldMapArea.getMinX(),
1032                                    oldMapArea.getMinY(), oldMapArea.getMaxX(), oldMapArea
1033                                                    .getMaxY());
1034    
1035                    final int xx1 = (int) Math.round(oldMapWindow.getMinX());
1036                    final int yy1 = (int) Math.round(oldMapWindow.getMinY());
1037                    final int xx2 = (int) Math.round(oldMapWindow.getMaxX());
1038                    final int yy2 = (int) Math.round(oldMapWindow.getMaxY());
1039    
1040                    graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
1041                                    RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
1042                    graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
1043                                    RenderingHints.VALUE_ANTIALIAS_OFF);
1044                    graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
1045                                    RenderingHints.VALUE_RENDER_SPEED);
1046    
1047                    graphics.drawImage(getPreFinalImage(), xx1, yy1, xx2, yy2,
1048                                    (int) visibleArea.getMinX(), (int) visibleArea.getMinY(),
1049                                    (int) visibleArea.getMaxX(), (int) visibleArea.getMaxY(),
1050                                    getMapBackgroundColor(), null);
1051    
1052                    final Rectangle painedArea = new Rectangle(xx1, yy1, xx2 - xx1, yy2
1053                                    - yy1);
1054    
1055                    SwingUtil.clearAround(graphics, painedArea, visibleArea,
1056                                    getMapBackgroundColor());
1057    
1058                    addGadgets(graphics, true);
1059    
1060                    // quickPreviewHint = 0;
1061    
1062                    repaintTimer.restart();
1063    
1064                    // Something has been drawn
1065                    return true;
1066            }
1067    
1068            public MapContext getBgContext() {
1069                    return bgContext;
1070            }
1071    
1072            /**
1073             * Lazyly initializes a {@link BufferedImage} for the background renderer.
1074             */
1075            private Image getBgImage() {
1076                    if (bgImage == null) {
1077                            bgImage = new BufferedImage(getVisibleRect().width,
1078                                            getVisibleRect().height, IMAGETYPE);
1079                            SwingUtil.clearImage(finalImage, getMapBackgroundColor());
1080                    }
1081    
1082                    return bgImage;
1083            }
1084    
1085            public MapContext getMapContext() {
1086                    if (localContext == null) {
1087                            setLocalContext(new DefaultMapContext());
1088                    }
1089                    return localContext;
1090            }
1091    
1092            private BufferedImage getFinalImage() {
1093                    //
1094                    if (finalImage == null) {
1095                            // Rectangle curPaintArea = getVisibleRect();
1096                            finalImage = new BufferedImage(getVisibleRect().width,
1097                                            getVisibleRect().height, IMAGETYPE);
1098                            SwingUtil.clearImage(finalImage, getMapBackgroundColor());
1099    
1100                            // requestStartRendering();
1101                    }
1102                    return finalImage;
1103            }
1104    
1105            /**
1106             * Lazyly initializes a {@link BufferedImage} for the background renderer.
1107             */
1108            private BufferedImage getLocalImage() {
1109    
1110                    if (localImage == null) {
1111                            localImage = new BufferedImage(getVisibleRect().width,
1112                                            getVisibleRect().height, IMAGETYPE_withAlpha);
1113                            SwingUtil.clearImage(localImage, getMapBackgroundColor());
1114                    }
1115    
1116                    return localImage;
1117            }
1118    
1119            /**
1120             * Returns a copy of the mapArea
1121             *
1122             * @return
1123             */
1124            public ReferencedEnvelope getMapArea() {
1125                    if (mapArea == null) {
1126                            ReferencedEnvelope mapArea_ = null;
1127                            try {
1128                                    mapArea_ = localContext.getLayerBounds();
1129                            } catch (final IOException e) {
1130                                    LOGGER.warn("localContext.getLayerBounds()", e);
1131                            }
1132    
1133                            if (mapArea_ == null && bgContext != null) {
1134                                    try {
1135                                            mapArea_ = bgContext.getLayerBounds();
1136                                    } catch (final IOException e) {
1137                                            LOGGER.warn("bgContext.getLayerBounds()", e);
1138                                    }
1139                            }
1140    
1141                            if (mapArea_ != null) {
1142                                    mapArea = bestAllowedMapArea(mapArea_);
1143                                    requestStartRendering();
1144                            }
1145                    }
1146    
1147                    if (mapArea == null)
1148                            return null;
1149    
1150                    // TODO is needed at all, this should go to setMapArea maybe
1151                    if (localContext.getCoordinateReferenceSystem() == null)
1152                            try {
1153                                    localContext.setCoordinateReferenceSystem(GeoImportUtil
1154                                                    .getDefaultCRS());
1155                            } catch (final Exception e) {
1156                                    throw new RuntimeException("setting context CRS:", e);
1157                            }
1158    
1159                    return new ReferencedEnvelope(mapArea, localContext
1160                                    .getCoordinateReferenceSystem());
1161            }
1162    
1163            /**
1164             * Returns the background {@link Color} of the map pane. If not set, the
1165             * methods looks for a parent component and will use its background color.
1166             * If no parent component is available, WHITE is returned.
1167             **/
1168            public Color getMapBackgroundColor() {
1169                    if (mapBackgroundColor == null) {
1170                            if (getParent() != null)
1171                                    return getParent().getBackground();
1172                            else
1173                                    return Color.WHITE;
1174                    }
1175                    return mapBackgroundColor;
1176            }
1177    
1178            /**
1179             * Get the BufferedImage to use as a flaoting icon in the lower right
1180             * corner.
1181             *
1182             * @return <code>null</code> if the feature is deactivated.
1183             */
1184            public BufferedImage getMapImage() {
1185                    return mapImage;
1186            }
1187    
1188            /**
1189             * Returns the evelope of the viewable area. The JMapPane will never show
1190             * anything outside of this extend. If this has been set to
1191             * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
1192             * quickly the context's bounds. It it takes to long to determine the
1193             * context bounds, <code>null</code> is returned.
1194             *
1195             * @param maxExtend
1196             *            <code>null</code> to not have this restriction.
1197             */
1198    
1199            public Envelope getMaxExtend() {
1200                    if (maxExtend == null) {
1201    
1202                            // The next command may take long time!
1203                            // long start = System.currentTimeMillis();
1204                            final ReferencedEnvelope layerBounds = GTUtil
1205                                            .getVisibleLayoutBounds(localContext);
1206                            //                      
1207                            // LOGGER.info(
1208                            // (System.currentTimeMillis()-start)+"m to get maxExtend");
1209                            //                      
1210                            if (layerBounds == null) {
1211                                    // // TODO Last fallback could be the CRS valid area
1212                                    return null;
1213                            }
1214    
1215                            // Vergrößerung um 10% nochmal rausgenommen
1216                            // // // Kartenbereich um 10% vergroessern
1217                            // return JTSUtil.fixAspectRatio(getVisibleRect(), JTSUtil
1218                            // .expandEnvelope(layerBounds, 0.1), true);
1219    
1220                            return JTSUtil.fixAspectRatio(getVisibleRect(), layerBounds, true);
1221                    }
1222                    return maxExtend;
1223          }          }
1224    
1225          /**          /**
# Line 1081  public class JMapPane extends JPanel imp Line 1234  public class JMapPane extends JPanel imp
1234          }          }
1235    
1236          /**          /**
1237             * Retuns the minimum allowed zoom scale. This is the bigger number value of
1238             * the two. Defaults to {@link Double}.MAX_VALUE
1239             *
1240             * @author <a href="mailto:[email protected]">Stefan Alfons
1241             *         Kr&uuml;ger</a>
1242             */
1243            public Double getMinZoomScale() {
1244                    return minZoomScale;
1245            }
1246    
1247            private Image getPreFinalImage() {
1248                    return preFinalImage;
1249            }
1250    
1251            public Map<Object, Object> getRendererHints() {
1252                    // Clear label cache
1253                    labelCache.clear();
1254                    rendererHints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);
1255    
1256                    return rendererHints;
1257            }
1258    
1259            /**
1260             * Liefert eine affine Transformation, um von den Fenster-Koordinaten in die
1261             * Karten-Koordinaten (Lat/Lon) umzurechnen.
1262             *
1263             * @return eine Kopie der aktuellen Transformation; <code>null</code> wenn
1264             *         noch keine Karte angezeigt wird
1265             */
1266            public AffineTransform getScreenToWorld() {
1267                    if (screenToWorld == null)
1268                            resetTransforms();
1269                    // nur Kopie der Transformation zurueckgeben!
1270                    if (screenToWorld == null)
1271                            return null;
1272                    return new AffineTransform(screenToWorld);
1273            }
1274    
1275            public int getState() {
1276                    return state;
1277            }
1278    
1279            /**
1280             * Liefert den statisch eingestellten Cursor, der unabhaengig von der
1281             * eingestellten MapPane-Aktion (Zoom, Auswahl, ...) verwendet wird.
1282             *
1283             * @return {@code null}, wenn kein statischer Cursor verwendet, sondern der
1284             *         Cursor automatisch je nach MapPane-Aktion eingestellt wird.
1285             */
1286            public Cursor getStaticCursor() {
1287                    return this.staticCursor;
1288            }
1289    
1290            public AffineTransform getWorldToScreenTransform() {
1291                    if (worldToScreen == null) {
1292                            resetTransforms();
1293                    }
1294                    // nur Kopie der Transformation zurueckgeben!
1295                    return new AffineTransform(worldToScreen);
1296            }
1297    
1298            /**
1299             * A flag indicating if dispose() has already been called. If true, then
1300             * further use of this {@link SelectableXMapPane} is undefined.
1301             */
1302            private boolean isDisposed() {
1303                    return disposed;
1304            }
1305    
1306            /**
1307             * Returns whether a layer is regarded or ignored on {@link #SELECT_TOP},
1308             * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions. Returns
1309             * <code>true</code> if the selectability has not been defined.
1310             *
1311             * @param layer
1312             *            a layer
1313             */
1314            public boolean isMapLayerSelectable(final MapLayer layer) {
1315                    final Boolean selectable = mapLayerSelectable.get(layer);
1316                    return selectable == null ? true : selectable;
1317            }
1318    
1319            /**
1320             * Return <code>true</code> if a CRS and a {@link #mapArea} are set and the
1321             * {@link XMapPane} is visible and has bounds set.
1322             */
1323            public boolean isWellDefined() {
1324                    try {
1325                            if (getMapContext() == null)
1326                                    return false;
1327                            if (getMapContext().getLayerCount() <= 0)
1328                                    return false;
1329                            if (getVisibleRect().getWidth() == 0)
1330                                    return false;
1331                            if (getVisibleRect().getHeight() == 0)
1332                                    return false;
1333                            // if (getMapArea() == null)
1334                            // return false;
1335                    } catch (final Exception e) {
1336                            return false;
1337                    }
1338                    return true;
1339            }
1340    
1341            /**
1342             * Called from the listeners while the mouse is dragging, this method either
1343             * paints a translated (moved/panned) version of the image, or a rectangle.
1344             *
1345             * @param startPos
1346             *            in screen coordinates
1347             * @param lastPos
1348             *            in screen coordinates
1349             * @param event
1350             *            the {@link MouseEvent} to read the mouse buttons from
1351             */
1352            public void mouseDragged(final Point startPos, final Point lastPos,
1353                            final MouseEvent event) {
1354    
1355                    if ((getState() == XMapPane.PAN)
1356                                    || ((event.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) {
1357    
1358                            // Panning needs a panning coursor
1359                            if (getCursor() != SwingUtil.PANNING_CURSOR) {
1360                                    setCursor(SwingUtil.PANNING_CURSOR);
1361    
1362                                    // While panning, we deactivate the rendering. So the tasks are
1363                                    // ready to start when the panning is finished.
1364                                    if (bgExecuter != null && bgExecuter.isRunning())
1365                                            bgExecuter.cancelTask();
1366                                    if (localExecuter.isRunning())
1367                                            localExecuter.cancelTask();
1368                            }
1369    
1370                            if (lastPos.x > 0 && lastPos.y > 0) {
1371                                    final int dx = event.getX() - lastPos.x;
1372                                    final int dy = event.getY() - lastPos.y;
1373    
1374                                    // TODO Stop dragging when the drag would not be valid...
1375                                    // boolean dragValid = true;
1376                                    // // check if this panning results in a valid mapArea
1377                                    // {
1378                                    // Rectangle winBounds = xMapPane.getBounds();
1379                                    // winBounds.translate(xMapPane.imageOrigin.x,
1380                                    // -xMapPane.imageOrigin.y);
1381                                    // Envelope newMapAreaBefore = xMapPane.tranformWindowToGeo(
1382                                    // winBounds.x, winBounds.y, winBounds.x
1383                                    // + winBounds.width, winBounds.y
1384                                    // + winBounds.height);
1385                                    //                                      
1386                                    //
1387                                    // winBounds = xMapPane.getBounds();
1388                                    // Point testIng = new Point(xMapPane.imageOrigin);
1389                                    // testIng.translate(dx, dy);
1390                                    // winBounds.translate(testIng.x, -testIng.y);
1391                                    // Envelope newMapAreaAfter = xMapPane.tranformWindowToGeo(
1392                                    // winBounds.x, winBounds.y, winBounds.x
1393                                    // + winBounds.width, winBounds.y
1394                                    // + winBounds.height);
1395                                    //
1396                                    // // If the last drag doesn't change the MapArea anymore cancel
1397                                    // it.
1398                                    // if (xMapPane.bestAllowedMapArea(newMapAreaAfter).equals(
1399                                    // xMapPane.bestAllowedMapArea(newMapAreaBefore))){
1400                                    // dragValid = false;
1401                                    // return;
1402                                    // }
1403                                    // }
1404    
1405                                    imageOrigin.translate(dx, dy);
1406                                    updateFinalImage();
1407                                    repaint();
1408                            }
1409    
1410                    } else if ((getState() == XMapPane.ZOOM_IN)
1411                                    || (getState() == XMapPane.ZOOM_OUT)
1412                                    || (getState() == XMapPane.SELECT_ALL)
1413                                    || (getState() == XMapPane.SELECT_TOP)) {
1414    
1415                            // Draws a rectangle
1416                            final Graphics2D graphics = (Graphics2D) getGraphics();
1417                            drawRectangle(graphics, startPos, event.getPoint());
1418                            if ((lastPos.x > 0) && (lastPos.y > 0))
1419                                    drawRectangle(graphics, startPos, lastPos);
1420                            graphics.dispose();
1421                    }
1422            }
1423    
1424            /**
1425             * Called by the {@link RenderingExecutor} when rendering was cancelled.
1426             */
1427            public void onRenderingCancelled() {
1428                    // LOGGER.debug("Rendering cancelled");
1429                    repaintTimer.stop();
1430            }
1431    
1432            /**
1433             * Called by the {@link RenderingExecutor} when rendering has been
1434             * completed.
1435             *
1436             * @param l
1437             *            long ms the rendering took
1438             */
1439            public void onRenderingCompleted(final long l) {
1440                    lastRenderingDuration = (lastRenderingDuration + l) / 2;
1441                    LOGGER
1442                                    .debug("complete rendering after " + lastRenderingDuration
1443                                                    + "ms");
1444    
1445                    repaintTimer.stop();
1446    
1447                    // We "forget" about an exception every time we complete a rendering
1448                    // thread successfully
1449                    if (renderingErrors.size() > 0)
1450                            renderingErrors.remove(0);
1451    
1452                    updateFinalImage();
1453                    repaint();
1454            }
1455    
1456            /**
1457             * Called by the {@linkplain XMapPane.RenderingTask} when rendering failed.
1458             * Publishes a {@linkplain MapPaneEvent} of type {@code
1459             * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
1460             *
1461             * @param renderingError
1462             *            The error that occured during rendering
1463             *
1464             * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
1465             */
1466            public void onRenderingFailed(final Exception renderingError) {
1467    
1468                    // Store the exceptions so we can show it to the user:
1469                    if (!(renderingError instanceof java.lang.IllegalArgumentException && renderingError
1470                                    .getMessage().equals(
1471                                                    "Argument \"sourceCRS\" should not be null.")))
1472                            this.renderingErrors.add(renderingError);
1473                    if (renderingErrors.size() > 3)
1474                            renderingErrors.remove(0);
1475    
1476                    repaintTimer.stop();
1477    
1478                    LOGGER.warn("Rendering failed", renderingError);
1479                    updateFinalImage();
1480                    repaint();
1481    
1482            }
1483    
1484            @Override
1485            protected void paintComponent(final Graphics g) {
1486    
1487                    // Maybe update the cursor and maybe stop the repainting timer
1488                    updateCursor();
1489    
1490                    if (!acceptsRepaintCalls)
1491                            return;
1492    
1493                    if (!isWellDefined())
1494                            return;
1495                    //
1496                    // if (paneResized) {
1497                    // // ((Graphics2D) g).setBackground(getMapBackgroundColor());
1498                    // // g.clearRect(0, 0, getVisibleRect().width,
1499                    // getVisibleRect().height);
1500                    // return;
1501                    // }
1502    
1503                    // super.paintComponent(g); // candidate for removal
1504    
1505                    boolean paintedSomething = false;
1506    
1507                    if (mapImageInvalid) { /* if the map changed then redraw */
1508    
1509                            mapImageInvalid = false; // Reset for next round
1510    
1511                            // If the new mapArea and the oldMapArea intersect, we can draw some
1512                            // quick scaled preview to make the user feel that something is
1513                            // happening.
1514                            if (lastRenderingDuration > PRESCALE_MINTIME && mapAreaChanged
1515                                            && oldMapArea != null
1516                                            && getMapArea().intersects(oldMapArea)
1517                                            && !getMapArea().equals(oldMapArea) && !paneResized) {
1518    
1519                                    mapAreaChanged = false;
1520    
1521                                    // if (getMapArea().covers(oldMapArea)) {
1522                                    // // quickPreviewHint = ZOOM_OUT;
1523                                    // paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D)
1524                                    // g);
1525                                    // } else if (oldMapArea.covers(getMapArea())) {
1526                                    // quickPreviewHint = ZOOM_IN;
1527                                    paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
1528                                    // }
1529                            }
1530                    }
1531    
1532                    if (!paintedSomething) {
1533    
1534                            g.drawImage(getFinalImage(), 0, 0, null);
1535    
1536                            paintedSomething = true; // cand. for removal
1537                    }
1538    
1539            }
1540    
1541            /**
1542             * Heavily works on releasing all resources related to the four
1543             * {@link Image}s used to cache the results of the different renderers.<br>
1544             * In November 2009 i had some memory leaking problems with {@link XMapPane}
1545             * . The resources of the buffered images were never released. It seem to be
1546             * important to call the GC right after flushing the images.<br>
1547             * Hence this method may take a while, because it calls the GC up to four
1548             * times.
1549             */
1550            private void disposeImages() {
1551    
1552                    // System.out.println("vorher = "
1553                    // + new MbDecimalFormatter().format(LangUtil.gcTotal()));
1554                    // bi.flush();
1555                    // return bi = null;
1556                    // System.out.println("nacher = "
1557                    // + new MbDecimalFormatter().format(LangUtil.gcTotal()));
1558                    //
1559                    // System.out.println("\n");
1560    
1561                    if (preFinalImage != null) {
1562                            preFinalImage.flush();
1563                            preFinalImage = null;
1564                            LangUtil.gc();
1565                    }
1566                    if (finalImage != null) {
1567                            finalImage.flush();
1568                            finalImage = null;
1569                            LangUtil.gc();
1570                    }
1571                    if (localImage != null) {
1572                            localImage.flush();
1573                            localImage = null;
1574                            LangUtil.gc();
1575                    }
1576                    if (bgImage != null) {
1577                            bgImage.flush();
1578                            bgImage = null;
1579                            LangUtil.gc();
1580                    }
1581    
1582            }
1583    
1584            /**
1585             * Performs a {@value #PAN} action. During panning, the displacement is
1586             * stored in {@link #imageOrigin} object. Calling {@link #performPan()} will
1587             * reset the offset and call {@link #setMapArea(Envelope)}.
1588             */
1589            public void performPan() {
1590    
1591                    final Rectangle winBounds = getVisibleRect();
1592    
1593                    winBounds.translate(-imageOrigin.x, -imageOrigin.y);
1594                    final Envelope newMapArea = tranformWindowToGeo(winBounds.x,
1595                                    winBounds.y, winBounds.x + winBounds.width, winBounds.y
1596                                                    + winBounds.height);
1597    
1598                    imageOrigin.x = 0;
1599                    imageOrigin.y = 0;
1600    
1601                    if (!setMapArea(newMapArea)) {
1602                            /**
1603                             * If setMapArea returns true, the finalImage is updated anyways.
1604                             * This if-case exists to ensure that we repaint a correct image
1605                             * even if the new panning area has been denied.
1606                             */
1607                            updateFinalImage();
1608                            repaint();
1609                    }
1610    
1611                    if (getCursor() == SwingUtil.PANNING_CURSOR)
1612                            setCursor(SwingUtil.PAN_CURSOR);
1613            }
1614    
1615            /**
1616             * Entfernt einen Listener von der Map.
1617             *
1618             * @param l
1619             *            zu entfernender Listener
1620             */
1621            public void removeMapPaneListener(final JMapPaneListener l) {
1622                    mapPaneListeners.remove(l);
1623            }
1624    
1625            /**
1626             * Cancels all running renderers and sets the flag to start new ones. <br>
1627             *
1628             * @see #startRenderThreadsTimer
1629             */
1630            private void requestStartRendering() {
1631                    if (bgExecuter != null)
1632                            bgExecuter.cancelTask();
1633    
1634                    localExecuter.cancelTask();
1635    
1636                    mapImageInvalid = true;
1637                    if (paneResized) {
1638                            paneResized = false;
1639                            disposeImages();
1640                    }
1641                    requestStartRendering = true;
1642    
1643            }
1644    
1645            /**
1646             * Calculate the affine transforms used to convert between world and pixel
1647             * coordinates. The calculations here are very basic and assume a cartesian
1648             * reference system.
1649             * <p>
1650             * Tne transform is calculated such that {@code envelope} will be centred in
1651             * the display
1652             *
1653             * @param envelope
1654             *            the current map extent (world coordinates)
1655             * @param paintArea
1656             *            the current map pane extent (screen units)
1657             */
1658            private void resetTransforms() {
1659                    final ReferencedEnvelope refMapEnv = new ReferencedEnvelope(mapArea,
1660                                    getMapContext().getCoordinateReferenceSystem());
1661    
1662                    // System.out
1663                    // .println("paintArea in resetTeansofrms = " + getVisibleRect());
1664                    if (!isWellDefined())
1665                            return;
1666    
1667                    worldToScreen = RendererUtilities.worldToScreenTransform(refMapEnv,
1668                                    getVisibleRect());
1669    
1670                    try {
1671                            screenToWorld = worldToScreen.createInverse();
1672    
1673                    } catch (final NoninvertibleTransformException ex) {
1674                            LOGGER
1675                                            .error("can't invert worldToScreen to get screenToWorld!",
1676                                                            ex);
1677                    }
1678            }
1679    
1680            public void setBgContext(final MapContext context) {
1681    
1682                    // Remove the default listener from the old context
1683                    if (this.bgContext != null) {
1684                            this.bgContext.removeMapLayerListListener(bgContextListener);
1685    
1686                            // adding listener to all layers
1687                            for (final MapLayer mapLayer : bgContext.getLayers()) {
1688                                    mapLayer.removeMapLayerListener(bgMapLayerListener);
1689                            }
1690                    }
1691    
1692                    this.bgContext = context;
1693    
1694                    if (context != null) {
1695                            // setMapArea(bgContext.getAreaOfInterest());
1696    
1697                            this.bgContext.addMapLayerListListener(bgContextListener);
1698    
1699                            // adding listener to all layers
1700                            for (final MapLayer mapLayer : bgContext.getLayers()) {
1701                                    mapLayer.addMapLayerListener(bgMapLayerListener);
1702                            }
1703                    }
1704    
1705                    requestStartRendering();
1706            }
1707    
1708            public void setJava2dHints(final RenderingHints java2dHints) {
1709                    this.java2dHints = java2dHints;
1710            }
1711    
1712            public void setLocalContext(final MapContext context) {
1713                    // Remove the default listener from the old context
1714                    if (this.localContext != null) {
1715                            this.localContext.removeMapLayerListListener(localContextListener);
1716    
1717                            // adding listener to all layers
1718                            for (final MapLayer mapLayer : localContext.getLayers()) {
1719                                    mapLayer.removeMapLayerListener(localMapLayerListener);
1720                            }
1721                    }
1722    
1723                    this.localContext = context;
1724    
1725                    if (context != null) {
1726    
1727                            // setMapArea(localContext.getAreaOfInterest());
1728    
1729                            getLocalRenderer().setContext(localContext);
1730    
1731                            this.localContext.addMapLayerListListener(localContextListener);
1732    
1733                            // adding listener to all layers
1734                            for (final MapLayer mapLayer : localContext.getLayers()) {
1735                                    mapLayer.addMapLayerListener(localMapLayerListener);
1736                            }
1737                    }
1738    
1739                    requestStartRendering();
1740    
1741            }
1742    
1743            public void setBorder(final Border b) {
1744                    super.setBorder(b);
1745            }
1746    
1747            /**
1748             * Triggers to repaint (fast) and re-render (slow) the JMapPane.
1749             */
1750            public void refresh() {
1751                    mapImageInvalid = true;
1752                    repaint();
1753            }
1754    
1755            // /**
1756            // * Triggers to use new {@link GTRenderer} and refresh the map. Should be
1757            // * called after {@link Style}s have been changed because GTRenderer is
1758            // * otherwise not working well.
1759            // */
1760            // public void refreshRenderers() {
1761            // localRenderer = GTUtil.createGTRenderer();
1762            // setLocalContext(getMapContext());
1763            // mapImageInvalid = true;
1764            // repaint();
1765            // }
1766    
1767            /**
1768             * Set the new map area.
1769             *
1770             * @param newMapArea
1771             * @return <code>true</code> if the mapArea has been changed and a repaint
1772             *         has been triggered.
1773             */
1774            public boolean setMapArea(final Envelope newMapArea) {
1775                    if (newMapArea == null)
1776                            return false;
1777                    if (getMapContext().getCoordinateReferenceSystem() == null)
1778                            return false;
1779                    return setMapArea(new ReferencedEnvelope(newMapArea, getMapContext()
1780                                    .getCoordinateReferenceSystem()));
1781            }
1782    
1783            /**
1784             * Set the new map area.
1785             *
1786             * @param newMapArea
1787             * @return <code>true</code> if the mapArea has been changed and a repaint
1788             *         has been triggered.
1789             */
1790            public boolean setMapArea(final ReferencedEnvelope newMapArea) {
1791    
1792                    if (newMapArea == null
1793                                    || bestAllowedMapArea(newMapArea).equals(mapArea)) {
1794                            // No change.. no need to repaint
1795                            return false;
1796                    }
1797    
1798                    // Testing, whether NaN or Infinity are used in the newMapArea
1799                    if (newMapArea.isNull() || Double.isInfinite(newMapArea.getMaxX())
1800                                    || Double.isInfinite(newMapArea.getMaxY())
1801                                    || Double.isInfinite(newMapArea.getMinX())
1802                                    || Double.isInfinite(newMapArea.getMinY())) {
1803                            // No change.. ugly new values
1804                            LOGGER.warn("setMapArea has been called with newArea = "
1805                                            + newMapArea);
1806                            return false;
1807                    }
1808    
1809                    final Envelope candNew = bestAllowedMapArea(newMapArea);
1810    
1811                    // Testing, whether the difference if just minimal
1812                    if (mapArea != null) {
1813                            final double tolX = mapArea.getWidth() / 1000.;
1814                            final double tolY = mapArea.getHeight() / 1000.;
1815                            if ((candNew.getMinX() - tolX < mapArea.getMinX())
1816                                            && (mapArea.getMinX() < candNew.getMinX() + tolX)
1817                                            && (candNew.getMaxX() - tolX < mapArea.getMaxX())
1818                                            && (mapArea.getMaxX() < candNew.getMaxX() + tolX)
1819    
1820                                            && (candNew.getMinY() - tolY < mapArea.getMinY())
1821                                            && (mapArea.getMinY() < candNew.getMinY() + tolY)
1822                                            && (candNew.getMaxY() - tolY < mapArea.getMaxY())
1823                                            && (mapArea.getMaxY() < candNew.getMaxY() + tolY)
1824    
1825                            ) {
1826                                    // The two mapAreas only differ my 1/1000th.. ignore
1827    
1828                                    return false;
1829                            }
1830                    }
1831    
1832                    // New map are is accepted:
1833                    oldMapArea = mapArea;
1834                    mapArea = candNew;
1835                    resetTransforms();
1836    
1837                    if (localContext != null) {
1838                            localContext.setAreaOfInterest(mapArea, localContext
1839                                            .getCoordinateReferenceSystem());
1840                    }
1841                    if (bgContext != null) {
1842                            bgContext.setAreaOfInterest(mapArea, localContext
1843                                            .getCoordinateReferenceSystem());
1844                    }
1845    
1846                    mapAreaChanged = true;
1847    
1848                    repaint(200); // Do not remove it!
1849    
1850                    requestStartRendering();
1851    
1852                    return true;
1853            }
1854    
1855            /**
1856             * Set the background color of the map.
1857             *
1858             * @param if <code>null</code>, white is used.
1859             */
1860            public void setMapBackgroundColor(final Color bgColor) {
1861                    this.mapBackgroundColor = bgColor;
1862            }
1863    
1864            /**
1865             * Set the BufferedImage to use as a flaoting icon in the lower right corner
1866             *
1867             * @param mapImageIcon
1868             *            <code>null</code> is allowed and deactivates this icon.
1869             */
1870            public void setMapImage(final BufferedImage mapImage) {
1871                    this.mapImage = mapImage;
1872            }
1873    
1874            /**
1875             * Sets whether a layer is regarded or ignored on {@link #SELECT_TOP},
1876             * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions.
1877             *
1878             * @param layer
1879             *            a layer
1880             * @param selectable
1881             *            if {@code false} the layer is ignored during the upper
1882             *            mentioned actions. If <code>null</code>, the default (true)
1883             *            will be used.
1884             */
1885            public void setMapLayerSelectable(final MapLayer layer,
1886                            final Boolean selectable) {
1887                    if (selectable == null)
1888                            mapLayerSelectable.remove(layer);
1889                    else
1890                            mapLayerSelectable.put(layer, selectable);
1891            }
1892    
1893            /**
1894             * Defines an evelope of the viwable area. The JMapPane will never show
1895             * anything outside of this extend.
1896             *
1897             * @param maxExtend
1898             *            <code>null</code> to not have this restriction.
1899             */
1900            public void setMaxExtend(final Envelope maxExtend) {
1901                    this.maxExtend = maxExtend;
1902            }
1903    
1904            /**
1905           * Set the maximum allowed zoom scale. This is the smaller number value of           * Set the maximum allowed zoom scale. This is the smaller number value of
1906           * the two.           * the two. If <code>null</code> is passed, Double.MINVALUE are used which
1907             * mean there is no restriction.
1908           *           *
1909           * @author <a href="mailto:[email protected]">Stefan Alfons           * @author <a href="mailto:[email protected]">Stefan Alfons
1910           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
1911           */           */
1912          public void setMaxZoomScale(final Double maxZoomScale) {          public void setMaxZoomScale(final Double maxZoomScale) {
1913                  this.maxZoomScale = maxZoomScale;                  this.maxZoomScale = maxZoomScale == null ? Double.MIN_VALUE
1914                                    : maxZoomScale;
1915          }          }
1916    
1917            // /** Stored the time used for the last real rendering in ms. **/
1918            private long lastRenderingDuration = 1000;
1919    
1920          /**          /**
1921           * Set the minimum (nearest) allowed zoom scale. This is the bigger number           * Set the minimum (nearest) allowed zoom scale. This is the bigger number
1922           * value of the two.           * value of the two. If <code>null</code> is passed, Double.MAXVALUE are
1923             * used which mean there is no restriction.
1924             *
1925           *           *
1926           * @author <a href="mailto:[email protected]">Stefan Alfons           * @author <a href="mailto:[email protected]">Stefan Alfons
1927           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
1928           */           */
1929          public void setMinZoomScale(final Double minZoomScale) {          public void setMinZoomScale(final Double minZoomScale) {
1930                  this.minZoomScale = minZoomScale;                  this.minZoomScale = minZoomScale == null ? Double.MAX_VALUE
1931                                    : minZoomScale;
1932          }          }
1933    
1934          /**          /**
1935           * Defines an evelope of the viwable area. The JMapPane will never show           * If <code>true</code>, allow the {@link XMapPane} to process #repaint()
1936           * anything outside of this extend.           * requests. Otherwise the map will not paint anything and not start any
1937             * rendering {@link Thread}s.
1938             */
1939            public void setPainting(final boolean b) {
1940                    acceptsRepaintCalls = b;
1941                    if (acceptsRepaintCalls == true)
1942                            repaint();
1943            }
1944    
1945            private void setRendererHints(final Map<Object, Object> rendererHints) {
1946                    if (rendererHints != null)
1947                            this.rendererHints = rendererHints;
1948            }
1949    
1950            /**
1951             * Enables/Disables the ZOOM Mouse Listener. Upates the Cursor and stops the
1952             * repaint Timer if
1953           *           *
1954           * @param maxExtend           * @param state
          *            <code>null</code> to not have this restriction.  
1955           */           */
1956          public void setMaxExtend(Envelope maxExtend) {          public void setState(final int state) {
1957                  this.maxExtend = maxExtend;                  this.state = state;
1958    
1959                    zoomMapPaneMouseListener.setEnabled((state == ZOOM_IN
1960                                    || state == ZOOM_OUT || state == PAN));
1961    
1962                    // Je nach Aktion den Cursor umsetzen
1963                    updateCursor();
1964          }          }
1965    
1966          /**          /**
1967           * Returns the evelope of the viewable area. The JMapPane will never show           * Standardmaessig wird der Cursor automatisch je nach MapPane-Aktion (Zoom,
1968           * anything outside of this extend. If this has been set to           * Auswahl, ...) gesetzt. Mit dieser Methode kann ein statischer Cursor
1969           * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return           * gesetzt werden, der unabhaengig von der aktuellen MapPanes-Aktion
1970           * quickly the context's bounds. It it takes to long to determine the           * beibehalten wird. Um diesen statischen Cursor wieder zu entfernen, kann
1971           * context bounds, <code>null</code> is returned.           * {@code null} als Parameter uebergeben werden
1972           *           *
1973           * @param maxExtend           * @param cursor
1974           *            <code>null</code> to not have this restriction.           *            Cursor
1975           */           */
1976            public void setStaticCursor(final Cursor cursor) {
1977                    this.staticCursor = cursor;
1978                    if (cursor != null)
1979                            super.setCursor(cursor);
1980            }
1981    
1982          public Envelope getMaxExtend() {          /**
1983                  if (maxExtend == null) {           * Starts rendering on one or two threads
1984                          try {           */
1985                                  return fixAspectRatio(          private void startRendering() {
1986                                      this.getBounds(),  
1987                          // Kartenbereich um 10% vergroessern                  if (!isWellDefined() || !acceptsRepaintCalls) {
1988                                      JTSUtil.expandEnvelope(context.getLayerBounds(), 0.1),                          // if we are not ready to start rendering, try it again the next
1989                                      true                          // time the timer is chacking the flag.
1990                                  );                          requestStartRendering = true;
1991                          } catch (IOException e) {                          return;
1992                                  LOGGER.warn(                  }
1993                                                                  "maxExtend == null; faild to getLayerBounds of context",  
1994                                                                  e);                  if (bgExecuter != null) {
1995                            // Stop all renderers
1996                            bgExecuter.cancelTask();
1997                    }
1998    
1999                    localExecuter.cancelTask();
2000    
2001                    final Rectangle curPaintArea = getVisibleRect();
2002    
2003                    /**
2004                     * We have to set new renderer
2005                     */
2006    
2007                    if (getBgContext() != null) {
2008                            bgRenderer.setJava2DHints(getJava2dHints());
2009                            bgRenderer.setRendererHints(getRendererHints());
2010    
2011                            // bgExecuter = new RenderingExecutor();
2012                            // LOGGER.debug("starting bg renderer:");
2013                            // // /* System.out.println("rendering"); */
2014                            // final GTRenderer createGTRenderer = GTUtil.createGTRenderer(
2015                            // bgContext, getRendererHints());
2016                            // createGTRenderer.setJava2DHints(getJava2dHints());
2017                            // bgExecuter.submit(getBgContext().getAreaOfInterest(),
2018                            // curPaintArea,
2019                            // (Graphics2D) getBgImage().getGraphics(), createGTRenderer);
2020                    }
2021    
2022                    if (getMapContext() != null) {
2023                            // localExecuter = new RenderingExecutor(this, 150l);
2024                            // LOGGER.debug("starting local renderer:");
2025    
2026                            getLocalRenderer().setJava2DHints(getJava2dHints());
2027                            getLocalRenderer().setRendererHints(getRendererHints());
2028    
2029                            final boolean submitted = localExecuter.submit(getMapArea(),
2030                                            curPaintArea, (Graphics2D) getLocalImage().getGraphics(),
2031                                            getLocalRenderer());
2032                            if (submitted)
2033                                    repaintTimer.restart();
2034                            else
2035                                    requestStartRendering = true; // Try to start rendering
2036                            // again in
2037                            // a moment
2038                    }
2039    
2040                    updateCursor();
2041            }
2042    
2043            private RenderingHints getJava2dHints() {
2044                    return java2dHints;
2045            }
2046    
2047            /**
2048             * Transformiert einen Geo-Koordinaten-Bereich in Fenster-Koordinaten.
2049             *
2050             * @param ox
2051             *            X-Koordinate der VON-Position
2052             * @param oy
2053             *            Y-Koordinate der VON-Position
2054             * @param px
2055             *            X-Koordinate der BIS-Position
2056             * @param py
2057             *            Y-Koordinate der BIS-Position
2058             * @param winToGeotransform
2059             *            Eine Window to Geo transform. If <code>null</code>,
2060             *            {@link #getScreenToWorld()} is used.
2061             */
2062            public Envelope tranformGeoToWindow(final double ox, final double oy,
2063                            final double px, final double py) {
2064                    final AffineTransform at = getWorldToScreenTransform();
2065                    Point2D geoO;
2066                    // try {
2067                    geoO = at.transform(new Point2D.Double(ox, oy), null);
2068                    final Point2D geoP = at.transform(new Point2D.Double(px, py), null);
2069                    return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP.getY());
2070                    // } catch (final NoninvertibleTransformException e) {
2071                    // LOGGER.error(e);
2072                    // return new Envelope(ox, oy, px, py);
2073                    // }
2074            }
2075    
2076            /**
2077             * Transformiert einen Fenster-Koordinaten-Bereich in Geo-Koordinaten.
2078             *
2079             * @param ox
2080             *            X-Koordinate der VON-Position
2081             * @param oy
2082             *            Y-Koordinate der VON-Position
2083             * @param px
2084             *            X-Koordinate der BIS-Position
2085             * @param py
2086             *            Y-Koordinate der BIS-Position
2087             */
2088            public Envelope tranformWindowToGeo(final int ox, final int oy,
2089                            final int px, final int py) {
2090                    final AffineTransform at = getScreenToWorld();
2091                    final Point2D geoO = at.transform(new Point2D.Double(ox, oy), null);
2092                    final Point2D geoP = at.transform(new Point2D.Double(px, py), null);
2093    
2094                    // Mmmmm... don't really understand why its x,x,y,y
2095                    // return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(),
2096                    // geoP.getY());
2097                    return new Envelope(new Coordinate(geoO.getX(), geoO.getY()),
2098                                    new Coordinate(geoP.getX(), geoP.getY()));
2099            }
2100    
2101            /**
2102             * Will update the cursor. If all rendering is finished also stops the
2103             * {@link #repaintTimer}
2104             */
2105            public void updateCursor() {
2106    
2107                    // if the renderers have stopped, also stop the timer that is updating
2108                    // the final image
2109                    if (bgExecuter != null && bgExecuter.isRunning()
2110                                    || localExecuter.isRunning()) {
2111                            setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
2112                            return;
2113                    } else {
2114                            // Allow one last rendering
2115                            if (repaintTimer.isRunning()) {
2116                                    // System.out.println("one last rendering....");
2117                                    repaintTimer.stop();
2118                                    updateFinalImage();
2119                                    repaint();
2120                          }                          }
2121                  }                  }
2122                  return maxExtend;  
2123                    // wenn manueller Cursor gesetzt ist, dann diesen verwenden (unabhaengig
2124                    // von der aktuellen Aktion
2125                    if (this.staticCursor != null) {
2126                            setCursor(staticCursor);
2127                            return;
2128                    }
2129                    if (getCursor() == SwingUtil.PANNING_CURSOR) {
2130                            // This cursor will reset itself
2131                            return;
2132                    }
2133    
2134                    // Set the cursor depending on what tool is in use...
2135                    switch (state) {
2136                    case SELECT_TOP:
2137                    case SELECT_ONE_FROM_TOP:
2138                    case SELECT_ALL:
2139                            setCursor(SwingUtil.CROSSHAIR_CURSOR);
2140                            break;
2141                    case ZOOM_IN:
2142                            setCursor(SwingUtil.ZOOMIN_CURSOR);
2143                            break;
2144                    case ZOOM_OUT:
2145                            setCursor(SwingUtil.ZOOMOUT_CURSOR);
2146                            break;
2147                    case PAN:
2148                            setCursor(SwingUtil.PAN_CURSOR);
2149                            break;
2150                    default:
2151                            setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
2152                            break;
2153                    }
2154            }
2155    
2156            /**
2157             * The renderers are all rendering into their own {@link Image}s. This
2158             * method combines all images to one {@link #finalImage}. The
2159             * {@link #repaintTimer} is calling this method regularely to update the
2160             * {@link #finalImage} even if the renderers are still working.
2161             */
2162            synchronized protected Image updateFinalImage() {
2163    
2164                    // Render the two map images first, into the preFinalImage
2165                    if (bgExecuter != null) {
2166                            final Graphics2D preFinalG = (Graphics2D) getPreFinalImage()
2167                                            .getGraphics();
2168                            preFinalG.setBackground(getMapBackgroundColor());
2169    
2170                            preFinalG.drawImage(getBgImage(), 0, 0, getMapBackgroundColor(),
2171                                            null);
2172    
2173                            // // Draw the local layers image
2174                            preFinalG.drawImage(getLocalImage(), 0, 0, null);
2175                            preFinalG.dispose();
2176    
2177                    } else {
2178                            preFinalImage = getLocalImage();
2179                    }
2180    
2181                    final Graphics2D finalG = getFinalImage().createGraphics();
2182                    finalG.setBackground(getMapBackgroundColor());
2183                    finalG.drawImage(getPreFinalImage(), imageOrigin.x, imageOrigin.y,
2184                                    getMapBackgroundColor(), null);
2185    
2186                    // When panning, we have to clear the area around the image
2187                    final Rectangle painedArea = new Rectangle(imageOrigin.x,
2188                                    imageOrigin.y, getFinalImage().getWidth(), getFinalImage()
2189                                                    .getHeight());
2190                    SwingUtil.clearAround(finalG, painedArea, getVisibleRect(),
2191                                    getMapBackgroundColor());
2192    
2193                    addGadgets(finalG, false);
2194    
2195                    finalG.dispose();
2196    
2197                    return finalImage;
2198            }
2199    
2200            /**
2201             * Paints some optional stuff into the given {@link Graphics2D}. Usually
2202             * called as the last layer when {@link #updateFinalImage()}
2203             *
2204             * @param forceWait
2205             *            if <code>true</code>, a Wait-message will be painted even
2206             *            though the rendering threads may not yet have started. If
2207             *            <code>false</code>, it will only depend on
2208             *            {@link #localExecuter.isRunning} and #bgExecuter.isRunning
2209             */
2210            private void addGadgets(final Graphics2D graphics, final boolean forceWait) {
2211    
2212                    // Paint a logo to the bottom right if available
2213                    if (mapImage != null) {
2214                            final Rectangle visibleRect = getVisibleRect();
2215                            graphics.drawImage(mapImage, visibleRect.width
2216                                            - mapImage.getWidth() - 10, getVisibleRect().height
2217                                            - mapImage.getHeight() - 10, null);
2218                    }
2219    
2220                    int y = 17;
2221    
2222                    // If the rendering process is still running, indicate this is the image
2223                    if (forceWait || bgExecuter != null && bgExecuter.isRunning()
2224                                    || localExecuter.isRunning()) {
2225    
2226                            y += 8;
2227    
2228                            final Color c = graphics.getColor();
2229                            graphics.setFont(waitFont);
2230    
2231                            graphics.setColor(getMapBackgroundColor());
2232                            graphics.drawString(waitMsg, 5, y);
2233                            graphics.setColor(getMapBackgroundColor());
2234                            graphics.drawString(waitMsg, 7, y + 2);
2235                            graphics.setColor(Color.BLACK);
2236                            graphics.drawString(waitMsg, 6, y + 1);
2237    
2238                            graphics.setColor(c);
2239    
2240                            y += 21;
2241                    }
2242    
2243                    if (!renderingErrors.isEmpty() && isShowExceptions()) {
2244    
2245                            final Color c = graphics.getColor();
2246                            graphics.setFont(errorFont);
2247    
2248                            for (final Exception ex : renderingErrors) {
2249    
2250                                    String errStr = ex.getLocalizedMessage();
2251    
2252                                    if (errStr == null)
2253                                            errStr = ex.getMessage();
2254                                    if (errStr == null)
2255                                            errStr = "unknown error: " + ex.getClass().getSimpleName();
2256    
2257                                    graphics.setColor(getMapBackgroundColor());
2258                                    graphics.drawString(errStr, 5, y);
2259                                    graphics.setColor(Color.RED);
2260                                    graphics.drawString(errStr, 6, y + 1);
2261    
2262                                    y += 19;
2263                            }
2264    
2265                            graphics.setColor(c);
2266                    }
2267    
2268            }
2269    
2270            /**
2271             * Sets the {@link #mapArea} to best possibly present the given features. If
2272             * only one single point is given, the window is moved over the point.
2273             *
2274             * @param features
2275             *            if <code>null</code> or size==0, the function doesn nothing.
2276             */
2277            public void zoomTo(
2278                            final FeatureCollection<SimpleFeatureType, SimpleFeature> features) {
2279    
2280                    // if (!isWellDefined()) return;
2281    
2282                    final CoordinateReferenceSystem mapCRS = getMapContext()
2283                                    .getCoordinateReferenceSystem();
2284                    final CoordinateReferenceSystem fCRS = features.getSchema()
2285                                    .getCoordinateReferenceSystem();
2286    
2287                    ReferencedEnvelope _mapArea;
2288                    if (mapArea == null)
2289                            _mapArea = features.getBounds();
2290                    else
2291                            _mapArea = getMapArea();
2292                    double width = _mapArea.getWidth();
2293                    double height = _mapArea.getHeight();
2294                    final double ratio = height / width;
2295    
2296                    if (features == null || features.size() == 0) {
2297                            // feature count == 0 Zoom to the full extend
2298                            return;
2299                    } else if (features.size() == 1) {
2300    
2301                            // feature count == 1 Just move the window to the point and zoom 'a
2302                            // bit'
2303                            final SimpleFeature singleFeature = features.iterator().next();
2304    
2305                            if (((Geometry) singleFeature.getDefaultGeometry())
2306                                            .getCoordinates().length > 1) {
2307                                    // System.out.println("Zoomed to only pne poylgon");
2308                                    // Poly
2309                                    // TODO max width vs. height
2310                                    width = features.getBounds().getWidth() * 3;
2311                                    height = ratio * width;
2312                            } else {
2313                                    // System.out.println("Zoomed in a bit becasue only one point");
2314                                    // width *= .9;
2315                                    // height *= .9;
2316                            }
2317    
2318                            Coordinate centre = features.getBounds().centre();
2319                            if (!mapCRS.equals(fCRS)) {
2320                                    // only to calculations if the CRS differ
2321                                    try {
2322                                            MathTransform fToMap;
2323                                            fToMap = CRS.findMathTransform(fCRS, mapCRS);
2324                                            // centre is transformed to the mapCRS
2325                                            centre = JTS.transform(centre, null, fToMap);
2326                                    } catch (final FactoryException e) {
2327                                            LOGGER.error("Looking for a Math transform", e);
2328                                    } catch (final TransformException e) {
2329                                            LOGGER.error("Looking for a Math transform", e);
2330                                    }
2331                            }
2332    
2333                            final Coordinate newLeftBottom = new Coordinate(centre.x - width
2334                                            / 2., centre.y - height / 2.);
2335                            final Coordinate newTopRight = new Coordinate(
2336                                            centre.x + width / 2., centre.y + height / 2.);
2337    
2338                            final Envelope newMapArea = new Envelope(newLeftBottom, newTopRight);
2339    
2340                            setMapArea(newMapArea);
2341    
2342                    } else {
2343                            final ReferencedEnvelope fBounds = features.getBounds();
2344    
2345                            ReferencedEnvelope bounds;
2346                            if (!mapCRS.equals(fCRS)) {
2347                                    bounds = JTSUtil.transformEnvelope(fBounds, mapCRS);
2348                            } else {
2349                                    bounds = fBounds;
2350                            }
2351                            // BB umrechnen von Layer-CRS in Map-CRS
2352    
2353                            // Expand a bit
2354                            bounds.expandBy(bounds.getWidth() / 6., bounds.getHeight() / 6.);
2355    
2356                            setMapArea(bounds);
2357                    }
2358            }
2359    
2360            /**
2361             * Zooms towards a point.
2362             *
2363             * @param center
2364             *            position in window coordinates
2365             * @param zoomFactor
2366             *            > 1 for zoom in, < 1 for zoom out. Default is 1.33
2367             */
2368            public void zoomTo(final Point center) {
2369                    zoomTo(center, null);
2370            }
2371    
2372            /**
2373             * Zooms towards a point.
2374             *
2375             * @param center
2376             *            position in window coordinates
2377             * @param zoomFaktor
2378             *            > 1 for zoom in, < 1 for zoom out. Default is 1.33.
2379             */
2380            public void zoomTo(Point center, Double zoomFaktor) {
2381                    if (zoomFaktor == null || zoomFaktor == 0.)
2382                            zoomFaktor = 2.;
2383    
2384                    final Point2D gcenter = getScreenToWorld().transform(center, null);
2385                    center = null;
2386    
2387                    if (Double.isNaN(gcenter.getX()) || Double.isNaN(gcenter.getY())
2388                                    || Double.isInfinite(gcenter.getX())
2389                                    || Double.isInfinite(gcenter.getY())
2390    
2391                    ) {
2392                            // Not inside valid CRS area! cancel
2393                            return;
2394                    }
2395    
2396                    final Envelope mapArea = getMapArea();
2397    
2398                    final Envelope newMapArea = new Envelope(mapArea);
2399                    newMapArea.expandBy((mapArea.getWidth() * zoomFaktor - mapArea
2400                                    .getWidth()) / 2., (mapArea.getHeight() * zoomFaktor - mapArea
2401                                    .getHeight()) / 2.);
2402    
2403                    // // Move the newMapArea above the new center if we zoom in:
2404                    if (zoomFaktor >= 1) {
2405                            newMapArea.translate(gcenter.getX() - mapArea.centre().x, gcenter
2406                                            .getY()
2407                                            - mapArea.centre().y);
2408                    }
2409    
2410                    setMapArea(newMapArea);
2411            }
2412    
2413            /**
2414             * Shall non-fatal rendering exceptions be reported in the mappane or be
2415             * dropped quitely.
2416             */
2417            public void setShowExceptions(final boolean showExceptions) {
2418                    this.showExceptions = showExceptions;
2419            }
2420    
2421            /**
2422             * Shall exceptions be reported in the mappane?
2423             */
2424            public boolean isShowExceptions() {
2425                    return showExceptions;
2426            }
2427    
2428            public GTRenderer getLocalRenderer() {
2429                    return localRenderer;
2430            }
2431    
2432    
2433    
2434            /**
2435             * Setzt den Kartenausschnitt auf die Ausdehnung eines bestimmten Layers.
2436             * Macht nichts, wenn {@code null} uebergeben wird.
2437             *
2438             * <br>
2439             *
2440             * @param layer
2441             *            ein Layer
2442             */
2443            public void zoomToLayer(MapLayer layer) {
2444                    if (layer == null)
2445                            return;
2446                    try {
2447    
2448                            // BB umrechnen von Layer-CRS in Map-CRS
2449                            final CoordinateReferenceSystem targetCRS = getMapContext()
2450                                            .getCoordinateReferenceSystem();
2451                            final CoordinateReferenceSystem sourceCRS = layer
2452                                            .getFeatureSource().getSchema()
2453                                            .getCoordinateReferenceSystem();
2454    
2455                            Envelope mapAreaNew;
2456                            if (!CRS.equalsIgnoreMetadata(sourceCRS, targetCRS)) {
2457                                    mapAreaNew = JTSUtil.transformEnvelope(layer.getFeatureSource()
2458                                                    .getBounds(), sourceCRS, targetCRS);
2459                            } else {
2460                                    try {
2461                                            mapAreaNew = layer.getFeatureSource().getBounds();
2462                                    } catch (java.lang.IllegalArgumentException e) {
2463                                            LOGGER.error("Can't calc layers bounds...", e);
2464                                            mapAreaNew = null;
2465    
2466                                            /**
2467                                             *
2468                                             23.10.2009 11:20:50
2469                                             * org.geotools.data.shapefile.shp.PolygonHandler read
2470                                             * WARNUNG: only one hole in this polygon record ERROR
2471                                             * JMapPane zoomToLayer Zoom to layer did not terminate
2472                                             * correctly java.lang.IllegalArgumentException: Points of
2473                                             * LinearRing do not form a closed linestring at
2474                                             * com.vividsolutions
2475                                             * .jts.geom.LinearRing.validateConstruction
2476                                             * (LinearRing.java:105) at
2477                                             * com.vividsolutions.jts.geom.LinearRing
2478                                             * .<init>(LinearRing.java:100) at
2479                                             * com.vividsolutions.jts.geom
2480                                             * .GeometryFactory.createLinearRing
2481                                             * (GeometryFactory.java:339) at
2482                                             * org.geotools.data.shapefile.
2483                                             * shp.PolygonHandler.read(PolygonHandler.java:188) at
2484                                             * org.geotools
2485                                             * .data.shapefile.shp.ShapefileReader$Record.shape
2486                                             * (ShapefileReader.java:106) at
2487                                             * org.geotools.data.shapefile.
2488                                             * ShapefileAttributeReader.next(
2489                                             * ShapefileAttributeReader.java:157) at
2490                                             * org.geotools.data.shapefile
2491                                             * .indexed.IndexedShapefileAttributeReader
2492                                             * .next(IndexedShapefileAttributeReader.java:122) at
2493                                             * org.geotools
2494                                             * .data.FIDFeatureReader.next(FIDFeatureReader.java:96) at
2495                                             * org.geotools.data.FIDFeatureReader.next(FIDFeatureReader.
2496                                             * java:55) at org.geotools.data.MaxFeatureReader.next(
2497                                             * MaxFeatureReader.java:61) at
2498                                             * org.geotools.data.MaxFeatureReader
2499                                             * .next(MaxFeatureReader.java:61)
2500                                             **/
2501                                    }
2502                            }
2503    
2504                            // Kartenbereich um 10% vergroessern, damit z.B. auch ein
2505                            // Punkt-Layer,
2506                            // welches nur aus 2 Punnkten besteht, sichtbar ist (Punkte liegen
2507                            // sonst
2508                            // genau auf dem Rand der angezeigten Flaeche)
2509    
2510                            if (mapAreaNew != null) {
2511                                    mapAreaNew.expandBy(mapAreaNew.getWidth() * 0.1, mapAreaNew
2512                                                    .getHeight() * 0.1);
2513                                    setMapArea(mapAreaNew);
2514                            } else {
2515                                    LOGGER
2516                                                    .warn("Couldn't transformEnvelope when zooming to the layer");
2517                            }
2518                    } catch (Exception err) {
2519                            LOGGER.error("Zoom to layer did not terminate correctly", err);
2520                    }
2521            }
2522    
2523            /**
2524             * Zooms the {@link SelectableXMapPane} to the {@link Envelope} of a layer.
2525             *
2526             * <br>
2527             * A refresh of the map is not done automatically
2528             *
2529             * @param index
2530             *            Index of the {@link MapLayer} in the {@link MapContext} (from
2531             *            back to top)
2532             *
2533             * @author <a href="mailto:[email protected]">Stefan Alfons
2534             *         Kr&uuml;ger</a>
2535             */
2536            public void zoomToLayer(int index) {
2537                    final MapContext context = getMapContext();
2538                    if (context != null)
2539                            zoomToLayer(context.getLayer(index));
2540            }
2541    
2542            /**
2543             * Zooms the {@link SelectableXMapPane} to the {@link Envelope} of the
2544             * selected layer. The layer is selected by the idx, counting from front to
2545             * back, like humans would expect in a {@link JList}
2546             *
2547             * <br>
2548             * A refresh of the map is not done automatically
2549             *
2550             *
2551             *
2552             * @param index
2553             *            Reverse index of the {@link MapLayer} in the
2554             *            {@link MapContext}
2555             *
2556             * @author <a href="mailto:[email protected]">Stefan Alfons
2557             *         Kr&uuml;ger</a>
2558             */
2559            public void zoomToLayerIdxReverse(int index) {
2560                    zoomToLayer(getMapContext().getLayerCount() - 1 - index);
2561            }
2562    
2563            
2564            
2565    
2566    
2567            /**
2568             * Aktiviert oder deaktiviert das AntiAliasing for diese
2569             * {@link SelectableXMapPane}. AntiALiasing ist besonders fuer
2570             * Textbeschriftung sehr schoen, verbraucht aber auch mehr Performance.
2571             *
2572             * @author <a href="mailto:[email protected]">Stefan Alfons
2573             *         Kr&uuml;ger</a>
2574             */
2575            public void setAntiAliasing(final boolean aa) {
2576                    // LOGGER.info("Setting AntiAliasing for this JMapPane to " + aa);
2577                    RenderingHints java2DHints = java2dHints;
2578                    if (java2DHints == null) {
2579                            java2DHints = GeoTools.getDefaultHints();
2580                    }
2581                    
2582                    java2DHints.put(RenderingHints.KEY_ANTIALIASING,
2583                                    aa ? RenderingHints.VALUE_ANTIALIAS_ON
2584                                                    : RenderingHints.VALUE_ANTIALIAS_OFF);
2585                    java2DHints.put(RenderingHints.KEY_TEXT_ANTIALIASING,
2586                                    aa ? RenderingHints.VALUE_TEXT_ANTIALIAS_ON
2587                                                    : RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
2588                    java2DHints.put(RenderingHints.KEY_RENDERING,
2589                                    aa ? RenderingHints.VALUE_RENDER_QUALITY
2590                                                    : RenderingHints.VALUE_RENDER_SPEED);
2591                    
2592          }          }
2593    
2594  }  }
Legend:
Removed from v.445  
changed lines
  Added in v.607
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26