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

trunk/src/org/geotools/gui/swing/JMapPane.java revision 307 by alfonx, Thu Aug 20 13:49:50 2009 UTC branches/1.0-gt2-2.6/src/gtmig/org/geotools/swing/JMapPane.java revision 494 by mojays, Fri Oct 23 14:16:17 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.gui.swing.event.HighlightChangeListener;  
 import org.geotools.gui.swing.event.HighlightChangedEvent;  
 import org.geotools.gui.swing.event.SelectionChangeListener;  
 import org.geotools.gui.swing.event.SelectionChangedEvent;  
 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;
 import org.geotools.renderer.shape.TransitionShapefileRenderer;  
 import org.geotools.styling.Graphic;  
 import org.geotools.styling.LineSymbolizer;  
 import org.geotools.styling.Mark;  
 import org.geotools.styling.PointSymbolizer;  
 import org.geotools.styling.PolygonSymbolizer;  
 import org.geotools.styling.Style;  
 import org.geotools.styling.StyleBuilder;  
 import org.geotools.styling.StyleFactory;  
 import org.opengis.filter.Filter;  
68  import org.opengis.filter.FilterFactory2;  import org.opengis.filter.FilterFactory2;
69  import org.opengis.referencing.crs.CoordinateReferenceSystem;  import org.opengis.referencing.crs.CoordinateReferenceSystem;
70    
71    import schmitzm.geotools.JTSUtil;
72  import schmitzm.swing.SwingUtil;  import schmitzm.swing.SwingUtil;
73    
74  import com.vividsolutions.jts.geom.Coordinate;  import com.vividsolutions.jts.geom.Coordinate;
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 {
80                  PropertyChangeListener, MapLayerListListener {          private static Logger LOGGER = Logger.getLogger(JMapPane.class);
         private static Logger LOGGER = Logger.getLogger(JMapPane.class.getName());  
81    
82          private static final long serialVersionUID = -8647971481359690499L;          private static final long serialVersionUID = -8647971481359690499L;
83    
# Line 111  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 201  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 218  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 263  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 305  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 329  public class JMapPane extends JPanel imp Line 227  public class JMapPane extends JPanel imp
227          }          }
228    
229          public void setRenderer(final GTRenderer renderer) {          public void setRenderer(final GTRenderer renderer) {
230                  Map hints = new HashMap();                  Map<Object, Object> hints = new HashMap<Object, Object>();
231                    
232                  this.renderer = renderer;                  this.renderer = renderer;
233                    //MS: Apply hint also for ShapeFileRenderer
234                  if (renderer instanceof StreamingRenderer || renderer instanceof TransitionShapefileRenderer) {  //              if (renderer instanceof StreamingRenderer) {
235                          hints = renderer.getRendererHints();                          hints = renderer.getRendererHints();
236                          if (hints == null) {                          if (hints == null) {
237                                  hints = new HashMap();                                  hints = new HashMap<Object, Object>();
238                          }                          }
239                          if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {                          if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {
240                                  labelCache = (LabelCache) hints                                  labelCache = (LabelCache) hints
# Line 346  public class JMapPane extends JPanel imp Line 244  public class JMapPane extends JPanel imp
244                          }                          }
245    
246                          hints.put("memoryPreloadingEnabled", Boolean.TRUE);                          hints.put("memoryPreloadingEnabled", Boolean.TRUE);
                           
                         renderer.setRendererHints(hints);  
                 }  
   
 //              this.highlightRenderer = new StreamingRenderer();  
 //              this.selectionRenderer = new StreamingRenderer();  
247    
248  //              highlightRenderer.setRendererHints(hints);                          renderer.setRendererHints(hints);
249  //              selectionRenderer.setRendererHints(hints);  //              }
                   
 //              renderer.setRendererHints(hints);  
250    
251                  if (this.context != null) {                  if (this.context != null) {
252                          this.renderer.setContext(this.context);                          this.renderer.setContext(this.context);
# Line 409  public class JMapPane extends JPanel imp Line 299  public class JMapPane extends JPanel imp
299                  this.zoomFactor = zoomFactor;                  this.zoomFactor = zoomFactor;
300          }          }
301    
         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;  
         }  
   
302          protected void paintComponent(final Graphics g) {          protected void paintComponent(final Graphics g) {
303                  super.paintComponent(g);                  super.paintComponent(g);
304    
# Line 513  public class JMapPane extends JPanel imp Line 314  public class JMapPane extends JPanel imp
314                                  try {                                  try {
315                                          mapArea = context.getLayerBounds();                                          mapArea = context.getLayerBounds();
316                                  } catch (final IOException e) {                                  } catch (final IOException e) {
317                                          // TODO Auto-generated catch block                                          LOGGER.warn("context.getLayerBounds()", e);
                                         e.printStackTrace();  
318                                  }                                  }
319                          }                          }
320    
# Line 524  public class JMapPane extends JPanel imp Line 324  public class JMapPane extends JPanel imp
324                                  reset = false; /* forget about the reset */                                  reset = false; /* forget about the reset */
325                                  oldRect = r; /* store what the current size is */                                  oldRect = r; /* store what the current size is */
326    
327                                  mapArea = fixAspectRatio(r, mapArea);                                  mapArea = JTSUtil.fixAspectRatio(r, mapArea, false);
328                          }                          }
329                  }                  }
330    
# Line 537  public class JMapPane extends JPanel imp Line 337  public class JMapPane extends JPanel imp
337                                          .getCoordinateReferenceSystem());                                          .getCoordinateReferenceSystem());
338                  }                  }
339    
340                  if (changed ) { /* if the map changed then redraw */                  if (changed) { /* if the map changed then redraw */
341                          changed = false;                          changed = false;
342                          baseImage = new BufferedImage(dr.width, dr.height,                          baseImage = new BufferedImage(dr.width, dr.height,
343                                          BufferedImage.TYPE_INT_ARGB);                                          BufferedImage.TYPE_INT_ARGB);
344    
345                          final Graphics2D ig = baseImage.createGraphics();                          final Graphics2D ig = baseImage.createGraphics();
346                          /* System.out.println("rendering"); */                          /* System.out.println("rendering"); */
347                          if (renderer.getContext() != null)                          if (renderer.getContext() != null)
348                                  renderer.setContext(context);                                  renderer.setContext(context);
349                          labelCache.clear(); // work around anoying labelcache bug                          labelCache.clear(); // work around anoying labelcache bug
350    
# Line 558  public class JMapPane extends JPanel imp Line 358  public class JMapPane extends JPanel imp
358                  }                  }
359    
360                  ((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);  
                 }  
         }  
   
         private Envelope fixAspectRatio(final Rectangle r, final Envelope mapArea) {  
   
                 final double mapWidth = mapArea.getWidth(); /* get the extent of the map */  
                 final double mapHeight = mapArea.getHeight();  
                 final double scaleX = r.getWidth() / mapArea.getWidth(); /*  
                                                                                                                          * calculate the new  
                                                                                                                          * scale  
                                                                                                                          */  
   
                 final double scaleY = r.getHeight() / mapArea.getHeight();  
                 double scale = 1.0; // stupid compiler!  
   
                 if (scaleX < scaleY) { /* pick the smaller scale */  
                         scale = scaleX;  
                 } else {  
                         scale = scaleY;  
                 }  
   
                 /* calculate the difference in width and height of the new extent */  
                 final double deltaX = /* Math.abs */((r.getWidth() / scale) - mapWidth);  
                 final double deltaY = /* Math.abs */((r.getHeight() / scale) - mapHeight);  
   
                 /*  
                  * System.out.println("delta x " + deltaX);  
                  * System.out.println("delta y " + deltaY);  
                  */  
   
                 /* create the new extent */  
                 final Coordinate ll = new Coordinate(mapArea.getMinX() - (deltaX / 2.0),  
                                 mapArea.getMinY() - (deltaY / 2.0));  
                 final Coordinate ur = new Coordinate(mapArea.getMaxX() + (deltaX / 2.0),  
                                 mapArea.getMaxY() + (deltaY / 2.0));  
   
                 return new Envelope(ll, ur);  
         }  
   
         public void doSelection(final double x, final double y, final MapLayer layer) {  
   
                 final Geometry geometry = gf.createPoint(new Coordinate(x, y));  
   
                 // org.opengis.geometry.Geometry geometry = new Point();  
   
                 findFeature(geometry, layer);  
   
         }  
   
         /**  
          * @param geometry  
          *            - a geometry to construct the filter with  
          * @param i  
          *            - the index of the layer to search  
          * @throws IndexOutOfBoundsException  
          */  
         private void findFeature(final Geometry geometry, final MapLayer layer)  
                         throws IndexOutOfBoundsException {  
                 org.opengis.filter.spatial.BinarySpatialOperator f = null;  
   
                 if ((context == null) || (layer == null)) {  
                         return;  
                 }  
   
                 try {  
                         String name = layer.getFeatureSource().getSchema()  
                                         .getDefaultGeometry().getLocalName();  
   
                         if (name == "") {  
                                 name = "the_geom";  
                         }  
   
                         try {  
                                 f = ff.contains(ff.property(name), ff.literal(geometry));  
                                 if (selectionManager != null) {  
 //                                      System.out.println("selection changed");  
                                         selectionManager.selectionChanged(this, f);  
   
                                 }  
                         } catch (final IllegalFilterException e) {  
                                 // TODO Auto-generated catch block  
                                 e.printStackTrace();  
                         }  
   
                         /*  
                          * // f.addLeftGeometry(ff.property(name)); //  
                          * System.out.println("looking with " + f); FeatureCollection fc =  
                          * layer.getFeatureSource().getFeatures(f);  
                          *  
                          *  
                          *  
                          * if (fcol == null) { fcol = fc;  
                          *  
                          * // here we should set the defaultgeom type } else {  
                          * fcol.addAll(fc); }  
                          */  
   
                         /*  
                          * GeometryAttributeType gat =  
                          * layer.getFeatureSource().getSchema().getDefaultGeometry();  
                          * fcol.setDefaultGeometry((Geometry)gat.createDefaultValue());  
                          */  
   
                         /*  
                          * Iterator fi = fc.iterator(); while (fi.hasNext()) { Feature feat  
                          * = (Feature) fi.next(); System.out.println("selected " +  
                          * feat.getAttribute("STATE_NAME")); }  
                          */  
                 } catch (final IllegalFilterException e) {  
                         // TODO Auto-generated catch block  
                         e.printStackTrace();  
                 }  
                 return;  
361          }          }
362    
363          public void mouseClicked(final MouseEvent e) {          public void mouseClicked(final MouseEvent e) {
364                  if (mapArea == null) return;                  if (mapArea == null)
365                            return;
366                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"
367                  // h:"+mapArea.getHeight());                  // h:"+mapArea.getHeight());
368                  final Rectangle bounds = this.getBounds();                  final Rectangle bounds = this.getBounds();
# Line 755  public class JMapPane extends JPanel imp Line 376  public class JMapPane extends JPanel imp
376                  final double width2 = width / 2.0;                  final double width2 = width / 2.0;
377                  final double height2 = height / 2.0;                  final double height2 = height / 2.0;
378                  // xulu.ec                  // xulu.ec
379                  final double mapX = ((x * width) / (double) bounds.width) + mapArea.getMinX();                  final double mapX = ((x * width) / (double) bounds.width)
380                                    + mapArea.getMinX();
381                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)                  final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)
382                                  + mapArea.getMinY();                                  + mapArea.getMinY();
383    
# Line 786  public class JMapPane extends JPanel imp Line 408  public class JMapPane extends JPanel imp
408                          zlevel = 1.0 / zoomFactor;                          zlevel = 1.0 / zoomFactor;
409    
410                          break;                          break;
411                    //
412                  case Select:                  // case Select:
413                          doSelection(mapX, mapY, selectionLayer);                  // doSelection(mapX, mapY, selectionLayer);
414                    //
415                          return;                  // return;
416    
417                  default:                  default:
418                          return;                          return;
# Line 862  public class JMapPane extends JPanel imp Line 484  public class JMapPane extends JPanel imp
484                                  // System.out.println("translate "+dx+","+dy);                                  // System.out.println("translate "+dx+","+dy);
485                                  final Graphics2D g2 = panningImage.createGraphics();                                  final Graphics2D g2 = panningImage.createGraphics();
486                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige
487                                                                                                                          // farbe? am besten                                  // farbe? am besten
488                                                                                                                          // vom L&F die                                  // vom L&F die
489                                                                                                                          // hintergrundfarbe                                  // hintergrundfarbe
490                                                                                                                          // auslesen...                                  // auslesen...
491                                    
492                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());
493                                  g2.drawImage(baseImage, dx, dy, this);                                  g2.drawImage(baseImage, dx, dy, this);
494                                  graphics.drawImage(panningImage, 0, 0, this);                                  graphics.drawImage(panningImage, 0, 0, this);
# Line 888  public class JMapPane extends JPanel imp Line 510  public class JMapPane extends JPanel imp
510                          lastX = x;                          lastX = x;
511                          lastY = y;                          lastY = y;
512                          drawRectangle(graphics);                          drawRectangle(graphics);
                 } 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);  
513                  }                  }
514                    // else if (state == JMapPane.Select && selectionLayer != null) {
515                    //
516                    // // construct a new bbox filter
517                    // final Rectangle bounds = this.getBounds();
518                    //
519                    // final double mapWidth = mapArea.getWidth();
520                    // final double mapHeight = mapArea.getHeight();
521                    //
522                    // final double x1 = ((this.startX * mapWidth) / (double) bounds.width)
523                    // + mapArea.getMinX();
524                    // final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) /
525                    // (double) bounds.height)
526                    // + mapArea.getMinY();
527                    // final double x2 = ((x * mapWidth) / (double) bounds.width)
528                    // + mapArea.getMinX();
529                    // final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double)
530                    // bounds.height)
531                    // + mapArea.getMinY();
532                    // final double left = Math.min(x1, x2);
533                    // final double right = Math.max(x1, x2);
534                    // final double bottom = Math.min(y1, y2);
535                    // final double top = Math.max(y1, y2);
536                    //
537                    // String name = selectionLayer.getFeatureSource().getSchema()
538                    // .getDefaultGeometry().getName();
539                    //
540                    // if (name == "") {
541                    // name = "the_geom";
542                    // }
543                    // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
544                    // top,
545                    // getContext().getCoordinateReferenceSystem().toString());
546                    // if (selectionManager != null) {
547                    // selectionManager.selectionChanged(this, bb);
548                    // }
549                    //
550                    // graphics.setXORMode(Color.green);
551                    //
552                    // /*
553                    // * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }
554                    // */
555                    //
556                    // // draw new box
557                    // lastX = x;
558                    // lastY = y;
559                    // drawRectangle(graphics);
560                    // }
561    
562          }          }
563    
# Line 941  public class JMapPane extends JPanel imp Line 567  public class JMapPane extends JPanel imp
567          protected void processDrag(final int x1, final int y1, final int x2,          protected void processDrag(final int x1, final int y1, final int x2,
568                          final int y2, final MouseEvent e) {                          final int y2, final MouseEvent e) {
569    
570    
571                  /****                  /****
572                   * If no layer is availabe we dont want a NullPointerException                   * If no layers exist, we ignore the drag.
573                   */                   */
574                  if (mapArea == null)                  if (context.getLayerCount() <= 0) {
575                          return;                          return;
576                    }
577                    
578                  // System.out.println("processing drag from " + x1 + "," + y1 + " -> "                  // System.out.println("processing drag from " + x1 + "," + y1 + " -> "
579                  // + x2 + "," + y2);                  // + x2 + "," + y2);
580                  if ((x1 == x2) && (y1 == y2)) {                  if ((x1 == x2) && (y1 == y2)) {
# Line 992  public class JMapPane extends JPanel imp Line 620  public class JMapPane extends JPanel imp
620                          final Coordinate ur = new Coordinate(right, top);                          final Coordinate ur = new Coordinate(right, top);
621                          // xulu.sc                          // xulu.sc
622                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
623                          setMapArea(fixAspectRatio(this.getBounds(), new Envelope(ll, ur)));                          
624    
625                            setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
626                          // xulu.ec                          // xulu.ec
627                  } else if (state == JMapPane.ZoomIn) {                  } else if (state == JMapPane.ZoomIn) {
628    
# Line 1016  public class JMapPane extends JPanel imp Line 646  public class JMapPane extends JPanel imp
646                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
647    
648                          // sk.sc                          // sk.sc
649  //                      {                          // {
650  //                      // SK tries to paint a preview of the zoom ;-9 aha.... well                          // // SK tries to paint a preview of the zoom ;-9 aha.... well
651  //                      Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();                          // Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();
652  //                      graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,                          // graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
653  //                                      RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);                          // RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
654  //                      graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,                          // graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
655  //                                      RenderingHints.VALUE_ANTIALIAS_OFF);                          // RenderingHints.VALUE_ANTIALIAS_OFF);
656  //                      graphics.setRenderingHint(RenderingHints.KEY_RENDERING,                          // graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
657  //                                      RenderingHints.VALUE_RENDER_SPEED);                          // RenderingHints.VALUE_RENDER_SPEED);
658  //                      graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),                          // graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),
659  //                                      JMapPane.this.getHeight(), x1, y1, x2, y2, null);                          // JMapPane.this.getHeight(), x1, y1, x2, y2, null);
660  //                      }                          // }
661                          // xulu.ec                          // xulu.ec
662                  } else if (state == JMapPane.ZoomOut) {                  } else if (state == JMapPane.ZoomOut) {
663                          drawRectangle(this.getGraphics());                          drawRectangle(this.getGraphics());
# Line 1056  public class JMapPane extends JPanel imp Line 686  public class JMapPane extends JPanel imp
686                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
687    
688                          // 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(); }  
                          */  
689                  }                  }
690                    // else if (state == JMapPane.Select && selectionLayer != null) {
691                    // final double left = Math.min(startX, endX);
692                    // final double right = Math.max(startX, endX);
693                    // final double bottom = Math.min(startY, endY);
694                    // final double top = Math.max(startY, endY);
695                    //
696                    // String name = selectionLayer.getFeatureSource().getSchema()
697                    // .getDefaultGeometry().getLocalName();
698                    //
699                    // if (name == "") {
700                    // name = "the_geom";
701                    // }
702                    // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
703                    // top,
704                    // getContext().getCoordinateReferenceSystem().toString());
705                    // // System.out.println(bb.toString());
706                    // if (selectionManager != null) {
707                    // selectionManager.selectionChanged(this, bb);
708                    // }
709                    // /*
710                    // * FeatureCollection fc; selection = null; try { fc =
711                    // * selectionLayer.getFeatureSource().getFeatures(bb); selection =
712                    // * fc; } catch (IOException e) { e.printStackTrace(); }
713                    // */
714                    // }
715    
716                  // xulu.so                  // xulu.so
717                  // setMapArea(mapArea);                  // setMapArea(mapArea);
# Line 1091  public class JMapPane extends JPanel imp Line 723  public class JMapPane extends JPanel imp
723                  return clickable;                  return clickable;
724          }          }
725    
726          private org.geotools.styling.Style setupStyle(final int type, final Color color) {          //
727                  final StyleFactory sf = org.geotools.factory.CommonFactoryFinder          // private org.geotools.styling.Style setupStyle(final int type, final Color
728                                  .getStyleFactory(null);          // color) {
729                  final StyleBuilder sb = new StyleBuilder();          // final StyleFactory sf = org.geotools.factory.CommonFactoryFinder
730            // .getStyleFactory(null);
731                  org.geotools.styling.Style s = sf.createStyle();          // final StyleBuilder sb = new StyleBuilder();
732                  s.setTitle("selection");          //
733            // org.geotools.styling.Style s = sf.createStyle();
734                  // TODO parameterise the color          // s.setTitle("selection");
735                  final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);          //
736                  ps.setStroke(sb.createStroke(color));          // // TODO parameterise the color
737            // final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);
738                  final LineSymbolizer ls = sb.createLineSymbolizer(color);          // ps.setStroke(sb.createStroke(color));
739                  final Graphic h = sb.createGraphic();          //
740                  h.setMarks(new Mark[] { sb.createMark("square", color) });          // final LineSymbolizer ls = sb.createLineSymbolizer(color);
741            // final Graphic h = sb.createGraphic();
742                  final PointSymbolizer pts = sb.createPointSymbolizer(h);          // h.setMarks(new Mark[] { sb.createMark("square", color) });
743            //
744                  // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});          // final PointSymbolizer pts = sb.createPointSymbolizer(h);
745                  switch (type) {          //
746                  case POLYGON:          // // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});
747                          s = sb.createStyle(ps);          // switch (type) {
748            // case POLYGON:
749                          break;          // s = sb.createStyle(ps);
750            //
751                  case POINT:          // break;
752                          s = sb.createStyle(pts);          //
753            // case POINT:
754                          break;          // s = sb.createStyle(pts);
755            //
756                  case LINE:          // break;
757                          s = sb.createStyle(ls);          //
758                  }          // case LINE:
759            // s = sb.createStyle(ls);
760                  return s;          // }
761          }          //
762            // return s;
763          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();  
         }  
764    
765          public void propertyChange(final PropertyChangeEvent evt) {          public void propertyChange(final PropertyChangeEvent evt) {
766                  final String prop = evt.getPropertyName();                  final String prop = evt.getPropertyName();
# Line 1223  public class JMapPane extends JPanel imp Line 844  public class JMapPane extends JPanel imp
844          public void mouseMoved(final MouseEvent e) {          public void mouseMoved(final MouseEvent e) {
845          }          }
846    
         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);  
   
         }  
   
847          // xulu.sn          // xulu.sn
848          /**          /**
849           * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste           * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste
# Line 1278  public class JMapPane extends JPanel imp Line 862  public class JMapPane extends JPanel imp
862                  if (env == null)                  if (env == null)
863                          return env;                          return env;
864    
865                    Envelope newArea = null;
866    
867                  /**                  /**
868                   * Correct the aspect Ratio before we check the rest. Otherwise we might                   * Correct the aspect Ratio before we check the rest. Otherwise we might
869                   * easily fail.                   * easily fail.
870                   */                   */
871                  env = fixAspectRatio(this.getBounds(), env);                  env = JTSUtil.fixAspectRatio(this.getBounds(), env, false);
872    
873                  final double scale = env.getWidth() / getWidth();                  final double scale = env.getWidth() / getWidth();
874                  final double centerX = env.getMinX() + env.getWidth() / 2.;                  final double centerX = env.getMinX() + env.getWidth() / 2.;
875                  final double centerY = env.getMinY() + env.getHeight() / 2.;                  final double centerY = env.getMinY() + env.getHeight() / 2.;
876                  double newWidth2;                  double newWidth2 = 0;
877                  double newHeight2;                  double newHeight2 = 0;
878                  if (scale < getMaxZoomScale()) {                  if (scale < getMaxZoomScale()) {
879                          // ****************************************************************************                          // ****************************************************************************
880                          // Wir zoomen weiter rein als erlaubt => Anpassen des envelope                          // Wir zoomen weiter rein als erlaubt => Anpassen des envelope
# Line 1305  public class JMapPane extends JPanel imp Line 891  public class JMapPane extends JPanel imp
891                          // ****************************************************************************                          // ****************************************************************************
892                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
893                          // ****************************************************************************                          // ****************************************************************************
894                          return env;                          newArea = env;
895                  }                  }
896    
897                  final Coordinate ll = new Coordinate(centerX - newWidth2, centerY                  if (newArea == null) {
                                 - newHeight2);  
                 final Coordinate ur = new Coordinate(centerX + newWidth2, centerY  
                                 + newHeight2);  
898    
899                  return new Envelope(ll, ur);                          final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
900                                            - newHeight2);
901                            final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
902                                            + newHeight2);
903    
904                            newArea = new Envelope(ll, ur);
905                    }
906    
907                    Envelope maxAllowedExtend = getMaxExtend();
908                    while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea) && newArea != null && !newArea.isNull() && !Double.isNaN(newArea.getMinX()) && !Double.isNaN(newArea.getMaxX()) && !Double.isNaN(newArea.getMinY()) && !Double.isNaN(newArea.getMaxY()) ) {
909                            /*
910                             * If a maxExtend is set, we have to honour that...
911                             */
912    
913                            // Exceeds top? Move down and maybe cut
914                            if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
915                                    double divY = newArea.getMaxY() - maxAllowedExtend.getMaxY();
916    //                              LOGGER.debug("Moving area down by " + divY);
917    
918                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
919                                                    newArea.getMinY() - divY), new Coordinate(newArea
920                                                    .getMaxX(), newArea.getMaxY() - divY));
921    
922                                    if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
923    //                                      LOGGER.debug("Now it exeeds the bottom border.. cut!");
924                                            // And cut the bottom if it moved out of the area
925                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
926                                                            maxAllowedExtend.getMinY()), new Coordinate(newArea
927                                                            .getMaxX(), newArea.getMaxY()));
928    
929    //                                      LOGGER.debug("and fix aspect ratio");
930    
931                                            newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea, false);
932                                    }
933                            }
934    
935                            // Exceeds bottom? Move up and maybe cut
936                            if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
937                                    double divY = newArea.getMinY() - maxAllowedExtend.getMinY();
938    //                              LOGGER.debug("Moving area up by " + divY);
939    
940                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
941                                                    newArea.getMinY() - divY), new Coordinate(newArea
942                                                    .getMaxX(), newArea.getMaxY() - divY));
943    
944                                    if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
945    //                                      LOGGER.debug("Now it exeeds the top border.. cut!");
946                                            // And cut the bottom if it moved out of the area
947                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
948                                                            newArea.getMinY()), new Coordinate(newArea
949                                                            .getMaxX(), maxAllowedExtend.getMaxY()));
950    
951    //                                      LOGGER.debug("and fix aspect ratio");
952    
953                                            newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea, false);
954                                    }
955                            }
956    
957                            // Exceeds to the right? move and maybe cut
958                            if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
959    
960                                    // Move left..
961                                    double divX = newArea.getMaxX() - maxAllowedExtend.getMaxX();
962    //                              LOGGER.debug("Moving area left by " + divX);
963    
964                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
965                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
966                                                    - divX, newArea.getMaxY()));
967    
968                                    if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
969    //                                      LOGGER.debug("Now it exeeds the left border.. cut!");
970                                            // And cut the left if it moved out of the area
971                                            newArea = new Envelope(new Coordinate(maxAllowedExtend.getMinX(),
972                                                            newArea.getMinY()), new Coordinate(newArea
973                                                            .getMaxX(), newArea.getMaxY()));
974    
975    //                                      LOGGER.debug("and fix aspect ratio");
976    
977                                            newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea, false);
978                                    }
979                            }
980    
981                            // Exceeds to the left? move and maybe cut
982                            if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
983    
984                                    // Move right..
985                                    double divX = newArea.getMinX() - maxAllowedExtend.getMinX();
986    //                              LOGGER.debug("Moving area right by " + divX);
987    
988                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
989                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
990                                                    - divX, newArea.getMaxY()));
991    
992                                    if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
993    //                                      LOGGER.debug("Now it exeeds the right border.. cut!");
994                                            // And cut the left if it moved out of the area
995                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
996                                                            newArea.getMinY()), new Coordinate(maxAllowedExtend
997                                                            .getMaxX(), newArea.getMaxY()));
998    
999    //                                      LOGGER.debug("and fix aspect ratio");
1000    
1001                                            newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea, false);
1002                                    }
1003                            }
1004    
1005                    }
1006    
1007                    return newArea;
1008          }          }
1009    
1010          /**          /**
# Line 1346  public class JMapPane extends JPanel imp Line 1037  public class JMapPane extends JPanel imp
1037           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
1038           */           */
1039          public void setMaxZoomScale(final Double maxZoomScale) {          public void setMaxZoomScale(final Double maxZoomScale) {
                 // System.out.println("setting max scale to "+maxZoomScale);  
1040                  this.maxZoomScale = maxZoomScale;                  this.maxZoomScale = maxZoomScale;
1041          }          }
1042    
# Line 1360  public class JMapPane extends JPanel imp Line 1050  public class JMapPane extends JPanel imp
1050          public void setMinZoomScale(final Double minZoomScale) {          public void setMinZoomScale(final Double minZoomScale) {
1051                  this.minZoomScale = minZoomScale;                  this.minZoomScale = minZoomScale;
1052          }          }
1053          // xulu.en  
1054            /**
1055             * Defines an evelope of the viwable area. The JMapPane will never show
1056             * anything outside of this extend.
1057             *
1058             * @param maxExtend
1059             *            <code>null</code> to not have this restriction.
1060             */
1061            public void setMaxExtend(Envelope maxExtend) {
1062                    this.maxExtend = maxExtend;
1063            }
1064    
1065            /**
1066             * Returns the evelope of the viewable area. The JMapPane will never show
1067             * anything outside of this extend. If this has been set to
1068             * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
1069             * quickly the context's bounds. It it takes to long to determine the
1070             * context bounds, <code>null</code> is returned.
1071             *
1072             * @param maxExtend
1073             *            <code>null</code> to not have this restriction.
1074             */
1075    
1076            public Envelope getMaxExtend() {
1077                    if (maxExtend == null) {
1078                            try {
1079                                    return fixAspectRatio(
1080                                        this.getBounds(),
1081                            // Kartenbereich um 10% vergroessern
1082                                        JTSUtil.expandEnvelope(context.getLayerBounds(), 0.1),
1083                                        true
1084                                    );
1085                            } catch (IOException e) {
1086                                    LOGGER.warn(
1087                                                                    "maxExtend == null; failed to getLayerBounds of context",
1088                                                                    e);
1089                            }
1090                    }
1091                    return maxExtend;
1092            }
1093    
1094  }  }
Legend:
Removed from v.307  
changed lines
  Added in v.494
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26