| 1 |
/* |
| 2 |
* GeoTools - OpenSource mapping toolkit |
| 3 |
* http://geotools.org |
| 4 |
* (C) 2002-2006, GeoTools Project Managment Committee (PMC) |
| 5 |
* |
| 6 |
* This library is free software; you can redistribute it and/or |
| 7 |
* modify it under the terms of the GNU Lesser General Public |
| 8 |
* License as published by the Free Software Foundation; |
| 9 |
* version 2.1 of the License. |
| 10 |
* |
| 11 |
* This library is distributed in the hope that it will be useful, |
| 12 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 14 |
* Lesser General Public License for more details. |
| 15 |
*/ |
| 16 |
package gtmig.org.geotools.swing; |
| 17 |
|
| 18 |
/** |
| 19 |
* <b>Xulu:<br> |
| 20 |
* Code taken from gt-2.4.5 to make some changes (marked with {@code xulu}), |
| 21 |
* which can not be realized in a subclass:</b> |
| 22 |
* <ul> |
| 23 |
* <li>{@link #getMapArea()} declared as {@code final}<li> |
| 24 |
* <li>some variables declared as {@code protected}</li> |
| 25 |
* <li>minimal/maximal zoom scale</li> |
| 26 |
* <li>zoom in and zoom out via mouse click realized by setMapArea(..)</li> |
| 27 |
* </ul> |
| 28 |
* <br><br> |
| 29 |
* A simple map container that is a JPanel with a map in. provides simple |
| 30 |
* pan,zoom, highlight and selection The mappane stores an image of the map |
| 31 |
* (drawn from the context) and an image of the slected feature(s) to speed up |
| 32 |
* rendering of the highlights. Thus the whole map is only redrawn when the bbox |
| 33 |
* changes, selection is only redrawn when the selected feature changes. |
| 34 |
* |
| 35 |
* |
| 36 |
* @author Ian Turton |
| 37 |
* |
| 38 |
*/ |
| 39 |
|
| 40 |
import java.awt.Color; |
| 41 |
import java.awt.Cursor; |
| 42 |
import java.awt.Graphics; |
| 43 |
import java.awt.Graphics2D; |
| 44 |
import java.awt.LayoutManager; |
| 45 |
import java.awt.Rectangle; |
| 46 |
import java.awt.event.InputEvent; |
| 47 |
import java.awt.event.MouseEvent; |
| 48 |
import java.awt.event.MouseListener; |
| 49 |
import java.awt.event.MouseMotionListener; |
| 50 |
import java.awt.image.BufferedImage; |
| 51 |
import java.beans.PropertyChangeEvent; |
| 52 |
import java.beans.PropertyChangeListener; |
| 53 |
import java.io.IOException; |
| 54 |
import java.util.Date; |
| 55 |
import java.util.HashMap; |
| 56 |
import java.util.Map; |
| 57 |
|
| 58 |
import javax.swing.JPanel; |
| 59 |
|
| 60 |
import org.apache.log4j.Logger; |
| 61 |
import org.geotools.map.MapContext; |
| 62 |
import org.geotools.map.event.MapLayerListEvent; |
| 63 |
import org.geotools.map.event.MapLayerListListener; |
| 64 |
import org.geotools.renderer.GTRenderer; |
| 65 |
import org.geotools.renderer.label.LabelCacheImpl; |
| 66 |
import org.geotools.renderer.lite.LabelCache; |
| 67 |
import org.geotools.renderer.lite.StreamingRenderer; |
| 68 |
import org.opengis.filter.FilterFactory2; |
| 69 |
import org.opengis.referencing.crs.CoordinateReferenceSystem; |
| 70 |
|
| 71 |
import schmitzm.geotools.JTSUtil; |
| 72 |
import schmitzm.swing.SwingUtil; |
| 73 |
|
| 74 |
import com.vividsolutions.jts.geom.Coordinate; |
| 75 |
import com.vividsolutions.jts.geom.Envelope; |
| 76 |
import com.vividsolutions.jts.geom.GeometryFactory; |
| 77 |
|
| 78 |
public class JMapPane extends JPanel implements MouseListener, |
| 79 |
MouseMotionListener, PropertyChangeListener, MapLayerListListener { |
| 80 |
private static Logger LOGGER = Logger.getLogger(JMapPane.class); |
| 81 |
|
| 82 |
private static final long serialVersionUID = -8647971481359690499L; |
| 83 |
|
| 84 |
public static final int Reset = 0; |
| 85 |
|
| 86 |
public static final int ZoomIn = 1; |
| 87 |
|
| 88 |
public static final int ZoomOut = 2; |
| 89 |
|
| 90 |
public static final int Pan = 3; |
| 91 |
|
| 92 |
public static final int Select = 4; |
| 93 |
|
| 94 |
/** |
| 95 |
* what renders the map |
| 96 |
*/ |
| 97 |
GTRenderer renderer; |
| 98 |
|
| 99 |
/** |
| 100 |
* the map context to render |
| 101 |
*/ |
| 102 |
MapContext context; |
| 103 |
|
| 104 |
/** |
| 105 |
* the area of the map to draw |
| 106 |
*/ |
| 107 |
protected Envelope mapArea; |
| 108 |
|
| 109 |
/** |
| 110 |
* the size of the pane last time we drew |
| 111 |
*/ |
| 112 |
protected Rectangle oldRect = null; |
| 113 |
|
| 114 |
/** |
| 115 |
* the last map area drawn. |
| 116 |
*/ |
| 117 |
protected Envelope oldMapArea = null; |
| 118 |
|
| 119 |
/** |
| 120 |
* the base image of the map |
| 121 |
*/ |
| 122 |
protected BufferedImage baseImage, panningImage; |
| 123 |
|
| 124 |
/** |
| 125 |
* a factory for filters |
| 126 |
*/ |
| 127 |
FilterFactory2 ff; |
| 128 |
|
| 129 |
/** |
| 130 |
* a factory for geometries |
| 131 |
*/ |
| 132 |
GeometryFactory gf = new GeometryFactory(); // FactoryFinder.getGeometryFactory(null); |
| 133 |
|
| 134 |
private int state = ZoomIn; |
| 135 |
|
| 136 |
/** |
| 137 |
* how far to zoom in or out |
| 138 |
*/ |
| 139 |
private double zoomFactor = 2.0; |
| 140 |
|
| 141 |
boolean changed = true; |
| 142 |
|
| 143 |
LabelCache labelCache = new LabelCacheImpl(); |
| 144 |
|
| 145 |
protected boolean reset = false; |
| 146 |
|
| 147 |
int startX; |
| 148 |
|
| 149 |
int startY; |
| 150 |
|
| 151 |
/** |
| 152 |
* If not <code>null</code>, the {@link JMapPane} will not allow to zoom/pan |
| 153 |
* out of that area |
| 154 |
**/ |
| 155 |
private Envelope maxExtend = null; |
| 156 |
|
| 157 |
// /** |
| 158 |
// * Is max. 1 or 0 of the 2 axised allowed to extend the maxExtend? If |
| 159 |
// * <code>true</code> the extends has to be fully inside maxExtend |
| 160 |
// **/ |
| 161 |
// boolean maxExtendForceMode = true; |
| 162 |
|
| 163 |
private boolean clickable; |
| 164 |
|
| 165 |
int lastX; |
| 166 |
|
| 167 |
int lastY; |
| 168 |
|
| 169 |
private Double maxZoomScale = Double.MIN_VALUE; |
| 170 |
private Double minZoomScale = Double.MAX_VALUE; |
| 171 |
|
| 172 |
/** |
| 173 |
* Wenn true, dann wurde PANNING via mouseDraged-Events begonnen. Dieses |
| 174 |
* Flag wird benutzt um nur einmal den passenden Cursor nur einmal zu |
| 175 |
* setzen. |
| 176 |
*/ |
| 177 |
private boolean panning_started = false; |
| 178 |
|
| 179 |
public JMapPane() { |
| 180 |
this(null, true, null, null); |
| 181 |
} |
| 182 |
|
| 183 |
/** |
| 184 |
* create a basic JMapPane |
| 185 |
* |
| 186 |
* @param render |
| 187 |
* - how to draw the map |
| 188 |
* @param context |
| 189 |
* - the map context to display |
| 190 |
*/ |
| 191 |
public JMapPane(final GTRenderer render, final MapContext context) { |
| 192 |
this(null, true, render, context); |
| 193 |
} |
| 194 |
|
| 195 |
/** |
| 196 |
* full constructor extending JPanel |
| 197 |
* |
| 198 |
* @param layout |
| 199 |
* - layout (probably shouldn't be set) |
| 200 |
* @param isDoubleBuffered |
| 201 |
* - a Swing thing I don't really understand |
| 202 |
* @param render |
| 203 |
* - what to draw the map with |
| 204 |
* @param context |
| 205 |
* - what to draw |
| 206 |
*/ |
| 207 |
public JMapPane(final LayoutManager layout, final boolean isDoubleBuffered, |
| 208 |
final GTRenderer render, final MapContext context) { |
| 209 |
super(layout, isDoubleBuffered); |
| 210 |
|
| 211 |
ff = (FilterFactory2) org.geotools.factory.CommonFactoryFinder |
| 212 |
.getFilterFactory(null); |
| 213 |
setRenderer(render); |
| 214 |
|
| 215 |
setContext(context); |
| 216 |
|
| 217 |
this.addMouseListener(this); |
| 218 |
this.addMouseMotionListener(this); |
| 219 |
setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR)); |
| 220 |
} |
| 221 |
|
| 222 |
/** |
| 223 |
* get the renderer |
| 224 |
*/ |
| 225 |
public GTRenderer getRenderer() { |
| 226 |
return renderer; |
| 227 |
} |
| 228 |
|
| 229 |
public void setRenderer(final GTRenderer renderer) { |
| 230 |
Map<Object, Object> hints = new HashMap<Object, Object>(); |
| 231 |
|
| 232 |
this.renderer = renderer; |
| 233 |
// MS: Apply hint also for ShapeFileRenderer |
| 234 |
// if (renderer instanceof StreamingRenderer) { |
| 235 |
hints = renderer.getRendererHints(); |
| 236 |
if (hints == null) { |
| 237 |
hints = new HashMap<Object, Object>(); |
| 238 |
} |
| 239 |
if (hints.containsKey(StreamingRenderer.LABEL_CACHE_KEY)) { |
| 240 |
labelCache = (LabelCache) hints |
| 241 |
.get(StreamingRenderer.LABEL_CACHE_KEY); |
| 242 |
} else { |
| 243 |
hints.put(StreamingRenderer.LABEL_CACHE_KEY, labelCache); |
| 244 |
} |
| 245 |
|
| 246 |
hints.put("memoryPreloadingEnabled", Boolean.TRUE); |
| 247 |
|
| 248 |
renderer.setRendererHints(hints); |
| 249 |
// } |
| 250 |
|
| 251 |
if (this.context != null) { |
| 252 |
this.renderer.setContext(this.context); |
| 253 |
} |
| 254 |
} |
| 255 |
|
| 256 |
public MapContext getContext() { |
| 257 |
return context; |
| 258 |
} |
| 259 |
|
| 260 |
public void setContext(final MapContext context) { |
| 261 |
if (this.context != null) { |
| 262 |
this.context.removeMapLayerListListener(this); |
| 263 |
} |
| 264 |
|
| 265 |
this.context = context; |
| 266 |
|
| 267 |
if (context != null) { |
| 268 |
this.context.addMapLayerListListener(this); |
| 269 |
} |
| 270 |
|
| 271 |
if (renderer != null) { |
| 272 |
renderer.setContext(this.context); |
| 273 |
} |
| 274 |
} |
| 275 |
|
| 276 |
public Envelope getMapArea() { |
| 277 |
return mapArea; |
| 278 |
} |
| 279 |
|
| 280 |
public void setMapArea(final Envelope mapArea) { |
| 281 |
this.mapArea = mapArea; |
| 282 |
} |
| 283 |
|
| 284 |
public int getState() { |
| 285 |
return state; |
| 286 |
} |
| 287 |
|
| 288 |
public void setState(final int state) { |
| 289 |
this.state = state; |
| 290 |
|
| 291 |
// System.out.println("State: " + state); |
| 292 |
} |
| 293 |
|
| 294 |
public double getZoomFactor() { |
| 295 |
return zoomFactor; |
| 296 |
} |
| 297 |
|
| 298 |
public void setZoomFactor(final double zoomFactor) { |
| 299 |
this.zoomFactor = zoomFactor; |
| 300 |
} |
| 301 |
|
| 302 |
protected void paintComponent(final Graphics g) { |
| 303 |
super.paintComponent(g); |
| 304 |
|
| 305 |
if ((renderer == null) || (mapArea == null)) { |
| 306 |
return; |
| 307 |
} |
| 308 |
|
| 309 |
final Rectangle r = getBounds(); |
| 310 |
final Rectangle dr = new Rectangle(r.width, r.height); |
| 311 |
|
| 312 |
if (!r.equals(oldRect) || reset) { |
| 313 |
if (!r.equals(oldRect) && (mapArea == null)) { |
| 314 |
try { |
| 315 |
mapArea = context.getLayerBounds(); |
| 316 |
} catch (final IOException e) { |
| 317 |
LOGGER.warn("context.getLayerBounds()", e); |
| 318 |
} |
| 319 |
} |
| 320 |
|
| 321 |
if (mapArea != null) { |
| 322 |
/* either the viewer size has changed or we've done a reset */ |
| 323 |
changed = true; /* note we need to redraw */ |
| 324 |
reset = false; /* forget about the reset */ |
| 325 |
oldRect = r; /* store what the current size is */ |
| 326 |
|
| 327 |
mapArea = JTSUtil.fixAspectRatio(r, mapArea, false); |
| 328 |
} |
| 329 |
} |
| 330 |
|
| 331 |
if (!mapArea.equals(oldMapArea)) { /* did the map extent change? */ |
| 332 |
changed = true; |
| 333 |
oldMapArea = mapArea; |
| 334 |
// when we tell the context that the bounds have changed WMSLayers |
| 335 |
// can refresh them selves |
| 336 |
context.setAreaOfInterest(mapArea, context |
| 337 |
.getCoordinateReferenceSystem()); |
| 338 |
} |
| 339 |
|
| 340 |
if (changed) { /* if the map changed then redraw */ |
| 341 |
changed = false; |
| 342 |
baseImage = new BufferedImage(dr.width, dr.height, |
| 343 |
BufferedImage.TYPE_INT_ARGB); |
| 344 |
|
| 345 |
final Graphics2D ig = baseImage.createGraphics(); |
| 346 |
/* System.out.println("rendering"); */ |
| 347 |
if (renderer.getContext() != null) |
| 348 |
renderer.setContext(context); |
| 349 |
labelCache.clear(); // work around anoying labelcache bug |
| 350 |
|
| 351 |
// draw the map |
| 352 |
renderer.paint((Graphics2D) ig, dr, mapArea); |
| 353 |
|
| 354 |
// TODO nur machen, wenn panning beginnt |
| 355 |
panningImage = new BufferedImage(dr.width, dr.height, |
| 356 |
BufferedImage.TYPE_INT_RGB); |
| 357 |
|
| 358 |
} |
| 359 |
|
| 360 |
((Graphics2D) g).drawImage(baseImage, 0, 0, this); |
| 361 |
} |
| 362 |
|
| 363 |
public void mouseClicked(final MouseEvent e) { |
| 364 |
if (mapArea == null) |
| 365 |
return; |
| 366 |
// System.out.println("before area "+mapArea+"\nw:"+mapArea.getWidth()+" |
| 367 |
// h:"+mapArea.getHeight()); |
| 368 |
final Rectangle bounds = this.getBounds(); |
| 369 |
final double x = (double) (e.getX()); |
| 370 |
final double y = (double) (e.getY()); |
| 371 |
final double width = mapArea.getWidth(); |
| 372 |
final double height = mapArea.getHeight(); |
| 373 |
// xulu.sc |
| 374 |
// double width2 = mapArea.getWidth() / 2.0; |
| 375 |
// double height2 = mapArea.getHeight() / 2.0; |
| 376 |
final double width2 = width / 2.0; |
| 377 |
final double height2 = height / 2.0; |
| 378 |
// xulu.ec |
| 379 |
final double mapX = ((x * width) / (double) bounds.width) |
| 380 |
+ mapArea.getMinX(); |
| 381 |
final double mapY = (((bounds.getHeight() - y) * height) / (double) bounds.height) |
| 382 |
+ mapArea.getMinY(); |
| 383 |
|
| 384 |
/* |
| 385 |
* System.out.println(""+x+"->"+mapX); |
| 386 |
* System.out.println(""+y+"->"+mapY); |
| 387 |
*/ |
| 388 |
|
| 389 |
/* |
| 390 |
* Coordinate ll = new Coordinate(mapArea.getMinX(), mapArea.getMinY()); |
| 391 |
* Coordinate ur = new Coordinate(mapArea.getMaxX(), mapArea.getMaxY()); |
| 392 |
*/ |
| 393 |
double zlevel = 1.0; |
| 394 |
|
| 395 |
switch (state) { |
| 396 |
case Pan: |
| 397 |
zlevel = 1.0; |
| 398 |
// xulu.sc SK: return here.. a mouselistener is managing the PANNING |
| 399 |
// break; |
| 400 |
return; |
| 401 |
// xulu.ec |
| 402 |
case ZoomIn: |
| 403 |
zlevel = zoomFactor; |
| 404 |
|
| 405 |
break; |
| 406 |
|
| 407 |
case ZoomOut: |
| 408 |
zlevel = 1.0 / zoomFactor; |
| 409 |
|
| 410 |
break; |
| 411 |
// |
| 412 |
// case Select: |
| 413 |
// doSelection(mapX, mapY, selectionLayer); |
| 414 |
// |
| 415 |
// return; |
| 416 |
|
| 417 |
default: |
| 418 |
return; |
| 419 |
} |
| 420 |
|
| 421 |
final Coordinate ll = new Coordinate(mapX - (width2 / zlevel), mapY |
| 422 |
- (height2 / zlevel)); |
| 423 |
final Coordinate ur = new Coordinate(mapX + (width2 / zlevel), mapY |
| 424 |
+ (height2 / zlevel)); |
| 425 |
// xulu.sc SK: Check for min/max scale |
| 426 |
// mapArea = new Envelope(ll, ur); |
| 427 |
final Envelope newMapArea = new Envelope(ll, ur); |
| 428 |
setMapArea(bestAllowedMapArea(newMapArea)); |
| 429 |
// xulu.ec |
| 430 |
|
| 431 |
// sk.ec |
| 432 |
|
| 433 |
// System.out.println("after area "+mapArea+"\nw:"+mapArea.getWidth()+" |
| 434 |
// h:"+mapArea.getHeight()); |
| 435 |
repaint(); |
| 436 |
} |
| 437 |
|
| 438 |
public void mouseEntered(final MouseEvent e) { |
| 439 |
} |
| 440 |
|
| 441 |
public void mouseExited(final MouseEvent e) { |
| 442 |
} |
| 443 |
|
| 444 |
public void mousePressed(final MouseEvent e) { |
| 445 |
startX = e.getX(); |
| 446 |
startY = e.getY(); |
| 447 |
lastX = 0; |
| 448 |
lastY = 0; |
| 449 |
} |
| 450 |
|
| 451 |
public void mouseReleased(final MouseEvent e) { |
| 452 |
final int endX = e.getX(); |
| 453 |
final int endY = e.getY(); |
| 454 |
|
| 455 |
processDrag(startX, startY, endX, endY, e); |
| 456 |
lastX = 0; |
| 457 |
lastY = 0; |
| 458 |
|
| 459 |
/** |
| 460 |
* Es wird nicht (mehr) gepannt! |
| 461 |
*/ |
| 462 |
panning_started = false; |
| 463 |
} |
| 464 |
|
| 465 |
public void mouseDragged(final MouseEvent e) { |
| 466 |
final Graphics graphics = this.getGraphics(); |
| 467 |
final int x = e.getX(); |
| 468 |
final int y = e.getY(); |
| 469 |
|
| 470 |
if ((state == JMapPane.Pan) |
| 471 |
|| ((e.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0)) { |
| 472 |
/** |
| 473 |
* SK: Der Cursor wird auf PANNING gesetzt. |
| 474 |
*/ |
| 475 |
if (panning_started == false) { |
| 476 |
panning_started = true; |
| 477 |
setCursor(SwingUtil.PANNING_CURSOR); |
| 478 |
} |
| 479 |
|
| 480 |
// move the image with the mouse |
| 481 |
if ((lastX > 0) && (lastY > 0)) { |
| 482 |
final int dx = lastX - startX; |
| 483 |
final int dy = lastY - startY; |
| 484 |
// System.out.println("translate "+dx+","+dy); |
| 485 |
final Graphics2D g2 = panningImage.createGraphics(); |
| 486 |
g2.setBackground(new Color(240, 240, 240)); // TODO richtige |
| 487 |
// farbe? am besten |
| 488 |
// vom L&F die |
| 489 |
// hintergrundfarbe |
| 490 |
// auslesen... |
| 491 |
|
| 492 |
g2.clearRect(0, 0, this.getWidth(), this.getHeight()); |
| 493 |
g2.drawImage(baseImage, dx, dy, this); |
| 494 |
graphics.drawImage(panningImage, 0, 0, this); |
| 495 |
} |
| 496 |
|
| 497 |
lastX = x; |
| 498 |
lastY = y; |
| 499 |
} else |
| 500 |
|
| 501 |
if ((state == JMapPane.ZoomIn) || (state == JMapPane.ZoomOut)) { |
| 502 |
|
| 503 |
graphics.setXORMode(Color.WHITE); |
| 504 |
|
| 505 |
if ((lastX > 0) && (lastY > 0)) { |
| 506 |
drawRectangle(graphics); |
| 507 |
} |
| 508 |
|
| 509 |
// draw new box |
| 510 |
lastX = x; |
| 511 |
lastY = y; |
| 512 |
drawRectangle(graphics); |
| 513 |
} |
| 514 |
// else if (state == JMapPane.Select && selectionLayer != null) { |
| 515 |
// |
| 516 |
// // construct a new bbox filter |
| 517 |
// final Rectangle bounds = this.getBounds(); |
| 518 |
// |
| 519 |
// final double mapWidth = mapArea.getWidth(); |
| 520 |
// final double mapHeight = mapArea.getHeight(); |
| 521 |
// |
| 522 |
// final double x1 = ((this.startX * mapWidth) / (double) bounds.width) |
| 523 |
// + mapArea.getMinX(); |
| 524 |
// final double y1 = (((bounds.getHeight() - this.startY) * mapHeight) / |
| 525 |
// (double) bounds.height) |
| 526 |
// + mapArea.getMinY(); |
| 527 |
// final double x2 = ((x * mapWidth) / (double) bounds.width) |
| 528 |
// + mapArea.getMinX(); |
| 529 |
// final double y2 = (((bounds.getHeight() - y) * mapHeight) / (double) |
| 530 |
// bounds.height) |
| 531 |
// + mapArea.getMinY(); |
| 532 |
// final double left = Math.min(x1, x2); |
| 533 |
// final double right = Math.max(x1, x2); |
| 534 |
// final double bottom = Math.min(y1, y2); |
| 535 |
// final double top = Math.max(y1, y2); |
| 536 |
// |
| 537 |
// String name = selectionLayer.getFeatureSource().getSchema() |
| 538 |
// .getDefaultGeometry().getName(); |
| 539 |
// |
| 540 |
// if (name == "") { |
| 541 |
// name = "the_geom"; |
| 542 |
// } |
| 543 |
// final Filter bb = ff.bbox(ff.property(name), left, bottom, right, |
| 544 |
// top, |
| 545 |
// getContext().getCoordinateReferenceSystem().toString()); |
| 546 |
// if (selectionManager != null) { |
| 547 |
// selectionManager.selectionChanged(this, bb); |
| 548 |
// } |
| 549 |
// |
| 550 |
// graphics.setXORMode(Color.green); |
| 551 |
// |
| 552 |
// /* |
| 553 |
// * if ((lastX > 0) && (lastY > 0)) { drawRectangle(graphics); } |
| 554 |
// */ |
| 555 |
// |
| 556 |
// // draw new box |
| 557 |
// lastX = x; |
| 558 |
// lastY = y; |
| 559 |
// drawRectangle(graphics); |
| 560 |
// } |
| 561 |
|
| 562 |
} |
| 563 |
|
| 564 |
// sk.cs |
| 565 |
// private void processDrag(int x1, int y1, int x2, int y2) { |
| 566 |
// sk.ce |
| 567 |
protected void processDrag(final int x1, final int y1, final int x2, |
| 568 |
final int y2, final MouseEvent e) { |
| 569 |
|
| 570 |
/**** |
| 571 |
* If no layers exist, we ignore the drag. |
| 572 |
*/ |
| 573 |
if (context.getLayerCount() <= 0) { |
| 574 |
return; |
| 575 |
} |
| 576 |
|
| 577 |
// System.out.println("processing drag from " + x1 + "," + y1 + " -> " |
| 578 |
// + x2 + "," + y2); |
| 579 |
if ((x1 == x2) && (y1 == y2)) { |
| 580 |
if (isClickable()) { |
| 581 |
mouseClicked(new MouseEvent(this, 0, new Date().getTime(), 0, |
| 582 |
x1, y1, y2, false)); |
| 583 |
} |
| 584 |
|
| 585 |
return; |
| 586 |
} |
| 587 |
|
| 588 |
final Rectangle bounds = this.getBounds(); |
| 589 |
|
| 590 |
final double mapWidth = mapArea.getWidth(); |
| 591 |
final double mapHeight = mapArea.getHeight(); |
| 592 |
|
| 593 |
final double startX = ((x1 * mapWidth) / (double) bounds.width) |
| 594 |
+ mapArea.getMinX(); |
| 595 |
final double startY = (((bounds.getHeight() - y1) * mapHeight) / (double) bounds.height) |
| 596 |
+ mapArea.getMinY(); |
| 597 |
final double endX = ((x2 * mapWidth) / (double) bounds.width) |
| 598 |
+ mapArea.getMinX(); |
| 599 |
final double endY = (((bounds.getHeight() - y2) * mapHeight) / (double) bounds.height) |
| 600 |
+ mapArea.getMinY(); |
| 601 |
|
| 602 |
if ((state == JMapPane.Pan) || (e.getButton() == MouseEvent.BUTTON3)) { |
| 603 |
// move the image with the mouse |
| 604 |
// calculate X offsets from start point to the end Point |
| 605 |
final double deltaX1 = endX - startX; |
| 606 |
|
| 607 |
// System.out.println("deltaX " + deltaX1); |
| 608 |
// new edges |
| 609 |
final double left = mapArea.getMinX() - deltaX1; |
| 610 |
final double right = mapArea.getMaxX() - deltaX1; |
| 611 |
|
| 612 |
// now for Y |
| 613 |
final double deltaY1 = endY - startY; |
| 614 |
|
| 615 |
// System.out.println("deltaY " + deltaY1); |
| 616 |
final double bottom = mapArea.getMinY() - deltaY1; |
| 617 |
final double top = mapArea.getMaxY() - deltaY1; |
| 618 |
final Coordinate ll = new Coordinate(left, bottom); |
| 619 |
final Coordinate ur = new Coordinate(right, top); |
| 620 |
// xulu.sc |
| 621 |
// mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur)); |
| 622 |
|
| 623 |
setMapArea(bestAllowedMapArea(new Envelope(ll, ur))); |
| 624 |
// xulu.ec |
| 625 |
} else if (state == JMapPane.ZoomIn) { |
| 626 |
|
| 627 |
// Zu kleine Flächen sollen nicht gezoomt werden. |
| 628 |
// sk.bc |
| 629 |
if ((Math.abs(x1 - x2) * Math.abs(y2 - y1)) < 150) |
| 630 |
return; |
| 631 |
// sk.ec |
| 632 |
|
| 633 |
drawRectangle(this.getGraphics()); |
| 634 |
// make the dragged rectangle (in map coords) the new BBOX |
| 635 |
final double left = Math.min(startX, endX); |
| 636 |
final double right = Math.max(startX, endX); |
| 637 |
final double bottom = Math.min(startY, endY); |
| 638 |
final double top = Math.max(startY, endY); |
| 639 |
final Coordinate ll = new Coordinate(left, bottom); |
| 640 |
final Coordinate ur = new Coordinate(right, top); |
| 641 |
// xulu.sc |
| 642 |
|
| 643 |
// mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur)); |
| 644 |
setMapArea(bestAllowedMapArea(new Envelope(ll, ur))); |
| 645 |
|
| 646 |
// sk.sc |
| 647 |
// { |
| 648 |
// // SK tries to paint a preview of the zoom ;-9 aha.... well |
| 649 |
// Graphics2D graphics = (Graphics2D) JMapPane.this.getGraphics(); |
| 650 |
// graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, |
| 651 |
// RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR); |
| 652 |
// graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, |
| 653 |
// RenderingHints.VALUE_ANTIALIAS_OFF); |
| 654 |
// graphics.setRenderingHint(RenderingHints.KEY_RENDERING, |
| 655 |
// RenderingHints.VALUE_RENDER_SPEED); |
| 656 |
// graphics.drawImage(baseImage, 0, 0, JMapPane.this.getWidth(), |
| 657 |
// JMapPane.this.getHeight(), x1, y1, x2, y2, null); |
| 658 |
// } |
| 659 |
// xulu.ec |
| 660 |
} else if (state == JMapPane.ZoomOut) { |
| 661 |
drawRectangle(this.getGraphics()); |
| 662 |
|
| 663 |
// make the dragged rectangle in screen coords the new map size? |
| 664 |
final double left = Math.min(startX, endX); |
| 665 |
final double right = Math.max(startX, endX); |
| 666 |
final double bottom = Math.min(startY, endY); |
| 667 |
final double top = Math.max(startY, endY); |
| 668 |
final double nWidth = (mapWidth * mapWidth) / (right - left); |
| 669 |
final double nHeight = (mapHeight * mapHeight) / (top - bottom); |
| 670 |
final double deltaX1 = left - mapArea.getMinX(); |
| 671 |
final double nDeltaX1 = (deltaX1 * nWidth) / mapWidth; |
| 672 |
final double deltaY1 = bottom - mapArea.getMinY(); |
| 673 |
final double nDeltaY1 = (deltaY1 * nHeight) / mapHeight; |
| 674 |
final Coordinate ll = new Coordinate(mapArea.getMinX() - nDeltaX1, |
| 675 |
mapArea.getMinY() - nDeltaY1); |
| 676 |
final double deltaX2 = mapArea.getMaxX() - right; |
| 677 |
final double nDeltaX2 = (deltaX2 * nWidth) / mapWidth; |
| 678 |
final double deltaY2 = mapArea.getMaxY() - top; |
| 679 |
final double nDeltaY2 = (deltaY2 * nHeight) / mapHeight; |
| 680 |
final Coordinate ur = new Coordinate(mapArea.getMaxX() + nDeltaX2, |
| 681 |
mapArea.getMaxY() + nDeltaY2); |
| 682 |
// xulu.sc |
| 683 |
// mapArea = fixAspectRatio(this.getBounds(), new Envelope(ll, ur)); |
| 684 |
setMapArea(bestAllowedMapArea(new Envelope(ll, ur))); |
| 685 |
|
| 686 |
// xulu.ec |
| 687 |
} |
| 688 |
// else if (state == JMapPane.Select && selectionLayer != null) { |
| 689 |
// final double left = Math.min(startX, endX); |
| 690 |
// final double right = Math.max(startX, endX); |
| 691 |
// final double bottom = Math.min(startY, endY); |
| 692 |
// final double top = Math.max(startY, endY); |
| 693 |
// |
| 694 |
// String name = selectionLayer.getFeatureSource().getSchema() |
| 695 |
// .getDefaultGeometry().getLocalName(); |
| 696 |
// |
| 697 |
// if (name == "") { |
| 698 |
// name = "the_geom"; |
| 699 |
// } |
| 700 |
// final Filter bb = ff.bbox(ff.property(name), left, bottom, right, |
| 701 |
// top, |
| 702 |
// getContext().getCoordinateReferenceSystem().toString()); |
| 703 |
// // System.out.println(bb.toString()); |
| 704 |
// if (selectionManager != null) { |
| 705 |
// selectionManager.selectionChanged(this, bb); |
| 706 |
// } |
| 707 |
// /* |
| 708 |
// * FeatureCollection fc; selection = null; try { fc = |
| 709 |
// * selectionLayer.getFeatureSource().getFeatures(bb); selection = |
| 710 |
// * fc; } catch (IOException e) { e.printStackTrace(); } |
| 711 |
// */ |
| 712 |
// } |
| 713 |
|
| 714 |
// xulu.so |
| 715 |
// setMapArea(mapArea); |
| 716 |
// xulu.eo |
| 717 |
repaint(); |
| 718 |
} |
| 719 |
|
| 720 |
private boolean isClickable() { |
| 721 |
return clickable; |
| 722 |
} |
| 723 |
|
| 724 |
// |
| 725 |
// private org.geotools.styling.Style setupStyle(final int type, final Color |
| 726 |
// color) { |
| 727 |
// final StyleFactory sf = org.geotools.factory.CommonFactoryFinder |
| 728 |
// .getStyleFactory(null); |
| 729 |
// final StyleBuilder sb = new StyleBuilder(); |
| 730 |
// |
| 731 |
// org.geotools.styling.Style s = sf.createStyle(); |
| 732 |
// s.setTitle("selection"); |
| 733 |
// |
| 734 |
// // TODO parameterise the color |
| 735 |
// final PolygonSymbolizer ps = sb.createPolygonSymbolizer(color); |
| 736 |
// ps.setStroke(sb.createStroke(color)); |
| 737 |
// |
| 738 |
// final LineSymbolizer ls = sb.createLineSymbolizer(color); |
| 739 |
// final Graphic h = sb.createGraphic(); |
| 740 |
// h.setMarks(new Mark[] { sb.createMark("square", color) }); |
| 741 |
// |
| 742 |
// final PointSymbolizer pts = sb.createPointSymbolizer(h); |
| 743 |
// |
| 744 |
// // Rule r = sb.createRule(new Symbolizer[]{ps,ls,pts}); |
| 745 |
// switch (type) { |
| 746 |
// case POLYGON: |
| 747 |
// s = sb.createStyle(ps); |
| 748 |
// |
| 749 |
// break; |
| 750 |
// |
| 751 |
// case POINT: |
| 752 |
// s = sb.createStyle(pts); |
| 753 |
// |
| 754 |
// break; |
| 755 |
// |
| 756 |
// case LINE: |
| 757 |
// s = sb.createStyle(ls); |
| 758 |
// } |
| 759 |
// |
| 760 |
// return s; |
| 761 |
// } |
| 762 |
|
| 763 |
public void propertyChange(final PropertyChangeEvent evt) { |
| 764 |
final String prop = evt.getPropertyName(); |
| 765 |
|
| 766 |
if (prop.equalsIgnoreCase("crs")) { |
| 767 |
context.setAreaOfInterest(context.getAreaOfInterest(), |
| 768 |
(CoordinateReferenceSystem) evt.getNewValue()); |
| 769 |
} |
| 770 |
} |
| 771 |
|
| 772 |
public boolean isReset() { |
| 773 |
return reset; |
| 774 |
} |
| 775 |
|
| 776 |
public void setReset(final boolean reset) { |
| 777 |
this.reset = reset; |
| 778 |
} |
| 779 |
|
| 780 |
public void layerAdded(final MapLayerListEvent event) { |
| 781 |
changed = true; |
| 782 |
|
| 783 |
if (context.getLayers().length == 1) { // the first one |
| 784 |
|
| 785 |
try { |
| 786 |
// xulu.sc |
| 787 |
// mapArea = context.getLayerBounds(); |
| 788 |
mapArea = context.getAreaOfInterest(); |
| 789 |
if (mapArea == null) |
| 790 |
mapArea = context.getLayerBounds(); |
| 791 |
// xulu.ec |
| 792 |
} catch (final IOException e) { |
| 793 |
// TODO Auto-generated catch block |
| 794 |
e.printStackTrace(); |
| 795 |
} |
| 796 |
|
| 797 |
reset = true; |
| 798 |
} |
| 799 |
|
| 800 |
repaint(); |
| 801 |
} |
| 802 |
|
| 803 |
public void layerRemoved(final MapLayerListEvent event) { |
| 804 |
changed = true; |
| 805 |
repaint(); |
| 806 |
} |
| 807 |
|
| 808 |
public void layerChanged(final MapLayerListEvent event) { |
| 809 |
changed = true; |
| 810 |
// System.out.println("layer changed - repaint"); |
| 811 |
repaint(); |
| 812 |
} |
| 813 |
|
| 814 |
public void layerMoved(final MapLayerListEvent event) { |
| 815 |
changed = true; |
| 816 |
repaint(); |
| 817 |
} |
| 818 |
|
| 819 |
protected void drawRectangle(final Graphics graphics) { |
| 820 |
// undraw last box/draw new box |
| 821 |
final int left = Math.min(startX, lastX); |
| 822 |
final int right = Math.max(startX, lastX); |
| 823 |
final int top = Math.max(startY, lastY); |
| 824 |
final int bottom = Math.min(startY, lastY); |
| 825 |
final int width = right - left; |
| 826 |
final int height = top - bottom; |
| 827 |
// System.out.println("drawing rect("+left+","+bottom+","+ width+","+ |
| 828 |
// height+")"); |
| 829 |
graphics.drawRect(left, bottom, width, height); |
| 830 |
} |
| 831 |
|
| 832 |
/** |
| 833 |
* if clickable is set to true then a single click on the map pane will zoom |
| 834 |
* or pan the map. |
| 835 |
* |
| 836 |
* @param clickable |
| 837 |
*/ |
| 838 |
public void setClickable(final boolean clickable) { |
| 839 |
this.clickable = clickable; |
| 840 |
} |
| 841 |
|
| 842 |
public void mouseMoved(final MouseEvent e) { |
| 843 |
} |
| 844 |
|
| 845 |
// xulu.sn |
| 846 |
/** |
| 847 |
* Korrigiert den {@link Envelope} aka {@code mapArea} auf die beste |
| 848 |
* erlaubte Flaeche damit die Massstabsbeschaenkungen noch eingehalten |
| 849 |
* werden, FALLS der uebergeben Envelope nicht schon gueltig sein sollte.<br/> |
| 850 |
* Since 21. April 09: Before thecalculation starts, the aspect ratio is |
| 851 |
* corrected. This change implies, that setMapArea() will most of the time |
| 852 |
* not allow setting to a wrong aspectRatio. |
| 853 |
* |
| 854 |
* @author <a href="mailto:[email protected]">Stefan Alfons |
| 855 |
* Krüger</a> |
| 856 |
*/ |
| 857 |
public Envelope bestAllowedMapArea(Envelope env) { |
| 858 |
if (getWidth() == 0) |
| 859 |
return env; |
| 860 |
if (env == null) |
| 861 |
return env; |
| 862 |
|
| 863 |
Envelope newArea = null; |
| 864 |
|
| 865 |
/** |
| 866 |
* Correct the aspect Ratio before we check the rest. Otherwise we might |
| 867 |
* easily fail. We allow to grow here, because we don't check against |
| 868 |
* the maxExtend |
| 869 |
*/ |
| 870 |
env = JTSUtil.fixAspectRatio(this.getBounds(), env, true); |
| 871 |
|
| 872 |
final double scale = env.getWidth() / getWidth(); |
| 873 |
final double centerX = env.getMinX() + env.getWidth() / 2.; |
| 874 |
final double centerY = env.getMinY() + env.getHeight() / 2.; |
| 875 |
double newWidth2 = 0; |
| 876 |
double newHeight2 = 0; |
| 877 |
if (scale < getMaxZoomScale()) { |
| 878 |
// **************************************************************************** |
| 879 |
// Wir zoomen weiter rein als erlaubt => Anpassen des envelope |
| 880 |
// **************************************************************************** |
| 881 |
newWidth2 = getMaxZoomScale() * getWidth() / 2.; |
| 882 |
newHeight2 = getMaxZoomScale() * getHeight() / 2.; |
| 883 |
} else if (scale > getMinZoomScale()) { |
| 884 |
// **************************************************************************** |
| 885 |
// Wir zoomen weiter raus als erlaubt => Anpassen des envelope |
| 886 |
// **************************************************************************** |
| 887 |
newWidth2 = getMinZoomScale() * getWidth() / 2.; |
| 888 |
newHeight2 = getMinZoomScale() * getHeight() / 2.; |
| 889 |
} else { |
| 890 |
// **************************************************************************** |
| 891 |
// Die mapArea / der Envelope ist ist gueltig! Keine Aenderungen |
| 892 |
// **************************************************************************** |
| 893 |
newArea = env; |
| 894 |
} |
| 895 |
|
| 896 |
if (newArea == null) { |
| 897 |
|
| 898 |
final Coordinate ll = new Coordinate(centerX - newWidth2, centerY |
| 899 |
- newHeight2); |
| 900 |
final Coordinate ur = new Coordinate(centerX + newWidth2, centerY |
| 901 |
+ newHeight2); |
| 902 |
|
| 903 |
newArea = new Envelope(ll, ur); |
| 904 |
} |
| 905 |
|
| 906 |
Envelope maxAllowedExtend = getMaxExtend(); |
| 907 |
while (maxAllowedExtend != null && !maxAllowedExtend.contains(newArea) |
| 908 |
&& newArea != null && !newArea.isNull() |
| 909 |
&& !Double.isNaN(newArea.getMinX()) |
| 910 |
&& !Double.isNaN(newArea.getMaxX()) |
| 911 |
&& !Double.isNaN(newArea.getMinY()) |
| 912 |
&& !Double.isNaN(newArea.getMaxY())) { |
| 913 |
/* |
| 914 |
* If a maxExtend is set, we have to honour that... |
| 915 |
*/ |
| 916 |
|
| 917 |
// Exceeds top? Move down and maybe cut |
| 918 |
if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) { |
| 919 |
double divY = newArea.getMaxY() - maxAllowedExtend.getMaxY(); |
| 920 |
// LOGGER.debug("Moving area down by " + divY); |
| 921 |
|
| 922 |
newArea = new Envelope(new Coordinate(newArea.getMinX(), |
| 923 |
newArea.getMinY() - divY), new Coordinate(newArea |
| 924 |
.getMaxX(), newArea.getMaxY() - divY)); |
| 925 |
|
| 926 |
if (newArea.getMinY() < maxAllowedExtend.getMinY()) { |
| 927 |
// LOGGER.debug("Now it exeeds the bottom border.. cut!"); |
| 928 |
// And cut the bottom if it moved out of the area |
| 929 |
newArea = new Envelope(new Coordinate(newArea.getMinX(), |
| 930 |
maxAllowedExtend.getMinY()), new Coordinate(newArea |
| 931 |
.getMaxX(), newArea.getMaxY())); |
| 932 |
|
| 933 |
// LOGGER.debug("and fix aspect ratio"); |
| 934 |
|
| 935 |
newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea, |
| 936 |
false); |
| 937 |
} |
| 938 |
} |
| 939 |
|
| 940 |
// Exceeds bottom? Move up and maybe cut |
| 941 |
if (newArea.getMinY() < maxAllowedExtend.getMinY()) { |
| 942 |
double divY = newArea.getMinY() - maxAllowedExtend.getMinY(); |
| 943 |
// LOGGER.debug("Moving area up by " + divY); |
| 944 |
|
| 945 |
newArea = new Envelope(new Coordinate(newArea.getMinX(), |
| 946 |
newArea.getMinY() - divY), new Coordinate(newArea |
| 947 |
.getMaxX(), newArea.getMaxY() - divY)); |
| 948 |
|
| 949 |
if (newArea.getMaxY() > maxAllowedExtend.getMaxY()) { |
| 950 |
// LOGGER.debug("Now it exeeds the top border.. cut!"); |
| 951 |
// And cut the bottom if it moved out of the area |
| 952 |
newArea = new Envelope(new Coordinate(newArea.getMinX(), |
| 953 |
newArea.getMinY()), new Coordinate(newArea |
| 954 |
.getMaxX(), maxAllowedExtend.getMaxY())); |
| 955 |
|
| 956 |
// LOGGER.debug("and fix aspect ratio"); |
| 957 |
|
| 958 |
newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea, |
| 959 |
false); |
| 960 |
} |
| 961 |
} |
| 962 |
|
| 963 |
// Exceeds to the right? move and maybe cut |
| 964 |
if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) { |
| 965 |
|
| 966 |
// Move left.. |
| 967 |
double divX = newArea.getMaxX() - maxAllowedExtend.getMaxX(); |
| 968 |
// LOGGER.debug("Moving area left by " + divX); |
| 969 |
|
| 970 |
newArea = new Envelope(new Coordinate(newArea.getMinX() - divX, |
| 971 |
newArea.getMinY()), new Coordinate(newArea.getMaxX() |
| 972 |
- divX, newArea.getMaxY())); |
| 973 |
|
| 974 |
if (newArea.getMinX() < maxAllowedExtend.getMinX()) { |
| 975 |
// LOGGER.debug("Now it exeeds the left border.. cut!"); |
| 976 |
// And cut the left if it moved out of the area |
| 977 |
newArea = new Envelope(new Coordinate(maxAllowedExtend |
| 978 |
.getMinX(), newArea.getMinY()), new Coordinate( |
| 979 |
newArea.getMaxX(), newArea.getMaxY())); |
| 980 |
|
| 981 |
// LOGGER.debug("and fix aspect ratio"); |
| 982 |
|
| 983 |
newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea, |
| 984 |
false); |
| 985 |
} |
| 986 |
} |
| 987 |
|
| 988 |
// Exceeds to the left? move and maybe cut |
| 989 |
if (newArea.getMinX() < maxAllowedExtend.getMinX()) { |
| 990 |
|
| 991 |
// Move right.. |
| 992 |
double divX = newArea.getMinX() - maxAllowedExtend.getMinX(); |
| 993 |
// LOGGER.debug("Moving area right by " + divX); |
| 994 |
|
| 995 |
newArea = new Envelope(new Coordinate(newArea.getMinX() - divX, |
| 996 |
newArea.getMinY()), new Coordinate(newArea.getMaxX() |
| 997 |
- divX, newArea.getMaxY())); |
| 998 |
|
| 999 |
if (newArea.getMaxX() > maxAllowedExtend.getMaxX()) { |
| 1000 |
// LOGGER.debug("Now it exeeds the right border.. cut!"); |
| 1001 |
// And cut the left if it moved out of the area |
| 1002 |
newArea = new Envelope(new Coordinate(newArea.getMinX(), |
| 1003 |
newArea.getMinY()), new Coordinate(maxAllowedExtend |
| 1004 |
.getMaxX(), newArea.getMaxY())); |
| 1005 |
|
| 1006 |
// LOGGER.debug("and fix aspect ratio"); |
| 1007 |
|
| 1008 |
newArea = JTSUtil.fixAspectRatio(this.getBounds(), newArea, |
| 1009 |
false); |
| 1010 |
} |
| 1011 |
} |
| 1012 |
|
| 1013 |
} |
| 1014 |
|
| 1015 |
return newArea; |
| 1016 |
} |
| 1017 |
|
| 1018 |
/** |
| 1019 |
* Retuns the minimum allowed zoom scale. This is the bigger number value of |
| 1020 |
* the two. Defaults to {@link Double}.MAX_VALUE |
| 1021 |
* |
| 1022 |
* @author <a href="mailto:[email protected]">Stefan Alfons |
| 1023 |
* Krüger</a> |
| 1024 |
*/ |
| 1025 |
public Double getMinZoomScale() { |
| 1026 |
return minZoomScale; |
| 1027 |
} |
| 1028 |
|
| 1029 |
/** |
| 1030 |
* Retuns the maximum allowed zoom scale. This is the smaller number value |
| 1031 |
* of the two. Defaults to {@link Double}.MIN_VALUE |
| 1032 |
* |
| 1033 |
* @author <a href="mailto:[email protected]">Stefan Alfons |
| 1034 |
* Krüger</a> |
| 1035 |
*/ |
| 1036 |
public Double getMaxZoomScale() { |
| 1037 |
return maxZoomScale; |
| 1038 |
} |
| 1039 |
|
| 1040 |
/** |
| 1041 |
* Set the maximum allowed zoom scale. This is the smaller number value of |
| 1042 |
* the two. If <code>null</code> is passed, Double.MINVALUE are used which |
| 1043 |
* mean there is no restriction. |
| 1044 |
* |
| 1045 |
* @author <a href="mailto:[email protected]">Stefan Alfons |
| 1046 |
* Krüger</a> |
| 1047 |
*/ |
| 1048 |
public void setMaxZoomScale(final Double maxZoomScale) { |
| 1049 |
this.maxZoomScale = maxZoomScale == null ? Double.MIN_VALUE |
| 1050 |
: maxZoomScale; |
| 1051 |
} |
| 1052 |
|
| 1053 |
/** |
| 1054 |
* Set the minimum (nearest) allowed zoom scale. This is the bigger number |
| 1055 |
* value of the two. If <code>null</code> is passed, Double.MAXVALUE are |
| 1056 |
* used which mean there is no restriction. |
| 1057 |
* |
| 1058 |
* |
| 1059 |
* @author <a href="mailto:[email protected]">Stefan Alfons |
| 1060 |
* Krüger</a> |
| 1061 |
*/ |
| 1062 |
public void setMinZoomScale(final Double minZoomScale) { |
| 1063 |
this.minZoomScale = minZoomScale == null ? Double.MAX_VALUE |
| 1064 |
: minZoomScale; |
| 1065 |
} |
| 1066 |
|
| 1067 |
/** |
| 1068 |
* Defines an evelope of the viwable area. The JMapPane will never show |
| 1069 |
* anything outside of this extend. |
| 1070 |
* |
| 1071 |
* @param maxExtend |
| 1072 |
* <code>null</code> to not have this restriction. |
| 1073 |
*/ |
| 1074 |
public void setMaxExtend(Envelope maxExtend) { |
| 1075 |
this.maxExtend = maxExtend; |
| 1076 |
} |
| 1077 |
|
| 1078 |
/** |
| 1079 |
* Returns the evelope of the viewable area. The JMapPane will never show |
| 1080 |
* anything outside of this extend. If this has been set to |
| 1081 |
* <code>null</code> via {@link #setMaxExtend(Envelope)}, it tries to return |
| 1082 |
* quickly the context's bounds. It it takes to long to determine the |
| 1083 |
* context bounds, <code>null</code> is returned. |
| 1084 |
* |
| 1085 |
* @param maxExtend |
| 1086 |
* <code>null</code> to not have this restriction. |
| 1087 |
*/ |
| 1088 |
|
| 1089 |
public Envelope getMaxExtend() { |
| 1090 |
if (maxExtend == null) { |
| 1091 |
try { |
| 1092 |
return JTSUtil.fixAspectRatio(this.getBounds(), |
| 1093 |
// Kartenbereich um 10% vergroessern |
| 1094 |
JTSUtil.expandEnvelope(context.getLayerBounds(), 0.1), |
| 1095 |
true); |
| 1096 |
} catch (IOException e) { |
| 1097 |
LOGGER |
| 1098 |
.warn( |
| 1099 |
"maxExtend == null; failed to getLayerBounds of context", |
| 1100 |
e); |
| 1101 |
} |
| 1102 |
} |
| 1103 |
return maxExtend; |
| 1104 |
} |
| 1105 |
|
| 1106 |
} |
Parent Directory
| 
Revision Log