IlvSegmentedHyperEdge (Perforce JViews 10.0 API)

java.lang.Object
- ilog.views.IlvGraphic
- - ilog.views.hypergraph.IlvHyperEdge
  - - ilog.views.hypergraph.IlvSegmentedHyperEdge

All Implemented Interfaces:

IlvCrossingAwareObject, IlvParameterizedCrossingAwareObject, IlvPersistentObject, IlvBlinkingObject, IlvBaseTextDirectionInterface, Transferable, Serializable
```
public class IlvSegmentedHyperEdge
extends IlvHyperEdge
implements IlvParameterizedCrossingAwareObject
```
IlvSegmentedHyperEdge is a hyperedge that consists of several line segments. The line segments can be orthogonal or vertical or have an arbitrary angle.

Since:

JViews 8.0

See Also:

IlvHyperGrapher, IlvHyperEdge, Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`IlvSegmentedHyperEdge.HyperEdgeEnd` This is the hyperedge end of an segmented hyperedge.
`class`	`IlvSegmentedHyperEdge.Segment` A segment of the hyperedge.
`static class`	`IlvSegmentedHyperEdge.SegmentShape` This class is used to store the internal shape of the hyperedge in ivl files.

Field Summary
- Fields inherited from interface ilog.views.hypergraph.crossing.IlvParameterizedCrossingAwareObject
  BRIDGE_CROSSINGS, CUSTOM_CROSSINGS, NO_CROSSINGS, TUNNEL_CROSSINGS

Constructor Summary

Constructors
Constructor and Description
`IlvSegmentedHyperEdge()` Creates a new segmented hyperedge.
`IlvSegmentedHyperEdge(IlvGraphicVector from, IlvGraphicVector to)` Creates a new segmented hyperedge.
`IlvSegmentedHyperEdge(IlvInputStream stream)` Reads the object from an `IlvInputStream`.
`IlvSegmentedHyperEdge(IlvSegmentedHyperEdge source)` Creates an `IlvSegmentedHyperEdge` by copying an existing one.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`actOnAdjustmentEnd()` Reacts on adjustment end.
`IlvSegmentedHyperEdge.Segment`	`addSegment(IlvHyperEdgeEnd end, double angle)` Adds a new segment at the hyperedge end.
`IlvSegmentedHyperEdge.Segment`	`addSegment(IlvHyperEdgeEnd end, double x, double y, IlvTransformer t)` Adds a new segment at the hyperedge end.
`IlvSegmentedHyperEdge.Segment`	`addSegment(IlvHyperEdgeEnd end1, IlvHyperEdgeEnd end2)` Adds a new segment at the hyperedge ends.
`IlvSegmentedHyperEdge.Segment`	`addSegment(IlvSegmentedHyperEdge.Segment existingSegment, double x1, double y1, double x2, double y2, IlvTransformer t)` Adds a new segment incident to the existing input segment.
`IlvSegmentedHyperEdge.Segment`	`addSegment(IlvSegmentedHyperEdge.Segment existingSegment, double angle, double x, double y, IlvTransformer t)` Adds a new segment incident to the existing input segment.
`IlvSegmentedHyperEdge.Segment`	`addSegment(IlvSegmentedHyperEdge.Segment existingSegment, double x, double y, IlvTransformer t)` Adds a new segment incident to the existing input segment.
`protected void`	`afterAddEnd(IlvHyperEdgeEnd end, boolean fromSide)` Called after the hyperedge end point is added to the edge.
`void`	`afterDo(IlvOrderedCompoundEdit undo)` This method must be called if undo support is needed for a specific operation.
`void`	`applyTransform(IlvTransformer t)` Applies a transformation to the shape of the hyperedge.
`IlvOrderedCompoundEdit`	`beforeDo(String undoPresentationName)` This method must be called if undo support is needed for a specific operation.
`protected void`	`beforeRemoveEnd(IlvHyperEdgeEnd end, boolean fromSide)` Called before the hyperedge end point is removed from the edge.
`IlvRect`	`boundingBoxCrossingGraphic(IlvTransformer t)` Returns the bounding rectangle of the crossing graphic that belongs to this object.
`protected IlvRect`	`calcBoundingBox(IlvTransformer t)` Calculates the bounding rectangle of the object.
`protected void`	`clearBoundingBoxCache()` Clears the bounding box cache.
`boolean`	`connectSegments(IlvSegmentedHyperEdge.Segment segment1, IlvSegmentedHyperEdge.Segment segment2)` Connects both input segments.
`boolean`	`contains(IlvPoint p, IlvPoint tp, IlvTransformer t)` Tests if a point lies within the outline of the hyperedge.
`boolean`	`containsAtCrossingGraphic(IlvPoint p, IlvPoint tp, IlvTransformer t)` Tests if a point lies within the outline of the crossing graphic that belongs to this object.
`HashMap`	`copyShapeFrom(IlvHyperEdge source)` Copies all the ends from the input source edge.
`protected IlvGraphic`	`createCrossingGraphic(int mode)` Creates the appropriate crossing graphic.
`protected IlvHyperEdgeEnd`	`createEnd(IlvGraphic node, boolean origin)` Creates a hyperedge end point.
`boolean`	`deleteSelection(boolean redraw)` Deletes the selection in the inner of the hyperedge.
`void`	`deSelectAll(boolean redraw)` Deselects all segments of this hyperedge.
`boolean`	`disconnectSegments(IlvSegmentedHyperEdge.Segment segment1, IlvSegmentedHyperEdge.Segment segment2)` Disconnects both input segments.
`void`	`draw(Graphics dst, IlvTransformer t)` Draws the hyperedge.
`void`	`drawCrossingGraphic(Graphics dst, IlvTransformer t)` Draws the crossing graphic that belongs to this object.
`protected void`	`drawLine(IlvPoint[] points, double lineWidth, float[] lineStyle, Graphics dst, IlvTransformer t)` Draws a line between the input points.
`protected Paint`	`getAdaptedSelectedSegmentsPaint(IlvTransformer t)` Returns the stroke paint of the selected segments adapted to the input transformer.
`protected IlvPoint`	`getArrowHeadControlPoint(IlvSegmentedHyperEdge.Segment segment, IlvSegmentedHyperEdge.HyperEdgeEnd end, IlvPoint arrowPoint, IlvPoint[] segmentPoints, IlvTransformer t)` Returns the control point of the arrow head drawn at the input segment.
`IlvSegmentedHyperEdge.Segment`	`getClosestSegment(double x, double y, IlvTransformer t)` Returns the segment closest to the input point.
`IlvSegmentedHyperEdge.Segment[]`	`getClosestSegments(double x, double y, IlvTransformer t, IlvSegmentedHyperEdge.Segment[] segments)` Returns the two segments whose connection point is closest to the input point.
`IlvPoint`	`getConnectionPoint(IlvSegmentedHyperEdge.Segment segment1, IlvSegmentedHyperEdge.Segment segment2, IlvTransformer t)` Returns the connection point of both input segments if the one segment is incident to the other segment.
`IlvGraphic`	`getCrossingAwareGraphic()` Returns the corresponding graphic.
`IlvCrossingAwareSegment[]`	`getCrossingAwareSegments(IlvTransformer t)` Returns those segments of the hyperedge that can display a crossing.
`IlvGraphic`	`getCrossingGraphic()` Returns the graphic object that draws the crossings.
`int`	`getCrossingMode()` Returns the crossing mode of the hyperedge.
`IlvSegmentedHyperEdge.Segment`	`getEndSegment(IlvHyperEdgeEnd end)` Returns the segment incident to the hyperedge end.
`double`	`getGap()` Returns the gap width of the hyperedge crossings.
`int`	`getLayerOfCrossingGraphic()` Returns the default layer of the graphic object that draws the crossings.
`IlvSegmentedHyperEdge.Segment`	`getNearEndSegment(IlvSegmentedHyperEdge.Segment segment)` Returns the near end segment that is reachable from the input segment along a segment path that never branches.
`int`	`getNodeSide(IlvHyperEdgeEnd end)` Decides on which side of the node the hyperedge end is located.
`Iterator`	`getSegments()` Returns the segments of the hyperedge.
`int`	`getSegmentsCount()` Returns the number of segments of the hyperedge.
`IlvSegmentedHyperEdge.Segment[]`	`getSelectedSegments()` Returns all selected segments.
`Paint`	`getSelectedSegmentsPaint()` Returns the stroke paint of the selected segments.
`IlvPoint[]`	`getUnclippedSegmentPoints(IlvHyperEdgeEnd end, IlvTransformer t)` Returns the end points of the segment that ends at the input hyperedge end.
`boolean`	`isAutoConnect()` Returns `true` if adding source or target nodes to the hyperedge creates segments that connect the new hyperedge end to the remaining segments.
`boolean`	`isConnected(IlvSegmentedHyperEdge.Segment segment1, IlvSegmentedHyperEdge.Segment segment2)` Returns whether both input segments are connected.
`boolean`	`isCrossingAdjusting()` Returns whether the segmented hyperedge is inside an adjustment session for the crossings.
`boolean`	`isCrossingEnabled()` Returns `true` if tunnel (jog) crossing display is enabled for this hyperedge.
`boolean`	`isGapZoomable()` Returns `true` if the gap of the link crossings is zoomable.
`boolean`	`isSegmentSetComplete()` Tests if the set of segments is complete.
`IlvSegmentedHyperEdge.Segment`	`joinSegments(IlvSegmentedHyperEdge.Segment segment1, IlvSegmentedHyperEdge.Segment segment2)` Join the two input segments.
`IlvSegmentedHyperEdge.Segment`	`joinSegments(IlvSegmentedHyperEdge.Segment segment1, IlvSegmentedHyperEdge.Segment segment2, IlvTransformer t)` Join the two input segments.
`IlvSelection`	`makeSelection()` Creates a selection object for this object.
`protected boolean`	`mergeCrossings(IlvCrossing cr1, IlvCrossing cr2, double dist, double gap)` Decides when to merge crossings.
`protected boolean`	`modeFitsCrossingGraphic(int mode)` Tests if the current crossing graphic fits to the input mode.
`void`	`moveConnectionPoint(IlvSegmentedHyperEdge.Segment seg1, IlvSegmentedHyperEdge.Segment seg2, double x, double y, IlvTransformer t)` Moves the connection point of both input segments to the input point.
`IlvSegmentedHyperEdge.Segment[]`	`parallelSplitSegment(IlvSegmentedHyperEdge.Segment segment, double x, double y, IlvTransformer t)` Splits the input segment and redistributes the incident segments, if the segment has incident segments at both sides.
`void`	`removeAllCrossings(IlvTransformer t)` Removes all crossings added at the object for a given transformer.
`void`	`removeAllSegments()` Removes all segments of the hyperedge.
`IlvSegmentedHyperEdge.Segment[]`	`removeSegment(IlvSegmentedHyperEdge.Segment segment)` Removes the input segment.
`void`	`removeSegments(IlvHyperEdgeEnd end)` Removes all segments of the hyperedge that branch from the current segment trunk to the input hyperedge end.
`void`	`selectAll(boolean redraw)` Selects all segments of this hyperedge.
`void`	`setAutoConnect(boolean autoconnect)` Sets whether adding source or target nodes to the hyperedge creates segments that connect the new hyperedge end to the remaining segments.
`void`	`setCrossingAdjusting(boolean adjusting)` Starts or end an adjustment session for the crossings.
`void`	`setCrossingEnabled(boolean enable)` Sets whether tunnel (jog) crossing display is enabled for this hyperedge.
`void`	`setCrossingGraphic(IlvGraphic g)` Sets the graphic object that draws the crossings.
`void`	`setCrossingGraphic(IlvGraphic g, int layerNumber)` Sets the graphic object that draws the crossings.
`void`	`setCrossingMode(int mode)` Sets the crossing mode of the hyperedge.
`void`	`setEndSegmentAngle(IlvHyperEdgeEnd end, double angle)` Sets the angle of the segment incident to the input end to the given angle.
`void`	`setGap(double gap)` Sets the gap width of the hyperedge crossings.
`void`	`setGapZoomable(boolean zoomable)` Sets whether the gap of the hyperedge crossings is zoomable.
`void`	`setGraphicBag(IlvGraphicBag bag)` Changes the bag that contains the object.
`void`	`setLayerOfCrossingGraphic(int layerNumber)` Sets the default layer of the graphic object that draws the crossings.
`boolean`	`setSegmentAngle(IlvSegmentedHyperEdge.Segment segment, double angle)` Sets the angle of a segment.
`void`	`setSelected(IlvSegmentedHyperEdge.Segment segment, boolean select, boolean redraw)` Selects or deselects the segment.
`void`	`setSelectedSegmentsPaint(Paint p)` Changes the stroke paint of the selected segments.
`IlvSegmentedHyperEdge.Segment[]`	`splitSegment(IlvSegmentedHyperEdge.Segment segment, double x, double y, IlvTransformer t)` Splits the input segment at the input point.
`IlvSegmentedHyperEdge.Segment[]`	`splitSegment(IlvSegmentedHyperEdge.Segment segment, IlvSegmentedHyperEdge.Segment connectingSegment)` Splits the input segment at the connection point with the connecting segment.
`IlvSegmentedHyperEdge.Segment[]`	`splitSegment(IlvSegmentedHyperEdge.Segment segment, IlvSegmentedHyperEdge.Segment connectingSegment, IlvTransformer t)` Splits the input segment at the connection point with the connecting segment.
`void`	`write(IlvOutputStream stream)` Writes the object to an `IlvOutputStream`.

Methods inherited from class ilog.views.hypergraph.IlvHyperEdge
adaptPaint, addFrom, addTo, arrowBBox, boundingBox, copy, drawArrow, finalize, getAdaptedStrokePaint, getArrowSize, getBoundingBoxCacheSize, getCenter, getClosestEnd, getEndNodeBoundingBox, getFrom, getFromArray, getFromConnectionPoints, getFromCount, getFromEnds, getFromEndsArray, getFromEndsArray, getFromEndsCount, getLineStyle, getLineWidth, getLineWidth, getMaximumLineWidth, getStrokePaint, getTo, getToArray, getToConnectionPoints, getToCount, getToEnds, getToEndsArray, getToEndsArray, getToEndsCount, getVisibleEndNode, isFromEnd, isInterGraphHyperEdge, isPaintAbsolute, isToEnd, isVisibleFrom, isVisibleTo, moveConnectionPoint, readEnds, removeFrom, removeFrom, removeTo, removeTo, setBoundingBoxCacheSize, setForeground, setFrom, setLineStyle, setLineWidth, setMaximumLineWidth, setPaintAbsolute, setStrokePaint, setTo, shortenForArrowDraw, writeEnds, zoomable

Methods inherited from class ilog.views.IlvGraphic
addActionListener, addNamedPropertyListener, allViewsRemoved, baseTextDirectionChanged, blinkingStateOn, boundingBox, callDraw, componentOrientationChanged, getAndAssociateObjectInteractor, getBaseTextDirection, getBlinkingAction, getBlinkingObjectOwner, getBlinkingOffPeriod, getBlinkingOnPeriod, getComponentOrientation, getDefaultInteractor, getGraphicBag, GetGraphicObject, getIntersectionWithOutline, getLocale, getName, getNamedProperty, getObjectInteractor, getPopupMenu, getPopupMenu, getPopupMenuName, getProperty, getResolvedBaseTextDirection, getToolTipBaseTextDirection, getToolTipText, getToolTipText, getTopLevelGraphicBag, getTransferData, getTransferDataFlavors, getULocale, getZOrderIndex, hasProperty, inside, intersects, invalidateBBoxCache, invalidateBidiCache, isBaseTextDirectionSensitive, isComponentOrientationSensitive, isDataFlavorSupported, isEditable, isInApplyToObject, isLocaleSensitive, isMovable, isPersistent, isSelectable, isVisible, localeChanged, move, move, moveResize, needsViewNotification, notifyObjectInteractorToManager, processActionEvent, reDraw, registerBlinkingResource, removeActionListener, removeNamedProperty, removeNamedPropertyListener, removeProperty, replaceProperty, resize, rotate, scale, setBackground, setBaseTextDirection, setBaseTextDirectionDuringConstruction, setBlinkingAction, setBlinkingOffPeriod, setBlinkingOnPeriod, setEditable, setFillOn, setInApplyToObject, setMovable, setName, setNamedProperty, setNameImpl, setObjectInteractor, setPopupMenu, setPopupMenuName, setProperty, setSelectable, setStrokeOn, setToolTipBaseTextDirection, setToolTipText, setVisible, setZOrderIndex, toString, translate, updateNeedsViewNotification, usesBidiMarkers, viewAddedOrRemoved

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

Methods inherited from interface ilog.views.hypergraph.crossing.IlvCrossingAwareObject
getLineWidth

- Constructor Detail
  - IlvSegmentedHyperEdge
```
public IlvSegmentedHyperEdge()
```
    Creates a new segmented hyperedge.
  - IlvSegmentedHyperEdge
```
public IlvSegmentedHyperEdge(IlvGraphicVector from,
                             IlvGraphicVector to)
```
    Creates a new segmented hyperedge. Then edge has one source end at each of the origin nodes, and one target end at each of the destination nodes.
    
    Parameters:
    
    from - The origin nodes.
    
    to - The destination nodes.
  - IlvSegmentedHyperEdge
```
public IlvSegmentedHyperEdge(IlvSegmentedHyperEdge source)
```
    Creates an IlvSegmentedHyperEdge by copying an existing one.
    
    Parameters:
    
    source - The origin of the copy.
  - IlvSegmentedHyperEdge
```
public IlvSegmentedHyperEdge(IlvInputStream stream)
                      throws IlvReadFileException
```
    Reads the object from an IlvInputStream.
    
    Parameters:
    
    stream - The input stream.
    
    Throws:
    
    IlvReadFileException - if the format is not correct.
- Method Detail
  - copyShapeFrom
```
public HashMap copyShapeFrom(IlvHyperEdge source)
```
    Copies all the ends from the input source edge. It adds copies of the ends to this hyperedge. If this hyperedge did not have any ends at the beginning, then its shape looks like a copy of the shape of the input hyperedge afterwards.
    If both edges are currently in different graphers, then this edge must be removed from its grapher before calling this method. Otherwise, if this edge can remain inside its grapher, this must be done inside an applyToObject session of the edge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Overrides:
    
    copyShapeFrom in class IlvHyperEdge
    
    Parameters:
    
    source - The source hyperedge
    
    Returns:
    
    A mapping from copied inner objects to original inner objects. This implementation contains a mapping from copied hyperedge ends to original hyperedge ends.
  - draw
```
public void draw(Graphics dst,
                 IlvTransformer t)
```
    Draws the hyperedge.
    
    Overrides:
    
    draw in class IlvHyperEdge
    
    Parameters:
    
    dst - The destination Graphics.
    
    t - The transformation used to draw the object.
    
    See Also:
    
    IlvGraphic.callDraw(Graphics,IlvTransformer), IlvGraphic.boundingBox(IlvTransformer), IlvGraphic.zoomable(), IlvGraphic
  - drawLine
```
protected void drawLine(IlvPoint[] points,
                        double lineWidth,
                        float[] lineStyle,
                        Graphics dst,
                        IlvTransformer t)
```
    Draws a line between the input points.
    
    Parameters:
    
    points - An array of two points that are the start and the end of the line in view coordinates.
    
    lineWidth - The line width in manager coordinates.
    
    lineStyle - The line style in manager coordinates.
    
    dst - The destination Graphics.
    
    t - The transformation used to draw the object.
  - getUnclippedSegmentPoints
```
public IlvPoint[] getUnclippedSegmentPoints(IlvHyperEdgeEnd end,
                                            IlvTransformer t)
```
    Returns the end points of the segment that ends at the input hyperedge end. The returned points are unclipped, and are used by the IlvHyperEdgeClippingConnector to calculate the clipping point.
    
    Overrides:
    
    getUnclippedSegmentPoints in class IlvHyperEdge
    
    Parameters:
    
    end - The hyperedge end.
    
    t - The transformer used to draw the hyperedge.
    
    Returns:
    
    An array of two points in view coordinates.
  - calcBoundingBox
```
protected IlvRect calcBoundingBox(IlvTransformer t)
```
    Calculates the bounding rectangle of the object. This method does not use any cache (see IlvHyperEdge.boundingBox(ilog.views.IlvTransformer)).
    
    Overrides:
    
    calcBoundingBox in class IlvHyperEdge
    
    Parameters:
    
    t - The transformer used to draw the object.
    
    Returns:
    
    A freshly allocated rectangle.
  - clearBoundingBoxCache
```
protected void clearBoundingBoxCache()
```
    Clears the bounding box cache. See IlvHyperEdge.boundingBox(ilog.views.IlvTransformer).
    
    Overrides:
    
    clearBoundingBoxCache in class IlvHyperEdge
  - contains
```
public boolean contains(IlvPoint p,
                        IlvPoint tp,
                        IlvTransformer t)
```
    Tests if a point lies within the outline of the hyperedge.
    
    Overrides:
    
    contains in class IlvHyperEdge
    
    Parameters:
    
    p - The point to be tested.
    
    tp - The point p transformed by the transformer t.
    
    t - The transformation that was applied to the object when it was drawn.
    
    Returns:
    
    true if the point lies inside this graphic object.
    
    See Also:
    
    IlvGraphic
  - getArrowHeadControlPoint
```
protected IlvPoint getArrowHeadControlPoint(IlvSegmentedHyperEdge.Segment segment,
                                            IlvSegmentedHyperEdge.HyperEdgeEnd end,
                                            IlvPoint arrowPoint,
                                            IlvPoint[] segmentPoints,
                                            IlvTransformer t)
```
    Returns the control point of the arrow head drawn at the input segment. The control point determines the direction the arrow head comes from. The input hyperedge end is the end where the arrow head must be drawn. The input arrow point is the point the arrow points to. The input segment points are the points of the segment. Returns null if the segment is not incoming to any hyperedge end, because in this case, no arrow head must be drawn.
    
    Parameters:
    
    segment - The hyperedge segment that has this arrow head.
    
    end - The hyperedge end that has this arrow head.
    
    arrowPoint - The point where the arrow must be drawn.
    
    segmentPoints - The two end points of the segment.
    
    t - The transformer to draw the hyperedge.
    
    Returns:
    
    The control point of the arrow head.
  - makeSelection
```
public IlvSelection makeSelection()
```
    Creates a selection object for this object. The default implementation creates an instance of IlvSegmentedHyperEdgeSelection.
    
    Overrides:
    
    makeSelection in class IlvHyperEdge
    
    See Also:
    
    IlvSegmentedHyperEdgeSelection
  - applyTransform
```
public void applyTransform(IlvTransformer t)
```
    Applies a transformation to the shape of the hyperedge. This method transforms all segments.
    
    Overrides:
    
    applyTransform in class IlvHyperEdge
    
    Parameters:
    
    t - The transformation to be applied.
    
    See Also:
    
    IlvGraphic
  - createEnd
```
protected IlvHyperEdgeEnd createEnd(IlvGraphic node,
                                    boolean origin)
```
    Creates a hyperedge end point. This creates an object of type IlvSegmentedHyperEdge.HyperEdgeEnd. This method can be overridden if a different type is needed.
    
    Overrides:
    
    createEnd in class IlvHyperEdge
    
    Parameters:
    
    node - The end node that is connected to the hyperedge by the new end point.
    
    origin - Whether the new end will be an origin end point or a destination end point.
    
    Returns:
    
    The new end at the node.
  - getSegments
```
public Iterator getSegments()
```
    Returns the segments of the hyperedge. The returned iterator does not support the Iterator.remove() operation. Use removeSegment(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment) instead.
    
    Returns:
    
    An iterator of IlvSegmentedHyperEdge.Segment objects.
  - getSegmentsCount
```
public int getSegmentsCount()
```
    Returns the number of segments of the hyperedge.
  - getEndSegment
```
public IlvSegmentedHyperEdge.Segment getEndSegment(IlvHyperEdgeEnd end)
```
    Returns the segment incident to the hyperedge end. Each hyperedge end can have only one incident segment. Returns null if there was never any segment added to the hyperedge end.
  - isSegmentSetComplete
```
public boolean isSegmentSetComplete()
```
    Tests if the set of segments is complete. The set of segments is complete if each hyperedge end has an incident segment, and each segment can reach each other segment by a segment traversal.
  - addSegment
```
public IlvSegmentedHyperEdge.Segment addSegment(IlvHyperEdgeEnd end,
                                                double angle)
```
    Adds a new segment at the hyperedge end. If the hyperedge end has already an incident segment, the old segment is removed. The hyperedge end must belong to this hyperedge.
    The new segment has a fixed angle. If the angle is 0, the segment is horizontal. If the angle is 90, the segment is vertical.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    end - The hyperedge end incident to the new segment.
    
    angle - The fixed angle of the new segment.
    
    Returns:
    
    The new segment.
    
    See Also:
    
    addSegment(IlvHyperEdgeEnd, double, double, IlvTransformer), addSegment(IlvHyperEdgeEnd, IlvHyperEdgeEnd), addSegment(IlvSegmentedHyperEdge.Segment, double, double, double, IlvTransformer), addSegment(IlvSegmentedHyperEdge.Segment, double, double, double, double, IlvTransformer), getEndSegment(ilog.views.hypergraph.IlvHyperEdgeEnd), removeSegment(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - addSegment
```
public IlvSegmentedHyperEdge.Segment addSegment(IlvHyperEdgeEnd end,
                                                double x,
                                                double y,
                                                IlvTransformer t)
```
    Adds a new segment at the hyperedge end. If the hyperedge end has already an incident segment, the old segment is removed. The hyperedge end must belong to this hyperedge.
    The new segment has a variable angle and reaches from the input hyperedge end to the position (x, y).
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    end - The hyperedge end incident to the new segment.
    
    x - The x coordinate of the other end point (in transformed view coordinates).
    
    y - The y coordinate of the other end point (in transformed view coordinates).
    
    t - The transformer to draw this hyperedge.
    
    Returns:
    
    The new segment.
    
    See Also:
    
    addSegment(IlvHyperEdgeEnd, double), addSegment(IlvHyperEdgeEnd, IlvHyperEdgeEnd), addSegment(IlvSegmentedHyperEdge.Segment, double, double, double, IlvTransformer), addSegment(IlvSegmentedHyperEdge.Segment, double, double, double, double, IlvTransformer), getEndSegment(ilog.views.hypergraph.IlvHyperEdgeEnd), removeSegment(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - addSegment
```
public IlvSegmentedHyperEdge.Segment addSegment(IlvHyperEdgeEnd end1,
                                                IlvHyperEdgeEnd end2)
```
    Adds a new segment at the hyperedge ends. If the hyperedge ends have already incident segments, the old segments are removed. The hyperedge end must belong to this hyperedge.
    The new segment has a variable angle.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    end1 - The one hyperedge end incident to the new segment.
    
    end2 - The other hyperedge end incident to the new segment.
    
    Returns:
    
    The new segment.
    
    See Also:
    
    addSegment(IlvHyperEdgeEnd, double), addSegment(IlvHyperEdgeEnd, double, double, IlvTransformer), addSegment(IlvSegmentedHyperEdge.Segment, double, double, double, IlvTransformer), addSegment(IlvSegmentedHyperEdge.Segment, double, double, double, double, IlvTransformer), getEndSegment(ilog.views.hypergraph.IlvHyperEdgeEnd), removeSegment(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - addSegment
```
public IlvSegmentedHyperEdge.Segment addSegment(IlvSegmentedHyperEdge.Segment existingSegment,
                                                double angle,
                                                double x,
                                                double y,
                                                IlvTransformer t)
```
    Adds a new segment incident to the existing input segment. The new segment has a fixed angle. If the angle is 0, the segment is horizontal. If the angle is 90, the segment is vertical. The position of the new segment is so that the ray through the segment goes through the input point (x, y).
    The input segment must belong to this hyperedge. The input segment can have a fixed or a variable angle. If it has a fixed angle, the angle must be at least 1 degree different to the input angle, otherwise both segments would be colinear.
    If it has a variable angle, adding a fixed segment is only possible if the input segment is not yet fully terminated. The new segment becomes a terminating segment of the input segment. Note that a variable segment can have only a limited number of terminating segments: 2 if it is not incident to any hyperedge end, 1 if it is incident to one hyperedge end, and 0 if it is incident to two hyperedge ends.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    existingSegment - The segment incident to the new segment.
    
    angle - The fixed angle of the new segment.
    
    x - The x coordinate of the new segment (in transformed view coordinates).
    
    y - The y coordinate of the new segment (in transformed view coordinates).
    
    t - The transformer to draw this hyperedge.
    
    Returns:
    
    The new segment.
    
    See Also:
    
    addSegment(IlvHyperEdgeEnd, double), addSegment(IlvHyperEdgeEnd, double, double, IlvTransformer), addSegment(IlvHyperEdgeEnd, IlvHyperEdgeEnd), addSegment(IlvSegmentedHyperEdge.Segment, double, double, double, double, IlvTransformer), getEndSegment(ilog.views.hypergraph.IlvHyperEdgeEnd), removeSegment(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - addSegment
```
public IlvSegmentedHyperEdge.Segment addSegment(IlvSegmentedHyperEdge.Segment existingSegment,
                                                double x,
                                                double y,
                                                IlvTransformer t)
```
    Adds a new segment incident to the existing input segment. The new segment has a fixed angle which is orthogonal to the existing segment, i.e. both segment angles differ by 90 degree. The position of the new segment is so that the ray through the segment goes through the input point (x, y).
    The input segment must belong to this hyperedge. The input segment can have a fixed or a variable angle.
    If it has a variable angle, adding a fixed segment is only possible if the input segment is not yet fully terminated. The new segment becomes a terminating segment of the input segment. Note that a variable segment can have only a limited number of terminating segments: 2 if it is not incident to any hyperedge end, 1 if it is incident to one hyperedge end, and 0 if it is incident to two hyperedge ends.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    existingSegment - The segment incident to the new segment.
    
    x - The x coordinate of the new segment (in transformed view coordinates).
    
    y - The y coordinate of the new segment (in transformed view coordinates).
    
    t - The transformer to draw this hyperedge.
    
    Returns:
    
    The new segment.
    
    See Also:
    
    addSegment(IlvHyperEdgeEnd, double), addSegment(IlvHyperEdgeEnd, double, double, IlvTransformer), addSegment(IlvHyperEdgeEnd, IlvHyperEdgeEnd), addSegment(IlvSegmentedHyperEdge.Segment, double, double, double, IlvTransformer), addSegment(IlvSegmentedHyperEdge.Segment, double, double, double, double, IlvTransformer), getEndSegment(ilog.views.hypergraph.IlvHyperEdgeEnd), removeSegment(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - addSegment
```
public IlvSegmentedHyperEdge.Segment addSegment(IlvSegmentedHyperEdge.Segment existingSegment,
                                                double x1,
                                                double y1,
                                                double x2,
                                                double y2,
                                                IlvTransformer t)
```
    Adds a new segment incident to the existing input segment. The new segment has a variable angle. The new segment connects to the input segment at the on the input segment that is closest to (x1, y1) and ranges from this point to (x2, y2).
    The input segment must belong to this hyperedge. The input segment can have a fixed or a variable angle. The input segment becomes a terminating segment of the new segment. If the input segment has a variable angle and is not fully terminated yet, the new segment also becomes a terminating segment of the input segment.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    existingSegment - The segment incident to the new segment.
    
    x1 - The start x coordinate of the new segment (in transformed view coordinates).
    
    y1 - The start y coordinate of the new segment (in transformed view coordinates).
    
    x2 - The end x coordinate of the new segment (in transformed view coordinates).
    
    y2 - The end y coordinate of the new segment (in transformed view coordinates).
    
    t - The transformer to draw this hyperedge.
    
    Returns:
    
    The new segment.
    
    See Also:
    
    addSegment(IlvHyperEdgeEnd, double), addSegment(IlvHyperEdgeEnd, double, double, IlvTransformer), addSegment(IlvHyperEdgeEnd, IlvHyperEdgeEnd), addSegment(IlvSegmentedHyperEdge.Segment, double, double, double, IlvTransformer), addSegment(IlvSegmentedHyperEdge.Segment, double, double, double, double, IlvTransformer), getEndSegment(ilog.views.hypergraph.IlvHyperEdgeEnd), removeSegment(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - removeSegment
```
public IlvSegmentedHyperEdge.Segment[] removeSegment(IlvSegmentedHyperEdge.Segment segment)
```
    Removes the input segment. Afterwards the input segment cannot be used anymore. The segments incident to the input segment are disconnected from the input segment.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    segment - The segment to be removed.
    
    Returns:
    
    The segments that were incident to the removed segment.
    
    See Also:
    
    addSegment(IlvHyperEdgeEnd, double), addSegment(IlvHyperEdgeEnd, double, double, IlvTransformer), addSegment(IlvHyperEdgeEnd, IlvHyperEdgeEnd), addSegment(IlvSegmentedHyperEdge.Segment, double, double, double, IlvTransformer), addSegment(IlvSegmentedHyperEdge.Segment, double, double, double, double, IlvTransformer), disconnectSegments(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - removeAllSegments
```
public void removeAllSegments()
```
    Removes all segments of the hyperedge. If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
  - removeSegments
```
public void removeSegments(IlvHyperEdgeEnd end)
```
    Removes all segments of the hyperedge that branch from the current segment trunk to the input hyperedge end. If the hyperedge has more than two ends, this removes the branch that reaches the input end, but all segments connecting the other ends remain in the hyperedge. If the hyperedge has two ends, it removes all segments starting at the input segment except the one segment at the other end. If the hyperedge has only one end, it removed all segments. The reason is that there is not common segment trunk in both cases.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    end - The end of the hyperedge whose branch is removed.
  - connectSegments
```
public boolean connectSegments(IlvSegmentedHyperEdge.Segment segment1,
                               IlvSegmentedHyperEdge.Segment segment2)
```
    Connects both input segments. The one segment must be horizontal and the other segment must be vertical. Both segments must belong to this hyperedge. If both input segments are already connected, this does nothing. Otherwise, it makes the one segment incident to the other segment.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    segment1 - The one segment.
    
    segment2 - The other segment.
    
    Returns:
    
    true if both segments were not yet connected before.
    
    See Also:
    
    disconnectSegments(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment), isConnected(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - disconnectSegments
```
public boolean disconnectSegments(IlvSegmentedHyperEdge.Segment segment1,
                                  IlvSegmentedHyperEdge.Segment segment2)
```
    Disconnects both input segments. Usually, this is called for two segments that are incident to each other. If they are not incident to each other but connected, the one segment is disconnected from the path of segments that reaches the other segment. Both segments must belong to this hyperedge and must be different. The segments are not be removed from the hyperedge, hence they can be reconnected later.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    segment1 - The one segment.
    
    segment2 - The other segment.
    
    Returns:
    
    true if both segments were connected before.
    
    See Also:
    
    connectSegments(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment), isConnected(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - isConnected
```
public boolean isConnected(IlvSegmentedHyperEdge.Segment segment1,
                           IlvSegmentedHyperEdge.Segment segment2)
```
    Returns whether both input segments are connected. They are connected if the one segment is reachable from the other segment by a path of incident segments.
    
    Parameters:
    
    segment1 - The one segment.
    
    segment2 - The other segment.
    
    Returns:
    
    true if both segments are connected.
    
    See Also:
    
    IlvSegmentedHyperEdge.Segment.isIncident(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - getConnectionPoint
```
public IlvPoint getConnectionPoint(IlvSegmentedHyperEdge.Segment segment1,
                                   IlvSegmentedHyperEdge.Segment segment2,
                                   IlvTransformer t)
```
    Returns the connection point of both input segments if the one segment is incident to the other segment. The returned point is in view coordinates.
    
    Parameters:
    
    segment1 - The one segment.
    
    segment2 - The other segment.
    
    t - The transformer to draw the hyperedge.
    
    Returns:
    
    The connection point, or null if both segments are not connected.
  - splitSegment
```
public IlvSegmentedHyperEdge.Segment[] splitSegment(IlvSegmentedHyperEdge.Segment segment,
                                                    double x,
                                                    double y,
                                                    IlvTransformer t)
```
    Splits the input segment at the input point. The input segment must belong to this hyperedge. If the point is (x,y) not on the segment, the split point is its orthogonal projection on the segment. If the orthogonal projection of (x, y) is not on the segment, splitting cannot be done.
    Splitting a segment creates one or two new segments which are returned. The new segment get their coordinate from the input point. Segments incident to the input segment are distributed between the input segment and the new segments.
    Note: in certain situations, the input segment cannot be reused. In this case, the operation removes the input segment and replaces it by a new segment.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    segment - The segment to be split.
    
    x - The x coordinate of the segment if it is vertical.
    
    y - The y coordinate of the segment if it is horizontal.
    
    t - The transformer to draw the hyperedge.
    
    Returns:
    
    The new segments if the split was successful, or null if the split was not successful.
    
    See Also:
    
    joinSegments(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.IlvTransformer), disconnectSegments(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - splitSegment
```
public IlvSegmentedHyperEdge.Segment[] splitSegment(IlvSegmentedHyperEdge.Segment segment,
                                                    IlvSegmentedHyperEdge.Segment connectingSegment,
                                                    IlvTransformer t)
```
    Splits the input segment at the connection point with the connecting segment. The connecting segment must be incident to the input segment. Both segments must belong to this hyperedge.
    This operation cannot be done if one of both segments has a variable angle and the other segment has a fixed angle.
    Splitting the segment can create one or two new segments. Usually, the input segment is reused, therefore only one new segment is created. The new segment is also connected to the connecting segment. Segments incident to the input segment are distributed between the input segment and the new segment. If the input segment cannot be reused, two new segments are created. In this case, segments incident to the input segment are distributed between the two new segments. The new segments are returned.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    segment - The segment to be split.
    
    connectingSegment - The segment that connects to the first segment.
    
    t - The transformer to draw the hyperedge.
    
    Returns:
    
    The new segments if the split was successful, or null if the split was not successful.
    
    See Also:
    
    joinSegments(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.IlvTransformer), disconnectSegments(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - splitSegment
```
public IlvSegmentedHyperEdge.Segment[] splitSegment(IlvSegmentedHyperEdge.Segment segment,
                                                    IlvSegmentedHyperEdge.Segment connectingSegment)
```
    Splits the input segment at the connection point with the connecting segment. The connecting segment must be incident to the input segment. Both segments must belong to this hyperedge.
    This operation cannot be done if one of both segments has a variable angle and the other segment has a fixed angle.
    This convenience method calls splitSegment(Segment, Segment, IlvTransformer) with a null transformer.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    segment - The segment to be split.
    
    connectingSegment - The segment that connects to the first segment.
    
    Returns:
    
    The new segments if the split was successful, or null if the split was not successful.
    
    See Also:
    
    joinSegments(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.IlvTransformer), disconnectSegments(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - parallelSplitSegment
```
public IlvSegmentedHyperEdge.Segment[] parallelSplitSegment(IlvSegmentedHyperEdge.Segment segment,
                                                            double x,
                                                            double y,
                                                            IlvTransformer t)
```
    Splits the input segment and redistributes the incident segments, if the segment has incident segments at both sides. For instance, if the segment is vertical and has incident segments at its left side and at its right side, the segment is split which creates a new parallel segment connected to the original segment by a bridge segment. All incident segments of the input segment are distributed between both parallel segments so that the one is connected to all segments that came from the left of the original segment and the other is connected to all segments that came from the right of the original segment. The input point (x,y) is the position of the bridge segment and of the new parallel segment.
    Splitting a segment creates two new segments (the bridge segment and the new parallel segment) which are returned. Splitting is not possible if all incident segments of the input segment come from the same side. In this case null is returned.
    If the input segment is not an end segment and has exactly one incident segment coming from the left and another one coming from the right, the effect of a parallel split is the same as the effect of a regular split via splitSegment(IlvSegmentedHyperEdge.Segment, double, double, IlvTransformer). As intuitive reminder: If a segment has multiple incident segments, the regular split is like a cut perpendicular to the segment orientation while the parallel split is like a cut parallel to the segment orientation.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    segment - The segment to be split.
    
    x - The x coordinate of the segment if it is vertical.
    
    y - The y coordinate of the segment if it is horizontal.
    
    t - The transformer to draw the hyperedge.
    
    Returns:
    
    An array of two segments if the split was successful, or null if the split was not successful.
    
    See Also:
    
    joinSegments(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.IlvTransformer), disconnectSegments(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - joinSegments
```
public IlvSegmentedHyperEdge.Segment joinSegments(IlvSegmentedHyperEdge.Segment segment1,
                                                  IlvSegmentedHyperEdge.Segment segment2,
                                                  IlvTransformer t)
```
    Join the two input segments. This works only if both segments are directly incident of both segments have a common incident segment, like the result of splitSegment(Segment, double, double, IlvTransformer) or splitSegment(Segment, Segment, IlvTransformer) or parallelSplitSegment(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, double, double, ilog.views.IlvTransformer). In principle, this is the inverse operation of the various split operations.
    It does not work if the number of ends of both segments together is more than 2 if at least one segment has a variable angle, or more than 1 if both segments have a fixed angle. It also does not work if the resulting segment must have a variable angle but would need to connect to more than 2 incident segments with fixed angle. It also does not work if the resulting segment must have a fixed angle but would need to connect to a colinear segment. One of both segments is removed. All segments incident to the removed segment are connected to the surviving segment. The surviving segment is returned.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    segment1 - The one segment.
    
    segment2 - The other segment.
    
    t - The transformer to draw the hyperedge.
    
    Returns:
    
    The surviving segment if the join was successful, or null if the join was not successful.
    
    See Also:
    
    connectSegments(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - joinSegments
```
public IlvSegmentedHyperEdge.Segment joinSegments(IlvSegmentedHyperEdge.Segment segment1,
                                                  IlvSegmentedHyperEdge.Segment segment2)
```
    Join the two input segments. This convenience method calls joinSegments(Segment, Segment, IlvTransformer) with a null transformer.
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    segment1 - The one segment.
    
    segment2 - The other segment.
    
    Returns:
    
    The surviving segment if the join was successful, or null if the join was not successful.
    
    See Also:
    
    connectSegments(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment)
  - moveConnectionPoint
```
public void moveConnectionPoint(IlvSegmentedHyperEdge.Segment seg1,
                                IlvSegmentedHyperEdge.Segment seg2,
                                double x,
                                double y,
                                IlvTransformer t)
```
    Moves the connection point of both input segments to the input point.
    Note that end segments cannot be moved by this method. In order to move an end segment, you must move the associated hyperedge end (see IlvSegmentedHyperEdge.Segment.getEnds()).
    If the edge is inside a grapher, this must be done inside an applyToObject session of the hyperedge (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Parameters:
    
    seg1 - The one segment to be moved.
    
    seg2 - The other segment to be moved.
    
    x - The x coordinate.
    
    y - The y coordinate.
    
    t - The transformer to draw the hyperedge.
  - setSegmentAngle
```
public boolean setSegmentAngle(IlvSegmentedHyperEdge.Segment segment,
                               double angle)
```
    Sets the angle of a segment. If the segment becomes colinear with one of the incident segments, the angle is not changed.
    
    Parameters:
    
    segment - The segment.
    
    angle - The desired angle.
    
    Returns:
    
    true if the change of the angle was successful.
  - setEndSegmentAngle
```
public void setEndSegmentAngle(IlvHyperEdgeEnd end,
                               double angle)
```
    Sets the angle of the segment incident to the input end to the given angle. This has only an effect if the segment incident to the input segment has a fixed angle. It also tries to reorganize the hyperedge so that all segments stay connected.
    
    Parameters:
    
    end - The hyperedge end.
    
    angle - The desired angle of the segment.
  - getNodeSide
```
public int getNodeSide(IlvHyperEdgeEnd end)
```
    Decides on which side of the node the hyperedge end is located. The returned value is one of IlvDirection.Top, IlvDirection.Bottom, IlvDirection.Left, IlvDirection.Right.
  - getClosestSegment
```
public IlvSegmentedHyperEdge.Segment getClosestSegment(double x,
                                                       double y,
                                                       IlvTransformer t)
```
    Returns the segment closest to the input point. The input coordinates are transformed in view coordinates.
    
    Parameters:
    
    x - The x coordinate.
    
    y - The y coordinate.
    
    t - The transformer to draw the hyperedge.
    
    Returns:
    
    The closest segment, or null if there are no segments yet.
  - getClosestSegments
```
public IlvSegmentedHyperEdge.Segment[] getClosestSegments(double x,
                                                          double y,
                                                          IlvTransformer t,
                                                          IlvSegmentedHyperEdge.Segment[] segments)
```
    Returns the two segments whose connection point is closest to the input point. The input coordinates are transformed in view coordinates.
    
    Parameters:
    
    x - The x coordinate.
    
    y - The y coordinate.
    
    t - The transformer to draw the hyperedge.
    
    segments - If null a new array of segments is allocated and returned. Otherwise the input array is filled with the segments and returned.
    
    Returns:
    
    An array of two segments, or null if there are no segments yet.
  - getNearEndSegment
```
public IlvSegmentedHyperEdge.Segment getNearEndSegment(IlvSegmentedHyperEdge.Segment segment)
```
    Returns the near end segment that is reachable from the input segment along a segment path that never branches. More precisely: If the input segment is an end segment (i.e., IlvSegmentedHyperEdge.Segment.getEnds() returns not an empty array), it returns the input segment. Otherwise it searches by traversing the segments starting at the input segment until it reaches a branch of multiple segments or an end segment. A branch of multiple segments is a segment with more than 2 incident segments (that is, one incident segment where it came from and the other to continue the traversal). If it reaches the end segment and the end segment has only one incident segment and only one incident end, the end segment is returned (because otherwise the end segment itself is a branch). If no end segment is reachable without going over a branch, the method returns null.
  - setSelected
```
public void setSelected(IlvSegmentedHyperEdge.Segment segment,
                        boolean select,
                        boolean redraw)
```
    Selects or deselects the segment.
    
    Parameters:
    
    segment - The segment to be selected.
    
    select - If true the object will be selected, and deselected otherwise.
    
    redraw - If true, the hyperedge is redrawn.
    
    See Also:
    
    getSelectedSegments(), selectAll(boolean), deSelectAll(boolean), IlvSegmentedHyperEdge.Segment.isSelected()
  - selectAll
```
public void selectAll(boolean redraw)
```
    Selects all segments of this hyperedge.
    
    Parameters:
    
    redraw - If true, the hyperedge is redrawn.
    
    See Also:
    
    setSelected(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, boolean, boolean), deSelectAll(boolean), IlvSegmentedHyperEdge.Segment.isSelected()
  - deSelectAll
```
public void deSelectAll(boolean redraw)
```
    Deselects all segments of this hyperedge.
    
    Parameters:
    
    redraw - If true, the hyperedge is redrawn.
    
    See Also:
    
    setSelected(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, boolean, boolean), selectAll(boolean), IlvSegmentedHyperEdge.Segment.isSelected()
  - deleteSelection
```
public boolean deleteSelection(boolean redraw)
```
    Deletes the selection in the inner of the hyperedge. Here, it means: delete the hyperedge end reachable from selected segments. Returns true if any inner segment was selected, and false otherwise.
    
    Overrides:
    
    deleteSelection in class IlvHyperEdge
  - getSelectedSegments
```
public IlvSegmentedHyperEdge.Segment[] getSelectedSegments()
```
    Returns all selected segments.
    
    See Also:
    
    setSelected(ilog.views.hypergraph.IlvSegmentedHyperEdge.Segment, boolean, boolean), selectAll(boolean), deSelectAll(boolean), IlvSegmentedHyperEdge.Segment.isSelected()
  - setSelectedSegmentsPaint
```
public void setSelectedSegmentsPaint(Paint p)
```
    Changes the stroke paint of the selected segments.
    
    Parameters:
    
    p - The new paint.
    
    See Also:
    
    getSelectedSegmentsPaint()
  - getSelectedSegmentsPaint
```
public Paint getSelectedSegmentsPaint()
```
    Returns the stroke paint of the selected segments.
    
    See Also:
    
    setSelectedSegmentsPaint(java.awt.Paint)
  - getAdaptedSelectedSegmentsPaint
```
protected Paint getAdaptedSelectedSegmentsPaint(IlvTransformer t)
```
    Returns the stroke paint of the selected segments adapted to the input transformer. If the paint mode is not absolute, this returns for gradient paint and textures a different paint, which is adapted to the bounding box of the object.
    
    Parameters:
    
    t - The transformer used to draw the object.
  - setAutoConnect
```
public void setAutoConnect(boolean autoconnect)
```
    Sets whether adding source or target nodes to the hyperedge creates segments that connect the new hyperedge end to the remaining segments. This is enabled by default.
    If autoconnect is disabled, any call of IlvHyperEdge.addFrom(ilog.views.IlvGraphic) or IlvHyperEdge.addTo(ilog.views.IlvGraphic) adds the hyperedge end, but no additional segments. Hence the hyperedge segments will be incomplete (see isSegmentSetComplete()). You are responsible for adding the segments yourself to make the segment set complete.
    
    See Also:
    
    addSegment(IlvHyperEdgeEnd, double), addSegment(IlvSegmentedHyperEdge.Segment, double, double, IlvTransformer), isAutoConnect()
  - isAutoConnect
```
public boolean isAutoConnect()
```
    Returns true if adding source or target nodes to the hyperedge creates segments that connect the new hyperedge end to the remaining segments. This is enabled by default.
    
    See Also:
    
    setAutoConnect(boolean)
  - afterAddEnd
```
protected void afterAddEnd(IlvHyperEdgeEnd end,
                           boolean fromSide)
```
    Called after the hyperedge end point is added to the edge. This method can be overridden if special handling is required when a hyperedge end is added.
    
    Overrides:
    
    afterAddEnd in class IlvHyperEdge
    
    Parameters:
    
    end - The hyperedge end.
    
    fromSide - Whether the hyperedge end is origin or destination.
  - beforeRemoveEnd
```
protected void beforeRemoveEnd(IlvHyperEdgeEnd end,
                               boolean fromSide)
```
    Called before the hyperedge end point is removed from the edge. This method can be overridden if special handling is required when a hyperedge end is removed.
    
    Overrides:
    
    beforeRemoveEnd in class IlvHyperEdge
    
    Parameters:
    
    end - The hyperedge end.
    
    fromSide - Whether the hyperedge end is origin or destination.
  - write
```
public void write(IlvOutputStream stream)
           throws IOException
```
    Writes the object to an IlvOutputStream. You should not call this method directly; instead, you should use the write methods of the manager.
    
    Specified by:
    
    write in interface IlvPersistentObject
    
    Overrides:
    
    write in class IlvHyperEdge
    
    Parameters:
    
    stream - The output stream.
    
    Throws:
    
    IOException - thrown when an exception occurs during the write operation for this object.
  - setCrossingMode
```
public void setCrossingMode(int mode)
```
    Sets the crossing mode of the hyperedge. The options are:
    - IlvParameterizedCrossingAwareObject.NO_CROSSINGS - crossings are not displayed in any particular way.
    - IlvParameterizedCrossingAwareObject.TUNNEL_CROSSINGS - crossings are displayed with a tunnel shape.
    - IlvParameterizedCrossingAwareObject.BRIDGE_CROSSINGS - crossings are displayed with a bridge shape.
    - IlvParameterizedCrossingAwareObject.CUSTOM_CROSSINGS - crossings are displayed with a custom shape that was set by setCrossingGraphic(ilog.views.IlvGraphic, int).
    The default value is IlvParameterizedCrossingAwareObject.NO_CROSSINGS
    This method is a convenience method that internally calls setCrossingEnabled(boolean), setCrossingGraphic(ilog.views.IlvGraphic, int) and createCrossingGraphic(int) to adjust the corresponding mode.
    Specified by:
    
    setCrossingMode in interface IlvParameterizedCrossingAwareObject
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    getCrossingMode()
  - getCrossingMode
```
public final int getCrossingMode()
```
    Returns the crossing mode of the hyperedge. It checks which mode fits to the current crossing graphic by calling modeFitsCrossingGraphic(int).
    
    Specified by:
    
    getCrossingMode in interface IlvParameterizedCrossingAwareObject
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setCrossingMode(int)
  - createCrossingGraphic
```
protected IlvGraphic createCrossingGraphic(int mode)
```
    Creates the appropriate crossing graphic. This can be overridden in subclasses. The default implementation returns:
    - a new instance of IlvTunnelCrossings if the mode is IlvParameterizedCrossingAwareObject.TUNNEL_CROSSINGS,
    - a new instance of IlvBridgeCrossings if the mode is IlvParameterizedCrossingAwareObject.BRIDGE_CROSSINGS,
    - null in all other cases.
    Since:
    
    JViews 8.1
    
    See Also:
    
    setCrossingMode(int), modeFitsCrossingGraphic(int)
  - modeFitsCrossingGraphic
```
protected boolean modeFitsCrossingGraphic(int mode)
```
    Tests if the current crossing graphic fits to the input mode. This must be overridden in subclasses, if the method createCrossingGraphic(int) is overridden as well. The default implementation returns true
    - if the crossing graphic is an instance of IlvTunnelCrossings and the mode is IlvParameterizedCrossingAwareObject.TUNNEL_CROSSINGS,
    - if the crossing graphic is an instance of IlvBridgeCrossings and the mode is IlvParameterizedCrossingAwareObject.BRIDGE_CROSSINGS.
    Since:
    
    JViews 8.1
    
    See Also:
    
    getCrossingMode()
  - setCrossingEnabled
```
public void setCrossingEnabled(boolean enable)
```
    Sets whether tunnel (jog) crossing display is enabled for this hyperedge. If the hyperedge is inside a grapher, this must be done inside an applyToObject session of the link (see IlvManager.applyToObject(ilog.views.IlvGraphic, ilog.views.IlvApplyObject, java.lang.Object, boolean)).
    
    Specified by:
    
    setCrossingEnabled in interface IlvParameterizedCrossingAwareObject
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    isCrossingEnabled()
  - isCrossingEnabled
```
public boolean isCrossingEnabled()
```
    Returns true if tunnel (jog) crossing display is enabled for this hyperedge.
    
    Specified by:
    
    isCrossingEnabled in interface IlvCrossingAwareObject
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setCrossingEnabled(boolean)
  - setCrossingGraphic
```
public void setCrossingGraphic(IlvGraphic g,
                               int layerNumber)
```
    Sets the graphic object that draws the crossings. This should be a subclass of IlvGraphic that can draw all the crossing points of this link. It must implement the IlvCrossingGraphic interface.
    This operation does not change the shape of this hyperedge, but it changes bounds of the crossing graphic. You can only set a crossing graphic when the crossing graphic is outside any grapher.
    When the crossing graphic becomes active due to crossings, it is automatically inserted into an appropriate grapher into the specified layer. The layer number should be above the layer that contains the links. If the layer number is -1, an appropriate layer is automatically calculated.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setCrossingGraphic(IlvGraphic), getCrossingGraphic()
  - setCrossingGraphic
```
public void setCrossingGraphic(IlvGraphic g)
```
    Sets the graphic object that draws the crossings. This should be a subclass of IlvGraphic that can draw all the crossing points of this hyperedge. It must implement the IlvCrossingGraphic interface.
    This operation does not change the shape of this hyperedge, but it changes bounds of the crossing graphic. You can only set a crossing graphic when the crossing graphic is outside any grapher.
    
    Specified by:
    
    setCrossingGraphic in interface IlvParameterizedCrossingAwareObject
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setCrossingGraphic(IlvGraphic, int), getCrossingGraphic()
  - getCrossingGraphic
```
public IlvGraphic getCrossingGraphic()
```
    Returns the graphic object that draws the crossings.
    
    Specified by:
    
    getCrossingGraphic in interface IlvCrossingAwareObject
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setCrossingGraphic(IlvGraphic), setCrossingGraphic(IlvGraphic, int)
  - setLayerOfCrossingGraphic
```
public void setLayerOfCrossingGraphic(int layerNumber)
```
    Sets the default layer of the graphic object that draws the crossings. 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.
    
    Specified by:
    
    setLayerOfCrossingGraphic in interface IlvParameterizedCrossingAwareObject
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    getLayerOfCrossingGraphic(), setCrossingGraphic(IlvGraphic, int)
  - getLayerOfCrossingGraphic
```
public final int getLayerOfCrossingGraphic()
```
    Returns the default layer of the graphic object that draws the crossings. Returns -1 if the layer is automatically calculated.
    
    Specified by:
    
    getLayerOfCrossingGraphic in interface IlvParameterizedCrossingAwareObject
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setLayerOfCrossingGraphic(int)
  - setGap
```
public void setGap(double gap)
```
    Sets the gap width of the hyperedge crossings. The default value is 2.
    
    Specified by:
    
    setGap in interface IlvParameterizedCrossingAwareObject
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    getGap()
  - getGap
```
public final double getGap()
```
    Returns the gap width of the hyperedge crossings.
    
    Specified by:
    
    getGap in interface IlvParameterizedCrossingAwareObject
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setGap(double)
  - setGapZoomable
```
public void setGapZoomable(boolean zoomable)
```
    Sets whether the gap of the hyperedge crossings is zoomable. 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 links of different graphers cross each other, it is visually more appealing if the gap is not zoomable.
    The option is enabled by default.
    
    Specified by:
    
    setGapZoomable in interface IlvParameterizedCrossingAwareObject
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    isGapZoomable()
  - isGapZoomable
```
public final boolean isGapZoomable()
```
    Returns true if the gap of the link crossings is zoomable.
    
    Specified by:
    
    isGapZoomable in interface IlvParameterizedCrossingAwareObject
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setGapZoomable(boolean)
  - getCrossingAwareGraphic
```
public IlvGraphic getCrossingAwareGraphic()
```
    Returns the corresponding graphic. If a subclass of IlvGraphic implements this interface, it should return the this handle.
    
    Specified by:
    
    getCrossingAwareGraphic in interface IlvCrossingAwareObject
    
    Since:
    
    JViews 8.1
  - getCrossingAwareSegments
```
public IlvCrossingAwareSegment[] getCrossingAwareSegments(IlvTransformer t)
```
    Returns those segments of the hyperedge that can display a crossing. The returned objects are proxy objects for the real segments of the hyperedge.
    
    Specified by:
    
    getCrossingAwareSegments in interface IlvCrossingAwareObject
    
    Parameters:
    
    t - The transformer to draw the object.
    
    Since:
    
    JViews 8.1
  - removeAllCrossings
```
public void removeAllCrossings(IlvTransformer t)
```
    Removes all crossings added at the object for a given transformer.
    
    Specified by:
    
    removeAllCrossings in interface IlvCrossingAwareObject
    
    Parameters:
    
    t - The transformer to draw the object.
    
    Since:
    
    JViews 8.1
  - drawCrossingGraphic
```
public void drawCrossingGraphic(Graphics dst,
                                IlvTransformer t)
```
    Draws the crossing graphic that belongs to this object. Crossing graphics can delegate their draw method to this method if necessary.
    
    Specified by:
    
    drawCrossingGraphic in interface IlvCrossingAwareObject
    
    Parameters:
    
    dst - The destination Graphics.
    
    t - The transformation used to draw this object.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    IlvAbstractCrossingGraphic.draw(java.awt.Graphics, ilog.views.IlvTransformer)
  - containsAtCrossingGraphic
```
public boolean containsAtCrossingGraphic(IlvPoint p,
                                         IlvPoint tp,
                                         IlvTransformer t)
```
    Tests if a point lies within the outline of the crossing graphic that belongs to this object. Crossing graphics can delegate their contains method to this method if necessary.
    
    Specified by:
    
    containsAtCrossingGraphic in interface IlvCrossingAwareObject
    
    Parameters:
    
    p - The point to be tested in the coordinate system of this object.
    
    tp - The point p transformed by the transformer t.
    
    t - The transformation that was applied to this object when it was drawn.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    IlvAbstractCrossingGraphic.contains(ilog.views.IlvPoint, ilog.views.IlvPoint, ilog.views.IlvTransformer)
  - boundingBoxCrossingGraphic
```
public IlvRect boundingBoxCrossingGraphic(IlvTransformer t)
```
    Returns the bounding rectangle of the crossing graphic that belongs to this object. Crossing graphics can delegate their boundingBox method to this method if necessary.
    
    Specified by:
    
    boundingBoxCrossingGraphic in interface IlvCrossingAwareObject
    
    Parameters:
    
    t - The transformer used to draw this object.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    IlvAbstractCrossingGraphic.boundingBox(ilog.views.IlvTransformer)
  - setCrossingAdjusting
```
public void setCrossingAdjusting(boolean adjusting)
```
    Starts or end an adjustment session for the crossings. This is part of the IlvCrossingAwareObject interface. You should not call this method.
    
    Specified by:
    
    setCrossingAdjusting in interface IlvCrossingAwareObject
    
    Since:
    
    JViews 8.1
  - isCrossingAdjusting
```
public boolean isCrossingAdjusting()
```
    Returns whether the segmented hyperedge is inside an adjustment session for the crossings. This is part of the IlvCrossingAwareObject interface. You should not call this method.
    
    Since:
    
    JViews 8.1
  - actOnAdjustmentEnd
```
protected void actOnAdjustmentEnd()
```
    Reacts on adjustment end. This is called for hyperedges that are registered at the hypergrapher that they want to receive an adjustment end notification.
    
    Overrides:
    
    actOnAdjustmentEnd in class IlvHyperEdge
    
    See Also:
    
    IlvHyperGrapher.registerWaitingForAdjustmentEnd(ilog.views.hypergraph.IlvHyperEdge)
  - setGraphicBag
```
public void setGraphicBag(IlvGraphicBag bag)
```
    Changes the bag that contains the object. You should not call this method directly unless you are creating a new type of bag.
    
    Overrides:
    
    setGraphicBag in class IlvGraphic
    
    Parameters:
    
    bag - The graphic bag.
    
    See Also:
    
    IlvGraphic
  - mergeCrossings
```
protected boolean mergeCrossings(IlvCrossing cr1,
                                 IlvCrossing cr2,
                                 double dist,
                                 double gap)
```
    Decides when to merge crossings.
    
    Parameters:
    
    cr1 - The one crossing.
    
    cr2 - The other crossing.
    
    dist - The distance between this crossing and the next crossing.
    
    gap - The desired gap for the crossing.
    
    Since:
    
    JViews 8.1
  - beforeDo
```
public IlvOrderedCompoundEdit beforeDo(String undoPresentationName)
```
    This method must be called if undo support is needed for a specific operation. It must be called at the beginning of the operation. It returns the undoable edit that can be used to undo the operation.
    The following example illustrates the typical use case:
```
 IlvOrderedCompoundEdit edit = hyperedge.beforeDo("Hyperedge Edition");
 ... do any changes on the hyperedge ...
 hyperedge.afterDo(edit); 
 // now add the edit to the undo manager so that the user can request
 // undoing the operation
 undoManager.addEdit(edit);
 
```
    Overrides:
    
    beforeDo in class IlvHyperEdge
    
    See Also:
    
    afterDo(ilog.views.hypergraph.undo.IlvOrderedCompoundEdit)
  - afterDo
```
public void afterDo(IlvOrderedCompoundEdit undo)
```
    This method must be called if undo support is needed for a specific operation. It must be called at the end of the operation.
    
    Overrides:
    
    afterDo in class IlvHyperEdge
    
    Parameters:
    
    undo - The undoable edit returned by beforeDo(java.lang.String).
    
    See Also:
    
    beforeDo(java.lang.String)

Class IlvSegmentedHyperEdge

Nested Class Summary

Field Summary

Fields inherited from interface ilog.views.hypergraph.crossing.IlvParameterizedCrossingAwareObject

Constructor Summary

Method Summary

Methods inherited from class ilog.views.hypergraph.IlvHyperEdge

Methods inherited from class ilog.views.IlvGraphic

Methods inherited from class java.lang.Object

Methods inherited from interface ilog.views.hypergraph.crossing.IlvCrossingAwareObject

Constructor Detail

IlvSegmentedHyperEdge

IlvSegmentedHyperEdge

IlvSegmentedHyperEdge

IlvSegmentedHyperEdge

Method Detail

copyShapeFrom

draw

drawLine

getUnclippedSegmentPoints

calcBoundingBox

clearBoundingBoxCache

contains

getArrowHeadControlPoint

makeSelection

applyTransform

createEnd

getSegments

getSegmentsCount

getEndSegment

isSegmentSetComplete

addSegment

addSegment

addSegment

addSegment

addSegment

addSegment

removeSegment

removeAllSegments

removeSegments

connectSegments

disconnectSegments

isConnected

getConnectionPoint

splitSegment

splitSegment

splitSegment

parallelSplitSegment

joinSegments

joinSegments

moveConnectionPoint

setSegmentAngle

setEndSegmentAngle

getNodeSide

getClosestSegment

getClosestSegments

getNearEndSegment

setSelected

selectAll

deSelectAll

deleteSelection

getSelectedSegments

setSelectedSegmentsPaint

getSelectedSegmentsPaint

getAdaptedSelectedSegmentsPaint

setAutoConnect

isAutoConnect

afterAddEnd

beforeRemoveEnd

write

setCrossingMode

getCrossingMode

createCrossingGraphic

modeFitsCrossingGraphic

setCrossingEnabled

isCrossingEnabled

setCrossingGraphic

setCrossingGraphic

getCrossingGraphic

setLayerOfCrossingGraphic