1 | ### Eclipse Workspace Patch 1.0
|
---|
2 | #P josm
|
---|
3 | Index: src/org/openstreetmap/josm/gui/MapView.java
|
---|
4 | ===================================================================
|
---|
5 | --- src/org/openstreetmap/josm/gui/MapView.java (revision 993)
|
---|
6 | +++ src/org/openstreetmap/josm/gui/MapView.java (working copy)
|
---|
7 | @@ -8,18 +8,19 @@
|
---|
8 | import java.awt.Graphics;
|
---|
9 | import java.awt.Graphics2D;
|
---|
10 | import java.awt.Point;
|
---|
11 | -import java.awt.Transparency;
|
---|
12 | -import java.awt.event.MouseEvent;
|
---|
13 | -import java.awt.event.MouseMotionListener;
|
---|
14 | import java.awt.event.ComponentAdapter;
|
---|
15 | import java.awt.event.ComponentEvent;
|
---|
16 | +import java.awt.event.InputEvent;
|
---|
17 | import java.awt.event.KeyEvent;
|
---|
18 | +import java.awt.event.MouseEvent;
|
---|
19 | +import java.awt.event.MouseMotionListener;
|
---|
20 | import java.awt.image.BufferedImage;
|
---|
21 | import java.util.ArrayList;
|
---|
22 | import java.util.Collection;
|
---|
23 | import java.util.Collections;
|
---|
24 | import java.util.LinkedList;
|
---|
25 |
|
---|
26 | +import javax.swing.InputMap;
|
---|
27 | import javax.swing.JComponent;
|
---|
28 | import javax.swing.JOptionPane;
|
---|
29 | import javax.swing.KeyStroke;
|
---|
30 | @@ -28,11 +29,11 @@
|
---|
31 | import org.openstreetmap.josm.actions.AutoScaleAction;
|
---|
32 | import org.openstreetmap.josm.actions.MoveAction;
|
---|
33 | import org.openstreetmap.josm.data.Bounds;
|
---|
34 | -import org.openstreetmap.josm.data.Preferences;
|
---|
35 | import org.openstreetmap.josm.data.SelectionChangedListener;
|
---|
36 | import org.openstreetmap.josm.data.coor.EastNorth;
|
---|
37 | import org.openstreetmap.josm.data.coor.LatLon;
|
---|
38 | import org.openstreetmap.josm.data.osm.DataSet;
|
---|
39 | +import org.openstreetmap.josm.data.osm.DataSource;
|
---|
40 | import org.openstreetmap.josm.data.osm.OsmPrimitive;
|
---|
41 | import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
|
---|
42 | import org.openstreetmap.josm.data.projection.Projection;
|
---|
43 | @@ -57,361 +58,398 @@
|
---|
44 | */
|
---|
45 | public class MapView extends NavigatableComponent {
|
---|
46 |
|
---|
47 | - /**
|
---|
48 | - * Interface to notify listeners of the change of the active layer.
|
---|
49 | - * @author imi
|
---|
50 | - * @deprecated Use Layer.LayerChangeListener instead
|
---|
51 | - */
|
---|
52 | - @Deprecated public interface LayerChangeListener {
|
---|
53 | - void activeLayerChange(Layer oldLayer, Layer newLayer);
|
---|
54 | - void layerAdded(Layer newLayer);
|
---|
55 | - void layerRemoved(Layer oldLayer);
|
---|
56 | - }
|
---|
57 | + /**
|
---|
58 | + * Interface to notify listeners of the change of the active layer.
|
---|
59 | + * @author imi
|
---|
60 | + * @deprecated Use Layer.LayerChangeListener instead
|
---|
61 | + */
|
---|
62 | + @Deprecated
|
---|
63 | + public interface LayerChangeListener {
|
---|
64 | + void activeLayerChange(Layer oldLayer, Layer newLayer);
|
---|
65 |
|
---|
66 | - /**
|
---|
67 | - * A list of all layers currently loaded.
|
---|
68 | - */
|
---|
69 | - private ArrayList<Layer> layers = new ArrayList<Layer>();
|
---|
70 | - /**
|
---|
71 | - * The play head marker: there is only one of these so it isn't in any specific layer
|
---|
72 | - */
|
---|
73 | - public PlayHeadMarker playHeadMarker = null;
|
---|
74 | - /**
|
---|
75 | - * Direct link to the edit layer (if any) in the layers list.
|
---|
76 | - */
|
---|
77 | - public OsmDataLayer editLayer;
|
---|
78 | - /**
|
---|
79 | - * The layer from the layers list that is currently active.
|
---|
80 | - */
|
---|
81 | - private Layer activeLayer;
|
---|
82 | -
|
---|
83 | - /**
|
---|
84 | - * The last event performed by mouse.
|
---|
85 | - */
|
---|
86 | - public MouseEvent lastMEvent;
|
---|
87 | + void layerAdded(Layer newLayer);
|
---|
88 |
|
---|
89 | - private LinkedList<MapViewPaintable> temporaryLayers = new LinkedList<MapViewPaintable>();
|
---|
90 | -
|
---|
91 | - private BufferedImage offscreenBuffer;
|
---|
92 | -
|
---|
93 | - /**
|
---|
94 | - * The listener of the active layer changes.
|
---|
95 | - * @deprecated Use Layer.listener instead.
|
---|
96 | - */
|
---|
97 | - @Deprecated private Collection<LayerChangeListener> listeners = new LinkedList<LayerChangeListener>();
|
---|
98 | + void layerRemoved(Layer oldLayer);
|
---|
99 | + }
|
---|
100 |
|
---|
101 | - public MapView() {
|
---|
102 | - addComponentListener(new ComponentAdapter(){
|
---|
103 | - @Override public void componentResized(ComponentEvent e) {
|
---|
104 | - removeComponentListener(this);
|
---|
105 | + /**
|
---|
106 | + * A list of all layers currently loaded.
|
---|
107 | + */
|
---|
108 | + private ArrayList<Layer> layers = new ArrayList<Layer>();
|
---|
109 | + /**
|
---|
110 | + * The play head marker: there is only one of these so it isn't in any specific layer
|
---|
111 | + */
|
---|
112 | + public PlayHeadMarker playHeadMarker = null;
|
---|
113 | + /**
|
---|
114 | + * Direct link to the edit layer (if any) in the layers list.
|
---|
115 | + */
|
---|
116 | + public OsmDataLayer editLayer;
|
---|
117 | + /**
|
---|
118 | + * The layer from the layers list that is currently active.
|
---|
119 | + */
|
---|
120 | + private Layer activeLayer;
|
---|
121 |
|
---|
122 | - new AutoScaleAction("data").actionPerformed(null);
|
---|
123 | + /**
|
---|
124 | + * The last event performed by mouse.
|
---|
125 | + */
|
---|
126 | + public MouseEvent lastMEvent;
|
---|
127 |
|
---|
128 | - new MapMover(MapView.this, Main.contentPane);
|
---|
129 | - Main.contentPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_UP, java.awt.event.InputEvent.SHIFT_MASK), "UP");
|
---|
130 | - Main.contentPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, java.awt.event.InputEvent.SHIFT_MASK), "DOWN");
|
---|
131 | - Main.contentPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, java.awt.event.InputEvent.SHIFT_MASK), "LEFT");
|
---|
132 | - Main.contentPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, java.awt.event.InputEvent.SHIFT_MASK), "RIGHT");
|
---|
133 | + private LinkedList<MapViewPaintable> temporaryLayers = new LinkedList<MapViewPaintable>();
|
---|
134 |
|
---|
135 | - Main.contentPane.getActionMap().put("UP", new MoveAction(MoveAction.Direction.UP));
|
---|
136 | - Main.contentPane.getActionMap().put("DOWN", new MoveAction(MoveAction.Direction.DOWN));
|
---|
137 | - Main.contentPane.getActionMap().put("LEFT", new MoveAction(MoveAction.Direction.LEFT));
|
---|
138 | - Main.contentPane.getActionMap().put("RIGHT", new MoveAction(MoveAction.Direction.RIGHT));
|
---|
139 | -
|
---|
140 | + private BufferedImage offscreenBuffer;
|
---|
141 |
|
---|
142 | - MapSlider zoomSlider = new MapSlider(MapView.this);
|
---|
143 | - add(zoomSlider);
|
---|
144 | - zoomSlider.setBounds(3, 0, 114, 30);
|
---|
145 | + /**
|
---|
146 | + * The listener of the active layer changes.
|
---|
147 | + * @deprecated Use Layer.listener instead.
|
---|
148 | + */
|
---|
149 | + @Deprecated
|
---|
150 | + private Collection<LayerChangeListener> listeners = new LinkedList<LayerChangeListener>();
|
---|
151 |
|
---|
152 | - MapScaler scaler = new MapScaler(MapView.this, Main.proj);
|
---|
153 | - add(scaler);
|
---|
154 | - scaler.setLocation(10,30);
|
---|
155 | - }
|
---|
156 | - });
|
---|
157 | + public MapView() {
|
---|
158 | + addComponentListener(new ComponentAdapter() {
|
---|
159 | + @Override
|
---|
160 | + public void componentResized(ComponentEvent e) {
|
---|
161 | + removeComponentListener(this);
|
---|
162 |
|
---|
163 | - // listend to selection changes to redraw the map
|
---|
164 | - DataSet.selListeners.add(new SelectionChangedListener(){
|
---|
165 | - public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
|
---|
166 | - repaint();
|
---|
167 | - }
|
---|
168 | - });
|
---|
169 | + if (!zoomToEditLayerBoundingBox())
|
---|
170 | + new AutoScaleAction("data").actionPerformed(null);
|
---|
171 |
|
---|
172 | - //store the last mouse action
|
---|
173 | - this.addMouseMotionListener(new MouseMotionListener() {
|
---|
174 | - public void mouseDragged(MouseEvent e) {
|
---|
175 | - mouseMoved(e);
|
---|
176 | - }
|
---|
177 | - public void mouseMoved(MouseEvent e) {
|
---|
178 | - lastMEvent = e;
|
---|
179 | - }
|
---|
180 | - });
|
---|
181 | - }
|
---|
182 | + new MapMover(MapView.this, Main.contentPane);
|
---|
183 | + InputMap inputMapWIFW = Main.contentPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
|
---|
184 | + inputMapWIFW.put(KeyStroke.getKeyStroke(KeyEvent.VK_UP, InputEvent.SHIFT_MASK), "UP");
|
---|
185 | + inputMapWIFW.put(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, InputEvent.SHIFT_MASK), "DOWN");
|
---|
186 | + inputMapWIFW.put(KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, InputEvent.SHIFT_MASK), "LEFT");
|
---|
187 | + inputMapWIFW.put(KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, InputEvent.SHIFT_MASK), "RIGHT");
|
---|
188 |
|
---|
189 | - /**
|
---|
190 | - * Add a layer to the current MapView. The layer will be added at topmost
|
---|
191 | - * position.
|
---|
192 | - */
|
---|
193 | - public void addLayer(Layer layer) {
|
---|
194 | - if (layer instanceof OsmDataLayer) {
|
---|
195 | - editLayer = (OsmDataLayer)layer;
|
---|
196 | - Main.ds = editLayer.data;
|
---|
197 | - editLayer.listenerModified.add(new ModifiedChangedListener(){
|
---|
198 | - public void modifiedChanged(boolean value, OsmDataLayer source) {
|
---|
199 | - JOptionPane.getFrameForComponent(Main.parent).setTitle((value?"*":"")+tr("Java OpenStreetMap - Editor"));
|
---|
200 | - }
|
---|
201 | - });
|
---|
202 | - }
|
---|
203 | - if (layer instanceof MarkerLayer && playHeadMarker == null)
|
---|
204 | - playHeadMarker = PlayHeadMarker.create();
|
---|
205 | - int pos = layers.size();
|
---|
206 | - while(pos > 0 && layers.get(pos-1).background)
|
---|
207 | - --pos;
|
---|
208 | - layers.add(pos, layer);
|
---|
209 | + Main.contentPane.getActionMap().put("UP", new MoveAction(MoveAction.Direction.UP));
|
---|
210 | + Main.contentPane.getActionMap().put("DOWN", new MoveAction(MoveAction.Direction.DOWN));
|
---|
211 | + Main.contentPane.getActionMap().put("LEFT", new MoveAction(MoveAction.Direction.LEFT));
|
---|
212 | + Main.contentPane.getActionMap().put("RIGHT", new MoveAction(MoveAction.Direction.RIGHT));
|
---|
213 |
|
---|
214 | - // TODO: Deprecated
|
---|
215 | - for (LayerChangeListener l : listeners)
|
---|
216 | - l.layerAdded(layer);
|
---|
217 | - for (Layer.LayerChangeListener l : Layer.listeners)
|
---|
218 | - l.layerAdded(layer);
|
---|
219 | - if (layer instanceof OsmDataLayer || activeLayer == null) {
|
---|
220 | - // autoselect the new layer
|
---|
221 | - Layer old = activeLayer;
|
---|
222 | - setActiveLayer(layer);
|
---|
223 | - for (Layer.LayerChangeListener l : Layer.listeners)
|
---|
224 | - l.activeLayerChange(old, layer);
|
---|
225 | - }
|
---|
226 | - repaint();
|
---|
227 | - }
|
---|
228 | + MapSlider zoomSlider = new MapSlider(MapView.this);
|
---|
229 | + add(zoomSlider);
|
---|
230 | + zoomSlider.setBounds(3, 0, 114, 30);
|
---|
231 |
|
---|
232 | - @Override
|
---|
233 | - protected DataSet getData()
|
---|
234 | - {
|
---|
235 | - if(activeLayer != null && activeLayer instanceof OsmDataLayer)
|
---|
236 | - return ((OsmDataLayer)activeLayer).data;
|
---|
237 | - return new DataSet();
|
---|
238 | - }
|
---|
239 | + MapScaler scaler = new MapScaler(MapView.this, Main.proj);
|
---|
240 | + add(scaler);
|
---|
241 | + scaler.setLocation(10, 30);
|
---|
242 | + }
|
---|
243 | + });
|
---|
244 |
|
---|
245 | - public Boolean isDrawableLayer()
|
---|
246 | - {
|
---|
247 | - return activeLayer != null && activeLayer instanceof OsmDataLayer;
|
---|
248 | - }
|
---|
249 | + // listend to selection changes to redraw the map
|
---|
250 | + DataSet.selListeners.add(new SelectionChangedListener() {
|
---|
251 | + public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
|
---|
252 | + repaint();
|
---|
253 | + }
|
---|
254 | + });
|
---|
255 |
|
---|
256 | - /**
|
---|
257 | - * Remove the layer from the mapview. If the layer was in the list before,
|
---|
258 | - * an LayerChange event is fired.
|
---|
259 | - */
|
---|
260 | - public void removeLayer(Layer layer) {
|
---|
261 | - if (layers.remove(layer)) {
|
---|
262 | - // TODO: Deprecated
|
---|
263 | - for (LayerChangeListener l : listeners)
|
---|
264 | - l.layerRemoved(layer);
|
---|
265 | - for (Layer.LayerChangeListener l : Layer.listeners)
|
---|
266 | - l.layerRemoved(layer);
|
---|
267 | - }
|
---|
268 | - if (layer == editLayer) {
|
---|
269 | - editLayer = null;
|
---|
270 | - Main.ds.setSelected();
|
---|
271 | - }
|
---|
272 | - layer.destroy();
|
---|
273 | - }
|
---|
274 | + //store the last mouse action
|
---|
275 | + this.addMouseMotionListener(new MouseMotionListener() {
|
---|
276 | + public void mouseDragged(MouseEvent e) {
|
---|
277 | + mouseMoved(e);
|
---|
278 | + }
|
---|
279 |
|
---|
280 | - private Boolean virtualnodes = false;
|
---|
281 | - public void enableVirtualNodes(Boolean state)
|
---|
282 | - {
|
---|
283 | - if(virtualnodes != state)
|
---|
284 | - {
|
---|
285 | - virtualnodes = state;
|
---|
286 | - repaint();
|
---|
287 | - }
|
---|
288 | - }
|
---|
289 | - public Boolean useVirtualNodes()
|
---|
290 | - {
|
---|
291 | - return virtualnodes;
|
---|
292 | - }
|
---|
293 | + public void mouseMoved(MouseEvent e) {
|
---|
294 | + lastMEvent = e;
|
---|
295 | + }
|
---|
296 | + });
|
---|
297 | + }
|
---|
298 |
|
---|
299 | - /**
|
---|
300 | - * Moves the layer to the given new position. No event is fired.
|
---|
301 | - * @param layer The layer to move
|
---|
302 | - * @param pos The new position of the layer
|
---|
303 | - */
|
---|
304 | - public void moveLayer(Layer layer, int pos) {
|
---|
305 | - int curLayerPos = layers.indexOf(layer);
|
---|
306 | - if (curLayerPos == -1)
|
---|
307 | - throw new IllegalArgumentException(tr("layer not in list."));
|
---|
308 | - if (pos == curLayerPos)
|
---|
309 | - return; // already in place.
|
---|
310 | - layers.remove(curLayerPos);
|
---|
311 | - if (pos >= layers.size())
|
---|
312 | - layers.add(layer);
|
---|
313 | - else
|
---|
314 | - layers.add(pos, layer);
|
---|
315 | - }
|
---|
316 | + /**
|
---|
317 | + * Tries to zoom to the download boundingbox[es] of the current edit layer
|
---|
318 | + * (aka {@link OsmDataLayer}). If the edit layer has multiple download bounding
|
---|
319 | + * boxes it zooms to a large virtual bounding box containing all smaller ones.
|
---|
320 | + * This implementation can be used for resolving ticket #1461.
|
---|
321 | + *
|
---|
322 | + * @return <code>true</code> if a zoom operation has been performed
|
---|
323 | + * @author Jan Peter Stotz
|
---|
324 | + */
|
---|
325 | + private boolean zoomToEditLayerBoundingBox() {
|
---|
326 | + // workaround for #1461 (zoom to download bounding box instead of all data)
|
---|
327 | + // In case we already have an existing data layer ...
|
---|
328 | + Collection<DataSource> dataSources = Main.main.editLayer().data.dataSources;
|
---|
329 | + // ... with bounding box[es] of data loaded from OSM or a file...
|
---|
330 | + BoundingXYVisitor bbox = new BoundingXYVisitor();
|
---|
331 | + for (DataSource ds : dataSources) {
|
---|
332 | + if (ds.bounds != null) {
|
---|
333 | + bbox.visit(Main.proj.latlon2eastNorth(ds.bounds.max));
|
---|
334 | + bbox.visit(Main.proj.latlon2eastNorth(ds.bounds.min));
|
---|
335 | + }
|
---|
336 | + if (bbox.max != null && bbox.min != null && !bbox.max.equals(bbox.min)) {
|
---|
337 | + // ... we zoom to it's bounding box
|
---|
338 | + recalculateCenterScale(bbox);
|
---|
339 | + return true;
|
---|
340 | + }
|
---|
341 | + }
|
---|
342 | + return false;
|
---|
343 | + }
|
---|
344 |
|
---|
345 | - /**
|
---|
346 | - * Draw the component.
|
---|
347 | - */
|
---|
348 | - @Override public void paint(Graphics g) {
|
---|
349 | - if (center == null)
|
---|
350 | - return; // no data loaded yet.
|
---|
351 | + /**
|
---|
352 | + * Add a layer to the current MapView. The layer will be added at topmost
|
---|
353 | + * position.
|
---|
354 | + */
|
---|
355 | + public void addLayer(Layer layer) {
|
---|
356 | + if (layer instanceof OsmDataLayer) {
|
---|
357 | + editLayer = (OsmDataLayer) layer;
|
---|
358 | + Main.ds = editLayer.data;
|
---|
359 | + editLayer.listenerModified.add(new ModifiedChangedListener() {
|
---|
360 | + public void modifiedChanged(boolean value, OsmDataLayer source) {
|
---|
361 | + JOptionPane.getFrameForComponent(Main.parent).setTitle(
|
---|
362 | + (value ? "*" : "") + tr("Java OpenStreetMap - Editor"));
|
---|
363 | + }
|
---|
364 | + });
|
---|
365 | + }
|
---|
366 | + if (layer instanceof MarkerLayer && playHeadMarker == null)
|
---|
367 | + playHeadMarker = PlayHeadMarker.create();
|
---|
368 | + int pos = layers.size();
|
---|
369 | + while (pos > 0 && layers.get(pos - 1).background)
|
---|
370 | + --pos;
|
---|
371 | + layers.add(pos, layer);
|
---|
372 |
|
---|
373 | - // re-create offscreen-buffer if we've been resized, otherwise
|
---|
374 | - // just re-use it.
|
---|
375 | - if (null == offscreenBuffer || offscreenBuffer.getWidth() != getWidth()
|
---|
376 | - || offscreenBuffer.getHeight() != getHeight())
|
---|
377 | - offscreenBuffer = new BufferedImage(getWidth(), getHeight(),
|
---|
378 | - BufferedImage.TYPE_INT_ARGB);
|
---|
379 | + // TODO: Deprecated
|
---|
380 | + for (LayerChangeListener l : listeners)
|
---|
381 | + l.layerAdded(layer);
|
---|
382 | + for (Layer.LayerChangeListener l : Layer.listeners)
|
---|
383 | + l.layerAdded(layer);
|
---|
384 | + if (layer instanceof OsmDataLayer || activeLayer == null) {
|
---|
385 | + // autoselect the new layer
|
---|
386 | + Layer old = activeLayer;
|
---|
387 | + setActiveLayer(layer);
|
---|
388 | + for (Layer.LayerChangeListener l : Layer.listeners)
|
---|
389 | + l.activeLayerChange(old, layer);
|
---|
390 | + }
|
---|
391 | + repaint();
|
---|
392 | + }
|
---|
393 |
|
---|
394 | - Graphics2D tempG = offscreenBuffer.createGraphics();
|
---|
395 | - tempG.setColor(Main.pref.getColor("background", Color.BLACK));
|
---|
396 | - tempG.fillRect(0, 0, getWidth(), getHeight());
|
---|
397 | + @Override
|
---|
398 | + protected DataSet getData() {
|
---|
399 | + if (activeLayer != null && activeLayer instanceof OsmDataLayer)
|
---|
400 | + return ((OsmDataLayer) activeLayer).data;
|
---|
401 | + return new DataSet();
|
---|
402 | + }
|
---|
403 |
|
---|
404 | - for (int i = layers.size()-1; i >= 0; --i) {
|
---|
405 | - Layer l = layers.get(i);
|
---|
406 | - if (l.visible/* && l != getActiveLayer()*/)
|
---|
407 | - l.paint(tempG, this);
|
---|
408 | - }
|
---|
409 | + public Boolean isDrawableLayer() {
|
---|
410 | + return activeLayer != null && activeLayer instanceof OsmDataLayer;
|
---|
411 | + }
|
---|
412 |
|
---|
413 | - /*if (getActiveLayer() != null && getActiveLayer().visible)
|
---|
414 | - getActiveLayer().paint(tempG, this);*/
|
---|
415 | + /**
|
---|
416 | + * Remove the layer from the mapview. If the layer was in the list before,
|
---|
417 | + * an LayerChange event is fired.
|
---|
418 | + */
|
---|
419 | + public void removeLayer(Layer layer) {
|
---|
420 | + if (layers.remove(layer)) {
|
---|
421 | + // TODO: Deprecated
|
---|
422 | + for (LayerChangeListener l : listeners)
|
---|
423 | + l.layerRemoved(layer);
|
---|
424 | + for (Layer.LayerChangeListener l : Layer.listeners)
|
---|
425 | + l.layerRemoved(layer);
|
---|
426 | + }
|
---|
427 | + if (layer == editLayer) {
|
---|
428 | + editLayer = null;
|
---|
429 | + Main.ds.setSelected();
|
---|
430 | + }
|
---|
431 | + layer.destroy();
|
---|
432 | + }
|
---|
433 |
|
---|
434 | - for (MapViewPaintable mvp : temporaryLayers) {
|
---|
435 | - mvp.paint(tempG, this);
|
---|
436 | - }
|
---|
437 | -
|
---|
438 | - // draw world borders
|
---|
439 | - tempG.setColor(Color.WHITE);
|
---|
440 | - Bounds b = new Bounds();
|
---|
441 | - Point min = getPoint(getProjection().latlon2eastNorth(b.min));
|
---|
442 | - Point max = getPoint(getProjection().latlon2eastNorth(b.max));
|
---|
443 | - int x1 = Math.min(min.x, max.x);
|
---|
444 | - int y1 = Math.min(min.y, max.y);
|
---|
445 | - int x2 = Math.max(min.x, max.x);
|
---|
446 | - int y2 = Math.max(min.y, max.y);
|
---|
447 | - if (x1 > 0 || y1 > 0 || x2 < getWidth() || y2 < getHeight())
|
---|
448 | - tempG.drawRect(x1, y1, x2-x1+1, y2-y1+1);
|
---|
449 | -
|
---|
450 | - if (playHeadMarker != null)
|
---|
451 | - playHeadMarker.paint(tempG, this);
|
---|
452 | + private Boolean virtualnodes = false;
|
---|
453 |
|
---|
454 | - g.drawImage(offscreenBuffer, 0, 0, null);
|
---|
455 | - super.paint(g);
|
---|
456 | - }
|
---|
457 | + public void enableVirtualNodes(Boolean state) {
|
---|
458 | + if (virtualnodes != state) {
|
---|
459 | + virtualnodes = state;
|
---|
460 | + repaint();
|
---|
461 | + }
|
---|
462 | + }
|
---|
463 |
|
---|
464 | - /**
|
---|
465 | - * Set the new dimension to the projection class. Also adjust the components
|
---|
466 | - * scale, if in autoScale mode.
|
---|
467 | - */
|
---|
468 | - public void recalculateCenterScale(BoundingXYVisitor box) {
|
---|
469 | - // -20 to leave some border
|
---|
470 | - int w = getWidth()-20;
|
---|
471 | - if (w < 20)
|
---|
472 | - w = 20;
|
---|
473 | - int h = getHeight()-20;
|
---|
474 | - if (h < 20)
|
---|
475 | - h = 20;
|
---|
476 | + public Boolean useVirtualNodes() {
|
---|
477 | + return virtualnodes;
|
---|
478 | + }
|
---|
479 |
|
---|
480 | - EastNorth oldCenter = center;
|
---|
481 | - double oldScale = this.scale;
|
---|
482 | + /**
|
---|
483 | + * Moves the layer to the given new position. No event is fired.
|
---|
484 | + * @param layer The layer to move
|
---|
485 | + * @param pos The new position of the layer
|
---|
486 | + */
|
---|
487 | + public void moveLayer(Layer layer, int pos) {
|
---|
488 | + int curLayerPos = layers.indexOf(layer);
|
---|
489 | + if (curLayerPos == -1)
|
---|
490 | + throw new IllegalArgumentException(tr("layer not in list."));
|
---|
491 | + if (pos == curLayerPos)
|
---|
492 | + return; // already in place.
|
---|
493 | + layers.remove(curLayerPos);
|
---|
494 | + if (pos >= layers.size())
|
---|
495 | + layers.add(layer);
|
---|
496 | + else
|
---|
497 | + layers.add(pos, layer);
|
---|
498 | + }
|
---|
499 |
|
---|
500 | - if (box == null || box.min == null || box.max == null || box.min.equals(box.max)) {
|
---|
501 | - // no bounds means whole world
|
---|
502 | - center = getProjection().latlon2eastNorth(new LatLon(0,0));
|
---|
503 | - EastNorth world = getProjection().latlon2eastNorth(new LatLon(Projection.MAX_LAT,Projection.MAX_LON));
|
---|
504 | - double scaleX = world.east()*2/w;
|
---|
505 | - double scaleY = world.north()*2/h;
|
---|
506 | - scale = Math.max(scaleX, scaleY); // minimum scale to see all of the screen
|
---|
507 | - } else {
|
---|
508 | - center = new EastNorth(box.min.east()/2+box.max.east()/2, box.min.north()/2+box.max.north()/2);
|
---|
509 | - double scaleX = (box.max.east()-box.min.east())/w;
|
---|
510 | - double scaleY = (box.max.north()-box.min.north())/h;
|
---|
511 | - scale = Math.max(scaleX, scaleY); // minimum scale to see all of the screen
|
---|
512 | - }
|
---|
513 | + /**
|
---|
514 | + * Draw the component.
|
---|
515 | + */
|
---|
516 | + @Override
|
---|
517 | + public void paint(Graphics g) {
|
---|
518 | + if (center == null)
|
---|
519 | + return; // no data loaded yet.
|
---|
520 |
|
---|
521 | - if (!center.equals(oldCenter))
|
---|
522 | - firePropertyChange("center", oldCenter, center);
|
---|
523 | - if (oldScale != scale)
|
---|
524 | - firePropertyChange("scale", oldScale, scale);
|
---|
525 | - repaint();
|
---|
526 | - }
|
---|
527 | + // re-create offscreen-buffer if we've been resized, otherwise
|
---|
528 | + // just re-use it.
|
---|
529 | + if (null == offscreenBuffer || offscreenBuffer.getWidth() != getWidth()
|
---|
530 | + || offscreenBuffer.getHeight() != getHeight())
|
---|
531 | + offscreenBuffer = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_ARGB);
|
---|
532 |
|
---|
533 | - /**
|
---|
534 | - * Add a listener for changes of active layer.
|
---|
535 | - * @param listener The listener that get added.
|
---|
536 | - * @deprecated Use Layer.listener.add instead.
|
---|
537 | - */
|
---|
538 | - @Deprecated public void addLayerChangeListener(LayerChangeListener listener) {
|
---|
539 | - if (listener != null)
|
---|
540 | - listeners.add(listener);
|
---|
541 | - }
|
---|
542 | + Graphics2D tempG = offscreenBuffer.createGraphics();
|
---|
543 | + tempG.setColor(Main.pref.getColor("background", Color.BLACK));
|
---|
544 | + tempG.fillRect(0, 0, getWidth(), getHeight());
|
---|
545 |
|
---|
546 | - /**
|
---|
547 | - * Remove the listener.
|
---|
548 | - * @param listener The listener that get removed from the list.
|
---|
549 | - * @deprecated Use Layer.listener.remove instead
|
---|
550 | - */
|
---|
551 | - @Deprecated public void removeLayerChangeListener(LayerChangeListener listener) {
|
---|
552 | - listeners.remove(listener);
|
---|
553 | - }
|
---|
554 | + for (int i = layers.size() - 1; i >= 0; --i) {
|
---|
555 | + Layer l = layers.get(i);
|
---|
556 | + if (l.visible/* && l != getActiveLayer()*/)
|
---|
557 | + l.paint(tempG, this);
|
---|
558 | + }
|
---|
559 |
|
---|
560 | - /**
|
---|
561 | - * @return An unmodificable list of all layers
|
---|
562 | - */
|
---|
563 | - public Collection<Layer> getAllLayers() {
|
---|
564 | - return Collections.unmodifiableCollection(layers);
|
---|
565 | - }
|
---|
566 | + /*if (getActiveLayer() != null && getActiveLayer().visible)
|
---|
567 | + getActiveLayer().paint(tempG, this);*/
|
---|
568 |
|
---|
569 | - /**
|
---|
570 | - * Set the active selection to the given value and raise an layerchange event.
|
---|
571 | - */
|
---|
572 | - public void setActiveLayer(Layer layer) {
|
---|
573 | - if (!layers.contains(layer))
|
---|
574 | - throw new IllegalArgumentException("Layer must be in layerlist");
|
---|
575 | - if (layer instanceof OsmDataLayer) {
|
---|
576 | - editLayer = (OsmDataLayer)layer;
|
---|
577 | - Main.ds = editLayer.data;
|
---|
578 | - }
|
---|
579 | - else
|
---|
580 | - Main.ds.setSelected();
|
---|
581 | - DataSet.fireSelectionChanged(Main.ds.getSelected());
|
---|
582 | - Layer old = activeLayer;
|
---|
583 | - activeLayer = layer;
|
---|
584 | - if (old != layer) {
|
---|
585 | - // TODO: Deprecated
|
---|
586 | - for (LayerChangeListener l : listeners)
|
---|
587 | - l.activeLayerChange(old, layer);
|
---|
588 | - for (Layer.LayerChangeListener l : Layer.listeners)
|
---|
589 | - l.activeLayerChange(old, layer);
|
---|
590 | - }
|
---|
591 | - repaint();
|
---|
592 | - }
|
---|
593 | + for (MapViewPaintable mvp : temporaryLayers) {
|
---|
594 | + mvp.paint(tempG, this);
|
---|
595 | + }
|
---|
596 |
|
---|
597 | - /**
|
---|
598 | - * @return The current active layer
|
---|
599 | - */
|
---|
600 | - public Layer getActiveLayer() {
|
---|
601 | - return activeLayer;
|
---|
602 | - }
|
---|
603 | + // draw world borders
|
---|
604 | + tempG.setColor(Color.WHITE);
|
---|
605 | + Bounds b = new Bounds();
|
---|
606 | + Point min = getPoint(getProjection().latlon2eastNorth(b.min));
|
---|
607 | + Point max = getPoint(getProjection().latlon2eastNorth(b.max));
|
---|
608 | + int x1 = Math.min(min.x, max.x);
|
---|
609 | + int y1 = Math.min(min.y, max.y);
|
---|
610 | + int x2 = Math.max(min.x, max.x);
|
---|
611 | + int y2 = Math.max(min.y, max.y);
|
---|
612 | + if (x1 > 0 || y1 > 0 || x2 < getWidth() || y2 < getHeight())
|
---|
613 | + tempG.drawRect(x1, y1, x2 - x1 + 1, y2 - y1 + 1);
|
---|
614 |
|
---|
615 | - /**
|
---|
616 | - * In addition to the base class funcitonality, this keep trak of the autoscale
|
---|
617 | - * feature.
|
---|
618 | - */
|
---|
619 | - @Override public void zoomTo(EastNorth newCenter, double scale) {
|
---|
620 | - EastNorth oldCenter = center;
|
---|
621 | - double oldScale = this.scale;
|
---|
622 | - super.zoomTo(newCenter, scale);
|
---|
623 | - if ((oldCenter == null && center != null) || !oldCenter.equals(center))
|
---|
624 | - firePropertyChange("center", oldCenter, center);
|
---|
625 | - if (oldScale != scale)
|
---|
626 | - firePropertyChange("scale", oldScale, scale);
|
---|
627 | - }
|
---|
628 | -
|
---|
629 | - public boolean addTemporaryLayer(MapViewPaintable mvp) {
|
---|
630 | - if (temporaryLayers.contains(mvp)) return false;
|
---|
631 | - return temporaryLayers.add(mvp);
|
---|
632 | - }
|
---|
633 | -
|
---|
634 | - public boolean removeTemporaryLayer(MapViewPaintable mvp) {
|
---|
635 | - return temporaryLayers.remove(mvp);
|
---|
636 | - }
|
---|
637 | + if (playHeadMarker != null)
|
---|
638 | + playHeadMarker.paint(tempG, this);
|
---|
639 | +
|
---|
640 | + g.drawImage(offscreenBuffer, 0, 0, null);
|
---|
641 | + super.paint(g);
|
---|
642 | + }
|
---|
643 | +
|
---|
644 | + /**
|
---|
645 | + * Set the new dimension to the projection class. Also adjust the components
|
---|
646 | + * scale, if in autoScale mode.
|
---|
647 | + */
|
---|
648 | + public void recalculateCenterScale(BoundingXYVisitor box) {
|
---|
649 | + // -20 to leave some border
|
---|
650 | + int w = getWidth() - 20;
|
---|
651 | + if (w < 20)
|
---|
652 | + w = 20;
|
---|
653 | + int h = getHeight() - 20;
|
---|
654 | + if (h < 20)
|
---|
655 | + h = 20;
|
---|
656 | +
|
---|
657 | + EastNorth oldCenter = center;
|
---|
658 | + double oldScale = this.scale;
|
---|
659 | +
|
---|
660 | + if (box == null || box.min == null || box.max == null || box.min.equals(box.max)) {
|
---|
661 | + // no bounds means whole world
|
---|
662 | + center = getProjection().latlon2eastNorth(new LatLon(0, 0));
|
---|
663 | + EastNorth world = getProjection().latlon2eastNorth(new LatLon(Projection.MAX_LAT, Projection.MAX_LON));
|
---|
664 | + double scaleX = world.east() * 2 / w;
|
---|
665 | + double scaleY = world.north() * 2 / h;
|
---|
666 | + scale = Math.max(scaleX, scaleY); // minimum scale to see all of the screen
|
---|
667 | + } else {
|
---|
668 | + center = new EastNorth(box.min.east() / 2 + box.max.east() / 2, box.min.north() / 2 + box.max.north() / 2);
|
---|
669 | + double scaleX = (box.max.east() - box.min.east()) / w;
|
---|
670 | + double scaleY = (box.max.north() - box.min.north()) / h;
|
---|
671 | + scale = Math.max(scaleX, scaleY); // minimum scale to see all of the screen
|
---|
672 | + }
|
---|
673 | +
|
---|
674 | + if (!center.equals(oldCenter))
|
---|
675 | + firePropertyChange("center", oldCenter, center);
|
---|
676 | + if (oldScale != scale)
|
---|
677 | + firePropertyChange("scale", oldScale, scale);
|
---|
678 | + repaint();
|
---|
679 | + }
|
---|
680 | +
|
---|
681 | + /**
|
---|
682 | + * Add a listener for changes of active layer.
|
---|
683 | + * @param listener The listener that get added.
|
---|
684 | + * @deprecated Use Layer.listener.add instead.
|
---|
685 | + */
|
---|
686 | + @Deprecated
|
---|
687 | + public void addLayerChangeListener(LayerChangeListener listener) {
|
---|
688 | + if (listener != null)
|
---|
689 | + listeners.add(listener);
|
---|
690 | + }
|
---|
691 | +
|
---|
692 | + /**
|
---|
693 | + * Remove the listener.
|
---|
694 | + * @param listener The listener that get removed from the list.
|
---|
695 | + * @deprecated Use Layer.listener.remove instead
|
---|
696 | + */
|
---|
697 | + @Deprecated
|
---|
698 | + public void removeLayerChangeListener(LayerChangeListener listener) {
|
---|
699 | + listeners.remove(listener);
|
---|
700 | + }
|
---|
701 | +
|
---|
702 | + /**
|
---|
703 | + * @return An unmodificable list of all layers
|
---|
704 | + */
|
---|
705 | + public Collection<Layer> getAllLayers() {
|
---|
706 | + return Collections.unmodifiableCollection(layers);
|
---|
707 | + }
|
---|
708 | +
|
---|
709 | + /**
|
---|
710 | + * Set the active selection to the given value and raise an layerchange event.
|
---|
711 | + */
|
---|
712 | + public void setActiveLayer(Layer layer) {
|
---|
713 | + if (!layers.contains(layer))
|
---|
714 | + throw new IllegalArgumentException("Layer must be in layerlist");
|
---|
715 | + if (layer instanceof OsmDataLayer) {
|
---|
716 | + editLayer = (OsmDataLayer) layer;
|
---|
717 | + Main.ds = editLayer.data;
|
---|
718 | + } else
|
---|
719 | + Main.ds.setSelected();
|
---|
720 | + DataSet.fireSelectionChanged(Main.ds.getSelected());
|
---|
721 | + Layer old = activeLayer;
|
---|
722 | + activeLayer = layer;
|
---|
723 | + if (old != layer) {
|
---|
724 | + // TODO: Deprecated
|
---|
725 | + for (LayerChangeListener l : listeners)
|
---|
726 | + l.activeLayerChange(old, layer);
|
---|
727 | + for (Layer.LayerChangeListener l : Layer.listeners)
|
---|
728 | + l.activeLayerChange(old, layer);
|
---|
729 | + }
|
---|
730 | + repaint();
|
---|
731 | + }
|
---|
732 | +
|
---|
733 | + /**
|
---|
734 | + * @return The current active layer
|
---|
735 | + */
|
---|
736 | + public Layer getActiveLayer() {
|
---|
737 | + return activeLayer;
|
---|
738 | + }
|
---|
739 | +
|
---|
740 | + /**
|
---|
741 | + * In addition to the base class funcitonality, this keep trak of the autoscale
|
---|
742 | + * feature.
|
---|
743 | + */
|
---|
744 | + @Override
|
---|
745 | + public void zoomTo(EastNorth newCenter, double scale) {
|
---|
746 | + EastNorth oldCenter = center;
|
---|
747 | + double oldScale = this.scale;
|
---|
748 | + super.zoomTo(newCenter, scale);
|
---|
749 | + if ((oldCenter == null && center != null) || !oldCenter.equals(center))
|
---|
750 | + firePropertyChange("center", oldCenter, center);
|
---|
751 | + if (oldScale != scale)
|
---|
752 | + firePropertyChange("scale", oldScale, scale);
|
---|
753 | + }
|
---|
754 | +
|
---|
755 | + public boolean addTemporaryLayer(MapViewPaintable mvp) {
|
---|
756 | + if (temporaryLayers.contains(mvp))
|
---|
757 | + return false;
|
---|
758 | + return temporaryLayers.add(mvp);
|
---|
759 | + }
|
---|
760 | +
|
---|
761 | + public boolean removeTemporaryLayer(MapViewPaintable mvp) {
|
---|
762 | + return temporaryLayers.remove(mvp);
|
---|
763 | + }
|
---|
764 | }
|
---|