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

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

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

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