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

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

Parent Directory | Revision Log | View Patch Patch

-trunk/src/org/geotools/gui/swing/JMapPane.java
revision 2 by mojays,
Tue Feb 24 22:43:52 2009 UTC
+branches/1.0-gt2-2.6/src/org/geotools/gui/swing/JMapPane.java
revision 318 by alfonx,
Wed Aug 26 13:33:32 2009 UTC
 Line 17 
 package org.geotools.gui.swing;
  /**
   * <b>Xulu:<br>
-  *    Code taken from gt-2.4.2 to make some changes (marked with {@code xulu}),
+  *    Code taken from gt-2.4.5 to make some changes (marked with {@code xulu}),
   *    which can not be realized in a subclass:</b>
   *    <ul>
   *       <li>{@link #getMapArea()} declared as {@code final}<li>
 Line 60 
 import javax.swing.JPanel;
  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;
  import org.geotools.map.MapContext;
  import org.geotools.map.MapLayer;
-Line 74 
 import org.geotools.renderer.GTRenderer;
+Line 70 
 import org.geotools.renderer.GTRenderer;
  import org.geotools.renderer.lite.LabelCache;
  import org.geotools.renderer.lite.LabelCacheDefault;
  import org.geotools.renderer.lite.StreamingRenderer;
+ import org.geotools.renderer.shape.TransitionShapefileRenderer;
  import org.geotools.styling.Graphic;
  import org.geotools.styling.LineSymbolizer;
  import org.geotools.styling.Mark;
-Line 94 
 import com.vividsolutions.jts.geom.Geome
+Line 91 
 import com.vividsolutions.jts.geom.Geome
  import com.vividsolutions.jts.geom.GeometryFactory;
  public class JMapPane extends JPanel implements MouseListener,
-         MouseMotionListener, HighlightChangeListener,SelectionChangeListener, PropertyChangeListener,
+                 MouseMotionListener, HighlightChangeListener, SelectionChangeListener,
-         MapLayerListListener {
+                 PropertyChangeListener, MapLayerListListener {
-     private static Logger LOGGER = Logger.getLogger( JMapPane.class.getName() );
+         private static Logger LOGGER = Logger.getLogger(JMapPane.class.getName());
-    /**
-      *
-      */
-     private static final long serialVersionUID = -8647971481359690499L;
-     public static final int Reset = 0;
+         private static final long serialVersionUID = -8647971481359690499L;
-     public static final int ZoomIn = 1;
+         public static final int Reset = 0;
-     public static final int ZoomOut = 2;
+         public static final int ZoomIn = 1;
-     public static final int Pan = 3;
+         public static final int ZoomOut = 2;
-     public static final int Select = 4;
+         public static final int Pan = 3;
-     private static final int POLYGON = 0;
+         public static final int Select = 4;
-     private static final int LINE = 1;
+         private static final int POLYGON = 0;
-     private static final int POINT = 2;
+         private static final int LINE = 1;
-     /**
+         private static final int POINT = 2;
-      * what renders the map
-      */
-     GTRenderer renderer;
-     private GTRenderer highlightRenderer, selectionRenderer;
+         /**
+          * what renders the map
+          */
+         GTRenderer renderer;
-     /**
+         private GTRenderer highlightRenderer, selectionRenderer;
-      * the map context to render
-      */
-     MapContext context;
-     private MapContext selectionContext;
+         /**
+          * the map context to render
+          */
+         MapContext context;
-     /**
+         private MapContext selectionContext;
-      * the area of the map to draw
-      */
- //xulu.sc
- //    Envelope mapArea;
-     protected Envelope mapArea;
- //xulu.ec
-     /**
+         /**
-      * the size of the pane last time we drew
+          * the area of the map to draw
-      */
+          */
- //xulu.sc
+         // xulu.sc
- //    private Rectangle oldRect = null;
+         // Envelope mapArea;
-     protected Rectangle oldRect = null;
+         protected Envelope mapArea;
- //xulu.ec
+         // xulu.ec
-     /**
+         /**
-      * the last map area drawn.
+          * the size of the pane last time we drew
-      */
+          */
- //xulu.sc
+         // xulu.sc
- //    private Envelope oldMapArea = null;
+         // private Rectangle oldRect = null;
-     protected Envelope oldMapArea = null;
+         protected Rectangle oldRect = null;
- //xulu.ec
+         // xulu.ec
-     /**
+         /**
-      * the base image of the map
+          * the last map area drawn.
-      */
+          */
-     protected  BufferedImage baseImage, panningImage;
+         // xulu.sc
-     // SK: private BufferedImage baseImage, panningImage;
+         // private Envelope oldMapArea = null;
+         protected Envelope oldMapArea = null;
+         // xulu.ec
-     /**
+         /**
-      * image of selection
+          * the base image of the map
-      */
+          */
-     private BufferedImage selectImage;
+         protected BufferedImage baseImage, panningImage;
+         // SK: private BufferedImage baseImage, panningImage;
-     /**
+         /**
-      * style for selected items
+          * image of selection
-      */
+          */
-     private Style selectionStyle;
+         private BufferedImage selectImage;
-     /**
+         /**
-      * layer that selection works on
+          * style for selected items
-      */
+          */
-     private MapLayer selectionLayer;
+         private Style selectionStyle;
-     /**
+         /**
-      * layer that highlight works on
+          * layer that selection works on
-      */
+          */
-     private MapLayer highlightLayer;
+         private MapLayer selectionLayer;
-     /**
+         /**
-      * the object which manages highlighting
+          * layer that highlight works on
-      */
+          */
-     private HighlightManager highlightManager;
+         private MapLayer highlightLayer;
-     /**
+         /**
-      * is highlighting on or off
+          * the object which manages highlighting
-      */
+          */
-     private boolean highlight = true;
+         private HighlightManager highlightManager;
-     /**
+         /**
-      * a factory for filters
+          * is highlighting on or off
-      */
+          */
-     FilterFactory2 ff;
+         private boolean highlight = true;
-     /**
+         /**
-      * a factory for geometries
+          * a factory for filters
-      */
+          */
-     GeometryFactory gf = new GeometryFactory(); // FactoryFinder.getGeometryFactory(null);
+         FilterFactory2 ff;
-     /**
+         /**
-      * the collections of features to be selected or highlighted
+          * a factory for geometries
-      */
+          */
-     FeatureCollection selection;
+         GeometryFactory gf = new GeometryFactory(); // FactoryFinder.getGeometryFactory(null);
-     /**
+         /**
-      * the collections of features to be selected or highlighted
+          * the collections of features to be selected or highlighted
-      */
+          */
-     FeatureCollection highlightFeature;
+         FeatureCollection selection;
-     private int state = ZoomIn;
+         /**
+          * the collections of features to be selected or highlighted
+          */
+         FeatureCollection highlightFeature;
-     /**
+         private int state = ZoomIn;
-      * how far to zoom in or out
-      */
-     private double zoomFactor = 2.0;
-     Style lineHighlightStyle;
+         /**
+          * how far to zoom in or out
+          */
+         private double zoomFactor = 2.0;
-     Style pointHighlightStyle;
+         Style lineHighlightStyle;
-     Style polygonHighlightStyle;
+         Style pointHighlightStyle;
-     Style polygonSelectionStyle;
+         Style polygonHighlightStyle;
-     Style pointSelectionStyle;
+         Style polygonSelectionStyle;
-     Style lineSelectionStyle;
+         Style pointSelectionStyle;
-     boolean changed = true;
+         Style lineSelectionStyle;
-     LabelCache labelCache = new LabelCacheDefault();
+         boolean changed = true;
- //xulu.sc
+         LabelCache labelCache = new LabelCacheDefault();
- //    private boolean reset = false;
-     protected boolean reset = false;
- //xulu.ec
-     int startX;
+         // xulu.sc
+         // private boolean reset = false;
+         protected boolean reset = false;
+         // xulu.ec
-     int startY;
+         int startX;
-     private boolean clickable;
+         int startY;
-     int lastX;
+         private boolean clickable;
-     int lastY;
+         int lastX;
-     private SelectionManager selectionManager;
+         int lastY;
- //xulu.sn
-     private Double maxZoomScale = Double.MIN_VALUE;
-     private Double minZoomScale = Double.MAX_VALUE;
- //xulu.en
- // sk.sn
+         private SelectionManager selectionManager;
-     /**
+         // xulu.sn
-      * Wenn true, dann wurde PANNING via mouseDraged-Events begonnen. Dieses Flag wird benutzt um nur einmal den passenden Cursor nur einmal zu setzen.
+         private Double maxZoomScale = Double.MIN_VALUE;
-      */
+         private Double minZoomScale = Double.MAX_VALUE;
+         // xulu.en
+         // sk.sn
+         /**
+          * Wenn true, dann wurde PANNING via mouseDraged-Events begonnen. Dieses
+          * Flag wird benutzt um nur einmal den passenden Cursor nur einmal zu
+          * setzen.
+          */
          private boolean panning_started = false;
- // sk.en
-     public JMapPane() {
+         // sk.en
-         this(null, true, null, null);
-     }
+         public JMapPane() {
+                 this(null, true, null, null);
-     /**
+         }
-      * create a basic JMapPane
-      *
+         /**
-      * @param render -
+          * create a basic JMapPane
-      *            how to draw the map
+          *
-      * @param context -
+          * @param render
-      *            the map context to display
+          *            - how to draw the map
-      */
+          * @param context
-     public JMapPane(GTRenderer render, MapContext context) {
+          *            - the map context to display
-         this(null, true, render, context);
+          */
-     }
+         public JMapPane(final GTRenderer render, final MapContext context) {
+                 this(null, true, render, context);
-     /**
+         }
-      * full constructor extending JPanel
-      *
+         /**
-      * @param layout -
+          * full constructor extending JPanel
-      *            layout (probably shouldn't be set)
+          *
-      * @param isDoubleBuffered -
+          * @param layout
-      *            a Swing thing I don't really understand
+          *            - layout (probably shouldn't be set)
-      * @param render -
+          * @param isDoubleBuffered
-      *            what to draw the map with
+          *            - a Swing thing I don't really understand
-      * @param context -
+          * @param render
-      *            what to draw
+          *            - what to draw the map with
-      */
+          * @param context
-     public JMapPane(LayoutManager layout, boolean isDoubleBuffered,
+          *            - what to draw
-             GTRenderer render, MapContext context) {
+          */
-         super(layout, isDoubleBuffered);
+         public JMapPane(final LayoutManager layout, final boolean isDoubleBuffered,
+                         final GTRenderer render, final MapContext context) {
-         ff = (FilterFactory2) org.geotools.factory.CommonFactoryFinder
+                 super(layout, isDoubleBuffered);
-                 .getFilterFactory(null);
-         setRenderer(render);
+                 ff = (FilterFactory2) org.geotools.factory.CommonFactoryFinder
+                                 .getFilterFactory(null);
-         setContext(context);
+                 setRenderer(render);
-         this.addMouseListener(this);
+                 setContext(context);
-         this.addMouseMotionListener(this);
-         setHighlightManager(new HighlightManager(highlightLayer));
+                 this.addMouseListener(this);
-         setSelectionManager(new SelectionManager(selectionLayer));
+                 this.addMouseMotionListener(this);
-         lineHighlightStyle = setupStyle(LINE, Color.red);
+                 setHighlightManager(new HighlightManager(highlightLayer));
+                 setSelectionManager(new SelectionManager(selectionLayer));
-         pointHighlightStyle = setupStyle(POINT, Color.red);
+                 lineHighlightStyle = setupStyle(LINE, Color.red);
-         polygonHighlightStyle = setupStyle(POLYGON, Color.red);
+                 pointHighlightStyle = setupStyle(POINT, Color.red);
-         polygonSelectionStyle = setupStyle(POLYGON, Color.cyan);
+                 polygonHighlightStyle = setupStyle(POLYGON, Color.red);
-         pointSelectionStyle = setupStyle(POINT, Color.cyan);
+                 polygonSelectionStyle = setupStyle(POLYGON, Color.cyan);
-         lineSelectionStyle = setupStyle(LINE, Color.cyan);
+                 pointSelectionStyle = setupStyle(POINT, Color.cyan);
-         setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
-     }
+                 lineSelectionStyle = setupStyle(LINE, Color.cyan);
+                 setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
-     /**
+         }
-      * get the renderer
-      */
+         /**
-     public GTRenderer getRenderer() {
+          * get the renderer
-         return renderer;
+          */
-     }
+         public GTRenderer getRenderer() {
+                 return renderer;
-     public void setRenderer(GTRenderer renderer) {
+         }
-         Map hints = new HashMap();
-         if (renderer instanceof StreamingRenderer) {
+         public void setRenderer(final GTRenderer renderer) {
-             hints = renderer.getRendererHints();
+                 Map hints = new HashMap();
-             if (hints == null) {
-                 hints = new HashMap();
+                 this.renderer = renderer;
-             }
-             if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {
+                 if (renderer instanceof StreamingRenderer || renderer instanceof TransitionShapefileRenderer) {
-                 labelCache = (LabelCache) hints
+                         hints = renderer.getRendererHints();
-                         .get(StreamingRenderer.LABEL_CACHE_KEY);
+                         if (hints == null) {
-             } else {
+                                 hints = new HashMap();
-                 hints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);
+                         }
-             }
+                         if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) {
-             renderer.setRendererHints(hints);
+                                 labelCache = (LabelCache) hints
-         }
+                                                 .get(StreamingRenderer.LABEL_CACHE_KEY);
+                         } else {
-         this.renderer = renderer;
+                                 hints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache);
-         this.highlightRenderer = new StreamingRenderer();
+                         }
-         this.selectionRenderer = new StreamingRenderer();
+                         hints.put("memoryPreloadingEnabled", Boolean.TRUE);
-         hints.put("memoryPreloadingEnabled", Boolean.FALSE);
-         highlightRenderer.setRendererHints(hints);
+                         renderer.setRendererHints(hints);
-         selectionRenderer.setRendererHints(hints);
+                 }
-         if (this.context != null) {
+ //              this.highlightRenderer = new StreamingRenderer();
-             this.renderer.setContext(this.context);
+ //              this.selectionRenderer = new StreamingRenderer();
-         }
-     }
+ //              highlightRenderer.setRendererHints(hints);
+ //              selectionRenderer.setRendererHints(hints);
-     public MapContext getContext() {
-         return context;
+ //              renderer.setRendererHints(hints);
-     }
+                 if (this.context != null) {
-     public void setContext(MapContext context) {
+                         this.renderer.setContext(this.context);
-         if (this.context != null) {
+                 }
-             this.context.removeMapLayerListListener(this);
+         }
-         }
+         public MapContext getContext() {
-         this.context = context;
+                 return context;
+         }
-         if (context != null) {
-             this.context.addMapLayerListListener(this);
+         public void setContext(final MapContext context) {
-         }
+                 if (this.context != null) {
+                         this.context.removeMapLayerListListener(this);
-         if (renderer != null) {
+                 }
-             renderer.setContext(this.context);
-         }
+                 this.context = context;
-     }
+                 if (context != null) {
-     public Envelope getMapArea() {
+                         this.context.addMapLayerListListener(this);
-         return mapArea;
+                 }
-     }
+                 if (renderer != null) {
-     public void setMapArea(Envelope mapArea) {
+                         renderer.setContext(this.context);
-         this.mapArea = mapArea;
+                 }
-     }
+         }
-     public int getState() {
+         public Envelope getMapArea() {
-         return state;
+                 return mapArea;
-     }
+         }
-     public void setState(int state) {
+         public void setMapArea(final Envelope mapArea) {
-         this.state = state;
+                 this.mapArea = mapArea;
+         }
-         // System.out.println("State: " + state);
-     }
+         public int getState() {
+                 return state;
-     public double getZoomFactor() {
+         }
-         return zoomFactor;
-     }
+         public void setState(final int state) {
+                 this.state = state;
-     public void setZoomFactor(double zoomFactor) {
-         this.zoomFactor = zoomFactor;
+                 // System.out.println("State: " + state);
-     }
+         }
-     public MapLayer getSelectionLayer() {
+         public double getZoomFactor() {
-         return selectionLayer;
+                 return zoomFactor;
-     }
+         }
-     public void setSelectionLayer(MapLayer selectionLayer) {
+         public void setZoomFactor(final double zoomFactor) {
-         this.selectionLayer = selectionLayer;
+                 this.zoomFactor = zoomFactor;
-         if(selectionManager!=null) {
+         }
-             selectionManager.setSelectionLayer(selectionLayer);
-         }
+         public MapLayer getSelectionLayer() {
-     }
+                 return selectionLayer;
+         }
-     public boolean isHighlight() {
-         return highlight;
+         public void setSelectionLayer(final MapLayer selectionLayer) {
-     }
+                 this.selectionLayer = selectionLayer;
+                 if (selectionManager != null) {
-     public void setHighlight(boolean highlight) {
+                         selectionManager.setSelectionLayer(selectionLayer);
-         this.highlight = highlight;
+                 }
-     }
+         }
-     public MapLayer getHighlightLayer() {
+         public boolean isHighlight() {
-         return highlightLayer;
+                 return highlight;
-     }
+         }
-     public void setHighlightLayer(MapLayer highlightLayer) {
+         public void setHighlight(final boolean highlight) {
-         this.highlightLayer = highlightLayer;
+                 this.highlight = highlight;
+         }
-         if (highlightManager != null) {
-             highlightManager.setHighlightLayer(highlightLayer);
+         public MapLayer getHighlightLayer() {
-         }
+                 return highlightLayer;
-     }
+         }
-     public HighlightManager getHighlightManager() {
+         public void setHighlightLayer(final MapLayer highlightLayer) {
-         return highlightManager;
+                 this.highlightLayer = highlightLayer;
-     }
+                 if (highlightManager != null) {
-     public void setHighlightManager(HighlightManager highlightManager) {
+                         highlightManager.setHighlightLayer(highlightLayer);
-         this.highlightManager = highlightManager;
+                 }
-         this.highlightManager.addHighlightChangeListener(this);
+         }
-         this.addMouseMotionListener(this.highlightManager);
-     }
+         public HighlightManager getHighlightManager() {
+                 return highlightManager;
-     public Style getLineHighlightStyle() {
+         }
-         return lineHighlightStyle;
-     }
+         public void setHighlightManager(final HighlightManager highlightManager) {
+                 this.highlightManager = highlightManager;
-     public void setLineHighlightStyle(Style lineHighlightStyle) {
+                 this.highlightManager.addHighlightChangeListener(this);
-         this.lineHighlightStyle = lineHighlightStyle;
+                 this.addMouseMotionListener(this.highlightManager);
-     }
+         }
-     public Style getLineSelectionStyle() {
+         public Style getLineHighlightStyle() {
-         return lineSelectionStyle;
+                 return lineHighlightStyle;
-     }
+         }
-     public void setLineSelectionStyle(Style lineSelectionStyle) {
+         public void setLineHighlightStyle(final Style lineHighlightStyle) {
-         this.lineSelectionStyle = lineSelectionStyle;
+                 this.lineHighlightStyle = lineHighlightStyle;
-     }
+         }
-     public Style getPointHighlightStyle() {
+         public Style getLineSelectionStyle() {
-         return pointHighlightStyle;
+                 return lineSelectionStyle;
-     }
+         }
-     public void setPointHighlightStyle(Style pointHighlightStyle) {
+         public void setLineSelectionStyle(final Style lineSelectionStyle) {
-         this.pointHighlightStyle = pointHighlightStyle;
+                 this.lineSelectionStyle = lineSelectionStyle;
-     }
+         }
-     public Style getPointSelectionStyle() {
+         public Style getPointHighlightStyle() {
-         return pointSelectionStyle;
+                 return pointHighlightStyle;
-     }
+         }
-     public void setPointSelectionStyle(Style pointSelectionStyle) {
+         public void setPointHighlightStyle(final Style pointHighlightStyle) {
-         this.pointSelectionStyle = pointSelectionStyle;
+                 this.pointHighlightStyle = pointHighlightStyle;
-     }
+         }
-     public Style getPolygonHighlightStyle() {
+         public Style getPointSelectionStyle() {
-         return polygonHighlightStyle;
+                 return pointSelectionStyle;
-     }
+         }
-     public void setPolygonHighlightStyle(Style polygonHighlightStyle) {
+         public void setPointSelectionStyle(final Style pointSelectionStyle) {
-         this.polygonHighlightStyle = polygonHighlightStyle;
+                 this.pointSelectionStyle = pointSelectionStyle;
-     }
+         }
-     public Style getPolygonSelectionStyle() {
+         public Style getPolygonHighlightStyle() {
-         return polygonSelectionStyle;
+                 return polygonHighlightStyle;
-     }
+         }
-     public void setPolygonSelectionStyle(Style polygonSelectionStyle) {
+         public void setPolygonHighlightStyle(final Style polygonHighlightStyle) {
-         this.polygonSelectionStyle = polygonSelectionStyle;
+                 this.polygonHighlightStyle = polygonHighlightStyle;
-     }
+         }
-     protected void paintComponent(Graphics g) {
+         public Style getPolygonSelectionStyle() {
-         super.paintComponent(g);
+                 return polygonSelectionStyle;
+         }
-         if ((renderer == null) || (mapArea == null)  ) {
-             return;
+         public void setPolygonSelectionStyle(final Style polygonSelectionStyle) {
-         }
+                 this.polygonSelectionStyle = polygonSelectionStyle;
+         }
-         Rectangle r = getBounds();
-         Rectangle dr = new Rectangle(r.width, r.height);
+         protected void paintComponent(final Graphics g) {
+                 super.paintComponent(g);
-         if (!r.equals(oldRect) || reset) {
-                 if(!r.equals(oldRect) && (mapArea == null)) {
+                 if ((renderer == null) || (mapArea == null)) {
-                         try {
+                         return;
-                                         mapArea=context.getLayerBounds();
+                 }
-                                 } catch (IOException e) {
-                                         // TODO Auto-generated catch block
+                 final Rectangle r = getBounds();
-                                         e.printStackTrace();
+                 final Rectangle dr = new Rectangle(r.width, r.height);
-                                 }
-                 }
+                 if (!r.equals(oldRect) || reset) {
+                         if (!r.equals(oldRect) && (mapArea == null)) {
-                 if (mapArea != null){
+                                 try {
-                         /* either the viewer size has changed or we've done a reset */
+                                         mapArea = context.getLayerBounds();
-                         changed = true; /* note we need to redraw */
+                                 } catch (final IOException e) {
-                         reset = false; /* forget about the reset */
+                                         // TODO Auto-generated catch block
-                         oldRect = r; /* store what the current size is */
+                                         e.printStackTrace();
+                                 }
-                         mapArea = fixAspectRatio(r, mapArea);
+                         }
-                 }
-         }
+                         if (mapArea != null) {
+                                 /* either the viewer size has changed or we've done a reset */
-         if (!mapArea.equals(oldMapArea)) { /* did the map extent change? */
+                                 changed = true; /* note we need to redraw */
-             changed = true;
+                                 reset = false; /* forget about the reset */
-             oldMapArea = mapArea;
+                                 oldRect = r; /* store what the current size is */
- //          when we tell the context that the bounds have changed WMSLayers
-             // can refresh them selves
+                                 mapArea = fixAspectRatio(r, mapArea);
-             context.setAreaOfInterest(mapArea, context
+                         }
-                     .getCoordinateReferenceSystem());
+                 }
-         }
+                 if (!mapArea.equals(oldMapArea)) { /* did the map extent change? */
-         if (changed) { /* if the map changed then redraw */
+                         changed = true;
-             changed = false;
+                         oldMapArea = mapArea;
-             baseImage = new BufferedImage(dr.width, dr.height,
+                         // when we tell the context that the bounds have changed WMSLayers
-                     BufferedImage.TYPE_INT_ARGB);
+                         // can refresh them selves
+                         context.setAreaOfInterest(mapArea, context
-             Graphics2D ig = baseImage.createGraphics();
+                                         .getCoordinateReferenceSystem());
-             /* System.out.println("rendering"); */
+                 }
-             renderer.setContext(context);
-             labelCache.clear(); // work around anoying labelcache bug
+                 if (changed ) { /* if the map changed then redraw */
+                         changed = false;
+                         baseImage = new BufferedImage(dr.width, dr.height,
-             // draw the map
+                                         BufferedImage.TYPE_INT_ARGB);
-             renderer.paint((Graphics2D) ig, dr, mapArea);
+                         final Graphics2D ig = baseImage.createGraphics();
-             // TODO , nur machen, wenn panning beginnt
+                         /* System.out.println("rendering"); */
-             panningImage = new BufferedImage(dr.width, dr.height,
+                         if (renderer.getContext() != null)
-                         BufferedImage.TYPE_INT_RGB);
+                                 renderer.setContext(context);
+                         labelCache.clear(); // work around anoying labelcache bug
-         }
+                         // draw the map
-         ((Graphics2D) g).drawImage(baseImage, 0, 0, this);
+                         renderer.paint((Graphics2D) ig, dr, mapArea);
-         if ((selection != null) && (selection.size() > 0)) {
+                         // TODO nur machen, wenn panning beginnt
-             // paint selection
+                         panningImage = new BufferedImage(dr.width, dr.height,
+                                         BufferedImage.TYPE_INT_RGB);
-             String type = selectionLayer.getFeatureSource().getSchema()
-             .getDefaultGeometry().getType().getName();
+                 }
-             /*String type = selection.getDefaultGeometry().getGeometryType();*/
-             /*System.out.println(type);*/
+                 ((Graphics2D) g).drawImage(baseImage, 0, 0, this);
-             if (type == null)
-                 type = "polygon";
+                 if ((selection != null) && (selection.size() > 0)) {
+                         // paint selection
-             /* String type = "point"; */
+                         String type = selectionLayer.getFeatureSource().getSchema()
-             if (type.toLowerCase().endsWith("polygon")) {
+                                         .getDefaultGeometry().getType().getName();
-                 selectionStyle = polygonSelectionStyle;
+                         /* String type = selection.getDefaultGeometry().getGeometryType(); */
-             } else if (type.toLowerCase().endsWith("point")) {
+                         /* System.out.println(type); */
-                 selectionStyle = pointSelectionStyle;
+                         if (type == null)
-             } else if (type.toLowerCase().endsWith("line")) {
+                                 type = "polygon";
-                 selectionStyle = lineSelectionStyle;
-             }
+                         /* String type = "point"; */
-             selectionContext = new DefaultMapContext(DefaultGeographicCRS.WGS84);
+                         if (type.toLowerCase().endsWith("polygon")) {
+                                 selectionStyle = polygonSelectionStyle;
-             selectionContext.addLayer(selection, selectionStyle);
+                         } else if (type.toLowerCase().endsWith("point")) {
-             selectionRenderer.setContext(selectionContext);
+                                 selectionStyle = pointSelectionStyle;
+                         } else if (type.toLowerCase().endsWith("line")) {
-             selectImage = new BufferedImage(dr.width, dr.height,
+                                 selectionStyle = lineSelectionStyle;
-                     BufferedImage.TYPE_INT_ARGB);
+                         }
-             Graphics2D ig = selectImage.createGraphics();
+                         selectionContext = new DefaultMapContext(DefaultGeographicCRS.WGS84);
-             /* System.out.println("rendering selection"); */
-             selectionRenderer.paint((Graphics2D) ig, dr, mapArea);
+                         selectionContext.addLayer(selection, selectionStyle);
+                         selectionRenderer.setContext(selectionContext);
-             ((Graphics2D) g).drawImage(selectImage, 0, 0, this);
-         }
+                         selectImage = new BufferedImage(dr.width, dr.height,
+                                         BufferedImage.TYPE_INT_ARGB);
-         if (highlight && (highlightFeature != null)
-                 && (highlightFeature.size() > 0)) {
+                         final Graphics2D ig = selectImage.createGraphics();
-             /*
+                         /* System.out.println("rendering selection"); */
-              * String type = selection.getDefaultGeometry().getGeometryType();
+                         selectionRenderer.paint((Graphics2D) ig, dr, mapArea);
-              * System.out.println(type); if(type==null) type="polygon";
-              */
+                         ((Graphics2D) g).drawImage(selectImage, 0, 0, this);
-             String type = highlightLayer.getFeatureSource().getSchema()
+                 }
-             .getDefaultGeometry().getType().getName();
-             /*String type = selection.getDefaultGeometry().getGeometryType();*/
+                 if (highlight && (highlightFeature != null)
-             //System.out.println(type);
+                                 && (highlightFeature.size() > 0)) {
-             if (type == null)
+                         /*
-                 type = "polygon";
+                          * String type = selection.getDefaultGeometry().getGeometryType();
+                          * System.out.println(type); if(type==null) type="polygon";
-             /* String type = "point"; */
+                          */
-             Style highlightStyle = null;
+                         String type = highlightLayer.getFeatureSource().getSchema()
-             if (type.toLowerCase().endsWith("polygon")) {
+                                         .getDefaultGeometry().getType().getName();
-                 highlightStyle = polygonHighlightStyle;
+                         /* String type = selection.getDefaultGeometry().getGeometryType(); */
-             } else if (type.toLowerCase().endsWith("point")) {
+                         // System.out.println(type);
-                 highlightStyle = pointHighlightStyle;
+                         if (type == null)
-             } else if (type.toLowerCase().endsWith("line")) {
+                                 type = "polygon";
-                 highlightStyle = lineHighlightStyle;
-             }
+                         /* String type = "point"; */
+                         Style highlightStyle = null;
+                         if (type.toLowerCase().endsWith("polygon")) {
+                                 highlightStyle = polygonHighlightStyle;
+                         } else if (type.toLowerCase().endsWith("point")) {
-             MapContext highlightContext = new DefaultMapContext(
+                                 highlightStyle = pointHighlightStyle;
-                     DefaultGeographicCRS.WGS84);
+                         } else if (type.toLowerCase().endsWith("line")) {
+                                 highlightStyle = lineHighlightStyle;
-             highlightContext.addLayer(highlightFeature, highlightStyle);
+                         }
-             highlightRenderer.setContext(highlightContext);
+                         final MapContext highlightContext = new DefaultMapContext(
-             /* System.out.println("rendering highlight"); */
+                                         DefaultGeographicCRS.WGS84);
-             highlightRenderer.paint((Graphics2D) g, dr, mapArea);
-         }
+                         highlightContext.addLayer(highlightFeature, highlightStyle);
-     }
+                         highlightRenderer.setContext(highlightContext);
-     private Envelope fixAspectRatio(Rectangle r, Envelope mapArea) {
+                         /* System.out.println("rendering highlight"); */
+                         highlightRenderer.paint((Graphics2D) g, dr, mapArea);
-         double mapWidth = mapArea.getWidth(); /* get the extent of the map */
+                 }
-         double mapHeight = mapArea.getHeight();
+         }
-         double scaleX = r.getWidth() / mapArea.getWidth(); /*
-                                                              * calculate the new
+         private Envelope fixAspectRatio(final Rectangle r, final Envelope mapArea) {
-                                                              * scale
-                                                              */
+                 final double mapWidth = mapArea.getWidth(); /* get the extent of the map */
+                 final double mapHeight = mapArea.getHeight();
-         double scaleY = r.getHeight() / mapArea.getHeight();
+                 final double scaleX = r.getWidth() / mapArea.getWidth(); /*
-         double scale = 1.0; // stupid compiler!
+                                                                                                                          * calculate the new
+                                                                                                                          * scale
-         if (scaleX < scaleY) { /* pick the smaller scale */
+                                                                                                                          */
-             scale = scaleX;
-         } else {
+                 final double scaleY = r.getHeight() / mapArea.getHeight();
-             scale = scaleY;
+                 double scale = 1.0; // stupid compiler!
-         }
+                 if (scaleX < scaleY) { /* pick the smaller scale */
-         /* calculate the difference in width and height of the new extent */
+                         scale = scaleX;
-         double deltaX = /* Math.abs */((r.getWidth() / scale) - mapWidth);
+                 } else {
-         double deltaY = /* Math.abs */((r.getHeight() / scale) - mapHeight);
+                         scale = scaleY;
+                 }
-         /*
-          * System.out.println("delta x " + deltaX); System.out.println("delta y " +
+                 /* calculate the difference in width and height of the new extent */
-          * deltaY);
+                 final double deltaX = /* Math.abs */((r.getWidth() / scale) - mapWidth);
-          */
+                 final double deltaY = /* Math.abs */((r.getHeight() / scale) - mapHeight);
-         /* create the new extent */
+                 /*
-         Coordinate ll = new Coordinate(mapArea.getMinX() - (deltaX / 2.0),
+                  * System.out.println("delta x " + deltaX);
-                 mapArea.getMinY() - (deltaY / 2.0));
+                  * System.out.println("delta y " + deltaY);
-         Coordinate ur = new Coordinate(mapArea.getMaxX() + (deltaX / 2.0),
+                  */
-                 mapArea.getMaxY() + (deltaY / 2.0));
+                 /* create the new extent */
-         return new Envelope(ll, ur);
+                 final Coordinate ll = new Coordinate(mapArea.getMinX() - (deltaX / 2.0),
-     }
+                                 mapArea.getMinY() - (deltaY / 2.0));
+                 final Coordinate ur = new Coordinate(mapArea.getMaxX() + (deltaX / 2.0),
-     public void doSelection(double x, double y, MapLayer layer) {
+                                 mapArea.getMaxY() + (deltaY / 2.0));
-         Geometry geometry = gf.createPoint(new Coordinate(x, y));
+                 return new Envelope(ll, ur);
+         }
-         // org.opengis.geometry.Geometry geometry = new Point();
+         public void doSelection(final double x, final double y, final MapLayer layer) {
-             findFeature(geometry, layer);
+                 final Geometry geometry = gf.createPoint(new Coordinate(x, y));
-     }
+                 // org.opengis.geometry.Geometry geometry = new Point();
-     /**
-      * @param geometry -
+                 findFeature(geometry, layer);
-      *            a geometry to construct the filter with
-      * @param i -
+         }
-      *            the index of the layer to search
-      * @throws IndexOutOfBoundsException
+         /**
-      */
+          * @param geometry
-     private void findFeature(Geometry geometry, MapLayer layer)
+          *            - a geometry to construct the filter with
-             throws IndexOutOfBoundsException {
+          * @param i
-         org.opengis.filter.spatial.BinarySpatialOperator f = null;
+          *            - the index of the layer to search
+          * @throws IndexOutOfBoundsException
+          */
-         if ((context == null) || (layer==null)) {
+         private void findFeature(final Geometry geometry, final MapLayer layer)
-             return ;
+                         throws IndexOutOfBoundsException {
-         }
+                 org.opengis.filter.spatial.BinarySpatialOperator f = null;
+                 if ((context == null) || (layer == null)) {
+                         return;
-         try {
+                 }
-             String name = layer.getFeatureSource().getSchema()
-                     .getDefaultGeometry().getName();
+                 try {
+                         String name = layer.getFeatureSource().getSchema()
-             if (name == "") {
+                                         .getDefaultGeometry().getLocalName();
-                 name = "the_geom";
-             }
+                         if (name == "") {
+                                 name = "the_geom";
-             try {
+                         }
-                 f = ff.contains(ff.property(name), ff.literal(geometry));
-                 if(selectionManager!=null) {
+                         try {
-                     System.out.println("selection changed");
+                                 f = ff.contains(ff.property(name), ff.literal(geometry));
-                     selectionManager.selectionChanged(this, f);
+                                 if (selectionManager != null) {
+ //                                      System.out.println("selection changed");
-                 }
+                                         selectionManager.selectionChanged(this, f);
-             } catch (IllegalFilterException e) {
-                 // TODO Auto-generated catch block
+                                 }
-                 e.printStackTrace();
+                         } catch (final IllegalFilterException e) {
-             }
+                                 // TODO Auto-generated catch block
+                                 e.printStackTrace();
-             /*// f.addLeftGeometry(ff.property(name));
+                         }
-             // System.out.println("looking with " + f);
-             FeatureCollection fc = layer.getFeatureSource().getFeatures(f);
+                         /*
+                          * // 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
+                          * if (fcol == null) { fcol = fc;
-             } else {
+                          *
-                 fcol.addAll(fc);
+                          * // here we should set the defaultgeom type } else {
-             }*/
+                          * fcol.addAll(fc); }
+                          */
-             /*
-              * GeometryAttributeType gat =
+                         /*
-              * layer.getFeatureSource().getSchema().getDefaultGeometry();
+                          * GeometryAttributeType gat =
-              * fcol.setDefaultGeometry((Geometry)gat.createDefaultValue());
+                          * 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 " +
+                          * Iterator fi = fc.iterator(); while (fi.hasNext()) { SimpleFeature feat
-              * feat.getAttribute("STATE_NAME")); }
+                          * = (SimpleFeature) fi.next(); System.out.println("selected " +
-              */
+                          * feat.getAttribute("STATE_NAME")); }
-         } catch (IllegalFilterException e) {
+                          */
-             // TODO Auto-generated catch block
+                 } catch (final IllegalFilterException e) {
-             e.printStackTrace();
+                         // TODO Auto-generated catch block
-         }
+                         e.printStackTrace();
-         return ;
+                 }
-     }
+                 return;
+         }
-     public void mouseClicked(MouseEvent e) {
-         // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"
+         public void mouseClicked(final MouseEvent e) {
-         // h:"+mapArea.getHeight());
+                 if (mapArea == null) return;
-         Rectangle bounds = this.getBounds();
+                 // System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+"
-         double x = (double) (e.getX());
+                 // h:"+mapArea.getHeight());
-         double y = (double) (e.getY());
+                 final Rectangle bounds = this.getBounds();
-         double width = mapArea.getWidth();
+                 final double x = (double) (e.getX());
-         double height = mapArea.getHeight();
+                 final double y = (double) (e.getY());
- //xulu.sc
+                 final double width = mapArea.getWidth();
- //        double width2 = mapArea.getWidth() / 2.0;
+                 final double height = mapArea.getHeight();
- //        double height2 = mapArea.getHeight() / 2.0;
+                 // xulu.sc
-         double width2 = width / 2.0;
+                 // double width2 = mapArea.getWidth() / 2.0;
-         double height2 = height / 2.0;
+                 // double height2 = mapArea.getHeight() / 2.0;
- //xulu.ec
+                 final double width2 = width / 2.0;
-         double mapX = ((x * width) / (double) bounds.width) + mapArea.getMinX();
+                 final double height2 = height / 2.0;
-         double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)
+                 // xulu.ec
-                 + mapArea.getMinY();
+                 final double mapX = ((x * width) / (double) bounds.width) + mapArea.getMinX();
+                 final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height)
-         /*
+                                 + mapArea.getMinY();
-          * System.out.println(""+x+"->"+mapX);
-          * System.out.println(""+y+"->"+mapY);
+                 /*
-          */
+                  * System.out.println(""+x+"->"+mapX);
+                  * System.out.println(""+y+"->"+mapY);
-         /*
+                  */
-          * Coordinate ll = new Coordinate(mapArea.getMinX(), mapArea.getMinY());
-          * Coordinate ur = new Coordinate(mapArea.getMaxX(), mapArea.getMaxY());
+                 /*
-          */
+                  * Coordinate ll = new Coordinate(mapArea.getMinX(), mapArea.getMinY());
-         double zlevel = 1.0;
+                  * Coordinate ur = new Coordinate(mapArea.getMaxX(), mapArea.getMaxY());
+                  */
-         switch (state) {
+                 double zlevel = 1.0;
-         case Pan:
-             zlevel = 1.0;
+                 switch (state) {
- //xulu.sc SK: return here.. a mouselistener is maanaging the PANNING
+                 case Pan:
- //            break;
+                         zlevel = 1.0;
-             return;
+                         // xulu.sc SK: return here.. a mouselistener is managing the PANNING
- //xulu.ec
+                         // break;
-         case ZoomIn:
+                         return;
-             zlevel = zoomFactor;
+                         // xulu.ec
+                 case ZoomIn:
-             break;
+                         zlevel = zoomFactor;
-         case ZoomOut:
+                         break;
-             zlevel = 1.0 / zoomFactor;
+                 case ZoomOut:
-             break;
+                         zlevel = 1.0 / zoomFactor;
-         case Select:
+                         break;
-             doSelection(mapX, mapY, selectionLayer);
+                 case Select:
+                         doSelection(mapX, mapY, selectionLayer);
-             return;
+                         return;
-         default:
-             return;
+                 default:
-         }
+                         return;
+                 }
-         Coordinate ll = new Coordinate(mapX - (width2 / zlevel), mapY
-                 - (height2 / zlevel));
+                 final Coordinate ll = new Coordinate(mapX - (width2 / zlevel), mapY
-         Coordinate ur = new Coordinate(mapX + (width2 / zlevel), mapY
+                                 - (height2 / zlevel));
-                 + (height2 / zlevel));
+                 final Coordinate ur = new Coordinate(mapX + (width2 / zlevel), mapY
- //xulu.sc SK: Check for min/max scale
+                                 + (height2 / zlevel));
- //        mapArea = new Envelope(ll, ur);
+                 // xulu.sc SK: Check for min/max scale
-         final Envelope newMapArea = new Envelope(ll, ur);
+                 // mapArea = new Envelope(ll, ur);
-         setMapArea( bestAllowedMapArea( newMapArea ) );
+                 final Envelope newMapArea = new Envelope(ll, ur);
- //xulu.ec
+                 setMapArea(bestAllowedMapArea(newMapArea));
+                 // xulu.ec
-         // System.out.println("after area "+mapArea+"\nw:"+mapArea.getWidth()+"
-         // h:"+mapArea.getHeight());
+                 // sk.ec
-         repaint();
-     }
+                 // System.out.println("after area "+mapArea+"\nw:"+mapArea.getWidth()+"
+                 // h:"+mapArea.getHeight());
-     public void mouseEntered(MouseEvent e) {
+                 repaint();
-     }
+         }
-     public void mouseExited(MouseEvent e) {
+         public void mouseEntered(final MouseEvent e) {
-     }
+         }
-     public void mousePressed(MouseEvent e) {
+         public void mouseExited(final MouseEvent e) {
-         startX = e.getX();
+         }
-         startY = e.getY();
-         lastX = 0;
+         public void mousePressed(final MouseEvent e) {
-         lastY = 0;
+                 startX = e.getX();
-     }
+                 startY = e.getY();
+                 lastX = 0;
-     public void mouseReleased(MouseEvent e) {
+                 lastY = 0;
-         int endX = e.getX();
+         }
-         int endY = e.getY();
+         public void mouseReleased(final MouseEvent e) {
-         processDrag(startX, startY, endX, endY, e);
+                 final int endX = e.getX();
-         lastX = 0;
+                 final int endY = e.getY();
-         lastY = 0;
+                 processDrag(startX, startY, endX, endY, e);
-         /**
+                 lastX = 0;
-          * Es wird nicht (mehr) gepannt!
+                 lastY = 0;
-          */
-         panning_started = false;
+                 /**
-     }
+                  * Es wird nicht (mehr) gepannt!
+                  */
-     public void mouseDragged(MouseEvent e) {
+                 panning_started = false;
-         Graphics graphics = this.getGraphics();
+         }
-         int x = e.getX();
-         int y = e.getY();
+         public void mouseDragged(final MouseEvent e) {
+                 final Graphics graphics = this.getGraphics();
+                 final int x = e.getX();
-         if ( (state == JMapPane.Pan) || ((e.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0))  {
+                 final int y = e.getY();
-             /**
-              * SK:
+                 if ((state == JMapPane.Pan)
-              * Der Cursor wird auf PANNING gesetzt.
+                                 || ((e.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) {
-              */
+                         /**
-                 if (panning_started == false){
+                          * SK: Der Cursor wird auf PANNING gesetzt.
-                         panning_started = true;
+                          */
-                         setCursor( SwingUtil.PANNING_CURSOR );
+                         if (panning_started == false) {
-                 }
+                                 panning_started = true;
+                                 setCursor(SwingUtil.PANNING_CURSOR);
+                         }
-             // move the image with the mouse
-             if ((lastX > 0) && (lastY > 0)) {
+                         // move the image with the mouse
-                 int dx = lastX - startX;
+                         if ((lastX > 0) && (lastY > 0)) {
-                 int dy = lastY - startY;
+                                 final int dx = lastX - startX;
-                 // System.out.println("translate "+dx+","+dy);
+                                 final int dy = lastY - startY;
-                 final Graphics2D g2 = panningImage.createGraphics();
+                                 // System.out.println("translate "+dx+","+dy);
-                 g2.setBackground( new Color(240,240,240) ); //TODO richtige farbe? am besten vom L&F die hintergrundfarbe auslesen...
+                                 final Graphics2D g2 = panningImage.createGraphics();
+                                 g2.setBackground(new Color(240, 240, 240)); // TODO richtige
+                                                                                                                         // farbe? am besten
+                                                                                                                         // vom L&F die
+                                                                                                                         // hintergrundfarbe
+                                                                                                                         // auslesen...
                                  g2.clearRect(0, 0, this.getWidth(), this.getHeight());
                                  g2.drawImage(baseImage, dx, dy, this);
-                 graphics.drawImage(panningImage, 0, 0, this);
+                                 graphics.drawImage(panningImage, 0, 0, this);
-             }
+                         }
-             lastX = x;
+                         lastX = x;
-             lastY = y;
+                         lastY = y;
-         } else
+                 } else
-         if ((state == JMapPane.ZoomIn) || (state == JMapPane.ZoomOut)) {
+                 if ((state == JMapPane.ZoomIn) || (state == JMapPane.ZoomOut)) {
+                         graphics.setXORMode(Color.WHITE);
-             graphics.setXORMode(Color.WHITE);
+                         if ((lastX > 0) && (lastY > 0)) {
-             if ((lastX > 0) && (lastY > 0)) {
+                                 drawRectangle(graphics);
-                 drawRectangle(graphics);
+                         }
-             }
+                         // draw new box
-             // draw new box
+                         lastX = x;
-             lastX = x;
+                         lastY = y;
-             lastY = y;
+                         drawRectangle(graphics);
-             drawRectangle(graphics);
+                 } else if (state == JMapPane.Select && selectionLayer != null) {
-         } else if (state == JMapPane.Select && selectionLayer != null) {
+                         // construct a new bbox filter
-             // construct a new bbox filter
+                         final Rectangle bounds = this.getBounds();
-             Rectangle bounds = this.getBounds();
+                         final double mapWidth = mapArea.getWidth();
-             double mapWidth = mapArea.getWidth();
+                         final double mapHeight = mapArea.getHeight();
-             double mapHeight = mapArea.getHeight();
+                         final double x1 = ((this.startX * mapWidth) / (double) bounds.width)
-             double x1 = ((this.startX * mapWidth) / (double) bounds.width)
+                                         + mapArea.getMinX();
-                     + mapArea.getMinX();
+                         final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) / (double) bounds.height)
-             double y1 = (((bounds.getHeight() - this.startY) * mapHeight) / (double) bounds.height)
+                                         + mapArea.getMinY();
-                     + mapArea.getMinY();
+                         final double x2 = ((x * mapWidth) / (double) bounds.width)
-             double x2 = ((x * mapWidth) / (double) bounds.width)
+                                         + mapArea.getMinX();
-                     + mapArea.getMinX();
+                         final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double) bounds.height)
-             double y2 = (((bounds.getHeight() - y) * mapHeight) / (double) bounds.height)
+                                         + mapArea.getMinY();
-                     + mapArea.getMinY();
+                         final double left = Math.min(x1, x2);
-             double left = Math.min(x1, x2);
+                         final double right = Math.max(x1, x2);
-             double right = Math.max(x1, x2);
+                         final double bottom = Math.min(y1, y2);
-             double bottom = Math.min(y1, y2);
+                         final double top = Math.max(y1, y2);
-             double top = Math.max(y1, y2);
+                         String name = selectionLayer.getFeatureSource().getSchema()
+                                         .getDefaultGeometry().getName();
-             String name = selectionLayer.getFeatureSource().getSchema()
-                     .getDefaultGeometry().getName();
+                         if (name == "") {
+                                 name = "the_geom";
-             if (name == "") {
+                         }
-                 name = "the_geom";
+                         final Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,
-             }
+                                         getContext().getCoordinateReferenceSystem().toString());
-             Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,
+                         if (selectionManager != null) {
-                     getContext().getCoordinateReferenceSystem().toString());
+                                 selectionManager.selectionChanged(this, bb);
-             if(selectionManager!=null) {
+                         }
-                 selectionManager.selectionChanged(this, bb);
-             }
+                         graphics.setXORMode(Color.green);
-             graphics.setXORMode(Color.green);
+                         /*
+                          * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }
-             /*
+                          */
-              * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); }
-              */
+                         // draw new box
+                         lastX = x;
-             // draw new box
+                         lastY = y;
-             lastX = x;
+                         drawRectangle(graphics);
-             lastY = y;
+                 }
-             drawRectangle(graphics);
-        }
+         }
-     }
+         // sk.cs
+         // private void processDrag(int x1, int y1, int x2, int y2) {
-     // sk.cs
+         // sk.ce
- //    private void processDrag(int x1, int y1, int x2, int y2) {
+         protected void processDrag(final int x1, final int y1, final int x2,
-     // sk.ce
+                         final int y2, final MouseEvent e) {
-     protected void processDrag(int x1, int y1, int x2, int y2, MouseEvent e) {
+                 /****
-         /****
+                  * If no layer is availabe we dont want a NullPointerException
-          * If no layer is availabe we dont want a NullPointerException
+                  */
-          */
+                 if (mapArea == null)
-         if (mapArea == null) return;
+                         return;
-         // System.out.println("processing drag from " + x1 + "," + y1 + " -> "
+                 // System.out.println("processing drag from " + x1 + "," + y1 + " -> "
-         // + x2 + "," + y2);
+                 // + x2 + "," + y2);
-         if ((x1 == x2) && (y1 == y2)) {
+                 if ((x1 == x2) && (y1 == y2)) {
-             if (isClickable()) {
+                         if (isClickable()) {
-                 mouseClicked(new MouseEvent(this, 0, new Date().getTime(), 0,
+                                 mouseClicked(new MouseEvent(this, 0, new Date().getTime(), 0,
-                         x1, y1, y2, false));
+                                                 x1, y1, y2, false));
-             }
+                         }
-             return;
+                         return;
-         }
+                 }
-         Rectangle bounds = this.getBounds();
+                 final Rectangle bounds = this.getBounds();
-         double mapWidth = mapArea.getWidth();
+                 final double mapWidth = mapArea.getWidth();
-         double mapHeight = mapArea.getHeight();
+                 final double mapHeight = mapArea.getHeight();
-         double startX = ((x1 * mapWidth) / (double) bounds.width)
+                 final double startX = ((x1 * mapWidth) / (double) bounds.width)
-                 + mapArea.getMinX();
+                                 + mapArea.getMinX();
-         double startY = (((bounds.getHeight() - y1) * mapHeight) / (double) bounds.height)
+                 final double startY = (((bounds.getHeight() - y1) * mapHeight) / (double) bounds.height)
-                 + mapArea.getMinY();
+                                 + mapArea.getMinY();
-         double endX = ((x2 * mapWidth) / (double) bounds.width)
+                 final double endX = ((x2 * mapWidth) / (double) bounds.width)
-                 + mapArea.getMinX();
+                                 + mapArea.getMinX();
-         double endY = (((bounds.getHeight() - y2) * mapHeight) / (double) bounds.height)
+                 final double endY = (((bounds.getHeight() - y2) * mapHeight) / (double) bounds.height)
-                 + mapArea.getMinY();
+                                 + mapArea.getMinY();
-         if (  (state == JMapPane.Pan) || (e.getButton()== MouseEvent.BUTTON3)) {
+                 if ((state == JMapPane.Pan) || (e.getButton() == MouseEvent.BUTTON3)) {
-             // move the image with the mouse
+                         // move the image with the mouse
-             // calculate X offsets from start point to the end Point
+                         // calculate X offsets from start point to the end Point
-             double deltaX1 = endX - startX;
+                         final double deltaX1 = endX - startX;
-             // System.out.println("deltaX " + deltaX1);
+                         // System.out.println("deltaX " + deltaX1);
-             // new edges
+                         // new edges
-             double left = mapArea.getMinX() - deltaX1;
+                         final double left = mapArea.getMinX() - deltaX1;
-             double right = mapArea.getMaxX() - deltaX1;
+                         final double right = mapArea.getMaxX() - deltaX1;
-             // now for Y
+                         // now for Y
-             double deltaY1 = endY - startY;
+                         final double deltaY1 = endY - startY;
-             // System.out.println("deltaY " + deltaY1);
+                         // System.out.println("deltaY " + deltaY1);
-             double bottom = mapArea.getMinY() - deltaY1;
+                         final double bottom = mapArea.getMinY() - deltaY1;
-             double top = mapArea.getMaxY() - deltaY1;
+                         final double top = mapArea.getMaxY() - deltaY1;
-             Coordinate ll = new Coordinate(left, bottom);
+                         final Coordinate ll = new Coordinate(left, bottom);
-             Coordinate ur = new Coordinate(right, top);
+                         final Coordinate ur = new Coordinate(right, top);
- //xulu.sc
+                         // xulu.sc
- //            mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
+                         // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
-             setMapArea( fixAspectRatio(this.getBounds(), new Envelope(ll, ur)) );
+                         setMapArea(fixAspectRatio(this.getBounds(), new Envelope(ll, ur)));
- //xulu.ec
+                         // xulu.ec
-         } else if (state == JMapPane.ZoomIn) {
+                 } else if (state == JMapPane.ZoomIn) {
+                         // Zu kleine Flächen sollen nicht gezoomt werden.
-                 // Zu kleine Flächen sollen nicht gezoomt werden.
+                         // sk.bc
-                 //sk.bc
+                         if ((Math.abs(x1 - x2) * Math.abs(y2 - y1)) < 150)
-                 if ( (Math.abs(x1-x2) * Math.abs(y2-y1) )<100 ) return;
+                                 return;
-                 // sk.ec
+                         // sk.ec
-                 drawRectangle(this.getGraphics());
+                         drawRectangle(this.getGraphics());
-             // make the dragged rectangle (in map coords) the new BBOX
+                         // make the dragged rectangle (in map coords) the new BBOX
-             double left = Math.min(startX, endX);
+                         final double left = Math.min(startX, endX);
-             double right = Math.max(startX, endX);
+                         final double right = Math.max(startX, endX);
-             double bottom = Math.min(startY, endY);
+                         final double bottom = Math.min(startY, endY);
-             double top = Math.max(startY, endY);
+                         final double top = Math.max(startY, endY);
-             Coordinate ll = new Coordinate(left, bottom);
+                         final Coordinate ll = new Coordinate(left, bottom);
-             Coordinate ur = new Coordinate(right, top);
+                         final Coordinate ur = new Coordinate(right, top);
- //xulu.sc
+                         // xulu.sc
- //            mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
-             setMapArea( fixAspectRatio(this.getBounds(), new Envelope(ll, ur)) );
+                         // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
- //xulu.ec
+                         setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
-         } else if (state == JMapPane.ZoomOut) {
-                 drawRectangle(this.getGraphics());
+                         // sk.sc
+ //                      {
-                 // make the dragged rectangle in screen coords the new map size?
+ //                      // SK tries to paint a preview of the zoom ;-9 aha.... well
-             double left = Math.min(startX, endX);
+ //                      Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics();
-             double right = Math.max(startX, endX);
+ //                      graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-             double bottom = Math.min(startY, endY);
+ //                                      RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
-             double top = Math.max(startY, endY);
+ //                      graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-             double nWidth = (mapWidth * mapWidth) / (right - left);
+ //                                      RenderingHints.VALUE_ANTIALIAS_OFF);
-             double nHeight = (mapHeight * mapHeight) / (top - bottom);
+ //                      graphics.setRenderingHint(RenderingHints.KEY_RENDERING,
-             double deltaX1 = left - mapArea.getMinX();
+ //                                      RenderingHints.VALUE_RENDER_SPEED);
-             double nDeltaX1 = (deltaX1 * nWidth) / mapWidth;
+ //                      graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(),
-             double deltaY1 = bottom - mapArea.getMinY();
+ //                                      JMapPane.this.getHeight(), x1, y1, x2, y2, null);
-             double nDeltaY1 = (deltaY1 * nHeight) / mapHeight;
+ //                      }
-             Coordinate ll = new Coordinate(mapArea.getMinX() - nDeltaX1,
+                         // xulu.ec
-                     mapArea.getMinY() - nDeltaY1);
+                 } else if (state == JMapPane.ZoomOut) {
-             double deltaX2 = mapArea.getMaxX() - right;
+                         drawRectangle(this.getGraphics());
-             double nDeltaX2 = (deltaX2 * nWidth) / mapWidth;
-             double deltaY2 = mapArea.getMaxY() - top;
+                         // make the dragged rectangle in screen coords the new map size?
-             double nDeltaY2 = (deltaY2 * nHeight) / mapHeight;
+                         final double left = Math.min(startX, endX);
-             Coordinate ur = new Coordinate(mapArea.getMaxX() + nDeltaX2,
+                         final double right = Math.max(startX, endX);
-                     mapArea.getMaxY() + nDeltaY2);
+                         final double bottom = Math.min(startY, endY);
- //xulu.sc
+                         final double top = Math.max(startY, endY);
- //            mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
+                         final double nWidth = (mapWidth * mapWidth) / (right - left);
-             setMapArea( fixAspectRatio(this.getBounds(), new Envelope(ll, ur)) );
+                         final double nHeight = (mapHeight * mapHeight) / (top - bottom);
- //xulu.ec
+                         final double deltaX1 = left - mapArea.getMinX();
-         } else if (state == JMapPane.Select && selectionLayer !=null) {
+                         final double nDeltaX1 = (deltaX1 * nWidth) / mapWidth;
-             double left = Math.min(startX, endX);
+                         final double deltaY1 = bottom - mapArea.getMinY();
-             double right = Math.max(startX, endX);
+                         final double nDeltaY1 = (deltaY1 * nHeight) / mapHeight;
-             double bottom = Math.min(startY, endY);
+                         final Coordinate ll = new Coordinate(mapArea.getMinX() - nDeltaX1,
-             double top = Math.max(startY, endY);
+                                         mapArea.getMinY() - nDeltaY1);
+                         final double deltaX2 = mapArea.getMaxX() - right;
+                         final double nDeltaX2 = (deltaX2 * nWidth) / mapWidth;
-             String name = selectionLayer.getFeatureSource().getSchema()
+                         final double deltaY2 = mapArea.getMaxY() - top;
-                     .getDefaultGeometry().getLocalName();
+                         final double nDeltaY2 = (deltaY2 * nHeight) / mapHeight;
+                         final Coordinate ur = new Coordinate(mapArea.getMaxX() + nDeltaX2,
-             if (name == "") {
+                                         mapArea.getMaxY() + nDeltaY2);
-                 name = "the_geom";
+                         // xulu.sc
-             }
+                         // mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur));
-             Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,
+                         setMapArea(bestAllowedMapArea(new Envelope(ll, ur)));
-                     getContext().getCoordinateReferenceSystem().toString());
-             //System.out.println(bb.toString());
+                         // xulu.ec
-             if(selectionManager!=null) {
+                 } else if (state == JMapPane.Select && selectionLayer != null) {
-                 selectionManager.selectionChanged(this, bb);
+                         final double left = Math.min(startX, endX);
-             }
+                         final double right = Math.max(startX, endX);
-             /*FeatureCollection fc;
+                         final double bottom = Math.min(startY, endY);
-             selection = null;
+                         final double top = Math.max(startY, endY);
-             try {
-                 fc = selectionLayer.getFeatureSource().getFeatures(bb);
+                         String name = selectionLayer.getFeatureSource().getSchema()
-                 selection = fc;
+                                         .getDefaultGeometry().getLocalName();
-             } catch (IOException e) {
-                 e.printStackTrace();
+                         if (name == "") {
-             }
+                                 name = "the_geom";
- */
+                         }
-         }
+                         final Filter bb = ff.bbox(ff.property(name), left, bottom, right, top,
+                                         getContext().getCoordinateReferenceSystem().toString());
- //xulu.so
+                         // System.out.println(bb.toString());
- //        setMapArea(mapArea);
+                         if (selectionManager != null) {
- //xulu.eo
+                                 selectionManager.selectionChanged(this, bb);
-         repaint();
+                         }
-     }
+                         /*
+                          * FeatureCollection fc; selection = null; try { fc =
-     private boolean isClickable() {
+                          * selectionLayer.getFeatureSource().getFeatures(bb); selection =
-         return clickable;
+                          * fc; } catch (IOException e) { e.printStackTrace(); }
-     }
+                          */
+                 }
-     private org.geotools.styling.Style setupStyle(int type, Color color) {
-         StyleFactory sf = org.geotools.factory.CommonFactoryFinder
+                 // xulu.so
-                 .getStyleFactory(null);
+                 // setMapArea(mapArea);
-         StyleBuilder sb = new StyleBuilder();
+                 // xulu.eo
+                 repaint();
-         org.geotools.styling.Style s = sf.createStyle();
+         }
-         s.setTitle("selection");
+         private boolean isClickable() {
-         // TODO parameterise the color
+                 return clickable;
-         PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);
+         }
-         ps.setStroke(sb.createStroke(color));
+         private org.geotools.styling.Style setupStyle(final int type, final Color color) {
-         LineSymbolizer ls = sb.createLineSymbolizer(color);
+                 final StyleFactory sf = org.geotools.factory.CommonFactoryFinder
-         Graphic h = sb.createGraphic();
+                                 .getStyleFactory(null);
-         h.setMarks(new Mark[] { sb.createMark("square", color) });
+                 final StyleBuilder sb = new StyleBuilder();
-         PointSymbolizer pts = sb.createPointSymbolizer(h);
+                 org.geotools.styling.Style s = sf.createStyle();
+                 s.setTitle("selection");
-         // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});
-         switch (type) {
+                 // TODO parameterise the color
-         case POLYGON:
+                 final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color);
-             s = sb.createStyle(ps);
+                 ps.setStroke(sb.createStroke(color));
-             break;
+                 final LineSymbolizer ls = sb.createLineSymbolizer(color);
+                 final Graphic h = sb.createGraphic();
-         case POINT:
+                 h.setMarks(new Mark[] { sb.createMark("square", color) });
-             s = sb.createStyle(pts);
+                 final PointSymbolizer pts = sb.createPointSymbolizer(h);
-             break;
+                 // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts});
-         case LINE:
+                 switch (type) {
-             s = sb.createStyle(ls);
+                 case POLYGON:
-         }
+                         s = sb.createStyle(ps);
-         return s;
+                         break;
-     }
+                 case POINT:
-     public void highlightChanged(HighlightChangedEvent e) {
+                         s = sb.createStyle(pts);
-         org.opengis.filter.Filter f = e.getFilter();
+                         break;
-         try {
-             highlightFeature = highlightLayer.getFeatureSource().getFeatures(f);
+                 case LINE:
-         } catch (IOException e1) {
+                         s = sb.createStyle(ls);
-             // TODO Auto-generated catch block
+                 }
-             e1.printStackTrace();
-         }
+                 return s;
+         }
-         repaint();
-     }
+         public void highlightChanged(final HighlightChangedEvent e) {
+                 final org.opengis.filter.Filter f = e.getFilter();
-     public void propertyChange(PropertyChangeEvent evt) {
-         String prop = evt.getPropertyName();
+                 try {
+                         highlightFeature = highlightLayer.getFeatureSource().getFeatures(f);
-         if (prop.equalsIgnoreCase("crs")) {
+                 } catch (final IOException e1) {
-             context.setAreaOfInterest(context.getAreaOfInterest(),
+                         // TODO Auto-generated catch block
-                     (CoordinateReferenceSystem) evt.getNewValue());
+                         e1.printStackTrace();
-         }
+                 }
-     }
+                 repaint();
-     public boolean isReset() {
+         }
-         return reset;
-     }
+         public void propertyChange(final PropertyChangeEvent evt) {
+                 final String prop = evt.getPropertyName();
-     public void setReset(boolean reset) {
-         this.reset = reset;
+                 if (prop.equalsIgnoreCase("crs")) {
-     }
+                         context.setAreaOfInterest(context.getAreaOfInterest(),
+                                         (CoordinateReferenceSystem) evt.getNewValue());
-     public void layerAdded(MapLayerListEvent event) {
+                 }
-         changed = true;
+         }
-         if (context.getLayers().length == 1) { // the first one
+         public boolean isReset() {
+                 return reset;
-             try {
+         }
- //xulu.sc
- //            mapArea = context.getLayerBounds();
+         public void setReset(final boolean reset) {
-               mapArea = context.getAreaOfInterest();
+                 this.reset = reset;
-               if ( mapArea == null )
+         }
-                 mapArea = context.getLayerBounds();
- //xulu.ec
+         public void layerAdded(final MapLayerListEvent event) {
-             } catch (IOException e) {
+                 changed = true;
-                 // TODO Auto-generated catch block
-                 e.printStackTrace();
+                 if (context.getLayers().length == 1) { // the first one
-             }
+                         try {
-             reset = true;
+                                 // xulu.sc
-         }
+                                 // mapArea = context.getLayerBounds();
+                                 mapArea = context.getAreaOfInterest();
-         repaint();
+                                 if (mapArea == null)
-     }
+                                         mapArea = context.getLayerBounds();
+                                 // xulu.ec
-     public void layerRemoved(MapLayerListEvent event) {
+                         } catch (final IOException e) {
-         changed = true;
+                                 // TODO Auto-generated catch block
-         repaint();
+                                 e.printStackTrace();
-     }
+                         }
-     public void layerChanged(MapLayerListEvent event) {
+                         reset = true;
-         changed = true;
+                 }
-         // System.out.println("layer changed - repaint");
-         repaint();
+                 repaint();
-     }
+         }
-     public void layerMoved(MapLayerListEvent event) {
+         public void layerRemoved(final MapLayerListEvent event) {
-         changed = true;
+                 changed = true;
-         repaint();
+                 repaint();
-     }
+         }
-     protected void drawRectangle(Graphics graphics) {
+         public void layerChanged(final MapLayerListEvent event) {
-         // undraw last box/draw new box
+                 changed = true;
-         int left = Math.min(startX, lastX);
+                 // System.out.println("layer changed - repaint");
-         int right = Math.max(startX, lastX);
+                 repaint();
-         int top = Math.max(startY, lastY);
+         }
-         int bottom = Math.min(startY, lastY);
-         int width = right - left;
+         public void layerMoved(final MapLayerListEvent event) {
-         int height = top - bottom;
+                 changed = true;
-         // System.out.println("drawing rect("+left+","+bottom+","+ width+","+
+                 repaint();
-         // height+")");
+         }
-         graphics.drawRect(left, bottom, width, height);
-     }
+         protected void drawRectangle(final Graphics graphics) {
+                 // undraw last box/draw new box
-     /**
+                 final int left = Math.min(startX, lastX);
-      * if clickable is set to true then a single click on the map pane will zoom
+                 final int right = Math.max(startX, lastX);
-      * or pan the map.
+                 final int top = Math.max(startY, lastY);
-      *
+                 final int bottom = Math.min(startY, lastY);
-      * @param clickable
+                 final int width = right - left;
-      */
+                 final int height = top - bottom;
-     public void setClickable(boolean clickable) {
+                 // System.out.println("drawing rect("+left+","+bottom+","+ width+","+
-         this.clickable = clickable;
+                 // height+")");
-     }
+                 graphics.drawRect(left, bottom, width, height);
+         }
-     public void mouseMoved(MouseEvent e) {
-     }
+         /**
+          * if clickable is set to true then a single click on the map pane will zoom
-     public FeatureCollection getSelection() {
+          * or pan the map.
-         return selection;
+          *
-     }
+          * @param clickable
+          */
-     public void setSelection(FeatureCollection selection) {
+         public void setClickable(final boolean clickable) {
-         this.selection = selection;
+                 this.clickable = clickable;
-         repaint();
+         }
-     }
+         public void mouseMoved(final MouseEvent e) {
-     /* (non-Javadoc)
+         }
-      * @see org.geotools.gui.swing.event.SelectionChangeListener#selectionChanged(org.geotools.gui.swing.event.SelectionChangedEvent)
-      */
+         public FeatureCollection getSelection() {
-     public void selectionChanged(SelectionChangedEvent e) {
+                 return selection;
+         }
-         try {
-             selection = selectionLayer.getFeatureSource().getFeatures(e.getFilter());
+         public void setSelection(final FeatureCollection selection) {
-             repaint();
+                 this.selection = selection;
-         } catch (IOException e1) {
+                 repaint();
-             e1.printStackTrace();
+         }
-         }
-     }
+         /*
+          * (non-Javadoc)
-     public SelectionManager getSelectionManager() {
+          *
-         return selectionManager;
+          * @see
-     }
+          * org.geotools.gui.swing.event.SelectionChangeListener#selectionChanged
+          * (org.geotools.gui.swing.event.SelectionChangedEvent)
-     public void setSelectionManager(SelectionManager selectionManager) {
+          */
-         this.selectionManager = selectionManager;
+         public void selectionChanged(final SelectionChangedEvent e) {
-         this.selectionManager.addSelectionChangeListener(this);
+                 try {
-     }
+                         selection = selectionLayer.getFeatureSource().getFeatures(
+                                         e.getFilter());
+                         repaint();
- //xulu.sn
+                 } catch (final IOException e1) {
-     /**
+                         e1.printStackTrace();
-      * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste erlaubte Flaeche damit
+                 }
-      * die Massstabsbeschaenkungen noch eingehalten werden, FALLS der uebergeben Envelope
+         }
-      * nicht schon gueltig sein sollte.
-      *
+         public SelectionManager getSelectionManager() {
-      * @author <a href="mailto:[email protected]">Stefan Alfons Kr&uuml;ger</a>
+                 return selectionManager;
-      */
+         }
-   public Envelope bestAllowedMapArea(Envelope env) {
-     if (getWidth() == 0) return env;
+         public void setSelectionManager(final SelectionManager selectionManager) {
-     if (env == null) return env;
+                 this.selectionManager = selectionManager;
+                 this.selectionManager.addSelectionChangeListener(this);
-     double scale = env.getWidth() / getWidth();
-     double centerX = env.getMinX() + env.getWidth() / 2.;
+         }
-     double centerY = env.getMinY() + env.getHeight() / 2.;
-     double newWidth2;
+         // xulu.sn
-     double newHeight2;
+         /**
-     if (scale < getMaxZoomScale()) {
+          * Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste
-       //****************************************************************************
+          * erlaubte Flaeche damit die Massstabsbeschaenkungen noch eingehalten
-       // Wir zoomen weiter rein als erlaubt => Anpassen des envelope
+          * werden, FALLS der uebergeben Envelope nicht schon gueltig sein sollte.<br/>
-       //****************************************************************************
+          * Since 21. April 09: Before thecalculation starts, the aspect ratio is
-       newWidth2 = getMaxZoomScale() * getWidth() / 2.;
+          * corrected. This change implies, that setMapArea() will most of the time
-       newHeight2 = getMaxZoomScale() * getHeight() / 2.;
+          * not allow setting to a wrong aspectRatio.
-     } else if (scale > getMinZoomScale()) {
+          *
-       //****************************************************************************
+          * @author <a href="mailto:[email protected]">Stefan Alfons
-       // Wir zoomen weiter raus als erlaubt => Anpassen des envelope
+          *         Kr&uuml;ger</a>
-       //****************************************************************************
+          */
-       newWidth2 = getMinZoomScale() * getWidth() / 2.;
+         public Envelope bestAllowedMapArea(Envelope env) {
-       newHeight2 = getMinZoomScale() * getHeight() / 2.;
+                 if (getWidth() == 0)
-     } else {
+                         return env;
-       //****************************************************************************
+                 if (env == null)
-       // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
+                         return env;
-       //****************************************************************************
-       return env;
+                 /**
-     }
+                  * Correct the aspect Ratio before we check the rest. Otherwise we might
+                  * easily fail.
-     Coordinate ll = new Coordinate(centerX - newWidth2, centerY
+                  */
-                                    - newHeight2);
+                 env = fixAspectRatio(this.getBounds(), env);
-     Coordinate ur = new Coordinate(centerX + newWidth2, centerY
-                                    + newHeight2);
+                 final double scale = env.getWidth() / getWidth();
+                 final double centerX = env.getMinX() + env.getWidth() / 2.;
-     return new Envelope(ll, ur);
+                 final double centerY = env.getMinY() + env.getHeight() / 2.;
-   }
+                 double newWidth2;
+                 double newHeight2;
-   /**
+                 if (scale < getMaxZoomScale()) {
-    * Retuns the minimum allowed zoom scale. This is the bigger number value of the two.
+                         // ****************************************************************************
-    * Defaults to {@link Double}.MAX_VALUE
+                         // Wir zoomen weiter rein als erlaubt => Anpassen des envelope
-    *
+                         // ****************************************************************************
-    * @author <a href="mailto:[email protected]">Stefan Alfons Kr&uuml;ger</a>
+                         newWidth2 = getMaxZoomScale() * getWidth() / 2.;
-    */
+                         newHeight2 = getMaxZoomScale() * getHeight() / 2.;
-   public Double getMinZoomScale() {
+                 } else if (scale > getMinZoomScale()) {
-     return minZoomScale;
+                         // ****************************************************************************
-   }
+                         // Wir zoomen weiter raus als erlaubt => Anpassen des envelope
+                         // ****************************************************************************
-   /**
+                         newWidth2 = getMinZoomScale() * getWidth() / 2.;
-    * Retuns the maximum allowed zoom scale. This is the smaller number value of the two.
+                         newHeight2 = getMinZoomScale() * getHeight() / 2.;
-    * Defaults to {@link Double}.MIN_VALUE
+                 } else {
-    *
+                         // ****************************************************************************
-    * @author <a href="mailto:[email protected]">Stefan Alfons Kr&uuml;ger</a>
+                         // Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen
-    */
+                         // ****************************************************************************
-   public Double getMaxZoomScale() {
+                         return env;
-     return maxZoomScale;
+                 }
-   }
+                 final Coordinate ll = new Coordinate(centerX - newWidth2, centerY
-   /**
+                                 - newHeight2);
-    * Set the maximum allowed zoom scale. This is the smaller number value of the two.
+                 final Coordinate ur = new Coordinate(centerX + newWidth2, centerY
-    *
+                                 + newHeight2);
-    * @author <a href="mailto:[email protected]">Stefan Alfons Kr&uuml;ger</a>
-    */
+                 return new Envelope(ll, ur);
-   public void setMaxZoomScale(Double maxZoomScale) {
+         }
-     // System.out.println("setting max scale to "+maxZoomScale);
-     this.maxZoomScale = maxZoomScale;
+         /**
-   }
+          * Retuns the minimum allowed zoom scale. This is the bigger number value of
+          * the two. Defaults to {@link Double}.MAX_VALUE
-   /**
+          *
-    * Set the minimum (nearest) allowed zoom scale. This is the bigger number value of the two.
+          * @author <a href="mailto:[email protected]">Stefan Alfons
-    *
+          *         Kr&uuml;ger</a>
-    * @author <a href="mailto:[email protected]">Stefan Alfons Kr&uuml;ger</a>
+          */
-    */
+         public Double getMinZoomScale() {
-   public void setMinZoomScale(Double minZoomScale) {
+                 return minZoomScale;
-     this.minZoomScale = minZoomScale;
+         }
-   }
- //xulu.en
+         /**
+          * Retuns the maximum allowed zoom scale. This is the smaller number value
+          * of the two. Defaults to {@link Double}.MIN_VALUE
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public Double getMaxZoomScale() {
+                 return maxZoomScale;
+         }
+         /**
+          * Set the maximum allowed zoom scale. This is the smaller number value of
+          * the two.
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public void setMaxZoomScale(final Double maxZoomScale) {
+                 // System.out.println("setting max scale to "+maxZoomScale);
+                 this.maxZoomScale = maxZoomScale;
+         }
+         /**
+          * Set the minimum (nearest) allowed zoom scale. This is the bigger number
+          * value of the two.
+          *
+          * @author <a href="mailto:[email protected]">Stefan Alfons
+          *         Kr&uuml;ger</a>
+          */
+         public void setMinZoomScale(final Double minZoomScale) {
+                 this.minZoomScale = minZoomScale;
+         }
+         // xulu.en
  }

 Legend:



Removed from v.2
 


changed lines


 
Added in v.318
 Legend:



Removed from v.2
 


changed lines


 
Added in v.318
-Removed from v.2
+Added in v.318

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26