LinearMarkDisplay

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

A display declared in config: a list of marks, each with an encoding from feature fields to channels, drawn in order over one score axis from one worker fetch per region.

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

4 inherited properties from 2 models

From TreeSidebarMixin: runClustering, clusterRegion, sortRowsBy

From BaseDisplay: id

Volatiles

Member	Description
sourceListing `AdapterRead<RowSourceListing \| null> \| undefined`	The latest `MarkGetRowSources` answer, stamped with the adapter config it answers; null where the adapter lists none or the read failed.
plotFields `PlotFields \| undefined`
plotFieldsError `unknown`
plotDefaultChecked `boolean`
plotFieldsPromise `Promise<PlotFields> \| undefined`
plotScanned `Region[]`
detailsRotation `{ begin(): ActiveFetch; cancel: () => void; dispose(): void; }`
plotScanRotation `{ begin(): ActiveFetch; cancel: () => void; dispose(): void; }`

29 inherited volatiles from 10 models

From StoredHoverMixin: storedHoveredFeature

From ContextMenuMixin: contextMenuInfo

From LegendMixin: dismissedLegendSections

From ScoreScaleMixin: unclippedFenceQuantile

From TreeSidebarMixin: hoveredTreeNode, treeCanvas, mouseoverCanvas

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
gateEnabled `boolean`	Opt into the byte gate: `CoreGetEncodedLayers` measures the index before it downloads, so an over-budget region is refused before a feature is read.
conf `LinearMarkDisplayConfig`	the config typed off the concrete schema
prefersOffset `boolean`	the track label sits above the plot so the y-axis stays on the edge
adapterOptions `object \| undefined`	Overridable hook: what every region's fetch hands the adapter beside the region and the zoom, or undefined for nothing. A fetch input, so a change refetches; `resolveAdapterOptions` places it on each region. Manhattan's LD join is one.
joinedPlotFields `JoinedPlotFields`	Overridable hook: the fields `adapterOptions` has the adapter write onto a feature, which Edit plot offers beside the ones a scan of the file found. Manhattan's LD join writes two.
markTypes `("bar" \| "line" \| "link" \| "point" \| "rule" \| "span" \| "text")[]`	The declared marks' types, in draw order.
facet `FacetSetting \| undefined`	The `facet` object as written, or undefined while unfaceted.
groupKeySpace `string`	`HiddenGroupsMixin`'s hook: a section key means nothing outside the facet that issued it, so moving the field drops what was hidden.
markEntries `MarkEntry[]`	Each mark's type and zoom range, what the mark list is built from.
textMarkEntries `TextMarkEntry[]`	Each mark as the text layer places it: the entry with whether it names a `y` and whether its color is written, a constant or a scale. Its own getter so a slot only a label reads never remakes the mark list.
markView `MarkView`	The marks at the view's zoom: whether each draws, inside its `minBpPerPx`..`maxBpPerPx` range where 0 is no bound.
markSizes `number[]`	Each mark's px, a point's `encoding.size` or a stroked mark's `encoding.strokeWidth` number, its type's default where none is written, and 0 for a bar, span or text, which draw none.
markRowProportions `number[]`	Each mark's `mark.height.band`, which a span alone reads.
rowProportion `number \| undefined`	The proportion the Row height dialog shows: the first span's, or undefined where no mark is a span, so the dialog asks for none.
hasLinkMark `boolean`	Whether any mark is a link, whose feet place through the view's regions rather than the block's own range.
pointSize `number`	The size the Point size menu shows: the first point mark's, or the default where no mark is a point.
encodings `MarkEncoding[]`	The declared marks' encodings, as the worker takes them.
sharedSteps `MarkTransformConfig[]`	The steps every mark runs before its own `transform`: the display's, then the facet's.
markStepLists `MarkTransformConfig[][]`	The steps that run before each mark's encode, in order: the display's, the facet's, then the mark's own.
markChannels `StepChannels[]`	The channels each mark's steps fill where its encoding leaves them unwritten.
markColors `ColorSource[]`	Where each mark's color comes from (`markColor.ts`), read from the config alone, so editing a color recolors the loaded regions rather than fetching them again.
facetSteps `TransformStep[]`	The facet's own steps as the worker takes them, run over each section before any mark's; with no field to split on they run over the one section there is, after the display's own steps.
layerRequests `LayerRequest[]`	The worker request, one layer per mark: its encoding and the lanes its type reads. Every mark is sent, the one outside its zoom range included, so the worker encodes a layer the view will not draw: measured at 280 ns a feature, 28 ms per 100,000, for the excluded half of the default multiscale pair (`encodeFeatures.bench.ts`, the pair table), against a parse in the hundreds of milliseconds. An empty slot for it would make the zoom a fetch input and refetch the pair on every crossing, so there is none (ADR-112). Its `auto` bin resolves at the bound it next draws at, so a zoom outside its range refetches nothing.
origin `number`
minWidthPx `number`
configuredFilters `() => string[]`	The `jexl:` expressions the `filter` list holds.
filterSteps `TransformStep[]`	The `filter` list as the worker's steps: each expression its own step, and the field tests one step of predicates.
baseFilters `() => string[]`	The expressions the track's config declares, which "Clear all filters" returns to.
rowsField `string`	`rows.field` as written: the field each value of which takes a row.
drawsRows `boolean`	Whether the display draws one row per value: a `rows` field and no `facet`, which draws in its place until bands of rows land.
splitField `string \| undefined`	The field the worker splits the features on: the facet's, else the rows'. One split serves both, so `rows` sends it as `facet`.
rowColorFields `readonly string[]`	`TreeSidebarMixin`'s hook: none, since a row is a value of the rows field and has no attributes.
featurePayloads `ReadonlyMap<number, MarkRegionData>`	The layers as they came back, keyed by displayedRegionIndex: the foundation's per-region store.
rowListing `RowSourceListing \| undefined`	The adapter's row listing where it names the rows drawn: its field is `rows.field`, or the key a `flatten` in the shared steps wrote over its field. Undefined for an adapter that lists no rows, for one that lists another field, and until the listing for the current adapter config arrives.
rowListingSettled `boolean`	The current adapter config's row listing has landed or failed, or this display draws no rows from one.
dataSuperseded `boolean`	True until the row listing settles, since the listing adds rows to the ones the features name and reorders them.
adapterSources `ListedRowSource[] \| undefined`	The sources the adapter lists whatever a region holds, a multi-BigWig's files or a MAF's species, in the adapter's order.
guideTreeNewick `string \| undefined`	`TreeSidebarMixin`'s hook: the guide tree the adapter lists over the rows, a MAF's species tree.
discoveredRows `RowSource[]`	`TreeSidebarMixin`'s hook: every row the adapter lists over the rows' field, in its order and with its label and color, so a source with nothing in the loaded regions keeps its row; then the other values the worker split the loaded regions on, in the order the field's sections stack.
rowKeySpace `RowKeySpace`	The key each row holds across every loaded region, assigned at its first arrival and never moved, and the name it is keyed by: under `rows` its section's value, under a facet that value and the row's depth in it. A new split field, or a switch between `rows` and a facet, is a new key space.
rowKeys `RowKeys`	`rowKeySpace`'s keys.
facetLayout `FacetLayout`	The sections drawn over every loaded region, in the domain's order and less the hidden ones, and where each key's rows start; under `rows`, one row per value in the rows' order, which no chip names.
rpcDataMap `ReadonlyMap<number, MarkRegionData>`	The layers the display draws. Under a facet or `rows` every row is a key the row table places, so a chip and the band beside it agree whichever region a span came from, and a reorder, a focus, a hidden section or a deeper section moves no instance. A region is keyed again only when it or the key space moves, which is what the upload re-packs.
rowTable `RowTable \| undefined`	The table every mark places a key through: under `rows` its slot in the rows' order, hidden where the focus leaves it out; under a facet its section's first row plus its depth, hidden with its section. Rebuilt on a reorder, a focus, a hidden or deeper section or a new row, which uploads one small texture and no instance bytes. Undefined while nothing splits the features.
drawnKeys `Uint8Array<ArrayBufferLike> \| undefined`	1 at each key the row table draws, undefined while every key a loaded region has is drawn: a focus or a hidden section moves it, a reorder does not.
scaleDataMap `ReadonlyMap<number, MarkRegionData>`	`rpcDataMap` with each layer's key and extents over the instances the row table draws, its lanes shared: what the legend, the axis and the size scales read, so a row the focus or a hidden section hides leaves them as it leaves the plot.
markList `DisplayMark[]`	The mark list the marks declare — one `defineMark` per config entry with a shape, reading `layers[markIndex]`, off outside its zoom range. A text mark has no shape and is the text layer's, so the list is shorter than `marks` where one is declared. Recomputed only when the entries move, so the component can key its backend factory on it.
hasPointMark `boolean`	Whether a point mark draws at the view's zoom, for the Point size menu.
drawingMarkIndices `number[]`	Every mark drawing at this zoom, in list order: what folds into the y domain and what the plot's inset and row count are read from.
autoscaleRange `[number, number] \| undefined`	[min, max] over the `y` of every mark drawing at this zoom, through the fence `encoding.y.scale` names, widened to every rule the scale declares and to the origin whenever a bar mark draws, or undefined before any valued mark loads
domain `[number, number] \| undefined`
sidebarPanel `SvgSidebarProps \| undefined`	The dendrogram, band strip and row labels at the display's left, which the axis sits past on screen and the export parks left of the figure; none while the rows are not drawn.
valueInsetPx `number`	The px the y scale stands in from both ends of its band, one number for the axis and every mark: room for the largest glyph or half the thickest rule where only those draw, and none beside a bar, whose top edge is its datum and wants the plot box itself. A text mark labels what is drawn and moves nothing.
valueScales `ValueScale[]`	The one y scale the chrome draws the axis from — `encoding.y` resolved: its type, its domain autoscaled where it pins nothing, its title as the caption and its rules. Every mark reads the same pair.
rowCount `number`	bands a span stacks into: the facet's rows, one per row drawn under `rows`, or else the highest `row` any loaded layer has, plus one
nrow `number`	`rowCount`, under the name `useRowVirtualScroll`'s shift+wheel resize divides the plot by.
autoRowHeight `number`	`RowHeightMixin`'s hook: the plot split between the rows.
rowsHeaderHeight `number`	`TreeSidebarMixin`'s hook: the plot's top inset.
plotBox `{ yTop: number; plotHeight: number; }`	The plot canvas's box: the axis inset, less the focus chip's line at its top, so the canvas starts where the rows do.
paintScales `(MarkColorScale \| undefined)[]`	The color scale each mark paints through where its color is quantitative: a ramp over the domain the legend already unioned across the regions, its middle stop a value, or a threshold's cuts and the packed color of each interval. Both ride uniforms, so a pan that widens a domain or an edit that moves a cut uploads no instance bytes and no table.
sizeScales `(LinkSizeScale \| undefined)[]`	Each link mark's size scale: its declared ends, the open ones the least and greatest the regions draw, so a value strokes at one width in every region; undefined for a mark whose size names no field. Over the drawn layers, as the color ramp's domain is, so a hidden section leaves the stroke widths the way it leaves the key.
linkRegions `readonly LinkRegion[]`	The view's displayed regions as a link's feet place through them (`viewRegionTable`). Empty where no mark is a link, reading nothing per frame.
renderState `MarkRenderState`	geometry and scale for the plot canvas, the same box the hit test measures in
highlightedHit `MarkHitInfo \| undefined`	The mark the hover or the open context menu is on, or undefined.
highlightStyle `HighlightStyle`	A ring around a point or a rule, since a wash over 4 px of ink is invisible and every hue may be the color scale's; a shade over anything else.
hoverInk `HighlightRect[]`	The box the hovered instance painted, for the chrome's highlight; the context menu's hit stands in while a menu is open. In the chrome's px, so the plot's inset is added to the canvas box. A ring wraps the ink a fixed margin out, round a point and along a rule's whole length, and floors at 6 px, so a tiny point stays findable.
configProblems `MarkProblem[]`	The rule list over the live config, with each problem's level and slot: jbrowse-img fails an export on an error and warns on the rest.
dataNotices `string[]`	What the adapter said about the loaded regions that the plot cannot show — an index SNP no LD record names — each once, for the corner notice.
displayNotices `string[]`	Overridable hook: notices a display derives from its state and the view, beside the adapter's. Manhattan's reports when the LD index SNP is out of reach of the screen.
sharedKeys `SharedKey[]`	The shape keys whose unlisted values collide on one shape, each with the domain Pin distinct shapes writes.
cornerNotices `string[]`	The config's lines, `dataNotices`, and the keys whose values collide: what the corner's problems notice lists. The skipped count appears in a separate chip.
liveNotices `string[]`	`dataNotices`, the colliding keys, and a mark whose every loaded feature was skipped, which a mistyped field is: a display with any of them still draws, so an agent's settle report lists them for a caller that cannot see the corner.
skippedFeatures `SkippedFeatures`	What the worker left out of the loaded regions — a feature whose position or `y` read as missing or not a number — for the corner notice, naming the field a binned position came from.
legendSections `MarkLegendSection[]`	the color keys for the loaded regions, one per scale the marks drawing at the view's zoom resolve through, each headed with its channel's `title`
colorScales `ColorScale[]`	`LegendMixin`'s hook: the keys as color scales, so the chrome and the export draw the legend off the tables the worker resolved, then the row color key
effectiveRowHeight `number`	The px each row is drawn in, the band every shape gets: `RowHeightMixin`'s under `rows`, pinned or fit. Elsewhere the bands fit the plot whatever `rowHeight` holds, since a facet's rows and have no scroll to reach past the plot's foot.
scrollContentHeight `number`	`TrackHeightMixin`'s hook: the rows under `rows`, taller than the plot wherever a pinned `rowHeight` asks for more than it holds.
scrollViewportHeight `number`	`TrackHeightMixin`'s hook: the plot the rows scroll behind.
valueMarkIndex `number`	The first mark drawing at this zoom that stands at a value: what a row's value at a column is read from, and what clustering compares. -1 where none does, so span rows cluster nothing: they would need multi-row's presence and categorical encodings (`buildMultiRowMatrix`) moved into tree-sidebar.
autoClusterReady `boolean`	Two or more clusterable rows once the row listing settles, and a mark that has a value.
svgSidebar `SvgSidebarProps \| undefined`
plotScanLocus `string \| undefined`	The window the held field scan read, for the dialog to name.

151 inherited getters from 14 models

From FacetWritesMixin: writtenFacet

From HiddenGroupsMixin: ownGroupState, hiddenGroups, hiddenGroupKeys, groupStateKey

From StoredHoverMixin: hoveredFeature

From LegendMixin: showLegend, legendRight, legendSpec, hasLegendKey

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

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

From RowHeightMixin: rowHeight

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

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

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

From RenderLifecycleMixin: painted

From RegionTooLargeMixin: 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, plotKeys, plot, configNotices, notices, plotExamples, configDocsUrl

Methods

Member	Description
resolveAdapterOptions `(options: object, _region: Region, _signal: AbortSignal) => Promise<object \| undefined>`	Overridable hook: `adapterOptions` as one region's fetch sends them as `CoreGetEncodedLayers`'s `opts`, resolved on the main thread, where the assembly's aliases are; undefined sends none.
plotRequest `() => { layers: LayerRequest[]; transform: TransformStep[]; facet?: FacetSpec \| undefined; }`	The plot as the worker reads it: each mark's encoding and lanes, and the filters as transform steps. Every field and expression the plot names is in it, and `adapterOptions` is not, so a display may derive its options from what the plot reads.
rpcProps `() => { layers: LayerRequest[]; transform: TransformStep[]; facet?: FacetSpec; opts?: object; }`	the fetch inputs SettingsInvalidate watches: `plotRequest`, all of it evaluated in the worker, and the `adapterOptions` each region resolves
floatingLabels `(palette: JBrowsePalette) => FloatingLabel[]`	The text marks' labels as records in the display's own px, for a host that shows the plot canvas but not the text layer over it: a ring of the circular view. Placed and culled as on screen.
configProblemsOf `(conf: AnyConfigurationModel) => string[]`	The rule list over a config, as lines. It replaces the schema's rules rather than adding to them, since it checks the colors and `encoding.y` itself.
liftMarkPlot `(plot: Plot) => MarkPlotSettings`	A draft as the rule list reads it, merged over `plot` and lifted by the config schema, throwing what a config file would be refused for. It changes no state on this display.
trackMenuItems `() => MenuItem[]`
contextMenuItems `() => MenuItem[]`

18 inherited methods from 5 models

From LegendMixin: colorScalesIn, legendSpecIn

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

From MultiRegionDisplayMixin: regionHasData, isCacheValid

From RegionTooLargeMixin: resolvedByteLimit, gateFetchState

From BaseDisplay: renderingProps, liftPlot, plotProblems, plotWrites

Actions

Member	Description
setSourceListing `(read: AdapterRead<RowSourceListing \| null>) => void`
setRowProportion `(n: number) => void`	Write every span mark's `mark.height.band`.
setFitToHeight `() => void`	Fit the rows to the plot. The `height` getter is the slot itself, so nothing needs seeding on the way in.
selectFeature `(hit: MarkHitInfo) => void`	Open the feature widget on the read, the bin or the run a hit drew, inside its facet section, through `selectEncodedFeature`.
setRpcData `(idx: number, data: EncodedLayersResult, region: Region) => void`	Stage a region as fetched, with this display's payload layout.
splitByPlotRows `(fields: PlotFields) => void`	A row per source where the adapter lists several and nothing splits the features yet: one value per row is the row axis, and a facet is for bands holding more than one row.
sortRowsByValueAt `(refName: string, pos: number) => boolean`	Order the rows by the value each stands at over (refName, pos), highest first, off the loaded regions with no refetch; false where no loaded region covers the column.
setFilter `(filters?: string[] \| undefined) => void`	Write the `filter` list's expressions; undefined returns them to what the track's config declares.
setPlotFields `(fields?: PlotFields \| undefined, error?: unknown) => void`
setPlotDefaultChecked `() => void`
setPlotFieldsPromise `(promise?: Promise<PlotFields> \| undefined, scanned?: Region[]) => void`
ensurePlotFields `() => Promise<PlotFields>`	Scan the features for the fields a plot can read. A scan that found a numeric field answers for the display's life; one that found none answers only for the window it read, and a failed one for nothing. A scan a newer one aborted answers with the newer one's fields.
openPlotDialog `(seed?: Plot \| undefined, seedOptions?: PlotWriteOptions \| undefined) => void`	Open the plot as text, over the same settings the controls write. `seed` overlays a setting the caller has in hand but has not applied.
setPointSize `(val?: number \| undefined) => void`	Write every point mark's `encoding.size` number; undefined returns each to the default.
pinDistinctShapes `() => void`	The ordinal analogue of the min/max dialog's "Use current range": every value a colliding shape key lists goes into the shape's `scale.domain`, in key order after what it already lists, so each takes a separate shape.
openMarkPlotDialog `(seed?: Plot \| undefined) => void`	Open the plot as controls: every mark, the channels its type reads, and what the rules say under each. The field scan runs behind it, as it does for the field dialog.
openPlotForm `(draft: Plot) => void`	The text box's "Back to form", opened on its draft.
fetchNeeded `(needed: IndexedRegion[]) => Promise<void>`	Fetch each needed region widened to the edges of the widest bin a shared step or a mark drawing at this zoom cuts, so no bin a drawn mark plots is cut at the fetch edge.
startRenderingBackend `(backend: MarkRenderingBackend) => void`	identity encode — the stored payload is what the backend uploads
renderSvg `(opts?: ExportSvgDisplayOptions \| undefined) => Promise<ReactElement<unknown, string \| JSXElementConstructor<any>> \| Iterable<ReactNode> \| AwaitedReactNode>`