/[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 320 by mojays, Wed Aug 26 13:49:19 2009 UTC branches/1.0-gt2-2.6/src/gtmig/org/geotools/swing/JMapPane.java revision 431 by alfonx, Sun Oct 4 16:55:52 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 58  import java.util.Map; Line 58  import java.util.Map;
58  import javax.swing.JPanel;  import javax.swing.JPanel;
59    
60  import org.apache.log4j.Logger;  import org.apache.log4j.Logger;
 import org.geotools.feature.FeatureCollection;  
 import org.geotools.filter.IllegalFilterException;  
 import org.geotools.map.DefaultMapContext;  
61  import org.geotools.map.MapContext;  import org.geotools.map.MapContext;
 import org.geotools.map.MapLayer;  
62  import org.geotools.map.event.MapLayerListEvent;  import org.geotools.map.event.MapLayerListEvent;
63  import org.geotools.map.event.MapLayerListListener;  import org.geotools.map.event.MapLayerListListener;
 import org.geotools.referencing.crs.DefaultGeographicCRS;  
64  import org.geotools.renderer.GTRenderer;  import org.geotools.renderer.GTRenderer;
65    import org.geotools.renderer.label.LabelCacheImpl;
66  import org.geotools.renderer.lite.LabelCache;  import org.geotools.renderer.lite.LabelCache;
 import org.geotools.renderer.lite.LabelCacheDefault;  
67  import org.geotools.renderer.lite.StreamingRenderer;  import org.geotools.renderer.lite.StreamingRenderer;
68  import org.geotools.renderer.shape.TransitionShapefileRenderer;  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.Style;  
 import org.geotools.styling.StyleBuilder;  
 import org.geotools.styling.StyleFactory;  
 import org.opengis.filter.Filter;  
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    
72  import schmitzm.swing.SwingUtil;  import schmitzm.swing.SwingUtil;
73    
 import com.sun.jini.jeri.internal.runtime.SelectionManager;  
74  import com.vividsolutions.jts.geom.Coordinate;  import com.vividsolutions.jts.geom.Coordinate;
75  import com.vividsolutions.jts.geom.Envelope;  import com.vividsolutions.jts.geom.Envelope;
 import com.vividsolutions.jts.geom.Geometry;  
76  import com.vividsolutions.jts.geom.GeometryFactory;  import com.vividsolutions.jts.geom.GeometryFactory;
77    
78  public class JMapPane extends JPanel implements MouseListener,  public class JMapPane extends JPanel implements MouseListener,
79                  MouseMotionListener, HighlightChangeListener, SelectionChangeListener,                  MouseMotionListener, PropertyChangeListener, MapLayerListListener {
                 PropertyChangeListener, MapLayerListListener {  
80          private static Logger LOGGER = Logger.getLogger(JMapPane.class.getName());          private static Logger LOGGER = Logger.getLogger(JMapPane.class.getName());
81    
82          private static final long serialVersionUID = -8647971481359690499L;          private static final long serialVersionUID = -8647971481359690499L;
# Line 108  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;  
   
         /**  
          * image of selection  
          */  
         private BufferedImage selectImage;  
   
         /**  
          * style for selected items  
          */  
         private Style selectionStyle;  
   
         /**  
          * layer that selection works on  
          */  
         private MapLayer selectionLayer;  
   
         /**  
          * layer that highlight works on  
          */  
         private MapLayer highlightLayer;  
   
         /**  
          * the object which manages highlighting  
          */  
         private HighlightManager highlightManager;  
   
         /**  
          * is highlighting on or off  
          */  
         private boolean highlight = true;  
123    
124          /**          /**
125           * a factory for filters           * a factory for filters
# Line 198  public class JMapPane extends JPanel imp Line 131  public class JMapPane extends JPanel imp
131           */           */
132          GeometryFactory gf = new GeometryFactory(); // FactoryFinder.getGeometryFactory(null);          GeometryFactory gf = new GeometryFactory(); // FactoryFinder.getGeometryFactory(null);
133    
         /**  
          * the collections of features to be selected or highlighted  
          */  
         FeatureCollection selection;  
   
         /**  
          * the collections of features to be selected or highlighted  
          */  
         FeatureCollection highlightFeature;  
   
134          private int state = ZoomIn;          private int state = ZoomIn;
135    
136          /**          /**
# Line 215  public class JMapPane extends JPanel imp Line 138  public class JMapPane extends JPanel imp
138           */           */
139          private double zoomFactor = 2.0;          private double zoomFactor = 2.0;
140    
         Style lineHighlightStyle;  
   
         Style pointHighlightStyle;  
   
         Style polygonHighlightStyle;  
   
         Style polygonSelectionStyle;  
   
         Style pointSelectionStyle;  
   
         Style lineSelectionStyle;  
   
141          boolean changed = true;          boolean changed = true;
142    
143          LabelCache labelCache = new LabelCacheDefault();          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    
         private SelectionManager selectionManager;  
         // 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 260  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 302  public class JMapPane extends JPanel imp Line 216  public class JMapPane extends JPanel imp
216    
217                  this.addMouseListener(this);                  this.addMouseListener(this);
218                  this.addMouseMotionListener(this);                  this.addMouseMotionListener(this);
                 setHighlightManager(new HighlightManager(highlightLayer));  
                 setSelectionManager(new SelectionManager(selectionLayer));  
                 lineHighlightStyle = setupStyle(LINE, Color.red);  
   
                 pointHighlightStyle = setupStyle(POINT, Color.red);  
   
                 polygonHighlightStyle = setupStyle(POLYGON, Color.red);  
   
                 polygonSelectionStyle = setupStyle(POLYGON, Color.cyan);  
   
                 pointSelectionStyle = setupStyle(POINT, Color.cyan);  
   
                 lineSelectionStyle = setupStyle(LINE, Color.cyan);  
219                  setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));                  setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
220          }          }
221    
# Line 326  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                    
234                  if (renderer instanceof StreamingRenderer || renderer instanceof TransitionShapefileRenderer) {                  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();                                  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 343  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);                  // highlightRenderer.setRendererHints(hints);
256  //              selectionRenderer.setRendererHints(hints);                  // selectionRenderer.setRendererHints(hints);
257                    
258  //              renderer.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 406  public class JMapPane extends JPanel imp Line 308  public class JMapPane extends JPanel imp
308                  this.zoomFactor = zoomFactor;                  this.zoomFactor = zoomFactor;
309          }          }
310    
         public MapLayer getSelectionLayer() {  
                 return selectionLayer;  
         }  
   
         public void setSelectionLayer(final MapLayer selectionLayer) {  
                 this.selectionLayer = selectionLayer;  
                 if (selectionManager != null) {  
                         selectionManager.setSelectionLayer(selectionLayer);  
                 }  
         }  
   
         public boolean isHighlight() {  
                 return highlight;  
         }  
   
         public void setHighlight(final boolean highlight) {  
                 this.highlight = highlight;  
         }  
   
         public MapLayer getHighlightLayer() {  
                 return highlightLayer;  
         }  
   
         public void setHighlightLayer(final MapLayer highlightLayer) {  
                 this.highlightLayer = highlightLayer;  
   
                 if (highlightManager != null) {  
                         highlightManager.setHighlightLayer(highlightLayer);  
                 }  
         }  
   
         public HighlightManager getHighlightManager() {  
                 return highlightManager;  
         }  
   
         public void setHighlightManager(final HighlightManager highlightManager) {  
                 this.highlightManager = highlightManager;  
                 this.highlightManager.addHighlightChangeListener(this);  
                 this.addMouseMotionListener(this.highlightManager);  
         }  
   
         public Style getLineHighlightStyle() {  
                 return lineHighlightStyle;  
         }  
   
         public void setLineHighlightStyle(final Style lineHighlightStyle) {  
                 this.lineHighlightStyle = lineHighlightStyle;  
         }  
   
         public Style getLineSelectionStyle() {  
                 return lineSelectionStyle;  
         }  
   
         public void setLineSelectionStyle(final Style lineSelectionStyle) {  
                 this.lineSelectionStyle = lineSelectionStyle;  
         }  
   
         public Style getPointHighlightStyle() {  
                 return pointHighlightStyle;  
         }  
   
         public void setPointHighlightStyle(final Style pointHighlightStyle) {  
                 this.pointHighlightStyle = pointHighlightStyle;  
         }  
   
         public Style getPointSelectionStyle() {  
                 return pointSelectionStyle;  
         }  
   
         public void setPointSelectionStyle(final Style pointSelectionStyle) {  
                 this.pointSelectionStyle = pointSelectionStyle;  
         }  
   
         public Style getPolygonHighlightStyle() {  
                 return polygonHighlightStyle;  
         }  
   
         public void setPolygonHighlightStyle(final Style polygonHighlightStyle) {  
                 this.polygonHighlightStyle = polygonHighlightStyle;  
         }  
   
         public Style getPolygonSelectionStyle() {  
                 return polygonSelectionStyle;  
         }  
   
         public void setPolygonSelectionStyle(final Style polygonSelectionStyle) {  
                 this.polygonSelectionStyle = polygonSelectionStyle;  
         }  
   
311          protected void paintComponent(final Graphics g) {          protected void paintComponent(final Graphics g) {
312                  super.paintComponent(g);                  super.paintComponent(g);
313    
# Line 510  public class JMapPane extends JPanel imp Line 323  public class JMapPane extends JPanel imp
323                                  try {                                  try {
324                                          mapArea = context.getLayerBounds();                                          mapArea = context.getLayerBounds();
325                                  } catch (final IOException e) {                                  } catch (final IOException e) {
326                                          // TODO Auto-generated catch block                                          LOGGER.warn("context.getLayerBounds()", e);
                                         e.printStackTrace();  
327                                  }                                  }
328                          }                          }
329    
# Line 521  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 534  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 555  public class JMapPane extends JPanel imp Line 367  public class JMapPane extends JPanel imp
367                  }                  }
368    
369                  ((Graphics2D) g).drawImage(baseImage, 0, 0, this);                  ((Graphics2D) g).drawImage(baseImage, 0, 0, this);
   
                 if ((selection != null) && (selection.size() > 0)) {  
                         // paint selection  
   
                         String type = selectionLayer.getFeatureSource().getSchema()  
                                         .getDefaultGeometry().getType().getName();  
                         /* String type = selection.getDefaultGeometry().getGeometryType(); */  
                         /* System.out.println(type); */  
                         if (type == null)  
                                 type = "polygon";  
   
                         /* String type = "point"; */  
   
                         if (type.toLowerCase().endsWith("polygon")) {  
                                 selectionStyle = polygonSelectionStyle;  
                         } else if (type.toLowerCase().endsWith("point")) {  
                                 selectionStyle = pointSelectionStyle;  
                         } else if (type.toLowerCase().endsWith("line")) {  
                                 selectionStyle = lineSelectionStyle;  
                         }  
   
                         selectionContext = new DefaultMapContext(DefaultGeographicCRS.WGS84);  
   
                         selectionContext.addLayer(selection, selectionStyle);  
                         selectionRenderer.setContext(selectionContext);  
   
                         selectImage = new BufferedImage(dr.width, dr.height,  
                                         BufferedImage.TYPE_INT_ARGB);  
   
                         final Graphics2D ig = selectImage.createGraphics();  
                         /* System.out.println("rendering selection"); */  
                         selectionRenderer.paint((Graphics2D) ig, dr, mapArea);  
   
                         ((Graphics2D) g).drawImage(selectImage, 0, 0, this);  
                 }  
   
                 if (highlight && (highlightFeature != null)  
                                 && (highlightFeature.size() > 0)) {  
                         /*  
                          * String type = selection.getDefaultGeometry().getGeometryType();  
                          * System.out.println(type); if(type==null) type="polygon";  
                          */  
                         String type = highlightLayer.getFeatureSource().getSchema()  
                                         .getDefaultGeometry().getType().getName();  
                         /* String type = selection.getDefaultGeometry().getGeometryType(); */  
                         // System.out.println(type);  
                         if (type == null)  
                                 type = "polygon";  
   
                         /* String type = "point"; */  
                         Style highlightStyle = null;  
                         if (type.toLowerCase().endsWith("polygon")) {  
                                 highlightStyle = polygonHighlightStyle;  
                         } else if (type.toLowerCase().endsWith("point")) {  
                                 highlightStyle = pointHighlightStyle;  
                         } else if (type.toLowerCase().endsWith("line")) {  
                                 highlightStyle = lineHighlightStyle;  
                         }  
   
                         final MapContext highlightContext = new DefaultMapContext(  
                                         DefaultGeographicCRS.WGS84);  
   
                         highlightContext.addLayer(highlightFeature, highlightStyle);  
                         highlightRenderer.setContext(highlightContext);  
   
                         /* System.out.println("rendering highlight"); */  
                         highlightRenderer.paint((Graphics2D) g, dr, mapArea);  
                 }  
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                    if (mapArea == null) {
382                            LOGGER.warn("mapArea has been null in method fixAspectRatio, returning an unmodified ");
383                    }
384    
385                  final double mapWidth = mapArea.getWidth(); /* get the extent of the map */                  final double mapWidth = mapArea.getWidth(); /* get the extent of the map */
386                  final double mapHeight = mapArea.getHeight();                  final double mapHeight = mapArea.getHeight();
387                  final double scaleX = r.getWidth() / mapArea.getWidth(); /*                  final double scaleX = r.getWidth() / mapArea.getWidth(); /*
388                                                                                                                           * calculate the new                                                                                                                                   * calculate the
389                                                                                                                           * scale                                                                                                                                   * new scale
390                                                                                                                           */                                                                                                                                   */
391    
392                  final double scaleY = r.getHeight() / mapArea.getHeight();                  final double scaleY = r.getHeight() / mapArea.getHeight();
393                  double scale = 1.0; // stupid compiler!                  double scale = 1.0; // stupid compiler!
394    
395                  if (scaleX < scaleY) { /* pick the smaller scale */                  if ((grow && scaleX < scaleY) || (!grow && scaleX > scaleY)) {
396                          scale = scaleX;                          scale = scaleX;
397                  } else {                  } else {
398                          scale = scaleY;                          scale = scaleY;
# Line 653  public class JMapPane extends JPanel imp Line 408  public class JMapPane extends JPanel imp
408                   */                   */
409    
410                  /* create the new extent */                  /* create the new extent */
411                  final Coordinate ll = new Coordinate(mapArea.getMinX() - (deltaX / 2.0),                  final Coordinate ll = new Coordinate(
412                                  mapArea.getMinY() - (deltaY / 2.0));                                  mapArea.getMinX() - (deltaX / 2.0), mapArea.getMinY()
413                  final Coordinate ur = new Coordinate(mapArea.getMaxX() + (deltaX / 2.0),                                                  - (deltaY / 2.0));
414                                  mapArea.getMaxY() + (deltaY / 2.0));                  final Coordinate ur = new Coordinate(
415                                    mapArea.getMaxX() + (deltaX / 2.0), mapArea.getMaxY()
416                                                    + (deltaY / 2.0));
417    
418                  return new Envelope(ll, ur);                  return new Envelope(ll, ur);
419          }          }
420    
         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;  
         }  
   
421          public void mouseClicked(final MouseEvent e) {          public void mouseClicked(final MouseEvent e) {
422                  if (mapArea == null) return;                  if (mapArea == null)
423                            return;
424                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"
425                  // h:"+mapArea.getHeight());                  // h:"+mapArea.getHeight());
426                  final Rectangle bounds = this.getBounds();                  final Rectangle bounds = this.getBounds();
# Line 752  public class JMapPane extends JPanel imp Line 434  public class JMapPane extends JPanel imp
434                  final double width2 = width / 2.0;                  final double width2 = width / 2.0;
435                  final double height2 = height / 2.0;                  final double height2 = height / 2.0;
436                  // xulu.ec                  // xulu.ec
437                  final double mapX = ((x * width) / (double) bounds.width) + mapArea.getMinX();                  final double mapX = ((x * width) / (double) bounds.width)
438                                    + mapArea.getMinX();
439                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)
440                                  + mapArea.getMinY();                                  + mapArea.getMinY();
441    
# Line 783  public class JMapPane extends JPanel imp Line 466  public class JMapPane extends JPanel imp
466                          zlevel = 1.0 / zoomFactor;                          zlevel = 1.0 / zoomFactor;
467    
468                          break;                          break;
469                    //
470                  case Select:                  // case Select:
471                          doSelection(mapX, mapY, selectionLayer);                  // doSelection(mapX, mapY, selectionLayer);
472                    //
473                          return;                  // return;
474    
475                  default:                  default:
476                          return;                          return;
# Line 859  public class JMapPane extends JPanel imp Line 542  public class JMapPane extends JPanel imp
542                                  // System.out.println("translate "+dx+","+dy);                                  // System.out.println("translate "+dx+","+dy);
543                                  final Graphics2D g2 = panningImage.createGraphics();                                  final Graphics2D g2 = panningImage.createGraphics();
544                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige
545                                                                                                                          // farbe? am besten                                  // farbe? am besten
546                                                                                                                          // vom L&F die                                  // vom L&F die
547                                                                                                                          // hintergrundfarbe                                  // hintergrundfarbe
548                                                                                                                          // auslesen...                                  // auslesen...
549                                    
550                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());
551                                  g2.drawImage(baseImage, dx, dy, this);                                  g2.drawImage(baseImage, dx, dy, this);
552                                  graphics.drawImage(panningImage, 0, 0, this);                                  graphics.drawImage(panningImage, 0, 0, this);
# Line 885  public class JMapPane extends JPanel imp Line 568  public class JMapPane extends JPanel imp
568                          lastX = x;                          lastX = x;
569                          lastY = y;                          lastY = y;
570                          drawRectangle(graphics);                          drawRectangle(graphics);
                 } else if (state == JMapPane.Select && selectionLayer != null) {  
   
                         // construct a new bbox filter  
                         final Rectangle bounds = this.getBounds();  
   
                         final double mapWidth = mapArea.getWidth();  
                         final double mapHeight = mapArea.getHeight();  
   
                         final double x1 = ((this.startX * mapWidth) / (double) bounds.width)  
                                         + mapArea.getMinX();  
                         final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) / (double) bounds.height)  
                                         + mapArea.getMinY();  
                         final double x2 = ((x * mapWidth) / (double) bounds.width)  
                                         + mapArea.getMinX();  
                         final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double) bounds.height)  
                                         + mapArea.getMinY();  
                         final double left = Math.min(x1, x2);  
                         final double right = Math.max(x1, x2);  
                         final double bottom = Math.min(y1, y2);  
                         final double top = Math.max(y1, y2);  
   
                         String name = selectionLayer.getFeatureSource().getSchema()  
                                         .getDefaultGeometry().getName();  
   
                         if (name == "") {  
                                 name = "the_geom";  
                         }  
                         final Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,  
                                         getContext().getCoordinateReferenceSystem().toString());  
                         if (selectionManager != null) {  
                                 selectionManager.selectionChanged(this, bb);  
                         }  
   
                         graphics.setXORMode(Color.green);  
   
                         /*  
                          * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }  
                          */  
   
                         // draw new box  
                         lastX = x;  
                         lastY = y;  
                         drawRectangle(graphics);  
571                  }                  }
572                    // else if (state == JMapPane.Select && selectionLayer != null) {
573                    //
574                    // // construct a new bbox filter
575                    // final Rectangle bounds = this.getBounds();
576                    //
577                    // final double mapWidth = mapArea.getWidth();
578                    // final double mapHeight = mapArea.getHeight();
579                    //
580                    // final double x1 = ((this.startX * mapWidth) / (double) bounds.width)
581                    // + mapArea.getMinX();
582                    // final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) /
583                    // (double) bounds.height)
584                    // + mapArea.getMinY();
585                    // final double x2 = ((x * mapWidth) / (double) bounds.width)
586                    // + mapArea.getMinX();
587                    // final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double)
588                    // bounds.height)
589                    // + mapArea.getMinY();
590                    // final double left = Math.min(x1, x2);
591                    // final double right = Math.max(x1, x2);
592                    // final double bottom = Math.min(y1, y2);
593                    // final double top = Math.max(y1, y2);
594                    //
595                    // String name = selectionLayer.getFeatureSource().getSchema()
596                    // .getDefaultGeometry().getName();
597                    //
598                    // if (name == "") {
599                    // name = "the_geom";
600                    // }
601                    // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
602                    // top,
603                    // getContext().getCoordinateReferenceSystem().toString());
604                    // if (selectionManager != null) {
605                    // selectionManager.selectionChanged(this, bb);
606                    // }
607                    //
608                    // graphics.setXORMode(Color.green);
609                    //
610                    // /*
611                    // * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }
612                    // */
613                    //
614                    // // draw new box
615                    // lastX = x;
616                    // lastY = y;
617                    // drawRectangle(graphics);
618                    // }
619    
620          }          }
621    
# Line 938  public class JMapPane extends JPanel imp Line 625  public class JMapPane extends JPanel imp
625          protected void processDrag(final int x1, final int y1, final int x2,          protected void processDrag(final int x1, final int y1, final int x2,
626                          final int y2, final MouseEvent e) {                          final int y2, final MouseEvent e) {
627    
628    
629                  /****                  /****
630                   * If no layer is availabe we dont want a NullPointerException                   * If no layers exist, we ignore the drag.
631                   */                   */
632                  if (mapArea == null)                  if (context.getLayerCount() <= 0) {
633                          return;                          return;
634                    }
635                    
636                  // System.out.println("processing drag from " + x1 + "," + y1 + " -> "                  // System.out.println("processing drag from " + x1 + "," + y1 + " -> "
637                  // + x2 + "," + y2);                  // + x2 + "," + y2);
638                  if ((x1 == x2) && (y1 == y2)) {                  if ((x1 == x2) && (y1 == y2)) {
# Line 989  public class JMapPane extends JPanel imp Line 678  public class JMapPane extends JPanel imp
678                          final Coordinate ur = new Coordinate(right, top);                          final Coordinate ur = new Coordinate(right, top);
679                          // xulu.sc                          // xulu.sc
680                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
681                          setMapArea(fixAspectRatio(this.getBounds(), new Envelope(ll, ur)));                          
682    
683                            setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
684                          // xulu.ec                          // xulu.ec
685                  } else if (state == JMapPane.ZoomIn) {                  } else if (state == JMapPane.ZoomIn) {
686    
# Line 1013  public class JMapPane extends JPanel imp Line 704  public class JMapPane extends JPanel imp
704                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
705    
706                          // sk.sc                          // sk.sc
707  //                      {                          // {
708  //                      // SK tries to paint a preview of the zoom ;-9 aha.... well                          // // SK tries to paint a preview of the zoom ;-9 aha.... well
709  //                      Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();                          // Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();
710  //                      graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,                          // graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
711  //                                      RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);                          // RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
712  //                      graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,                          // graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
713  //                                      RenderingHints.VALUE_ANTIALIAS_OFF);                          // RenderingHints.VALUE_ANTIALIAS_OFF);
714  //                      graphics.setRenderingHint(RenderingHints.KEY_RENDERING,                          // graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
715  //                                      RenderingHints.VALUE_RENDER_SPEED);                          // RenderingHints.VALUE_RENDER_SPEED);
716  //                      graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),                          // graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),
717  //                                      JMapPane.this.getHeight(), x1, y1, x2, y2, null);                          // JMapPane.this.getHeight(), x1, y1, x2, y2, null);
718  //                      }                          // }
719                          // xulu.ec                          // xulu.ec
720                  } else if (state == JMapPane.ZoomOut) {                  } else if (state == JMapPane.ZoomOut) {
721                          drawRectangle(this.getGraphics());                          drawRectangle(this.getGraphics());
# Line 1053  public class JMapPane extends JPanel imp Line 744  public class JMapPane extends JPanel imp
744                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
745    
746                          // xulu.ec                          // xulu.ec
                 } else if (state == JMapPane.Select && selectionLayer != null) {  
                         final double left = Math.min(startX, endX);  
                         final double right = Math.max(startX, endX);  
                         final double bottom = Math.min(startY, endY);  
                         final double top = Math.max(startY, endY);  
   
                         String name = selectionLayer.getFeatureSource().getSchema()  
                                         .getDefaultGeometry().getLocalName();  
   
                         if (name == "") {  
                                 name = "the_geom";  
                         }  
                         final Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,  
                                         getContext().getCoordinateReferenceSystem().toString());  
                         // System.out.println(bb.toString());  
                         if (selectionManager != null) {  
                                 selectionManager.selectionChanged(this, bb);  
                         }  
                         /*  
                          * FeatureCollection fc; selection = null; try { fc =  
                          * selectionLayer.getFeatureSource().getFeatures(bb); selection =  
                          * fc; } catch (IOException e) { e.printStackTrace(); }  
                          */  
747                  }                  }
748                    // else if (state == JMapPane.Select && selectionLayer != null) {
749                    // final double left = Math.min(startX, endX);
750                    // final double right = Math.max(startX, endX);
751                    // final double bottom = Math.min(startY, endY);
752                    // final double top = Math.max(startY, endY);
753                    //
754                    // String name = selectionLayer.getFeatureSource().getSchema()
755                    // .getDefaultGeometry().getLocalName();
756                    //
757                    // if (name == "") {
758                    // name = "the_geom";
759                    // }
760                    // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
761                    // top,
762                    // getContext().getCoordinateReferenceSystem().toString());
763                    // // System.out.println(bb.toString());
764                    // if (selectionManager != null) {
765                    // selectionManager.selectionChanged(this, bb);
766                    // }
767                    // /*
768                    // * FeatureCollection fc; selection = null; try { fc =
769                    // * selectionLayer.getFeatureSource().getFeatures(bb); selection =
770                    // * fc; } catch (IOException e) { e.printStackTrace(); }
771                    // */
772                    // }
773    
774                  // xulu.so                  // xulu.so
775                  // setMapArea(mapArea);                  // setMapArea(mapArea);
# Line 1088  public class JMapPane extends JPanel imp Line 781  public class JMapPane extends JPanel imp
781                  return clickable;                  return clickable;
782          }          }
783    
784          private org.geotools.styling.Style setupStyle(final int type, final Color color) {          //
785                  final StyleFactory sf = org.geotools.factory.CommonFactoryFinder          // private org.geotools.styling.Style setupStyle(final int type, final Color
786                                  .getStyleFactory(null);          // color) {
787                  final StyleBuilder sb = new StyleBuilder();          // final StyleFactory sf = org.geotools.factory.CommonFactoryFinder
788            // .getStyleFactory(null);
789                  org.geotools.styling.Style s = sf.createStyle();          // final StyleBuilder sb = new StyleBuilder();
790                  s.setTitle("selection");          //
791            // org.geotools.styling.Style s = sf.createStyle();
792                  // TODO parameterise the color          // s.setTitle("selection");
793                  final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);          //
794                  ps.setStroke(sb.createStroke(color));          // // TODO parameterise the color
795            // final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);
796                  final LineSymbolizer ls = sb.createLineSymbolizer(color);          // ps.setStroke(sb.createStroke(color));
797                  final Graphic h = sb.createGraphic();          //
798                  h.setMarks(new Mark[] { sb.createMark("square", color) });          // final LineSymbolizer ls = sb.createLineSymbolizer(color);
799            // final Graphic h = sb.createGraphic();
800                  final PointSymbolizer pts = sb.createPointSymbolizer(h);          // h.setMarks(new Mark[] { sb.createMark("square", color) });
801            //
802                  // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});          // final PointSymbolizer pts = sb.createPointSymbolizer(h);
803                  switch (type) {          //
804                  case POLYGON:          // // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});
805                          s = sb.createStyle(ps);          // switch (type) {
806            // case POLYGON:
807                          break;          // s = sb.createStyle(ps);
808            //
809                  case POINT:          // break;
810                          s = sb.createStyle(pts);          //
811            // case POINT:
812                          break;          // s = sb.createStyle(pts);
813            //
814                  case LINE:          // break;
815                          s = sb.createStyle(ls);          //
816                  }          // case LINE:
817            // s = sb.createStyle(ls);
818                  return s;          // }
819          }          //
820            // return s;
821          public void highlightChanged(final HighlightChangedEvent e) {          // }
                 final org.opengis.filter.Filter f = e.getFilter();  
   
                 try {  
                         highlightFeature = highlightLayer.getFeatureSource().getFeatures(f);  
                 } catch (final IOException e1) {  
                         // TODO Auto-generated catch block  
                         e1.printStackTrace();  
                 }  
   
                 repaint();  
         }  
822    
823          public void propertyChange(final PropertyChangeEvent evt) {          public void propertyChange(final PropertyChangeEvent evt) {
824                  final String prop = evt.getPropertyName();                  final String prop = evt.getPropertyName();
# Line 1220  public class JMapPane extends JPanel imp Line 902  public class JMapPane extends JPanel imp
902          public void mouseMoved(final MouseEvent e) {          public void mouseMoved(final MouseEvent e) {
903          }          }
904    
         public FeatureCollection getSelection() {  
                 return selection;  
         }  
   
         public void setSelection(final FeatureCollection selection) {  
                 this.selection = selection;  
                 repaint();  
         }  
   
         /*  
          * (non-Javadoc)  
          *  
          * @see  
          * org.geotools.gui.swing.event.SelectionChangeListener#selectionChanged  
          * (org.geotools.gui.swing.event.SelectionChangedEvent)  
          */  
         public void selectionChanged(final SelectionChangedEvent e) {  
   
                 try {  
                         selection = selectionLayer.getFeatureSource().getFeatures(  
                                         e.getFilter());  
                         repaint();  
                 } catch (final IOException e1) {  
                         e1.printStackTrace();  
                 }  
         }  
   
         public SelectionManager getSelectionManager() {  
                 return selectionManager;  
         }  
   
         public void setSelectionManager(final SelectionManager selectionManager) {  
                 this.selectionManager = selectionManager;  
                 this.selectionManager.addSelectionChangeListener(this);  
   
         }  
   
905          // xulu.sn          // xulu.sn
906          /**          /**
907           * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste           * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste
# Line 1275  public class JMapPane extends JPanel imp Line 920  public class JMapPane extends JPanel imp
920                  if (env == null)                  if (env == null)
921                          return env;                          return env;
922    
923                    Envelope newArea = null;
924    
925                  /**                  /**
926                   * Correct the aspect Ratio before we check the rest. Otherwise we might                   * Correct the aspect Ratio before we check the rest. Otherwise we might
927                   * easily fail.                   * easily fail.
928                   */                   */
929                  env = fixAspectRatio(this.getBounds(), env);                  env = fixAspectRatio(this.getBounds(), env, false);
930    
931                  final double scale = env.getWidth() / getWidth();                  final double scale = env.getWidth() / getWidth();
932                  final double centerX = env.getMinX() + env.getWidth() / 2.;                  final double centerX = env.getMinX() + env.getWidth() / 2.;
933                  final double centerY = env.getMinY() + env.getHeight() / 2.;                  final double centerY = env.getMinY() + env.getHeight() / 2.;
934                  double newWidth2;                  double newWidth2 = 0;
935                  double newHeight2;                  double newHeight2 = 0;
936                  if (scale < getMaxZoomScale()) {                  if (scale < getMaxZoomScale()) {
937                          // ****************************************************************************                          // ****************************************************************************
938                          // Wir zoomen weiter rein als erlaubt => Anpassen des envelope                          // Wir zoomen weiter rein als erlaubt => Anpassen des envelope
# Line 1302  public class JMapPane extends JPanel imp Line 949  public class JMapPane extends JPanel imp
949                          // ****************************************************************************                          // ****************************************************************************
950                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
951                          // ****************************************************************************                          // ****************************************************************************
952                          return env;                          newArea = env;
953                  }                  }
954    
955                  final Coordinate ll = new Coordinate(centerX - newWidth2, centerY                  if (newArea == null) {
                                 - newHeight2);  
                 final Coordinate ur = new Coordinate(centerX + newWidth2, centerY  
                                 + newHeight2);  
956    
957                  return new Envelope(ll, ur);                          final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
958                                            - newHeight2);
959                            final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
960                                            + newHeight2);
961    
962                            newArea = new Envelope(ll, ur);
963                    }
964    
965                    Envelope maxAllowedExtend = getMaxExtend();
966                    while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea)) {
967                            /*
968                             * If a maxExtend is set, we have to honour that...
969                             */
970    
971                            // Exceeds top? Move down and maybe cut
972                            if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
973                                    double divY = newArea.getMaxY() - maxAllowedExtend.getMaxY();
974                                    LOGGER.debug("Moving area down by " + divY);
975    
976                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
977                                                    newArea.getMinY() - divY), new Coordinate(newArea
978                                                    .getMaxX(), newArea.getMaxY() - divY));
979    
980                                    if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
981                                            LOGGER.debug("Now it exeeds the bottom border.. cut!");
982                                            // And cut the bottom if it moved out of the area
983                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
984                                                            maxAllowedExtend.getMinY()), new Coordinate(newArea
985                                                            .getMaxX(), newArea.getMaxY()));
986    
987                                            LOGGER.debug("and fix aspect ratio");
988    
989                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
990                                    }
991                            }
992    
993                            // Exceeds bottom? Move up and maybe cut
994                            if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
995                                    double divY = newArea.getMinY() - maxAllowedExtend.getMinY();
996                                    LOGGER.debug("Moving area up by " + divY);
997    
998                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
999                                                    newArea.getMinY() - divY), new Coordinate(newArea
1000                                                    .getMaxX(), newArea.getMaxY() - divY));
1001    
1002                                    if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
1003                                            LOGGER.debug("Now it exeeds the top border.. cut!");
1004                                            // And cut the bottom if it moved out of the area
1005                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
1006                                                            newArea.getMinY()), new Coordinate(newArea
1007                                                            .getMaxX(), maxAllowedExtend.getMaxY()));
1008    
1009                                            LOGGER.debug("and fix aspect ratio");
1010    
1011                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
1012                                    }
1013                            }
1014    
1015                            // Exceeds to the right? move and maybe cut
1016                            if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
1017    
1018                                    // Move left..
1019                                    double divX = newArea.getMaxX() - maxAllowedExtend.getMaxX();
1020                                    LOGGER.debug("Moving area left by " + divX);
1021    
1022                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
1023                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
1024                                                    - divX, newArea.getMaxY()));
1025    
1026                                    if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
1027                                            LOGGER.debug("Now it exeeds the left border.. cut!");
1028                                            // And cut the left if it moved out of the area
1029                                            newArea = new Envelope(new Coordinate(maxAllowedExtend.getMinX(),
1030                                                            newArea.getMinY()), new Coordinate(newArea
1031                                                            .getMaxX(), newArea.getMaxY()));
1032    
1033                                            LOGGER.debug("and fix aspect ratio");
1034    
1035                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
1036                                    }
1037                            }
1038    
1039                            // Exceeds to the left? move and maybe cut
1040                            if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
1041    
1042                                    // Move right..
1043                                    double divX = newArea.getMinX() - maxAllowedExtend.getMinX();
1044                                    LOGGER.debug("Moving area right by " + divX);
1045    
1046                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
1047                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
1048                                                    - divX, newArea.getMaxY()));
1049    
1050                                    if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
1051                                            LOGGER.debug("Now it exeeds the right border.. cut!");
1052                                            // And cut the left if it moved out of the area
1053                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
1054                                                            newArea.getMinY()), new Coordinate(maxAllowedExtend
1055                                                            .getMaxX(), newArea.getMaxY()));
1056    
1057                                            LOGGER.debug("and fix aspect ratio");
1058    
1059                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
1060                                    }
1061                            }
1062    
1063                    }
1064    
1065                    return newArea;
1066          }          }
1067    
1068          /**          /**
# Line 1343  public class JMapPane extends JPanel imp Line 1095  public class JMapPane extends JPanel imp
1095           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
1096           */           */
1097          public void setMaxZoomScale(final Double maxZoomScale) {          public void setMaxZoomScale(final Double maxZoomScale) {
                 // System.out.println("setting max scale to "+maxZoomScale);  
1098                  this.maxZoomScale = maxZoomScale;                  this.maxZoomScale = maxZoomScale;
1099          }          }
1100    
# Line 1357  public class JMapPane extends JPanel imp Line 1108  public class JMapPane extends JPanel imp
1108          public void setMinZoomScale(final Double minZoomScale) {          public void setMinZoomScale(final Double minZoomScale) {
1109                  this.minZoomScale = minZoomScale;                  this.minZoomScale = minZoomScale;
1110          }          }
1111          // xulu.en  
1112            /**
1113             * Defines an evelope of the viwable area. The JMapPane will never show
1114             * anything outside of this extend.
1115             *
1116             * @param maxExtend
1117             *            <code>null</code> to not have this restriction.
1118             */
1119            public void setMaxExtend(Envelope maxExtend) {
1120                    this.maxExtend = maxExtend;
1121            }
1122    
1123            /**
1124             * Returns the evelope of the viewable area. The JMapPane will never show
1125             * anything outside of this extend. If this has been set to
1126             * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
1127             * quickly the context's bounds. It it takes to long to determine the
1128             * context bounds, <code>null</code> is returned.
1129             *
1130             * @param maxExtend
1131             *            <code>null</code> to not have this restriction.
1132             */
1133    
1134            public Envelope getMaxExtend() {
1135                    if (maxExtend == null) {
1136                            try {
1137                                    return fixAspectRatio(this.getBounds(), context.getLayerBounds(), true);
1138                            } catch (IOException e) {
1139                                    LOGGER
1140                                                    .warn(
1141                                                                    "maxExtend == null; faild to getLayerBounds of context",
1142                                                                    e);
1143                            }
1144                    }
1145                    return maxExtend;
1146            }
1147    
1148  }  }
Legend:
Removed from v.320  
changed lines
  Added in v.431
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26