LinearWiggleDisplay

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

The quantitative display: one plot per rendering, drawn over one source or over many. rows: 'source' puts each source in a separate row, with the clustering sidebar, row labels and separators beside them, and holds the arrangement a reader sets; unset, every source shares one plot box.

Example usage

A complete QuantitativeTrack config to paste into tracks:

{
  type: 'QuantitativeTrack',
  trackId: 'coverage',
  name: 'Coverage',
  assemblyNames: ['hg38'],
  adapter: { type: 'BigWigAdapter', uri: 'https://example.com/coverage.bw' },
  displays: [
    {
      type: 'LinearWiggleDisplay',
      displayId: 'coverage-LinearWiggleDisplay',
      height: 100,
    },
  ],
}

The two row-ordering triggers are display properties, not config slots, so they go on the display node in a session — defaultSession here, and the same shape a session=spec- link uses. Written in the track config's displays entry they would be dropped as unknown slots.

runClustering is a transient declarative launch spec, the same idea as LinearGenomeView's init: it runs the real "Cluster columns" RPC once automatically (no dialog) as soon as subtrack data is available, then clears itself so a saved session never re-triggers it. sortRowsBy is the other one, and the declarative form of the right-click "Sort rows by score here" — where clustering orders rows by the whole region in view, this ranks them by the score each has at one base, so a cohort can open already ranked at a candidate locus with the surrounding context still on screen. Use one or the other; whichever applies last owns the row order.

defaultSession: {
  name: 'Copy number at CCL3L1',
  views: [
    {
      type: 'LinearGenomeView',
      assembly: 'hg38',
      loc: 'chr17:36,080,000-36,270,000',
      tracks: [
        {
          trackId: 'pur_copynumber_1000g',
          type: 'LinearWiggleDisplay',
          sortRowsBy: { refName: 'chr17', pos: 36180000 },
        },
      ],
    },
  ],
}

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('LinearWiggleDisplay')`
configuration `configuration: ConfigurationReference(configSchema)`

5 inherited properties from 3 models

From TreeSidebarMixin: runClustering, clusterRegion, sortRowsBy

From ParkedColorMixin: parkedColors

From BaseDisplay: id

Volatiles

29 inherited volatiles from 10 models

From ContextMenuMixin: contextMenuInfo

From TreeSidebarMixin: hoveredTreeNode, treeCanvas, mouseoverCanvas

From LegendMixin: dismissedLegendSections

From StoredHoverMixin: storedHoveredFeature

From ScoreScaleMixin: unclippedFenceQuantile

From MultiRegionDisplayMixin: loadedRegions

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
isDensityMode `boolean`
colorSetting `ColorSetting`	The `encoding.color` channel as written, `value` undefined while nothing names a color and the layout decides (`effectiveColor`).
rows `RowsSetting \| undefined`	The `rows` object's field and order, or undefined while every source shares one plot. `source` is the only field the config admits here.
isRowLayout `boolean`	Whether each source is drawn in a separate row, which is all that `rows` decides here: the tree sidebar, the row labels, the separators, the clustering menu and the row-order sort all hang off it.
isOverlay `boolean`	Every source in one plot box. The complement of the row layout, named for what is drawn rather than for the setting that is off.
discoveredRows `Source[]`	`TreeSidebarMixin`'s hook: the adapter's sources, discovered from the loaded regions in adapter order.
sharesPanel `boolean`	`TreeSidebarMixin`'s hook: whether several plots share one box, where only color tells the sources apart. A lone plot has nothing to be told apart from and is the pos/neg picture a quantitative track has always drawn.
rowNoun `string`	`TreeSidebarMixin`'s hook: the row color key over a shared panel lists subtracks.
effectiveColor `ColorSetting`	The color actually painted: what the config says, else the pos/neg pair about the `origin`.
colorEncoding `string \| FieldColorEncoding \| undefined`	`effectiveColor` as it paints, through the one resolver every display's color object goes through.
wiggleColor `ResolvedWiggleColor`	`colorEncoding` as the encoder and both backends take it.
markColoring `{ gradientPaints: boolean; rowColorPaintsMarks: boolean; }`	How the plot spends color (`wiggleMarkColoring`): whether the score gradient paints, whether row colors do, and which of a source's colors its marks take.
scoreGradientPaints `boolean`	Whether a gradient spends color on the score: any mark under a `linear` color, which a heatmap draws its unset pair as.
liveNotices `string[]`	What the loaded sources said they could not serve.
legendColor `string`	The one color the circular view's key names this track by (`CircularLegendSource`), which a ring of this display answers where it draws no ramp. The positive side, which is the whole plot wherever nothing parts.
rowColorPaintsMarks `boolean`	`TreeSidebarMixin`'s hook: a subtrack's color paints its plot while nothing else colors it: no score gradient, and no declared `color`.
markSources `{ name: string; color?: string \| undefined; }[]`	Each source and the color its marks paint in (`wiggleMarkSources`), which the encoder and the tooltip read.
scoreRuleValues `number[]`	Overrides WiggleCommonMixin's empty base, so the axis reaches a rule of `encoding.y.rules` even where the visible data does not. Empty in density, where no rule is drawn: the domain is spent on the color ramp there, so widening it stretches the ramp over a range nothing on screen reaches.
numSources `number`
autoscaleSourceNames `Set<string>`
effectiveRowHeight `number`	Resolved per-row height. This display is always fit-to-display-height — there is no pinned-height setting and so no `rowHeight` sentinel to resolve — but it uses the same name every row display exposes its resolved height under (see agent-docs/reference/ROW_HEIGHT_AND_FIT), which is also what tree-sidebar's `TreeDrawingModel` reads.
rowsHeight `number`	The height under `rowsTopOffset` the rows, or the one plot, fill.
numRows `number`	Rows actually drawn: overlay collapses every source onto one shared plot. Read by the render state and by everything that repeats itself per row (scalebars, cross hatches), so they can't disagree about how many rows exist.
plotGeometry `{ yTop: number; plotHeight: number; numRows: number; tickHeight: number; }`	One row takes the scalebar-label gutter at top and bottom, so its end labels are never clipped; a stack of rows gives that up, because the axis is drawn per row and maximum density is the point. `ticks`, the render height, the on-screen canvas and the SVG clip all read this, so a tick stays on the data it labels.
scoreRampReplacesAxis `boolean`	A density row has no y scale, so under the one ramp the ramp is the key and shows the domain; bars and points keep their axis beside it.
scoreColorScale `RampScale \| undefined`	The score ramp as a color scale, or undefined when there is no single ramp to describe or no domain yet. `LegendMixin`'s `colorScales` lists it, so the on-screen key and the export draw one bar. The bar is drawn from the resolved color — the same cached LUT bytes both renderers color through — so a declared ramp's key is what the track paints.
renderState `WiggleGPURenderState`
drawsRowLabels `boolean`	Overlay draws every source on one row, so it names none.
autoClusterReady `boolean`	`TreeSidebarMixin`'s hook. On a log or symlog axis it also waits for the domain the matrix places scores through, which lags the data until the view settles; with no scores loaded there is none to wait for.
sidebarPanel `SvgSidebarProps`	The dendrogram and row labels at the display's left, which the axis sits past on screen and the export parks left of the figure.
valueScales `ValueScale[]`	The one scale every row shares, ruling a band per row stacked down the track, past the dendrogram where one is shown. Density rows, one color per row, map the scale to color rather than to y, so they rule no band and the chrome captions the domain instead; under the one ramp the ramp is the key and shows the domain itself.
showRowSeparators `boolean`
thresholdColorScale `ColorScale \| undefined`	The key a threshold with declared cuts draws: one row per interval, labelled by the span it covers. A threshold cutting at the `origin` draws none, because the axis already shows where the origin is and a `< 0` / `≥ 0` key on every bigWig adds nothing a reader asked for. A heatmap has no axis, so its threshold keys the origin's cut too.
prefersOffset `boolean`	Offset the track label above the plot so the left y-axis stays pinned to the content edge instead of dodging right of the label, and so a stack of rows is not hidden behind it. One density plot draws no left axis (just a top score legend), so there let the label overlap.
colorScales `ColorScale[]`	`LegendMixin`'s hook: the score ramp or threshold key, then the row color key, except in a shared panel painting the score gradient, where no row color shows.
drawsTree `boolean`	`TreeSidebarMixin`'s hook: off in overlay, which collapses every source onto one row, so a tree spreading its leaves over the full height would align to nothing. A subtree filter set in a row mode still applies and is still clearable from the track menu and WiggleHint.
svgSidebar `SvgSidebarProps`

165 inherited getters from 15 models

From TreeSidebarMixin: showTree, showBranchLength, showRowLabels, treeAreaWidth, rowSort, rowLabels, rowTreeProvenance, rowFocus, rowColorSetting, baseRowColorSetting, baseRowSort, guideTreeNewick, rowAlias, unlistedRowsSort, rowBanding, rowsHeaderHeight, rowFocusLineHeight, rowsTopOffset, guideTree, guideTreeHonoursDomain, rowTree, rowOrder, expandedRows, internalRowFields, rowColorFields, rowBandingNotices, rowPaletteDeals, rowColorDealRows, rowColorIsCustom, rowColorChoice, rowColorField, dealtValueColors, rowColorFieldsOffered, resolvedRowColors, rowArrangementIsCustom, editableSources, rowColorKeyInputs, rowColorScales, clusterableSources, parsedTree, rotatableRowTree, root, bandedRows, bandedSources, rowBands, sources, treeRoot, awaitingDependentData, rowsContentHeight, hierarchy, spatialIndex, clusterPartition, treelessBandCount, treeHasBranchLengths

From ParkedColorMixin: parkedColor

From LegendMixin: showLegend, legendRight, legendSpec, hasLegendKey

From StoredHoverMixin: hoveredFeature

From WiggleCommonMixin: resolution, rpcDataMap, origin, lineWidth, size, maxGapMultiple, extent, renderingType, hasResolution, effectiveExtent, tooltipShowsMinMax, autoscaleRange, domain, defaultScoreDomain

From YFieldConfigMixin: yField, summaryField

From WiggleScoreConfigMixin: axisReachesZero

From ScoreScaleMixin: scaleType, scaleZero, fenceQuantile, clipFenceQuantile, symlogConstant, manualMinScore, manualMaxScore, autoscaleGroup, scaleTitle, grid, scoreRulesDrawn, scoreRules

From ScoreAxisMixin: autoscaledDomain, minScoreBound, maxScoreBound, hasManualScoreBounds, axes

From MultiRegionDisplayMixin: host, canvasWidthPx, settledSubPixelBinBp, canRender, rendersCanvas, trackVisibleRegions, viewportWithinLoadedData, viewportEmpty, fetchSuspended, layoutReady, dataSuperseded, renderBlocks, fetchInputs, regionPayloads, hasRegionData, staleSettingsDrawn, dataCurrent, loadedAssembly, phaseViewportCurrent, svgReady, paintInert, paintSuperseded, displayPhase

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

From RenderLifecycleMixin: 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, scrollContentHeight, scrollViewportHeight, scrollableHeight

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

Methods

Member	Description
sharedRpcProps `() => { resolution: number; yField: string; }`	The fetch cache keys, spread into the display's own `rpcProps()`. The color settings are not among them: every mode partitions by sign on the main thread, so moving the pivot re-encodes and refetches nothing. Named apart from `rpcProps` rather than overridden through it: MST intersects what each `.views()` layer returns, so two same-named methods resolve to the first one at the type level however the runtime member behaves.
sharedGpuProps `() => { wiggleColor: ResolvedWiggleColor; origin: number; summaryField: string; effectiveExtent: string; renderingType: string; maxGapMultiple: number; }`	The encoder inputs — everything but the row list and the row layout. Spread into the display's `gpuProps()`; see `sharedRpcProps` for why it isn't an override.
rpcProps `() => { resolution: number; yField: string; }`	`y` is a fetch key as written, so picking another stored summary refetches arrays the worker already shipped; `extent` is not (WIGGLE_DISPLAY.md, "`y`, `extent`").
gpuProps `() => { sources: { name: string; color?: string \| undefined; }[]; rowLayout: boolean; perSource: boolean; wiggleColor: ResolvedWiggleColor; origin: number; summaryField: string; effectiveExtent: string; renderingType: string; maxGapMultiple: number; }`	The row list is this display's own: the encoder places each payload source by its position here, so a filter or a reorder re-uploads bytes already in hand. The color rides here and not in `rpcProps`: the worker ships one set of score arrays and the main thread colors each instance by its side of the cut, so a new color re-encodes and refetches nothing.
configProblemsOf `(conf: AnyConfigurationModel) => string[]`	The schema's rules, then what the plot cannot paint as written: threshold cuts past eight, and a gradient on a line.
trackMenuItems `() => MenuItem[]`
contextMenuItems `() => MenuItem[]`	Right-click menu, built from the column under the click. The position is captured here rather than read inside the onClick, because `closeContextMenu` runs first when an item is clicked.

19 inherited methods from 6 models

From TreeSidebarMixin: expandRows, svgSidebarWidth, rowBand, rowColorDeclaredValues, dealtValueColorsFor, rowColorFor, orderDropsRowTree, rowOrderWillDropTree

From ParkedColorMixin: parkedColorOf

From LegendMixin: colorScalesIn, legendSpecIn

From MultiRegionDisplayMixin: regionHasData, isCacheValid

From RegionTooLargeMixin: resolvedByteLimit, gateFetchState

From BaseDisplay: renderingProps, liftPlot, plotProblems, plotWrites

Actions

Member	Description
startRenderingBackend `(backend: WiggleRenderingBackend) => void`
setShowRowSeparators `(arg: boolean) => void`
setRowLayout `(on: boolean) => void`	The layout half of a Plot type leaf — `Multi-row` or `Overlapping`, each holding the five plot names. Writes the field alone, so the arrangement survives a trip through the shared plot and comes back with the rows.
setPlot `({ mark, rowLayout, }: { mark: WiggleMarkObject; rowLayout: boolean; }) => void`	A Plot type leaf whole, so the regions encode once and never as the new plot in the old layout.
openPlotDialog `(seed?: Plot \| undefined) => void`	The arrangement dialog's "Edit plot..." button: the color object and the rows beside it as text, the escape for a ramp, several cut points or a typed row order, none of which the dialog's own controls offer.
sortRowsByScoreAt `(refName: string, pos: number) => boolean`	Rank the rows by each source's score at one genomic base. Reads the region data already in hand — no refetch, no RPC — and writes the order through `rows.sort`, the same channel clustering and the arrangement dialog write, so "Reset row order" undoes all three. Named by coordinate rather than by loaded-region index because both entry points are: the right-click hit resolves to one, and a session's `sortRowsBy` holds one across a reload. Resolving that region and refusing the two cases where a sort would only cost a `rows.sort` write are `sortRowsAtColumn`'s, shared with the multi-row feature display's twin, and so is the returned "did it sort" the declarative entry point reads to decide whether to keep its trigger for a later fetch.
fetchNeeded `(needed: IndexedRegion[]) => Promise<void>`
renderSvg `(opts?: ExportSvgDisplayOptions \| undefined) => Promise<ReactElement<unknown, string \| JSXElementConstructor<any>> \| Iterable<ReactNode> \| AwaitedReactNode>`