Changeset 2946 in josm

Timestamp:

Feb 6, 2010 5:37:52 PM (3 years ago)

Author:

bastiK

Message:

autocompletion: Always add the preset keys/values to the autocompletion list.
Does not apply to the Properties dialog, because it has a seperate implementation of the autocompletion feature.

Location:

trunk/src/org/openstreetmap/josm

Files:

• actions/OpenFileAction.java (modified) (2 diffs)
• gui/preferences/TaggingPresetPreference.java (modified) (2 diffs)
• gui/tagging/TagCellEditor.java (modified) (2 diffs)
• gui/tagging/TaggingPreset.java (modified) (1 diff)
• gui/tagging/ac/AutoCompletionCache.java (modified) (11 diffs)
• gui/tagging/ac/AutoCompletionItemPritority.java (modified) (1 diff)
• gui/tagging/ac/AutoCompletionList.java (modified) (1 diff)
• tools/MultiMap.java (modified) (1 diff)

trunk/src/org/openstreetmap/josm/actions/OpenFileAction.java

@@ -135 +135 @@
                         for (FileImporter importer : ExtensionFileFilter.importers) {
                             if (importer.acceptFile(f)) {
-                                map.add(importer, f);
+                                map.put(importer, f);
                                 continue FILES;
                             }
@@ -146 +146 @@
                 for (FileImporter importer : ims) {
                     //System.err.println("Using "+importer.getClass().getName());
-                    List<File> files = map.get(importer);
+                    List<File> files = new ArrayList<File>(map.get(importer));
                     //System.err.println("for files: "+files);
                     importData(importer, files);

trunk/src/org/openstreetmap/josm/gui/preferences/TaggingPresetPreference.java

@@ -21 +21 @@
 import org.openstreetmap.josm.gui.tagging.TaggingPresetMenu;
 import org.openstreetmap.josm.gui.tagging.TaggingPresetSeparator;
+import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionCache;
 import org.openstreetmap.josm.tools.GBC;
 
@@ -87 +88 @@
         else
         {
+            AutoCompletionCache.cachePresets(taggingPresets);
             HashMap<TaggingPresetMenu,JMenu> submenus = new HashMap<TaggingPresetMenu,JMenu>();
             for (final TaggingPreset p : taggingPresets)

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

@@ -62 +62 @@
         // add the list of keys in the current data set
         //
-        for (String key : acCache.getKeys()) {
-            autoCompletionList.add(
-                    new AutoCompletionListItem(key, AutoCompletionItemPritority.IS_IN_DATASET)
-            );
-        }
+        acCache.populateWithKeys(autoCompletionList, true);
 
         // remove the keys already present in the current tag model
@@ -91 +87 @@
             return;
         }
-        autoCompletionList.clear();
-        for (String value : acCache.getValues(forKey)) {
-            autoCompletionList.add(
-                    new AutoCompletionListItem(value, AutoCompletionItemPritority.IS_IN_DATASET)
-            );
-        }
+        acCache.populateWithTagValues(autoCompletionList, forKey, false);
     }
 

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

@@ -82 +82 @@
             if (layer == null) return;
             AutoCompletionList list  = new AutoCompletionList();
-            List<String> values = AutoCompletionCache.getCacheForLayer(Main.main.getEditLayer()).getValues(key);
-            list.add(values,AutoCompletionItemPritority.IS_IN_DATASET);
+            AutoCompletionCache.getCacheForLayer(Main.main.getEditLayer()).populateWithTagValues(list, key, false);
             field.setAutoCompletionList(list);
         }

trunk/src/org/openstreetmap/josm/gui/tagging/ac/AutoCompletionCache.java

@@ -10 +10 @@
 
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.OsmUtils;
 import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.RelationMember;
@@ -15 +16 @@
 import org.openstreetmap.josm.gui.layer.Layer;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
+import org.openstreetmap.josm.gui.tagging.TaggingPreset;
+import org.openstreetmap.josm.tools.MultiMap;
 
 /**
@@ -67 +70 @@
     }
 
-    /** the cached tags give by a tag key and a list of values for this tag*/
-    private HashMap<String, Set<String>> tagCache;
+    /** the cached tags given by a tag key and a list of values for this tag */
+    private MultiMap<String, String> tagCache;
+    /**  the layer this cache is built for */
+    private OsmDataLayer layer;
+    /** the same as tagCache but for the preset keys and values */
+    private static MultiMap<String, String> presetTagCache = new MultiMap<String, String>();
     /** the cached list of member roles */
     private  Set<String> roleCache;
-    /**  the layer this cache is built for */
-    private OsmDataLayer layer;
 
     /**
@@ -78 +83 @@
      */
     public AutoCompletionCache(OsmDataLayer layer) {
-        tagCache = new HashMap<String, Set<String>>();
+        tagCache = new MultiMap<String, String>();
         roleCache = new HashSet<String>();
         this.layer = layer;
@@ -85 +90 @@
     public AutoCompletionCache() {
         this(null);
-    }
-
-    /**
-     * make sure, <code>key</code> is in the cache
-     *
-     * @param key  the key
-     */
-    protected void cacheKey(String key) {
-        if (tagCache.containsKey(key))
-            return;
-        tagCache.put(key, new HashSet<String>());
-    }
-
-    /**
-     * make sure, value is one of the auto completion values allowed for key
-     *
-     * @param key the key
-     * @param value the value
-     */
-    protected void cacheValue(String key, String value) {
-        cacheKey(key);
-        tagCache.get(key).add(value);
     }
 
@@ -118 +101 @@
         for (String key: primitive.keySet()) {
             String value = primitive.get(key);
-            cacheValue(key, value);
+            tagCache.put(key, value);
         }
     }
@@ -141 +124 @@
      */
     public void initFromDataSet() {
-        tagCache = new HashMap<String, Set<String>>();
+        tagCache = new MultiMap<String, String>();
         if (layer == null)
             return;
@@ -157 +140 @@
 
     /**
+     * Initialize the cache for presets. This is done only once.
+     */
+    public static void cachePresets(Collection<TaggingPreset> presets) {
+        for (final TaggingPreset p : presets) {
+            for (TaggingPreset.Item item : p.data) {
+                if (item instanceof TaggingPreset.Check) {
+                    TaggingPreset.Check ch = (TaggingPreset.Check) item;
+                    presetTagCache.put(ch.key, OsmUtils.falseval);
+                    presetTagCache.put(ch.key, OsmUtils.trueval);
+                } else if (item instanceof TaggingPreset.Combo) {
+                    TaggingPreset.Combo co = (TaggingPreset.Combo) item;
+                    for (String value : co.values.split(",")) {
+                        presetTagCache.put(co.key, value);
+                    }
+                } else if (item instanceof TaggingPreset.Key) {
+                    TaggingPreset.Key ky = (TaggingPreset.Key) item;
+                    presetTagCache.put(ky.key, ky.value);
+                } else if (item instanceof TaggingPreset.Text) {
+                    TaggingPreset.Text tt = (TaggingPreset.Text) item;
+                    presetTagCache.putVoid(tt.key);
+                    if (tt.default_ != null && !tt.default_.equals("")) {
+                        presetTagCache.put(tt.key, tt.default_);
+                    }
+                }
+            }
+        }
+    }
+    
+    /**
      * replies the keys held by the cache
      *
      * @return the list of keys held by the cache
      */
-    public List<String> getKeys() {
+    protected List<String> getDataKeys() {
         return new ArrayList<String>(tagCache.keySet());
+    }
+
+    protected List<String> getPresetKeys() {
+        return new ArrayList<String>(presetTagCache.keySet());
     }
 
@@ -172 +188 @@
      * @return the list of auto completion values
      */
-    public List<String> getValues(String key) {
-        if (!tagCache.containsKey(key))
-            return new ArrayList<String>();
-        return new ArrayList<String>(tagCache.get(key));
+    protected List<String> getDataValues(String key) {
+        return new ArrayList<String>(tagCache.getValues(key));
+    }
+
+    protected static List<String> getPresetValues(String key) {
+        return new ArrayList<String>(presetTagCache.getValues(key));
     }
 
@@ -211 +229 @@
             list.clear();
         }
-        list.add(getValues(key), AutoCompletionItemPritority.IS_IN_DATASET);
+        list.add(getDataValues(key), AutoCompletionItemPritority.IS_IN_DATASET);
+        list.add(getPresetValues(key), AutoCompletionItemPritority.IS_IN_STANDARD);
     }
 
@@ -226 +245 @@
             list.clear();
         }
-        list.add(tagCache.keySet(), AutoCompletionItemPritority.IS_IN_DATASET);
+        list.add(getDataKeys(), AutoCompletionItemPritority.IS_IN_DATASET);
+        list.add(getPresetKeys(), AutoCompletionItemPritority.IS_IN_STANDARD);
     }
 }

trunk/src/org/openstreetmap/josm/gui/tagging/ac/AutoCompletionItemPritority.java

@@ -4 +4 @@
 public enum AutoCompletionItemPritority implements Comparable<AutoCompletionItemPritority> {
 
-    /** indicates that a value is in the current selection */
+    /** Indicates that a value is in the current selection. */
     IS_IN_SELECTION,
 
-    /** indicates that this is a standard value, i.e. a standard tag name
-     *  or a standard value for a given tag name
+    /**
+     * Indicates, that the value is standard and it is found in the data.
+     * This has higher priority than some arbitrary standard value that is
+     * usually not used by the user.
+     */
+    IS_IN_STANDARD_AND_IN_DATASET,
+
+    /**
+     * Indicates that this is a standard value, i.e. a standard tag name
+     * or a standard value for a given tag name (from the presets).
      */
     IS_IN_STANDARD,
 
     /**
-     * indicates that this is an arbitrary value from the data set, i.e.
-     * the value of a tag name=xxx
+     * Indicates that this is an arbitrary value from the data set, i.e.
+     * the value of a tag name=*.
      */
     IS_IN_DATASET,
 
-    /** unknown priority. This is the lowest priority. */
+    /** Unknown priority. This is the lowest priority. */
     UNKNOWN
 }

trunk/src/org/openstreetmap/josm/gui/tagging/ac/AutoCompletionList.java

@@ -157 +157 @@
         } else {
             // new item already exists. Update priority if necessary
-            //
-            if (toadd.getPriority().compareTo(item.getPriority()) < 0) {
-                item.setPriority(toadd.getPriority());
+
+            // If it is both in the dataset and in the presets, update the priority.
+            final AutoCompletionItemPritority IS_IN_DATASET = AutoCompletionItemPritority.IS_IN_DATASET;
+            final AutoCompletionItemPritority IS_IN_STANDARD = AutoCompletionItemPritority.IS_IN_STANDARD;
+            if ((toadd.getPriority() == IS_IN_STANDARD && item.getPriority() == IS_IN_DATASET) ||
+                (toadd.getPriority() == IS_IN_DATASET && item.getPriority() == IS_IN_STANDARD)) {
+
+                item.setPriority(AutoCompletionItemPritority.IS_IN_STANDARD_AND_IN_DATASET);
+            } else {
+                if (toadd.getPriority().compareTo(item.getPriority()) < 0) {
+                    item.setPriority(toadd.getPriority());
+                }
             }
         }

trunk/src/org/openstreetmap/josm/tools/MultiMap.java

@@ -2 +2 @@
 package org.openstreetmap.josm.tools;
 
-import java.util.ArrayList;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.HashMap;
 
 /**
- * Maps keys to a list of values. Partial implementation. Extend if you need more!
+ * Maps keys to ordered sets of values.
  */
-public class MultiMap<A, B> extends HashMap<A, List<B>> {
-    public void add(A key, B value) {
-        List<B> vals = get(key);
+public class MultiMap<A, B> extends HashMap<A, LinkedHashSet<B>> {
+    /**
+     * Map a key to a value. Can be called multiple times with the same key, but different value.
+     */
+    public void put(A key, B value) {
+        LinkedHashSet<B> vals = get(key);
         if (vals == null) {
-            vals = new ArrayList<B>();
+            vals = new LinkedHashSet<B>();
             put(key, vals);
         }
         vals.add(value);
     }
+    
+    /**
+     * Put a key that maps to nothing.
+     */
+    public void putVoid(A key) {
+        if (containsKey(key))
+            return;
+        put(key, new LinkedHashSet<B>());
+    }
+
+    /**
+     * Returns a list of values for the given key
+     * or an empty list, if it maps to nothing.
+     */
+    public LinkedHashSet<B> getValues(A key) {
+        if (!containsKey(key))
+            return new LinkedHashSet<B>();
+        return get(key);
+    }
 }