MultiWaySyntenyDisplay

Auto-generated from the @jbrowse/mobx-state-tree model in the source — see the developer guide for concepts. Provided by the linear-comparative-view plugin. View source.

Draws a multi-genome ortholog track as one lane per assembly inside a linear genome view, with ribbons joining each gene's placements between adjacent lanes.

The configuration slots for this model are documented on its config schema page.

Each section ends with the members a composed model contributes, linked to the page that documents them.

Properties

Member	Description
type `type: types.literal('MultiWaySyntenyDisplay')`
configuration `configuration: ConfigurationReference(configSchema)`
hiddenLaneNames `hiddenLaneNames: types.frozen<readonly string[] \| undefined>()`	the lanes a reader hid from the lane menu, by assembly name; the lanes chosen are `rows.kept`
frozenLanes `frozenLanes: types.frozen<FrozenLanes \| undefined>()`
lanePins `lanePins: types.frozen<readonly LanePin[] \| undefined>()`	the reader's pins: a lane's contig, or a block on it, and its orientation on a contig against the anchor it was set under

2 inherited properties from 2 models

From ParkedColorMixin: parkedColors

From BaseDisplay: id

Volatiles

Member	Description
fetchedFeatures `{ anchor: string; features: Feature[]; ops: AlignmentOpsById; lanes?: string[] \| undefined; deletions: readonly WindowDeletion[]; } \| undefined`
seenAttributeRanges `Record<string, AttributeRange>`
laneGenes `LaneFetchState<HeldLaneGenes>`
laneDescriptions `Map<string, AssemblyDescription>`
describedLanes `Set<string>`
lanesBeingDescribed `Set<string>`
releasedLanes `Set<string>`
laneLinks `LaneFetchState<HeldLaneLinks>`	per adjacent mate-lane pair, at the lanes' own coordinates
laneGroups `LaneFetchState<HeldLaneGroups>`	per mate lane, a gene table's rows on the lane's own window
laneLayerData `LaneFetchState<HeldLaneLayer>`
hoverTarget `HoverTarget \| undefined`
clickedTarget `RibbonRef \| undefined`
laneDecisions `Map<string, LaneDecision \| undefined>`
renderOriginPx `number`	the view's `offsetPx` the stack was last laid out against
laneTransitions `Map<string, LaneTransition>`
laneMotionClockMs `number`
heldLaneOrder `HeldLaneOrder \| undefined`	the structure order graph haplotype lanes stack by while nothing pins one, with the window and lane selection it was worked out on
laneMotionHalfway `ReadonlySet<string>`
laneDragPx `ReadonlyMap<string, number>`

24 inherited volatiles from 7 models

From LodTierInfoMixin: adapterHeaderRead

From LegendMixin: dismissedLegendSections

From KeyedFetchMixin: loadedFetchKey

From FetchMixin: activeSignal, fetchGeneration, reloadCounter, statusWindow, error, statusMessage, statusProgress, fetchCanceled, fetchRotation

From RenderLifecycleMixin: canvasDrawn, paintCount, currentRenderingBackend, renderTick, autorunsInstalled, renderError, offScreen

From RegionTooLargeMixin: forceLoadTrack, byteEstimate, gateMeasuredViewportKey

From TrackHeightMixin: scrollTop, hostHeight

Getters

Member	Description
declaredLanes `DeclaredLane[] \| undefined`
starAnchor `string \| undefined`
lgv `LinearGenomeView`
features `Feature[] \| undefined`	undefined while the view's anchor differs from the fetch's
featureOps `AlignmentOpsById`
windowDeletions `readonly WindowDeletion[]`	the deletions a record states across the whole fetched window, for a lane the window shows none of
hoveredGroupKey `string \| undefined`
resolution `LodMode`
ribbonColor `string`
laneChoice `readonly string[] \| undefined`	`rows.kept` as a choice: undefined while it names no lane
ribbonColorField `string \| undefined`
ribbonColorDomain `string[]`
ribbonPaint `SyntenyColorPaint`
hideUnlabelled `boolean`
interpolate `"bump" \| "linear"`	The curve every ribbon side takes, `ribbons.mark.interpolate`.
showLaneTicks `boolean`
splitStrands `boolean`
showGeneLabels `boolean`
geneTextField `string`	a field, a jexl expression, or empty for the name-else-ID default
inlineLaneNames `boolean`
geneLabelPx `number`
laneLayerHeights `number[]`
layerPx `number`
geneColorSettings `GeneColorSettings`
geneColorEncoding `string \| FieldColorEncoding \| undefined`
geneColorField `string \| undefined`	undefined while `encoding.color.value` paints
geneSolidColor `string \| undefined`	the constant `encoding.color.value` holds, undefined for none or a `jexl:` one
hasLodCapableAdapter `boolean`
lodTier `LodTier`	read off the settled zoom, so a passing gesture refetches nothing
liveLodTier `LodTier`
viewSignature `string \| undefined`
groups `MultiWayGroup[]`
laneIndels `{ openings: (assemblyName: string, refName: string) => readonly LaneOpening[]; changes: (assemblyName: string, refName: string) => readonly LaneChange[]; }`	each lane's holes and stated changes against the anchor, read off every fetched group rather than the viewport's, so one appears once both its pieces arrive and not as the second scrolls in
laneOpenings `(assemblyName: string, refName: string) => readonly LaneOpening[]`	each lane's holes, one per deletion `laneIndels` opens
laneChanges `(assemblyName: string, refName: string) => readonly LaneChange[]`	each lane's deletions, insertions and inversions as its records state them, for the header
ribbonColorAttributes `string[]`
ribbonAttributeRanges `Record<string, AttributeRange>`
geneColorSlots `HeldSlots \| undefined`	The slots an ordinal gene color deals its values into.
dealtGeneColorSlots `HeldSlots \| undefined`	`geneColorSlots` once every value the boxes and lane genes show is dealt as one batch, so the two take colors apart whichever lands first
boxColors `GeneColors`
laneGeneColors `ReadonlyMap<string, GeneColors>`
selectedFeatureId `string \| undefined`
anchorAssemblyName `string`
adapterCapabilities `readonly string[]`
adapterDeclaresLanes `boolean`
adapterPairsOnAnchor `boolean`
adapterBatchesLanePairs `boolean`	the adapter answers a window's `lanePairs` in one call
sessionTracksById `ReadonlyMap<string, AnyTrackConfig>`	every session track, connections' included
rowsVsAnchor `boolean`	a source that names an anchor and answers no lane pairs states each lane against the anchor alone, so each gutter draws its lower lane against the anchor
laneFetchKinds `{ lanePairs: boolean; laneRows: boolean; }`	the fetches beyond the anchor's that its records call for
domain `string[]`	`rows.sort` in each placed lane's own spelling, so an order a config wrote with an alias merges with one a drag writes
configuredLanes `string[]`	the track's assemblies beside the anchor for a source that declares the lanes itself, empty for every other source
laneSelection `readonly string[] \| undefined`	undefined means every lane, and a hidden lane stays in force
hiddenLanes `readonly string[]`
fetchLaneSelection `string[] \| undefined`	undefined unless the adapter declares its lanes, and lists each held genome under every name the session knows it by
anchorAssembly `Assembly \| undefined`
anchorLocString `string`
declaredLaneLabels `Map<string, string>`	keyed by `laneKey`
rowLabels `Map<string, string>`	`rows.labels`, keyed by `laneKey`
laneUniverse `LaneChoice[]`	the anchor is never a lane
rowAssemblies `string[]`	a paralogy mate on the anchor assembly draws on its axis, not as a row
pinsInForce `LanePin[]`	the pins that hold under the anchor, each naming its lane as `rowAssemblies` spells it
laneStructureOrder `string[]`	the drawn lanes chained by their deletions and insertions against the anchor, for "Order lanes by structure"; empty for a gene table
rowOfLane `ReadonlyMap<string, string>`	each drawn lane's row name by its canonical name, for data keyed by the records' spelling of a lane
lanesToDescribe `string[]`
laneAssemblyConfs `Map<string, Record<string, unknown>>`
canReanchor `boolean`
visibleBpSpan `number`	the bp the canvas spans: a lane's bpPerPx is this times its rung over `canvasWidthPx`, so the two read one width or every lane but the anchor is scaled against a box it doesn't fill
visibleGroupWindows `{ group: MultiWayGroup; start: number; end: number; }[]`	each with the hull, in anchor bp, of the settled blocks it meets
visibleGroups `MultiWayGroup[]`	uncut at the viewport edge, cut only at a displayed region's end
fitGroups `MultiWayGroup[]`	the visible groups cut to the viewport, which each lane's frame fits
tickIntervalBp `number`
stackGeometry `LaneGeometry`	every lane's band, the anchor's first
scrollContentHeight `number`
laneGeneTracks `Map<string, AnyTrackConfig>`	keyed by each lane's own spelling, not by `laneKey`
laneGeneTrackEntries `Map<string, TrackConfigEntry>`	each lane's gene track config as a hydrated track reads it, so a frozen entry's `displayDefaults` and retired display types count
laneGeneAdapters `Map<string, Record<string, unknown>>`
scrollViewportHeight `number`
dragOffsetPx `number`	the px the view has scrolled since the stack was laid out
anchorReversed `boolean`
anchorStage `AnchorStage`	the live view, laid out against `renderOriginPx`, as the lanes draw against it
anchorSpans `Map<string, Span>`	the anchor placements in stack px, relative to `renderOriginPx`
rowFrames `Map<string, RowFrame \| undefined>`
lanesFrozen `boolean`	true only while the view, on the anchor the lanes froze on, still shows part of the window they froze on
frozenDecisions `ReadonlyMap<string, LaneDecision>`	empty unless `lanesFrozen`
anchorFetchRegions `FetchRegion[]`
laneWindows `ReadonlyMap<string, LaneWindow>`	what each lane's dependent fetches ask for: the anchor's merged blocks, and each held, framed lane's window
lanePairs `LanePair[]`
anchorlessGroups `PlacedGroup[]`
laneGenesFetchSpecs `LaneGenesFetchSpec[]`
laneGroupsFetchSpecs `LaneGroupsFetchSpec[]`	a gene table read on each mate lane's window, for the rows the anchor lacks; a star source indexes its anchor alone, so it has none to give
laneLinksFetchSpecs `LaneLinksFetchSpec[]`	one spec per adjacent mate-lane pair whose gutter is on screen or within a screen of it
laneLayerTemplates `(Record<string, unknown> \| undefined)[]`
laneLayerSources `Map<string, LaneLayerSource>[]`
laneLayerReads `{ specs: LaneLayerFetchSpec[]; pastCap: boolean[]; }`	`pastCap` flags a layer that skipped a lane past `LANE_TEMPLATE_MAX_BP`
laneLayersFetchSpecs `LaneLayerFetchSpec[]`
laneStack `LaneStack`	has no lane genes, so a gene commit re-uploads no ribbon or tick
laneMaps `ReadonlyMap<number, LaneMap>`
laneHeaderRows `LaneHeaderRow[]`
pairLinks `ReadonlyMap<string, LaneLinks>`	the alignments the source answered for each adjacent mate-lane pair, keyed `upper\|lower`; a pair it has not answered draws nothing
loadingGutterYs `number[]`	the centre, in stack px, of each gutter whose lane pair was asked for and has not landed
ribbonGeometry `RibbonGeometry`	in the stack's own px
tickGeometry `TickGeometry`
bandCell `MultiWayCell`
anchorTickXs `number[]`	px of the anchor's ticks across the displayed regions, over the reach the anchor's rule draws
laneCells `{ cells: Map<string, MultiWayCell>; boxNames: Map<string, NamedSpan[]>; geneGroups: Map<string, Map<string, string>>; }`	boxes before glyphs, so an in-order hit test finds a box over a gene
laneGlyphCells `Map<string, MultiWayCell>`
laneBoxNames `Map<string, NamedSpan[]>`
laneGeneGroups `Map<string, Map<string, string>>`	per lane, each drawn gene's group, keyed by feature id
pinnedLabelGroups `ReadonlySet<string>`
geneTextOf `(feature: Feature) => string \| undefined`
geneColorScales `ColorScale[]`	keys every lane, over the settled window, or the anchor lane alone where every lane's values are too many to list
colorScales `ColorScale[]`
legendRight `number`
laneLayerPlacements `LaneLayerPlacement[]`	each payload's region placed in its lane's own frame; a payload whose lane or contig no longer draws is left out
laneLayerDomains `([number, number] \| undefined)[]`	undefined for a layer no drawn lane holds values for yet
laneLayerColors `ColorSource[][]`	where each lane layer's marks take their color from, one per mark, read the way the mark display reads its colors
selectedGlyphHits `GlyphHit[][]`	the selected feature's glyph hits per row, which a pan leaves alone
laneLayerColorScales `(MarkColorScale \| undefined)[][]`	the ramp or threshold each lane layer's bars paint numbers through, one per mark and undefined for a mark colored another way; a ramp's domain covers the values of every drawn lane, as `laneLayerDomains` does for y, so one value takes one color in all of them
laneLayerTitles `{ key: string; text: string; top: number; }[]`
laneLayerCells `{ cells: Map<string, MultiWayCell>; layers: BarLayer[]; }`
namedCells `ReadonlyMap<string, MultiWayCell>`
namedLayers `MultiWayLayer[]`	back to front, bands first to cover the view's gridlines
hoveredFeatureId `number`
clickedFeatureId `number`
hoverInk `HighlightRect[]`
selectionInk `HighlightRect[]`
highlightStyle `HighlightStyle`
groundPalette `JBrowsePalette`
outlineCells `ReadonlyMap<string, MultiWayCell>`
renderCells `ReadonlyMap<number, MultiWayCell>`	keyed by `sharedBackendKey`
renderLayers `ReadonlyMap<number, MultiWayLayer>`	back to front, each outline immediately over the gutter it traces
ribbonRegions `ReadonlyMap<number, SyntenyInstanceData>`	in draw order
ribbonRecords `ReadonlyMap<number, ReadonlyMap<number, Feature>>`	`ribbonGeometry.records` keyed by `sharedBackendKey`
renderState `MultiWayRenderState`
renderBlocks `RenderBlock[]`
ribbonPickState `SyntenyRenderState`
animating `boolean`
laneFetches `{ state: LaneFetchState<HeldLane>; specs: LaneFetchSpec[]; }[]`
awaitingDependentData `boolean`
dataSuperseded `boolean`
hoveredFeature `Feature \| undefined`

67 inherited getters from 11 models

From LodTierInfoMixin: adapterHeader, lodTierInfo

From ColorWritesMixin: writtenColor

From ParkedColorMixin: parkedColor

From LegendMixin: showLegend, legendSpec, hasLegendKey

From GlobalFetchMixin: host, canvasWidthPx, staticBlockSignature, dynamicBlockSignature, viewportEmpty, canRender, rendersCanvas, paintInert, svgReady, displayPhase

From KeyedFetchMixin: currentFetchKey, dataCurrent

From FetchMixin: isLoading, isLoadingOrCanceled, fetchInert, awaitingPrerequisite, settingsFetchInputs

From RenderLifecycleMixin: paintSuperseded, painted

From RegionTooLargeMixin: gateEnabled, byteGateAdapterConfig, configuredFetchSizeLimit, densityTooLarge, byteGateAdapterPath, adapterFetchSizeLimit, configForceLoad, gateViewportSpanBp, gateViewport, aboveForceLoadFloor, gateExempt, estimatedFetchBytes, gateMeasurementStale, gateByteLimit, gateActive, densityGateActive, tooLargeStatus, regionTooLarge, regionTooLargeReason, zoomCanReleaseGate, gateSkipsMeasuredViewport

From TrackHeightMixin: configuredHeight, allottedHeight, height, resizing, scrollableHeight

From BaseDisplay: parentTrack, RenderingComponent, DisplayBlurb, adapterConfig, isMinimized, featureNoun, featureWidgetType, liveNotices, plotKeys, plot, configNotices, notices, cornerNotices, plotExamples, configDocsUrl

Methods

Member	Description
laneKey `(assemblyName: string) => string`	the canonical name, so two spellings of one assembly share a key
laneSpellings `(assemblyName: string) => string[]`	`assemblyName` and every alias the session holds it under
namedLaneTracks `(entries: readonly string[], key: string) => AnyTrackConfig[]`	the tracks `entries` names for the lane keyed `key`, best first: plain ids, then `{assembly}` entries, each in entry order
rpcProps `() => { haplotypes: string[] \| undefined; }`	reads only user-controlled state, never a fetch's output, or it loops
holdsAssembly `(assemblyName: string) => boolean`
holdsTemporarily `(assemblyName: string) => boolean`
laneLabel `(assemblyName: string) => string`
anchorStageAt `(originPx: number, bpPerPx: number) => AnchorStage`	the view at `bpPerPx`, laid out against `originPx`, as the lanes decide against it
anchorAbsXAt `(bpPerPx: number) => Map<string, { coord: AnchorCoord; x: number; }>`	each group's viewport-cut centre, in view px at `bpPerPx` before the scroll offset
laneFrameOf `(decision: LaneDecision, assemblyName: string) => RowFrame \| undefined`	undefined once the pivot is off the displayed regions
laneDecisionsAt `({ originPx, bpPerPx, previous, frozen, }: { originPx: number; bpPerPx: number; previous: ReadonlyMap<string, LaneDecision \| undefined>; frozen: ReadonlyMap<string, LaneDecision>; }) => Map<string, LaneDecision \| undefined>`	for the viewport at `originPx` and `bpPerPx`: which group is the pivot and what the hold test counts are judged in it. A lane in `frozen` keeps its frozen decision
bandCellOn `(page: string) => MultiWayCell`
laneGeneLabels `(fontFamily: string \| undefined, pinnedGroups?: ReadonlySet<string>, width?: number) => PlacedLaneLabel[]`	placed in the stack's px
coloredLayersOf `(held: HeldLaneLayer) => EncodedChannels[]`	a held payload's layers, each colored as its mark declares
pickRibbonAt `(x: number, y: number) => SyntenyPickResult \| undefined`	`x` and `y` are container-relative; the topmost ribbon wins
slidableLaneAt `(y: number) => string \| undefined`	`y` is container-relative; undefined unless the lanes are frozen
hitTest `(x: number, y: number) => HoverTarget \| undefined`	`x` and `y` are container-relative
trackMenuItems `() => MenuItem[]`

10 inherited methods from 4 models

From ParkedColorMixin: parkedColorOf

From LegendMixin: colorScalesIn, legendSpecIn

From RegionTooLargeMixin: resolvedByteLimit, gateFetchState

From BaseDisplay: renderingProps, configProblemsOf, liftPlot, plotProblems, plotWrites

Actions

Member	Description
setFeatures `(features: Feature[], anchor?: string, lanes?: string[] \| undefined, ops?: AlignmentOpsById, deletions?: readonly WindowDeletion[]) => void`
beginDescribingLanes `(names: string[]) => void`
endDescribingLanes `(names: string[], descriptions: Record<string, AssemblyDescription>) => void`
forgetUndescribedLanes `() => void`
setLaneGenes `(fetched: ReadonlyMap<string, HeldLaneGenes>, specs: LaneFetchSpec[], anchor: string) => void`	`specs` holds every lane the run was asked for, and `anchor` the anchor the specs were built under
setLaneLayerData `(fetched: ReadonlyMap<string, HeldLaneLayer>, specs: LaneFetchSpec[], anchor: string) => void`
setLaneLinks `(fetched: ReadonlyMap<string, HeldLaneLinks>, specs: LaneFetchSpec[], anchor: string) => void`
setLaneGroups `(fetched: ReadonlyMap<string, HeldLaneGroups>, specs: LaneFetchSpec[], anchor: string) => void`
setSelectedLanes `(names: readonly string[] \| undefined) => void`	writes `rows.kept`; undefined restores `configuredLanes`, or every lane
setRibbonColorField `(field: string \| undefined) => void`
setDomain `(domain: string[]) => void`	takes the whole pinned order, empty meaning densest-first; merge a partial one with `mergeDomain` first
setRibbonColorDomain `(domain: string[]) => void`
setHideUnlabelled `(flag: boolean) => void`
setInterpolate `(interpolate: "bump" \| "linear") => void`
setShowLaneTicks `(flag: boolean) => void`
setSplitStrands `(flag: boolean) => void`
setInlineLaneNames `(flag: boolean) => void`
setShowGeneLabels `(flag: boolean) => void`
setGeneTextField `(field: string) => void`
setResolution `(mode: LodMode) => void`
holdLaneOrder `(regions: FetchRegion[]) => void`	runs when the anchor fetch for `regions` completes. Haplotype lanes read off a graph stack by structure while no order is pinned, worked out again only once a fetch leaves the window it was worked out on or the lane selection changes, so panning never reshuffles the stack
chooseLanes `(names: string[]) => void`
hideLane `(assemblyName: string) => void`
showLane `(assemblyName: string) => void`
showHiddenLanes `() => void`
openLaneSelection `() => void`
setLanesFrozen `(flag: boolean) => void`
realignLane `(assemblyName: string) => void`
nudgeLane `(assemblyName: string, dxPx: number) => void`	slides a mate lane `dxPx` screen px, only while the lanes are frozen
setLaneDragPx `(assemblyName: string, dxPx: number) => void`
endLaneDrag `(assemblyName: string) => void`
pinLane `(assemblyName: string, pin: Omit<LanePlacePin, "lane"> \| undefined) => void`	a contig, or a block on it; `undefined` lets the lane choose again
flipLane `(assemblyName: string) => void`
unpinLaneFlip `(assemblyName: string) => void`
setLaneFrames `(originPx: number, decisions: Map<string, LaneDecision \| undefined>) => void`	`originPx` is the view offset the lanes are laid out against; the same origin and decisions write nothing
restampOrigin `() => void`	lays the lanes out against where the view is now; a lane's position does not depend on the origin, only what the stack clips to does
advanceAnimation `(nowMs: number) => void`
endAnimation `() => void`
setRibbonColorValue `(value: string \| undefined) => void`	Paint every ribbon `value`, undefined returning to the strand colors.
openRibbonSolidColorDialog `() => void`	the picker the ribbon Color by's Solid color... opens
openSolidColorDialog `() => void`	the picker the gene Color by's Solid color... opens
selectFeature `(feature: Feature) => void`
openInNewView `(assemblyName: string, loc: string) => void`
reanchor `(assemblyName: string, loc: string) => void`
setHoverTarget `(target: HoverTarget \| undefined) => void`
startRenderingBackend `(backend: MultiWayRenderingBackend) => void`
setPointer `(state?: MouseState \| undefined) => void`
clearHoveredFeature `() => void`
selectHovered `() => void`
renderSvg `(opts?: ExportSvgDisplayOptions \| undefined) => Promise<ReactNode>`