/[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

revision 388 by alfonx, Fri Sep 11 19:06:17 2009 UTC revision 504 by alfonx, Tue Oct 27 12:57:58 2009 UTC
# Line 65  import org.geotools.renderer.GTRenderer; Line 65  import org.geotools.renderer.GTRenderer;
65  import org.geotools.renderer.label.LabelCacheImpl;  import org.geotools.renderer.label.LabelCacheImpl;
66  import org.geotools.renderer.lite.LabelCache;  import org.geotools.renderer.lite.LabelCache;
67  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;  
68  import org.opengis.filter.FilterFactory2;  import org.opengis.filter.FilterFactory2;
69  import org.opengis.referencing.crs.CoordinateReferenceSystem;  import org.opengis.referencing.crs.CoordinateReferenceSystem;
70    
71    import schmitzm.geotools.JTSUtil;
72  import schmitzm.swing.SwingUtil;  import schmitzm.swing.SwingUtil;
73    
74  import com.vividsolutions.jts.geom.Coordinate;  import com.vividsolutions.jts.geom.Coordinate;
# Line 84  import com.vividsolutions.jts.geom.Geome Line 77  import com.vividsolutions.jts.geom.Geome
77    
78  public class JMapPane extends JPanel implements MouseListener,  public class JMapPane extends JPanel implements MouseListener,
79                  MouseMotionListener, PropertyChangeListener, MapLayerListListener {                  MouseMotionListener, PropertyChangeListener, MapLayerListListener {
80          private static Logger LOGGER = Logger.getLogger(JMapPane.class.getName());          private static Logger LOGGER = Logger.getLogger(JMapPane.class);
81    
82          private static final long serialVersionUID = -8647971481359690499L;          private static final long serialVersionUID = -8647971481359690499L;
83    
# Line 98  public class JMapPane extends JPanel imp Line 91  public class JMapPane extends JPanel imp
91    
92          public static final int Select = 4;          public static final int Select = 4;
93    
         private static final int POLYGON = 0;  
   
         private static final int LINE = 1;  
   
         private static final int POINT = 2;  
   
94          /**          /**
95           * what renders the map           * what renders the map
96           */           */
97          GTRenderer renderer;          GTRenderer renderer;
98    
         private GTRenderer highlightRenderer, selectionRenderer;  
   
99          /**          /**
100           * the map context to render           * the map context to render
101           */           */
102          MapContext context;          MapContext context;
103    
         private MapContext selectionContext;  
   
104          /**          /**
105           * the area of the map to draw           * the area of the map to draw
106           */           */
         // xulu.sc  
         // Envelope mapArea;  
107          protected Envelope mapArea;          protected Envelope mapArea;
         // xulu.ec  
108    
109          /**          /**
110           * the size of the pane last time we drew           * the size of the pane last time we drew
111           */           */
         // xulu.sc  
         // private Rectangle oldRect = null;  
112          protected Rectangle oldRect = null;          protected Rectangle oldRect = null;
         // xulu.ec  
113    
114          /**          /**
115           * the last map area drawn.           * the last map area drawn.
116           */           */
         // xulu.sc  
         // private Envelope oldMapArea = null;  
117          protected Envelope oldMapArea = null;          protected Envelope oldMapArea = null;
         // xulu.ec  
118    
119          /**          /**
120           * the base image of the map           * the base image of the map
121           */           */
122          protected BufferedImage baseImage, panningImage;          protected BufferedImage baseImage, panningImage;
         // SK: private BufferedImage baseImage, panningImage;  
123    
124          /**          /**
125           * a factory for filters           * a factory for filters
# Line 169  public class JMapPane extends JPanel imp Line 142  public class JMapPane extends JPanel imp
142    
143          LabelCache labelCache = new LabelCacheImpl();          LabelCache labelCache = new LabelCacheImpl();
144    
         // xulu.sc  
         // private boolean reset = false;  
145          protected boolean reset = false;          protected boolean reset = false;
         // xulu.ec  
146    
147          int startX;          int startX;
148    
149          int startY;          int startY;
150    
151            /**
152             * If not <code>null</code>, the {@link JMapPane} will not allow to zoom/pan
153             * out of that area
154             **/
155            private Envelope maxExtend = null;
156    
157            // /**
158            // * Is max. 1 or 0 of the 2 axised allowed to extend the maxExtend? If
159            // * <code>true</code> the extends has to be fully inside maxExtend
160            // **/
161            // boolean maxExtendForceMode = true;
162    
163          private boolean clickable;          private boolean clickable;
164    
165          int lastX;          int lastX;
166    
167          int lastY;          int lastY;
168    
         // xulu.sn  
169          private Double maxZoomScale = Double.MIN_VALUE;          private Double maxZoomScale = Double.MIN_VALUE;
170          private Double minZoomScale = Double.MAX_VALUE;          private Double minZoomScale = Double.MAX_VALUE;
         // xulu.en  
171    
         // sk.sn  
172          /**          /**
173           * Wenn true, dann wurde PANNING via mouseDraged-Events begonnen. Dieses           * Wenn true, dann wurde PANNING via mouseDraged-Events begonnen. Dieses
174           * 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 176  public class JMapPane extends JPanel imp
176           */           */
177          private boolean panning_started = false;          private boolean panning_started = false;
178    
         // sk.en  
   
179          public JMapPane() {          public JMapPane() {
180                  this(null, true, null, null);                  this(null, true, null, null);
181          }          }
# Line 250  public class JMapPane extends JPanel imp Line 227  public class JMapPane extends JPanel imp
227          }          }
228    
229          public void setRenderer(final GTRenderer renderer) {          public void setRenderer(final GTRenderer renderer) {
230                  Map<Object,Object> hints = new HashMap<Object,Object>();                  Map<Object, Object> hints = new HashMap<Object, Object>();
231                    
232                  this.renderer = renderer;                  this.renderer = renderer;
233                                    // MS: Apply hint also for ShapeFileRenderer
234                  if (renderer instanceof StreamingRenderer || renderer instanceof ShapefileRenderer) {                  // if (renderer instanceof StreamingRenderer) {
235                          hints = renderer.getRendererHints();                  hints = renderer.getRendererHints();
236                          if (hints == null) {                  if (hints == null) {
237                                  hints = new HashMap<Object,Object>();                          hints = new HashMap<Object, Object>();
238                          }                  }
239                          if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {                  if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {
240                                  labelCache = (LabelCache) hints                          labelCache = (LabelCache) hints
241                                                  .get(StreamingRenderer.LABEL_CACHE_KEY);                                          .get(StreamingRenderer.LABEL_CACHE_KEY);
242                          } else {                  } else {
243                                  hints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);                          hints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);
244                          }                  }
245    
246                          hints.put("memoryPreloadingEnabled", Boolean.TRUE);                  hints.put("memoryPreloadingEnabled", Boolean.TRUE);
247                            
248                          renderer.setRendererHints(hints);                  renderer.setRendererHints(hints);
249                  }                  // }
   
 //              this.highlightRenderer = new StreamingRenderer();  
 //              this.selectionRenderer = new StreamingRenderer();  
   
 //              highlightRenderer.setRendererHints(hints);  
 //              selectionRenderer.setRendererHints(hints);  
                   
 //              renderer.setRendererHints(hints);  
250    
251                  if (this.context != null) {                  if (this.context != null) {
252                          this.renderer.setContext(this.context);                          this.renderer.setContext(this.context);
# Line 330  public class JMapPane extends JPanel imp Line 299  public class JMapPane extends JPanel imp
299                  this.zoomFactor = zoomFactor;                  this.zoomFactor = zoomFactor;
300          }          }
301    
   
302          protected void paintComponent(final Graphics g) {          protected void paintComponent(final Graphics g) {
303                  super.paintComponent(g);                  super.paintComponent(g);
304    
# Line 356  public class JMapPane extends JPanel imp Line 324  public class JMapPane extends JPanel imp
324                                  reset = false; /* forget about the reset */                                  reset = false; /* forget about the reset */
325                                  oldRect = r; /* store what the current size is */                                  oldRect = r; /* store what the current size is */
326    
327                                  mapArea = fixAspectRatio(r, mapArea);                                  mapArea = JTSUtil.fixAspectRatio(r, mapArea, false);
328                          }                          }
329                  }                  }
330    
# Line 369  public class JMapPane extends JPanel imp Line 337  public class JMapPane extends JPanel imp
337                                          .getCoordinateReferenceSystem());                                          .getCoordinateReferenceSystem());
338                  }                  }
339    
340                  if (changed ) { /* if the map changed then redraw */                  if (changed) { /* if the map changed then redraw */
341                          changed = false;                          changed = false;
342                          baseImage = new BufferedImage(dr.width, dr.height,                          baseImage = new BufferedImage(dr.width, dr.height,
343                                          BufferedImage.TYPE_INT_ARGB);                                          BufferedImage.TYPE_INT_ARGB);
344    
345                          final Graphics2D ig = baseImage.createGraphics();                          final Graphics2D ig = baseImage.createGraphics();
346                          /* System.out.println("rendering"); */                          /* System.out.println("rendering"); */
347                          if (renderer.getContext() != null)                          if (renderer.getContext() != null)
348                                  renderer.setContext(context);                                  renderer.setContext(context);
349                          labelCache.clear(); // work around anoying labelcache bug                          labelCache.clear(); // work around anoying labelcache bug
350    
# Line 392  public class JMapPane extends JPanel imp Line 360  public class JMapPane extends JPanel imp
360                  ((Graphics2D) g).drawImage(baseImage, 0, 0, this);                  ((Graphics2D) g).drawImage(baseImage, 0, 0, this);
361          }          }
362    
         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;  
 //      }  
   
363          public void mouseClicked(final MouseEvent e) {          public void mouseClicked(final MouseEvent e) {
364                  if (mapArea == null) return;                  if (mapArea == null)
365                            return;
366                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"
367                  // h:"+mapArea.getHeight());                  // h:"+mapArea.getHeight());
368                  final Rectangle bounds = this.getBounds();                  final Rectangle bounds = this.getBounds();
# Line 519  public class JMapPane extends JPanel imp Line 376  public class JMapPane extends JPanel imp
376                  final double width2 = width / 2.0;                  final double width2 = width / 2.0;
377                  final double height2 = height / 2.0;                  final double height2 = height / 2.0;
378                  // xulu.ec                  // xulu.ec
379                  final double mapX = ((x * width) / (double) bounds.width) + mapArea.getMinX();                  final double mapX = ((x * width) / (double) bounds.width)
380                                    + mapArea.getMinX();
381                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)
382                                  + mapArea.getMinY();                                  + mapArea.getMinY();
383    
# Line 550  public class JMapPane extends JPanel imp Line 408  public class JMapPane extends JPanel imp
408                          zlevel = 1.0 / zoomFactor;                          zlevel = 1.0 / zoomFactor;
409    
410                          break;                          break;
411  //                  //
412  //              case Select:                  // case Select:
413  //                      doSelection(mapX, mapY, selectionLayer);                  // doSelection(mapX, mapY, selectionLayer);
414  //                  //
415  //                      return;                  // return;
416    
417                  default:                  default:
418                          return;                          return;
# Line 626  public class JMapPane extends JPanel imp Line 484  public class JMapPane extends JPanel imp
484                                  // System.out.println("translate "+dx+","+dy);                                  // System.out.println("translate "+dx+","+dy);
485                                  final Graphics2D g2 = panningImage.createGraphics();                                  final Graphics2D g2 = panningImage.createGraphics();
486                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige
487                                                                                                                          // farbe? am besten                                  // farbe? am besten
488                                                                                                                          // vom L&F die                                  // vom L&F die
489                                                                                                                          // hintergrundfarbe                                  // hintergrundfarbe
490                                                                                                                          // auslesen...                                  // auslesen...
491                                    
492                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());
493                                  g2.drawImage(baseImage, dx, dy, this);                                  g2.drawImage(baseImage, dx, dy, this);
494                                  graphics.drawImage(panningImage, 0, 0, this);                                  graphics.drawImage(panningImage, 0, 0, this);
# Line 652  public class JMapPane extends JPanel imp Line 510  public class JMapPane extends JPanel imp
510                          lastX = x;                          lastX = x;
511                          lastY = y;                          lastY = y;
512                          drawRectangle(graphics);                          drawRectangle(graphics);
513                  }                  }
514  //              else if (state == JMapPane.Select && selectionLayer != null) {                  // else if (state == JMapPane.Select && selectionLayer != null) {
515  //                  //
516  //                      // construct a new bbox filter                  // // construct a new bbox filter
517  //                      final Rectangle bounds = this.getBounds();                  // final Rectangle bounds = this.getBounds();
518  //                  //
519  //                      final double mapWidth = mapArea.getWidth();                  // final double mapWidth = mapArea.getWidth();
520  //                      final double mapHeight = mapArea.getHeight();                  // final double mapHeight = mapArea.getHeight();
521  //                  //
522  //                      final double x1 = ((this.startX * mapWidth) / (double) bounds.width)                  // final double x1 = ((this.startX * mapWidth) / (double) bounds.width)
523  //                                      + mapArea.getMinX();                  // + mapArea.getMinX();
524  //                      final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) / (double) bounds.height)                  // final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) /
525  //                                      + mapArea.getMinY();                  // (double) bounds.height)
526  //                      final double x2 = ((x * mapWidth) / (double) bounds.width)                  // + mapArea.getMinY();
527  //                                      + mapArea.getMinX();                  // final double x2 = ((x * mapWidth) / (double) bounds.width)
528  //                      final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double) bounds.height)                  // + mapArea.getMinX();
529  //                                      + mapArea.getMinY();                  // final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double)
530  //                      final double left = Math.min(x1, x2);                  // bounds.height)
531  //                      final double right = Math.max(x1, x2);                  // + mapArea.getMinY();
532  //                      final double bottom = Math.min(y1, y2);                  // final double left = Math.min(x1, x2);
533  //                      final double top = Math.max(y1, y2);                  // final double right = Math.max(x1, x2);
534  //                  // final double bottom = Math.min(y1, y2);
535  //                      String name = selectionLayer.getFeatureSource().getSchema()                  // final double top = Math.max(y1, y2);
536  //                                      .getDefaultGeometry().getName();                  //
537  //                  // String name = selectionLayer.getFeatureSource().getSchema()
538  //                      if (name == "") {                  // .getDefaultGeometry().getName();
539  //                              name = "the_geom";                  //
540  //                      }                  // if (name == "") {
541  //                      final Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,                  // name = "the_geom";
542  //                                      getContext().getCoordinateReferenceSystem().toString());                  // }
543  //                      if (selectionManager != null) {                  // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
544  //                              selectionManager.selectionChanged(this, bb);                  // top,
545  //                      }                  // getContext().getCoordinateReferenceSystem().toString());
546  //                  // if (selectionManager != null) {
547  //                      graphics.setXORMode(Color.green);                  // selectionManager.selectionChanged(this, bb);
548  //                  // }
549  //                      /*                  //
550  //                       * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }                  // graphics.setXORMode(Color.green);
551  //                       */                  //
552  //                  // /*
553  //                      // draw new box                  // * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }
554  //                      lastX = x;                  // */
555  //                      lastY = y;                  //
556  //                      drawRectangle(graphics);                  // // draw new box
557  //              }                  // lastX = x;
558                    // lastY = y;
559                    // drawRectangle(graphics);
560                    // }
561    
562          }          }
563    
# Line 707  public class JMapPane extends JPanel imp Line 568  public class JMapPane extends JPanel imp
568                          final int y2, final MouseEvent e) {                          final int y2, final MouseEvent e) {
569    
570                  /****                  /****
571                   * If no layer is availabe we dont want a NullPointerException                   * If no layers exist, we ignore the drag.
572                   */                   */
573                  if (mapArea == null)                  if (context.getLayerCount() <= 0) {
574                          return;                          return;
575                    }
576    
577                  // System.out.println("processing drag from " + x1 + "," + y1 + " -> "                  // System.out.println("processing drag from " + x1 + "," + y1 + " -> "
578                  // + x2 + "," + y2);                  // + x2 + "," + y2);
# Line 757  public class JMapPane extends JPanel imp Line 619  public class JMapPane extends JPanel imp
619                          final Coordinate ur = new Coordinate(right, top);                          final Coordinate ur = new Coordinate(right, top);
620                          // xulu.sc                          // xulu.sc
621                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
622                          setMapArea(fixAspectRatio(this.getBounds(), new Envelope(ll, ur)));  
623                            setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
624                          // xulu.ec                          // xulu.ec
625                  } else if (state == JMapPane.ZoomIn) {                  } else if (state == JMapPane.ZoomIn) {
626    
# Line 781  public class JMapPane extends JPanel imp Line 644  public class JMapPane extends JPanel imp
644                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
645    
646                          // sk.sc                          // sk.sc
647  //                      {                          // {
648  //                      // SK tries to paint a preview of the zoom ;-9 aha.... well                          // // SK tries to paint a preview of the zoom ;-9 aha.... well
649  //                      Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();                          // Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();
650  //                      graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,                          // graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
651  //                                      RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);                          // RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
652  //                      graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,                          // graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
653  //                                      RenderingHints.VALUE_ANTIALIAS_OFF);                          // RenderingHints.VALUE_ANTIALIAS_OFF);
654  //                      graphics.setRenderingHint(RenderingHints.KEY_RENDERING,                          // graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
655  //                                      RenderingHints.VALUE_RENDER_SPEED);                          // RenderingHints.VALUE_RENDER_SPEED);
656  //                      graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),                          // graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),
657  //                                      JMapPane.this.getHeight(), x1, y1, x2, y2, null);                          // JMapPane.this.getHeight(), x1, y1, x2, y2, null);
658  //                      }                          // }
659                          // xulu.ec                          // xulu.ec
660                  } else if (state == JMapPane.ZoomOut) {                  } else if (state == JMapPane.ZoomOut) {
661                          drawRectangle(this.getGraphics());                          drawRectangle(this.getGraphics());
# Line 821  public class JMapPane extends JPanel imp Line 684  public class JMapPane extends JPanel imp
684                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
685    
686                          // xulu.ec                          // xulu.ec
687                  }                  }
688  //              else if (state == JMapPane.Select && selectionLayer != null) {                  // else if (state == JMapPane.Select && selectionLayer != null) {
689  //                      final double left = Math.min(startX, endX);                  // final double left = Math.min(startX, endX);
690  //                      final double right = Math.max(startX, endX);                  // final double right = Math.max(startX, endX);
691  //                      final double bottom = Math.min(startY, endY);                  // final double bottom = Math.min(startY, endY);
692  //                      final double top = Math.max(startY, endY);                  // final double top = Math.max(startY, endY);
693  //                  //
694  //                      String name = selectionLayer.getFeatureSource().getSchema()                  // String name = selectionLayer.getFeatureSource().getSchema()
695  //                                      .getDefaultGeometry().getLocalName();                  // .getDefaultGeometry().getLocalName();
696  //                  //
697  //                      if (name == "") {                  // if (name == "") {
698  //                              name = "the_geom";                  // name = "the_geom";
699  //                      }                  // }
700  //                      final Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,                  // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
701  //                                      getContext().getCoordinateReferenceSystem().toString());                  // top,
702  //                      // System.out.println(bb.toString());                  // getContext().getCoordinateReferenceSystem().toString());
703  //                      if (selectionManager != null) {                  // // System.out.println(bb.toString());
704  //                              selectionManager.selectionChanged(this, bb);                  // if (selectionManager != null) {
705  //                      }                  // selectionManager.selectionChanged(this, bb);
706  //                      /*                  // }
707  //                       * FeatureCollection fc; selection = null; try { fc =                  // /*
708  //                       * selectionLayer.getFeatureSource().getFeatures(bb); selection =                  // * FeatureCollection fc; selection = null; try { fc =
709  //                       * fc; } catch (IOException e) { e.printStackTrace(); }                  // * selectionLayer.getFeatureSource().getFeatures(bb); selection =
710  //                       */                  // * fc; } catch (IOException e) { e.printStackTrace(); }
711  //              }                  // */
712                    // }
713    
714                  // xulu.so                  // xulu.so
715                  // setMapArea(mapArea);                  // setMapArea(mapArea);
# Line 857  public class JMapPane extends JPanel imp Line 721  public class JMapPane extends JPanel imp
721                  return clickable;                  return clickable;
722          }          }
723    
724          private org.geotools.styling.Style setupStyle(final int type, final Color color) {          //
725                  final StyleFactory sf = org.geotools.factory.CommonFactoryFinder          // private org.geotools.styling.Style setupStyle(final int type, final Color
726                                  .getStyleFactory(null);          // color) {
727                  final StyleBuilder sb = new StyleBuilder();          // final StyleFactory sf = org.geotools.factory.CommonFactoryFinder
728            // .getStyleFactory(null);
729                  org.geotools.styling.Style s = sf.createStyle();          // final StyleBuilder sb = new StyleBuilder();
730                  s.setTitle("selection");          //
731            // org.geotools.styling.Style s = sf.createStyle();
732                  // TODO parameterise the color          // s.setTitle("selection");
733                  final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);          //
734                  ps.setStroke(sb.createStroke(color));          // // TODO parameterise the color
735            // final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);
736                  final LineSymbolizer ls = sb.createLineSymbolizer(color);          // ps.setStroke(sb.createStroke(color));
737                  final Graphic h = sb.createGraphic();          //
738                  h.setMarks(new Mark[] { sb.createMark("square", color) });          // final LineSymbolizer ls = sb.createLineSymbolizer(color);
739            // final Graphic h = sb.createGraphic();
740                  final PointSymbolizer pts = sb.createPointSymbolizer(h);          // h.setMarks(new Mark[] { sb.createMark("square", color) });
741            //
742                  // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});          // final PointSymbolizer pts = sb.createPointSymbolizer(h);
743                  switch (type) {          //
744                  case POLYGON:          // // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});
745                          s = sb.createStyle(ps);          // switch (type) {
746            // case POLYGON:
747                          break;          // s = sb.createStyle(ps);
748            //
749                  case POINT:          // break;
750                          s = sb.createStyle(pts);          //
751            // case POINT:
752                          break;          // s = sb.createStyle(pts);
753            //
754                  case LINE:          // break;
755                          s = sb.createStyle(ls);          //
756                  }          // case LINE:
757            // s = sb.createStyle(ls);
758                  return s;          // }
759          }          //
760            // return s;
761            // }
762    
763          public void propertyChange(final PropertyChangeEvent evt) {          public void propertyChange(final PropertyChangeEvent evt) {
764                  final String prop = evt.getPropertyName();                  final String prop = evt.getPropertyName();
# Line 977  public class JMapPane extends JPanel imp Line 842  public class JMapPane extends JPanel imp
842          public void mouseMoved(final MouseEvent e) {          public void mouseMoved(final MouseEvent e) {
843          }          }
844    
   
   
845          // xulu.sn          // xulu.sn
846          /**          /**
847           * 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 860  public class JMapPane extends JPanel imp
860                  if (env == null)                  if (env == null)
861                          return env;                          return env;
862    
863                    Envelope newArea = null;
864    
865                  /**                  /**
866                   * Correct the aspect Ratio before we check the rest. Otherwise we might                   * Correct the aspect Ratio before we check the rest. Otherwise we might
867                   * easily fail.                   * easily fail. We allow to grow here, because we don't check against
868                     * the maxExtend
869                   */                   */
870                  env = fixAspectRatio(this.getBounds(), env);                  env = JTSUtil.fixAspectRatio(this.getBounds(), env, true);
871    
872                  final double scale = env.getWidth() / getWidth();                  final double scale = env.getWidth() / getWidth();
873                  final double centerX = env.getMinX() + env.getWidth() / 2.;                  final double centerX = env.getMinX() + env.getWidth() / 2.;
874                  final double centerY = env.getMinY() + env.getHeight() / 2.;                  final double centerY = env.getMinY() + env.getHeight() / 2.;
875                  double newWidth2;                  double newWidth2 = 0;
876                  double newHeight2;                  double newHeight2 = 0;
877                  if (scale < getMaxZoomScale()) {                  if (scale < getMaxZoomScale()) {
878                          // ****************************************************************************                          // ****************************************************************************
879                          // 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 890  public class JMapPane extends JPanel imp
890                          // ****************************************************************************                          // ****************************************************************************
891                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
892                          // ****************************************************************************                          // ****************************************************************************
893                          return env;                          newArea = env;
894                    }
895    
896                    if (newArea == null) {
897    
898                            final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
899                                            - newHeight2);
900                            final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
901                                            + newHeight2);
902    
903                            newArea = new Envelope(ll, ur);
904                  }                  }
905    
906                  final Coordinate ll = new Coordinate(centerX - newWidth2, centerY                  Envelope maxAllowedExtend = getMaxExtend();
907                                  - newHeight2);                  while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea)
908                  final Coordinate ur = new Coordinate(centerX + newWidth2, centerY                                  && newArea != null && !newArea.isNull()
909                                  + newHeight2);                                  && !Double.isNaN(newArea.getMinX())
910                                    && !Double.isNaN(newArea.getMaxX())
911                                    && !Double.isNaN(newArea.getMinY())
912                                    && !Double.isNaN(newArea.getMaxY())) {
913                            /*
914                             * If a maxExtend is set, we have to honour that...
915                             */
916    
917                            // Exceeds top? Move down and maybe cut
918                            if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
919                                    double divY = newArea.getMaxY() - maxAllowedExtend.getMaxY();
920                                    // LOGGER.debug("Moving area down by " + divY);
921    
922                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
923                                                    newArea.getMinY() - divY), new Coordinate(newArea
924                                                    .getMaxX(), newArea.getMaxY() - divY));
925    
926                                    if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
927                                            // LOGGER.debug("Now it exeeds the bottom border.. cut!");
928                                            // And cut the bottom if it moved out of the area
929                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
930                                                            maxAllowedExtend.getMinY()), new Coordinate(newArea
931                                                            .getMaxX(), newArea.getMaxY()));
932    
933                                            // LOGGER.debug("and fix aspect ratio");
934    
935                                            newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
936                                                            false);
937                                    }
938                            }
939    
940                            // Exceeds bottom? Move up and maybe cut
941                            if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
942                                    double divY = newArea.getMinY() - maxAllowedExtend.getMinY();
943                                    // LOGGER.debug("Moving area up by " + divY);
944    
945                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
946                                                    newArea.getMinY() - divY), new Coordinate(newArea
947                                                    .getMaxX(), newArea.getMaxY() - divY));
948    
949                                    if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
950                                            // LOGGER.debug("Now it exeeds the top border.. cut!");
951                                            // And cut the bottom if it moved out of the area
952                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
953                                                            newArea.getMinY()), new Coordinate(newArea
954                                                            .getMaxX(), maxAllowedExtend.getMaxY()));
955    
956                                            // LOGGER.debug("and fix aspect ratio");
957    
958                                            newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
959                                                            false);
960                                    }
961                            }
962    
963                            // Exceeds to the right? move and maybe cut
964                            if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
965    
966                                    // Move left..
967                                    double divX = newArea.getMaxX() - maxAllowedExtend.getMaxX();
968                                    // LOGGER.debug("Moving area left by " + divX);
969    
970                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
971                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
972                                                    - divX, newArea.getMaxY()));
973    
974                                    if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
975                                            // LOGGER.debug("Now it exeeds the left border.. cut!");
976                                            // And cut the left if it moved out of the area
977                                            newArea = new Envelope(new Coordinate(maxAllowedExtend
978                                                            .getMinX(), newArea.getMinY()), new Coordinate(
979                                                            newArea.getMaxX(), newArea.getMaxY()));
980    
981                                            // LOGGER.debug("and fix aspect ratio");
982    
983                                            newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
984                                                            false);
985                                    }
986                            }
987    
988                            // Exceeds to the left? move and maybe cut
989                            if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
990    
991                                    // Move right..
992                                    double divX = newArea.getMinX() - maxAllowedExtend.getMinX();
993                                    // LOGGER.debug("Moving area right by " + divX);
994    
995                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
996                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
997                                                    - divX, newArea.getMaxY()));
998    
999                                    if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
1000                                            // LOGGER.debug("Now it exeeds the right border.. cut!");
1001                                            // And cut the left if it moved out of the area
1002                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
1003                                                            newArea.getMinY()), new Coordinate(maxAllowedExtend
1004                                                            .getMaxX(), newArea.getMaxY()));
1005    
1006                                            // LOGGER.debug("and fix aspect ratio");
1007    
1008                                            newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea,
1009                                                            false);
1010                                    }
1011                            }
1012    
1013                    }
1014    
1015                  return new Envelope(ll, ur);                  return newArea;
1016          }          }
1017    
1018          /**          /**
# Line 1059  public class JMapPane extends JPanel imp Line 1039  public class JMapPane extends JPanel imp
1039    
1040          /**          /**
1041           * 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
1042           * the two.           * the two. If <code>null</code> is passed, Double.MINVALUE are used which
1043             * mean there is no restriction.
1044           *           *
1045           * @author <a href="mailto:[email protected]">Stefan Alfons           * @author <a href="mailto:[email protected]">Stefan Alfons
1046           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
1047           */           */
1048          public void setMaxZoomScale(final Double maxZoomScale) {          public void setMaxZoomScale(final Double maxZoomScale) {
1049                  // System.out.println("setting max scale to "+maxZoomScale);                  this.maxZoomScale = maxZoomScale == null ? Double.MIN_VALUE
1050                  this.maxZoomScale = maxZoomScale;                                  : maxZoomScale;
1051          }          }
1052    
1053          /**          /**
1054           * Set the minimum (nearest) allowed zoom scale. This is the bigger number           * Set the minimum (nearest) allowed zoom scale. This is the bigger number
1055           * value of the two.           * value of the two. If <code>null</code> is passed, Double.MAXVALUE are
1056             * used which mean there is no restriction.
1057             *
1058           *           *
1059           * @author <a href="mailto:[email protected]">Stefan Alfons           * @author <a href="mailto:[email protected]">Stefan Alfons
1060           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
1061           */           */
1062          public void setMinZoomScale(final Double minZoomScale) {          public void setMinZoomScale(final Double minZoomScale) {
1063                  this.minZoomScale = minZoomScale;                  this.minZoomScale = minZoomScale == null ? Double.MAX_VALUE
1064                                    : minZoomScale;
1065            }
1066    
1067            /**
1068             * Defines an evelope of the viwable area. The JMapPane will never show
1069             * anything outside of this extend.
1070             *
1071             * @param maxExtend
1072             *            <code>null</code> to not have this restriction.
1073             */
1074            public void setMaxExtend(Envelope maxExtend) {
1075                    this.maxExtend = maxExtend;
1076            }
1077    
1078            /**
1079             * Returns the evelope of the viewable area. The JMapPane will never show
1080             * anything outside of this extend. If this has been set to
1081             * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
1082             * quickly the context's bounds. It it takes to long to determine the
1083             * context bounds, <code>null</code> is returned.
1084             *
1085             * @param maxExtend
1086             *            <code>null</code> to not have this restriction.
1087             */
1088    
1089            public Envelope getMaxExtend() {
1090                    if (maxExtend == null) {
1091                            try {
1092                                    return JTSUtil.fixAspectRatio(this.getBounds(),
1093                                                    // Kartenbereich um 10% vergroessern
1094                                                    JTSUtil.expandEnvelope(context.getLayerBounds(), 0.1),
1095                                                    true);
1096                            } catch (IOException e) {
1097                                    LOGGER
1098                                                    .warn(
1099                                                                    "maxExtend == null; failed to getLayerBounds of context",
1100                                                                    e);
1101                            }
1102                    }
1103                    return maxExtend;
1104          }          }
         // xulu.en  
1105    
1106  }  }
Legend:
Removed from v.388  
changed lines
  Added in v.504
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26