/[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 415 by alfonx, Thu Sep 24 17:58:32 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);
256                    // selectionRenderer.setRendererHints(hints);
257    
258  //              highlightRenderer.setRendererHints(hints);                  // renderer.setRendererHints(hints);
 //              selectionRenderer.setRendererHints(hints);  
                   
 //              renderer.setRendererHints(hints);  
259    
260                  if (this.context != null) {                  if (this.context != null) {
261                          this.renderer.setContext(this.context);                          this.renderer.setContext(this.context);
# Line 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 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) {          private Envelope fixAspectRatio(final Rectangle r, final Envelope mapArea) {
# Line 630  public class JMapPane extends JPanel imp Line 374  public class JMapPane extends JPanel imp
374                  final double mapWidth = mapArea.getWidth(); /* get the extent of the map */                  final double mapWidth = mapArea.getWidth(); /* get the extent of the map */
375                  final double mapHeight = mapArea.getHeight();                  final double mapHeight = mapArea.getHeight();
376                  final double scaleX = r.getWidth() / mapArea.getWidth(); /*                  final double scaleX = r.getWidth() / mapArea.getWidth(); /*
377                                                                                                                           * calculate the new                                                                                                                                   * calculate the
378                                                                                                                           * scale                                                                                                                                   * new scale
379                                                                                                                           */                                                                                                                                   */
380    
381                  final double scaleY = r.getHeight() / mapArea.getHeight();                  final double scaleY = r.getHeight() / mapArea.getHeight();
382                  double scale = 1.0; // stupid compiler!                  double scale = 1.0; // stupid compiler!
383    
384                  if (scaleX < scaleY) { /* pick the smaller scale */                  if (scaleX > scaleY) { /* pick the smaller scale */
385                          scale = scaleX;                          scale = scaleX;
386                  } else {                  } else {
387                          scale = scaleY;                          scale = scaleY;
# Line 653  public class JMapPane extends JPanel imp Line 397  public class JMapPane extends JPanel imp
397                   */                   */
398    
399                  /* create the new extent */                  /* create the new extent */
400                  final Coordinate ll = new Coordinate(mapArea.getMinX() - (deltaX / 2.0),                  final Coordinate ll = new Coordinate(
401                                  mapArea.getMinY() - (deltaY / 2.0));                                  mapArea.getMinX() - (deltaX / 2.0), mapArea.getMinY()
402                  final Coordinate ur = new Coordinate(mapArea.getMaxX() + (deltaX / 2.0),                                                  - (deltaY / 2.0));
403                                  mapArea.getMaxY() + (deltaY / 2.0));                  final Coordinate ur = new Coordinate(
404                                    mapArea.getMaxX() + (deltaX / 2.0), mapArea.getMaxY()
405                                                    + (deltaY / 2.0));
406    
407                  return new Envelope(ll, ur);                  return new Envelope(ll, ur);
408          }          }
409    
         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;  
         }  
   
410          public void mouseClicked(final MouseEvent e) {          public void mouseClicked(final MouseEvent e) {
411                  if (mapArea == null) return;                  if (mapArea == null)
412                            return;
413                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"
414                  // h:"+mapArea.getHeight());                  // h:"+mapArea.getHeight());
415                  final Rectangle bounds = this.getBounds();                  final Rectangle bounds = this.getBounds();
# Line 752  public class JMapPane extends JPanel imp Line 423  public class JMapPane extends JPanel imp
423                  final double width2 = width / 2.0;                  final double width2 = width / 2.0;
424                  final double height2 = height / 2.0;                  final double height2 = height / 2.0;
425                  // xulu.ec                  // xulu.ec
426                  final double mapX = ((x * width) / (double) bounds.width) + mapArea.getMinX();                  final double mapX = ((x * width) / (double) bounds.width)
427                                    + mapArea.getMinX();
428                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)
429                                  + mapArea.getMinY();                                  + mapArea.getMinY();
430    
# Line 783  public class JMapPane extends JPanel imp Line 455  public class JMapPane extends JPanel imp
455                          zlevel = 1.0 / zoomFactor;                          zlevel = 1.0 / zoomFactor;
456    
457                          break;                          break;
458                    //
459                  case Select:                  // case Select:
460                          doSelection(mapX, mapY, selectionLayer);                  // doSelection(mapX, mapY, selectionLayer);
461                    //
462                          return;                  // return;
463    
464                  default:                  default:
465                          return;                          return;
# Line 859  public class JMapPane extends JPanel imp Line 531  public class JMapPane extends JPanel imp
531                                  // System.out.println("translate "+dx+","+dy);                                  // System.out.println("translate "+dx+","+dy);
532                                  final Graphics2D g2 = panningImage.createGraphics();                                  final Graphics2D g2 = panningImage.createGraphics();
533                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige
534                                                                                                                          // farbe? am besten                                  // farbe? am besten
535                                                                                                                          // vom L&F die                                  // vom L&F die
536                                                                                                                          // hintergrundfarbe                                  // hintergrundfarbe
537                                                                                                                          // auslesen...                                  // auslesen...
538                                    
539                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());
540                                  g2.drawImage(baseImage, dx, dy, this);                                  g2.drawImage(baseImage, dx, dy, this);
541                                  graphics.drawImage(panningImage, 0, 0, this);                                  graphics.drawImage(panningImage, 0, 0, this);
# Line 885  public class JMapPane extends JPanel imp Line 557  public class JMapPane extends JPanel imp
557                          lastX = x;                          lastX = x;
558                          lastY = y;                          lastY = y;
559                          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);  
560                  }                  }
561                    // else if (state == JMapPane.Select && selectionLayer != null) {
562                    //
563                    // // construct a new bbox filter
564                    // final Rectangle bounds = this.getBounds();
565                    //
566                    // final double mapWidth = mapArea.getWidth();
567                    // final double mapHeight = mapArea.getHeight();
568                    //
569                    // final double x1 = ((this.startX * mapWidth) / (double) bounds.width)
570                    // + mapArea.getMinX();
571                    // final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) /
572                    // (double) bounds.height)
573                    // + mapArea.getMinY();
574                    // final double x2 = ((x * mapWidth) / (double) bounds.width)
575                    // + mapArea.getMinX();
576                    // final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double)
577                    // bounds.height)
578                    // + mapArea.getMinY();
579                    // final double left = Math.min(x1, x2);
580                    // final double right = Math.max(x1, x2);
581                    // final double bottom = Math.min(y1, y2);
582                    // final double top = Math.max(y1, y2);
583                    //
584                    // String name = selectionLayer.getFeatureSource().getSchema()
585                    // .getDefaultGeometry().getName();
586                    //
587                    // if (name == "") {
588                    // name = "the_geom";
589                    // }
590                    // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
591                    // top,
592                    // getContext().getCoordinateReferenceSystem().toString());
593                    // if (selectionManager != null) {
594                    // selectionManager.selectionChanged(this, bb);
595                    // }
596                    //
597                    // graphics.setXORMode(Color.green);
598                    //
599                    // /*
600                    // * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }
601                    // */
602                    //
603                    // // draw new box
604                    // lastX = x;
605                    // lastY = y;
606                    // drawRectangle(graphics);
607                    // }
608    
609          }          }
610    
# Line 1013  public class JMapPane extends JPanel imp Line 689  public class JMapPane extends JPanel imp
689                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
690    
691                          // sk.sc                          // sk.sc
692  //                      {                          // {
693  //                      // SK tries to paint a preview of the zoom ;-9 aha.... well                          // // SK tries to paint a preview of the zoom ;-9 aha.... well
694  //                      Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();                          // Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();
695  //                      graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,                          // graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
696  //                                      RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);                          // RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
697  //                      graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,                          // graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
698  //                                      RenderingHints.VALUE_ANTIALIAS_OFF);                          // RenderingHints.VALUE_ANTIALIAS_OFF);
699  //                      graphics.setRenderingHint(RenderingHints.KEY_RENDERING,                          // graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
700  //                                      RenderingHints.VALUE_RENDER_SPEED);                          // RenderingHints.VALUE_RENDER_SPEED);
701  //                      graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),                          // graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),
702  //                                      JMapPane.this.getHeight(), x1, y1, x2, y2, null);                          // JMapPane.this.getHeight(), x1, y1, x2, y2, null);
703  //                      }                          // }
704                          // xulu.ec                          // xulu.ec
705                  } else if (state == JMapPane.ZoomOut) {                  } else if (state == JMapPane.ZoomOut) {
706                          drawRectangle(this.getGraphics());                          drawRectangle(this.getGraphics());
# Line 1053  public class JMapPane extends JPanel imp Line 729  public class JMapPane extends JPanel imp
729                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
730    
731                          // 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(); }  
                          */  
732                  }                  }
733                    // else if (state == JMapPane.Select && selectionLayer != null) {
734                    // final double left = Math.min(startX, endX);
735                    // final double right = Math.max(startX, endX);
736                    // final double bottom = Math.min(startY, endY);
737                    // final double top = Math.max(startY, endY);
738                    //
739                    // String name = selectionLayer.getFeatureSource().getSchema()
740                    // .getDefaultGeometry().getLocalName();
741                    //
742                    // if (name == "") {
743                    // name = "the_geom";
744                    // }
745                    // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
746                    // top,
747                    // getContext().getCoordinateReferenceSystem().toString());
748                    // // System.out.println(bb.toString());
749                    // if (selectionManager != null) {
750                    // selectionManager.selectionChanged(this, bb);
751                    // }
752                    // /*
753                    // * FeatureCollection fc; selection = null; try { fc =
754                    // * selectionLayer.getFeatureSource().getFeatures(bb); selection =
755                    // * fc; } catch (IOException e) { e.printStackTrace(); }
756                    // */
757                    // }
758    
759                  // xulu.so                  // xulu.so
760                  // setMapArea(mapArea);                  // setMapArea(mapArea);
# Line 1088  public class JMapPane extends JPanel imp Line 766  public class JMapPane extends JPanel imp
766                  return clickable;                  return clickable;
767          }          }
768    
769          private org.geotools.styling.Style setupStyle(final int type, final Color color) {          //
770                  final StyleFactory sf = org.geotools.factory.CommonFactoryFinder          // private org.geotools.styling.Style setupStyle(final int type, final Color
771                                  .getStyleFactory(null);          // color) {
772                  final StyleBuilder sb = new StyleBuilder();          // final StyleFactory sf = org.geotools.factory.CommonFactoryFinder
773            // .getStyleFactory(null);
774                  org.geotools.styling.Style s = sf.createStyle();          // final StyleBuilder sb = new StyleBuilder();
775                  s.setTitle("selection");          //
776            // org.geotools.styling.Style s = sf.createStyle();
777                  // TODO parameterise the color          // s.setTitle("selection");
778                  final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);          //
779                  ps.setStroke(sb.createStroke(color));          // // TODO parameterise the color
780            // final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);
781                  final LineSymbolizer ls = sb.createLineSymbolizer(color);          // ps.setStroke(sb.createStroke(color));
782                  final Graphic h = sb.createGraphic();          //
783                  h.setMarks(new Mark[] { sb.createMark("square", color) });          // final LineSymbolizer ls = sb.createLineSymbolizer(color);
784            // final Graphic h = sb.createGraphic();
785                  final PointSymbolizer pts = sb.createPointSymbolizer(h);          // h.setMarks(new Mark[] { sb.createMark("square", color) });
786            //
787                  // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});          // final PointSymbolizer pts = sb.createPointSymbolizer(h);
788                  switch (type) {          //
789                  case POLYGON:          // // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});
790                          s = sb.createStyle(ps);          // switch (type) {
791            // case POLYGON:
792                          break;          // s = sb.createStyle(ps);
793            //
794                  case POINT:          // break;
795                          s = sb.createStyle(pts);          //
796            // case POINT:
797                          break;          // s = sb.createStyle(pts);
798            //
799                  case LINE:          // break;
800                          s = sb.createStyle(ls);          //
801                  }          // case LINE:
802            // s = sb.createStyle(ls);
803                  return s;          // }
804          }          //
805            // return s;
806          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();  
         }  
807    
808          public void propertyChange(final PropertyChangeEvent evt) {          public void propertyChange(final PropertyChangeEvent evt) {
809                  final String prop = evt.getPropertyName();                  final String prop = evt.getPropertyName();
# Line 1220  public class JMapPane extends JPanel imp Line 887  public class JMapPane extends JPanel imp
887          public void mouseMoved(final MouseEvent e) {          public void mouseMoved(final MouseEvent e) {
888          }          }
889    
         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);  
   
         }  
   
890          // xulu.sn          // xulu.sn
891          /**          /**
892           * 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 905  public class JMapPane extends JPanel imp
905                  if (env == null)                  if (env == null)
906                          return env;                          return env;
907    
908                    Envelope newArea = null;
909    
910                  /**                  /**
911                   * Correct the aspect Ratio before we check the rest. Otherwise we might                   * Correct the aspect Ratio before we check the rest. Otherwise we might
912                   * easily fail.                   * easily fail.
# Line 1284  public class JMapPane extends JPanel imp Line 916  public class JMapPane extends JPanel imp
916                  final double scale = env.getWidth() / getWidth();                  final double scale = env.getWidth() / getWidth();
917                  final double centerX = env.getMinX() + env.getWidth() / 2.;                  final double centerX = env.getMinX() + env.getWidth() / 2.;
918                  final double centerY = env.getMinY() + env.getHeight() / 2.;                  final double centerY = env.getMinY() + env.getHeight() / 2.;
919                  double newWidth2;                  double newWidth2 = 0;
920                  double newHeight2;                  double newHeight2 = 0;
921                  if (scale < getMaxZoomScale()) {                  if (scale < getMaxZoomScale()) {
922                          // ****************************************************************************                          // ****************************************************************************
923                          // 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 934  public class JMapPane extends JPanel imp
934                          // ****************************************************************************                          // ****************************************************************************
935                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
936                          // ****************************************************************************                          // ****************************************************************************
937                          return env;                          newArea = env;
938                  }                  }
939    
940                  final Coordinate ll = new Coordinate(centerX - newWidth2, centerY                  if (newArea == null) {
                                 - newHeight2);  
                 final Coordinate ur = new Coordinate(centerX + newWidth2, centerY  
                                 + newHeight2);  
941    
942                  return new Envelope(ll, ur);                          final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
943                                            - newHeight2);
944                            final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
945                                            + newHeight2);
946    
947                            newArea = new Envelope(ll, ur);
948                    }
949    
950                    if (getMaxExtend() != null) {
951    
952                            while (!getMaxExtend().contains(newArea)) {
953                                    /*
954                                     * If a maxExtend is set, we have to honour that...
955                                     */
956    
957                                    // Exceeds top? Move down and maybe cut
958                                    if (newArea.getMaxY() > maxExtend.getMaxY()) {
959                                            double divY = newArea.getMaxY() - maxExtend.getMaxY();
960                                            LOGGER.debug("Moving area down by " + divY);
961    
962                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
963                                                            newArea.getMinY() - divY), new Coordinate(newArea
964                                                            .getMaxX(), newArea.getMaxY() - divY));
965    
966                                            if (newArea.getMinY() < maxExtend.getMinY()) {
967                                                    LOGGER.debug("Now it exeeds the bottom border.. cut!");
968                                                    // And cut the bottom if it moved out of the area
969                                                    newArea = new Envelope(new Coordinate(
970                                                                    newArea.getMinX(), maxExtend.getMinY()),
971                                                                    new Coordinate(newArea.getMaxX(), newArea
972                                                                                    .getMaxY()));
973    
974                                                    LOGGER.debug("and fix aspect ratio");
975    
976                                                    newArea = fixAspectRatio(this.getBounds(), newArea);
977                                            }
978                                    }
979    
980                                    // Exceeds bottom? Move up and maybe cut
981                                    if (newArea.getMinY() < maxExtend.getMinY()) {
982                                            double divY = newArea.getMinY() - maxExtend.getMinY();
983                                            LOGGER.debug("Moving area up by " + divY);
984    
985                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
986                                                            newArea.getMinY() - divY), new Coordinate(newArea
987                                                            .getMaxX(), newArea.getMaxY() - divY));
988    
989                                            if (newArea.getMaxY() > maxExtend.getMaxY()) {
990                                                    LOGGER.debug("Now it exeeds the top border.. cut!");
991                                                    // And cut the bottom if it moved out of the area
992                                                    newArea = new Envelope(new Coordinate(
993                                                                    newArea.getMinX(), newArea.getMinY()),
994                                                                    new Coordinate(newArea.getMaxX(), maxExtend
995                                                                                    .getMaxY()));
996    
997                                                    LOGGER.debug("and fix aspect ratio");
998    
999                                                    newArea = fixAspectRatio(this.getBounds(), newArea);
1000                                            }
1001                                    }
1002    
1003                                    // Exceeds to the right? move and maybe cut
1004                                    if (newArea.getMaxX() > maxExtend.getMaxX()) {
1005    
1006                                            // Move left..
1007                                            double divX = newArea.getMaxX() - maxExtend.getMaxX();
1008                                            LOGGER.debug("Moving area left by " + divX);
1009    
1010                                            newArea = new Envelope(new Coordinate(newArea.getMinX()
1011                                                            - divX, newArea.getMinY()), new Coordinate(newArea
1012                                                            .getMaxX()
1013                                                            - divX, newArea.getMaxY()));
1014    
1015                                            if (newArea.getMinX() < maxExtend.getMinX()) {
1016                                                    LOGGER.debug("Now it exeeds the left border.. cut!");
1017                                                    // And cut the left if it moved out of the area
1018                                                    newArea = new Envelope(new Coordinate(maxExtend
1019                                                                    .getMinX(), newArea.getMinY()), new Coordinate(
1020                                                                    newArea.getMaxX(), newArea.getMaxY()));
1021    
1022                                                    LOGGER.debug("and fix aspect ratio");
1023    
1024                                                    newArea = fixAspectRatio(this.getBounds(), newArea);
1025                                            }
1026                                    }
1027    
1028                                    // Exceeds to the left? move and maybe cut
1029                                    if (newArea.getMinX() < maxExtend.getMinX()) {
1030    
1031                                            // Move right..
1032                                            double divX = newArea.getMinX() - maxExtend.getMinX();
1033                                            LOGGER.debug("Moving area right by " + divX);
1034    
1035                                            newArea = new Envelope(new Coordinate(newArea.getMinX()
1036                                                            - divX, newArea.getMinY()), new Coordinate(newArea
1037                                                            .getMaxX()
1038                                                            - divX, newArea.getMaxY()));
1039    
1040                                            if (newArea.getMaxX() > maxExtend.getMaxX()) {
1041                                                    LOGGER.debug("Now it exeeds the right border.. cut!");
1042                                                    // And cut the left if it moved out of the area
1043                                                    newArea = new Envelope(new Coordinate(
1044                                                                    newArea.getMinX(), newArea.getMinY()),
1045                                                                    new Coordinate(maxExtend.getMaxX(), newArea
1046                                                                                    .getMaxY()));
1047    
1048                                                    LOGGER.debug("and fix aspect ratio");
1049    
1050                                                    newArea = fixAspectRatio(this.getBounds(), newArea);
1051                                            }
1052                                    }
1053    
1054                            }
1055    
1056                    }
1057    
1058                    return newArea;
1059          }          }
1060    
1061          /**          /**
# Line 1343  public class JMapPane extends JPanel imp Line 1088  public class JMapPane extends JPanel imp
1088           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
1089           */           */
1090          public void setMaxZoomScale(final Double maxZoomScale) {          public void setMaxZoomScale(final Double maxZoomScale) {
                 // System.out.println("setting max scale to "+maxZoomScale);  
1091                  this.maxZoomScale = maxZoomScale;                  this.maxZoomScale = maxZoomScale;
1092          }          }
1093    
# Line 1357  public class JMapPane extends JPanel imp Line 1101  public class JMapPane extends JPanel imp
1101          public void setMinZoomScale(final Double minZoomScale) {          public void setMinZoomScale(final Double minZoomScale) {
1102                  this.minZoomScale = minZoomScale;                  this.minZoomScale = minZoomScale;
1103          }          }
1104          // xulu.en  
1105            /**
1106             * Defines an evelope of the viwable area. The JMapPane will never show
1107             * anything outside of this extend.
1108             *
1109             * @param maxExtend
1110             *            <code>null</code> to not have this restriction.
1111             */
1112            public void setMaxExtend(Envelope maxExtend) {
1113                    this.maxExtend = maxExtend;
1114            }
1115    
1116            /**
1117             * Returns the evelope of the viewable area. The JMapPane will never show
1118             * anything outside of this extend.
1119             *
1120             * @param maxExtend
1121             *            <code>null</code> to not have this restriction.
1122             */
1123    
1124            public Envelope getMaxExtend() {
1125                    return maxExtend;
1126            }
1127    
1128  }  }
Legend:
Removed from v.320  
changed lines
  Added in v.415
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26