001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.gui.dialogs;
003
004import static org.openstreetmap.josm.gui.help.HelpUtil.ht;
005import static org.openstreetmap.josm.tools.I18n.tr;
006import static org.openstreetmap.josm.tools.I18n.trn;
007
008import java.awt.BorderLayout;
009import java.awt.Dimension;
010import java.awt.FlowLayout;
011import java.awt.GridBagLayout;
012import java.awt.event.ActionEvent;
013import java.awt.event.WindowAdapter;
014import java.awt.event.WindowEvent;
015import java.io.Serializable;
016import java.util.ArrayList;
017import java.util.Collection;
018import java.util.Comparator;
019import java.util.List;
020import java.util.Set;
021import java.util.stream.Collectors;
022
023import javax.swing.AbstractAction;
024import javax.swing.JButton;
025import javax.swing.JDialog;
026import javax.swing.JPanel;
027import javax.swing.JScrollPane;
028import javax.swing.JTable;
029import javax.swing.event.TableModelEvent;
030import javax.swing.event.TableModelListener;
031import javax.swing.table.DefaultTableColumnModel;
032import javax.swing.table.DefaultTableModel;
033import javax.swing.table.TableColumn;
034
035import org.openstreetmap.josm.data.osm.DefaultNameFormatter;
036import org.openstreetmap.josm.data.osm.NameFormatter;
037import org.openstreetmap.josm.data.osm.OsmPrimitive;
038import org.openstreetmap.josm.data.osm.Relation;
039import org.openstreetmap.josm.data.osm.RelationToChildReference;
040import org.openstreetmap.josm.gui.MainApplication;
041import org.openstreetmap.josm.gui.PrimitiveRenderer;
042import org.openstreetmap.josm.gui.help.ContextSensitiveHelpAction;
043import org.openstreetmap.josm.gui.help.HelpUtil;
044import org.openstreetmap.josm.gui.util.GuiHelper;
045import org.openstreetmap.josm.gui.util.WindowGeometry;
046import org.openstreetmap.josm.gui.widgets.HtmlPanel;
047import org.openstreetmap.josm.tools.GBC;
048import org.openstreetmap.josm.tools.I18n;
049import org.openstreetmap.josm.tools.ImageProvider;
050import org.openstreetmap.josm.tools.Pair;
051import org.openstreetmap.josm.tools.Utils;
052
053/**
054 * This dialog is used to get a user confirmation that a collection of primitives can be removed
055 * from their parent relations.
056 * @since 2308
057 */
058public class DeleteFromRelationConfirmationDialog extends JDialog implements TableModelListener {
059    /** the unique instance of this dialog */
060    private static DeleteFromRelationConfirmationDialog instance;
061
062    /**
063     * Replies the unique instance of this dialog
064     *
065     * @return The unique instance of this dialog
066     */
067    public static synchronized DeleteFromRelationConfirmationDialog getInstance() {
068        if (instance == null) {
069            instance = new DeleteFromRelationConfirmationDialog();
070        }
071        return instance;
072    }
073
074    /** the data model */
075    private RelationMemberTableModel model;
076    /** The data model for deleting relations */
077    private RelationDeleteModel deletedRelationsModel;
078    /** The table to hide/show if the relations to delete are not empty*/
079    private final HtmlPanel htmlPanel = new HtmlPanel();
080    private boolean canceled;
081    private final JButton btnOK = new JButton(new OKAction());
082
083    protected JPanel buildRelationMemberTablePanel() {
084        JTable table = new JTable(model, new RelationMemberTableColumnModel());
085        JPanel pnl = new JPanel(new GridBagLayout());
086        pnl.add(new JScrollPane(table), GBC.eol().fill());
087        JTable deletedRelationsTable = new JTable(this.deletedRelationsModel, new RelationDeleteTableColumnModel());
088        JScrollPane deletedRelationsModelTableScrollPane = new JScrollPane(deletedRelationsTable);
089        this.deletedRelationsModel.addTableModelListener(
090                e -> deletedRelationsModelTableScrollPane.setVisible(this.deletedRelationsModel.getRowCount() > 0));
091        // Default to not visible
092        deletedRelationsModelTableScrollPane.setVisible(false);
093        pnl.add(deletedRelationsModelTableScrollPane, GBC.eol().fill());
094        return pnl;
095    }
096
097    protected JPanel buildButtonPanel() {
098        JPanel pnl = new JPanel(new FlowLayout());
099        pnl.add(btnOK);
100        btnOK.setFocusable(true);
101        pnl.add(new JButton(new CancelAction()));
102        pnl.add(new JButton(new ContextSensitiveHelpAction(ht("/Action/Delete#DeleteFromRelations"))));
103        return pnl;
104    }
105
106    protected final void build() {
107        model = new RelationMemberTableModel();
108        model.addTableModelListener(this);
109        this.deletedRelationsModel = new RelationDeleteModel();
110        this.deletedRelationsModel.addTableModelListener(this);
111        getContentPane().setLayout(new BorderLayout());
112        getContentPane().add(htmlPanel, BorderLayout.NORTH);
113        getContentPane().add(buildRelationMemberTablePanel(), BorderLayout.CENTER);
114        getContentPane().add(buildButtonPanel(), BorderLayout.SOUTH);
115
116        HelpUtil.setHelpContext(this.getRootPane(), ht("/Action/Delete#DeleteFromRelations"));
117
118        addWindowListener(new WindowEventHandler());
119    }
120
121    protected void updateMessage() {
122        int numObjectsToDelete = this.model.getNumObjectsToDelete() + this.deletedRelationsModel.getNumObjectsToDelete();
123        int numParentRelations = this.model.getNumParentRelations() + this.deletedRelationsModel.getNumParentRelations();
124        final String msg1 = trn(
125                "Please confirm to remove <strong>{0} object</strong>.",
126                "Please confirm to remove <strong>{0} objects</strong>.",
127                numObjectsToDelete, numObjectsToDelete);
128        final String msg2 = trn(
129                "{0} relation is affected.",
130                "{0} relations are affected.",
131                numParentRelations, numParentRelations);
132        @I18n.QuirkyPluralString
133        final String msg = "<html>" + msg1 + ' ' + msg2 + "</html>";
134        htmlPanel.getEditorPane().setText(msg);
135        invalidate();
136    }
137
138    protected void updateTitle() {
139        int numObjectsToDelete = this.model.getNumObjectsToDelete() + this.deletedRelationsModel.getNumObjectsToDelete();
140        if (numObjectsToDelete > 0) {
141            setTitle(trn("Deleting {0} object", "Deleting {0} objects", numObjectsToDelete, numObjectsToDelete));
142        } else {
143            setTitle(tr("Delete objects"));
144        }
145    }
146
147    /**
148     * Constructs a new {@code DeleteFromRelationConfirmationDialog}.
149     */
150    public DeleteFromRelationConfirmationDialog() {
151        super(GuiHelper.getFrameForComponent(MainApplication.getMainFrame()), "", ModalityType.DOCUMENT_MODAL);
152        build();
153    }
154
155    /**
156     * Replies the data model used in this dialog
157     *
158     * @return the data model
159     */
160    public RelationMemberTableModel getModel() {
161        return model;
162    }
163
164    /**
165     * Replies the data model used for relations that should probably be deleted.
166     * @return the data model
167     * @since 18395
168     */
169    public RelationDeleteModel getDeletedRelationsModel() {
170        return this.deletedRelationsModel;
171    }
172
173    /**
174     * Replies true if the dialog was canceled
175     *
176     * @return true if the dialog was canceled
177     */
178    public boolean isCanceled() {
179        return canceled;
180    }
181
182    protected void setCanceled(boolean canceled) {
183        this.canceled = canceled;
184    }
185
186    @Override
187    public void setVisible(boolean visible) {
188        if (visible) {
189            new WindowGeometry(
190                    getClass().getName() + ".geometry",
191                    WindowGeometry.centerInWindow(
192                            MainApplication.getMainFrame(),
193                            new Dimension(400, 200)
194                    )
195            ).applySafe(this);
196            setCanceled(false);
197        } else {
198            if (isShowing()) { // Avoid IllegalComponentStateException like in #8775
199                new WindowGeometry(this).remember(getClass().getName() + ".geometry");
200            }
201            model.data.clear();
202            this.deletedRelationsModel.data.clear();
203        }
204        super.setVisible(visible);
205    }
206
207    @Override
208    public void tableChanged(TableModelEvent e) {
209        updateMessage();
210        updateTitle();
211    }
212
213    /**
214     * The table model which manages the list of relation-to-child references
215     */
216    public static class RelationMemberTableModel extends DefaultTableModel {
217        private static final class RelationToChildReferenceComparator implements Comparator<RelationToChildReference>, Serializable {
218            private static final long serialVersionUID = 1L;
219            @Override
220            public int compare(RelationToChildReference o1, RelationToChildReference o2) {
221                NameFormatter nf = DefaultNameFormatter.getInstance();
222                int cmp = o1.getChild().getDisplayName(nf).compareTo(o2.getChild().getDisplayName(nf));
223                if (cmp != 0) return cmp;
224                cmp = o1.getParent().getDisplayName(nf).compareTo(o2.getParent().getDisplayName(nf));
225                if (cmp != 0) return cmp;
226                return Integer.compare(o1.getPosition(), o2.getPosition());
227            }
228        }
229
230        private final transient List<RelationToChildReference> data;
231
232        /**
233         * Constructs a new {@code RelationMemberTableModel}.
234         */
235        public RelationMemberTableModel() {
236            data = new ArrayList<>();
237        }
238
239        @Override
240        public int getRowCount() {
241            if (data == null) return 0;
242            return data.size();
243        }
244
245        /**
246         * Sets the data that should be displayed in the list.
247         * @param references A list of references to display
248         */
249        public void populate(Collection<RelationToChildReference> references) {
250            data.clear();
251            if (references != null) {
252                data.addAll(references);
253            }
254            data.sort(new RelationToChildReferenceComparator());
255            fireTableDataChanged();
256        }
257
258        /**
259         * Gets the list of children that are currently displayed.
260         * @return The children.
261         */
262        public Set<OsmPrimitive> getObjectsToDelete() {
263            return data.stream().map(RelationToChildReference::getChild).collect(Collectors.toSet());
264        }
265
266        /**
267         * Gets the number of elements {@link #getObjectsToDelete()} would return.
268         * @return That number.
269         */
270        public int getNumObjectsToDelete() {
271            return getObjectsToDelete().size();
272        }
273
274        /**
275         * Gets the set of parent relations
276         * @return All parent relations of the references
277         */
278        public Set<OsmPrimitive> getParentRelations() {
279            return data.stream().map(RelationToChildReference::getParent).collect(Collectors.toSet());
280        }
281
282        /**
283         * Gets the number of elements {@link #getParentRelations()} would return.
284         * @return That number.
285         */
286        public int getNumParentRelations() {
287            return getParentRelations().size();
288        }
289
290        @Override
291        public Object getValueAt(int rowIndex, int columnIndex) {
292            if (data == null) return null;
293            RelationToChildReference ref = data.get(rowIndex);
294            switch (columnIndex) {
295            case 0: return ref.getChild();
296            case 1: return ref.getParent();
297            case 2: return ref.getPosition()+1;
298            case 3: return ref.getRole();
299            default:
300                assert false : "Illegal column index";
301            }
302            return null;
303        }
304
305        @Override
306        public boolean isCellEditable(int row, int column) {
307            return false;
308        }
309    }
310
311    private static class RelationMemberTableColumnModel extends DefaultTableColumnModel {
312
313        protected final void createColumns() {
314
315            // column 0 - To Delete
316            TableColumn col = new TableColumn(0);
317            col.setHeaderValue(tr("To delete"));
318            col.setResizable(true);
319            col.setWidth(100);
320            col.setPreferredWidth(100);
321            col.setCellRenderer(new PrimitiveRenderer());
322            addColumn(col);
323
324            // column 0 - From Relation
325            col = new TableColumn(1);
326            col.setHeaderValue(tr("From Relation"));
327            col.setResizable(true);
328            col.setWidth(100);
329            col.setPreferredWidth(100);
330            col.setCellRenderer(new PrimitiveRenderer());
331            addColumn(col);
332
333            // column 1 - Pos.
334            col = new TableColumn(2);
335            col.setHeaderValue(tr("Pos."));
336            col.setResizable(true);
337            col.setWidth(30);
338            col.setPreferredWidth(30);
339            addColumn(col);
340
341            // column 2 - Role
342            col = new TableColumn(3);
343            col.setHeaderValue(tr("Role"));
344            col.setResizable(true);
345            col.setWidth(50);
346            col.setPreferredWidth(50);
347            addColumn(col);
348        }
349
350        RelationMemberTableColumnModel() {
351            createColumns();
352        }
353    }
354
355    /**
356     * The table model which manages relations that will be deleted, if their children are deleted.
357     * @since 18395
358     */
359    public static class RelationDeleteModel extends DefaultTableModel {
360        private final transient List<Pair<Relation, Boolean>> data = new ArrayList<>();
361
362        @Override
363        public int getRowCount() {
364            // This is called in the super constructor. Before we have instantiated the list. Removing the null check
365            // WILL LEAD TO A SILENT NPE!
366            if (this.data == null) {
367                return 0;
368            }
369            return this.data.size();
370        }
371
372        /**
373         * Sets the data that should be displayed in the list.
374         * @param references A list of references to display
375         */
376        public void populate(Collection<Pair<Relation, Boolean>> references) {
377            this.data.clear();
378            if (references != null) {
379                this.data.addAll(references);
380            }
381            this.data.sort(Comparator.comparing(pair -> pair.a));
382            fireTableDataChanged();
383        }
384
385        /**
386         * Gets the list of children that are currently displayed.
387         * @return The children.
388         */
389        public Set<Relation> getObjectsToDelete() {
390            return this.data.stream().filter(relation -> relation.b).map(relation -> relation.a).collect(Collectors.toSet());
391        }
392
393        /**
394         * Gets the number of elements {@link #getObjectsToDelete()} would return.
395         * @return That number.
396         */
397        public int getNumObjectsToDelete() {
398            return getObjectsToDelete().size();
399        }
400
401        /**
402         * Gets the set of parent relations
403         * @return All parent relations of the references
404         */
405        public Set<OsmPrimitive> getParentRelations() {
406            return this.data.stream()
407                    .flatMap(pair -> Utils.filteredCollection(pair.a.getReferrers(), Relation.class).stream())
408                    .collect(Collectors.toSet());
409        }
410
411        /**
412         * Gets the number of elements {@link #getParentRelations()} would return.
413         * @return That number.
414         */
415        public int getNumParentRelations() {
416            return getParentRelations().size();
417        }
418
419        @Override
420        public Object getValueAt(int rowIndex, int columnIndex) {
421            if (this.data.isEmpty()) {
422                return null;
423            }
424            Pair<Relation, Boolean> ref = this.data.get(rowIndex);
425            switch (columnIndex) {
426            case 0: return ref.a;
427            case 1: return ref.b;
428            default:
429                assert false : "Illegal column index";
430            }
431            return null;
432        }
433
434        @Override
435        public boolean isCellEditable(int row, int column) {
436            return !this.data.isEmpty() && column == 1;
437        }
438
439        @Override
440        public void setValueAt(Object aValue, int row, int column) {
441            if (this.data.size() > row && column == 1 && aValue instanceof Boolean) {
442                this.data.get(row).b = ((Boolean) aValue);
443            }
444        }
445
446        @Override
447        public Class<?> getColumnClass(int columnIndex) {
448            switch (columnIndex) {
449            case 0:
450                return Relation.class;
451            case 1:
452                return Boolean.class;
453            default:
454                return super.getColumnClass(columnIndex);
455            }
456        }
457    }
458
459    private static class RelationDeleteTableColumnModel extends DefaultTableColumnModel {
460        protected final void createColumns() {
461            // column 0 - To Delete
462            TableColumn col = new TableColumn(0);
463            col.setHeaderValue(tr("Relation"));
464            col.setResizable(true);
465            col.setWidth(100);
466            col.setPreferredWidth(100);
467            col.setCellRenderer(new PrimitiveRenderer());
468            addColumn(col);
469
470            // column 0 - From Relation
471            col = new TableColumn(1);
472            final String toDelete = tr("To delete");
473            col.setHeaderValue(toDelete);
474            col.setResizable(true);
475            col.setPreferredWidth(toDelete.length());
476            addColumn(col);
477        }
478
479        RelationDeleteTableColumnModel() {
480            createColumns();
481        }
482    }
483
484    class OKAction extends AbstractAction {
485        OKAction() {
486            putValue(NAME, tr("OK"));
487            new ImageProvider("ok").getResource().attachImageIcon(this);
488            putValue(SHORT_DESCRIPTION, tr("Click to close the dialog and remove the object from the relations"));
489        }
490
491        @Override
492        public void actionPerformed(ActionEvent e) {
493            setCanceled(false);
494            setVisible(false);
495        }
496    }
497
498    class CancelAction extends AbstractAction {
499        CancelAction() {
500            putValue(NAME, tr("Cancel"));
501            new ImageProvider("cancel").getResource().attachImageIcon(this);
502            putValue(SHORT_DESCRIPTION, tr("Click to close the dialog and to abort deleting the objects"));
503        }
504
505        @Override
506        public void actionPerformed(ActionEvent e) {
507            setCanceled(true);
508            setVisible(false);
509        }
510    }
511
512    class WindowEventHandler extends WindowAdapter {
513
514        @Override
515        public void windowClosing(WindowEvent e) {
516            setCanceled(true);
517        }
518
519        @Override
520        public void windowOpened(WindowEvent e) {
521            btnOK.requestFocusInWindow();
522        }
523    }
524}