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