/[schmitzm]/trunk/src/skrueger/geotools/XMapPane.java
ViewVC logotype

Diff of /trunk/src/skrueger/geotools/XMapPane.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

branches/1.0-gt2-2.6/src/org/geotools/gui/swing/JMapPane.java revision 341 by alfonx, Mon Aug 31 10:16:40 2009 UTC branches/1.0-gt2-2.6/src/gtmig/org/geotools/swing/JMapPane.java revision 485 by mojays, Tue Oct 20 16:22:47 2009 UTC
# Line 13  Line 13 
13   *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU   *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14   *    Lesser General Public License for more details.   *    Lesser General Public License for more details.
15   */   */
16  package org.geotools.gui.swing;  package gtmig.org.geotools.swing;
17    
18  /**  /**
19   * <b>Xulu:<br>   * <b>Xulu:<br>
# Line 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.TransitionShapefileRenderer;  
 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 hints = new HashMap();                  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 TransitionShapefileRenderer) {  //              if (renderer instanceof StreamingRenderer) {
235                          hints = renderer.getRendererHints();                          hints = renderer.getRendererHints();
236                          if (hints == null) {                          if (hints == null) {
237                                  hints = new HashMap();                                  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
# Line 267  public class JMapPane extends JPanel imp Line 244  public class JMapPane extends JPanel imp
244                          }                          }
245    
246                          hints.put("memoryPreloadingEnabled", Boolean.TRUE);                          hints.put("memoryPreloadingEnabled", Boolean.TRUE);
                           
                         renderer.setRendererHints(hints);  
                 }  
247    
248  //              this.highlightRenderer = new StreamingRenderer();                          renderer.setRendererHints(hints);
249  //              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 = 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    
363          private Envelope fixAspectRatio(final Rectangle r, final Envelope mapArea) {          /**
364             * Returns an {@link Envelope} that has the same aspect ratio as the given rectangle
365             * @param grow
366             *            If <code>true</code>, than the area will be enlarged to match
367             *            the aspect ratio. If <code>false</code>, it will only shrink.
368             */
369            private Envelope fixAspectRatio(final Rectangle r, final Envelope mapArea,
370                            boolean grow) {
371                    
372                    if (mapArea == null) {
373                            LOGGER.warn("mapArea has been null in method fixAspectRatio, returning an unmodified ");
374                    }
375    
376                  final double mapWidth = mapArea.getWidth(); /* get the extent of the map */                  final double mapWidth = mapArea.getWidth(); /* get the extent of the map */
377                  final double mapHeight = mapArea.getHeight();                  final double mapHeight = mapArea.getHeight();
378                  final double scaleX = r.getWidth() / mapArea.getWidth(); /*                  final double scaleX = r.getWidth() / mapArea.getWidth(); /*
379                                                                                                                           * calculate the new                                                                                                                                   * calculate the
380                                                                                                                           * scale                                                                                                                                   * new scale
381                                                                                                                           */                                                                                                                                   */
382    
383                  final double scaleY = r.getHeight() / mapArea.getHeight();                  final double scaleY = r.getHeight() / mapArea.getHeight();
384                  double scale = 1.0; // stupid compiler!                  double scale = 1.0; // stupid compiler!
385    
386                  if (scaleX < scaleY) { /* pick the smaller scale */                  if ((grow && scaleX < scaleY) || (!grow && scaleX > scaleY)) {
387                          scale = scaleX;                          scale = scaleX;
388                  } else {                  } else {
389                          scale = scaleY;                          scale = scaleY;
# Line 420  public class JMapPane extends JPanel imp Line 399  public class JMapPane extends JPanel imp
399                   */                   */
400    
401                  /* create the new extent */                  /* create the new extent */
402                  final Coordinate ll = new Coordinate(mapArea.getMinX() - (deltaX / 2.0),                  final Coordinate ll = new Coordinate(
403                                  mapArea.getMinY() - (deltaY / 2.0));                                  mapArea.getMinX() - (deltaX / 2.0), mapArea.getMinY()
404                  final Coordinate ur = new Coordinate(mapArea.getMaxX() + (deltaX / 2.0),                                                  - (deltaY / 2.0));
405                                  mapArea.getMaxY() + (deltaY / 2.0));                  final Coordinate ur = new Coordinate(
406                                    mapArea.getMaxX() + (deltaX / 2.0), mapArea.getMaxY()
407                                                    + (deltaY / 2.0));
408    
409                  return new Envelope(ll, ur);                  return new Envelope(ll, ur);
410          }          }
411    
 //      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;  
 //      }  
   
412          public void mouseClicked(final MouseEvent e) {          public void mouseClicked(final MouseEvent e) {
413                  if (mapArea == null) return;                  if (mapArea == null)
414                            return;
415                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"
416                  // h:"+mapArea.getHeight());                  // h:"+mapArea.getHeight());
417                  final Rectangle bounds = this.getBounds();                  final Rectangle bounds = this.getBounds();
# Line 519  public class JMapPane extends JPanel imp Line 425  public class JMapPane extends JPanel imp
425                  final double width2 = width / 2.0;                  final double width2 = width / 2.0;
426                  final double height2 = height / 2.0;                  final double height2 = height / 2.0;
427                  // xulu.ec                  // xulu.ec
428                  final double mapX = ((x * width) / (double) bounds.width) + mapArea.getMinX();                  final double mapX = ((x * width) / (double) bounds.width)
429                                    + mapArea.getMinX();
430                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)
431                                  + mapArea.getMinY();                                  + mapArea.getMinY();
432    
# Line 550  public class JMapPane extends JPanel imp Line 457  public class JMapPane extends JPanel imp
457                          zlevel = 1.0 / zoomFactor;                          zlevel = 1.0 / zoomFactor;
458    
459                          break;                          break;
460  //                  //
461  //              case Select:                  // case Select:
462  //                      doSelection(mapX, mapY, selectionLayer);                  // doSelection(mapX, mapY, selectionLayer);
463  //                  //
464  //                      return;                  // return;
465    
466                  default:                  default:
467                          return;                          return;
# Line 626  public class JMapPane extends JPanel imp Line 533  public class JMapPane extends JPanel imp
533                                  // System.out.println("translate "+dx+","+dy);                                  // System.out.println("translate "+dx+","+dy);
534                                  final Graphics2D g2 = panningImage.createGraphics();                                  final Graphics2D g2 = panningImage.createGraphics();
535                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige
536                                                                                                                          // farbe? am besten                                  // farbe? am besten
537                                                                                                                          // vom L&F die                                  // vom L&F die
538                                                                                                                          // hintergrundfarbe                                  // hintergrundfarbe
539                                                                                                                          // auslesen...                                  // auslesen...
540                                    
541                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());
542                                  g2.drawImage(baseImage, dx, dy, this);                                  g2.drawImage(baseImage, dx, dy, this);
543                                  graphics.drawImage(panningImage, 0, 0, this);                                  graphics.drawImage(panningImage, 0, 0, this);
# Line 652  public class JMapPane extends JPanel imp Line 559  public class JMapPane extends JPanel imp
559                          lastX = x;                          lastX = x;
560                          lastY = y;                          lastY = y;
561                          drawRectangle(graphics);                          drawRectangle(graphics);
562                  }                  }
563  //              else if (state == JMapPane.Select && selectionLayer != null) {                  // else if (state == JMapPane.Select && selectionLayer != null) {
564  //                  //
565  //                      // construct a new bbox filter                  // // construct a new bbox filter
566  //                      final Rectangle bounds = this.getBounds();                  // final Rectangle bounds = this.getBounds();
567  //                  //
568  //                      final double mapWidth = mapArea.getWidth();                  // final double mapWidth = mapArea.getWidth();
569  //                      final double mapHeight = mapArea.getHeight();                  // final double mapHeight = mapArea.getHeight();
570  //                  //
571  //                      final double x1 = ((this.startX * mapWidth) / (double) bounds.width)                  // final double x1 = ((this.startX * mapWidth) / (double) bounds.width)
572  //                                      + mapArea.getMinX();                  // + mapArea.getMinX();
573  //                      final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) / (double) bounds.height)                  // final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) /
574  //                                      + mapArea.getMinY();                  // (double) bounds.height)
575  //                      final double x2 = ((x * mapWidth) / (double) bounds.width)                  // + mapArea.getMinY();
576  //                                      + mapArea.getMinX();                  // final double x2 = ((x * mapWidth) / (double) bounds.width)
577  //                      final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double) bounds.height)                  // + mapArea.getMinX();
578  //                                      + mapArea.getMinY();                  // final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double)
579  //                      final double left = Math.min(x1, x2);                  // bounds.height)
580  //                      final double right = Math.max(x1, x2);                  // + mapArea.getMinY();
581  //                      final double bottom = Math.min(y1, y2);                  // final double left = Math.min(x1, x2);
582  //                      final double top = Math.max(y1, y2);                  // final double right = Math.max(x1, x2);
583  //                  // final double bottom = Math.min(y1, y2);
584  //                      String name = selectionLayer.getFeatureSource().getSchema()                  // final double top = Math.max(y1, y2);
585  //                                      .getDefaultGeometry().getName();                  //
586  //                  // String name = selectionLayer.getFeatureSource().getSchema()
587  //                      if (name == "") {                  // .getDefaultGeometry().getName();
588  //                              name = "the_geom";                  //
589  //                      }                  // if (name == "") {
590  //                      final Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,                  // name = "the_geom";
591  //                                      getContext().getCoordinateReferenceSystem().toString());                  // }
592  //                      if (selectionManager != null) {                  // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
593  //                              selectionManager.selectionChanged(this, bb);                  // top,
594  //                      }                  // getContext().getCoordinateReferenceSystem().toString());
595  //                  // if (selectionManager != null) {
596  //                      graphics.setXORMode(Color.green);                  // selectionManager.selectionChanged(this, bb);
597  //                  // }
598  //                      /*                  //
599  //                       * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }                  // graphics.setXORMode(Color.green);
600  //                       */                  //
601  //                  // /*
602  //                      // draw new box                  // * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }
603  //                      lastX = x;                  // */
604  //                      lastY = y;                  //
605  //                      drawRectangle(graphics);                  // // draw new box
606  //              }                  // lastX = x;
607                    // lastY = y;
608                    // drawRectangle(graphics);
609                    // }
610    
611          }          }
612    
# Line 706  public class JMapPane extends JPanel imp Line 616  public class JMapPane extends JPanel imp
616          protected void processDrag(final int x1, final int y1, final int x2,          protected void processDrag(final int x1, final int y1, final int x2,
617                          final int y2, final MouseEvent e) {                          final int y2, final MouseEvent e) {
618    
619    
620                  /****                  /****
621                   * If no layer is availabe we dont want a NullPointerException                   * If no layers exist, we ignore the drag.
622                   */                   */
623                  if (mapArea == null)                  if (context.getLayerCount() <= 0) {
624                          return;                          return;
625                    }
626                    
627                  // System.out.println("processing drag from " + x1 + "," + y1 + " -> "                  // System.out.println("processing drag from " + x1 + "," + y1 + " -> "
628                  // + x2 + "," + y2);                  // + x2 + "," + y2);
629                  if ((x1 == x2) && (y1 == y2)) {                  if ((x1 == x2) && (y1 == y2)) {
# Line 757  public class JMapPane extends JPanel imp Line 669  public class JMapPane extends JPanel imp
669                          final Coordinate ur = new Coordinate(right, top);                          final Coordinate ur = new Coordinate(right, top);
670                          // xulu.sc                          // xulu.sc
671                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
672                          setMapArea(fixAspectRatio(this.getBounds(), new Envelope(ll, ur)));                          
673    
674                            setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
675                          // xulu.ec                          // xulu.ec
676                  } else if (state == JMapPane.ZoomIn) {                  } else if (state == JMapPane.ZoomIn) {
677    
# Line 781  public class JMapPane extends JPanel imp Line 695  public class JMapPane extends JPanel imp
695                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
696    
697                          // sk.sc                          // sk.sc
698  //                      {                          // {
699  //                      // SK tries to paint a preview of the zoom ;-9 aha.... well                          // // SK tries to paint a preview of the zoom ;-9 aha.... well
700  //                      Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();                          // Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();
701  //                      graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,                          // graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
702  //                                      RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);                          // RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
703  //                      graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,                          // graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
704  //                                      RenderingHints.VALUE_ANTIALIAS_OFF);                          // RenderingHints.VALUE_ANTIALIAS_OFF);
705  //                      graphics.setRenderingHint(RenderingHints.KEY_RENDERING,                          // graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
706  //                                      RenderingHints.VALUE_RENDER_SPEED);                          // RenderingHints.VALUE_RENDER_SPEED);
707  //                      graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),                          // graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),
708  //                                      JMapPane.this.getHeight(), x1, y1, x2, y2, null);                          // JMapPane.this.getHeight(), x1, y1, x2, y2, null);
709  //                      }                          // }
710                          // xulu.ec                          // xulu.ec
711                  } else if (state == JMapPane.ZoomOut) {                  } else if (state == JMapPane.ZoomOut) {
712                          drawRectangle(this.getGraphics());                          drawRectangle(this.getGraphics());
# Line 821  public class JMapPane extends JPanel imp Line 735  public class JMapPane extends JPanel imp
735                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
736    
737                          // xulu.ec                          // xulu.ec
738                  }                  }
739  //              else if (state == JMapPane.Select && selectionLayer != null) {                  // else if (state == JMapPane.Select && selectionLayer != null) {
740  //                      final double left = Math.min(startX, endX);                  // final double left = Math.min(startX, endX);
741  //                      final double right = Math.max(startX, endX);                  // final double right = Math.max(startX, endX);
742  //                      final double bottom = Math.min(startY, endY);                  // final double bottom = Math.min(startY, endY);
743  //                      final double top = Math.max(startY, endY);                  // final double top = Math.max(startY, endY);
744  //                  //
745  //                      String name = selectionLayer.getFeatureSource().getSchema()                  // String name = selectionLayer.getFeatureSource().getSchema()
746  //                                      .getDefaultGeometry().getLocalName();                  // .getDefaultGeometry().getLocalName();
747  //                  //
748  //                      if (name == "") {                  // if (name == "") {
749  //                              name = "the_geom";                  // name = "the_geom";
750  //                      }                  // }
751  //                      final Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,                  // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
752  //                                      getContext().getCoordinateReferenceSystem().toString());                  // top,
753  //                      // System.out.println(bb.toString());                  // getContext().getCoordinateReferenceSystem().toString());
754  //                      if (selectionManager != null) {                  // // System.out.println(bb.toString());
755  //                              selectionManager.selectionChanged(this, bb);                  // if (selectionManager != null) {
756  //                      }                  // selectionManager.selectionChanged(this, bb);
757  //                      /*                  // }
758  //                       * FeatureCollection fc; selection = null; try { fc =                  // /*
759  //                       * selectionLayer.getFeatureSource().getFeatures(bb); selection =                  // * FeatureCollection fc; selection = null; try { fc =
760  //                       * fc; } catch (IOException e) { e.printStackTrace(); }                  // * selectionLayer.getFeatureSource().getFeatures(bb); selection =
761  //                       */                  // * fc; } catch (IOException e) { e.printStackTrace(); }
762  //              }                  // */
763                    // }
764    
765                  // xulu.so                  // xulu.so
766                  // setMapArea(mapArea);                  // setMapArea(mapArea);
# Line 857  public class JMapPane extends JPanel imp Line 772  public class JMapPane extends JPanel imp
772                  return clickable;                  return clickable;
773          }          }
774    
775          private org.geotools.styling.Style setupStyle(final int type, final Color color) {          //
776                  final StyleFactory sf = org.geotools.factory.CommonFactoryFinder          // private org.geotools.styling.Style setupStyle(final int type, final Color
777                                  .getStyleFactory(null);          // color) {
778                  final StyleBuilder sb = new StyleBuilder();          // final StyleFactory sf = org.geotools.factory.CommonFactoryFinder
779            // .getStyleFactory(null);
780                  org.geotools.styling.Style s = sf.createStyle();          // final StyleBuilder sb = new StyleBuilder();
781                  s.setTitle("selection");          //
782            // org.geotools.styling.Style s = sf.createStyle();
783                  // TODO parameterise the color          // s.setTitle("selection");
784                  final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);          //
785                  ps.setStroke(sb.createStroke(color));          // // TODO parameterise the color
786            // final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);
787                  final LineSymbolizer ls = sb.createLineSymbolizer(color);          // ps.setStroke(sb.createStroke(color));
788                  final Graphic h = sb.createGraphic();          //
789                  h.setMarks(new Mark[] { sb.createMark("square", color) });          // final LineSymbolizer ls = sb.createLineSymbolizer(color);
790            // final Graphic h = sb.createGraphic();
791                  final PointSymbolizer pts = sb.createPointSymbolizer(h);          // h.setMarks(new Mark[] { sb.createMark("square", color) });
792            //
793                  // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});          // final PointSymbolizer pts = sb.createPointSymbolizer(h);
794                  switch (type) {          //
795                  case POLYGON:          // // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});
796                          s = sb.createStyle(ps);          // switch (type) {
797            // case POLYGON:
798                          break;          // s = sb.createStyle(ps);
799            //
800                  case POINT:          // break;
801                          s = sb.createStyle(pts);          //
802            // case POINT:
803                          break;          // s = sb.createStyle(pts);
804            //
805                  case LINE:          // break;
806                          s = sb.createStyle(ls);          //
807                  }          // case LINE:
808            // s = sb.createStyle(ls);
809                  return s;          // }
810          }          //
811            // return s;
812            // }
813    
814          public void propertyChange(final PropertyChangeEvent evt) {          public void propertyChange(final PropertyChangeEvent evt) {
815                  final String prop = evt.getPropertyName();                  final String prop = evt.getPropertyName();
# Line 977  public class JMapPane extends JPanel imp Line 893  public class JMapPane extends JPanel imp
893          public void mouseMoved(final MouseEvent e) {          public void mouseMoved(final MouseEvent e) {
894          }          }
895    
   
   
896          // xulu.sn          // xulu.sn
897          /**          /**
898           * 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 911  public class JMapPane extends JPanel imp
911                  if (env == null)                  if (env == null)
912                          return env;                          return env;
913    
914                    Envelope newArea = null;
915    
916                  /**                  /**
917                   * Correct the aspect Ratio before we check the rest. Otherwise we might                   * Correct the aspect Ratio before we check the rest. Otherwise we might
918                   * easily fail.                   * easily fail.
919                   */                   */
920                  env = fixAspectRatio(this.getBounds(), env);                  env = fixAspectRatio(this.getBounds(), env, false);
921    
922                  final double scale = env.getWidth() / getWidth();                  final double scale = env.getWidth() / getWidth();
923                  final double centerX = env.getMinX() + env.getWidth() / 2.;                  final double centerX = env.getMinX() + env.getWidth() / 2.;
924                  final double centerY = env.getMinY() + env.getHeight() / 2.;                  final double centerY = env.getMinY() + env.getHeight() / 2.;
925                  double newWidth2;                  double newWidth2 = 0;
926                  double newHeight2;                  double newHeight2 = 0;
927                  if (scale < getMaxZoomScale()) {                  if (scale < getMaxZoomScale()) {
928                          // ****************************************************************************                          // ****************************************************************************
929                          // 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 940  public class JMapPane extends JPanel imp
940                          // ****************************************************************************                          // ****************************************************************************
941                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
942                          // ****************************************************************************                          // ****************************************************************************
943                          return env;                          newArea = env;
944                  }                  }
945    
946                  final Coordinate ll = new Coordinate(centerX - newWidth2, centerY                  if (newArea == null) {
                                 - newHeight2);  
                 final Coordinate ur = new Coordinate(centerX + newWidth2, centerY  
                                 + newHeight2);  
947    
948                  return new Envelope(ll, ur);                          final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
949                                            - newHeight2);
950                            final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
951                                            + newHeight2);
952    
953                            newArea = new Envelope(ll, ur);
954                    }
955    
956                    Envelope maxAllowedExtend = getMaxExtend();
957                    while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea) && newArea != null && !newArea.isNull() && !Double.isNaN(newArea.getMinX()) && !Double.isNaN(newArea.getMaxX()) && !Double.isNaN(newArea.getMinY()) && !Double.isNaN(newArea.getMaxY()) ) {
958                            /*
959                             * If a maxExtend is set, we have to honour that...
960                             */
961    
962                            // Exceeds top? Move down and maybe cut
963                            if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
964                                    double divY = newArea.getMaxY() - maxAllowedExtend.getMaxY();
965    //                              LOGGER.debug("Moving area down by " + divY);
966    
967                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
968                                                    newArea.getMinY() - divY), new Coordinate(newArea
969                                                    .getMaxX(), newArea.getMaxY() - divY));
970    
971                                    if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
972    //                                      LOGGER.debug("Now it exeeds the bottom border.. cut!");
973                                            // And cut the bottom if it moved out of the area
974                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
975                                                            maxAllowedExtend.getMinY()), new Coordinate(newArea
976                                                            .getMaxX(), newArea.getMaxY()));
977    
978    //                                      LOGGER.debug("and fix aspect ratio");
979    
980                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
981                                    }
982                            }
983    
984                            // Exceeds bottom? Move up and maybe cut
985                            if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
986                                    double divY = newArea.getMinY() - maxAllowedExtend.getMinY();
987    //                              LOGGER.debug("Moving area up by " + divY);
988    
989                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
990                                                    newArea.getMinY() - divY), new Coordinate(newArea
991                                                    .getMaxX(), newArea.getMaxY() - divY));
992    
993                                    if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
994    //                                      LOGGER.debug("Now it exeeds the top border.. cut!");
995                                            // And cut the bottom if it moved out of the area
996                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
997                                                            newArea.getMinY()), new Coordinate(newArea
998                                                            .getMaxX(), maxAllowedExtend.getMaxY()));
999    
1000    //                                      LOGGER.debug("and fix aspect ratio");
1001    
1002                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
1003                                    }
1004                            }
1005    
1006                            // Exceeds to the right? move and maybe cut
1007                            if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
1008    
1009                                    // Move left..
1010                                    double divX = newArea.getMaxX() - maxAllowedExtend.getMaxX();
1011    //                              LOGGER.debug("Moving area left by " + divX);
1012    
1013                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
1014                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
1015                                                    - divX, newArea.getMaxY()));
1016    
1017                                    if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
1018    //                                      LOGGER.debug("Now it exeeds the left border.. cut!");
1019                                            // And cut the left if it moved out of the area
1020                                            newArea = new Envelope(new Coordinate(maxAllowedExtend.getMinX(),
1021                                                            newArea.getMinY()), new Coordinate(newArea
1022                                                            .getMaxX(), newArea.getMaxY()));
1023    
1024    //                                      LOGGER.debug("and fix aspect ratio");
1025    
1026                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
1027                                    }
1028                            }
1029    
1030                            // Exceeds to the left? move and maybe cut
1031                            if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
1032    
1033                                    // Move right..
1034                                    double divX = newArea.getMinX() - maxAllowedExtend.getMinX();
1035    //                              LOGGER.debug("Moving area right by " + divX);
1036    
1037                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
1038                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
1039                                                    - divX, newArea.getMaxY()));
1040    
1041                                    if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
1042    //                                      LOGGER.debug("Now it exeeds the right border.. cut!");
1043                                            // And cut the left if it moved out of the area
1044                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
1045                                                            newArea.getMinY()), new Coordinate(maxAllowedExtend
1046                                                            .getMaxX(), newArea.getMaxY()));
1047    
1048    //                                      LOGGER.debug("and fix aspect ratio");
1049    
1050                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
1051                                    }
1052                            }
1053    
1054                    }
1055    
1056                    return newArea;
1057          }          }
1058    
1059          /**          /**
# Line 1065  public class JMapPane extends JPanel imp Line 1086  public class JMapPane extends JPanel imp
1086           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
1087           */           */
1088          public void setMaxZoomScale(final Double maxZoomScale) {          public void setMaxZoomScale(final Double maxZoomScale) {
                 // System.out.println("setting max scale to "+maxZoomScale);  
1089                  this.maxZoomScale = maxZoomScale;                  this.maxZoomScale = maxZoomScale;
1090          }          }
1091    
# Line 1079  public class JMapPane extends JPanel imp Line 1099  public class JMapPane extends JPanel imp
1099          public void setMinZoomScale(final Double minZoomScale) {          public void setMinZoomScale(final Double minZoomScale) {
1100                  this.minZoomScale = minZoomScale;                  this.minZoomScale = minZoomScale;
1101          }          }
1102          // xulu.en  
1103            /**
1104             * Defines an evelope of the viwable area. The JMapPane will never show
1105             * anything outside of this extend.
1106             *
1107             * @param maxExtend
1108             *            <code>null</code> to not have this restriction.
1109             */
1110            public void setMaxExtend(Envelope maxExtend) {
1111                    this.maxExtend = maxExtend;
1112            }
1113    
1114            /**
1115             * Returns the evelope of the viewable area. The JMapPane will never show
1116             * anything outside of this extend. If this has been set to
1117             * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
1118             * quickly the context's bounds. It it takes to long to determine the
1119             * context bounds, <code>null</code> is returned.
1120             *
1121             * @param maxExtend
1122             *            <code>null</code> to not have this restriction.
1123             */
1124    
1125            public Envelope getMaxExtend() {
1126                    if (maxExtend == null) {
1127                            try {
1128                                    return fixAspectRatio(
1129                                        this.getBounds(),
1130                            // Kartenbereich um 10% vergroessern
1131                                        JTSUtil.expandEnvelope(context.getLayerBounds(), 0.1),
1132                                        true
1133                                    );
1134                            } catch (IOException e) {
1135                                    LOGGER.warn(
1136                                                                    "maxExtend == null; failed to getLayerBounds of context",
1137                                                                    e);
1138                            }
1139                    }
1140                    return maxExtend;
1141            }
1142    
1143  }  }
Legend:
Removed from v.341  
changed lines
  Added in v.485
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26