source: josm/trunk/src/org/openstreetmap/josm/actions/mapmode/SelectAction.java @ 5241

Revision 5174, 38.5 KB checked in by akks, 6 weeks ago (diff)

should fix #7580 - NPE on Alt-F4 (while in select-moving mode)
  • Property svn:eol-style set to native
Line 
1// License: GPL. Copyright 2007 by Immanuel Scholz and others
2package org.openstreetmap.josm.actions.mapmode;
3
4import static org.openstreetmap.josm.gui.help.HelpUtil.ht;
5import static org.openstreetmap.josm.tools.I18n.tr;
6import static org.openstreetmap.josm.tools.I18n.trn;
7
8import java.awt.AWTEvent;
9import java.awt.Cursor;
10import java.awt.Point;
11import java.awt.Rectangle;
12import java.awt.Toolkit;
13import java.awt.event.AWTEventListener;
14import java.awt.event.InputEvent;
15import java.awt.event.KeyEvent;
16import java.awt.event.MouseEvent;
17import java.awt.geom.Point2D;
18import java.util.Collection;
19import java.util.Collections;
20import java.util.HashSet;
21import java.util.Iterator;
22import java.util.LinkedList;
23import java.util.Set;
24
25import javax.swing.JOptionPane;
26
27import org.openstreetmap.josm.Main;
28import org.openstreetmap.josm.actions.MergeNodesAction;
29import org.openstreetmap.josm.command.AddCommand;
30import org.openstreetmap.josm.command.ChangeCommand;
31import org.openstreetmap.josm.command.Command;
32import org.openstreetmap.josm.command.MoveCommand;
33import org.openstreetmap.josm.command.RotateCommand;
34import org.openstreetmap.josm.command.ScaleCommand;
35import org.openstreetmap.josm.command.SequenceCommand;
36import org.openstreetmap.josm.data.coor.EastNorth;
37import org.openstreetmap.josm.data.osm.DataSet;
38import org.openstreetmap.josm.data.osm.Node;
39import org.openstreetmap.josm.data.osm.OsmPrimitive;
40import org.openstreetmap.josm.data.osm.Way;
41import org.openstreetmap.josm.data.osm.WaySegment;
42import org.openstreetmap.josm.data.osm.visitor.AllNodesVisitor;
43import org.openstreetmap.josm.data.osm.visitor.paint.WireframeMapRenderer;
44import org.openstreetmap.josm.gui.ExtendedDialog;
45import org.openstreetmap.josm.gui.MapFrame;
46import org.openstreetmap.josm.gui.MapView;
47import org.openstreetmap.josm.gui.SelectionManager;
48import org.openstreetmap.josm.gui.SelectionManager.SelectionEnded;
49import org.openstreetmap.josm.gui.layer.Layer;
50import org.openstreetmap.josm.gui.layer.OsmDataLayer;
51import org.openstreetmap.josm.tools.ImageProvider;
52import org.openstreetmap.josm.tools.Pair;
53import org.openstreetmap.josm.tools.PlatformHookOsx;
54import org.openstreetmap.josm.tools.Shortcut;
55
56/**
57 * Move is an action that can move all kind of OsmPrimitives (except keys for now).
58 *
59 * If an selected object is under the mouse when dragging, move all selected objects.
60 * If an unselected object is under the mouse when dragging, it becomes selected
61 * and will be moved.
62 * If no object is under the mouse, move all selected objects (if any)
63 *
64 * @author imi
65 */
66public class SelectAction extends MapMode implements AWTEventListener, SelectionEnded {
67    // "select" means the selection rectangle and "move" means either dragging
68    // or select if no mouse movement occurs (i.e. just clicking)
69    enum Mode { move, rotate, scale, select }
70
71    // contains all possible cases the cursor can be in the SelectAction
72    static private enum SelectActionCursor {
73        rect("normal", "selection"),
74        rect_add("normal", "select_add"),
75        rect_rm("normal", "select_remove"),
76        way("normal", "select_way"),
77        way_add("normal", "select_way_add"),
78        way_rm("normal", "select_way_remove"),
79        node("normal", "select_node"),
80        node_add("normal", "select_node_add"),
81        node_rm("normal", "select_node_remove"),
82        virtual_node("normal", "addnode"),
83        scale("scale", null),
84        rotate("rotate", null),
85        merge("crosshair", null),
86        lasso("normal", "rope"),
87        merge_to_node("crosshair", "joinnode"),
88        move(Cursor.MOVE_CURSOR);
89
90        private final Cursor c;
91        private SelectActionCursor(String main, String sub) {
92            c = ImageProvider.getCursor(main, sub);
93        }
94        private SelectActionCursor(int systemCursor) {
95            c = Cursor.getPredefinedCursor(systemCursor);
96        }
97        public Cursor cursor() {
98            return c;
99        }
100    }
101
102    private boolean lassoMode = false;
103
104    // Cache previous mouse event (needed when only the modifier keys are
105    // pressed but the mouse isn't moved)
106    private MouseEvent oldEvent = null;
107
108    private Mode mode = null;
109    private SelectionManager selectionManager;
110    private boolean cancelDrawMode = false;
111    private boolean drawTargetHighlight;
112    private boolean didMouseDrag = false;
113    /**
114     * The component this SelectAction is associated with.
115     */
116    private final MapView mv;
117    /**
118     * The old cursor before the user pressed the mouse button.
119     */
120    private Point startingDraggingPos;
121    /**
122     * The last known position of the mouse.
123     */
124    private Point lastMousePos;
125    /**
126     * The time of the user mouse down event.
127     */
128    private long mouseDownTime = 0;
129    /**
130     * The pressed button of the user mouse down event.
131     */
132    private int mouseDownButton = 0;
133    /**
134     * The time of the user mouse down event.
135     */
136    private long mouseReleaseTime = 0;
137    /**
138     * The time which needs to pass between click and release before something
139     * counts as a move, in milliseconds
140     */
141    private int initialMoveDelay;
142    /**
143     * The screen distance which needs to be travelled before something
144     * counts as a move, in pixels
145     */
146    private int initialMoveThreshold;
147    private boolean initialMoveThresholdExceeded = false;
148
149    /**
150     * elements that have been highlighted in the previous iteration. Used
151     * to remove the highlight from them again as otherwise the whole data
152     * set would have to be checked.
153     */
154    private Set<OsmPrimitive> oldHighlights = new HashSet<OsmPrimitive>();
155
156    /**
157     * Create a new SelectAction
158     * @param mapFrame The MapFrame this action belongs to.
159     */
160    public SelectAction(MapFrame mapFrame) {
161        super(tr("Select"), "move/move", tr("Select, move, scale and rotate objects"),
162                Shortcut.registerShortcut("mapmode:select", tr("Mode: {0}", tr("Select")), KeyEvent.VK_S, Shortcut.DIRECT),
163                mapFrame,
164                ImageProvider.getCursor("normal", "selection"));
165        mv = mapFrame.mapView;
166        putValue("help", ht("/Action/Select"));
167        selectionManager = new SelectionManager(this, false, mv);
168        initialMoveDelay = Main.pref.getInteger("edit.initial-move-delay", 200);
169        initialMoveThreshold = Main.pref.getInteger("edit.initial-move-threshold", 5);
170    }
171
172    @Override
173    public void enterMode() {
174        super.enterMode();
175        mv.addMouseListener(this);
176        mv.addMouseMotionListener(this);
177        mv.setVirtualNodesEnabled(Main.pref.getInteger("mappaint.node.virtual-size", 8) != 0);
178        drawTargetHighlight = Main.pref.getBoolean("draw.target-highlight", true);
179        // This is required to update the cursors when ctrl/shift/alt is pressed
180        try {
181            Toolkit.getDefaultToolkit().addAWTEventListener(this, AWTEvent.KEY_EVENT_MASK);
182        } catch (SecurityException ex) {}
183    }
184
185    @Override
186    public void exitMode() {
187        super.exitMode();
188        selectionManager.unregister(mv);
189        mv.removeMouseListener(this);
190        mv.removeMouseMotionListener(this);
191        mv.setVirtualNodesEnabled(false);
192        try {
193            Toolkit.getDefaultToolkit().removeAWTEventListener(this);
194        } catch (SecurityException ex) {}
195        removeHighlighting();
196    }
197
198    /**
199     * works out which cursor should be displayed for most of SelectAction's
200     * features. The only exception is the "move" cursor when actually dragging
201     * primitives.
202     * @param nearbyStuff  primitives near the cursor
203     * @return the cursor that should be displayed
204     */
205    private Cursor getCursor(Collection<OsmPrimitive> nearbyStuff) {
206        String c = "rect";
207        switch(mode) {
208        case move:
209            if(virtualNode != null) {
210                c = "virtual_node";
211                break;
212            }
213            final Iterator<OsmPrimitive> it = nearbyStuff.iterator();
214            final OsmPrimitive osm = it.hasNext() ? it.next() : null;
215
216            if(dragInProgress()) {
217                // only consider merge if ctrl is pressed and there are nodes in
218                // the selection that could be merged
219                if(!ctrl || getCurrentDataSet().getSelectedNodes().isEmpty()) {
220                    c = "move";
221                    break;
222                }
223                // only show merge to node cursor if nearby node and that node is currently
224                // not being dragged
225                final boolean hasTarget = osm != null && osm instanceof Node && !osm.isSelected();
226                c = hasTarget ? "merge_to_node" : "merge";
227                break;
228            }
229
230            c = (osm instanceof Node) ? "node" : c;
231            c = (osm instanceof Way) ? "way" : c;
232            if(shift) {
233                c += "_add";
234            } else if(ctrl) {
235                c += osm == null || osm.isSelected() ? "_rm" : "_add";
236            }
237            break;
238        case rotate:
239            c = "rotate";
240            break;
241        case scale:
242            c = "scale";
243            break;
244        case select:
245            if (lassoMode) {
246                c = "lasso";
247            } else {
248                c = "rect" + (shift ? "_add" : (ctrl ? "_rm" : ""));
249            }
250            break;
251        }
252        return SelectActionCursor.valueOf(c).cursor();
253    }
254
255    /**
256     * Removes all existing highlights.
257     * @return true if a repaint is required
258     */
259    private boolean removeHighlighting() {
260        boolean needsRepaint = false;
261        DataSet ds = getCurrentDataSet();
262        if(ds != null && !ds.getHighlightedVirtualNodes().isEmpty()) {
263            needsRepaint = true;
264            ds.clearHighlightedVirtualNodes();
265        }
266        if(oldHighlights.isEmpty())
267            return needsRepaint;
268
269        for(OsmPrimitive prim : oldHighlights) {
270            prim.setHighlighted(false);
271        }
272        oldHighlights = new HashSet<OsmPrimitive>();
273        return true;
274    }
275
276    private boolean repaintIfRequired(HashSet<OsmPrimitive> newHighlights) {
277        if(!drawTargetHighlight)
278            return false;
279
280        boolean needsRepaint = false;
281        for(OsmPrimitive x : newHighlights) {
282            if(oldHighlights.contains(x)) {
283                continue;
284            }
285            needsRepaint = true;
286            x.setHighlighted(true);
287        }
288        oldHighlights.removeAll(newHighlights);
289        for(OsmPrimitive x : oldHighlights) {
290            x.setHighlighted(false);
291            needsRepaint = true;
292        }
293        oldHighlights = newHighlights;
294        return needsRepaint;
295    }
296
297    /**
298     * handles adding highlights and updating the cursor for the given mouse event.
299     * Please note that the highlighting for merging while moving is handled via mouseDragged.
300     * @param MouseEvent which should be used as base for the feedback
301     * @return true if repaint is required
302     */
303    private boolean giveUserFeedback(MouseEvent e) {
304        return giveUserFeedback(e, e.getModifiers());
305    }
306
307    /**
308     * handles adding highlights and updating the cursor for the given mouse event.
309     * Please note that the highlighting for merging while moving is handled via mouseDragged.
310     * @param MouseEvent which should be used as base for the feedback
311     * @param define custom keyboard modifiers if the ones from MouseEvent are outdated or similar
312     * @return true if repaint is required
313     */
314    private boolean giveUserFeedback(MouseEvent e, int modifiers) {
315        Collection<OsmPrimitive> c = MapView.asColl(
316                mv.getNearestNodeOrWay(e.getPoint(), OsmPrimitive.isSelectablePredicate, true));
317
318        updateKeyModifiers(modifiers);
319        determineMapMode(!c.isEmpty());
320
321        HashSet<OsmPrimitive> newHighlights = new HashSet<OsmPrimitive>();
322
323        virtualWays.clear();
324        virtualNode = null;
325        if(mode == Mode.move && setupVirtual(e)) {
326            DataSet ds = getCurrentDataSet();
327            if (ds != null && drawTargetHighlight) {
328                ds.setHighlightedVirtualNodes(virtualWays);
329            }
330            mv.setNewCursor(SelectActionCursor.virtual_node.cursor(), this);
331            // don't highlight anything else if a virtual node will be
332            return repaintIfRequired(newHighlights);
333        }
334
335        mv.setNewCursor(getCursor(c), this);
336
337        // return early if there can't be any highlights
338        if(!drawTargetHighlight || mode != Mode.move || c.isEmpty())
339            return repaintIfRequired(newHighlights);
340
341        // CTRL toggles selection, but if while dragging CTRL means merge
342        final boolean isToggleMode = ctrl && !dragInProgress();
343        for(OsmPrimitive x : c) {
344            // only highlight primitives that will change the selection
345            // when clicked. I.e. don't highlight selected elements unless
346            // we are in toggle mode.
347            if(isToggleMode || !x.isSelected()) {
348                newHighlights.add(x);
349            }
350        }
351        return repaintIfRequired(newHighlights);
352    }
353
354    /**
355     * This is called whenever the keyboard modifier status changes
356     */
357    public void eventDispatched(AWTEvent e) {
358        if(oldEvent == null)
359            return;
360        // We don't have a mouse event, so we pass the old mouse event but the
361        // new modifiers.
362        if(giveUserFeedback(oldEvent, ((InputEvent) e).getModifiers())) {
363            mv.repaint();
364        }
365    }
366
367    /**
368     * If the left mouse button is pressed, move all currently selected
369     * objects (if one of them is under the mouse) or the current one under the
370     * mouse (which will become selected).
371     */
372    @Override
373    public void mouseDragged(MouseEvent e) {
374        if (!mv.isActiveLayerVisible())
375            return;
376
377        // Swing sends random mouseDragged events when closing dialogs by double-clicking their top-left icon on Windows
378        // Ignore such false events to prevent issues like #7078
379        if (mouseDownButton == MouseEvent.BUTTON1 && mouseReleaseTime > mouseDownTime)
380            return;
381
382        cancelDrawMode = true;
383        if (mode == Mode.select)
384            return;
385
386        // do not count anything as a move if it lasts less than 100 milliseconds.
387        if ((mode == Mode.move) && (System.currentTimeMillis() - mouseDownTime < initialMoveDelay))
388            return;
389
390        if (mode != Mode.rotate && mode != Mode.scale) // button is pressed in rotate mode
391        {
392            if ((e.getModifiersEx() & MouseEvent.BUTTON1_DOWN_MASK) == 0)
393                return;
394        }
395
396        if (mode == Mode.move) {
397            // If ctrl is pressed we are in merge mode. Look for a nearby node,
398            // highlight it and adjust the cursor accordingly.
399            final boolean canMerge = ctrl && !getCurrentDataSet().getSelectedNodes().isEmpty();
400            final OsmPrimitive p = canMerge ? (OsmPrimitive)findNodeToMergeTo(e) : null;
401            boolean needsRepaint = removeHighlighting();
402            if(p != null) {
403                p.setHighlighted(true);
404                oldHighlights.add(p);
405                needsRepaint = true;
406            }
407            mv.setNewCursor(getCursor(MapView.asColl(p)), this);
408            // also update the stored mouse event, so we can display the correct cursor
409            // when dragging a node onto another one and then press CTRL to merge
410            oldEvent = e;
411            if(needsRepaint) {
412                mv.repaint();
413            }
414        }
415
416        if (startingDraggingPos == null) {
417            startingDraggingPos = new Point(e.getX(), e.getY());
418        }
419
420        if( lastMousePos == null ) {
421            lastMousePos = e.getPoint();
422            return;
423        }
424
425        if (!initialMoveThresholdExceeded) {
426            int dxp = lastMousePos.x - e.getX();
427            int dyp = lastMousePos.y - e.getY();
428            int dp = (int) Math.sqrt(dxp * dxp + dyp * dyp);
429            if (dp < initialMoveThreshold)
430                return;
431            initialMoveThresholdExceeded = true;
432        }
433
434        EastNorth currentEN = mv.getEastNorth(e.getX(), e.getY());
435        EastNorth lastEN = mv.getEastNorth(lastMousePos.x, lastMousePos.y);
436        //EastNorth startEN = mv.getEastNorth(startingDraggingPos.x, startingDraggingPos.y);
437        double dx = currentEN.east() - lastEN.east();
438        double dy = currentEN.north() - lastEN.north();
439        if (dx == 0 && dy == 0)
440            return;
441
442        if (virtualWays.size() > 0) {
443            Collection<Command> virtualCmds = new LinkedList<Command>();
444            virtualCmds.add(new AddCommand(virtualNode));
445            for (WaySegment virtualWay : virtualWays) {
446                Way w = virtualWay.way;
447                Way wnew = new Way(w);
448                wnew.addNode(virtualWay.lowerIndex + 1, virtualNode);
449                virtualCmds.add(new ChangeCommand(w, wnew));
450            }
451            virtualCmds.add(new MoveCommand(virtualNode, dx, dy));
452            String text = trn("Add and move a virtual new node to way",
453                    "Add and move a virtual new node to {0} ways", virtualWays.size(),
454                    virtualWays.size());
455            Main.main.undoRedo.add(new SequenceCommand(text, virtualCmds));
456            getCurrentDataSet().setSelected(Collections.singleton((OsmPrimitive) virtualNode));
457            virtualWays.clear();
458            virtualNode = null;
459        } else {
460            // Currently we support only transformations which do not affect relations.
461            // So don't add them in the first place to make handling easier
462            Collection<OsmPrimitive> selection = getCurrentDataSet().getSelectedNodesAndWays();
463            Collection<Node> affectedNodes = AllNodesVisitor.getAllNodes(selection);
464
465            // for these transformations, having only one node makes no sense - quit silently
466            if (affectedNodes.size() < 2 && (mode == Mode.rotate || mode == Mode.scale))
467                return;
468
469            Command c = !Main.main.undoRedo.commands.isEmpty()
470                    ? Main.main.undoRedo.commands.getLast() : null;
471            if (c instanceof SequenceCommand) {
472                c = ((SequenceCommand) c).getLastCommand();
473            }
474
475            if (mode == Mode.move) {
476                if (c instanceof MoveCommand && affectedNodes.equals(((MoveCommand) c).getParticipatingPrimitives())) {
477                    ((MoveCommand) c).moveAgain(dx, dy);
478                } else {
479                    Main.main.undoRedo.add(
480                            c = new MoveCommand(selection, dx, dy));
481                }
482
483                for (Node n : affectedNodes) {
484                    if (n.getCoor().isOutSideWorld()) {
485                        // Revert move
486                        ((MoveCommand) c).moveAgain(-dx, -dy);
487
488                        JOptionPane.showMessageDialog(
489                                Main.parent,
490                                tr("Cannot move objects outside of the world."),
491                                tr("Warning"),
492                                JOptionPane.WARNING_MESSAGE);
493                        mv.setNewCursor(cursor, this);
494                        return;
495                    }
496                }
497            } else if (mode == Mode.rotate) {
498                if (c instanceof RotateCommand && affectedNodes.equals(((RotateCommand) c).getTransformedNodes())) {
499                    ((RotateCommand) c).handleEvent(currentEN);
500                } else {
501                    Main.main.undoRedo.add(new RotateCommand(selection, currentEN));
502                }
503            } else if (mode == Mode.scale) {
504                if (c instanceof ScaleCommand && affectedNodes.equals(((ScaleCommand) c).getTransformedNodes())) {
505                    ((ScaleCommand) c).handleEvent(currentEN);
506                } else {
507                    Main.main.undoRedo.add(new ScaleCommand(selection, currentEN));
508                }
509            }
510        }
511
512        mv.repaint();
513        if (mode != Mode.scale) {
514            lastMousePos = e.getPoint();
515        }
516
517        didMouseDrag = true;
518    }
519
520    @Override
521    public void mouseMoved(MouseEvent e) {
522        // Mac OSX simulates with  ctrl + mouse 1  the second mouse button hence no dragging events get fired.
523        if ((Main.platform instanceof PlatformHookOsx) && (mode == Mode.rotate || mode == Mode.scale)) {
524            mouseDragged(e);
525            return;
526        }
527        oldEvent = e;
528        if(giveUserFeedback(e)) {
529            mv.repaint();
530        }
531    }
532
533    @Override
534    public void mouseExited(MouseEvent e) {
535        if(removeHighlighting()) {
536            mv.repaint();
537        }
538    }
539
540    /** returns true whenever elements have been grabbed and moved (i.e. the initial
541     * thresholds have been exceeded) and is still in progress (i.e. mouse button
542     * still pressed)
543     */
544    final private boolean dragInProgress() {
545        return didMouseDrag && startingDraggingPos != null;
546    }
547
548    private Node virtualNode = null;
549    private Collection<WaySegment> virtualWays = new LinkedList<WaySegment>();
550
551    /**
552     * Calculate a virtual node if there is enough visual space to draw a crosshair
553     * node and the middle of a way segment is clicked.  If the user drags the
554     * crosshair node, it will be added to all ways in <code>virtualWays</code>.
555     *
556     * @param e contains the point clicked
557     * @return whether <code>virtualNode</code> and <code>virtualWays</code> were setup.
558     */
559    private boolean setupVirtual(MouseEvent e) {
560        if (Main.pref.getInteger("mappaint.node.virtual-size", 8) > 0) {
561            int virtualSnapDistSq = Main.pref.getInteger("mappaint.node.virtual-snap-distance", 8);
562            int virtualSpace = Main.pref.getInteger("mappaint.node.virtual-space", 70);
563            virtualSnapDistSq *= virtualSnapDistSq;
564
565            Collection<WaySegment> selVirtualWays = new LinkedList<WaySegment>();
566            Pair<Node, Node> vnp = null, wnp = new Pair<Node, Node>(null, null);
567            Point p = e.getPoint();
568            Way w = null;
569
570            for (WaySegment ws : mv.getNearestWaySegments(p, OsmPrimitive.isSelectablePredicate)) {
571                w = ws.way;
572
573                Point2D p1 = mv.getPoint2D(wnp.a = w.getNode(ws.lowerIndex));
574                Point2D p2 = mv.getPoint2D(wnp.b = w.getNode(ws.lowerIndex + 1));
575                if (WireframeMapRenderer.isLargeSegment(p1, p2, virtualSpace)) {
576                    Point2D pc = new Point2D.Double((p1.getX() + p2.getX()) / 2, (p1.getY() + p2.getY()) / 2);
577                    if (p.distanceSq(pc) < virtualSnapDistSq) {
578                        // Check that only segments on top of each other get added to the
579                        // virtual ways list. Otherwise ways that coincidentally have their
580                        // virtual node at the same spot will be joined which is likely unwanted
581                        Pair.sort(wnp);
582                        if (vnp == null) {
583                            vnp = new Pair<Node, Node>(wnp.a, wnp.b);
584                            virtualNode = new Node(mv.getLatLon(pc.getX(), pc.getY()));
585                        }
586                        if (vnp.equals(wnp)) {
587                            (w.isSelected() ? selVirtualWays : virtualWays).add(ws);
588                        }
589                    }
590                }
591            }
592
593            if (!selVirtualWays.isEmpty()) {
594                virtualWays = selVirtualWays;
595            }
596        }
597
598        return !virtualWays.isEmpty();
599    }
600    private Collection<OsmPrimitive> cycleList = Collections.emptyList();
601    private boolean cyclePrims = false;
602    private OsmPrimitive cycleStart = null;
603
604    /**
605     *
606     * @param osm nearest primitive found by simple method
607     * @param e
608     * @return
609     */
610    private Collection<OsmPrimitive> cycleSetup(Collection<OsmPrimitive> single, MouseEvent e) {
611        OsmPrimitive osm = null;
612
613        if (single != null && !single.isEmpty()) {
614            osm = single.iterator().next();
615
616            Point p = e.getPoint();
617            boolean waitForMouseUp = Main.pref.getBoolean("mappaint.select.waits-for-mouse-up", false);
618            updateKeyModifiers(e);
619            alt = alt || Main.pref.getBoolean("selectaction.cycles.multiple.matches", false);
620
621            if (!alt) {
622                cycleList = MapView.asColl(osm);
623
624                if (waitForMouseUp) {
625                    // prefer a selected nearest node or way, if possible
626                    osm = mv.getNearestNodeOrWay(p, OsmPrimitive.isSelectablePredicate, true);
627                }
628            } else {
629                cycleList = mv.getAllNearest(p, OsmPrimitive.isSelectablePredicate);
630
631                if (cycleList.size() > 1) {
632                    cyclePrims = false;
633
634                    OsmPrimitive old = osm;
635                    for (OsmPrimitive o : cycleList) {
636                        if (o.isSelected()) {
637                            cyclePrims = true;
638                            osm = o;
639                            break;
640                        }
641                    }
642
643                    // special case:  for cycle groups of 2, we can toggle to the
644                    // true nearest primitive on mousePressed right away
645                    if (cycleList.size() == 2 && !waitForMouseUp) {
646                        if (!(osm.equals(old) || osm.isNew() || ctrl)) {
647                            cyclePrims = false;
648                            osm = old;
649                        } // else defer toggling to mouseRelease time in those cases:
650                        /*
651                         * osm == old        -- the true nearest node is the selected one
652                         * osm is a new node -- do not break unglue ways in ALT mode
653                         * ctrl is pressed   -- ctrl generally works on mouseReleased
654                         */
655                    }
656                }
657            }
658        }
659
660        return MapView.asColl(osm);
661    }
662
663    /**
664     * sets the mapmode according to key modifiers and if there are any
665     * selectables nearby. Everything has to be pre-determined for this
666     * function; its main purpose is to centralize what the modifiers do.
667     * @param hasSelectionNearby
668     */
669    private void determineMapMode(boolean hasSelectionNearby) {
670        if (shift && ctrl) {
671            mode = Mode.rotate;
672        } else if (alt && ctrl) {
673            mode = Mode.scale;
674        } else if (hasSelectionNearby || dragInProgress()) {
675            mode = Mode.move;
676        } else {
677            mode = Mode.select;
678        }
679    }
680
681    /**
682     * Look, whether any object is selected. If not, select the nearest node.
683     * If there are no nodes in the dataset, do nothing.
684     *
685     * If the user did not press the left mouse button, do nothing.
686     *
687     * Also remember the starting position of the movement and change the mouse
688     * cursor to movement.
689     */
690    @Override
691    public void mousePressed(MouseEvent e) {
692        // return early
693        if (!mv.isActiveLayerVisible() || !(Boolean) this.getValue("active") || (mouseDownButton = e.getButton()) != MouseEvent.BUTTON1)
694            return;
695
696        // request focus in order to enable the expected keyboard shortcuts
697        mv.requestFocus();
698
699        // update which modifiers are pressed (shift, alt, ctrl)
700        updateKeyModifiers(e);
701
702        // We don't want to change to draw tool if the user tries to (de)select
703        // stuff but accidentally clicks in an empty area when selection is empty
704        cancelDrawMode = (shift || ctrl);
705        didMouseDrag = false;
706        initialMoveThresholdExceeded = false;
707        mouseDownTime = System.currentTimeMillis();
708        lastMousePos = e.getPoint();
709
710        Collection<OsmPrimitive> c = MapView.asColl(
711                mv.getNearestNodeOrWay(e.getPoint(), OsmPrimitive.isSelectablePredicate, true));
712
713        determineMapMode(!c.isEmpty());
714        switch(mode) {
715        case rotate:
716        case scale:
717            if (getCurrentDataSet().getSelected().isEmpty()) {
718                getCurrentDataSet().setSelected(c);
719            }
720
721            // Mode.select redraws when selectPrims is called
722            // Mode.move   redraws when mouseDragged is called
723            // Mode.rotate redraws here
724            // Mode.scale redraws here
725            break;
726        case move:
727            if (!cancelDrawMode && c.iterator().next() instanceof Way) {
728                setupVirtual(e);
729            }
730
731            selectPrims(cycleSetup(c, e), e, false, false);
732            break;
733        case select:
734        default:
735            selectionManager.register(mv, lassoMode);
736            selectionManager.mousePressed(e);
737            break;
738        }
739        giveUserFeedback(e);
740        mv.repaint();
741        updateStatusLine();
742    }
743
744    @Override
745    public void mouseReleased(MouseEvent e) {
746        if (!mv.isActiveLayerVisible())
747            return;
748
749        startingDraggingPos = null;
750        mouseReleaseTime = System.currentTimeMillis();
751
752        if (mode == Mode.select) {
753            selectionManager.unregister(mv);
754
755            // Select Draw Tool if no selection has been made
756            if (getCurrentDataSet().getSelected().size() == 0 && !cancelDrawMode) {
757                Main.map.selectDrawTool(true);
758                return;
759            }
760        }
761
762        if (mode == Mode.move && e.getButton() == MouseEvent.BUTTON1) {
763            if (!didMouseDrag) {
764                // only built in move mode
765                virtualWays.clear();
766                virtualNode = null;
767
768                // do nothing if the click was to short too be recognized as a drag,
769                // but the release position is farther than 10px away from the press position
770                if (lastMousePos == null || lastMousePos.distanceSq(e.getPoint()) < 100) {
771                    selectPrims(cyclePrims(cycleList, e), e, true, false);
772
773                    // If the user double-clicked a node, change to draw mode
774                    Collection<OsmPrimitive> c = getCurrentDataSet().getSelected();
775                    if (e.getClickCount() >= 2 && c.size() == 1 && c.iterator().next() instanceof Node) {
776                        // We need to do it like this as otherwise drawAction will see a double
777                        // click and switch back to SelectMode
778                        Main.worker.execute(new Runnable() {
779                            public void run() {
780                                Main.map.selectDrawTool(true);
781                            }
782                        });
783                        return;
784                    }
785                }
786            } else {
787                int max = Main.pref.getInteger("warn.move.maxelements", 20), limit = max;
788                for (OsmPrimitive osm : getCurrentDataSet().getSelected()) {
789                    if (osm instanceof Way) {
790                        limit -= ((Way) osm).getNodes().size();
791                    }
792                    if ((limit -= 1) < 0) {
793                        break;
794                    }
795                }
796                if (limit < 0) {
797                    ExtendedDialog ed = new ExtendedDialog(
798                            Main.parent,
799                            tr("Move elements"),
800                            new String[]{tr("Move them"), tr("Undo move")});
801                    ed.setButtonIcons(new String[]{"reorder.png", "cancel.png"});
802                    ed.setContent(tr("You moved more than {0} elements. " + "Moving a large number of elements is often an error.\n" + "Really move them?", max));
803                    ed.setCancelButton(2);
804                    ed.toggleEnable("movedManyElements");
805                    ed.showDialog();
806
807                    if (ed.getValue() != 1) {
808                        Main.main.undoRedo.undo();
809                    }
810                } else {
811                    mergePrims(e);
812                }
813                getCurrentDataSet().fireSelectionChanged();
814            }
815        }
816
817        mode = null;
818
819        // simply remove any highlights if the middle click popup is active because
820        // the highlights don't depend on the cursor position there. If something was
821        // selected beforehand this would put us into move mode as well, which breaks
822        // the cycling through primitives on top of each other (see #6739).
823        if(e.getButton() == MouseEvent.BUTTON2) {
824            removeHighlighting();
825        } else {
826            giveUserFeedback(e);
827        }
828        updateStatusLine();
829    }
830
831    public void selectionEnded(Rectangle r, MouseEvent e) {
832        updateKeyModifiers(e);
833        mv.repaint();
834        selectPrims(selectionManager.getSelectedObjects(alt), e, true, true);
835    }
836
837    /**
838     * Modifies current selection state and returns the next element in a
839     * selection cycle given by <code>prims</code>.
840     * @param prims the primitives that form the selection cycle
841     * @param mouse event
842     * @return the next element of cycle list <code>prims</code>.
843     */
844    private Collection<OsmPrimitive> cyclePrims(Collection<OsmPrimitive> prims, MouseEvent e) {
845        OsmPrimitive nxt = null;
846
847        if (prims.size() > 1) {
848            updateKeyModifiers(e);
849
850            DataSet ds = getCurrentDataSet();
851            OsmPrimitive first = prims.iterator().next(), foundInDS = null;
852            nxt = first;
853
854            for (Iterator<OsmPrimitive> i = prims.iterator(); i.hasNext();) {
855                if (cyclePrims && shift) {
856                    if (!(nxt = i.next()).isSelected()) {
857                        break; // take first primitive in prims list not in sel
858                    }
859                } else {
860                    if ((nxt = i.next()).isSelected()) {
861                        foundInDS = nxt;
862                        if (cyclePrims || ctrl) {
863                            ds.clearSelection(foundInDS);
864                            nxt = i.hasNext() ? i.next() : first;
865                        }
866                        break; // take next primitive in prims list
867                    }
868                }
869            }
870
871            if (ctrl) {
872                // a member of prims was found in the current dataset selection
873                if (foundInDS != null) {
874                    // mouse was moved to a different selection group w/ a previous sel
875                    if (!prims.contains(cycleStart)) {
876                        ds.clearSelection(prims);
877                        cycleStart = foundInDS;
878                    } else if (cycleStart.equals(nxt)) {
879                        // loop detected, insert deselect step
880                        ds.addSelected(nxt);
881                    }
882                } else {
883                    // setup for iterating a sel group again or a new, different one..
884                    nxt = (prims.contains(cycleStart)) ? cycleStart : first;
885                    cycleStart = nxt;
886                }
887            } else {
888                cycleStart = null;
889            }
890        }
891
892        // pass on prims, if it had less than 2 elements
893        return (nxt != null) ? MapView.asColl(nxt) : prims;
894    }
895
896    /** Merges the selected nodes to the one closest to the given mouse position iff the control
897     * key is pressed. If there is no such node, no action will be done and no error will be
898     * reported. If there is, it will execute the merge and add it to the undo buffer. */
899    final private void mergePrims(MouseEvent e) {
900        updateKeyModifiers(e);
901        Collection<Node> selNodes = getCurrentDataSet().getSelectedNodes();
902        if (!ctrl || selNodes.isEmpty())
903            return;
904
905        Node target = findNodeToMergeTo(e);
906        if (target == null)
907            return;
908
909        Collection<Node> nodesToMerge = new LinkedList<Node>(selNodes);
910        nodesToMerge.add(target);
911        Command cmd = MergeNodesAction.mergeNodes(Main.main.getEditLayer(), nodesToMerge, target);
912        if (cmd != null) {
913            Main.main.undoRedo.add(cmd);
914            getCurrentDataSet().setSelected(target);
915        }
916    }
917
918    /** tries to find a node to merge to when in move-merge mode for the current mouse
919     * position. Either returns the node or null, if no suitable one is nearby. */
920    final private Node findNodeToMergeTo(MouseEvent e) {
921        Collection<Node> target = mv.getNearestNodes(e.getPoint(),
922                getCurrentDataSet().getSelectedNodes(),
923                OsmPrimitive.isSelectablePredicate);
924        return target.isEmpty() ? null : target.iterator().next();
925    }
926
927    private void selectPrims(Collection<OsmPrimitive> prims, MouseEvent e, boolean released, boolean area) {
928        updateKeyModifiers(e);
929        DataSet ds = getCurrentDataSet();
930
931        // not allowed together: do not change dataset selection, return early
932        // Virtual Ways: if non-empty the cursor is above a virtual node. So don't highlight
933        // anything if about to drag the virtual node (i.e. !released) but continue if the
934        // cursor is only released above a virtual node by accident (i.e. released). See #7018
935        if ((shift && ctrl) || (ctrl && !released) || (!virtualWays.isEmpty() && !released))
936            return;
937
938        if (!released) {
939            // Don't replace the selection if the user clicked on a
940            // selected object (it breaks moving of selected groups).
941            // Do it later, on mouse release.
942            shift |= getCurrentDataSet().getSelected().containsAll(prims);
943        }
944
945        if (ctrl) {
946            // Ctrl on an item toggles its selection status,
947            // but Ctrl on an *area* just clears those items
948            // out of the selection.
949            if (area) {
950                ds.clearSelection(prims);
951            } else {
952                ds.toggleSelected(prims);
953            }
954        } else if (shift) {
955            // add prims to an existing selection
956            ds.addSelected(prims);
957        } else {
958            // clear selection, then select the prims clicked
959            ds.setSelected(prims);
960        }
961    }
962
963    @Override
964    public String getModeHelpText() {
965        if (mode == Mode.select)
966            return tr("Release the mouse button to select the objects in the rectangle.");
967        else if (mode == Mode.move) {
968            final boolean canMerge = getCurrentDataSet()!=null && !getCurrentDataSet().getSelectedNodes().isEmpty();
969            final String mergeHelp = canMerge ? (" " + tr("Ctrl to merge with nearest node.")) : "";
970            return tr("Release the mouse button to stop moving.") + mergeHelp;
971        } else if (mode == Mode.rotate)
972            return tr("Release the mouse button to stop rotating.");
973        else if (mode == Mode.scale)
974            return tr("Release the mouse button to stop scaling.");
975        else
976            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");
977    }
978
979    @Override
980    public boolean layerIsSupported(Layer l) {
981        return l instanceof OsmDataLayer;
982    }
983
984    public void setLassoMode(boolean lassoMode) {
985        this.selectionManager.setLassoMode(lassoMode);
986        this.lassoMode = lassoMode;
987    }
988}
Note: See TracBrowser for help on using the repository browser.