Index: trunk/src/org/openstreetmap/josm/actions/mapmode/ExtrudeAction.java =================================================================== --- trunk/src/org/openstreetmap/josm/actions/mapmode/ExtrudeAction.java (revision 2428) +++ trunk/src/org/openstreetmap/josm/actions/mapmode/ExtrudeAction.java (revision 2429) @@ -11,7 +11,15 @@ import java.awt.Graphics2D; import java.awt.Point; +import java.awt.Rectangle; import java.awt.event.KeyEvent; import java.awt.event.MouseEvent; +import java.awt.event.ActionEvent; +import java.awt.geom.AffineTransform; +import java.awt.geom.NoninvertibleTransformException; import java.awt.geom.GeneralPath; +import java.awt.geom.Point2D; +import java.awt.geom.Line2D; +import java.awt.geom.Line2D.Double; +import java.lang.Math; import java.util.Collection; import java.util.LinkedList; @@ -21,7 +29,9 @@ import org.openstreetmap.josm.command.ChangeCommand; import org.openstreetmap.josm.command.Command; +import org.openstreetmap.josm.command.MoveCommand; import org.openstreetmap.josm.command.SequenceCommand; import org.openstreetmap.josm.data.coor.EastNorth; import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.data.osm.OsmPrimitive; import org.openstreetmap.josm.data.osm.Way; import org.openstreetmap.josm.data.osm.WaySegment; @@ -36,28 +46,17 @@ /** * Makes a rectangle from a line, or modifies a rectangle. - * - * This class currently contains some "sleeping" code copied from DrawAction (move and rotate) - * which can eventually be removed, but it may also get activated here and removed in DrawAction. */ public class ExtrudeAction extends MapMode implements MapViewPaintable { - enum Mode { EXTRUDE, rotate, select } - private Mode mode = null; + enum Mode { extrude, translate, select } + private Mode mode = Mode.select; private long mouseDownTime = 0; private WaySegment selectedSegment = null; private Color selectedColor; - double xoff; - double yoff; - double distance; - /** * The old cursor before the user pressed the mouse button. */ private Cursor oldCursor; - /** - * The current position of the mouse - */ - private Point mousePos; /** * The position of the mouse cursor when the drag action was initiated. @@ -68,5 +67,32 @@ * counts as a move, in milliseconds */ - private int initialMoveDelay = 200; + private static int initialMoveDelay = 200; + /** + * The initial EastNorths of node1 and node2 + */ + private EastNorth initialN1en; + private EastNorth initialN2en; + /** + * The new EastNorths of node1 and node2 + */ + private EastNorth newN1en; + private EastNorth newN2en; + /** + * This is to work around some deficiencies in MoveCommand when translating + */ + private EastNorth lastTranslatedN1en; + /** + * Normal unit vector of the selected segment. + */ + private EastNorth normalUnitVector; + /** + * Vector of node2 from node1. + */ + private EastNorth segmentVector; + /** + * Transforms the mouse point (in EastNorth space) to the normal-shifted position + * of point 1 of the selectedSegment. + */ + private AffineTransform normalTransform; /** @@ -117,80 +143,159 @@ Main.map.mapView.removeMouseMotionListener(this); Main.map.mapView.removeTemporaryLayer(this); - - } - - /** - * If the left mouse button is pressed, move all currently selected - * objects (if one of them is under the mouse) or the current one under the - * mouse (which will become selected). + } + + /** + * Perform action depending on what mode we're in. */ @Override public void mouseDragged(MouseEvent e) { if(!Main.map.mapView.isActiveLayerVisible()) return; - if (mode == Mode.select) return; - - // do not count anything as a move if it lasts less than 100 milliseconds. - if ((mode == Mode.EXTRUDE) && (System.currentTimeMillis() - mouseDownTime < initialMoveDelay)) return; - - if ((e.getModifiersEx() & MouseEvent.BUTTON1_DOWN_MASK) == 0) - return; - - if (mode == Mode.EXTRUDE) { + + // do not count anything as a drag if it lasts less than 100 milliseconds. + if (System.currentTimeMillis() - mouseDownTime < initialMoveDelay) return; + + if (mode == Mode.select) { + // Just sit tight and wait for mouse to be released. + } else { + // This may be ugly, but I can't see any other way of getting a mapview from here. + EastNorth mouseen = Main.map.mapView.getEastNorth(e.getPoint().x, e.getPoint().y); + + Point2D newN1point = normalTransform.transform(mouseen, null); + + newN1en = new EastNorth(newN1point.getX(), newN1point.getY()); + newN2en = newN1en.add(segmentVector.getX(), segmentVector.getY()); + + // find out the distance, in metres, between the initial position of N1 and the new one. + Main.map.statusLine.setDist(Main.proj.eastNorth2latlon(initialN1en).greatCircleDistance(Main.proj.eastNorth2latlon(newN1en))); + updateStatusLine(); + setCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR)); - } - - if (mousePos == null) { - mousePos = e.getPoint(); - return; - } - - Main.map.mapView.repaint(); - mousePos = e.getPoint(); - + + if (mode == Mode.extrude) { + + } else if (mode == Mode.translate) { + Command c = !Main.main.undoRedo.commands.isEmpty() + ? Main.main.undoRedo.commands.getLast() : null; + if (c instanceof SequenceCommand) { + c = ((SequenceCommand)c).getLastCommand(); + } + + Node n1 = selectedSegment.way.getNode(selectedSegment.lowerIndex); + Node n2 = selectedSegment.way.getNode(selectedSegment.lowerIndex+1); + + EastNorth difference = new EastNorth(newN1en.getX()-lastTranslatedN1en.getX(), newN1en.getY()-lastTranslatedN1en.getY()); + + // Better way of testing list equality non-order-sensitively? + if (c instanceof MoveCommand + && ((MoveCommand)c).getMovedNodes().contains(n1) + && ((MoveCommand)c).getMovedNodes().contains(n2) + && ((MoveCommand)c).getMovedNodes().size() == 2) { + // MoveCommand doesn't let us know how much it has already moved the selection + // so we have to do some ugly record-keeping. + ((MoveCommand)c).moveAgain(difference.getX(), difference.getY()); + lastTranslatedN1en = newN1en; + } else { + Collection nodelist = new LinkedList(); + nodelist.add(n1); + nodelist.add(n2); + Main.main.undoRedo.add(c = new MoveCommand(nodelist, difference.getX(), difference.getY())); + lastTranslatedN1en = newN1en; + } + } + Main.map.mapView.repaint(); + } + } + + /** + * Create a new Line that extends off the edge of the viewport in one direction + * @param start The start point of the line + * @param unitvector A unit vector denoting the direction of the line + * @param g the Graphics2D object it will be used on + */ + static private Line2D createSemiInfiniteLine(Point2D start, Point2D unitvector, Graphics2D g) { + Rectangle bounds = g.getDeviceConfiguration().getBounds(); + try { + AffineTransform invtrans = g.getTransform().createInverse(); + Point2D widthpoint = invtrans.deltaTransform(new Point2D.Double(bounds.width,0), null); + Point2D heightpoint = invtrans.deltaTransform(new Point2D.Double(0,bounds.height), null); + + // Here we should end up with a gross overestimate of the maximum viewport diagonal in what + // Graphics2D calls 'user space'. Essentially a manhattan distance of manhattan distances. + // This can be used as a safe length of line to generate which will always go off-viewport. + double linelength = Math.abs(widthpoint.getX()) + Math.abs(widthpoint.getY()) + Math.abs(heightpoint.getX()) + Math.abs(heightpoint.getY()); + + return new Line2D.Double(start, new Point2D.Double(start.getX() + (unitvector.getX() * linelength) , start.getY() + (unitvector.getY() * linelength))); + } + catch (NoninvertibleTransformException e) { + return new Line2D.Double(start, new Point2D.Double(start.getX() + (unitvector.getX() * 10) , start.getY() + (unitvector.getY() * 10))); + } } public void paint(Graphics g, MapView mv) { - if (selectedSegment != null) { - Node n1 = selectedSegment.way.getNode(selectedSegment.lowerIndex); - Node n2 = selectedSegment.way.getNode(selectedSegment.lowerIndex + 1); - - EastNorth en1 = n1.getEastNorth(); - EastNorth en2 = n2.getEastNorth(); - EastNorth en3 = mv.getEastNorth(mousePos.x, mousePos.y); - - double u = ((en3.east() - en1.east()) * (en2.east() - en1.east()) + - (en3.north() - en1.north()) * (en2.north() - en1.north())) / - en2.distanceSq(en1); - // the point on the segment from which the distance to mouse pos is shortest - EastNorth base = new EastNorth(en1.east() + u * (en2.east() - en1.east()), - en1.north() + u * (en2.north() - en1.north())); - - // find out the distance, in metres, between the base point and the mouse cursor - distance = Main.proj.eastNorth2latlon(base).greatCircleDistance(Main.proj.eastNorth2latlon(en3)); - Main.map.statusLine.setDist(distance); - updateStatusLine(); - - // compute vertical and horizontal components. - xoff = en3.east() - base.east(); - yoff = en3.north() - base.north(); - - Graphics2D g2 = (Graphics2D)g; - g2.setColor(selectedColor); - g2.setStroke(new BasicStroke(3, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); - GeneralPath b = new GeneralPath(); - Point p1 = mv.getPoint(en1); - Point p2 = mv.getPoint(en2); - Point p3 = mv.getPoint(en1.add(xoff, yoff)); - Point p4 = mv.getPoint(en2.add(xoff, yoff)); - - b.moveTo(p1.x, p1.y); b.lineTo(p3.x, p3.y); - b.lineTo(p4.x, p4.y); b.lineTo(p2.x, p2.y); - b.lineTo(p1.x, p1.y); - g2.draw(b); - g2.setStroke(new BasicStroke(1)); - } - } - - /** + if (mode == Mode.select) { + // Nothing to do + } else { + if (newN1en != null) { + Graphics2D g2 = (Graphics2D)g; + g2.setColor(selectedColor); + g2.setStroke(new BasicStroke(3, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); + + Point p1 = mv.getPoint(initialN1en); + Point p2 = mv.getPoint(initialN2en); + Point p3 = mv.getPoint(newN1en); + Point p4 = mv.getPoint(newN2en); + + if (mode == Mode.extrude) { + // Draw rectangle around new area. + GeneralPath b = new GeneralPath(); + b.moveTo(p1.x, p1.y); b.lineTo(p3.x, p3.y); + b.lineTo(p4.x, p4.y); b.lineTo(p2.x, p2.y); + b.lineTo(p1.x, p1.y); + g2.draw(b); + g2.setStroke(new BasicStroke(1)); + } else if (mode == Mode.translate) { + // Highlight the new and old segments. + Line2D newline = new Line2D.Double(p3, p4); + g2.draw(newline); + g2.setStroke(new BasicStroke(1)); + Line2D oldline = new Line2D.Double(p1, p2); + g2.draw(oldline); + + // Draw a guideline along the normal. + Line2D normline; + Point2D centerpoint = new Point2D.Double((p1.getX()+p2.getX())*0.5, (p1.getY()+p2.getY())*0.5); + EastNorth drawnorm; + // Check to see if our new N1 is in a positive direction with respect to the normalUnitVector. + // Even if the x component is zero, we should still be able to discern using +0.0 and -0.0 + if (newN1en == null || (newN1en.getX() > initialN1en.getX() == normalUnitVector.getX() > -0.0)) + drawnorm = normalUnitVector; + else + // If not, use a sign-flipped version of the normalUnitVector. + drawnorm = new EastNorth(-normalUnitVector.getX(), -normalUnitVector.getY()); + normline = createSemiInfiniteLine(centerpoint, drawnorm, g2); + g2.draw(normline); + + // EastNorth units per pixel + double factor = 1.0/g2.getTransform().getScaleX(); + + // Draw right angle marker on initial position. + double raoffsetx = 8.0*factor*drawnorm.getX(); + double raoffsety = 8.0*factor*drawnorm.getY(); + Point2D ra1 = new Point2D.Double(centerpoint.getX()+raoffsetx, centerpoint.getY()+raoffsety); + Point2D ra3 = new Point2D.Double(centerpoint.getX()-raoffsety, centerpoint.getY()+raoffsetx); + Point2D ra2 = new Point2D.Double(ra1.getX()-raoffsety, ra1.getY()+raoffsetx); + GeneralPath ra = new GeneralPath(); + ra.moveTo(ra1.getX(), ra1.getY()); + ra.lineTo(ra2.getX(), ra2.getY()); + ra.lineTo(ra3.getX(), ra3.getY()); + g2.draw(ra); + } + } + } + } + + /** + * If the left mouse button is pressed over a segment, switch + * to either extrude or translate mode depending on whether ctrl is held. */ @Override public void mousePressed(MouseEvent e) { @@ -204,69 +309,117 @@ // boolean shift = (e.getModifiers() & ActionEvent.SHIFT_MASK) != 0; - mouseDownTime = System.currentTimeMillis(); - - selectedSegment = - Main.map.mapView.getNearestWaySegment(e.getPoint()); - - mode = (selectedSegment == null) ? Mode.select : Mode.EXTRUDE; - oldCursor = Main.map.mapView.getCursor(); - - updateStatusLine(); - Main.map.mapView.addTemporaryLayer(this); - Main.map.mapView.repaint(); - - mousePos = e.getPoint(); - initialMousePos = e.getPoint(); - - if(selectedSegment != null) { - getCurrentDataSet().setSelected(selectedSegment.way); - } - } - - /** - * Restore the old mouse cursor. + selectedSegment = Main.map.mapView.getNearestWaySegment(e.getPoint()); + + if (selectedSegment == null) { + // If nothing gets caught, stay in select mode + } else { + // Otherwise switch to another mode + + // For extrusion, these positions are actually never changed, + // but keeping note of this anyway allows us to not continually + // look it up and also allows us to unify code with the translate mode + initialN1en = selectedSegment.way.getNode(selectedSegment.lowerIndex).getEastNorth(); + initialN2en = selectedSegment.way.getNode(selectedSegment.lowerIndex + 1).getEastNorth(); + + // Signifies that nothing has happened yet + newN1en = null; + newN2en = null; + + Main.map.mapView.addTemporaryLayer(this); + + updateStatusLine(); + Main.map.mapView.repaint(); + + // Make note of time pressed + mouseDownTime = System.currentTimeMillis(); + + // Make note of mouse position + initialMousePos = e.getPoint(); + + segmentVector = new EastNorth(initialN2en.getX()-initialN1en.getX(), initialN2en.getY()-initialN1en.getY()); + double factor = 1.0 / Math.hypot(segmentVector.getX(), segmentVector.getY()); + // swap coords to get normal, mult by factor to get unit vector. + normalUnitVector = new EastNorth(segmentVector.getY() * factor, segmentVector.getX() * factor); + + // The calculation of points along the normal of the segment from mouse + // points is actually a purely affine mapping. So the majority of the maths + // can be done once, on mousePress, by building an AffineTransform which + // we can use in the other functions. + double r = 1.0 / ( (normalUnitVector.getX()*normalUnitVector.getX()) + (normalUnitVector.getY()*normalUnitVector.getY()) ); + double s = (normalUnitVector.getX()*initialN1en.getX()) - (normalUnitVector.getY()*initialN1en.getY()); + double compcoordcoeff = -r*normalUnitVector.getX()*normalUnitVector.getY(); + + // Build the matrix. Takes a mouse position in EastNorth-space and returns the new position of node1 + // based on that. + normalTransform = new AffineTransform( + r*normalUnitVector.getX()*normalUnitVector.getX(), compcoordcoeff, + compcoordcoeff, r*normalUnitVector.getY()*normalUnitVector.getY(), + initialN1en.getX()-(s*r*normalUnitVector.getX()), initialN1en.getY()+(s*r*normalUnitVector.getY())); + + // Switch mode. + if ( (e.getModifiers() & ActionEvent.CTRL_MASK) != 0 ) { + mode = Mode.translate; + lastTranslatedN1en = initialN1en; + } else { + mode = Mode.extrude; + getCurrentDataSet().setSelected(selectedSegment.way); + } + } + } + + /** + * Do anything that needs to be done, then switch back to select mode */ @Override public void mouseReleased(MouseEvent e) { + if(!Main.map.mapView.isActiveLayerVisible()) return; - restoreCursor(); - if (selectedSegment == null) return; - if (mousePos.distance(initialMousePos) > 10) { - Node n1 = selectedSegment.way.getNode(selectedSegment.lowerIndex); - Node n2 = selectedSegment.way.getNode(selectedSegment.lowerIndex+1); - EastNorth en3 = n2.getEastNorth().add(xoff, yoff); - Node n3 = new Node(Main.proj.eastNorth2latlon(en3)); - EastNorth en4 = n1.getEastNorth().add(xoff, yoff); - Node n4 = new Node(Main.proj.eastNorth2latlon(en4)); - Way wnew = new Way(selectedSegment.way); - wnew.addNode(selectedSegment.lowerIndex+1, n3); - wnew.addNode(selectedSegment.lowerIndex+1, n4); - if (wnew.getNodesCount() == 4) { - wnew.addNode(n1); + + if (mode == mode.select) { + // Nothing to be done + } else { + if (mode == mode.extrude) { + if (e.getPoint().distance(initialMousePos) > 10 && newN1en != null) { + // Commit extrusion + + Node n1 = selectedSegment.way.getNode(selectedSegment.lowerIndex); + Node n2 = selectedSegment.way.getNode(selectedSegment.lowerIndex+1); + Node n3 = new Node(Main.proj.eastNorth2latlon(newN2en)); + Node n4 = new Node(Main.proj.eastNorth2latlon(newN1en)); + Way wnew = new Way(selectedSegment.way); + wnew.addNode(selectedSegment.lowerIndex+1, n3); + wnew.addNode(selectedSegment.lowerIndex+1, n4); + if (wnew.getNodesCount() == 4) { + wnew.addNode(n1); + } + Collection cmds = new LinkedList(); + cmds.add(new AddCommand(n4)); + cmds.add(new AddCommand(n3)); + cmds.add(new ChangeCommand(selectedSegment.way, wnew)); + Command c = new SequenceCommand(tr("Extrude Way"), cmds); + Main.main.undoRedo.add(c); + } + } else if (mode == mode.translate) { + // I don't think there's anything to do } - Collection cmds = new LinkedList(); - cmds.add(new AddCommand(n4)); - cmds.add(new AddCommand(n3)); - cmds.add(new ChangeCommand(selectedSegment.way, wnew)); - Command c = new SequenceCommand(tr("Extrude Way"), cmds); - Main.main.undoRedo.add(c); - } - - Main.map.mapView.removeTemporaryLayer(this); - selectedSegment = null; - mode = null; - updateStatusLine(); - Main.map.mapView.repaint(); + + // Switch back into select mode + restoreCursor(); + Main.map.mapView.removeTemporaryLayer(this); + selectedSegment = null; + mode = Mode.select; + + updateStatusLine(); + Main.map.mapView.repaint(); + } } @Override public String getModeHelpText() { - if (mode == Mode.select) - return tr("Release the mouse button to select the objects in the rectangle."); - else if (mode == Mode.EXTRUDE) + if (mode == Mode.translate) + return tr("Move a segment along its normal, then release the mouse button."); + else if (mode == Mode.extrude) return tr("Draw a rectangle of the desired size, then release the mouse button."); - else if (mode == Mode.rotate) - return tr("Release the mouse button to stop rotating."); else - return tr("Drag a way segment to make a rectangle."); + return tr("Drag a way segment to make a rectangle. Ctrl-drag to move a segment along its normal."); }