/[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 506 by alfonx, Sat Oct 31 12:15:37 2009 UTC branches/1.0-gt2-2.6/src/gtmig/org/geotools/swing/XMapPane.java revision 511 by alfonx, Thu Nov 5 17:41:33 2009 UTC
# Line 16  Line 16 
16  package gtmig.org.geotools.swing;  package gtmig.org.geotools.swing;
17    
18  /**  /**
19   * <b>Xulu:<br>   * This class is 50% copied from GeoTools 2.6.x JMapPane. GeoTools is LGPL, SCHMITZM also.<br/>
20   *    Code taken from gt-2.4.5 to make some changes (marked with {@code xulu}),   * In addition to
  *    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  
  *  
21   */   */
22    
23    import java.awt.AlphaComposite;
24  import java.awt.Color;  import java.awt.Color;
25  import java.awt.Cursor;  import java.awt.Cursor;
26    import java.awt.Font;
27  import java.awt.Graphics;  import java.awt.Graphics;
28  import java.awt.Graphics2D;  import java.awt.Graphics2D;
29  import java.awt.LayoutManager;  import java.awt.Image;
30    import java.awt.Point;
31  import java.awt.Rectangle;  import java.awt.Rectangle;
32  import java.awt.RenderingHints;  import java.awt.RenderingHints;
33    import java.awt.event.ActionEvent;
34    import java.awt.event.ActionListener;
35    import java.awt.event.ComponentAdapter;
36    import java.awt.event.ComponentEvent;
37  import java.awt.event.InputEvent;  import java.awt.event.InputEvent;
38  import java.awt.event.MouseEvent;  import java.awt.event.MouseEvent;
39  import java.awt.event.MouseListener;  import java.awt.event.MouseListener;
 import java.awt.event.MouseMotionListener;  
40  import java.awt.geom.AffineTransform;  import java.awt.geom.AffineTransform;
41    import java.awt.geom.NoninvertibleTransformException;
42    import java.awt.geom.Point2D;
43  import java.awt.image.BufferedImage;  import java.awt.image.BufferedImage;
44  import java.beans.PropertyChangeEvent;  import java.beans.PropertyChangeEvent;
45  import java.beans.PropertyChangeListener;  import java.beans.PropertyChangeListener;
46  import java.io.IOException;  import java.io.IOException;
 import java.util.Date;  
47  import java.util.HashMap;  import java.util.HashMap;
48  import java.util.Map;  import java.util.Map;
49    import java.util.Vector;
50    
51    import javax.swing.JFrame;
52  import javax.swing.JPanel;  import javax.swing.JPanel;
53    import javax.swing.Timer;
54    
55  import org.apache.log4j.Logger;  import org.apache.log4j.Logger;
56    import org.geotools.feature.FeatureCollection;
57    import org.geotools.geometry.jts.JTS;
58    import org.geotools.geometry.jts.ReferencedEnvelope;
59    import org.geotools.map.DefaultMapContext;
60  import org.geotools.map.MapContext;  import org.geotools.map.MapContext;
61    import org.geotools.map.MapLayer;
62    import org.geotools.map.event.MapLayerEvent;
63  import org.geotools.map.event.MapLayerListEvent;  import org.geotools.map.event.MapLayerListEvent;
64  import org.geotools.map.event.MapLayerListListener;  import org.geotools.map.event.MapLayerListListener;
65    import org.geotools.map.event.MapLayerListener;
66    import org.geotools.referencing.CRS;
67  import org.geotools.renderer.GTRenderer;  import org.geotools.renderer.GTRenderer;
68  import org.geotools.renderer.label.LabelCacheImpl;  import org.geotools.renderer.label.LabelCacheImpl;
69  import org.geotools.renderer.lite.LabelCache;  import org.geotools.renderer.lite.LabelCache;
70  import org.geotools.renderer.lite.StreamingRenderer;  import org.geotools.swing.JMapPane;
71  import org.opengis.filter.FilterFactory2;  import org.geotools.swing.RenderingExecutor;
72    import org.geotools.swing.event.MapMouseEvent;
73    import org.geotools.swing.event.MapPaneEvent;
74    import org.geotools.swing.event.MapPaneListener;
75    import org.opengis.feature.simple.SimpleFeature;
76    import org.opengis.feature.simple.SimpleFeatureType;
77    import org.opengis.referencing.FactoryException;
78  import org.opengis.referencing.crs.CoordinateReferenceSystem;  import org.opengis.referencing.crs.CoordinateReferenceSystem;
79    import org.opengis.referencing.operation.MathTransform;
80    import org.opengis.referencing.operation.TransformException;
81    
82    import schmitzm.geotools.GTUtil;
83  import schmitzm.geotools.JTSUtil;  import schmitzm.geotools.JTSUtil;
84    import schmitzm.geotools.gui.SelectableXMapPane;
85    import schmitzm.geotools.map.event.JMapPaneListener;
86    import schmitzm.geotools.map.event.MapLayerAdapter;
87  import schmitzm.swing.SwingUtil;  import schmitzm.swing.SwingUtil;
88    
89  import com.vividsolutions.jts.geom.Coordinate;  import com.vividsolutions.jts.geom.Coordinate;
90  import com.vividsolutions.jts.geom.Envelope;  import com.vividsolutions.jts.geom.Envelope;
91  import com.vividsolutions.jts.geom.GeometryFactory;  import com.vividsolutions.jts.geom.Geometry;
92    
93  public class JMapPane extends JPanel implements MouseListener,  public class XMapPane extends JPanel implements PropertyChangeListener {
94                  MouseMotionListener, PropertyChangeListener, MapLayerListListener {          private static Logger LOGGER = Logger.getLogger(XMapPane.class);
         private static Logger LOGGER = Logger.getLogger(JMapPane.class);  
95    
96          private static final long serialVersionUID = -8647971481359690499L;          /**
97             * Sets whether a layer is regarded or ignored on {@link #SELECT_TOP},
98             * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions.
99             *
100             * @param layer
101             *            a layer
102             * @param selectable
103             *            if {@code false} the layer is ignored during the upper
104             *            mentioned actions. If <code>null</code>, the default (true)
105             *            will be used.
106             */
107            public void setMapLayerSelectable(MapLayer layer, Boolean selectable) {
108                    if (selectable == null)
109                            mapLayerSelectable.remove(layer);
110                    else
111                            mapLayerSelectable.put(layer, selectable);
112            }
113    
114          public static final int Reset = 0;          /**
115             * Holds a flag for each layer, whether it is regarded or ignored on
116             * {@link #SELECT_TOP}, {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP}
117             * actions.
118             */
119            final protected HashMap<MapLayer, Boolean> mapLayerSelectable = new HashMap<MapLayer, Boolean>();
120    
121          public static final int ZoomIn = 1;          /**
122             * Returns whether a layer is regarded or ignored on {@link #SELECT_TOP},
123             * {@link #SELECT_ALL} and {@link #SELECT_ONE_FROM_TOP} actions. Returns
124             * <code>true</code> if the selectability has not been defined.
125             *
126             * @param layer
127             *            a layer
128             */
129            public boolean isMapLayerSelectable(MapLayer layer) {
130                    Boolean selectable = mapLayerSelectable.get(layer);
131                    return selectable == null ? true : selectable;
132            }
133    
134          public static final int ZoomOut = 2;          /**
135             * Flag fuer Modus "Kartenausschnitt bewegen". Nicht fuer Window-Auswahl
136             * moeglich!
137             *
138             * @see #setState(int)
139             */
140            public static final int PAN = 1;
141            /**
142             * Flag fuer Modus "Heran zoomen".
143             *
144             * @see #setState(int)
145             * @see #setState(int)
146             */
147            public static final int ZOOM_IN = 2;
148            /**
149             * Flag fuer Modus "Heraus zoomen". Nicht fuer Window-Auswahl moeglich!
150             *
151             * @see #setState(int)
152             */
153            public static final int ZOOM_OUT = 3;
154            /**
155             * Flag fuer Modus
156             * "SimpleFeature-Auswahl auf dem obersten (sichtbaren) Layer".
157             *
158             * @see #setState(int)
159             * @see #setState(int)
160             */
161            public static final int SELECT_TOP = 4;
162            /**
163             * Flag fuer Modus "SimpleFeature-Auswahl auf allen (sichtbaren) Layern".
164             *
165             * @see #setState(int)
166             * @see #setState(int)
167             */
168            public static final int SELECT_ALL = 103;
169            /**
170             * Flag fuer Modus
171             * "Auswahl nur eines Features, das erste sichtbare von Oben".
172             *
173             * @see #setState(int)
174             * @see #setState(int)
175             */
176            public static final int SELECT_ONE_FROM_TOP = 104;
177    
178          public static final int Pan = 3;          public static final long DEFAULT_REPAINTING_DELAY = 200;
179    
180          public static final int Select = 4;          protected skrueger.geotools.RenderingExecutor bgExecuter;
181    
182          /**          /**
183           * what renders the map           * the map context to render
184           */           */
185          GTRenderer renderer;          MapContext localContext;
   
186          /**          /**
187           * the map context to render           * the map context to render
188           */           */
189          MapContext context;          MapContext bgContext;
190    
191          /**          /**
192           * the area of the map to draw           * the area of the map to draw
193           */           */
194          protected Envelope mapArea;          protected Envelope mapArea = null;
195            /**
196             * We store the old mapArea for a moment to use it for the
197             * "quick scaled preview" in case of ZoomOut
198             **/
199            protected Envelope oldMapArea = null;
200    
201          /**          /**
202           * the size of the pane last time we drew           * the size of the pane last time we drew
203           */           */
204          protected Rectangle oldRect = null;          protected Rectangle oldRect = null;
205    
         /** We store the old mapArea for a moment to use it for the  
         "quick scaled preview" in case of ZoomOut **/  
         protected Envelope oldMapArea = null;  
   
206          /**          /**
207           * the base image of the map           * The Renderer for the Background uses this Image. When set to null, please
208             * dispose the {@link Graphics2D}
209           */           */
210          protected BufferedImage baseImage, panningImage;          protected BufferedImage bgImage;
211    
212          /**          /**
213           * a factory for filters           * The Renderer for the LocalLayers uses this Image. When set to null,
214             * please dispose this {@link Graphics2D}
215           */           */
216          FilterFactory2 ff;          volatile protected BufferedImage localImage;
217    
218          /**          /**
219           * a factory for geometries           * compass and icon are rendered into this image
220           */           */
221          GeometryFactory gf = new GeometryFactory(); // FactoryFinder.getGeometryFactory(null);  //      protected BufferedImage gadgetsImage;
222    
223          private int state = ZoomIn;          /**
224             * The default state is ZOOM_IN, hence by default the
225             * {@link #zoomMapPaneMouseListener} is also enabled.
226             **/
227            private int state = ZOOM_IN;
228    
229          /**          /**
230           * how far to zoom in or out           * Konvertiert die Maus-Koordinaten (relativ zum <code>JMapPane</code>) in
231             * Karten-Koordinaten.
232             *
233             * @param e
234             *            Maus-Ereignis
235           */           */
236          private double zoomFactor = 2.0;          public static Point2D getMapCoordinatesFromEvent(MouseEvent e) {
237                    // aktuelle Geo-Position aus GeoMouseEvent ermitteln
238          boolean changed = true;                  if (e != null && e instanceof MapMouseEvent)
239                            try {
240          LabelCache labelCache = new LabelCacheImpl();                                  return ((MapMouseEvent) e).getMapPosition().toPoint2D();
241                            } catch (Exception err) {
242                                    LOGGER
243                                                    .error(
244                                                                    "return ((GeoMouseEvent) e).getMapCoordinate(null).toPoint2D();",
245                                                                    err);
246                            }
247    
248          protected boolean reset = false;                  // aktuelle Geo-Position ueber Transformation des JMapPane berechnen
249                    if (e != null && e.getSource() instanceof XMapPane) {
250                            
251                            final XMapPane xMapPane = (XMapPane) e.getSource();
252                            
253                            if (!xMapPane.isWellDefined()) return null;
254                            
255                            AffineTransform at = xMapPane.getScreenToWorld();
256                            if (at != null)
257                                    return at.transform(e.getPoint(), null);
258                            return null;
259                    }
260                    throw new IllegalArgumentException(
261                                    "MouseEvent has to be of instance MapMouseEvent or come from an XMapPane");
262            }
263    
264          int startX;          /**
265             * A flag indicating that the shown image is invalid and needs to be
266             * re-rendered.
267             */
268            protected boolean mapImageInvalid = true;
269    
270          int startY;          protected LabelCache labelCache = new LabelCacheImpl();
271    
272          /**          /**
273           * If not <code>null</code>, the {@link JMapPane} will not allow to zoom/pan           * If not <code>null</code>, the {@link XMapPane} will not allow to zoom/pan
274           * out of that area           * out of that area
275           **/           **/
276          private Envelope maxExtend = null;          private Envelope maxExtend = null;
277    
278          // /**          private Double maxZoomScale = Double.MIN_VALUE;
279          // * Is max. 1 or 0 of the 2 axised allowed to extend the maxExtend? If          private Double minZoomScale = Double.MAX_VALUE;
         // * <code>true</code> the extends has to be fully inside maxExtend  
         // **/  
         // boolean maxExtendForceMode = true;  
   
         private boolean clickable;  
280    
281          int lastX;          /**
282             * This color is used as the default background color when painting a map.
283             */
284            private Color mapBackgroundColor = Color.WHITE;
285    
286          int lastY;          /**
287             * This {@link MouseListener} is managing all zoom related tasks
288             */
289            public final ZoomXMapPaneMouseListener zoomMapPaneMouseListener = new ZoomXMapPaneMouseListener(
290                            this);
291    
292          private Double maxZoomScale = Double.MIN_VALUE;          /**
293          private Double minZoomScale = Double.MAX_VALUE;           * A flag indicating, that the image size has changed and the buffered
294             * images are not big enough any more
295             **/
296            protected boolean paneResized = false;
297    
298          /**          /**
299           * Wenn true, dann wurde PANNING via mouseDraged-Events begonnen. Dieses           * While threads are working, we call {@link XMapPane#updateFinalImage()}
300           * Flag wird benutzt um nur einmal den passenden Cursor nur einmal zu           * regularly and repaint(). This {@link Timer} is stoppen when all renderers
301           * setzen.           * finished.
302           */           */
303          private boolean panning_started = false;          final private Timer repainterTimer;
304    
305          /**          /**
306           * This color is used as the default background color when painting a map.           * The flag {@link #requestStartRendering} can be set to true by events.
307             * This {@link Timer} checks the flag regularly and starts one renderer
308             * thread.
309           */           */
310          private Color mapBackgroundColor = Color.WHITE;          final private Timer startRenderThreadsTimer;
311    
312            private Map<Object, Object> rendererHints;
313    
314          public JMapPane() {          public Map<Object, Object> getRendererHints() {
315                  this(null, true, null, null);                  return rendererHints;
316          }          }
317    
318          /**          /**
319           * create a basic JMapPane           * Nuetzlich wenn die Componente gedruckt (z.B. wenn ein Screenshot gemacht
320             * wird) wird. Dann werden wird der Hintergrund auf WEISS gesetzt.
321           *           *
322           * @param render           * @author <a href="mailto:[email protected]">Stefan Alfons
323           *            - how to draw the map           *         Kr&uuml;ger</a>
          * @param context  
          *            - the map context to display  
324           */           */
325          public JMapPane(final GTRenderer render, final MapContext context) {          @Override
326                  this(null, true, render, context);          public void print(Graphics g) {
327                    Color orig = getBackground();
328                    setBackground(Color.WHITE);
329    
330                    // wrap in try/finally so that we always restore the state
331                    try {
332                            super.print(g);
333                    } finally {
334                            setBackground(orig);
335                    }
336          }          }
337    
338          /**          /**
339           * full constructor extending JPanel           * full constructor extending JPanel
340           *           *
341             * @param rendererHints
342             *
343           * @param layout           * @param layout
344           *            - layout (probably shouldn't be set)           *            - layout (probably shouldn't be set)
345           * @param isDoubleBuffered           * @param isDoubleBuffered
346           *            - a Swing thing I don't really understand           *            - a Swing thing I don't really understand
347           * @param render           * @param render
348           *            - what to draw the map with           *            - what to draw the map with
349           * @param context           * @param localContext
350           *            - what to draw           *            - {@link MapContext} of layer to render.
351           */           */
352          public JMapPane(final LayoutManager layout, final boolean isDoubleBuffered,          public XMapPane(final MapContext localContext,
353                          final GTRenderer render, final MapContext context) {                          Map<Object, Object> rendererHints) {
354                  super(layout, isDoubleBuffered);                  super(true);
355    
356                    setRendererHints(rendererHints);
357    
358                    setOpaque(true);
359    
360                    setLocalContext(localContext);
361    
362                    /**
363                     * Adding the #zoomMapPaneMouseListener
364                     */
365                    this.addMouseListener(zoomMapPaneMouseListener);
366                    this.addMouseMotionListener(zoomMapPaneMouseListener);
367                    this.addMouseWheelListener(zoomMapPaneMouseListener);
368    
369                    /*
370                     * We use a Timer object to avoid rendering delays and flickering when
371                     * the user is drag-resizing the parent container of this map pane.
372                     *
373                     * Using a ComponentListener doesn't work because, unlike a JFrame, the
374                     * pane receives a stream of events during drag-resizing.
375                     */
376                    resizingPaintDelay = DEFAULT_RESIZING_PAINT_DELAY;
377                    resizeTimer = new Timer(resizingPaintDelay, new ActionListener() {
378    
379                            public void actionPerformed(ActionEvent e) {
380                                    paneResized = true;
381    
382                                    if (!isWellDefined())
383                                            return;
384    
385                                    Rectangle bounds = getVisibleRect();
386    
387                                    Envelope geoMapArea = tranformWindowToGeo(bounds.x, bounds.y,
388                                                    bounds.x + bounds.width, bounds.y + bounds.height);
389    
390                                    setMapArea(bestAllowedMapArea(geoMapArea));
391                            }
392                    });
393                    resizeTimer.setRepeats(false);
394                    this.addComponentListener(new ComponentAdapter() {
395    
396                            @Override
397                            public void componentResized(ComponentEvent e) {
398                                    if (bgExecuter != null)
399                                            bgExecuter.cancelTask();
400                                    if (localExecuter != null)
401                                            localExecuter.cancelTask();
402                                    resizeTimer.restart();
403                            }
404    
405                    });
406    
407                  ff = (FilterFactory2) org.geotools.factory.CommonFactoryFinder                  repainterTimer = new Timer((int) DEFAULT_REPAINTING_DELAY,
408                                  .getFilterFactory(null);                                  new ActionListener() {
                 setRenderer(render);  
409    
410                  setContext(context);                                          @Override
411                                            public void actionPerformed(ActionEvent e) {
412                                                    updateFinalImage();
413                                                    XMapPane.this.repaint(DEFAULT_REPAINTING_DELAY);
414                                            }
415                                    });
416                    repainterTimer.setInitialDelay(1000);
417                    repainterTimer.setRepeats(true);
418    
419                    startRenderThreadsTimer = new Timer(200, new ActionListener() {
420    
421                            @Override
422                            public void actionPerformed(ActionEvent e) {
423                                    synchronized (requestStartRendering) {
424                                            if (requestStartRendering && isValid())
425                                                    startRendering();
426                                            requestStartRendering = false;
427                                    }
428                            }
429                    });
430                    startRenderThreadsTimer.start();
431    
432                  this.addMouseListener(this);          }
433                  this.addMouseMotionListener(this);  
434                  setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));          // TODO doku
435            public XMapPane() {
436                    this(null, null);
437          }          }
438    
439          /**          /**
440           * get the renderer           * Sets the mapArea to best possibly present the given features. If only one
441             * single point is given, the window is moved over the point.
442             *
443             * Note: The method does not call {@link #repaint()} on the
444             * {@link SelectableXMapPane} .
445             *
446             * @param features
447             *            if <code>null</code> or size==0, the function doesn nothing.
448           */           */
449          public GTRenderer getRenderer() {          public void zoomTo(
450                  return renderer;                          FeatureCollection<SimpleFeatureType, SimpleFeature> features) {
451          }  
452                    CoordinateReferenceSystem mapCRS = getContext()
453                                    .getCoordinateReferenceSystem();
454                    CoordinateReferenceSystem fCRS = features.getSchema()
455                                    .getGeometryDescriptor().getCoordinateReferenceSystem();
456    
457                    double width = mapArea.getWidth();
458                    double height = mapArea.getHeight();
459                    double ratio = height / width;
460    
461                    if (features == null || features.size() == 0) {
462                            // feature count == 0 Zoom to the full extend
463                            return;
464                    } else if (features.size() == 1) {
465    
466                            // feature count == 1 Just move the window to the point and zoom 'a
467                            // bit'
468                            SimpleFeature singleFeature = (SimpleFeature) features.iterator()
469                                            .next();
470    
471                            if (((Geometry) singleFeature.getDefaultGeometry())
472                                            .getCoordinates().length > 1) {
473                                    // System.out.println("Zoomed to only pne poylgon");
474                                    // Poly
475                                    // TODO max width vs. height
476                                    width = features.getBounds().getWidth() * 3;
477                                    height = ratio * width;
478                            } else {
479                                    // System.out.println("Zoomed in a bit becasue only one point");
480                                    // width *= .9;
481                                    // height *= .9;
482                            }
483    
484                            Coordinate centre = features.getBounds().centre();
485                            if (!mapCRS.equals(fCRS)) {
486                                    // only to calculations if the CRS differ
487                                    try {
488                                            MathTransform fToMap;
489                                            fToMap = CRS.findMathTransform(fCRS, mapCRS);
490                                            // centre is transformed to the mapCRS
491                                            centre = JTS.transform(centre, null, fToMap);
492                                    } catch (FactoryException e) {
493                                            LOGGER.error("Looking for a Math transform", e);
494                                    } catch (TransformException e) {
495                                            LOGGER.error("Looking for a Math transform", e);
496                                    }
497                            }
498    
499                            Coordinate newLeftBottom = new Coordinate(centre.x - width / 2.,
500                                            centre.y - height / 2.);
501                            Coordinate newTopRight = new Coordinate(centre.x + width / 2.,
502                                            centre.y + height / 2.);
503    
504                            Envelope newMapArea = new Envelope(newLeftBottom, newTopRight);
505    
506          public void setRenderer(final GTRenderer renderer) {                          setMapArea(newMapArea);
                 Map<Object, Object> hints = new HashMap<Object, Object>();  
507    
508                  this.renderer = renderer;                  } else {
509                  // MS: Apply hint also for ShapeFileRenderer                          ReferencedEnvelope fBounds = features.getBounds();
510                  // if (renderer instanceof StreamingRenderer) {  
511                  hints = renderer.getRendererHints();                          Envelope bounds;
512                  if (hints == null) {                          if (!mapCRS.equals(fCRS)) {
513                          hints = new HashMap<Object, Object>();                                  bounds = JTSUtil.transformEnvelope(fBounds, fCRS, mapCRS);
514                            } else {
515                                    bounds = fBounds;
516                            }
517                            // BB umrechnen von Layer-CRS in Map-CRS
518    
519                            // Expand a bit
520                            bounds.expandBy(bounds.getWidth() / 6., bounds.getHeight() / 6.);
521    
522                            setMapArea(bounds);
523                  }                  }
524                  if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {          }
525                          labelCache = (LabelCache) hints  
526                                          .get(StreamingRenderer.LABEL_CACHE_KEY);          private void setRendererHints(Map<Object, Object> rendererHints) {
527                    this.rendererHints = rendererHints;
528            }
529    
530            /**
531             * Return <code>true</code> if a CRS and a {@link #mapArea} are set and the
532             * {@link XMapPane} is visible and has bounds set.
533             */
534            public boolean isWellDefined() {
535                    
536                    try {
537                            
538                    if (getContext() == null)
539                            return false;
540                    if (getContext().getLayerCount() <= 0)
541                            return false;
542                    if (getMapArea() == null)
543                            return false;
544                    if (getBounds().getWidth() == 0)
545                            return false;
546                    if (getBounds().getHeight() == 0)
547                            return false;
548                    } catch (Exception e) {
549                            return false;
550                    }
551                    return true;
552            }
553    
554            /**
555             * Default delay (milliseconds) before the map will be redrawn when resizing
556             * the pane. This is to avoid flickering while drag-resizing.
557             */
558            public static final int DEFAULT_RESIZING_PAINT_DELAY = 500; // delay in
559            // milliseconds
560    
561            private Timer resizeTimer;
562            private int resizingPaintDelay;
563            /**
564             * We store the old transform for a moment to use it for the
565             * "quick scaled preview" in case of ZoomIn
566             **/
567            protected AffineTransform oldScreenToWorld = null;
568    
569            /**
570             * Manuell gesetzter statischer Cursor, unabhaengig von der aktuellen
571             * MapPane-Funktion
572             */
573            protected Cursor staticCursor = null;
574    
575            /**
576             * Standardmaessig wird der Cursor automatisch je nach MapPane-Aktion (Zoom,
577             * Auswahl, ...) gesetzt. Mit dieser Methode kann ein statischer Cursor
578             * gesetzt werden, der unabhaengig von der aktuellen MapPanes-Aktion
579             * beibehalten wird. Um diesen statischen Cursor wieder zu entfernen, kann
580             * {@code null} als Parameter uebergeben werden
581             *
582             * @param cursor
583             *            Cursor
584             */
585            public void setStaticCursor(Cursor cursor) {
586                    this.staticCursor = cursor;
587                    if (cursor != null)
588                            super.setCursor(cursor);
589            }
590    
591            /**
592             * Liefert den statisch eingestellten Cursor, der unabhaengig von der
593             * eingestellten MapPane-Aktion (Zoom, Auswahl, ...) verwendet wird.
594             *
595             * @return {@code null}, wenn kein statischer Cursor verwendet, sondern der
596             *         Cursor automatisch je nach MapPane-Aktion eingestellt wird.
597             */
598            public Cursor getStaticCursor() {
599                    return this.staticCursor;
600            }
601    
602            /**
603             * Abhaengig von selState wird der Cursor gesetzt
604             */
605            public void updateCursorAndRepaintTimer() {
606    
607                    if (bgExecuter != null && bgExecuter.isRunning()
608                                    || localExecuter != null && localExecuter.isRunning()) {
609                            setCursor(WAIT_CURSOR);
610                            return;
611                  } else {                  } else {
612                          hints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);                          // Allow one last rendering
613                            if (repainterTimer.isRunning()) {
614                                    repainterTimer.stop();
615                                    updateFinalImage();
616                                    repaint();
617                            }
618                  }                  }
619    
620                  hints.put("memoryPreloadingEnabled", Boolean.TRUE);                  // wenn manueller Cursor gesetzt ist, dann diesen verwenden (unabhaengig
621                    // von der aktuellen Aktion
622                    if (this.staticCursor != null) {
623                            setCursor(staticCursor);
624                            return;
625                    }
626                    if (getCursor() == SwingUtil.PANNING_CURSOR) {
627                            // This cursor will reset itself
628                            return;
629                    }
630    
631                  renderer.setRendererHints(hints);                  // Je nach Aktion den Cursor umsetzen
632                  // }                  switch (state) {
633                    case SELECT_TOP:
634                    case SELECT_ONE_FROM_TOP:
635                    case SELECT_ALL:
636                            setCursor(SwingUtil.CROSSHAIR_CURSOR);
637                            break;
638                    case ZOOM_IN:
639                            setCursor(SwingUtil.ZOOMIN_CURSOR);
640                            break;
641                    case ZOOM_OUT:
642                            setCursor(SwingUtil.ZOOMOUT_CURSOR);
643                            break;
644                    case PAN:
645                            setCursor(SwingUtil.PAN_CURSOR);
646                            break;
647                    default:
648                            setCursor(normalCursor);
649                            break;
650                    }
651            }
652    
653            //
654            // /**
655            // * Gibt den "normalen" Cursor zurueck. Dieser kann neben dem "pointer"
656            // auch
657            // * ein Sanduhr-Wartecursor sein.
658            // *
659            // * @author <a href="mailto:[email protected]">Stefan Alfons
660            // * Kr&uuml;ger</a>
661            // */
662            // public Cursor getNormalCursor() {
663            // return normalCursor;
664            // }
665            //
666            // /**
667            // * Setzt den "normalen" Cursor. Dieser kann neben dem default "pointer"
668            // z.B.
669            // * auch ein Sanduhr-Wartecursor sein.
670            // *
671            // * @author <a href="mailto:[email protected]">Stefan Alfons
672            // * Kr&uuml;ger</a>
673            // */
674            // public void setNormalCursor(Cursor normalCursor) {
675            // this.normalCursor = normalCursor;
676            // }
677    
678            /**
679             * Berechnet die Transformation zwischen Fenster- und Karten-Koordinaten
680             * neu.
681             */
682            protected void resetTransforms() {
683                    if (getMapArea() == null || getWidth() == 0 || getHeight() == 0)
684                            return;
685    
686                    // We store the last Transform
687                    oldScreenToWorld = screenToWorld;
688    
689                    this.screenToWorld = new AffineTransform(
690                    // Genauso wie die Fenster-Koordinaten, werden die Longitude-Koordinaten
691                                    // nach rechts (Osten) hin groesser
692                                    // --> positive Verschiebung
693                                    getMapArea().getWidth() / getWidth(),
694                                    // keine Verzerrung
695                                    0.0, 0.0,
696                                    // Waehrend die Fenster-Koordinaten nach unten hin groesser
697                                    // werden,
698                                    // werden Latitude-Koordinaten nach Sueden hin keiner
699                                    // --> negative Verschiebung
700                                    -getMapArea().getHeight() / getHeight(),
701                                    // Die Longitude-Koordinaten werden nach Osten hin groesser
702                                    // --> obere linke Ecke des Fensters hat also den Minimalwert
703                                    getMapArea().getMinX(),
704                                    // Die Latitude-Koordinaten werden nach Norden hin groesser
705                                    // --> obere linke Ecke des Fensters hat also den Maximalwert
706                                    getMapArea().getMaxY());
707    
708                    try {
709                            this.worldToScreen = screenToWorld.createInverse();
710                    } catch (NoninvertibleTransformException e) {
711                            LOGGER.error(e);
712                    }
713            }
714    
715            /**
716             * Transformation zwischen Fenster-Koordinaten und Karten-Koordinaten
717             * (lat/lon)
718             */
719            protected AffineTransform screenToWorld = null;
720    
721            private AffineTransform worldToScreen;
722    
723            /**
724             * Listens to changes of the "local" {@link MapContext} and triggers
725             * repaints where needed.
726             */
727            private MapLayerListListener localContextListener = new MapLayerListListener() {
728    
729                    @Override
730                    public void layerAdded(final MapLayerListEvent event) {
731                            event.getLayer().addMapLayerListener(localMapLayerListener);
732    
733                            if (localContext.getLayers().length == 1) { // the first one
734                                    // if the Area of Interest is unset, the LayerBounds are used
735                                    if (!setMapArea(localContext.getAreaOfInterest()))
736                                            repaint();
737    
738                                    return;
739                            }
740    
741                            // We need to redraw, even in case that the mapArea didn't change
742                            // mapImageInvalid = true;
743                            // repaint();
744                            requestStartRendering();
745    
746                    }
747    
748                    @Override
749                    public void layerRemoved(final MapLayerListEvent event) {
750                            if (event.getLayer() != null)
751                                    event.getLayer().removeMapLayerListener(localMapLayerListener);
752                            // mapImageInvalid = true;
753                            // repaint();
754                            requestStartRendering();
755                    }
756    
757                    @Override
758                    public void layerChanged(final MapLayerListEvent event) {
759                            // mapImageInvalid = true;
760                            // repaint();
761                            requestStartRendering();
762                    }
763    
764                    @Override
765                    public void layerMoved(final MapLayerListEvent event) {
766                            // mapImageInvalid = true;
767                            // repaint();
768                            requestStartRendering();
769                    }
770            };
771    
772            /**
773             * Listens to changes of the "background" {@link MapContext} and triggers
774             * repaints where needed.
775             */
776            private MapLayerListListener bgContextListener = new MapLayerListListener() {
777    
778                    @Override
779                    public void layerAdded(final MapLayerListEvent event) {
780                            event.getLayer().addMapLayerListener(bgMapLayerListener);
781    
782                            if (localContext.getLayers().length == 0
783                                            && bgContext.getLayers().length == 1) { // the first one and
784                                    // localContext is
785                                    // empty
786                                    if (!setMapArea(localContext.getAreaOfInterest()))
787                                            requestStartRendering();
788                                    return;
789                            }
790    
791                            // We need to redraw, even in case that the mapArea didn't change
792                            // mapImageInvalid = true;
793                            // repaint();
794                            requestStartRendering();
795    
796                    }
797    
798                    @Override
799                    public void layerRemoved(final MapLayerListEvent event) {
800                            if (event.getLayer() != null)
801                                    event.getLayer().removeMapLayerListener(bgMapLayerListener);
802                            // mapImageInvalid = true;
803                            // repaint();
804                            requestStartRendering();
805                    }
806    
807                    @Override
808                    public void layerChanged(final MapLayerListEvent event) {
809                            // mapImageInvalid = true;
810                            // repaint();
811                            requestStartRendering();
812                    }
813    
814                    @Override
815                    public void layerMoved(final MapLayerListEvent event) {
816                            // mapImageInvalid = true;
817                            // repaint();
818                            requestStartRendering();
819                    }
820            };
821    
822            /**
823             * Listens to each layer in the local {@link MapContext} for changes and
824             * triggers repaints.
825             */
826            protected MapLayerListener localMapLayerListener = new MapLayerAdapter() {
827    
828                    @Override
829                    public void layerShown(MapLayerEvent event) {
830                            // mapImageInvalid = true;
831                            // repaint();
832                            requestStartRendering();
833                    }
834    
835                    @Override
836                    public void layerHidden(MapLayerEvent event) {
837                            // mapImageInvalid = true;
838                            // repaint();
839                            requestStartRendering();
840                    }
841    
842                  if (this.context != null) {                  @Override
843                          this.renderer.setContext(this.context);                  public void layerChanged(MapLayerEvent event) {
844                            // Change of SLD for example
845                            // mapImageInvalid = true;
846                            // repaint();
847                            requestStartRendering();
848                  }                  }
849            };
850    
851            /**
852             * Listens to each layer in the local {@link MapContext} for changes and
853             * triggers repaints.
854             */
855            protected MapLayerListener bgMapLayerListener = new MapLayerAdapter() {
856    
857                    @Override
858                    public void layerShown(MapLayerEvent event) {
859                            // mapImageInvalid = true;
860                            // repaint();
861                            requestStartRendering();
862                    }
863    
864                    @Override
865                    public void layerHidden(MapLayerEvent event) {
866                            // mapImageInvalid = true;
867                            // repaint();
868                            requestStartRendering();
869                    }
870    
871                    @Override
872                    public void layerChanged(MapLayerEvent event) {
873                            // Change of SLD for example
874                            // mapImageInvalid = true;
875                            // repaint();
876                            requestStartRendering();
877                    }
878            };
879    
880            /**
881             * Liefert eine affine Transformation, um von den Fenster-Koordinaten in die
882             * Karten-Koordinaten (Lat/Lon) umzurechnen.
883             *
884             * @return eine Kopie der aktuellen Transformation; <code>null</code> wenn
885             *         noch keine Karte angezeigt wird
886             */
887            public AffineTransform getScreenToWorld() {
888                    if (screenToWorld == null)
889                            resetTransforms();
890                    // nur Kopie der Transformation zurueckgeben!
891                    if (screenToWorld == null)
892                            return null;
893                    return new AffineTransform(screenToWorld);
894            }
895    
896            public AffineTransform getWorldToScreenTransform() {
897                    if (worldToScreen == null) {
898                            resetTransforms();
899                    }
900                    // nur Kopie der Transformation zurueckgeben!
901                    return new AffineTransform(worldToScreen);
902          }          }
903    
904          public MapContext getContext() {          public MapContext getContext() {
905                  return context;                  if (localContext == null) {
906                            this.localContext = new DefaultMapContext();
907                            this.localContext.addMapLayerListListener(localContextListener);
908                    }
909                    return localContext;
910            }
911    
912            public MapContext getBgContext() {
913                    return bgContext;
914          }          }
915    
916          public void setContext(final MapContext context) {          /**
917                  if (this.context != null) {           *
918                          this.context.removeMapLayerListListener(this);           * @param context
919             */
920            public void setLocalContext(final MapContext context) {
921                    // Remove the default listener from the old context
922                    if (this.localContext != null) {
923                            this.localContext.removeMapLayerListListener(localContextListener);
924    
925                            // adding listener to all layers
926                            for (MapLayer mapLayer : localContext.getLayers()) {
927                                    mapLayer.removeMapLayerListener(localMapLayerListener);
928                            }
929                  }                  }
930    
931                  this.context = context;                  this.localContext = context;
932    
933                  if (context != null) {                  if (context != null) {
934                          this.context.addMapLayerListListener(this);                          setMapArea(localContext.getAreaOfInterest());
935    
936                            this.localContext.addMapLayerListListener(localContextListener);
937    
938                            // adding listener to all layers
939                            for (MapLayer mapLayer : localContext.getLayers()) {
940                                    mapLayer.addMapLayerListener(localMapLayerListener);
941                            }
942                    }
943    
944                    mapImageInvalid = true;
945                    repaint();
946            }
947    
948            public void setBgContext(final MapContext context) {
949    
950                    // Remove the default listener from the old context
951                    if (this.bgContext != null) {
952                            this.bgContext.removeMapLayerListListener(bgContextListener);
953    
954                            // adding listener to all layers
955                            for (MapLayer mapLayer : bgContext.getLayers()) {
956                                    mapLayer.removeMapLayerListener(bgMapLayerListener);
957                            }
958                  }                  }
959    
960                  if (renderer != null) {                  this.bgContext = context;
961                          renderer.setContext(this.context);  
962                    if (context != null) {
963                            setMapArea(bgContext.getAreaOfInterest());
964    
965                            this.bgContext.addMapLayerListListener(bgContextListener);
966    
967                            // adding listener to all layers
968                            for (MapLayer mapLayer : bgContext.getLayers()) {
969                                    mapLayer.addMapLayerListener(bgMapLayerListener);
970                            }
971                  }                  }
972                    mapImageInvalid = true;
973                    repaint();
974          }          }
975    
976            /**
977             * Returns a copy of the mapArea
978             *
979             * @return
980             */
981          public Envelope getMapArea() {          public Envelope getMapArea() {
982                  return mapArea;                  if (mapArea == null) {
983                            final Rectangle paneBounds = getBounds();
984    
985                            try {
986                                    mapArea = localContext.getLayerBounds();
987                            } catch (final IOException e) {
988                                    LOGGER.warn("context.getLayerBounds()", e);
989                            }
990    
991                            if (mapArea != null) {
992                                    /* either the viewer size has changed or we've done a reset */
993                                    mapImageInvalid = true; /* note we need to redraw */
994                                    oldRect = paneBounds; /* store what the current size is */
995                                    mapArea = bestAllowedMapArea(mapArea);
996                            }
997                    }
998    
999                    if (mapArea == null)
1000                            return null;
1001    
1002                    return new Envelope(mapArea);
1003          }          }
1004    
1005          public void setMapArea(final Envelope mapArea) {          /**
1006                  this.mapArea = mapArea;           * @param newMapArea
1007             * @return <code>true</code> if the mapArea has been changed and a repaint
1008             *         has been triggered.
1009             */
1010            public boolean setMapArea(final Envelope newMapArea) {
1011    
1012                    if (newMapArea == null
1013                                    || bestAllowedMapArea(newMapArea).equals(mapArea)) {
1014                            // No change.. no need to repaint
1015                            return false;
1016                    }
1017    
1018                    // Testen, ob der Unterschied nur im minimalen Rundungsfehlerbereich
1019                    // liegt
1020                    if (mapArea != null) {
1021                            Envelope candNew = bestAllowedMapArea(newMapArea);
1022                            double tolX = mapArea.getWidth() / 1000.;
1023                            double tolY = mapArea.getHeight() / 1000.;
1024                            if ((candNew.getMinX() - tolX < mapArea.getMinX())
1025                                            && (mapArea.getMinX() < candNew.getMinX() + tolX)
1026                                            && (candNew.getMaxX() - tolX < mapArea.getMaxX())
1027                                            && (mapArea.getMaxX() < candNew.getMaxX() + tolX)
1028    
1029                                            && (candNew.getMinY() - tolY < mapArea.getMinY())
1030                                            && (mapArea.getMinY() < candNew.getMinY() + tolY)
1031                                            && (candNew.getMaxY() - tolY < mapArea.getMaxY())
1032                                            && (mapArea.getMaxY() < candNew.getMaxY() + tolY)
1033    
1034                            ) {
1035                                    // The two mapAreas only differ my 1/1000th.. ignore
1036    
1037                                    return false;
1038                            }
1039                    }
1040    
1041                    oldMapArea = mapArea;
1042    
1043                    System.out.println("requested setting to \\t" + newMapArea);
1044                    this.mapArea = bestAllowedMapArea(newMapArea);
1045                    System.out.println("set to \\t\\ŧ" + newMapArea);
1046    
1047                    if (localContext != null) {
1048                            localContext.setAreaOfInterest(mapArea, localContext
1049                                            .getCoordinateReferenceSystem());
1050                    }
1051                    if (bgContext != null) {
1052                            bgContext.setAreaOfInterest(mapArea, localContext
1053                                            .getCoordinateReferenceSystem());
1054                    }
1055                    resetTransforms();
1056                    mapImageInvalid = true;
1057                    mapAreaChanged = true;
1058                    repaint();
1059                    return true;
1060          }          }
1061    
1062          public int getState() {          public int getState() {
1063                  return state;                  return state;
1064          }          }
1065    
1066            /**
1067             * Enables/Disables the ZOOM Mouse Listener. Upates the Cursor and stops the
1068             * repaint Timer if
1069             *
1070             * @param state
1071             */
1072          public void setState(final int state) {          public void setState(final int state) {
1073                  this.state = state;                  this.state = state;
1074    
1075                  // System.out.println("State: " + state);                  zoomMapPaneMouseListener.setEnabled((state == ZOOM_IN
1076          }                                  || state == ZOOM_OUT || state == PAN));
1077    
1078          public double getZoomFactor() {                  // Je nach Aktion den Cursor umsetzen
1079                  return zoomFactor;                  updateCursorAndRepaintTimer();
1080          }          }
1081    
1082          public void setZoomFactor(final double zoomFactor) {          /** Cursor wenn kein Mausbutton gedrueckt wird. default oder SwingUtil.PAN **/
1083                  this.zoomFactor = zoomFactor;          protected static Cursor normalCursor = Cursor
1084          }                          .getPredefinedCursor(Cursor.DEFAULT_CURSOR);
1085    
1086            public static final Cursor WAIT_CURSOR = Cursor
1087                            .getPredefinedCursor(Cursor.WAIT_CURSOR);
1088    
1089            public static final int NONE = -123;
1090    
1091            private skrueger.geotools.RenderingExecutor localExecuter;
1092    
1093            private BufferedImage finalImage;
1094    
1095            /**
1096             * A flag set it {@link #setMapArea(Envelope)} to indicated the
1097             * {@link #paintComponent(Graphics)} method, that the image on-screen is
1098             * associated with {@link #oldMapArea} and may hence be scaled for a quick
1099             * preview.<br/>
1100             * The flag is reset
1101             **/
1102            private boolean mapAreaChanged = false;
1103    
1104            private JFrame finalImageFrame;
1105    
1106            private volatile Boolean requestStartRendering = false;
1107            private BufferedImage preFinalImage;
1108    
1109          protected void paintComponent(final Graphics g) {          protected void paintComponent(final Graphics g) {
1110                  super.paintComponent(g);                  // Maybe update the cursor
1111                    updateCursorAndRepaintTimer();
1112    
1113                  if ((renderer == null) || (mapArea == null)) {                  if (!acceptsRepaintCalls)
1114                          return;                          return;
                 }  
1115    
1116                  final Rectangle r = getBounds();                  boolean paintedSomething = false;
                 final Rectangle dr = new Rectangle(r.width, r.height);  
1117    
1118                  if (!r.equals(oldRect) || reset) {                  if (mapImageInvalid) { /* if the map changed then redraw */
1119                          if (!r.equals(oldRect) && (mapArea == null)) {  
1120                                  try {                          mapImageInvalid = false; // Reset for next round
1121                                          mapArea = context.getLayerBounds();  
1122                                  } catch (final IOException e) {                          // If the new mapArea and the oldMapArea intersect, we can draw some
1123                                          LOGGER.warn("context.getLayerBounds()", e);                          // quick scaled preview to make the user feel that something is
1124                            // happening.
1125                            if (mapAreaChanged && oldMapArea != null
1126                                            && getMapArea().intersects(oldMapArea)
1127                                            & !getMapArea().equals(oldMapArea)) {
1128    
1129                                    mapAreaChanged = false;
1130    
1131                                    if (getMapArea().covers(oldMapArea)) {
1132                                            setQuickPreviewHint(ZOOM_OUT);
1133                                            paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
1134                                    } else if (oldMapArea.covers(getMapArea())) {
1135                                            setQuickPreviewHint(ZOOM_IN);
1136                                            paintedSomething = drawScaledPreviewImage_Zoom((Graphics2D) g);
1137                                  }                                  }
                         }  
1138    
1139                          if (mapArea != null) {                          }
                                 /* either the viewer size has changed or we've done a reset */  
                                 changed = true; /* note we need to redraw */  
                                 reset = false; /* forget about the reset */  
                                 oldRect = r; /* store what the current size is */  
1140    
1141                                  mapArea = JTSUtil.fixAspectRatio(r, mapArea, false);                          if (paneResized) {
1142                                    paneResized = false;
1143                                    preFinalImage = null;
1144                                    finalImage = null;
1145                                    localImage = null;
1146                                    bgImage = null;
1147    //                              gadgetsImage = null;
1148                          }                          }
                 }  
1149    
1150                  if (!mapArea.equals(oldMapArea)) { /* did the map extent change? */                          // Start the Threads and Timers to render the image
1151                          changed = true;                          requestStartRendering();
1152                          oldMapArea = mapArea;  
                         // when we tell the context that the bounds have changed WMSLayers  
                         // can refresh them selves  
                         context.setAreaOfInterest(mapArea, context  
                                         .getCoordinateReferenceSystem());  
1153                  }                  }
1154    
1155                  if (changed) { /* if the map changed then redraw */                  if (!paintedSomething) {
                         changed = false;  
                           
                         // The baseImage should not have alpha  
                         baseImage = new BufferedImage(dr.width, dr.height,  
                                         BufferedImage.TYPE_INT_RGB);  
   
                         final Graphics2D ig = baseImage.createGraphics();  
                         ig.setBackground(getMapBackgroundColor());  
                         ig.fillRect(0, 0, dr.width, dr.height);  
                           
 //                      /* System.out.println("rendering"); */  
                         if (renderer.getContext() != null)  
                                 renderer.setContext(context);  
1156    
1157                          // TODO is this clearing still needed? We already replace all that stuff whenever we change the style. Deactivated 31.10.09.. let's see                          // TODO Should just paint the getFinalImage(). Update should be
1158  //                      labelCache.clear(); // work around anoying labelcache bug                          // called by timer every 300ms, and the repaint() until all threads
1159                            // are done.
1160                            g.drawImage(getFinalImage(), 0, 0, this);
1161    
1162                          // draw the map                          paintedSomething = true;
1163                          renderer.paint(ig, dr, mapArea);                  }
1164    
1165                          panningImage = new BufferedImage(dr.width, dr.height, BufferedImage.TYPE_INT_RGB);          }
1166    
1167                  }          /**
1168             * Cancels all running renderers and sets the flag to start new ones. <br/>
1169             *
1170             * @see #startRenderThreadsTimer
1171             */
1172            private void requestStartRendering() {
1173                    if (bgExecuter != null)
1174                            bgExecuter.cancelTask();
1175                    if (localExecuter != null)
1176                            localExecuter.cancelTask();
1177                    requestStartRendering = true;
1178            }
1179    
1180                  ((Graphics2D) g).drawImage(baseImage, 0, 0, this);          /**
1181             * Transformiert einen Fenster-Koordinaten-Bereich in Geo-Koordinaten.
1182             *
1183             * @param ox
1184             *            X-Koordinate der VON-Position
1185             * @param oy
1186             *            Y-Koordinate der VON-Position
1187             * @param px
1188             *            X-Koordinate der BIS-Position
1189             * @param py
1190             *            Y-Koordinate der BIS-Position
1191             */
1192            public Envelope tranformWindowToGeo(int ox, int oy, int px, int py) {
1193                    AffineTransform at = getScreenToWorld();
1194                    Point2D geoO = at.transform(new Point2D.Double(ox, oy), null);
1195                    Point2D geoP = at.transform(new Point2D.Double(px, py), null);
1196                    return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP.getY());
1197          }          }
1198    
1199          public void mouseClicked(final MouseEvent e) {          /**
1200                  if (mapArea == null)           * Transformiert einen Geo-Koordinaten-Bereich in Fenster-Koordinaten.
1201                          return;           *
1202                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"           * @param ox
1203                  // h:"+mapArea.getHeight());           *            X-Koordinate der VON-Position
1204                  final Rectangle bounds = this.getBounds();           * @param oy
1205                  final double x = (double) (e.getX());           *            Y-Koordinate der VON-Position
1206                  final double y = (double) (e.getY());           * @param px
1207                  final double width = mapArea.getWidth();           *            X-Koordinate der BIS-Position
1208                  final double height = mapArea.getHeight();           * @param py
1209                  // xulu.sc           *            Y-Koordinate der BIS-Position
1210                  // double width2 = mapArea.getWidth() / 2.0;           * @param winToGeotransform
1211                  // double height2 = mapArea.getHeight() / 2.0;           *            Eine Window to Geo transform. If <code>null</code>,
1212                  final double width2 = width / 2.0;           *            {@link #getScreenToWorld()} is used.
1213                  final double height2 = height / 2.0;           */
1214                  // xulu.ec          public Envelope tranformGeoToWindow(double ox, double oy, double px,
1215                  final double mapX = ((x * width) / (double) bounds.width)                          double py, AffineTransform winToGeotransform) {
1216                                  + mapArea.getMinX();                  AffineTransform at = winToGeotransform == null ? getScreenToWorld()
1217                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)                                  : winToGeotransform;
1218                                  + mapArea.getMinY();                  Point2D geoO;
1219                    try {
1220                            geoO = at.inverseTransform(new Point2D.Double(ox, oy), null);
1221                            Point2D geoP = at
1222                                            .inverseTransform(new Point2D.Double(px, py), null);
1223                            return new Envelope(geoO.getX(), geoP.getX(), geoO.getY(), geoP
1224                                            .getY());
1225                    } catch (NoninvertibleTransformException e) {
1226                            LOGGER.error(e);
1227                            return new Envelope(ox, oy, px, py);
1228                    }
1229            }
1230    
1231                  /*          /**
1232                   * System.out.println(""+x+"->"+mapX);           * Diretly paints scaled preview into the {@link SelectableXMapPane}. Used
1233                   * System.out.println(""+y+"->"+mapY);           * to give the user something to look at while we are rendering. Method
1234                   */           * should be called after {@link #setMapArea(Envelope)} has been set to the
1235             * new mapArea and transform has been reset.<br/>
1236             * This method does nothing if the {@link #lastRenderingDuration} is smaller
1237             * then a trashhold.
1238             *
1239             * @param g
1240             *            Graphics2D to paint the preview into
1241             *
1242             * @param state
1243             *            Max be {@link #ZOOM_IN} or {@link #ZOOM_OUT}
1244             */
1245            protected boolean drawScaledPreviewImage_Zoom(Graphics2D graphics) {
1246    
1247                  /*                  if (quickPreviewHint == 0)
1248                   * Coordinate ll = new Coordinate(mapArea.getMinX(), mapArea.getMinY());                          return false;
                  * Coordinate ur = new Coordinate(mapArea.getMaxX(), mapArea.getMaxY());  
                  */  
                 double zlevel = 1.0;  
1249    
1250                  switch (state) {                  graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
1251                  case Pan:                                  RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
1252                          zlevel = 1.0;                  graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
1253                          // xulu.sc SK: return here.. a mouselistener is managing the PANNING                                  RenderingHints.VALUE_ANTIALIAS_OFF);
1254                          // break;                  graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
1255                          return;                                  RenderingHints.VALUE_RENDER_SPEED);
                         // xulu.ec  
                 case ZoomIn:  
                         zlevel = zoomFactor;  
1256    
1257                          break;                  if (oldMapArea == null)
1258                            return false;
1259    
1260                  case ZoomOut:                  Rectangle visibleArea = getVisibleRect();
                         zlevel = 1.0 / zoomFactor;  
1261    
1262                          break;                  // Calculate the oldMapArea in the current WindowCoordinates:
1263                  //                  Envelope oldMapWindow = tranformGeoToWindow(oldMapArea.getMinX(),
1264                  // case Select:                                  oldMapArea.getMinY(), oldMapArea.getMaxX(), oldMapArea
1265                  // doSelection(mapX, mapY, selectionLayer);                                                  .getMaxY(), null);
                 //  
                 // return;  
1266    
1267                  default:                  int xx1 = (int) Math.round(oldMapWindow.getMinX());
1268                          return;                  int yy1 = (int) Math.round(oldMapWindow.getMinY());
1269                  }                  int xx2 = (int) Math.round(oldMapWindow.getMaxX());
1270                    int yy2 = (int) Math.round(oldMapWindow.getMaxY());
1271    
1272                  final Coordinate ll = new Coordinate(mapX - (width2 / zlevel), mapY                  graphics.drawImage(getPreFinalImage(), xx1, yy1, xx2, yy2,
1273                                  - (height2 / zlevel));                                  (int) visibleArea.getMinX(), (int) visibleArea.getMinY(),
1274                  final Coordinate ur = new Coordinate(mapX + (width2 / zlevel), mapY                                  (int) visibleArea.getMaxX(), (int) visibleArea.getMaxY(),
1275                                  + (height2 / zlevel));                                  getMapBackgroundColor(), null);
1276                  // xulu.sc SK: Check for min/max scale                  
                 // mapArea = new Envelope(ll, ur);  
                 final Envelope newMapArea = new Envelope(ll, ur);  
                 setMapArea(bestAllowedMapArea(newMapArea));  
                 // xulu.ec  
1277    
1278                  // sk.ec                  Rectangle painedArea = new Rectangle(xx1, yy1, xx2 - xx1, yy2 - yy1);
1279    
1280                  // System.out.println("after area "+mapArea+"\nw:"+mapArea.getWidth()+"                  SwingUtil.clearAround(graphics, painedArea, visibleArea);
1281                  // h:"+mapArea.getHeight());                  
1282                  repaint();                  addGadgets(graphics);
1283          }  //              graphics.drawImage(getGadgetsImage(), 0,0, (int) visibleArea.getMaxX(), (int) visibleArea.getMaxY(),null);
1284    
1285          public void mouseEntered(final MouseEvent e) {                  quickPreviewHint = 0;
         }  
1286    
1287          public void mouseExited(final MouseEvent e) {                  graphics.dispose();
1288                    // Something has been drawn
1289                    return true;
1290          }          }
1291            
1292            final static Font waitFont = new Font("Arial", Font.BOLD, 30);
1293    
1294            /**
1295             * Paints some optinal stuff into the given {@link Graphics2D}. Usually called as the last paint on the mapImage.
1296             */
1297            private void addGadgets(Graphics2D graphics) {
1298    
1299          public void mousePressed(final MouseEvent e) {                  if (mapImage != null)
1300                  startX = e.getX();                          graphics.drawImage(mapImage,
1301                  startY = e.getY();                                          getBounds().width - mapImage.getWidth() - 10,
1302                  lastX = 0;                                          getBounds().height - mapImage.getHeight() - 10, this);
1303                  lastY = 0;  
1304                    // If still rendering, paint a gray shadow or so...
1305                    if (bgExecuter != null && bgExecuter.isRunning()
1306                                    || localExecuter != null && localExecuter.isRunning()) {
1307                            graphics.setColor(Color.BLACK);
1308                            
1309                            graphics.setFont(waitFont);
1310                            graphics.drawString("Wait...", 40, 70);
1311                    }
1312                    
1313          }          }
1314    
1315          public void mouseReleased(final MouseEvent e) {          /**
1316                  final int endX = e.getX();           * Accumulates all three images
1317                  final int endY = e.getY();           *
1318             * @return
1319             */
1320            synchronized protected BufferedImage updateFinalImage() {
1321    
1322                  processDrag(startX, startY, endX, endY, e);                  final Graphics2D finalG = (Graphics2D) getFinalImage().getGraphics();
1323                  lastX = 0;                  finalG.setBackground(getMapBackgroundColor());
1324                  lastY = 0;                  
1325                    
1326                    // Render the two map images first, into the preFinalImage
1327                    {
1328                            final Graphics2D preFinalG = (Graphics2D) getPreFinalImage().getGraphics();
1329                            preFinalG.setBackground(getMapBackgroundColor());
1330                            
1331                            preFinalG.drawImage(getBgImage(), 0, 0,
1332                                            getMapBackgroundColor(), null);
1333                            // // Draw the local layers image
1334                            preFinalG.drawImage(getLocalImage(), 0, 0, null);
1335                            preFinalG.dispose();
1336                    }
1337                    
1338                    finalG.drawImage(getPreFinalImage(), imageOrigin.x, imageOrigin.y,
1339                                    getMapBackgroundColor(), null);
1340    
1341                  /**                  // System.out.println(new Date().getTime() - startTime +
1342                   * Es wird nicht (mehr) gepannt!                  // "ms for update");
1343                   */                  //
1344                  panning_started = false;                  // if (finalImageFrame == null) {
1345          }                  // finalImageFrame = new JFrame();
1346                    // finalImageFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
1347                    // SwingUtil.setRelativeFramePosition(finalImageFrame, 0, 0);
1348                    // }
1349                    // finalImageFrame.setContentPane(new JLabel(new
1350                    // ImageIcon(finalImage)));
1351                    // finalImageFrame.pack();
1352                    // finalImageFrame.setVisible(true);
1353    
1354          public void mouseDragged(final MouseEvent e) {                  final int finalImageHeight = getFinalImage().getHeight(null);
1355                  final Graphics graphics = this.getGraphics();                  final int finalImageWidth = getFinalImage().getWidth(null);
                 final int x = e.getX();  
                 final int y = e.getY();  
   
                 if ((state == JMapPane.Pan)  
                                 || ((e.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) {  
                         /**  
                          * SK: Der Cursor wird auf PANNING gesetzt.  
                          */  
                         if (panning_started == false) {  
                                 panning_started = true;  
                                 setCursor(SwingUtil.PANNING_CURSOR);  
                         }  
1356    
1357                          // move the image with the mouse                  Rectangle painedArea = new Rectangle(imageOrigin.x, imageOrigin.y,
1358                          if ((lastX > 0) && (lastY > 0)) {                                  finalImageWidth, finalImageHeight);
1359                                  final int dx = lastX - startX;                  SwingUtil.clearAround(finalG, painedArea, getVisibleRect());
                                 final int dy = lastY - startY;  
                                 // System.out.println("translate "+dx+","+dy);  
                                 final Graphics2D g2 = panningImage.createGraphics();  
                                 g2.setBackground(getMapBackgroundColor());  
1360    
1361                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());                  addGadgets(finalG);
1362                                  g2.drawImage(baseImage, dx, dy, this);  //              finalG.drawImage(getGadgetsImage(), 0, 0, null);
1363                                  graphics.drawImage(panningImage, 0, 0, this);  
1364                          }                  finalG.dispose();
1365    
1366                    return finalImage;
1367            }
1368    
1369                          lastX = x;          /*
1370                          lastY = y;           * Set alpha composite. For example, pass in 1.0f to have 100% opacity pass
1371                  } else           * in 0.25f to have 25% opacity.
1372             */
1373            private AlphaComposite makeComposite(float alpha) {
1374                    int type = AlphaComposite.SRC_OVER;
1375                    return (AlphaComposite.getInstance(type, alpha));
1376            }
1377    
1378                  if ((state == JMapPane.ZoomIn) || (state == JMapPane.ZoomOut)) {          private Image getFinalImage() {
1379    
1380                          graphics.setXORMode(Color.WHITE);                  if (finalImage == null) {
1381                            finalImage = null;
1382                            Rectangle curPaintArea = getVisibleRect();
1383                            finalImage = new BufferedImage(curPaintArea.width,
1384                                            curPaintArea.height, BufferedImage.TYPE_INT_RGB);
1385    
1386                          if ((lastX > 0) && (lastY > 0)) {                          requestStartRendering();
1387                                  drawRectangle(graphics);                  }
1388                          }                  return finalImage;
1389            }
1390            
1391            private Image getPreFinalImage() {
1392                    
1393                    if (preFinalImage == null) {
1394                            preFinalImage = null;
1395                            Rectangle curPaintArea = getVisibleRect();
1396    
1397                          // draw new box                          preFinalImage = new BufferedImage(curPaintArea.width,
1398                          lastX = x;                                          curPaintArea.height, BufferedImage.TYPE_INT_RGB);
1399                          lastY = y;                          
1400                          drawRectangle(graphics);                          requestStartRendering();
1401                  }                  }
1402                  // else if (state == JMapPane.Select && selectionLayer != null) {                  return preFinalImage;
1403            }
1404    
1405            /**
1406             * While dragging, the {@link #updateFinalImage()} method is translating the
1407             * cached images while setting it together.
1408             **/
1409            Point imageOrigin = new Point(0, 0);
1410    
1411            /**
1412             * Starts rendering on one or two threads
1413             */
1414            private void startRendering() {
1415    
1416                    if (!isWellDefined())
1417                            return;
1418    
1419                    if (bgExecuter != null)
1420                            // Stop all renderers
1421                            bgExecuter.cancelTask();
1422    
1423                    if (localExecuter != null)
1424                            localExecuter.cancelTask();
1425                  //                  //
                 // // construct a new bbox filter  
                 // final Rectangle bounds = this.getBounds();  
1426                  //                  //
1427                  // final double mapWidth = mapArea.getWidth();                  // LOGGER.debug("stopping any running renderes:");
1428                  // final double mapHeight = mapArea.getHeight();                  // int count = 0;
1429                    // while (bgExecuter.isRunning() || localExecuter.isRunning()) {
1430                    // LOGGER.debug("waiting for threads to stop");
1431                  //                  //
1432                  // final double x1 = ((this.startX * mapWidth) / (double) bounds.width)                  // bgExecuter.cancelTask();
1433                  // + mapArea.getMinX();                  // localExecuter.cancelTask();
                 // 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);  
1434                  //                  //
1435                  // String name = selectionLayer.getFeatureSource().getSchema()                  // count++;
                 // .getDefaultGeometry().getName();  
1436                  //                  //
1437                  // if (name == "") {                  // try {
1438                  // name = "the_geom";                  // Thread.sleep(100);
1439                    // } catch (InterruptedException e) {
1440                    // LOGGER.error(e);
1441                  // }                  // }
                 // 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); }  
                 // */  
1442                  //                  //
1443                  // // draw new box                  // if (count > 100) {
1444                  // lastX = x;                  // throw new RuntimeException(
1445                  // lastY = y;                  // "Unable to stop rendering thread for 10secs");
                 // drawRectangle(graphics);  
1446                  // }                  // }
1447                    // }
1448                    // LOGGER.debug(" threads stopped after " + count / 10. + "secs");
1449    
1450          }                  Rectangle curPaintArea = getVisibleRect();
1451    
1452          // sk.cs                  // allow a single pixel margin at the right and bottom edges
1453          // private void processDrag(int x1, int y1, int x2, int y2) {                  curPaintArea.width -= 1;
1454          // sk.ce                  curPaintArea.height -= 1;
         protected void processDrag(final int x1, final int y1, final int x2,  
                         final int y2, final MouseEvent e) {  
1455    
1456                  /****                  labelCache.clear();
1457                   * If no layers exist, we ignore the drag.  
1458                    /**
1459                   */                   */
                 if (context.getLayerCount() <= 0) {  
                         return;  
                 }  
1460    
1461                  // System.out.println("processing drag from " + x1 + "," + y1 + " -> "                  /**
1462                  // + x2 + "," + y2);                   * We have to set new renderer
1463                  if ((x1 == x2) && (y1 == y2)) {                   */
                         if (isClickable()) {  
                                 mouseClicked(new MouseEvent(this, 0, new Date().getTime(), 0,  
                                                 x1, y1, y2, false));  
                         }  
1464    
1465                          return;                  if (getBgContext() != null) {
1466                            bgExecuter = new skrueger.geotools.RenderingExecutor(this);
1467                            LOGGER.debug("starting bg renderer:");
1468                            // /* System.out.println("rendering"); */
1469                            final GTRenderer createGTRenderer = GTUtil.createGTRenderer(
1470                                            localContext, getRendererHints());
1471                            createGTRenderer.setJava2DHints(getJava2dHints());
1472                            bgExecuter.submit(getBgContext().getAreaOfInterest(), curPaintArea,
1473                                            (Graphics2D) getBgImage().getGraphics(), createGTRenderer);
1474                  }                  }
1475    
1476                  final Rectangle bounds = this.getBounds();                  if (getContext() != null) {
1477                            localExecuter = new skrueger.geotools.RenderingExecutor(this);
1478                  final double mapWidth = mapArea.getWidth();                          LOGGER.debug("starting local renderer:");
1479                  final double mapHeight = mapArea.getHeight();                          final GTRenderer createGTRenderer = GTUtil.createGTRenderer(
1480                                            localContext, getRendererHints());
1481                            createGTRenderer.setJava2DHints(getJava2dHints());
1482                            localExecuter.submit(getContext().getAreaOfInterest(),
1483                                            curPaintArea, (Graphics2D) getLocalImage().getGraphics(),
1484                                            createGTRenderer);
1485                    }
1486    
1487                  final double startX = ((x1 * mapWidth) / (double) bounds.width)                  updateCursorAndRepaintTimer();
                                 + 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;  
                         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  
1488    
1489                          drawRectangle(this.getGraphics());                  // start regular repaints until all renderers are done.
1490                          // make the dragged rectangle (in map coords) the new BBOX                  repainterTimer.setRepeats(true);
1491                          final double left = Math.min(startX, endX);                  repainterTimer.restart();
                         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)));  
   
                 } 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(); }  
                 // */  
                 // }  
1492    
                 // xulu.so  
                 // setMapArea(mapArea);  
                 // xulu.eo  
                 repaint();  
1493          }          }
1494    
1495          private boolean isClickable() {          /**
1496                  return clickable;           * Lazyly initializes a {@link BufferedImage} for the background renderer.
1497          }           */
1498            private BufferedImage getBgImage() {
1499    
1500          public void propertyChange(final PropertyChangeEvent evt) {                  if (bgImage == null) {
1501                  final String prop = evt.getPropertyName();                          LOGGER.debug("creating a new background image");
1502    
1503                  if (prop.equalsIgnoreCase("crs")) {                          Rectangle curPaintArea = getVisibleRect();
1504                          context.setAreaOfInterest(context.getAreaOfInterest(),                          // allow a single pixel margin at the right and bottom edges
1505                                          (CoordinateReferenceSystem) evt.getNewValue());                          curPaintArea.width -= 1;
1506                            curPaintArea.height -= 1;
1507    
1508                            bgImage = new BufferedImage(curPaintArea.width + 1,
1509                                            curPaintArea.height + 1, BufferedImage.TYPE_INT_ARGB);
1510                  }                  }
         }  
1511    
1512          public boolean isReset() {                  return bgImage;
                 return reset;  
1513          }          }
1514    
1515          public void setReset(final boolean reset) {          /** An (transparent) image to paint over the map in the lower right corner **/
1516                  this.reset = reset;          private BufferedImage mapImage = null;
         }  
1517    
1518          public void layerAdded(final MapLayerListEvent event) {          private boolean acceptsRepaintCalls = true;
                 changed = true;  
1519    
1520                  if (context.getLayers().length == 1) { // the first one          /**
1521             * Get the BufferedImage to use as a flaoting icon in the lower right
1522             * corner.
1523             *
1524             * @return <code>null</code> if the feature is deactivated.
1525             */
1526            public BufferedImage getMapImage() {
1527                    return mapImage;
1528            }
1529    
1530                          try {          /**
1531                                  // xulu.sc           * Set the BufferedImage to use as a flaoting icon in the lower right corner
1532                                  // mapArea = context.getLayerBounds();           *
1533                                  mapArea = context.getAreaOfInterest();           * @param mapImageIcon
1534                                  if (mapArea == null)           *            <code>null</code> is allowed and deactivates this icon.
1535                                          mapArea = context.getLayerBounds();           */
1536                                  // xulu.ec          public void setMapImage(BufferedImage mapImage) {
1537                          } catch (final IOException e) {                  this.mapImage = mapImage;
1538                                  LOGGER.error(e);  //              gadgetsImage = null;
1539                          }          }
1540    
1541                          reset = true;          /**
1542                  }           * Lazyly initializes a {@link BufferedImage} for the background renderer.
1543             */
1544            private BufferedImage getLocalImage() {
1545    
1546                    if (localImage == null) {
1547                            LOGGER.debug("creating a new local image");
1548    
1549                            Rectangle curPaintArea = getVisibleRect();
1550                            // allow a single pixel margin at the right and bottom edges
1551                            curPaintArea.width -= 1;
1552                            curPaintArea.height -= 1;
1553    
1554                            localImage = new BufferedImage(curPaintArea.width + 1,
1555                                            curPaintArea.height + 1, BufferedImage.TYPE_INT_ARGB);
1556                    }
1557    
1558                    return localImage;
1559            }
1560    //
1561    //      /**
1562    //       * Lazyly initializes a {@link BufferedImage} for the background renderer.
1563    //       */
1564    //      private BufferedImage getGadgetsImage() {
1565    //
1566    //              if (gadgetsImage == null) {
1567    //                      LOGGER.debug("creating a new gadgets image");
1568    //
1569    //                      Rectangle curPaintArea = getVisibleRect();
1570    //                      // allow a single pixel margin at the right and bottom edges
1571    //                      curPaintArea.width -= 1;
1572    //                      curPaintArea.height -= 1;
1573    //
1574    //                      gadgetsImage = new BufferedImage(curPaintArea.width + 1,
1575    //                                      curPaintArea.height + 1, BufferedImage.TYPE_INT_ARGB);
1576    //
1577    //                      if (mapImage != null)
1578    //                              gadgetsImage.getGraphics().drawImage(mapImage,
1579    //                                              curPaintArea.width - mapImage.getWidth() - 10,
1580    //                                              curPaintArea.height - mapImage.getHeight() - 10, this);
1581    //                      
1582    //              }
1583    //
1584    //              return gadgetsImage;
1585    //      }
1586    
1587            /**
1588             * Called by the {@linkplain XMapPane.RenderingTask} when rendering has been
1589             * completed Publishes a {@linkplain MapPaneEvent} of type {@code
1590             * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
1591             *
1592             * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
1593             */
1594            public void onRenderingCompleted() {
1595                    System.out.println("onRenderingCompleted");
1596    
1597                  repaint();                  updateFinalImage();
         }  
1598    
         public void layerRemoved(final MapLayerListEvent event) {  
                 changed = true;  
1599                  repaint();                  repaint();
1600    
1601          }          }
1602    
1603          public void layerChanged(final MapLayerListEvent event) {          /**
1604                  changed = true;           * Called by the {@linkplain XMapPane.RenderingTask} when rendering was
1605                  // System.out.println("layer changed - repaint");           * cancelled. Publishes a {@linkplain MapPaneEvent} of type {@code
1606                  repaint();           * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
1607             *
1608             * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
1609             */
1610            public void onRenderingCancelled() {
1611                    LOGGER.debug("Rendering cancelled");
1612          }          }
1613    
1614          public void layerMoved(final MapLayerListEvent event) {          /**
1615                  changed = true;           * Called by the {@linkplain XMapPane.RenderingTask} when rendering failed.
1616             * Publishes a {@linkplain MapPaneEvent} of type {@code
1617             * MapPaneEvent.Type.RENDERING_STOPPED} to listeners.
1618             *
1619             * @param renderingError
1620             *            The error that occured during rendering
1621             *
1622             * @see MapPaneListener#onRenderingStopped(org.geotools.swing.event.MapPaneEvent)
1623             */
1624            public void onRenderingFailed(Exception renderingError) {
1625                    // MapPaneEvent ev = new MapPaneEvent(this,
1626                    // MapPaneEvent.Type.RENDERING_STOPPED);
1627                    // publishEvent(ev);
1628                    LOGGER.warn("Rendering failed", renderingError);
1629                    updateFinalImage();
1630                  repaint();                  repaint();
         }  
1631    
         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);  
1632          }          }
1633    
1634          /**          /**
1635           * if clickable is set to true then a single click on the map pane will zoom           * Called when a rendering request has been rejected. This will be common,
1636           * or pan the map.           * such as when the user pauses during drag-resizing fo the map pane. The
1637           *           * base implementation does nothing. It is provided for sub-classes to
1638           * @param clickable           * override if required.
1639           */           */
1640          public void setClickable(final boolean clickable) {          public void onRenderingRejected() {
1641                  this.clickable = clickable;                  LOGGER.warn("Rendering rejected");
1642                    repaint();
1643          }          }
1644    
1645          public void mouseMoved(final MouseEvent e) {          @Override
1646            public void propertyChange(final PropertyChangeEvent evt) {
1647                    final String prop = evt.getPropertyName();
1648    
1649                    if (prop.equalsIgnoreCase("crs")) {
1650                            localContext.setAreaOfInterest(localContext.getAreaOfInterest(),
1651                                            (CoordinateReferenceSystem) evt.getNewValue());
1652                    }
1653          }          }
1654    
1655          // xulu.sn          // xulu.sn
# Line 809  public class JMapPane extends JPanel imp Line 1668  public class JMapPane extends JPanel imp
1668                  if (getWidth() == 0)                  if (getWidth() == 0)
1669                          return env;                          return env;
1670                  if (env == null)                  if (env == null)
1671                          return env;                          return null;
1672    
1673                  Envelope newArea = null;                  Envelope newArea = null;
1674    
# Line 818  public class JMapPane extends JPanel imp Line 1677  public class JMapPane extends JPanel imp
1677                   * easily fail. We allow to grow here, because we don't check against                   * easily fail. We allow to grow here, because we don't check against
1678                   * the maxExtend                   * the maxExtend
1679                   */                   */
1680                  env = JTSUtil.fixAspectRatio(this.getBounds(), env, true);                  Rectangle curPaintArea = getVisibleRect();
1681    
1682                    env = JTSUtil.fixAspectRatio(curPaintArea, env, true);
1683    
1684                  final double scale = env.getWidth() / getWidth();                  final double scale = env.getWidth() / getWidth();
1685                  final double centerX = env.getMinX() + env.getWidth() / 2.;                  final double centerX = env.getMinX() + env.getWidth() / 2.;
# Line 1039  public class JMapPane extends JPanel imp Line 1900  public class JMapPane extends JPanel imp
1900    
1901          public Envelope getMaxExtend() {          public Envelope getMaxExtend() {
1902                  if (maxExtend == null) {                  if (maxExtend == null) {
1903                          try {                          final ReferencedEnvelope layerBounds = GTUtil
1904                                  return JTSUtil.fixAspectRatio(this.getBounds(),                                          .getVisibleLayoutBounds(localContext);
1905                                                  // Kartenbereich um 10% vergroessern                          if (layerBounds == null) {
1906                                                  JTSUtil.expandEnvelope(context.getLayerBounds(), 0.1),                                  // TODO Last fallback could be the CRS valid area
1907                                                  true);                                  return null;
                         } catch (IOException e) {  
                                 LOGGER  
                                                 .warn(  
                                                                 "maxExtend == null; failed to getLayerBounds of context",  
                                                                 e);  
1908                          }                          }
1909    
1910                            // Kartenbereich um 10% vergroessern
1911                            return JTSUtil.fixAspectRatio(this.getBounds(), JTSUtil
1912                                            .expandEnvelope(layerBounds, 0.1), true);
1913                  }                  }
1914                  return maxExtend;                  return maxExtend;
1915          }          }
1916    
1917          /**          /**
1918           * Set the background color of the map.           * Set the background color of the map.
1919             *
1920           * @param if <code>null</code>, white is used.           * @param if <code>null</code>, white is used.
1921           */           */
1922          public void setMapBackgroundColor(Color bgColor) {          public void setMapBackgroundColor(Color bgColor) {
1923                  if (bgColor == null) bgColor = Color.WHITE;                  if (bgColor == null)
1924                            bgColor = Color.WHITE;
1925                  this.mapBackgroundColor = bgColor;                  this.mapBackgroundColor = bgColor;
1926          }          }
1927    
1928          /**          /**
1929           * Returns the background {@link Color} of the map pane. Default is white.           * Returns the background {@link Color} of the map pane. Default is white.
1930          **/           **/
1931          public Color getMapBackgroundColor() {          public Color getMapBackgroundColor() {
1932                  return mapBackgroundColor;                  return mapBackgroundColor;
1933          }          }
1934    
1935            /**
1936             *
1937             * @param b
1938             */
1939            public void setPainting(boolean b) {
1940                    acceptsRepaintCalls = b;
1941            }
1942    
1943            /**
1944             * Fuegt der Map einen Listener hinzu.
1945             *
1946             * @param l
1947             *            neuer Listener
1948             */
1949            public void addMapPaneListener(JMapPaneListener l) {
1950                    mapPaneListeners.add(l);
1951            }
1952    
1953            /**
1954             * Liste der angeschlossenen Listener, die auf Aktionen des MapPanes
1955             * lauschen.
1956             */
1957            protected Vector<JMapPaneListener> mapPaneListeners = new Vector<JMapPaneListener>();
1958    
1959            /**
1960             * A flag indicating if dispose() was already called. If true, then further
1961             * use of this {@link SelectableXMapPane} is undefined.
1962             */
1963            private boolean disposed = false;
1964    
1965            /**
1966             * Entfernt einen Listener von der Map.
1967             *
1968             * @param l
1969             *            zu entfernender Listener
1970             */
1971            public void removeMapPaneListener(JMapPaneListener l) {
1972                    mapPaneListeners.remove(l);
1973            }
1974    
1975            /** Stored the time used for the last real rendering in ms. **/
1976            private long lastRenderingDuration = Long.MAX_VALUE;
1977    
1978            // if null, no quick preview will be shown
1979            private int quickPreviewHint = 0;
1980    
1981            /**
1982             * For every rendering thread started,
1983             * {@link GTUtil#createGTRenderer(MapContext)} is called to create a new
1984             * renderer. These Java2D rendering hints are passed to the
1985             * {@link GTRenderer}. The java2dHints are the same for all renderers (bg
1986             * and local).
1987             */
1988            private RenderingHints java2dHints;
1989    
1990            /**
1991             * Returns in milli seconds the time the last rending of the
1992             * {@link SelectableXMapPane} took. #Long.MAX_VALUE if the JMapPane has not
1993             * been rendered yet.
1994             */
1995            public long getLastRenderingDuration() {
1996                    return lastRenderingDuration;
1997            }
1998    
1999            /**
2000             * Should be called when the {@link JMapPane} is not needed no more to help
2001             * the GarbageCollector
2002             *
2003             * Removes all {@link JMapPaneListener}s that are registered
2004             *
2005             * @author <a href="mailto:[email protected]">Stefan Alfons
2006             *         Kr&uuml;ger</a>
2007             */
2008            public void dispose() {
2009                    if (isDisposed())
2010                            return;
2011    
2012                    disposed = true;
2013    
2014                    if (bgExecuter != null) {
2015                            bgExecuter.cancelTask();
2016                    }
2017    
2018                    if (localExecuter != null) {
2019                            localExecuter.cancelTask();
2020                    }
2021    
2022                    startRenderThreadsTimer.stop();
2023                    repainterTimer.stop();
2024    
2025                    if (bgImage != null)
2026                            bgImage.flush();
2027                    if (localImage != null)
2028                            localImage.flush();
2029    //              if (gadgetsImage != null)
2030    //                      gadgetsImage.flush();
2031                    if (finalImage != null)
2032                            finalImage.flush();
2033                    if (preFinalImage != null)
2034                            preFinalImage.flush();
2035    
2036                    // if (dragWaitCursorListener != null)
2037                    // this.removeMouseListener(dragWaitCursorListener);
2038                    // if (mouseWheelZoomListener != null)
2039                    // this.removeMouseWheelListener(mouseWheelZoomListener);
2040    
2041                    // Alle mapPaneListener entfernen
2042                    mapPaneListeners.clear();
2043    
2044                    removeMouseMotionListener(zoomMapPaneMouseListener);
2045                    removeMouseListener(zoomMapPaneMouseListener);
2046    
2047                    if (localContext != null)
2048                            getContext().clearLayerList();
2049                    if (bgContext != null)
2050                            getBgContext().clearLayerList();
2051    
2052                    removeAll();
2053            }
2054    
2055            /**
2056             * A flag indicating if dispose() has already been called. If true, then
2057             * further use of this {@link SelectableXMapPane} is undefined.
2058             */
2059            private boolean isDisposed() {
2060                    return disposed;
2061            }
2062    
2063            public void setQuickPreviewHint(int quickPreviewHint) {
2064                    this.quickPreviewHint = quickPreviewHint;
2065    
2066            }
2067    
2068            public void setJava2dHints(RenderingHints java2dHints) {
2069                    this.java2dHints = java2dHints;
2070            }
2071    
2072            public RenderingHints getJava2dHints() {
2073                    return java2dHints;
2074            }
2075    
2076            /**
2077             * Zooms towards a point.
2078             *
2079             * @param center
2080             *            position in window coordinates
2081             * @param zoomFaktor
2082             *            > 1 for zoom in, < 1 for zoom out. Default is 1.33.
2083             */
2084            public void zoomTo(Point center, Double zoomFaktor) {
2085                    if (zoomFaktor == null || zoomFaktor == 0.)
2086                            zoomFaktor = 2.;
2087    
2088                    Point2D gcenter = getScreenToWorld().transform(center, null);
2089                    center = null;
2090                    
2091                    if (
2092                                    Double.isNaN(gcenter.getX()) || Double.isNaN(gcenter.getY())
2093                                    ||
2094                                    Double.isInfinite(gcenter.getX()) || Double.isInfinite(gcenter.getY())
2095                                    
2096                    ) {
2097                            // Not inside valid CRS area! cancel
2098                            return;
2099                    }
2100    
2101                    final Envelope mapArea = getMapArea();
2102                    
2103                    Envelope newMapArea = new Envelope(mapArea);
2104                    newMapArea
2105                                    .expandBy((mapArea.getWidth() * zoomFaktor - mapArea
2106                                                    .getWidth()) / 2., (mapArea.getHeight()
2107                                                    * zoomFaktor - mapArea.getHeight()) / 2.);
2108    
2109                    // Move the newMapArea above the new center
2110                    newMapArea.translate(gcenter.getX() - mapArea.centre().x, gcenter.getY()
2111                                    - mapArea.centre().y);
2112    
2113                    setMapArea(newMapArea);
2114            }
2115    
2116            /**
2117             * Zooms towards a point.
2118             *
2119             * @param center
2120             *            position in window coordinates
2121             * @param zoomFactor
2122             *            > 1 for zoom in, < 1 for zoom out. Default is 1.33
2123             */
2124            public void zoomTo(Point center) {
2125                    zoomTo(center, null);
2126            }
2127    
2128            public void mouseDragged(Point startPos, Point lastPos, MouseEvent event) {
2129    
2130                    if ((getState() == XMapPane.PAN)
2131                                    || ((event.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) {
2132    
2133                            if (getCursor() != SwingUtil.PANNING_CURSOR) {
2134                                    setCursor(SwingUtil.PANNING_CURSOR);
2135    
2136                                    // While panning, we deactivate the rendering. So the tasts are
2137                                    // ready to start when the panning os done.
2138                                    if (bgExecuter != null)
2139                                            bgExecuter.cancelTask();
2140                                    if (localExecuter != null)
2141                                            localExecuter.cancelTask();
2142                            }
2143    
2144                            if (lastPos.x > 0 && lastPos.y > 0) {
2145                                    final int dx = event.getX() - lastPos.x;
2146                                    final int dy = event.getY() - lastPos.y;
2147    
2148                                    // TODO Stop dragging when the drag would not be valid...
2149                                    // boolean dragValid = true;
2150                                    // // check if this panning results in a valid mapArea
2151                                    // {
2152                                    // Rectangle winBounds = xMapPane.getBounds();
2153                                    // winBounds.translate(xMapPane.imageOrigin.x,
2154                                    // -xMapPane.imageOrigin.y);
2155                                    // Envelope newMapAreaBefore = xMapPane.tranformWindowToGeo(
2156                                    // winBounds.x, winBounds.y, winBounds.x
2157                                    // + winBounds.width, winBounds.y
2158                                    // + winBounds.height);
2159                                    //                                      
2160                                    //
2161                                    // winBounds = xMapPane.getBounds();
2162                                    // Point testIng = new Point(xMapPane.imageOrigin);
2163                                    // testIng.translate(dx, dy);
2164                                    // winBounds.translate(testIng.x, -testIng.y);
2165                                    // Envelope newMapAreaAfter = xMapPane.tranformWindowToGeo(
2166                                    // winBounds.x, winBounds.y, winBounds.x
2167                                    // + winBounds.width, winBounds.y
2168                                    // + winBounds.height);
2169                                    //
2170                                    // // If the last drag doesn't change the MapArea anymore cancel
2171                                    // it.
2172                                    // if (xMapPane.bestAllowedMapArea(newMapAreaAfter).equals(
2173                                    // xMapPane.bestAllowedMapArea(newMapAreaBefore))){
2174                                    // dragValid = false;
2175                                    // return;
2176                                    // }
2177                                    // }
2178    
2179                                    imageOrigin.translate(dx, dy);
2180                                    updateFinalImage();
2181                                    repaint();
2182                            }
2183    
2184                    } else if ((getState() == XMapPane.ZOOM_IN)
2185                                    || (getState() == XMapPane.ZOOM_OUT)
2186                                    || (getState() == XMapPane.SELECT_ALL)
2187                                    || (getState() == XMapPane.SELECT_TOP)
2188                    // || (getState() == XMapPane.SELECT_ONE_FROM_TOP)
2189                    ) {
2190                            final Graphics graphics = getGraphics();
2191    
2192                            drawRectangle(graphics, startPos, event.getPoint());
2193    
2194                            if ((lastPos.x > 0) && (lastPos.y > 0)) {
2195                                    drawRectangle(graphics, startPos, lastPos);
2196                            }
2197    
2198                    }
2199    
2200            }
2201    
2202            /**
2203             * Draws a rectangle in XOR mode from the origin at {@link #startPos} to the
2204             * given point. All in screen coordinates.
2205             */
2206            protected void drawRectangle(final Graphics graphics, Point startPos,
2207                            Point e) {
2208                    // undraw last box/draw new box
2209                    final int left = Math.min(startPos.x, e.x);
2210                    final int right = Math.max(startPos.x, e.x);
2211                    final int top = Math.max(startPos.y, e.y);
2212                    final int bottom = Math.min(startPos.y, e.y);
2213                    final int width = right - left;
2214                    final int height = top - bottom;
2215    
2216                    if (width == 0 && height == 0)
2217                            return;
2218    
2219                    graphics.setXORMode(Color.WHITE);
2220                    graphics.drawRect(left, bottom, width, height);
2221            }
2222    
2223            /**
2224             * Finalizes a PAN action
2225             */
2226            public void performPan() {
2227                    Rectangle winBounds = getBounds();
2228                    winBounds.translate(-imageOrigin.x, -imageOrigin.y);
2229                    Envelope newMapArea = tranformWindowToGeo(winBounds.x, winBounds.y,
2230                                    winBounds.x + winBounds.width, winBounds.y + winBounds.height);
2231    
2232                    imageOrigin.x = 0;
2233                    imageOrigin.y = 0;
2234    
2235                    if (!setMapArea(newMapArea)){
2236                            updateFinalImage();
2237                            repaint();
2238                    }
2239    
2240                    if (getCursor() == SwingUtil.PANNING_CURSOR)
2241                            setCursor(SwingUtil.PAN_CURSOR);
2242            }
2243    
2244  }  }
Legend:
Removed from v.506  
changed lines
  Added in v.511
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26