Ignore:
Timestamp:
2009-12-12T17:10:01+01:00 (14 years ago)
Author:
jttt
Message:

Remove OsmPrimitive.setIncomplete()

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r2180 r2620  
    44import static org.openstreetmap.josm.tools.I18n.trc;
    55
    6 import javax.swing.table.AbstractTableModel;
    7 
     6import java.util.Collection;
    87import java.util.LinkedList;
    98import java.util.List;
    10 import java.util.Collection;
    119import java.util.Map;
    1210
    13 import org.openstreetmap.josm.data.osm.Filter;
     11import javax.swing.table.AbstractTableModel;
     12
    1413import org.openstreetmap.josm.Main;
     14import org.openstreetmap.josm.actions.search.SearchAction;
    1515import org.openstreetmap.josm.actions.search.SearchAction.Function;
    16 import org.openstreetmap.josm.actions.search.SearchAction;
    1716
    1817/**
    … …  
    2221public class Filters extends AbstractTableModel{
    2322
    24    public int disabledCount, hiddenCount;
    25 
    26    public Filters(){
    27       loadPrefs();
    28    }
    29 
    30    private List<Filter> filters = new LinkedList<Filter>();
    31    public void filter(){
    32       Collection<OsmPrimitive> seld = new LinkedList<OsmPrimitive> ();
    33       Collection<OsmPrimitive> self = new LinkedList<OsmPrimitive> ();
    34       if(Main.main.getCurrentDataSet() == null)return;
    35       Main.main.getCurrentDataSet().setFiltered();
    36       Main.main.getCurrentDataSet().setDisabled();
    37       for (Filter flt : filters){
     23    public int disabledCount, hiddenCount;
     24
     25    public Filters(){
     26        loadPrefs();
     27    }
     28
     29    private List<Filter> filters = new LinkedList<Filter>();
     30    public void filter(){
     31        Collection<OsmPrimitive> seld = new LinkedList<OsmPrimitive> ();
     32        Collection<OsmPrimitive> self = new LinkedList<OsmPrimitive> ();
     33        if(Main.main.getCurrentDataSet() == null)return;
     34        Main.main.getCurrentDataSet().setFiltered();
     35        Main.main.getCurrentDataSet().setDisabled();
     36        for (Filter flt : filters){
    3837            if(flt.enable){
    39                SearchAction.getSelection(flt, seld, new Function(){
    40                   public Boolean isSomething(OsmPrimitive o){
    41                      return o.isDisabled();
    42                   }
    43                });
    44                if(flt.hide) {
    45                   SearchAction.getSelection(flt, self, new Function(){
    46                      public Boolean isSomething(OsmPrimitive o){
    47                         return o.isFiltered();
    48                      }
    49                   });
    50                }
     38                SearchAction.getSelection(flt, seld, new Function(){
     39                    public Boolean isSomething(OsmPrimitive o){
     40                        return o.isDisabled();
     41                    }
     42                });
     43                if(flt.hide) {
     44                    SearchAction.getSelection(flt, self, new Function(){
     45                        public Boolean isSomething(OsmPrimitive o){
     46                            return o.isFiltered();
     47                        }
     48                    });
     49                }
    5150            }
    52       }
    53       disabledCount = seld.size() - self.size();
    54       hiddenCount = self.size();
    55       Main.main.getCurrentDataSet().setFiltered(self);
    56       Main.main.getCurrentDataSet().setDisabled(seld);
    57       Main.map.mapView.repaint();
    58    }
    59 
    60    private void loadPrefs(){
    61       Map<String,String> prefs = Main.pref.getAllPrefix("filters.filter");
    62       for (String value : prefs.values()) {
    63          Filter filter = new Filter(value);
    64          if(filter!=null)
    65             filters.add(filter);
    66       }
    67    }
    68 
    69    private void savePrefs(){
    70       Map<String,String> prefs = Main.pref.getAllPrefix("filters.filter");
    71       for (String key : prefs.keySet()) {
    72          String[] sts = key.split("\\.");
    73          if (sts.length != 3)throw new Error("Incompatible filter preferences");
    74          Main.pref.put("filters.filter." + sts[2], null);
    75       }
    76 
    77       int i = 0;
    78       for (Filter flt : filters){
    79          Main.pref.put("filters.filter." + i++, flt.getPrefString());
    80       }
    81    }
    82 
    83    private void savePref(int i){
    84       if(i >= filters.size())
    85          Main.pref.put("filters.filter." + i, null);
    86       else
    87          Main.pref.put("filters.filter." + i, filters.get(i).getPrefString());
    88    }
    89 
    90    public void addFilter(Filter f){
    91       filters.add(f);
    92       savePref(filters.size()-1);
    93       filter();
    94       fireTableRowsInserted(filters.size()-1, filters.size()-1);
    95    }
    96 
    97    public void moveDownFilter(int i){
    98       if(i >= filters.size()-1) return;
    99       filters.add(i+1, filters.remove(i));
    100       savePref(i);
    101       savePref(i+1);
    102       filter();
    103       fireTableRowsUpdated(i, i+1);
    104    }
    105 
    106    public void moveUpFilter(int i){
    107       if(i == 0) return;
    108       filters.add(i-1, filters.remove(i));
    109       savePref(i);
    110       savePref(i-1);
    111       filter();
    112       fireTableRowsUpdated(i-1, i);
    113    }
    114 
    115    public void removeFilter(int i){
    116       filters.remove(i);
    117       savePrefs();
    118       filter();
    119       fireTableRowsDeleted(i, i);
    120    }
    121 
    122    public void setFilter(int i, Filter f){
    123       filters.set(i, f);
    124       savePref(i);
    125       filter();
    126       fireTableRowsUpdated(i, i);
    127    }
    128 
    129    public Filter getFilter(int i){
    130       return filters.get(i);
    131    }
    132 
    133    public int getRowCount(){
    134       return filters.size();
    135    }
    136 
    137    public int getColumnCount(){
    138       return 6;
    139    }
    140 
    141    public String getColumnName(int column){
    142       String[] names = { /* translators notes must be in front */
    143           /* column header: enable filter */             trc("filter","E"),
    144           /* column header: hide filter */               tr("H"),
    145           /* column header: filter text */               tr("Text"),
    146           /* column header: apply filter for children */ tr("C"),
    147           /* column header: inverted filter */           tr("I"),
    148           /* column header: filter mode */               tr("M")
    149       };
    150       return names[column];
    151    }
    152 
    153    public Class getColumnClass(int column){
    154       Class[] classes = { Boolean.class, Boolean.class, String.class, Boolean.class, Boolean.class, String.class };
    155       return classes[column];
    156    }
    157 
    158    public boolean isCellEnabled(int row, int column){
    159       if(!filters.get(row).enable && column!=0) return false;
    160       return true;
    161    }
    162 
    163    public boolean isCellEditable(int row, int column){
    164       if(!filters.get(row).enable && column!=0) return false;
    165       if(column < 5)return true;
    166       return false;
    167    }
    168 
    169    public void setValueAt(Object aValue, int row, int column){
    170       Filter f = filters.get(row);
    171       switch(column){
    172          case 0: f.enable = (Boolean)aValue;
    173                  savePref(row);
    174                  filter();
    175                  fireTableRowsUpdated(row, row);
    176                  break;
    177          case 1: f.hide = (Boolean)aValue;
    178                  savePref(row);
    179                  filter();
    180                  break;
    181          case 2: f.text = (String)aValue;
    182                  savePref(row);
    183                  break;
    184          case 3: f.applyForChildren = (Boolean)aValue;
    185                  savePref(row);
    186                  filter();
    187                  break;
    188          case 4: f.inverted = (Boolean)aValue;
    189                  savePref(row);
    190                  filter();
    191                  break;
    192       }
    193       if(column!=0)fireTableCellUpdated(row, column);
    194    }
    195 
    196    public Object getValueAt(int row, int column){
    197       Filter f = filters.get(row);
    198       switch(column){
    199          case 0: return f.enable;
    200          case 1: return f.hide;
    201          case 2: return f.text;
    202          case 3: return f.applyForChildren;
    203          case 4: return f.inverted;
    204          case 5:
    205                  switch(f.mode){ /* translators notes must be in front */
    206                     case replace:      /* filter mode: replace */      return tr("R");
    207                     case add:          /* filter mode: add */          return tr("A");
    208                     case remove:       /* filter mode: remove */       return tr("D");
    209                     case in_selection: /* filter mode: in selection */ return tr("F");
    210                  }
    211       }
    212       return null;
    213    }
     51        }
     52        disabledCount = seld.size() - self.size();
     53        hiddenCount = self.size();
     54        Main.main.getCurrentDataSet().setFiltered(self);
     55        Main.main.getCurrentDataSet().setDisabled(seld);
     56        Main.map.mapView.repaint();
     57    }
     58
     59    private void loadPrefs(){
     60        Map<String,String> prefs = Main.pref.getAllPrefix("filters.filter");
     61        for (String value : prefs.values()) {
     62            filters.add(new Filter(value));
     63        }
     64    }
     65
     66    private void savePrefs(){
     67        Map<String,String> prefs = Main.pref.getAllPrefix("filters.filter");
     68        for (String key : prefs.keySet()) {
     69            String[] sts = key.split("\\.");
     70            if (sts.length != 3)throw new Error("Incompatible filter preferences");
     71            Main.pref.put("filters.filter." + sts[2], null);
     72        }
     73
     74        int i = 0;
     75        for (Filter flt : filters){
     76            Main.pref.put("filters.filter." + i++, flt.getPrefString());
     77        }
     78    }
     79
     80    private void savePref(int i){
     81        if(i >= filters.size()) {
     82            Main.pref.put("filters.filter." + i, null);
     83        } else {
     84            Main.pref.put("filters.filter." + i, filters.get(i).getPrefString());
     85        }
     86    }
     87
     88    public void addFilter(Filter f){
     89        filters.add(f);
     90        savePref(filters.size()-1);
     91        filter();
     92        fireTableRowsInserted(filters.size()-1, filters.size()-1);
     93    }
     94
     95    public void moveDownFilter(int i){
     96        if(i >= filters.size()-1) return;
     97        filters.add(i+1, filters.remove(i));
     98        savePref(i);
     99        savePref(i+1);
     100        filter();
     101        fireTableRowsUpdated(i, i+1);
     102    }
     103
     104    public void moveUpFilter(int i){
     105        if(i == 0) return;
     106        filters.add(i-1, filters.remove(i));
     107        savePref(i);
     108        savePref(i-1);
     109        filter();
     110        fireTableRowsUpdated(i-1, i);
     111    }
     112
     113    public void removeFilter(int i){
     114        filters.remove(i);
     115        savePrefs();
     116        filter();
     117        fireTableRowsDeleted(i, i);
     118    }
     119
     120    public void setFilter(int i, Filter f){
     121        filters.set(i, f);
     122        savePref(i);
     123        filter();
     124        fireTableRowsUpdated(i, i);
     125    }
     126
     127    public Filter getFilter(int i){
     128        return filters.get(i);
     129    }
     130
     131    public int getRowCount(){
     132        return filters.size();
     133    }
     134
     135    public int getColumnCount(){
     136        return 6;
     137    }
     138
     139    @Override
     140    public String getColumnName(int column){
     141        String[] names = { /* translators notes must be in front */
     142                /* column header: enable filter */             trc("filter","E"),
     143                /* column header: hide filter */               tr("H"),
     144                /* column header: filter text */               tr("Text"),
     145                /* column header: apply filter for children */ tr("C"),
     146                /* column header: inverted filter */           tr("I"),
     147                /* column header: filter mode */               tr("M")
     148        };
     149        return names[column];
     150    }
     151
     152    @Override
     153    public Class<?> getColumnClass(int column){
     154        Class<?>[] classes = { Boolean.class, Boolean.class, String.class, Boolean.class, Boolean.class, String.class };
     155        return classes[column];
     156    }
     157
     158    public boolean isCellEnabled(int row, int column){
     159        if(!filters.get(row).enable && column!=0) return false;
     160        return true;
     161    }
     162
     163    @Override
     164    public boolean isCellEditable(int row, int column){
     165        if(!filters.get(row).enable && column!=0) return false;
     166        if(column < 5)return true;
     167        return false;
     168    }
     169
     170    @Override
     171    public void setValueAt(Object aValue, int row, int column){
     172        Filter f = filters.get(row);
     173        switch(column){
     174        case 0: f.enable = (Boolean)aValue;
     175        savePref(row);
     176        filter();
     177        fireTableRowsUpdated(row, row);
     178        break;
     179        case 1: f.hide = (Boolean)aValue;
     180        savePref(row);
     181        filter();
     182        break;
     183        case 2: f.text = (String)aValue;
     184        savePref(row);
     185        break;
     186        case 3: f.applyForChildren = (Boolean)aValue;
     187        savePref(row);
     188        filter();
     189        break;
     190        case 4: f.inverted = (Boolean)aValue;
     191        savePref(row);
     192        filter();
     193        break;
     194        }
     195        if(column!=0) {
     196            fireTableCellUpdated(row, column);
     197        }
     198    }
     199
     200    public Object getValueAt(int row, int column){
     201        Filter f = filters.get(row);
     202        switch(column){
     203        case 0: return f.enable;
     204        case 1: return f.hide;
     205        case 2: return f.text;
     206        case 3: return f.applyForChildren;
     207        case 4: return f.inverted;
     208        case 5:
     209            switch(f.mode){ /* translators notes must be in front */
     210            case replace:      /* filter mode: replace */      return tr("R");
     211            case add:          /* filter mode: add */          return tr("A");
     212            case remove:       /* filter mode: remove */       return tr("D");
     213            case in_selection: /* filter mode: in selection */ return tr("F");
     214            }
     215        }
     216        return null;
     217    }
    214218}
Note: See TracChangeset for help on using the changeset viewer.