Ticket #10730: 10730-alpha.patch

src/org/openstreetmap/josm/actions/SplitWayAction.java

@@ -5 +5 @@
 import static org.openstreetmap.josm.tools.I18n.tr;
 import static org.openstreetmap.josm.tools.I18n.trn;
 
+import java.awt.Component;
+import java.awt.GridLayout;
 import java.awt.event.ActionEvent;
 import java.awt.event.KeyEvent;
 import java.util.ArrayList;
@@ -17 +19 @@
 import java.util.List;
 import java.util.Set;
 
+import javax.swing.DefaultListCellRenderer;
+import javax.swing.JLabel;
+import javax.swing.JList;
 import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.ListSelectionModel;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
 
 import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.command.AddCommand;
 import org.openstreetmap.josm.command.ChangeCommand;
 import org.openstreetmap.josm.command.Command;
 import org.openstreetmap.josm.command.SequenceCommand;
+import org.openstreetmap.josm.data.osm.NameFormatter;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.PrimitiveId;
@@ -31 +41 @@
 import org.openstreetmap.josm.data.osm.RelationMember;
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.gui.DefaultNameFormatter;
+import org.openstreetmap.josm.gui.ExtendedDialog;
 import org.openstreetmap.josm.gui.Notification;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 import org.openstreetmap.josm.tools.CheckParameterUtil;
 import org.openstreetmap.josm.tools.Shortcut;
+import org.openstreetmap.josm.tools.Utils;
 
 /**
  * Splits a way into multiple ways (all identical except for their node list).
@@ -175 +187 @@
         }
 
         // Finally, applicableWays contains only one perfect way
-        Way selectedWay = applicableWays.get(0);
+        final Way selectedWay = applicableWays.get(0);
 
         List<List<Node>> wayChunks = buildSplitChunks(selectedWay, selectedNodes);
         if (wayChunks != null) {
-            List<OsmPrimitive> sel = new ArrayList<>(selectedWays.size() + selectedRelations.size());
+            final List<OsmPrimitive> sel = new ArrayList<>(selectedWays.size() + selectedRelations.size());
             sel.addAll(selectedWays);
             sel.addAll(selectedRelations);
-            SplitWayResult result = splitWay(getEditLayer(), selectedWay, wayChunks, sel);
-            Main.main.undoRedo.add(result.getCommand());
-            getCurrentDataSet().setSelected(result.getNewSelection());
+
+            final List<Way> newWays = createNewWaysFromChunks(selectedWay, wayChunks);
+            Way wayToKeep = newWays.get(0);
+
+            if (ExpertToggleAction.isExpert() && !selectedWay.isNew()) {
+                final JList<Way> list = new JList<>(newWays.toArray(new Way[newWays.size()]));
+                list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+                list.addListSelectionListener(new ListSelectionListener() {
+                    @Override
+                    public void valueChanged(ListSelectionEvent e) {
+                        final Way selected = list.getSelectedValue();
+                        if (Main.isDisplayingMapView() && selected != null) {
+                            // todo somehow select/highlight this way although it is not yet part of the dataset
+                        }
+                    }
+                });
+                list.setCellRenderer(new DefaultListCellRenderer() {
+                    @Override
+                    public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
+                        final Component c = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+                        ((JLabel) c).setText(tr("Segment {0}: {1}", index + 1, DefaultNameFormatter.getInstance().format((Way) value)));
+                        return c;
+                    }
+                });
+                list.setSelectedValue(wayToKeep, true);
+                final String question = tr("Which way segment should reuse id {0}?", selectedWay.getId());
+                final ExtendedDialog dialog = new ExtendedDialog(Main.parent, question, new String[]{tr("Ok"), tr("Cancel")}, true) {
+                    @Override
+                    protected void buttonAction(int buttonIndex, ActionEvent evt) {
+                        super.buttonAction(buttonIndex, evt);
+                        if (getValue() == 1) {
+                            final Way wayToKeep = list.getSelectedValue();
+                            final SplitWayResult result = doSplitWay(getEditLayer(), selectedWay, wayToKeep, newWays, sel);
+                            Main.main.undoRedo.add(result.getCommand());
+                            getCurrentDataSet().setSelected(result.getNewSelection());
+                        }
+                    }
+
+                    {
+                        setButtonIcons(new String[]{"ok", "cancel"});
+                        final JPanel pane = new JPanel(new GridLayout(2, 1));
+                        pane.add(new JLabel(question));
+                        pane.add(list);
+                        setContent(pane);
+                    }
+                };
+                dialog.setModal(false);
+                dialog.showDialog();
+            } else {
+                final SplitWayResult result = doSplitWay(getEditLayer(), selectedWay, wayToKeep, newWays, sel);
+                Main.main.undoRedo.add(result.getCommand());
+                getCurrentDataSet().setSelected(result.getNewSelection());
+            }
         }
     }
 
@@ -327 +389 @@
         return wayChunks;
     }
 
+    protected static List<Way> createNewWaysFromChunks(Way way, List<List<Node>> wayChunks) {
+        final List<Way> newWays = new ArrayList<>();
+        for (List<Node> wayChunk : wayChunks) {
+            Way wayToAdd = new Way();
+            wayToAdd.setKeys(way.getKeys());
+            wayToAdd.setNodes(wayChunk);
+            newWays.add(wayToAdd);
+        }
+        return newWays;
+    }
+
     /**
      * Splits the way {@code way} into chunks of {@code wayChunks} and replies
      * the result of this process in an instance of {@link SplitWayResult}.
@@ -341 +414 @@
      * @param selection The list of currently selected primitives
      * @return the result from the split operation
      */
-    public static SplitWayResult splitWay(OsmDataLayer layer, Way way, List<List<Node>> wayChunks,
+    public static SplitWayResult splitWay(final OsmDataLayer layer, final Way way, List<List<Node>> wayChunks,
             Collection<? extends OsmPrimitive> selection) {
         // build a list of commands, and also a new selection list
-        Collection<Command> commandList = new ArrayList<>(wayChunks.size());
-        List<OsmPrimitive> newSelection = new ArrayList<>(selection.size() + wayChunks.size());
+        final List<OsmPrimitive> newSelection = new ArrayList<>(selection.size() + wayChunks.size());
         newSelection.addAll(selection);
 
-        Iterator<List<Node>> chunkIt = wayChunks.iterator();
+        // Create all potential new ways
+        final List<Way> newWays = createNewWaysFromChunks(way, wayChunks);
+
+        // Determine which part reuses the existing way
+        final Way wayToKeep = newWays.get(0);
+
+        return doSplitWay(layer, way, wayToKeep, newWays, newSelection);
+    }
+
+    static SplitWayResult doSplitWay(OsmDataLayer layer, Way way, Way wayToKeep, List<Way> newWays,
+                                   List<OsmPrimitive> newSelection) {
+
+        Collection<Command> commandList = new ArrayList<>(newWays.size());
         Collection<String> nowarnroles = Main.pref.getCollection("way.split.roles.nowarn",
                 Arrays.asList("outer", "inner", "forward", "backward", "north", "south", "east", "west"));
 
-        // First, change the original way
-        Way changedWay = new Way(way);
-        changedWay.setNodes(chunkIt.next());
+        // Change the original way
+        final Way changedWay = new Way(way);
+        changedWay.setNodes(wayToKeep.getNodes());
         commandList.add(new ChangeCommand(way, changedWay));
         if (!newSelection.contains(way)) {
             newSelection.add(way);
         }
+        newWays.remove(wayToKeep);
 
-        List<Way> newWays = new ArrayList<>();
-        // Second, create new ways
-        while (chunkIt.hasNext()) {
-            Way wayToAdd = new Way();
-            wayToAdd.setKeys(way.getKeys());
-            newWays.add(wayToAdd);
-            wayToAdd.setNodes(chunkIt.next());
+        for (Way wayToAdd : newWays) {
             commandList.add(new AddCommand(layer, wayToAdd));
             newSelection.add(wayToAdd);
         }
+
         boolean warnmerole = false;
         boolean warnme = false;
         // now copy all relations to new way also
@@ -508 +588 @@
         return new SplitWayResult(
                 new SequenceCommand(
                         /* for correct i18n of plural forms - see #9110 */
-                        trn("Split way {0} into {1} part", "Split way {0} into {1} parts", wayChunks.size(),
-                                way.getDisplayName(DefaultNameFormatter.getInstance()), wayChunks.size()),
+                        trn("Split way {0} into {1} part", "Split way {0} into {1} parts", newWays.size(),
+                                way.getDisplayName(DefaultNameFormatter.getInstance()), newWays.size()),
                         commandList
                         ),
                         newSelection,