Changeset 103 in josm


Ignore:
Timestamp:
2006-07-01T00:56:23+02:00 (14 years ago)
Author:
imi
Message:
  • fixed unicode compatibility
  • added Layer menu which mirrors the layer list context menu
  • added "convert to data layer" for all gps layers
  • removed raw gpx import and 0.2 osm-file import
  • removed dependency to JDOM
Files:
1 added
5 deleted
32 edited

Legend:

Unmodified
Added
Removed
  • .classpath

    r101 r103  
    44        <classpathentry including="images/" kind="src" path=""/>
    55        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
    6         <classpathentry kind="lib" path="lib/jdom.jar"/>
    76        <classpathentry sourcepath="JUNIT_SRC_HOME/junitsrc.zip" kind="var" path="JUNIT_HOME/junit.jar"/>
    87        <classpathentry kind="lib" path="lib/MinML2.jar"/>
  • CONTRIBUTION

    r101 r103  
    1 One XML Parser is JDOM 1.0 which comes from www.jdom.org and
    2 is licensed under "JDOM license", a modified Apache License
    3 with Aknowledgement removed. The other XML Parser is MinML2
    4 from http://www.wilson.co.uk/xml/minml2.htm. The license is
     1The XML Parser is MinML2 from
     2http://www.wilson.co.uk/xml/minml2.htm. The license is
    53attached below.
    64
  • src/org/openstreetmap/josm/Main.java

    r101 r103  
    9494                        panel.setVisible(true);
    9595                        map.mapView.addLayerChangeListener(new LayerChangeListener(){
    96                                 public void activeLayerChange(final Layer oldLayer, final Layer newLayer) {}
     96                                public void activeLayerChange(final Layer oldLayer, final Layer newLayer) {
     97                                        setLayerMenu(newLayer.getMenuEntries());
     98                                }
    9799                                public void layerAdded(final Layer newLayer) {
    98100                                        if (newLayer instanceof OsmDataLayer)
     
    102104                                        if (oldLayer instanceof OsmDataLayer)
    103105                                                Main.main.editLayer().listenerCommands.add(redoUndoListener);
     106                                        if (map.mapView.getAllLayers().isEmpty())
     107                                                setLayerMenu(null);
    104108                                }
    105109                        });
     
    110114        }
    111115
     116        /**
     117         * Set the layer menu (changed when active layer changes).
     118         */
     119        public final void setLayerMenu(Component[] entries) {
     120                if (entries == null || entries.length == 0)
     121                        layerMenu.setVisible(false);
     122                else {
     123                        layerMenu.removeAll();
     124                        for (Component c : entries)
     125                                layerMenu.add(c);
     126                        layerMenu.setVisible(true);
     127                }
     128        }
     129       
    112130        /**
    113131         * Remove the specified layer from the map. If it is the last layer, remove the map as well.
     
    141159
    142160
    143                 final JMenu layerMenu = new JMenu("Layer");
     161                final JMenu connectionMenu = new JMenu("Connection");
     162                connectionMenu.setMnemonic('C');
     163                connectionMenu.add(downloadAction);
     164                connectionMenu.add(uploadAction);
     165                mainMenu.add(connectionMenu);
     166
     167                layerMenu = new JMenu("Layer");
    144168                layerMenu.setMnemonic('L');
    145                 layerMenu.add(downloadAction);
    146                 layerMenu.add(uploadAction);
    147                 layerMenu.addSeparator();
    148169                mainMenu.add(layerMenu);
    149 
     170                layerMenu.setVisible(false);
     171               
    150172                final JMenu editMenu = new JMenu("Edit");
    151173                editMenu.setMnemonic('E');
     
    185207        public final void addLayer(final Layer layer) {
    186208                if (map == null) {
    187                         final MapFrame mapFrame = new MapFrame(layer);
     209                        final MapFrame mapFrame = new MapFrame();
    188210                        setMapFrame(mapFrame);
    189211                        mapFrame.selectMapMode((MapMode)mapFrame.getDefaultButtonAction());
    190212                        mapFrame.setVisible(true);
    191213                        mapFrame.setVisibleDialogs();
    192                 } else
    193                         map.mapView.addLayer(layer);
     214                }
     215                map.mapView.addLayer(layer);
    194216        }
    195217        /**
     
    232254                }
    233255        };
     256        private JMenu layerMenu;
    234257
    235258        /**
  • src/org/openstreetmap/josm/actions/DownloadAction.java

    r101 r103  
    3030import javax.swing.event.ListSelectionListener;
    3131
    32 import org.jdom.JDOMException;
    3332import org.openstreetmap.josm.Main;
    3433import org.openstreetmap.josm.data.Bounds;
     
    9998                }
    10099
    101                 @Override public void realRun() throws IOException, JDOMException {
     100                @Override public void realRun() throws IOException, SAXException {
    102101                        rawData = reader.parseRawGps();
    103102                }
  • src/org/openstreetmap/josm/actions/GpxExportAction.java

    r99 r103  
    88import java.awt.event.KeyEvent;
    99import java.io.File;
    10 import java.io.FileWriter;
     10import java.io.FileOutputStream;
    1111import java.io.IOException;
    1212import java.util.Calendar;
     
    5858                        return;
    5959
     60                exportGpx(file, this.layer == null ? Main.main.editLayer() : this.layer);
     61        }
     62
     63        public static void exportGpx(File file, Layer layer) {
    6064                String fn = file.getPath();
    6165                if (fn.indexOf('.') == -1) {
     
    113117               
    114118                try {
    115                         Layer layer = this.layer == null ? Main.main.editLayer() : this.layer;
    116                         FileWriter out = new FileWriter(file);
    117                         GpxWriter w = new GpxWriter(out, layer.name, desc.getText(),
     119                        GpxWriter w = new GpxWriter(new FileOutputStream(file), layer.name, desc.getText(),
    118120                                        authorName.getText(), email.getText(), copyright.getText(),
    119121                                        copyrightYear.getText(), keywords.getText());
     
    122124                        else
    123125                                w.output(Main.ds);
    124                         out.close();
     126                        w.close();
    125127                } catch (IOException x) {
    126128                        x.printStackTrace();
     
    128130                }               
    129131        }
    130 
     132       
    131133        /**
    132134         * Add all those listeners to handle the enable state of the fields.
     
    137139         * @param warning
    138140         */
    139         private void addDependencies(
     141        private static void addDependencies(
    140142                        final JCheckBox author,
    141143                        final JTextField authorName,
     
    204206        }
    205207
    206         private void enableCopyright(final JTextField copyright, final JButton predefined, final JTextField copyrightYear, final JLabel copyrightLabel, final JLabel copyrightYearLabel, final JLabel warning, boolean enable) {
     208        private static void enableCopyright(final JTextField copyright, final JButton predefined, final JTextField copyrightYear, final JLabel copyrightLabel, final JLabel copyrightYearLabel, final JLabel warning, boolean enable) {
    207209                copyright.setEnabled(enable);
    208210                predefined.setEnabled(enable);
  • src/org/openstreetmap/josm/actions/OpenAction.java

    r101 r103  
    55import java.awt.event.KeyEvent;
    66import java.io.File;
     7import java.io.FileInputStream;
    78import java.io.FileReader;
    89import java.io.IOException;
     
    1415import javax.swing.KeyStroke;
    1516
    16 import org.jdom.JDOMException;
    1717import org.openstreetmap.josm.Main;
    1818import org.openstreetmap.josm.data.osm.DataSet;
     
    2020import org.openstreetmap.josm.gui.layer.RawGpsLayer;
    2121import org.openstreetmap.josm.gui.layer.RawGpsLayer.GpsPoint;
    22 import org.openstreetmap.josm.io.GpxReader;
    2322import org.openstreetmap.josm.io.OsmReader;
    24 import org.openstreetmap.josm.io.OsmReaderOld;
    2523import org.openstreetmap.josm.io.RawCsvReader;
    2624import org.openstreetmap.josm.io.RawGpsReader;
     
    6058                                Collection<Collection<GpsPoint>> data;
    6159                                if (ExtensionFileFilter.filters[ExtensionFileFilter.GPX].acceptName(fn)) {
    62                                         data = new RawGpsReader(new FileReader(filename)).parse();
     60                                        data = RawGpsReader.parse(new FileInputStream(filename));
    6361                                } else if (ExtensionFileFilter.filters[ExtensionFileFilter.CSV].acceptName(fn)) {
    6462                                        data = new LinkedList<Collection<GpsPoint>>();
     
    6967                        } else {
    7068                                DataSet dataSet;
    71                                 if (ExtensionFileFilter.filters[ExtensionFileFilter.GPX].acceptName(fn)) {
    72                                         JOptionPane.showMessageDialog(Main.parent, "Warning: Soon, it will be no longer possible to open GPX files as osm data. Please convert your files to .osm format.");
    73                                         dataSet = new GpxReader(new FileReader(filename)).parse();
    74                                 } else if (ExtensionFileFilter.filters[ExtensionFileFilter.OSM].acceptName(fn)) {
    75                                         try {
    76                                                 // temporary allow loading of old xml format.
    77                                                 dataSet = OsmReader.parseDataSet(new FileReader(filename), null, null);
    78                                         } catch (SAXException x) {
    79                                                 if (x.getMessage().equals("Unknown version null")) {
    80                                                         int answer = JOptionPane.showConfirmDialog(Main.parent,
    81                                                                         fn+" seems to be an old 0.2 API XML file.\n" +
    82                                                                         "JOSM can try to open it with the old parser. This option\n" +
    83                                                                         "will not be available in future JOSM version. You should\n" +
    84                                                                         "immediatly save the file, if successfull imported.",
    85                                                                         "Load as 0.2 API file?",
    86                                                                         JOptionPane.YES_NO_OPTION);
    87                                                         if (answer != JOptionPane.YES_OPTION)
    88                                                                 return;
    89                                                         dataSet = new OsmReaderOld(new FileReader(filename)).parse();
    90                                                 } else
    91                                                         throw x;
    92                                         }                                       
     69                                if (ExtensionFileFilter.filters[ExtensionFileFilter.OSM].acceptName(fn)) {
     70                                        dataSet = OsmReader.parseDataSet(new FileInputStream(filename), null, null);
    9371                                } else if (ExtensionFileFilter.filters[ExtensionFileFilter.CSV].acceptName(fn)) {
    9472                                        JOptionPane.showMessageDialog(Main.parent, fn+": CSV Data import for non-GPS data is not implemented yet.");
     
    10179                        }
    10280                } catch (SAXException x) {
    103                         x.printStackTrace();
    104                         JOptionPane.showMessageDialog(Main.parent, "Error while parsing "+fn+": "+x.getMessage());
    105                 } catch (JDOMException x) {
    10681                        x.printStackTrace();
    10782                        JOptionPane.showMessageDialog(Main.parent, "Error while parsing "+fn+": "+x.getMessage());
     
    12196                if (!ExtensionFileFilter.filters[ExtensionFileFilter.GPX].acceptName(fn))
    12297                        return false;
    123                 return JOptionPane.YES_OPTION == JOptionPane.showConfirmDialog(
    124                                 Main.parent, "Do you want to open "+fn+" as raw gps data?",
    125                                 "Open as raw data?", JOptionPane.YES_NO_OPTION);
     98                return true;
    12699        }
    127100}
  • src/org/openstreetmap/josm/actions/SaveAction.java

    r98 r103  
    55import java.awt.event.KeyEvent;
    66import java.io.File;
    7 import java.io.FileWriter;
     7import java.io.FileOutputStream;
    88import java.io.IOException;
    99
     
    1414
    1515import org.openstreetmap.josm.Main;
    16 import org.openstreetmap.josm.data.osm.Segment;
    17 import org.openstreetmap.josm.io.GpxWriter;
    1816import org.openstreetmap.josm.io.OsmWriter;
    1917
     
    6462                                file = new File(fn);
    6563                        }
    66                         FileWriter fileWriter;
    6764                        if (ExtensionFileFilter.filters[ExtensionFileFilter.GPX].acceptName(fn)) {
    68                                 for (Segment ls : Main.ds.segments) {
    69                                         if (ls.incomplete) {
    70                                                 JOptionPane.showMessageDialog(Main.parent, "Export of data containing incomplete ways to GPX is not implemented.\nBe aware, that in future versions of JOSM, GPX support will be kept at a minimum.\nPlease use .osm or .xml as extension for the better OSM support.");
    71                                                 return;
    72                                         }
    73                                 }
    74                                 new GpxWriter(fileWriter = new FileWriter(file), Main.ds).output();
    75                         } else if (ExtensionFileFilter.filters[ExtensionFileFilter.OSM].acceptName(fn))
    76                                 OsmWriter.output(fileWriter = new FileWriter(file), Main.ds, false);
    77                         else if (ExtensionFileFilter.filters[ExtensionFileFilter.CSV].acceptName(fn)) {
     65                                GpxExportAction.exportGpx(file, Main.main.editLayer());
     66                                Main.main.editLayer().cleanData(null, false);
     67                                return;
     68                        } else if (ExtensionFileFilter.filters[ExtensionFileFilter.OSM].acceptName(fn)) {
     69                                OsmWriter.output(new FileOutputStream(file), Main.ds, false);
     70                                Main.main.editLayer().cleanData(null, false);
     71                        } else if (ExtensionFileFilter.filters[ExtensionFileFilter.CSV].acceptName(fn)) {
    7872                                JOptionPane.showMessageDialog(Main.parent, "CSV output not supported yet.");
    7973                                return;
     
    8276                                return;
    8377                        }
    84                         fileWriter.close();
    85                         Main.main.editLayer().cleanData(null, false);
    8678                } catch (IOException e) {
    8779                        e.printStackTrace();
  • src/org/openstreetmap/josm/actions/UploadAction.java

    r101 r103  
    1515import javax.swing.KeyStroke;
    1616
    17 import org.jdom.JDOMException;
    1817import org.openstreetmap.josm.Main;
    1918import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    2221import org.openstreetmap.josm.io.OsmServerWriter;
    2322import org.openstreetmap.josm.tools.GBC;
     23import org.xml.sax.SAXException;
    2424
    2525/**
     
    7373
    7474                PleaseWaitRunnable uploadTask = new PleaseWaitRunnable("Uploading data"){
    75                         @Override protected void realRun() throws JDOMException {
     75                        @Override protected void realRun() throws SAXException {
    7676                                server.setProgressInformation(currentAction, progress);
    7777                                server.uploadOsm(all);
  • src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

    r94 r103  
    164164       
    165165        public String getTimeStr() {
    166                 return timestamp == null ? null : new SimpleDateFormat("y-M-d H:m:s").format(timestamp);
     166                return timestamp == null ? null : new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(timestamp);
    167167        }
    168168}
  • src/org/openstreetmap/josm/gui/MapFrame.java

    r101 r103  
    3232import org.openstreetmap.josm.gui.dialogs.SelectionListDialog;
    3333import org.openstreetmap.josm.gui.dialogs.ToggleDialog;
    34 import org.openstreetmap.josm.gui.layer.Layer;
    3534
    3635/**
     
    6968         * @param layer The first layer in the mapView.
    7069         */
    71         public MapFrame(Layer layer) {
     70        public MapFrame() {
    7271                setSize(400,400);
    7372                setLayout(new BorderLayout());
     
    7574                final AutoScaleAction autoScaleAction = new AutoScaleAction(this);
    7675                add(mapView = new MapView(autoScaleAction), BorderLayout.CENTER);
    77                 mapView.addLayer(layer);
    7876
    7977                // toolbar
  • src/org/openstreetmap/josm/gui/MapStatus.java

    r100 r103  
    4444 */
    4545public class MapStatus extends JPanel {
    46        
     46
    4747        /**
    4848         * The MapView this status belongs.
     
    5757         */
    5858        JTextField nameText = new JTextField(30);
    59        
     59
    6060        /**
    6161         * The collector class that waits for notification and then update
     
    7777                 */
    7878                private Popup popup;
    79                
     79
    8080                private MapFrame parent;
    81                
     81
    8282                public Collector(MapFrame parent) {
    8383                        this.parent = parent;
    8484                }
    85                
     85
    8686                /**
    8787                 * Execution function for the Collector.
     
    100100                                        continue; // freeze display when holding down ctrl
    101101
     102                                if (mv.center == null)
     103                                        continue;
     104
    102105                                // This try/catch is a hack to stop the flooding bug reports about this.
    103106                                // The exception needed to handle with in the first place, means that this
     
    106109                                try {
    107110                                        Collection<OsmPrimitive> osms = mv.getAllNearest(ms.mousePos);
    108                                        
     111
    109112                                        if (osms == null && osmStatus == null && ms.modifiers == oldModifiers)
    110113                                                continue;
    111114                                        if (osms != null && osms.equals(osmStatus) && ms.modifiers == oldModifiers)
    112115                                                continue;
    113                                        
     116
    114117                                        osmStatus = osms;
    115118                                        oldModifiers = ms.modifiers;
    116                                        
     119
    117120                                        OsmPrimitive osmNearest = null;
    118121                                        // Set the text label in the bottom status bar
     
    124127                                        } else
    125128                                                nameText.setText("");
    126                                        
     129
    127130                                        // Popup Information
    128131                                        if ((ms.modifiers & MouseEvent.BUTTON2_DOWN_MASK) != 0 && osms != null) {
    129132                                                if (popup != null)
    130133                                                        popup.hide();
    131                                                
     134
    132135                                                JPanel c = new JPanel(new GridBagLayout());
    133136                                                for (final OsmPrimitive osm : osms) {
     
    160163                                                        c.add(l, GBC.eol());
    161164                                                }
    162                                                
     165
    163166                                                Point p = mv.getLocationOnScreen();
    164167                                                popup = PopupFactory.getSharedInstance().getPopup(mv, c, p.x+ms.mousePos.x+16, p.y+ms.mousePos.y+16);
     
    173176                }
    174177        }
    175        
     178
    176179        /**
    177180         * Everything, the collector is interested of. Access must be synchronized.
     
    186189         */
    187190        MouseState mouseState = new MouseState();
    188        
     191
    189192        /**
    190193         * Construct a new MapStatus and attach it to the map view.
     
    193196        public MapStatus(final MapFrame mapFrame) {
    194197                this.mv = mapFrame.mapView;
    195                
     198
    196199                // Listen for mouse movements and set the position text field
    197200                mv.addMouseMotionListener(new MouseMotionListener(){
     
    207210                        }
    208211                });
    209                
     212
    210213                positionText.setEditable(false);
    211214                nameText.setEditable(false);
     
    216219                add(new JLabel(" Object "));
    217220                add(nameText);
    218                
     221
    219222                // The background thread
    220223                final Collector collector = new Collector(mapFrame);
    221224                new Thread(collector).start();
    222                
     225
    223226                // Listen to keyboard/mouse events for pressing/releasing alt key and
    224227                // inform the collector.
  • src/org/openstreetmap/josm/gui/MapView.java

    r101 r103  
    207207         */
    208208        @Override public void paint(Graphics g) {
     209                if (center == null)
     210                        return; // no data loaded yet.
    209211                g.setColor(SimplePaintVisitor.getPreferencesColor("background", Color.BLACK));
    210212                g.fillRect(0, 0, getWidth(), getHeight());
  • src/org/openstreetmap/josm/gui/PleaseWaitRunnable.java

    r99 r103  
    1919import javax.swing.JProgressBar;
    2020
    21 import org.jdom.JDOMException;
    2221import org.openstreetmap.josm.Main;
    2322import org.openstreetmap.josm.tools.GBC;
     
    7776                        x.printStackTrace();
    7877                        errorMessage = "Error while parsing: "+x.getMessage();
    79                 } catch (JDOMException x) {
    80                         x.printStackTrace();
    81                         errorMessage = "Error while parsing: "+x.getMessage();
    8278                } catch (FileNotFoundException x) {
    8379                        x.printStackTrace();
     
    10197         * is called. finish() is called in any case.
    10298         */
    103         protected abstract void realRun() throws SAXException, JDOMException, IOException;
     99        protected abstract void realRun() throws SAXException, IOException;
    104100
    105101        /**
  • src/org/openstreetmap/josm/gui/dialogs/LayerList.java

    r101 r103  
    4343public class LayerList extends ToggleDialog implements LayerChangeListener {
    4444
     45        /**
     46         * The last layerlist created. Used to update the list in the Show/Hide and Delete actions.
     47         * TODO: Replace with Listener-Pattern.
     48         */
     49        static JList instance;
     50
    4551        public final static class DeleteLayerAction extends AbstractAction {
    4652
    47         private final JList layers;
    48         private final Layer layer;
    49 
    50         public DeleteLayerAction(JList layers, Layer layer) {
    51             super("Delete", ImageProvider.get("dialogs", "delete"));
    52             putValue(SHORT_DESCRIPTION, "Delete the selected layer.");
    53             this.layers = layers;
    54             this.layer = layer;
    55         }
    56 
    57         public void actionPerformed(ActionEvent e) {
    58             int sel = layers.getSelectedIndex();
    59             if (layer != null)
    60                 Main.main.removeLayer(layer);
    61             else
    62                 Main.main.removeLayer((Layer)layers.getSelectedValue());
    63             if (sel >= layers.getModel().getSize())
    64                 sel = layers.getModel().getSize()-1;
    65             if (layers.getSelectedValue() == null)
    66                 layers.setSelectedIndex(sel);
    67         }
    68     }
    69 
    70     public final static class ShowHideLayerAction extends AbstractAction {
    71         private final Layer layer;
    72         private final JList layers;
    73 
    74         public ShowHideLayerAction(JList layers, Layer layer) {
    75             super("Show/Hide", ImageProvider.get("dialogs", "showhide"));
    76             putValue(SHORT_DESCRIPTION, "Toggle visible state of the selected layer.");
    77             this.layer = layer;
    78             this.layers = layers;
    79         }
    80 
    81         public void actionPerformed(ActionEvent e) {
    82             Layer l = layer == null ? (Layer)layers.getSelectedValue() : layer;
    83             l.visible = !l.visible;
    84                 Main.map.mapView.repaint();
    85                 layers.repaint();
    86         }
    87     }
    88 
    89     /**
     53                private final Layer layer;
     54
     55                public DeleteLayerAction(Layer layer) {
     56                        super("Delete", ImageProvider.get("dialogs", "delete"));
     57                        putValue(SHORT_DESCRIPTION, "Delete the selected layer.");
     58                        this.layer = layer;
     59                }
     60
     61                public void actionPerformed(ActionEvent e) {
     62                        int sel = instance.getSelectedIndex();
     63                        if (layer != null)
     64                                Main.main.removeLayer(layer);
     65                        else
     66                                Main.main.removeLayer((Layer)instance.getSelectedValue());
     67                        if (sel >= instance.getModel().getSize())
     68                                sel = instance.getModel().getSize()-1;
     69                        if (instance.getSelectedValue() == null)
     70                                instance.setSelectedIndex(sel);
     71                }
     72        }
     73
     74        public final static class ShowHideLayerAction extends AbstractAction {
     75                private final Layer layer;
     76
     77                public ShowHideLayerAction(Layer layer) {
     78                        super("Show/Hide", ImageProvider.get("dialogs", "showhide"));
     79                        putValue(SHORT_DESCRIPTION, "Toggle visible state of the selected layer.");
     80                        this.layer = layer;
     81                }
     82
     83                public void actionPerformed(ActionEvent e) {
     84                        Layer l = layer == null ? (Layer)instance.getSelectedValue() : layer;
     85                        l.visible = !l.visible;
     86                        Main.map.mapView.repaint();
     87                        instance.repaint();
     88                }
     89        }
     90
     91        /**
    9092         * The data model for the list component.
    9193         */
    9294        DefaultListModel model = new DefaultListModel();
    93         /**
    94          * The list component holding all layers.
    95          */
    96         JList layers = new JList(model);
    9795        /**
    9896         * The merge action. This is only called, if the current selection and its
     
    111109         * Button for delete layer.
    112110         */
    113         private Action deleteAction = new DeleteLayerAction(layers, null);
     111        private Action deleteAction = new DeleteLayerAction(null);
    114112
    115113        /**
     
    118116        public LayerList(MapFrame mapFrame) {
    119117                super("Layers", "layerlist", "Open a list of all loaded layers.", KeyEvent.VK_L);
     118                instance = new JList(model);
    120119                setPreferredSize(new Dimension(320,100));
    121                 add(new JScrollPane(layers), BorderLayout.CENTER);
    122                 layers.setBackground(UIManager.getColor("Button.background"));
    123                 layers.setCellRenderer(new DefaultListCellRenderer(){
     120                add(new JScrollPane(instance), BorderLayout.CENTER);
     121                instance.setBackground(UIManager.getColor("Button.background"));
     122                instance.setCellRenderer(new DefaultListCellRenderer(){
    124123                        @Override public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
    125124                                Layer layer = (Layer)value;
     
    141140                        model.addElement(l);
    142141
    143                 layers.setSelectedValue(mapView.getActiveLayer(), true);
    144                 layers.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    145                 layers.addListSelectionListener(new ListSelectionListener(){
     142                instance.setSelectedValue(mapView.getActiveLayer(), true);
     143                instance.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
     144                instance.addListSelectionListener(new ListSelectionListener(){
    146145                        public void valueChanged(ListSelectionEvent e) {
    147                                 if (layers.getModel().getSize() == 0)
     146                                if (instance.getModel().getSize() == 0)
    148147                                        return;
    149                                 if (layers.getSelectedIndex() == -1)
    150                                         layers.setSelectedIndex(e.getFirstIndex());
    151                                 mapView.setActiveLayer((Layer)layers.getSelectedValue());
     148                                if (instance.getSelectedIndex() == -1)
     149                                        instance.setSelectedIndex(e.getFirstIndex());
     150                                mapView.setActiveLayer((Layer)instance.getSelectedValue());
    152151                        }
    153152                });
    154153                mapView.addLayerChangeListener(this);
    155154
    156                 layers.addMouseListener(new MouseAdapter(){
     155                instance.addMouseListener(new MouseAdapter(){
    157156                        private void openPopup(MouseEvent e) {
    158                                 int index = layers.locationToIndex(e.getPoint());
    159                                 Layer layer = (Layer)layers.getModel().getElementAt(index);
    160                                 LayerListPopup menu = new LayerListPopup(layers, layer);
     157                                int index = instance.locationToIndex(e.getPoint());
     158                                Layer layer = (Layer)instance.getModel().getElementAt(index);
     159                                LayerListPopup menu = new LayerListPopup(instance, layer);
    161160                                menu.show(LayerList.this, e.getX(), e.getY());
    162161                        }
     
    170169                        }
    171170                });
    172                
    173                
     171
     172
    174173                // Buttons
    175174                JPanel buttonPanel = new JPanel(new GridLayout(1, 5));
     
    177176                ActionListener upDown = new ActionListener(){
    178177                        public void actionPerformed(ActionEvent e) {
    179                                 Layer l = (Layer)layers.getSelectedValue();
    180                                 int sel = layers.getSelectedIndex();
     178                                Layer l = (Layer)instance.getSelectedValue();
     179                                int sel = instance.getSelectedIndex();
    181180                                int selDest = e.getActionCommand().equals("up") ? sel-1 : sel+1;
    182181                                mapView.moveLayer(l, selDest);
    183182                                model.set(sel, model.get(selDest));
    184183                                model.set(selDest, l);
    185                                 layers.setSelectedIndex(selDest);
     184                                instance.setSelectedIndex(selDest);
    186185                                updateButtonEnabled();
    187186                                mapView.repaint();
     
    193192                upButton.setActionCommand("up");
    194193                buttonPanel.add(upButton);
    195                
     194
    196195                downButton.setToolTipText("Move the selected layer one row down.");
    197196                downButton.addActionListener(upDown);
    198197                downButton.setActionCommand("down");
    199198                buttonPanel.add(downButton);
    200                
    201                 JButton showHideButton = new JButton(new ShowHideLayerAction(layers, null));
    202         showHideButton.setText("");
    203         buttonPanel.add(showHideButton);
    204                
    205         JButton deleteButton = new JButton(deleteAction);
    206         deleteButton.setText("");
    207         buttonPanel.add(deleteButton);
     199
     200                JButton showHideButton = new JButton(new ShowHideLayerAction(null));
     201                showHideButton.setText("");
     202                buttonPanel.add(showHideButton);
     203
     204                JButton deleteButton = new JButton(deleteAction);
     205                deleteButton.setText("");
     206                buttonPanel.add(deleteButton);
    208207
    209208                mergeButton.setToolTipText("Merge the selected layer into the layer directly below.");
    210209                mergeButton.addActionListener(new ActionListener(){
    211210                        public void actionPerformed(ActionEvent e) {
    212                                 Layer lFrom = (Layer)layers.getSelectedValue();
    213                                 Layer lTo = (Layer)model.get(layers.getSelectedIndex()+1);
     211                                Layer lFrom = (Layer)instance.getSelectedValue();
     212                                Layer lTo = (Layer)model.get(instance.getSelectedIndex()+1);
    214213                                lTo.mergeFrom(lFrom);
    215                                 layers.setSelectedValue(lTo, true);
     214                                instance.setSelectedValue(lTo, true);
    216215                                mapView.removeLayer(lFrom);
    217216                        }
     
    220219
    221220                add(buttonPanel, BorderLayout.SOUTH);
    222                
     221
    223222                updateButtonEnabled();
    224223        }
     
    228227         */
    229228        void updateButtonEnabled() {
    230                 int sel = layers.getSelectedIndex();
    231                 Layer l = (Layer)layers.getSelectedValue();
     229                int sel = instance.getSelectedIndex();
     230                Layer l = (Layer)instance.getSelectedValue();
    232231                boolean enable = model.getSize() > 1;
    233232                enable = enable && sel < model.getSize()-1;
     
    249248        public void layerRemoved(Layer oldLayer) {
    250249                model.removeElement(oldLayer);
    251                 if (layers.getSelectedIndex() == -1)
    252                         layers.setSelectedIndex(0);
     250                if (instance.getSelectedIndex() == -1)
     251                        instance.setSelectedIndex(0);
    253252                updateButtonEnabled();
    254253        }
     
    258257         */
    259258        public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    260                 if (newLayer != layers.getSelectedValue())
    261                         layers.setSelectedValue(newLayer, true);
     259                if (newLayer != instance.getSelectedValue())
     260                        instance.setSelectedValue(newLayer, true);
    262261                updateButtonEnabled();
    263262        }
  • src/org/openstreetmap/josm/gui/dialogs/LayerListPopup.java

    r98 r103  
    11package org.openstreetmap.josm.gui.dialogs;
    22
     3import java.awt.Component;
    34import java.awt.event.ActionEvent;
    45
     
    2930
    3031        public LayerListPopup(final JList layers, final Layer layer) {
    31                 add(new LayerList.ShowHideLayerAction(layers, layer));
    32                 add(new LayerList.DeleteLayerAction(layers, layer));
    33                 addSeparator();
    34 
    35                 layer.addMenuEntries(this);
     32                for (Component c : layer.getMenuEntries())
     33                        add(c);
    3634        }
    3735}
  • src/org/openstreetmap/josm/gui/dialogs/SelectionListDialog.java

    r101 r103  
    1111import java.awt.event.MouseEvent;
    1212import java.io.IOException;
    13 import java.io.Reader;
     13import java.io.InputStream;
    1414import java.net.MalformedURLException;
    1515import java.net.URL;
     
    7373                        try {
    7474                        URLConnection con = url.openConnection();
    75                         Reader in = new ProgressReader(con, progress, currentAction);
     75                        InputStream in = new ProgressReader(con, progress, currentAction);
    7676                                currentAction.setText("Downloading...");
    7777                                Map<Long, String> ids = idReader.parseIds(in);
  • src/org/openstreetmap/josm/gui/layer/GeoImageLayer.java

    r102 r103  
    3636import javax.swing.JOptionPane;
    3737import javax.swing.JPanel;
    38 import javax.swing.JPopupMenu;
    3938import javax.swing.JScrollPane;
     39import javax.swing.JSeparator;
    4040import javax.swing.JTextField;
    4141import javax.swing.JToggleButton;
     
    5151import org.openstreetmap.josm.gui.MapView;
    5252import org.openstreetmap.josm.gui.PleaseWaitRunnable;
     53import org.openstreetmap.josm.gui.dialogs.LayerList;
    5354import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
    5455import org.openstreetmap.josm.gui.layer.RawGpsLayer.GpsPoint;
     
    314315        }
    315316
    316         @Override public void addMenuEntries(JPopupMenu menu) {
     317        @Override public Component[] getMenuEntries() {
    317318                JMenuItem sync = new JMenuItem("Sync clock", ImageProvider.get("clock"));
    318319                sync.addActionListener(new ActionListener(){
     
    338339                        }
    339340                });
    340                 menu.add(sync);
    341 
    342                 menu.addSeparator();
    343                 menu.add(new LayerListPopup.InfoAction(this));
     341                return new Component[]{
     342                                new JMenuItem(new LayerList.ShowHideLayerAction(this)),
     343                                new JMenuItem(new LayerList.DeleteLayerAction(this)),
     344                                new JSeparator(),
     345                                sync,
     346                                new JSeparator(),
     347                                new JMenuItem(new LayerListPopup.InfoAction(this))};
    344348        }
    345349
  • src/org/openstreetmap/josm/gui/layer/Layer.java

    r100 r103  
    11package org.openstreetmap.josm.gui.layer;
    22
     3import java.awt.Component;
    34import java.awt.Graphics;
    45
    56import javax.swing.Icon;
    6 import javax.swing.JPopupMenu;
    77
    88import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
     
    8282        abstract public Object getInfoComponent();
    8383       
    84         abstract public void addMenuEntries(JPopupMenu menu);
     84        abstract public Component[] getMenuEntries();
    8585       
    8686        /**
  • src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

    r100 r103  
    11package org.openstreetmap.josm.gui.layer;
    22
     3import java.awt.Component;
    34import java.awt.Graphics;
    45import java.awt.GridBagLayout;
     
    1617import javax.swing.JOptionPane;
    1718import javax.swing.JPanel;
    18 import javax.swing.JPopupMenu;
     19import javax.swing.JSeparator;
    1920
    2021import org.openstreetmap.josm.Main;
     
    3334import org.openstreetmap.josm.gui.MapView;
    3435import org.openstreetmap.josm.gui.dialogs.ConflictDialog;
     36import org.openstreetmap.josm.gui.dialogs.LayerList;
    3537import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
    3638import org.openstreetmap.josm.tools.GBC;
     
    309311        }
    310312
    311         @Override public void addMenuEntries(final JPopupMenu menu) {
    312                 menu.add(new JMenuItem(new SaveAction()));
    313                 menu.add(new JMenuItem(new GpxExportAction(this)));
    314                 menu.addSeparator();
    315                 menu.add(new LayerListPopup.InfoAction(this));
     313        @Override public Component[] getMenuEntries() {
     314                return new Component[]{
     315                                new JMenuItem(new LayerList.ShowHideLayerAction(this)),
     316                                new JMenuItem(new LayerList.DeleteLayerAction(this)),
     317                                new JSeparator(),
     318                                new JMenuItem(new SaveAction()),
     319                                new JMenuItem(new GpxExportAction(this)),
     320                                new JSeparator(),
     321                                new JMenuItem(new LayerListPopup.InfoAction(this))};
    316322        }
    317323}
  • src/org/openstreetmap/josm/gui/layer/RawGpsLayer.java

    r102 r103  
    22
    33import java.awt.Color;
     4import java.awt.Component;
    45import java.awt.Graphics;
    56import java.awt.Point;
     
    1617import javax.swing.JMenuItem;
    1718import javax.swing.JOptionPane;
    18 import javax.swing.JPopupMenu;
     19import javax.swing.JSeparator;
    1920import javax.swing.filechooser.FileFilter;
    2021
     
    3031import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
    3132import org.openstreetmap.josm.gui.MapView;
     33import org.openstreetmap.josm.gui.dialogs.LayerList;
    3234import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
    3335import org.openstreetmap.josm.tools.ColorHelper;
     
    4244public class RawGpsLayer extends Layer implements PreferenceChangedListener {
    4345
    44         public class ConvertToOsmAction extends AbstractAction {
    45                 public ConvertToOsmAction() {
    46                         super("Convert layer to OSM");
     46        public class ConvertToDataLayerAction extends AbstractAction {
     47                public ConvertToDataLayerAction() {
     48                        super("Convert to data layer", ImageProvider.get("converttoosm"));
    4749        }
    4850                public void actionPerformed(ActionEvent e) {
     
    154156        }
    155157
    156         @Override public void addMenuEntries(JPopupMenu menu) {
    157                 menu.add(new JMenuItem(new GpxExportAction(this)));
    158                
     158        @Override public Component[] getMenuEntries() {
    159159                JMenuItem color = new JMenuItem("Customize Color", ImageProvider.get("colorchooser"));
    160160                color.addActionListener(new ActionListener(){
     
    177177                        }
    178178                });
    179                 menu.add(color);
    180179               
    181180                JMenuItem tagimage = new JMenuItem("Import images", ImageProvider.get("tagimages"));
     
    213212            }
    214213                });
    215                 menu.add(tagimage);
    216                
    217                 menu.add(new JMenuItem(new ConvertToOsmAction()));
    218                
    219                 menu.addSeparator();
    220                 menu.add(new LayerListPopup.InfoAction(this));
     214                return new Component[]{
     215                                new JMenuItem(new LayerList.ShowHideLayerAction(this)),
     216                                new JMenuItem(new LayerList.DeleteLayerAction(this)),
     217                                new JSeparator(),
     218                                new JMenuItem(new GpxExportAction(this)),
     219                                color,
     220                                tagimage,
     221                                new JMenuItem(new ConvertToDataLayerAction()),
     222                                new JSeparator(),
     223                                new JMenuItem(new LayerListPopup.InfoAction(this))};
    221224    }
    222225
  • src/org/openstreetmap/josm/gui/layer/WmsServerLayer.java

    r86 r103  
    11package org.openstreetmap.josm.gui.layer;
    22
     3import java.awt.Component;
    34import java.awt.Graphics;
    45import java.awt.Image;
     
    67
    78import javax.swing.Icon;
    8 import javax.swing.JPopupMenu;
     9import javax.swing.JMenuItem;
     10import javax.swing.JSeparator;
    911
    1012import org.openstreetmap.josm.Main;
     
    1416import org.openstreetmap.josm.data.projection.Projection;
    1517import org.openstreetmap.josm.gui.MapView;
     18import org.openstreetmap.josm.gui.dialogs.LayerList;
    1619import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
    1720import org.openstreetmap.josm.tools.ImageProvider;
     
    9598        }
    9699
    97         @Override public void addMenuEntries(JPopupMenu menu) {
    98                 menu.addSeparator();
    99                 menu.add(new LayerListPopup.InfoAction(this));
     100        @Override public Component[] getMenuEntries() {
     101                return new Component[]{
     102                                new JMenuItem(new LayerList.ShowHideLayerAction(this)),
     103                                new JMenuItem(new LayerList.DeleteLayerAction(this)),
     104                                new JSeparator(),
     105                                new JMenuItem(new LayerListPopup.InfoAction(this))};
    100106    }
    101107}
  • src/org/openstreetmap/josm/io/GpxWriter.java

    r100 r103  
    11package org.openstreetmap.josm.io;
    22
    3 import java.io.IOException;
     3import java.io.OutputStream;
     4import java.io.OutputStreamWriter;
    45import java.io.PrintWriter;
    5 import java.io.Writer;
     6import java.io.UnsupportedEncodingException;
    67import java.util.Collection;
    7 import java.util.HashMap;
    88import java.util.LinkedList;
    9 import java.util.Map;
    10 import java.util.StringTokenizer;
    11 import java.util.Map.Entry;
    12 
    13 import org.jdom.Document;
    14 import org.jdom.Element;
    15 import org.jdom.Namespace;
    16 import org.jdom.output.Format;
    17 import org.jdom.output.XMLOutputter;
     9
    1810import org.openstreetmap.josm.data.Bounds;
    1911import org.openstreetmap.josm.data.coor.LatLon;
    2012import org.openstreetmap.josm.data.osm.DataSet;
    21 import org.openstreetmap.josm.data.osm.Segment;
    2213import org.openstreetmap.josm.data.osm.Node;
    2314import org.openstreetmap.josm.data.osm.OsmPrimitive;
     15import org.openstreetmap.josm.data.osm.Segment;
    2416import org.openstreetmap.josm.data.osm.Way;
    2517import org.openstreetmap.josm.gui.layer.RawGpsLayer.GpsPoint;
     
    3931
    4032        /**
    41          * The GPX namespace used.
    42          */
    43         public static final Namespace GPX = Namespace.getNamespace("http://www.topografix.com/GPX/1/0");
    44         /**
    45          * The OSM namespace used (for extensions).
    46          */
    47         public static final Namespace OSM = Namespace.getNamespace("osm", "http://www.openstreetmap.org");
    48         /**
    49          * The JOSM namespace (for JOSM-extensions).
    50          */
    51         public static final Namespace JOSM = Namespace.getNamespace("josm", "http://wiki.eigenheimstrasse.de/wiki/JOSM");
    52 
    53         /**
    5433         * This is the output writer to store the resulting data in.
    5534         */
    5635        private PrintWriter out;
    57         /**
    58          * The dataset beeing processed.
    59          */
    60         private DataSet ds;
    61         /**
    62          * Map all new primitives to the element which hold them. After inserting everything,
    63          * the writer sets ids to every element that was in the list and had more than one
    64          * element using it.
    65          */
    66         private HashMap<OsmPrimitive, Collection<Element>> usedNewPrimitives = new HashMap<OsmPrimitive, Collection<Element>>();
    67         /**
    68          * The counter for new created objects used more than once.
    69          * Starting at -1 and goes down.
    70          */
    71         private long newIdCounter = -1;
    72        
    73         /**
    74          * Create a GpxWrite from an output writer. As example to write in a file,
    75          * use FileWriter.
    76          *
    77          * @param out The Writer to store the result data in.
    78          */
    79         public GpxWriter(Writer out, DataSet ds) {
    80                 this.out = new PrintWriter(out);
    81                 this.ds = ds;
    82         }
    83 
    84 
    85         /**
    86          * Do the output in the former set writer.
    87          * @exception IOException In case of IO errors, throw this exception.
    88          */
    89         public void output() throws IOException {
    90                 Element root = parseDataSet();
    91                 root.addNamespaceDeclaration(OSM);
    92                 root.addNamespaceDeclaration(JOSM);
    93                 Document d = new Document(root);
    94                 XMLOutputter xmlOut = new XMLOutputter(Format.getPrettyFormat());
    95                 xmlOut.output(d, out);
    96         }
    97 
    98 
    99         /**
    100          * Write the whole DataSet in an JDom-Element and return the new element.
    101          * @return The created element, out of the dataset.
    102          */
    103         @SuppressWarnings("unchecked")
    104         private Element parseDataSet() {
    105                 Element e = new Element("gpx", GPX);
    106                 e.setAttribute("version", "1.0");
    107                 e.setAttribute("creator", "JOSM");
    108                 // for getting all unreferenced waypoints in the wpt-list
    109                 LinkedList<Node> unrefNodes = new LinkedList<Node>(ds.nodes);
    110                 // for getting all unreferenced segments
    111                 LinkedList<Segment> unrefLs = new LinkedList<Segment>(ds.segments);
    112 
    113                 // ways
    114                 for (Way w : ds.ways) {
    115                         if (w.deleted && w.id == 0)
    116                                 continue;
    117                         Element tElem = new Element("trk", GPX);
    118                         HashMap<String, String> keys = null;
    119                         if (w.keys != null) {
    120                                 keys = new HashMap<String, String>(w.keys);
    121                                 addAndRemovePropertyTag("name", tElem, keys);
    122                                 addAndRemovePropertyTag("cmt", tElem, keys);
    123                                 addAndRemovePropertyTag("desc", tElem, keys);
    124                                 addAndRemovePropertyTag("src", tElem, keys);
    125                                 addAndRemovePropertyLinkTag(tElem, keys);
    126                                 addAndRemovePropertyTag("number", tElem, keys);
    127                                 addAndRemovePropertyTag("type", tElem, keys);
    128                         }
    129                         addPropertyExtensions(tElem, keys, w);
    130 
    131                         // segments
    132                         for (Segment ls : w.segments) {
    133                                 if (ls.incomplete)
    134                                         continue;
    135                                 tElem.getChildren().add(parseSegment(ls));
    136                                 unrefNodes.remove(ls.from);
    137                                 unrefNodes.remove(ls.to);
    138                                 unrefLs.remove(ls);
    139                         }
    140 
    141                         e.getChildren().add(tElem);
    142                 }
    143                
    144                 // encode pending segments as ways
    145                 for (Segment ls : unrefLs) {
    146                         if (ls.deleted && ls.id == 0)
    147                                 continue;
    148                         Element t = new Element("trk", GPX);
    149                         t.getChildren().add(parseSegment(ls));
    150                         unrefNodes.remove(ls.from);
    151                         unrefNodes.remove(ls.to);
    152                         Element ext = new Element("extensions", GPX);
    153                         ext.getChildren().add(new Element("segment", JOSM));
    154                         t.getChildren().add(ext);
    155                         e.getChildren().add(t);
    156                 }
    157 
    158                 // waypoints (missing nodes)
    159                 for (Node n : unrefNodes) {
    160                         if (n.deleted && n.id == 0)
    161                                 continue;
    162                         e.getChildren().add(parseWaypoint(n, "wpt"));
    163                 }
    164 
    165                 // link all ids used more than once
    166                 for (Entry<OsmPrimitive, Collection<Element>> entry : usedNewPrimitives.entrySet()) {
    167                         if (entry.getValue().size() > 1) {
    168                                 long id = newIdCounter--;
    169                                 for (Element element : entry.getValue()) {
    170                                         Element ext = element.getChild("extensions", GPX);
    171                                         if (ext == null)
    172                                                 element.getChildren().add(ext = new Element("extensions", GPX));
    173                                         ext.getChildren().add(new Element("uid", JOSM).setText(""+id));
    174                                 }
    175                         }
    176                 }
    177 
    178                 return e;
    179         }
    180 
    181 
    182         /**
    183          * Parse a segment and store it into a JDOM-Element. Return that element.
    184          */
    185         @SuppressWarnings("unchecked")
    186         private Element parseSegment(Segment ls) {
    187                 Element lsElem = new Element("trkseg", GPX);
    188                 addPropertyExtensions(lsElem, ls.keys, ls);
    189                 lsElem.getChildren().add(parseWaypoint(ls.from, "trkpt"));
    190                 lsElem.getChildren().add(parseWaypoint(ls.to, "trkpt"));
    191                 return lsElem;
    192         }
    193 
    194         /**
    195          * Parse a waypoint (node) and store it into an JDOM-Element. Return that
    196          * element.
    197          *
    198          * @param n The Node to parse and store
    199          * @param name The name of the tag (different names for nodes in GPX)
    200          * @return The resulting GPX-Element
    201          */
    202         private Element parseWaypoint(Node n, String name) {
    203                 Element e = new Element(name, GPX);
    204                 e.setAttribute("lat", Double.toString(n.coor.lat()));
    205                 e.setAttribute("lon", Double.toString(n.coor.lon()));
    206                 HashMap<String, String> keys = null;
    207                 if (n.keys != null) {
    208                         keys = new HashMap<String, String>(n.keys);
    209                         addAndRemovePropertyTag("ele", e, keys);
    210                         addAndRemovePropertyTag("time", e, keys);
    211                         addAndRemovePropertyTag("magvar", e, keys);
    212                         addAndRemovePropertyTag("geoidheight", e, keys);
    213                         addAndRemovePropertyTag("name", e, keys);
    214                         addAndRemovePropertyTag("cmt", e, keys);
    215                         addAndRemovePropertyTag("desc", e, keys);
    216                         addAndRemovePropertyTag("src", e, keys);
    217                         addAndRemovePropertyLinkTag(e, keys);
    218                         addAndRemovePropertyTag("sym", e, keys);
    219                         addAndRemovePropertyTag("type", e, keys);
    220                         addAndRemovePropertyTag("fix", e, keys);
    221                         addAndRemovePropertyTag("sat", e, keys);
    222                         addAndRemovePropertyTag("hdop", e, keys);
    223                         addAndRemovePropertyTag("vdop", e, keys);
    224                         addAndRemovePropertyTag("pdop", e, keys);
    225                         addAndRemovePropertyTag("ageofdgpsdata", e, keys);
    226                         addAndRemovePropertyTag("dgpsid", e, keys);
    227                 }
    228                 addPropertyExtensions(e, keys, n);
    229                 return e;
    230         }
    231 
    232 
    233         /**
    234          * Add a link-tag to the element, if the property list contain a value named
    235          * "link". The property is removed from the map afterwards.
    236          *
    237          * For the format, @see GpxReader#parseKeyValueLink(OsmPrimitive, Element).
    238          * @param e             The element to add the link to.
    239          * @param keys  The map containing the link property.
    240          */
    241         @SuppressWarnings("unchecked")
    242         private void addAndRemovePropertyLinkTag(Element e, Map<String, String> keys) {
    243                 String value = keys.get("link");
    244                 if (value != null) {
    245                         StringTokenizer st = new StringTokenizer(value, ";");
    246                         if (st.countTokens() != 2)
    247                                 return;
    248                         Element link = new Element("link", GPX);
    249                         link.getChildren().add(new Element("type", GPX).setText(st.nextToken()));
    250                         link.getChildren().add(0,new Element("text", GPX).setText(st.nextToken()));
    251                         e.getChildren().add(link);
    252                         keys.remove("link");
    253                 }
    254         }
    255 
    256 
    257         /**
    258          * Helper to add a property with a given name as tag to the element. This
    259          * will look like &lt;name&gt;<i>keys.get(name)</i>&lt;/name&gt;
    260          *
    261          * After adding, the property is removed from the map.
    262          *
    263          * If the property does not exist, nothing is done.
    264          *
    265          * @param name The properties name
    266          * @param e The element to add the tag to.
    267          * @param osm The data to get the property from.
    268          */
    269         @SuppressWarnings("unchecked")
    270         private void addAndRemovePropertyTag(String name, Element e, Map<String, String> keys) {
    271                 String value = keys.get(name);
    272                 if (value != null) {
    273                         e.getChildren().add(new Element(name, GPX).setText(value));
    274                         keys.remove(name);
    275                 }
    276         }
    277        
    278         /**
    279          * Add the property in the entry as &lt;extensions&gt; to the element
    280          * @param e             The element to add the property to.
    281          * @param prop  The property to add.
    282          */
    283         @SuppressWarnings("unchecked")
    284         private void addPropertyExtensions(Element e, Map<String, String> keys, OsmPrimitive osm) {
    285                 LinkedList<Element> extensions = new LinkedList<Element>();
    286                 if (keys != null && !keys.isEmpty()) {
    287                         for (Entry<String, String> prop : keys.entrySet()) {
    288                                 Element propElement = new Element("property", OSM);
    289                                 propElement.setAttribute("key", prop.getKey());
    290                                 propElement.setAttribute("value", prop.getValue());
    291                                 extensions.add(propElement);
    292                         }
    293                 }
    294                
    295                 if (osm.id != 0) {
    296                         Element propElement = new Element("uid", JOSM);
    297                         propElement.setText(""+osm.id);
    298                         extensions.add(propElement);
    299                 } else {
    300                         Collection<Element> l = usedNewPrimitives.get(osm);
    301                         if (l == null)
    302                                 l = new LinkedList<Element>();
    303                         l.add(e);
    304                         usedNewPrimitives.put(osm, l);
    305                 }
    306                 if (osm.modified) {
    307                         Element modElement = new Element("modified", JOSM);
    308                         extensions.add(modElement);
    309                 }
    310                 if (osm.deleted) {
    311                         Element modElement = new Element("deleted", JOSM);
    312                         extensions.add(modElement);
    313                 }
    314                
    315                 if (extensions.isEmpty())
    316                         return;
    317 
    318                 Element ext = e.getChild("extensions", GPX);
    319                 if (ext == null)
    320                         e.getChildren().add(ext = new Element("extensions", GPX));
    321                 ext.getChildren().addAll(extensions);
    322         }
    323 
    324 
    325         public GpxWriter(Writer writer, String name, String desc, String author, String email, String copyright, String year, String keywords) {
    326                 out = writer instanceof PrintWriter ? (PrintWriter)writer : new PrintWriter(writer);
     36
     37        public GpxWriter(OutputStream os, String name, String desc, String author, String email, String copyright, String year, String keywords) {
     38                try {
     39                        out = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
     40                } catch (UnsupportedEncodingException e) {
     41                        throw new RuntimeException(e);
     42                }
    32743                out.println(XmlWriter.header());
    32844                out.println("<gpx version='1.1' creator='JOSM' xmlns='http://www.topografix.com/GPX/1/1'>");
     
    37389                out.println("    <bounds minlat='"+b.min.lat()+"' minlon='"+b.min.lon()+"' maxlat='"+b.max.lat()+"' maxlon='"+b.max.lon()+"' />");
    37490                out.println("  </metadata>");
    375                
     91
    37692                // add ways
    37793                for (Way w : data.ways) {
     
    407123                        all.remove(w);
    408124                }
    409                
     125
    410126                // add remaining segments
    411127                Collection<Segment> segments = new LinkedList<Segment>();
     
    426142                        out.println("  </trk>");
    427143                }
    428                
     144
    429145                // finally add the remaining nodes
    430146                for (OsmPrimitive osm : all)
    431147                        if (osm instanceof Node)
    432148                                outputNode((Node)osm, true);
    433                
     149
    434150                out.println("</gpx>");
    435151        }
     
    453169                out.println("    <bounds minlat='"+b.min.lat()+"' minlon='"+b.min.lon()+"' maxlat='"+b.max.lat()+"' maxlon='"+b.max.lon()+"' />");
    454170                out.println("  </metadata>");
    455                
     171
    456172                out.println("  <trk>");
    457173                for (Collection<GpsPoint> c : data) {
     
    508224                        out.println(" />");
    509225        }
     226
     227        public void close() {
     228                out.flush();
     229                out.close();
     230        }
    510231}
  • src/org/openstreetmap/josm/io/OsmConnection.java

    r99 r103  
    2626public class OsmConnection {
    2727
     28        public static class OsmParseException extends Exception {
     29                public OsmParseException() {super();}
     30                public OsmParseException(String message, Throwable cause) {super(message, cause);}
     31                public OsmParseException(String message) {super(message);}
     32                public OsmParseException(Throwable cause) {super(cause);}
     33        }
     34       
    2835        protected boolean cancel = false;
    2936        protected HttpURLConnection activeConnection;
  • src/org/openstreetmap/josm/io/OsmIdReader.java

    r92 r103  
    22
    33import java.io.IOException;
     4import java.io.InputStream;
     5import java.io.InputStreamReader;
    46import java.io.Reader;
    57import java.util.HashMap;
     
    3335    }
    3436
    35         public Map<Long, String> parseIds(Reader in) throws IOException, SAXException {
    36         this.in = in;
     37        public Map<Long, String> parseIds(InputStream in) throws IOException, SAXException {
     38        this.in = new InputStreamReader(in, "UTF-8");
    3739                try {
    38                 parse(in);
     40                parse(this.in);
    3941        } catch (SAXException e) {
    4042                if (!cancel)
  • src/org/openstreetmap/josm/io/OsmReader.java

    r101 r103  
    22
    33import java.io.IOException;
    4 import java.io.Reader;
     4import java.io.InputStream;
     5import java.io.InputStreamReader;
    56import java.text.DateFormat;
    67import java.text.ParseException;
     
    5657         */
    5758        private Map<Long, Node> nodes = new HashMap<Long, Node>();
    58        
     59
    5960        private static class OsmPrimitiveData extends OsmPrimitive {
    6061                @Override public void visit(Visitor visitor) {}
     
    6869                        osm.deleted = deleted;
    6970                        osm.timestamp = timestamp;
    70         }
    71         }
    72        
     71                }
     72        }
     73
    7374        /**
    7475         * Data structure for the remaining segment objects
     
    200201         * Parse the given input source and return the dataset.
    201202         */
    202         public static DataSet parseDataSet(Reader source, JLabel currentAction, BoundedRangeModel progress) throws SAXException, IOException {
     203        public static DataSet parseDataSet(InputStream source, JLabel currentAction, BoundedRangeModel progress) throws SAXException, IOException {
    203204                OsmReader osm = new OsmReader();
    204205
    205206                // phase 1: Parse nodes and read in raw segments and ways
    206                 osm.new Parser().parse(source);
     207                osm.new Parser().parse(new InputStreamReader(source, "UTF-8"));
    207208                if (progress != null)
    208209                        progress.setValue(0);
  • src/org/openstreetmap/josm/io/OsmServerReader.java

    r101 r103  
    22
    33import java.io.IOException;
    4 import java.io.Reader;
     4import java.io.InputStream;
    55import java.net.HttpURLConnection;
    66import java.net.URL;
     
    88import java.util.LinkedList;
    99
    10 import org.jdom.JDOMException;
    1110import org.openstreetmap.josm.Main;
    1211import org.openstreetmap.josm.data.osm.DataSet;
     
    4645         *              ways.
    4746         */
    48         public Collection<Collection<GpsPoint>> parseRawGps() throws IOException, JDOMException {
     47        public Collection<Collection<GpsPoint>> parseRawGps() throws IOException, SAXException {
    4948                try {
    5049                        String url = Main.pref.get("osm-server.url")+"/0.3/trackpoints?bbox="+lon1+","+lat1+","+lon2+","+lat2+"&page=";
     
    5453                        for (int i = 0;;++i) {
    5554                                currentAction.setText("Downloading points "+(i*5000)+" to "+((i+1)*5000)+"...");
    56                                 Reader r = getReader(url+i);
    57                                 if (r == null)
     55                                InputStream in = getInputStream(url+i);
     56                                if (in == null)
    5857                                        break;
    59                                 RawGpsReader gpsReader = new RawGpsReader(r);
    60                                 Collection<Collection<GpsPoint>> allWays = gpsReader.parse();
     58                                Collection<Collection<GpsPoint>> allWays = RawGpsReader.parse(in);
    6159                                boolean foundSomething = false;
    6260                                for (Collection<GpsPoint> t : allWays) {
     
    6866                                if (!foundSomething)
    6967                                        break;
    70                                 r.close();
     68                                in.close();
    7169                                activeConnection = null;
    7270                        }
     
    7876                                return null;
    7977                        throw e;
    80                 } catch (JDOMException e) {
     78                } catch (SAXException e) {
    8179                        throw e;
    8280                } catch (Exception e) {
     
    9694        public DataSet parseOsm() throws SAXException, IOException {
    9795                try {
    98                         final Reader r = getReader(Main.pref.get("osm-server.url")+"/0.3/map?bbox="+lon1+","+lat1+","+lon2+","+lat2);
    99                         if (r == null)
     96                        final InputStream in = getInputStream(Main.pref.get("osm-server.url")+"/0.3/map?bbox="+lon1+","+lat1+","+lon2+","+lat2);
     97                        if (in == null)
    10098                                return null;
    10199                        currentAction.setText("Downloading OSM data...");
    102                         final DataSet data = OsmReader.parseDataSet(r, currentAction, progress);
    103                         r.close();
     100                        final DataSet data = OsmReader.parseDataSet(in, currentAction, progress);
     101                        in.close();
    104102                        activeConnection = null;
    105103                        return data;
     
    126124         * @return An reader reading the input stream (servers answer) or <code>null</code>.
    127125         */
    128         private Reader getReader(String urlStr) throws IOException {
     126        private InputStream getInputStream(String urlStr) throws IOException {
    129127                System.out.println("download: "+urlStr);
    130128                initAuthentication();
  • src/org/openstreetmap/josm/io/OsmServerWriter.java

    r100 r103  
    22
    33import java.io.BufferedReader;
     4import java.io.ByteArrayOutputStream;
    45import java.io.IOException;
    56import java.io.InputStream;
    67import java.io.InputStreamReader;
    7 import java.io.OutputStreamWriter;
    8 import java.io.StringWriter;
    9 import java.io.Writer;
     8import java.io.OutputStream;
    109import java.net.HttpURLConnection;
    1110import java.net.URL;
     
    1413import java.util.LinkedList;
    1514
    16 import org.jdom.JDOMException;
    1715import org.openstreetmap.josm.Main;
    1816import org.openstreetmap.josm.data.osm.Node;
     
    2220import org.openstreetmap.josm.data.osm.visitor.NameVisitor;
    2321import org.openstreetmap.josm.data.osm.visitor.Visitor;
     22import org.xml.sax.SAXException;
    2423
    2524/**
     
    5554         * does not want to send the data.
    5655         */
    57         public void uploadOsm(Collection<OsmPrimitive> list) throws JDOMException {
     56        public void uploadOsm(Collection<OsmPrimitive> list) throws SAXException {
    5857                processed = new LinkedList<OsmPrimitive>();
    5958                initAuthentication();
     
    7372                        }
    7473                } catch (RuntimeException e) {
    75                         throw new JDOMException("An error occoured: ", e);
     74                        throw new SAXException("An error occoured: ", e);
    7675                }
    7776        }
     
    162161
    163162                        if (addBody) {
    164                                 Writer out = new OutputStreamWriter(activeConnection.getOutputStream());
     163                                OutputStream out = activeConnection.getOutputStream();
    165164                                OsmWriter.outputSingle(out, osm, true);
    166165                                out.close();
     
    176175                                return; // everything fine.. was already deleted.
    177176                        if (retCode != 200) {
    178                                 StringWriter o = new StringWriter();
     177                                ByteArrayOutputStream o = new ByteArrayOutputStream();
    179178                                OsmWriter.outputSingle(o, osm, true);
    180                                 System.out.println(o.getBuffer().toString());
     179                                System.out.println(new String(o.toByteArray(), "UTF-8").toString());
    181180                                throw new RuntimeException(retCode+" "+retMsg);
    182181                        }
  • src/org/openstreetmap/josm/io/OsmWriter.java

    r90 r103  
    11package org.openstreetmap.josm.io;
    22
     3import java.io.OutputStream;
     4import java.io.OutputStreamWriter;
    35import java.io.PrintWriter;
    4 import java.io.Writer;
     6import java.io.UnsupportedEncodingException;
    57import java.util.HashMap;
    68import java.util.Map.Entry;
     
    4446         *              is lost and id's remain 0 instead of decrementing from -1)
    4547         */
    46         public static void output(Writer out, DataSet ds, boolean osmConform) {
     48        public static void output(OutputStream out, DataSet ds, boolean osmConform) {
    4749                OsmWriter writer = new OsmWriter(out, osmConform);
    4850                writer.out.println("<?xml version='1.0' encoding='UTF-8'?>");
     
    5557                        writer.visit(w);
    5658                writer.out.println("</osm>");
     59                writer.close();
    5760        }
    5861
    59         public static void outputSingle(Writer out, OsmPrimitive osm, boolean osmConform) {
     62        public static void outputSingle(OutputStream out, OsmPrimitive osm, boolean osmConform) {
    6063                OsmWriter writer = new OsmWriter(out, osmConform);
    6164                writer.out.println(XmlWriter.header());
     
    6366                osm.visit(writer);
    6467                writer.out.println("</osm>");
     68                writer.close();
    6569        }
    6670
    67         private OsmWriter(Writer out, boolean osmConform) {
    68                 if (out instanceof PrintWriter)
    69                         this.out = (PrintWriter)out;
    70                 else
    71                         this.out = new PrintWriter(out);
     71        private OsmWriter(OutputStream out, boolean osmConform) {
     72                try {
     73                this.out = new PrintWriter(new OutputStreamWriter(out, "UTF-8"));
     74        } catch (UnsupportedEncodingException e) {
     75                throw new RuntimeException(e);
     76        }
    7277                this.osmConform = osmConform;
    7378        }
     
    141146                }
    142147        }
     148
     149        public void close() {
     150            out.close();
     151    }
    143152}
  • src/org/openstreetmap/josm/io/ProgressReader.java

    r101 r103  
    22
    33import java.io.IOException;
     4import java.io.InputStream;
    45import java.io.InputStreamReader;
    56import java.io.Reader;
     
    1314 * @author Imi
    1415 */
    15 public class ProgressReader extends Reader {
     16public class ProgressReader extends InputStream {
    1617
    1718        private final Reader in;
     
    3637        }
    3738
    38         @Override public int read(char[] cbuf, int off, int len) throws IOException {
    39                 int read = in.read(cbuf, off, len);
    40                 readSoFar += read;
     39        @Override public int read() throws IOException {
     40                int read = in.read();
     41                readSoFar++;
    4142
    4243                String progStr = " ("+readSoFar+"/";
     
    5556                progress.setValue(readSoFar);
    5657                return read;
    57         }
    58 
     58    }
    5959}
  • src/org/openstreetmap/josm/io/RawCsvReader.java

    r99 r103  
    99import java.util.StringTokenizer;
    1010
    11 import org.jdom.JDOMException;
    1211import org.openstreetmap.josm.Main;
    1312import org.openstreetmap.josm.data.coor.LatLon;
    1413import org.openstreetmap.josm.gui.layer.RawGpsLayer.GpsPoint;
     14import org.xml.sax.SAXException;
    1515
    1616/**
     
    2929        }
    3030
    31         public Collection<GpsPoint> parse() throws JDOMException, IOException {
     31        public Collection<GpsPoint> parse() throws SAXException, IOException {
    3232                Collection<GpsPoint> data = new LinkedList<GpsPoint>();
    3333                String formatStr = Main.pref.get("csv.importstring");
     
    3535                        formatStr = in.readLine();
    3636                if (formatStr == null)
    37                         throw new JDOMException("Could not detect data format string.");
     37                        throw new SAXException("Could not detect data format string.");
    3838
    3939                // get delimiter
     
    5858                if (!format.contains("lat") || !format.contains("lon")) {
    5959                        if (Main.pref.get("csv.importstring").equals(""))
    60                                 throw new JDOMException("Format string in data is incomplete or not found. Try setting an manual format string in Preferences.");
    61                         throw new JDOMException("Format string is incomplete. Need at least 'lat' and 'lon' specification");
     60                                throw new SAXException("Format string in data is incomplete or not found. Try setting an manual format string in Preferences.");
     61                        throw new SAXException("Format string is incomplete. Need at least 'lat' and 'lon' specification");
    6262                }
    6363
     
    7979                                                st.nextToken();
    8080                                        else
    81                                                 throw new JDOMException("Unknown data type: '"+token+"'."+(Main.pref.get("csv.importstring").equals("") ? " Maybe add an format string in preferences." : ""));
     81                                                throw new SAXException("Unknown data type: '"+token+"'."+(Main.pref.get("csv.importstring").equals("") ? " Maybe add an format string in preferences." : ""));
    8282                                }
    8383                                data.add(new GpsPoint(new LatLon(lat, lon), time));
    8484                        }
    8585                } catch (RuntimeException e) {
    86                         throw new JDOMException("Parsing error in line "+lineNo, e);
     86                        throw new SAXException("Parsing error in line "+lineNo, e);
    8787                }
    8888                return data;
  • src/org/openstreetmap/josm/io/RawGpsReader.java

    r99 r103  
    22
    33import java.io.IOException;
    4 import java.io.Reader;
     4import java.io.InputStream;
     5import java.io.InputStreamReader;
    56import java.util.Collection;
    67import java.util.LinkedList;
    78
    8 import org.jdom.Element;
    9 import org.jdom.JDOMException;
    10 import org.jdom.Namespace;
    11 import org.jdom.input.SAXBuilder;
    129import org.openstreetmap.josm.data.coor.LatLon;
    1310import org.openstreetmap.josm.gui.layer.RawGpsLayer.GpsPoint;
     11import org.xml.sax.Attributes;
     12import org.xml.sax.SAXException;
     13
     14import uk.co.wilson.xml.MinML2;
    1415
    1516/**
     
    2021public class RawGpsReader {
    2122
    22         /**
    23          * The data source from this reader.
    24          */
    25         public Reader source;
    26        
    27         /**
    28          * Construct a gps reader from an input reader source.
    29          * @param source The source to read the raw gps data from. The data must be
    30          *              in GPX format.
    31          */
    32         public RawGpsReader(Reader source) {
    33                 this.source = source;
     23        private static class Parser extends MinML2 {
     24                /**
     25                 * Current track to be read. The last entry is the current trkpt.
     26                 * If in wpt-mode, it contain only one GpsPoint.
     27                 */
     28                private Collection<GpsPoint> current = new LinkedList<GpsPoint>();
     29                public Collection<Collection<GpsPoint>> data = new LinkedList<Collection<GpsPoint>>();
     30                private LatLon currentLatLon;
     31                private String currentTime;
     32
     33                @Override public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
     34                        if (qName.equals("wpt") || qName.equals("trkpt")) {
     35                                try {
     36                        double lat = Double.parseDouble(atts.getValue("lat"));
     37                        double lon = Double.parseDouble(atts.getValue("lon"));
     38                                if (Math.abs(lat) > 90)
     39                                        throw new SAXException("Data error: lat value '"+lat+"' is out of bound.");
     40                                if (Math.abs(lon) > 180)
     41                                        throw new SAXException("Data error: lon value '"+lon+"' is out of bound.");
     42                        currentLatLon = new LatLon(lat, lon);
     43                } catch (NumberFormatException e) {
     44                        e.printStackTrace();
     45                        throw new SAXException(e);
     46                }
     47                        } else if (qName.equals("time")) {
     48                                currentTime = "";
     49                        }
     50                }
     51
     52                @Override public void characters(char[] ch, int start, int length) {
     53                        if (currentTime != null && currentTime.equals(""))
     54                                currentTime = new String(ch, start, length);
     55                }
     56
     57                @Override public void endElement(String namespaceURI, String localName, String qName) {
     58                        if (qName.equals("wpt") || qName.equals("trkpt")) {
     59                                current.add(new GpsPoint(currentLatLon, currentTime));
     60                        } else if (qName.equals("trkseg") || qName.equals("trk") || qName.equals("gpx"))
     61                                newTrack();
     62        }
     63
     64                private void newTrack() {
     65                        if (!current.isEmpty()) {
     66                                data.add(current);
     67                                current = new LinkedList<GpsPoint>();
     68                        }
     69                }
    3470        }
    3571
    3672        /**
    37          * The gpx namespace.
    38          */
    39         private Namespace GPX = Namespace.getNamespace("http://www.topografix.com/GPX/1/0");
    40        
    41         /**
    4273         * Parse and return the read data
    4374         */
    44         public Collection<Collection<GpsPoint>> parse() throws JDOMException, IOException {
    45                 final SAXBuilder builder = new SAXBuilder();
    46                 builder.setValidation(false);
    47                 Element root = builder.build(source).getRootElement();
    48                 return parseData(root);
    49         }
    50 
    51         /**
    52          * Parse and return the whole data thing.
    53          * @param root
    54          * @return
    55          */
    56         @SuppressWarnings("unchecked")
    57         private Collection<Collection<GpsPoint>> parseData(Element root) throws JDOMException {
    58                 Collection<Collection<GpsPoint>> data = new LinkedList<Collection<GpsPoint>>();
    59 
    60                 // workaround for bug where the server adds /gpx.asd to the namespace
    61                 GPX = Namespace.getNamespace(root.getNamespaceURI());
    62                
    63                 for (Object o : root.getChildren("wpt", GPX)) {
    64                         Collection<GpsPoint> line = new LinkedList<GpsPoint>();
    65                         line.add(new GpsPoint(
    66                                         new LatLon(parseDouble((Element)o, LatLonAttr.lat), parseDouble((Element)o, LatLonAttr.lon)),
    67                                         ((Element)o).getChildText("time", GPX)));
    68                         data.add(line);
    69                 }
    70                 for (Object o : root.getChildren("trk", GPX)) {
    71                         for (Object seg : ((Element)o).getChildren("trkseg", GPX)) {
    72                                 Collection<GpsPoint> data1 = new LinkedList<GpsPoint>();
    73                                 for (Object trkObj : ((Element)seg).getChildren("trkpt", GPX)) {
    74                                         data1.add(new GpsPoint(
    75                                                         new LatLon(parseDouble((Element)trkObj, LatLonAttr.lat), parseDouble((Element)trkObj, LatLonAttr.lon)),
    76                                                         ((Element)trkObj).getChildText("time", GPX)));
    77                                 }
    78                                 Collection<GpsPoint> line = data1;
    79                                 if (!line.isEmpty())
    80                                         data.add(line);
    81                         }
    82                 }
    83                 return data;
    84         }
    85 
    86         private enum LatLonAttr {lat, lon}
    87         /**
    88          * Return a parsed float value from the element behind the object o.
    89          * @param o An object of dynamic type org.jdom.Element (will be casted).
    90          * @param attr The name of the attribute.
    91          * @throws JDOMException If the absolute of the value is out of bound.
    92          */
    93         private double parseDouble(Element e, LatLonAttr attr) throws JDOMException {
    94                 double d = Double.parseDouble(e.getAttributeValue(attr.toString()));
    95                 if (Math.abs(d) > (attr == LatLonAttr.lat ? 90 : 180))
    96                         throw new JDOMException("Data error: "+attr+" value '"+d+"' is out of bound.");
    97                 return d;
     75        public static Collection<Collection<GpsPoint>> parse(InputStream source) throws SAXException, IOException {
     76                Parser parser = new Parser();
     77                parser.parse(new InputStreamReader(source, "UTF-8"));
     78                return parser.data;
    9879        }
    9980}
  • src/org/openstreetmap/josm/tools/BugReportExceptionHandler.java

    r98 r103  
    2929                e.printStackTrace();
    3030                if (Main.parent != null) {
     31                        if (e instanceof OutOfMemoryError) {
     32                                JOptionPane.showMessageDialog(Main.parent, "You are out of memory. Strange things may happen.\nPlease restart JOSM and load smaller data sets.");
     33                                return;
     34                        }
     35                       
    3136                        Object[] options = new String[]{"Do nothing", "Report Bug"};
    3237                        int answer = JOptionPane.showOptionDialog(Main.parent, "An unexpected exception occoured.\n\n" +
Note: See TracChangeset for help on using the changeset viewer.