LinearSyntenyView

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.

Example usage

Hand-authored under defaultSession.views, with every setting written directly on the view object. views declares the member assemblies (stacked as linear views) and tracks the synteny feature track connecting them with a ribbon:

{
  type: 'LinearSyntenyView',
  views: [{ assembly: 'hg38' }, { assembly: 'mm10' }],
  tracks: ['hg38_vs_mm10.paf'],
  drawCurves: true,
  colorBy: { field: 'query' },
}

The launch keys are views, tracks, levelHeights, autoDiagonalize, sameScale and collapseEmptyRows; everything else is a property below and needs no list to join.

Members a composed model contributes are listed here too, so these tables are the whole surface.

Properties

Member	Description	Defined by
id `id: ElementId`		LinearSyntenyView
type `type: types.literal('LinearSyntenyView')`		LinearSyntenyView
cigarMode `cigarMode: types.stripDefault( types.enumeration(['off', 'matches', 'full'] as const), 'full', )`	How per-base insertions and deletions inside each alignment are shown: 'full' paints indel wedges, 'matches' leaves them see-through, 'off' draws blocks only.	LinearSyntenyView
drawCurves `drawCurves: types.stripDefault(types.boolean, false)`	Draw every band's ribbons as bezier curves rather than straight chords.	LinearSyntenyView
drawLocationMarkers `drawLocationMarkers: types.stripDefault(types.boolean, false)`	Continue the query row's scalebar grid down through every band: a tick at each round query coordinate, joined to the coordinate the alignment pairs it with.	LinearSyntenyView
showOffscreenMates `showOffscreenMates: types.stripDefault(types.boolean, true)`	Mark the alignments the view cannot draw a ribbon for, along both edges of each band. Costs a second query per pair of rows.	LinearSyntenyView
overdrawPx `overdrawPx: types.stripDefault(types.number, DEFAULT_OVERDRAW_PX)`	pixels beyond the visible viewport edge that synteny lines are still drawn. Effective up to the pan buffer (`syntenyPanBufferPx`: 2000px, or half the viewport when that is wider) — the worker emits CIGAR detail and location markers only that far, so a larger value draws ribbons whose detail stops partway along them.	LinearSyntenyView
alpha `alpha: types.stripDefault(types.number, DEFAULT_ALPHA)`	Per-feature opacity in [0,1]. The default is tuned for dense unfiltered hairballs; a whole-genome view with minAlignmentLength set can use a higher value (~0.4) for stronger color.	LinearSyntenyView
minAlignmentLength `minAlignmentLength: types.stripDefault( types.number, DEFAULT_MIN_ALIGNMENT_LENGTH, )`	Hide alignment blocks shorter than this many bp, which cuts whole-genome hairball noise.	LinearSyntenyView
lodMode `lodMode: types.stripDefault( types.enumeration('LodMode', ['auto', 'fine', 'coarse']), 'auto', )`	Level-of-detail tier selection for PIF adapters. 'auto' uses the adapter's bpPerPx threshold; 'fine' forces the per-row CIGAR tier (t/q); 'coarse' forces the tier whose CIGAR is folded to its large indels (T/Q) when present.	LinearSyntenyView
opacityByIdentity `opacityByIdentity: types.stripDefault(types.boolean, false)`	Fade alignment blocks by per-feature identity (lower identity = more transparent), whatever the color mode.	LinearSyntenyView
fadeThinAlignmentsMode `fadeThinAlignmentsMode: types.stripDefault( types.enumeration('FadeThinMode', ['auto', 'on', 'off']), 'auto', )`	Fade a sub-pixel-thin ribbon's opacity by its on-screen width, so an unfiltered whole-genome view doesn't read as a full-opacity hairball. 'auto' fades once a display is dominated by sub-pixel ribbons and leaves a sparse comparison at full alpha; 'on'/'off' pin it. Resolved view-wide by `fadeThinAlignments`.	LinearSyntenyView
launch `launch: types.frozen< LaunchInput<LinearSyntenyViewCommands> \| undefined >()`	Transient launch state: the settings written on the view object that need resolving before they can be view state — the genome rows to open, the synteny tracks per level, the shared scale. The afterAttach autorun applies and clears it. Not written by hand: author every setting directly on the view.	LinearSyntenyView
trackSelectorType `trackSelectorType: types.stripDefault(types.string, 'hierarchical')`	Ignored: the hierarchical selector is the only one. Declared because configs still carry it.	LinearSyntenyView
followSynteny `followSynteny: types.stripDefault(types.boolean, false)`	The non-anchor rows follow the anchor row through the alignment, moving to whatever region aligns to its window.	LinearSyntenyView
sameScale `sameScale: types.stripDefault(types.boolean, false)`	Hold every genome row on one bp/px — the coarsest row's fit — so the rows compare by drawn length instead of each filling its pane. Moves the rows' zoom-out limit (`sharedFit`), so it holds across later zooms.	LinearSyntenyView
followAnchorIndex `followAnchorIndex: types.stripDefault(types.number, 0)`	Which genome row drives the others while following.	LinearSyntenyView
diagonalizeAnchorRow `diagonalizeAnchorRow: types.stripDefault(types.number, 0)`	Which genome row "Re-order chromosomes" keeps as it is: the rows below it are ordered against the row above them, and the rows above it against the row below.	LinearSyntenyView
followMatchOrientation `followMatchOrientation: types.stripDefault(types.boolean, false)`	While following, flip a row whose placing alignment runs the other way from the anchor's, so the two pan in the same direction.	LinearSyntenyView
levels `levels: types.array(LinearSyntenyLevel)`	One synteny band per adjacent pair of `views`, each holding its own track list. The track-selector and add-track widgets address a band through `trackContainerFor`.	LinearSyntenyView
views `views: types.array( pluginManager.getViewType('LinearGenomeView').stateModel, )`	N genome rows, with N-1 synteny `levels` between adjacent pairs (see reconcileLevels).	LinearSyntenyView
displayName `displayName: types.maybe(types.string)`	displayName is displayed in the header of the view, or assembly names being used if none is specified	BaseViewModel
minimized `minimized: types.stripDefault(types.boolean, false)`	collapse the view to its header bar, keeping it in the session rather than closing it	BaseViewModel
colorBy `colorBy: syntenyColorConfigSchema`	The colour every track in the view paints with, a SyntenyColor object: `{ field: "strand" }`, `{ field: "query" }`, `{ field: "reference" }`, `{ field: "track" }`, a measurement (`identity`, `mappingQual`, `dnds`) or a column the tracks declare, with `domain` ordering a text column's labels; a colour string paints every alignment. Unset, the default scheme paints.	TrackColorsMixin
trackColors `trackColors: types.map(types.string)`	trackId -> explicit color under `colorBy: { field: 'track' }`. Absent means the track takes an automatic slot from the palette.	TrackColorsMixin
hideUnlabelled `hideUnlabelled: types.stripDefault(types.boolean, false)`	Under a text-column mode, draw only the rows that carry a label.	TrackColorsMixin

Volatiles

Member	Description	Defined by
width `width: undefined as number \| undefined`		LinearSyntenyView
volatileError `volatileError: undefined as unknown`	View-level failure, e.g. a launch that couldn't be applied. Volatile so a reload retries from a clean slate.	LinearSyntenyView
followReport `followReport: EMPTY_FOLLOW_REPORT`	What the follow's last settled pass reports, for the header's follow button: rows holding because nothing aligns under the anchor, a row placed proportionally rather than by a CIGAR walk, a level with no synteny track, a multi-contig answer refused as mostly filler.	LinearSyntenyView
fadeThinLatch `fadeThinLatch: false`	Whether the 'auto' thin-fade is latched on (see `fadeThinAlignments`).	LinearSyntenyView
bodyMounted `bodyMounted: true`	Whether the container has this view's body in the DOM. `ViewContainer` mounts a view's body only while an IntersectionObserver says it is on screen, to hold the app under the WebGL2 context ceiling (`reference/GPU_CONTEXT_BUDGET.md`). A view below the fold therefore has no canvas, so nothing ever calls `markCanvasDrawn` and the pre-first-paint term of `displayPhase` pins every display in it at `loading` with nothing left to resolve it — which parks `[data-app-phase="ready"]` for the whole app on a view the user cannot see. Defaults true so the containers that always mount a body — embedded views, workspace panels, and any test rendering a display directly — are unaffected and need not set it. The raw flag, written by this view's own container. A display asks `effectiveBodyMounted` instead, because a nested view has no container of its own.	BaseViewModel
awaitingAutoDiagonalize `awaitingAutoDiagonalize: false`	True while the init autorun is waiting on the diagonalize RPC. Gates the canvas off — otherwise the user watches an undiagonalized hairball flash before the reorder kicks in.	DiagonalizeProgressMixin
pendingAutoDiagonalize `pendingAutoDiagonalize: false`	A reorder this init asked for that has not succeeded yet. Raised before any render can paint, and lowered only once the pass RESOLVES — a skipped or thrown reorder leaves it up, so the view's `settled` gate never reports done on an undiagonalized view and the capture fails loudly (times out) instead of committing a hairball. One flag rather than a requested/complete pair: the two only ever moved together, and every state a pair can drift into either wedges the gate shut or opens it on the wrong pass.	DiagonalizeProgressMixin
diagonalizeStatus `diagonalizeStatus: createStatusChannel()`	Live status from the auto-diagonalize RPC (download %, parse, algorithm phase) shown on the reordering spinner; blank outside that wait. A `StatusChannel` rather than a status field plus a setter: there is one operation to narrate here, and the channel is that pair with the message/fraction split already done, so the spinner reads `{ message, fraction }` instead of calling `statusMessageText` / `statusFraction` at every render site.	DiagonalizeProgressMixin
diagonalizeCancel `diagonalizeCancel: undefined as (() => void) \| undefined`	Aborts the in-flight auto-diagonalize, so the spinner's Cancel can reach it; undefined when none is running.	DiagonalizeProgressMixin
diagonalizeError `diagonalizeError: undefined as unknown`	Why the last reorder failed, while its gate is still up; cleared by the next run, a finish or a cancel	DiagonalizeProgressMixin
importFormSyntenyTrackSelections `importFormSyntenyTrackSelections: observable.array<ImportFormSyntenyTrack>()`		ImportFormSyntenyMixin
colorLegendDismissedFor `colorLegendDismissedFor: undefined as string \| undefined`	The field whose legend the reader closed. The legend comes back with the next field that has one, so a dismissal is scoped to the field it was made in rather than being a setting to find again.	TrackColorsMixin
seenAttributeRanges `seenAttributeRanges: {} as Record<string, AttributeRange>`	The widest span each numeric channel has been seen to cover, over every fetch this view has taken — what keeps a column's ramp from re-scaling under a pan. Widened by `observeAttributeRanges`, dropped by `resetAttributeRanges`, read through `attributeRanges`, which is where the reasoning is.	TrackColorsMixin

Getters

Member	Description	Defined by
bandGestureRows `(ModelInstanceTypeProps<_OverrideProps<{ id: IOptionalIType<…>; displayName: IMaybe<…>; minimized: IOptionalIType<…>; }, { ...; }>> & ... 25 more ... & IStateTreeNode<...>)[]`	The rows a drag or a wheel on a band moves: every row the follow cannot place. Off, that is every row; on, it is the anchor and any row whose level toward the anchor has no synteny track.	LinearSyntenyView
scrollZoom `boolean`	scroll-to-zoom is a global, personal preference resolved from the session; toggling it in any view applies everywhere	LinearSyntenyView
initialized `boolean`		LinearSyntenyView
error `unknown`	The view's own failure or the first failed row's, so an export or launcher waiting on a stack with a failed row is told why.	LinearSyntenyView
stackError `unknown`	The failure that leaves the stack nothing to show: the view's own, or every row's. One failed row reports itself in its place in the stack.	LinearSyntenyView
assemblyNames `string[]`		LinearSyntenyView
sharedFit `SharedFit`	The zoom-out limit every row shares while `sameScale` is on (`sharedFit.ts`). Each row pulls it through its own `maxBpPerPx`, finding this view by the presence of this getter.	LinearSyntenyView
allSyntenyDisplays `LinearSyntenyDisplayModel[]`	Every synteny display across every level.	LinearSyntenyView
followPairs `{…}[]`	Each connected synteny level resolved into the pair of rows a follow moves it between: which row stays, which moves, which axis the anchor window is read off, and the assembly naming the level's lane of an all-vs-all track. Ordered outward from the anchor, so each level's staying row is the anchor or a row a nearer level has already placed, and a stack of three or more settles in one pass.	LinearSyntenyView
syntenyWarnings `ComparativeWarning[]`	Data-quality warnings raised by every synteny display, e.g. a reversed assembly row order. What the header's warning button counts.	LinearSyntenyView
trackWarnings `TrackWarning[]`	The same warnings grouped under the track that raised each, which is what the dialog reports.	LinearSyntenyView
trackContainers `TrackContainer[]`	Every band's track list, for a reader walking the session for displays.	LinearSyntenyView
ownTracks `{ configuration: { trackId: string; }; displays: { type: string; configuration: AnyConfigurationModel; }[]; }[]`	Every track in the view, across its bands.	LinearSyntenyView
ownViews `(ModelInstanceTypeProps<_OverrideProps<{ id: IOptionalIType<…>; displayName: IMaybe<…>; minimized: IOptionalIType<…>; }, { ...; }>> & ... 25 more ... & IStateTreeNode<...>)[]`		LinearSyntenyView
pendingLaunch `LaunchInput<LinearSyntenyViewCommands & { unknown?: Record<…> \| undefined; malformed?: Record<…> \| undefined; legacyInit?: boolean \| undefined; } & IStateTreeNode<...>> \| undefined`	the launch state that still has something to apply — the gate the loading and import-form paths below read.	LinearSyntenyView
hasSomethingToShow `boolean`		LinearSyntenyView
initPending `boolean`	A launch that has not finished applying: the rows can exist, and be initialized, while the synteny tracks are still several awaits away. The levels' `settled` gate reads it.	LinearSyntenyView
showAssemblyNameInSubviewScalebar `boolean`	Opts each row's scalebar into captioning its refName labels with the assembly name ("hg38" ahead of "chr1"). Read duck-typed by the child LinearGenomeView.	LinearSyntenyView
drawCIGAR `boolean`		LinearSyntenyView
drawCIGARMatchesOnly `boolean`		LinearSyntenyView
syntenyTracks `ComparativeTrackModel[]`		LinearSyntenyView
hasLodCapableAdapter `boolean`	Whether any track has an adapter with tiered storage, which gates the "Level of detail" setting.	LinearSyntenyView
hasCigarData `boolean`	Whether any synteny display could show CIGAR detail, which gates the CIGAR setting. True while no display has fetched yet, and false with no synteny tracks.	LinearSyntenyView
presentCigarKinds `number`	Union across loaded displays of the CIGAR indel ops drawn on screen, which the legend lists chips for.	LinearSyntenyView
fadeThinAlignments `boolean`	The resolved fade-thin flag every display renders by. 'auto' fades once any loaded display is dominated by sub-pixel ribbons, latched with a deadband (`fadesThinAt`, ADR-083) so a view near the threshold does not flip while panning. View-wide, so stacked levels fade together.	LinearSyntenyView
autoFadeWidthPx `number`	The width 'auto' compares against its thresholds: the narrowest capped mean block width of any loaded display with at least `FADE_AUTO_MIN_FEATURES` blocks, or `Infinity` with none.	LinearSyntenyView
anchorAssemblyName `string \| undefined`	The assembly the 'reference' color field keys on: the one bordering the most synteny levels, ties to the topmost. In a stacked ref-vs-A / ref-vs-B layout that is the shared reference, so a region keeps its color across levels.	LinearSyntenyView
showLoading `boolean`	Whether to show a loading indicator instead of the import form or view	LinearSyntenyView
loadingAssembly `(ModelInstanceTypeProps<…> & { error: unknown; loadingP: Promise<…> \| undefined; ... 10 more ...; refNameMismatches: Map<…>; } & ... 13 more ... & IStateTreeNode<...>) \| undefined`	The assembly whose load the spinner is waiting on. `init` names them before the rows are built, so it is the source until then.	LinearSyntenyView
loading `ViewLoading \| undefined`	What the loading screen says while `showLoading`, read off the assembly whose load is the wait; undefined otherwise.	LinearSyntenyView
showImportForm `boolean`	Whether to show the import form: nothing to show, or a failure that leaves the stack nothing to show (`stackError`), which the form reports in a banner.	LinearSyntenyView
status `ViewStatus`	The view's lifecycle as one value — ready, error, loading or noRegions — for a host that draws its own chrome. Same shape and precedence as the linear view's.	LinearSyntenyView
rendersDisplays `boolean`	Overridable hook (default true): whether this view's mounted body renders its own displays. A linear genome view collapsed to its ruler mounts the scalebar and none of its tracks, so a display in it can no more paint than one in a view scrolled off screen. Views nested in this one are unaffected: they paint wherever their own body is.	BaseViewModel
effectiveBodyMounted `boolean`	Whether this view's displays have a canvas to paint into: its body is in the DOM, counting the views it is nested inside, and the body renders them (`rendersDisplays`). This is the question a display's phase asks. `bodyMounted` alone answers the DOM half only for a view a container renders directly. A view nested in another view (a synteny row, a breakpoint panel) has no container writing its flag, so it reads `true` forever while its whole subtree is out of the DOM, and every display in it waits for a first paint that nothing will make — the hang this flag exists to prevent, one level down. An ancestor that does not carry the flag at all leaves the answer alone rather than excusing the paint: only an explicit `false` unmounts, so a duck-typed stand-in that forgot it keeps waiting, which is the failure that shows up as a slow test rather than as a picture of an empty view.	BaseViewModel
colorBySetting `SyntenyColorSnapshot`	The `colorBy` object as its snapshot holds it.	TrackColorsMixin
colorByValue `string \| undefined`	`colorBy.value`: the colour every alignment paints under the default mode in place of the view's own scheme, or undefined for that scheme.	TrackColorsMixin
colorDomain `readonly string[]`	`colorBy.domain`, the order a text column's labels take.	TrackColorsMixin
colorableAttributes `string[]`	Distinct numeric columns across the overlaid tracks, in first-seen order — two tracks declaring `dn` offer one `dn` mode, not two.	TrackColorsMixin
attributeRanges `Record<string, AttributeRange>`	The span each numeric channel covers: unioned over the loaded displays, and over every fetch this view has already taken (`seenAttributeRanges`). A column has no declared domain, so this is what its ramp scales to, what the legend labels it with, and — since it is the one domain — what the two cannot disagree about. MONOTONIC, which is the point. A fetch's payload reports the span of the slice it holds, and that slice is the snapped window: painting straight off it re-maps every feature onto the ramp each time a pan rolls the window over, so a ribbon in the middle of the ramp turns into one at the bottom while the reader is scrolling and its value has not changed. A domain that only ever widens still says what the reader is looking at — the legend prints the actual numbers — and settles instead of oscillating. Monotonic UNTIL A MODE IS PICKED, which is the way back: one window holding an outlier would otherwise compress the ramp for the rest of the session, and the union above is over the LOADED spans, so `resetAttributeRanges` rescales to what is on screen there and then. View-wide rather than per display because the floating legend is one box for the whole view: two displays scaling the same ramp from different spans would make that one legend lie about one of them.	TrackColorsMixin
colorableTracks `ColorableTrack[]`	`colorableTrackConfigs` paired with whatever color the user pinned. This is the single definition of "the tracks that get colors" — the palette, the legend and the palette menu all read it, so they cannot disagree about which tracks are in play.	TrackColorsMixin
trackColorAssignments `Map<string, string>`	trackId -> the color it draws in under `colorBy: { field: 'track' }`. Assigned across the whole view rather than per display, so an automatic slot can't duplicate a color pinned on a sibling.	TrackColorsMixin
colorByField `string`	The field `colorBy` paints by, `''` for the default colour.	TrackColorsMixin
hasLegendKey `boolean`	Whether the floating legend is up: the mode has a key worth drawing — a ramp, a label per track, a chip per category — and the reader has not closed it for this mode. Default and strand are read without one, and the by-chromosome modes have no fixed key to show. Whether the mode has a key worth a box: a track palette, a ramp, or a reader-named column. The two structural presets key nothing on screen — their colors are the menu preview's.	TrackColorsMixin
showLegend `boolean`	The legend-host half of `LegendMixin` a view needs: whether the key draws, which is the mode having one and the reader not having closed it in this mode. `ChromeLegend` and `SvgLegend` read it.	TrackColorsMixin
colorLegendChips `ColorChip[]`	Legend rows naming the overlaid tracks — one per track with its palette color, however many levels it is on, and only under `colorBy: { field: 'track' }`, since every other mode has a fixed legend of its own.	TrackColorsMixin
colorScales `ColorScale[]`	The active mode's key as its one color scale, or none for a mode without one. View-wide rather than per display because the key is one box for the whole view, and the ramp domain it labels is the view's.	TrackColorsMixin
legendSpec `LegendSpec`	The key `ChromeLegend` draws on screen and `SvgLegend` in the export.	TrackColorsMixin

Methods

Member	Description	Defined by
trackContainerFor `(id: string) => TrackContainer \| undefined`	The level that owns a given track list, by id. The track-selector and add-track widgets target a level through here, since this view holds one track list per band rather than one of its own.	LinearSyntenyView
colorableTrackConfigs `() => { trackId: string; name: string; }[]`	Every synteny track across every level, in order.	LinearSyntenyView
colorableAttributeNames `() => string[]`	The numeric columns the overlaid tracks declare (the ortholog-table adapter's `attributeColumns`), one color mode each.	LinearSyntenyView
loadedAttributeRanges `() => Record<string, AttributeRange>[]`	Each loaded display's observed attribute spans, which the mixin unions into the domain the legend labels its ramp with.	LinearSyntenyView
legendAlpha `() => number`	The key's chips are composited by the ribbon alpha, as the ribbons are.	LinearSyntenyView
legendCigarOps `() => number`	Only the indel ops drawn on screen get a chip.	LinearSyntenyView
headerMenuItems `(extraSubMenus?: MenuItem[]) => MenuItem[]`	The header's view-options menu: the zoom actions, the row coupling, what varies with the stack under "Rows", then Export SVG. Every render setting is in `SyntenySettingsMenu` instead. `ViewOptionsMenuButton` passes the "Show..." submenu as `extraSubMenus`, since the search box prefs are React state.	LinearSyntenyView
menuItems `() => MenuItem[]`		LinearSyntenyView
rubberBandMenuItems `() => { label: string; onClick: () => void; }[]`		LinearSyntenyView
legendPointBased `() => boolean`	Overridable hook: whether the view draws each alignment as one flat point (the dotplot) rather than a ribbon with match and indel blocks.	TrackColorsMixin
trackColorFor `(trackId: string) => string`		TrackColorsMixin

Actions

Member	Description	Defined by
setFollowReport `(report: Partial<FollowReport>) => void`	Merge into `followReport`. Declared ahead of afterAttach, which installs the follow that calls it.	LinearSyntenyView
setFollowSynteny `(flag: boolean) => void`		LinearSyntenyView
setFollowAnchorIndex `(idx: number) => void`		LinearSyntenyView
clearClickedFeatures `() => void`	Release the clicked ribbon in every band, ahead of a band pointing its own: the drawer shows one feature, so one ribbon is outlined	LinearSyntenyView
holdFollowAnchor `<T>(fn: () => T) => T`	Run a navigation of a row as the follow's own placement rather than as a gesture. While following, a gesture on any row makes that row the anchor, and the follow tells a gesture from its own work by root action: whatever `fn` navigates is a nested action of this one.	LinearSyntenyView
takeOutRows `() => void`		LinearSyntenyView
reconcileLevels `() => void`	Keep exactly one synteny level per gap between adjacent views, growing or shrinking from the end, and both anchors inside the stack.	LinearSyntenyView
setWidth `(newWidth: number) => void`		LinearSyntenyView
setError `(e: unknown) => void`		LinearSyntenyView
setViews `(views: LaunchSnapshotIn<IModelType<…>, InitState, "bpPerPx" \| "cytobandsVisible" \| "offsetPx" \| "showCytobandsSetting">[]) => void`		LinearSyntenyView
addView `(view: LaunchSnapshotIn<IModelType<…>, InitState, "bpPerPx" \| "cytobandsVisible" \| "offsetPx" \| "showCytobandsSetting">) => void`	Push a new genome row. The new trailing level starts with no synteny tracks.	LinearSyntenyView
removeRow `(idx: number) => void`	Drop one genome row and the bands beside it. An interior row leaves one new band between the rows it separated, drawn by a track that connects them where the session has one — a track the removed bands were already showing first, which is what an all-vs-all file gives.	LinearSyntenyView
reverseRows `() => void`	Flip the stack top to bottom. Every band keeps the pair of rows it draws between, so its tracks stay with it.	LinearSyntenyView
setFollowMatchOrientation `(arg: boolean) => void`		LinearSyntenyView
setScrollZoom `(arg: boolean) => void`		LinearSyntenyView
activateTrackSelector `(level: number) => Widget`		LinearSyntenyView
toggleTrack `(trackId: string, level?: any) => boolean`		LinearSyntenyView
showTrack `(trackId: string, level?: any, initialSnapshot?: object, displayInitialSnapshot?: DisplayInitialSnapshot, inlineConf?: Record<string, unknown> \| undefined) => any`	No-op for a level that doesn't exist, matching hideTrack/toggleTrack.	LinearSyntenyView
launchTrack `(trackId: string, level?: any, initialSnapshot?: object, displayInitialSnapshot?: DisplayInitialSnapshot, inlineConf?: Record<string, unknown> \| undefined) => Promise<...>`	showTrack for a track whose display state model may be lazily loaded: loads it, then shows	LinearSyntenyView
hideTrack `(trackId: string, level?: any) => void`		LinearSyntenyView
panStack `(dx: number) => void`	A band's drag, over `bandGestureRows`. The rows' scrolls nest under this action, so none of them reads as a gesture that would take the anchor.	LinearSyntenyView
squareView `() => void`	Every row onto the rows' average bp/px, each keeping its centre.	LinearSyntenyView
showAllRegionsAcrossRows `(sameScale: boolean) => void`	Every row onto its whole assembly, either all on one bp/px — the coarsest row's fit, so the largest genome fills its pane and the others draw shorter in proportion — or each fit to its own pane. `sameScale` latches, so the shared scale holds across later zooms.	LinearSyntenyView
setSameScale `(sameScale: boolean) => void`		LinearSyntenyView
setDiagonalizeAnchorRow `(row: number) => void`		LinearSyntenyView
applySharedScale `() => void`	Latch `sameScale` and zoom every row onto the shared scale, keeping each row's regions and centre.	LinearSyntenyView
clearView `() => void`	Back to the import form. Drops `launch` too, which `hasSomethingToShow` keys off while there are no rows.	LinearSyntenyView
compactAllViews `() => void`		LinearSyntenyView
expandAllViews `() => void`		LinearSyntenyView
resizeAllLevelHeights `(distance: number) => void`	Resize every synteny band by the same delta, keeping their differences. Each level clamps its own drag (`resizeHeight`).	LinearSyntenyView
autoScaleLevelHeights `() => void`		LinearSyntenyView
appendRow `({ assembly, loc, syntenyTrackId, }: { assembly: string; loc?: string \| undefined; syntenyTrackId?: string \| undefined; }) => Promise<any> \| undefined`	Append an assembly to the bottom of the stack, optionally showing a synteny track on the new level. Returns `launchTrack`'s promise rather than awaiting it, so the action stays synchronous.	LinearSyntenyView
setDrawCurves `(arg: boolean) => void`		LinearSyntenyView
setCigarMode `(arg: "full" \| "matches" \| "off") => void`		LinearSyntenyView
setDrawLocationMarkers `(arg: boolean) => void`		LinearSyntenyView
setShowOffscreenMates `(flag: boolean) => void`		LinearSyntenyView
setOverdrawPx `(arg: number) => void`		LinearSyntenyView
setAlpha `(arg: number) => void`		LinearSyntenyView
setMinAlignmentLength `(arg: number) => void`		LinearSyntenyView
setLodMode `(arg: LodMode) => void`		LinearSyntenyView
setOpacityByIdentity `(arg: boolean) => void`		LinearSyntenyView
setFadeThinAlignmentsMode `(arg: FadeThinMode) => void`		LinearSyntenyView
setFadeThinLatch `(arg: boolean) => void`	Move the latched 'auto' thin-fade decision — `installAutoFadeLatch` is the only caller.	LinearSyntenyView
showAllRegions `() => void`	Every row back to its own whole assembly, fit to its own width, which also turns `sameScale` off.	LinearSyntenyView
setLaunch `(launch?: LaunchInput<LinearSyntenyViewCommands> \| undefined) => void`		LinearSyntenyView
exportSvg `(opts?: ExportSvgOptions) => Promise<string>`		LinearSyntenyView
setDisplayName `(name: string) => void`		BaseViewModel
setBodyMounted `(flag: boolean) => void`	See `bodyMounted`. Written by the view's container, which is the only thing that knows whether it rendered the body.	BaseViewModel
setMinimized `(flag: boolean) => void`		BaseViewModel
setAwaitingAutoDiagonalize `(arg: boolean) => void`		DiagonalizeProgressMixin
beginAutoDiagonalize `(requested: boolean) => void`	Declare the gate at the top of one init apply pass: a reorder is pending iff THIS init asked for one. Assigning rather than raising is what hands the gate over cleanly — a superseded init that asked for a reorder and then skipped it would otherwise leave the flag up with nothing coming, wedging `settled` forever.	DiagonalizeProgressMixin
finishAutoDiagonalize `() => void`	A reorder resolved, the init's or a manual one, so the view on screen is the diagonalized one — open the gate.	DiagonalizeProgressMixin
setDiagonalizeError `(error: unknown) => void`		DiagonalizeProgressMixin
setDiagonalizeCancel `(arg?: (() => void) \| undefined) => void`		DiagonalizeProgressMixin
cancelAutoDiagonalize `() => void`	Abort an in-flight auto-diagonalize; `withDiagonalizeProgress`'s finally clears the wait flag, revealing the (undiagonalized) view. Lowers the gate too. The abort reaches the caller as a throw, which skips its `finishAutoDiagonalize()` — right for a reorder that failed on its own (`settled` stays false and a capture times out loudly rather than committing a hairball), wrong for one the user stopped: cancelling IS the user settling for this view, and a gate nothing will lower again leaves `settled` false forever.	DiagonalizeProgressMixin
setImportFormSyntenyTrack `(idx: number, val: ImportFormSyntenyTrack) => void`		ImportFormSyntenyMixin
clearImportFormSyntenyTracks `() => void`	Drop the pending selections once a launch has applied them. Left in place they outlive the form: "Return to import form" would reopen on a finished upload from the previous launch, and a pair whose assemblies no longer match it reads as an unfinished upload and disables Launch.	ImportFormSyntenyMixin
observeAttributeRanges `(ranges: Record<string, AttributeRange>) => void`	Fold one fetch's observed attribute spans into the domain this view paints and labels its ramps with. Called by each display as its fetch lands, because the accumulation has to outlive the payload it came from: the previous window's span is gone from `loadedAttributeRanges` the moment the next one commits.	TrackColorsMixin
resetAttributeRanges `() => void`	Forget the accumulated domain, leaving `attributeRanges` reporting what the LOADED fetches cover and nothing else. The way back from a monotonic domain, and the only one: a single window holding an outlier widens the ramp for the rest of the session, and `attributeRanges` unions the loaded spans over this, so a reset rescales to what is on screen without waiting for a refetch. Picking a mode is what calls it — the gesture a reader makes when the ramp is telling them nothing is to choose it again.	TrackColorsMixin
setHideUnlabelled `(value: boolean) => void`		TrackColorsMixin
setColorBy `(field: string) => void`	Set the field the view paints by over the `colorBy` object (`''` for the default colour), and rescale the ramp, which is the only way back from a domain one outlying window widened.	TrackColorsMixin
setColorDomain `(domain: string[]) => void`	Declare the order a text column's labels take. The labels listed lead, the rest follow sorted; an empty list gives back the order the fetches found them in.	TrackColorsMixin
setTrackColor `(trackId: string, value: string \| undefined) => void`	Pin one track's color under `colorBy: { field: 'track' }`, or release it back to an automatic palette slot.	TrackColorsMixin
clearTrackColors `() => void`		TrackColorsMixin
setShowLegend `(show: boolean) => void`	Close the legend for the mode in use. The legend host's setter: closing the key hides it for this mode only, so picking another mode brings its key up.	TrackColorsMixin
dismissLegendSection `() => void`	One section is the whole key here.	TrackColorsMixin

Guide: URL query parameter API

LinearSyntenyView

Example usage#

Properties#

Volatiles#

Getters#

Methods#

Actions#

Related links#