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

Last change on this file since 3020 was 3020, checked in by bastiK, 15 years ago

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