Changes in / [3:1] in josm


Ignore:
Files:
3 deleted
10 edited

Legend:

Unmodified
Added
Removed

  • /

    • Property svn:ignore deleted

  • /src/org/openstreetmap/josm/actions/DebugAction.java

    r3 r1  
    2525
    2626        public DebugAction(MapFrame mapFrame) {
    27                 super("Debug Zones", "debug", KeyEvent.VK_D, mapFrame);
     27                super("Debug Zones", "images/debug.png", KeyEvent.VK_D, mapFrame);
    2828        }
    2929       

  • /src/org/openstreetmap/josm/actions/MapMode.java

    r3 r1  
    3131         */
    3232        public MapMode(String name, String iconName, int mnemonic, MapFrame mapFrame) {
    33                 super(name, new ImageIcon("images/"+iconName+".png"));
     33                super(name, new ImageIcon(iconName));
    3434                putValue(MNEMONIC_KEY, mnemonic);
    3535                this.mapFrame = mapFrame;

  • /src/org/openstreetmap/josm/actions/OpenGpxAction.java

    r3 r1  
    5454                try {
    5555                        DataSet dataSet = new GpxReader().parse(new FileReader(gpxFile));
     56                        if (dataSet.name == null)
     57                                dataSet.name = gpxFile.getName();
    5658                        MapFrame map = new MapFrame(dataSet);
    5759                        Main.main.setMapFrame(gpxFile.getName(), map);

  • /src/org/openstreetmap/josm/actions/ZoomAction.java

    r3 r1  
    11package org.openstreetmap.josm.actions;
    22
     3import static java.awt.event.MouseEvent.BUTTON1;
     4import static java.awt.event.MouseEvent.BUTTON3;
     5
     6import java.awt.Color;
     7import java.awt.Cursor;
     8import java.awt.Graphics;
     9import java.awt.Point;
    310import java.awt.Rectangle;
    411import java.awt.event.KeyEvent;
    5 
    6 import org.openstreetmap.josm.actions.SelectionManager.SelectionEnded;
     12import java.awt.event.MouseEvent;
     13import java.awt.event.MouseListener;
     14import java.awt.event.MouseMotionListener;
     15import java.awt.event.MouseWheelEvent;
     16import java.awt.event.MouseWheelListener;
     17
    718import org.openstreetmap.josm.data.GeoPoint;
    819import org.openstreetmap.josm.gui.MapFrame;
    … …  
    1021
    1122/**
    12  * Enable the zoom mode within the MapFrame.
    13  *
    14  * Holding down the left mouse button select a rectangle with the same aspect
    15  * ratio than the current map view.
    16  * Holding down left and right let the user move the former selected rectangle.
    17  * Releasing the left button zoom to the selection.
     23 * Enable the zoom mode within the MapFrame.
    1824 *
    1925 * @author imi
    2026 */
    21 public class ZoomAction extends MapMode implements SelectionEnded {
    22 
     27public class ZoomAction extends MapMode
     28        implements MouseListener, MouseMotionListener, MouseWheelListener {
     29
     30        /**
     31         * Point, the mouse was when pressing the button.
     32         */
     33        private Point mousePosStart;
     34        /**
     35         * Point to the actual mouse position.
     36         */
     37        private Point mousePos;
     38        /**
     39         * The point in the map that was the under the mouse point
     40         * when moving around started.
     41         */
     42        private GeoPoint mousePosMove;
    2343        /**
    2444         * Shortcut to the mapview.
    … …  
    2646        private final MapView mv;
    2747        /**
    28          * Manager that manages the selection rectangle with the aspect ratio of the
    29          * MapView.
    30          */
    31         private final SelectionManager selectionManager;
     48         * Whether currently an zooming rectangle is visible or not
     49         */
     50        private boolean zoomRectVisible = false;
     51
     52        /**
     53         * For the current state.
     54         */
     55        enum State {NOTHING, MOVE, ZOOM, ZOOM_POS};
     56        /**
     57         * The current state, the ZoomAction is in.
     58         */
     59        State state = State.NOTHING;
     60       
    3261       
    3362       
    … …  
    3766         */
    3867        public ZoomAction(MapFrame mapFrame) {
    39                 super("Zoom", "zoom", KeyEvent.VK_Z, mapFrame);
     68                super("Zoom", "images/zoom.png", KeyEvent.VK_Z, mapFrame);
    4069                mv = mapFrame.mapView;
    41                 selectionManager = new SelectionManager(this, true, mv);
    42         }
    43 
    44         /**
    45          * Zoom to the rectangle on the map.
    46          */
    47         public void selectionEnded(Rectangle r, int modifier) {
    48                 double scale = mv.getScale() * r.getWidth()/mv.getWidth();
    49                 GeoPoint newCenter = mv.getPoint(r.x+r.width/2, r.y+r.height/2, false);
    50                 mv.zoomTo(newCenter, scale);
     70        }
     71
     72        /**
     73         * Just to keep track of mouse movements.
     74         */
     75        public void mouseMoved(MouseEvent e) {
     76                mousePos = e.getPoint();
     77        }
     78
     79        /**
     80         * Initializing the mouse moving state.
     81         */
     82        public void mousePressed(MouseEvent e) {
     83                switch (state) {
     84                case NOTHING:
     85                        switch (e.getButton()) {
     86                        case BUTTON1:
     87                                state = State.ZOOM;
     88                                mousePosStart = e.getPoint();
     89                                paintZoomRect(true);
     90                                break;
     91                        case BUTTON3:
     92                                state = State.MOVE;
     93                                mousePosMove = mv.getPoint(e.getX(), e.getY(), false);
     94                                mv.setCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
     95                                break;
     96                        }
     97                        break;
     98                case ZOOM:
     99                        if (e.getButton() == BUTTON3)
     100                                state = State.ZOOM_POS;
     101                        break;
     102                case MOVE:
     103                        if (e.getButton() == BUTTON1) {
     104                                state = State.ZOOM_POS;
     105                                mousePosStart = e.getPoint();
     106                                mousePos = e.getPoint();
     107                        }
     108                }
     109        }
     110
     111        public void mouseReleased(MouseEvent e) {
     112                switch (state) {
     113                case ZOOM:
     114                        if (e.getButton() == BUTTON1) {
     115                                state = State.NOTHING;
     116                                paintZoomRect(false);
     117                                Rectangle r = calculateZoomableRectangle();
     118                                mousePosStart = null;
     119                                // zoom to the rectangle
     120                                if (r != null) {
     121                                        double scale = mv.getScale() * r.getWidth()/mv.getWidth();
     122                                        GeoPoint newCenter = mv.getPoint(r.x+r.width/2, r.y+r.height/2, false);
     123                                        mv.zoomTo(newCenter, scale);
     124                                }
     125                        }
     126                        break;
     127                case MOVE:
     128                        if (e.getButton() == BUTTON3) {
     129                                state = State.NOTHING;
     130                                mousePosMove = null;
     131                                mv.setCursor(Cursor.getDefaultCursor());
     132                        }
     133                        break;
     134                case ZOOM_POS:
     135                        switch (e.getButton()) {
     136                        case BUTTON1:
     137                                state = State.MOVE;
     138                                paintZoomRect(false);
     139                                mousePosStart = null;
     140                                mousePos = null;
     141                                mousePosMove = mv.getPoint(e.getX(), e.getY(), false);
     142                                mv.setCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
     143                                break;
     144                        case BUTTON3:
     145                                state = State.ZOOM;
     146                                break;
     147                        }
     148                }
     149        }
     150
     151        public void mouseDragged(MouseEvent e) {
     152                switch (state) {
     153                case MOVE:
     154                        if (mousePosMove == null) {
     155                                mousePosMove = mv.getCenter();
     156                                mv.setCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
     157                        }
     158                        GeoPoint center = mv.getCenter();
     159                        GeoPoint mouseCenter = mv.getPoint(e.getX(), e.getY(), false);
     160                        GeoPoint p = new GeoPoint();
     161                        p.x = mousePosMove.x + center.x - mouseCenter.x; 
     162                        p.y = mousePosMove.y + center.y - mouseCenter.y; 
     163                        mv.zoomTo(p, mv.getScale());
     164                        break;
     165                case ZOOM:
     166                        if (mousePosStart == null)
     167                                mousePosStart = e.getPoint();
     168                        if (mousePos == null)
     169                                mousePos = e.getPoint();
     170                        paintZoomRect(false);
     171                        mousePos = e.getPoint();
     172                        paintZoomRect(true);
     173                        break;
     174                case ZOOM_POS:
     175                        if (mousePosStart == null)
     176                                mousePosStart = e.getPoint();
     177                        if (mousePos == null)
     178                                mousePos = e.getPoint();
     179                        paintZoomRect(false);
     180                        mousePosStart.x += e.getX()-mousePos.x;
     181                        mousePosStart.y += e.getY()-mousePos.y;
     182                        mousePos = e.getPoint();
     183                        paintZoomRect(true);
     184                        break;
     185                }
     186        }
     187
     188        public void mouseWheelMoved(MouseWheelEvent e) {
     189                boolean zoomRect = zoomRectVisible;
     190                paintZoomRect(false);
     191                double zoom = Math.max(0.1, 1 + e.getWheelRotation()/5.0);
     192                mv.zoomTo(mv.getCenter(), mv.getScale()*zoom);
     193                paintZoomRect(zoomRect);
     194        }
     195
     196        /**
     197         * Calculate the zoomable rectangle between mousePos and mousePosStart.
     198         * Zoomable is the rectangle with a fix point at mousePosStart and the
     199         * correct aspect ratio that fits into the current mapView's size.
     200         * @return Rectangle which should be used to zoom.
     201         */
     202        private Rectangle calculateZoomableRectangle() {
     203                if (mousePosStart == null || mousePos == null || mousePosStart == mousePos)
     204                        return null;
     205                Rectangle r = new Rectangle();
     206                r.x = mousePosStart.x;
     207                r.y = mousePosStart.y;
     208                r.width = mousePos.x - mousePosStart.x;
     209                r.height = mousePos.y - mousePosStart.y;
     210                if (r.width < 0) {
     211                        r.x += r.width;
     212                        r.width = -r.width;
     213                }
     214                if (r.height < 0) {
     215                        r.y += r.height;
     216                        r.height = -r.height;
     217                }
     218               
     219                // keep the aspect ration by shrinking the rectangle
     220                double aspectRatio = (double)mv.getWidth()/mv.getHeight();
     221                if ((double)r.width/r.height > aspectRatio)
     222                        r.width = (int)(r.height*aspectRatio);
     223                else
     224                        r.height = (int)(r.width/aspectRatio);
     225
     226                return r;
     227        }
     228       
     229        /**
     230         * Paint the mouse selection rectangle XOR'ed over the display.
     231         *
     232         * @param drawVisible True, to draw the rectangle or false to erase it.
     233         */
     234        private void paintZoomRect(boolean drawVisible) {
     235                Rectangle r = calculateZoomableRectangle();
     236                if (r != null && drawVisible != zoomRectVisible) {
     237                        Graphics g = mv.getGraphics();
     238                        g.setColor(Color.BLACK);
     239                        g.setXORMode(Color.WHITE);
     240                        g.drawRect(r.x,r.y,r.width,r.height);
     241                        zoomRectVisible = !zoomRectVisible;
     242                }
    51243        }
    52244
    53245        public void registerListener(MapView mapView) {
    54                 selectionManager.register(mapView);
     246                mapView.addMouseListener(this);
     247                mapView.addMouseMotionListener(this);
     248                mapView.addMouseWheelListener(this);
    55249        }
    56250
    57251        public void unregisterListener(MapView mapView) {
    58                 selectionManager.unregister(mapView);
    59         }
     252                mapView.removeMouseListener(this);
     253                mapView.removeMouseMotionListener(this);
     254                mapView.removeMouseWheelListener(this);
     255        }
     256       
     257        /**
     258         * Does nothing. Only to satisfy MouseListener
     259         */
     260        public void mouseClicked(MouseEvent e) {}
     261        /**
     262         * Does nothing. Only to satisfy MouseListener
     263         */
     264        public void mouseEntered(MouseEvent e) {}
     265        /**
     266         * Does nothing. Only to satisfy MouseListener
     267         */
     268        public void mouseExited(MouseEvent e) {}
    60269}

  • /src/org/openstreetmap/josm/data/osm/DataSet.java

    r3 r1  
    11package org.openstreetmap.josm.data.osm;
    22
    3 import java.util.Collection;
    43import java.util.List;
    54
    … …  
    1716 */
    1817public class DataSet implements Cloneable {
     18
     19        /**
     20         * human readable name of the data.
     21         */
     22        public String name;
     23
     24        /**
     25         * human readable description of what the data is about. Space for comments.
     26         */
     27        public String desc;
     28
     29        /**
     30         * Who recorded/created it.
     31         */
     32        public String author;
    1933
    2034        /**
    … …  
    95109        }
    96110
    97         /**
    98          * Remove the selection of the whole dataset.
    99          */
    100         public void clearSelection() {
    101                 clearSelection(allNodes);
    102                 clearSelection(tracks);
    103                 for (Track t : tracks)
    104                         clearSelection(t.segments);
    105         }
    106        
    107         /**
    108          * Remove the selection from every value in the collection.
    109          * @param list The collection to remove the selection from.
    110          */
    111         private void clearSelection(Collection<? extends OsmPrimitive> list) {
    112                 if (list == null)
    113                         return;
    114                 for (OsmPrimitive osm : list) {
    115                         osm.selected = false;
    116                         if (osm.keys != null)
    117                                 clearSelection(osm.keys.keySet());
    118                 }
    119         }
    120        
    121111        public DataSet clone() {
    122112                try {return (DataSet)super.clone();} catch (CloneNotSupportedException e) {}

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

    r3 r1  
    1616         */
    1717        public Map<Key, String> keys;
    18        
    19         /**
    20          * If set to true, this object has been modified in the current session.
    21          */
    22         public boolean modified = false;
    23        
    24         /**
    25          * If set to true, this object is currently selected.
    26          */
    27         public boolean selected = false;
    2818}

  • /src/org/openstreetmap/josm/gui/MapFrame.java

    r3 r1  
    2727import org.openstreetmap.josm.actions.DebugAction;
    2828import org.openstreetmap.josm.actions.MapMode;
    29 import org.openstreetmap.josm.actions.SelectionAction;
    3029import org.openstreetmap.josm.actions.ZoomAction;
    3130import org.openstreetmap.josm.data.Preferences;
    … …  
    126125                toolBarActions.setFloatable(false);
    127126                toolBarActions.add(new IconToggleButton(new ZoomAction(this)));
    128                 toolBarActions.add(new IconToggleButton(new SelectionAction(this)));
    129127                toolBarActions.add(new IconToggleButton(new DebugAction(this)));
    130128

  • /src/org/openstreetmap/josm/gui/MapView.java

    r3 r1  
    44import java.awt.Component;
    55import java.awt.Graphics;
    6 import java.awt.Point;
    76import java.awt.event.ActionEvent;
    87import java.awt.event.ComponentEvent;
    … …  
    127126                addComponentListener(this);
    128127               
    129                 // initialize the movement listener
    130                 new MapMover(this);
    131                
    132128                // initialize the projection
    133129                setProjection(Main.pref.projection.clone());
    … …  
    156152                        getProjection().xy2latlon(p);
    157153                return p;
    158         }
    159        
    160         /**
    161          * Return the point on the screen where this GeoPoint would be.
    162          * @param point The point, where this geopoint would be drawn.
    163          * @return The point on screen where "point" would be drawn, relative
    164          *              to the own top/left.
    165          */
    166         public Point getScreenPoint(GeoPoint point) {
    167                 GeoPoint p;
    168                 if (!Double.isNaN(point.x) && !Double.isNaN(point.y))
    169                         p = point;
    170                 else {
    171                         if (Double.isNaN(point.lat) || Double.isNaN(point.lon))
    172                                 throw new IllegalArgumentException("point: Either lat/lon or x/y must be set.");
    173                         p = point.clone();
    174                         projection.latlon2xy(p);
    175                 }
    176                 return new Point(toScreenX(p.x), toScreenY(p.y));
    177154        }
    178155       
    … …  
    248225               
    249226                // draw tracks
     227                g.setColor(Color.RED);
    250228                if (dataSet.tracks != null)
    251229                        for (Track track : dataSet.tracks)
    252                                 for (LineSegment ls : track.segments) {
    253                                         g.setColor(ls.selected ? Color.WHITE : Color.GRAY);
     230                                for (LineSegment ls : track.segments)
    254231                                        g.drawLine(toScreenX(ls.start.coor.x), toScreenY(ls.start.coor.y),
    255232                                                        toScreenX(ls.end.coor.x), toScreenY(ls.end.coor.y));
    256                                 }
    257233
    258234                // draw nodes
     235                g.setColor(Color.YELLOW);
    259236                for (Node w : dataSet.allNodes) {
    260                         g.setColor(w.selected ? Color.WHITE : Color.RED);
    261237                        g.drawArc(toScreenX(w.coor.x), toScreenY(w.coor.y), 3, 3, 0, 360);
    262238                }

  • /src/org/openstreetmap/josm/io/GpxReader.java

    r3 r1  
    6767        private DataSet parseDataSet(Element e) {
    6868                DataSet data = new DataSet();
     69                // read global information
     70                data.author = e.getAttributeValue("creator");
     71                Element metadata = e.getChild("metadata");
     72                if (metadata != null)
     73                {
     74                        data.desc = metadata.getChildText("desc", XSD);
     75                        data.name = metadata.getChildText("name", XSD);
     76                }
     77               
    6978                // read waypoints not contained in tracks or areas
    7079                data.allNodes = new LinkedList<Node>();
Note: See TracChangeset for help on using the changeset viewer.