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