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

Remove OsmPrimitive.setIncomplete()

Location:
trunk/src/org/openstreetmap/josm/data
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/org/openstreetmap/josm/data/Preferences.java

    r2618 r2620  
    1919import java.util.Collections;
    2020import java.util.LinkedList;
     21import java.util.List;
    2122import java.util.Map;
    2223import java.util.Properties;
    … …  
    6263
    6364    private static class DefaultPreferenceChangeEvent implements PreferenceChangeEvent {
    64         private String key;
    65         private String oldValue;
    66         private String newValue;
     65        private final String key;
     66        private final String oldValue;
     67        private final String newValue;
    6768
    6869        public DefaultPreferenceChangeEvent(String key, String oldValue, String newValue) {
    … …  
    7576            return key;
    7677        }
    77         public void setKey(String key) {
    78             this.key = key;
    79         }
    8078        public String getOldValue() {
    8179            return oldValue;
    8280        }
    83         public void setOldValue(String oldValue) {
    84             this.oldValue = oldValue;
    85         }
    8681        public String getNewValue() {
    8782            return newValue;
    88         }
    89         public void setNewValue(String newValue) {
    90             this.newValue = newValue;
    9183        }
    9284    }
    … …  
    713705    }
    714706    synchronized public void removeFromCollection(String key, String value) {
    715         ArrayList<String> a = new ArrayList<String>(getCollection(key, null));
    716         if(a != null)
    717         {
    718             a.remove(value);
    719             putCollection(key, a);
    720         }
     707        List<String> a = new ArrayList<String>(getCollection(key, null));
     708        a.remove(value);
     709        putCollection(key, a);
    721710    }
    722711    synchronized public boolean putCollection(String key, Collection<String> val) {

  • 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}

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

    r2612 r2620  
    6868    public Node(long id) {
    6969        super(id, false);
     70    }
     71
     72    /**
     73     * Create new complete node
     74     * @param id
     75     * @param version
     76     */
     77    public Node(long id, int version) {
     78        super(id, false);
     79        setOsmId(id, version);
    7080    }
    7181

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

    r2615 r2620  
    245245
    246246    /**
    247      * Creates a new primitive for the given id. If the id > 0, the primitive is marked
    248      * as incomplete.
    249      *
    250      * @param id the id. > 0 required
    251      * @param allowNegativeId Allows to set negative id. For internal use
     247     * Creates a new primitive for the given id.
     248     *
     249     * If allowNegativeId is set, provided id can be < 0 and will be set to primitive without any processing.
     250     * If allowNegativeId is not set, then id will have to be 0 (in that case new unique id will be generated) or
     251     * positive number.
     252     *
     253     * @param id the id
     254     * @param allowNegativeId
    252255     * @throws IllegalArgumentException thrown if id < 0 and allowNegativeId is false
    253256     */
    … …  
    12061209    }
    12071210
    1208     //TODO This method should not be necessary, incomplete state should be handled internally by OsmPrimitive
    1209     public void setIncomplete(boolean incomplete) {
     1211    private void setIncomplete(boolean incomplete) {
    12101212        this.incomplete = incomplete;
    12111213    }

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

    r2579 r2620  
    169169    public Relation(long id) throws IllegalArgumentException {
    170170        super(id, false);
     171    }
     172
     173    /**
     174     * Creates new complete relation
     175     * @param id
     176     * @param version
     177     */
     178    public Relation(long id, int version) {
     179        super(id, false);
     180        setOsmId(id, version);
    171181    }
    172182

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

    r2609 r2620  
    173173    /**
    174174     * Creates a new way for the given id. If the id > 0, the way is marked
    175      * as incomplete.
    176      *
    177      * @param id the id. > 0 required
     175     * as incomplete. If id == 0 then way is marked as new
     176     *
     177     * @param id the id. >= 0 required
    178178     * @throws IllegalArgumentException thrown if id < 0
    179179     */
    180180    public Way(long id) throws IllegalArgumentException {
    181181        super(id, false);
     182    }
     183
     184    /**
     185     * Creates new way with given id and version. Way is marked as complete
     186     * @param id
     187     * @param version
     188     */
     189    public Way(long id, int version) {
     190        super(id, false);
     191        setOsmId(id, version);
    182192    }
    183193

  • trunk/src/org/openstreetmap/josm/data/osm/visitor/MergeSourceBuildingVisitor.java

    r2578 r2620  
    4848    }
    4949
     50    protected boolean isInSelectionBase(OsmPrimitive primitive) {
     51        return selectionBase.getSelected().contains(primitive);
     52    }
     53
     54    protected boolean isAlreadyRemembered(OsmPrimitive primitive) {
     55        return mappedPrimitives.keySet().contains(primitive);
     56    }
     57
    5058    /**
    5159     * Remebers a node in the "hull"
    … …  
    6977            return;
    7078        Way clone = new Way(w);
    71         List<Node> newNodes = new ArrayList<Node>();
     79        List<Node> newNodes = new ArrayList<Node>(w.getNodesCount());
    7280        for (Node n: w.getNodes()) {
    7381            newNodes.add((Node)mappedPrimitives.get(n));
    … …  
    8492    protected void rememberRelation(Relation r) {
    8593        Relation clone;
    86         if (mappedPrimitives.keySet().contains(r)) {
     94        if (isAlreadyRemembered(r)) {
    8795            clone = (Relation)mappedPrimitives.get(r);
    8896            clone.cloneFrom(r);
    … …  
    99107        clone.setMembers(newMembers);
    100108
    101         if (! mappedPrimitives.keySet().contains(r)) {
     109        if (!isAlreadyRemembered(r)) {
    102110            mappedPrimitives.put(r, clone);
    103111        }
    … …  
    127135
    128136    protected void rememberNodeIncomplete(Node n) {
    129         if (isAlreadyRemembered(n))
    130             return;
    131         Node clone = new Node(n);
    132         clone.setIncomplete(true);
    133         mappedPrimitives.put(n, clone);
     137        if (!isAlreadyRemembered(n)) {
     138            mappedPrimitives.put(n, new Node(n.getId()));
     139        }
    134140    }
    135141
    136142    protected void rememberWayIncomplete(Way w) {
    137         if (isAlreadyRemembered(w))
    138             return;
    139         Way clone = new Way(w);
    140         clone.setNodes(null);
    141         clone.setIncomplete(true);
    142         mappedPrimitives.put(w, clone);
     143        if (!isAlreadyRemembered(w)) {
     144            mappedPrimitives.put(w, new Way(w.getId()));
     145        }
    143146    }
    144147
    145148    protected void rememberRelationIncomplete(Relation r) {
    146         Relation clone;
    147         if (isAlreadyRemembered(r)) {
    148             clone = (Relation)mappedPrimitives.get(r);
    149             clone.cloneFrom(r);
    150         } else {
    151             clone = new Relation(r);
    152         }
    153         clone.setMembers(null);
    154         clone.setIncomplete(true);
    155         if (! isAlreadyRemembered(r)) {
    156             mappedPrimitives.put(r, clone);
     149        if (!isAlreadyRemembered(r)) {
     150            mappedPrimitives.put(r, new Relation(r.getId()));
    157151        }
    158152    }
    … …  
    166160        //
    167161        for (Node n: w.getNodes()) {
    168             if (! isAlreadyRemembered(n)) {
    169                 n.visit(this);
    170             }
     162            n.visit(this);
    171163        }
    172164        // ... and the way itself
    173165        rememberWay(w);
    174     }
    175 
    176     protected boolean isInSelectionBase(OsmPrimitive primitive) {
    177         return selectionBase.getSelected().contains(primitive);
    178     }
    179 
    180     protected boolean isAlreadyRemembered(OsmPrimitive primitive) {
    181         return mappedPrimitives.keySet().contains(primitive);
    182166    }
    183167

  • trunk/src/org/openstreetmap/josm/data/projection/NTV2GridShiftFile.java

    r2507 r2620  
    2020package org.openstreetmap.josm.data.projection;
    2121
     22import java.io.IOException;
    2223import java.io.InputStream;
    23 import java.io.IOException;
    24 import java.io.RandomAccessFile;
    2524import java.io.Serializable;
    2625import java.util.ArrayList;
    … …  
    6261public class NTV2GridShiftFile implements Serializable {
    6362
    64     private static final int REC_SIZE = 16;
    6563    private String overviewHeaderCountId;
    6664    private int overviewHeaderCount;
    … …  
    270268    }
    271269
    272     public void unload() throws IOException {
     270    public void unload() {
    273271        topLevelSubGrid = null;
    274272    }
Note: See TracChangeset for help on using the changeset viewer.