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 BaseDisplay: id

From TreeSidebarMixin: runClustering, clusterRegion, sortRowsBy

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 11 models

From ScoreScaleMixin: unclippedQuantile

From LegendMixin: dismissedLegendSections

From ContextMenuMixin: contextMenuInfo

From StoredHoverMixin: storedHoveredFeature

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 TreeSidebarMixin: hoveredTreeNode, treeCanvas, mouseoverCanvas

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 `ConfigNodeProps<…> & ConfigNodeActions & ConfigNodeBrand<ConfigurationSchemaType<…>>`	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 `encoding.size` number in px, its type's default where none is written, which a bar or span leaves unread.
markRowProportions `number[]`	Each mark's `rowProportion`, 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.
markStepLists UnionNode<{ filter: ConfigurationSchemaType<…>; formula: ConfigurationSchemaType<…>; bin: ConfigurationSchemaType<…>; aggregate: ConfigurationSchemaType<…>; window: ConfigurationSchemaType<…>; coverage: ConfigurationSchemaType<…>; flatten: ConfigurationSchemaType<…>; cells: ConfigurationSchemaType<…>; pileup: ConfigurationSchemaType<…>; mate: ConfigurationSchemaType<{ type: { type: "string"; } & { defaultValue: string; }; }, ConfigurationSchemaOptions<undefined, undefined, true, ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>; }>[][]	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 `filter` slot
baseFilters `() => string[]`	What the track's config declares for `filter`, 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 carries no attribute of its own.
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 none, one that lists another field, and until the current adapter config's listing lands.
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.
rowKeys `RowKeys`	The key each value of `rows.field` holds across every loaded region, assigned at the value's first arrival and never moved; a new field is a new key space.
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 every region's rows are offset onto the one layout, so a chip and the band beside it agree whichever region a span came from; under `rows` every row is a key the row table places, so a reorder or a focus moves no instance. A region is offset or keyed again only when it, the facet's layout or the key space moves, which is what the upload re-packs.
rowTable `RowTable \| undefined`	Under `rows`, the table every mark places a key through: its slot in the rows' order, hidden where the focus leaves it out. Rebuilt on a reorder, a focus or a new value, which uploads one small texture and no instance bytes. Undefined wherever the lanes are not keys.
drawnKeys `Uint8Array<ArrayBufferLike> \| undefined`	1 at each key the row table draws, undefined while every key a loaded region carries is drawn: a focus 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 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 autoscale mode `scales.y` 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 — `scales.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 carries, 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[]`	What the declared marks say that the display cannot draw as written, reported where a load would once have refused the track.
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.
sharedKeys `SharedKey[]`	The shape keys whose unlisted values collide on one shape, each with the domain Pin distinct shapes writes.
cornerNotices `string[]`	The config problems as lines, `dataNotices`, and the keys whose values collide: what the corner's problems notice lists. The skipped count has a chip of its own.
notices `string[]`	`cornerNotices` and a mark whose every loaded feature was skipped, which a mistyped field is, as lines an agent's settle report carries: a display with any of them still draws, so nothing else reaches 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 the loaded regions carry, 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 carries a value.
svgSidebar `SvgSidebarProps \| undefined`
plotScanLocus `string \| undefined`	The window the held field scan read, for the dialog to name.

152 inherited getters from 13 models

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

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

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

From StoredHoverMixin: hoveredFeature

From HiddenGroupsMixin: displayHiddenGroupKeys, ownGroupState, hiddenGroups, hiddenGroupKeys, groupStateKey

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

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

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 RegionTooLargeMixin: 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 TreeSidebarMixin: showTree, showBranchLength, showRowLabels, treeAreaWidth, rowDomain, rowLabels, rowTreeProvenance, rowFocus, rowColorSetting, baseRowColor, baseRowDomain, rowAlias, unlistedRowsSort, rowBanding, rowFocusLineHeight, rowsTopOffset, guideTree, guideTreeHonoursDomain, rowTree, rowOrder, expandedRows, sharesPanel, rowColorPaintsMarks, rowNoun, internalRowFields, rowBandingNotices, rowPaletteDeals, rowColorDealRows, rowStylingIsCustom, rowColorChoice, rowColorAttribute, dealtRowColors, rowColorAttributesOffered, resolvedRowColors, rowArrangementIsCustom, editableSources, rowColorKeyInputs, rowColorScales, clusterableSources, parsedTree, root, bandedRows, bandedSources, rowBands, sources, treeRoot, drawsTree, rowsContentHeight, hierarchy, spatialIndex, clusterPartition, treelessBandCount, treeHasBranchLengths

From RowHeightMixin: rowHeight

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 \| undefined; opts?: object \| undefined; }`	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.
plotProblems `(plot: Plot) => string[]`	What a draft plot would report once applied, as the lines `notices` carries, without touching the display; one a config file would refuse throws the refusal.
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. Nothing on this display is touched.
trackMenuItems `() => MenuItem[]`
contextMenuItems `() => MenuItem[]`

16 inherited methods from 5 models

From LegendMixin: svgLegendWidth, colorScalesIn, legendSpecIn

From BaseDisplay: renderingProps, liftPlot, plotWrites

From MultiRegionDisplayMixin: regionHasData, isCacheValid

From RegionTooLargeMixin: resolvedByteLimit, gateFetchState

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

Actions

Member	Description
setSourceListing `(read: AdapterRead<RowSourceListing \| null>) => void`
setRowProportion `(n: number) => void`	Write every span mark's `rowProportion`.
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.
setFacetDomain `(domain: string[]) => void`	The Sections menu's reorder lands on the declaration.
setFacetField `(field: string) => void`	A field's own bands, in their sorted order: the outgoing field's domain and hidden sections go with it, and the facet's steps stay.
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` slot; undefined returns it 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) => 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 categorical analogue of the min/max dialog's "Use current range": every value a colliding shape key lists goes into the shape's `domain`, in key order after what it already lists, so each takes a shape of its own.
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>`
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>`