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, 9 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.