Ticket #7458: CreateMultipolygonAction.java.patch

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

@@ -6 +6 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.KeyEvent;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import java.util.Set;
+import java.util.TreeSet;
 import javax.swing.JOptionPane;
 
 import javax.swing.SwingUtilities;
 import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.command.AddCommand;
+import org.openstreetmap.josm.command.ChangeCommand;
 import org.openstreetmap.josm.command.ChangePropertyCommand;
 import org.openstreetmap.josm.command.Command;
 import org.openstreetmap.josm.command.SequenceCommand;
@@ -98 +102 @@
 
         } else {
             //Just add the relation
-            List<Command> list = this.removeTagsFromInnerWays(relation);
+            List<Command> list = this.removeTagsFromWaysIfNeeded(relation);
             list.add(new AddCommand(relation));
             Main.main.undoRedo.add(new SequenceCommand(tr("Create multipolygon"), list));
             // Use 'SwingUtilities.invokeLater' to make sure the relationListDialog
@@ -172 +176 @@
         return rel;
     }
 
+    static public final List<String> DEFAULT_LINEAR_TAGS = Arrays.asList(new String[] {"barrier", "source"});
+    private static final Set<String> REMOVE_FROM_BOUNDARY_TAGS = new TreeSet<String>(Arrays.asList(new String[] {
+                "boundary", "boundary_type", "type", "admin_level"
+            }));
+
     /**
+     * This method removes tags/value pairs from inner and outer ways and put them on relation if necessary
+     * Function was extended in reltoolbox plugin by Zverikk and copied back to the core 
+     * @param relation
+     */
+    private List<Command> removeTagsFromWaysIfNeeded( Relation relation ) {
+        Map<String, String> values = new HashMap<String, String>();
+
+        if( relation.hasKeys() ) {
+            for( String key : relation.keySet() ) {
+                values.put(key, relation.get(key));
+            }
+        }
+
+        List<Way> innerWays = new ArrayList<Way>();
+        List<Way> outerWays = new ArrayList<Way>();
+
+        Set<String> conflictingKeys = new TreeSet<String>();
+
+        for( RelationMember m : relation.getMembers() ) {
+
+            if( m.hasRole() && "inner".equals(m.getRole()) && m.isWay() && m.getWay().hasKeys() ) {
+                innerWays.add(m.getWay());
+            }
+
+            if( m.hasRole() && "outer".equals(m.getRole()) && m.isWay() && m.getWay().hasKeys() ) {
+                Way way = m.getWay();
+                outerWays.add(way);
+                for( String key : way.keySet() ) {
+                    if( !values.containsKey(key) ) { //relation values take precedence
+                        values.put(key, way.get(key));
+                    } else if( !relation.hasKey(key) && !values.get(key).equals(way.get(key)) ) {
+                        conflictingKeys.add(key);
+                    }
+                }
+            }
+        }
+
+        // filter out empty key conflicts - we need second iteration
+        boolean isBoundary = Main.pref.getBoolean("multipoly.boundary", false);
+        if( isBoundary || !Main.pref.getBoolean("multipoly.alltags", false) )
+            for( RelationMember m : relation.getMembers() )
+                if( m.hasRole() && m.getRole().equals("outer") && m.isWay() )
+                    for( String key : values.keySet() )
+                        if( !m.getWay().hasKey(key) && !relation.hasKey(key) )
+                            conflictingKeys.add(key);
+
+        for( String key : conflictingKeys )
+            values.remove(key);
+
+        for( String linearTag : Main.pref.getCollection("multipoly.lineartagstokeep", DEFAULT_LINEAR_TAGS) )
+            values.remove(linearTag);
+
+        if( values.containsKey("natural") && values.get("natural").equals("coastline") )
+            values.remove("natural");
+
+        String name = values.get("name");
+        if( isBoundary ) {
+            Set<String> keySet = new TreeSet<String>(values.keySet());
+            for( String key : keySet )
+                if( !REMOVE_FROM_BOUNDARY_TAGS.contains(key) )
+                    values.remove(key);
+        }
+
+        values.put("area", "yes");
+
+        List<Command> commands = new ArrayList<Command>();
+        boolean moveTags = Main.pref.getBoolean("multipoly.movetags", true);
+
+        for( String key : values.keySet() ) {
+            List<OsmPrimitive> affectedWays = new ArrayList<OsmPrimitive>();
+            String value = values.get(key);
+
+            for( Way way : innerWays ) {
+                if( way.hasKey(key) && (isBoundary || value.equals(way.get(key))) ) {
+                    affectedWays.add(way);
+                }
+            }
+
+            if( moveTags ) {
+                // remove duplicated tags from outer ways
+                for( Way way : outerWays ) {
+                    if( way.hasKey(key) ) {
+                        affectedWays.add(way);
+                    }
+                }
+            }
+
+            if( affectedWays.size() > 0 ) {
+                // reset key tag on affected ways
+                commands.add(new ChangePropertyCommand(affectedWays, key, null));
+            }
+        }
+
+        if( moveTags ) {
+            // add those tag values to the relation
+            if( isBoundary )
+                values.put("name", name);
+            boolean fixed = false;
+            Relation r2 = new Relation(relation);
+            for( String key : values.keySet() ) {
+                if( !r2.hasKey(key) && !key.equals("area")
+                        && (!isBoundary || key.equals("admin_level") || key.equals("name")) ) {
+                    if( relation.isNew() )
+                        relation.put(key, values.get(key));
+                    else
+                        r2.put(key, values.get(key));
+                    fixed = true;
+                }
+            }
+            if( fixed && !relation.isNew() )
+                commands.add(new ChangeCommand(relation, r2));
+        }
+
+        return commands;
+    }
+    
+    /**
      * This method removes tags/value pairs from inner ways that are present in relation or outer ways.
      * @param relation
      */