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