source: josm/trunk/src/org/openstreetmap/josm/gui/dialogs/RelationListDialog.java@ 2503

Last change on this file since 2503 was 2503, checked in by Gubaer, 14 years ago

fixed #4009: New relation does not show up in relation editor
  • Property svn:eol-style set to native
File size: 28.2 KB
Line 
1package org.openstreetmap.josm.gui.dialogs;
2
3import static org.openstreetmap.josm.gui.help.HelpUtil.ht;
4import static org.openstreetmap.josm.tools.I18n.tr;
5
6import java.awt.BorderLayout;
7import java.awt.GridLayout;
8import java.awt.Point;
9import java.awt.event.ActionEvent;
10import java.awt.event.KeyEvent;
11import java.awt.event.MouseAdapter;
12import java.awt.event.MouseEvent;
13import java.util.ArrayList;
14import java.util.Collection;
15import java.util.Collections;
16import java.util.Comparator;
17import java.util.HashSet;
18import java.util.List;
19import java.util.Set;
20
21import javax.swing.AbstractAction;
22import javax.swing.AbstractListModel;
23import javax.swing.DefaultListSelectionModel;
24import javax.swing.JList;
25import javax.swing.JPanel;
26import javax.swing.JPopupMenu;
27import javax.swing.JScrollPane;
28import javax.swing.KeyStroke;
29import javax.swing.ListSelectionModel;
30import javax.swing.SwingUtilities;
31import javax.swing.event.ListSelectionEvent;
32import javax.swing.event.ListSelectionListener;
33
34import org.openstreetmap.josm.Main;
35import org.openstreetmap.josm.data.osm.DataSetListener;
36import org.openstreetmap.josm.data.osm.NameFormatter;
37import org.openstreetmap.josm.data.osm.Node;
38import org.openstreetmap.josm.data.osm.OsmPrimitive;
39import org.openstreetmap.josm.data.osm.Relation;
40import org.openstreetmap.josm.data.osm.RelationMember;
41import org.openstreetmap.josm.data.osm.Way;
42import org.openstreetmap.josm.gui.DefaultNameFormatter;
43import org.openstreetmap.josm.gui.OsmPrimitivRenderer;
44import org.openstreetmap.josm.gui.SideButton;
45import org.openstreetmap.josm.gui.dialogs.relation.GenericRelationEditor;
46import org.openstreetmap.josm.gui.dialogs.relation.RelationEditor;
47import org.openstreetmap.josm.gui.layer.DataChangeListener;
48import org.openstreetmap.josm.gui.layer.Layer;
49import org.openstreetmap.josm.gui.layer.OsmDataLayer;
50import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
51import org.openstreetmap.josm.tools.GBC;
52import org.openstreetmap.josm.tools.ImageProvider;
53import org.openstreetmap.josm.tools.Shortcut;
54
55/**
56 * A dialog showing all known relations, with buttons to add, edit, and
57 * delete them.
58 *
59 * We don't have such dialogs for nodes, segments, and ways, because those
60 * objects are visible on the map and can be selected there. Relations are not.
61 */
62public class RelationListDialog extends ToggleDialog implements LayerChangeListener, DataSetListener, DataChangeListener {
63 //private static final Logger logger = Logger.getLogger(RelationListDialog.class.getName());
64
65 /** The display list. */
66 private JList displaylist;
67 /** the list model used */
68 private RelationListModel model;
69
70 /** the edit action */
71 private EditAction editAction;
72 /** the delete action */
73 private DeleteAction deleteAction;
74 private NewAction newAction;
75 /** the popup menu */
76 private RelationDialogPopupMenu popupMenu;
77
78 /**
79 * constructor
80 */
81 public RelationListDialog() {
82 super(tr("Relations"), "relationlist", tr("Open a list of all relations."),
83 Shortcut.registerShortcut("subwindow:relations", tr("Toggle: {0}", tr("Relations")), KeyEvent.VK_R, Shortcut.GROUP_LAYER), 150);
84
85 // create the list of relations
86 //
87 DefaultListSelectionModel selectionModel = new DefaultListSelectionModel();
88 model = new RelationListModel(selectionModel);
89 displaylist = new JList(model);
90 displaylist.setSelectionModel(selectionModel);
91 displaylist.setCellRenderer(new OsmPrimitivRenderer());
92 displaylist.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
93 displaylist.addMouseListener(new MouseEventHandler());
94 add(new JScrollPane(displaylist), BorderLayout.CENTER);
95
96 // create the panel with buttons
97 //
98 JPanel buttonPanel = new JPanel(new GridLayout(1,3));
99
100 // the new action
101 //
102 newAction = new NewAction();
103 buttonPanel.add(new SideButton(newAction), GBC.std());
104
105 // the edit action
106 //
107 editAction = new EditAction();
108 displaylist.addListSelectionListener(editAction);
109 buttonPanel.add(new SideButton(editAction), GBC.std());
110
111 // the duplicate action
112 //
113 DuplicateAction duplicateAction = new DuplicateAction();
114 displaylist.addListSelectionListener(duplicateAction);
115 buttonPanel.add(new SideButton(duplicateAction), GBC.std());
116
117 // the delete action
118 //
119 deleteAction = new DeleteAction();
120 displaylist.addListSelectionListener(deleteAction);
121 buttonPanel.add(new SideButton(deleteAction), GBC.eol());
122
123 // the select action
124 //
125 SelectAction selectAction = new SelectAction();
126 displaylist.addListSelectionListener(selectAction);
127 buttonPanel.add(new SideButton(selectAction), GBC.eol());
128
129 add(buttonPanel, BorderLayout.SOUTH);
130
131 // activate DEL in the list of relations
132 displaylist.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE,0), "deleteRelation");
133 displaylist.getActionMap().put("deleteRelation", deleteAction);
134
135 popupMenu = new RelationDialogPopupMenu();
136 }
137
138 @Override public void showNotify() {
139 Layer.listeners.add(this);
140 Layer.listeners.add(newAction);
141 // Register as a data set listener for the current edit layer only.
142 // See also activeLayerChanged
143 if (Main.main.getEditLayer() != null) {
144 Main.main.getEditLayer().data.addDataSetListener(this);
145 }
146 }
147
148 @Override public void hideNotify() {
149 Layer.listeners.remove(this);
150 Layer.listeners.remove(newAction);
151 Layer.listeners.add(newAction);
152 // unregistering from *all* data layer is somewhat overkill but it
153 // doesn't harm either.
154 for (OsmDataLayer layer:Main.map.mapView.getLayersOfType(OsmDataLayer.class)) {
155 layer.data.removeDataSetListener(this);
156 }
157 }
158
159 /**
160 * Initializes the relation list dialog from a layer. If <code>layer</code> is null
161 * or if it isn't an {@see OsmDataLayer} the dialog is reset to an empty dialog.
162 * Otherwise it is initialized with the list of non-deleted and visible relations
163 * in the layer's dataset.
164 *
165 * @param layer the layer. May be null.
166 */
167 protected void initFromLayer(Layer layer) {
168 if (layer == null || ! (layer instanceof OsmDataLayer)) {
169 model.setRelations(null);
170 return;
171 }
172 OsmDataLayer l = (OsmDataLayer)layer;
173 model.setRelations(l.data.getRelations());
174 if(model.getSize() > 0) {
175 setTitle(tr("Relations: {0}", model.getSize()));
176 } else {
177 setTitle(tr("Relations"));
178 }
179 }
180
181 /**
182 * Adds a selection listener to the relation list.
183 *
184 * @param listener the listener to add
185 */
186 public void addListSelectionListener(ListSelectionListener listener) {
187 displaylist.addListSelectionListener(listener);
188 }
189
190 /**
191 * Removes a selection listener from the relation list.
192 *
193 * @param listener the listener to remove
194 */
195 public void removeListSelectionListener(ListSelectionListener listener) {
196 displaylist.removeListSelectionListener(listener);
197 }
198
199 /**
200 * @return The selected relation in the list
201 */
202 private Relation getSelected() {
203 if(model.getSize() == 1) {
204 displaylist.setSelectedIndex(0);
205 }
206 return (Relation) displaylist.getSelectedValue();
207 }
208
209 /**
210 * Selects the relation <code>relation</code> in the list of relations.
211 *
212 * @param relation the relation
213 */
214 public void selectRelation(Relation relation) {
215 if (relation == null) {
216 model.setSelectedRelations(null);
217 } else {
218 model.setSelectedRelations(Collections.singletonList(relation));
219 }
220 }
221
222 class MouseEventHandler extends MouseAdapter {
223 protected void setCurrentRelationAsSelection() {
224 Main.main.getCurrentDataSet().setSelected((Relation)displaylist.getSelectedValue());
225 }
226
227 protected void editCurrentRelation() {
228 new EditAction().launchEditor(getSelected());
229 }
230
231 @Override public void mouseClicked(MouseEvent e) {
232 if (e.getClickCount() == 2 && SwingUtilities.isLeftMouseButton(e)) {
233 if (e.isControlDown()) {
234 editCurrentRelation();
235 } else {
236 setCurrentRelationAsSelection();
237 }
238 }
239 }
240 private void openPopup(MouseEvent e) {
241 Point p = e.getPoint();
242 int index = displaylist.locationToIndex(p);
243 if (index < 0) return;
244 if (!displaylist.getCellBounds(index, index).contains(e.getPoint()))
245 return;
246 if (! displaylist.isSelectedIndex(index)) {
247 displaylist.setSelectedIndex(index);
248 }
249 popupMenu.show(RelationListDialog.this, p.x, p.y-3);
250 }
251 @Override public void mousePressed(MouseEvent e) {
252 if (e.isPopupTrigger()) {
253 openPopup(e);
254 }
255 }
256 @Override public void mouseReleased(MouseEvent e) {
257 if (e.isPopupTrigger()) {
258 openPopup(e);
259 }
260 }
261 }
262
263 /**
264 * The edit action
265 *
266 */
267 class EditAction extends AbstractAction implements ListSelectionListener{
268 public EditAction() {
269 putValue(SHORT_DESCRIPTION,tr( "Open an editor for the selected relation"));
270 //putValue(NAME, tr("Edit"));
271 putValue(SMALL_ICON, ImageProvider.get("dialogs", "edit"));
272 setEnabled(false);
273 }
274 protected Collection<RelationMember> getMembersForCurrentSelection(Relation r) {
275 Collection<RelationMember> members = new HashSet<RelationMember>();
276 Collection<OsmPrimitive> selection = Main.map.mapView.getEditLayer().data.getSelected();
277 for (RelationMember member: r.getMembers()) {
278 if (selection.contains(member.getMember())) {
279 members.add(member);
280 }
281 }
282 return members;
283 }
284
285 public void launchEditor(Relation toEdit) {
286 if (toEdit == null)
287 return;
288 RelationEditor.getEditor(Main.map.mapView.getEditLayer(),toEdit, getMembersForCurrentSelection(toEdit)).setVisible(true);
289 }
290
291 public void actionPerformed(ActionEvent e) {
292 if (!isEnabled())
293 return;
294 launchEditor(getSelected());
295 }
296
297 public void valueChanged(ListSelectionEvent e) {
298 setEnabled(displaylist.getSelectedIndices() != null && displaylist.getSelectedIndices().length == 1);
299 }
300 }
301
302 /**
303 * The delete action
304 *
305 */
306 class DeleteAction extends AbstractAction implements ListSelectionListener {
307 class AbortException extends Exception {}
308
309 public DeleteAction() {
310 putValue(SHORT_DESCRIPTION,tr("Delete the selected relation"));
311 //putValue(NAME, tr("Delete"));
312 putValue(SMALL_ICON, ImageProvider.get("dialogs", "delete"));
313 setEnabled(false);
314 }
315
316 protected void deleteRelation(Relation toDelete) {
317 if (toDelete == null)
318 return;
319 org.openstreetmap.josm.actions.mapmode.DeleteAction.deleteRelation(
320 Main.main.getEditLayer(),
321 toDelete
322 );
323 }
324
325 public void actionPerformed(ActionEvent e) {
326 if (!isEnabled()) return;
327 int [] idx = displaylist.getSelectedIndices();
328 ArrayList<Relation> toDelete = new ArrayList<Relation>(idx.length);
329 for (int i: idx) {
330 toDelete.add(model.getRelation(i));
331 }
332 for (Relation r: toDelete) {
333 deleteRelation(r);
334 }
335 }
336
337 public void valueChanged(ListSelectionEvent e) {
338 setEnabled(displaylist.getSelectedIndices() != null && displaylist.getSelectedIndices().length > 0);
339 }
340 }
341
342 /**
343 * The action for creating a new relation
344 *
345 */
346 class NewAction extends AbstractAction implements LayerChangeListener{
347 public NewAction() {
348 putValue(SHORT_DESCRIPTION,tr("Create a new relation"));
349 //putValue(NAME, tr("New"));
350 putValue(SMALL_ICON, ImageProvider.get("dialogs", "addrelation"));
351 setEnabled(false);
352 }
353
354 public void run() {
355 RelationEditor.getEditor(Main.main.getEditLayer(),null, null).setVisible(true);
356 }
357
358 public void actionPerformed(ActionEvent e) {
359 run();
360 }
361
362 protected void updateEnabledState() {
363 setEnabled(Main.main != null && Main.main.getEditLayer() != null);
364 }
365
366 public void activeLayerChange(Layer oldLayer, Layer newLayer) {
367 updateEnabledState();
368 }
369
370 public void layerAdded(Layer newLayer) {
371 updateEnabledState();
372 }
373
374 public void layerRemoved(Layer oldLayer) {
375 updateEnabledState();
376 }
377 }
378
379 /**
380 * Creates a new relation with a copy of the current editor state
381 *
382 */
383 class DuplicateAction extends AbstractAction implements ListSelectionListener {
384 public DuplicateAction() {
385 putValue(SHORT_DESCRIPTION, tr("Create a copy of this relation and open it in another editor window"));
386 putValue(SMALL_ICON, ImageProvider.get("duplicate"));
387 //putValue(NAME, tr("Duplicate"));
388 updateEnabledState();
389 }
390
391 public void launchEditorForDuplicate(Relation original) {
392 Relation copy = new Relation(original, true);
393 copy.setModified(true);
394 RelationEditor editor = RelationEditor.getEditor(
395 Main.main.getEditLayer(),
396 copy,
397 null /* no selected members */
398 );
399 editor.setVisible(true);
400 }
401
402 public void actionPerformed(ActionEvent e) {
403 if (!isEnabled())
404 return;
405 launchEditorForDuplicate(getSelected());
406 }
407
408 protected void updateEnabledState() {
409 setEnabled(displaylist.getSelectedIndices() != null && displaylist.getSelectedIndices().length == 1);
410 }
411
412 public void valueChanged(ListSelectionEvent e) {
413 updateEnabledState();
414 }
415 }
416
417 /**
418 * Sets the current selection to the list of relations selected in this dialog
419 *
420 */
421 class SelectAction extends AbstractAction implements ListSelectionListener{
422 public SelectAction() {
423 putValue(SHORT_DESCRIPTION,tr("Set the current selection to the list of selected relations"));
424 putValue(SMALL_ICON, ImageProvider.get("dialogs", "select"));
425 setEnabled(false);
426 }
427
428 public void actionPerformed(ActionEvent e) {
429 if (!isEnabled()) return;
430 int [] idx = displaylist.getSelectedIndices();
431 if (idx == null || idx.length == 0) return;
432 ArrayList<OsmPrimitive> selection = new ArrayList<OsmPrimitive>(idx.length);
433 for (int i: idx) {
434 selection.add(model.getRelation(i));
435 }
436 Main.map.mapView.getEditLayer().data.setSelected(selection);
437 }
438
439 public void valueChanged(ListSelectionEvent e) {
440 setEnabled(displaylist.getSelectedIndices() != null && displaylist.getSelectedIndices().length > 0);
441 }
442 }
443
444 /**
445 * Sets the current selection to the list of relations selected in this dialog
446 *
447 */
448 class SelectMembersAction extends AbstractAction implements ListSelectionListener{
449 public SelectMembersAction() {
450 putValue(SHORT_DESCRIPTION,tr("Select the members of all selected relations"));
451 putValue(SMALL_ICON, ImageProvider.get("selectall"));
452 putValue(NAME, tr("Select members"));
453 updateEnabledState();
454 }
455
456 public void actionPerformed(ActionEvent e) {
457 if (!isEnabled()) return;
458 List<Relation> relations = model.getSelectedRelations();
459 HashSet<OsmPrimitive> members = new HashSet<OsmPrimitive>();
460 for(Relation r: relations) {
461 members.addAll(r.getMemberPrimitives());
462 }
463 Main.map.mapView.getEditLayer().data.setSelected(members);
464 }
465
466 protected void updateEnabledState() {
467 setEnabled(displaylist.getSelectedIndices() != null && displaylist.getSelectedIndices().length > 0);
468 }
469
470 public void valueChanged(ListSelectionEvent e) {
471 updateEnabledState();
472 }
473 }
474
475 /**
476 * The action for downloading members of all selected relations
477 *
478 */
479 class DownloadMembersAction extends AbstractAction implements ListSelectionListener{
480
481 public DownloadMembersAction() {
482 putValue(SHORT_DESCRIPTION,tr("Download all members of the selected relations"));
483 putValue(NAME, tr("Download members"));
484 putValue(SMALL_ICON, ImageProvider.get("dialogs", "downloadincomplete"));
485 putValue("help", ht("/Dialog/RelationList#DownloadMembers"));
486 updateEnabledState();
487 }
488
489 protected void updateEnabledState() {
490 setEnabled(! model.getSelectedNonNewRelations().isEmpty());
491 }
492
493 public void valueChanged(ListSelectionEvent e) {
494 updateEnabledState();
495 }
496
497 public void actionPerformed(ActionEvent e) {
498 List<Relation> relations = model.getSelectedNonNewRelations();
499 if (relations.isEmpty())
500 return;
501 Main.worker.submit(new GenericRelationEditor.DownloadTask(
502 model.getSelectedNonNewRelations(),
503 Main.map.mapView.getEditLayer(), null));
504 }
505 }
506
507 /**
508 * The list model for the list of relations displayed in the relation list
509 * dialog.
510 *
511 */
512 private static class RelationListModel extends AbstractListModel {
513 /** the list of relations managaged by this model. Should never be null */
514 private ArrayList<Relation> relations;
515 private DefaultListSelectionModel selectionModel;
516
517 public RelationListModel(DefaultListSelectionModel selectionModel) {
518 this.selectionModel = selectionModel;
519 relations = new ArrayList<Relation>();
520 }
521
522 public Relation getRelation(int idx) {
523 return relations.get(idx);
524 }
525
526 public synchronized void setRelations(Collection<Relation> relations) {
527 List<Relation> sel = getSelectedRelations();
528 if (relations == null) {
529 this.relations.clear();
530 } else {
531 this.relations = new ArrayList<Relation>(relations.size());
532 for (Relation r: relations) {
533 if (! r.isDeleted() && r.isVisible() && !r.incomplete) {
534 this.relations.add(r);
535 }
536 }
537 }
538 sort();
539 fireIntervalAdded(this, 0, getSize());
540 setSelectedRelations(sel);
541 }
542
543 public synchronized void sort() {
544 Collections.sort(
545 relations,
546 new Comparator<Relation>() {
547 NameFormatter formatter = DefaultNameFormatter.getInstance();
548
549 public int compare(Relation r1, Relation r2) {
550 return r1.getDisplayName(formatter).compareTo(r2.getDisplayName(formatter));
551 }
552 }
553 );
554 }
555
556 /**
557 * Add all relations in <code>addedPrimitives</code> to the model for the
558 * relation list dialog
559 *
560 * @param addedPrimitives the collection of added primitives. May include nodes,
561 * ways, and relations.
562 */
563 public synchronized void addRelations(Collection<? extends OsmPrimitive> addedPrimitives) {
564 if (addedPrimitives == null || addedPrimitives.isEmpty()) return;
565 boolean added = false;
566 if (relations == null) {
567 relations = new ArrayList<Relation>();
568 }
569 for (OsmPrimitive p: addedPrimitives) {
570 if (! (p instanceof Relation)) {
571 continue;
572 }
573 if (relations.contains(p)) {
574 continue;
575 }
576 relations.add((Relation)p);
577 added = true;
578 }
579 if (added) {
580 List<Relation> sel = getSelectedRelations();
581 sort();
582 fireIntervalAdded(this, 0, getSize());
583 setSelectedRelations(sel);
584 }
585 }
586
587 /**
588 * Removes all relations in <code>removedPrimitives</code> from the model
589 *
590 * @param removedPrimitives the removed primitives. May include nodes, ways,
591 * and relations
592 */
593 public synchronized void removeRelations(Collection<? extends OsmPrimitive> removedPrimitives) {
594 if (removedPrimitives == null) return;
595 // extract the removed relations
596 //
597 Set<Relation> removedRelations = new HashSet<Relation>();
598 for (OsmPrimitive p: removedPrimitives) {
599 if (! (p instanceof Relation)) {
600 continue;
601 }
602 removedRelations.add((Relation)p);
603 }
604 if (removedRelations.isEmpty())
605 return;
606 int size = relations.size();
607 relations.removeAll(removedRelations);
608 if (size != relations.size()) {
609 List<Relation> sel = getSelectedRelations();
610 sort();
611 fireContentsChanged(this, 0, getSize());
612 setSelectedRelations(sel);
613 }
614 }
615
616 public Object getElementAt(int index) {
617 return relations.get(index);
618 }
619
620 public int getSize() {
621 return relations.size();
622 }
623
624 /**
625 * Replies the list of selected, non-new relations. Empty list,
626 * if there are no selected, non-new relations.
627 *
628 * @return the list of selected, non-new relations.
629 */
630 public List<Relation> getSelectedNonNewRelations() {
631 ArrayList<Relation> ret = new ArrayList<Relation>();
632 for (int i=0; i<getSize();i++) {
633 if (!selectionModel.isSelectedIndex(i)) {
634 continue;
635 }
636 if (relations.get(i).isNew()) {
637 continue;
638 }
639 ret.add(relations.get(i));
640 }
641 return ret;
642 }
643
644 /**
645 * Replies the list of selected relations. Empty list,
646 * if there are no selected relations.
647 *
648 * @return the list of selected, non-new relations.
649 */
650 public List<Relation> getSelectedRelations() {
651 ArrayList<Relation> ret = new ArrayList<Relation>();
652 for (int i=0; i<getSize();i++) {
653 if (!selectionModel.isSelectedIndex(i)) {
654 continue;
655 }
656 ret.add(relations.get(i));
657 }
658 return ret;
659 }
660
661 /**
662 * Sets the selected relations.
663 *
664 * @return sel the list of selected relations
665 */
666 public synchronized void setSelectedRelations(List<Relation> sel) {
667 selectionModel.clearSelection();
668 if (sel == null || sel.isEmpty() || relations == null)
669 return;
670 for (Relation r: sel) {
671 int i = relations.indexOf(r);
672 if (i<0) {
673 continue;
674 }
675 selectionModel.addSelectionInterval(i,i);
676 }
677 }
678 }
679
680 class RelationDialogPopupMenu extends JPopupMenu {
681 protected void build() {
682 // -- download members action
683 //
684 DownloadMembersAction downloadMembersAction = new DownloadMembersAction();
685 displaylist.addListSelectionListener(downloadMembersAction);
686 add(downloadMembersAction);
687
688 // -- select members action
689 //
690 SelectMembersAction selectMembersAction = new SelectMembersAction();
691 displaylist.addListSelectionListener(selectMembersAction);
692 add(selectMembersAction);
693 }
694
695 public RelationDialogPopupMenu() {
696 build();
697 }
698 }
699
700 /* ---------------------------------------------------------------------------------- */
701 /* LayerChangeListener */
702 /* ---------------------------------------------------------------------------------- */
703 public void activeLayerChange(Layer a, Layer b) {
704 initFromLayer(b);
705 if (a != null && a instanceof OsmDataLayer) {
706 ((OsmDataLayer)a).data.removeDataSetListener(this);
707 ((OsmDataLayer)a).listenerDataChanged.remove(this);
708 }
709 if (b != null && b instanceof OsmDataLayer) {
710 ((OsmDataLayer)b).data.addDataSetListener(this);
711 ((OsmDataLayer)b).listenerDataChanged.add(this);
712 }
713
714 }
715 public void layerRemoved(Layer a) {/* irrelevant in this context */}
716 public void layerAdded(Layer a) {/* irrelevant in this context */}
717
718
719 /* ---------------------------------------------------------------------------------- */
720 /* DataSetListener */
721 /* ---------------------------------------------------------------------------------- */
722
723 public void nodeMoved(Node node) {/* irrelevant in this context */}
724
725 public void wayNodesChanged(Way way) {/* irrelevant in this context */}
726
727 public void primtivesAdded(final Collection<? extends OsmPrimitive> added) {
728 Runnable task = new Runnable() {
729 public void run() {
730 model.addRelations(added);
731 }
732 };
733 if (SwingUtilities.isEventDispatchThread()) {
734 task.run();
735 } else {
736 SwingUtilities.invokeLater(task);
737 }
738 }
739
740 public void primtivesRemoved(final Collection<? extends OsmPrimitive> removed) {
741 Runnable task = new Runnable() {
742 public void run() {
743 model.removeRelations(removed);
744 }
745 };
746 if (SwingUtilities.isEventDispatchThread()) {
747 task.run();
748 } else {
749 SwingUtilities.invokeLater(task);
750 }
751 }
752
753 public void relationMembersChanged(final Relation r) {
754 Runnable task = new Runnable() {
755 public void run() {
756 List<Relation> sel = model.getSelectedRelations();
757 model.sort();
758 model.setSelectedRelations(sel);
759 displaylist.repaint();
760 }
761 };
762 if (SwingUtilities.isEventDispatchThread()) {
763 task.run();
764 } else {
765 SwingUtilities.invokeLater(task);
766 }
767 }
768
769 public void tagsChanged(OsmPrimitive prim) {
770 if (prim == null || ! (prim instanceof Relation))
771 return;
772 Runnable task = new Runnable() {
773 public void run() {
774 // trigger a sort of the relation list because the display name may
775 // have changed
776 //
777 List<Relation> sel = model.getSelectedRelations();
778 model.sort();
779 model.setSelectedRelations(sel);
780 displaylist.repaint();
781 }
782 };
783 if (SwingUtilities.isEventDispatchThread()) {
784 task.run();
785 } else {
786 SwingUtilities.invokeLater(task);
787 }
788 }
789
790 public void dataChanged() {
791 Layer l = Main.main.getEditLayer();
792 if (l != null) {
793 initFromLayer(l);
794 }
795 }
796
797 /* ---------------------------------------------------------------------------------- */
798 /* DataSetListener */
799 /* ---------------------------------------------------------------------------------- */
800 public void dataChanged(OsmDataLayer l) {
801 if (l != null && l == Main.main.getEditLayer()) {
802 initFromLayer(l);
803 }
804 }
805}
Note: See TracBrowser for help on using the repository browser.