Protected_Protected Readonly_Protected Readonly_Protected Readonly_ReadonlyfloatingShell-level anchor container dedicated to floating groups. Unlike
rootDropTargetContainer it is never disabled by the
dndOverlayMounting: 'relative' theme setting: a floating group cannot
use an in-place ('relative') overlay because the overlay would be
appended inside the floating window's stacking context
(.dv-resize-container, a lower z-index than the shell-level render
overlay that hosts the floating panel's content) and be painted over.
Routing floating groups through this always-anchored container keeps
their drop overlays visible in both mounting modes.
Protected ReadonlygridviewReadonlyonReadonlyonReadonlyonReadonlyonReadonlyonFires when any group is added; the service filters for location.type === 'edge'.
ReadonlyonReadonlyonReadonlyonReadonlyonFires whenever a popout window opens or closes, i.e. the set of popout documents changed. Used by accessibility services that mirror per-window state (e.g. a live region in each popout).
ReadonlyonReadonlyonReadonlyonReadonlyonFires when a group's resolved auto-hide state changes at runtime
(per-group setAutoHide), so a controller can dock/undock retroactively.
ReadonlyonFires with the dragged group when a floating group's move/resize drag
ends. Consumed by the Smart Guides service (ISmartGuidesHost) to tear
down its per-drag guides.
ReadonlyonCoalesced (microtask-buffered) ping after any layout change; the only signal for sash resize, which does not go through the mutation boundary.
ReadonlyonReadonlyonReadonlyonReadonlyonReadonlyonFires after a structural mutation; used to capture the post-image.
ReadonlyonReadonlyonFires after updateOptions; the service re-applies wrap to every group
so a runtime overflow.mode change takes effect.
ReadonlyonReadonlyonReadonlyonReadonlyonReadonlyonReadonlyonReadonlyonReadonlyonReadonlyonFires with the dragged group when a floating group move-drag first moves.
Consumed by the Smart Guides service (ISmartGuidesHost) to start each
drag from a clean slate (a redock long-press aborts with no end event).
ReadonlyonReadonlyonReadonlyonReadonlyonReadonlyonReadonlyonReadonlyonReadonlyonFires before / after a structural layout change; used to restore focus on close.
ReadonlyonFires on each drag-over with the hovered group + native event; the
signal the compass widget mounts/follows. The service filters for
kind === 'content'.
ReadonlyoverlayReadonlypopupReadonlyrootWhether the two-band edge drag-reveal affordance is registered. See
IRootDropTargetHost.hasEdgeDragReveal; must not be read during
module initialisation, only from init/postConstruct onwards.
Fires when a dragged float commits an alignment snap on drop.
Fires when a dragged float commits a dock/merge on drop.
The auto-hide peek mounts on the shell, the same element the
OverlayRenderContainer roots on, so always content re-anchors in the
peek's coordinate space.
The PinnedTabs module service, or undefined when that module is not
registered. The tab context menu auto-injects a Pin/Unpin item only when
this is present (and pinning is enabled); it's an optional enhancement,
never a hard dependency.
Promise that resolves when all popout groups from the last fromJSON call are restored. Useful for tests that need to wait for delayed popout creation.
Outermost element: the shell (incl. edge groups) once built, else the gridview.
Whether Smart Guides snapping is currently active.
Optionaloptions: FloatingGroupOptionsInternalOptionaloptions: AddGroupOptionsOptionaloptions: DockviewPopoutGroupOptionsInternalThe next / previous group in gridview (spatial) order, wrapping round. The keyboard accessibility module's focus navigation is built on this primitive, the only piece that needs the grid internals; the rest of the navigation logic lives in the KeyboardNavigationService.
The nearest grid group in a spatial direction from group, by
comparing group centre points. Floating and popout groups sit outside
the grid's geometry and are ignored. Returns undefined when there is
no group in that direction.
Announce a message to assistive technology via the shared live region
(no-op when no live-region service / announcements: false).
Auto-hide (collapse to strip) the edge group at a position.
Resolve the custom group drag ghost (via the AdvancedDnD module), or
undefined to fall back to the default chip. Returns undefined when
the module is absent, and the default ghost then renders.
IDndCompassHost: whether a content drop at position on group is
allowed, for compass cell gating (only legal cells are shown). The same
predicate the content drop target uses, so the compass and the real drop
agree.
Drop both undo and redo stacks.
Optionaloptions: GroupOptionsThe origin of the operation currently in progress ('user' by default).
Read inside a mutation() or active-panel change to learn whether the
change was driven by application code (via the DockviewApi) or a
user gesture.
Coalesce a panel's onDidLocationChange to the end of the enclosing
transaction, or fire it immediately when no transaction is in flight.
Relocating a panel touches its location twice: once as it is reparented
into the destination group - which, when that group has just been created
for a floating or popout window, has not been told where it lives yet -
and once as the group is tagged with its final location. Reporting each
signal as it happens therefore leaks an intermediate grid location the
panel was never in, at a moment when it belongs to neither group's panel
list and so is missing from api.panels.
Deferring collapses those signals into a single event carrying the
settled location. Note the signals are deliberately not compared
against the panel's previous location: a panel can move between two
floating windows without its location type changing, and this event is
the only signal OverlayRenderContainer has to re-resolve the panel's
z-index against its new host window.
Build, fire, and return the verdict for an unhandled-drag-over event. Implemented on the component side so the service stays free of circular imports with the event class declared in dockviewComponent.
ProtecteddoOptionalsize: numberDock the dragged item against the whole-layout edge at position (the
orthogonalized root group), as the layout-edge drop zones do. Shared by
the root drop target and by an edge-flagged drop on a group content
target (a position resolver that marks an outer "dock to the layout edge"
cell). No-op when there is no active drag data.
ProtecteddoOptionaloptions: {Float the panel into a new floating group: the keyboard-move "float" terminal action.
ProtectedforceOptionaloptions: { reuseExistingPanels: boolean }IDndCompassHost: the frame the content drop target measures (mirrors the
getOverlayOutline rule in content.ts): the whole group when
dndPanelOverlay === 'group', else just the content. The compass paints
in this frame so its cells align with where a drop resolves.
The drop-position resolver installed on the group content drop targets:
the app's dropPositionResolver option if set, else the DnD compass
module's compass resolver (undefined when the compass is disabled). Read
live by the content drop targets; undefined ⇒ default cursor-quadrant.
Viewport rect of the docked content area (the element the root/group drop targets hit-test against), used by the two-band drag-reveal affordance to classify a pointer's distance from each edge. This is the gridview/center container, which is inset when edge groups are present, so the outer band sits at the boundary of the content area (adjacent to any existing edge group) rather than at the shell's outer edge.
The size an edge group expands to (pre-collapse); sizes the peek.
The edge group panel at a position (the model, not the api).
ISmartGuidesHost: the positioning parent floats are placed in, also the coordinate space the Smart Guides overlay draws its alignment lines in.
ISmartGuidesHost: the other floats' group identity + container-relative box, for the snap-together detector.
Resolve the floating window hosting group, matched by membership so it
finds nested (non-anchor) members too — a floating window can host a
whole nested gridview, not just its anchor group. Returns undefined
when the group isn't in any floating window. floatingGroups alone only
exposes each window's anchor, so consumers that must act on any member
(e.g. lifting an always-rendered panel's overlay above the window)
should use this instead of a .find(f => f.group === group).
ISmartGuidesHost: the main grid's splitter (sash) rectangles, in the floating container's coordinate space, for the optional splitter target.
Resolve which gridview root currently owns a group: the main grid, or the nested gridview of the floating / popout window it lives in.
IDndCompassHost: the layout root (.dv-dockview, a positioned element),
the surface the outer-cell landing preview is drawn over.
Enumerate the popout groups currently open in their own windows.
The live popout Window handles, one per open popout group. The
narrow surface accessibility services need to mirror per-window state.
Returns the PopupService that should host popovers (context menus, tab overflow menus) for the given group. Popout groups have their own service rooted in their popout window so the popover renders there and dismisses on events from that window.
IMultiRowTabsHost: the group's scrollable tab list (.dv-tabs-container),
the element the wrap controller toggles + measures.
Resolve whether an edge group should behave as an auto-hide (pinnable)
tool window: the per-group flag when set, otherwise the per-edge
autoHideEdgeGroups option for the group's edge. This is what lets a
static edge group and an auto-hiding one co-exist in the same layout.
OptionalforceResize: booleanISmartGuidesHost: dock/merge a dragged float into a target group via the existing move primitive (so events + undo cover it).
Bracket a structural mutation with onWillMutateLayout /
onDidMutateLayout. Re-entrant: nested calls (a compound operation such
as a drag that relocates a panel) join the outermost transaction, so the
events fire exactly once around the whole operation. kind reflects the
outermost mutation.
Does this dock own node, in any of its windows? True when the node is
inside the main shell, or inside one of this component's popout documents.
A popout window hosts only this component's content, so whole-document
membership is sufficient there; the main document may hold sibling docks,
so it must be a containment check. A same-document popout (the jsdom mock)
is already covered by the main check and contributes nothing.
Peek (slide out) / close the collapsed edge group at a position.
Pin (expand) the edge group at a position. Reports the missing module if
AutoHideEdgeGroup is absent, since this command is reachable without the
autoHideEdgeGroups option that would otherwise have named it.
Re-apply the next layout mutation (no-op if nothing to redo).
IMultiRowTabsHost: re-run a group's layout so a wrapped-header height change propagates to the content + active panel.
Optionaloptions: {Optionaloptions: {Reposition a single renderer:'always' panel's overlay over its
reference container, optionally forcing it visible (the auto-hide peek
slides an always panel out without reparenting it or touching its
visibility state). No-op for non-overlay-rendered panels.
Optionalclip: DOMRectResolve the app-supplied drop overlay model (via the AdvancedDnD module)
for a group drop target, or undefined to keep the target's default.
Optionalgroup: DockviewGroupPanelReveal (create-or-fill) the edge group at position and move the dragged
item described by data into it. A newly created edge group is created
collapsed, flagged autoReveal so it tears down to zero footprint when
later emptied, and takes its auto-hide state from options.autoHide. If an
edge group already exists there it is reused: the panel is added to its
tabs and its collapsed/toggled and auto-hide state are left as-is (never
re-created; addEdgeGroup throws on a duplicate position). This keeps a
drag-reveal from silently converting a static edge group into an
auto-hiding one; to change an existing group's auto-hide, call
api.getEdgeGroup(position)?.setAutoHide(...) directly. No-op if the
EdgeGroup module is absent.
This is the primitive behind the dock-to-edge groups: the two-band drag-reveal affordance routes its outer-band drops here.
Optionaloptions: { autoHide?: boolean }Set (or clear, via undefined) the per-group auto-hide flag and notify
the auto-hide module so it can dock/undock the group at runtime.
Collapse/expand an edge group: the single mutate path (fires
onDidCollapsedChange, no-op guarded).
Set the peek state and fire the group's onDidPeekChange (called by the
auto-hide service).
IMultiRowTabsHost: force the wrap controller's surplus set (rows beyond
overflow.maxRows) into the group's overflow dropdown.
Pin/unpin a panel's tab. The single gated entry point behind
panel.api.setPinned. Dormant unless pinnedTabs.enabled is set (a
silent no-op), and a silent no-op when the PinnedTabs module is not
registered: reaching past the enabled check means the option was set,
so the option rule has already named the missing module. When active it
mutates the panel's pinned flag (which fires
panel.api.onDidChangePinned) and the component-level
onDidPanelPinnedChange; the module reacts to enforce pinned-first
ordering.
Toggle Smart Guides snapping at runtime (no-op if the module is absent).
Serialize the current state of the layout
A JSON respresentation of the layout
Undo the previous recorded layout mutation (no-op if nothing to undo or
the LayoutHistory module is absent). Requires layoutHistory.enabled.
Merge a partial Smart Guides option override in at runtime.
Run func with the operation origin set to origin, restoring the
previous value afterwards. Used by the DockviewApi boundary to tag
programmatic operations as 'api', and by user-gesture handlers to tag
'user'. Only the outermost caller sets the origin; a nested call (or a
call made while a mutation is already in flight) keeps whatever the
enclosing operation established, so the trigger always wins.
The narrow surface the layout-history service needs from the host (
DockviewComponent). It reads/writes whole-layout snapshots and listens to the mutation-transaction boundary, the only place a pre-image can be taken before a mutation runs.