Changeset 15 in josm for src/org/openstreetmap/josm


Ignore:
Timestamp:
2005-10-07T01:13:49+02:00 (15 years ago)
Author:
imi
Message:

renamed alot (Layer instead of MapView) and removed feature of having
projections on every Layer.

Location:
src/org/openstreetmap/josm
Files:
1 added
27 edited
1 moved

Legend:

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

    r12 r15  
    1515import org.openstreetmap.josm.data.osm.DataSet;
    1616import org.openstreetmap.josm.gui.Main;
    17 import org.openstreetmap.josm.gui.MapFrame;
    1817import org.openstreetmap.josm.io.GpxReader;
    1918import org.openstreetmap.josm.io.DataReader.ConnectionException;
     
    5554                try {
    5655                        DataSet dataSet = new GpxReader(new FileReader(gpxFile)).parse();
    57                         MapFrame map = new MapFrame(dataSet);
    58                         Main.main.setMapFrame(gpxFile.getName(), map);
     56                        Main.main.setMapFrame(gpxFile.getName(), dataSet);
    5957                } catch (ParseException x) {
    6058                        x.printStackTrace();
  • src/org/openstreetmap/josm/actions/SaveGpxAction.java

    r11 r15  
    4646                try {
    4747                        FileWriter fileWriter = new FileWriter(gpxFile);
    48                         GpxWriter out = new GpxWriter(fileWriter, Main.main.getMapFrame().mapView.dataSet);
     48                        GpxWriter out = new GpxWriter(fileWriter, Main.main.getMapFrame().layer.dataSet);
    4949                        out.output();
    5050                        fileWriter.close();
  • src/org/openstreetmap/josm/actions/mapmode/AddLineSegmentAction.java

    r8 r15  
    5959        public void registerListener() {
    6060                super.registerListener();
    61                 mv.addMouseListener(this);
    62                 mv.addMouseMotionListener(this);
     61                layer.addMouseListener(this);
     62                layer.addMouseMotionListener(this);
    6363        }
    6464
     
    6666        public void unregisterListener() {
    6767                super.unregisterListener();
    68                 mv.removeMouseListener(this);
    69                 mv.removeMouseMotionListener(this);
     68                layer.removeMouseListener(this);
     69                layer.removeMouseMotionListener(this);
    7070                drawHint(false);
    7171        }
     
    7979                        return;
    8080
    81                 OsmPrimitive clicked = mv.getNearest(e.getPoint(), false);
     81                OsmPrimitive clicked = layer.getNearest(e.getPoint(), false);
    8282                if (clicked == null || !(clicked instanceof Node))
    8383                        return;
     
    9696                        return;
    9797
    98                 OsmPrimitive clicked = mv.getNearest(e.getPoint(), (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) != 0);
     98                OsmPrimitive clicked = layer.getNearest(e.getPoint(), (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) != 0);
    9999                if (clicked == null || clicked == second || !(clicked instanceof Node))
    100100                        return;
     
    161161                }
    162162               
    163                 mv.repaint();
     163                layer.repaint();
    164164        }
    165165
     
    175175                        return;
    176176
    177                 Graphics g = mv.getGraphics();
     177                Graphics g = layer.getGraphics();
    178178                g.setColor(Color.BLACK);
    179179                g.setXORMode(Color.WHITE);
    180                 Point firstDrawn = mv.getScreenPoint(first.coor);
    181                 Point secondDrawn = mv.getScreenPoint(second.coor);
     180                Point firstDrawn = layer.getScreenPoint(first.coor);
     181                Point secondDrawn = layer.getScreenPoint(second.coor);
    182182                g.drawLine(firstDrawn.x, firstDrawn.y, secondDrawn.x, secondDrawn.y);
    183183                hintDrawn = !hintDrawn;
  • src/org/openstreetmap/josm/actions/mapmode/AddNodeAction.java

    r7 r15  
    3030        public void registerListener() {
    3131                super.registerListener();
    32                 mv.addMouseListener(this);
     32                layer.addMouseListener(this);
    3333        }
    3434
     
    3636        public void unregisterListener() {
    3737                super.unregisterListener();
    38                 mv.removeMouseListener(this);
     38                layer.removeMouseListener(this);
    3939        }
    4040
     
    4747                if (e.getButton() == MouseEvent.BUTTON1) {
    4848                        Node node = new Node();
    49                         node.coor = mv.getPoint(e.getX(), e.getY(), true);
     49                        node.coor = layer.getPoint(e.getX(), e.getY(), true);
    5050                        ds.nodes.add(node);
    51                         mv.repaint();
     51                        layer.repaint();
    5252                }
    5353        }
  • src/org/openstreetmap/josm/actions/mapmode/AddTrackAction.java

    r8 r15  
    4343        public AddTrackAction(MapFrame mapFrame) {
    4444                super("Add Track", "addtrack", "Combine line segments to a new track.", KeyEvent.VK_T, mapFrame);
    45                 this.selectionManager = new SelectionManager(this, false, mv);
     45                this.selectionManager = new SelectionManager(this, false, layer);
    4646        }
    4747
     
    4949        public void registerListener() {
    5050                super.registerListener();
    51                 selectionManager.register(mv);
     51                selectionManager.register(layer);
    5252        }
    5353
     
    5555        public void unregisterListener() {
    5656                super.unregisterListener();
    57                 selectionManager.unregister(mv);
     57                selectionManager.unregister(layer);
    5858        }
    5959
     
    8282                        osm.setSelected(!ctrl, ds);
    8383
    84                 mv.repaint(); // from now on, the map has to be repainted.
     84                layer.repaint(); // from now on, the map has to be repainted.
    8585
    8686                if (ctrl || shift)
  • src/org/openstreetmap/josm/actions/mapmode/CombineAction.java

    r8 r15  
    8080        public void registerListener() {
    8181                super.registerListener();
    82                 mv.addMouseListener(this);
    83                 mv.addMouseMotionListener(this);
     82                layer.addMouseListener(this);
     83                layer.addMouseMotionListener(this);
    8484                ds.clearSelection();
    8585        }
     
    8888        public void unregisterListener() {
    8989                super.unregisterListener();
    90                 mv.removeMouseListener(this);
    91                 mv.removeMouseMotionListener(this);
     90                layer.removeMouseListener(this);
     91                layer.removeMouseMotionListener(this);
    9292                drawCombineHint(false);
    9393        }
     
    103103                        return;
    104104
    105                 OsmPrimitive clicked = mv.getNearest(e.getPoint(), true);
     105                OsmPrimitive clicked = layer.getNearest(e.getPoint(), true);
    106106                if (clicked == null || clicked instanceof Node)
    107107                        return;
     
    119119                        return;
    120120               
    121                 OsmPrimitive clicked = mv.getNearest(e.getPoint(), true);
     121                OsmPrimitive clicked = layer.getNearest(e.getPoint(), true);
    122122                if (clicked == null || clicked == second || clicked instanceof Node)
    123123                        return;
     
    168168                        }
    169169                }
    170                 mv.repaint();
     170                layer.repaint();
    171171        }
    172172
     
    198198                        return;
    199199
    200                 Graphics g = mv.getGraphics();
     200                Graphics g = layer.getGraphics();
    201201                g.setColor(Color.BLACK);
    202202                g.setXORMode(Color.WHITE);
     
    214214                if (osm instanceof LineSegment) {
    215215                        LineSegment ls = (LineSegment)osm;
    216                         Point start = mv.getScreenPoint(ls.getStart().coor);
    217                         Point end = mv.getScreenPoint(ls.getEnd().coor);
    218                         if (mv.dataSet.pendingLineSegments().contains(osm) && g.getColor() == Color.GRAY)
     216                        Point start = layer.getScreenPoint(ls.getStart().coor);
     217                        Point end = layer.getScreenPoint(ls.getEnd().coor);
     218                        if (layer.dataSet.pendingLineSegments().contains(osm) && g.getColor() == Color.GRAY)
    219219                                g.drawLine(start.x, start.y, end.x, end.y);
    220220                        else
  • src/org/openstreetmap/josm/actions/mapmode/DebugAction.java

    r8 r15  
    3131        public void registerListener() {
    3232                super.registerListener();
    33                 mv.addMouseMotionListener(this);
    34                 mv.addMouseListener(this);
     33                layer.addMouseMotionListener(this);
     34                layer.addMouseListener(this);
    3535                mapFrame.add(label, BorderLayout.SOUTH);
    3636        }
     
    3939        public void unregisterListener() {
    4040                super.unregisterListener();
    41                 mv.removeMouseMotionListener(this);
    42                 mv.removeMouseListener(this);
     41                layer.removeMouseMotionListener(this);
     42                layer.removeMouseListener(this);
    4343                mapFrame.remove(label);
    4444        }
     
    4646        @Override
    4747        public void mouseClicked(MouseEvent e) {
    48                 Graphics g = mapFrame.mapView.getGraphics();
     48                Graphics g = mapFrame.layer.getGraphics();
    4949                g.setColor(Color.WHITE);
    50                 for (Track t :mapFrame.mapView.dataSet.tracks())
     50                for (Track t :mapFrame.layer.dataSet.tracks())
    5151                        for (LineSegment ls : t.segments()) {
    52                                 Point A = mapFrame.mapView.getScreenPoint(ls.getStart().coor);
    53                                 Point B = mapFrame.mapView.getScreenPoint(ls.getEnd().coor);
     52                                Point A = mapFrame.layer.getScreenPoint(ls.getStart().coor);
     53                                Point B = mapFrame.layer.getScreenPoint(ls.getEnd().coor);
    5454                                Point C = e.getPoint();
    5555                                Rectangle r = new Rectangle(A.x, A.y, B.x-A.x, B.y-A.y);
  • src/org/openstreetmap/josm/actions/mapmode/DeleteAction.java

    r8 r15  
    7171        public void registerListener() {
    7272                super.registerListener();
    73                 mv.addMouseListener(this);
     73                layer.addMouseListener(this);
    7474        }
    7575
     
    7777        public void unregisterListener() {
    7878                super.unregisterListener();
    79                 mv.removeMouseListener(this);
     79                layer.removeMouseListener(this);
    8080        }
    8181
     
    8989                        return;
    9090               
    91                 OsmPrimitive sel = mv.getNearest(e.getPoint(), (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) != 0);
     91                OsmPrimitive sel = layer.getNearest(e.getPoint(), (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) != 0);
    9292                if (sel == null)
    9393                        return;
     
    9898                        delete(sel);
    9999
    100                 mv.repaint();
     100                layer.repaint();
    101101        }
    102102
  • src/org/openstreetmap/josm/actions/mapmode/MapMode.java

    r11 r15  
    1414import org.openstreetmap.josm.gui.Main;
    1515import org.openstreetmap.josm.gui.MapFrame;
    16 import org.openstreetmap.josm.gui.MapView;
     16import org.openstreetmap.josm.gui.Layer;
    1717
    1818/**
     
    3131        protected final MapFrame mapFrame;
    3232        /**
    33          * Shortcut to the MapView.
     33         * Shortcut to the Layer.
    3434         */
    35         protected final MapView mv;
     35        protected final Layer layer;
    3636        /**
    3737         * Shortcut to the DataSet.
     
    5353                mapFrame.getActionMap().put(this, this);
    5454                this.mapFrame = mapFrame;
    55                 mv = mapFrame.mapView;
    56                 ds = mv.dataSet;
     55                layer = mapFrame.layer;
     56                ds = layer.dataSet;
    5757        }
    5858       
    5959        /**
    60          * Register all listener to the mapView
    61          * @param mapView       The view, where the listener should be registered.
     60         * Register all listener to the layer
    6261         */
    6362        public void registerListener() {
     
    6766        /**
    6867         * Unregister all listener previously registered.
    69          * @param mapView       The view from which the listener should be deregistered.
    7068         */
    7169        public void unregisterListener() {
  • src/org/openstreetmap/josm/actions/mapmode/MoveAction.java

    r8 r15  
    4848        public void registerListener() {
    4949                super.registerListener();
    50                 mv.addMouseListener(this);
    51                 mv.addMouseMotionListener(this);
     50                layer.addMouseListener(this);
     51                layer.addMouseMotionListener(this);
    5252        }
    5353
     
    5555        public void unregisterListener() {
    5656                super.unregisterListener();
    57                 mv.removeMouseListener(this);
    58                 mv.removeMouseMotionListener(this);
     57                layer.removeMouseListener(this);
     58                layer.removeMouseMotionListener(this);
    5959        }
    6060
     
    8686
    8787                for (Node n : movingNodes) {
    88                         Point pos = mv.getScreenPoint(n.coor);
     88                        Point pos = layer.getScreenPoint(n.coor);
    8989                        pos.x += dx;
    9090                        pos.y += dy;
    91                         n.coor = mv.getPoint(pos.x, pos.y, true);
     91                        n.coor = layer.getPoint(pos.x, pos.y, true);
    9292                }
    93                 mv.repaint();
     93                layer.repaint();
    9494               
    9595                mousePos = e.getPoint();
     
    111111
    112112                if (ds.getSelected().size() == 0) {
    113                         OsmPrimitive osm = mv.getNearest(e.getPoint(), (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) != 0);
     113                        OsmPrimitive osm = layer.getNearest(e.getPoint(), (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) != 0);
    114114                        if (osm != null)
    115115                                osm.setSelected(true, ds);
    116116                        singleOsmPrimitive = osm;
    117                         mv.repaint();
     117                        layer.repaint();
    118118                } else
    119119                        singleOsmPrimitive = null;
    120120               
    121121                mousePos = e.getPoint();
    122                 oldCursor = mv.getCursor();
    123                 mv.setCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
     122                oldCursor = layer.getCursor();
     123                layer.setCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
    124124        }
    125125       
     
    129129        @Override
    130130        public void mouseReleased(MouseEvent e) {
    131                 mv.setCursor(oldCursor);
     131                layer.setCursor(oldCursor);
    132132                if (singleOsmPrimitive != null) {
    133133                        singleOsmPrimitive.setSelected(false, ds);
    134                         mv.repaint();
     134                        layer.repaint();
    135135                }
    136136        }
  • src/org/openstreetmap/josm/actions/mapmode/SelectionAction.java

    r8 r15  
    4646 * and the user clicked in or 10 pixel away from an area, this area is selected.
    4747 * If there is even no area, nothing is selected. Shift and Ctrl key applies to
    48  * this as usual. For more, @see MapView#getNearest(Point, boolean)
     48 * this as usual. For more, @see Layer#getNearest(Point, boolean)
    4949 *
    5050 * @author imi
     
    6363        public SelectionAction(MapFrame mapFrame) {
    6464                super("Selection", "selection", "Select objects by dragging or clicking", KeyEvent.VK_S, mapFrame);
    65                 this.selectionManager = new SelectionManager(this, false, mv);
     65                this.selectionManager = new SelectionManager(this, false, layer);
    6666        }
    6767
     
    6969        public void registerListener() {
    7070                super.registerListener();
    71                 selectionManager.register(mv);
     71                selectionManager.register(layer);
    7272        }
    7373
     
    7575        public void unregisterListener() {
    7676                super.unregisterListener();
    77                 selectionManager.unregister(mv);
     77                selectionManager.unregister(layer);
    7878        }
    7979
     
    9292                for (OsmPrimitive osm : selectionList)
    9393                        osm.setSelected(!ctrl, ds);
    94                 mv.repaint();
     94                layer.repaint();
    9595        }
    9696}
  • src/org/openstreetmap/josm/actions/mapmode/ZoomAction.java

    r7 r15  
    66import org.openstreetmap.josm.data.GeoPoint;
    77import org.openstreetmap.josm.gui.MapFrame;
    8 import org.openstreetmap.josm.gui.MapView;
     8import org.openstreetmap.josm.gui.Layer;
    99import org.openstreetmap.josm.gui.SelectionManager;
    1010import org.openstreetmap.josm.gui.SelectionManager.SelectionEnded;
     
    1414 *
    1515 * Holding down the left mouse button select a rectangle with the same aspect
    16  * ratio than the current map view.
     16 * ratio than the current layer.
    1717 * Holding down left and right let the user move the former selected rectangle.
    1818 * Releasing the left button zoom to the selection.
     
    2828         * Shortcut to the mapview.
    2929         */
    30         private final MapView mv;
     30        private final Layer mv;
    3131        /**
    3232         * Manager that manages the selection rectangle with the aspect ratio of the
    33          * MapView.
     33         * Layer.
    3434         */
    3535        private final SelectionManager selectionManager;
     
    4242        public ZoomAction(MapFrame mapFrame) {
    4343                super("Zoom", "zoom", "Zoom in by dragging", KeyEvent.VK_Z, mapFrame);
    44                 mv = mapFrame.mapView;
     44                mv = mapFrame.layer;
    4545                selectionManager = new SelectionManager(this, true, mv);
    4646        }
  • src/org/openstreetmap/josm/data/Preferences.java

    r6 r15  
    11package org.openstreetmap.josm.data;
    22
     3import java.beans.PropertyChangeEvent;
     4import java.beans.PropertyChangeListener;
    35import java.io.File;
    46import java.io.FileReader;
    57import java.io.FileWriter;
     8import java.util.LinkedList;
    69import java.util.List;
    710
     
    2528public class Preferences {
    2629
     30       
    2731        /**
    2832         * The look and feel. Classname of the look and feel class to use.
    2933         */
    30         public LookAndFeelInfo laf = UIManager.getInstalledLookAndFeels()[0];
    31 
     34        private LookAndFeelInfo laf = UIManager.getInstalledLookAndFeels()[0];
    3235        /**
    3336         * The convertor used to translate lat/lon points to screen points.
    3437         */
    35         public Projection projection = new UTM();
     38        private Projection projection = new UTM();
     39        /**
     40         * Whether nodes on the same place should be considered identical.
     41         */
     42        private boolean mergeNodes = true;
     43
    3644
    3745
    3846        /**
    39          * Whether nodes on the same place should be considered identical.
     47         * Exception thrown in case of any loading/saving error (including parse errors).
     48         * @author imi
    4049         */
    41         public boolean mergeNodes = true;
    42        
    43        
     50        public static class PreferencesException extends Exception {
     51                public PreferencesException(String message, Throwable cause) {
     52                        super(message, cause);
     53                }
     54        }
    4455
    4556        /**
     
    5162        };
    5263
     64
     65
     66
     67        // listener stuff
     68       
     69        /**
     70         * The event listener list
     71         */
     72        private List<PropertyChangeListener> listener = new LinkedList<PropertyChangeListener>();
     73        /**
     74         * If <code>listener != null</code>, add it to the listener list.
     75         */
     76        public void addPropertyChangeListener(PropertyChangeListener listener) {
     77                if (listener != null)
     78                        this.listener.add(listener);
     79        }
     80        /**
     81         * If <code>listener != null</code>, remove it from the listener list.
     82         */
     83        public void removePropertyChangeListener(PropertyChangeListener listener) {
     84                if (listener != null)
     85                        this.listener.remove(listener);
     86        }
     87        /**
     88         * Fires an event that the property has changed.
     89         */
     90        private void firePropertyChanged(String propName, Object oldValue, Object newValue) {
     91                PropertyChangeEvent event = null;
     92                for (PropertyChangeListener l : listener) {
     93                        if (event == null)
     94                                event = new PropertyChangeEvent(this, propName, oldValue, newValue);
     95                        l.propertyChange(event);
     96                }
     97        }
     98
     99       
     100       
    53101        /**
    54102         * Return the location of the preferences file
     
    58106        }
    59107       
    60         /**
    61          * Exception thrown in case of any loading/saving error (including parse errors).
    62          * @author imi
    63          */
    64         public static class PreferencesException extends Exception {
    65                 public PreferencesException(String message, Throwable cause) {
    66                         super(message, cause);
    67                 }
    68         }
    69108        /**
    70109         * Load from disk.
     
    81120                        for (LookAndFeelInfo lafInfo : UIManager.getInstalledLookAndFeels())
    82121                                if (lafInfo.getClassName().equals(lafClassName)) {
    83                                         laf = lafInfo;
     122                                        setLaf(lafInfo);
    84123                                        break;
    85124                                }
    86                         if (laf == null)
     125                        if (getLaf() == null)
    87126                                throw new PreferencesException("Look and Feel not found.", null);
    88                        
    89                         projection = (Projection)Class.forName(root.getChildText("projection")).newInstance();
    90                         mergeNodes = root.getChild("mergeNodes") != null;
     127
     128                        // set projection
     129                        Class<?> projectionClass = Class.forName(root.getChildText("projection"));
     130                        projection = allProjections[0]; // defaults to UTM
     131                        for (Projection p : allProjections) {
     132                                if (p.getClass() == projectionClass) {
     133                                        projection = p;
     134                                        break;
     135                                }
     136                        }
     137
     138                        setMergeNodes(root.getChild("mergeNodes") != null);
    91139                } catch (Exception e) {
    92140                        if (e instanceof PreferencesException)
     
    105153               
    106154                List children = root.getChildren();
    107                 children.add(new Element("laf").setText(laf.getClassName()));
    108                 children.add(new Element("projection").setText(projection.getClass().getName()));
    109                 if (mergeNodes)
     155                children.add(new Element("laf").setText(getLaf().getClassName()));
     156                children.add(new Element("projection").setText(getProjection().getClass().getName()));
     157                if (isMergeNodes())
    110158                        children.add(new Element("mergeNodes"));
    111159
     
    118166                }
    119167        }
     168
     169        // getter / setter
     170
     171        public void setProjection(Projection projection) {
     172                Projection old = this.projection;
     173                this.projection = projection;
     174                firePropertyChanged("projection", old, projection);
     175        }
     176        public Projection getProjection() {
     177                return projection;
     178        }
     179        public void setMergeNodes(boolean mergeNodes) {
     180                boolean old = this.mergeNodes;
     181                this.mergeNodes = mergeNodes;
     182                firePropertyChanged("mergeNodes", old, mergeNodes);
     183        }
     184        public boolean isMergeNodes() {
     185                return mergeNodes;
     186        }
     187        public void setLaf(LookAndFeelInfo laf) {
     188                LookAndFeelInfo old = this.laf;
     189                this.laf = laf;
     190                firePropertyChanged("laf", old, laf);
     191        }
     192        public LookAndFeelInfo getLaf() {
     193                return laf;
     194        }
    120195}
  • src/org/openstreetmap/josm/data/osm/DataSet.java

    r8 r15  
    113113                Node first = nodes.iterator().next();
    114114                Bounds b = new Bounds(first.coor.clone(), first.coor.clone());
    115                 for (Node w : nodes)
     115                for (Node n : nodes)
    116116                {
    117                         if (Double.isNaN(w.coor.x) || Double.isNaN(w.coor.y))
     117                        if (Double.isNaN(n.coor.x) || Double.isNaN(n.coor.y))
    118118                                return null;
    119                         if (w.coor.x < b.min.x)
    120                                 b.min.x = w.coor.x;
    121                         if (w.coor.y < b.min.y)
    122                                 b.min.y = w.coor.y;
    123                         if (w.coor.x > b.max.x)
    124                                 b.max.x = w.coor.x;
    125                         if (w.coor.y > b.max.y)
    126                                 b.max.y = w.coor.y;
     119                        if (n.coor.x < b.min.x)
     120                                b.min.x = n.coor.x;
     121                        if (n.coor.y < b.min.y)
     122                                b.min.y = n.coor.y;
     123                        if (n.coor.x > b.max.x)
     124                                b.max.x = n.coor.x;
     125                        if (n.coor.y > b.max.y)
     126                                b.max.y = n.coor.y;
    127127                }
    128128                return b;
  • src/org/openstreetmap/josm/data/projection/Projection.java

    r7 r15  
    1010import org.openstreetmap.josm.data.GeoPoint;
    1111import org.openstreetmap.josm.data.osm.DataSet;
    12 import org.openstreetmap.josm.data.osm.Node;
    1312
    1413/**
     
    6665         */
    6766        abstract public JComponent getConfigurationPanel();
    68        
     67
    6968        /**
    7069         * Initialize itself with the given dataSet.
    7170         *
    7271         * This function should initialize own parameters needed to do the
    73          * projection and then initialize every Node of the dataset with x/y
    74          * projection values.
     72         * projection at best effort.
    7573         *
    76          * This implementation loops through the dataset's nodes and call latlon2xy
    77          * for each member. Subclasses can call this to initialize the dataset.
    78          * 
    79          * init must not fire an state changed event, since it is usually called
    80          * from the event handler.
     74         * Init must not fire an state changed event, since it is usually called
     75         * during the initialization of the mapFrame.
     76         *
     77         * This implementation does nothing. It is provided only for subclasses
     78         * to initialize their data members.
    8179         *
    8280         * @param dataSet
     
    8886         *            is far away from any coordinate in the dataset)
    8987         */
    90         public void init(DataSet dataSet) {
    91                 for (Node w : dataSet.nodes)
    92                         latlon2xy(w.coor);
    93         }
    94        
    95         /**
    96          * All projections support cloning.
    97          */
    98         @Override
    99         public Projection clone() {
    100                 try {return (Projection)super.clone();} catch (CloneNotSupportedException e) {}
    101                 return null;
    102         }
     88        public void init(DataSet dataSet) {}
    10389       
    10490        /**
  • src/org/openstreetmap/josm/data/projection/UTM.java

    r6 r15  
    210210                        hemisphere = lat > 0 ? Hemisphere.north : Hemisphere.south;
    211211                }
    212                 super.init(dataSet);
    213212        }
    214213
  • src/org/openstreetmap/josm/gui/Layer.java

    r14 r15  
    33import java.awt.Graphics;
    44import java.awt.Point;
    5 import java.awt.event.ActionEvent;
    65import java.awt.event.ComponentEvent;
    76import java.awt.event.ComponentListener;
    8 import java.awt.event.KeyEvent;
    9 
    10 import javax.swing.AbstractAction;
    11 import javax.swing.ImageIcon;
     7import java.beans.PropertyChangeEvent;
     8import java.beans.PropertyChangeListener;
     9
    1210import javax.swing.JComponent;
    1311import javax.swing.event.ChangeEvent;
     
    2725/**
    2826 * This is a component used in the MapFrame for browsing the map. It use is to
    29  * provide the MapMode's enough capabilities to operate. 
     27 * provide the MapMode's enough capabilities to operate.
    3028 *
    31  * MapView holds the map data, organize it, convert it, provide access to it.
     29 * Layer holds one dataset. There can be more than one Layer active.
    3230 *
    33  * MapView hold meta-data about the data set currently displayed, as scale level,
    34  * center point viewed, what scrolling mode or editing mode is selected or with
    35  * what projection the map is viewed etc..
    36  *
     31 * Layer hold data of the current displayed graphics as scale level and
     32 * center point view.
     33 *
    3734 * @author imi
    3835 */
    39 public class MapView extends JComponent implements ComponentListener, ChangeListener {
    40 
    41         /**
    42          * Toggles the autoScale feature of the mapView
    43          * @author imi
    44          */
    45         public class AutoScaleAction extends AbstractAction {
    46                 public AutoScaleAction() {
    47                         super("Auto Scale", new ImageIcon(Main.class.getResource("/images/autoscale.png")));
    48                         putValue(MNEMONIC_KEY, KeyEvent.VK_A);
    49                 }
    50                 public void actionPerformed(ActionEvent e) {
    51                         autoScale = !autoScale;
    52                         recalculateCenterScale();
    53                 }
    54         }
     36public class Layer extends JComponent implements ComponentListener, ChangeListener, PropertyChangeListener {
    5537
    5638        /**
     
    6951
    7052        /**
    71          * Used projection method in this map
    72          */
    73         private Projection projection = Main.pref.projection.clone();
    74 
    75         /**
    7653         * The underlying DataSet.
    7754         */
     
    8461       
    8562        /**
    86          * Construct a MapView.
    87          */
    88         public MapView(DataSet dataSet) {
     63         * Construct a Layer.
     64         */
     65        public Layer(DataSet dataSet) {
    8966                this.dataSet = dataSet;
    9067                addComponentListener(this);
     
    9370                new MapMover(this);
    9471
    95                 // initialize the projection
    96                 setProjection(Main.pref.projection.clone());
    97 
    9872                // initialize the drawing engine
    9973                engine = new SimpleEngine(this);
     74               
     75                // initialize on the preferences for projection changes.
     76                Main.pref.addPropertyChangeListener(this);
    10077        }
    10178
     
    12097                p.y = (getHeight()/2.0 - y)*scale + center.y;
    12198                if (latlon)
    122                         getProjection().xy2latlon(p);
     99                        Main.pref.getProjection().xy2latlon(p);
    123100                return p;
    124101        }
     
    138115                                throw new IllegalArgumentException("point: Either lat/lon or x/y must be set.");
    139116                        p = point.clone();
    140                         projection.latlon2xy(p);
     117                        Main.pref.getProjection().latlon2xy(p);
    141118                }
    142119                int x = ((int)Math.round((p.x-center.x) / scale + getWidth()/2));
     
    236213                autoScale = false;
    237214                center = newCenter.clone();
    238                 projection.xy2latlon(center);
     215                Main.pref.getProjection().xy2latlon(center);
    239216                this.scale = scale;
    240217                recalculateCenterScale();
     
    268245         */
    269246        public void stateChanged(ChangeEvent e) {
    270                 projection.init(dataSet);
    271                 recalculateCenterScale();
    272         }
    273 
    274         /**
    275          * Set a new projection method. This call is not cheap, as it will
    276          * transform the whole underlying dataSet and repaint itself.
    277          *
    278          * @param projection The new projection method to set.
    279          */
    280         public void setProjection(Projection projection) {
    281                 if (projection == this.projection)
    282                         return;
    283 
    284                 Projection oldProjection = this.projection;
    285                
    286                 if (this.projection != null)
    287                         this.projection.removeChangeListener(this);
    288                 this.projection = projection;
    289                 projection.addChangeListener(this);
    290                
    291                 stateChanged(new ChangeEvent(this));
    292                 firePropertyChange("projection", oldProjection, projection);
    293         }
    294 
    295         /**
    296          * Return the projection method for this map view.
    297          * @return The projection method.
    298          */
    299         public Projection getProjection() {
    300                 return projection;
     247                initDataSet();
     248        }
     249
     250        /**
     251         * Called when a property, as example the projection of the Main preferences
     252         * changes.
     253         */
     254        public void propertyChange(PropertyChangeEvent evt) {
     255                if (evt.getPropertyName().equals("projection")) {
     256                        Projection oldProjection = (Projection)evt.getOldValue();
     257                        if (oldProjection != null)
     258                                oldProjection.removeChangeListener(this);
     259
     260                        Projection newProjection = (Projection)evt.getNewValue();
     261                        if (newProjection != null)
     262                                newProjection.addChangeListener(this);
     263
     264                        initDataSet();
     265                }
    301266        }
    302267
     
    322287                if (this.autoScale != autoScale) {
    323288                        this.autoScale = autoScale;
     289                        if (autoScale)
     290                                recalculateCenterScale();
    324291                        firePropertyChange("autoScale", !autoScale, autoScale);
    325292                }
     
    333300        }
    334301
     302        /**
     303         * Initialize the DataSet with the projection taken from the preference
     304         * settings.
     305         */
     306        public void initDataSet() {
     307                for (Node n : dataSet.nodes)
     308                        Main.pref.getProjection().latlon2xy(n.coor);
     309                recalculateCenterScale();
     310        }
    335311       
    336312       
     
    357333                                // no bounds means standard scale and center
    358334                                center = new GeoPoint(51.526447, -0.14746371);
    359                                 getProjection().latlon2xy(center);
     335                                Main.pref.getProjection().latlon2xy(center);
    360336                                scale = 10;
    361337                        } else {
    362338                                center = bounds.centerXY();
    363                                 getProjection().xy2latlon(center);
     339                                Main.pref.getProjection().xy2latlon(center);
    364340                                double scaleX = (bounds.max.x-bounds.min.x)/w;
    365341                                double scaleY = (bounds.max.y-bounds.min.y)/h;
  • src/org/openstreetmap/josm/gui/Main.java

    r9 r15  
    1919import org.openstreetmap.josm.data.Preferences;
    2020import org.openstreetmap.josm.data.Preferences.PreferencesException;
     21import org.openstreetmap.josm.data.osm.DataSet;
     22import org.openstreetmap.josm.data.projection.Projection;
    2123
    2224/**
     
    119121               
    120122                try {
    121                         UIManager.setLookAndFeel(pref.laf.getClassName());
     123                        UIManager.setLookAndFeel(pref.getLaf().getClassName());
    122124                } catch (Exception e) {
    123125                        e.printStackTrace();
     
    131133
    132134        /**
    133          * Set the main's mapframe. If a changed old mapFrame is already set,
    134          * ask the user whether he want to save, discard or abort. If the user
     135         * Create and set the main's mapframe. If a changed old mapFrame is already
     136         * set, ask the user whether he want to save, discard or abort. If the user
    135137         * aborts, nothing happens.
    136138         */
    137         public void setMapFrame(String name, MapFrame mapFrame) {
     139        public void setMapFrame(String name, DataSet dataSet) {
    138140                //TODO: Check for changes and ask user
     141                MapFrame mapFrame = new MapFrame(dataSet);
    139142                this.name = name;
    140143                this.mapFrame = mapFrame;
     
    144147                panel.add(mapFrame.toolBarActions, BorderLayout.WEST);
    145148                panel.add(mapFrame.statusLine, BorderLayout.SOUTH);
     149                for (Projection p : Preferences.allProjections)
     150                        p.init(dataSet);
     151                mapFrame.layer.initDataSet();
    146152                panel.setVisible(true);
    147153        }
  • src/org/openstreetmap/josm/gui/MapFrame.java

    r9 r15  
    1414import javax.swing.JToolBar;
    1515
     16import org.openstreetmap.josm.actions.AutoScaleAction;
    1617import org.openstreetmap.josm.actions.mapmode.AddLineSegmentAction;
    1718import org.openstreetmap.josm.actions.mapmode.AddNodeAction;
     
    2526import org.openstreetmap.josm.actions.mapmode.ZoomAction;
    2627import org.openstreetmap.josm.data.osm.DataSet;
    27 import org.openstreetmap.josm.gui.dialogs.PropertiesDialog;
    2828import org.openstreetmap.josm.gui.dialogs.SelectionListDialog;
    2929
     
    4343         * The view control displayed.
    4444         */
    45         public MapView mapView;
     45        public Layer layer;
    4646        /**
    4747         * The toolbar with the action icons
     
    6161                setLayout(new BorderLayout());
    6262
    63                 add(mapView = new MapView(dataSet), BorderLayout.CENTER);
     63                add(layer = new Layer(dataSet), BorderLayout.CENTER);
    6464
    6565                // toolbar
     
    8484                // autoScale
    8585                toolBarActions.addSeparator();
    86                 final JToggleButton autoScaleButton = new IconToggleButton(this, mapView.new AutoScaleAction());
     86                final JToggleButton autoScaleButton = new IconToggleButton(this, new AutoScaleAction(layer));
    8787                toolBarActions.add(autoScaleButton);
    8888                autoScaleButton.setText(null);
    89                 autoScaleButton.setSelected(mapView.isAutoScale());
    90                 mapView.addPropertyChangeListener(new PropertyChangeListener(){
     89                autoScaleButton.setSelected(layer.isAutoScale());
     90                layer.addPropertyChangeListener(new PropertyChangeListener(){
    9191                        public void propertyChange(PropertyChangeEvent evt) {
    9292                                if (evt.getPropertyName().equals("autoScale"))
    93                                         autoScaleButton.setSelected(mapView.isAutoScale());
     93                                        autoScaleButton.setSelected(layer.isAutoScale());
    9494                        }
    9595                });
    96 
    97                 // properties
    98                 toolBarActions.add(new IconToggleButton(this, new PropertiesDialog(this)));
    9996
    10097                // selection dialog
     
    110107
    111108                // status line below the map
    112                 statusLine = new MapStatus(mapView);
     109                statusLine = new MapStatus(layer);
    113110        }
    114111
  • src/org/openstreetmap/josm/gui/MapMover.java

    r6 r15  
    2626         * The map to move around.
    2727         */
    28         private final MapView mv;
     28        private final Layer mv;
    2929        /**
    3030         * The old cursor when we changed it to movement cursor.
     
    3434        /**
    3535         * Create a new MapMover
    36          * @param mapView The map that should be moved.
     36         * @param layer The map that should be moved.
    3737         */
    38         public MapMover(MapView mapView) {
    39                 this.mv = mapView;
     38        public MapMover(Layer layer) {
     39                this.mv = layer;
    4040                mv.addMouseListener(this);
    4141                mv.addMouseMotionListener(this);
  • src/org/openstreetmap/josm/gui/MapStatus.java

    r9 r15  
    3939
    4040        /**
    41          * The MapView this status belongs.
     41         * The Layer this status belongs.
    4242         */
    43         final MapView mv;
     43        final Layer mv;
    4444        /**
    4545         * The position of the mouse cursor.
     
    145145       
    146146        /**
    147          * Construct a new MapStatus and attach it to the map view.
    148          * @param mv The MapView the status line is part of.
     147         * Construct a new MapStatus and attach it to the Layer.
     148         * @param mv The Layer the status line is part of.
    149149         */
    150         public MapStatus(final MapView mv) {
     150        public MapStatus(final Layer mv) {
    151151                this.mv = mv;
    152152               
  • src/org/openstreetmap/josm/gui/PreferenceDialog.java

    r11 r15  
    4848                public void actionPerformed(ActionEvent e) {
    4949                        Preferences pref = new Preferences();
    50                         pref.laf = (LookAndFeelInfo)lafCombo.getSelectedItem();
    51                         pref.projection = (Projection)projectionCombo.getSelectedItem();
    52                         pref.mergeNodes = mergeNodes.isSelected();
    53                         Main.pref.projection = pref.projection;
     50                        pref.setLaf((LookAndFeelInfo)lafCombo.getSelectedItem());
     51                        pref.setProjection((Projection)projectionCombo.getSelectedItem());
     52                        pref.setMergeNodes(mergeNodes.isSelected());
     53                        Main.pref.setProjection(pref.getProjection());
    5454                        try {
    5555                                pref.save();
     
    125125                                return oldRenderer.getListCellRendererComponent(list, ((LookAndFeelInfo)value).getName(), index, isSelected, cellHasFocus);
    126126                        }});
    127                 lafCombo.setSelectedItem(pref.laf);
     127                lafCombo.setSelectedItem(pref.getLaf());
    128128                lafCombo.addActionListener(new ActionListener(){
    129129                        public void actionPerformed(ActionEvent e) {
     
    133133                // projection method combo box
    134134                for (int i = 0; i < projectionCombo.getItemCount(); ++i) {
    135                         if (projectionCombo.getItemAt(i).getClass().equals(pref.projection.getClass())) {
     135                        if (projectionCombo.getItemAt(i).getClass().equals(pref.getProjection().getClass())) {
    136136                                projectionCombo.setSelectedIndex(i);
    137137                                break;
     
    160160                map.add(labelNoteProjection, GBC.eol().insets(0,5,0,20));
    161161                map.add(new JLabel("GPX import / export"), GBC.eol());
    162                 mergeNodes.setSelected(pref.mergeNodes);
     162                mergeNodes.setSelected(pref.isMergeNodes());
    163163                map.add(mergeNodes, GBC.eol());
    164164                map.add(Box.createVerticalGlue(), GBC.eol().fill(GBC.VERTICAL));
  • src/org/openstreetmap/josm/gui/SelectionManager.java

    r8 r15  
    8888        private Point mousePos;
    8989        /**
    90          * The MapView, the selection rectangle is drawn onto.
    91          */
    92         private final MapView mv;
     90         * The Layer, the selection rectangle is drawn onto.
     91         */
     92        private final Layer mv;
    9393        /**
    9494         * Whether the selection rectangle must obtain the aspect ratio of the
     
    104104         * @param aspectRatio If true, the selection window must obtain the aspect
    105105         *              ratio of the drawComponent.
    106          * @param mapView The view, the rectangle is drawn onto.
    107          */
    108         public SelectionManager(SelectionEnded selectionEndedListener, boolean aspectRatio, MapView mapView) {
     106         * @param layer The view, the rectangle is drawn onto.
     107         */
     108        public SelectionManager(SelectionEnded selectionEndedListener, boolean aspectRatio, Layer layer) {
    109109                this.selectionEndedListener = selectionEndedListener;
    110110                this.aspectRatio = aspectRatio;
    111                 this.mv = mapView;
     111                this.mv = layer;
    112112        }
    113113       
  • src/org/openstreetmap/josm/gui/dialogs/PropertiesDialog.java

    r8 r15  
    11package org.openstreetmap.josm.gui.dialogs;
    22
    3 import java.awt.event.ActionEvent;
    4 import java.awt.event.ActionListener;
    53import java.awt.event.KeyEvent;
    64
    75import javax.swing.BorderFactory;
    86import javax.swing.Box;
    9 import javax.swing.BoxLayout;
    10 import javax.swing.JComboBox;
    11 import javax.swing.JComponent;
    12 import javax.swing.JLabel;
    13 import javax.swing.JPanel;
    14 import javax.swing.border.Border;
    157
    16 import org.openstreetmap.josm.data.Preferences;
    17 import org.openstreetmap.josm.data.projection.Projection;
    188import org.openstreetmap.josm.gui.Main;
    199import org.openstreetmap.josm.gui.MapFrame;
     
    3525                putValue(MNEMONIC_KEY, KeyEvent.VK_P);
    3626
    37                 final Border panelBorder = BorderFactory.createEmptyBorder(5,0,0,0);
     27//              final Border panelBorder = BorderFactory.createEmptyBorder(5,0,0,0);
    3828                Box panel = Box.createVerticalBox();
    3929
    4030                // making an array of all projections and the current one within
    41                 Projection[] allProjections = Preferences.allProjections.clone();
    42                 for (int i = 0; i < allProjections.length; ++i)
    43                         if (allProjections[i].getClass() == frame.mapView.getProjection().getClass())
    44                                 allProjections[i] = frame.mapView.getProjection();
    45                
    46                 // projection
    47                 Box projectionPanel = Box.createHorizontalBox();
    48                 projectionPanel.setBorder(panelBorder);
    49                 projectionPanel.add(new JLabel("Projection"));
    50                 final JComboBox projectionCombo = new JComboBox(allProjections);
    51                 projectionPanel.add(projectionCombo);
    52                 panel.add(projectionPanel);
    53                 final JPanel configurationPanel = new JPanel();
    54                 configurationPanel.setLayout(new BoxLayout(configurationPanel, BoxLayout.X_AXIS));
    55                
    56                 // projections details
    57                 projectionCombo.addActionListener(new ActionListener(){
    58                         public void actionPerformed(ActionEvent e) {
    59                                 configurationPanel.removeAll();
    60                                 frame.mapView.setProjection((Projection)projectionCombo.getSelectedItem());
    61                                 JComponent panel = frame.mapView.getProjection().getConfigurationPanel();
    62                                 if (panel != null) {
    63                                         panel.setBorder(panelBorder);
    64                                         configurationPanel.add(panel);
    65                                 }
    66                                 pack();
    67                         }
    68                 });
    69                 panel.add(configurationPanel);
    70                 projectionCombo.setSelectedItem(frame.mapView.getProjection());
     31//              Projection[] allProjections = Preferences.allProjections.clone();
     32//              for (int i = 0; i < allProjections.length; ++i)
     33//                      if (allProjections[i].getClass() == frame.layer.getProjection().getClass())
     34//                              allProjections[i] = frame.layer.getProjection();
     35//             
     36//              // projection
     37//              Box projectionPanel = Box.createHorizontalBox();
     38//              projectionPanel.setBorder(panelBorder);
     39//              projectionPanel.add(new JLabel("Projection"));
     40//              final JComboBox projectionCombo = new JComboBox(allProjections);
     41//              projectionPanel.add(projectionCombo);
     42//              panel.add(projectionPanel);
     43//              final JPanel configurationPanel = new JPanel();
     44//              configurationPanel.setLayout(new BoxLayout(configurationPanel, BoxLayout.X_AXIS));
     45//             
     46//              // projections details
     47//              projectionCombo.addActionListener(new ActionListener(){
     48//                      public void actionPerformed(ActionEvent e) {
     49//                              configurationPanel.removeAll();
     50//                              frame.layer.setProjection((Projection)projectionCombo.getSelectedItem());
     51//                              JComponent panel = frame.layer.getProjection().getConfigurationPanel();
     52//                              if (panel != null) {
     53//                                      panel.setBorder(panelBorder);
     54//                                      configurationPanel.add(panel);
     55//                              }
     56//                              pack();
     57//                      }
     58//              });
     59//              panel.add(configurationPanel);
     60//              projectionCombo.setSelectedItem(frame.layer.getProjection());
    7161               
    7262                panel.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
  • src/org/openstreetmap/josm/gui/dialogs/ToggleDialog.java

    r11 r15  
    22
    33import java.awt.event.ActionEvent;
    4 import java.awt.event.KeyEvent;
    54import java.util.HashMap;
    65import java.util.Map;
     
    3130                putValue(NAME, name);
    3231                putValue(MNEMONIC_KEY, mnemonic);
    33                 putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_E,0));
    34                 putValue(LONG_DESCRIPTION, "Open a selection list window.");
     32                putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(mnemonic,0));
     33                putValue(LONG_DESCRIPTION, tooltip);
    3534        }
    3635
  • src/org/openstreetmap/josm/gui/engine/Engine.java

    r8 r15  
    22
    33import java.awt.Graphics;
    4 import java.beans.PropertyChangeEvent;
    5 import java.beans.PropertyChangeListener;
    64
    75import org.openstreetmap.josm.data.GeoPoint;
     
    97import org.openstreetmap.josm.data.osm.Node;
    108import org.openstreetmap.josm.data.osm.Track;
    11 import org.openstreetmap.josm.data.projection.Projection;
    12 import org.openstreetmap.josm.gui.MapView;
     9import org.openstreetmap.josm.gui.Layer;
    1310
    1411/**
     
    1815 * @author imi
    1916 */
    20 abstract public class Engine implements PropertyChangeListener {
     17abstract public class Engine {
    2118
    22         /**
    23          * The projection method, this engine uses to render the graphics.
    24          */
    25         protected Projection projection;
    2619        /**
    2720         * The Graphics surface to draw on. This should be set before each painting
     
    3023        protected Graphics g;
    3124        /**
    32          * The mapView, this engine was created for.
     25         * The layer, this engine was created for.
    3326         */
    34         protected final MapView mv;
     27        protected final Layer layer;
    3528
    3629       
    3730        /**
    38          * Creates an Engine from an MapView it belongs to.
    39          * @param mapView The mapview this engine belongs to.
     31         * Creates an Engine from an Layer it belongs to.
     32         * @param layer The mapview this engine belongs to.
    4033         */
    41         public Engine(MapView mapView) {
    42                 mv = mapView;
    43                 mv.addPropertyChangeListener(this);
     34        public Engine(Layer layer) {
     35                this.layer = layer;
    4436        }
    4537       
     
    7365         */
    7466        abstract public void drawPendingLineSegment(LineSegment ls);
    75 
    76         /**
    77          * Called when the projection method for the map changed. Subclasses with
    78          * caches depending on the projection should empty the cache now.
    79          */
    80         public void propertyChange(PropertyChangeEvent e) {
    81                 if (e.getPropertyName().equals("projection"))
    82                         projection = (Projection)e.getNewValue();
    83         }
    8467}
  • src/org/openstreetmap/josm/gui/engine/SimpleEngine.java

    r8 r15  
    1010import org.openstreetmap.josm.data.osm.Node;
    1111import org.openstreetmap.josm.data.osm.Track;
    12 import org.openstreetmap.josm.gui.MapView;
     12import org.openstreetmap.josm.gui.Layer;
    1313
    1414/**
     
    2323        private final static Color darkgreen = new Color(0,128,0);
    2424
    25         public SimpleEngine(MapView mapView) {
    26                 super(mapView);
     25        public SimpleEngine(Layer layer) {
     26                super(layer);
    2727        }
    2828
     
    3333        public void drawBackground(GeoPoint ulGeo, GeoPoint lrGeo) {
    3434                g.setColor(Color.BLACK);
    35                 g.fillRect(0,0,mv.getWidth(),mv.getHeight());
     35                g.fillRect(0,0,layer.getWidth(),layer.getHeight());
    3636        }
    3737
     
    109109        private void drawLineSegment(LineSegment ls, Color color) {
    110110                g.setColor(ls.isSelected() ? Color.WHITE : color);
    111                 Point p1 = mv.getScreenPoint(ls.getStart().coor);
    112                 Point p2 = mv.getScreenPoint(ls.getEnd().coor);
     111                Point p1 = layer.getScreenPoint(ls.getStart().coor);
     112                Point p2 = layer.getScreenPoint(ls.getEnd().coor);
    113113                g.drawLine(p1.x, p1.y, p2.x, p2.y);
    114114        }
     
    121121         */
    122122        private void drawNode(Node n, Color color) {
    123                 Point p = mv.getScreenPoint(n.coor);
     123                Point p = layer.getScreenPoint(n.coor);
    124124                g.setColor(color);
    125125                g.drawRect(p.x-1, p.y-1, 2, 2);
  • src/org/openstreetmap/josm/io/GpxReader.java

    r13 r15  
    161161         */
    162162        private Node addNode (DataSet data, Node node) {
    163                 if (Main.pref.mergeNodes)
     163                if (Main.pref.isMergeNodes())
    164164                        for (Node n : data.nodes)
    165165                                if (node.coor.lat == n.coor.lat && node.coor.lon == n.coor.lon)
Note: See TracChangeset for help on using the changeset viewer.