/[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/org/geotools/gui/swing/JMapPane.java revision 348 by alfonx, Mon Aug 31 12:06:30 2009 UTC branches/1.0-gt2-2.6/src/gtmig/org/geotools/swing/JMapPane.java revision 505 by alfonx, Sat Oct 31 10:53:43 2009 UTC
# Line 13  Line 13 
13   *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU   *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14   *    Lesser General Public License for more details.   *    Lesser General Public License for more details.
15   */   */
16  package org.geotools.gui.swing;  package gtmig.org.geotools.swing;
17    
18  /**  /**
19   * <b>Xulu:<br>   * <b>Xulu:<br>
# Line 43  import java.awt.Graphics; Line 43  import java.awt.Graphics;
43  import java.awt.Graphics2D;  import java.awt.Graphics2D;
44  import java.awt.LayoutManager;  import java.awt.LayoutManager;
45  import java.awt.Rectangle;  import java.awt.Rectangle;
46    import java.awt.RenderingHints;
47  import java.awt.event.InputEvent;  import java.awt.event.InputEvent;
48  import java.awt.event.MouseEvent;  import java.awt.event.MouseEvent;
49  import java.awt.event.MouseListener;  import java.awt.event.MouseListener;
50  import java.awt.event.MouseMotionListener;  import java.awt.event.MouseMotionListener;
51    import java.awt.geom.AffineTransform;
52  import java.awt.image.BufferedImage;  import java.awt.image.BufferedImage;
53  import java.beans.PropertyChangeEvent;  import java.beans.PropertyChangeEvent;
54  import java.beans.PropertyChangeListener;  import java.beans.PropertyChangeListener;
# Line 65  import org.geotools.renderer.GTRenderer; Line 67  import org.geotools.renderer.GTRenderer;
67  import org.geotools.renderer.label.LabelCacheImpl;  import org.geotools.renderer.label.LabelCacheImpl;
68  import org.geotools.renderer.lite.LabelCache;  import org.geotools.renderer.lite.LabelCache;
69  import org.geotools.renderer.lite.StreamingRenderer;  import org.geotools.renderer.lite.StreamingRenderer;
 import org.geotools.renderer.shape.ShapefileRenderer;  
 import org.geotools.styling.Graphic;  
 import org.geotools.styling.LineSymbolizer;  
 import org.geotools.styling.Mark;  
 import org.geotools.styling.PointSymbolizer;  
 import org.geotools.styling.PolygonSymbolizer;  
 import org.geotools.styling.StyleBuilder;  
 import org.geotools.styling.StyleFactory;  
70  import org.opengis.filter.FilterFactory2;  import org.opengis.filter.FilterFactory2;
71  import org.opengis.referencing.crs.CoordinateReferenceSystem;  import org.opengis.referencing.crs.CoordinateReferenceSystem;
72    
73    import schmitzm.geotools.JTSUtil;
74  import schmitzm.swing.SwingUtil;  import schmitzm.swing.SwingUtil;
75    
76  import com.vividsolutions.jts.geom.Coordinate;  import com.vividsolutions.jts.geom.Coordinate;
# Line 84  import com.vividsolutions.jts.geom.Geome Line 79  import com.vividsolutions.jts.geom.Geome
79    
80  public class JMapPane extends JPanel implements MouseListener,  public class JMapPane extends JPanel implements MouseListener,
81                  MouseMotionListener, PropertyChangeListener, MapLayerListListener {                  MouseMotionListener, PropertyChangeListener, MapLayerListListener {
82          private static Logger LOGGER = Logger.getLogger(JMapPane.class.getName());          private static Logger LOGGER = Logger.getLogger(JMapPane.class);
83    
84          private static final long serialVersionUID = -8647971481359690499L;          private static final long serialVersionUID = -8647971481359690499L;
85    
# Line 98  public class JMapPane extends JPanel imp Line 93  public class JMapPane extends JPanel imp
93    
94          public static final int Select = 4;          public static final int Select = 4;
95    
         private static final int POLYGON = 0;  
   
         private static final int LINE = 1;  
   
         private static final int POINT = 2;  
   
96          /**          /**
97           * what renders the map           * what renders the map
98           */           */
99          GTRenderer renderer;          GTRenderer renderer;
100    
         private GTRenderer highlightRenderer, selectionRenderer;  
   
101          /**          /**
102           * the map context to render           * the map context to render
103           */           */
104          MapContext context;          MapContext context;
105    
         private MapContext selectionContext;  
   
106          /**          /**
107           * the area of the map to draw           * the area of the map to draw
108           */           */
         // xulu.sc  
         // Envelope mapArea;  
109          protected Envelope mapArea;          protected Envelope mapArea;
         // xulu.ec  
110    
111          /**          /**
112           * the size of the pane last time we drew           * the size of the pane last time we drew
113           */           */
         // xulu.sc  
         // private Rectangle oldRect = null;  
114          protected Rectangle oldRect = null;          protected Rectangle oldRect = null;
         // xulu.ec  
115    
116          /**          /**
117           * the last map area drawn.           * the last map area drawn.
118           */           */
         // xulu.sc  
         // private Envelope oldMapArea = null;  
119          protected Envelope oldMapArea = null;          protected Envelope oldMapArea = null;
         // xulu.ec  
120    
121          /**          /**
122           * the base image of the map           * the base image of the map
123           */           */
124          protected BufferedImage baseImage, panningImage;          protected BufferedImage baseImage, panningImage;
         // SK: private BufferedImage baseImage, panningImage;  
125    
126          /**          /**
127           * a factory for filters           * a factory for filters
# Line 169  public class JMapPane extends JPanel imp Line 144  public class JMapPane extends JPanel imp
144    
145          LabelCache labelCache = new LabelCacheImpl();          LabelCache labelCache = new LabelCacheImpl();
146    
         // xulu.sc  
         // private boolean reset = false;  
147          protected boolean reset = false;          protected boolean reset = false;
         // xulu.ec  
148    
149          int startX;          int startX;
150    
151          int startY;          int startY;
152    
153            /**
154             * If not <code>null</code>, the {@link JMapPane} will not allow to zoom/pan
155             * out of that area
156             **/
157            private Envelope maxExtend = null;
158    
159            // /**
160            // * Is max. 1 or 0 of the 2 axised allowed to extend the maxExtend? If
161            // * <code>true</code> the extends has to be fully inside maxExtend
162            // **/
163            // boolean maxExtendForceMode = true;
164    
165          private boolean clickable;          private boolean clickable;
166    
167          int lastX;          int lastX;
168    
169          int lastY;          int lastY;
170    
         // xulu.sn  
171          private Double maxZoomScale = Double.MIN_VALUE;          private Double maxZoomScale = Double.MIN_VALUE;
172          private Double minZoomScale = Double.MAX_VALUE;          private Double minZoomScale = Double.MAX_VALUE;
         // xulu.en  
173    
         // sk.sn  
174          /**          /**
175           * Wenn true, dann wurde PANNING via mouseDraged-Events begonnen. Dieses           * Wenn true, dann wurde PANNING via mouseDraged-Events begonnen. Dieses
176           * Flag wird benutzt um nur einmal den passenden Cursor nur einmal zu           * Flag wird benutzt um nur einmal den passenden Cursor nur einmal zu
# Line 197  public class JMapPane extends JPanel imp Line 178  public class JMapPane extends JPanel imp
178           */           */
179          private boolean panning_started = false;          private boolean panning_started = false;
180    
181          // sk.en          /**
182             * This color is used as the default background color when painting a map.
183             */
184            private Color mapBackgroundColor = Color.WHITE;
185    
186          public JMapPane() {          public JMapPane() {
187                  this(null, true, null, null);                  this(null, true, null, null);
# Line 250  public class JMapPane extends JPanel imp Line 234  public class JMapPane extends JPanel imp
234          }          }
235    
236          public void setRenderer(final GTRenderer renderer) {          public void setRenderer(final GTRenderer renderer) {
237                  Map<Object,Object> hints = new HashMap<Object,Object>();                  Map<Object, Object> hints = new HashMap<Object, Object>();
                   
                 this.renderer = renderer;  
                   
                 if (renderer instanceof StreamingRenderer || renderer instanceof ShapefileRenderer) {  
                         hints = renderer.getRendererHints();  
                         if (hints == null) {  
                                 hints = new HashMap<Object,Object>();  
                         }  
                         if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {  
                                 labelCache = (LabelCache) hints  
                                                 .get(StreamingRenderer.LABEL_CACHE_KEY);  
                         } else {  
                                 hints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);  
                         }  
238    
239                          hints.put("memoryPreloadingEnabled", Boolean.TRUE);                  this.renderer = renderer;
240                                            // MS: Apply hint also for ShapeFileRenderer
241                          renderer.setRendererHints(hints);                  // if (renderer instanceof StreamingRenderer) {
242                    hints = renderer.getRendererHints();
243                    if (hints == null) {
244                            hints = new HashMap<Object, Object>();
245                    }
246                    if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {
247                            labelCache = (LabelCache) hints
248                                            .get(StreamingRenderer.LABEL_CACHE_KEY);
249                    } else {
250                            hints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);
251                  }                  }
252    
253  //              this.highlightRenderer = new StreamingRenderer();                  hints.put("memoryPreloadingEnabled", Boolean.TRUE);
 //              this.selectionRenderer = new StreamingRenderer();  
254    
255  //              highlightRenderer.setRendererHints(hints);                  renderer.setRendererHints(hints);
256  //              selectionRenderer.setRendererHints(hints);                  // }
                   
 //              renderer.setRendererHints(hints);  
257    
258                  if (this.context != null) {                  if (this.context != null) {
259                          this.renderer.setContext(this.context);                          this.renderer.setContext(this.context);
# Line 330  public class JMapPane extends JPanel imp Line 306  public class JMapPane extends JPanel imp
306                  this.zoomFactor = zoomFactor;                  this.zoomFactor = zoomFactor;
307          }          }
308    
   
309          protected void paintComponent(final Graphics g) {          protected void paintComponent(final Graphics g) {
310                  super.paintComponent(g);                  super.paintComponent(g);
311    
# Line 356  public class JMapPane extends JPanel imp Line 331  public class JMapPane extends JPanel imp
331                                  reset = false; /* forget about the reset */                                  reset = false; /* forget about the reset */
332                                  oldRect = r; /* store what the current size is */                                  oldRect = r; /* store what the current size is */
333    
334                                  mapArea = fixAspectRatio(r, mapArea);                                  mapArea = JTSUtil.fixAspectRatio(r, mapArea, false);
335                          }                          }
336                  }                  }
337    
# Line 369  public class JMapPane extends JPanel imp Line 344  public class JMapPane extends JPanel imp
344                                          .getCoordinateReferenceSystem());                                          .getCoordinateReferenceSystem());
345                  }                  }
346    
347                  if (changed ) { /* if the map changed then redraw */                  if (changed) { /* if the map changed then redraw */
348                          changed = false;                          changed = false;
349                            
350                            // The baseImage should not have alpha
351                          baseImage = new BufferedImage(dr.width, dr.height,                          baseImage = new BufferedImage(dr.width, dr.height,
352                                          BufferedImage.TYPE_INT_ARGB);                                          BufferedImage.TYPE_INT_RGB);
353    
354                          final Graphics2D ig = baseImage.createGraphics();                          final Graphics2D ig = baseImage.createGraphics();
355                          /* System.out.println("rendering"); */                          ig.setBackground(getMapBackgroundColor());
356                          if (renderer.getContext() != null)                          ig.fillRect(0, 0, dr.width, dr.height);
357                            
358    //                      /* System.out.println("rendering"); */
359                            if (renderer.getContext() != null)
360                                  renderer.setContext(context);                                  renderer.setContext(context);
361                          labelCache.clear(); // work around anoying labelcache bug  
362                            // TODO is this clearing still needed? We already replace all that stuff whenever we change the style. Deactivated 31.10.09.. let's see
363    //                      labelCache.clear(); // work around anoying labelcache bug
364    
365                          // draw the map                          // draw the map
366                          renderer.paint((Graphics2D) ig, dr, mapArea);                          renderer.paint(ig, dr, mapArea);
367    
368                          // TODO nur machen, wenn panning beginnt                          // TODO nur machen, wenn panning beginnt
369                          panningImage = new BufferedImage(dr.width, dr.height,                          panningImage = new BufferedImage(dr.width, dr.height,
# Line 392  public class JMapPane extends JPanel imp Line 374  public class JMapPane extends JPanel imp
374                  ((Graphics2D) g).drawImage(baseImage, 0, 0, this);                  ((Graphics2D) g).drawImage(baseImage, 0, 0, this);
375          }          }
376    
         private Envelope fixAspectRatio(final Rectangle r, final Envelope mapArea) {  
   
                 final double mapWidth = mapArea.getWidth(); /* get the extent of the map */  
                 final double mapHeight = mapArea.getHeight();  
                 final double scaleX = r.getWidth() / mapArea.getWidth(); /*  
                                                                                                                          * calculate the new  
                                                                                                                          * scale  
                                                                                                                          */  
   
                 final double scaleY = r.getHeight() / mapArea.getHeight();  
                 double scale = 1.0; // stupid compiler!  
   
                 if (scaleX < scaleY) { /* pick the smaller scale */  
                         scale = scaleX;  
                 } else {  
                         scale = scaleY;  
                 }  
   
                 /* calculate the difference in width and height of the new extent */  
                 final double deltaX = /* Math.abs */((r.getWidth() / scale) - mapWidth);  
                 final double deltaY = /* Math.abs */((r.getHeight() / scale) - mapHeight);  
   
                 /*  
                  * System.out.println("delta x " + deltaX);  
                  * System.out.println("delta y " + deltaY);  
                  */  
   
                 /* create the new extent */  
                 final Coordinate ll = new Coordinate(mapArea.getMinX() - (deltaX / 2.0),  
                                 mapArea.getMinY() - (deltaY / 2.0));  
                 final Coordinate ur = new Coordinate(mapArea.getMaxX() + (deltaX / 2.0),  
                                 mapArea.getMaxY() + (deltaY / 2.0));  
   
                 return new Envelope(ll, ur);  
         }  
   
 //      public void doSelection(final double x, final double y, final MapLayer layer) {  
 //  
 //              final Geometry geometry = gf.createPoint(new Coordinate(x, y));  
 //  
 //              // org.opengis.geometry.Geometry geometry = new Point();  
 //  
 //              findFeature(geometry, layer);  
 //  
 //      }  
 //  
 //      /**  
 //       * @param geometry  
 //       *            - a geometry to construct the filter with  
 //       * @param i  
 //       *            - the index of the layer to search  
 //       * @throws IndexOutOfBoundsException  
 //       */  
 //      private void findFeature(final Geometry geometry, final MapLayer layer)  
 //                      throws IndexOutOfBoundsException {  
 //              org.opengis.filter.spatial.BinarySpatialOperator f = null;  
 //  
 //              if ((context == null) || (layer == null)) {  
 //                      return;  
 //              }  
 //  
 //              try {  
 //                      String name = layer.getFeatureSource().getSchema()  
 //                                      .getDefaultGeometry().getLocalName();  
 //  
 //                      if (name == "") {  
 //                              name = "the_geom";  
 //                      }  
 //  
 //                      try {  
 //                              f = ff.contains(ff.property(name), ff.literal(geometry));  
 //                              if (selectionManager != null) {  
 ////                                    System.out.println("selection changed");  
 //                                      selectionManager.selectionChanged(this, f);  
 //  
 //                              }  
 //                      } catch (final IllegalFilterException e) {  
 //                              // TODO Auto-generated catch block  
 //                              e.printStackTrace();  
 //                      }  
 //  
 //                      /*  
 //                       * // f.addLeftGeometry(ff.property(name)); //  
 //                       * System.out.println("looking with " + f); FeatureCollection fc =  
 //                       * layer.getFeatureSource().getFeatures(f);  
 //                       *  
 //                       *  
 //                       *  
 //                       * if (fcol == null) { fcol = fc;  
 //                       *  
 //                       * // here we should set the defaultgeom type } else {  
 //                       * fcol.addAll(fc); }  
 //                       */  
 //  
 //                      /*  
 //                       * GeometryAttributeType gat =  
 //                       * layer.getFeatureSource().getSchema().getDefaultGeometry();  
 //                       * fcol.setDefaultGeometry((Geometry)gat.createDefaultValue());  
 //                       */  
 //  
 //                      /*  
 //                       * Iterator fi = fc.iterator(); while (fi.hasNext()) { SimpleFeature feat  
 //                       * = (SimpleFeature) fi.next(); System.out.println("selected " +  
 //                       * feat.getAttribute("STATE_NAME")); }  
 //                       */  
 //              } catch (final IllegalFilterException e) {  
 //                      // TODO Auto-generated catch block  
 //                      e.printStackTrace();  
 //              }  
 //              return;  
 //      }  
   
377          public void mouseClicked(final MouseEvent e) {          public void mouseClicked(final MouseEvent e) {
378                  if (mapArea == null) return;                  if (mapArea == null)
379                            return;
380                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"
381                  // h:"+mapArea.getHeight());                  // h:"+mapArea.getHeight());
382                  final Rectangle bounds = this.getBounds();                  final Rectangle bounds = this.getBounds();
# Line 519  public class JMapPane extends JPanel imp Line 390  public class JMapPane extends JPanel imp
390                  final double width2 = width / 2.0;                  final double width2 = width / 2.0;
391                  final double height2 = height / 2.0;                  final double height2 = height / 2.0;
392                  // xulu.ec                  // xulu.ec
393                  final double mapX = ((x * width) / (double) bounds.width) + mapArea.getMinX();                  final double mapX = ((x * width) / (double) bounds.width)
394                                    + mapArea.getMinX();
395                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)
396                                  + mapArea.getMinY();                                  + mapArea.getMinY();
397    
# Line 550  public class JMapPane extends JPanel imp Line 422  public class JMapPane extends JPanel imp
422                          zlevel = 1.0 / zoomFactor;                          zlevel = 1.0 / zoomFactor;
423    
424                          break;                          break;
425  //                  //
426  //              case Select:                  // case Select:
427  //                      doSelection(mapX, mapY, selectionLayer);                  // doSelection(mapX, mapY, selectionLayer);
428  //                  //
429  //                      return;                  // return;
430    
431                  default:                  default:
432                          return;                          return;
# Line 625  public class JMapPane extends JPanel imp Line 497  public class JMapPane extends JPanel imp
497                                  final int dy = lastY - startY;                                  final int dy = lastY - startY;
498                                  // System.out.println("translate "+dx+","+dy);                                  // System.out.println("translate "+dx+","+dy);
499                                  final Graphics2D g2 = panningImage.createGraphics();                                  final Graphics2D g2 = panningImage.createGraphics();
500                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige                                  g2.setBackground(getMapBackgroundColor());
501                                                                                                                          // farbe? am besten  
                                                                                                                         // vom L&F die  
                                                                                                                         // hintergrundfarbe  
                                                                                                                         // auslesen...  
                                   
502                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());
503                                  g2.drawImage(baseImage, dx, dy, this);                                  g2.drawImage(baseImage, dx, dy, this);
504                                  graphics.drawImage(panningImage, 0, 0, this);                                  graphics.drawImage(panningImage, 0, 0, this);
# Line 652  public class JMapPane extends JPanel imp Line 520  public class JMapPane extends JPanel imp
520                          lastX = x;                          lastX = x;
521                          lastY = y;                          lastY = y;
522                          drawRectangle(graphics);                          drawRectangle(graphics);
523                  }                  }
524  //              else if (state == JMapPane.Select && selectionLayer != null) {                  // else if (state == JMapPane.Select && selectionLayer != null) {
525  //                  //
526  //                      // construct a new bbox filter                  // // construct a new bbox filter
527  //                      final Rectangle bounds = this.getBounds();                  // final Rectangle bounds = this.getBounds();
528  //                  //
529  //                      final double mapWidth = mapArea.getWidth();                  // final double mapWidth = mapArea.getWidth();
530  //                      final double mapHeight = mapArea.getHeight();                  // final double mapHeight = mapArea.getHeight();
531  //                  //
532  //                      final double x1 = ((this.startX * mapWidth) / (double) bounds.width)                  // final double x1 = ((this.startX * mapWidth) / (double) bounds.width)
533  //                                      + mapArea.getMinX();                  // + mapArea.getMinX();
534  //                      final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) / (double) bounds.height)                  // final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) /
535  //                                      + mapArea.getMinY();                  // (double) bounds.height)
536  //                      final double x2 = ((x * mapWidth) / (double) bounds.width)                  // + mapArea.getMinY();
537  //                                      + mapArea.getMinX();                  // final double x2 = ((x * mapWidth) / (double) bounds.width)
538  //                      final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double) bounds.height)                  // + mapArea.getMinX();
539  //                                      + mapArea.getMinY();                  // final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double)
540  //                      final double left = Math.min(x1, x2);                  // bounds.height)
541  //                      final double right = Math.max(x1, x2);                  // + mapArea.getMinY();
542  //                      final double bottom = Math.min(y1, y2);                  // final double left = Math.min(x1, x2);
543  //                      final double top = Math.max(y1, y2);                  // final double right = Math.max(x1, x2);
544  //                  // final double bottom = Math.min(y1, y2);
545  //                      String name = selectionLayer.getFeatureSource().getSchema()                  // final double top = Math.max(y1, y2);
546  //                                      .getDefaultGeometry().getName();                  //
547  //                  // String name = selectionLayer.getFeatureSource().getSchema()
548  //                      if (name == "") {                  // .getDefaultGeometry().getName();
549  //                              name = "the_geom";                  //
550  //                      }                  // if (name == "") {
551  //                      final Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,                  // name = "the_geom";
552  //                                      getContext().getCoordinateReferenceSystem().toString());                  // }
553  //                      if (selectionManager != null) {                  // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
554  //                              selectionManager.selectionChanged(this, bb);                  // top,
555  //                      }                  // getContext().getCoordinateReferenceSystem().toString());
556  //                  // if (selectionManager != null) {
557  //                      graphics.setXORMode(Color.green);                  // selectionManager.selectionChanged(this, bb);
558  //                  // }
559  //                      /*                  //
560  //                       * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }                  // graphics.setXORMode(Color.green);
561  //                       */                  //
562  //                  // /*
563  //                      // draw new box                  // * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }
564  //                      lastX = x;                  // */
565  //                      lastY = y;                  //
566  //                      drawRectangle(graphics);                  // // draw new box
567  //              }                  // lastX = x;
568                    // lastY = y;
569                    // drawRectangle(graphics);
570                    // }
571    
572          }          }
573    
# Line 707  public class JMapPane extends JPanel imp Line 578  public class JMapPane extends JPanel imp
578                          final int y2, final MouseEvent e) {                          final int y2, final MouseEvent e) {
579    
580                  /****                  /****
581                   * If no layer is availabe we dont want a NullPointerException                   * If no layers exist, we ignore the drag.
582                   */                   */
583                  if (mapArea == null)                  if (context.getLayerCount() <= 0) {
584                          return;                          return;
585                    }
586    
587                  // System.out.println("processing drag from " + x1 + "," + y1 + " -> "                  // System.out.println("processing drag from " + x1 + "," + y1 + " -> "
588                  // + x2 + "," + y2);                  // + x2 + "," + y2);
# Line 757  public class JMapPane extends JPanel imp Line 629  public class JMapPane extends JPanel imp
629                          final Coordinate ur = new Coordinate(right, top);                          final Coordinate ur = new Coordinate(right, top);
630                          // xulu.sc                          // xulu.sc
631                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
632                          setMapArea(fixAspectRatio(this.getBounds(), new Envelope(ll, ur)));  
633                            setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
634                          // xulu.ec                          // xulu.ec
635                  } else if (state == JMapPane.ZoomIn) {                  } else if (state == JMapPane.ZoomIn) {
636    
# Line 781  public class JMapPane extends JPanel imp Line 654  public class JMapPane extends JPanel imp
654                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
655    
656                          // sk.sc                          // sk.sc
657  //                      {                           {
658  //                      // SK tries to paint a preview of the zoom ;-9 aha.... well                          // // SK tries to paint a preview of the zoom ;-9 aha.... well
659  //                      Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();  //                              
660  //                      graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,  //                               double reductionFactor = 1/8.;
661  //                                      RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);  ////                            
662  //                      graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,  ////                     BufferedImage reducedBaseImage = new BufferedImage((int)(baseImage.getWidth()*reductionFactor), (int)(baseImage.getHeight()*reductionFactor), BufferedImage.TYPE_INT_RGB);
663  //                                      RenderingHints.VALUE_ANTIALIAS_OFF);  ////                     Graphics2D reducedG = (Graphics2D) reducedBaseImage.getGraphics();
664  //                      graphics.setRenderingHint(RenderingHints.KEY_RENDERING,  //                       AffineTransform reductionTransform =new AffineTransform();
665  //                                      RenderingHints.VALUE_RENDER_SPEED);  //                       reductionTransform.scale(reductionFactor, reductionFactor);
666  //                      graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),  ////                    reducedG.drawImage(baseImage, reductionTransform, null);
667  //                                      JMapPane.this.getHeight(), x1, y1, x2, y2, null);  //                      
668  //                      }  //                       Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();
669    ////                     graphics.getTransform().scale(reductionFactor, reductionFactor);
670    //                      
671    //                       graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
672    //                       RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
673    //                       graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
674    //                       RenderingHints.VALUE_ANTIALIAS_OFF);
675    //                       graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
676    //                       RenderingHints.VALUE_RENDER_SPEED);
677    //                       graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),
678    //                       JMapPane.this.getHeight(), x1, y1, x2, y2, null);
679                             }
680                          // xulu.ec                          // xulu.ec
681                  } else if (state == JMapPane.ZoomOut) {                  } else if (state == JMapPane.ZoomOut) {
682                          drawRectangle(this.getGraphics());                          drawRectangle(this.getGraphics());
# Line 821  public class JMapPane extends JPanel imp Line 705  public class JMapPane extends JPanel imp
705                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
706    
707                          // xulu.ec                          // xulu.ec
708                  }                  }
709  //              else if (state == JMapPane.Select && selectionLayer != null) {                  // else if (state == JMapPane.Select && selectionLayer != null) {
710  //                      final double left = Math.min(startX, endX);                  // final double left = Math.min(startX, endX);
711  //                      final double right = Math.max(startX, endX);                  // final double right = Math.max(startX, endX);
712  //                      final double bottom = Math.min(startY, endY);                  // final double bottom = Math.min(startY, endY);
713  //                      final double top = Math.max(startY, endY);                  // final double top = Math.max(startY, endY);
714  //                  //
715  //                      String name = selectionLayer.getFeatureSource().getSchema()                  // String name = selectionLayer.getFeatureSource().getSchema()
716  //                                      .getDefaultGeometry().getLocalName();                  // .getDefaultGeometry().getLocalName();
717  //                  //
718  //                      if (name == "") {                  // if (name == "") {
719  //                              name = "the_geom";                  // name = "the_geom";
720  //                      }                  // }
721  //                      final Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,                  // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
722  //                                      getContext().getCoordinateReferenceSystem().toString());                  // top,
723  //                      // System.out.println(bb.toString());                  // getContext().getCoordinateReferenceSystem().toString());
724  //                      if (selectionManager != null) {                  // // System.out.println(bb.toString());
725  //                              selectionManager.selectionChanged(this, bb);                  // if (selectionManager != null) {
726  //                      }                  // selectionManager.selectionChanged(this, bb);
727  //                      /*                  // }
728  //                       * FeatureCollection fc; selection = null; try { fc =                  // /*
729  //                       * selectionLayer.getFeatureSource().getFeatures(bb); selection =                  // * FeatureCollection fc; selection = null; try { fc =
730  //                       * fc; } catch (IOException e) { e.printStackTrace(); }                  // * selectionLayer.getFeatureSource().getFeatures(bb); selection =
731  //                       */                  // * fc; } catch (IOException e) { e.printStackTrace(); }
732  //              }                  // */
733                    // }
734    
735                  // xulu.so                  // xulu.so
736                  // setMapArea(mapArea);                  // setMapArea(mapArea);
# Line 857  public class JMapPane extends JPanel imp Line 742  public class JMapPane extends JPanel imp
742                  return clickable;                  return clickable;
743          }          }
744    
745          private org.geotools.styling.Style setupStyle(final int type, final Color color) {          //
746                  final StyleFactory sf = org.geotools.factory.CommonFactoryFinder          // private org.geotools.styling.Style setupStyle(final int type, final Color
747                                  .getStyleFactory(null);          // color) {
748                  final StyleBuilder sb = new StyleBuilder();          // final StyleFactory sf = org.geotools.factory.CommonFactoryFinder
749            // .getStyleFactory(null);
750                  org.geotools.styling.Style s = sf.createStyle();          // final StyleBuilder sb = new StyleBuilder();
751                  s.setTitle("selection");          //
752            // org.geotools.styling.Style s = sf.createStyle();
753                  // TODO parameterise the color          // s.setTitle("selection");
754                  final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);          //
755                  ps.setStroke(sb.createStroke(color));          // // TODO parameterise the color
756            // final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);
757                  final LineSymbolizer ls = sb.createLineSymbolizer(color);          // ps.setStroke(sb.createStroke(color));
758                  final Graphic h = sb.createGraphic();          //
759                  h.setMarks(new Mark[] { sb.createMark("square", color) });          // final LineSymbolizer ls = sb.createLineSymbolizer(color);
760            // final Graphic h = sb.createGraphic();
761                  final PointSymbolizer pts = sb.createPointSymbolizer(h);          // h.setMarks(new Mark[] { sb.createMark("square", color) });
762            //
763                  // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});          // final PointSymbolizer pts = sb.createPointSymbolizer(h);
764                  switch (type) {          //
765                  case POLYGON:          // // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});
766                          s = sb.createStyle(ps);          // switch (type) {
767            // case POLYGON:
768                          break;          // s = sb.createStyle(ps);
769            //
770                  case POINT:          // break;
771                          s = sb.createStyle(pts);          //
772            // case POINT:
773                          break;          // s = sb.createStyle(pts);
774            //
775                  case LINE:          // break;
776                          s = sb.createStyle(ls);          //
777                  }          // case LINE:
778            // s = sb.createStyle(ls);
779                  return s;          // }
780          }          //
781            // return s;
782            // }
783    
784          public void propertyChange(final PropertyChangeEvent evt) {          public void propertyChange(final PropertyChangeEvent evt) {
785                  final String prop = evt.getPropertyName();                  final String prop = evt.getPropertyName();
# Line 977  public class JMapPane extends JPanel imp Line 863  public class JMapPane extends JPanel imp
863          public void mouseMoved(final MouseEvent e) {          public void mouseMoved(final MouseEvent e) {
864          }          }
865    
   
   
866          // xulu.sn          // xulu.sn
867          /**          /**
868           * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste           * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste
# Line 997  public class JMapPane extends JPanel imp Line 881  public class JMapPane extends JPanel imp
881                  if (env == null)                  if (env == null)
882                          return env;                          return env;
883    
884                    Envelope newArea = null;
885    
886                  /**                  /**
887                   * Correct the aspect Ratio before we check the rest. Otherwise we might                   * Correct the aspect Ratio before we check the rest. Otherwise we might
888                   * easily fail.                   * easily fail. We allow to grow here, because we don't check against
889                     * the maxExtend
890                   */                   */
891                  env = fixAspectRatio(this.getBounds(), env);                  env = JTSUtil.fixAspectRatio(this.getBounds(), env, true);
892    
893                  final double scale = env.getWidth() / getWidth();                  final double scale = env.getWidth() / getWidth();
894                  final double centerX = env.getMinX() + env.getWidth() / 2.;                  final double centerX = env.getMinX() + env.getWidth() / 2.;
895                  final double centerY = env.getMinY() + env.getHeight() / 2.;                  final double centerY = env.getMinY() + env.getHeight() / 2.;
896                  double newWidth2;                  double newWidth2 = 0;
897                  double newHeight2;                  double newHeight2 = 0;
898                  if (scale < getMaxZoomScale()) {                  if (scale < getMaxZoomScale()) {
899                          // ****************************************************************************                          // ****************************************************************************
900                          // Wir zoomen weiter rein als erlaubt => Anpassen des envelope                          // Wir zoomen weiter rein als erlaubt => Anpassen des envelope
# Line 1024  public class JMapPane extends JPanel imp Line 911  public class JMapPane extends JPanel imp
911                          // ****************************************************************************                          // ****************************************************************************
912                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
913                          // ****************************************************************************                          // ****************************************************************************
914                          return env;                          newArea = env;
915                    }
916    
917                    if (newArea == null) {
918    
919                            final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
920                                            - newHeight2);
921                            final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
922                                            + newHeight2);
923    
924                            newArea = new Envelope(ll, ur);
925                  }                  }
926    
927                  final Coordinate ll = new Coordinate(centerX - newWidth2, centerY                  Envelope maxAllowedExtend = getMaxExtend();
928                                  - newHeight2);                  while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea)
929                  final Coordinate ur = new Coordinate(centerX + newWidth2, centerY                                  && newArea != null && !newArea.isNull()
930                                  + newHeight2);                                  && !Double.isNaN(newArea.getMinX())
931                                    && !Double.isNaN(newArea.getMaxX())
932                                    && !Double.isNaN(newArea.getMinY())
933                                    && !Double.isNaN(newArea.getMaxY())) {
934                            /*
935                             * If a maxExtend is set, we have to honour that...
936                             */
937    
938                            // Exceeds top? Move down and maybe cut
939                            if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
940                                    double divY = newArea.getMaxY() - maxAllowedExtend.getMaxY();
941                                    // LOGGER.debug("Moving area down by " + divY);
942    
943                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
944                                                    newArea.getMinY() - divY), new Coordinate(newArea
945                                                    .getMaxX(), newArea.getMaxY() - divY));
946    
947                                    if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
948                                            // LOGGER.debug("Now it exeeds the bottom border.. cut!");
949                                            // And cut the bottom if it moved out of the area
950                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
951                                                            maxAllowedExtend.getMinY()), new Coordinate(newArea
952                                                            .getMaxX(), newArea.getMaxY()));
953    
954                                            // LOGGER.debug("and fix aspect ratio");
955    
956                                            newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
957                                                            false);
958                                    }
959                            }
960    
961                            // Exceeds bottom? Move up and maybe cut
962                            if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
963                                    double divY = newArea.getMinY() - maxAllowedExtend.getMinY();
964                                    // LOGGER.debug("Moving area up by " + divY);
965    
966                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
967                                                    newArea.getMinY() - divY), new Coordinate(newArea
968                                                    .getMaxX(), newArea.getMaxY() - divY));
969    
970                                    if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
971                                            // LOGGER.debug("Now it exeeds the top border.. cut!");
972                                            // And cut the bottom if it moved out of the area
973                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
974                                                            newArea.getMinY()), new Coordinate(newArea
975                                                            .getMaxX(), maxAllowedExtend.getMaxY()));
976    
977                                            // LOGGER.debug("and fix aspect ratio");
978    
979                                            newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
980                                                            false);
981                                    }
982                            }
983    
984                            // Exceeds to the right? move and maybe cut
985                            if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
986    
987                                    // Move left..
988                                    double divX = newArea.getMaxX() - maxAllowedExtend.getMaxX();
989                                    // LOGGER.debug("Moving area left by " + divX);
990    
991                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
992                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
993                                                    - divX, newArea.getMaxY()));
994    
995                                    if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
996                                            // LOGGER.debug("Now it exeeds the left border.. cut!");
997                                            // And cut the left if it moved out of the area
998                                            newArea = new Envelope(new Coordinate(maxAllowedExtend
999                                                            .getMinX(), newArea.getMinY()), new Coordinate(
1000                                                            newArea.getMaxX(), newArea.getMaxY()));
1001    
1002                                            // LOGGER.debug("and fix aspect ratio");
1003    
1004                                            newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
1005                                                            false);
1006                                    }
1007                            }
1008    
1009                            // Exceeds to the left? move and maybe cut
1010                            if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
1011    
1012                                    // Move right..
1013                                    double divX = newArea.getMinX() - maxAllowedExtend.getMinX();
1014                                    // LOGGER.debug("Moving area right by " + divX);
1015    
1016                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
1017                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
1018                                                    - divX, newArea.getMaxY()));
1019    
1020                                    if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
1021                                            // LOGGER.debug("Now it exeeds the right border.. cut!");
1022                                            // And cut the left if it moved out of the area
1023                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
1024                                                            newArea.getMinY()), new Coordinate(maxAllowedExtend
1025                                                            .getMaxX(), newArea.getMaxY()));
1026    
1027                                            // LOGGER.debug("and fix aspect ratio");
1028    
1029                  return new Envelope(ll, ur);                                          newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
1030                                                            false);
1031                                    }
1032                            }
1033    
1034                    }
1035    
1036                    return newArea;
1037          }          }
1038    
1039          /**          /**
# Line 1059  public class JMapPane extends JPanel imp Line 1060  public class JMapPane extends JPanel imp
1060    
1061          /**          /**
1062           * Set the maximum allowed zoom scale. This is the smaller number value of           * Set the maximum allowed zoom scale. This is the smaller number value of
1063           * the two.           * the two. If <code>null</code> is passed, Double.MINVALUE are used which
1064             * mean there is no restriction.
1065           *           *
1066           * @author <a href="mailto:[email protected]">Stefan Alfons           * @author <a href="mailto:[email protected]">Stefan Alfons
1067           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
1068           */           */
1069          public void setMaxZoomScale(final Double maxZoomScale) {          public void setMaxZoomScale(final Double maxZoomScale) {
1070                  // System.out.println("setting max scale to "+maxZoomScale);                  this.maxZoomScale = maxZoomScale == null ? Double.MIN_VALUE
1071                  this.maxZoomScale = maxZoomScale;                                  : maxZoomScale;
1072          }          }
1073    
1074          /**          /**
1075           * Set the minimum (nearest) allowed zoom scale. This is the bigger number           * Set the minimum (nearest) allowed zoom scale. This is the bigger number
1076           * value of the two.           * value of the two. If <code>null</code> is passed, Double.MAXVALUE are
1077             * used which mean there is no restriction.
1078             *
1079           *           *
1080           * @author <a href="mailto:[email protected]">Stefan Alfons           * @author <a href="mailto:[email protected]">Stefan Alfons
1081           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
1082           */           */
1083          public void setMinZoomScale(final Double minZoomScale) {          public void setMinZoomScale(final Double minZoomScale) {
1084                  this.minZoomScale = minZoomScale;                  this.minZoomScale = minZoomScale == null ? Double.MAX_VALUE
1085                                    : minZoomScale;
1086            }
1087    
1088            /**
1089             * Defines an evelope of the viwable area. The JMapPane will never show
1090             * anything outside of this extend.
1091             *
1092             * @param maxExtend
1093             *            <code>null</code> to not have this restriction.
1094             */
1095            public void setMaxExtend(Envelope maxExtend) {
1096                    this.maxExtend = maxExtend;
1097            }
1098    
1099            /**
1100             * Returns the evelope of the viewable area. The JMapPane will never show
1101             * anything outside of this extend. If this has been set to
1102             * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
1103             * quickly the context's bounds. It it takes to long to determine the
1104             * context bounds, <code>null</code> is returned.
1105             *
1106             * @param maxExtend
1107             *            <code>null</code> to not have this restriction.
1108             */
1109    
1110            public Envelope getMaxExtend() {
1111                    if (maxExtend == null) {
1112                            try {
1113                                    return JTSUtil.fixAspectRatio(this.getBounds(),
1114                                                    // Kartenbereich um 10% vergroessern
1115                                                    JTSUtil.expandEnvelope(context.getLayerBounds(), 0.1),
1116                                                    true);
1117                            } catch (IOException e) {
1118                                    LOGGER
1119                                                    .warn(
1120                                                                    "maxExtend == null; failed to getLayerBounds of context",
1121                                                                    e);
1122                            }
1123                    }
1124                    return maxExtend;
1125            }
1126    
1127            /**
1128             * Set the background color of the map.
1129             * @param if <code>null</code>, white is used.
1130             */
1131            public void setMapBackgroundColor(Color bgColor) {
1132                    if (bgColor == null) bgColor = Color.WHITE;
1133                    this.mapBackgroundColor = bgColor;
1134            }
1135    
1136            /**
1137             * Returns the background {@link Color} of the map pane. Default is white.
1138            **/
1139            public Color getMapBackgroundColor() {
1140                    return mapBackgroundColor;
1141          }          }
         // xulu.en  
1142    
1143  }  }
Legend:
Removed from v.348  
changed lines
  Added in v.505
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26