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