IlvMakeSegmentedHyperEdgeInteractor (Rogue Wave JViews 9.0 API)

java.lang.Object
- ilog.views.IlvManagerViewInteractor
- - ilog.views.hypergraph.interactor.IlvMakeHyperEdgeBaseInteractor
  - - ilog.views.hypergraph.interactor.IlvMakeHyperEdgeInteractor
    - - ilog.views.hypergraph.interactor.IlvMakeSegmentedHyperEdgeInteractor

All Implemented Interfaces:

IlvPermanentInteractorInterface, Serializable
```
public class IlvMakeSegmentedHyperEdgeInteractor
extends IlvMakeHyperEdgeInteractor
```
An interactor that allows to create or to extend an IlvSegmentedHyperEdge. This interactor must be attached to a view that is attached to an IlvHyperGrapher.
Clicking on a start node and on an end node with the left mouse button creates a new hyperedge that has the start node as source and the end node as target. Clicking on a start node and on an existing hyperedge extends this hyperedge with the start node as new source node. Clicking on an existing hyperedge and on an end node extends this hyperedge with the end node as new target node. Pressing the Control-key while clicking on a node inverses the source and target notion of the node.
Clicking on a start hyperedge and on an end hyperedge combines both hyperedges into one hyperedge. This means, one of both hyperedges survives and the other is removed. The surviving hyperedge receives all ends of the removed hyperedge. This works only if both hyperedges have the same type, and if IlvMakeHyperEdgeInteractor.isCombiningHyperEdgesAllowed() returns true.
Clicking on the right mouse button cancels the current interaction. Clicking on the middle mouse button shortens the hyperedge ghost by one segment.
Segmented hyperedges can have two types of segments: those with fixed angle and those with variable angle. By default, this interactor creates segments with fixed orthogonal angle (i.e. horizontal and vertical segments). The mode can be changed any time by pressing the tab key or the backspace key, even in the middle of a hyperedge creation. Then it changes the mode from segments with fixed angle to segments with variable angle, and vice versa. You can also customize the keys that should toggle this mode.
When creating segments with fixed angle, it is possible to change the angle of the currently created segment by pressing the space key. By default, the angle changes in steps of 45 degree. You can also customize the step size and which keys should change the angle.
Pressing the escape key during the interaction cancels the current interaction. You can also customize the keys that should cancel the current interaction. See setCancelKeyCodes(int[]).

Since:

JViews 8.0

See Also:

IlvSegmentedHyperEdge, IlvHyperGrapher, Serialized Form

Constructor Summary

Constructors
Constructor and Description

IlvMakeSegmentedHyperEdgeInteractor()
Creates a new interactor.

Constructors
Constructor and Description
`IlvMakeSegmentedHyperEdgeInteractor()` Creates a new interactor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected boolean`	`acceptBend(IlvPoint p)` Tests if creating a bend for the hyperedge when clicking in the space is allowed.
`protected boolean`	`acceptContinuation(IlvPoint p, IlvHyperEdge hyperedge)` Tests if a hyperedge can be extended towards a new origin or destination end.
`protected boolean`	`allowEnd(IlvGraphic obj)` Returns whether the object can be end of the interaction.
`protected boolean`	`allowStart(IlvGraphic obj)` Returns whether the object can be start of the interaction.
`protected void`	`attach(IlvManagerView v)` This method is called when the interactor is attached to the manager view.
`protected void`	`createGhost()` Creates the ghost.
`double`	`getBendThreshold()` Returns the threshold for creating bends.
`int[]`	`getCancelKeyCodes()` Returns the key codes for canceling the current operation.
`double`	`getDeltaAngle()` Returns the change of the segment angle when the space key is pressed.
`int[]`	`getDeltaAngleKeyCodes()` Returns the key codes for changing the segment angle.
`double`	`getEndThreshold()` Returns the threshold for the last segment that connects to the node.
`int[]`	`getFixedAngleModeKeyCodes()` Returns the key codes for toggling the fixed angle mode.
`double`	`getGap()` Returns the gap width of the hyperedge crossings at the newly created edge.
`int`	`getLayerOfCrossingGraphic()` Returns the default layer of the graphic object that draws the crossings at the newly created edge.
`Paint`	`getSelectedSegmentsPaint()` Returns the stroke paint of selected segments of the newly created hyperedge.
`protected void`	`initGhost(IlvHyperEdge hyperedge)` Initializes the ghost with the properties of the original edge.
`boolean`	`isCrossingEnabled()` Returns whether the crossing mode should be enabled at the newly created edge.
`boolean`	`isCurrentFixedAngleMode()` Returns `true` if the interactor is currently creating segments with fixed angle, and `false` if the interactor is currently creating segments with variable angle.
`boolean`	`isFixedAngleMode()` Returns `true` if the interactor creates segments with fixed angle, and `false` if the interactor creates segments with variable angle.
`boolean`	`isGapZoomable()` Returns `true` if the gap of the link crossings is zoomable at the newly created edge.
`protected boolean`	`isNearlyHorizontal(IlvSegmentedHyperEdge.Segment seg)` Returns whether the segment is nearly horizontal.
`protected boolean`	`isNearlyVertical(IlvSegmentedHyperEdge.Segment seg)` Returns whether the segment is nearly vertical.
`protected boolean`	`isShortenClick(MouseEvent event)` Returns `true` if the mouse event was a segment shorten click.
`protected void`	`moveGhost(IlvPoint p)` Move the ghost when moving the mouse to point p.
`protected boolean`	`onChangeDeltaAngle()` Called when the space character was pressed.
`protected void`	`onEndOrContinuationCreation(IlvPoint p, boolean arrowAtEnd)` Called on the second mouse click that might finish the creation of a hyperedge or might create a bend of the hyperedge.
`protected boolean`	`onToggleFixedAngleMode()` Called when the tab or backspace key was pressed.
`protected void`	`processKeyEvent(KeyEvent e)` Processes the key events.
`protected void`	`processMouseEvent(MouseEvent event)` Processes the mouse events.
`protected void`	`reInitialize()` Reinitializes the interactor.
`void`	`setBendThreshold(double value)` Sets the threshold for creating bends.
`void`	`setCancelKeyCodes(int[] keycodes)` Set the key codes for canceling the current operation.
`void`	`setCrossingEnabled(boolean enable)` Sets whether the crossing mode should be enabled at the newly created edge.
`void`	`setDeltaAngle(double delta)` Sets the change of the segment angle when the space key is pressed.
`void`	`setDeltaAngleKeyCodes(int[] keycodes)` Set the key codes for changing the angle of the currently edited segment.
`void`	`setEndThreshold(double value)` Sets the threshold for the last segment that connects to the node.
`void`	`setFixedAngleMode(boolean enable)` Sets whether the interactor creates segments with fixed angle or with variable angle.
`void`	`setFixedAngleModeKeyCodes(int[] keycodes)` Set the key codes for toggling the fixed angle mode.
`void`	`setGap(double gap)` Sets the gap width of the hyperedge crossings at the newly created edge.
`void`	`setGapZoomable(boolean zoomable)` Sets whether the gap of the hyperedge crossings is zoomable at the newly created edge.
`void`	`setLayerOfCrossingGraphic(int layerNumber)` Sets the default layer of the graphic object that draws the crossings at the newly created edge.
`void`	`setSelectedSegmentsPaint(Paint paint)` Sets the stroke paint of selected segments of the newly created hyperedge.

Methods inherited from class ilog.views.hypergraph.interactor.IlvMakeHyperEdgeInteractor
acceptDestination, acceptOrigin, afterChange, afterChange, beforeChange, beforeChange, drawGhost, eraseGhost, getLineStyle, getLineWidth, getMaximumLineWidth, getStrokePaint, isCancelClick, isCombiningHyperEdgesAllowed, isNormalClick, isSelectionMode, needsChangeGraphicBag, onEndCreation, onStartCreation, processMouseMotionEvent, react, refreshGhost, selectIfNecessary, setCombiningHyperEdgesAllowed, setLineStyle, setLineWidth, setMaximumLineWidth, setSelectionMode, setStrokePaint

Methods inherited from class ilog.views.hypergraph.interactor.IlvMakeHyperEdgeBaseInteractor
detach, getCursor, getHighlightedGraphic, getHighlightedPin, getObjectDrawingTransformer, getObjectToBeHighlighted, getPin, getPinCursor, getPinMargin, highlightObject, highlightPin, isCreationInSubManagersAllowed, isGridMode, isHyperEdge, isManagerToBeHighlighted, isNode, isPermanent, setCreationInSubManagersAllowed, setCursor, setGridMode, setPermanent, setPinCursor, setPinMargin, setPinSelected

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

- Constructor Detail
  - IlvMakeSegmentedHyperEdgeInteractor
```
public IlvMakeSegmentedHyperEdgeInteractor()
```
    Creates a new interactor.
    
    See Also:
    
    IlvManagerView.pushInteractor(ilog.views.IlvManagerViewInteractor, java.awt.AWTEvent), IlvManagerView.popInteractor()
- Method Detail
  - setCancelKeyCodes
```
public void setCancelKeyCodes(int[] keycodes)
```
    Set the key codes for canceling the current operation. During the creation of segments, you can cancel the operation by pressing the cancel key. You can specify with this method which keys act as cancel key.
    By default, the escape key cancels the current operation.
    
    Parameters:
    
    keycodes - An array of key codes, as defined in java.awt.event.KeyEvent Passing null is allowed to disable the possibility to toggle the mode with key presses.
    
    See Also:
    
    getCancelKeyCodes()
  - getCancelKeyCodes
```
public int[] getCancelKeyCodes()
```
    Returns the key codes for canceling the current operation.
    
    See Also:
    
    setCancelKeyCodes(int[])
  - setFixedAngleModeKeyCodes
```
public void setFixedAngleModeKeyCodes(int[] keycodes)
```
    Set the key codes for toggling the fixed angle mode. Segmented hyperedges can have two types of segments: those with fixed angle and those with variable angle. Which segment is currently created by default depends whether isFixedAngleMode() returns true or false. The mode can be changed any time by a key press, even in the middle of a hyperedge creation. You can specify with this method which keys toggle the fixed angle mode.
    By default, the tab key and the backspace key toggle the mode.
    
    Parameters:
    
    keycodes - An array of key codes, as defined in java.awt.event.KeyEvent Passing null is allowed to disable the possibility to toggle the mode with key presses.
    
    See Also:
    
    setFixedAngleMode(boolean), getFixedAngleModeKeyCodes()
  - getFixedAngleModeKeyCodes
```
public int[] getFixedAngleModeKeyCodes()
```
    Returns the key codes for toggling the fixed angle mode.
    
    See Also:
    
    setFixedAngleModeKeyCodes(int[])
  - setFixedAngleMode
```
public void setFixedAngleMode(boolean enable)
```
    Sets whether the interactor creates segments with fixed angle or with variable angle. The fixed angle mode is the default.
    
    See Also:
    
    setFixedAngleModeKeyCodes(int[]), isFixedAngleMode(), onToggleFixedAngleMode()
  - isFixedAngleMode
```
public boolean isFixedAngleMode()
```
    Returns true if the interactor creates segments with fixed angle, and false if the interactor creates segments with variable angle.
    
    See Also:
    
    setFixedAngleModeKeyCodes(int[]), setFixedAngleMode(boolean), onToggleFixedAngleMode()
  - isCurrentFixedAngleMode
```
public boolean isCurrentFixedAngleMode()
```
    Returns true if the interactor is currently creating segments with fixed angle, and false if the interactor is currently creating segments with variable angle. During the interaction, you can change the mode by pressing the tab key or the backspace key (or the keys specified with setFixedAngleModeKeyCodes(int[])).
    
    See Also:
    
    setFixedAngleMode(boolean), onToggleFixedAngleMode()
  - setBendThreshold
```
public void setBendThreshold(double value)
```
    Sets the threshold for creating bends. This is only used when creating segments with fixed angle.
    If the user clicks in the white space, usually a bend is created. If the last segment before the click point is smaller than the bend threshold, the interactor assumes that only one segment is created, otherwise two segments are created. This avoids that the user accidently creates tiny segments.
    If the last segment before the click point is smaller than the bend threshold, the real bend will be close, but not exactly at the click point. If the last segment before the click point is larger than the threshold, the bend is created exactly at the click point.
    The default value is 5.
    
    See Also:
    
    getBendThreshold(), setFixedAngleMode(boolean)
  - getBendThreshold
```
public double getBendThreshold()
```
    Returns the threshold for creating bends. This is only used when creating segments with fixed angle.
    
    See Also:
    
    setBendThreshold(double), setFixedAngleMode(boolean)
  - setEndThreshold
```
public void setEndThreshold(double value)
```
    Sets the threshold for the last segment that connects to the node. This is only used when creating segments with fixed angle.
    If the user clicks on a node, the edge is connected to the node. If the last segment of the edge at the node is smaller then the end threshold, it is ignored, and the second last segment is connected to the node. This avoids that the user accidently creates tiny segments.
    The default value is 5.
    
    See Also:
    
    getEndThreshold(), setFixedAngleMode(boolean)
  - getEndThreshold
```
public double getEndThreshold()
```
    Returns the threshold for the last segment that connects to the node. This is only used when creating segments with fixed angle.
    
    See Also:
    
    setEndThreshold(double), setFixedAngleMode(boolean)
  - setDeltaAngleKeyCodes
```
public void setDeltaAngleKeyCodes(int[] keycodes)
```
    Set the key codes for changing the angle of the currently edited segment. Normally, the interactor creates horizontal and vertical segments. However it is also possible to create segments with a different fixed angle. During the creation of a segment with fixed angle, you can change the angle by a key press. You can specify with this method which keys change the angle.
    By default, the space key changes the angle.
    
    Parameters:
    
    keycodes - An array of key codes, as defined in java.awt.event.KeyEvent Passing null is allowed to disable the possibility to change the angle with key presses.
    
    See Also:
    
    setDeltaAngle(double), getDeltaAngleKeyCodes()
  - getDeltaAngleKeyCodes
```
public int[] getDeltaAngleKeyCodes()
```
    Returns the key codes for changing the segment angle.
    
    See Also:
    
    setDeltaAngleKeyCodes(int[])
  - setDeltaAngle
```
public void setDeltaAngle(double delta)
```
    Sets the change of the segment angle when the space key is pressed. This is only used when creating segments with fixed angle. When pressing the space key, the last segment of the currently edited hyperedge changes its angle by a delta. This allows to create hyperedge segments with various angles. The angle must be given in degree between 1 and 90. If is recommended to set the delta angle to a fraction of 90, e.g. to 90/2 = 45, 90/3 = 30, 90/4 = 22.5, so that pressing space multiple times sets the angle of the segment back to its original value. If you set the delta angle to 0, pressing the space key has no effect anymore. The default value is 45.
    
    See Also:
    
    onChangeDeltaAngle(), getDeltaAngle(), setFixedAngleMode(boolean), setDeltaAngleKeyCodes(int[])
  - getDeltaAngle
```
public double getDeltaAngle()
```
    Returns the change of the segment angle when the space key is pressed. This is only used when creating segments with fixed angle.
    
    See Also:
    
    onChangeDeltaAngle(), setDeltaAngle(double), setFixedAngleMode(boolean), setDeltaAngleKeyCodes(int[])
  - setSelectedSegmentsPaint
```
public void setSelectedSegmentsPaint(Paint paint)
```
    Sets the stroke paint of selected segments of the newly created hyperedge.
    
    See Also:
    
    getSelectedSegmentsPaint(), IlvSegmentedHyperEdge.setSelectedSegmentsPaint(java.awt.Paint)
  - getSelectedSegmentsPaint
```
public Paint getSelectedSegmentsPaint()
```
    Returns the stroke paint of selected segments of the newly created hyperedge.
    
    See Also:
    
    setSelectedSegmentsPaint(java.awt.Paint)
  - isCrossingEnabled
```
public boolean isCrossingEnabled()
```
    Returns whether the crossing mode should be enabled at the newly created edge.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setCrossingEnabled(boolean)
  - setCrossingEnabled
```
public void setCrossingEnabled(boolean enable)
```
    Sets whether the crossing mode should be enabled at the newly created edge.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    isCrossingEnabled(), IlvSegmentedHyperEdge.setCrossingEnabled(boolean)
  - setGap
```
public void setGap(double gap)
```
    Sets the gap width of the hyperedge crossings at the newly created edge. The default value is 2.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    getGap()
  - getGap
```
public final double getGap()
```
    Returns the gap width of the hyperedge crossings at the newly created edge.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setGap(double), IlvSegmentedHyperEdge.setGap(double)
  - setGapZoomable
```
public void setGapZoomable(boolean zoomable)
```
    Sets whether the gap of the hyperedge crossings is zoomable at the newly created edge.
    If the gap is zoomable, the gap width follows the zoom level. If the gap is not zoomable, the gap width is the same for all zoom levels. In particular in nested graphers where hyperedges of different graphers cross each other, it is visually more appealing if the gap is not zoomable.
    The option is enabled by default.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    isGapZoomable()
  - isGapZoomable
```
public final boolean isGapZoomable()
```
    Returns true if the gap of the link crossings is zoomable at the newly created edge.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setGapZoomable(boolean), IlvSegmentedHyperEdge.setGapZoomable(boolean)
  - setLayerOfCrossingGraphic
```
public void setLayerOfCrossingGraphic(int layerNumber)
```
    Sets the default layer of the graphic object that draws the crossings at the newly created edge. The layer number should be above the layer that contains the hyperedges and links. If the default layer is -1, an appropriate layer is automatically calculated.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    getLayerOfCrossingGraphic(), IlvSegmentedHyperEdge.setLayerOfCrossingGraphic(int)
  - getLayerOfCrossingGraphic
```
public final int getLayerOfCrossingGraphic()
```
    Returns the default layer of the graphic object that draws the crossings at the newly created edge. Returns -1 if the layer is automatically calculated.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setLayerOfCrossingGraphic(int)
  - attach
```
protected void attach(IlvManagerView v)
```
    This method is called when the interactor is attached to the manager view.
    
    Overrides:
    
    attach in class IlvMakeHyperEdgeBaseInteractor
    
    Parameters:
    
    v - The manager view.
    
    See Also:
    
    IlvMakeHyperEdgeBaseInteractor.detach()
  - reInitialize
```
protected void reInitialize()
```
    Reinitializes the interactor. You do not have to use this method.
    
    Overrides:
    
    reInitialize in class IlvMakeHyperEdgeInteractor
  - initGhost
```
protected void initGhost(IlvHyperEdge hyperedge)
```
    Initializes the ghost with the properties of the original edge. This is used if a hyperedge is extended by a new branch.
    
    Overrides:
    
    initGhost in class IlvMakeHyperEdgeInteractor
    
    Parameters:
    
    hyperedge - The original hyperedge.
  - createGhost
```
protected void createGhost()
```
    Creates the ghost.
    
    Overrides:
    
    createGhost in class IlvMakeHyperEdgeInteractor
  - moveGhost
```
protected void moveGhost(IlvPoint p)
```
    Move the ghost when moving the mouse to point p. To ensure that the moved ghost is property drawn, you must first erase the ghost, then move the ghost, then refresh the ghost:
```
 // rerases the drawing of the old ghost position
 eraseGhost();
 moveGhost(p);
 // draws the new ghost position
 refreshGhost();
 
```
    Overrides:
    
    moveGhost in class IlvMakeHyperEdgeInteractor
    
    Parameters:
    
    p - The point in the coordinate space of the view.
  - processKeyEvent
```
protected void processKeyEvent(KeyEvent e)
```
    Processes the key events.
    
    Overrides:
    
    processKeyEvent in class IlvManagerViewInteractor
    
    Parameters:
    
    e - The event.
    
    See Also:
    
    IlvManagerViewInteractor.addKeyListener(java.awt.event.KeyListener)
  - onChangeDeltaAngle
```
protected boolean onChangeDeltaAngle()
```
    Called when the space character was pressed. The default implementation changes the angle of the last ghost segment by the delta angle (by default 45 degree), if the ghost segment has a fixed angle.
    
    Returns:
    
    true if the key event was handled, false if the key event was not handled and should be forwarded to other key event listeners.
    
    See Also:
    
    getDeltaAngle()
  - onToggleFixedAngleMode
```
protected boolean onToggleFixedAngleMode()
```
    Called when the tab or backspace key was pressed. The default implementation toggles the mode between segments with fixed angle and segments with variable angle.
    
    Returns:
    
    true if the key event was handled, false if the key event was not handled and should be forwarded to other key event listeners.
    
    See Also:
    
    isCurrentFixedAngleMode()
  - processMouseEvent
```
protected void processMouseEvent(MouseEvent event)
```
    Processes the mouse events.
    
    Overrides:
    
    processMouseEvent in class IlvMakeHyperEdgeInteractor
    
    Parameters:
    
    event - The event.
    
    See Also:
    
    IlvManagerViewInteractor.addMouseListener(java.awt.event.MouseListener)
  - isShortenClick
```
protected boolean isShortenClick(MouseEvent event)
```
    Returns true if the mouse event was a segment shorten click. On segment cancel click, the hyperedge branch currently edited is shortened by one segment. By default, this is a middle mouse click.
  - acceptContinuation
```
protected boolean acceptContinuation(IlvPoint p,
                                     IlvHyperEdge hyperedge)
```
    Tests if a hyperedge can be extended towards a new origin or destination end.
    If creation in submanagers is not allowed (see IlvMakeHyperEdgeBaseInteractor.isCreationInSubManagersAllowed()) and the hyperege is not in the topmost grapher, the method returns false.
    
    Overrides:
    
    acceptContinuation in class IlvMakeHyperEdgeInteractor
    
    Parameters:
    
    p - The clicked point, in view coordinates.
    
    hyperedge - The hyperedge to test.
  - acceptBend
```
protected boolean acceptBend(IlvPoint p)
```
    Tests if creating a bend for the hyperedge when clicking in the space is allowed. By default, this returns always true.
    
    Parameters:
    
    p - The clicked point in view coordinates.
  - onEndOrContinuationCreation
```
protected void onEndOrContinuationCreation(IlvPoint p,
                                           boolean arrowAtEnd)
```
    Called on the second mouse click that might finish the creation of a hyperedge or might create a bend of the hyperedge. It checks whether there is a node under the mouse position which can become the end node. If pins should be used, it determined the appropriate pin of the hyperedge pin connector at this node. It also checks whether there is a hyperedge under the mouse position that allows to be extended by a new branch. If one of the above conditions is true, it creates the new hyperedge or extends the existing hyperedge by a new branch. Otherwise it creates a bend in the current ghost of the hyperedge to be created.
    
    Parameters:
    
    p - The click point in view coordinates
    
    arrowAtEnd - Whether we try to select an end target or an end source.
  - isNearlyHorizontal
```
protected boolean isNearlyHorizontal(IlvSegmentedHyperEdge.Segment seg)
```
    Returns whether the segment is nearly horizontal. We consider segments with angle below 10 degree as nearly horizontal. When connecting a segment to a pin, and the pin is at the top or bottom side of the node, then nearly horizontal end segments look ugly and are corrected.
  - isNearlyVertical
```
protected boolean isNearlyVertical(IlvSegmentedHyperEdge.Segment seg)
```
    Returns whether the segment is nearly vertical. We consider segments with angle between 80 and 100 degree as nearly vertical. When connecting a segment to a pin, and the pin is at the left or right side of the node, then nearly vertical end segments look ugly and are corrected.
  - allowStart
```
protected boolean allowStart(IlvGraphic obj)
```
    Returns whether the object can be start of the interaction.
    
    Overrides:
    
    allowStart in class IlvMakeHyperEdgeInteractor
  - allowEnd
```
protected boolean allowEnd(IlvGraphic obj)
```
    Returns whether the object can be end of the interaction.
    
    Overrides:
    
    allowEnd in class IlvMakeHyperEdgeInteractor

Class IlvMakeSegmentedHyperEdgeInteractor

Constructor Summary

Method Summary

Methods inherited from class ilog.views.hypergraph.interactor.IlvMakeHyperEdgeInteractor

Methods inherited from class ilog.views.hypergraph.interactor.IlvMakeHyperEdgeBaseInteractor

Methods inherited from class ilog.views.IlvManagerViewInteractor

Methods inherited from class java.lang.Object

Constructor Detail

IlvMakeSegmentedHyperEdgeInteractor

Method Detail

setCancelKeyCodes

getCancelKeyCodes

setFixedAngleModeKeyCodes

getFixedAngleModeKeyCodes

setFixedAngleMode

isFixedAngleMode

isCurrentFixedAngleMode

setBendThreshold

getBendThreshold

setEndThreshold

getEndThreshold

setDeltaAngleKeyCodes

getDeltaAngleKeyCodes

setDeltaAngle

getDeltaAngle

setSelectedSegmentsPaint

getSelectedSegmentsPaint

isCrossingEnabled

setCrossingEnabled

setGap

getGap

setGapZoomable

isGapZoomable

setLayerOfCrossingGraphic

getLayerOfCrossingGraphic

attach

reInitialize

initGhost

createGhost

moveGhost

processKeyEvent

onChangeDeltaAngle

onToggleFixedAngleMode

processMouseEvent

isShortenClick

acceptContinuation

acceptBend

onEndOrContinuationCreation

isNearlyHorizontal

isNearlyVertical

allowStart

allowEnd