Ticket #3475: filters_dialogs.2.diff

File filters_dialogs.2.diff, 28.9 KB (added by Petr Dlouhý <petr.dlouhy@…>, 3 years ago)

new version without mathematic symbols

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

     
     1package org.openstreetmap.josm.data.osm; 
     2 
     3import org.openstreetmap.josm.actions.search.SearchAction; 
     4import org.openstreetmap.josm.actions.search.SearchAction.SearchSetting; 
     5import org.openstreetmap.josm.actions.search.SearchAction.SearchMode; 
     6 
     7/** 
     8 * 
     9 * @author Petr_DlouhÃœ 
     10 */ 
     11public class Filter extends SearchSetting { 
     12   private final String version = "1"; 
     13   public String filterName = ""; 
     14   public Boolean filtered = false; 
     15   public Boolean disabled = true; 
     16   public Boolean inverted = false; 
     17   public Boolean applyForChildren = true; 
     18   public Filter() { 
     19       super("", SearchMode.add, false, false); 
     20   } 
     21   public Filter(String text, SearchMode mode, boolean caseSensitive, boolean regexSearch, String filterName) { 
     22       super(text, mode, caseSensitive, regexSearch); 
     23       this.filterName = filterName; 
     24   } 
     25 
     26   public Filter(String prefText){ 
     27      super("", SearchMode.add, false, false); 
     28      String[] prfs = prefText.split(";"); 
     29      if(prfs.length != 10 && !prfs[0].equals(version)) 
     30         throw new Error("Incompatible filter preferences"); 
     31      text = prfs[1]; 
     32      if(prfs[2].equals("replace")) mode = SearchMode.replace; 
     33      if(prfs[2].equals("add")) mode = SearchMode.add; 
     34      if(prfs[2].equals("remove")) mode = SearchMode.remove; 
     35      if(prfs[2].equals("in_selection")) mode = SearchMode.in_selection; 
     36      caseSensitive = Boolean.parseBoolean(prfs[3]); 
     37      regexSearch = Boolean.parseBoolean(prfs[4]); 
     38      filterName = prfs[5]; 
     39      filtered = Boolean.parseBoolean(prfs[6]); 
     40      disabled = Boolean.parseBoolean(prfs[7]); 
     41      inverted = Boolean.parseBoolean(prfs[8]); 
     42      applyForChildren = Boolean.parseBoolean(prfs[9]); 
     43 
     44   }   
     45 
     46   public String getPrefString(){ 
     47      return version + ";" +  
     48          text + ";" + mode + ";" + caseSensitive + ";" + regexSearch + ";" + 
     49          filterName + ";" + filtered + ";" + disabled + ";" +  
     50          inverted + ";" + applyForChildren; 
     51   } 
     52} 

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

     
     1package org.openstreetmap.josm.data.osm; 
     2 
     3import static org.openstreetmap.josm.tools.I18n.tr; 
     4 
     5import javax.swing.table.AbstractTableModel; 
     6 
     7import java.util.LinkedList; 
     8import java.util.List; 
     9import java.util.Collection; 
     10import java.util.Map; 
     11 
     12import org.openstreetmap.josm.data.osm.Filter; 
     13import org.openstreetmap.josm.Main; 
     14import org.openstreetmap.josm.actions.search.SearchAction.Function; 
     15import org.openstreetmap.josm.actions.search.SearchAction; 
     16 
     17/** 
     18 * 
     19 * @author Petr_DlouhÃœ 
     20 */ 
     21public class Filters extends AbstractTableModel{ 
     22 
     23   public Filters(){ 
     24      loadPrefs(); 
     25   } 
     26 
     27   private List<Filter> filters = new LinkedList<Filter>(); 
     28   public void filter(){ 
     29      Collection<OsmPrimitive> seld = new LinkedList<OsmPrimitive> (); 
     30      Collection<OsmPrimitive> self = new LinkedList<OsmPrimitive> (); 
     31      Main.main.getCurrentDataSet().setFiltered(); 
     32      Main.main.getCurrentDataSet().setDisabled(); 
     33      for (Filter flt : filters){ 
     34            if(flt.filtered){ 
     35               SearchAction.getSelection(flt, self, new Function(){ 
     36                  public Boolean isSomething(OsmPrimitive o){ 
     37                     return o.isFiltered(); 
     38                  } 
     39               }); 
     40            }  
     41            if(flt.disabled) { 
     42               SearchAction.getSelection(flt, seld, new Function(){ 
     43                  public Boolean isSomething(OsmPrimitive o){ 
     44                     return o.isDisabled(); 
     45                  } 
     46               }); 
     47            } 
     48      } 
     49      Main.main.getCurrentDataSet().setFiltered(self); 
     50      Main.main.getCurrentDataSet().setDisabled(seld); 
     51      Main.map.mapView.repaint(); 
     52   } 
     53 
     54   private void loadPrefs(){ 
     55      Map<String,String> prefs = Main.pref.getAllPrefix("filters.filter"); 
     56      for (String value : prefs.values()) { 
     57         Filter filter = new Filter(value); 
     58         if(filter!=null) 
     59            filters.add(filter); 
     60      } 
     61   } 
     62 
     63   private void savePrefs(){ 
     64      Map<String,String> prefs = Main.pref.getAllPrefix("filters.filter"); 
     65      for (String key : prefs.keySet()) { 
     66         String[] sts = key.split("\\."); 
     67         if (sts.length != 3)throw new Error("Incompatible filter preferences"); 
     68         Main.pref.put("filters.filter." + sts[2], null); 
     69      } 
     70 
     71      int i = 0; 
     72      for (Filter flt : filters){ 
     73         Main.pref.put("filters.filter." + i++, flt.getPrefString()); 
     74      } 
     75   } 
     76 
     77   private void savePref(int i){ 
     78      if(i >= filters.size()) 
     79         Main.pref.put("filters.filter." + i, null); 
     80      else 
     81         Main.pref.put("filters.filter." + i, filters.get(i).getPrefString()); 
     82   } 
     83 
     84   public void addFilter(Filter f){ 
     85      filters.add(f); 
     86      savePref(filters.size()-1); 
     87      filter(); 
     88      fireTableRowsInserted(filters.size()-1, filters.size()-1); 
     89   } 
     90 
     91   public void moveDownFilter(int i){ 
     92      if(i >= filters.size()-1) return; 
     93      filters.add(i+1, filters.remove(i)); 
     94      savePref(i); 
     95      savePref(i+1); 
     96      filter(); 
     97      fireTableRowsUpdated(i, i+1); 
     98   } 
     99 
     100   public void moveUpFilter(int i){ 
     101      if(i == 0) return; 
     102      filters.add(i-1, filters.remove(i)); 
     103      savePref(i); 
     104      savePref(i-1); 
     105      filter(); 
     106      fireTableRowsUpdated(i-1, i); 
     107   } 
     108 
     109   public void removeFilter(int i){ 
     110      filters.remove(i); 
     111      savePrefs(); 
     112      filter(); 
     113      fireTableRowsDeleted(i, i); 
     114   } 
     115 
     116   public void setFilter(int i, Filter f){ 
     117      filters.set(i, f); 
     118      savePref(i); 
     119      filter(); 
     120      fireTableRowsUpdated(i, i); 
     121   } 
     122 
     123   public Filter getFilter(int i){ 
     124      return filters.get(i); 
     125   } 
     126 
     127   public int getRowCount(){ 
     128      return filters.size(); 
     129   } 
     130 
     131   public int getColumnCount(){ 
     132      return 6; 
     133   } 
     134 
     135   public String getColumnName(int column){ 
     136      String[] names = { tr("F"), tr("D"), tr("Name"), tr("C"), tr("I"), tr("M") }; 
     137      return names[column]; 
     138   } 
     139 
     140   public Class getColumnClass(int column){ 
     141      Class[] classes = { Boolean.class, Boolean.class, String.class, Boolean.class, Boolean.class, String.class }; 
     142      return classes[column]; 
     143   } 
     144 
     145   public boolean isCellEditable(int row, int column){ 
     146      if(column < 5)return true; 
     147      return false; 
     148   } 
     149 
     150   public void setValueAt(Object aValue, int row, int column){ 
     151      Filter f = filters.get(row); 
     152      switch(column){ 
     153         case 0: f.filtered = (Boolean)aValue; 
     154                 savePref(row); 
     155                 filter(); 
     156                 return; 
     157         case 1: f.disabled = (Boolean)aValue; 
     158                 savePref(row); 
     159                 filter(); 
     160                 return; 
     161         case 2: f.filterName = (String)aValue; 
     162                 savePref(row); 
     163                 return; 
     164         case 3: f.applyForChildren = (Boolean)aValue; 
     165                 savePref(row); 
     166                 filter(); 
     167                 return; 
     168         case 4: f.inverted = (Boolean)aValue; 
     169                 savePref(row); 
     170                 filter(); 
     171                 return; 
     172      } 
     173   } 
     174 
     175   public Object getValueAt(int row, int column){ 
     176      Filter f = filters.get(row); 
     177      switch(column){ 
     178         case 0: return f.filtered; 
     179         case 1: return f.disabled; 
     180         case 2: return f.filterName; 
     181         case 3: return f.applyForChildren; 
     182         case 4: return f.inverted; 
     183         case 5: 
     184                 switch(f.mode){ 
     185                    case replace: return tr("R"); 
     186                    case add: return tr("A"); 
     187                    case remove: return tr("D"); 
     188                    case in_selection: return tr("F"); 
     189                 } 
     190      } 
     191      return null; 
     192   } 
     193} 

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

     
     1// License: GPL. Copyright 2007 by Immanuel Scholz and others 
     2package org.openstreetmap.josm.gui.dialogs; 
     3 
     4import static org.openstreetmap.josm.tools.I18n.marktr; 
     5import static org.openstreetmap.josm.tools.I18n.tr; 
     6import static org.openstreetmap.josm.tools.I18n.trn; 
     7 
     8import javax.swing.JPanel; 
     9import javax.swing.JTable; 
     10import javax.swing.table.JTableHeader; 
     11import javax.swing.ListSelectionModel; 
     12import javax.swing.JPopupMenu; 
     13import javax.swing.table.AbstractTableModel; 
     14import javax.swing.JScrollPane; 
     15 
     16import java.awt.FlowLayout; 
     17import java.awt.BorderLayout; 
     18import java.awt.GridLayout; 
     19import java.awt.event.KeyEvent; 
     20import java.awt.event.ActionListener; 
     21import java.awt.event.ActionEvent; 
     22import java.awt.event.MouseEvent; 
     23 
     24import org.openstreetmap.josm.Main; 
     25import org.openstreetmap.josm.gui.SideButton; 
     26import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener; 
     27import org.openstreetmap.josm.gui.layer.DataChangeListener; 
     28import org.openstreetmap.josm.gui.layer.OsmDataLayer; 
     29import org.openstreetmap.josm.gui.layer.Layer; 
     30import org.openstreetmap.josm.data.osm.Filters; 
     31import org.openstreetmap.josm.data.osm.Filter; 
     32import org.openstreetmap.josm.tools.Shortcut; 
     33import org.openstreetmap.josm.data.osm.DataSet; 
     34import org.openstreetmap.josm.actions.search.SearchAction; 
     35 
     36/** 
     37 * 
     38 * @author Petr_DlouhÃœ 
     39 */ 
     40public class FilterDialog extends ToggleDialog implements DataChangeListener, LayerChangeListener { 
     41    private JTable userTable; 
     42    private Filters filters = new Filters(); 
     43    private SideButton addButton; 
     44    private SideButton editButton; 
     45    private SideButton deleteButton; 
     46    private SideButton upButton; 
     47    private SideButton downButton; 
     48    private JPopupMenu popupMenu; 
     49 
     50    public FilterDialog(){ 
     51       super(tr("Filter"), "filter", tr("Filter objects and hide/disable them."), 
     52               Shortcut.registerShortcut("subwindow:filter", tr("Toggle: {0}", tr("Filter")), KeyEvent.VK_F, Shortcut.GROUP_LAYER, Shortcut.SHIFT_DEFAULT), 162); 
     53 
     54       Layer.listeners.add(this); 
     55       build(); 
     56    } 
     57 
     58    protected JPanel buildButtonRow() { 
     59        JPanel pnl = new JPanel(new GridLayout(1, 4)); 
     60 
     61        addButton = new SideButton(marktr("Add"), "add", "SelectionList", tr("Add filter."), 
     62              new ActionListener(){ 
     63                 public void actionPerformed(ActionEvent evt){ 
     64                    Filter filter = (Filter)SearchAction.showSearchDialog(new Filter()); 
     65                    if(filter != null){ 
     66                       filters.addFilter(filter); 
     67                       filters.filter(); 
     68                    } 
     69                 } 
     70              }); 
     71        pnl.add(addButton); 
     72 
     73        editButton = new SideButton(marktr("Edit"), "edit", "SelectionList", tr("Edit filter."), 
     74              new ActionListener(){ 
     75                 public void actionPerformed(ActionEvent evt){ 
     76                    int index = userTable.getSelectionModel().getMinSelectionIndex(); 
     77                    if(index < 0) return; 
     78                    Filter f = filters.getFilter(index); 
     79                    Filter filter = (Filter)SearchAction.showSearchDialog(f); 
     80                    if(filter != null){ 
     81                       filters.setFilter(index, filter); 
     82                       filters.filter(); 
     83                    } 
     84                 } 
     85              }); 
     86        pnl.add(editButton); 
     87 
     88        deleteButton = new SideButton(marktr("Delete"), "delete", "SelectionList", tr("Delete filter."), 
     89              new ActionListener(){ 
     90                 public void actionPerformed(ActionEvent evt){ 
     91                    int index = userTable.getSelectionModel().getMinSelectionIndex(); 
     92                    if(index < 0) return; 
     93                    filters.removeFilter(index); 
     94                 } 
     95              }); 
     96        pnl.add(deleteButton); 
     97 
     98        upButton = new SideButton(marktr("Up"), "up", "SelectionList", tr("Move filter up."), 
     99              new ActionListener(){ 
     100                 public void actionPerformed(ActionEvent evt){ 
     101                    int index = userTable.getSelectionModel().getMinSelectionIndex(); 
     102                    if(index < 0) return; 
     103                    filters.moveUpFilter(index); 
     104                    userTable.getSelectionModel().setSelectionInterval(index-1, index-1); 
     105                 } 
     106              }); 
     107        pnl.add(upButton); 
     108         
     109        downButton = new SideButton(marktr("Down"), "down", "SelectionList", tr("Move filter down."), 
     110              new ActionListener(){ 
     111                 public void actionPerformed(ActionEvent evt){ 
     112                    int index = userTable.getSelectionModel().getMinSelectionIndex(); 
     113                    if(index < 0) return; 
     114                    filters.moveDownFilter(index); 
     115                    userTable.getSelectionModel().setSelectionInterval(index+1, index+1); 
     116                 } 
     117              }); 
     118        pnl.add(downButton); 
     119        return pnl; 
     120    } 
     121 
     122    protected String[] columnToolTips = { 
     123        tr("Filter elements"), 
     124        tr("Disable elements"), 
     125        tr("Apply also for children"), 
     126        tr("Inverse filter"), 
     127        null, 
     128        tr("Filter mode") 
     129    }; 
     130 
     131    protected void build() { 
     132        JPanel pnl = new JPanel(); 
     133        pnl.setLayout(new BorderLayout()); 
     134        userTable = new JTable(filters){ 
     135            protected JTableHeader createDefaultTableHeader() { 
     136                return new JTableHeader(columnModel) { 
     137                   public String getToolTipText(MouseEvent e) { 
     138                       String tip = null; 
     139                       java.awt.Point p = e.getPoint(); 
     140                       int index = columnModel.getColumnIndexAtX(p.x); 
     141                       int realIndex = columnModel.getColumn(index).getModelIndex(); 
     142                       return columnToolTips[realIndex]; 
     143                   } 
     144               }; 
     145           } 
     146        };    
     147   
     148        userTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); 
     149 
     150        userTable.getColumnModel().getColumn(0).setMaxWidth(1); 
     151        userTable.getColumnModel().getColumn(1).setMaxWidth(1); 
     152        userTable.getColumnModel().getColumn(3).setMaxWidth(1); 
     153        userTable.getColumnModel().getColumn(4).setMaxWidth(1); 
     154        userTable.getColumnModel().getColumn(5).setMaxWidth(1); 
     155 
     156        userTable.getColumnModel().getColumn(0).setResizable(false); 
     157        userTable.getColumnModel().getColumn(1).setResizable(false); 
     158        userTable.getColumnModel().getColumn(3).setResizable(false); 
     159        userTable.getColumnModel().getColumn(4).setResizable(false); 
     160        userTable.getColumnModel().getColumn(5).setResizable(false); 
     161 
     162        pnl.add(new JScrollPane(userTable), BorderLayout.CENTER); 
     163 
     164        // -- the button row 
     165        pnl.add(buildButtonRow(), BorderLayout.SOUTH); 
     166        /*userTable.addMouseListener(new DoubleClickAdapter());*/ 
     167        add(pnl, BorderLayout.CENTER); 
     168    } 
     169 
     170    public void layerRemoved(Layer a) { 
     171        if (a instanceof OsmDataLayer) { 
     172            ((OsmDataLayer)a).listenerDataChanged.remove(this); 
     173        } 
     174    } 
     175 
     176    public void layerAdded(Layer a) { 
     177        if (a instanceof OsmDataLayer) { 
     178            ((OsmDataLayer)a).listenerDataChanged.add(this); 
     179        } 
     180    } 
     181 
     182   public void activeLayerChange(Layer oldLayer, Layer newLayer) { 
     183      filters.filter(); 
     184   } 
     185 
     186   public void dataChanged(OsmDataLayer l){ 
     187      filters.filter(); 
     188   } 
     189} 

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

     
    2424import org.openstreetmap.josm.gui.ExtendedDialog; 
    2525import org.openstreetmap.josm.tools.GBC; 
    2626import org.openstreetmap.josm.tools.Shortcut; 
     27import org.openstreetmap.josm.data.osm.Filter; 
    2728 
    2829public class SearchAction extends JosmAction{ 
    2930 
    3031    public static final int SEARCH_HISTORY_SIZE = 10; 
    3132 
    3233    public static enum SearchMode { 
    33         replace, add, remove 
     34        replace, add, remove, in_selection 
    3435    } 
    3536 
    3637    public static final LinkedList<SearchSetting> searchHistory = new LinkedList<SearchSetting>(); 
    … …  
    5657        } 
    5758        SearchSetting s = lastSearch; 
    5859        if (s == null) { 
    59             s = new SearchSetting("", false, false, SearchMode.replace); 
     60            s = new SearchSetting("", SearchMode.replace, false, false); 
    6061        } 
    61         showSearchDialog(s); 
     62        SearchSetting se = showSearchDialog(s); 
     63        if(se != null) searchWithHistory(se); 
    6264    } 
    6365 
    64     public void showSearchDialog(SearchSetting initialValues) { 
    65         JLabel label = new JLabel(tr("Please enter a search string.")); 
     66    public static SearchSetting showSearchDialog(SearchSetting initialValues) { 
     67        JLabel label = new JLabel( initialValues instanceof Filter ? tr("Please enter a filter string.") : tr("Please enter a search string.")); 
    6668        final JTextField input = new JTextField(initialValues.text); 
    6769        input.selectAll(); 
    6870        input.requestFocusInWindow(); 
    6971        JRadioButton replace = new JRadioButton(tr("replace selection"), initialValues.mode == SearchMode.replace); 
    7072        JRadioButton add = new JRadioButton(tr("add to selection"), initialValues.mode == SearchMode.add); 
    7173        JRadioButton remove = new JRadioButton(tr("remove from selection"), initialValues.mode == SearchMode.remove); 
     74        JRadioButton in_selection = new JRadioButton(tr("find in selection"), initialValues.mode == SearchMode.in_selection); 
    7275        ButtonGroup bg = new ButtonGroup(); 
    7376        bg.add(replace); 
    7477        bg.add(add); 
    7578        bg.add(remove); 
     79        bg.add(in_selection); 
    7680 
    7781        JCheckBox caseSensitive = new JCheckBox(tr("case sensitive"), initialValues.caseSensitive); 
    7882        JCheckBox regexSearch   = new JCheckBox(tr("regular expression"), initialValues.regexSearch); 
    7983 
    8084        JPanel left = new JPanel(new GridBagLayout()); 
     85 
     86        JTextField finput = null; 
     87        if(initialValues instanceof Filter){ 
     88           JLabel fLabel = new JLabel(tr("Please enter a filter name.")); 
     89           finput = new JTextField(((Filter)initialValues).filterName); 
     90           left.add(fLabel, GBC.eop()); 
     91           left.add(finput, GBC.eop().fill(GBC.HORIZONTAL)); 
     92        } 
     93 
    8194        left.add(label, GBC.eop()); 
    8295        left.add(input, GBC.eop().fill(GBC.HORIZONTAL)); 
    8396        left.add(replace, GBC.eol()); 
    8497        left.add(add, GBC.eol()); 
    85         left.add(remove, GBC.eop()); 
     98        left.add(remove, GBC.eol()); 
     99        left.add(in_selection, GBC.eop()); 
    86100        left.add(caseSensitive, GBC.eol()); 
    87101        left.add(regexSearch, GBC.eol()); 
    88102 
    … …  
    119133        p.add(right); 
    120134        ExtendedDialog dialog = new ExtendedDialog( 
    121135                Main.parent, 
    122                 tr("Search"), 
    123                 new String[] {tr("Start Search"), tr("Cancel")} 
     136                initialValues instanceof Filter ? tr("Filter") : tr("Search"), 
     137                new String[] { 
     138                   initialValues instanceof Filter ? tr("Make filter") : tr("Start Search"), 
     139                tr("Cancel")} 
    124140        ); 
    125141        dialog.setButtonIcons(new String[] {"dialogs/search.png", "cancel.png"}); 
    126142        dialog.setContent(p); 
    127143        dialog.showDialog(); 
    128144        int result = dialog.getValue(); 
    129145 
    130         if(result != 1) return; 
     146        if(result != 1) return null; 
    131147 
    132148        // User pressed OK - let's perform the search 
    133149        SearchMode mode = replace.isSelected() ? SearchAction.SearchMode.replace 
    134                 : (add.isSelected() ? SearchAction.SearchMode.add : SearchAction.SearchMode.remove); 
    135         SearchSetting setting = new SearchSetting(input.getText(), caseSensitive.isSelected(), regexSearch.isSelected(), mode); 
    136         searchWithHistory(setting); 
     150                : (add.isSelected() ? SearchAction.SearchMode.add 
     151                : (remove.isSelected() ? SearchAction.SearchMode.remove : SearchAction.SearchMode.in_selection)); 
     152        if(initialValues instanceof Filter){ 
     153           return new Filter(input.getText(), mode, caseSensitive.isSelected(), regexSearch.isSelected(), finput.getText()); 
     154        } else { 
     155           return new SearchSetting(input.getText(), mode, caseSensitive.isSelected(), regexSearch.isSelected()); 
     156        } 
    137157    } 
    138158 
    139159    /** 
    … …  
    150170            searchHistory.removeLast(); 
    151171        } 
    152172        lastSearch = s; 
    153         search(s.text, s.mode, s.caseSensitive, s.regexSearch); 
     173        search(s); 
    154174    } 
    155175 
    156176    public static void searchWithoutHistory(SearchSetting s) { 
    157177        lastSearch = s; 
    158         search(s.text, s.mode, s.caseSensitive, s.regexSearch); 
     178        search(s); 
    159179    } 
    160180 
    161     public static void search(String search, SearchMode mode, boolean caseSensitive, boolean regexSearch) { 
    162         // FIXME: This is confusing. The GUI says nothing about loading primitives from an URL. We'd like to *search* 
    163         // for URLs in the current data set. 
    164         // Disabling until a better solution is in place 
    165         // 
    166         //        if (search.startsWith("http://") || search.startsWith("ftp://") || search.startsWith("https://") 
    167         //                || search.startsWith("file:/")) { 
    168         //            SelectionWebsiteLoader loader = new SelectionWebsiteLoader(search, mode); 
    169         //            if (loader.url != null && loader.url.getHost() != null) { 
    170         //                Main.worker.execute(loader); 
    171         //                return; 
    172         //            } 
    173         //        } 
     181    public interface Function{ 
     182       public Boolean isSomething(OsmPrimitive o); 
     183    } 
     184 
     185    public static Integer getSelection(SearchSetting s, Collection<OsmPrimitive> sel, Function f) { 
     186        Integer foundMatches = 0; 
    174187        try { 
    175             Collection<OsmPrimitive> sel = Main.main.getCurrentDataSet().getSelected(); 
    176             SearchCompiler.Match matcher = SearchCompiler.compile(search, caseSensitive, regexSearch); 
    177             int foundMatches = 0; 
     188            String searchText = s.text; 
     189            if(s instanceof Filter){ 
     190               searchText = ((Filter)s).inverted ? "-" : ""; 
     191               searchText = searchText + "(" + ((Filter)s).text + ")" + (((Filter)s).applyForChildren ? ("| child (" + ((Filter)s).text + ")"): ""); 
     192            } 
     193            /*System.out.println(searchText);  */ 
     194            SearchCompiler.Match matcher = SearchCompiler.compile(searchText, s.caseSensitive, s.regexSearch); 
     195            foundMatches = 0; 
    178196            for (OsmPrimitive osm : Main.main.getCurrentDataSet().allNonDeletedCompletePrimitives()) { 
    179                 if (mode == SearchMode.replace) { 
     197                if (s.mode == SearchMode.replace) { 
    180198                    if (matcher.match(osm)) { 
    181199                        sel.add(osm); 
    182200                        ++foundMatches; 
    183201                    } else { 
    184202                        sel.remove(osm); 
    185203                    } 
    186                 } else if (mode == SearchMode.add && !osm.isSelected() && matcher.match(osm)) { 
     204                } else if (s.mode == SearchMode.add && !f.isSomething(osm) && matcher.match(osm)) { 
    187205                    sel.add(osm); 
    188206                    ++foundMatches; 
    189                 } else if (mode == SearchMode.remove && osm.isSelected() && matcher.match(osm)) { 
     207                } else if (s.mode == SearchMode.remove && f.isSomething(osm) && matcher.match(osm)) { 
    190208                    sel.remove(osm); 
    191209                    ++foundMatches; 
     210                } else if (s.mode == SearchMode.in_selection &&  f.isSomething(osm)&& !matcher.match(osm)) { 
     211                    sel.remove(osm); 
     212                    ++foundMatches; 
    192213                } 
    193214            } 
    194             Main.main.getCurrentDataSet().setSelected(sel); 
    195             if (foundMatches == 0) { 
    196                 String msg = null; 
    197                 if (mode == SearchMode.replace) { 
    198                     msg = tr("No match found for ''{0}''", search); 
    199                 } else if (mode == SearchMode.add) { 
    200                     msg = tr("Nothing added to selection by searching for ''{0}''", search); 
    201                 } else if (mode == SearchMode.remove) { 
    202                     msg = tr("Nothing removed from selection by searching for ''{0}''", search); 
    203                 } 
    204                 Main.map.statusLine.setHelpText(msg); 
    205                 JOptionPane.showMessageDialog( 
    206                         Main.parent, 
    207                         msg, 
    208                         tr("Warning"), 
    209                         JOptionPane.WARNING_MESSAGE 
    210                 ); 
    211             } else { 
    212                 Main.map.statusLine.setHelpText(tr("Found {0} matches", foundMatches)); 
    213             } 
    214215        } catch (SearchCompiler.ParseError e) { 
    215216            JOptionPane.showMessageDialog( 
    216217                    Main.parent, 
    … …  
    220221 
    221222            ); 
    222223        } 
     224        return foundMatches; 
    223225    } 
     226  
     227    public static void search(String search, SearchMode mode, boolean caseSensitive, boolean regexSearch) { 
     228       search(new SearchSetting(search, mode, caseSensitive, regexSearch)); 
     229    } 
    224230 
     231    public static void search(SearchSetting s) { 
     232        // FIXME: This is confusing. The GUI says nothing about loading primitives from an URL. We'd like to *search* 
     233        // for URLs in the current data set. 
     234        // Disabling until a better solution is in place 
     235        // 
     236        //        if (search.startsWith("http://") || search.startsWith("ftp://") || search.startsWith("https://") 
     237        //                || search.startsWith("file:/")) { 
     238        //            SelectionWebsiteLoader loader = new SelectionWebsiteLoader(search, mode); 
     239        //            if (loader.url != null && loader.url.getHost() != null) { 
     240        //                Main.worker.execute(loader); 
     241        //                return; 
     242        //            } 
     243        //        } 
     244          
     245       Collection<OsmPrimitive> sel = Main.main.getCurrentDataSet().getSelected(); 
     246       int foundMatches = getSelection(s, sel, new Function(){ 
     247          public Boolean isSomething(OsmPrimitive o){ 
     248             return o.isSelected(); 
     249          } 
     250       }); 
     251       Main.main.getCurrentDataSet().setSelected(sel); 
     252       if (foundMatches == 0) { 
     253           String msg = null; 
     254           if (s.mode == SearchMode.replace) { 
     255               msg = tr("No match found for ''{0}''", s.text); 
     256           } else if (s.mode == SearchMode.add) { 
     257               msg = tr("Nothing added to selection by searching for ''{0}''", s.text); 
     258           } else if (s.mode == SearchMode.remove) { 
     259               msg = tr("Nothing removed from selection by searching for ''{0}''", s.text); 
     260           } else if (s.mode == SearchMode.in_selection) { 
     261               msg = tr("Nothing find in selection by searching for ''{0}''", s.text); 
     262           } 
     263           Main.map.statusLine.setHelpText(msg); 
     264           JOptionPane.showMessageDialog( 
     265                   Main.parent, 
     266                   msg, 
     267                   tr("Warning"), 
     268                   JOptionPane.WARNING_MESSAGE 
     269           ); 
     270       } else { 
     271           Main.map.statusLine.setHelpText(tr("Found {0} matches", foundMatches)); 
     272       } 
     273    } 
     274 
    225275    public static class SearchSetting { 
    226         String text; 
    227         SearchMode mode; 
    228         boolean caseSensitive; 
    229         boolean regexSearch; 
     276        public String text; 
     277        public SearchMode mode; 
     278        public boolean caseSensitive; 
     279        public boolean regexSearch; 
    230280 
    231         public SearchSetting(String text, boolean caseSensitive, boolean regexSearch, SearchMode mode) { 
     281        public SearchSetting(String text, SearchMode mode, boolean caseSensitive, boolean regexSearch) { 
    232282            super(); 
    233283            this.caseSensitive = caseSensitive; 
    234284            this.regexSearch = regexSearch; 

  • src/org/openstreetmap/josm/gui/MapFrame.java

     
    2828import org.openstreetmap.josm.gui.dialogs.PropertiesDialog; 
    2929import org.openstreetmap.josm.gui.dialogs.RelationListDialog; 
    3030import org.openstreetmap.josm.gui.dialogs.SelectionListDialog; 
     31import org.openstreetmap.josm.gui.dialogs.FilterDialog; 
    3132import org.openstreetmap.josm.gui.dialogs.ToggleDialog; 
    3233import org.openstreetmap.josm.gui.dialogs.UserListDialog; 
    3334import org.openstreetmap.josm.tools.Destroyable; 
    … …  
    103104        addToggleDialog(new PropertiesDialog(this)); 
    104105        addToggleDialog(new HistoryDialog()); 
    105106        addToggleDialog(new SelectionListDialog()); 
     107        addToggleDialog(new FilterDialog()); 
    106108        addToggleDialog(new UserListDialog()); 
    107109        addToggleDialog(conflictDialog = new ConflictDialog()); 
    108110        addToggleDialog(new CommandStackDialog(this));