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 TLcdTouchPoint
s which are not-consumed, and marks the
TLcdTouchPoint
s it uses as consumed, similar to the ALcdGXYTouchChainableController
.
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.
|
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. |
addStatusListener, removeStatusListener
asGXYController, fireStatusEvent, getCursor, getIcon, getName, getShortDescription, isTraceOn, registerInstance, setClassTraceOn, setCursor, setIcon, setName, setShortDescription, setTraceOn, viewRepaint
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
getCursor, getIcon, getLayered, getName, getShortDescription, viewRepaint
public TLcdGXYTouchSelectEditController()
public TLcdGXYTouchSelectEditController(int aMaximalNumberOfInputPoints)
aMaximalNumberOfInputPoints
- the maximal number of input points that will be used to
editTLcdGXYTouchSelectEditController(com.luciad.view.gxy.controller.TLcdGXYSelectControllerModel2,
com.luciad.view.gxy.controller.TLcdGXYMultiPointEditControllerModel, int)
public TLcdGXYTouchSelectEditController(TLcdGXYSelectControllerModel2 aSelectControllerModel, TLcdGXYMultiPointEditControllerModel aEditControllerModel, int aMaximalNumberOfEditPoints)
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 editpublic boolean isHaloEnabled()
isDragRectangle()
,
setDragRectangle(boolean)
public void setHaloEnabled(boolean aHaloEnabled)
aHaloEnabled
- if true the halo will be enabled, if false disabled.isDragRectangle()
,
isHaloEnabled()
public int getRectangleLineWidth()
isDragRectangle()
,
setRectangleLineWidth(int)
public void setRectangleLineWidth(int aRectangleLineWidth)
aRectangleLineWidth
- the line width that will be used to draw the selection rectangle.isDragRectangle()
,
getRectangleLineWidth()
public Color getRectangleColor()
isDragRectangle()
,
setRectangleColor(java.awt.Color)
public void setRectangleColor(Color aRectangleColor)
aRectangleColor
- the color that will be used to paint the selection rectangle.isDragRectangle()
,
getRectangleColor()
public Color getHaloColor()
isDragRectangle()
,
setRectangleColor(java.awt.Color)
public void setHaloColor(Color aHaloColor)
aHaloColor
- the color that will be used to paint the halo around the selection
rectangle.isDragRectangle()
,
getRectangleColor()
public int getHaloThickness()
isDragRectangle()
,
setHaloThickness(int)
public void setHaloThickness(int aHaloThickness)
aHaloThickness
- the thickness of the halo that will be drawn around the selection
rectangle.isDragRectangle()
,
getHaloThickness()
public void handleAWTEvent(AWTEvent aEvent)
ILcdAWTEventListener
handleAWTEvent
in interface ILcdAWTEventListener
aEvent
- The event to be handled.public ILcdGXYView getGXYView()
ALcdGXYController
ILcdGXYView
the controller is interacting with.getGXYView
in class ALcdGXYController
ILcdGXYView
the controller is interacting with, or null if the view is not interacting
with a viewprotected void setGXYView(ILcdGXYView aGXYView)
ALcdGXYController
ILcdGXYView
the controller is interacting with.
This method is called when ILcdGXYView.setGXYController
is used to set an
ILcdGXYController
active on an ILcdGXYView
.
setGXYView
in class ALcdGXYController
aGXYView
- the view the controller is interacting withALcdGXYController.startInteraction(com.luciad.view.gxy.ILcdGXYView)
,
ILcdGXYView.setGXYController(com.luciad.view.gxy.ILcdGXYController)
protected ILcdGXYViewXYWorldTransformation retrieveGXYViewXYWorldTransformation()
ALcdGXYController
ILcdGXYViewXYWorldTransformation
for the
ILcdGXYView
this controller interacts with.
The default implementation returns the view's own transformation.retrieveGXYViewXYWorldTransformation
in class ALcdGXYController
ILcdGXYViewXYWorldTransformation
for the ILcdGXYView
this controller interacts with.public void startInteraction(ILcdGXYView aGXYView)
ALcdGXYChainableController
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.
startInteraction
in interface ILcdGXYController
startInteraction
in class ALcdGXYChainableController
aGXYView
- the ILcdGXYView
this ILcdGXYController
will interact with.ALcdGXYChainableController.startInteractionImpl(com.luciad.view.gxy.ILcdGXYView)
protected void startInteractionImpl(ILcdGXYView aGXYView)
ALcdGXYChainableController
startInteraction
for this controller.startInteractionImpl
in class ALcdGXYChainableController
aGXYView
- the view to start interaction with.public void terminateInteraction(ILcdGXYView aGXYView)
ALcdGXYChainableController
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.
terminateInteraction
in interface ILcdGXYController
terminateInteraction
in class ALcdGXYChainableController
aGXYView
- the ILcdGXYView
this ILcdGXYController
interacted with.ALcdGXYChainableController.terminateInteractionImpl(com.luciad.view.gxy.ILcdGXYView)
protected void terminateInteractionImpl(ILcdGXYView aGXYView)
ALcdGXYChainableController
terminateInteraction
for this controller.terminateInteractionImpl
in class ALcdGXYChainableController
aGXYView
- the view to terminate interaction with.public void paint(Graphics aGraphics)
ALcdGXYChainableController
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.
paint
in interface ILcdGXYController
paint
in class ALcdGXYChainableController
aGraphics
- the Graphics on which the view was rendered.ALcdGXYChainableController.paintImpl(java.awt.Graphics)
protected void paintImpl(Graphics aGraphics)
ALcdGXYChainableController
paint
for this controller.paintImpl
in class ALcdGXYChainableController
aGraphics
- the graphics to be used for painting.public void setNextGXYController(ILcdGXYChainableController aNext)
ILcdGXYChainableController
setNextGXYController
in interface ILcdGXYChainableController
setNextGXYController
in class ALcdGXYChainableController
aNext
- the reference to the controller that will be the next element in the chainILcdGXYChainableController.getNextGXYController()
public ILcdGXYChainableController getNextGXYController()
ILcdGXYChainableController
getNextGXYController
in interface ILcdGXYChainableController
getNextGXYController
in class ALcdGXYChainableController
ILcdGXYChainableController.setNextGXYController(ILcdGXYChainableController)
public void appendGXYController(ILcdGXYChainableController aEnd)
ILcdGXYChainableController
appendGXYController
in interface ILcdGXYChainableController
appendGXYController
in class ALcdGXYChainableController
aEnd
- the controller to be appended to the end of the chain.public void addUndoableListener(ILcdUndoableListener aUndoableListener)
ILcdUndoableSource
addUndoableListener
in interface ILcdUndoableSource
aUndoableListener
- The listener to be notified when something undoable has happened.public void removeUndoableListener(ILcdUndoableListener aUndoableListener)
ILcdUndoableSource
removeUndoableListener
in interface ILcdUndoableSource
aUndoableListener
- The listener to remove.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
.
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.SELECT_BY
.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
.
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
.SELECT_HOW
.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.
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
.EDIT_WHAT
.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
.
ILcdGXYPainter/ILcdGXYEditor
that is used.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
.TLcdGXYMultiPointEditControllerModel
that start with EDIT_HOW
.public TLcdGXYSelectControllerModel2 getSelectControllerModel()
TLcdGXYSelectControllerModel2
used for the selection operations.TLcdGXYSelectControllerModel2
.setSelectControllerModel(TLcdGXYSelectControllerModel2)
public void setSelectControllerModel(TLcdGXYSelectControllerModel2 aSelectControllerModel)
TLcdGXYSelectControllerModel2
. This allows for instance to disable
selection by touching labels etc... Please refer to TLcdGXYSelectControllerModel2
for
more information.aSelectControllerModel
- The select controller model to set. Must not be null
TLcdGXYSelectControllerModel2
,
getSelectControllerModel()
public TLcdGXYMultiPointEditControllerModel getEditControllerModel()
Returns the TLcdGXYMultiPointEditControllerModel
used for the editing
operations.
TLcdGXYMultiPointEditControllerModel
setEditControllerModel(TLcdGXYMultiPointEditControllerModel)
public void setEditControllerModel(TLcdGXYMultiPointEditControllerModel aEditControllerModel)
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.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.TLcdGXYMultiPointEditControllerModel
,
getEditControllerModel()
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.
aSnappables
- the list of objects that are candidates to snap to.getSnappables()
public ILcdGXYLayerSubsetList getSnappables()
Returns the snappables.
setSnappables(com.luciad.view.gxy.ILcdGXYLayerSubsetList)
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.
aMoveThreshold
- the threshold for move events. Must be positive.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.
setMoveThreshold(int)
public boolean isDragRectangle()
public void setDragRectangle(boolean aDrag)
aDrag
- true indicates selecting by dragging a rectangle, false indicates selecting the
object you touch.public ILcdAction getTouchAndHoldAction()
null
setTouchAndHoldAction(com.luciad.gui.ILcdAction)
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.
aTouchAndHoldAction
- the action to trigger when a touch-and-hold is detected. May be
null
getTouchAndHoldAction()
public ILcdIcon getTouchAndHoldIcon()
null
setTouchAndHoldAction(com.luciad.gui.ILcdAction)
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.
aTouchAndHoldIcon
- the icon. May be null
.getTouchAndHoldIcon()
,
getTouchAndHoldAction()
,
getPostTouchAndHoldAction()
public ILcdAction getPostTouchAndHoldAction()
null
setPostTouchAndHoldAction(com.luciad.gui.ILcdAction)
public void setPostTouchAndHoldAction(ILcdAction aPostTouchAndHoldAction)
aPostTouchAndHoldAction
- the action which will be triggered when the input point which
caused a touch-and-hold is removed. May be null
public int getTouchAndHoldDelay()
setTouchAndHoldDelay(int)
,
setMoveThreshold(int)
public void setTouchAndHoldDelay(int aTouchAndHoldDelay)
aTouchAndHoldDelay
- the time it will take for a touch and hold to occur.getTouchAndHoldDelay()
,
setMoveThreshold(int)
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
.
true
if this controller instantly edits objects, without painting them in
a temporary state, false
otherwise.setInstantEditing(boolean)
public void setInstantEditing(boolean aInstantEditing)
The recommended value for multi-editing is true
.
aInstantEditing
- when true instant editing will be enabled, when false disabled.isInstantEditing()