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

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

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

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