/[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/swing/JMapPane.java revision 384 by alfonx, Fri Sep 11 16:16:38 2009 UTC branches/1.0-gt2-2.6/src/gtmig/org/geotools/swing/JMapPane.java revision 418 by alfonx, Mon Sep 28 15:36:11 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.swing;  package gtmig.org.geotools.swing;
17    
18  /**  /**
19   * <b>Xulu:<br>   * <b>Xulu:<br>
# Line 66  import org.geotools.renderer.label.Label Line 66  import org.geotools.renderer.label.Label
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;
68  import org.geotools.renderer.shape.ShapefileRenderer;  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;  
69  import org.opengis.filter.FilterFactory2;  import org.opengis.filter.FilterFactory2;
70  import org.opengis.referencing.crs.CoordinateReferenceSystem;  import org.opengis.referencing.crs.CoordinateReferenceSystem;
71    
# 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                    
234                  if (renderer instanceof StreamingRenderer || renderer instanceof ShapefileRenderer) {                  if (renderer instanceof StreamingRenderer
235                                    || renderer instanceof ShapefileRenderer) {
236                          hints = renderer.getRendererHints();                          hints = renderer.getRendererHints();
237                          if (hints == null) {                          if (hints == null) {
238                                  hints = new HashMap<Object,Object>();                                  hints = new HashMap<Object, Object>();
239                          }                          }
240                          if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {                          if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {
241                                  labelCache = (LabelCache) hints                                  labelCache = (LabelCache) hints
# Line 267  public class JMapPane extends JPanel imp Line 245  public class JMapPane extends JPanel imp
245                          }                          }
246    
247                          hints.put("memoryPreloadingEnabled", Boolean.TRUE);                          hints.put("memoryPreloadingEnabled", Boolean.TRUE);
248                            
249                          renderer.setRendererHints(hints);                          renderer.setRendererHints(hints);
250                  }                  }
251    
252  //              this.highlightRenderer = new StreamingRenderer();                  // this.highlightRenderer = new StreamingRenderer();
253  //              this.selectionRenderer = new StreamingRenderer();                  // this.selectionRenderer = new StreamingRenderer();
254    
255                    // highlightRenderer.setRendererHints(hints);
256                    // selectionRenderer.setRendererHints(hints);
257    
258  //              highlightRenderer.setRendererHints(hints);                  // renderer.setRendererHints(hints);
 //              selectionRenderer.setRendererHints(hints);  
                   
 //              renderer.setRendererHints(hints);  
259    
260                  if (this.context != null) {                  if (this.context != null) {
261                          this.renderer.setContext(this.context);                          this.renderer.setContext(this.context);
# Line 330  public class JMapPane extends JPanel imp Line 308  public class JMapPane extends JPanel imp
308                  this.zoomFactor = zoomFactor;                  this.zoomFactor = zoomFactor;
309          }          }
310    
   
311          protected void paintComponent(final Graphics g) {          protected void paintComponent(final Graphics g) {
312                  super.paintComponent(g);                  super.paintComponent(g);
313    
# Line 356  public class JMapPane extends JPanel imp Line 333  public class JMapPane extends JPanel imp
333                                  reset = false; /* forget about the reset */                                  reset = false; /* forget about the reset */
334                                  oldRect = r; /* store what the current size is */                                  oldRect = r; /* store what the current size is */
335    
336                                  mapArea = fixAspectRatio(r, mapArea);                                  mapArea = fixAspectRatio(r, mapArea, false);
337                          }                          }
338                  }                  }
339    
# Line 369  public class JMapPane extends JPanel imp Line 346  public class JMapPane extends JPanel imp
346                                          .getCoordinateReferenceSystem());                                          .getCoordinateReferenceSystem());
347                  }                  }
348    
349                  if (changed ) { /* if the map changed then redraw */                  if (changed) { /* if the map changed then redraw */
350                          changed = false;                          changed = false;
351                          baseImage = new BufferedImage(dr.width, dr.height,                          baseImage = new BufferedImage(dr.width, dr.height,
352                                          BufferedImage.TYPE_INT_ARGB);                                          BufferedImage.TYPE_INT_ARGB);
353    
354                          final Graphics2D ig = baseImage.createGraphics();                          final Graphics2D ig = baseImage.createGraphics();
355                          /* System.out.println("rendering"); */                          /* System.out.println("rendering"); */
356                          if (renderer.getContext() != null)                          if (renderer.getContext() != null)
357                                  renderer.setContext(context);                                  renderer.setContext(context);
358                          labelCache.clear(); // work around anoying labelcache bug                          labelCache.clear(); // work around anoying labelcache bug
359    
# Line 392  public class JMapPane extends JPanel imp Line 369  public class JMapPane extends JPanel imp
369                  ((Graphics2D) g).drawImage(baseImage, 0, 0, this);                  ((Graphics2D) g).drawImage(baseImage, 0, 0, this);
370          }          }
371    
372          private Envelope fixAspectRatio(final Rectangle r, final Envelope mapArea) {          /**
373             * Returns an {@link Envelope} that has the same aspect ratio as the given rectangle
374             * @param grow
375             *            If <code>true</code>, than the area will be enlarged to match
376             *            the aspect ratio. If <code>false</code>, it will only shrink.
377             */
378            private Envelope fixAspectRatio(final Rectangle r, final Envelope mapArea,
379                            boolean grow) {
380    
381                  final double mapWidth = mapArea.getWidth(); /* get the extent of the map */                  final double mapWidth = mapArea.getWidth(); /* get the extent of the map */
382                  final double mapHeight = mapArea.getHeight();                  final double mapHeight = mapArea.getHeight();
383                  final double scaleX = r.getWidth() / mapArea.getWidth(); /*                  final double scaleX = r.getWidth() / mapArea.getWidth(); /*
384                                                                                                                           * calculate the new                                                                                                                                   * calculate the
385                                                                                                                           * scale                                                                                                                                   * new scale
386                                                                                                                           */                                                                                                                                   */
387    
388                  final double scaleY = r.getHeight() / mapArea.getHeight();                  final double scaleY = r.getHeight() / mapArea.getHeight();
389                  double scale = 1.0; // stupid compiler!                  double scale = 1.0; // stupid compiler!
390    
391                  if (scaleX < scaleY) { /* pick the smaller scale */                  if ((grow && scaleX < scaleY) || (!grow && scaleX > scaleY)) {
392                          scale = scaleX;                          scale = scaleX;
393                  } else {                  } else {
394                          scale = scaleY;                          scale = scaleY;
# Line 420  public class JMapPane extends JPanel imp Line 404  public class JMapPane extends JPanel imp
404                   */                   */
405    
406                  /* create the new extent */                  /* create the new extent */
407                  final Coordinate ll = new Coordinate(mapArea.getMinX() - (deltaX / 2.0),                  final Coordinate ll = new Coordinate(
408                                  mapArea.getMinY() - (deltaY / 2.0));                                  mapArea.getMinX() - (deltaX / 2.0), mapArea.getMinY()
409                  final Coordinate ur = new Coordinate(mapArea.getMaxX() + (deltaX / 2.0),                                                  - (deltaY / 2.0));
410                                  mapArea.getMaxY() + (deltaY / 2.0));                  final Coordinate ur = new Coordinate(
411                                    mapArea.getMaxX() + (deltaX / 2.0), mapArea.getMaxY()
412                                                    + (deltaY / 2.0));
413    
414                  return new Envelope(ll, ur);                  return new Envelope(ll, ur);
415          }          }
416    
 //      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;  
 //      }  
   
417          public void mouseClicked(final MouseEvent e) {          public void mouseClicked(final MouseEvent e) {
418                  if (mapArea == null) return;                  if (mapArea == null)
419                            return;
420                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"
421                  // h:"+mapArea.getHeight());                  // h:"+mapArea.getHeight());
422                  final Rectangle bounds = this.getBounds();                  final Rectangle bounds = this.getBounds();
# Line 519  public class JMapPane extends JPanel imp Line 430  public class JMapPane extends JPanel imp
430                  final double width2 = width / 2.0;                  final double width2 = width / 2.0;
431                  final double height2 = height / 2.0;                  final double height2 = height / 2.0;
432                  // xulu.ec                  // xulu.ec
433                  final double mapX = ((x * width) / (double) bounds.width) + mapArea.getMinX();                  final double mapX = ((x * width) / (double) bounds.width)
434                                    + mapArea.getMinX();
435                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)
436                                  + mapArea.getMinY();                                  + mapArea.getMinY();
437    
# Line 550  public class JMapPane extends JPanel imp Line 462  public class JMapPane extends JPanel imp
462                          zlevel = 1.0 / zoomFactor;                          zlevel = 1.0 / zoomFactor;
463    
464                          break;                          break;
465  //                  //
466  //              case Select:                  // case Select:
467  //                      doSelection(mapX, mapY, selectionLayer);                  // doSelection(mapX, mapY, selectionLayer);
468  //                  //
469  //                      return;                  // return;
470    
471                  default:                  default:
472                          return;                          return;
# Line 626  public class JMapPane extends JPanel imp Line 538  public class JMapPane extends JPanel imp
538                                  // System.out.println("translate "+dx+","+dy);                                  // System.out.println("translate "+dx+","+dy);
539                                  final Graphics2D g2 = panningImage.createGraphics();                                  final Graphics2D g2 = panningImage.createGraphics();
540                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige
541                                                                                                                          // farbe? am besten                                  // farbe? am besten
542                                                                                                                          // vom L&F die                                  // vom L&F die
543                                                                                                                          // hintergrundfarbe                                  // hintergrundfarbe
544                                                                                                                          // auslesen...                                  // auslesen...
545                                    
546                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());
547                                  g2.drawImage(baseImage, dx, dy, this);                                  g2.drawImage(baseImage, dx, dy, this);
548                                  graphics.drawImage(panningImage, 0, 0, this);                                  graphics.drawImage(panningImage, 0, 0, this);
# Line 652  public class JMapPane extends JPanel imp Line 564  public class JMapPane extends JPanel imp
564                          lastX = x;                          lastX = x;
565                          lastY = y;                          lastY = y;
566                          drawRectangle(graphics);                          drawRectangle(graphics);
567                  }                  }
568  //              else if (state == JMapPane.Select && selectionLayer != null) {                  // else if (state == JMapPane.Select && selectionLayer != null) {
569  //                  //
570  //                      // construct a new bbox filter                  // // construct a new bbox filter
571  //                      final Rectangle bounds = this.getBounds();                  // final Rectangle bounds = this.getBounds();
572  //                  //
573  //                      final double mapWidth = mapArea.getWidth();                  // final double mapWidth = mapArea.getWidth();
574  //                      final double mapHeight = mapArea.getHeight();                  // final double mapHeight = mapArea.getHeight();
575  //                  //
576  //                      final double x1 = ((this.startX * mapWidth) / (double) bounds.width)                  // final double x1 = ((this.startX * mapWidth) / (double) bounds.width)
577  //                                      + mapArea.getMinX();                  // + mapArea.getMinX();
578  //                      final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) / (double) bounds.height)                  // final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) /
579  //                                      + mapArea.getMinY();                  // (double) bounds.height)
580  //                      final double x2 = ((x * mapWidth) / (double) bounds.width)                  // + mapArea.getMinY();
581  //                                      + mapArea.getMinX();                  // final double x2 = ((x * mapWidth) / (double) bounds.width)
582  //                      final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double) bounds.height)                  // + mapArea.getMinX();
583  //                                      + mapArea.getMinY();                  // final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double)
584  //                      final double left = Math.min(x1, x2);                  // bounds.height)
585  //                      final double right = Math.max(x1, x2);                  // + mapArea.getMinY();
586  //                      final double bottom = Math.min(y1, y2);                  // final double left = Math.min(x1, x2);
587  //                      final double top = Math.max(y1, y2);                  // final double right = Math.max(x1, x2);
588  //                  // final double bottom = Math.min(y1, y2);
589  //                      String name = selectionLayer.getFeatureSource().getSchema()                  // final double top = Math.max(y1, y2);
590  //                                      .getDefaultGeometry().getName();                  //
591  //                  // String name = selectionLayer.getFeatureSource().getSchema()
592  //                      if (name == "") {                  // .getDefaultGeometry().getName();
593  //                              name = "the_geom";                  //
594  //                      }                  // if (name == "") {
595  //                      final Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,                  // name = "the_geom";
596  //                                      getContext().getCoordinateReferenceSystem().toString());                  // }
597  //                      if (selectionManager != null) {                  // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
598  //                              selectionManager.selectionChanged(this, bb);                  // top,
599  //                      }                  // getContext().getCoordinateReferenceSystem().toString());
600  //                  // if (selectionManager != null) {
601  //                      graphics.setXORMode(Color.green);                  // selectionManager.selectionChanged(this, bb);
602  //                  // }
603  //                      /*                  //
604  //                       * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }                  // graphics.setXORMode(Color.green);
605  //                       */                  //
606  //                  // /*
607  //                      // draw new box                  // * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }
608  //                      lastX = x;                  // */
609  //                      lastY = y;                  //
610  //                      drawRectangle(graphics);                  // // draw new box
611  //              }                  // lastX = x;
612                    // lastY = y;
613                    // drawRectangle(graphics);
614                    // }
615    
616          }          }
617    
# Line 757  public class JMapPane extends JPanel imp Line 672  public class JMapPane extends JPanel imp
672                          final Coordinate ur = new Coordinate(right, top);                          final Coordinate ur = new Coordinate(right, top);
673                          // xulu.sc                          // xulu.sc
674                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
675                          setMapArea(fixAspectRatio(this.getBounds(), new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
676                          // xulu.ec                          // xulu.ec
677                  } else if (state == JMapPane.ZoomIn) {                  } else if (state == JMapPane.ZoomIn) {
678    
# Line 781  public class JMapPane extends JPanel imp Line 696  public class JMapPane extends JPanel imp
696                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
697    
698                          // sk.sc                          // sk.sc
699  //                      {                          // {
700  //                      // SK tries to paint a preview of the zoom ;-9 aha.... well                          // // SK tries to paint a preview of the zoom ;-9 aha.... well
701  //                      Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();                          // Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();
702  //                      graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,                          // graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
703  //                                      RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);                          // RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
704  //                      graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,                          // graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
705  //                                      RenderingHints.VALUE_ANTIALIAS_OFF);                          // RenderingHints.VALUE_ANTIALIAS_OFF);
706  //                      graphics.setRenderingHint(RenderingHints.KEY_RENDERING,                          // graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
707  //                                      RenderingHints.VALUE_RENDER_SPEED);                          // RenderingHints.VALUE_RENDER_SPEED);
708  //                      graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),                          // graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),
709  //                                      JMapPane.this.getHeight(), x1, y1, x2, y2, null);                          // JMapPane.this.getHeight(), x1, y1, x2, y2, null);
710  //                      }                          // }
711                          // xulu.ec                          // xulu.ec
712                  } else if (state == JMapPane.ZoomOut) {                  } else if (state == JMapPane.ZoomOut) {
713                          drawRectangle(this.getGraphics());                          drawRectangle(this.getGraphics());
# Line 821  public class JMapPane extends JPanel imp Line 736  public class JMapPane extends JPanel imp
736                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
737    
738                          // xulu.ec                          // xulu.ec
739                  }                  }
740  //              else if (state == JMapPane.Select && selectionLayer != null) {                  // else if (state == JMapPane.Select && selectionLayer != null) {
741  //                      final double left = Math.min(startX, endX);                  // final double left = Math.min(startX, endX);
742  //                      final double right = Math.max(startX, endX);                  // final double right = Math.max(startX, endX);
743  //                      final double bottom = Math.min(startY, endY);                  // final double bottom = Math.min(startY, endY);
744  //                      final double top = Math.max(startY, endY);                  // final double top = Math.max(startY, endY);
745  //                  //
746  //                      String name = selectionLayer.getFeatureSource().getSchema()                  // String name = selectionLayer.getFeatureSource().getSchema()
747  //                                      .getDefaultGeometry().getLocalName();                  // .getDefaultGeometry().getLocalName();
748  //                  //
749  //                      if (name == "") {                  // if (name == "") {
750  //                              name = "the_geom";                  // name = "the_geom";
751  //                      }                  // }
752  //                      final Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,                  // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
753  //                                      getContext().getCoordinateReferenceSystem().toString());                  // top,
754  //                      // System.out.println(bb.toString());                  // getContext().getCoordinateReferenceSystem().toString());
755  //                      if (selectionManager != null) {                  // // System.out.println(bb.toString());
756  //                              selectionManager.selectionChanged(this, bb);                  // if (selectionManager != null) {
757  //                      }                  // selectionManager.selectionChanged(this, bb);
758  //                      /*                  // }
759  //                       * FeatureCollection fc; selection = null; try { fc =                  // /*
760  //                       * selectionLayer.getFeatureSource().getFeatures(bb); selection =                  // * FeatureCollection fc; selection = null; try { fc =
761  //                       * fc; } catch (IOException e) { e.printStackTrace(); }                  // * selectionLayer.getFeatureSource().getFeatures(bb); selection =
762  //                       */                  // * fc; } catch (IOException e) { e.printStackTrace(); }
763  //              }                  // */
764                    // }
765    
766                  // xulu.so                  // xulu.so
767                  // setMapArea(mapArea);                  // setMapArea(mapArea);
# Line 857  public class JMapPane extends JPanel imp Line 773  public class JMapPane extends JPanel imp
773                  return clickable;                  return clickable;
774          }          }
775    
776          private org.geotools.styling.Style setupStyle(final int type, final Color color) {          //
777                  final StyleFactory sf = org.geotools.factory.CommonFactoryFinder          // private org.geotools.styling.Style setupStyle(final int type, final Color
778                                  .getStyleFactory(null);          // color) {
779                  final StyleBuilder sb = new StyleBuilder();          // final StyleFactory sf = org.geotools.factory.CommonFactoryFinder
780            // .getStyleFactory(null);
781                  org.geotools.styling.Style s = sf.createStyle();          // final StyleBuilder sb = new StyleBuilder();
782                  s.setTitle("selection");          //
783            // org.geotools.styling.Style s = sf.createStyle();
784                  // TODO parameterise the color          // s.setTitle("selection");
785                  final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);          //
786                  ps.setStroke(sb.createStroke(color));          // // TODO parameterise the color
787            // final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);
788                  final LineSymbolizer ls = sb.createLineSymbolizer(color);          // ps.setStroke(sb.createStroke(color));
789                  final Graphic h = sb.createGraphic();          //
790                  h.setMarks(new Mark[] { sb.createMark("square", color) });          // final LineSymbolizer ls = sb.createLineSymbolizer(color);
791            // final Graphic h = sb.createGraphic();
792                  final PointSymbolizer pts = sb.createPointSymbolizer(h);          // h.setMarks(new Mark[] { sb.createMark("square", color) });
793            //
794                  // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});          // final PointSymbolizer pts = sb.createPointSymbolizer(h);
795                  switch (type) {          //
796                  case POLYGON:          // // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});
797                          s = sb.createStyle(ps);          // switch (type) {
798            // case POLYGON:
799                          break;          // s = sb.createStyle(ps);
800            //
801                  case POINT:          // break;
802                          s = sb.createStyle(pts);          //
803            // case POINT:
804                          break;          // s = sb.createStyle(pts);
805            //
806                  case LINE:          // break;
807                          s = sb.createStyle(ls);          //
808                  }          // case LINE:
809            // s = sb.createStyle(ls);
810                  return s;          // }
811          }          //
812            // return s;
813            // }
814    
815          public void propertyChange(final PropertyChangeEvent evt) {          public void propertyChange(final PropertyChangeEvent evt) {
816                  final String prop = evt.getPropertyName();                  final String prop = evt.getPropertyName();
# Line 977  public class JMapPane extends JPanel imp Line 894  public class JMapPane extends JPanel imp
894          public void mouseMoved(final MouseEvent e) {          public void mouseMoved(final MouseEvent e) {
895          }          }
896    
   
   
897          // xulu.sn          // xulu.sn
898          /**          /**
899           * 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 912  public class JMapPane extends JPanel imp
912                  if (env == null)                  if (env == null)
913                          return env;                          return env;
914    
915                    Envelope newArea = null;
916    
917                  /**                  /**
918                   * Correct the aspect Ratio before we check the rest. Otherwise we might                   * Correct the aspect Ratio before we check the rest. Otherwise we might
919                   * easily fail.                   * easily fail.
920                   */                   */
921                  env = fixAspectRatio(this.getBounds(), env);                  env = fixAspectRatio(this.getBounds(), env, false);
922    
923                  final double scale = env.getWidth() / getWidth();                  final double scale = env.getWidth() / getWidth();
924                  final double centerX = env.getMinX() + env.getWidth() / 2.;                  final double centerX = env.getMinX() + env.getWidth() / 2.;
925                  final double centerY = env.getMinY() + env.getHeight() / 2.;                  final double centerY = env.getMinY() + env.getHeight() / 2.;
926                  double newWidth2;                  double newWidth2 = 0;
927                  double newHeight2;                  double newHeight2 = 0;
928                  if (scale < getMaxZoomScale()) {                  if (scale < getMaxZoomScale()) {
929                          // ****************************************************************************                          // ****************************************************************************
930                          // 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 941  public class JMapPane extends JPanel imp
941                          // ****************************************************************************                          // ****************************************************************************
942                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
943                          // ****************************************************************************                          // ****************************************************************************
944                          return env;                          newArea = env;
945                  }                  }
946    
947                  final Coordinate ll = new Coordinate(centerX - newWidth2, centerY                  if (newArea == null) {
                                 - newHeight2);  
                 final Coordinate ur = new Coordinate(centerX + newWidth2, centerY  
                                 + newHeight2);  
948    
949                  return new Envelope(ll, ur);                          final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
950                                            - newHeight2);
951                            final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
952                                            + newHeight2);
953    
954                            newArea = new Envelope(ll, ur);
955                    }
956    
957                    Envelope maxAllowedExtend = getMaxExtend();
958                    while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea)) {
959                            /*
960                             * If a maxExtend is set, we have to honour that...
961                             */
962    
963                            // Exceeds top? Move down and maybe cut
964                            if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
965                                    double divY = newArea.getMaxY() - maxAllowedExtend.getMaxY();
966                                    LOGGER.debug("Moving area down by " + divY);
967    
968                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
969                                                    newArea.getMinY() - divY), new Coordinate(newArea
970                                                    .getMaxX(), newArea.getMaxY() - divY));
971    
972                                    if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
973                                            LOGGER.debug("Now it exeeds the bottom border.. cut!");
974                                            // And cut the bottom if it moved out of the area
975                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
976                                                            maxAllowedExtend.getMinY()), new Coordinate(newArea
977                                                            .getMaxX(), newArea.getMaxY()));
978    
979                                            LOGGER.debug("and fix aspect ratio");
980    
981                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
982                                    }
983                            }
984    
985                            // Exceeds bottom? Move up and maybe cut
986                            if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
987                                    double divY = newArea.getMinY() - maxAllowedExtend.getMinY();
988                                    LOGGER.debug("Moving area up by " + divY);
989    
990                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
991                                                    newArea.getMinY() - divY), new Coordinate(newArea
992                                                    .getMaxX(), newArea.getMaxY() - divY));
993    
994                                    if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
995                                            LOGGER.debug("Now it exeeds the top border.. cut!");
996                                            // And cut the bottom if it moved out of the area
997                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
998                                                            newArea.getMinY()), new Coordinate(newArea
999                                                            .getMaxX(), maxAllowedExtend.getMaxY()));
1000    
1001                                            LOGGER.debug("and fix aspect ratio");
1002    
1003                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
1004                                    }
1005                            }
1006    
1007                            // Exceeds to the right? move and maybe cut
1008                            if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
1009    
1010                                    // Move left..
1011                                    double divX = newArea.getMaxX() - maxAllowedExtend.getMaxX();
1012                                    LOGGER.debug("Moving area left by " + divX);
1013    
1014                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
1015                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
1016                                                    - divX, newArea.getMaxY()));
1017    
1018                                    if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
1019                                            LOGGER.debug("Now it exeeds the left border.. cut!");
1020                                            // And cut the left if it moved out of the area
1021                                            newArea = new Envelope(new Coordinate(maxExtend.getMinX(),
1022                                                            newArea.getMinY()), new Coordinate(newArea
1023                                                            .getMaxX(), newArea.getMaxY()));
1024    
1025                                            LOGGER.debug("and fix aspect ratio");
1026    
1027                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
1028                                    }
1029                            }
1030    
1031                            // Exceeds to the left? move and maybe cut
1032                            if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
1033    
1034                                    // Move right..
1035                                    double divX = newArea.getMinX() - maxAllowedExtend.getMinX();
1036                                    LOGGER.debug("Moving area right by " + divX);
1037    
1038                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
1039                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
1040                                                    - divX, newArea.getMaxY()));
1041    
1042                                    if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
1043                                            LOGGER.debug("Now it exeeds the right border.. cut!");
1044                                            // And cut the left if it moved out of the area
1045                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
1046                                                            newArea.getMinY()), new Coordinate(maxAllowedExtend
1047                                                            .getMaxX(), newArea.getMaxY()));
1048    
1049                                            LOGGER.debug("and fix aspect ratio");
1050    
1051                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
1052                                    }
1053                            }
1054    
1055                    }
1056    
1057                    return newArea;
1058          }          }
1059    
1060          /**          /**
# Line 1065  public class JMapPane extends JPanel imp Line 1087  public class JMapPane extends JPanel imp
1087           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
1088           */           */
1089          public void setMaxZoomScale(final Double maxZoomScale) {          public void setMaxZoomScale(final Double maxZoomScale) {
                 // System.out.println("setting max scale to "+maxZoomScale);  
1090                  this.maxZoomScale = maxZoomScale;                  this.maxZoomScale = maxZoomScale;
1091          }          }
1092    
# Line 1079  public class JMapPane extends JPanel imp Line 1100  public class JMapPane extends JPanel imp
1100          public void setMinZoomScale(final Double minZoomScale) {          public void setMinZoomScale(final Double minZoomScale) {
1101                  this.minZoomScale = minZoomScale;                  this.minZoomScale = minZoomScale;
1102          }          }
1103          // xulu.en  
1104            /**
1105             * Defines an evelope of the viwable area. The JMapPane will never show
1106             * anything outside of this extend.
1107             *
1108             * @param maxExtend
1109             *            <code>null</code> to not have this restriction.
1110             */
1111            public void setMaxExtend(Envelope maxExtend) {
1112                    this.maxExtend = maxExtend;
1113            }
1114    
1115            /**
1116             * Returns the evelope of the viewable area. The JMapPane will never show
1117             * anything outside of this extend. If this has been set to
1118             * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
1119             * quickly the context's bounds. It it takes to long to determine the
1120             * context bounds, <code>null</code> is returned.
1121             *
1122             * @param maxExtend
1123             *            <code>null</code> to not have this restriction.
1124             */
1125    
1126            public Envelope getMaxExtend() {
1127                    if (maxExtend == null) {
1128                            try {
1129                                    return fixAspectRatio(this.getBounds(), context.getLayerBounds(), true);
1130                            } catch (IOException e) {
1131                                    LOGGER
1132                                                    .warn(
1133                                                                    "maxExtend == null; faild to getLayerBounds of context",
1134                                                                    e);
1135                            }
1136                    }
1137                    return maxExtend;
1138            }
1139    
1140  }  }
Legend:
Removed from v.384  
changed lines
  Added in v.418
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26