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