type: types.literal('LinearSyntenyView') | | LinearSyntenyView |
| **cigarMode**drawCurves: types.stripDefault(types.boolean, false) | Render ribbons as bezier curves rather than straight chords. Reads much better at whole-genome scale, where straight crossings stack into noise. | LinearSyntenyView |
| **drawLocationMarkers**drawLocationMarkers: types.stripDefault(types.boolean, false) | Continue the query view's scalebar grid down through the ribbons: 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, on the query axis, the alignments whose mate is on a contig the facing row is not displaying — real synteny a ribbon has nowhere to land, which the view otherwise draws nothing for. | LinearSyntenyView |
| **bidirectionalFetch**bidirectionalFetch: types.stripDefault(types.boolean, false) | Ask each level's adapter for the alignments anchored on its LOWER row as well as its upper one.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**opacityByIdentity: types.stripDefault(types.boolean, false) | Fade alignment blocks by per-feature identity (lower identity = more transparent). Orthogonal to colorBy — surfaces identity-dropoff zones without consuming the color channel. | LinearSyntenyView |
| **fadeThinAlignmentsMode**init: types.frozen<LinearSyntenyViewCommands | undefined>() | used for initializing the view from a session snapshot. tracks is 2D — outer index is the level (the gap between views[i] and views[i+1]), so a 3-way view has two entries. example: ```json { views: [ { loc: "chr1:1-100", assembly: "hg38", tracks: ["genes"] }, { loc: "chr1:1-100", assembly: "mm39" }, { loc: "chr1:1-100", assembly: "rn7" } ], tracks: [["hg38_vs_mm39_synteny"], ["mm39_vs_rn7_synteny"]] } ``` | LinearSyntenyView |
| **id**id: ElementId | | [LinearComparativeView](../linearcomparativeview#property-id) |
| **trackSelectorType**linkViews: types.stripDefault(types.boolean, false) | sync scroll and zoom across the genome rows, so panning one pans them all | [LinearComparativeView](../linearcomparativeview#property-linkviews) |
| **followSynteny**followSynteny: types.stripDefault(types.boolean, false) | Move the non-anchor genome rows to whatever region aligns to the anchor row, re-resolved through the synteny data each time the anchor settles. The synteny-aware alternative to `linkViews`, which locks the rows in PIXELS and so drifts apart as soon as an indel accumulates — the two are mutually exclusive (see setRowSyncMode). | [LinearComparativeView](../linearcomparativeview#property-followsynteny) |
| **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 all filling their pane. A mode rather than a one-shot zoom because it is the rows' zoom-out LIMIT it moves (`sharedFit`), and a limit has to still be there on the next wheel tick. | [LinearComparativeView](../linearcomparativeview#property-samescale) |
| **followAnchorIndex**followAnchorIndex: types.stripDefault(types.number, 0) | Which genome row drives the others while `followSynteny` is on. Every other row is placed by mapping this one's window outward one level at a time. Clamped to the views array by reconcileLevels. | [LinearComparativeView](../linearcomparativeview#property-followanchorindex) |
| **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. Off by default: the crossing ribbons are the picture of an inversion, and a row turning round under the reader is the loudest thing one can do. | [LinearComparativeView](../linearcomparativeview#property-followmatchorientation) |
| **levels**levels: types.array(LinearSyntenyLevel) | One synteny band per adjacent pair of `views`. Each holds its own track list, which is why the track-selector and add-track widgets address them through `trackContainerFor` — a level is not a view and cannot be the target of their `view` reference. | [LinearComparativeView](../linearcomparativeview#property-levels) |
| **views**displayName: types.maybe(types.string) | displayName is displayed in the header of the view, or assembly names being used if none is specified | [BaseViewModel](../baseviewmodel#property-displayname) |
| **minimized**minimized: types.stripDefault(types.boolean, false) | collapse the view to its header bar, keeping it in the session rather than closing it | [BaseViewModel](../baseviewmodel#property-minimized) |
| **colorBy**colorBy: types.stripDefault(types.string, 'default') | The color-by mode the whole view renders with, unless a track overrides it in `trackColorBy`. | [TrackColorsMixin](../trackcolorsmixin#property-colorby) |
| **trackColorBy**trackColorBy: types.map(types.string) | trackId -> color-by mode for that track alone. Absent means the track follows the view-wide `colorBy`. | [TrackColorsMixin](../trackcolorsmixin#property-trackcolorby) |
| **trackColors**trackColors: types.map(types.string) | trackId -> explicit color under `colorBy: 'track'`. Absent means the track takes an automatic slot from the palette. | [TrackColorsMixin](../trackcolorsmixin#property-trackcolors) |
| **showColorLegend**showColorLegend: types.stripDefault(types.boolean, false) | Show the floating color-by legend. Dismissible via the legend's close button; re-enable from the color-by (palette) menu. | [TrackColorsMixin](../trackcolorsmixin#property-showcolorlegend) |
## Volatiles
| Member | Description | Defined by |
| --- | --- | --- |
| **importFormSyntenyTrackSelections**fadeThinLatch: false | Whether the 'auto' thin-fade is latched on. State rather than a derived value because the decision has hysteresis, and hysteresis is a memory — see `fadeThinAlignments`. | LinearSyntenyView |
| **width**width: undefined as number | undefined | | [LinearComparativeView](../linearcomparativeview#volatile-width) |
| **volatileError**volatileError: undefined as unknown | View-level failure (e.g. an `init` block that couldn't be applied). Volatile on purpose: a reload re-runs the init autorun from a clean slate, so a transient failure stays recoverable. | [LinearComparativeView](../linearcomparativeview#volatile-volatileerror) |
| **followUnaligned**followUnaligned: false | The follow found no alignment over the anchor row's window on its last pass, so the other rows are holding position. What the header's follow button reports; without it the rows simply stop tracking, which is the same picture as a broken follow. Volatile because it describes the current window, not the session. | [LinearComparativeView](../linearcomparativeview#volatile-followunaligned) |
| **followApproximate**followApproximate: false | The follow placed a row by mapping the anchor window proportionally rather than by walking a CIGAR, so its position is close but not base-exact — a window wider than one alignment, or a tier carrying no CIGAR. What the header's follow tooltip reports; nothing else in the view distinguishes the two. | [LinearComparativeView](../linearcomparativeview#volatile-followapproximate) |
| **followPartial**followPartial: undefined as FollowPartialReport | undefined | The follow had a multi-contig answer and refused it: placing a row on two regions that are not neighbours in its layout puts every contig between them on screen too, and past a point that is nearly all of what the reader is looking at. The rows are on one of the anchor's regions instead, and this names it and the ones whose answers are therefore off screen — enough for the header to say which region to scroll onto to see those instead. Read only by the header's follow tooltip. | [LinearComparativeView](../linearcomparativeview#volatile-followpartial) |
| **bodyMounted**bodyMounted: true | Whether the container has this view's body in the DOM.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](../diagonalizeprogressmixin#volatile-awaitingautodiagonalize) |
| **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.diagonalizeStatus: createStatusChannel() | Live status from the auto-diagonalize RPC (download %, parse, algorithm phase) shown on the reordering spinner; blank outside that wait.diagonalizeStopToken: undefined as StopToken | undefined | Stop token for the in-flight auto-diagonalize, so the spinner's Cancel can abort it; undefined when none is running. | [DiagonalizeProgressMixin](../diagonalizeprogressmixin#volatile-diagonalizestoptoken) |
| **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 an `attribute:boolean | | LinearSyntenyView |
| **initPending**boolean | An `init` blob that has not been applied yet — `installInitAutorun` clears it as the last thing an apply pass does. The view is assembling itself: the rows can already exist, and be initialized, while the synteny tracks are still several awaits away, which is why the levels' `settled` gate reads this.boolean | Opt each sub-view's scalebar into prefixing its refName labels with the assembly name (e.g. "hg38:chr1"), so stacked genome rows of different assemblies stay distinguishable. Read duck-typed by the child LinearGenomeView (scalebarDisplayPrefix) to avoid an upward plugin dependency. | LinearSyntenyView |
| **drawCIGAR**boolean | | LinearSyntenyView |
| **drawCIGARMatchesOnly**boolean | | LinearSyntenyView |
| **hasLodCapableAdapter**boolean | True if any track on any level has an adapter with tiered storage. Used to gate the "Level of detail" row — PAFAdapter, BlastTabularAdapter and friends have nothing to switch between. | LinearSyntenyView |
| **hasCigarData**boolean | True if any synteny display could show CIGAR detail — used to gate the CIGAR settings row, which a CIGAR-less PAF has nothing to put in. Optimistic while no display has finished a fetch yet, so the row is there from the first render rather than popping in once data lands (the common case: most synteny files carry CIGARs). A view with no synteny tracks at all has nothing to gate, so it reports false. | LinearSyntenyView |
| **offscreenMateMode**"both" | "off" | "query" | Which of the three steps the two properties are in. `both` implies marking, so a hand-written snapshot that fetches the lower row without drawing it reads as the mode it behaves like — the fetch is happening, and the marks are the half of it that shows. | LinearSyntenyView |
| **offscreenMateTally**{ refName: string; count: number; }[] | The contigs this view has alignments to and cannot draw, largest first. A locus can be syntenic to a contig you did not stack, and a view showing no ribbon for it looks exactly like one where it is syntenic to nothing; the marks along the axis are what says so, and a mark's tooltip is where this contig's own number appears.number | Union across every loaded synteny display of which CIGAR indel ops are actually drawn on screen. The floating legend lists an indel chip only when a visible-width op of that kind is painted somewhere in the view. | LinearSyntenyView |
| **fadeThinAlignments**boolean | Resolved fade-thin flag that every display's renderParams reads. In 'auto' mode the fade turns on once ANY loaded synteny display is dominated by sub-pixel ribbons (a thin hairball that benefits from decluttering); a sparse view keeps its few ribbons at full alpha. 'on'/'off' pin it.number | The width 'auto' compares against its thresholds: the narrowest capped mean block width any loaded display reports, or `Infinity` when none of them has enough blocks to judge by. Each display measures its own ribbons (`cappedMeanAlignmentPx`) and this takes the thinnest, so the densest level in a stack carries the view-wide decision.string | undefined | The "anchor" assembly for colorBy:'reference': the assembly bordering the most synteny levels. In a stacked ref-vs-A / ref-vs-B layout each interior assembly touches two levels and the ends touch one, so the max-adjacency assembly is the shared reference. Ties resolve to the topmost. Every level then colors by this assembly's chromosome names, so a region keeps its color as it's traced across levels. | LinearSyntenyView |
| **colorableTrackConfigs**() => { trackId: string; name: string; }[] | Every synteny track across every level, in order, paired with whatever color the user pinned on it. View-wide rather than per level: the floating legend is one box for the whole stack, so two levels handing out the same color would make that one legend lie. | LinearSyntenyView |
| **showLoading**boolean | Whether to show a loading indicator instead of the import form or view | LinearSyntenyView |
| **loadingAssembly**string | undefined | Label for the generic loading spinner, naming the assembly file being downloaded when the assembly load is what the wait is. The auto-diagonalize wait is a separate render branch (DiagonalizeLoadingScreen), so this only covers the plain "view not ready" case. | LinearSyntenyView |
| **loadingProgress**number | undefined | Determinate fraction for the spinner's bar, when the assembly load reports one | LinearSyntenyView |
| **loadingSource**string | undefined | The URL the assembly load is currently fetching, when the phase named one. Only the stalled-load notice reads it — see `ViewLoadingScreen`. | LinearSyntenyView |
| **showImportForm**boolean | Whether to show the import form. A failed `init` counts: `init` is kept so a reload can retry it, but in this session there is nothing to show and no second attempt coming, so the form (with the error banner) is the only way forward — matching LGV/dotplot/circular, which also fall back to the form on error rather than spinning. | LinearSyntenyView |
| **status**ViewStatus | The view's lifecycle as one value — ready, error, loading or noRegions — for a host that draws its own chrome and has to render all four. Same shape and same precedence as the linear view's, through `computeViewStatus`.boolean | scroll-to-zoom is a global, personal preference resolved from the session; toggling it in any view applies everywhere | [LinearComparativeView](../linearcomparativeview#getter-scrollzoom) |
| **initialized**boolean | | [LinearComparativeView](../linearcomparativeview#getter-initialized) |
| **error**unknown | | [LinearComparativeView](../linearcomparativeview#getter-error) |
| **assemblyNames**string[] | | [LinearComparativeView](../linearcomparativeview#getter-assemblynames) |
| SharedFit | The zoom-out limit every row shares while `sameScale` is on, and whether it can be answered at all. Each row PULLS this back through its own `maxBpPerPx` (`sharedScaleContainerOf` finds this view by the presence of this getter), so nothing here is copied onto the rows and nothing can go stale between a resize and the next layout. The dotplot's `lockAspectRatio` derives the same quantity the same way.any[] | Every synteny display across every level, flattened. One memoized getter for the view-wide aggregates that would otherwise each re-flatten the levels. | [LinearComparativeView](../linearcomparativeview#getter-allsyntenydisplays) |
| **followPairs**{…}[] | Each synteny level resolved into the pair of rows a follow would move it between: which row stays, which row moves, which axis the anchor window is read off, and the assembly naming the level's lane of an all-vs-all track. Levels whose rows are not both initialized are dropped, since there is nothing to place yet.ComparativeWarning[] | Data-quality warnings raised by every synteny display, e.g. a reversed assembly row order. What the header's warning button counts. | [LinearComparativeView](../linearcomparativeview#getter-syntenywarnings) |
| **trackWarnings**TrackWarning[] | The same warnings grouped under the track that raised each, which is what the dialog reports. A stacked view's levels raise `swappedAssembliesWarning` verbatim, and so does every overlaid track that hits it, so the flat list above was N identical rows with nothing to tell the user which file to go fix. Shared with the dotplot's table so the two reports say the same thing. | [LinearComparativeView](../linearcomparativeview#getter-trackwarnings) |
| **trackContainers**TrackContainer[] | The same track lists, for a reader with no id to ask with. This view has no `tracks` of its own, so anything walking a session for displays — `AppReadyMarker`, the capture harness's busy probe — sees an empty view and reports a still-fetching synteny stack as idle unless it asks here too. | [LinearComparativeView](../linearcomparativeview#getter-trackcontainers) |
| **effectiveBodyMounted**boolean | Whether this view's body is in the DOM, counting the views it is nested inside — which is the question a display's phase actually asks.string[] | Distinct numeric columns across the overlaid tracks, in first-seen order — two tracks declaring `dn` offer one `dn` mode, not two. | [TrackColorsMixin](../trackcolorsmixin#getter-colorableattributes) |
| **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`). An `attribute: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](../trackcolorsmixin#getter-colorabletracks) |
| **trackColorAssignments**Map<string, string> | trackId -> the color it draws in under `colorBy: 'track'`. Assigned across the whole view rather than per display, so an automatic slot can't duplicate a color pinned on a sibling. | [TrackColorsMixin](../trackcolorsmixin#getter-trackcolorassignments) |
| **uniformColorBy**SyntenyColorBy | undefined | The mode to report as "the view's mode" — undefined when tracks disagree, so the menu shows nothing checked and the legend says so instead of picking one track's answer for everyone. | [TrackColorsMixin](../trackcolorsmixin#getter-uniformcolorby) |
| **colorLegendChips**ColorChip[] | Legend rows naming the overlaid tracks — non-empty only when they are colored by track, or by different modes. | [TrackColorsMixin](../trackcolorsmixin#getter-colorlegendchips) |
## Methods
| Member | Description | Defined by |
| --- | --- | --- |
| **colorableAttributeNames**() => string[] | The numeric columns the overlaid tracks declare, so the palette menu can offer one mode per measurement without any of them being a named mode. `attributeColumns` is the ortholog-table adapter's slot; a track whose adapter has no such slot contributes nothing. | 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 |
| () => MenuItem[] | The header hamburger, which is NOT a subset of `menuItems()` — the two share only Export SVG. This one is the synteny surface; the app menubar's is the generic view one.() => MenuItem[] | | LinearSyntenyView |
| **isViewCompact**(idx: number) => boolean | | [LinearComparativeView](../linearcomparativeview#method-isviewcompact) |
| **trackContainerFor**(id: string) => TrackContainer | undefined | The level that owns a given track list. This view holds one track list per synteny band rather than one of its own, so the track-selector and add-track widgets target a level through here instead of referencing this view directly. By id, not index: reconcileLevels pops levels when a genome row is removed, and an index would silently retarget a different pair. | [LinearComparativeView](../linearcomparativeview#method-trackcontainerfor) |
| () => MenuItem[] | items for the "Show..." submenu in the header. overridden by subclasses to add view-specific toggle options | [LinearComparativeView](../linearcomparativeview#method-showmenuitems) |
| () => { label: string; onClick: () => void; }[] | | [LinearComparativeView](../linearcomparativeview#method-rubberbandmenuitems) |
| **colorableTrackConfigs**() => { trackId: string; name: string; }[] | The tracks that can take a palette slot, in paint order. Overridden by the composing view; a method rather than a getter because that is the form MST overrides cleanly. | [TrackColorsMixin](../trackcolorsmixin#method-colorabletrackconfigs) |
| **resolveColorBy**(trackId: string) => SyntenyColorBy | The mode one track renders with: its own override, else the view-wide mode. | [TrackColorsMixin](../trackcolorsmixin#method-resolvecolorby) |
| **trackColorFor**(trackId: string) => string | | [TrackColorsMixin](../trackcolorsmixin#method-trackcolorfor) |
## Actions
| Member | Description | Defined by |
| --- | --- | --- |
| **clearImportFormSyntenyTracks**() => void | Drop every pending pair-selection. The import form rewrites the whole list through this whenever its assembly rows change (a selection is about a pair of assemblies, not a row index — see `remapSelectionsToPairs`), and again once they have been applied. | LinearSyntenyView |
| **setImportFormSyntenyTrack**(arg: number, val: ImportFormSyntenyTrack) => void | | LinearSyntenyView |
| **setDrawCurves**(arg: boolean) => void | | LinearSyntenyView |
| **setCigarMode**(arg: "full" | "matches" | "off") => void | | LinearSyntenyView |
| **setDrawLocationMarkers**(arg: boolean) => void | | LinearSyntenyView |
| **setShowOffscreenMates**(arg: boolean) => void | | LinearSyntenyView |
| **setBidirectionalFetch**(arg: boolean) => void | | LinearSyntenyView |
| **setOffscreenMateMode**(mode: "both" | "off" | "query") => void | The two properties above as the one question a reader is actually answering — how much of what this view cannot draw to go and find.(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 — and so also the way off `sameScale`, whose raised ceiling would otherwise make "show all regions" mean the shared scale on every row. The fit-to-width half of `showAllRegionsAcrossRows`, under the name the rest of the app reaches it by. | LinearSyntenyView |
| **setInit**(init?: LinearSyntenyViewCommands | undefined) => void | | LinearSyntenyView |
| **clearView**() => void | Also drops `init`, which `hasSomethingToShow` keys off while views is empty — leaving it set would bounce "return to import form" straight back to the loading spinner. | LinearSyntenyView |
| **exportSvg**(opts: ExportSvgOptions) => Promise<void> | | LinearSyntenyView |
| **setFollowUnaligned**(arg: boolean) => void | Written by the follow's autorun and read only by the header, which is what keeps it from being a dependency of the very pass that writes it.(arg: boolean) => void | Same terms as setFollowUnaligned above: written by the autorun, read only by the header. | [LinearComparativeView](../linearcomparativeview#action-setfollowapproximate) |
| **setFollowPartial**(arg: FollowPartialReport | undefined) => void | Same terms again: written by the autorun, read only by the header. | [LinearComparativeView](../linearcomparativeview#action-setfollowpartial) |
| **reconcileLevels**() => void | Reconcile the levels array to the views array: exactly one synteny level per gap between adjacent views (N views -> N-1 levels). Grows or shrinks from the end, preserving existing levels and their tracks. The single source of truth for the views/levels invariant. | [LinearComparativeView](../linearcomparativeview#action-reconcilelevels) |
| **setWidth**(newWidth: number) => void | | [LinearComparativeView](../linearcomparativeview#action-setwidth) |
| **setError**(e: unknown) => void | | [LinearComparativeView](../linearcomparativeview#action-seterror) |
| **setViews**() => void | Drop the bottom genome row and its synteny level. Only terminal removal is supported: a level's `level` index addresses views[level]/[level+1], so removing a middle row would require reindexing every level below it. Growth and shrinkage both happen at the end of the chain. | [LinearComparativeView](../linearcomparativeview#action-removelastrow) |
| **setLinkViews**(arg: boolean) => void | Kept for the plugin ABI; `setRowSyncMode` is what the UI calls. It still has to drop the follow, since the exclusion below is a property of the two flags rather than of the action that happens to set them. | [LinearComparativeView](../linearcomparativeview#action-setlinkviews) |
| **setRowSyncMode**(mode: "follow" | "independent" | "link") => void | The one way the UI changes how the rows track each other, so the two flags can't both be on. They fight if they are: `linkViews` replays the anchor's own scroll/zoom onto every row, which is precisely the pixel lock the follow then has to undo on the next settle, and the moving row visibly jumps twice. | [LinearComparativeView](../linearcomparativeview#action-setrowsyncmode) |
| **setFollowAnchorIndex**(idx: number) => void | | [LinearComparativeView](../linearcomparativeview#action-setfollowanchorindex) |
| **setFollowMatchOrientation**(arg: boolean) => void | | [LinearComparativeView](../linearcomparativeview#action-setfollowmatchorientation) |
| **setScrollZoom**(arg: boolean) => void | | [LinearComparativeView](../linearcomparativeview#action-setscrollzoom) |
| **activateTrackSelector**(level: number) => Widget | | [LinearComparativeView](../linearcomparativeview#action-activatetrackselector) |
| **toggleTrack**(trackId: string, level?: any) => any | | [LinearComparativeView](../linearcomparativeview#action-toggletrack) |
| **showTrack**(trackId: string, level?: any) => void | | [LinearComparativeView](../linearcomparativeview#action-hidetrack) |
| **squareView**() => void | | [LinearComparativeView](../linearcomparativeview#action-squareview) |
| **showAllRegionsAcrossRows**(sameScale: boolean) => void | Every row onto its whole assembly, and the one choice about it: leave them all on ONE bp/px — the coarsest row's fit, so the largest genome fills its pane and every other row is drawn shorter in proportion to its size — or hand each row its own fit, so each fills its own pane.(sameScale: boolean) => void | | [LinearComparativeView](../linearcomparativeview#action-setsamescale) |
| () => void | Latch the mode and zoom every row onto the scale it implies, without touching any row's regions or its centre — `init` names a `loc` per row, and both a region reset and a re-centre would throw that away. `zoomTo` anchors at the centre, which is the difference. | [LinearComparativeView](../linearcomparativeview#action-applysharedscale) |
| **toggleCompactView**(idx: number) => void | | [LinearComparativeView](../linearcomparativeview#action-togglecompactview) |
| **compactAllViews**() => void | | [LinearComparativeView](../linearcomparativeview#action-compactallviews) |
| **expandAllViews**() => void | | [LinearComparativeView](../linearcomparativeview#action-expandallviews) |
| **autoScaleLevelHeights**() => void | | [LinearComparativeView](../linearcomparativeview#action-autoscalelevelheights) |
| **appendRow**(name: string) => void | | [BaseViewModel](../baseviewmodel#action-setdisplayname) |
| **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](../baseviewmodel#action-setbodymounted) |
| **setMinimized**(flag: boolean) => void | | [BaseViewModel](../baseviewmodel#action-setminimized) |
| **setAwaitingAutoDiagonalize**(arg: boolean) => void | | [DiagonalizeProgressMixin](../diagonalizeprogressmixin#action-setawaitingautodiagonalize) |
| **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](../diagonalizeprogressmixin#action-beginautodiagonalize) |
| **finishAutoDiagonalize**() => void | The init-time reorder resolved, so the view on screen is the diagonalized one — open the gate. | [DiagonalizeProgressMixin](../diagonalizeprogressmixin#action-finishautodiagonalize) |
| **setDiagonalizeStopToken**(arg?: StopToken | undefined) => void | | [DiagonalizeProgressMixin](../diagonalizeprogressmixin#action-setdiagonalizestoptoken) |
| **cancelAutoDiagonalize**() => void | Abort an in-flight auto-diagonalize; `withDiagonalizeProgress`'s finally clears the wait flag, revealing the (undiagonalized) view.(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](../trackcolorsmixin#action-observeattributeranges) |
| **resetAttributeRanges**() => void | Forget the accumulated domain, leaving `attributeRanges` reporting what the LOADED fetches cover and nothing else.(value: SyntenyColorBy) => void | Set the view-wide mode. Clears every per-track override, so picking a mode from the top level of the palette menu really does mean "all tracks" — and rescales the ramp, which is the only way back from a domain one outlying window widened. | [TrackColorsMixin](../trackcolorsmixin#action-setcolorby) |
| **setTrackColorBy**(trackId: string, value: SyntenyColorBy | undefined) => void | Point one track at its own mode, or back at the view-wide one. | [TrackColorsMixin](../trackcolorsmixin#action-settrackcolorby) |
| **setTrackColor**(trackId: string, value: string | undefined) => void | Pin one track's color under `colorBy: 'track'`, or release it back to an automatic palette slot. | [TrackColorsMixin](../trackcolorsmixin#action-settrackcolor) |
| **clearTrackColorSettings**() => void | | [TrackColorsMixin](../trackcolorsmixin#action-cleartrackcolorsettings) |
| **setShowColorLegend**(value: boolean) => void | | [TrackColorsMixin](../trackcolorsmixin#action-setshowcolorlegend) |