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