TLcdGXYTouchSelectEditController (LuciadLightspeed API documentation)

java.lang.Object
- com.luciad.view.gxy.controller.ALcdGXYController
- - com.luciad.view.gxy.controller.ALcdGXYChainableController
  - - com.luciad.view.gxy.controller.touch.TLcdGXYTouchSelectEditController

All Implemented Interfaces:

ILcdUndoableSource, ILcdAWTEventListener, ILcdStatusSource, ILcdGXYChainableController, ILcdGXYController, Serializable
```
public class TLcdGXYTouchSelectEditController
extends ALcdGXYChainableController
implements ILcdUndoableSource
```
A touch controller combining selection and editing behaviour.

This controller uses two controller models: TLcdGXYSelectControllerModel2 for selection and TLcdGXYMultiPointEditControllerModel for editing. The default constructor configures the controller for single-touch editing. Refer to the other constructors for how to set up multi-touch editing.

Besides select and edit behaviour it also has support for touch-and-hold detection. When a touch-and-hold is detected, the touch-and-hold action is triggered. When the input point causing the touch-and-hold is removed, the post touch-and-hold action is triggered.

A typical use case for the touch-and-hold action is to display a context menu.

This controller only tries to handle TLcdTouchPoints which are not-consumed, and marks the TLcdTouchPoints it uses as consumed, similar to the ALcdGXYTouchChainableController.

Since:

10.0

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description
`TLcdGXYTouchSelectEditController()` Default constructor supporting selecting and single-touch editing for a standard selection model and edit model.
`TLcdGXYTouchSelectEditController(int aMaximalNumberOfInputPoints)` Creates a controller capable of editing with multiple points.
`TLcdGXYTouchSelectEditController(TLcdGXYSelectControllerModel2 aSelectControllerModel, TLcdGXYMultiPointEditControllerModel aEditControllerModel, int aMaximalNumberOfEditPoints)` Creates a new controller which supports selecting and editing, using the given select and edit controller models.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addUndoableListener(ILcdUndoableListener aUndoableListener)` Adds a listener to this source, so this listener is notified when something undoable has happened.
`void`	`appendGXYController(ILcdGXYChainableController aEnd)` This method will append the passed controller to the end of the chain.
`protected int`	`editHowMode(List<Point> aFrom, List<Point> aTo)` Returns the edit-how mode.
`protected int`	`editWhatMode(List<Point> aFrom, List<Point> aTo, int aEditHow)` Returns the edit-what mode.
`TLcdGXYMultiPointEditControllerModel`	`getEditControllerModel()` Returns the `TLcdGXYMultiPointEditControllerModel` used for the editing operations.
`ILcdGXYView`	`getGXYView()` Returns the `ILcdGXYView` the controller is interacting with.
`Color`	`getHaloColor()` Returns the color used to paint the halo around the selection rectangle.
`int`	`getHaloThickness()` Returns the thickness of the halo drawn around the selection rectangle.
`int`	`getMoveThreshold()` Returns the current threshold for move events.
`ILcdGXYChainableController`	`getNextGXYController()` Returns a reference to the controller that is located after this one in a chain, or null if this controller is the last element of the chain.
`ILcdAction`	`getPostTouchAndHoldAction()` Returns the action which will be triggered when the input point which caused a touch-and-hold is removed.
`Color`	`getRectangleColor()` Returns the color used to paint the selection rectangle.
`int`	`getRectangleLineWidth()` Returns the line width used to draw the selection rectangle.
`TLcdGXYSelectControllerModel2`	`getSelectControllerModel()` Returns the `TLcdGXYSelectControllerModel2` used for the selection operations.
`ILcdGXYLayerSubsetList`	`getSnappables()` Returns the snappables.
`ILcdAction`	`getTouchAndHoldAction()` Returns the action which is triggered when a touch-and-hold is detected.
`int`	`getTouchAndHoldDelay()` Returns the time a touch must remain immobile (within the move threshold) to cause a touch and hold.
`ILcdIcon`	`getTouchAndHoldIcon()` Returns the icon used to indicate the touch-and-hold.
`void`	`handleAWTEvent(AWTEvent aEvent)` This is method is called when the target of the listener has a new AWTEvent available.
`boolean`	`isDragRectangle()` This method indicates whether or not this controller will drag a rectangle and select all objects, interacting with the rectangle, or select objects on a TOUCH_DOWN event.
`boolean`	`isHaloEnabled()` Returns whether or not the selection rectangle (when in drag rectangle mode) will be drawn with a halo.
`boolean`	`isInstantEditing()` This method indicates whether the object being edited is painted in a temporary state and only changed when a touch point is removed or created, or whether the object is instantly edited while the touch point(s) are moved.
`void`	`paint(Graphics aGraphics)` Enables the controller to give visual feedback on the current user interactions.
`protected void`	`paintImpl(Graphics aGraphics)` The specific implementation of `paint` for this controller.
`void`	`removeUndoableListener(ILcdUndoableListener aUndoableListener)` Removes the specified listener so it is no longer notified.
`protected ILcdGXYViewXYWorldTransformation`	`retrieveGXYViewXYWorldTransformation()` Convenience method to retrieve the `ILcdGXYViewXYWorldTransformation` for the `ILcdGXYView` this controller interacts with.
`protected int`	`selectByWhatMode(Rectangle aSelectionBounds, int aInputMode)` Returns the mode that defines by what objects can be selected: by their bodies, their labels, ...
`protected int`	`selectHowMode(Rectangle aSelectionBounds, int aInputMode, int aSelectByWhatMode)` Returns the mode that defines how the objects involved in the selection should interact with the existing selection, for example add them, remove them, toggle their selection state, etc.
`void`	`setDragRectangle(boolean aDrag)` This method can be used to toggle between selecting by dragging a rectangle, and selecting by a single touch.
`void`	`setEditControllerModel(TLcdGXYMultiPointEditControllerModel aEditControllerModel)` Sets the `TLcdGXYMultiPointEditControllerModel` used for the edit operations.
`protected void`	`setGXYView(ILcdGXYView aGXYView)` Sets the `ILcdGXYView` the controller is interacting with.
`void`	`setHaloColor(Color aHaloColor)` Sets the color used to paint the halo around the selection rectangle.
`void`	`setHaloEnabled(boolean aHaloEnabled)` Enables or disables the halo effect when drawing the selection rectangle.
`void`	`setHaloThickness(int aHaloThickness)` Sets the thickness of the halo drawn around the selection rectangle.
`void`	`setInstantEditing(boolean aInstantEditing)` The method can be used to activate or deactivate instant editing.
`void`	`setMoveThreshold(int aMoveThreshold)` Sets the threshold for move events.
`void`	`setNextGXYController(ILcdGXYChainableController aNext)` This method sets the next controller in the chain for this controller.
`void`	`setPostTouchAndHoldAction(ILcdAction aPostTouchAndHoldAction)` Sets the action which will be triggered when the input point which caused a touch-and-hold is removed.
`void`	`setRectangleColor(Color aRectangleColor)` Sets the color used to paint the selection rectangle.
`void`	`setRectangleLineWidth(int aRectangleLineWidth)` Sets the line width used to draw the selection rectangle.
`void`	`setSelectControllerModel(TLcdGXYSelectControllerModel2 aSelectControllerModel)` Sets the `TLcdGXYSelectControllerModel2`.
`void`	`setSnappables(ILcdGXYLayerSubsetList aSnappables)` Sets the set of objects that are used as candidates-to-snap-to while editing other objects.
`void`	`setTouchAndHoldAction(ILcdAction aTouchAndHoldAction)` Sets the action which is triggered when a touch-and-hold is detected.
`void`	`setTouchAndHoldDelay(int aTouchAndHoldDelay)` Sets the time a touch must remain immobile (within the move threshold) to cause a touch and hold.
`void`	`setTouchAndHoldIcon(ILcdIcon aTouchAndHoldIcon)` Sets the icon which will be used to indicate a touch-and-hold.
`void`	`startInteraction(ILcdGXYView aGXYView)` Sets up the controller to receive input through the view passed.
`protected void`	`startInteractionImpl(ILcdGXYView aGXYView)` The specific implementation of `startInteraction` for this controller.
`void`	`terminateInteraction(ILcdGXYView aGXYView)` Releases a few items.
`protected void`	`terminateInteractionImpl(ILcdGXYView aGXYView)` The specific implementation of `terminateInteraction` for this controller.

Methods inherited from class com.luciad.view.gxy.controller.ALcdGXYChainableController
addStatusListener, removeStatusListener

Methods inherited from class com.luciad.view.gxy.controller.ALcdGXYController
asGXYController, fireStatusEvent, getCursor, getIcon, getName, getShortDescription, isTraceOn, registerInstance, setClassTraceOn, setCursor, setIcon, setName, setShortDescription, setTraceOn, viewRepaint

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

Methods inherited from interface com.luciad.view.gxy.ILcdGXYController
getCursor, getIcon, getLayered, getName, getShortDescription, viewRepaint

- Constructor Detail
  - TLcdGXYTouchSelectEditController
```
public TLcdGXYTouchSelectEditController()
```
    Default constructor supporting selecting and single-touch editing for a standard selection model and edit model.
    
    See Also:
    
    TLcdGXYTouchSelectEditController(com.luciad.view.gxy.controller.TLcdGXYSelectControllerModel2, com.luciad.view.gxy.controller.TLcdGXYMultiPointEditControllerModel, int)
  - TLcdGXYTouchSelectEditController
```
public TLcdGXYTouchSelectEditController(int aMaximalNumberOfInputPoints)
```
    Creates a controller capable of editing with multiple points. It will use a standard selection model and edit model.
    
    Parameters:
    
    aMaximalNumberOfInputPoints - the maximal number of input points that will be used to edit
    
    See Also:
    
    TLcdGXYTouchSelectEditController(com.luciad.view.gxy.controller.TLcdGXYSelectControllerModel2, com.luciad.view.gxy.controller.TLcdGXYMultiPointEditControllerModel, int)
  - TLcdGXYTouchSelectEditController
```
public TLcdGXYTouchSelectEditController(TLcdGXYSelectControllerModel2 aSelectControllerModel,
                                        TLcdGXYMultiPointEditControllerModel aEditControllerModel,
                                        int aMaximalNumberOfEditPoints)
```
    Creates a new controller which supports selecting and editing, using the given select and edit controller models.
    
    Parameters:
    
    aSelectControllerModel - the selection model. Must not be null.
    
    aEditControllerModel - the edit model. May be null. When set to null, this controller will no longer try to edit and only perform selection.
    
    aMaximalNumberOfEditPoints - the maximal number of input points that will be used to edit
- Method Detail
  - isHaloEnabled
```
public boolean isHaloEnabled()
```
    Returns whether or not the selection rectangle (when in drag rectangle mode) will be drawn with a halo.
    
    Returns:
    
    true is the halo is enabled, false otherwise
    
    See Also:
    
    isDragRectangle(), setDragRectangle(boolean)
  - setHaloEnabled
```
public void setHaloEnabled(boolean aHaloEnabled)
```
    Enables or disables the halo effect when drawing the selection rectangle.
    
    Parameters:
    
    aHaloEnabled - if true the halo will be enabled, if false disabled.
    
    See Also:
    
    isDragRectangle(), isHaloEnabled()
  - getRectangleLineWidth
```
public int getRectangleLineWidth()
```
    Returns the line width used to draw the selection rectangle.
    
    Returns:
    
    the width used to paint the selection rectangle.
    
    See Also:
    
    isDragRectangle(), setRectangleLineWidth(int)
  - setRectangleLineWidth
```
public void setRectangleLineWidth(int aRectangleLineWidth)
```
    Sets the line width used to draw the selection rectangle.
    
    Parameters:
    
    aRectangleLineWidth - the line width that will be used to draw the selection rectangle.
    
    See Also:
    
    isDragRectangle(), getRectangleLineWidth()
  - getRectangleColor
```
public Color getRectangleColor()
```
    Returns the color used to paint the selection rectangle.
    
    Returns:
    
    the color used to paint the selection rectangle.
    
    See Also:
    
    isDragRectangle(), setRectangleColor(java.awt.Color)
  - setRectangleColor
```
public void setRectangleColor(Color aRectangleColor)
```
    Sets the color used to paint the selection rectangle.
    
    Parameters:
    
    aRectangleColor - the color that will be used to paint the selection rectangle.
    
    See Also:
    
    isDragRectangle(), getRectangleColor()
  - getHaloColor
```
public Color getHaloColor()
```
    Returns the color used to paint the halo around the selection rectangle.
    
    Returns:
    
    the color used to paint the halo around the selection rectangle.
    
    See Also:
    
    isDragRectangle(), setRectangleColor(java.awt.Color)
  - setHaloColor
```
public void setHaloColor(Color aHaloColor)
```
    Sets the color used to paint the halo around the selection rectangle.
    
    Parameters:
    
    aHaloColor - the color that will be used to paint the halo around the selection rectangle.
    
    See Also:
    
    isDragRectangle(), getRectangleColor()
  - getHaloThickness
```
public int getHaloThickness()
```
    Returns the thickness of the halo drawn around the selection rectangle.
    
    Returns:
    
    the thickness of the halo drawn around the selection rectangle.
    
    See Also:
    
    isDragRectangle(), setHaloThickness(int)
  - setHaloThickness
```
public void setHaloThickness(int aHaloThickness)
```
    Sets the thickness of the halo drawn around the selection rectangle.
    
    Parameters:
    
    aHaloThickness - the thickness of the halo that will be drawn around the selection rectangle.
    
    See Also:
    
    isDragRectangle(), getHaloThickness()
  - handleAWTEvent
```
public void handleAWTEvent(AWTEvent aEvent)
```
    Description copied from interface: ILcdAWTEventListener
    
    This is method is called when the target of the listener has a new AWTEvent available.
    
    Specified by:
    
    handleAWTEvent in interface ILcdAWTEventListener
    
    Parameters:
    
    aEvent - The event to be handled.
  - getGXYView
```
public ILcdGXYView getGXYView()
```
    Description copied from class: ALcdGXYController
    
    Returns the ILcdGXYView the controller is interacting with.
    
    Overrides:
    
    getGXYView in class ALcdGXYController
    
    Returns:
    
    the ILcdGXYView the controller is interacting with, or null if the view is not interacting with a view
  - setGXYView
```
protected void setGXYView(ILcdGXYView aGXYView)
```
    Description copied from class: ALcdGXYController
    
    Sets the ILcdGXYView the controller is interacting with.
    This method is called when ILcdGXYView.setGXYController is used to set an ILcdGXYController active on an ILcdGXYView.
    
    Overrides:
    
    setGXYView in class ALcdGXYController
    
    Parameters:
    
    aGXYView - the view the controller is interacting with
    
    See Also:
    
    ALcdGXYController.startInteraction(com.luciad.view.gxy.ILcdGXYView), ILcdGXYView.setGXYController(com.luciad.view.gxy.ILcdGXYController)
  - retrieveGXYViewXYWorldTransformation
```
protected ILcdGXYViewXYWorldTransformation retrieveGXYViewXYWorldTransformation()
```
    Description copied from class: ALcdGXYController
    
    Convenience method to retrieve the ILcdGXYViewXYWorldTransformation for the ILcdGXYView this controller interacts with. The default implementation returns the view's own transformation.
    
    Overrides:
    
    retrieveGXYViewXYWorldTransformation in class ALcdGXYController
    
    Returns:
    
    a ILcdGXYViewXYWorldTransformation for the ILcdGXYView this controller interacts with.
  - startInteraction
```
public void startInteraction(ILcdGXYView aGXYView)
```
    Description copied from class: ALcdGXYChainableController
    
    Sets up the controller to receive input through the view passed.
    All ILcdGXYView implementations that support interaction call this method when the controller has been made active with setGXYController on the view, so this method shouldn't normally be called directly. Note that most view implementations add the controller as listener if appropriate before calling this method.
    Sets the cursor on the view and sets the view for which this controller is now active. Sends out a status event based on the short description.
    This method also calls ALcdGXYChainableController.startInteraction(com.luciad.view.gxy.ILcdGXYView) on the next controller. Override ALcdGXYChainableController.startInteractionImpl(com.luciad.view.gxy.ILcdGXYView) if you want to add your own behavior to this controller.
    
    Specified by:
    
    startInteraction in interface ILcdGXYController
    
    Overrides:
    
    startInteraction in class ALcdGXYChainableController
    
    Parameters:
    
    aGXYView - the ILcdGXYView this ILcdGXYController will interact with.
    
    See Also:
    
    ALcdGXYChainableController.startInteractionImpl(com.luciad.view.gxy.ILcdGXYView)
  - startInteractionImpl
```
protected void startInteractionImpl(ILcdGXYView aGXYView)
```
    Description copied from class: ALcdGXYChainableController
    
    The specific implementation of startInteraction for this controller.
    
    Overrides:
    
    startInteractionImpl in class ALcdGXYChainableController
    
    Parameters:
    
    aGXYView - the view to start interaction with.
  - terminateInteraction
```
public void terminateInteraction(ILcdGXYView aGXYView)
```
    Description copied from class: ALcdGXYChainableController
    
    Releases a few items. Can be redefined but this 'super' method should be called too.
    This method also calls ALcdGXYChainableController.terminateInteraction(com.luciad.view.gxy.ILcdGXYView) on the next controller. Override ALcdGXYChainableController.terminateInteractionImpl(com.luciad.view.gxy.ILcdGXYView) if you want to add your own behavior to this controller.
    
    Specified by:
    
    terminateInteraction in interface ILcdGXYController
    
    Overrides:
    
    terminateInteraction in class ALcdGXYChainableController
    
    Parameters:
    
    aGXYView - the ILcdGXYView this ILcdGXYController interacted with.
    
    See Also:
    
    ALcdGXYChainableController.terminateInteractionImpl(com.luciad.view.gxy.ILcdGXYView)
  - terminateInteractionImpl
```
protected void terminateInteractionImpl(ILcdGXYView aGXYView)
```
    Description copied from class: ALcdGXYChainableController
    
    The specific implementation of terminateInteraction for this controller.
    
    Overrides:
    
    terminateInteractionImpl in class ALcdGXYChainableController
    
    Parameters:
    
    aGXYView - the view to terminate interaction with.
  - paint
```
public void paint(Graphics aGraphics)
```
    Description copied from class: ALcdGXYChainableController
    
    Enables the controller to give visual feedback on the current user interactions. Note that the controller is responsible for repainting the view.
    Empty implementation. Redefine this method to render on the Graphics on which the view is rendered.
    This method also calls ALcdGXYChainableController.paint(java.awt.Graphics) on the next controller. Override ALcdGXYChainableController.paintImpl(java.awt.Graphics) if you want to add your own behavior to this controller.
    
    Specified by:
    
    paint in interface ILcdGXYController
    
    Overrides:
    
    paint in class ALcdGXYChainableController
    
    Parameters:
    
    aGraphics - the Graphics on which the view was rendered.
    
    See Also:
    
    ALcdGXYChainableController.paintImpl(java.awt.Graphics)
  - paintImpl
```
protected void paintImpl(Graphics aGraphics)
```
    Description copied from class: ALcdGXYChainableController
    
    The specific implementation of paint for this controller.
    
    Overrides:
    
    paintImpl in class ALcdGXYChainableController
    
    Parameters:
    
    aGraphics - the graphics to be used for painting.
  - setNextGXYController
```
public void setNextGXYController(ILcdGXYChainableController aNext)
```
    Description copied from interface: ILcdGXYChainableController
    
    This method sets the next controller in the chain for this controller. You can set null if you want the chain to end. This method does not start or terminate any interaction. If you need to replace a controller while it's being used you are responsible for properly terminating and starting it yourself.
    
    Specified by:
    
    setNextGXYController in interface ILcdGXYChainableController
    
    Overrides:
    
    setNextGXYController in class ALcdGXYChainableController
    
    Parameters:
    
    aNext - the reference to the controller that will be the next element in the chain
    
    See Also:
    
    ILcdGXYChainableController.getNextGXYController()
  - getNextGXYController
```
public ILcdGXYChainableController getNextGXYController()
```
    Description copied from interface: ILcdGXYChainableController
    
    Returns a reference to the controller that is located after this one in a chain, or null if this controller is the last element of the chain.
    
    Specified by:
    
    getNextGXYController in interface ILcdGXYChainableController
    
    Overrides:
    
    getNextGXYController in class ALcdGXYChainableController
    
    Returns:
    
    a reference to the next controller.
    
    See Also:
    
    ILcdGXYChainableController.setNextGXYController(ILcdGXYChainableController)
  - appendGXYController
```
public void appendGXYController(ILcdGXYChainableController aEnd)
```
    Description copied from interface: ILcdGXYChainableController
    
    This method will append the passed controller to the end of the chain. The controller will be the stored as the next controller in the last element of the current chain.
    
    Specified by:
    
    appendGXYController in interface ILcdGXYChainableController
    
    Overrides:
    
    appendGXYController in class ALcdGXYChainableController
    
    Parameters:
    
    aEnd - the controller to be appended to the end of the chain.
  - addUndoableListener
```
public void addUndoableListener(ILcdUndoableListener aUndoableListener)
```
    Description copied from interface: ILcdUndoableSource
    
    Adds a listener to this source, so this listener is notified when something undoable has happened.
    
    Specified by:
    
    addUndoableListener in interface ILcdUndoableSource
    
    Parameters:
    
    aUndoableListener - The listener to be notified when something undoable has happened.
  - removeUndoableListener
```
public void removeUndoableListener(ILcdUndoableListener aUndoableListener)
```
    Description copied from interface: ILcdUndoableSource
    
    Removes the specified listener so it is no longer notified.
    
    Specified by:
    
    removeUndoableListener in interface ILcdUndoableSource
    
    Parameters:
    
    aUndoableListener - The listener to remove.
  - selectByWhatMode
```
protected int selectByWhatMode(Rectangle aSelectionBounds,
                               int aInputMode)
```
    Returns the mode that defines by what objects can be selected: by their bodies, their labels, ...
    
    The default value is a bit-wise or of TLcdGXYSelectControllerModel2.SELECT_BY_WHAT_BODIES_ON_CLICK, TLcdGXYSelectControllerModel2.SELECT_BY_WHAT_BODIES_ON_DRAG_CONTAINS, TLcdGXYSelectControllerModel2.SELECT_BY_WHAT_LABELS_ON_CLICK and TLcdGXYSelectControllerModel2.SELECT_BY_WHAT_LABELS_ON_DRAG_CONTAINS.
    
    Parameters:
    
    aSelectionBounds - The selection rectangle, in view coordinates (pixels). This could for example be the rectangle the user dragged on the map, or a one pixel wide rectangle for a click.
    
    aInputMode - Either TLcdGXYSelectControllerModel2.INPUT_MODE_POINT or TLcdGXYSelectControllerModel2.INPUT_MODE_RECTANGLE, indicating if this selection change originated from a click or from a drag.
    
    Returns:
    
    The select-by-what mode, a bit-wise or of the constants defined in the TLcdGXYSelectControllerModel2 class that start with SELECT_BY.
  - selectHowMode
```
protected int selectHowMode(Rectangle aSelectionBounds,
                            int aInputMode,
                            int aSelectByWhatMode)
```
    Returns the mode that defines how the objects involved in the selection should interact with the existing selection, for example add them, remove them, toggle their selection state, etc.
    
    The default implementation returns TLcdGXYSelectControllerModel2.SELECT_HOW_FIRST_TOUCHED.
    
    Parameters:
    
    aSelectionBounds - The selection rectangle, in view coordinates (pixels). This could for example be the rectangle the user dragged on the map, or a one pixel wide rectangle for a touch.
    
    aInputMode - Either TLcdGXYSelectControllerModel2.INPUT_MODE_POINT or TLcdGXYSelectControllerModel2.INPUT_MODE_RECTANGLE, indicating if this selection change originated from a click or from a drag.
    
    aSelectByWhatMode - The select-by-what mode, for example the result of the method selectByWhatMode. It is a bit-wise or of the constants in the TLcdGXYSelectControllerModel2 class that start with SELECT_BY.
    
    Returns:
    
    The select-how mode, a bit-wise or of the constants in the TLcdGXYSelectControllerModel2 class that start with SELECT_HOW.
  - editWhatMode
```
protected int editWhatMode(List<Point> aFrom,
                           List<Point> aTo,
                           int aEditHow)
```
    Returns the edit-what mode. This mode indicates what the edit should do: should the labels be edited, or the objects themselves?
    
    This method returns TLcdGXYMultiPointEditControllerModel.EDIT_WHAT_LABELS if one or more labels are touched. If none of the labels is touched, it will check whether an object is touched, and return TLcdGXYMultiPointEditControllerModel.EDIT_WHAT_OBJECTS if this is the case. If none of the previous conditions is met, it will return TLcdGXYMultiPointEditControllerModel.EDIT_WHAT_NO_CHANGE.
    
    This method calls the editingCandidates method with all the input points of aFrom and aTo.
    
    Touched is defined as returning true when calling ILcdGXYPainter.isTouched(java.awt.Graphics, int, com.luciad.view.gxy.ILcdGXYContext) or ILcdGXYLabelPainter2.isLabelTouched(java.awt.Graphics, int, com.luciad.view.gxy.ILcdGXYContext) for every input point.
    
    A possible customization of this method is to return TLcdGXYMultiPointEditControllerModel.EDIT_WHAT_FIRST_TOUCHED_LABEL instead of TLcdGXYMultiPointEditControllerModel.EDIT_WHAT_LABELS when a label is touched.
    
    Parameters:
    
    aFrom - A list with point(s) where the edit originated. Should have the same length as aTo, and the order of the points in both lists should be the same, e.g. the location of the first point of aFrom when the edit terminated should be passed as the first point in aTo.
    
    aTo - A list with point(s) where the edit terminated (so far). Should have the same length as aFrom, and the order of the points in both list should be the same, e.g. the location of the first point of aFrom when the edit terminated should be passed as the first point in aTo.
    
    aEditHow - The edit-how mode: one of the constants in the TLcdGXYMultiPointEditControllerModel class that start with EDIT_HOW.
    
    Returns:
    
    one of the constants in the TLcdGXYMultiPointEditControllerModel class that start with EDIT_WHAT.
  - editHowMode
```
protected int editHowMode(List<Point> aFrom,
                          List<Point> aTo)
```
    Returns the edit-how mode. This mode indicates how the edit should behave: should the editing candidates be translated or reshaped? This method should be overridden if a different behaviour is desired.
    
    The default implementation returns TLcdGXYMultiPointEditControllerModel.EDIT_HOW_TRANSLATING.
    Please note that the actual meaning of reshaping and translating is defined by the implementation of ILcdGXYPainter/ILcdGXYEditor that is used.
    
    Parameters:
    
    aFrom - A list with point(s) where the edit originated. Should have the same length as aTo, and the order of the points in both lists should be the same, e.g. the location of the first point of aFrom when the edit terminated should be passed as the first point in aTo.
    
    aTo - A list with point(s) where the edit terminated (so far). Should have the same length as aFrom, and the order of the points in both list should be the same, e.g. the location of the first point of aFrom when the edit terminated should be passed as the first point in aTo.
    
    Returns:
    
    One of the constants in TLcdGXYMultiPointEditControllerModel that start with EDIT_HOW.
  - getSelectControllerModel
```
public TLcdGXYSelectControllerModel2 getSelectControllerModel()
```
    Returns the TLcdGXYSelectControllerModel2 used for the selection operations.
    
    Returns:
    
    the TLcdGXYSelectControllerModel2.
    
    See Also:
    
    setSelectControllerModel(TLcdGXYSelectControllerModel2)
  - setSelectControllerModel
```
public void setSelectControllerModel(TLcdGXYSelectControllerModel2 aSelectControllerModel)
```
    Sets the TLcdGXYSelectControllerModel2. This allows for instance to disable selection by touching labels etc... Please refer to TLcdGXYSelectControllerModel2 for more information.
    
    Parameters:
    
    aSelectControllerModel - The select controller model to set. Must not be null
    
    See Also:
    
    TLcdGXYSelectControllerModel2, getSelectControllerModel()
  - getEditControllerModel
```
public TLcdGXYMultiPointEditControllerModel getEditControllerModel()
```
    Returns the TLcdGXYMultiPointEditControllerModel used for the editing operations.
    
    Returns:
    
    the TLcdGXYMultiPointEditControllerModel
    
    See Also:
    
    setEditControllerModel(TLcdGXYMultiPointEditControllerModel)
  - setEditControllerModel
```
public void setEditControllerModel(TLcdGXYMultiPointEditControllerModel aEditControllerModel)
```
    Sets the TLcdGXYMultiPointEditControllerModel used for the edit operations. This allows to customize the editing logic, such as which objects should be edited, etc. . Please refer to TLcdGXYMultiPointEditControllerModel for more information.
    
    Parameters:
    
    aEditControllerModel - The edit controller model to set. May be null. When set to null, this controller will no longer try to edit and only perform selection.
    
    See Also:
    
    TLcdGXYMultiPointEditControllerModel, getEditControllerModel()
  - setSnappables
```
public void setSnappables(ILcdGXYLayerSubsetList aSnappables)
```
    Sets the set of objects that are used as candidates-to-snap-to while editing other objects. Set to null to disable snapping.
    Please refer to the developer guide for more information about snapping.
    
    Parameters:
    
    aSnappables - the list of objects that are candidates to snap to.
    
    See Also:
    
    getSnappables()
  - getSnappables
```
public ILcdGXYLayerSubsetList getSnappables()
```
    Returns the snappables.
    
    Returns:
    
    the snappables.
    
    See Also:
    
    setSnappables(com.luciad.view.gxy.ILcdGXYLayerSubsetList)
  - setMoveThreshold
```
public void setMoveThreshold(int aMoveThreshold)
```
    Sets the threshold for move events.
    
    Only MOVED events describing a move of the point to a location further then the threshold in either the X or Y direction from its previous location should be considered by this controller.
    
    For example, when the threshold is set to 5, and the point is currently located at location (A,B), all move events should not be considered by this controller until the point is moved to a new location (A+x, B+y) where the absolute value of x and/or y must at least be 5.
    
    The new value of the threshold will not affect any events which arrived at the controller prior to the change in threshold.
    
    The default value for this property is 0, which means every move of a tracked input point will be handled.
    
    Parameters:
    
    aMoveThreshold - the threshold for move events. Must be positive.
    
    See Also:
    
    getMoveThreshold()
  - getMoveThreshold
```
public int getMoveThreshold()
```
    Returns the current threshold for move events.
    
    Only TOUCH_POINT_MOVED events describing a move of the point to a location further then the threshold in either the X or Y direction from its previous location should be considered by this controller.
    
    For example, when the threshold is set to 5, and the point is currently located at location (A,B), all move events should not be considered by this controller until the point is moved to a new location (A+x, B+y) where the absolute value of x and/or y must at least be 5.
    
    The default value for this property is 10.
    
    Returns:
    
    the current threshold for move events
    
    See Also:
    
    setMoveThreshold(int)
  - isDragRectangle
```
public boolean isDragRectangle()
```
    This method indicates whether or not this controller will drag a rectangle and select all objects, interacting with the rectangle, or select objects on a TOUCH_DOWN event.
    
    Returns:
    
    true if drag rectangle mode is active, and false if object are selected by a touch.
  - setDragRectangle
```
public void setDragRectangle(boolean aDrag)
```
    This method can be used to toggle between selecting by dragging a rectangle, and selecting by a single touch.
    
    Parameters:
    
    aDrag - true indicates selecting by dragging a rectangle, false indicates selecting the object you touch.
  - getTouchAndHoldAction
```
public ILcdAction getTouchAndHoldAction()
```
    Returns the action which is triggered when a touch-and-hold is detected.
    
    Returns:
    
    the action which is triggered when a touch-and-hold is detected. The default value is null
    
    See Also:
    
    setTouchAndHoldAction(com.luciad.gui.ILcdAction)
  - setTouchAndHoldAction
```
public void setTouchAndHoldAction(ILcdAction aTouchAndHoldAction)
```
    Sets the action which is triggered when a touch-and-hold is detected.
    
    A typical use case is to display a context-menu on a touch-and-hold.
    
    Parameters:
    
    aTouchAndHoldAction - the action to trigger when a touch-and-hold is detected. May be null
    
    See Also:
    
    getTouchAndHoldAction()
  - getTouchAndHoldIcon
```
public ILcdIcon getTouchAndHoldIcon()
```
    Returns the icon used to indicate the touch-and-hold.
    
    Returns:
    
    the icon used to indicate the touch-and-hold. The default value is null
    
    See Also:
    
    setTouchAndHoldAction(com.luciad.gui.ILcdAction)
  - setTouchAndHoldIcon
```
public void setTouchAndHoldIcon(ILcdIcon aTouchAndHoldIcon)
```
    Sets the icon which will be used to indicate a touch-and-hold. It is painted at the input location from the moment the touch-and-hold action is executed until the post touch-and-hold action is executed.
    
    When the view is an instance of Component, it is passed to the ILcdIcon.paintIcon(java.awt.Component, java.awt.Graphics, int, int) method. This allows for animated icons. In such case, the animated icon should call Component.repaint() every time it changes.
    
    Parameters:
    
    aTouchAndHoldIcon - the icon. May be null.
    
    See Also:
    
    getTouchAndHoldIcon(), getTouchAndHoldAction(), getPostTouchAndHoldAction()
  - getPostTouchAndHoldAction
```
public ILcdAction getPostTouchAndHoldAction()
```
    Returns the action which will be triggered when the input point which caused a touch-and-hold is removed.
    
    Returns:
    
    the action which will be triggered when the input point which caused a touch-and-hold is removed. The default value is null
    
    See Also:
    
    setPostTouchAndHoldAction(com.luciad.gui.ILcdAction)
  - setPostTouchAndHoldAction
```
public void setPostTouchAndHoldAction(ILcdAction aPostTouchAndHoldAction)
```
    Sets the action which will be triggered when the input point which caused a touch-and-hold is removed.
    
    Parameters:
    
    aPostTouchAndHoldAction - the action which will be triggered when the input point which caused a touch-and-hold is removed. May be null
  - getTouchAndHoldDelay
```
public int getTouchAndHoldDelay()
```
    Returns the time a touch must remain immobile (within the move threshold) to cause a touch and hold.
    
    Returns:
    
    the time it takes for a touch and hold to occur.
    
    See Also:
    
    setTouchAndHoldDelay(int), setMoveThreshold(int)
  - setTouchAndHoldDelay
```
public void setTouchAndHoldDelay(int aTouchAndHoldDelay)
```
    Sets the time a touch must remain immobile (within the move threshold) to cause a touch and hold. The default value is 1000.
    
    Parameters:
    
    aTouchAndHoldDelay - the time it will take for a touch and hold to occur.
    
    See Also:
    
    getTouchAndHoldDelay(), setMoveThreshold(int)
  - isInstantEditing
```
public boolean isInstantEditing()
```
    This method indicates whether the object being edited is painted in a temporary state and only changed when a touch point is removed or created, or whether the object is instantly edited while the touch point(s) are moved.
    
    The default value for this property is false.
    
    Returns:
    
    true if this controller instantly edits objects, without painting them in a temporary state, false otherwise.
    
    See Also:
    
    setInstantEditing(boolean)
  - setInstantEditing
```
public void setInstantEditing(boolean aInstantEditing)
```
    The method can be used to activate or deactivate instant editing. When instant editing is enabled objects will be edited whenever a touch point is moved. When it is disabled, objects will be edited only when the touch points are removed or created, and will be painted in a temporary state. When enabling instant editing, take into account:
    - performance may suffer, the view invalidates the layer that is edited, and as a result this layer has to be repainted.
    - no snap targets will be visible, snapping will still work but with less feedback.
    - when dragging a handle over another handle, it's possible that the second handle is edited instead of the first
    The recommended value for multi-editing is true.
    Parameters:
    
    aInstantEditing - when true instant editing will be enabled, when false disabled.
    
    See Also:
    
    isInstantEditing()

LuciadLightspeedClass TLcdGXYTouchSelectEditController

Constructor Summary

Method Summary

Methods inherited from class com.luciad.view.gxy.controller.ALcdGXYChainableController

Methods inherited from class com.luciad.view.gxy.controller.ALcdGXYController

Methods inherited from class java.lang.Object

Methods inherited from interface com.luciad.view.gxy.ILcdGXYController

Constructor Detail

TLcdGXYTouchSelectEditController

TLcdGXYTouchSelectEditController

TLcdGXYTouchSelectEditController

Method Detail

isHaloEnabled

setHaloEnabled

getRectangleLineWidth

setRectangleLineWidth

getRectangleColor

setRectangleColor

getHaloColor

setHaloColor

getHaloThickness

setHaloThickness

handleAWTEvent

getGXYView

setGXYView

retrieveGXYViewXYWorldTransformation

startInteraction

startInteractionImpl

terminateInteraction

terminateInteractionImpl

paint

paintImpl

setNextGXYController

getNextGXYController

appendGXYController

addUndoableListener

removeUndoableListener

selectByWhatMode

selectHowMode

editWhatMode

editHowMode

getSelectControllerModel

setSelectControllerModel

getEditControllerModel

setEditControllerModel

setSnappables

getSnappables

setMoveThreshold

getMoveThreshold

isDragRectangle

setDragRectangle

getTouchAndHoldAction

setTouchAndHoldAction

getTouchAndHoldIcon

setTouchAndHoldIcon

getPostTouchAndHoldAction

setPostTouchAndHoldAction

getTouchAndHoldDelay

setTouchAndHoldDelay

isInstantEditing

setInstantEditing