Changeset 4530 in josm


Ignore:
Timestamp:
2011-10-20T04:45:57+02:00 (9 years ago)
Author:
Don-vip
Message:

see #6653 and #6960 - Allow JOSM to download osmChange files again

Location:
trunk/src/org/openstreetmap/josm
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/actions/OpenLocationAction.java

    r4521 r4530  
    2323import org.openstreetmap.josm.Main;
    2424import org.openstreetmap.josm.actions.downloadtasks.DownloadGpsTask;
     25import org.openstreetmap.josm.actions.downloadtasks.DownloadOsmChangeTask;
    2526import org.openstreetmap.josm.actions.downloadtasks.DownloadOsmTask;
    2627import org.openstreetmap.josm.actions.downloadtasks.DownloadTask;
     
    5152        addDownloadTaskClass(DownloadOsmTask.class);
    5253        addDownloadTaskClass(DownloadGpsTask.class);
     54        addDownloadTaskClass(DownloadOsmChangeTask.class);
    5355    }
    5456
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/DownloadOsmTask.java

    r4523 r4530  
    3333    protected DataSet downloadedData;
    3434    protected DownloadTask downloadTask;
     35   
     36    protected OsmDataLayer targetLayer;
    3537
    3638    protected void rememberDownloadedData(DataSet ds) {
     
    7981    }
    8082
    81      protected class DownloadTask extends PleaseWaitRunnable {
     83    protected class DownloadTask extends PleaseWaitRunnable {
    8284        protected OsmServerReader reader;
    8385        protected DataSet dataSet;
     
    8991            this.newLayer = newLayer;
    9092        }
     93       
     94        protected DataSet parseDataSet() throws OsmTransferException {
     95            return reader.parseOsm(progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false));
     96        }
    9197
    9298        @Override public void realRun() throws IOException, SAXException, OsmTransferException {
     
    94100                if (isCanceled())
    95101                    return;
    96                 dataSet = reader.parseOsm(progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false));
     102                dataSet = parseDataSet();
    97103            } catch(Exception e) {
    98104                if (isCanceled()) {
     
    161167                // or it is not clear which layer to merge to
    162168                //
    163                 OsmDataLayer layer = createNewLayer();
     169                targetLayer = createNewLayer();
    164170                final boolean isDisplayingMapView = Main.isDisplayingMapView();
    165171
    166                 Main.main.addLayer(layer);
     172                Main.main.addLayer(targetLayer);
    167173
    168174                // If the mapView is not there yet, we cannot calculate the bounds (see constructor of MapView).
    169175                // Otherwise jump to the current download.
    170176                if (isDisplayingMapView) {
    171                     BoundingXYVisitor v = new BoundingXYVisitor();
    172                     if (currentBounds != null) {
    173                         v.visit(currentBounds);
    174                     } else {
    175                         v.computeBoundingBox(dataSet.getNodes());
    176                     }
    177                     Main.map.mapView.recalculateCenterScale(v);
     177                    computeBboxAndCenterScale();
    178178                }
    179179            } else {
    180                 OsmDataLayer target;
    181                 target = getEditLayer();
    182                 if (target == null) {
    183                     target = getFirstDataLayer();
    184                 }
    185                 target.mergeFrom(dataSet);
    186                 BoundingXYVisitor v = new BoundingXYVisitor();
    187                 if (currentBounds != null) {
    188                     v.visit(currentBounds);
    189                 } else {
    190                     v.computeBoundingBox(dataSet.getNodes());
    191                 }
    192                 Main.map.mapView.recalculateCenterScale(v);
    193                 target.onPostDownloadFromServer();
    194             }
     180                targetLayer = getEditLayer();
     181                if (targetLayer == null) {
     182                    targetLayer = getFirstDataLayer();
     183                }
     184                targetLayer.mergeFrom(dataSet);
     185                computeBboxAndCenterScale();
     186                targetLayer.onPostDownloadFromServer();
     187            }
     188        }
     189       
     190        protected void computeBboxAndCenterScale() {
     191            BoundingXYVisitor v = new BoundingXYVisitor();
     192            if (currentBounds != null) {
     193                v.visit(currentBounds);
     194            } else {
     195                v.computeBoundingBox(dataSet.getNodes());
     196            }
     197            Main.map.mapView.recalculateCenterScale(v);
    195198        }
    196199
  • trunk/src/org/openstreetmap/josm/io/OsmReader.java

    r4490 r4530  
    1212import java.util.regex.Pattern;
    1313
     14import javax.xml.stream.Location;
    1415import javax.xml.stream.XMLInputFactory;
    15 import javax.xml.stream.XMLStreamReader;
    1616import javax.xml.stream.XMLStreamConstants;
    1717import javax.xml.stream.XMLStreamException;
    18 import javax.xml.stream.Location;
     18import javax.xml.stream.XMLStreamReader;
    1919
    2020import org.openstreetmap.josm.data.Bounds;
     
    4848public class OsmReader extends AbstractReader {
    4949
    50     private XMLStreamReader parser;
     50    protected XMLStreamReader parser;
    5151
    5252    /**
    53      * constructor (for private use only)
     53     * constructor (for private and subclasses use only)
    5454     *
    5555     * @see #parseDataSet(InputStream, DataSet, ProgressMonitor)
    5656     */
    57     private OsmReader() {
    58     }
    59 
    60     public void setParser(XMLStreamReader parser) {
     57    protected OsmReader() {
     58    }
     59
     60    protected void setParser(XMLStreamReader parser) {
    6161        this.parser = parser;
    6262    }
     
    6666    }
    6767
    68     public void parse() throws XMLStreamException {
     68    protected void parse() throws XMLStreamException {
    6969        int event = parser.getEventType();
    7070        while (true) {
    7171            if (event == XMLStreamConstants.START_ELEMENT) {
    72                 if (parser.getLocalName().equals("osm") || parser.getLocalName().equals("osmChange")) {
    73                     parseOsm();
    74                 } else {
    75                     parseUnkown();
    76                 }
     72                parseRoot();
    7773            } else if (event == XMLStreamConstants.END_ELEMENT) {
    7874                return;
     
    8581        }
    8682        parser.close();
     83    }
     84   
     85    protected void parseRoot() throws XMLStreamException {
     86        if (parser.getLocalName().equals("osm")) {
     87            parseOsm();
     88        } else {
     89            parseUnknown();
     90        }
    8791    }
    8892
     
    115119                    parseChangeset(uploadChangesetId);
    116120                } else {
    117                     parseUnkown();
     121                    parseUnknown();
    118122                }
    119123            } else if (event == XMLStreamConstants.END_ELEMENT) {
     
    152156    }
    153157
    154     private void parseNode() throws XMLStreamException {
     158    protected void parseNode() throws XMLStreamException {
    155159        NodeData nd = new NodeData();
    156160        nd.setCoor(new LatLon(Double.parseDouble(parser.getAttributeValue(null, "lat")), Double.parseDouble(parser.getAttributeValue(null, "lon"))));
     
    166170                    parseTag(n);
    167171                } else {
    168                     parseUnkown();
     172                    parseUnknown();
    169173                }
    170174            } else if (event == XMLStreamConstants.END_ELEMENT) {
     
    174178    }
    175179
    176     private void parseWay() throws XMLStreamException {
     180    protected void parseWay() throws XMLStreamException {
    177181        WayData wd = new WayData();
    178182        readCommon(wd);
     
    191195                    parseTag(w);
    192196                } else {
    193                     parseUnkown();
     197                    parseUnknown();
    194198                }
    195199            } else if (event == XMLStreamConstants.END_ELEMENT) {
     
    220224    }
    221225
    222     private void parseRelation() throws XMLStreamException {
     226    protected void parseRelation() throws XMLStreamException {
    223227        RelationData rd = new RelationData();
    224228        readCommon(rd);
     
    237241                    parseTag(r);
    238242                } else {
    239                     parseUnkown();
     243                    parseUnknown();
    240244                }
    241245            } else if (event == XMLStreamConstants.END_ELEMENT) {
     
    293297                        parseTag(uploadChangeset);
    294298                    } else {
    295                         parseUnkown();
     299                        parseUnknown();
    296300                    }
    297301                } else if (event == XMLStreamConstants.END_ELEMENT) {
     
    314318    }
    315319
    316     private void parseUnkown(boolean printWarning) throws XMLStreamException {
     320    protected void parseUnknown(boolean printWarning) throws XMLStreamException {
    317321        if (printWarning) {
    318322            System.out.println(tr("Undefined element ''{0}'' found in input stream. Skipping.", parser.getLocalName()));
     
    321325            int event = parser.next();
    322326            if (event == XMLStreamConstants.START_ELEMENT) {
    323                 parseUnkown(false); /* no more warning for inner elements */
     327                parseUnknown(false); /* no more warning for inner elements */
    324328            } else if (event == XMLStreamConstants.END_ELEMENT) {
    325329                return;
     
    328332    }
    329333
    330     private void parseUnkown() throws XMLStreamException {
    331         parseUnkown(true);
     334    protected void parseUnknown() throws XMLStreamException {
     335        parseUnknown(true);
    332336    }
    333337
     
    343347            int event = parser.next();
    344348            if (event == XMLStreamConstants.START_ELEMENT) {
    345                 parseUnkown(printWarning);
     349                parseUnknown(printWarning);
    346350            } else if (event == XMLStreamConstants.END_ELEMENT) {
    347351                return;
     
    531535    }
    532536
     537    protected DataSet doParseDataSet(InputStream source, ProgressMonitor progressMonitor) throws IllegalDataException {
     538        if (progressMonitor == null) {
     539            progressMonitor = NullProgressMonitor.INSTANCE;
     540        }
     541        CheckParameterUtil.ensureParameterNotNull(source, "source");
     542        try {
     543            progressMonitor.beginTask(tr("Prepare OSM data...", 2));
     544            progressMonitor.indeterminateSubTask(tr("Parsing OSM data..."));
     545
     546            InputStreamReader ir = UTFInputStreamReader.create(source, "UTF-8");
     547            XMLStreamReader parser = XMLInputFactory.newInstance().createXMLStreamReader(ir);
     548            setParser(parser);
     549            parse();
     550            progressMonitor.worked(1);
     551
     552            progressMonitor.indeterminateSubTask(tr("Preparing data set..."));
     553            prepareDataSet();
     554            progressMonitor.worked(1);
     555            return getDataSet();
     556        } catch(IllegalDataException e) {
     557            throw e;
     558        } catch(OsmParsingException e) {
     559            throw new IllegalDataException(e.getMessage(), e);
     560        } catch(XMLStreamException e) {
     561            String msg = e.getMessage();
     562            Pattern p = Pattern.compile("Message: (.+)");
     563            Matcher m = p.matcher(msg);
     564            if (m.find()) {
     565                msg = m.group(1);
     566            }
     567            if (e.getLocation() != null) {
     568                throw new IllegalDataException(tr("Line {0} column {1}: ", e.getLocation().getLineNumber(), e.getLocation().getColumnNumber()) + msg, e);
     569            } else {
     570                throw new IllegalDataException(msg, e);
     571            }
     572        } catch(Exception e) {
     573            throw new IllegalDataException(e);
     574        } finally {
     575            progressMonitor.finishTask();
     576        }
     577    }
     578   
    533579    /**
    534580     * Parse the given input source and return the dataset.
     
    542588     */
    543589    public static DataSet parseDataSet(InputStream source, ProgressMonitor progressMonitor) throws IllegalDataException {
    544         if (progressMonitor == null) {
    545             progressMonitor = NullProgressMonitor.INSTANCE;
    546         }
    547         CheckParameterUtil.ensureParameterNotNull(source, "source");
    548         OsmReader reader = new OsmReader();
    549         try {
    550             progressMonitor.beginTask(tr("Prepare OSM data...", 2));
    551             progressMonitor.indeterminateSubTask(tr("Parsing OSM data..."));
    552 
    553             InputStreamReader ir = UTFInputStreamReader.create(source, "UTF-8");
    554             XMLStreamReader parser = XMLInputFactory.newInstance().createXMLStreamReader(ir);
    555             reader.setParser(parser);
    556             reader.parse();
    557             progressMonitor.worked(1);
    558 
    559             progressMonitor.indeterminateSubTask(tr("Preparing data set..."));
    560             reader.prepareDataSet();
    561             progressMonitor.worked(1);
    562             return reader.getDataSet();
    563         } catch(IllegalDataException e) {
    564             throw e;
    565         } catch(OsmParsingException e) {
    566             throw new IllegalDataException(e.getMessage(), e);
    567         } catch(XMLStreamException e) {
    568             String msg = e.getMessage();
    569             Pattern p = Pattern.compile("Message: (.+)");
    570             Matcher m = p.matcher(msg);
    571             if (m.find()) {
    572                 msg = m.group(1);
    573             }
    574             if (e.getLocation() != null) {
    575                 throw new IllegalDataException(tr("Line {0} column {1}: ", e.getLocation().getLineNumber(), e.getLocation().getColumnNumber()) + msg, e);
    576             } else {
    577                 throw new IllegalDataException(msg, e);
    578             }
    579         } catch(Exception e) {
    580             throw new IllegalDataException(e);
    581         } finally {
    582             progressMonitor.finishTask();
    583         }
     590        return new OsmReader().doParseDataSet(source, progressMonitor);
    584591    }
    585592}
  • trunk/src/org/openstreetmap/josm/io/OsmServerLocationReader.java

    r4521 r4530  
    4848    }
    4949
     50    /* (non-Javadoc)
     51     * @see org.openstreetmap.josm.io.OsmServerReader#parseOsmChange(org.openstreetmap.josm.gui.progress.ProgressMonitor)
     52     */
     53    @Override
     54    public DataSet parseOsmChange(ProgressMonitor progressMonitor)
     55            throws OsmTransferException {
     56        InputStream in = null;
     57        progressMonitor.beginTask(tr("Contacting Server...", 10));
     58        try {
     59            in = getInputStreamRaw(url, progressMonitor.createSubTaskMonitor(9, false));
     60            if (in == null)
     61                return null;
     62            progressMonitor.subTask(tr("Downloading OSM data..."));
     63            return OsmChangeReader.parseDataSet(in, progressMonitor.createSubTaskMonitor(1, false));
     64        } catch(OsmTransferException e) {
     65            throw e;
     66        } catch (Exception e) {
     67            if (cancel)
     68                return null;
     69            throw new OsmTransferException(e);
     70        } finally {
     71            progressMonitor.finishTask();
     72            try {
     73                activeConnection = null;
     74                if (in != null) {
     75                    in.close();
     76                }
     77            } catch(Exception e) {/* ignore it */}
     78        }
     79    }
     80
    5081    @Override
    5182    public GpxData parseRawGps(ProgressMonitor progressMonitor) throws OsmTransferException {
  • trunk/src/org/openstreetmap/josm/io/OsmServerReader.java

    r4521 r4530  
    142142    public abstract DataSet parseOsm(ProgressMonitor progressMonitor) throws OsmTransferException;
    143143
     144    public DataSet parseOsmChange(ProgressMonitor progressMonitor) throws OsmTransferException {
     145        return null;
     146    }
     147   
    144148    public GpxData parseRawGps(ProgressMonitor progressMonitor) throws OsmTransferException {
    145149        return null;
Note: See TracChangeset for help on using the changeset viewer.