LinearSyntenyViewHelper
Auto-generated @jbrowse/mobx-state-tree API for the current JBrowse release —
see pluggable elements for concepts. Provided by the
linear-comparative-view plugin.
View source.
Holds one level of a linear synteny comparison: its track list, height and level index, composed with the shared rendering-lifecycle state.
Nested in LinearComparativeView.levels, never in session.views: it is a track
container, not a view, and satisfies core's TrackContainer so the
track-selector and add-track widgets can write into it via the parent view's
trackContainerFor. The LinearSyntenyViewHelper name and type literal are
kept only because saved sessions persist them.
Members a composed model contributes are listed here too, so these tables are the whole surface.
Properties
| Member | Description |
|---|---|
idid: ElementId | |
typetype: 'LinearSyntenyViewHelper' | |
| tracks | |
heightheight: types.stripDefault(types.number, 100) | |
levellevel: types.number |
Volatiles
| Member | Description | Defined by |
|---|---|---|
canvasDrawncanvasDrawn: false | flips true on first paint; read by test selectors to detect render | RenderLifecycleMixin |
currentRenderingBackendcurrentRenderingBackend: undefined | current backend reference, updated on context-loss recovery. Typed unknown (not generic B) on purpose: this mixin is composed by every display via a non-generic factory, so the per-display backend type B isn't known here — it's supplied at attachRenderingBackend<B> and narrowed with as B inside the autoruns. Don't "fix" the cast. | RenderLifecycleMixin |
renderTickrenderTick: 0 | counter the render autorun observes; bumped to force a re-render | RenderLifecycleMixin |
autorunsInstalledautorunsInstalled: false | guards attachRenderingBackend so the autorun pair spawns once per instance | RenderLifecycleMixin |
renderErrorrenderError: undefined | the render-backend (GPU/Canvas2D init or context-loss) error, or undefined. Single source of truth for the render-error terminal state: useRenderingBackend writes it from the canvas-init mechanism so the model — not React-local hook state — owns every terminal state. Read by displayPhase (whose renderError term outranks loading, suppressing the scrim) and by DisplayChrome (shows the retry overlay). | RenderLifecycleMixin |
Getters
| Member | Description | Defined by |
|---|---|---|
gpuRenderingBackendSyntenyRenderingBackend | undefined | Typed accessor for the slot-mixin-owned currentRenderingBackend. All synteny displays within the level upload their geometry to the same backend and render onto one canvas. | LinearSyntenyViewHelper |
parentViewParentViewDuck | LinearSyntenyViewHelper | |
assemblyNamesstring[] | LinearSyntenyViewHelper | |
linearSyntenyDisplaysLinearSyntenyDisplayModel[] | All synteny displays under this level's tracks. | LinearSyntenyViewHelper |
bandTransformKeystring | The numbers that move a ribbon under a stationary cursor: each connected row's offsetPx and bpPerPx, plus the band height the ribbons are drawn through. Synteny's twin of DotplotView.plotTransform — and, like it, the value installClearHoverOnBandMove watches to decide the picture has moved.A key rather than the object dotplot returns, because nothing else consumes it: a string only differs when a number does, so a re-evaluation that lands on the same viewport fires nothing. Taking these off LinearSyntenyDisplay.renderParams instead would subscribe the reaction to hoveredFeatureId — which the reaction itself writes, so it would re-fire on its own effect.Empty while the rows are not both there (a trailing level, or before init), which no viewport can produce, so the first real value is a change and any hover held across init clears with it. | LinearSyntenyViewHelper |
displayErrorstring | undefined | Every failed track's error in this level, combined into the one value the band has room to report — resolved here rather than per display because they all paint the same full-height band. On-screen only: it is one banner floating over the ribbons that did render, and a figure has nowhere to float one, so a failed track fails the SVG export outright from that display's own awaitSvgReady. | LinearSyntenyViewHelper |
surfaceReadinessComparativeSurface | This level's band as the displays drawing onto it see it: first paint, plus the two parent-view flags that mean what is on screen is not the answer yet. Published here so a display reads one field instead of walking to the level for paint and on to the view for the init flags — and so settled below and every display's displayPhase are computed from the same three values. | LinearSyntenyViewHelper |
displayPhaseDisplayStatusPhase | What the shared canvas publishes as data-display-phase: the ranking over the ribbons drawing onto it. Its twin settled below is the stricter question — see comparativeReadiness. | LinearSyntenyViewHelper |
settledboolean | Canvas has painted and no display is still fetching, so what's on screen is the final settled content. Drives synteny_canvas's data-display-drawn test-id, which screenshot capture and the browser-test suites wait on before snapshotting — so it must mean "done", not just "first paint".Not the same question as "is every display finished" — see comparativeReadiness, which holds both and says why an error answers them differently. | LinearSyntenyViewHelper |
geometryByDisplayKeyMap<number, SyntenyInstanceData> | Per-display GPU geometry keyed by displayKey. The upload autorun diffs this map — new entries upload, vanished entries evict. | LinearSyntenyViewHelper |
syntenyRenderStateSyntenyRenderState | Aggregated per-frame render state — a resolved value, never undefined; "the view isn't measured yet" is the canRender precondition below. Every display in the level draws starting at yTop=0 since each level owns its own canvas.An empty perTrack is a real frame, not a skip: the row pair has no synteny track (a legal launch — the rows just stack with no ribbons), the one it had was hidden, or every one is minimized. The backend clears before drawing, so painting zero tracks is what drops a hidden track's ribbons. | LinearSyntenyViewHelper |
hoveringFeatureboolean | The pointer is over a ribbon somewhere in this band. Drives the canvas cursor, which is the only thing that says a ribbon can be clicked at all — the hover shading is subtle at the default 0.2 opacity. | LinearSyntenyViewHelper |
canRenderboolean | Render-lifecycle precondition (overrides RenderLifecycleMixin's default-true hook): the render callback sizes the canvas off parentView.width, which throws by design before the view is measured. Gating the autorun pair here is what lets syntenyRenderState stay a resolved getter. | LinearSyntenyViewHelper |
rendersCanvasboolean | Overridable hook (default true): whether this display paints a canvas in its current configuration, as opposed to a deliberate static placeholder (LD with the triangle off, sequence past base resolution — both render a message where the <canvas> would go, so canvasRef is never called and canvasDrawn can never flip).Lives here, beside canvasDrawn, because every consumer of "has this display painted" needs the pair — and until 2026-08 each family declared its own copy (per-region hard-coded true, global carried the hook for LD), so a display could express the state only to whichever family it happened to compose. See painted below for the reader that was missed. | RenderLifecycleMixin |
paintInertboolean | Overridable hook (default false): the display has reached a state it will not paint its way out of, so painted below should answer finished rather than pending. Both LGV fetch families fill it with !!error — a fetch that failed before first paint keeps its canvas mounted, since the error bar is an overlay rather than a subtree replacement, so nothing ever draws into it. Named for fetchInert on the comparative side.A hook rather than a read of error here, for two reasons that both bite: this package is a leaf and error belongs to the fetch mixins, and declaring that name here would collide with FetchMixin's volatile — types.compose gives the collision to its later argument, and the two families compose the two mixins in opposite orders. | RenderLifecycleMixin |
paintedboolean | The first-paint answer every consumer outside the display should read, canvasDrawn being only the raw flag: a display that is deliberately not painting a canvas has finished, and saying otherwise is a lie that never resolves.The two rendersCanvas: false states each had three of their four consumers wired by hand — the loading scrim (rendersCanvas / fetchInert) and the SVG export (fetchInert) — while the fourth, data-display-drawn, went on publishing "false" forever off the raw flag. That attribute is what PENDING_DISPLAYS (@jbrowse/browser-test-utils) selects on, so a zoomed-out reference sequence track made every waitForDisplaysDone on the page burn its full timeout — silently, since that wait swallows its own. Same shape as fetchInert on the comparative side: the reader you forget is the one outside the display, so the display has to publish one name for it.paintInert is the third term and the same argument once more, for the state where a display would paint a canvas and never gets to — a fetch that failed before first paint. See that hook. | RenderLifecycleMixin |
Methods
| Member | Description |
|---|---|
displayFor(key: number) => LinearSyntenyDisplayModel | undefined | The display a pick hit belongs to. A scan over the level's handful of displays, not a keyed map: the map this replaces was a computed no reaction observed, so every access rebuilt it in full anyway. |
Actions
| Member | Description | Defined by |
|---|---|---|
setHeight(n: number) => void | LinearSyntenyViewHelper | |
| showTrack | LinearSyntenyViewHelper | |
hideTrack(trackId: string) => boolean | LinearSyntenyViewHelper | |
toggleTrack(trackId: string) => boolean | LinearSyntenyViewHelper | |
| setHoveredFeature | LinearSyntenyViewHelper | |
| setClickedFeature | Clicked-state twin of setHoveredFeature. | LinearSyntenyViewHelper |
| showOffscreenMateContig | Show the contig an off-screen mate mark points at, on the row that is not displaying it — what clicking a mark does.row rather than level + 1, because a level has a strip on each edge: a mark on the query axis names a contig the row BELOW is not showing, and one on the target axis names a contig the row ABOVE is not. The caller resolved which strip it hit, and the hit carries the answer.THE LOCUS, NOT THE CONTIG. A bare refName is a whole chromosome, so every click used to answer a question about one locus by zooming out past every other one — and the mate coordinates that make it answerable were being collected and dropped ( collectOffscreenMates). grow and a floor rather than an exact span, so the ribbons that now have both ends have something around them to be read against at either end of the size range. Every mark carries one; the bare form here is for a caller that has a contig and nothing else.A CONTIG THAT ROW ALREADY HAS IS SCROLLED TO, not navigated to. Its marks are the ones the band is culling rather than the ones it never had a second endpoint for ( culledRibbonMates), and that class arises precisely where the row displays everything — so replacing its regions would answer "your mate is over there" by discarding every other chromosome of the row the mark was pointing at. The rest below is the other class.navToLocString REPLACES that row's displayed regions, which is exactly the narrowing the synteny follow must never do to itself. Here it is the whole request: the mark says "these go to ctgB", and the only thing that turns it into a ribbon is that row showing ctgB. That replacement is also why this offers an UNDO rather than leaving the reader to reconstruct what the row was showing: what it replaced is a region list they may have spent several navigations building, and "Show all regions" — the only thing that was on offer — is not it.IT ALSO TAKES THE ANCHOR, when the follow is on and this is not already the anchor row. A row the follow MOVES is re-asserted onto the anchor's mapping every time the anchor settles — that is what the exact pass is for, "re-asserting the follow over a row the user dragged" — so the click ran, posted its snackbar, and the row came straight back ( LinearSyntenyOffscreenMateFollow.test.tsx is the proof). Anchoring the row is what the click MEANS: this row should show that contig, and the others should come to it. The undo puts the anchor back too. | LinearSyntenyViewHelper |
startRenderingBackend(backend: SyntenyRenderingBackend) => void | LinearSyntenyViewHelper | |
markCanvasDrawn() => void | RenderLifecycleMixin | |
resetCanvasDrawn() => void | RenderLifecycleMixin | |
stopRenderingBackend() => void | RenderLifecycleMixin | |
renderNow() => void | RenderLifecycleMixin | |
setRenderError(error: unknown) => void | set/clear the render-backend error. Called by useRenderingBackend: with the error when the canvas factory rejects (or context-loss re-init fails), and with undefined on successful (re)init and on retry. | RenderLifecycleMixin |
| attachRenderingBackend | attach a GPU/Canvas2D backend and install the upload + render autorun pair. Idempotent: re-calling swaps the backend and does not run setup again, so the callbacks and everything they close over are the first call's. | RenderLifecycleMixin |