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