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

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

fixed #3997: relation-list does not update
RelationListDialog now listening to dataChanged events too
  • 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 private ArrayList<Relation> relations;
514 private DefaultListSelectionModel selectionModel;
515
516 public RelationListModel(DefaultListSelectionModel selectionModel) {
517 this.selectionModel = selectionModel;
518 }
519
520 public Relation getRelation(int idx) {
521 return relations.get(idx);
522 }
523
524 public synchronized void setRelations(Collection<Relation> relations) {
525 List<Relation> sel = getSelectedRelations();
526 if (relations == null) {
527 this.relations = null;
528 } else {
529 this.relations = new ArrayList<Relation>(relations.size());
530 for (Relation r: relations) {
531 if (! r.isDeleted() && r.isVisible() && !r.incomplete) {
532 this.relations.add(r);
533 }
534 }
535 }
536 sort();
537 fireIntervalAdded(this, 0, getSize());
538 setSelectedRelations(sel);
539 }
540
541 public synchronized void sort() {
542 if (relations == null) return;
543 Collections.sort(
544 relations,
545 new Comparator<Relation>() {
546 NameFormatter formatter = DefaultNameFormatter.getInstance();
547
548 public int compare(Relation r1, Relation r2) {
549 return r1.getDisplayName(formatter).compareTo(r2.getDisplayName(formatter));
550 }
551 }
552 );
553 }
554
555 /**
556 * Add all relations in <code>addedPrimitives</code> to the model for the
557 * relation list dialog
558 *
559 * @param addedPrimitives the collection of added primitives. May include nodes,
560 * ways, and relations.
561 */
562 public synchronized void addRelations(Collection<? extends OsmPrimitive> addedPrimitives) {
563 if (addedPrimitives == null || addedPrimitives.isEmpty()) return;
564 boolean added = false;
565 for (OsmPrimitive p: addedPrimitives) {
566 if (! (p instanceof Relation)) {
567 continue;
568 }
569 if (relations.contains(p)) {
570 continue;
571 }
572 relations.add((Relation)p);
573 added = true;
574 }
575 if (added) {
576 List<Relation> sel = getSelectedRelations();
577 sort();
578 fireIntervalAdded(this, 0, getSize());
579 setSelectedRelations(sel);
580 }
581 }
582
583 /**
584 * Removes all relations in <code>removedPrimitives</code> from the model
585 *
586 * @param removedPrimitives the removed primitives. May include nodes, ways,
587 * and relations
588 */
589 public synchronized void removeRelations(Collection<? extends OsmPrimitive> removedPrimitives) {
590 if (removedPrimitives == null) return;
591 // extract the removed relations
592 //
593 Set<Relation> removedRelations = new HashSet<Relation>();
594 for (OsmPrimitive p: removedPrimitives) {
595 if (! (p instanceof Relation)) {
596 continue;
597 }
598 removedRelations.add((Relation)p);
599 }
600 if (removedRelations.isEmpty())
601 return;
602 int size = relations.size();
603 relations.removeAll(removedRelations);
604 if (size != relations.size()) {
605 List<Relation> sel = getSelectedRelations();
606 sort();
607 fireContentsChanged(this, 0, getSize());
608 setSelectedRelations(sel);
609 }
610 }
611
612 public Object getElementAt(int index) {
613 if (relations == null) return null;
614 return relations.get(index);
615 }
616
617 public int getSize() {
618 if (relations == null) return 0;
619 return relations.size();
620 }
621
622 public int getIndexOfRelation(Relation relation) {
623 if (relation == null) return -1;
624 return relations.indexOf(relation);
625 }
626
627 /**
628 * Replies the list of selected, non-new relations. Empty list,
629 * if there are no selected, non-new relations.
630 *
631 * @return the list of selected, non-new relations.
632 */
633 public List<Relation> getSelectedNonNewRelations() {
634 ArrayList<Relation> ret = new ArrayList<Relation>();
635 if (relations == null) return ret;
636 for (int i=0; i<getSize();i++) {
637 if (!selectionModel.isSelectedIndex(i)) {
638 continue;
639 }
640 if (relations.get(i).isNew()) {
641 continue;
642 }
643 ret.add(relations.get(i));
644 }
645 return ret;
646 }
647
648 /**
649 * Replies the list of selected relations. Empty list,
650 * if there are no selected relations.
651 *
652 * @return the list of selected, non-new relations.
653 */
654 public List<Relation> getSelectedRelations() {
655 ArrayList<Relation> ret = new ArrayList<Relation>();
656 if (relations == null) return ret;
657 for (int i=0; i<getSize();i++) {
658 if (!selectionModel.isSelectedIndex(i)) {
659 continue;
660 }
661 ret.add(relations.get(i));
662 }
663 return ret;
664 }
665
666 /**
667 * Sets the selected relations.
668 *
669 * @return sel the list of selected relations
670 */
671 public synchronized void setSelectedRelations(List<Relation> sel) {
672 selectionModel.clearSelection();
673 if (sel == null || sel.isEmpty())
674 return;
675 for (Relation r: sel) {
676 int i = relations.indexOf(r);
677 if (i<0) {
678 continue;
679 }
680 selectionModel.addSelectionInterval(i,i);
681 }
682 }
683 }
684
685 class RelationDialogPopupMenu extends JPopupMenu {
686 protected void build() {
687 // -- download members action
688 //
689 DownloadMembersAction downloadMembersAction = new DownloadMembersAction();
690 displaylist.addListSelectionListener(downloadMembersAction);
691 add(downloadMembersAction);
692
693 // -- select members action
694 //
695 SelectMembersAction selectMembersAction = new SelectMembersAction();
696 displaylist.addListSelectionListener(selectMembersAction);
697 add(selectMembersAction);
698 }
699
700 public RelationDialogPopupMenu() {
701 build();
702 }
703 }
704
705 /* ---------------------------------------------------------------------------------- */
706 /* LayerChangeListener */
707 /* ---------------------------------------------------------------------------------- */
708 public void activeLayerChange(Layer a, Layer b) {
709 initFromLayer(b);
710 if (a != null && a instanceof OsmDataLayer) {
711 ((OsmDataLayer)a).data.removeDataSetListener(this);
712 ((OsmDataLayer)a).listenerDataChanged.remove(this);
713 }
714 if (b != null && b instanceof OsmDataLayer) {
715 ((OsmDataLayer)b).data.addDataSetListener(this);
716 ((OsmDataLayer)b).listenerDataChanged.add(this);
717 }
718
719 }
720 public void layerRemoved(Layer a) {/* irrelevant in this context */}
721 public void layerAdded(Layer a) {/* irrelevant in this context */}
722
723
724 /* ---------------------------------------------------------------------------------- */
725 /* DataSetListener */
726 /* ---------------------------------------------------------------------------------- */
727
728 public void nodeMoved(Node node) {/* irrelevant in this context */}
729
730 public void wayNodesChanged(Way way) {/* irrelevant in this context */}
731
732 public void primtivesAdded(final Collection<? extends OsmPrimitive> added) {
733 Runnable task = new Runnable() {
734 public void run() {
735 model.addRelations(added);
736 }
737 };
738 if (SwingUtilities.isEventDispatchThread()) {
739 task.run();
740 } else {
741 SwingUtilities.invokeLater(task);
742 }
743 }
744
745 public void primtivesRemoved(final Collection<? extends OsmPrimitive> removed) {
746 Runnable task = new Runnable() {
747 public void run() {
748 model.removeRelations(removed);
749 }
750 };
751 if (SwingUtilities.isEventDispatchThread()) {
752 task.run();
753 } else {
754 SwingUtilities.invokeLater(task);
755 }
756 }
757
758 public void relationMembersChanged(final Relation r) {
759 Runnable task = new Runnable() {
760 public void run() {
761 List<Relation> sel = model.getSelectedRelations();
762 model.sort();
763 model.setSelectedRelations(sel);
764 displaylist.repaint();
765 }
766 };
767 if (SwingUtilities.isEventDispatchThread()) {
768 task.run();
769 } else {
770 SwingUtilities.invokeLater(task);
771 }
772 }
773
774 public void tagsChanged(OsmPrimitive prim) {
775 if (prim == null || ! (prim instanceof Relation))
776 return;
777 Runnable task = new Runnable() {
778 public void run() {
779 // trigger a sort of the relation list because the display name may
780 // have changed
781 //
782 List<Relation> sel = model.getSelectedRelations();
783 model.sort();
784 model.setSelectedRelations(sel);
785 displaylist.repaint();
786 }
787 };
788 if (SwingUtilities.isEventDispatchThread()) {
789 task.run();
790 } else {
791 SwingUtilities.invokeLater(task);
792 }
793 }
794
795 /* ---------------------------------------------------------------------------------- */
796 /* DataSetListener */
797 /* ---------------------------------------------------------------------------------- */
798 public void dataChanged(OsmDataLayer l) {
799 if (l != null && l == Main.main.getEditLayer()) {
800 initFromLayer(l);
801 }
802 }
803}
Note: See TracBrowser for help on using the repository browser.