Changeset 2620 in josm for trunk


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

Remove OsmPrimitive.setIncomplete()

Location:
trunk
Files:
14 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    }
  • trunk/src/org/openstreetmap/josm/io/GpxWriter.java

    r2327 r2620  
    5050        out.println("<gpx version=\"1.1\" creator=\"JOSM GPX export\" xmlns=\"http://www.topografix.com/GPX/1/1\"\n" +
    5151                "    xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" \n" +
    52                 "    xsi:schemaLocation=\"http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd\">");
     52        "    xsi:schemaLocation=\"http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd\">");
    5353        indent = "  ";
    5454        writeMetaData();
     
    6060    }
    6161
     62    @SuppressWarnings("unchecked")
    6263    private void writeAttr(Map<String, Object> attr) {
    6364        // FIXME this loop is evil, because it does not assure the
     
    6768            String k = ent.getKey();
    6869            if (k.equals(GpxData.META_LINKS)) {
    69                 for (Object link : (Collection) ent.getValue()) {
    70                     gpxLink((GpxLink) link);
     70                for (GpxLink link : (Collection<GpxLink>) ent.getValue()) {
     71                    gpxLink(link);
    7172                }
    7273            } else {
     
    7677    }
    7778
     79    @SuppressWarnings("unchecked")
    7880    private void writeMetaData() {
    7981        Map<String, Object> attr = data.attr;
     
    8183
    8284        // write the description
    83         if (attr.containsKey(GpxData.META_DESC)) simpleTag("desc", (String)attr.get(GpxData.META_DESC));
     85        if (attr.containsKey(GpxData.META_DESC)) {
     86            simpleTag("desc", (String)attr.get(GpxData.META_DESC));
     87        }
    8488
    8589        // write the author details
     
    116120        // write links
    117121        if(attr.containsKey(GpxData.META_LINKS)) {
    118             for (Object link : (Collection) attr.get(GpxData.META_LINKS)) {
    119                 gpxLink((GpxLink) link);
     122            for (GpxLink link : (Collection<GpxLink>) attr.get(GpxData.META_LINKS)) {
     123                gpxLink(link);
    120124            }
    121125        }
    122126
    123127        // write keywords
    124         if (attr.containsKey(GpxData.META_KEYWORDS)) simpleTag("keywords", (String)attr.get(GpxData.META_KEYWORDS));
     128        if (attr.containsKey(GpxData.META_KEYWORDS)) {
     129            simpleTag("keywords", (String)attr.get(GpxData.META_KEYWORDS));
     130        }
    125131
    126132        Bounds bounds = data.recalculateBounds();
     
    128134        {
    129135            String b = "minlat=\"" + bounds.getMin().lat() + "\" minlon=\"" + bounds.getMin().lon() +
    130                 "\" maxlat=\"" + bounds.getMax().lat() + "\" maxlon=\"" + bounds.getMax().lon() + "\"" ;
     136            "\" maxlat=\"" + bounds.getMax().lat() + "\" maxlon=\"" + bounds.getMax().lon() + "\"" ;
    131137            inline("bounds", b);
    132138        }
  • trunk/src/org/openstreetmap/josm/plugins/PluginInformation.java

    r2512 r2620  
    2121
    2222import org.openstreetmap.josm.Main;
    23 import org.openstreetmap.josm.actions.AboutAction;
    2423import org.openstreetmap.josm.data.Version;
    2524import org.openstreetmap.josm.tools.LanguageInfo;
     
    125124        {
    126125            int myv = Version.getInstance().getVersion();
    127             for(Map.Entry entry : attr.entrySet())
     126            for(Map.Entry<Object, Object> entry : attr.entrySet())
    128127            {
    129128                try {
  • trunk/test/unit/org/openstreetmap/josm/data/osm/APIDataSetTest.java

    r2578 r2620  
    7474        r3.put("name", "r3");
    7575
    76         Relation r4 = new Relation(1);
     76        Relation r4 = new Relation(1, 1);
    7777        r4.put("name", "r4");
    78         r4.setIncomplete(false);
    7978        r4.setModified(true);
    8079
  • trunk/test/unit/org/openstreetmap/josm/data/osm/DataSetMergerTest.java

    r2587 r2620  
    191191        DataSet my = new DataSet();
    192192        my.setVersion("0.6");
    193         Node n = new Node(1);
     193        Node n = new Node(1, 1);
    194194        n.setCoor(new LatLon(0,0));
    195         n.setIncomplete(false);
    196195        n.setDeleted(true);
    197196        n.put("key1", "value1");
     
    201200        their.setVersion("0.6");
    202201        Node n1 = new Node(new LatLon(0,0));
    203         n1.setOsmId(1,1);
     202        n1.setOsmId(1,2);
    204203        n1.setModified(false);
    205204        n1.put("key1", "value1-new");
     
    437436        DataSet my = new DataSet();
    438437        my.setVersion("0.6");
    439         Node n = new Node();
    440         n.setCoor(new LatLon(0,0));
    441         n.setOsmId(1,1);
    442         n.setIncomplete(true);
     438        Node n = new Node(1);
    443439        my.addPrimitive(n);
    444440
     
    10571053        my.addPrimitive(n5);
    10581054
    1059         Way w6 = new Way(3);
    1060         w6.setIncomplete(false);
     1055        Way w6 = new Way(3, 1);
    10611056        w6.setNodes(Arrays.asList(n4,n5));
    10621057        my.addPrimitive(w6);
     
    10971092
    10981093        // an complete node
    1099         Node n1 = new Node(1);
     1094        Node n1 = new Node(1, 1);
    11001095        n1.setCoor(new LatLon(1,1));
    1101         n1.setIncomplete(false);
    11021096        source.addPrimitive(n1);
    11031097
    11041098        // another complete node
    1105         Node n2 = new Node(2);
     1099        Node n2 = new Node(2, 1);
    11061100        n2.setCoor(new LatLon(2,2));
    1107         n2.setIncomplete(false);
    11081101        source.addPrimitive(n2);
    11091102
    1110         // --- target daset
     1103        // --- target dataset
    11111104        DataSet target = new DataSet();
    11121105        target.setVersion("0.6");
     
    11181111        target.addPrimitive(n5);
    11191112
    1120         Way w6 = new Way(3);
    1121         w6.setIncomplete(false);
     1113        Way w6 = new Way(3, 1);
    11221114        w6.addNode(n4);
    11231115        w6.addNode(n5);
    1124         w6.setIncomplete(true);
    11251116        target.addPrimitive(w6);
    11261117
     
    11431134        assertNotNull(w);
    11441135        assertFalse(w.hasIncompleteNodes());
    1145         assertFalse(w.isUsable());
     1136        assertTrue(w.isUsable());
    11461137        assertEquals(2, w.getNodesCount());
    11471138        assertEquals(1, w.getNode(0).getId());
  • trunk/test/unit/org/openstreetmap/josm/data/osm/visitor/MergeSourceBuildingVisitorTest.java

    r2578 r2620  
    7171        Node n1 = new Node(1);
    7272        Node n2 = new Node(2);
    73         Way w1 = new Way(3);
    74         w1.setIncomplete(false);
     73        Way w1 = new Way(3, 1);
    7574        w1.addNode(n1);
    7675        w1.addNode(n2);
     
    104103        Node n1 = new Node(1);
    105104        Node n2 = new Node(2);
    106         Way w1 = new Way(3);
    107         w1.setIncomplete(false);
     105        Way w1 = new Way(3, 1);
    108106        w1.addNode(n1);
    109107        w1.addNode(n2);
     
    154152        DataSet source = new DataSet();
    155153        Relation r1 = new Relation(1);
    156         Node n20 = new Node(20);
     154        Node n20 = new Node(20, 1);
    157155        r1.addMember(new RelationMember("node-20",n20));
    158         r1.setIncomplete(false);
    159         Way w30 = new Way(30);
    160         w30.setIncomplete(false);
     156        Way w30 = new Way(30, 1);
    161157        Node n21;
    162158        w30.addNode(n21 = new Node(21));
     
    216212        Node n20 = new Node(20);
    217213        r1.addMember(new RelationMember("node-20",n20));
    218         Way w30 = new Way(30);
    219         w30.setIncomplete(false);
     214        Way w30 = new Way(30, 1);
    220215        Node n21;
    221216        w30.addNode(n21 = new Node(21));
  • trunk/test/unit/org/openstreetmap/josm/gui/conflict/nodes/NodeListMergeModelTest.java

    r2578 r2620  
    2929    }
    3030
    31     protected DefaultListSelectionModel inspectListSelectionModel(NodeListMergeModel model, String name) throws NoSuchFieldException, IllegalAccessException {
     31    protected DefaultListSelectionModel inspectListSelectionModel(NodeListMergeModel model, String name) {
    3232        return field(name).ofType(DefaultListSelectionModel.class)
    3333        .in(model)
     
    6161
    6262    @Test
    63     public void test_copyMyNodesToTop_1() throws IllegalAccessException, NoSuchFieldException {
    64         NodeListMergeModel model = new NodeListMergeModel();
    65 
    66         Way myWay = new Way(1);
    67         myWay.setIncomplete(false);
     63    public void test_copyMyNodesToTop_1() {
     64        NodeListMergeModel model = new NodeListMergeModel();
     65
     66        Way myWay = new Way(1, 1);
    6867        myWay.addNode(new Node(2));
    6968        myWay.addNode(new Node(3));
     
    8584
    8685    @Test
    87     public void test_copyMyNodesToTop_2() throws IllegalAccessException, NoSuchFieldException {
    88         NodeListMergeModel model = new NodeListMergeModel();
    89 
    90 
    91         Way myWay = new Way(1);
    92         myWay.setIncomplete(false);
     86    public void test_copyMyNodesToTop_2() {
     87        NodeListMergeModel model = new NodeListMergeModel();
     88
     89
     90        Way myWay = new Way(1, 1);
    9391        myWay.addNode(new Node(2));
    9492        myWay.addNode(new Node(3));
     
    117115
    118116    @Test
    119     public void test_copyMyNodesToTop_3() throws IllegalAccessException, NoSuchFieldException {
    120         NodeListMergeModel model = new NodeListMergeModel();
    121 
    122 
    123         Way myWay = new Way(1);
    124         myWay.setIncomplete(false);
     117    public void test_copyMyNodesToTop_3() {
     118        NodeListMergeModel model = new NodeListMergeModel();
     119
     120
     121        Way myWay = new Way(1, 1);
    125122        myWay.addNode(new Node(2));
    126123        myWay.addNode(new Node(3));
     
    145142
    146143    @Test
    147     public void test_copyMyNodesToTop_4() throws IllegalAccessException, NoSuchFieldException {
    148         NodeListMergeModel model = new NodeListMergeModel();
    149 
    150 
    151         Way myWay = new Way(1);
    152         myWay.setIncomplete(false);
     144    public void test_copyMyNodesToTop_4() {
     145        NodeListMergeModel model = new NodeListMergeModel();
     146
     147
     148        Way myWay = new Way(1, 1);
    153149        myWay.addNode(new Node(2));
    154150        myWay.addNode(new Node(3));
     
    175171
    176172    @Test
    177     public void test_copyMyNodesToEnd_1() throws IllegalAccessException, NoSuchFieldException {
    178         NodeListMergeModel model = new NodeListMergeModel();
    179 
    180         Way myWay = new Way(1);
    181         myWay.setIncomplete(false);
     173    public void test_copyMyNodesToEnd_1() {
     174        NodeListMergeModel model = new NodeListMergeModel();
     175
     176        Way myWay = new Way(1, 1);
    182177        myWay.addNode(new Node(2));
    183178        myWay.addNode(new Node(3));
     
    197192
    198193    @Test
    199     public void test_copyMyNodesToEnd_2() throws IllegalAccessException, NoSuchFieldException {
    200         NodeListMergeModel model = new NodeListMergeModel();
    201 
    202         Way myWay = new Way(1);
    203         myWay.setIncomplete(false);
     194    public void test_copyMyNodesToEnd_2() {
     195        NodeListMergeModel model = new NodeListMergeModel();
     196
     197        Way myWay = new Way(1, 1);
    204198        myWay.addNode(new Node(2));
    205199        myWay.addNode(new Node(3));
     
    223217
    224218    @Test
    225     public void test_copyMyNodesToEnd_3() throws IllegalAccessException, NoSuchFieldException {
    226         NodeListMergeModel model = new NodeListMergeModel();
    227 
    228 
    229         Way myWay = new Way(1);
    230         myWay.setIncomplete(false);
     219    public void test_copyMyNodesToEnd_3() {
     220        NodeListMergeModel model = new NodeListMergeModel();
     221
     222
     223        Way myWay = new Way(1, 1);
    231224        myWay.addNode(new Node(2));
    232225        myWay.addNode(new Node(3));
     
    251244
    252245    @Test
    253     public void test_copyMyNodesToEnd_4() throws IllegalAccessException, NoSuchFieldException {
    254         NodeListMergeModel model = new NodeListMergeModel();
    255 
    256 
    257         Way myWay = new Way(1);
    258         myWay.setIncomplete(false);
     246    public void test_copyMyNodesToEnd_4() {
     247        NodeListMergeModel model = new NodeListMergeModel();
     248
     249
     250        Way myWay = new Way(1, 1);
    259251        myWay.addNode(new Node(2));
    260252        myWay.addNode(new Node(3));
     
    285277
    286278    @Test
    287     public void test_copyMyNodesBeforeCurrent_1() throws IllegalAccessException, NoSuchFieldException {
    288         NodeListMergeModel model = new NodeListMergeModel();
    289 
    290         Way myWay = new Way(1);
    291         myWay.setIncomplete(false);
     279    public void test_copyMyNodesBeforeCurrent_1() {
     280        NodeListMergeModel model = new NodeListMergeModel();
     281
     282        Way myWay = new Way(1, 1);
    292283        myWay.addNode(new Node(1));
    293284        myWay.addNode(new Node(2));
     
    314305
    315306    @Test
    316     public void test_copyMyNodesBeforeCurrent_2() throws IllegalAccessException, NoSuchFieldException {
    317         NodeListMergeModel model = new NodeListMergeModel();
    318 
    319         Way myWay = new Way(1);
    320         myWay.setIncomplete(false);
     307    public void test_copyMyNodesBeforeCurrent_2() {
     308        NodeListMergeModel model = new NodeListMergeModel();
     309
     310        Way myWay = new Way(1, 1);
    321311        myWay.addNode(new Node(1));
    322312        myWay.addNode(new Node(2));
     
    343333
    344334    @Test
    345     public void test_copyMyNodesBeforeCurrent_3() throws IllegalAccessException, NoSuchFieldException {
    346         NodeListMergeModel model = new NodeListMergeModel();
    347 
    348         Way myWay = new Way(1);
    349         myWay.setIncomplete(false);
     335    public void test_copyMyNodesBeforeCurrent_3() {
     336        NodeListMergeModel model = new NodeListMergeModel();
     337
     338        Way myWay = new Way(1, 1);
    350339        myWay.addNode(new Node(1));
    351340        myWay.addNode(new Node(2));
     
    377366    /* ----------------------------------------------------------------------------- */
    378367    @Test
    379     public void test_copyMyNodesAfterCurrent_1() throws IllegalAccessException, NoSuchFieldException {
    380         NodeListMergeModel model = new NodeListMergeModel();
    381 
    382         Way myWay = new Way(1);
    383         myWay.setIncomplete(false);
     368    public void test_copyMyNodesAfterCurrent_1() {
     369        NodeListMergeModel model = new NodeListMergeModel();
     370
     371        Way myWay = new Way(1, 1);
    384372        myWay.addNode(new Node(1));
    385373        myWay.addNode(new Node(2));
     
    406394
    407395    @Test
    408     public void test_copyMyNodesAfterCurrent_2() throws IllegalAccessException, NoSuchFieldException {
    409         NodeListMergeModel model = new NodeListMergeModel();
    410 
    411         Way myWay = new Way(1);
    412         myWay.setIncomplete(false);
     396    public void test_copyMyNodesAfterCurrent_2() {
     397        NodeListMergeModel model = new NodeListMergeModel();
     398
     399        Way myWay = new Way(1, 1);
    413400        myWay.addNode(new Node(1));
    414401        myWay.addNode(new Node(2));
     
    437424
    438425    @Test
    439     public void test_copyMyNodesAfterCurrent_3() throws IllegalAccessException, NoSuchFieldException {
    440         NodeListMergeModel model = new NodeListMergeModel();
    441 
    442         Way myWay = new Way(1);
    443         myWay.setIncomplete(false);
     426    public void test_copyMyNodesAfterCurrent_3() {
     427        NodeListMergeModel model = new NodeListMergeModel();
     428
     429        Way myWay = new Way(1, 1);
    444430        myWay.addNode(new Node(1));
    445431        myWay.addNode(new Node(2));
     
    467453
    468454    @Test
    469     public void test_copyMyNodesAfterCurrent_4() throws IllegalAccessException, NoSuchFieldException {
    470         NodeListMergeModel model = new NodeListMergeModel();
    471 
    472         Way myWay = new Way(1);
    473         myWay.setIncomplete(false);
     455    public void test_copyMyNodesAfterCurrent_4() {
     456        NodeListMergeModel model = new NodeListMergeModel();
     457
     458        Way myWay = new Way(1, 1);
    474459        myWay.addNode(new Node(1));
    475460        myWay.addNode(new Node(2));
     
    501486    /* ----------------------------------------------------------------------------- */
    502487    @Test
    503     public void test_moveUpMergedNodes_1() throws IllegalAccessException, NoSuchFieldException {
    504         NodeListMergeModel model = new NodeListMergeModel();
    505 
    506         Way myWay = new Way(1);
    507         myWay.setIncomplete(false);
     488    public void test_moveUpMergedNodes_1() {
     489        NodeListMergeModel model = new NodeListMergeModel();
     490
     491        Way myWay = new Way(1, 1);
    508492        myWay.addNode(new Node(1));
    509493        myWay.addNode(new Node(2));
     
    528512
    529513    @Test
    530     public void test_moveUpMergedNodes_2() throws IllegalAccessException, NoSuchFieldException {
    531         NodeListMergeModel model = new NodeListMergeModel();
    532 
    533         Way myWay = new Way(1);
    534         myWay.setIncomplete(false);
     514    public void test_moveUpMergedNodes_2() {
     515        NodeListMergeModel model = new NodeListMergeModel();
     516
     517        Way myWay = new Way(1, 1);
    535518        myWay.addNode(new Node(1));
    536519        myWay.addNode(new Node(2));
     
    559542
    560543    @Test
    561     public void test_moveUpMergedNodes_3() throws IllegalAccessException, NoSuchFieldException {
    562         NodeListMergeModel model = new NodeListMergeModel();
    563 
    564         Way myWay = new Way(1);
    565         myWay.setIncomplete(false);
     544    public void test_moveUpMergedNodes_3() {
     545        NodeListMergeModel model = new NodeListMergeModel();
     546
     547        Way myWay = new Way(1, 1);
    566548        myWay.addNode(new Node(1));
    567549        myWay.addNode(new Node(2));
     
    593575    /* ----------------------------------------------------------------------------- */
    594576    @Test
    595     public void test_moveDownMergedNodes_1() throws IllegalAccessException, NoSuchFieldException {
    596         NodeListMergeModel model = new NodeListMergeModel();
    597 
    598         Way myWay = new Way(1);
    599         myWay.setIncomplete(false);
     577    public void test_moveDownMergedNodes_1() {
     578        NodeListMergeModel model = new NodeListMergeModel();
     579
     580        Way myWay = new Way(1, 1);
    600581        myWay.addNode(new Node(1));
    601582        myWay.addNode(new Node(2));
     
    620601
    621602    @Test
    622     public void test_moveDownMergedNodes_2() throws IllegalAccessException, NoSuchFieldException {
    623         NodeListMergeModel model = new NodeListMergeModel();
    624 
    625         Way myWay = new Way(1);
    626         myWay.setIncomplete(false);
     603    public void test_moveDownMergedNodes_2() {
     604        NodeListMergeModel model = new NodeListMergeModel();
     605
     606        Way myWay = new Way(1, 1);
    627607        myWay.addNode(new Node(1));
    628608        myWay.addNode(new Node(2));
     
    651631
    652632    @Test
    653     public void test_moveDownMergedNodes_3() throws IllegalAccessException, NoSuchFieldException {
    654         NodeListMergeModel model = new NodeListMergeModel();
    655 
    656         Way myWay = new Way(1);
    657         myWay.setIncomplete(false);
     633    public void test_moveDownMergedNodes_3() {
     634        NodeListMergeModel model = new NodeListMergeModel();
     635
     636        Way myWay = new Way(1, 1);
    658637        myWay.addNode(new Node(1));
    659638        myWay.addNode(new Node(2));
Note: See TracChangeset for help on using the changeset viewer.