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