/[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

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