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

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

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

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