DrawAction (JOSM)

java.lang.Object
- javax.swing.AbstractAction
- - org.openstreetmap.josm.actions.JosmAction
  - - org.openstreetmap.josm.actions.mapmode.MapMode
    - - org.openstreetmap.josm.actions.mapmode.DrawAction

All Implemented Interfaces:

ActionListener, AWTEventListener, MouseListener, MouseMotionListener, Serializable, Cloneable, EventListener, Action, SelectionChangedListener, MapViewPaintable, Destroyable
```
public class DrawAction
extends MapMode
implements MapViewPaintable, SelectionChangedListener, AWTEventListener
```
Mapmode to add nodes, create and extend ways.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class DrawAction.BackSpaceAction

private class DrawAction.SnapChangeAction

private class DrawAction.SnapHelper

Nested Classes
Modifier and Type	Class and Description
`class`	`DrawAction.BackSpaceAction`
`private class`	`DrawAction.SnapChangeAction`
`private class`	`DrawAction.SnapHelper`

Field Summary

Fields
Modifier and Type	Field and Description
`private DrawAction.BackSpaceAction`	`backspaceAction`
`private Shortcut`	`backspaceShortcut`
`private static BasicStroke`	`BASIC_STROKE`
`private Node`	`currentBaseNode`
`private EastNorth`	`currentMouseEastNorth`
`private Cursor`	`cursorJoinNode`
`private Cursor`	`cursorJoinWay`
`private boolean`	`drawHelperLine`
`private boolean`	`drawTargetHighlight`
`private Node`	`lastUsedNode`
`private Node`	`mouseOnExistingNode`
`private Set<Way>`	`mouseOnExistingWays`
`private Point`	`mousePos`
`private Set<OsmPrimitive>`	`newHighlights`
`private Set<OsmPrimitive>`	`oldHighlights`
`private Point`	`oldMousePos`
`private double`	`PHI`
`private Node`	`previousNode`
`private KeyEvent`	`releaseEvent`
`private Point`	`rightClickPressPos`
`private Color`	`rubberLineColor`
`private Stroke`	`rubberLineStroke`
`private Set<Integer>`	`set`
`private DrawAction.SnapChangeAction`	`snapChangeAction`
`private JCheckBoxMenuItem`	`snapCheckboxMenuItem`
`private DrawAction.SnapHelper`	`snapHelper`
`private Shortcut`	`snappingShortcut`
`private Timer`	`timer`
`private double`	`toleranceMultiplier`
`private boolean`	`useRepeatedShortcut`
`private boolean`	`wayIsFinished`

Fields inherited from class org.openstreetmap.josm.actions.mapmode.MapMode
alt, ctrl, cursor, shift

Fields inherited from class org.openstreetmap.josm.actions.JosmAction
sc

Fields inherited from class javax.swing.AbstractAction
changeSupport, enabled

Fields inherited from interface javax.swing.Action
ACCELERATOR_KEY, ACTION_COMMAND_KEY, DEFAULT, DISPLAYED_MNEMONIC_INDEX_KEY, LARGE_ICON_KEY, LONG_DESCRIPTION, MNEMONIC_KEY, NAME, SELECTED_KEY, SHORT_DESCRIPTION, SMALL_ICON

Constructor Summary

Constructors
Constructor and Description

DrawAction(MapFrame mapFrame)

Constructors
Constructor and Description
`DrawAction(MapFrame mapFrame)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private void`	`addHighlighting()` Takes the data from computeHelperLine to determine which ways/nodes should be highlighted (if feature enabled).
`private JCheckBoxMenuItem`	`addMenuItem()`
`private static void`	`adjustNode(Collection<Pair<Node,Node>> segs, Node n)` Adjusts the position of a node to lie on a segment (or a segment intersection).
`private void`	`computeHelperLine()` This method prepares data required for painting the "helper line" from the last used position to the mouse cursor.
`private void`	`continueWayFromNode(Way way, Node node)` if one of the ends of @param way is given @param node , then set currentBaseNode = node and previousNode = adjacent node of way
`void`	`destroy()` Called when the object has been destroyed.
`(package private) static double`	`det(double a, double b, double c, double d)`
`private void`	`determineCurrentBaseNodeAndPreviousNode(Collection<OsmPrimitive> selection)` Helper function that sets fields currentBaseNode and previousNode
`private void`	`doKeyPressEvent(KeyEvent e)`
`private void`	`doKeyReleaseEvent(KeyEvent e)`
`void`	`enterMode()` Makes this map mode active.
`void`	`eventDispatched(AWTEvent event)` redraw to (possibly) get rid of helper line if selection changes.
`void`	`exitMode()` Makes this map mode inactive.
`private Node`	`findNodeToContinueFrom(Node selectedNode, Way selectedWay)` Finds a node to continue drawing from.
`private void`	`finishDrawing()` This function should be called when the user wishes to finish his current draw action.
`Node`	`getCurrentBaseNode()`
`Collection<OsmPrimitive>`	`getInProgressSelection()` Get selected primitives, while draw action is in progress.
`String`	`getModeHelpText()`
`static Way`	`getWayForNode(Node n)`
`private void`	`insertNodeIntoAllNearbySegments(List<WaySegment> wss, Node n, Collection<OsmPrimitive> newSelection, Collection<Command> cmds, List<Way> replacedWays, List<Way> reuseWays)`
`private boolean`	`isSelfContainedWay(Way selectedWay, Node currentNode, Node targetNode)` Prevent creation of ways that look like this: <----> This happens if users want to draw a no-exit-sideway from the main way like this: ^ \|<----> \| The solution isn't ideal because the main way will end in the side way, which is bad for navigation software ("drive straight on") but at least easier to fix.
`boolean`	`layerIsSupported(Layer l)`
`void`	`mouseDragged(MouseEvent e)`
`void`	`mouseExited(MouseEvent e)` Repaint on mouse exit so that the helper line goes away.
`void`	`mouseMoved(MouseEvent e)`
`void`	`mousePressed(MouseEvent e)`
`void`	`mouseReleased(MouseEvent e)` If user clicked with the left button, add a node at the current mouse position.
`void`	`paint(Graphics2D g, MapView mv, Bounds box)` Paint the dataset using the engine set.
`(package private) void`	`processKeyEvent(KeyEvent e)`
`private static void`	`pruneSuccsAndReverse(List<Integer> is)`
`private boolean`	`redrawIfRequired()` Checks if a map redraw is required and does so if needed.
`private boolean`	`removeHighlighting()` Removes target highlighting from primitives.
`void`	`selectionChanged(Collection<? extends OsmPrimitive> newSelection)` redraw to (possibly) get rid of helper line if selection changes.
`private void`	`showStatusInfo(double angle, double hdg, double distance, boolean activeFlag)`
`private void`	`tryAgain(MouseEvent e)`
`private void`	`tryToMoveNodeOnIntersection(List<WaySegment> wss, Node n)`
`private void`	`tryToSetBaseSegmentForAngleSnap()` This method is used to detect segment under mouse and use it as reference for angle snapping
`protected void`	`updateEnabledState()` Override in subclasses to update the enabled state of the action when something in the JOSM state changes, i.e. when a layer is removed or added.

Methods inherited from class org.openstreetmap.josm.actions.mapmode.MapMode
actionPerformed, mouseClicked, mouseEntered, requestFocusInMapView, updateKeyModifiers, updateKeyModifiers, updateKeyModifiers, updateStatusLine

Methods inherited from class org.openstreetmap.josm.actions.JosmAction
getCurrentDataSet, getEditLayer, getShortcut, initEnabledState, installAdapters, setTooltip, updateEnabledState

Methods inherited from class javax.swing.AbstractAction
addPropertyChangeListener, clone, firePropertyChange, getKeys, getPropertyChangeListeners, getValue, isEnabled, putValue, removePropertyChangeListener, setEnabled

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - cursorJoinNode
```
private final Cursor cursorJoinNode
```
  - cursorJoinWay
```
private final Cursor cursorJoinWay
```
  - lastUsedNode
```
private Node lastUsedNode
```
  - PHI
```
private double PHI
```
  - toleranceMultiplier
```
private double toleranceMultiplier
```
  - mouseOnExistingNode
```
private Node mouseOnExistingNode
```
  - mouseOnExistingWays
```
private Set<Way> mouseOnExistingWays
```
  - oldHighlights
```
private Set<OsmPrimitive> oldHighlights
```
  - newHighlights
```
private Set<OsmPrimitive> newHighlights
```
  - drawHelperLine
```
private boolean drawHelperLine
```
  - wayIsFinished
```
private boolean wayIsFinished
```
  - drawTargetHighlight
```
private boolean drawTargetHighlight
```
  - mousePos
```
private Point mousePos
```
  - oldMousePos
```
private Point oldMousePos
```
  - rubberLineColor
```
private Color rubberLineColor
```
  - currentBaseNode
```
private Node currentBaseNode
```
  - previousNode
```
private Node previousNode
```
  - currentMouseEastNorth
```
private EastNorth currentMouseEastNorth
```
  - snapHelper
```
private final DrawAction.SnapHelper snapHelper
```
  - backspaceShortcut
```
private Shortcut backspaceShortcut
```
  - backspaceAction
```
private DrawAction.BackSpaceAction backspaceAction
```
  - snappingShortcut
```
private final Shortcut snappingShortcut
```
  - snapChangeAction
```
private final DrawAction.SnapChangeAction snapChangeAction
```
  - snapCheckboxMenuItem
```
private final JCheckBoxMenuItem snapCheckboxMenuItem
```
  - useRepeatedShortcut
```
private boolean useRepeatedShortcut
```
  - rubberLineStroke
```
private Stroke rubberLineStroke
```
  - BASIC_STROKE
```
private static final BasicStroke BASIC_STROKE
```
  - set
```
private final Set<Integer> set
```
  - releaseEvent
```
private KeyEvent releaseEvent
```
  - timer
```
private Timer timer
```
  - rightClickPressPos
```
private Point rightClickPressPos
```
- Constructor Detail
  - DrawAction
```
public DrawAction(MapFrame mapFrame)
```
- Method Detail
  - addMenuItem
```
private JCheckBoxMenuItem addMenuItem()
```
  - redrawIfRequired
```
private boolean redrawIfRequired()
```
    Checks if a map redraw is required and does so if needed. Also updates the status bar
  - enterMode
```
public void enterMode()
```
    Description copied from class: MapMode
    
    Makes this map mode active.
    
    Overrides:
    
    enterMode in class MapMode
  - exitMode
```
public void exitMode()
```
    Description copied from class: MapMode
    
    Makes this map mode inactive.
    
    Overrides:
    
    exitMode in class MapMode
  - eventDispatched
```
public void eventDispatched(AWTEvent event)
```
    redraw to (possibly) get rid of helper line if selection changes.
    
    Specified by:
    
    eventDispatched in interface AWTEventListener
  - processKeyEvent
```
void processKeyEvent(KeyEvent e)
```
  - doKeyPressEvent
```
private void doKeyPressEvent(KeyEvent e)
```
  - doKeyReleaseEvent
```
private void doKeyReleaseEvent(KeyEvent e)
```
  - selectionChanged
```
public void selectionChanged(Collection<? extends OsmPrimitive> newSelection)
```
    redraw to (possibly) get rid of helper line if selection changes.
    
    Specified by:
    
    selectionChanged in interface SelectionChangedListener
    
    Parameters:
    
    newSelection - The new selection.
  - tryAgain
```
private void tryAgain(MouseEvent e)
```
  - finishDrawing
```
private void finishDrawing()
```
    This function should be called when the user wishes to finish his current draw action. If Potlatch Style is enabled, it will switch to select tool, otherwise simply disable the helper line until the user chooses to draw something else.
  - mousePressed
```
public void mousePressed(MouseEvent e)
```
    Specified by:
    
    mousePressed in interface MouseListener
    
    Overrides:
    
    mousePressed in class MapMode
  - mouseReleased
```
public void mouseReleased(MouseEvent e)
```
    If user clicked with the left button, add a node at the current mouse position. If in nodeway mode, insert the node into the way.
    
    Specified by:
    
    mouseReleased in interface MouseListener
    
    Overrides:
    
    mouseReleased in class MapMode
  - insertNodeIntoAllNearbySegments
```
private void insertNodeIntoAllNearbySegments(List<WaySegment> wss,
                                             Node n,
                                             Collection<OsmPrimitive> newSelection,
                                             Collection<Command> cmds,
                                             List<Way> replacedWays,
                                             List<Way> reuseWays)
```
  - isSelfContainedWay
```
private boolean isSelfContainedWay(Way selectedWay,
                                   Node currentNode,
                                   Node targetNode)
```
    Prevent creation of ways that look like this: <----> This happens if users want to draw a no-exit-sideway from the main way like this: ^ |<----> | The solution isn't ideal because the main way will end in the side way, which is bad for navigation software ("drive straight on") but at least easier to fix. Maybe users will fix it on their own, too. At least it's better than producing an error.
    
    Parameters:
    
    selectedWay - the way to check
    
    currentNode - the current node (i.e. the one the connection will be made from)
    
    targetNode - the target node (i.e. the one the connection will be made to)
    
    Returns:
    
    true if this would create a selfcontaining way, false otherwise.
  - findNodeToContinueFrom
```
private Node findNodeToContinueFrom(Node selectedNode,
                                    Way selectedWay)
```
    Finds a node to continue drawing from. Decision is based upon given node and way.
    
    Parameters:
    
    selectedNode - Currently selected node, may be null
    
    selectedWay - Currently selected way, may be null
    
    Returns:
    
    Node if a suitable node is found, null otherwise
  - mouseDragged
```
public void mouseDragged(MouseEvent e)
```
    Specified by:
    
    mouseDragged in interface MouseMotionListener
    
    Overrides:
    
    mouseDragged in class MapMode
  - mouseMoved
```
public void mouseMoved(MouseEvent e)
```
    Specified by:
    
    mouseMoved in interface MouseMotionListener
    
    Overrides:
    
    mouseMoved in class MapMode
  - tryToSetBaseSegmentForAngleSnap
```
private void tryToSetBaseSegmentForAngleSnap()
```
    This method is used to detect segment under mouse and use it as reference for angle snapping
  - computeHelperLine
```
private void computeHelperLine()
```
    This method prepares data required for painting the "helper line" from the last used position to the mouse cursor. It duplicates some code from mouseReleased() (FIXME).
  - showStatusInfo
```
private void showStatusInfo(double angle,
                            double hdg,
                            double distance,
                            boolean activeFlag)
```
  - determineCurrentBaseNodeAndPreviousNode
```
private void determineCurrentBaseNodeAndPreviousNode(Collection<OsmPrimitive> selection)
```
    Helper function that sets fields currentBaseNode and previousNode
    
    Parameters:
    
    selection - uses also lastUsedNode field
  - continueWayFromNode
```
private void continueWayFromNode(Way way,
                                 Node node)
```
    if one of the ends of @param way is given @param node , then set currentBaseNode = node and previousNode = adjacent node of way
  - mouseExited
```
public void mouseExited(MouseEvent e)
```
    Repaint on mouse exit so that the helper line goes away.
    
    Specified by:
    
    mouseExited in interface MouseListener
    
    Overrides:
    
    mouseExited in class MapMode
  - getWayForNode
```
public static Way getWayForNode(Node n)
```
    Returns:
    
    If the node is the end of exactly one way, return this. null otherwise.
  - getCurrentBaseNode
```
public Node getCurrentBaseNode()
```
  - pruneSuccsAndReverse
```
private static void pruneSuccsAndReverse(List<Integer> is)
```
  - adjustNode
```
private static void adjustNode(Collection<Pair<Node,Node>> segs,
                               Node n)
```
    Adjusts the position of a node to lie on a segment (or a segment intersection). If one or more than two segments are passed, the node is adjusted to lie on the first segment that is passed. If two segments are passed, the node is adjusted to be at their intersection. No action is taken if no segments are passed.
    
    Parameters:
    
    segs - the segments to use as a reference when adjusting
    
    n - the node to adjust
  - det
```
static double det(double a,
                  double b,
                  double c,
                  double d)
```
  - tryToMoveNodeOnIntersection
```
private void tryToMoveNodeOnIntersection(List<WaySegment> wss,
                                         Node n)
```
  - addHighlighting
```
private void addHighlighting()
```
    Takes the data from computeHelperLine to determine which ways/nodes should be highlighted (if feature enabled). Also sets the target cursor if appropriate. It adds the to-be- highlighted primitives to newHighlights but does not actually highlight them. This work is done in redrawIfRequired. This means, calling addHighlighting() without redrawIfRequired() will leave the data in an inconsistent state. The status bar derives its information from oldHighlights, so in order to update the status bar both addHighlighting() and repaintIfRequired() are needed, since former fills newHighlights and latter processes them into oldHighlights.
  - removeHighlighting
```
private boolean removeHighlighting()
```
    Removes target highlighting from primitives. Issues repaint if required. Returns true if a repaint has been issued.
  - paint
```
public void paint(Graphics2D g,
                  MapView mv,
                  Bounds box)
```
    Description copied from interface: MapViewPaintable
    
    Paint the dataset using the engine set.
    
    Specified by:
    
    paint in interface MapViewPaintable
    
    mv - The object that can translate GeoPoints to screen coordinates.
  - getModeHelpText
```
public String getModeHelpText()
```
    Overrides:
    
    getModeHelpText in class MapMode
  - getInProgressSelection
```
public Collection<OsmPrimitive> getInProgressSelection()
```
    Get selected primitives, while draw action is in progress. While drawing a way, technically the last node is selected. This is inconvenient when the user tries to add tags to the way using a keyboard shortcut. In that case, this method returns the current way as selection, to work around this issue. Otherwise the normal selection of the current data layer is returned.
  - layerIsSupported
```
public boolean layerIsSupported(Layer l)
```
    Overrides:
    
    layerIsSupported in class MapMode
  - updateEnabledState
```
protected void updateEnabledState()
```
    Description copied from class: JosmAction
    
    Override in subclasses to update the enabled state of the action when something in the JOSM state changes, i.e. when a layer is removed or added. See JosmAction.updateEnabledState(Collection) to respond to changes in the collection of selected primitives. Default behavior is empty.
    
    Overrides:
    
    updateEnabledState in class JosmAction
    
    See Also:
    
    JosmAction.updateEnabledState(Collection), JosmAction.initEnabledState()
  - destroy
```
public void destroy()
```
    Description copied from interface: Destroyable
    
    Called when the object has been destroyed.
    
    Specified by:
    
    destroy in interface Destroyable
    
    Overrides:
    
    destroy in class JosmAction

Class DrawAction

Nested Class Summary

Field Summary

Fields inherited from class org.openstreetmap.josm.actions.mapmode.MapMode

Fields inherited from class org.openstreetmap.josm.actions.JosmAction

Fields inherited from class javax.swing.AbstractAction

Fields inherited from interface javax.swing.Action

Constructor Summary

Method Summary

Methods inherited from class org.openstreetmap.josm.actions.mapmode.MapMode

Methods inherited from class org.openstreetmap.josm.actions.JosmAction

Methods inherited from class javax.swing.AbstractAction

Methods inherited from class java.lang.Object

Field Detail

cursorJoinNode

cursorJoinWay

lastUsedNode

PHI

toleranceMultiplier

mouseOnExistingNode

mouseOnExistingWays

oldHighlights

newHighlights

drawHelperLine

wayIsFinished

drawTargetHighlight

mousePos

oldMousePos

rubberLineColor

currentBaseNode

previousNode

currentMouseEastNorth

snapHelper

backspaceShortcut

backspaceAction

snappingShortcut

snapChangeAction

snapCheckboxMenuItem

useRepeatedShortcut

rubberLineStroke

BASIC_STROKE

set

releaseEvent

timer

rightClickPressPos

Constructor Detail

DrawAction

Method Detail

addMenuItem

redrawIfRequired

enterMode

exitMode

eventDispatched

processKeyEvent

doKeyPressEvent

doKeyReleaseEvent

selectionChanged

tryAgain

finishDrawing

mousePressed

mouseReleased

insertNodeIntoAllNearbySegments

isSelfContainedWay

findNodeToContinueFrom

mouseDragged

mouseMoved

tryToSetBaseSegmentForAngleSnap

computeHelperLine

showStatusInfo

determineCurrentBaseNodeAndPreviousNode

continueWayFromNode

mouseExited

getWayForNode

getCurrentBaseNode

pruneSuccsAndReverse

adjustNode

det

tryToMoveNodeOnIntersection

addHighlighting

removeHighlighting