Changeset 4327 in josm for trunk/src/org/openstreetmap/josm/actions

Timestamp:

2011-08-21T13:12:53+02:00 (14 years ago)

Author:

xeen

Message:

updates visual appearance of highlights and adds them to select and delete action

in more detail:

• add target highlighting to select action
• add target cursor to select action
• add target highlighting to delete action
• unify ctrl/alt/shift modifier detection in MapMode actions
• highlights are now a halo around the way/node instead of a color change
• default highlight color is now the same as the select color (red)
• ability to highlight WaySegments and VirtualNodes
• various style/whitespace nits
• fixes #2411

This patch touches a lot of areas, so please report any regressions in the map mode
tools. Also please add a comment to #2411 if you find to highlighting in select
mode distracting, so it can be fine tuned (or turned off by default).

Location:

trunk/src/org/openstreetmap/josm/actions/mapmode

Files:

• DeleteAction.java (modified) (12 diffs)
• DrawAction.java (modified) (4 diffs)
• ExtrudeAction.java (modified) (3 diffs)
• MapMode.java (modified) (3 diffs)
• ParallelWayAction.java (modified) (6 diffs)
• PlayHeadDragMode.java (modified) (3 diffs)
• SelectAction.java (modified) (21 diffs)

trunk/src/org/openstreetmap/josm/actions/mapmode/DeleteAction.java

@@ -6 +6 @@
 import java.awt.AWTEvent;
 import java.awt.Cursor;
-import java.awt.EventQueue;
 import java.awt.Toolkit;
 import java.awt.event.AWTEventListener;
@@ -14 +13 @@
 import java.awt.event.MouseEvent;
 import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
 
 import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.command.Command;
 import org.openstreetmap.josm.command.DeleteCommand;
+import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
@@ -45 +47 @@
  * @author imi
  */
-
-/**
- * This class contains stubs for highlighting affected primitives when affected.
- * However, way segments can be deleted as well, but cannot be highlighted
- * alone. If the highlight feature for this delete action is to be implemented
- * properly, highlighting way segments must be possible first. --xeen, 2009-09-02
- */
 public class DeleteAction extends MapMode implements AWTEventListener {
     // Cache previous mouse event (needed when only the modifier keys are
     // pressed but the mouse isn't moved)
     private MouseEvent oldEvent = null;
+
+    /**
+     * elements that have been highlighted in the previous iteration. Used
+     * to remove the highlight from them again as otherwise the whole data
+     * set would have to be checked.
+     */
+    private Set<OsmPrimitive> oldHighlights = new HashSet<OsmPrimitive>();
+
+    private boolean drawTargetHighlight;
 
     private enum DeleteMode {
@@ -101 +105 @@
             return;
 
+        drawTargetHighlight = Main.pref.getBoolean("draw.target-highlight", true);
+
         Main.map.mapView.addMouseListener(this);
         Main.map.mapView.addMouseMotionListener(this);
@@ -120 +126 @@
             System.out.println(ex);
         }
+        removeHighlighting();
     }
 
@@ -157 +164 @@
     @Override public void mouseMoved(MouseEvent e) {
         oldEvent = e;
-        updateCursor(e, e.getModifiers());
+        giveUserFeedback(e);
+    }
+
+    /**
+     * removes any highlighting that may have been set beforehand.
+     */
+    private void removeHighlighting() {
+        for(OsmPrimitive prim : oldHighlights) {
+            prim.setHighlighted(false);
+        }
+        oldHighlights = new HashSet<OsmPrimitive>();
+        DataSet ds = getCurrentDataSet();
+        if(ds != null) {
+            ds.clearHighlightedWaySegments();
+        }
+    }
+
+    /**
+     * handles everything related to highlighting primitives and way
+     * segments for the given pointer position (via MouseEvent) and
+     * modifiers.
+     * @param e
+     * @param modifiers
+     */
+    private void addHighlighting(MouseEvent e, int modifiers) {
+        if(!drawTargetHighlight)
+            return;
+        removeHighlighting();
+
+        DeleteParameters parameters = getDeleteParameters(e, modifiers);
+
+        if(parameters.mode == DeleteMode.segment) {
+            // deleting segments is the only action not working on OsmPrimitives
+            // so we have to handle them separately.
+            DataSet ds = getCurrentDataSet();
+            if(ds != null) {
+                ds.setHighlightedWaySegments(Collections.singleton(parameters.nearestSegment));
+            }
+        } else {
+            // don't call buildDeleteCommands for DeleteMode.segment because it doesn't support
+            // silent operation and SplitWayAction will show dialogs. A lot.
+            Command delCmd = buildDeleteCommands(e, modifiers, true);
+            if(delCmd == null) {
+                Main.map.mapView.repaint();
+                return;
+            }
+
+            // all other cases delete OsmPrimitives directly, so we can
+            // safely do the following
+            for(OsmPrimitive osm : delCmd.getParticipatingPrimitives()) {
+                osm.setHighlighted(true);
+                oldHighlights.add(osm);
+            }
+        }
+        Main.map.mapView.repaint();
     }
 
     /**
      * This function handles all work related to updating the cursor and
-     * highlights. For now, only the cursor is enabled because highlighting
-     * requires WaySegment to be highlightable.
+     * highlights
      *
+     * @param MouseEvent
+     * @param int modifiers
+     */
+    private void updateCursor(MouseEvent e, int modifiers) {
+        if (!Main.isDisplayingMapView())
+            return;
+        if(!Main.map.mapView.isActiveLayerVisible() || e == null)
+            return;
+
+        DeleteParameters parameters = getDeleteParameters(e, modifiers);
+        Main.map.mapView.setNewCursor(parameters.mode.cursor(), this);
+    }
+    /**
+     * Gives the user feedback for the action he/she is about to do. Currently
+     * calls the cursor and target highlighting routines. Allows for modifiers
+     * not taken from the given mouse event.
+     * 
      * Normally the mouse event also contains the modifiers. However, when the
      * mouse is not moved and only modifier keys are pressed, no mouse event
@@ -170 +247 @@
      * mouseevent. Instead we copy the previous event and only update the
      * modifiers.
-     *
-     * @param MouseEvent
-     * @param int modifiers
-     */
-    private void updateCursor(MouseEvent e, int modifiers) {
-        if (!Main.isDisplayingMapView())
-            return;
-        if(!Main.map.mapView.isActiveLayerVisible() || e == null)
-            return;
-
-        DeleteParameters parameters = getDeleteParameters(e, modifiers);
-        Main.map.mapView.setNewCursor(parameters.mode.cursor(), this);
+     */
+    private void giveUserFeedback(MouseEvent e, int modifiers) {
+        updateCursor(e, modifiers);
+        addHighlighting(e, modifiers);
+    }
+
+    /**
+     * Gives the user feedback for the action he/she is about to do. Currently
+     * calls the cursor and target highlighting routines. Extracts modifiers
+     * from mouse event.
+     */
+    private void giveUserFeedback(MouseEvent e) {
+        giveUserFeedback(e, e.getModifiers());
     }
 
@@ -204 +282 @@
 
         getCurrentDataSet().setSelected();
+        giveUserFeedback(e);
         Main.map.mapView.repaint();
     }
@@ -242 +321 @@
 
     private DeleteParameters getDeleteParameters(MouseEvent e, int modifiers) {
-        // Note: CTRL is the only modifier that is checked in MouseMove, don't
-        // forget updating it there
-        boolean ctrl = (modifiers & ActionEvent.CTRL_MASK) != 0;
-        boolean shift = (modifiers & ActionEvent.SHIFT_MASK) != 0;
-        boolean alt = (modifiers & (ActionEvent.ALT_MASK|InputEvent.ALT_GRAPH_MASK)) != 0;
+        updateKeyModifiers(modifiers);
 
         DeleteParameters result = new DeleteParameters();
@@ -288 +363 @@
             return DeleteCommand.delete(getEditLayer(),Collections.singleton(parameters.nearestNode), false, silent);
         case node_with_references:
-            return DeleteCommand.deleteWithReferences(getEditLayer(),Collections.singleton(parameters.nearestNode));
+            return DeleteCommand.deleteWithReferences(getEditLayer(),Collections.singleton(parameters.nearestNode), silent);
         case segment:
             return DeleteCommand.deleteWaySegment(getEditLayer(), parameters.nearestSegment);
@@ -296 +371 @@
             return DeleteCommand.delete(getEditLayer(), Collections.singleton(parameters.nearestSegment.way), true, silent);
         case way_with_references:
-            return DeleteCommand.deleteWithReferences(getEditLayer(),Collections.singleton(parameters.nearestSegment.way),true);
+            return DeleteCommand.deleteWithReferences(getEditLayer(), Collections.singleton(parameters.nearestSegment.way), true);
         default:
             return null;
@@ -306 +381 @@
      */
     public void eventDispatched(AWTEvent e) {
+        if(e == null)
+            return;
         // We don't have a mouse event, so we pass the old mouse event but the
         // new modifiers.
-        updateCursor(oldEvent, ((InputEvent)e).getModifiers());
+        giveUserFeedback(oldEvent, ((InputEvent) e).getModifiers());
     }
 }

trunk/src/org/openstreetmap/josm/actions/mapmode/DrawAction.java

@@ -9 +9 @@
 import java.awt.Color;
 import java.awt.Cursor;
-import java.awt.EventQueue;
 import java.awt.Graphics2D;
 import java.awt.Point;
 import java.awt.Toolkit;
 import java.awt.event.AWTEventListener;
-import java.awt.event.ActionEvent;
 import java.awt.event.InputEvent;
 import java.awt.event.KeyEvent;
@@ -66 +64 @@
     private double PHI=Math.toRadians(90);
 
-    private boolean ctrl;
-    private boolean alt;
-    private boolean shift;
     private Node mouseOnExistingNode;
     private Set<Way> mouseOnExistingWays = new HashSet<Way>();
@@ -513 +508 @@
         getCurrentDataSet().setSelected(newSelection);
 
-        // "viewport following" mode for tracing long features 
-        // from aerial imagery or GPS tracks. 
+        // "viewport following" mode for tracing long features
+        // from aerial imagery or GPS tracks.
         if (n != null && Main.map.mapView.viewportFollowing) {
             Main.map.mapView.smoothScrollTo(n.getEastNorth());
@@ -602 +597 @@
     }
 
-    private void updateKeyModifiers(InputEvent e) {
-        ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0;
-        alt = (e.getModifiers() & (ActionEvent.ALT_MASK|InputEvent.ALT_GRAPH_MASK)) != 0;
-        shift = (e.getModifiers() & ActionEvent.SHIFT_MASK) != 0;
-    }
-
-    private void updateKeyModifiers(MouseEvent e) {
-        ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0;
-        alt = (e.getModifiers() & (ActionEvent.ALT_MASK|InputEvent.ALT_GRAPH_MASK)) != 0;
-        shift = (e.getModifiers() & ActionEvent.SHIFT_MASK) != 0;
-    }
-
     /**
      * This method prepares data required for painting the "helper line" from

trunk/src/org/openstreetmap/josm/actions/mapmode/ExtrudeAction.java

@@ -185 +185 @@
             return;
 
+        updateKeyModifiers(e);
+
         selectedSegment = Main.map.mapView.getNearestWaySegment(e.getPoint(), OsmPrimitive.isSelectablePredicate);
 
@@ -192 +194 @@
             // Otherwise switch to another mode
 
-            if ((e.getModifiers() & ActionEvent.CTRL_MASK) != 0) {
+            if (ctrl) {
                 mode = Mode.translate;
-            } else if ((e.getModifiers() & (ActionEvent.ALT_MASK|InputEvent.ALT_GRAPH_MASK)) != 0) {
+            } else if (alt) {
                 mode = Mode.create_new;
                 // create a new segment and then select and extrude the new segment
@@ -202 +204 @@
                 mode = Mode.extrude;
                 getCurrentDataSet().setSelected(selectedSegment.way);
-                alwaysCreateNodes = ((e.getModifiers() & ActionEvent.SHIFT_MASK) != 0);
+                alwaysCreateNodes = shift;
             }
 

trunk/src/org/openstreetmap/josm/actions/mapmode/MapMode.java

@@ -4 +4 @@
 import java.awt.Cursor;
 import java.awt.event.ActionEvent;
+import java.awt.event.InputEvent;
 import java.awt.event.MouseEvent;
 import java.awt.event.MouseListener;
@@ -25 +26 @@
 abstract public class MapMode extends JosmAction implements MouseListener, MouseMotionListener {
     protected final Cursor cursor;
+    protected boolean ctrl;
+    protected boolean alt;
+    protected boolean shift;
 
     /**
@@ -77 +81 @@
     }
 
+    protected void updateKeyModifiers(InputEvent e) {
+        updateKeyModifiers(e.getModifiers());
+    }
+
+    protected void updateKeyModifiers(MouseEvent e) {
+        updateKeyModifiers(e.getModifiers());
+    }
+
+    protected void updateKeyModifiers(int modifiers) {
+        ctrl = (modifiers & ActionEvent.CTRL_MASK) != 0;
+        alt = (modifiers & (ActionEvent.ALT_MASK|InputEvent.ALT_GRAPH_MASK)) != 0;
+        shift = (modifiers & ActionEvent.SHIFT_MASK) != 0;
+    }
+
     public void mouseReleased(MouseEvent e) {}
     public void mouseExited(MouseEvent e) {}

trunk/src/org/openstreetmap/josm/actions/mapmode/ParallelWayAction.java

@@ -14 +14 @@
 import java.awt.Toolkit;
 import java.awt.event.AWTEventListener;
-import java.awt.event.ActionEvent;
 import java.awt.event.InputEvent;
 import java.awt.event.KeyEvent;
@@ -109 +108 @@
     private final MapView mv;
 
-    private boolean ctrl;
-    private boolean alt;
-    private boolean shift;
-
     // Mouse tracking state
     private Point mousePressedPos;
@@ -233 +228 @@
     private boolean updateModifiersState(InputEvent e) {
         boolean oldAlt = alt, oldShift = shift, oldCtrl = ctrl;
-        alt = (e.getModifiers() & (ActionEvent.ALT_MASK | InputEvent.ALT_GRAPH_MASK)) != 0;
-        ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0;
-        shift = (e.getModifiers() & ActionEvent.SHIFT_MASK) != 0;
+        updateKeyModifiers(e);
         boolean changed = (oldAlt != alt || oldShift != shift || oldCtrl != ctrl);
         return changed;
@@ -394 +387 @@
             if (!isModifiersValidForDragMode())
                 return;
-            if (!initParallelWays(mousePressedPos, copyTags)) {
+            if (!initParallelWays(mousePressedPos, copyTags))
                 return;
-            }
             setMode(Mode.dragging);
         }
@@ -409 +401 @@
         double realD = mv.getProjection().eastNorth2latlon(enp).greatCircleDistance(mv.getProjection().eastNorth2latlon(nearestPointOnRefLine));
         double snappedRealD = realD;
-        
+
         // TODO: abuse of isToTheRightSideOfLine function.
         boolean toTheRight = Geometry.isToTheRightSideOfLine(referenceSegment.getFirstNode(),
@@ -431 +423 @@
         }
         pWays.changeOffset(d);
-        
+
         Main.map.statusLine.setDist(Math.abs(snappedRealD));
         Main.map.statusLine.repaint();

trunk/src/org/openstreetmap/josm/actions/mapmode/PlayHeadDragMode.java

@@ -6 +6 @@
 import java.awt.Cursor;
 import java.awt.Point;
-import java.awt.event.ActionEvent;
 import java.awt.event.MouseEvent;
 
@@ -28 +27 @@
     public PlayHeadDragMode(PlayHeadMarker m) {
         super(tr("Drag play head"), "playheaddrag", tr("Drag play head"), null,
-        Main.map, Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
+                Main.map, Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
         playHeadMarker = m;
     }
@@ -68 +67 @@
         if (ev.getButton() != MouseEvent.BUTTON1 || p == null || ! dragging)
             return;
-        boolean shift = (ev.getModifiers() & ActionEvent.SHIFT_MASK) != 0;
+
+        updateKeyModifiers(ev);
+
         EastNorth en = Main.map.mapView.getEastNorth(ev.getX(), ev.getY());
         if (! shift) {

trunk/src/org/openstreetmap/josm/actions/mapmode/SelectAction.java

@@ -6 +6 @@
 import static org.openstreetmap.josm.tools.I18n.trn;
 
+import java.awt.AWTEvent;
 import java.awt.Cursor;
 import java.awt.Point;
 import java.awt.Rectangle;
+import java.awt.Toolkit;
+import java.awt.event.AWTEventListener;
 import java.awt.event.ActionEvent;
 import java.awt.event.InputEvent;
@@ -16 +19 @@
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedList;
+import java.util.Set;
 
 import javax.swing.JOptionPane;
@@ -60 +65 @@
  * @author imi
  */
-public class SelectAction extends MapMode implements SelectionEnded {
+public class SelectAction extends MapMode implements AWTEventListener, SelectionEnded {
+    // "select" means the selection rectangle and "move" means either dragging
+    // or select if no mouse movement occurs (i.e. just clicking)
     enum Mode { move, rotate, scale, select }
-    
+
+    // contains all possible cases the cursor can be in the SelectAction except the
+    // the move pointer (latter is a system one and not an image)
+    private enum SelectActionCursor {
+        rect("normal", "selection"),
+        rect_add("normal", "select_add"),
+        rect_rm("normal", "select_remove"),
+        way("normal", "select_way"),
+        way_add("normal", "select_way_add"),
+        way_rm("normal", "select_way_remove"),
+        node("normal", "select_node"),
+        node_add("normal", "select_node_add"),
+        node_rm("normal", "select_node_remove"),
+        virtual_node("normal", "addnode"),
+        scale("scale", null),
+        rotate("rotate", null);
+
+        private final Cursor c;
+        private SelectActionCursor(String main, String sub) {
+            c = ImageProvider.getCursor(main, sub);
+        }
+        public Cursor cursor() {
+            return c;
+        }
+    }
+
+    // Cache previous mouse event (needed when only the modifier keys are
+    // pressed but the mouse isn't moved)
+    private MouseEvent oldEvent = null;
+
     private Mode mode = null;
     private SelectionManager selectionManager;
     private boolean cancelDrawMode = false;
+    private boolean drawTargetHighlight;
     private boolean didMouseDrag = false;
     /**
@@ -94 +131 @@
     private int initialMoveThreshold;
     private boolean initialMoveThresholdExceeded = false;
+
+    /**
+     * elements that have been highlighted in the previous iteration. Used
+     * to remove the highlight from them again as otherwise the whole data
+     * set would have to be checked.
+     */
+    private Set<OsmPrimitive> oldHighlights = new HashSet<OsmPrimitive>();
 
     /**
@@ -109 +153 @@
         initialMoveDelay = Main.pref.getInteger("edit.initial-move-delay", 200);
         initialMoveThreshold = Main.pref.getInteger("edit.initial-move-threshold", 5);
+        drawTargetHighlight = Main.pref.getBoolean("draw.target-highlight", true);
+        // This is required to update the cursors when ctrl/shift/alt is pressed
+        try {
+            Toolkit.getDefaultToolkit().addAWTEventListener(this, AWTEvent.KEY_EVENT_MASK);
+        } catch (SecurityException ex) {
+            System.out.println(ex);
+        }
     }
 
@@ -127 +178 @@
         mv.removeMouseMotionListener(this);
         mv.setVirtualNodesEnabled(false);
+        removeHighlighting();
+    }
+
+    /**
+     * works out which cursor should be displayed for most of SelectAction's
+     * features. The only exception is the "move" cursor when actually dragging
+     * primitives.
+     * @param nearbyStuff  primitives near the cursor
+     * @return the cursor that should be displayed
+     */
+    private Cursor getCursor(Collection<OsmPrimitive> nearbyStuff) {
+        String c = "rect";
+        switch(mode) {
+        case move:
+            if(virtualNode != null) {
+                c = "virtual_node";
+                break;
+            }
+
+            // nearbyStuff cannot be empty as otherwise we would be in
+            // Move.select and not Move.move
+            OsmPrimitive osm = nearbyStuff.iterator().next();
+
+            c = (osm instanceof Node) ? "node" : c;
+            c = (osm instanceof Way) ? "way" : c;
+
+            if(shift) {
+                c += "_add";
+            } else if(ctrl) {
+                c += osm.isSelected() ? "_rm" : "_add";
+            }
+            break;
+        case rotate:
+            c = "rotate";
+            break;
+        case scale:
+            c = "scale";
+            break;
+        case select:
+            c = "rect" + (shift ? "_add" : (ctrl ? "_rm" : ""));
+            break;
+        }
+        return SelectActionCursor.valueOf(c).cursor();
+    }
+
+    /**
+     * Removes all existing highlights.
+     * @return true if a repaint is required
+     */
+    private boolean removeHighlighting() {
+        boolean needsRepaint = false;
+        DataSet ds = getCurrentDataSet();
+        if(ds != null && !ds.getHighlightedVirtualNodes().isEmpty()) {
+            needsRepaint = true;
+            ds.clearHighlightedVirtualNodes();
+        }
+        if(oldHighlights.isEmpty())
+            return needsRepaint;
+
+        for(OsmPrimitive prim : oldHighlights) {
+            prim.setHighlighted(false);
+        }
+        oldHighlights = new HashSet<OsmPrimitive>();
+        return true;
+    }
+
+    /**
+     * handles adding highlights and updating the cursor for the given mouse event.
+     * @param MouseEvent which should be used as base for the feedback
+     * @return true if repaint is required
+     */
+    private boolean giveUserFeedback(MouseEvent e) {
+        return giveUserFeedback(e, e.getModifiers());
+    }
+
+    /**
+     * handles adding highlights and updating the cursor for the given mouse event.
+     * @param MouseEvent which should be used as base for the feedback
+     * @param define custom keyboard modifiers if the ones from MouseEvent are outdated or similar
+     * @return true if repaint is required
+     */
+    private boolean giveUserFeedback(MouseEvent e, int modifiers) {
+        boolean needsRepaint = false;
+
+        Collection<OsmPrimitive> c = MapView.asColl(
+                mv.getNearestNodeOrWay(e.getPoint(), OsmPrimitive.isSelectablePredicate, true));
+
+        updateKeyModifiers(modifiers);
+        determineMapMode(!c.isEmpty());
+
+        if(drawTargetHighlight) {
+            needsRepaint = removeHighlighting();
+        }
+
+        virtualWays.clear();
+        virtualNode = null;
+        if(mode == Mode.move && setupVirtual(e)) {
+            DataSet ds = getCurrentDataSet();
+            if (ds != null) {
+                ds.setHighlightedVirtualNodes(virtualWays);
+            }
+            mv.setNewCursor(SelectActionCursor.virtual_node.cursor(), this);
+            // don't highlight anything else if a virtual node will be
+            return true;
+        }
+
+        mv.setNewCursor(getCursor(c), this);
+
+        // return early if there can't be any highlights
+        if(!drawTargetHighlight || mode != Mode.move || c.isEmpty())
+            return needsRepaint;
+
+        for(OsmPrimitive x : c) {
+            // only highlight primitives that will change the selection
+            // when clicked. I.e. don't highlight selected elements unless
+            // we are in toggle mode.
+            if(ctrl || !x.isSelected()) {
+                x.setHighlighted(true);
+                oldHighlights.add(x);
+            }
+        }
+        return needsRepaint || !oldHighlights.isEmpty();
+    }
+
+    /**
+     * This is called whenever the keyboard modifier status changes
+     */
+    public void eventDispatched(AWTEvent e) {
+        if(oldEvent == null)
+            return;
+        // We don't have a mouse event, so we pass the old mouse event but the
+        // new modifiers.
+        giveUserFeedback(oldEvent, ((InputEvent) e).getModifiers());
     }
 
@@ -264 +448 @@
     public void mouseMoved(MouseEvent e) {
         // Mac OSX simulates with  ctrl + mouse 1  the second mouse button hence no dragging events get fired.
-        //
         if ((Main.platform instanceof PlatformHookOsx) && (mode == Mode.rotate || mode == Mode.scale)) {
             mouseDragged(e);
-        }
-    }
+            return;
+        }
+        oldEvent = e;
+        if(giveUserFeedback(e)) {
+            mv.repaint();
+        }
+    }
+
+    @Override
+    public void mouseExited(MouseEvent e) {
+        if(removeHighlighting()) {
+            mv.repaint();
+        }
+    }
+
     private Node virtualNode = null;
     private Collection<WaySegment> virtualWays = new LinkedList<WaySegment>();
@@ -339 +535 @@
             Point p = e.getPoint();
             boolean waitForMouseUp = Main.pref.getBoolean("mappaint.select.waits-for-mouse-up", false);
-            boolean ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0;
-            boolean alt = ((e.getModifiers() & (ActionEvent.ALT_MASK | InputEvent.ALT_GRAPH_MASK)) != 0 || Main.pref.getBoolean("selectaction.cycles.multiple.matches", false));
+            updateKeyModifiers(e);
+            alt = alt || Main.pref.getBoolean("selectaction.cycles.multiple.matches", false);
 
             if (!alt) {
@@ -389 +585 @@
 
     /**
+     * sets the mapmode according to key modifiers and if there are any
+     * selectables nearby. Everything has to be pre-determined for this
+     * function; its main purpose is to centralize what the modifiers do.
+     * @param nearSelectables
+     */
+    private void determineMapMode(boolean hasSelectionNearby) {
+        if (shift && ctrl) {
+            mode = Mode.rotate;
+        } else if (alt && ctrl) {
+            mode = Mode.scale;
+        } else if (hasSelectionNearby) {
+            mode = Mode.move;
+        } else {
+            mode = Mode.select;
+        }
+    }
+
+    /**
      * Look, whether any object is selected. If not, select the nearest node.
      * If there are no nodes in the dataset, do nothing.
@@ -400 +614 @@
     public void mousePressed(MouseEvent e) {
         // return early
-        if (!mv.isActiveLayerVisible() || !(Boolean) this.getValue("active") || e.getButton() != MouseEvent.BUTTON1) {
-            return;
-        }
+        if (!mv.isActiveLayerVisible() || !(Boolean) this.getValue("active") || e.getButton() != MouseEvent.BUTTON1)
+            return;
 
         // request focus in order to enable the expected keyboard shortcuts
         mv.requestFocus();
 
-        boolean ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0;
-        boolean shift = (e.getModifiers() & ActionEvent.SHIFT_MASK) != 0;
-        boolean alt = (e.getModifiers() & ActionEvent.ALT_MASK) != 0;
+        // update which modifiers are pressed (shift, alt, ctrl)
+        updateKeyModifiers(e);
 
         // We don't want to change to draw tool if the user tries to (de)select
@@ -422 +634 @@
                 mv.getNearestNodeOrWay(e.getPoint(), OsmPrimitive.isSelectablePredicate, true));
 
-        if (shift && ctrl) {
-            mode = Mode.rotate;
-
+        determineMapMode(!c.isEmpty());
+        switch(mode) {
+        case rotate:
+        case scale:
             if (getCurrentDataSet().getSelected().isEmpty()) {
                 getCurrentDataSet().setSelected(c);
@@ -432 +645 @@
             // Mode.move   redraws when mouseDragged is called
             // Mode.rotate redraws here
-            mv.setNewCursor(ImageProvider.getCursor("rotate", null), this);
-            mv.repaint();
-        } else if (alt && ctrl) {
-            mode = Mode.scale;
-
-            if (getCurrentDataSet().getSelected().isEmpty()) {
-                getCurrentDataSet().setSelected(c);
-            }
-
-            // Mode.select redraws when selectPrims is called
-            // Mode.move   redraws when mouseDragged is called
             // Mode.scale redraws here
-            mv.setNewCursor(ImageProvider.getCursor("scale", null), this);
-            mv.repaint();
-        } else if (!c.isEmpty()) {
-            mode = Mode.move;
-
+            break;
+        case move:
             if (!cancelDrawMode && c.iterator().next() instanceof Way) {
                 setupVirtual(e);
@@ -454 +653 @@
 
             selectPrims(cycleSetup(c, e), e, false, false);
-        } else {
-            mode = Mode.select;
-
+            break;
+        case select:
+        default:
             selectionManager.register(mv);
             selectionManager.mousePressed(e);
-        }
-
+            break;
+        }
+        giveUserFeedback(e);
+        mv.repaint();
         updateStatusLine();
     }
@@ -466 +667 @@
     @Override
     public void mouseReleased(MouseEvent e) {
-        if (!mv.isActiveLayerVisible()) {
-            return;
-        }
+        if (!mv.isActiveLayerVisible())
+            return;
 
         startingDraggingPos = null;
 
-        mv.setNewCursor(cursor, this);
         if (mode == Mode.select) {
             selectionManager.unregister(mv);
@@ -489 +688 @@
                 virtualNode = null;
 
-                // do nothing if the click was to short to be recognized as a drag,
+                // do nothing if the click was to short too be recognized as a drag,
                 // but the release position is farther than 10px away from the press position
-                if (lastMousePos.distanceSq(e.getPoint()) < 100) {
+                if (lastMousePos == null || lastMousePos.distanceSq(e.getPoint()) < 100) {
                     selectPrims(cyclePrims(cycleList, e), e, true, false);
 
@@ -500 +699 @@
                         // click and switch back to SelectMode
                         Main.worker.execute(new Runnable() {
-
                             public void run() {
                                 Main.map.selectDrawTool(true);
@@ -539 +737 @@
         }
 
-        // I don't see why we need this.
-        //updateStatusLine();
         mode = null;
+        giveUserFeedback(e);
         updateStatusLine();
     }
 
     public void selectionEnded(Rectangle r, MouseEvent e) {
-        boolean alt = (e.getModifiersEx() & (MouseEvent.ALT_DOWN_MASK | MouseEvent.ALT_GRAPH_DOWN_MASK)) != 0;
+        updateKeyModifiers(e);
         selectPrims(selectionManager.getObjectsInRectangle(r, alt), e, true, true);
     }
@@ -554 +751 @@
      * selection cycle given by <code>prims</code>.
      * @param prims the primitives that form the selection cycle
-     * @param shift whether shift is pressed
-     * @param ctrl whether ctrl is pressed
+     * @param mouse event
      * @return the next element of cycle list <code>prims</code>.
      */
@@ -562 +758 @@
 
         if (prims.size() > 1) {
-            boolean ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0;
-            boolean shift = (e.getModifiers() & ActionEvent.SHIFT_MASK) != 0;
+            updateKeyModifiers(e);
 
             DataSet ds = getCurrentDataSet();
@@ -630 +825 @@
 
     private void selectPrims(Collection<OsmPrimitive> prims, MouseEvent e, boolean released, boolean area) {
-        boolean ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0;
-        boolean shift = (e.getModifiers() & ActionEvent.SHIFT_MASK) != 0;
+        updateKeyModifiers(e);
         DataSet ds = getCurrentDataSet();
 
         // not allowed together: do not change dataset selection, return early
-        if ((shift && ctrl) || (ctrl && !released) || (!virtualWays.isEmpty())) {
-            return;
-        }
+        if ((shift && ctrl) || (ctrl && !released) || (!virtualWays.isEmpty()))
+            return;
 
         if (!released) {
@@ -666 +859 @@
     @Override
     public String getModeHelpText() {
-        if (mode == Mode.select) {
+        if (mode == Mode.select)
             return tr("Release the mouse button to select the objects in the rectangle.");
-        } else if (mode == Mode.move) {
+        else if (mode == Mode.move)
             return tr("Release the mouse button to stop moving. Ctrl to merge with nearest node.");
-        } else if (mode == Mode.rotate) {
+        else if (mode == Mode.rotate)
             return tr("Release the mouse button to stop rotating.");
-        } else if (mode == Mode.scale) {
+        else if (mode == Mode.scale)
             return tr("Release the mouse button to stop scaling.");
-        } else {
+        else
             return tr("Move objects by dragging; Shift to add to selection (Ctrl to toggle); Shift-Ctrl to rotate selected; Alt-Ctrl to scale selected; or change selection");
-        }
     }