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.

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 carries. Written on the track config's own 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 carries 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 quantitative display: one plot per rendering, drawn over one source or over many. rows: 'source' gives each source a row of its own, with the clustering sidebar, row labels and separators beside them, and holds the arrangement a reader gives them; unset, every source shares one plot box.

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)`

4 inherited properties from 2 models

From BaseDisplay: id

From TreeSidebarMixin: runClustering, clusterRegion, sortRowsBy

Volatiles

29 inherited volatiles from 11 models

From BaseDisplay: error, statusMessage, statusProgress

From TrackHeightMixin: scrollTop, hostHeight

From MultiRegionDisplayMixin: loadedRegions

From RegionTooLargeMixin: forceLoadTrack, byteEstimate, gateMeasuredViewportKey

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

From FetchMixin: activeSignal, fetchGeneration, reloadCounter, statusWindow, fetchCanceled, fetchRotation

From ScoreScaleMixin: unclippedQuantile

From StoredHoverMixin: storedHoveredFeature

From LegendMixin: dismissedLegendSections

From TreeSidebarMixin: hoveredTreeNode, treeCanvas, mouseoverCanvas

From ContextMenuMixin: contextMenuInfo

Getters

Member	Description
isDensityMode `boolean`
colorSetting `ColorSetting`	The `color` object 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 takes a row of its own, which is the whole of what `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; markColor: MarkColorSource; }`	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 color is spent on the score: density always, where the white fade counts, and bars or points under a declared `linear` color. Lines part in two colors even then.
notices `string[]`	What `colorSetting`'s and `scales.y`'s slots say together that they cannot draw as written, and a gradient a line cannot paint, for the corner notice.
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 (`markColorOf`), which the encoder and the tooltip read. Where the palette deals the shared panel and some row took a color, a row left without one paints `UNCOLORED_ROW` grey rather than the plot color, which reads as one of the dealt.
scoreRuleValues `number[]`	Overrides WiggleCommonMixin's empty base, so the axis reaches a rule of `scales.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 carries 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.
scoreRampApplies `boolean`	`scoreRampApplies` over the colors the marks paint in
scoreRampReplacesAxis `boolean`	A density row has no y scale, so under the one ramp the ramp is the key and carries 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.
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 each in their own color 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 carries 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 says nothing a reader did not ask for. Density draws none either: there the ramp is the key.
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`

163 inherited getters from 13 models

From BaseDisplay: parentTrack, RenderingComponent, DisplayBlurb, adapterConfig, isMinimized, hoveredFeature, featureNoun, featureWidgetType, plotKeys, plot, plotExamples, configDocsUrl

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

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 RegionTooLargeMixin: gateEnabled, byteGateAdapterConfig, configuredFetchSizeLimit, densityTooLarge, byteGateAdapterPath, adapterFetchSizeLimit, configForceLoad, gateViewportSpanBp, gateViewport, aboveForceLoadFloor, gateExempt, estimatedFetchBytes, gateMeasurementStale, gateByteLimit, gateActive, densityGateActive, tooLargeStatus, regionTooLarge, regionTooLargeReason, zoomCanReleaseGate, gateSkipsMeasuredViewport

From RenderLifecycleMixin: painted

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

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

From YFieldConfigMixin: yField

From WiggleScoreConfigMixin: axisReachesZero

From ScoreScaleMixin: scaleType, scaleZero, domainQuantile, clipQuantile, symlogConstant, manualMinScore, manualMaxScore, valueScaleNotices, autoscaleGroup, scaleTitle, grid, minimalTicks, scoreRulesDrawn, scoreRules

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

From LegendMixin: showLegend, legendTop, legendRight, legendSpec, hasLegendKey

From TreeSidebarMixin: showTree, showBranchLength, showRowLabels, treeAreaWidth, rowDomain, rowLabels, rowTreeProvenance, rowFocus, rowColorSetting, baseRowColor, baseRowDomain, guideTreeNewick, rowAlias, unlistedRowsSort, rowBanding, rowsHeaderHeight, rowFocusLineHeight, rowsTopOffset, guideTree, guideTreeHonoursDomain, rowTree, rowOrder, expandedRows, internalRowFields, rowColorFields, rowBandingNotices, rowPaletteDeals, rowColorDealRows, rowStylingIsCustom, rowColorChoice, rowColorAttribute, dealtRowColors, rowColorAttributesOffered, resolvedRowColors, rowArrangementIsCustom, editableSources, rowColorKeyInputs, rowColorScales, clusterableSources, parsedTree, root, bandedRows, bandedSources, rowBands, sources, treeRoot, rowsContentHeight, hierarchy, spatialIndex, clusterPartition, treelessBandCount, treeHasBranchLengths

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; aggregate: 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; }`	Neither `aggregate` nor `extent` is a fetch key: both pick among arrays the fetch already ships, so a change re-encodes and refetches nothing (WIGGLE_DISPLAY.md, "`aggregate`, `extent`").
gpuProps `() => { sources: { name: string; color?: string \| undefined; }[]; rowLayout: boolean; perSource: boolean; wiggleColor: ResolvedWiggleColor; origin: number; aggregate: 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.
trackMenuItems `() => MenuItem[]`
contextMenuItems `() => MenuItem[]`	Right-click menu, built from the column the click landed on. The position is captured here rather than read inside the onClick, because `closeContextMenu` runs first when an item is clicked.

17 inherited methods from 5 models

From BaseDisplay: renderingProps, liftPlot, plotProblems, plotWrites

From MultiRegionDisplayMixin: regionHasData, isCacheValid

From RegionTooLargeMixin: resolvedByteLimit, gateFetchState

From LegendMixin: svgLegendWidth, colorScalesIn, legendSpecIn

From TreeSidebarMixin: expandRows, svgSidebarWidth, rowBand, dealtRowColorsFor, rowColorFor, rowOrderWillDropTree

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, interpolate, rowLayout, }: { mark: "bar" \| "line" \| "point" \| "span"; interpolate?: "linear" \| "step" \| undefined; 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.domain`, 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` carries one across a reload. Resolving that region and refusing the two cases where a sort would only cost a `rows.domain` 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>`