/[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 148 by alfonx, Thu Jun 18 16:31:56 2009 UTC branches/1.0-gt2-2.6/src/gtmig/org/geotools/swing/JMapPane.java revision 431 by alfonx, Sun Oct 4 16:55:52 2009 UTC
# Line 13  Line 13 
13   *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU   *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14   *    Lesser General Public License for more details.   *    Lesser General Public License for more details.
15   */   */
16  package org.geotools.gui.swing;  package gtmig.org.geotools.swing;
17    
18  /**  /**
19   * <b>Xulu:<br>   * <b>Xulu:<br>
# Line 43  import java.awt.Graphics; Line 43  import java.awt.Graphics;
43  import java.awt.Graphics2D;  import java.awt.Graphics2D;
44  import java.awt.LayoutManager;  import java.awt.LayoutManager;
45  import java.awt.Rectangle;  import java.awt.Rectangle;
 import java.awt.RenderingHints;  
46  import java.awt.event.InputEvent;  import java.awt.event.InputEvent;
47  import java.awt.event.MouseEvent;  import java.awt.event.MouseEvent;
48  import java.awt.event.MouseListener;  import java.awt.event.MouseListener;
# Line 57  import java.util.HashMap; Line 56  import java.util.HashMap;
56  import java.util.Map;  import java.util.Map;
57    
58  import javax.swing.JPanel;  import javax.swing.JPanel;
 import javax.swing.LookAndFeel;  
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;
68  import org.geotools.styling.Graphic;  import org.geotools.renderer.shape.ShapefileRenderer;
 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    
# Line 92  import schmitzm.swing.SwingUtil; Line 73  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 {
                 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;
83    
84          public static final int Reset = 0;          public static final int Reset = 0;
# Line 114  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 204  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 221  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 266  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 280  public class JMapPane extends JPanel imp Line 188  public class JMapPane extends JPanel imp
188           * @param context           * @param context
189           *            - the map context to display           *            - the map context to display
190           */           */
191          public JMapPane(GTRenderer render, MapContext context) {          public JMapPane(final GTRenderer render, final MapContext context) {
192                  this(null, true, render, context);                  this(null, true, render, context);
193          }          }
194    
# Line 296  public class JMapPane extends JPanel imp Line 204  public class JMapPane extends JPanel imp
204           * @param context           * @param context
205           *            - what to draw           *            - what to draw
206           */           */
207          public JMapPane(LayoutManager layout, boolean isDoubleBuffered,          public JMapPane(final LayoutManager layout, final boolean isDoubleBuffered,
208                          GTRenderer render, MapContext context) {                          final GTRenderer render, final MapContext context) {
209                  super(layout, isDoubleBuffered);                  super(layout, isDoubleBuffered);
210    
211                  ff = (FilterFactory2) org.geotools.factory.CommonFactoryFinder                  ff = (FilterFactory2) org.geotools.factory.CommonFactoryFinder
# Line 308  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 331  public class JMapPane extends JPanel imp Line 226  public class JMapPane extends JPanel imp
226                  return renderer;                  return renderer;
227          }          }
228    
229          public void setRenderer(GTRenderer renderer) {          public void setRenderer(final GTRenderer renderer) {
230                  Map hints = new HashMap();                  Map<Object, Object> hints = new HashMap<Object, Object>();
231                  if (renderer instanceof StreamingRenderer) {  
232                    this.renderer = renderer;
233    
234                    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 344  public class JMapPane extends JPanel imp Line 243  public class JMapPane extends JPanel imp
243                          } else {                          } else {
244                                  hints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);                                  hints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);
245                          }                          }
246    
247                            hints.put("memoryPreloadingEnabled", Boolean.TRUE);
248    
249                          renderer.setRendererHints(hints);                          renderer.setRendererHints(hints);
250                  }                  }
251    
252                  this.renderer = renderer;                  // this.highlightRenderer = new StreamingRenderer();
253                  this.highlightRenderer = new StreamingRenderer();                  // this.selectionRenderer = new StreamingRenderer();
                 this.selectionRenderer = new StreamingRenderer();  
254    
255                  hints.put("memoryPreloadingEnabled", Boolean.FALSE);                  // highlightRenderer.setRendererHints(hints);
256                  highlightRenderer.setRendererHints(hints);                  // selectionRenderer.setRendererHints(hints);
257                  selectionRenderer.setRendererHints(hints);  
258                    // 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 364  public class JMapPane extends JPanel imp Line 266  public class JMapPane extends JPanel imp
266                  return context;                  return context;
267          }          }
268    
269          public void setContext(MapContext context) {          public void setContext(final MapContext context) {
270                  if (this.context != null) {                  if (this.context != null) {
271                          this.context.removeMapLayerListListener(this);                          this.context.removeMapLayerListListener(this);
272                  }                  }
# Line 384  public class JMapPane extends JPanel imp Line 286  public class JMapPane extends JPanel imp
286                  return mapArea;                  return mapArea;
287          }          }
288    
289          public void setMapArea(Envelope mapArea) {          public void setMapArea(final Envelope mapArea) {
290                  this.mapArea = mapArea;                  this.mapArea = mapArea;
291          }          }
292    
# Line 392  public class JMapPane extends JPanel imp Line 294  public class JMapPane extends JPanel imp
294                  return state;                  return state;
295          }          }
296    
297          public void setState(int state) {          public void setState(final int state) {
298                  this.state = state;                  this.state = state;
299    
300                  // System.out.println("State: " + state);                  // System.out.println("State: " + state);
# Line 402  public class JMapPane extends JPanel imp Line 304  public class JMapPane extends JPanel imp
304                  return zoomFactor;                  return zoomFactor;
305          }          }
306    
307          public void setZoomFactor(double zoomFactor) {          public void setZoomFactor(final double zoomFactor) {
308                  this.zoomFactor = zoomFactor;                  this.zoomFactor = zoomFactor;
309          }          }
310    
311          public MapLayer getSelectionLayer() {          protected void paintComponent(final Graphics g) {
                 return selectionLayer;  
         }  
   
         public void setSelectionLayer(MapLayer selectionLayer) {  
                 this.selectionLayer = selectionLayer;  
                 if (selectionManager != null) {  
                         selectionManager.setSelectionLayer(selectionLayer);  
                 }  
         }  
   
         public boolean isHighlight() {  
                 return highlight;  
         }  
   
         public void setHighlight(boolean highlight) {  
                 this.highlight = highlight;  
         }  
   
         public MapLayer getHighlightLayer() {  
                 return highlightLayer;  
         }  
   
         public void setHighlightLayer(MapLayer highlightLayer) {  
                 this.highlightLayer = highlightLayer;  
   
                 if (highlightManager != null) {  
                         highlightManager.setHighlightLayer(highlightLayer);  
                 }  
         }  
   
         public HighlightManager getHighlightManager() {  
                 return highlightManager;  
         }  
   
         public void setHighlightManager(HighlightManager highlightManager) {  
                 this.highlightManager = highlightManager;  
                 this.highlightManager.addHighlightChangeListener(this);  
                 this.addMouseMotionListener(this.highlightManager);  
         }  
   
         public Style getLineHighlightStyle() {  
                 return lineHighlightStyle;  
         }  
   
         public void setLineHighlightStyle(Style lineHighlightStyle) {  
                 this.lineHighlightStyle = lineHighlightStyle;  
         }  
   
         public Style getLineSelectionStyle() {  
                 return lineSelectionStyle;  
         }  
   
         public void setLineSelectionStyle(Style lineSelectionStyle) {  
                 this.lineSelectionStyle = lineSelectionStyle;  
         }  
   
         public Style getPointHighlightStyle() {  
                 return pointHighlightStyle;  
         }  
   
         public void setPointHighlightStyle(Style pointHighlightStyle) {  
                 this.pointHighlightStyle = pointHighlightStyle;  
         }  
   
         public Style getPointSelectionStyle() {  
                 return pointSelectionStyle;  
         }  
   
         public void setPointSelectionStyle(Style pointSelectionStyle) {  
                 this.pointSelectionStyle = pointSelectionStyle;  
         }  
   
         public Style getPolygonHighlightStyle() {  
                 return polygonHighlightStyle;  
         }  
   
         public void setPolygonHighlightStyle(Style polygonHighlightStyle) {  
                 this.polygonHighlightStyle = polygonHighlightStyle;  
         }  
   
         public Style getPolygonSelectionStyle() {  
                 return polygonSelectionStyle;  
         }  
   
         public void setPolygonSelectionStyle(Style polygonSelectionStyle) {  
                 this.polygonSelectionStyle = polygonSelectionStyle;  
         }  
   
         protected void paintComponent(Graphics g) {  
312                  super.paintComponent(g);                  super.paintComponent(g);
313    
314                  if ((renderer == null) || (mapArea == null)) {                  if ((renderer == null) || (mapArea == null)) {
315                          return;                          return;
316                  }                  }
317    
318                  Rectangle r = getBounds();                  final Rectangle r = getBounds();
319                  Rectangle dr = new Rectangle(r.width, r.height);                  final Rectangle dr = new Rectangle(r.width, r.height);
320    
321                  if (!r.equals(oldRect) || reset) {                  if (!r.equals(oldRect) || reset) {
322                          if (!r.equals(oldRect) && (mapArea == null)) {                          if (!r.equals(oldRect) && (mapArea == null)) {
323                                  try {                                  try {
324                                          mapArea = context.getLayerBounds();                                          mapArea = context.getLayerBounds();
325                                  } catch (IOException e) {                                  } catch (final IOException e) {
326                                          // TODO Auto-generated catch block                                          LOGGER.warn("context.getLayerBounds()", e);
                                         e.printStackTrace();  
327                                  }                                  }
328                          }                          }
329    
# Line 521  public class JMapPane extends JPanel imp Line 333  public class JMapPane extends JPanel imp
333                                  reset = false; /* forget about the reset */                                  reset = false; /* forget about the reset */
334                                  oldRect = r; /* store what the current size is */                                  oldRect = r; /* store what the current size is */
335    
336                                  mapArea = fixAspectRatio(r, mapArea);                                  mapArea = fixAspectRatio(r, mapArea, false);
337                          }                          }
338                  }                  }
339    
# Line 539  public class JMapPane extends JPanel imp Line 351  public class JMapPane extends JPanel imp
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                          Graphics2D ig = baseImage.createGraphics();                          final Graphics2D ig = baseImage.createGraphics();
355                          /* System.out.println("rendering"); */                          /* System.out.println("rendering"); */
356                          renderer.setContext(context);                          if (renderer.getContext() != null)
357                                    renderer.setContext(context);
358                          labelCache.clear(); // work around anoying labelcache bug                          labelCache.clear(); // work around anoying labelcache bug
359    
360                          // draw the map                          // draw the map
361                          renderer.paint((Graphics2D) ig, dr, mapArea);                          renderer.paint((Graphics2D) ig, dr, mapArea);
362    
363                          // TODO , nur machen, wenn panning beginnt                          // TODO nur machen, wenn panning beginnt
364                          panningImage = new BufferedImage(dr.width, dr.height,                          panningImage = new BufferedImage(dr.width, dr.height,
365                                          BufferedImage.TYPE_INT_RGB);                                          BufferedImage.TYPE_INT_RGB);
366    
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);  
   
                         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;  
                         }  
   
                         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(Rectangle r, Envelope mapArea) {          /**
373             * Returns an {@link Envelope} that has the same aspect ratio as the given rectangle
374                  double mapWidth = mapArea.getWidth(); /* get the extent of the map */           * @param grow
375                  double mapHeight = mapArea.getHeight();           *            If <code>true</code>, than the area will be enlarged to match
376                  double scaleX = r.getWidth() / mapArea.getWidth(); /*           *            the aspect ratio. If <code>false</code>, it will only shrink.
377                                                                                                                           * calculate the new           */
378                                                                                                                           * scale          private Envelope fixAspectRatio(final Rectangle r, final Envelope mapArea,
379                                                                                                                           */                          boolean grow) {
380                    
381                    if (mapArea == null) {
382                            LOGGER.warn("mapArea has been null in method fixAspectRatio, returning an unmodified ");
383                    }
384    
385                    final double mapWidth = mapArea.getWidth(); /* get the extent of the map */
386                    final double mapHeight = mapArea.getHeight();
387                    final double scaleX = r.getWidth() / mapArea.getWidth(); /*
388                                                                                                                                     * calculate the
389                                                                                                                                     * new scale
390                                                                                                                                     */
391    
392                  double scaleY = r.getHeight() / mapArea.getHeight();                  final double scaleY = r.getHeight() / mapArea.getHeight();
393                  double scale = 1.0; // stupid compiler!                  double scale = 1.0; // stupid compiler!
394    
395                  if (scaleX < scaleY) { /* pick the smaller scale */                  if ((grow && scaleX < scaleY) || (!grow && scaleX > scaleY)) {
396                          scale = scaleX;                          scale = scaleX;
397                  } else {                  } else {
398                          scale = scaleY;                          scale = scaleY;
399                  }                  }
400    
401                  /* calculate the difference in width and height of the new extent */                  /* calculate the difference in width and height of the new extent */
402                  double deltaX = /* Math.abs */((r.getWidth() / scale) - mapWidth);                  final double deltaX = /* Math.abs */((r.getWidth() / scale) - mapWidth);
403                  double deltaY = /* Math.abs */((r.getHeight() / scale) - mapHeight);                  final double deltaY = /* Math.abs */((r.getHeight() / scale) - mapHeight);
404    
405                  /*                  /*
406                   * System.out.println("delta x " + deltaX);                   * System.out.println("delta x " + deltaX);
# Line 652  public class JMapPane extends JPanel imp Line 408  public class JMapPane extends JPanel imp
408                   */                   */
409    
410                  /* create the new extent */                  /* create the new extent */
411                  Coordinate ll = new Coordinate(mapArea.getMinX() - (deltaX / 2.0),                  final Coordinate ll = new Coordinate(
412                                  mapArea.getMinY() - (deltaY / 2.0));                                  mapArea.getMinX() - (deltaX / 2.0), mapArea.getMinY()
413                  Coordinate ur = new Coordinate(mapArea.getMaxX() + (deltaX / 2.0),                                                  - (deltaY / 2.0));
414                                  mapArea.getMaxY() + (deltaY / 2.0));                  final Coordinate ur = new Coordinate(
415                                    mapArea.getMaxX() + (deltaX / 2.0), mapArea.getMaxY()
416                                                    + (deltaY / 2.0));
417    
418                  return new Envelope(ll, ur);                  return new Envelope(ll, ur);
419          }          }
420    
421          public void doSelection(double x, double y, MapLayer layer) {          public void mouseClicked(final MouseEvent e) {
422                    if (mapArea == null)
                 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(Geometry geometry, MapLayer layer)  
                         throws IndexOutOfBoundsException {  
                 org.opengis.filter.spatial.BinarySpatialOperator f = null;  
   
                 if ((context == null) || (layer == null)) {  
423                          return;                          return;
                 }  
   
                 try {  
                         String name = layer.getFeatureSource().getSchema()  
                                         .getDefaultGeometry().getName();  
   
                         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 (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 (IllegalFilterException e) {  
                         // TODO Auto-generated catch block  
                         e.printStackTrace();  
                 }  
                 return;  
         }  
   
         public void mouseClicked(MouseEvent e) {  
424                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"                  // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"
425                  // h:"+mapArea.getHeight());                  // h:"+mapArea.getHeight());
426                  Rectangle bounds = this.getBounds();                  final Rectangle bounds = this.getBounds();
427                  double x = (double) (e.getX());                  final double x = (double) (e.getX());
428                  double y = (double) (e.getY());                  final double y = (double) (e.getY());
429                  double width = mapArea.getWidth();                  final double width = mapArea.getWidth();
430                  double height = mapArea.getHeight();                  final double height = mapArea.getHeight();
431                  // xulu.sc                  // xulu.sc
432                  // double width2 = mapArea.getWidth() / 2.0;                  // double width2 = mapArea.getWidth() / 2.0;
433                  // double height2 = mapArea.getHeight() / 2.0;                  // double height2 = mapArea.getHeight() / 2.0;
434                  double width2 = width / 2.0;                  final double width2 = width / 2.0;
435                  double height2 = height / 2.0;                  final double height2 = height / 2.0;
436                  // xulu.ec                  // xulu.ec
437                  double mapX = ((x * width) / (double) bounds.width) + mapArea.getMinX();                  final double mapX = ((x * width) / (double) bounds.width)
438                  double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)                                  + mapArea.getMinX();
439                    final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)
440                                  + mapArea.getMinY();                                  + mapArea.getMinY();
441    
442                  /*                  /*
# Line 781  public class JMapPane extends JPanel imp Line 466  public class JMapPane extends JPanel imp
466                          zlevel = 1.0 / zoomFactor;                          zlevel = 1.0 / zoomFactor;
467    
468                          break;                          break;
469                    //
470                  case Select:                  // case Select:
471                          doSelection(mapX, mapY, selectionLayer);                  // doSelection(mapX, mapY, selectionLayer);
472                    //
473                          return;                  // return;
474    
475                  default:                  default:
476                          return;                          return;
477                  }                  }
478    
479                  Coordinate ll = new Coordinate(mapX - (width2 / zlevel), mapY                  final Coordinate ll = new Coordinate(mapX - (width2 / zlevel), mapY
480                                  - (height2 / zlevel));                                  - (height2 / zlevel));
481                  Coordinate ur = new Coordinate(mapX + (width2 / zlevel), mapY                  final Coordinate ur = new Coordinate(mapX + (width2 / zlevel), mapY
482                                  + (height2 / zlevel));                                  + (height2 / zlevel));
483                  // xulu.sc SK: Check for min/max scale                  // xulu.sc SK: Check for min/max scale
484                  // mapArea = new Envelope(ll, ur);                  // mapArea = new Envelope(ll, ur);
# Line 808  public class JMapPane extends JPanel imp Line 493  public class JMapPane extends JPanel imp
493                  repaint();                  repaint();
494          }          }
495    
496          public void mouseEntered(MouseEvent e) {          public void mouseEntered(final MouseEvent e) {
497          }          }
498    
499          public void mouseExited(MouseEvent e) {          public void mouseExited(final MouseEvent e) {
500          }          }
501    
502          public void mousePressed(MouseEvent e) {          public void mousePressed(final MouseEvent e) {
503                  startX = e.getX();                  startX = e.getX();
504                  startY = e.getY();                  startY = e.getY();
505                  lastX = 0;                  lastX = 0;
506                  lastY = 0;                  lastY = 0;
507          }          }
508    
509          public void mouseReleased(MouseEvent e) {          public void mouseReleased(final MouseEvent e) {
510                  int endX = e.getX();                  final int endX = e.getX();
511                  int endY = e.getY();                  final int endY = e.getY();
512    
513                  processDrag(startX, startY, endX, endY, e);                  processDrag(startX, startY, endX, endY, e);
514                  lastX = 0;                  lastX = 0;
# Line 835  public class JMapPane extends JPanel imp Line 520  public class JMapPane extends JPanel imp
520                  panning_started = false;                  panning_started = false;
521          }          }
522    
523          public void mouseDragged(MouseEvent e) {          public void mouseDragged(final MouseEvent e) {
524                  Graphics graphics = this.getGraphics();                  final Graphics graphics = this.getGraphics();
525                  int x = e.getX();                  final int x = e.getX();
526                  int y = e.getY();                  final int y = e.getY();
527    
528                  if ((state == JMapPane.Pan)                  if ((state == JMapPane.Pan)
529                                  || ((e.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) {                                  || ((e.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) {
# Line 852  public class JMapPane extends JPanel imp Line 537  public class JMapPane extends JPanel imp
537    
538                          // move the image with the mouse                          // move the image with the mouse
539                          if ((lastX > 0) && (lastY > 0)) {                          if ((lastX > 0) && (lastY > 0)) {
540                                  int dx = lastX - startX;                                  final int dx = lastX - startX;
541                                  int dy = lastY - startY;                                  final int dy = lastY - startY;
542                                  // System.out.println("translate "+dx+","+dy);                                  // System.out.println("translate "+dx+","+dy);
543                                  final Graphics2D g2 = panningImage.createGraphics();                                  final Graphics2D g2 = panningImage.createGraphics();
544                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige                                  g2.setBackground(new Color(240, 240, 240)); // TODO richtige
545                                                                                                                          // farbe? am besten                                  // farbe? am besten
546                                                                                                                          // vom L&F die                                  // vom L&F die
547                                                                                                                          // hintergrundfarbe                                  // hintergrundfarbe
548                                                                                                                          // auslesen...                                  // auslesen...
549                                    
550                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());
551                                  g2.drawImage(baseImage, dx, dy, this);                                  g2.drawImage(baseImage, dx, dy, this);
552                                  graphics.drawImage(panningImage, 0, 0, this);                                  graphics.drawImage(panningImage, 0, 0, this);
# Line 883  public class JMapPane extends JPanel imp Line 568  public class JMapPane extends JPanel imp
568                          lastX = x;                          lastX = x;
569                          lastY = y;                          lastY = y;
570                          drawRectangle(graphics);                          drawRectangle(graphics);
                 } else if (state == JMapPane.Select && selectionLayer != null) {  
   
                         // construct a new bbox filter  
                         Rectangle bounds = this.getBounds();  
   
                         double mapWidth = mapArea.getWidth();  
                         double mapHeight = mapArea.getHeight();  
   
                         double x1 = ((this.startX * mapWidth) / (double) bounds.width)  
                                         + mapArea.getMinX();  
                         double y1 = (((bounds.getHeight() - this.startY) * mapHeight) / (double) bounds.height)  
                                         + mapArea.getMinY();  
                         double x2 = ((x * mapWidth) / (double) bounds.width)  
                                         + mapArea.getMinX();  
                         double y2 = (((bounds.getHeight() - y) * mapHeight) / (double) bounds.height)  
                                         + mapArea.getMinY();  
                         double left = Math.min(x1, x2);  
                         double right = Math.max(x1, x2);  
                         double bottom = Math.min(y1, y2);  
                         double top = Math.max(y1, y2);  
   
                         String name = selectionLayer.getFeatureSource().getSchema()  
                                         .getDefaultGeometry().getName();  
   
                         if (name == "") {  
                                 name = "the_geom";  
                         }  
                         Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,  
                                         getContext().getCoordinateReferenceSystem().toString());  
                         if (selectionManager != null) {  
                                 selectionManager.selectionChanged(this, bb);  
                         }  
   
                         graphics.setXORMode(Color.green);  
   
                         /*  
                          * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }  
                          */  
   
                         // draw new box  
                         lastX = x;  
                         lastY = y;  
                         drawRectangle(graphics);  
571                  }                  }
572                    // else if (state == JMapPane.Select && selectionLayer != null) {
573                    //
574                    // // construct a new bbox filter
575                    // final Rectangle bounds = this.getBounds();
576                    //
577                    // final double mapWidth = mapArea.getWidth();
578                    // final double mapHeight = mapArea.getHeight();
579                    //
580                    // final double x1 = ((this.startX * mapWidth) / (double) bounds.width)
581                    // + mapArea.getMinX();
582                    // final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) /
583                    // (double) bounds.height)
584                    // + mapArea.getMinY();
585                    // final double x2 = ((x * mapWidth) / (double) bounds.width)
586                    // + mapArea.getMinX();
587                    // final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double)
588                    // bounds.height)
589                    // + mapArea.getMinY();
590                    // final double left = Math.min(x1, x2);
591                    // final double right = Math.max(x1, x2);
592                    // final double bottom = Math.min(y1, y2);
593                    // final double top = Math.max(y1, y2);
594                    //
595                    // String name = selectionLayer.getFeatureSource().getSchema()
596                    // .getDefaultGeometry().getName();
597                    //
598                    // if (name == "") {
599                    // name = "the_geom";
600                    // }
601                    // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
602                    // top,
603                    // getContext().getCoordinateReferenceSystem().toString());
604                    // if (selectionManager != null) {
605                    // selectionManager.selectionChanged(this, bb);
606                    // }
607                    //
608                    // graphics.setXORMode(Color.green);
609                    //
610                    // /*
611                    // * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }
612                    // */
613                    //
614                    // // draw new box
615                    // lastX = x;
616                    // lastY = y;
617                    // drawRectangle(graphics);
618                    // }
619    
620          }          }
621    
# Line 934  public class JMapPane extends JPanel imp Line 623  public class JMapPane extends JPanel imp
623          // private void processDrag(int x1, int y1, int x2, int y2) {          // private void processDrag(int x1, int y1, int x2, int y2) {
624          // sk.ce          // sk.ce
625          protected void processDrag(final int x1, final int y1, final int x2,          protected void processDrag(final int x1, final int y1, final int x2,
626                          final int y2, MouseEvent e) {                          final int y2, final MouseEvent e) {
627    
628    
629                  /****                  /****
630                   * If no layer is availabe we dont want a NullPointerException                   * If no layers exist, we ignore the drag.
631                   */                   */
632                  if (mapArea == null)                  if (context.getLayerCount() <= 0) {
633                          return;                          return;
634                    }
635                    
636                  // System.out.println("processing drag from " + x1 + "," + y1 + " -> "                  // System.out.println("processing drag from " + x1 + "," + y1 + " -> "
637                  // + x2 + "," + y2);                  // + x2 + "," + y2);
638                  if ((x1 == x2) && (y1 == y2)) {                  if ((x1 == x2) && (y1 == y2)) {
# Line 953  public class JMapPane extends JPanel imp Line 644  public class JMapPane extends JPanel imp
644                          return;                          return;
645                  }                  }
646    
647                  Rectangle bounds = this.getBounds();                  final Rectangle bounds = this.getBounds();
648    
649                  double mapWidth = mapArea.getWidth();                  final double mapWidth = mapArea.getWidth();
650                  double mapHeight = mapArea.getHeight();                  final double mapHeight = mapArea.getHeight();
651    
652                  double startX = ((x1 * mapWidth) / (double) bounds.width)                  final double startX = ((x1 * mapWidth) / (double) bounds.width)
653                                  + mapArea.getMinX();                                  + mapArea.getMinX();
654                  double startY = (((bounds.getHeight() - y1) * mapHeight) / (double) bounds.height)                  final double startY = (((bounds.getHeight() - y1) * mapHeight) / (double) bounds.height)
655                                  + mapArea.getMinY();                                  + mapArea.getMinY();
656                  double endX = ((x2 * mapWidth) / (double) bounds.width)                  final double endX = ((x2 * mapWidth) / (double) bounds.width)
657                                  + mapArea.getMinX();                                  + mapArea.getMinX();
658                  double endY = (((bounds.getHeight() - y2) * mapHeight) / (double) bounds.height)                  final double endY = (((bounds.getHeight() - y2) * mapHeight) / (double) bounds.height)
659                                  + mapArea.getMinY();                                  + mapArea.getMinY();
660    
661                  if ((state == JMapPane.Pan) || (e.getButton() == MouseEvent.BUTTON3)) {                  if ((state == JMapPane.Pan) || (e.getButton() == MouseEvent.BUTTON3)) {
662                          // move the image with the mouse                          // move the image with the mouse
663                          // calculate X offsets from start point to the end Point                          // calculate X offsets from start point to the end Point
664                          double deltaX1 = endX - startX;                          final double deltaX1 = endX - startX;
665    
666                          // System.out.println("deltaX " + deltaX1);                          // System.out.println("deltaX " + deltaX1);
667                          // new edges                          // new edges
668                          double left = mapArea.getMinX() - deltaX1;                          final double left = mapArea.getMinX() - deltaX1;
669                          double right = mapArea.getMaxX() - deltaX1;                          final double right = mapArea.getMaxX() - deltaX1;
670    
671                          // now for Y                          // now for Y
672                          double deltaY1 = endY - startY;                          final double deltaY1 = endY - startY;
673    
674                          // System.out.println("deltaY " + deltaY1);                          // System.out.println("deltaY " + deltaY1);
675                          double bottom = mapArea.getMinY() - deltaY1;                          final double bottom = mapArea.getMinY() - deltaY1;
676                          double top = mapArea.getMaxY() - deltaY1;                          final double top = mapArea.getMaxY() - deltaY1;
677                          Coordinate ll = new Coordinate(left, bottom);                          final Coordinate ll = new Coordinate(left, bottom);
678                          Coordinate ur = new Coordinate(right, top);                          final Coordinate ur = new Coordinate(right, top);
679                          // xulu.sc                          // xulu.sc
680                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
681                          setMapArea(fixAspectRatio(this.getBounds(), new Envelope(ll, ur)));                          
682    
683                            setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
684                          // xulu.ec                          // xulu.ec
685                  } else if (state == JMapPane.ZoomIn) {                  } else if (state == JMapPane.ZoomIn) {
686    
# Line 999  public class JMapPane extends JPanel imp Line 692  public class JMapPane extends JPanel imp
692    
693                          drawRectangle(this.getGraphics());                          drawRectangle(this.getGraphics());
694                          // make the dragged rectangle (in map coords) the new BBOX                          // make the dragged rectangle (in map coords) the new BBOX
695                          double left = Math.min(startX, endX);                          final double left = Math.min(startX, endX);
696                          double right = Math.max(startX, endX);                          final double right = Math.max(startX, endX);
697                          double bottom = Math.min(startY, endY);                          final double bottom = Math.min(startY, endY);
698                          double top = Math.max(startY, endY);                          final double top = Math.max(startY, endY);
699                          Coordinate ll = new Coordinate(left, bottom);                          final Coordinate ll = new Coordinate(left, bottom);
700                          Coordinate ur = new Coordinate(right, top);                          final Coordinate ur = new Coordinate(right, top);
701                          // xulu.sc                          // xulu.sc
702    
703                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
704                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
705    
706                          // sk.sc                          // sk.sc
707  //                      {                          // {
708  //                      // SK tries to paint a preview of the zoom ;-9 aha.... well                          // // SK tries to paint a preview of the zoom ;-9 aha.... well
709  //                      Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();                          // Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();
710  //                      graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,                          // graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
711  //                                      RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);                          // RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
712  //                      graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,                          // graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
713  //                                      RenderingHints.VALUE_ANTIALIAS_OFF);                          // RenderingHints.VALUE_ANTIALIAS_OFF);
714  //                      graphics.setRenderingHint(RenderingHints.KEY_RENDERING,                          // graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
715  //                                      RenderingHints.VALUE_RENDER_SPEED);                          // RenderingHints.VALUE_RENDER_SPEED);
716  //                      graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),                          // graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),
717  //                                      JMapPane.this.getHeight(), x1, y1, x2, y2, null);                          // JMapPane.this.getHeight(), x1, y1, x2, y2, null);
718  //                      }                          // }
719                          // xulu.ec                          // xulu.ec
720                  } else if (state == JMapPane.ZoomOut) {                  } else if (state == JMapPane.ZoomOut) {
721                          drawRectangle(this.getGraphics());                          drawRectangle(this.getGraphics());
722    
723                          // make the dragged rectangle in screen coords the new map size?                          // make the dragged rectangle in screen coords the new map size?
724                          double left = Math.min(startX, endX);                          final double left = Math.min(startX, endX);
725                          double right = Math.max(startX, endX);                          final double right = Math.max(startX, endX);
726                          double bottom = Math.min(startY, endY);                          final double bottom = Math.min(startY, endY);
727                          double top = Math.max(startY, endY);                          final double top = Math.max(startY, endY);
728                          double nWidth = (mapWidth * mapWidth) / (right - left);                          final double nWidth = (mapWidth * mapWidth) / (right - left);
729                          double nHeight = (mapHeight * mapHeight) / (top - bottom);                          final double nHeight = (mapHeight * mapHeight) / (top - bottom);
730                          double deltaX1 = left - mapArea.getMinX();                          final double deltaX1 = left - mapArea.getMinX();
731                          double nDeltaX1 = (deltaX1 * nWidth) / mapWidth;                          final double nDeltaX1 = (deltaX1 * nWidth) / mapWidth;
732                          double deltaY1 = bottom - mapArea.getMinY();                          final double deltaY1 = bottom - mapArea.getMinY();
733                          double nDeltaY1 = (deltaY1 * nHeight) / mapHeight;                          final double nDeltaY1 = (deltaY1 * nHeight) / mapHeight;
734                          Coordinate ll = new Coordinate(mapArea.getMinX() - nDeltaX1,                          final Coordinate ll = new Coordinate(mapArea.getMinX() - nDeltaX1,
735                                          mapArea.getMinY() - nDeltaY1);                                          mapArea.getMinY() - nDeltaY1);
736                          double deltaX2 = mapArea.getMaxX() - right;                          final double deltaX2 = mapArea.getMaxX() - right;
737                          double nDeltaX2 = (deltaX2 * nWidth) / mapWidth;                          final double nDeltaX2 = (deltaX2 * nWidth) / mapWidth;
738                          double deltaY2 = mapArea.getMaxY() - top;                          final double deltaY2 = mapArea.getMaxY() - top;
739                          double nDeltaY2 = (deltaY2 * nHeight) / mapHeight;                          final double nDeltaY2 = (deltaY2 * nHeight) / mapHeight;
740                          Coordinate ur = new Coordinate(mapArea.getMaxX() + nDeltaX2,                          final Coordinate ur = new Coordinate(mapArea.getMaxX() + nDeltaX2,
741                                          mapArea.getMaxY() + nDeltaY2);                                          mapArea.getMaxY() + nDeltaY2);
742                          // xulu.sc                          // xulu.sc
743                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));                          // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
744                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));                          setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
745    
746                          // xulu.ec                          // xulu.ec
                 } else if (state == JMapPane.Select && selectionLayer != null) {  
                         double left = Math.min(startX, endX);  
                         double right = Math.max(startX, endX);  
                         double bottom = Math.min(startY, endY);  
                         double top = Math.max(startY, endY);  
   
                         String name = selectionLayer.getFeatureSource().getSchema()  
                                         .getDefaultGeometry().getLocalName();  
   
                         if (name == "") {  
                                 name = "the_geom";  
                         }  
                         Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,  
                                         getContext().getCoordinateReferenceSystem().toString());  
                         // System.out.println(bb.toString());  
                         if (selectionManager != null) {  
                                 selectionManager.selectionChanged(this, bb);  
                         }  
                         /*  
                          * FeatureCollection fc; selection = null; try { fc =  
                          * selectionLayer.getFeatureSource().getFeatures(bb); selection =  
                          * fc; } catch (IOException e) { e.printStackTrace(); }  
                          */  
747                  }                  }
748                    // else if (state == JMapPane.Select && selectionLayer != null) {
749                    // final double left = Math.min(startX, endX);
750                    // final double right = Math.max(startX, endX);
751                    // final double bottom = Math.min(startY, endY);
752                    // final double top = Math.max(startY, endY);
753                    //
754                    // String name = selectionLayer.getFeatureSource().getSchema()
755                    // .getDefaultGeometry().getLocalName();
756                    //
757                    // if (name == "") {
758                    // name = "the_geom";
759                    // }
760                    // final Filter bb = ff.bbox(ff.property(name), left, bottom, right,
761                    // top,
762                    // getContext().getCoordinateReferenceSystem().toString());
763                    // // System.out.println(bb.toString());
764                    // if (selectionManager != null) {
765                    // selectionManager.selectionChanged(this, bb);
766                    // }
767                    // /*
768                    // * FeatureCollection fc; selection = null; try { fc =
769                    // * selectionLayer.getFeatureSource().getFeatures(bb); selection =
770                    // * fc; } catch (IOException e) { e.printStackTrace(); }
771                    // */
772                    // }
773    
774                  // xulu.so                  // xulu.so
775                  // setMapArea(mapArea);                  // setMapArea(mapArea);
# Line 1086  public class JMapPane extends JPanel imp Line 781  public class JMapPane extends JPanel imp
781                  return clickable;                  return clickable;
782          }          }
783    
784          private org.geotools.styling.Style setupStyle(int type, Color color) {          //
785                  StyleFactory sf = org.geotools.factory.CommonFactoryFinder          // private org.geotools.styling.Style setupStyle(final int type, final Color
786                                  .getStyleFactory(null);          // color) {
787                  StyleBuilder sb = new StyleBuilder();          // final StyleFactory sf = org.geotools.factory.CommonFactoryFinder
788            // .getStyleFactory(null);
789                  org.geotools.styling.Style s = sf.createStyle();          // final StyleBuilder sb = new StyleBuilder();
790                  s.setTitle("selection");          //
791            // org.geotools.styling.Style s = sf.createStyle();
792                  // TODO parameterise the color          // s.setTitle("selection");
793                  PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);          //
794                  ps.setStroke(sb.createStroke(color));          // // TODO parameterise the color
795            // final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);
796                  LineSymbolizer ls = sb.createLineSymbolizer(color);          // ps.setStroke(sb.createStroke(color));
797                  Graphic h = sb.createGraphic();          //
798                  h.setMarks(new Mark[] { sb.createMark("square", color) });          // final LineSymbolizer ls = sb.createLineSymbolizer(color);
799            // final Graphic h = sb.createGraphic();
800                  PointSymbolizer pts = sb.createPointSymbolizer(h);          // h.setMarks(new Mark[] { sb.createMark("square", color) });
801            //
802                  // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});          // final PointSymbolizer pts = sb.createPointSymbolizer(h);
803                  switch (type) {          //
804                  case POLYGON:          // // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});
805                          s = sb.createStyle(ps);          // switch (type) {
806            // case POLYGON:
807                          break;          // s = sb.createStyle(ps);
808            //
809                  case POINT:          // break;
810                          s = sb.createStyle(pts);          //
811            // case POINT:
812                          break;          // s = sb.createStyle(pts);
813            //
814                  case LINE:          // break;
815                          s = sb.createStyle(ls);          //
816                  }          // case LINE:
817            // s = sb.createStyle(ls);
818                  return s;          // }
819          }          //
820            // return s;
821          public void highlightChanged(HighlightChangedEvent e) {          // }
                 org.opengis.filter.Filter f = e.getFilter();  
   
                 try {  
                         highlightFeature = highlightLayer.getFeatureSource().getFeatures(f);  
                 } catch (IOException e1) {  
                         // TODO Auto-generated catch block  
                         e1.printStackTrace();  
                 }  
   
                 repaint();  
         }  
822    
823          public void propertyChange(PropertyChangeEvent evt) {          public void propertyChange(final PropertyChangeEvent evt) {
824                  String prop = evt.getPropertyName();                  final String prop = evt.getPropertyName();
825    
826                  if (prop.equalsIgnoreCase("crs")) {                  if (prop.equalsIgnoreCase("crs")) {
827                          context.setAreaOfInterest(context.getAreaOfInterest(),                          context.setAreaOfInterest(context.getAreaOfInterest(),
# Line 1149  public class JMapPane extends JPanel imp Line 833  public class JMapPane extends JPanel imp
833                  return reset;                  return reset;
834          }          }
835    
836          public void setReset(boolean reset) {          public void setReset(final boolean reset) {
837                  this.reset = reset;                  this.reset = reset;
838          }          }
839    
840          public void layerAdded(MapLayerListEvent event) {          public void layerAdded(final MapLayerListEvent event) {
841                  changed = true;                  changed = true;
842    
843                  if (context.getLayers().length == 1) { // the first one                  if (context.getLayers().length == 1) { // the first one
# Line 1165  public class JMapPane extends JPanel imp Line 849  public class JMapPane extends JPanel imp
849                                  if (mapArea == null)                                  if (mapArea == null)
850                                          mapArea = context.getLayerBounds();                                          mapArea = context.getLayerBounds();
851                                  // xulu.ec                                  // xulu.ec
852                          } catch (IOException e) {                          } catch (final IOException e) {
853                                  // TODO Auto-generated catch block                                  // TODO Auto-generated catch block
854                                  e.printStackTrace();                                  e.printStackTrace();
855                          }                          }
# Line 1176  public class JMapPane extends JPanel imp Line 860  public class JMapPane extends JPanel imp
860                  repaint();                  repaint();
861          }          }
862    
863          public void layerRemoved(MapLayerListEvent event) {          public void layerRemoved(final MapLayerListEvent event) {
864                  changed = true;                  changed = true;
865                  repaint();                  repaint();
866          }          }
867    
868          public void layerChanged(MapLayerListEvent event) {          public void layerChanged(final MapLayerListEvent event) {
869                  changed = true;                  changed = true;
870                  // System.out.println("layer changed - repaint");                  // System.out.println("layer changed - repaint");
871                  repaint();                  repaint();
872          }          }
873    
874          public void layerMoved(MapLayerListEvent event) {          public void layerMoved(final MapLayerListEvent event) {
875                  changed = true;                  changed = true;
876                  repaint();                  repaint();
877          }          }
878    
879          protected void drawRectangle(Graphics graphics) {          protected void drawRectangle(final Graphics graphics) {
880                  // undraw last box/draw new box                  // undraw last box/draw new box
881                  int left = Math.min(startX, lastX);                  final int left = Math.min(startX, lastX);
882                  int right = Math.max(startX, lastX);                  final int right = Math.max(startX, lastX);
883                  int top = Math.max(startY, lastY);                  final int top = Math.max(startY, lastY);
884                  int bottom = Math.min(startY, lastY);                  final int bottom = Math.min(startY, lastY);
885                  int width = right - left;                  final int width = right - left;
886                  int height = top - bottom;                  final int height = top - bottom;
887                  // System.out.println("drawing rect("+left+","+bottom+","+ width+","+                  // System.out.println("drawing rect("+left+","+bottom+","+ width+","+
888                  // height+")");                  // height+")");
889                  graphics.drawRect(left, bottom, width, height);                  graphics.drawRect(left, bottom, width, height);
# Line 1211  public class JMapPane extends JPanel imp Line 895  public class JMapPane extends JPanel imp
895           *           *
896           * @param clickable           * @param clickable
897           */           */
898          public void setClickable(boolean clickable) {          public void setClickable(final boolean clickable) {
899                  this.clickable = clickable;                  this.clickable = clickable;
900          }          }
901    
902          public void mouseMoved(MouseEvent e) {          public void mouseMoved(final MouseEvent e) {
         }  
   
         public FeatureCollection getSelection() {  
                 return selection;  
         }  
   
         public void setSelection(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(SelectionChangedEvent e) {  
   
                 try {  
                         selection = selectionLayer.getFeatureSource().getFeatures(  
                                         e.getFilter());  
                         repaint();  
                 } catch (IOException e1) {  
                         e1.printStackTrace();  
                 }  
         }  
   
         public SelectionManager getSelectionManager() {  
                 return selectionManager;  
         }  
   
         public void setSelectionManager(SelectionManager selectionManager) {  
                 this.selectionManager = selectionManager;  
                 this.selectionManager.addSelectionChangeListener(this);  
   
903          }          }
904    
905          // xulu.sn          // xulu.sn
# Line 1273  public class JMapPane extends JPanel imp Line 920  public class JMapPane extends JPanel imp
920                  if (env == null)                  if (env == null)
921                          return env;                          return env;
922    
923                    Envelope newArea = null;
924    
925                  /**                  /**
926                   * Correct the aspect Ratio before we check the rest. Otherwise we might                   * Correct the aspect Ratio before we check the rest. Otherwise we might
927                   * easily fail.                   * easily fail.
928                   */                   */
929                  env = fixAspectRatio(this.getBounds(), env);                  env = fixAspectRatio(this.getBounds(), env, false);
930    
931                  double scale = env.getWidth() / getWidth();                  final double scale = env.getWidth() / getWidth();
932                  double centerX = env.getMinX() + env.getWidth() / 2.;                  final double centerX = env.getMinX() + env.getWidth() / 2.;
933                  double centerY = env.getMinY() + env.getHeight() / 2.;                  final double centerY = env.getMinY() + env.getHeight() / 2.;
934                  double newWidth2;                  double newWidth2 = 0;
935                  double newHeight2;                  double newHeight2 = 0;
936                  if (scale < getMaxZoomScale()) {                  if (scale < getMaxZoomScale()) {
937                          // ****************************************************************************                          // ****************************************************************************
938                          // Wir zoomen weiter rein als erlaubt => Anpassen des envelope                          // Wir zoomen weiter rein als erlaubt => Anpassen des envelope
# Line 1300  public class JMapPane extends JPanel imp Line 949  public class JMapPane extends JPanel imp
949                          // ****************************************************************************                          // ****************************************************************************
950                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen                          // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
951                          // ****************************************************************************                          // ****************************************************************************
952                          return env;                          newArea = env;
953                  }                  }
954    
955                  Coordinate ll = new Coordinate(centerX - newWidth2, centerY                  if (newArea == null) {
                                 - newHeight2);  
                 Coordinate ur = new Coordinate(centerX + newWidth2, centerY  
                                 + newHeight2);  
956    
957                  return new Envelope(ll, ur);                          final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
958                                            - newHeight2);
959                            final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
960                                            + newHeight2);
961    
962                            newArea = new Envelope(ll, ur);
963                    }
964    
965                    Envelope maxAllowedExtend = getMaxExtend();
966                    while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea)) {
967                            /*
968                             * If a maxExtend is set, we have to honour that...
969                             */
970    
971                            // Exceeds top? Move down and maybe cut
972                            if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
973                                    double divY = newArea.getMaxY() - maxAllowedExtend.getMaxY();
974                                    LOGGER.debug("Moving area down by " + divY);
975    
976                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
977                                                    newArea.getMinY() - divY), new Coordinate(newArea
978                                                    .getMaxX(), newArea.getMaxY() - divY));
979    
980                                    if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
981                                            LOGGER.debug("Now it exeeds the bottom border.. cut!");
982                                            // And cut the bottom if it moved out of the area
983                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
984                                                            maxAllowedExtend.getMinY()), new Coordinate(newArea
985                                                            .getMaxX(), newArea.getMaxY()));
986    
987                                            LOGGER.debug("and fix aspect ratio");
988    
989                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
990                                    }
991                            }
992    
993                            // Exceeds bottom? Move up and maybe cut
994                            if (newArea.getMinY() < maxAllowedExtend.getMinY()) {
995                                    double divY = newArea.getMinY() - maxAllowedExtend.getMinY();
996                                    LOGGER.debug("Moving area up by " + divY);
997    
998                                    newArea = new Envelope(new Coordinate(newArea.getMinX(),
999                                                    newArea.getMinY() - divY), new Coordinate(newArea
1000                                                    .getMaxX(), newArea.getMaxY() - divY));
1001    
1002                                    if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) {
1003                                            LOGGER.debug("Now it exeeds the top border.. cut!");
1004                                            // And cut the bottom if it moved out of the area
1005                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
1006                                                            newArea.getMinY()), new Coordinate(newArea
1007                                                            .getMaxX(), maxAllowedExtend.getMaxY()));
1008    
1009                                            LOGGER.debug("and fix aspect ratio");
1010    
1011                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
1012                                    }
1013                            }
1014    
1015                            // Exceeds to the right? move and maybe cut
1016                            if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
1017    
1018                                    // Move left..
1019                                    double divX = newArea.getMaxX() - maxAllowedExtend.getMaxX();
1020                                    LOGGER.debug("Moving area left by " + divX);
1021    
1022                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
1023                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
1024                                                    - divX, newArea.getMaxY()));
1025    
1026                                    if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
1027                                            LOGGER.debug("Now it exeeds the left border.. cut!");
1028                                            // And cut the left if it moved out of the area
1029                                            newArea = new Envelope(new Coordinate(maxAllowedExtend.getMinX(),
1030                                                            newArea.getMinY()), new Coordinate(newArea
1031                                                            .getMaxX(), newArea.getMaxY()));
1032    
1033                                            LOGGER.debug("and fix aspect ratio");
1034    
1035                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
1036                                    }
1037                            }
1038    
1039                            // Exceeds to the left? move and maybe cut
1040                            if (newArea.getMinX() < maxAllowedExtend.getMinX()) {
1041    
1042                                    // Move right..
1043                                    double divX = newArea.getMinX() - maxAllowedExtend.getMinX();
1044                                    LOGGER.debug("Moving area right by " + divX);
1045    
1046                                    newArea = new Envelope(new Coordinate(newArea.getMinX() - divX,
1047                                                    newArea.getMinY()), new Coordinate(newArea.getMaxX()
1048                                                    - divX, newArea.getMaxY()));
1049    
1050                                    if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) {
1051                                            LOGGER.debug("Now it exeeds the right border.. cut!");
1052                                            // And cut the left if it moved out of the area
1053                                            newArea = new Envelope(new Coordinate(newArea.getMinX(),
1054                                                            newArea.getMinY()), new Coordinate(maxAllowedExtend
1055                                                            .getMaxX(), newArea.getMaxY()));
1056    
1057                                            LOGGER.debug("and fix aspect ratio");
1058    
1059                                            newArea = fixAspectRatio(this.getBounds(), newArea, false);
1060                                    }
1061                            }
1062    
1063                    }
1064    
1065                    return newArea;
1066          }          }
1067    
1068          /**          /**
# Line 1340  public class JMapPane extends JPanel imp Line 1094  public class JMapPane extends JPanel imp
1094           * @author <a href="mailto:[email protected]">Stefan Alfons           * @author <a href="mailto:[email protected]">Stefan Alfons
1095           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
1096           */           */
1097          public void setMaxZoomScale(Double maxZoomScale) {          public void setMaxZoomScale(final Double maxZoomScale) {
                 // System.out.println("setting max scale to "+maxZoomScale);  
1098                  this.maxZoomScale = maxZoomScale;                  this.maxZoomScale = maxZoomScale;
1099          }          }
1100    
# Line 1352  public class JMapPane extends JPanel imp Line 1105  public class JMapPane extends JPanel imp
1105           * @author <a href="mailto:[email protected]">Stefan Alfons           * @author <a href="mailto:[email protected]">Stefan Alfons
1106           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
1107           */           */
1108          public void setMinZoomScale(Double minZoomScale) {          public void setMinZoomScale(final Double minZoomScale) {
1109                  this.minZoomScale = minZoomScale;                  this.minZoomScale = minZoomScale;
1110          }          }
1111          // xulu.en  
1112            /**
1113             * Defines an evelope of the viwable area. The JMapPane will never show
1114             * anything outside of this extend.
1115             *
1116             * @param maxExtend
1117             *            <code>null</code> to not have this restriction.
1118             */
1119            public void setMaxExtend(Envelope maxExtend) {
1120                    this.maxExtend = maxExtend;
1121            }
1122    
1123            /**
1124             * Returns the evelope of the viewable area. The JMapPane will never show
1125             * anything outside of this extend. If this has been set to
1126             * <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return
1127             * quickly the context's bounds. It it takes to long to determine the
1128             * context bounds, <code>null</code> is returned.
1129             *
1130             * @param maxExtend
1131             *            <code>null</code> to not have this restriction.
1132             */
1133    
1134            public Envelope getMaxExtend() {
1135                    if (maxExtend == null) {
1136                            try {
1137                                    return fixAspectRatio(this.getBounds(), context.getLayerBounds(), true);
1138                            } catch (IOException e) {
1139                                    LOGGER
1140                                                    .warn(
1141                                                                    "maxExtend == null; faild to getLayerBounds of context",
1142                                                                    e);
1143                            }
1144                    }
1145                    return maxExtend;
1146            }
1147    
1148  }  }
Legend:
Removed from v.148  
changed lines
  Added in v.431
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26