Changes in trunk/src [10274:10270] in josm
- Location:
- trunk/src/org/openstreetmap/josm
- Files:
-
- 2 deleted
- 6 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/org/openstreetmap/josm/Main.java
r10274 r10270 87 87 import org.openstreetmap.josm.gui.MapFrame; 88 88 import org.openstreetmap.josm.gui.MapFrameListener; 89 import org.openstreetmap.josm.gui.MapView; 89 90 import org.openstreetmap.josm.gui.dialogs.LayerListDialog; 90 91 import org.openstreetmap.josm.gui.help.HelpUtil; … … 92 93 import org.openstreetmap.josm.gui.layer.AbstractModifiableLayer; 93 94 import org.openstreetmap.josm.gui.layer.Layer; 94 import org.openstreetmap.josm.gui.layer.LayerManagerWithActive;95 95 import org.openstreetmap.josm.gui.layer.OsmDataLayer; 96 96 import org.openstreetmap.josm.gui.layer.OsmDataLayer.CommandQueueListener; … … 190 190 /** 191 191 * The MapFrame. Use {@link Main#setMapFrame} to set or clear it. 192 * <p>193 * There should be no need to access this to access any map data. Use {@link #layerManager} instead.194 192 */ 195 193 public static MapFrame map; 196 197 /**198 * Provides access to the layers displayed in the main view.199 * @since 10271200 */201 private static final LayerManagerWithActive layerManager = new LayerManagerWithActive();202 194 203 195 /** … … 539 531 public final synchronized void removeLayer(final Layer layer) { 540 532 if (map != null) { 541 getLayerManager().removeLayer(layer);542 if (isDisplayingMapView() && getLayerManager().getLayers().isEmpty()) {533 map.mapView.removeLayer(layer); 534 if (isDisplayingMapView() && map.mapView.getAllLayers().isEmpty()) { 543 535 setMapFrame(null); 544 536 } … … 616 608 public void initialize() { 617 609 validator = new OsmValidator(); 618 getLayerManager().addLayerChangeListener(validator);610 MapView.addLayerChangeListener(validator); 619 611 } 620 612 }); … … 738 730 739 731 /** 740 * Returns the main layer manager that is used by the map view.741 * @return The layer manager. The value returned will never change.742 * @since 10271743 */744 public static LayerManagerWithActive getLayerManager() {745 return layerManager;746 }747 748 /**749 732 * Add a new layer to the map. 750 733 * … … 790 773 } 791 774 layer.hookUpMapView(); 792 getLayerManager().addLayer(layer);775 map.mapView.addLayer(layer); 793 776 if (noMap) { 794 777 Main.map.setVisible(true); … … 830 813 public OsmDataLayer getEditLayer() { 831 814 if (!isDisplayingMapView()) return null; 832 return getLayerManager().getEditLayer();815 return map.mapView.getEditLayer(); 833 816 } 834 817 … … 869 852 public Layer getActiveLayer() { 870 853 if (!isDisplayingMapView()) return null; 871 return getLayerManager().getActiveLayer();854 return map.mapView.getActiveLayer(); 872 855 } 873 856 … … 1050 1033 public static boolean saveUnsavedModifications() { 1051 1034 if (!isDisplayingMapView()) return true; 1052 return saveUnsavedModifications( getLayerManager().getLayersOfType(AbstractModifiableLayer.class), true);1035 return saveUnsavedModifications(map.mapView.getLayersOfType(AbstractModifiableLayer.class), true); 1053 1036 } 1054 1037 … … 1117 1100 // Remove all layers because somebody may rely on layerRemoved events (like AutosaveTask) 1118 1101 if (Main.isDisplayingMapView()) { 1119 Collection<Layer> layers = new ArrayList<>( getLayerManager().getLayers());1102 Collection<Layer> layers = new ArrayList<>(Main.map.mapView.getAllLayers()); 1120 1103 for (Layer l: layers) { 1121 1104 Main.main.removeLayer(l); -
trunk/src/org/openstreetmap/josm/data/validation/OsmValidator.java
r10274 r10270 59 59 import org.openstreetmap.josm.data.validation.tests.WayConnectedToArea; 60 60 import org.openstreetmap.josm.data.validation.tests.WronglyOrderedWays; 61 import org.openstreetmap.josm.gui.layer.LayerManager.LayerAddEvent; 62 import org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener; 63 import org.openstreetmap.josm.gui.layer.LayerManager.LayerOrderChangeEvent; 64 import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent; 61 import org.openstreetmap.josm.gui.MapView.LayerChangeListener; 62 import org.openstreetmap.josm.gui.layer.Layer; 65 63 import org.openstreetmap.josm.gui.layer.OsmDataLayer; 66 64 import org.openstreetmap.josm.gui.layer.ValidatorLayer; … … 341 339 /* -------------------------------------------------------------------------- */ 342 340 @Override 343 public void layerAdded(LayerAddEvent e) {344 // do nothing341 public void activeLayerChange(Layer oldLayer, Layer newLayer) { 342 // Do nothing 345 343 } 346 344 347 345 @Override 348 public void layer OrderChanged(LayerOrderChangeEvent e) {349 // do nothing346 public void layerAdded(Layer newLayer) { 347 // Do nothing 350 348 } 351 349 352 350 @Override 353 public void layerRemov ing(LayerRemoveEvent e) {354 if ( e.getRemovedLayer()== errorLayer) {351 public void layerRemoved(Layer oldLayer) { 352 if (oldLayer == errorLayer) { 355 353 errorLayer = null; 356 354 return; 357 355 } 358 if ( e.getSource().getLayersOfType(OsmDataLayer.class).isEmpty()) {356 if (Main.map.mapView.getLayersOfType(OsmDataLayer.class).isEmpty()) { 359 357 if (errorLayer != null) { 360 358 Main.main.removeLayer(errorLayer); -
trunk/src/org/openstreetmap/josm/gui/MapFrame.java
r10274 r10270 76 76 import org.openstreetmap.josm.gui.dialogs.properties.PropertiesDialog; 77 77 import org.openstreetmap.josm.gui.layer.Layer; 78 import org.openstreetmap.josm.gui.layer.LayerManager;79 78 import org.openstreetmap.josm.gui.util.AdvancedKeyPressDetector; 80 79 import org.openstreetmap.josm.tools.Destroyable; … … 99 98 /** 100 99 * The view control displayed. 101 * <p>102 * Accessing this is discouraged. Use the {@link LayerManager} to access map data.103 100 */ 104 101 public final MapView mapView; … … 193 190 setLayout(new BorderLayout()); 194 191 195 mapView = new MapView( Main.getLayerManager(),contentPane, viewportData);192 mapView = new MapView(contentPane, viewportData); 196 193 if (!GraphicsEnvironment.isHeadless()) { 197 194 new FileDrop(mapView); … … 778 775 } 779 776 // invalidate repaint cache 780 mapView.preferenceChanged(null); 777 Main.map.mapView.preferenceChanged(null); 781 778 } 782 779 -
trunk/src/org/openstreetmap/josm/gui/MapView.java
r10274 r10270 26 26 import java.util.Collection; 27 27 import java.util.Collections; 28 import java.util.EnumSet; 28 29 import java.util.LinkedHashSet; 29 30 import java.util.List; 31 import java.util.ListIterator; 30 32 import java.util.Set; 31 33 import java.util.concurrent.CopyOnWriteArrayList; … … 57 59 import org.openstreetmap.josm.gui.layer.ImageryLayer; 58 60 import org.openstreetmap.josm.gui.layer.Layer; 59 import org.openstreetmap.josm.gui.layer.LayerManager; 60 import org.openstreetmap.josm.gui.layer.LayerManager.LayerAddEvent; 61 import org.openstreetmap.josm.gui.layer.LayerManager.LayerOrderChangeEvent; 62 import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent; 63 import org.openstreetmap.josm.gui.layer.LayerManagerWithActive; 64 import org.openstreetmap.josm.gui.layer.LayerManagerWithActive.ActiveLayerChangeEvent; 65 import org.openstreetmap.josm.gui.layer.LayerManagerWithActive.ActiveLayerChangeListener; 61 import org.openstreetmap.josm.gui.layer.LayerPositionStrategy; 66 62 import org.openstreetmap.josm.gui.layer.MapViewPaintable; 67 63 import org.openstreetmap.josm.gui.layer.MapViewPaintable.PaintableInvalidationEvent; 68 64 import org.openstreetmap.josm.gui.layer.MapViewPaintable.PaintableInvalidationListener; 65 import org.openstreetmap.josm.gui.layer.NativeScaleLayer; 69 66 import org.openstreetmap.josm.gui.layer.OsmDataLayer; 70 67 import org.openstreetmap.josm.gui.layer.geoimage.GeoImageLayer; … … 90 87 */ 91 88 public class MapView extends NavigatableComponent 92 implements PropertyChangeListener, PreferenceChangedListener, OsmDataLayer.LayerStateChangeListener ,93 LayerManager.LayerChangeListener, LayerManagerWithActive.ActiveLayerChangeListener { 89 implements PropertyChangeListener, PreferenceChangedListener, OsmDataLayer.LayerStateChangeListener { 90 94 91 /** 95 92 * Interface to notify listeners of a layer change. 96 * <p>97 * To be removed: end of 2016. Use {@link org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener} instead.98 93 * @author imi 99 94 */ 100 @Deprecated101 95 public interface LayerChangeListener { 102 96 … … 123 117 /** 124 118 * An interface that needs to be implemented in order to listen for changes to the active edit layer. 125 * <p> 126 * To be removed: end of 2016. Use {@link ActiveLayerChangeListener} instead. 127 */ 128 @Deprecated 119 */ 129 120 public interface EditLayerChangeListener { 130 121 … … 140 131 * An invalidation listener that simply calls repaint() for now. 141 132 * @author Michael Zangl 142 * @since 10271143 133 */ 144 134 private class LayerInvalidatedListener implements PaintableInvalidationListener { … … 182 172 } 183 173 184 /** 185 * This class is an adapter for the old layer change interface. 186 * <p> 187 * New implementations should use {@link org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener} 188 * @author Michael Zangl 189 * @since 10271 190 */ 191 protected static class LayerChangeAdapter implements ActiveLayerChangeListener, LayerManager.LayerChangeListener { 192 193 private final LayerChangeListener wrapped; 194 private boolean receiveOneInitialFire; 195 196 public LayerChangeAdapter(LayerChangeListener wrapped) { 197 this.wrapped = wrapped; 198 } 199 200 public LayerChangeAdapter(LayerChangeListener wrapped, boolean initialFire) { 201 this(wrapped); 202 this.receiveOneInitialFire = initialFire; 203 } 204 205 @Override 206 public void layerAdded(LayerAddEvent e) { 207 wrapped.layerAdded(e.getAddedLayer()); 208 } 209 210 @Override 211 public void layerRemoving(LayerRemoveEvent e) { 212 wrapped.layerRemoved(e.getRemovedLayer()); 213 } 214 215 @Override 216 public void layerOrderChanged(LayerOrderChangeEvent e) { 217 // not in old API 218 } 219 220 @Override 221 public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) { 222 Layer oldActive = receiveOneInitialFire ? null : e.getPreviousActiveLayer(); 223 Layer newActive = e.getSource().getActiveLayer(); 224 if (oldActive != newActive) { 225 wrapped.activeLayerChange(oldActive, newActive); 226 } 227 receiveOneInitialFire = false; 228 } 229 230 @Override 231 public int hashCode() { 232 final int prime = 31; 233 int result = 1; 234 result = prime * result + ((wrapped == null) ? 0 : wrapped.hashCode()); 235 return result; 236 } 237 238 @Override 239 public boolean equals(Object obj) { 240 if (this == obj) 241 return true; 242 if (obj == null) 243 return false; 244 if (getClass() != obj.getClass()) 245 return false; 246 LayerChangeAdapter other = (LayerChangeAdapter) obj; 247 if (wrapped == null) { 248 if (other.wrapped != null) 249 return false; 250 } else if (!wrapped.equals(other.wrapped)) 251 return false; 252 return true; 253 } 254 255 @Override 256 public String toString() { 257 return "LayerChangeAdapter [wrapped=" + wrapped + "]"; 258 } 259 260 } 261 262 /** 263 * This class is an adapter for the old layer change interface. 264 * <p> 265 * New implementations should use {@link org.openstreetmap.josm.gui.layer.LayerManagerWithActive.ActiveLayerChangeListener} 266 * @author Michael Zangl 267 * @since 10271 268 */ 269 protected static class EditLayerChangeAdapter implements ActiveLayerChangeListener { 270 271 private final EditLayerChangeListener wrapped; 272 273 public EditLayerChangeAdapter(EditLayerChangeListener wrapped) { 274 this.wrapped = wrapped; 275 } 276 277 @Override 278 public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) { 279 OsmDataLayer oldLayer = e.getPreviousEditLayer(); 280 OsmDataLayer newLayer = e.getSource().getEditLayer(); 281 if (oldLayer != newLayer) { 282 wrapped.editLayerChanged(oldLayer, newLayer); 283 } 284 } 285 286 @Override 287 public int hashCode() { 288 final int prime = 31; 289 int result = 1; 290 result = prime * result + ((wrapped == null) ? 0 : wrapped.hashCode()); 291 return result; 292 } 293 294 @Override 295 public boolean equals(Object obj) { 296 if (this == obj) 297 return true; 298 if (obj == null) 299 return false; 300 if (getClass() != obj.getClass()) 301 return false; 302 EditLayerChangeAdapter other = (EditLayerChangeAdapter) obj; 303 if (wrapped == null) { 304 if (other.wrapped != null) 305 return false; 306 } else if (!wrapped.equals(other.wrapped)) 307 return false; 308 return true; 309 } 310 311 @Override 312 public String toString() { 313 return "EditLayerChangeAdapter [wrapped=" + wrapped + "]"; 314 } 315 316 } 174 public boolean viewportFollowing; 175 176 /** 177 * the layer listeners 178 */ 179 private static final CopyOnWriteArrayList<LayerChangeListener> layerChangeListeners = new CopyOnWriteArrayList<>(); 180 private static final CopyOnWriteArrayList<EditLayerChangeListener> editLayerChangeListeners = new CopyOnWriteArrayList<>(); 317 181 318 182 /** 319 183 * Removes a layer change listener 320 * <p> 321 * You should register the listener on {@link Main#getLayerManager()} instead. To be removed: end of 2016. 322 * 323 * @param listener the listener. Ignored if null or not registered. 324 */ 325 @Deprecated 184 * 185 * @param listener the listener. Ignored if null or already registered. 186 */ 326 187 public static void removeLayerChangeListener(LayerChangeListener listener) { 327 LayerChangeAdapter adapter = new LayerChangeAdapter(listener); 328 try { 329 Main.getLayerManager().removeLayerChangeListener(adapter); 330 } catch (IllegalArgumentException e) { 331 // Ignored in old implementation 332 } 333 try { 334 Main.getLayerManager().removeActiveLayerChangeListener(adapter); 335 } catch (IllegalArgumentException e) { 336 // Ignored in old implementation 337 } 338 } 339 340 /** 341 * Removes an edit layer change listener 342 * <p> 343 * You should register the listener on {@link Main#getLayerManager()} instead. To be removed: end of 2016. 344 * 345 * @param listener the listener. Ignored if null or not registered. 346 */ 347 @Deprecated 188 layerChangeListeners.remove(listener); 189 } 190 348 191 public static void removeEditLayerChangeListener(EditLayerChangeListener listener) { 349 try { 350 Main.getLayerManager().removeActiveLayerChangeListener(new EditLayerChangeAdapter(listener)); 351 } catch (IllegalArgumentException e) { 352 // Ignored in old implementation 353 } 192 editLayerChangeListeners.remove(listener); 354 193 } 355 194 356 195 /** 357 196 * Adds a layer change listener 358 * <p>359 * You should register the listener on {@link Main#getLayerManager()} instead. To be removed: end of 2016.360 197 * 361 198 * @param listener the listener. Ignored if null or already registered. 362 199 */ 363 @Deprecated364 200 public static void addLayerChangeListener(LayerChangeListener listener) { 365 addLayerChangeListener(listener, false); 201 if (listener != null) { 202 layerChangeListeners.addIfAbsent(listener); 203 } 366 204 } 367 205 368 206 /** 369 207 * Adds a layer change listener 370 * <p>371 * You should register the listener on {@link Main#getLayerManager()} instead. To be removed: end of 2016.372 208 * 373 209 * @param listener the listener. Ignored if null or already registered. … … 375 211 * the listener in case there is a layer present (should be) 376 212 */ 377 @Deprecated378 213 public static void addLayerChangeListener(LayerChangeListener listener, boolean initialFire) { 379 if (listener != null) { 380 initialFire = initialFire && Main.isDisplayingMapView(); 381 382 LayerChangeAdapter adapter = new LayerChangeAdapter(listener, initialFire); 383 Main.getLayerManager().addLayerChangeListener(adapter, false); 384 Main.getLayerManager().addActiveLayerChangeListener(adapter, initialFire); 385 adapter.receiveOneInitialFire = false; 214 addLayerChangeListener(listener); 215 if (initialFire && Main.isDisplayingMapView()) { 216 listener.activeLayerChange(null, Main.map.mapView.getActiveLayer()); 386 217 } 387 218 } … … 389 220 /** 390 221 * Adds an edit layer change listener 391 * <p>392 * You should register the listener on {@link Main#getLayerManager()} instead. To be removed: end of 2016.393 222 * 394 223 * @param listener the listener. Ignored if null or already registered. … … 396 225 * the listener in case there is an edit layer present 397 226 */ 398 @Deprecated399 227 public static void addEditLayerChangeListener(EditLayerChangeListener listener, boolean initialFire) { 228 addEditLayerChangeListener(listener); 229 if (initialFire && Main.isDisplayingMapView() && Main.map.mapView.getEditLayer() != null) { 230 listener.editLayerChanged(null, Main.map.mapView.getEditLayer()); 231 } 232 } 233 234 /** 235 * Adds an edit layer change listener 236 * 237 * @param listener the listener. Ignored if null or already registered. 238 */ 239 public static void addEditLayerChangeListener(EditLayerChangeListener listener) { 400 240 if (listener != null) { 401 Main.getLayerManager().addActiveLayerChangeListener(new EditLayerChangeAdapter(listener), initialFire && Main.isDisplayingMapView() && Main.map.mapView.getEditLayer() != null); 402 } 403 } 404 405 /** 406 * Adds an edit layer change listener 407 * <p> 408 * You should register the listener on {@link Main#getLayerManager()} instead. To be removed: end of 2016. 409 * 410 * @param listener the listener. Ignored if null or already registered. 411 */ 412 @Deprecated 413 public static void addEditLayerChangeListener(EditLayerChangeListener listener) { 414 addEditLayerChangeListener(listener, false); 415 } 416 417 public boolean viewportFollowing = false; 418 419 /** 420 * A list of all layers currently loaded. If we support multiple map views, this list may be different for each of them. 421 */ 422 private final LayerManagerWithActive layerManager; 241 editLayerChangeListeners.addIfAbsent(listener); 242 } 243 } 244 245 /** 246 * Calls the {@link LayerChangeListener#activeLayerChange(Layer, Layer)} method of all listeners. 247 * 248 * @param oldLayer The old layer 249 * @param newLayer The new active layer. 250 */ 251 protected void fireActiveLayerChanged(Layer oldLayer, Layer newLayer) { 252 for (LayerChangeListener l : layerChangeListeners) { 253 l.activeLayerChange(oldLayer, newLayer); 254 } 255 } 256 257 protected void fireLayerAdded(Layer newLayer) { 258 for (MapView.LayerChangeListener l : MapView.layerChangeListeners) { 259 l.layerAdded(newLayer); 260 } 261 } 262 263 protected void fireLayerRemoved(Layer layer) { 264 for (MapView.LayerChangeListener l : MapView.layerChangeListeners) { 265 l.layerRemoved(layer); 266 } 267 } 268 269 protected void fireEditLayerChanged(OsmDataLayer oldLayer, OsmDataLayer newLayer) { 270 for (EditLayerChangeListener l : editLayerChangeListeners) { 271 l.editLayerChanged(oldLayer, newLayer); 272 } 273 } 274 275 /** 276 * A list of all layers currently loaded. 277 */ 278 private final transient List<Layer> layers = new ArrayList<>(); 423 279 424 280 /** … … 426 282 */ 427 283 public transient PlayHeadMarker playHeadMarker; 284 285 /** 286 * The layer from the layers list that is currently active. 287 */ 288 private transient Layer activeLayer; 289 290 /** 291 * The edit layer is the current active data layer. 292 */ 293 private transient OsmDataLayer editLayer; 428 294 429 295 /** … … 456 322 /** 457 323 * Constructs a new {@code MapView}. 458 * @param layerManager The layers to display.459 324 * @param contentPane The content pane used to register shortcuts in its 460 325 * {@link InputMap} and {@link ActionMap} … … 462 327 * the viewport is derived from the layer data. 463 328 */ 464 public MapView(LayerManagerWithActive layerManager, final JPanel contentPane, final ViewportData viewportData) { 465 this.layerManager = layerManager; 329 public MapView(final JPanel contentPane, final ViewportData viewportData) { 466 330 initialViewport = viewportData; 467 layerManager.addLayerChangeListener(this);468 layerManager.addActiveLayerChangeListener(this, false);469 331 Main.pref.addPreferenceChangeListener(this); 470 332 … … 543 405 544 406 /** 545 * Add a layer to the current MapView. 546 * <p> 547 * Use {@link Main#getLayerManager()}.addLayer() instead. To be removed: end of 2016. 407 * Add a layer to the current MapView. The layer will be added at topmost 408 * position. 548 409 * @param layer The layer to add 549 410 */ 550 @Deprecated551 411 public void addLayer(Layer layer) { 552 layerManager.addLayer(layer); 412 boolean isOsmDataLayer = layer instanceof OsmDataLayer; 413 EnumSet<LayerListenerType> listenersToFire = EnumSet.noneOf(LayerListenerType.class); 414 Layer oldActiveLayer = activeLayer; 415 OsmDataLayer oldEditLayer = editLayer; 416 417 synchronized (layers) { 418 if (layer instanceof MarkerLayer && playHeadMarker == null) { 419 playHeadMarker = PlayHeadMarker.create(); 420 } 421 422 LayerPositionStrategy positionStrategy = layer.getDefaultLayerPosition(); 423 int position = positionStrategy.getPosition(this); 424 checkPosition(position); 425 insertLayerAt(layer, position); 426 427 if (isOsmDataLayer || oldActiveLayer == null) { 428 // autoselect the new layer 429 listenersToFire.addAll(setActiveLayer(layer, true)); 430 } 431 432 if (isOsmDataLayer) { 433 ((OsmDataLayer) layer).addLayerStateChangeListener(this); 434 } 435 436 if (layer instanceof NativeScaleLayer) { 437 Main.map.mapView.setNativeScaleLayer((NativeScaleLayer) layer); 438 } 439 440 layer.addPropertyChangeListener(this); 441 invalidatedListener.addTo(layer); 442 Main.addProjectionChangeListener(layer); 443 AudioPlayer.reset(); 444 } 445 fireLayerAdded(layer); 446 onActiveEditLayerChanged(oldActiveLayer, oldEditLayer, listenersToFire); 447 448 if (!listenersToFire.isEmpty()) { 449 repaint(); 450 } 451 } 452 453 /** 454 * Check if the (new) position is valid 455 * @param position The position index 456 * @throws IndexOutOfBoundsException if it is not. 457 */ 458 private void checkPosition(int position) { 459 if (position < 0 || position > layers.size()) { 460 throw new IndexOutOfBoundsException("Position " + position + " out of range."); 461 } 462 } 463 464 /** 465 * Insert a layer at a given position. 466 * @param layer The layer to add. 467 * @param position The position on which we should add it. 468 */ 469 private void insertLayerAt(Layer layer, int position) { 470 if (position == layers.size()) { 471 layers.add(layer); 472 } else { 473 layers.add(position, layer); 474 } 553 475 } 554 476 555 477 @Override 556 public void layerAdded(LayerAddEvent e) {557 Layer layer = e.getAddedLayer();558 if (layer instanceof MarkerLayer && playHeadMarker == null) {559 playHeadMarker = PlayHeadMarker.create();560 }561 562 boolean isOsmDataLayer = layer instanceof OsmDataLayer;563 if (isOsmDataLayer) {564 ((OsmDataLayer) layer).addLayerStateChangeListener(this);565 }566 567 layer.addPropertyChangeListener(this);568 Main.addProjectionChangeListener(layer);569 invalidatedListener.addTo(layer);570 AudioPlayer.reset();571 572 repaint();573 }574 575 /**576 * Use {@link Main#getLayerManager()} instead. To be removed: end of 2016.577 */578 @Override579 @Deprecated580 478 protected DataSet getCurrentDataSet() { 581 return layerManager.getEditDataSet(); 479 synchronized (layers) { 480 if (editLayer != null) 481 return editLayer.data; 482 else 483 return null; 484 } 582 485 } 583 486 … … 588 491 */ 589 492 public boolean isActiveLayerDrawable() { 590 return getEditLayer() != null; 493 synchronized (layers) { 494 return editLayer != null; 495 } 591 496 } 592 497 … … 597 502 */ 598 503 public boolean isActiveLayerVisible() { 599 OsmDataLayer e = getEditLayer(); 600 return e != null && e.isVisible(); 504 synchronized (layers) { 505 return isActiveLayerDrawable() && editLayer.isVisible(); 506 } 601 507 } 602 508 … … 609 515 * <li>otherwise, the top most layer of any type becomes active</li> 610 516 * </ul> 611 * To be removed: end of 2016 (now handled by {@link LayerManagerWithActive}612 517 * @param layersList lit of layers 613 518 * 614 519 * @return the next active data layer 615 520 */ 616 @Deprecated617 521 protected Layer determineNextActiveLayer(List<Layer> layersList) { 618 522 // First look for data layer … … 628 532 // and then give up 629 533 return null; 534 630 535 } 631 536 … … 633 538 * Remove the layer from the mapview. If the layer was in the list before, 634 539 * an LayerChange event is fired. 635 * <p>636 * Use {@link Main#getLayerManager()}.removeLayer() instead. To be removed: end of 2016.637 540 * @param layer The layer to remove 638 541 */ 639 @Deprecated640 542 public void removeLayer(Layer layer) { 641 layerManager.removeLayer(layer); 642 } 643 644 @Override 645 public void layerRemoving(LayerRemoveEvent e) { 646 Layer layer = e.getRemovedLayer(); 647 if (layer instanceof OsmDataLayer) { 648 ((OsmDataLayer) layer).removeLayerPropertyChangeListener(this); 649 } 650 651 Main.removeProjectionChangeListener(layer); 652 layer.removePropertyChangeListener(this); 653 invalidatedListener.removeFrom(layer); 654 layer.destroy(); 655 AudioPlayer.reset(); 543 EnumSet<LayerListenerType> listenersToFire = EnumSet.noneOf(LayerListenerType.class); 544 Layer oldActiveLayer = activeLayer; 545 OsmDataLayer oldEditLayer = editLayer; 546 547 synchronized (layers) { 548 List<Layer> layersList = new ArrayList<>(layers); 549 550 if (!layersList.remove(layer)) 551 return; 552 553 listenersToFire = setEditLayer(layersList); 554 555 if (layer == activeLayer) { 556 listenersToFire.addAll(setActiveLayer(determineNextActiveLayer(layersList), false)); 557 } 558 559 if (layer instanceof OsmDataLayer) { 560 ((OsmDataLayer) layer).removeLayerPropertyChangeListener(this); 561 } 562 563 layers.remove(layer); 564 Main.removeProjectionChangeListener(layer); 565 layer.removePropertyChangeListener(this); 566 invalidatedListener.removeFrom(layer); 567 layer.destroy(); 568 AudioPlayer.reset(); 569 } 570 onActiveEditLayerChanged(oldActiveLayer, oldEditLayer, listenersToFire); 571 fireLayerRemoved(layer); 656 572 657 573 repaint(); 574 } 575 576 private void onEditLayerChanged(OsmDataLayer oldEditLayer) { 577 fireEditLayerChanged(oldEditLayer, editLayer); 578 refreshTitle(); 658 579 } 659 580 … … 684 605 */ 685 606 public void moveLayer(Layer layer, int pos) { 686 layerManager.moveLayer(layer, pos); 687 } 688 689 @Override 690 public void layerOrderChanged(LayerOrderChangeEvent e) { 691 AudioPlayer.reset(); 607 EnumSet<LayerListenerType> listenersToFire; 608 Layer oldActiveLayer = activeLayer; 609 OsmDataLayer oldEditLayer = editLayer; 610 611 synchronized (layers) { 612 int curLayerPos = layers.indexOf(layer); 613 if (curLayerPos == -1) 614 throw new IllegalArgumentException(tr("Layer not in list.")); 615 if (pos == curLayerPos) 616 return; // already in place. 617 layers.remove(curLayerPos); 618 if (pos >= layers.size()) { 619 layers.add(layer); 620 } else { 621 layers.add(pos, layer); 622 } 623 listenersToFire = setEditLayer(layers); 624 AudioPlayer.reset(); 625 } 626 onActiveEditLayerChanged(oldActiveLayer, oldEditLayer, listenersToFire); 627 692 628 repaint(); 693 629 } … … 695 631 /** 696 632 * Gets the index of the layer in the layer list. 697 * <p>698 * Access the layer list using {@link Main#getLayerManager()} instead. To be removed: end of 2016.699 633 * @param layer The layer to search for. 700 634 * @return The index in the list. 701 635 * @throws IllegalArgumentException if that layer does not belong to this view. 702 636 */ 703 @Deprecated704 637 public int getLayerPos(Layer layer) { 705 int curLayerPos = layerManager.getLayers().indexOf(layer); 638 int curLayerPos; 639 synchronized (layers) { 640 curLayerPos = layers.indexOf(layer); 641 } 706 642 if (curLayerPos == -1) 707 643 throw new IllegalArgumentException(tr("Layer not in list.")); 708 644 return curLayerPos; 645 } 646 647 /** 648 * Creates a list of the visible layers in Z-Order, the layer with the lowest Z-Order 649 * first, layer with the highest Z-Order last. 650 * <p> 651 * The active data layer is pulled above all adjacent data layers. 652 * 653 * @return a list of the visible in Z-Order, the layer with the lowest Z-Order 654 * first, layer with the highest Z-Order last. 655 */ 656 public List<Layer> getVisibleLayersInZOrder() { 657 synchronized (layers) { 658 List<Layer> ret = new ArrayList<>(); 659 // This is set while we delay the addition of the active layer. 660 boolean activeLayerDelayed = false; 661 for (ListIterator<Layer> iterator = layers.listIterator(layers.size()); iterator.hasPrevious();) { 662 Layer l = iterator.previous(); 663 if (!l.isVisible()) { 664 // ignored 665 } else if (l == activeLayer && l instanceof OsmDataLayer) { 666 // delay and add after the current block of OsmDataLayer 667 activeLayerDelayed = true; 668 } else { 669 if (activeLayerDelayed && !(l instanceof OsmDataLayer)) { 670 // add active layer before the current one. 671 ret.add(activeLayer); 672 activeLayerDelayed = false; 673 } 674 // Add this layer now 675 ret.add(l); 676 } 677 } 678 if (activeLayerDelayed) { 679 ret.add(activeLayer); 680 } 681 return ret; 682 } 709 683 } 710 684 … … 726 700 } 727 701 728 List<Layer> visibleLayers = layerManager.getVisibleLayersInZOrder();702 List<Layer> visibleLayers = getVisibleLayersInZOrder(); 729 703 730 704 int nonChangedLayersCount = 0; … … 919 893 920 894 /** 921 * Use {@link LayerManager#getLayers()} instead. To be removed: end of 2016.922 *923 895 * @return An unmodifiable collection of all layers 924 896 */ 925 @Deprecated926 897 public Collection<Layer> getAllLayers() { 927 return layerManager.getLayers();928 }929 930 /**931 * Use {@link LayerManager#getLayers()} instead. To be removed: end of 2016. 932 898 synchronized (layers) { 899 return Collections.unmodifiableCollection(new ArrayList<>(layers)); 900 } 901 } 902 903 /** 933 904 * @return An unmodifiable ordered list of all layers 934 905 */ 935 @Deprecated936 906 public List<Layer> getAllLayersAsList() { 937 return layerManager.getLayers(); 938 } 939 940 /** 941 * Replies an unmodifiable list of layers of a certain type. To be removed: end of 2016. 907 synchronized (layers) { 908 return Collections.unmodifiableList(new ArrayList<>(layers)); 909 } 910 } 911 912 /** 913 * Replies an unmodifiable list of layers of a certain type. 942 914 * 943 915 * Example: … … 945 917 * List<WMSLayer> wmsLayers = getLayersOfType(WMSLayer.class); 946 918 * </pre> 947 * Use {@link LayerManager#getLayersOfType(Class)} instead.948 *949 919 * @param <T> layer type 950 920 * … … 952 922 * @return an unmodifiable list of layers of a certain type. 953 923 */ 954 @Deprecated955 924 public <T extends Layer> List<T> getLayersOfType(Class<T> ofType) { 956 return layerManager.getLayersOfType(ofType); 957 } 958 959 /** 960 * Replies the number of layers managed by this map view. To be removed: end of 2016. 961 * <p> 962 * You can use {@link Main#getLayerManager()}.getLayers().size() instead. 925 return new ArrayList<>(Utils.filteredCollection(getAllLayers(), ofType)); 926 } 927 928 /** 929 * Replies the number of layers managed by this map view 963 930 * 964 931 * @return the number of layers managed by this map view 965 932 */ 966 @Deprecated967 933 public int getNumLayers() { 968 return getAllLayers().size(); 934 synchronized (layers) { 935 return layers.size(); 936 } 969 937 } 970 938 971 939 /** 972 940 * Replies true if there is at least one layer in this map view 973 * <p>974 * You can use !{@link Main#getLayerManager()}.getLayers().isEmpty() instead.975 941 * 976 942 * @return true if there is at least one layer in this map view 977 943 */ 978 @Deprecated979 944 public boolean hasLayers() { 980 945 return getNumLayers() > 0; … … 982 947 983 948 /** 949 * Sets the active edit layer. 950 * <p> 951 * @param layersList A list to select that layer from. 952 * @return A list of change listeners that should be fired using {@link #onActiveEditLayerChanged(Layer, OsmDataLayer, EnumSet)} 953 */ 954 private EnumSet<LayerListenerType> setEditLayer(List<Layer> layersList) { 955 final OsmDataLayer newEditLayer = findNewEditLayer(layersList); 956 957 // Set new edit layer 958 if (newEditLayer != editLayer) { 959 if (newEditLayer == null) { 960 // Note: Unsafe to call while layer write lock is held. 961 getCurrentDataSet().setSelected(); 962 } 963 964 editLayer = newEditLayer; 965 return EnumSet.of(LayerListenerType.EDIT_LAYER_CHANGE); 966 } else { 967 return EnumSet.noneOf(LayerListenerType.class); 968 } 969 970 } 971 972 private OsmDataLayer findNewEditLayer(List<Layer> layersList) { 973 OsmDataLayer newEditLayer = layersList.contains(editLayer) ? editLayer : null; 974 // Find new edit layer 975 if (activeLayer != editLayer || !layersList.contains(editLayer)) { 976 if (activeLayer instanceof OsmDataLayer && layersList.contains(activeLayer)) { 977 newEditLayer = (OsmDataLayer) activeLayer; 978 } else { 979 for (Layer layer:layersList) { 980 if (layer instanceof OsmDataLayer) { 981 newEditLayer = (OsmDataLayer) layer; 982 break; 983 } 984 } 985 } 986 } 987 return newEditLayer; 988 } 989 990 /** 984 991 * Sets the active layer to <code>layer</code>. If <code>layer</code> is an instance 985 * of {@link OsmDataLayer} also sets editLayer to <code>layer</code>. 986 * <p> 987 * You can use !{@link Main#getLayerManager()}.setActiveLayer() instead. 992 * of {@link OsmDataLayer} also sets {@link #editLayer} to <code>layer</code>. 988 993 * 989 994 * @param layer the layer to be activate; must be one of the layers in the list of layers 990 995 * @throws IllegalArgumentException if layer is not in the list of layers 991 996 */ 992 @Deprecated993 997 public void setActiveLayer(Layer layer) { 994 layerManager.setActiveLayer(layer); 995 } 998 EnumSet<LayerListenerType> listenersToFire; 999 Layer oldActiveLayer; 1000 OsmDataLayer oldEditLayer; 1001 1002 synchronized (layers) { 1003 oldActiveLayer = activeLayer; 1004 oldEditLayer = editLayer; 1005 listenersToFire = setActiveLayer(layer, true); 1006 } 1007 onActiveEditLayerChanged(oldActiveLayer, oldEditLayer, listenersToFire); 1008 1009 repaint(); 1010 } 1011 1012 /** 1013 * Sets the active layer. Propagates this change to all map buttons. 1014 * @param layer The layer to be active. 1015 * @param setEditLayer if this is <code>true</code>, the edit layer is also set. 1016 * @return A list of change listeners that should be fired using {@link #onActiveEditLayerChanged(Layer, OsmDataLayer, EnumSet)} 1017 */ 1018 private EnumSet<LayerListenerType> setActiveLayer(final Layer layer, boolean setEditLayer) { 1019 if (layer != null && !layers.contains(layer)) 1020 throw new IllegalArgumentException(tr("Layer ''{0}'' must be in list of layers", layer.toString())); 1021 1022 if (layer == activeLayer) 1023 return EnumSet.noneOf(LayerListenerType.class); 1024 1025 activeLayer = layer; 1026 EnumSet<LayerListenerType> listenersToFire = EnumSet.of(LayerListenerType.ACTIVE_LAYER_CHANGE); 1027 if (setEditLayer) { 1028 listenersToFire.addAll(setEditLayer(layers)); 1029 } 1030 1031 return listenersToFire; 1032 } 1033 996 1034 /** 997 1035 * Replies the currently active layer 998 * <p>999 * You can use !{@link Main#getLayerManager()}.getActiveLayer() instead.1000 1036 * 1001 1037 * @return the currently active layer (may be null) 1002 1038 */ 1003 @Deprecated1004 1039 public Layer getActiveLayer() { 1005 return layerManager.getActiveLayer(); 1006 } 1007 1008 @Override 1009 public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) { 1040 synchronized (layers) { 1041 return activeLayer; 1042 } 1043 } 1044 1045 private enum LayerListenerType { 1046 ACTIVE_LAYER_CHANGE, 1047 EDIT_LAYER_CHANGE 1048 } 1049 1050 /** 1051 * This is called whenever one of active layer/edit layer or both may have been changed, 1052 * @param oldActive The old active layer 1053 * @param oldEdit The old edit layer. 1054 * @param listenersToFire A mask of listeners to fire using {@link LayerListenerType}s 1055 */ 1056 private void onActiveEditLayerChanged(final Layer oldActive, final OsmDataLayer oldEdit, EnumSet<LayerListenerType> listenersToFire) { 1057 if (listenersToFire.contains(LayerListenerType.EDIT_LAYER_CHANGE)) { 1058 onEditLayerChanged(oldEdit); 1059 } 1060 if (listenersToFire.contains(LayerListenerType.ACTIVE_LAYER_CHANGE)) { 1061 onActiveLayerChanged(oldActive); 1062 } 1063 } 1064 1065 private void onActiveLayerChanged(final Layer old) { 1066 fireActiveLayerChanged(old, activeLayer); 1067 1010 1068 /* This only makes the buttons look disabled. Disabling the actions as well requires 1011 1069 * the user to re-select the tool after i.e. moving a layer. While testing I found … … 1014 1072 for (final AbstractButton b: Main.map.allMapModeButtons) { 1015 1073 MapMode mode = (MapMode) b.getAction(); 1016 final boolean activeLayerSupported = mode.layerIsSupported( layerManager.getActiveLayer());1074 final boolean activeLayerSupported = mode.layerIsSupported(activeLayer); 1017 1075 if (activeLayerSupported) { 1018 1076 Main.registerActionShortcut(mode, mode.getShortcut()); //fix #6876 … … 1027 1085 } 1028 1086 AudioPlayer.reset(); 1029 refreshTitle();1030 1087 repaint(); 1031 1088 } … … 1033 1090 /** 1034 1091 * Replies the current edit layer, if any 1035 * <p>1036 * You can use !{@link Main#getLayerManager()}.getEditLayer() instead. To be made private: end of 2016.1037 1092 * 1038 1093 * @return the current edit layer. May be null. 1039 1094 */ 1040 @Deprecated1041 1095 public OsmDataLayer getEditLayer() { 1042 return layerManager.getEditLayer(); 1096 synchronized (layers) { 1097 return editLayer; 1098 } 1043 1099 } 1044 1100 1045 1101 /** 1046 1102 * replies true if the list of layers managed by this map view contain layer 1047 * <p>1048 * You can use !{@link Main#getLayerManager()}.containsLayer() instead.1049 1103 * 1050 1104 * @param layer the layer 1051 1105 * @return true if the list of layers managed by this map view contain layer 1052 1106 */ 1053 @Deprecated1054 1107 public boolean hasLayer(Layer layer) { 1055 return layerManager.containsLayer(layer); 1108 synchronized (layers) { 1109 return layers.contains(layer); 1110 } 1056 1111 } 1057 1112 … … 1125 1180 protected void refreshTitle() { 1126 1181 if (Main.parent != null) { 1127 OsmDataLayer editLayer = layerManager.getEditLayer(); 1128 boolean dirty = editLayer != null && 1129 (editLayer.requiresSaveToFile() || (editLayer.requiresUploadToServer() && !editLayer.isUploadDiscouraged())); 1130 ((JFrame) Main.parent).setTitle((dirty ? "* " : "") + tr("Java OpenStreetMap Editor")); 1131 ((JFrame) Main.parent).getRootPane().putClientProperty("Window.documentModified", dirty); 1182 synchronized (layers) { 1183 boolean dirty = editLayer != null && 1184 (editLayer.requiresSaveToFile() || (editLayer.requiresUploadToServer() && !editLayer.isUploadDiscouraged())); 1185 ((JFrame) Main.parent).setTitle((dirty ? "* " : "") + tr("Java OpenStreetMap Editor")); 1186 ((JFrame) Main.parent).getRootPane().putClientProperty("Window.documentModified", dirty); 1187 } 1132 1188 } 1133 1189 } … … 1148 1204 1149 1205 public void destroy() { 1150 layerManager.removeLayerChangeListener(this);1151 layerManager.removeActiveLayerChangeListener(this);1152 1206 Main.pref.removePreferenceChangeListener(this); 1153 1207 DataSet.removeSelectionListener(repaintSelectionChangedListener); … … 1156 1210 mapMover.destroy(); 1157 1211 } 1158 nonChangedLayers.clear(); 1212 synchronized (layers) { 1213 activeLayer = null; 1214 changedLayer = null; 1215 editLayer = null; 1216 layers.clear(); 1217 nonChangedLayers.clear(); 1218 } 1159 1219 synchronized (temporaryLayers) { 1160 1220 temporaryLayers.clear(); … … 1164 1224 @Override 1165 1225 public void uploadDiscouragedChanged(OsmDataLayer layer, boolean newValue) { 1166 if (layer == layerManager.getEditLayer()) {1226 if (layer == getEditLayer()) { 1167 1227 refreshTitle(); 1168 1228 } -
trunk/src/org/openstreetmap/josm/gui/layer/LayerPositionStrategy.java
r10274 r10270 4 4 import java.util.List; 5 5 6 import org.openstreetmap.josm.gui.MapView; 6 7 import org.openstreetmap.josm.tools.Predicate; 7 8 import org.openstreetmap.josm.tools.Predicates; … … 19 20 public static final LayerPositionStrategy IN_FRONT = new LayerPositionStrategy() { 20 21 @Override 21 public int getPosition( LayerManagermanager) {22 public int getPosition(MapView manager) { 22 23 return 0; 23 24 } … … 72 73 return new LayerPositionStrategy() { 73 74 @Override 74 public int getPosition( LayerManagermanager) {75 List<Layer> layers = manager.get Layers();75 public int getPosition(MapView manager) { 76 List<Layer> layers = manager.getAllLayersAsList(); 76 77 for (int i = 0; i < layers.size(); i++) { 77 78 if (what.evaluate(layers.get(i))) { … … 92 93 return new LayerPositionStrategy() { 93 94 @Override 94 public int getPosition( LayerManagermanager) {95 List<Layer> layers = manager.get Layers();95 public int getPosition(MapView manager) { 96 List<Layer> layers = manager.getAllLayersAsList(); 96 97 for (int i = layers.size() - 1; i >= 0; i--) { 97 98 if (what.evaluate(layers.get(i))) { … … 109 110 * @return The position in the range 0...layers.size 110 111 */ 111 public abstract int getPosition( LayerManagermanager);112 public abstract int getPosition(MapView manager); 112 113 } -
trunk/src/org/openstreetmap/josm/gui/util/GuiHelper.java
r10274 r10270 131 131 132 132 /** 133 * Executes synchronously a runnable in134 * <a href="http://docs.oracle.com/javase/tutorial/uiswing/concurrency/dispatch.html">Event Dispatch Thread</a>.135 * <p>136 * Passes on the exception that was thrown to the thread calling this. The exception is wrapped in a {@link RuntimeException} if it was a normal {@link Throwable}.137 * @param task The runnable to execute138 * @see SwingUtilities#invokeAndWait139 * @since 10271140 */141 public static void runInEDTAndWaitWithException(Runnable task) {142 if (SwingUtilities.isEventDispatchThread()) {143 task.run();144 } else {145 try {146 SwingUtilities.invokeAndWait(task);147 } catch (InterruptedException e) {148 Main.error(e);149 } catch (InvocationTargetException e) {150 if (e.getCause() instanceof RuntimeException) {151 throw (RuntimeException) e.getCause();152 } else {153 throw new RuntimeException("Exception while clling " + task, e.getCause());154 }155 }156 }157 }158 159 /**160 133 * Executes synchronously a callable in 161 134 * <a href="http://docs.oracle.com/javase/tutorial/uiswing/concurrency/dispatch.html">Event Dispatch Thread</a> … … 183 156 return null; 184 157 } 185 }186 }187 188 /**189 * This function fails if it was not called from the EDT thread.190 * @throws IllegalStateException if called from wrong thread.191 * @since 10271192 */193 public static void assertCallFromEdt() {194 if (!SwingUtilities.isEventDispatchThread()) {195 throw new IllegalStateException(196 "Needs to be called from the EDT thread, not from " + Thread.currentThread().getName());197 158 } 198 159 }
Note:
See TracChangeset
for help on using the changeset viewer.