Changeset 3355 in josm for trunk/src/org/openstreetmap

Timestamp:

2010-06-29T08:52:59+02:00 (15 years ago)

Author:

jttt

Message:

Simplify/optimize filters implementation

Location:

trunk/src/org/openstreetmap/josm

Files:

• actions/search/SearchAction.java (modified) (7 diffs)
• actions/search/SearchCompiler.java (modified) (1 diff)
• data/osm/Filter.java (modified) (2 diffs)
• data/osm/FilterMatcher.java (added)
• data/osm/Filters.java (modified) (7 diffs)
• gui/ExtendedDialog.java (modified) (1 diff)
• gui/dialogs/FilterDialog.java (modified) (2 diffs)

trunk/src/org/openstreetmap/josm/actions/search/SearchAction.java

@@ -30 +30 @@
 import org.openstreetmap.josm.actions.ParameterizedAction;
 import org.openstreetmap.josm.actions.ActionParameter.SearchSettingsActionParameter;
+import org.openstreetmap.josm.actions.search.SearchCompiler.ParseError;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.Filter;
@@ -157 +158 @@
         bg.add(in_selection);
 
-        JCheckBox caseSensitive = new JCheckBox(tr("case sensitive"), initialValues.caseSensitive);
+        final JCheckBox caseSensitive = new JCheckBox(tr("case sensitive"), initialValues.caseSensitive);
         JCheckBox allElements = new JCheckBox(tr("all objects"), initialValues.allElements);
         allElements.setToolTipText(tr("Also include incomplete and deleted objects in search."));
-        JCheckBox regexSearch   = new JCheckBox(tr("regular expression"), initialValues.regexSearch);
+        final JCheckBox regexSearch   = new JCheckBox(tr("regular expression"), initialValues.regexSearch);
 
         JPanel left = new JPanel(new GridBagLayout());
@@ -218 +219 @@
                     initialValues instanceof Filter ? tr("Submit filter") : tr("Start Search"),
                             tr("Cancel")}
-        );
+        ) {
+            @Override
+            protected void buttonAction(int buttonIndex, ActionEvent evt) {
+                if (buttonIndex == 0) {
+                    try {
+                        SearchCompiler.compile(hcbSearchString.getText(), caseSensitive.isSelected(), regexSearch.isSelected());
+                        super.buttonAction(buttonIndex, evt);
+                    } catch (ParseError e) {
+                        JOptionPane.showMessageDialog(
+                                Main.parent,
+                                tr("Search expression is not valid: \n\n {0}", e.getMessage()),
+                                tr("Invalid search expression"),
+                                JOptionPane.ERROR_MESSAGE);
+                    }
+                } else {
+                    super.buttonAction(buttonIndex, evt);
+                }
+            }
+        };
         dialog.setButtonIcons(new String[] {"dialogs/search.png", "cancel.png"});
         dialog.configureContextsensitiveHelp("/Action/Search", true /* show help button */);
@@ -282 +301 @@
 
             Collection<OsmPrimitive> all;
-            if(s.allElements)
+            if(s.allElements) {
                 all = Main.main.getCurrentDataSet().allPrimitives();
-            else
+            } else {
                 all = Main.main.getCurrentDataSet().allNonDeletedCompletePrimitives();
+            }
             for (OsmPrimitive osm : all) {
                 if (s.mode == SearchMode.replace) {
@@ -415 +435 @@
         public SearchSetting() {
             this("", SearchMode.replace, false /* case insensitive */,
-            false /* no regexp */, false /* only useful primitives */);
+                    false /* no regexp */, false /* only useful primitives */);
         }
 
         public SearchSetting(String text, SearchMode mode, boolean caseSensitive,
-        boolean regexSearch, boolean allElements) {
+                boolean regexSearch, boolean allElements) {
             this.caseSensitive = caseSensitive;
             this.regexSearch = regexSearch;
@@ -429 +449 @@
         public SearchSetting(SearchSetting original) {
             this(original.text, original.mode, original.caseSensitive,
-            original.regexSearch, original.allElements);
+                    original.regexSearch, original.allElements);
         }
 
@@ -436 +456 @@
             String cs = caseSensitive ?
                     /*case sensitive*/  trc("search", "CS") :
-                    /*case insensitive*/  trc("search", "CI");
-            String rx = regexSearch ? (", " +
-                    /*regex search*/ trc("search", "RX")) : "";
-            String all = allElements ? (", " +
-                    /*all elements*/ trc("search", "A")) : "";
-            return "\"" + text + "\" (" + cs + rx + all + ", " + mode + ")";
+                        /*case insensitive*/  trc("search", "CI");
+                    String rx = regexSearch ? (", " +
+                            /*regex search*/ trc("search", "RX")) : "";
+                    String all = allElements ? (", " +
+                            /*all elements*/ trc("search", "A")) : "";
+                    return "\"" + text + "\" (" + cs + rx + all + ", " + mode + ")";
         }
 

trunk/src/org/openstreetmap/josm/actions/search/SearchCompiler.java

@@ -75 +75 @@
     }
 
-    private static class Not extends Match {
+    public static class Not extends Match {
         private final Match match;
         public Not(Match match) {this.match = match;}

trunk/src/org/openstreetmap/josm/data/osm/Filter.java

@@ -11 +11 @@
     private static final String version = "1";
 
-    public Boolean enable = true;
-    public Boolean hiding = false;
-    public Boolean inverted = false;
+    public boolean enable = true;
+    public boolean hiding = false;
+    public boolean inverted = false;
+
     public Filter() {
         super("", SearchMode.add, false, false, false);
     }
     public Filter(String text, SearchMode mode, boolean caseSensitive,
-    boolean regexSearch, boolean allElements) {
+            boolean regexSearch, boolean allElements) {
         super(text, mode, caseSensitive, regexSearch, allElements);
     }
 
-    public Filter(String prefText){
+    public Filter(String prefText) {
         super("", SearchMode.add, false, false, false);
         String[] prfs = prefText.split(";");
@@ -49 +50 @@
     public String getPrefString(){
         return version + ";" +
-            text + ";" + mode + ";" + caseSensitive + ";" + regexSearch + ";" +
-            "legacy" + ";" + enable + ";" + hiding + ";" +
-            inverted + ";" +
-            "false"; // last parameter is not used any more (was: applyForChildren)
+        text + ";" + mode + ";" + caseSensitive + ";" + regexSearch + ";" +
+        "legacy" + ";" + enable + ";" + hiding + ";" +
+        inverted + ";" +
+        "false"; // last parameter is not used any more (was: applyForChildren)
     }
 }

trunk/src/org/openstreetmap/josm/data/osm/Filters.java

@@ -16 +16 @@
 import javax.swing.BorderFactory;
 import javax.swing.JLabel;
+import javax.swing.JOptionPane;
 import javax.swing.table.AbstractTableModel;
 
 import org.openstreetmap.josm.Main;
-import org.openstreetmap.josm.actions.search.SearchAction;
-import org.openstreetmap.josm.tools.Property;
+import org.openstreetmap.josm.actions.search.SearchCompiler.ParseError;
 
 /**
@@ -37 +37 @@
     }
 
-    private List<Filter> filters = new LinkedList<Filter>();
+    private final List<Filter> filters = new LinkedList<Filter>();
+    private final FilterMatcher filterMatcher = new FilterMatcher();
+
+    private void updateFilters() {
+        try {
+            filterMatcher.update(filters);
+            executeFilters();
+        } catch (ParseError e) {
+            JOptionPane.showMessageDialog(
+                    Main.parent,
+                    e.getMessage(),
+                    tr("Error in filter"),
+                    JOptionPane.ERROR_MESSAGE);
+        }
+    }
+
 
     /**
@@ -69 +84 @@
 
         final Collection<OsmPrimitive> all = ds.allNonDeletedCompletePrimitives();
-        // temporary set to collect the primitives returned by the search engine
-        final Collection<OsmPrimitive> collect = new HashSet<OsmPrimitive>();
-
-        // an auxiliary property to collect the results of the search engine
-        class CollectProperty implements Property<OsmPrimitive,Boolean> {
-            boolean collectValue;
-            boolean hidden;
-
-            /**
-             * Depending on the parameters, there are 4 different instances
-             * of this class.
-             *
-             * @param collectValue
-             *          If true: collect only those primitives that are added
-             *              by the search engine.
-             *          If false: Collect only those primitives that are removed
-             *              by the search engine.
-             * @param hidden Whether the property refers to primitives that
-             *          are disabled and hidden or to primitives
-             *          that are disabled only.
-             */
-            public CollectProperty(boolean collectValue, boolean hidden) {
-                this.collectValue = collectValue;
-                this.hidden = hidden;
-            }
-
-            public Boolean get(OsmPrimitive osm) {
-                if (hidden)
-                    return osm.isDisabledAndHidden();
-                else
-                    return osm.isDisabled();
-            }
-
-            public void set(OsmPrimitive osm, Boolean value) {
-                if (collectValue == value.booleanValue()) {
-                    collect.add(osm);
-                }
-            }
-        }
-
-        clearFilterFlags();
-
-        for (Filter flt : filters){
-            if (flt.enable) {
-                collect.clear();
-                // Decide, whether primitives are collected that are added to the current
-                // selection or those that are removed from the current selection
-                boolean collectValue = flt.mode == SearchAction.SearchMode.replace || flt.mode == SearchAction.SearchMode.add;
-                Property<OsmPrimitive,Boolean> collectProp = new CollectProperty(collectValue, flt.hiding);
-
-                SearchAction.getSelection(flt, all, collectProp);
-
-                switch (flt.mode) {
-                case replace:
-                    for (OsmPrimitive osm : all) {
-                        osm.unsetDisabledState();
+
+        for (OsmPrimitive primitive: all) {
+            if (filterMatcher.isHidden(primitive)) {
+                primitive.setDisabledState(true);
+            } else if (filterMatcher.isDisabled(primitive)) {
+                primitive.setDisabledState(false);
+            } else {
+                primitive.unsetDisabledState();
+            }
+        }
+
+        for (OsmPrimitive primitive: all) {
+            if (primitive instanceof Way && primitive.isDisabled()) {
+                Way w = (Way)primitive;
+                for (Node n: w.getNodes()) {
+
+                    if (n.isTagged()) {
+                        continue;
                     }
-                case add:
-                    if (!flt.inverted) {
-                        for (OsmPrimitive osm : collect) {
-                            osm.setDisabledState(flt.hiding);
-                        }
-
-                        // Find child nodes of hidden ways and add them to the hidden nodes
-                        for (OsmPrimitive osm : collect) {
-                            if (osm instanceof Way) {
-                                nodes:
-                                    for (Node n : ((Way)osm).getNodes()) {
-                                        // if node is already disabled, there is nothing to do
-                                        if (n.isDisabledAndHidden() || (!flt.hiding && n.isDisabled())) {
-                                            continue;
-                                        }
-
-                                        // if the node is tagged, don't disable it
-                                        if (n.isTagged()) {
-                                            continue;
-                                        }
-
-                                        // if the node has undisabled parent ways, don't disable it
-                                        for (OsmPrimitive ref : n.getReferrers()) {
-                                            if (ref instanceof Way) {
-                                                if (!ref.isDisabled()) {
-                                                    continue nodes;
-                                                }
-                                                if (flt.hiding && !ref.isDisabledAndHidden()) {
-                                                    continue nodes;
-                                                }
-                                            }
-                                        }
-                                        n.setDisabledState(flt.hiding);
-                                    }
-                            }
-                        }
-                    } else { // inverted filter in add mode
-                        // update flags, except for nodes
-                        for (OsmPrimitive osm : collect) {
-                            if (!(osm instanceof Node)) {
-                                osm.setDisabledState(flt.hiding);
-                            }
-                        }
-
-                        // update flags for nodes
-                        nodes:
-                            for (OsmPrimitive osm : collect) {
-                                if (osm instanceof Node) {
-                                    // if node is already disabled, there is nothing to do
-                                    if (osm.isDisabledAndHidden() || (!flt.hiding && osm.isDisabled())) {
-                                        continue;
-                                    }
-
-                                    // if the node has undisabled parent ways, don't disable it
-                                    for (OsmPrimitive ref : osm.getReferrers()) {
-                                        if (ref instanceof Way) {
-                                            if (!ref.isDisabled()) {
-                                                continue nodes;
-                                            }
-                                            if (flt.hiding && !ref.isDisabledAndHidden()) {
-                                                continue nodes;
-                                            }
-                                        }
-                                    }
-                                    osm.setDisabledState(flt.hiding);
-                                }
-                            }
-                    }
-                    break;
-                case remove:
-                case in_selection:
-                    if (!flt.inverted) {
-                        // make the described primitive undisabled again
-                        for (OsmPrimitive osm : collect) {
-                            osm.unsetDisabledState();
-                        }
-
-                        // Undisable the child nodes of undisabled ways
-                        for (OsmPrimitive osm : collect) {
-                            if (osm instanceof Way) {
-                                for (Node n : ((Way) osm).getNodes()) {
-                                    n.unsetDisabledState();
-                                }
-                            }
-                        }
-                    } else { // inverted filter in remove mode
-                        // make the described primitive undisabled again
-                        for (OsmPrimitive osm : collect) {
-                            osm.unsetDisabledState();
-                        }
-
-                        // Undisable the child nodes of undisabled ways
-                        for (OsmPrimitive osm : collect) {
-                            if (osm instanceof Way) {
-                                for (Node n : ((Way) osm).getNodes()) {
-                                    n.unsetDisabledState();
-                                }
-                            }
+
+                    boolean disabled = w.isDisabled();
+                    boolean hidden = w.isDisabledAndHidden();
+                    for (OsmPrimitive ref: n.getReferrers()) {
+                        if (ref instanceof Way) {
+                            disabled = disabled && ref.isDisabled();
+                            hidden = hidden && ref.isDisabledAndHidden();
                         }
                     }
-                    break;
-                default:
-                    throw new IllegalStateException();
+
+                    if (disabled) {
+                        n.setDisabledState(hidden);
+                    }
                 }
             }
@@ -269 +156 @@
 
     private void loadPrefs() {
-        Map<String,String> prefs = Main.pref.getAllPrefix("filters.filter");
+        Map<String, String> prefs = Main.pref.getAllPrefix("filters.filter");
         for (String value : prefs.values()) {
             filters.add(new Filter(value));
         }
-    }
-
-    private void savePrefs(){
-        Map<String,String> prefs = Main.pref.getAllPrefix("filters.filter");
+        updateFilters();
+    }
+
+    private void savePrefs() {
+        Map<String, String> prefs = Main.pref.getAllPrefix("filters.filter");
         for (String key : prefs.keySet()) {
             String[] sts = key.split("\\.");
-            if (sts.length != 3)throw new Error("Incompatible filter preferences");
+            if (sts.length != 3)
+                throw new Error("Incompatible filter preferences");
             Main.pref.put("filters.filter." + sts[2], null);
         }
 
         int i = 0;
-        for (Filter flt : filters){
+        for (Filter flt : filters) {
             Main.pref.put("filters.filter." + i++, flt.getPrefString());
         }
     }
 
-    private void savePref(int i){
-        if(i >= filters.size()) {
+    private void savePref(int i) {
+        if (i >= filters.size()) {
             Main.pref.put("filters.filter." + i, null);
         } else {
@@ -297 +186 @@
     }
 
-    public void addFilter(Filter f){
+    public void addFilter(Filter f) {
         filters.add(f);
-        savePref(filters.size()-1);
-        executeFilters();
-        fireTableRowsInserted(filters.size()-1, filters.size()-1);
-    }
-
-    public void moveDownFilter(int i){
-        if(i >= filters.size()-1) return;
-        filters.add(i+1, filters.remove(i));
+        savePref(filters.size() - 1);
+        updateFilters();
+        fireTableRowsInserted(filters.size() - 1, filters.size() - 1);
+    }
+
+    public void moveDownFilter(int i) {
+        if (i >= filters.size() - 1)
+            return;
+        filters.add(i + 1, filters.remove(i));
         savePref(i);
-        savePref(i+1);
-        executeFilters();
-        fireTableRowsUpdated(i, i+1);
-    }
-
-    public void moveUpFilter(int i){
-        if(i == 0) return;
-        filters.add(i-1, filters.remove(i));
+        savePref(i + 1);
+        updateFilters();
+        fireTableRowsUpdated(i, i + 1);
+    }
+
+    public void moveUpFilter(int i) {
+        if (i == 0)
+            return;
+        filters.add(i - 1, filters.remove(i));
         savePref(i);
-        savePref(i-1);
-        executeFilters();
-        fireTableRowsUpdated(i-1, i);
-    }
-
-    public void removeFilter(int i){
+        savePref(i - 1);
+        updateFilters();
+        fireTableRowsUpdated(i - 1, i);
+    }
+
+    public void removeFilter(int i) {
         filters.remove(i);
         savePrefs();
-        executeFilters();
+        updateFilters();
         fireTableRowsDeleted(i, i);
     }
 
-    public void setFilter(int i, Filter f){
+    public void setFilter(int i, Filter f) {
         filters.set(i, f);
         savePref(i);
-        executeFilters();
+        updateFilters();
         fireTableRowsUpdated(i, i);
     }
 
-    public Filter getFilter(int i){
+    public Filter getFilter(int i) {
         return filters.get(i);
     }
 
-    public int getRowCount(){
+    public int getRowCount() {
         return filters.size();
     }
 
-    public int getColumnCount(){
+    public int getColumnCount() {
         return 5;
     }
 
     @Override
-    public String getColumnName(int column){
+    public String getColumnName(int column) {
         String[] names = { /* translators notes must be in front */
-                /* column header: enable filter */             trc("filter","E"),
-                /* column header: hide filter */               trc("filter", "H"),
-                /* column header: filter text */               trc("filter", "Text"),
-                /* column header: inverted filter */           trc("filter", "I"),
-                /* column header: filter mode */               trc("filter", "M")
-        };
+                /* column header: enable filter */trc("filter", "E"),
+                /* column header: hide filter */trc("filter", "H"),
+                /* column header: filter text */trc("filter", "Text"),
+                /* column header: inverted filter */trc("filter", "I"),
+                /* column header: filter mode */trc("filter", "M") };
         return names[column];
     }
 
     @Override
-    public Class<?> getColumnClass(int column){
+    public Class<?> getColumnClass(int column) {
         Class<?>[] classes = { Boolean.class, Boolean.class, String.class, Boolean.class, String.class };
         return classes[column];
     }
 
-    public boolean isCellEnabled(int row, int column){
-        if(!filters.get(row).enable && column!=0) return false;
+    public boolean isCellEnabled(int row, int column) {
+        if (!filters.get(row).enable && column != 0)
+            return false;
         return true;
     }
 
     @Override
-    public boolean isCellEditable(int row, int column){
-        if(!filters.get(row).enable && column!=0) return false;
-        if(column < 4)return true;
+    public boolean isCellEditable(int row, int column) {
+        if (!filters.get(row).enable && column != 0)
+            return false;
+        if (column < 4)
+            return true;
         return false;
     }
 
     @Override
-    public void setValueAt(Object aValue, int row, int column){
+    public void setValueAt(Object aValue, int row, int column) {
         Filter f = filters.get(row);
-        switch(column){
+        switch (column) {
         case 0:
-            f.enable = (Boolean)aValue;
+            f.enable = (Boolean) aValue;
             savePref(row);
-            executeFilters();
+            updateFilters();
             fireTableRowsUpdated(row, row);
             break;
         case 1:
-            f.hiding = (Boolean)aValue;
+            f.hiding = (Boolean) aValue;
             savePref(row);
-            executeFilters();
+            updateFilters();
             break;
         case 2:
-            f.text = (String)aValue;
+            f.text = (String) aValue;
             savePref(row);
             break;
         case 3:
-            f.inverted = (Boolean)aValue;
+            f.inverted = (Boolean) aValue;
             savePref(row);
-            executeFilters();
+            updateFilters();
             break;
         }
-        if(column!=0) {
+        if (column != 0) {
             fireTableCellUpdated(row, column);
         }
     }
 
-    public Object getValueAt(int row, int column){
+    public Object getValueAt(int row, int column) {
         Filter f = filters.get(row);
-        switch(column){
-        case 0: return f.enable;
-        case 1: return f.hiding;
-        case 2: return f.text;
-        case 3: return f.inverted;
+        switch (column) {
+        case 0:
+            return f.enable;
+        case 1:
+            return f.hiding;
+        case 2:
+            return f.text;
+        case 3:
+            return f.inverted;
         case 4:
-            switch(f.mode){ /* translators notes must be in front */
-            case replace:      /* filter mode: replace */      return trc("filter", "R");
-            case add:          /* filter mode: add */          return trc("filter", "A");
-            case remove:       /* filter mode: remove */       return trc("filter", "D");
-            case in_selection: /* filter mode: in selection */ return trc("filter", "F");
+            switch (f.mode) { /* translators notes must be in front */
+            case replace: /* filter mode: replace */
+                return trc("filter", "R");
+            case add: /* filter mode: add */
+                return trc("filter", "A");
+            case remove: /* filter mode: remove */
+                return trc("filter", "D");
+            case in_selection: /* filter mode: in selection */
+                return trc("filter", "F");
             }
         }
@@ -434 +335 @@
             setOpaque(true);
             setForeground(Color.black);
-            setBackground(new Color(0,0,0,0));
+            setBackground(new Color(0, 0, 0, 0));
             setFont(getFont().deriveFont(Font.PLAIN));
             setBorder(BorderFactory.createEmptyBorder(0, 10, 10, 10));
@@ -450 +351 @@
 
     public void drawOSDText(Graphics2D g) {
-        String message = "<html>"+tr("<h2>Filter active</h2>");
+        String message = "<html>" + tr("<h2>Filter active</h2>");
 
         if (disabledCount == 0 && disabledAndHiddenCount == 0)

trunk/src/org/openstreetmap/josm/gui/ExtendedDialog.java

@@ -291 +291 @@
      * @param evt the button event
      */
-    protected void buttonAction(int i, ActionEvent evt) {
+    protected void buttonAction(int buttonIndex, ActionEvent evt) {
         String a = evt.getActionCommand();
-        result = i+1;
+        result = buttonIndex+1;
         setVisible(false);
     }

trunk/src/org/openstreetmap/josm/gui/dialogs/FilterDialog.java

@@ -80 +80 @@
                 if(filter != null){
                     filters.addFilter(filter);
-                    filters.executeFilters();
                 }
             }
@@ -95 +94 @@
                 if(filter != null){
                     filters.setFilter(index, filter);
-                    filters.executeFilters();
                 }
             }