LayeredLayout.Compaction.OneD

data Direction

Constructors

• LEFT
• RIGHT
• UP
• DOWN
• UNDEFINED

Instances

• Eq Direction
• Ord Direction

isHorizontalDir :: Direction -> Boolean

isVerticalDir :: Direction -> Boolean

type Rect = { height :: Number, width :: Number, x :: Number, y :: Number }

type KVec = { x :: Number, y :: Number }

zeroVec :: KVec

type CNodeId = Int

type CGroupId = Int

type CNode a = { cGroup :: Maybe CGroupId, cGroupOffset :: KVec, constraints :: Array CNodeId, hitbox :: Rect, hitboxPreCompaction :: Rect, id :: CNodeId, ignoreSpacing :: Quadruplet, kind :: Maybe String, origin :: Maybe a, startPos :: Number }

Node in the constraint graph.

The origin field is polymorphic — the layered-graph bridge tags it with a sum of LNode and VerticalSegment, but this module does not need to look inside.

type CGroup = { cNodes :: Array CNodeId, delta :: Number, deltaNormalized :: Number, id :: CGroupId, incomingConstraints :: Array CNodeId, master :: Maybe CNodeId, outDegree :: Int, outDegreeReal :: Int, reference :: Maybe CNodeId, startPos :: Number }

Group of nodes whose relative offsets are preserved during compaction.

type CGraph a = { cGroupOrder :: Array CGroupId, cGroups :: Map CGroupId CGroup, cNodeOrder :: Array CNodeId, cNodes :: Map CNodeId (CNode a), nextCGroupId :: Int, nextCNodeId :: Int, predefinedHorizontalConstraints :: Array (CNodeId /\ CNodeId), predefinedVerticalConstraints :: Array (CNodeId /\ CNodeId), supportedDirections :: Set Direction }

Constraint graph.

type OneDState a = { cGraph :: CGraph a, compactionAlgorithm :: Maybe (ICompactionAlgorithm a), constraintAlgorithm :: Maybe (IConstraintCalculationAlgorithm a), direction :: Direction, finished :: Boolean, lockFun :: Maybe (ILockFunction a), spacingsHandler :: ISpacingsHandler a }

type ISpacingsHandler a = { horizontalSpacing :: CNode a -> CNode a -> Number, verticalSpacing :: CNode a -> CNode a -> Number }

type ILockFunction a = CNode a -> Direction -> Boolean

newtype ICompactionAlgorithm a

Constructors

• ICompactionAlgorithm (OneDState a -> OneDState a)

newtype IConstraintCalculationAlgorithm a

Constructors

• IConstraintCalculationAlgorithm (OneDState a -> CGraph a)

runCompactionAlgorithm :: forall a. ICompactionAlgorithm a -> OneDState a -> OneDState a

runConstraintAlgorithm :: forall a. IConstraintCalculationAlgorithm a -> OneDState a -> CGraph a

type Quadruplet = { down :: Boolean, left :: Boolean, right :: Boolean, up :: Boolean }

emptyQuadruplet :: Quadruplet

quadGet :: Direction -> Quadruplet -> Boolean

quadSet :: Direction -> Boolean -> Quadruplet -> Quadruplet

quadOr :: Quadruplet -> Quadruplet -> Quadruplet

fuzzyTolerance :: Number

fuzzyEq :: Number -> Number -> Boolean

fuzzyGt :: Number -> Number -> Boolean

fuzzyLt :: Number -> Number -> Boolean

fuzzyGe :: Number -> Number -> Boolean

fuzzyLe :: Number -> Number -> Boolean

defaultSpacingsHandler :: forall a. ISpacingsHandler a

newCGraph :: forall a. Set Direction -> CGraph a

addCNode :: forall a. { hitbox :: Rect, kind :: Maybe String, origin :: Maybe a } -> CGraph a -> { graph :: CGraph a, id :: CNodeId }

Create a new free-standing CNode in the graph. The node is not placed in any group yet — the OneDimensionalCompactor constructor wraps every group-less node in a singleton group.

addCNodeWithGroup :: forall a. { hitbox :: Rect, kind :: Maybe String, origin :: Maybe a } -> CNodeId -> CGraph a -> { graph :: CGraph a, id :: CNodeId }

Add a node and immediately group it with parent. Mirrors CNodeBuilder.groupWith(parent).create(graph).

addCGroup :: forall a. { master :: Maybe CNodeId, nodes :: Array CNodeId } -> CGraph a -> { graph :: CGraph a, id :: CGroupId }

Create a new CGroup containing nodes. The first node in nodes becomes the initial reference.

addCNodeToGroup :: forall a. CNodeId -> CGroupId -> CGraph a -> CGraph a

Move a node into a group. Mirrors CGroup.addCNode (which throws if the node already belongs to a group). The first node added becomes the group's reference.

removeCNodeFromGroup :: forall a. CNodeId -> CGroupId -> CGraph a -> CGraph a

supports :: forall a. Direction -> CGraph a -> Boolean

lookupCNode :: forall a. CNodeId -> CGraph a -> Maybe (CNode a)

lookupCGroup :: forall a. CGroupId -> CGraph a -> Maybe CGroup

updateCNode :: forall a. CNodeId -> (CNode a -> CNode a) -> CGraph a -> CGraph a

setCNodeIgnoreSpacing :: forall a. CNodeId -> Quadruplet -> CGraph a -> CGraph a

OR q into the CNode's existing ignoreSpacing flags. Mirrors the merge semantics of VerticalSegment.unionInto so flags set by the transformer accumulate when a node is touched multiple times.

updateCGroup :: forall a. CGroupId -> (CGroup -> CGroup) -> CGraph a -> CGraph a

allCNodes :: forall a. CGraph a -> Array (CNode a)

Iterate every CNode in insertion order.

allCGroups :: forall a. CGraph a -> Array CGroup

Iterate every CGroup in insertion order.

newOneD :: forall a. CGraph a -> OneDState a

Construct a new compactor for the given graph. Matches the Java constructor: (1) compute group offsets so the left-most node in each group becomes the reference, (2) wrap any plain node in a singleton group, (3) snapshot the pre-compaction hitbox.

setSpacingsHandler :: forall a. ISpacingsHandler a -> OneDState a -> OneDState a

setCompactionAlgorithm :: forall a. ICompactionAlgorithm a -> OneDState a -> OneDState a

setConstraintAlgorithm :: forall a. IConstraintCalculationAlgorithm a -> OneDState a -> OneDState a

setLockFunction :: forall a. ILockFunction a -> OneDState a -> OneDState a

compact :: forall a. OneDState a -> OneDState a

Compact in the current direction. Defaults to LEFT if no direction has been set, then resets per-group outDegree and per-node startPos before running the configured algorithm.

finish :: forall a. OneDState a -> OneDState a

Mark the compactor as finished and restore the canonical LEFT orientation so any hitbox mirrors / transposes are undone.

changeDirection :: forall a. Direction -> OneDState a -> OneDState a

Switch compaction direction. Mirrors / transposes hitboxes as needed and either recalculates the constraints or reverses them (for the LEFT<->RIGHT and UP<->DOWN flips).

calculateGroupOffsets :: forall a. OneDState a -> OneDState a

Public re-export of calculateGroupOffsetsGraph operating on the full state.

forceConstraintsRecalculation :: forall a. OneDState a -> OneDState a

Run the constraint calculation again without changing direction.

isNodeLocked :: forall a. CNode a -> Direction -> OneDState a -> Boolean

isGroupLocked :: forall a. CGroupId -> Direction -> OneDState a -> Boolean