# LinearFeatureBaseDisplay

Auto-generated from the @jbrowse/mobx-state-tree model in the source. See the [developer guide](https://jbrowse.org/jb2/docs/developer_guide/) for concepts. Provided by the `features` plugin. [View source](https://github.com/GMOD/jbrowse-components/blob/main/plugins/features/src/LinearBasicDisplay/baseModel.ts).

Shared GPU-accelerated feature display base for canvas-rendered tracks.

The configuration slots for this model are documented on its [config schema page](../../config/linearfeaturebasedisplay).

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

## Properties

| Member | Description |
| --- | --- |
| **configuration**<br><code><a href="../../config/linearfeaturebasedisplay">LinearFeatureBaseDisplayConfig</a></code> | The config node this model reads its settings from, through `getConf`. Its slots are documented on its [config schema page](../../config/linearfeaturebasedisplay). |
| **pinnedFeatureIds**<br><code>string[]</code> · default <code>[]</code> | Feature ids the user pinned to the top of the layout via the feature right-click menu. |
| **soloFeatureIds**<br><code>string[]</code> · default <code>[]</code> | "Show only these features": the collected set the user builds by ctrl+clicking features (or via the right-click menu). |
| **soloApplied**<br><code>boolean</code> · default <code>false</code> | Whether the collected soloFeatureIds set is actually isolating the view (worker drops non-members). |
| **hiddenFeatureIds**<br><code>string[]</code> · default <code>[]</code> | "Hide this feature" exclusion set (inverse of solo): the worker drops these from layout/drawing. |
| **expandedGeneIds**<br><code>string[]</code> · default <code>[]</code> | Genes the user opened from the isoform badge on the gene's label: these draw every isoform whatever `geneGlyphMode` or the fit ladder's isoform rung would otherwise collapse them to. |
| **featureHighlights**<br><code>types.stripDefault( types.array(FeatureHighlightModel), [], )</code> | Declarative feature highlights, typically seeded by a text search (highlight the gene you searched for). |

3 inherited properties from 2 models:

From [ParkedColorMixin](../parkedcolormixin): [`parkedColors`](../parkedcolormixin#property-parkedcolors)

From [BaseDisplay](../basedisplay): [`id`](../basedisplay#property-id), [`type`](../basedisplay#property-type)


## Volatiles

| Member | Description |
| --- | --- |
| **featureIdUnderMouse**<br><code>string &#124; undefined</code> |  |
| **subfeatureIdUnderMouse**<br><code>string &#124; undefined</code> |  |
| **mouseoverExtraInformation**<br><code>string[] &#124; undefined</code> | the hover tooltip's rows, each rendered as a separate element — see hoverTooltipRows for why this is a list and not one HTML string |
| **sequenceHoverPosition**<br><code>SequenceHoverPosition &#124; undefined</code> | genomic base currently hovered in a feature sequence dialog opened from this display, read by the LGV crosshair overlay |
| **onScreenIdsMemo**<br><code>(next: ReadonlySet&lt;string&gt;) =&gt; ReadonlySet&lt;string&gt;</code> |  |
| **morphFromTops**<br><code>Map&lt;string, number&gt; &#124; undefined</code> |  |
| **morphProgress**<br><code>number</code> |  |
| **morphStartMs**<br><code>number</code> |  |
| **morphFromMaxY**<br><code>number</code> |  |

24 inherited volatiles from 8 models:

From [ContextMenuMixin](../contextmenumixin): [`contextMenuInfo`](../contextmenumixin#volatile-contextmenuinfo)

From [FeatureGateMixin](../featuregatemixin): [`densityStatsPerRegion`](../featuregatemixin#volatile-densitystatsperregion)

From [LegendMixin](../legendmixin): [`dismissedLegendSections`](../legendmixin#volatile-dismissedlegendsections)

From [MultiRegionDisplayMixin](../multiregiondisplaymixin): [`loadedRegions`](../multiregiondisplaymixin#volatile-loadedregions)

From [FetchMixin](../fetchmixin): [`activeSignal`](../fetchmixin#volatile-activesignal), [`fetchGeneration`](../fetchmixin#volatile-fetchgeneration), [`reloadCounter`](../fetchmixin#volatile-reloadcounter), [`statusWindow`](../fetchmixin#volatile-statuswindow), [`error`](../fetchmixin#volatile-error), [`statusMessage`](../fetchmixin#volatile-statusmessage), [`statusProgress`](../fetchmixin#volatile-statusprogress), [`fetchCanceled`](../fetchmixin#volatile-fetchcanceled), [`fetchRotation`](../fetchmixin#volatile-fetchrotation)

From [RenderLifecycleMixin](../renderlifecyclemixin): [`canvasDrawn`](../renderlifecyclemixin#volatile-canvasdrawn), [`paintCount`](../renderlifecyclemixin#volatile-paintcount), [`currentRenderingBackend`](../renderlifecyclemixin#volatile-currentrenderingbackend), [`renderTick`](../renderlifecyclemixin#volatile-rendertick), [`renderError`](../renderlifecyclemixin#volatile-rendererror), [`offScreen`](../renderlifecyclemixin#volatile-offscreen)

From [RegionTooLargeMixin](../regiontoolargemixin): [`forceLoadTrack`](../regiontoolargemixin#volatile-forceloadtrack), [`byteEstimate`](../regiontoolargemixin#volatile-byteestimate), [`gateMeasuredViewportKey`](../regiontoolargemixin#volatile-gatemeasuredviewportkey)

From [TrackHeightMixin](../trackheightmixin): [`scrollTop`](../trackheightmixin#volatile-scrolltop), [`hostHeight`](../trackheightmixin#volatile-hostheight)


## Getters

| Member | Description |
| --- | --- |
| **rpcDataMap**<br><code>ReadonlyMap&lt;number, LoadedFeatureData&gt;</code> | The fetched features, keyed by displayedRegionIndex — the foundation's per-region store, narrowed. |
| **conf**<br><code><a href="../../config/linearfeaturebasedisplay">LinearFeatureBaseDisplayConfig</a></code> | the config typed off the concrete schema; `ConfigurationReference` erases `self.configuration` to `any`, so direct reads route through this to stay typed (same move as `BaseAdapter<CONF>`). |
| **colorSetting**<br><code>ColorSetting</code> | The `color` object as written, its `value` and `field` raw: either may be a `jexl:` expression over a feature, which has none here. |
| **workerColor**<br><code>WorkerColor</code> | The two members the worker reads, the rest being the main thread's. |
| **colorEncoding**<br><code>string &#124; FieldColorEncoding &#124; undefined</code> | `colorSetting` as it paints, through the one resolver every display's color channel goes through: `encoding.color.value`, or a field through its scale, `score` a ramp and any other field ordinal while `scale.type` is unset. |
| **colorField**<br><code>string &#124; undefined</code> | The field the color paints by, through any scale, or undefined while `encoding.color.value` paints. |
| **solidColor**<br><code>string &#124; undefined</code> | The constant `encoding.color.value` holds, painting or kept beside a field; undefined where it holds none or a `jexl:` expression. |
| **colorByMode**<br><code>"attribute" &#124; "default" &#124; "solid" &#124; "strand"</code> | The Color by radio that is ticked: a field, else a constant, else the track's own color. An identity scale's field ticks Attribute..., as on the multi-row display. |
| **categoricalColorField**<br><code>CategoricalField &#124; undefined</code> | The color channel's field while it paints through an ordinal scale, which a facet on the same field shares. |
| **paintedColorField**<br><code>CategoricalField &#124; undefined</code> | The field the color channel paints through an ordinal or threshold scale, a threshold's values filed under their bins. |
| **identityKeyEntries**<br><code>{ value: string; label: string; color: string; }[]</code> | The rows an identity scale's key names, empty under any other scale. |
| **colorKeyTitle**<br><code>string &#124; undefined</code> | The key's heading: the channel's `legend.title`, or its field's preset's, else the field. |
| **colorValueExtent**<br><code>[number, number]</code> | The smallest and largest number the loaded regions' values of the painting field hold, which a ramp's open ends follow. |
| **colorValueGaps**<br><code>{ missing: boolean; notNumber: boolean; }</code> | Whether a loaded feature has no value in the painting field, or has text that is not a number; a ramp's key lists these beside its bar. |
| **colorRamp**<br><code>{ domain: [number, number]; lut: Uint8Array&lt;ArrayBufferLike&gt;; midNorm: number; colorOf: (value: number) =&gt; number; } &#124; undefined</code> | The ramp a linear, log or symlog color paints through, over the loaded values where an end is left open. |
| **paintColorValue**<br><code>((value: string) =&gt; string) &#124; undefined</code> | The color a field value paints, while a field paints. A ramp paints a value-less feature the no-value grey, as the categorical and threshold scales do. |
| **fieldPalette**<br><code>FieldPalette &#124; undefined</code> | `paintColorValue` with each value's packed colors held for every region and re-encode that asks, while the scale stands. |
| **featureColor**<br><code>string</code> |  |
| **colorByAttribute**<br><code>string</code> |  |
| **liveNotices**<br><code>string[]</code> | Each `filter` field no loaded feature carries. |
| **geneGlyphNotice**<br><code>GeneGlyphNotice &#124; undefined</code> | Overridable hook (default absent): the isoform-collapse control the shared canvas body draws in its bottom-right chip stack, or nothing when the display has no gene glyphs. |
| **facet**<br><code>FacetSetting &#124; undefined</code> | The `facet` object as written, or undefined while ungrouped. |
| **displayMode**<br><code>"collapsed" &#124; "compact" &#124; "normal" &#124; "superCompact"</code> |  |
| **groupKeySpace**<br><code>string</code> | `HiddenGroupsMixin`'s hook: a section key means nothing outside the field that issued it, so moving the field drops what was hidden. |
| **labelFontSize**<br><code>number</code> |  |
| **showNames**<br><code>boolean</code> | `labels.name.show`, the persisted intent before the density gate and collapsed mode have a say, so the menu's checkbox reflects the choice. |
| **showDescriptions**<br><code>boolean</code> | `labels.description.show`, the persisted intent, as `showNames` is. |
| **hiddenGroupFeatureIds**<br><code>ReadonlySet&lt;string&gt; &#124; undefined</code> | The features of the sections the user hid, which sit unplaced by choice and so count as nothing the track failed to show. |
| **layoutReady**<br><code>boolean</code> | Whether features can be laid out: data is fetched, in-bounds, the view is measured. |
| **onScreenFeatureIds**<br><code>ReadonlySet&lt;string&gt; &#124; undefined</code> | The features whose bp span touches the viewport, less any in a hidden section, as one Set for as long as the membership holds. |
| **onScreenWidthPx**<br><code>number</code> |  |
| **showChevrons**<br><code>boolean</code> | Overridable hook (default on): whether intron lines have chevrons. Drawn from the render state, not baked by the worker, so the toggle refetches nothing. |
| **renderState**<br><code>RenderState</code> |  |
| **labelScrollBucket**<br><code>number</code> |  |
| **effectiveSubfeatureLabels**<br><code>"auto" &#124; "below" &#124; "none" &#124; "overlay"</code> | Overridable hook (default none): the subfeature-label mode the worker bakes. |
| **colorByFrame**<br><code>boolean</code> |  |
| **showAminoAcids**<br><code>boolean</code> |  |
| **reversedRegions**<br><code>Set&lt;number&gt;</code> | Deprecated: read each rpcDataMap entry's `reversed`. |
| **pinnedFeatureIdSet**<br><code>ReadonlySet&lt;string&gt;</code> |  |
| **expandedGeneIdSet**<br><code>ReadonlySet&lt;string&gt;</code> |  |
| **soloFeatureIdSet**<br><code>ReadonlySet&lt;string&gt;</code> |  |
| **hiddenFeatureCount**<br><code>number</code> |  |
| **soloFeatureCount**<br><code>number</code> |  |
| **pinnedFeatureCount**<br><code>number</code> |  |
| **canonicalFeatureHighlights**<br><code>FeatureHighlight[]</code> |  |
| **resolvedHighlights**<br><code>ResolvedHighlights</code> |  |
| **highlightedFeatureIdSet**<br><code>ReadonlySet&lt;string&gt;</code> |  |
| **layoutPinnedFeatureIdSet**<br><code>ReadonlySet&lt;string&gt;</code> |  |
| **featureHighlightCount**<br><code>number</code> |  |
| **geneGlyphSettings**<br><code>GeneGlyphSettings</code> | Overridable hook (default the gene-glyph defaults): the gene-glyph settings the worker reads, for a display declaring no gene slots. |
| **renderSettings**<br><code>Omit&lt;DisplayConfig, "geneGlyphMode"&gt;</code> | Each slot the worker reads, named member by member, so an unrelated slot write — `height` on every resize-drag frame — stays out of the RPC cache key. The gate budgets are not cache keys: a raised budget reaches the verdict through the tracked `regionTooLarge`, and as a key one would clear and refetch on every zoom across the 20 kb floor. The `field` slots and the `filter` list are read raw: a `jexl:` expression there is the worker's to evaluate per feature. The label fields alone: the `show` switches are the main thread's, so a label toggle never refetches. |
| **canonicalTranscripts**<br><code>CanonicalTranscripts</code> | the tags the worker ranks a gene's isoforms by, which the sequence panel reads to open on the isoform this display draws first |
| **showsEveryIsoform**<br><code>boolean</code> | Overridable hook (default false): the display's transcript setting names every isoform, so the fit ladder's `isoforms` rung may not trim — the surplus scrolls instead. |
| **effectiveGeneGlyphMode**<br><code>ResolvedGeneGlyphMode</code> | Overridable hook (default all): the gene-glyph mode the worker collapses under. |
| **hidesOverflow**<br><code>boolean</code> | A feature track squeezes an overflowing stack into its height rather than hide what overflows. |
| **labelDensityPerPx**<br><code>number</code> | Features per pixel of what is actually ON SCREEN — the density the `auto` label modes gate on (ADR-093). |
| **geneLabelDensityPerPx**<br><code>number &#124; undefined</code> | On-screen gene features per pixel, which `auto` holds to the same threshold so gene names outlast a crowd of other features. Undefined with no gene on screen. |
| **labelVisibility**<br><code>{ showLabels: boolean; geneNamesOnly: boolean; showDescriptions: boolean; }</code> | Which of the shown labels draw at the on-screen feature density: names, descriptions, and whether only gene names survive. |
| **showLabels**<br><code>boolean</code> |  |
| **geneNamesOnly**<br><code>boolean</code> | Past the name threshold, with the gene features alone still under it: gene names stay and every other name goes. |
| **effectiveShowDescriptions**<br><code>boolean</code> |  |
| **sectionHeadPx**<br><code>4 &#124; 16</code> | The px above each facet section's first row: its chip's row, or a gap on a host that draws no chips. |
| **layoutInputs**<br><code>{ bpPerPx: number; displayMode: "collapsed" &#124; "compact" &#124; "normal" &#124; "superCompact"; pinnedFeatureIds: ReadonlySet&lt;string&gt;; expandedGeneIds: ReadonlySet&lt;string&gt;; facet: FacetSetting &#124; undefined; sectionHeadPx: number; hiddenGroupKeys: ReadonlySet&lt;string&gt;; geneNamesOnly: boolean; }</code> | Layout inputs shared by the base layout and every fit rung, `expandedGeneIds` included: a rung inheriting them without the exemption re-collapses the gene the user just opened. |
| **fitMeasureFeatureIds**<br><code>ReadonlySet&lt;string&gt; &#124; undefined</code> | The features the ladder measures its rungs and its isoform solve against: the on-screen set in `fit` and `fixed`, undefined in `grow` (which measures the whole stack). |
| **reservesBelowLabelRows**<br><code>boolean</code> | Whether the settings reserve `below` subfeature-label rows, which the fit ladder's `bare` rung depends on — with nothing reserved the rung would repack an identical stack. |
| **fullReservation**<br><code>LabelReservation</code> | What the `full` rung reserves: the names and descriptions the settings ask for. |
| **labelsReservation**<br><code>LabelReservation</code> | The `labels` and `decimated` rungs' reservation: names kept, descriptions dropped. |
| **isoformsReservation**<br><code>LabelReservation</code> | The `isoforms` rung's reservation: the `labels` rung's when fitting to the display, else the `full` rung's. |
| **fitNameTiers**<br><code>{ gene: boolean; other: boolean; }</code> | Which of the decimation's two name tiers hold an on-screen name. |
| **fitGeneNameFloor**<br><code>number</code> | The floor gene names are solved at: the squeeze floor `bodies` would draw down to, since a gene name is a landmark worth a shorter body, except on a host that hides overflow and never squeezes. |
| **isoformsBaseInputs**<br><code>IsoformCountFreeInputs</code> | The `isoforms` rung's layout inputs minus the count itself, typed without it so the solve's shared preparation provably cannot depend on it. |
| **isoformsHeightProbe**<br><code>(maxIsoforms: number) =&gt; number</code> | Measures the `isoforms` rung's stack height at any isoform count, against the features the ladder measures its rungs with. |
| **maxIsoformsOnScreen**<br><code>number</code> | The most isoforms any trimmable gene on screen has — the top of the solve's bracket, and the count above which a trim can take nothing away. |
| **fitIsoformCount**<br><code>number &#124; undefined</code> | The isoform count the `isoforms` rung commits at: the largest whose names-kept stack fits `fitTargetHeight`, so the most transcripts are kept without giving up a name. |
| **fitIsoformsSolved**<br><code>Map&lt;number, FeatureDataResult&gt;</code> | The `isoforms` stack: every gene trimmed to `fitIsoformCount` transcripts, names intact. |
| **thinnedBaseInputs**<br><code>LabelRoomFactorFreeInputs</code> | The `thinned` rung's layout inputs minus the body scale: every name, no descriptions, the `isoforms` rung's count. |
| **fitLabeledBodyFloor**<br><code>number</code> | The smallest body scale the labelled rungs may pack at: the tallest body stays `LABELED_BODY_TO_FONT_RATIO` of the label font, and the shortest stays drawn. |
| **fitBodyScale**<br><code>number &#124; undefined</code> | The body scale the `thinned` rung commits at: the largest whose stack, every name kept, fits `fitTargetHeight`, or undefined when even the floor overflows. |
| **fitThinnedSolved**<br><code>Map&lt;number, FeatureDataResult&gt;</code> | The `thinned` stack: every name at its font size over bodies shortened to `fitBodyScale`. |
| **baseLaidOutDataMap**<br><code>Map&lt;number, FeatureDataResult&gt;</code> | Full reservation (names + descriptions): rendered at fit stage `full` and in non-fit modes, and the first stack `fitStage` probes. |
| **fitLabelsOnlyLayout**<br><code>Map&lt;number, FeatureDataResult&gt;</code> | Names reserved, descriptions dropped — the `labels` stage's stack. |
| **fitDecimatedFactors**<br><code>LabelRoomFactors &#124; undefined</code> | The whitespace factors the `decimated` rung commits at: the smallest whose packed stack fits `fitTargetHeight`, so the most names are kept. When those keep no name, or no factor fits, the names that fit anyway ride along as `keptNameIds`. |
| **fitDecimatedSolved**<br><code>Map&lt;number, FeatureDataResult&gt;</code> | The `decimated` stack: names kept only on features with at least their tier's `fitDecimatedFactors ×` their label width in neighbour whitespace (plus pinned/highlighted, always). |
| **fitDecimatedBodyScale**<br><code>number &#124; undefined</code> | The body scale the `decimated` rung commits at. |
| **fitBodiesOnlyLayout**<br><code>Map&lt;number, FeatureDataResult&gt;</code> |  |
| **fitBareLayout**<br><code>Map&lt;number, FeatureDataResult&gt;</code> | The `bare` stack: `bodies` with the `below` subfeature-label rows spent at zero height, so the last reduction before a squeeze gives back rows whose text the squeeze was about to hide anyway. |
| **fitSmallestBoxPx**<br><code>number</code> | The shortest box the layout draws on screen, read off the layout rather than `mark.height`, which some boxes draw short of: a UTR or a repeat's internal body at `INSET_HEIGHT_FRACTION` of its row, a cleavage product padded inside its row. |
| **fitMinScale**<br><code>number</code> | Floor on the fit squeeze: the smallest vertical scale that still leaves every drawn box at least `MIN_FIT_BOX_PX` tall. |
| **fitStage**<br><code>FitStage</code> | The resolved fit outcome — which reservation `level` survived, its unscaled `layout`, and the vertical `scale` to fill the track — bundled so the three can never disagree. |
| **laidOutDataMap**<br><code>ReadonlyMap&lt;number, FeatureDataResult&gt;</code> | What every consumer (hit test, GPU upload, React render) reads: the kept stack, cloned and scaled only when squeezed, or with what overflows left unplaced on a host that hides it. |
| **renderedLabels**<br><code>LabelPlacementContext</code> | The labels the kept rung reserved room for, and the size it priced them at: what the canvas, the DOM layer, the hit test, the highlight and the SVG export all draw or measure. |
| **fitDrops**<br><code>FitDrops</code> | What the ladder took from the labels the settings reserved, and how far it squeezed — the one derivation both user-facing notes read. |
| **fitNote**<br><code>string &#124; undefined</code> | The track-sizing control's account of what fit mode gave up, or undefined when nothing. |
| **labelFitHints**<br><code>{ names: string &#124; undefined; descriptions: string &#124; undefined; }</code> | The note on the Names and Descriptions checkboxes while the ladder is not honouring them. |
| **groupSections**<br><code>FeatureGroupSection[]</code> | The stacked sections in stacking order, each with the chip row the packer reserved above it, read off the same rows the glyphs paint; empty while ungrouped. |
| **featureIdIndex**<br><code>Map&lt;string, FlatbushItem&gt;</code> |  |
| **subfeatureIdIndex**<br><code>Map&lt;string, SubfeatureInfo&gt;</code> |  |
| **flatbushIndexes**<br><code>ReadonlyMap&lt;number, FlatbushRegionIndexes&gt;</code> | Per-region hit index over the kept stack and the RENDERED label flags, a label's overhang being part of its hit box. |
| **regionInstanceIndexes**<br><code>ReadonlyMap&lt;number, RegionInstanceIndex&gt;</code> | Feature and subfeature ids to the primitives they painted, per laid-out region. Deliberately held by no autorun: nothing builds it until a hover or a selection asks which instances to light, and the per-region memo outlives the computed that MobX drops between hovers. |
| **showsGroupLabels**<br><code>boolean</code> | Whether the section chips and dividers draw: a grouping is set and the layout produced a section for it. |
| **fitScale**<br><code>number</code> | Uniform vertical scale for fit mode; below 1 only while the stack is squeezed to fit. |
| **prefersOffset**<br><code>boolean</code> | A grouped track puts its track label above the plot, where it cannot cover the first section's chip. Reads the setting, not the sections, so the label does not jump when data lands. |
| **renderedShowDescriptions**<br><code>boolean</code> | Deprecated: read `renderedLabels.showDescriptions`. |
| **renderedShowLabels**<br><code>boolean</code> | Deprecated: read `renderedLabels.showLabels`. |
| **renderedShowSubfeatureLabels**<br><code>boolean</code> | Deprecated: read `renderedLabels.showSubfeatureLabels`. |
| **renderedLabelFontSize**<br><code>number</code> | Deprecated: read `renderedLabels.fontSize`. |
| **morphEased**<br><code>number</code> |  |
| **animating**<br><code>boolean</code> | a row morph is in flight, which the chrome publishes for the capture waits |
| **renderDataMap**<br><code>ReadonlyMap&lt;number, FeatureDataResult&gt;</code> |  |
| **settledMaxY**<br><code>number</code> |  |
| **maxY**<br><code>number</code> |  |
| **scrollExtentMaxY**<br><code>number</code> |  |
| **hasOverflow**<br><code>boolean</code> |  |
| **truncatedFeatureCount**<br><code>number</code> |  |
| **contentHeight**<br><code>number</code> |  |
| **scrollContentHeight**<br><code>number</code> |  |
| **scrollViewportHeight**<br><code>number</code> |  |
| **growTargetHeight**<br><code>number</code> |  |
| **hoveredFeature**<br><code>FlatbushItem &#124; undefined</code> |  |
| **hoveredSubfeature**<br><code>SubfeatureInfo &#124; undefined</code> |  |
| **hoverBoxFeature**<br><code>FlatbushItem &#124; undefined</code> | The feature the hover box frames: the open context menu's target while one is open, so the box always agrees with what the menu acts on, else the feature under the cursor. |
| **hoverBoxSubfeature**<br><code>SubfeatureInfo &#124; undefined</code> | The transcript the hover box frames instead of its gene, by the rule of `hoverBoxFeature`. |
| **namedFeatures**<br><code>NamedFeature[]</code> | Every named feature drawn, boxed over its body, for a host that places the names itself. |
| **hoverInk**<br><code>HighlightRect[]</code> | What the chrome lights under the pointer: the open context menu's target while one is open, else the hovered subfeature, else the hovered feature — one box per region over its glyph and its labels. |
| **shownTooltipLines**<br><code>string[] &#124; undefined</code> | The hover tooltip less any line that repeats a label drawn for the hovered feature or subfeature; undefined when nothing is left or `tooltip.show` is off. "Copy tooltip text" still copies every line. |
| **selectionInk**<br><code>HighlightRect[]</code> | The session's selected feature, boxed the same way. |
| **pinnedInk**<br><code>HighlightRect[]</code> | Every feature the user pinned — a search hit, a right-click highlight, a session spec's `featureHighlights` — boxed the same way. The one highlight list the SVG export draws. |
| **soloInk**<br><code>HighlightRect[]</code> | The features collected for a solo, boxed the same way, while the solo is still pending. Empty once it applies, since the view then shows only these. |
| **derivedColorScales**<br><code>ColorScale[]</code> | The key the color channel's scale derives from what the worker painted, narrowed where the window is known to the boxes the layout kept of the on-screen features, so an isoform the fit trimmed keys nothing, less the values only a hidden section painted, in the sections' order where the facet reads the same field. An identity scale's key is its `domain` colors whole, once anything is drawn. |
| **colorScales**<br><code>ColorScale[]</code> | `LegendMixin`'s hook: the key the color channel's scale derives. |

95 inherited getters from 13 models:

From [HiddenGroupsMixin](../hiddengroupsmixin): [`hiddenGroups`](../hiddengroupsmixin#getter-hiddengroups), [`ownGroupState`](../hiddengroupsmixin#getter-owngroupstate), [`hiddenGroupKeys`](../hiddengroupsmixin#getter-hiddengroupkeys), [`groupStateKey`](../hiddengroupsmixin#getter-groupstatekey)

From [FeatureGateMixin](../featuregatemixin): [`gateEnabled`](../featuregatemixin#getter-gateenabled), [`visibleFeatureDensityPerPx`](../featuregatemixin#getter-visiblefeaturedensityperpx), [`configuredMaxFeatureScreenDensity`](../featuregatemixin#getter-configuredmaxfeaturescreendensity), [`maxFeatureDensity`](../featuregatemixin#getter-maxfeaturedensity), [`densityTooLarge`](../featuregatemixin#getter-densitytoolarge)

From [FacetWritesMixin](../facetwritesmixin): [`writtenFacet`](../facetwritesmixin#getter-writtenfacet)

From [ColorWritesMixin](../colorwritesmixin): [`writtenColor`](../colorwritesmixin#getter-writtencolor)

From [ParkedColorMixin](../parkedcolormixin): [`parkedColor`](../parkedcolormixin#getter-parkedcolor), [`parkedIdentity`](../parkedcolormixin#getter-parkedidentity)

From [LegendMixin](../legendmixin): [`showLegend`](../legendmixin#getter-showlegend), [`legendRight`](../legendmixin#getter-legendright), [`legendTop`](../legendmixin#getter-legendtop), [`legendSpec`](../legendmixin#getter-legendspec), [`hasLegendKey`](../legendmixin#getter-haslegendkey), [`keyDrawnByHost`](../legendmixin#getter-keydrawnbyhost)

From [MultiRegionDisplayMixin](../multiregiondisplaymixin): [`host`](../multiregiondisplaymixin#getter-host), [`canvasWidthPx`](../multiregiondisplaymixin#getter-canvaswidthpx), [`settledSubPixelBinBp`](../multiregiondisplaymixin#getter-settledsubpixelbinbp), [`canRender`](../multiregiondisplaymixin#getter-canrender), [`rendersCanvas`](../multiregiondisplaymixin#getter-renderscanvas), [`trackVisibleRegions`](../multiregiondisplaymixin#getter-trackvisibleregions), [`viewportWithinLoadedData`](../multiregiondisplaymixin#getter-viewportwithinloadeddata), [`viewportEmpty`](../multiregiondisplaymixin#getter-viewportempty), [`fetchSuspended`](../multiregiondisplaymixin#getter-fetchsuspended), [`dataSuperseded`](../multiregiondisplaymixin#getter-datasuperseded), [`fetchHeld`](../multiregiondisplaymixin#getter-fetchheld), [`renderBlocks`](../multiregiondisplaymixin#getter-renderblocks), [`fetchInputs`](../multiregiondisplaymixin#getter-fetchinputs), [`regionPayloads`](../multiregiondisplaymixin#getter-regionpayloads), [`hasRegionData`](../multiregiondisplaymixin#getter-hasregiondata), [`staleSettingsDrawn`](../multiregiondisplaymixin#getter-stalesettingsdrawn), [`dataCurrent`](../multiregiondisplaymixin#getter-datacurrent), [`loadedAssembly`](../multiregiondisplaymixin#getter-loadedassembly), [`phaseViewportCurrent`](../multiregiondisplaymixin#getter-phaseviewportcurrent), [`svgReady`](../multiregiondisplaymixin#getter-svgready), [`paintInert`](../multiregiondisplaymixin#getter-paintinert), [`paintSuperseded`](../multiregiondisplaymixin#getter-paintsuperseded), [`displayPhase`](../multiregiondisplaymixin#getter-displayphase)

From [FetchMixin](../fetchmixin): [`isLoading`](../fetchmixin#getter-isloading), [`isLoadingOrCanceled`](../fetchmixin#getter-isloadingorcanceled), [`fetchInert`](../fetchmixin#getter-fetchinert), [`awaitingPrerequisite`](../fetchmixin#getter-awaitingprerequisite), [`awaitingDependentData`](../fetchmixin#getter-awaitingdependentdata), [`settingsFetchInputs`](../fetchmixin#getter-settingsfetchinputs)

From [RenderLifecycleMixin](../renderlifecyclemixin): [`painted`](../renderlifecyclemixin#getter-painted)

From [RegionTooLargeMixin](../regiontoolargemixin): [`byteGateAdapterConfig`](../regiontoolargemixin#getter-bytegateadapterconfig), [`byteGateAdapterPath`](../regiontoolargemixin#getter-bytegateadapterpath), [`adapterFetchSizeLimit`](../regiontoolargemixin#getter-adapterfetchsizelimit), [`gateViewportSpanBp`](../regiontoolargemixin#getter-gateviewportspanbp), [`gateViewport`](../regiontoolargemixin#getter-gateviewport), [`configuredFetchSizeLimit`](../regiontoolargemixin#getter-configuredfetchsizelimit), [`configForceLoad`](../regiontoolargemixin#getter-configforceload), [`aboveForceLoadFloor`](../regiontoolargemixin#getter-aboveforceloadfloor), [`gateExempt`](../regiontoolargemixin#getter-gateexempt), [`estimatedFetchBytes`](../regiontoolargemixin#getter-estimatedfetchbytes), [`gateByteLimit`](../regiontoolargemixin#getter-gatebytelimit), [`gateActive`](../regiontoolargemixin#getter-gateactive), [`gateMeasurementStale`](../regiontoolargemixin#getter-gatemeasurementstale), [`densityGateActive`](../regiontoolargemixin#getter-densitygateactive), [`tooLargeStatus`](../regiontoolargemixin#getter-toolargestatus), [`regionTooLarge`](../regiontoolargemixin#getter-regiontoolarge), [`regionTooLargeReason`](../regiontoolargemixin#getter-regiontoolargereason), [`zoomCanReleaseGate`](../regiontoolargemixin#getter-zoomcanreleasegate), [`gateSkipsMeasuredViewport`](../regiontoolargemixin#getter-gateskipsmeasuredviewport)

From [HeightModeMixin](../heightmodemixin): [`heightMode`](../heightmodemixin#getter-heightmode), [`autoHeight`](../heightmodemixin#getter-autoheight), [`fitHeightToDisplay`](../heightmodemixin#getter-fitheighttodisplay), [`growMaxHeight`](../heightmodemixin#getter-growmaxheight), [`fitTargetHeight`](../heightmodemixin#getter-fittargetheight), [`grownHeight`](../heightmodemixin#getter-grownheight), [`height`](../heightmodemixin#getter-height), [`hostInitialized`](../heightmodemixin#getter-hostinitialized)

From [TrackHeightMixin](../trackheightmixin): [`configuredHeight`](../trackheightmixin#getter-configuredheight), [`allottedHeight`](../trackheightmixin#getter-allottedheight), [`resizing`](../trackheightmixin#getter-resizing), [`scrollableHeight`](../trackheightmixin#getter-scrollableheight)

From [BaseDisplay](../basedisplay): [`parentTrack`](../basedisplay#getter-parenttrack), [`selectedFeatureId`](../basedisplay#getter-selectedfeatureid), [`RenderingComponent`](../basedisplay#getter-renderingcomponent), [`DisplayBlurb`](../basedisplay#getter-displayblurb), [`adapterConfig`](../basedisplay#getter-adapterconfig), [`isMinimized`](../basedisplay#getter-isminimized), [`featureNoun`](../basedisplay#getter-featurenoun), [`featureWidgetType`](../basedisplay#getter-featurewidgettype), [`plotKeys`](../basedisplay#getter-plotkeys), [`plot`](../basedisplay#getter-plot), [`configNotices`](../basedisplay#getter-confignotices), [`notices`](../basedisplay#getter-notices), [`cornerNotices`](../basedisplay#getter-cornernotices), [`plotExamples`](../basedisplay#getter-plotexamples), [`configDocsUrl`](../basedisplay#getter-configdocsurl)


## Methods

| Member | Description |
| --- | --- |
| **configuredFilters**<br><code>() =&gt; string[]</code> | The `jexl:` expressions the `filter` list holds. |
| **baseFilters**<br><code>() =&gt; string[]</code> | The expressions the track's config declares, which "Clear all filters" returns to. |
| **rampColorScales**<br><code>(id: string) =&gt; ColorScale[]</code> | The key a ramp paints, under the caller's scale `id`: the bar over its domain, and a row apiece for the values the ramp has no color for. |
| **rpcProps**<br><code>() =&gt; { displayConfig: { color: { field: string; value: string &#124; undefined; itemRgbOn?: true; identityField?: string; }; filter: FieldPredicate[]; labels: { name: string; description: string; }; tooltip: string; subfeatureLabels: "auto" &#124; "below" &#124; "none" &#124; "overlay"; transcriptTypes: string[]; canonicalTranscriptField: string; canonicalTranscriptTags: string[]; containerTypes: string[]; utrColor: string &#124; undefined; facetField?: string; featureHeight: number; }; colorByFrame: boolean; soloFeatureIds: string[] &#124; undefined; hiddenFeatureIds: string[] &#124; undefined; }</code> |  |
| **gpuProps**<br><code>() =&gt; { colorTable: Uint32Array&lt;ArrayBuffer&gt;; fieldPalette: { field: string; paint: (value: string) =&gt; string; tableOf(values: readonly string[], withTints: boolean): Uint32Array&lt;ArrayBuffer&gt;; } &#124; undefined; }</code> | What the main-thread encode needs beyond a region's own data: the packed color for every theme class the worker emitted, off `session.palette`, and the color field's scale, so a theme toggle or a recolor re-encodes what is loaded instead of refetching it. |
| **exportedFeatures**<br><code>(features: Feature[]) =&gt; Feature[]</code> | The fetched features the worker's admission lets through: the `filter`, the isolated and hidden features, and the NCBI source records the track never draws; then whatever sits in a section the user hid. |
| **fitLayoutAt**<br><code>(memo: IncrementalLayout, reserved: LabelReservation) =&gt; Map&lt;number, FeatureDataResult&gt;</code> | One fit-escalation candidate: the stack packed with the given label reservation, via that config's own memo instance so each keeps stable references across renders. |
| **decimatedInputsAt**<br><code>(floor: number) =&gt; LabelRoomFactorFreeInputs</code> | The `decimated` rung's layout inputs minus the whitespace factor, with the bodies at `floor`. |
| **decimatedFloor**<br><code>(factors: LabelRoomFactors) =&gt; number</code> | The floor the `decimated` stack at `factors` packs down to: the labelled floor while any name other than a gene's is kept, else the gene names' floor. |
| **decimatedLayoutInputs**<br><code>(factors: LabelRoomFactors) =&gt; LayoutInputs</code> | Layout inputs for the `decimated` rung at one pair of whitespace factors. |
| **decimatedHeightProbeAt**<br><code>(floor: number) =&gt; (labelRoomFactor: number &#124; undefined, geneLabelRoomFactor?: number) =&gt; number</code> | Measures the `decimated` stack's height at any whitespace factor with the bodies at `floor`, against the features the ladder measures its rungs with — so the factor the solve picks is judged on the same stack the rung is then kept or rejected on. |
| **solveLabelRoomFactors**<br><code>(trackHeight: number) =&gt; LabelRoomFactors &#124; undefined</code> | The whitespace factors the `decimated` rung commits at: gene names first, over bodies at their own floor, then the rest beside them over bodies at the labelled floor, each the smallest whose packed stack fits `trackHeight` (smallest = most names kept), or undefined when even the most aggressive decimation overflows. |
| **bodyScaleHeightProbe**<br><code>(cache: PackHeightCache, inputs: LabelRoomFactorFreeInputs, factors?: LabelRoomFactors) =&gt; (bodyScale: number) =&gt; number</code> | Measures a labelled stack's height at any body scale. Each scale needs a separate prep, since the pack reads body heights from it. |
| **namesThatFit**<br><code>(factors: LabelRoomFactors) =&gt; Set&lt;string&gt;</code> | The names among the on-screen ones, genes first, whose stack still fits at the floor `factors` pack down to, with `factors` dropping the rest, and only gene names below the labelled floor; none past `MAX_KEPT_NAME_CANDIDATES` on screen, where the pick would be arbitrary and change with every pan. |
| **decimatedLayoutAt**<br><code>(factors: LabelRoomFactors) =&gt; Map&lt;number, FeatureDataResult&gt;</code> | The `decimated` stack at `factors`, its bodies grown back into whatever height the dropped names freed. |
| **decimatedBodyScale**<br><code>(factors: LabelRoomFactors) =&gt; number</code> | The largest body scale, down to the floor `factors` pack down to, whose stack with the names `factors` keep fits `fitTargetHeight`. |
| **searchFeatureByID**<br><code>(id: string) =&gt; readonly [number, number, number, number] &#124; undefined</code> | Where a feature drew, `[startBp, top, endBp, bottom]`. A feature the layout left unplaced, truncated or in a hidden section, is not found. |
| **floatingLabels**<br><code>(palette: JBrowsePalette) =&gt; FloatingLabel[]</code> | The labels the floating label layer draws over the canvas, as records in the display's own px, for a host that shows the canvas but not this display's DOM: a ring of the circular view. The isoform badge is a control, not a label, and stays out. |
| **featuresNamed**<br><code>(name: string) =&gt; FeatureMatch[]</code> | The laid-out features this name or description labels, each with the box its body drew, so a screenshot or a test can point at a feature by what it is. Built only when called. |
| **renderSvg**<br><code>(opts?: ExportSvgDisplayOptions) =&gt; Promise&lt;ReactNode&gt;</code> |  |
| **featureNarrowings**<br><code>() =&gt; Reversibles</code> | Everything this display is doing to narrow what the user sees, each declared once, so the "Filter by (n)" count, its undo rows and "Clear all filters" cannot disagree; a method, not a getter, because a getter cannot be super-captured. |
| **featureMarks**<br><code>() =&gt; Reversibles</code> | Reversible state that MARKS features rather than hiding them — the highlight boxes and the pins holding features at the top of the layout. |
| **zoomFetchArgs**<br><code>() =&gt; { geneGlyphMode: ResolvedGeneGlyphMode; peptides: boolean; expandedGeneIds: string[] &#124; undefined; }</code> | The worker's zoom-dependent decisions, resolved: the RPC spreads this object and the foundation stamps it beside each region, so a track with the overlay off and a fixed mode never refetches on zoom. `expandedGeneIds` only under `representative`, the one mode the worker collapses in. |
| **groupByColor**<br><code>(field: string &#124; undefined, colorByGroup: boolean) =&gt; ColorSlots &#124; undefined</code> | The color the Group by dialog's choice of field writes: a color by the field when ticked, left alone while it already paints through any scale; and unticked, no field over a categorical color by the field chosen, or for None the field it leaves, so regrouping keeps a color by another field. The alignments display's rule too. Both keep a written constant, as Color by does. Undefined where the color stays as it is. |
| **groupByPlot**<br><code>(field: string &#124; undefined, colorByGroup: boolean) =&gt; Plot</code> | The Group by dialog's choice of field as plot settings, which its Apply writes and its Edit plot button shows: the facet, keeping its domain while the field is the one already set, and `groupByColor`. |
| **scanGroupByCandidates**<br><code>(opts: AttributeScanOptions) =&gt; Promise&lt;RegionTooLargeResult &#124; GroupByCandidate[]&gt;</code> | The attributes the features in view have and the sections each would make, for the Group by dialog: the render fetch's download over the visible blocks, under the same admission and byte budget. |
| **configProblemsOf**<br><code>(conf: AnyConfigurationModel) =&gt; string[]</code> | The schema's rules, then a `jexl:` color or filter that does not compile. |
| **showSubmenuCheckboxItems**<br><code>() =&gt; MenuItem[]</code> |  |
| **showSubmenuRadioGroups**<br><code>() =&gt; MenuItem[]</code> |  |
| **filterSubMenuItems**<br><code>() =&gt; MenuItem[]</code> | Overridable hook (default none): the rows "Filter by" lists beside the dialog, one per `filter` member a display adds. |
| **showSubmenuMenuItems**<br><code>() =&gt; MenuItem[]</code> | Flattened "Show" submenu: all checkbox toggles first, then the radio groups (each under a subHeader), then the legend. |
| **contextMenuItems**<br><code>() =&gt; MenuItem[]</code> | The feature right-click menu (open details, zoom to, get sequence, highlight scopes, pin/solo/hide, copy). |
| **colorBySubMenuItems**<br><code>() =&gt; MenuItem[]</code> | The "Color by" radio choices (solid/strand/attribute). |
| **colorMenuItems**<br><code>() =&gt; MenuItem[]</code> | Color-related track menu entries: a single "Color by" entry whose radios pick the track's own color or a field, and whose "Solid color..." item opens the solid+UTR color picker. |
| **featureHeightMenuItems**<br><code>() =&gt; MenuItem[]</code> | One "Feature height" menu with two independent radio groups: the size presets and, under a "When features overflow" subheader, how the track responds when there are more features than fit. |
| **trackMenuItems**<br><code>() =&gt; MenuItem[]</code> |  |

12 inherited methods from 6 models:

From [FeatureGateMixin](../featuregatemixin): [`observedMaxDensity`](../featuregatemixin#method-observedmaxdensity)

From [ParkedColorMixin](../parkedcolormixin): [`parkedColorOf`](../parkedcolormixin#method-parkedcolorof)

From [LegendMixin](../legendmixin): [`colorScalesIn`](../legendmixin#method-colorscalesin), [`legendSpecIn`](../legendmixin#method-legendspecin)

From [MultiRegionDisplayMixin](../multiregiondisplaymixin): [`regionHasData`](../multiregiondisplaymixin#method-regionhasdata), [`isCacheValid`](../multiregiondisplaymixin#method-iscachevalid)

From [RegionTooLargeMixin](../regiontoolargemixin): [`gateFetchState`](../regiontoolargemixin#method-gatefetchstate), [`resolvedByteLimit`](../regiontoolargemixin#method-resolvedbytelimit)

From [BaseDisplay](../basedisplay): [`renderingProps`](../basedisplay#method-renderingprops), [`liftPlot`](../basedisplay#method-liftplot), [`plotProblems`](../basedisplay#method-plotproblems), [`plotWrites`](../basedisplay#method-plotwrites)


## Actions

| Member | Description |
| --- | --- |
| **beginYMorph**<br><code>(fromTops: Map&lt;string, number&gt;, fromMaxY: number) =&gt; void</code> |  |
| **setMorphProgress**<br><code>(t: number) =&gt; void</code> |  |
| **advanceAnimation**<br><code>(nowMs: number) =&gt; void</code> | the chrome's frame clock |
| **endAnimation**<br><code>() =&gt; void</code> |  |
| **setRpcData**<br><code>(displayedRegionIndex: number, data: FeatureDataResult, region: Region) =&gt; void</code> | Stage a region as fetched — the store's raw write with this display's payload shape, so a test stands up a loaded display in one call. |
| **startRenderingBackend**<br><code>(backend: FeatureRenderingBackend) =&gt; void</code> |  |
| **togglePinnedFeature**<br><code>(featureId: string) =&gt; void</code> |  |
| **clearPinnedFeatures**<br><code>() =&gt; void</code> |  |
| **toggleExpandedGene**<br><code>(featureId: string) =&gt; void</code> | Open or re-collapse one gene's isoforms, from the badge on the gene's label. |
| **clearExpandedGenes**<br><code>() =&gt; void</code> | Re-collapse every gene opened from a badge. |
| **toggleSoloFeature**<br><code>(featureId: string) =&gt; void</code> |  |
| **applySolo**<br><code>() =&gt; void</code> |  |
| **soloFeature**<br><code>(featureId: string) =&gt; void</code> |  |
| **clearSolo**<br><code>() =&gt; void</code> |  |
| **hideFeature**<br><code>(featureId: string) =&gt; void</code> |  |
| **showAllHidden**<br><code>() =&gt; void</code> |  |
| **setHover**<br><code>(featureId: string &#124; undefined, subfeatureId: string &#124; undefined, tooltip: string[] &#124; undefined) =&gt; void</code> |  |
| **clearHover**<br><code>() =&gt; void</code> |  |
| **openContextMenu**<br><code>(info: FeatureContextMenuInfo) =&gt; void</code> | Drops the hover first, so its tooltip does not sit under the menu; the highlight box stays on the target through `hoverBoxFeature`. |
| **openFeatureDetails**<br><code>(fetch: () =&gt; Promise&lt;Feature &#124; undefined&gt;, parentFeature?: ParentFeatureSummary) =&gt; void</code> | Open the feature-details widget on what `fetch` resolves to, with the adapter's header metadata beside it; a lookup that resolves to nothing is reported as a miss. |
| **selectFeature**<br><code>(feature: Feature) =&gt; void</code> | Open the feature-details widget on a feature already in hand. |
| **clearSelection**<br><code>() =&gt; void</code> |  |
| **setShowNames**<br><code>(show: boolean) =&gt; void</code> |  |
| **setShowDescriptions**<br><code>(show: boolean) =&gt; void</code> |  |
| **setShowLabels**<br><code>(value: "auto" &#124; "description" &#124; "name" &#124; "nameAndDescription" &#124; "none") =&gt; void</code> | The five-value label mode, written as `setShowNames` and `setShowDescriptions`. |
| **setFilter**<br><code>(filters?: string[]) =&gt; void</code> | Write the `filter` list's expressions, its other entries kept; undefined returns them to what the track's config declares. |
| **setSequenceHoverPosition**<br><code>(pos: SequenceHoverPosition &#124; undefined) =&gt; void</code> |  |
| **openFilterDialog**<br><code>() =&gt; void</code> |  |
| **setDisplayMode**<br><code>(value: "collapsed" &#124; "compact" &#124; "normal" &#124; "superCompact") =&gt; void</code> |  |
| **dropGroupState**<br><code>() =&gt; void</code> | The stack starts over from the top when its sections change. |
| **openSolidColorDialog**<br><code>() =&gt; void</code> | the picker Color by's Solid color... opens |
| **fetchFullFeature**<br><code>(featureId: string, displayedRegionIndex: number, opts?: { signal?: AbortSignal; statusCallback?: StatusCallback; }) =&gt; Promise&lt;SimpleFeature &#124; undefined&gt;</code> |  |
| **selectFeatureById**<br><code>(featureId: string, subfeatureInfo: SubfeatureInfo &#124; undefined, displayedRegionIndex: number) =&gt; void</code> |  |
| **fetchNeeded**<br><code>(needed: IndexedRegion[]) =&gt; void</code> |  |
| **openPlotDialog**<br><code>(seed?: Plot) =&gt; void</code> | "Edit plot...", seeded with a draft a dialog has not applied. |
| **applyGroupBy**<br><code>(field: string &#124; undefined, colorByGroup: boolean) =&gt; void</code> | What the Group by dialog applies: `groupByPlot`, the draft its Edit plot button shows. |
| **openColorByAttributeDialog**<br><code>() =&gt; void</code> |  |
| **clearHoveredFeature**<br><code>() =&gt; void</code> | Fills `BaseDisplay`'s hover-clear hook, which the fetch foundation's reaction calls on every viewport change. |
| **openGroupByDialog**<br><code>() =&gt; void</code> |  |

57 inherited actions from 14 models:

From [HiddenGroupsMixin](../hiddengroupsmixin): [`hideGroup`](../hiddengroupsmixin#action-hidegroup), [`showAllGroups`](../hiddengroupsmixin#action-showallgroups)

From [ContextMenuMixin](../contextmenumixin): [`closeContextMenu`](../contextmenumixin#action-closecontextmenu)

From [FeatureGateMixin](../featuregatemixin): [`setDensityStats`](../featuregatemixin#action-setdensitystats), [`clearGateMeasurements`](../featuregatemixin#action-cleargatemeasurements), [`commitGateMeasurements`](../featuregatemixin#action-commitgatemeasurements)

From [FacetWritesMixin](../facetwritesmixin): [`facetByField`](../facetwritesmixin#action-facetbyfield), [`setFacetSort`](../facetwritesmixin#action-setfacetsort)

From [ColorWritesMixin](../colorwritesmixin): [`colorByField`](../colorwritesmixin#action-colorbyfield), [`setColorValue`](../colorwritesmixin#action-setcolorvalue), [`colorByIdentity`](../colorwritesmixin#action-colorbyidentity), [`colorByScheme`](../colorwritesmixin#action-colorbyscheme), [`pickDefaultColor`](../colorwritesmixin#action-pickdefaultcolor), [`pickSolidColor`](../colorwritesmixin#action-picksolidcolor)

From [ParkedColorMixin](../parkedcolormixin): [`parkColor`](../parkedcolormixin#action-parkcolor)

From [LegendMixin](../legendmixin): [`setShowLegend`](../legendmixin#action-setshowlegend), [`dismissLegendSection`](../legendmixin#action-dismisslegendsection)

From [MultiRegionDisplayMixin](../multiregiondisplaymixin): [`setLoadedRegion`](../multiregiondisplaymixin#action-setloadedregion), [`evictRegionStore`](../multiregiondisplaymixin#action-evictregionstore), [`dropLoadedRegion`](../multiregiondisplaymixin#action-droploadedregion), [`clearDisplaySpecificData`](../multiregiondisplaymixin#action-cleardisplayspecificdata), [`clearSettingsBakedData`](../multiregiondisplaymixin#action-clearsettingsbakeddata), [`lapseHeldFetch`](../multiregiondisplaymixin#action-lapseheldfetch), [`clearAllRpcData`](../multiregiondisplaymixin#action-clearallrpcdata), [`invalidateSettings`](../multiregiondisplaymixin#action-invalidatesettings), [`reload`](../multiregiondisplaymixin#action-reload), [`fetchRegions`](../multiregiondisplaymixin#action-fetchregions), [`afterAttach`](../multiregiondisplaymixin#action-afterattach)

From [FetchMixin](../fetchmixin): [`setError`](../fetchmixin#action-seterror), [`setStatusMessage`](../fetchmixin#action-setstatusmessage), [`stopActiveFetch`](../fetchmixin#action-stopactivefetch), [`openStatusStream`](../fetchmixin#action-openstatusstream), [`cancelFetch`](../fetchmixin#action-cancelfetch), [`cancelFetchByUser`](../fetchmixin#action-cancelfetchbyuser), [`beforeDestroy`](../fetchmixin#action-beforedestroy), [`beginFetch`](../fetchmixin#action-beginfetch), [`endFetch`](../fetchmixin#action-endfetch), [`runFetch`](../fetchmixin#action-runfetch)

From [RenderLifecycleMixin](../renderlifecyclemixin): [`markCanvasDrawn`](../renderlifecyclemixin#action-markcanvasdrawn), [`resetCanvasDrawn`](../renderlifecyclemixin#action-resetcanvasdrawn), [`stopRenderingBackend`](../renderlifecyclemixin#action-stoprenderingbackend), [`renderNow`](../renderlifecyclemixin#action-rendernow), [`setOffScreen`](../renderlifecyclemixin#action-setoffscreen), [`setRenderError`](../renderlifecyclemixin#action-setrendererror), [`attachRenderingBackend`](../renderlifecyclemixin#action-attachrenderingbackend)

From [RegionTooLargeMixin](../regiontoolargemixin): [`clearByteEstimate`](../regiontoolargemixin#action-clearbyteestimate), [`setForceLoadTrack`](../regiontoolargemixin#action-setforceloadtrack), [`commitFetchBytes`](../regiontoolargemixin#action-commitfetchbytes), [`forceLoad`](../regiontoolargemixin#action-forceload)

From [HeightModeMixin](../heightmodemixin): [`setHeightMode`](../heightmodemixin#action-setheightmode), [`resizeHeight`](../heightmodemixin#action-resizeheight)

From [TrackHeightMixin](../trackheightmixin): [`setScrollTop`](../trackheightmixin#action-setscrolltop), [`setHostHeight`](../trackheightmixin#action-sethostheight), [`setHeight`](../trackheightmixin#action-setheight), [`expandToContentHeight`](../trackheightmixin#action-expandtocontentheight)

From [BaseDisplay](../basedisplay): [`applyDisplaySettings`](../basedisplay#action-applydisplaysettings), [`applyPlot`](../basedisplay#action-applyplot)


