Changeset 7153 in josm

Timestamp:

2014-05-20T21:48:59+02:00 (11 years ago)

Author:

simon04

Message:

Search preset: also show adequate relations to be created (according to the defined role member match expressions)

Location:

trunk/src/org/openstreetmap/josm/gui/tagging

Files:

• TaggingPreset.java (modified) (1 diff)
• TaggingPresetSelector.java (modified) (2 diffs)

trunk/src/org/openstreetmap/josm/gui/tagging/TaggingPreset.java

@@ -384 +384 @@
         originalSelectionEmpty = participants.isEmpty();
         Collection<OsmPrimitive> sel = new LinkedList<>();
-        for (OsmPrimitive osm : participants)
-        {
-            if (types != null)
-            {
-                if(osm instanceof Relation)
-                {
-                    if(!types.contains(TaggingPresetType.RELATION) &&
-                            !(types.contains(TaggingPresetType.CLOSEDWAY) && ((Relation)osm).isMultipolygon())) {
-                        continue;
-                    }
-                }
-                else if(osm instanceof Node)
-                {
-                    if(!types.contains(TaggingPresetType.NODE)) {
-                        continue;
-                    }
-                }
-                else if(osm instanceof Way)
-                {
-                    if(!types.contains(TaggingPresetType.WAY) &&
-                            !(types.contains(TaggingPresetType.CLOSEDWAY) && ((Way)osm).isClosed())) {
-                        continue;
-                    }
-                }
-            }
-            sel.add(osm);
+        for (OsmPrimitive osm : participants) {
+            if (typeMatches(EnumSet.of(TaggingPresetType.forPrimitive(osm)))) {
+                sel.add(osm);
+            }
         }
         return sel;

trunk/src/org/openstreetmap/josm/gui/tagging/TaggingPresetSelector.java

@@ -53 +53 @@
 import org.openstreetmap.josm.gui.widgets.JosmTextField;
 import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
+import org.openstreetmap.josm.tools.Predicate;
+import org.openstreetmap.josm.tools.Utils;
 
 /**
@@ -334 +336 @@
         boolean inTags = ckSearchInTags != null && ckSearchInTags.isSelected();
 
-        List<PresetClassification> result = new ArrayList<>();
-        PRESET_LOOP:
-            for (PresetClassification presetClasification: classifications) {
-                TaggingPreset preset = presetClasification.preset;
-                presetClasification.classification = 0;
-
-                if (onlyApplicable && preset.types != null) {
-                    boolean found = false;
-                    for (TaggingPresetType type: preset.types) {
-                        if (getTypesInSelection().contains(type)) {
-                            found = true;
-                            break;
-                        }
-                    }
-                    if (!found) {
-                        continue;
-                    }
-                }
-
-                if (groupWords != null && presetClasification.isMatchingGroup(groupWords) == 0) {
-                    continue PRESET_LOOP;
-                }
-
-                int matchName = presetClasification.isMatchingName(nameWords);
-
-                if (matchName == 0) {
-                    if (groupWords == null) {
-                        int groupMatch = presetClasification.isMatchingGroup(nameWords);
-                        if (groupMatch > 0) {
-                            presetClasification.classification = CLASSIFICATION_GROUP_MATCH + groupMatch;
-                        }
-                    }
-                    if (presetClasification.classification == 0 && inTags) {
-                        int tagsMatch = presetClasification.isMatchingTags(nameWords);
-                        if (tagsMatch > 0) {
-                            presetClasification.classification = CLASSIFICATION_TAGS_MATCH + tagsMatch;
-                        }
-                    }
+        final List<PresetClassification> result = new ArrayList<>();
+        for (PresetClassification presetClassification : classifications) {
+            TaggingPreset preset = presetClassification.preset;
+            presetClassification.classification = 0;
+
+            if (onlyApplicable && !preset.typeMatches(getTypesInSelection())) {
+                final Predicate<Role> memberExpressionMatchesOnePrimitive = new Predicate<Role>() {
+                    @Override
+                    public boolean evaluate(Role object) {
+                        return object.memberExpression != null && Utils.exists(Main.main.getCurrentDataSet().getSelected(), object.memberExpression);
+                    }
+                };
+                if (preset.types.contains(TaggingPresetType.RELATION) && preset.roles != null
+                        && Utils.exists(preset.roles.roles, memberExpressionMatchesOnePrimitive)) {
+                    // keep to allow the creation of new relations
                 } else {
-                    presetClasification.classification = CLASSIFICATION_NAME_MATCH + matchName;
-                }
-
-                if (presetClasification.classification > 0) {
-                    presetClasification.classification += presetClasification.favoriteIndex;
-                    result.add(presetClasification);
-                }
-            }
+                    continue;
+                }
+            }
+
+            if (groupWords != null && presetClassification.isMatchingGroup(groupWords) == 0) {
+                continue;
+            }
+
+            int matchName = presetClassification.isMatchingName(nameWords);
+
+            if (matchName == 0) {
+                if (groupWords == null) {
+                    int groupMatch = presetClassification.isMatchingGroup(nameWords);
+                    if (groupMatch > 0) {
+                        presetClassification.classification = CLASSIFICATION_GROUP_MATCH + groupMatch;
+                    }
+                }
+                if (presetClassification.classification == 0 && inTags) {
+                    int tagsMatch = presetClassification.isMatchingTags(nameWords);
+                    if (tagsMatch > 0) {
+                        presetClassification.classification = CLASSIFICATION_TAGS_MATCH + tagsMatch;
+                    }
+                }
+            } else {
+                presetClassification.classification = CLASSIFICATION_NAME_MATCH + matchName;
+            }
+
+            if (presetClassification.classification > 0) {
+                presetClassification.classification += presetClassification.favoriteIndex;
+                result.add(presetClassification);
+            }
+        }
 
         Collections.sort(result);