| NPhosphorAnimation | |
| Ndetail | |
| COkLab | |
| CDecomposedTransform | |
| NSnapPolicy | Snap-animation policy gate — decides if a transition merits animation and builds a MotionSpec<QRectF> for AnimatedValue::start() |
| CSnapParams | |
| CAnimatedValue | Unified motion primitive: one value of type T transitioning from start to target over time, driven by a curve and a clock |
| CAnimationUniformExtension | IUniformExtension that appends animation-shader spatial uniforms after PhosphorShaders::BaseUniforms in the UBO |
| CCurveState | Mutable state for stateful curve progression (springs carry position+velocity across frames; stateless curves share the struct for uniform caller treatment) |
| CCurve | Polymorphic base for all animation curves |
| CCurveLoader | Scans JSON curve-definition files and registers them with CurveRegistry |
| CEntry | |
| CCurveRegistry | String-id <-> curve factory registry |
| CEasing | Parametric easing curve: cubic bezier, elastic, or bounce |
| CIMotionClock | Abstract clock interface for the motion runtime |
| CInterpolate | Type-specific linear interpolation and path-distance for AnimatedValue<T> |
| CInterpolate< qreal > | |
| CInterpolate< QPointF > | |
| CInterpolate< QSizeF > | |
| CInterpolate< QRectF > | |
| CInterpolate< QColor > | |
| CInterpolate< QTransform > | |
| CMotionSpec | Runtime call-site bundle for starting an AnimatedValue<T> |
| CPhosphorCurve | Opaque QML value-type wrapper around shared_ptr<const Curve> |
| CPhosphorEasing | QML value-type wrapper around PhosphorAnimation::Easing |
| CPhosphorMotionAnimation | QQuickPropertyAnimation subclass driving property animation with a phosphor-animation Profile |
| CPhosphorProfile | QML value-type wrapper around PhosphorAnimation::Profile |
| CPhosphorProfileRegistry | Registry mapping profile path strings to Profile values |
| CPhosphorSpring | QML value-type wrapper around PhosphorAnimation::Spring |
| CProfile | Configuration for a single animation event |
| CProfileLoader | Scans JSON profile-definition files and registers them with PhosphorProfileRegistry |
| CEntry | |
| CProfileTree | Hierarchical profile storage with walk-up inheritance |
| CQtQuickClock | Qt Quick adapter implementing IMotionClock |
| CQtQuickClockManager | Enforces "one QtQuickClock per QQuickWindow" within a single composition-root-owned manager instance |
| CSpring | Damped harmonic oscillator |
| NPhosphorAnimationLayer | |
| CSurfaceAnimator | Concrete PhosphorLayer::ISurfaceAnimator driving show/hide via phosphor-animation Profiles |
| CConfig | Per-role profile + scale tuning bundle |
| NPhosphorAnimationShaders | |
| CAnimationShaderEffect | Metadata for a single animation shader effect (transition) |
| CParameterInfo | Declared shader inputs beyond the standard set (iTime, iFrame, etc.) |
| CTextureSlot | User texture slot |
| CAnimationShaderRegistry | Registry of available animation shader transition effects |
| CAnimationPack | Registry entry: a discovered animation effect as a PhosphorRegistry factory |
| CShaderProfile | Per-event shader effect selection and configuration |
| CShaderProfileTree | Hierarchical ShaderProfile storage with walk-up inheritance |
| NPhosphorAudio | |
| CCavaSpectrumProvider | |
| CSpectrumOptions | Full analysis parameter set for a spectrum provider |
| CIAudioSpectrumProvider | |
| NPhosphorChannel | |
| CAcceptOptions | What a reader takes |
| CRingWriter | |
| CRingReader | |
| CStreamWriter | The writing end of one channel of a stream |
| CStreamReader | The reading end of one channel of a stream |
| CStream | |
| COptions | |
| NPhosphorCompositor | |
| NTilingStateHelpers | Compositor-agnostic tiling-family state accessors and pure helpers |
| CTilingWindowState | Bundles per-window state maps for cleanup operations |
| CDaemonClient | |
| CDebouncedScreenAction | Compositor-agnostic debounced action with coalescing |
| CDecorationManager | The single owner of server-side decoration (title-bar) state |
| COwner | An owner is a (kind, screen) pair |
| CFloatingCache | Compositor-agnostic floating window state cache |
| CWindowInfo | Compositor-agnostic window property snapshot |
| CICompositorBridge | Abstract interface bridging compositor-agnostic logic to compositor-specific APIs |
| CIDragHandler | |
| CGeometryRequest | |
| CIGeometryHandler | |
| CILifecycleHandler | |
| CBorderState | Compositor-agnostic engine-managed (tiling-family) border state |
| CParsedTrigger | Pre-parsed activation trigger (avoids QVariant unboxing in hot path) |
| CZoneCache | Compositor-agnostic snap-zone state cache |
| NPhosphorConfig | |
| CHostDescriptor | One host of a settings API, as the static descriptor its package installs in <datadir>/phosphor-works/<api>-hosts/ describes it: |
| CHostRecord | What the last host of an API to start wrote about itself, or the choice a user made between several hosts (pid 0) |
| CHostResolution | Which host's settings file a module edits, from HostDirectory::resolve() |
| CHostDirectory | The descriptors and the host record of one settings API |
| CIGroup | Scoped view into a single configuration group |
| CIBackend | Pluggable configuration backend |
| CIGroupPathResolver | Optional plug-in for custom group name semantics |
| CJsonGroup | Scoped group view backed by a JsonBackend |
| CJsonBackend | Atomic-write JSON configuration backend |
| CMigrationRunner | Executes a Schema's migration chain against a JSON document |
| CQSettingsBackend | Reader for legacy KConfig-style INI configuration files |
| CChoiceDef | One legal value of an enum-style key: the value as stored, plus a stable token naming it |
| CKeyDef | Declaration for a single configuration key |
| CMigrationStep | One step in a schema version migration chain |
| CSchema | Declarative description of a configuration store |
| CStore | High-level declarative configuration facade |
| NPhosphorContext | |
| CContextHandle | Frozen snapshot of "where am I right now?" for a single resolver query |
| CContextResolver | Default IContextResolver implementation backed by three adapter pointers |
| CIWorkspaceState | Adapter interfaces the concrete ContextResolver depends on |
| CIModeProvider | Per-screen mode dispatcher adapter |
| CIContextGateSource | Disable / lock cascade adapter |
| CIContextResolver | The single resolver façade every Phosphor consumer goes through for "what does this screen look like RIGHT NOW under the disable / lock / mode cascade? |
| NPhosphorControl | |
| CApplicationController | Top-level orchestrator for a phosphor-control application |
| CIControlModule | The root object of a control module |
| CDBusEndpoint | Configured endpoint for a single D-Bus service the settings app talks to |
| CDBusBridge | Thin wrapper around QDBusConnection::sessionBus() that bakes in a pre-configured endpoint |
| CExtensionSlotModel | The sections in one slot of one page, as ApplicationController:: extensionsFor() lists them, for ExtensionSlot's Repeater |
| CISearchProvider | Source of dynamic (content) search entries — rules, shaders, layouts, virtual screens, etc |
| CLocalizedContext | Minimal QML i18n context that routes through Qt's translation system |
| CModuleContext | What the host hands a module while it loads (IControlModule::registerInto) |
| CModuleHost | Hosts control modules in an ApplicationController |
| CRefusedExtension | An extension that will not be shown, and why: its target module is installed but could not be placed, its target page does not exist or has no place in the sidebar, the page has no such slot, or offers the slot at another version |
| CModuleExtension | A section a module registered while loading (ModuleContext:: registerExtension) |
| CModuleCategoryMetadata | A top-level sidebar category a module defines |
| CModulePageMetadata | One page of a module, as its metadata describes it |
| CModuleExtensionPointMetadata | A named place on one of the module's pages that other modules may add a section to, beyond the implicit top, bottom, before:<anchor> and after:<anchor> slots every page has |
| CModuleExtensionMetadata | A section this module adds to another module's page |
| CModuleSearchEntryMetadata | A static search target on one of the module's pages: a setting or section at one of the page's anchors |
| CModuleMetadata | The metadata a control module embeds with Q_PLUGIN_METADATA: |
| CModulePlaceholderPage | The controller of a page that stands in for a control module's page while the module is not loaded |
| CModuleTestHost | Checks one control module without a window, for the module's own CI |
| CPageController | Base class for a settings page: a staging domain backed by a QML page that appears in the sidebar |
| CPageRegistry | Holds the catalogue of pages an application has registered |
| CEntry | Public-by-value view of a registry entry |
| CSearchController | Global settings search: builds a ranked result list for a query |
| CSearchEntry | One searchable item in the global settings search index |
| CSearchRanker | Pure, stateless scoring + ranking for the global settings search |
| CSidebarRows | Derives the sidebar's visible row list from the page registry |
| CStagingDomain | Abstract base for anything that holds staged user changes pending an Apply |
| NPhosphorDBus | |
| CClient | A lightweight, service-agnostic D-Bus method-call client |
| CObjectManager | Service-agnostic observer for org.freedesktop.DBus.ObjectManager |
| CHasDBusStreaming | Compile-time check that a type has QDBusArgument streaming operators |
| CHasDBusStreaming< T, std::void_t< decltype(std::declval< QDBusArgument & >()<< std::declval< const T & >()), decltype(std::declval< const QDBusArgument & >() > > std::declval< T & >())> > | |
| NPhosphorEngine | |
| CDesktopRemap | How KWin's desktop positions moved in one change of its desktop list: for each 1-based position in the OLD list, the position the same desktop holds in the NEW list, or 0 when it was removed |
| CPlacementStateKey | Identity of a per-screen placement state: a window's placement is scoped to the (screen, virtual desktop, activity) triple it was created in |
| CResnapEntry | |
| CSnapResult | |
| CUnfloatResult | |
| CZoneAssignmentEntry | |
| CDesktopSpan | The contexts a window occupies, as the per-desktop membership pass reads them: which desktops (x11 numbering, the numbering the state keys use) and which activity |
| CMembershipReconcileResult | What a membership pass did, so the caller can drive the bookkeeping the engines cannot reach: the placement re-capture and the effect's per-window zone mirror for a snap release, and the adaptor-level untrack for a window that holds no context at all any more |
| CICrossSurfaceResolver | Resolves the neighbouring surface — output or virtual desktop — in a direction, for cross-surface window navigation |
| CIGeometrySettings | |
| CIPlacementEngine | Unified placement engine interface, implemented by all three engines (snap zone layouts, autotile algorithms, the scrolling strip) so the daemon dispatches every lifecycle event and navigation intent through one polymorphic call with no mode branches |
| CDragInsertTarget | Where a drag-insert preview should place the dragged window, in the TARGET ENGINE's slot vocabulary |
| CHandoffContext | Context for a cross-engine window handoff |
| CIPlacementState | Per-screen placement state contract |
| CIVirtualDesktopManager | |
| CWindowDesktopContext | The contexts the compositor last reported a window on, as far as the registry knows them, in KWin's current desktop numbering: a renumber moves the numbers of records not reported since (WindowRegistry::remapDesktops) |
| CIWindowRegistry | |
| CIWindowTrackingService | |
| CLayerSwitchSide | One side (tiled or floating) of a layer focus switch, as the owning engine sees it |
| CLayerSwitchResult | Outcome of resolving a layer focus switch |
| CNavigationContext | Target window + screen for a navigation or lifecycle operation |
| CPerScreenStates | Exported because this is a header-only template used from every engine library, so the category has to resolve outside phosphor-engine |
| CPlacementEngineBase | Abstract base class for placement engines |
| CContextChange | Outcome of a context mutation on ScreenContextTracker |
| CScreenContextTracker | Tracks the "current context" of each screen for a placement engine: the global current virtual desktop, per-output desktop overrides (Plasma 6.7 "switch desktops independently per screen", #648), the sticky-desktop pin (KWin "virtualdesktopsonlyonprimary" model), and the current activity |
| CEngineSlot | One engine's view of a window: which managed slot it occupies (or that it is floating / unmanaged) in THAT engine's mode |
| CWindowPlacement | One window's single, authoritative placement record — the unit of the unified, engine-agnostic restore model |
| CWindowPlacementStore | The single source of truth for window restore state in the unified model |
| CWindowMetadata | |
| CWindowRegistry | |
| CWindowContext | The window's own context for per-window mode resolution: its virtual desktop (0 = all/unknown), the full desktop list when it spans several (empty otherwise), and activity (empty = all/unknown), read without copying the full ~30-field metadata record — this sits on the per-query float-resolver path |
| CIScrollSettings | Settings surface the scrolling engine reads, injected by the daemon via PlacementEngineBase::setEngineSettings (qobject_cast at point of use, mirroring IAutotileSettings) |
| CISnapSettings | |
| CIAutotileSettings | |
| NPhosphorFsLoader | |
| CContainedFile | What readFileWithinDirectory hands back on success |
| CDirectoryLoader | Generic JSON-directory loader with debounced live reload |
| CEntry | Tracked entry — mirrors ParsedEntry minus the payload |
| CIDirectoryLoaderSink | Consumer-supplied strategy for a DirectoryLoader |
| CIScanStrategy | Pluggable enumeration / parse / commit policy for WatchedDirectorySet |
| CJsonEnvelope | Result of a successful envelope validation |
| CMetadataPackScanStrategy | Reusable scan strategy for metadata.json-driven subdirectory pack registries |
| CParsedEntry | One parsed file's payload + metadata |
| CSchemaValidator | Validates parsed JSON documents against a JSON Schema (Draft 7) |
| CError | A single schema violation |
| CWatchedDirectorySet | Watcher + debounce + rescan scaffolding for filesystem-backed loaders |
| CWatchedFileSet | Watch an explicit set of files and report only the ones that really changed |
| NPhosphorIpc | |
| CIpcCallContext | |
| CIpcPendingReply | |
| CRequest | |
| CIpcRouter | |
| CIpcTarget | |
| NPhosphorLayer | |
| CDefaultScreenProvider | IScreenProvider backed by QGuiApplication::screens() |
| CJsonSurfaceStore | File-backed ISurfaceStore — one JSON document on disk |
| CNoOpSurfaceAnimator | Pass-through ISurfaceAnimator — calls onComplete() synchronously |
| CPhosphorWaylandTransport | Default transport: binds surfaces to wlr-layer-shell via PhosphorWayland's LayerSurface class |
| CXdgToplevelTransport | Fallback transport for compositors without wlr-layer-shell |
| CTransportAttachArgs | Arguments passed to ILayerShellTransport::attach() |
| CITransportHandle | Handle returned by attach(); lets the caller mutate post-show properties that the wlr-layer-shell protocol permits (margins, layer, exclusive zone, keyboard interactivity) without re-attaching |
| CILayerShellTransport | Abstracts the layer-shell protocol binding |
| CIQmlEngineProvider | Hook point for consumer-controlled QQmlEngine ownership policy |
| CScreenProviderNotifier | QObject that emits signals for IScreenProvider state changes |
| CIScreenProvider | Source-of-truth interface for the available QScreen set |
| CISurfaceAnimator | Hook point for show/hide transitions on Surfaces |
| CISurfaceStore | Key-value JSON store for surface-related persistence |
| CRole | Value type describing a surface's protocol-level configuration |
| CScreenSurfaceRegistry | Per-screen bookkeeping for surfaces with AllScreens affinity |
| CSurfaceDeps | Bundle of dependencies the Surface inherits from the factory |
| CSurface | One layer-shell surface with a managed lifecycle |
| CCtorToken | Opaque construction token — only SurfaceFactory can create instances of it |
| CSurfaceConfig | Immutable per-surface configuration passed to SurfaceFactory::create() |
| CSurfaceFactory | Stateless constructor for Surfaces |
| CDeps | Dependency bundle for SurfaceFactory |
| CTopologyConfig | Tunables for TopologyCoordinator |
| CTopologyCoordinator | Reacts to screen hot-plug / virtual-screen reconfiguration / compositor restart; drives surface recreations via the registries |
| NPhosphorLayout | |
| CAlgorithmMetadata | Capability + display metadata for a single autotile algorithm |
| CCompositeLayoutSource | Aggregates multiple ILayoutSource implementations behind one ILayoutSource interface |
| CEdgeGaps | Per-side edge gap values (resolved, non-negative pixel values) |
| CILayoutSource | Abstract producer of LayoutPreview values |
| CILayoutSourceFactory | Abstract factory for an ILayoutSource implementation |
| CILayoutSourceRegistry | Abstract notifier surface for every registry that feeds an ILayoutSource |
| CLayoutPreview | Renderer-ready snapshot of one layout entry (manual zone layout OR autotile algorithm result) |
| CLayoutSourceBundle | Owning bundle that assembles a list of ILayoutSourceFactory instances into a single CompositeLayoutSource |
| CFactoryContext | Service registry passed to a layout-source-provider builder so it can pull whatever registries / dependencies its factory needs |
| CPendingLayoutSourceProvider | One pending layout-source-provider registration |
| CLayoutSourceProviderRegistrar | Static-init self-registration helper for provider libraries |
| NPhosphorOverlay | |
| CShellHost | |
| CSurfaceStateWants | What the consumer's live content wants from the shell surface on one screen |
| CShellState | |
| CSlotEntry | |
| NPhosphorPlacement | |
| CIGeometryResolver | |
| CPlacementConfig | |
| CSnapStateResolver | Seam onto the snap engine's per-(screen,desktop,activity) SnapState stores |
| CWindowTrackingService | Window-zone tracking service (business logic layer) |
| CPendingRestoreTarget | A pre-computed snap restore target for the effect's instant-restore cache: zone geometry, the saved screen (so the effect only applies it on that screen's output) and the record's window id (an entry for a window the effect can still see is dropped) |
| CZonePruneResult | unsnapped: windows left in no zone in view (windowId, targetScreenId) |
| NPhosphorPointerShaders | |
| CPointerFrameState | Plain-data snapshot of everything the pointer contract's tail carries for one frame |
| CPointerHistory | The ring-buffer pointer sampler both hosts feed: the compositor from slotMouseChanged, the preview from its figure-eight driver |
| CPointerShaderEffect | Metadata for a single pointer shader effect |
| CParameterInfo | Declared parameter |
| CTextureSlot | User texture slot |
| CPointerShaderRegistry | Registry of available pointer shader effects |
| CPointerPack | Registry entry: a discovered pointer effect as a PhosphorRegistry factory, wrapping the parsed PointerShaderEffect by value |
| CPointerUniformsTail | C++ mirror of the POINTER contract's UBO tail |
| CPointerUniformExtension | IUniformExtension that appends PointerUniformsTail after PhosphorShaders::BaseUniforms in the preview runtime's UBO |
| NPhosphorPopout | |
| CIPopoutService | |
| CIPopoutTransport | |
| CPopoutController | |
| CPopoutRequest | |
| NPhosphorProtocol | D-Bus marshalling for the shared tiling-family value types (see AutotileTypes.h; the file names predate the autotile-to-tiling generalization and are load-bearing across the build, so only the docs moved with the split) |
| CTileRequestEntry | D-Bus struct for the shared tiling-family tile requests (autotile + scrolling ride the same windowsTileRequested pipeline): (siiiissbbbbssiiibsb) |
| CAlgorithmInfoEntry | D-Bus struct for algorithm metadata: (sssbbbbdibsbbb) |
| CPreTileGeometryEntry | D-Bus struct for pre-tile geometry entries: (siiiiss) Replaces the JSON blob previously returned by getPreTileGeometriesJson |
| CBridgeRegistrationResult | D-Bus struct for bridge registration result: (sss) |
| CDragPolicy | Drag policy — daemon-authoritative decision about how a drag should be handled |
| CDragOutcome | Drag outcome — daemon-authoritative decision about what to apply at drag end |
| CSnapAllResultEntry | D-Bus struct for snap-all result entries: (sssiiii) Carries targetZoneId so the plugin can confirm snaps without a second JSON parse |
| CMoveTargetResult | D-Bus struct for move/push/zone-number navigation result: (bssiiiiss) |
| CFocusTargetResult | D-Bus struct for focus navigation result: (bsssss) |
| CCycleTargetResult | D-Bus struct for cycle navigation result: (bssss) |
| CSwapTargetResult | D-Bus struct for swap navigation result: (bssiiiissiiiisssss) |
| CRestoreTargetResult | D-Bus struct for restore navigation result: (bbiiii) |
| CWindowGeometryEntry | D-Bus struct for batch geometry entries: (siiiis) |
| CSnapConfirmationEntry | D-Bus struct for batch snap confirmation: (sssb) |
| CWindowOpenedEntry | D-Bus struct for batch window-opened notification: (ssii) |
| CWindowStateEntry | D-Bus struct for window state: (sssbsasb) |
| CUnfloatRestoreResult | D-Bus struct for unfloat restore result: (bassiiii) |
| COutputSettleRow | One window in the effect's output-settle report, sent when a screen change settles that added or removed an output or deferred a crossing: (ssssbiiiiiiiiiiibbbbssiiibiiii) |
| COutputSettleVerdict | The daemon's answer for one OutputSettleRow: (sis) |
| CZoneGeometryRect | D-Bus struct for zone geometry: (iiii) |
| CEmptyZoneEntry | D-Bus struct for empty zone info: (siiiiiibsssdd) |
| CSnapAssistCandidate | D-Bus struct for snap assist candidate: (ssss) |
| CNamedZoneGeometry | D-Bus struct for named zone geometry: (siiii) |
| NPhosphorRegistry | |
| CIBarWidgetFactory | |
| CIBarWidgetPlugin | The root object of a bar-widget plugin |
| CIControlCenterTileFactory | |
| CIDesktopWidgetFactory | |
| CIFactoryBase | |
| CLauncherResult | |
| CILauncherProvider | |
| CILauncherProviderFactory | |
| CIOSDFactory | |
| CMetadataPackLoader | |
| CPathKeyedOverrides | A baseline payload plus keyed overrides, in insertion order |
| CPluginSeam | One kind of plugin the suite loads, such as bar widgets |
| CPluginSearchPath | A directory to search and the origin its plugins get |
| CPluginMetadata | A plugin known from its metadata. Building one never loads the library |
| CRefusedPlugin | A plugin file the catalog found and will not offer, with the reason |
| CPluginCatalog | Finds the plugins of one seam, reads their metadata without loading them, and loads one only when asked |
| CPluginLoader | Loads every bar-widget plugin into a Registry<IBarWidgetFactory> and keeps it in step with the plugins on disk |
| CRegistry | |
| CRegistryNotifier | |
| NPhosphorRendering | |
| CShaderCompiler | Static utility for GLSL → SPIR-V compilation with include resolution and caching |
| CResult | |
| CShaderEffect | QQuickItem that renders a fullscreen fragment shader via Qt RHI |
| CShaderNodeLiveness | Shared liveness block linking a render node to the ShaderEffect that tracks it |
| CShaderNodeRhi | QSGRenderNode for fullscreen-quad shader rendering via Qt RHI (Vulkan / OpenGL) |
| CWarmShaderBakeResult | Result of warmShaderBakeCacheForPaths for reporting to UI |
| CZoneLabelTile | One rendered zone-label glyph (number) plus where its top-left sits in the full, screen-addressed labels texture |
| CZoneLabelTexture | Sparse zone-labels payload: the full screen-addressed texture size plus only the glyph tiles that actually carry a number |
| CZoneShaderUniforms | GPU uniform buffer layout — BaseUniforms + zone extension |
| CZoneData | Per-zone payload pushed into the UBO each frame |
| CZoneRect | Parsed zone rectangle data for shader rendering |
| CZoneColor | Parsed zone color data for shader rendering |
| CZoneDataSnapshot | Thread-safe zone data snapshot for the render thread |
| CZoneShaderNodeRhi | QSGRenderNode for zone overlay rendering, delegating to ShaderNodeRhi |
| CZoneUniformExtension | IUniformExtension implementation for zone data |
| NPhosphorRules | |
| NContextRuleBridge | |
| CContextRemap | How the desktops and activities a rule set names have moved |
| CMatchExpression | A composable predicate tree evaluated against a WindowQuery |
| CPredicate | Leaf predicate payload |
| CAspectRatioToken | One entry of the Field::ScreenAspectRatio vocabulary: the token a rule compares against and the width-over-height ratio it stands for |
| CFieldDescriptor | Compile-time descriptor for one Field |
| CValidationIssue | One semantic compatibility issue between a rule's match and an action |
| CRule | One rule — { id, name, enabled, priority, match, actions, managed } |
| CRuleAction | One action carried by a Rule |
| CParamSchema | Structural schema for one action param |
| CActionDescriptor | Static metadata describing one registered action type |
| CActionRegistry | Process-wide registry of action descriptors |
| CResolvedActions | The output of a resolution — the first action filling each slot |
| CRuleEvaluator | The single evaluation model — resolves a WindowQuery against a RuleSet |
| CRuleSet | An ordered collection of Rules — the persistent rule store |
| CRuleStore | Persistent store for the unified Rule set |
| CRuleStoreWatcher | Opt-in cross-process auto-reload for a RuleStore |
| CWindowQuery | The evaluation input — an attribute bag matched against a MatchExpression |
| NPhosphorScreens | |
| CDBusScreenAdaptor | D-Bus adaptor for the org.phosphor_works.Placement.Screen screen-topology surface: screen queries, virtual-screen mutation, the JSON round-trip for setVirtualScreenConfig, caches, and signals |
| CIConfigStore | Pluggable persistence for virtual-screen configurations |
| CInMemoryConfigStore | Trivial IConfigStore that holds its state in process memory |
| CIPanelSource | Pluggable producer of panel-reservation offsets per screen |
| COffsets | Per-edge reserved geometry, in physical pixels relative to the screen's top-left |
| CIPhysicalScreenSource | Pluggable source of the connected-output set and its lifecycle |
| CScreenManagerConfig | Construction-time wiring for ScreenManager |
| CScreenManager | Centralized screen-topology service |
| CNoOpPanelSource | Trivial IPanelSource that reports zero offsets and ready=true |
| CPhysicalScreen | A physical output as ScreenManager sees it — decoupled from QScreen |
| CPlasmaPanelSource | IPanelSource implementation that queries KDE Plasma Shell over D-Bus for panel-reservation offsets |
| CQtPhysicalScreenSource | Production IPhysicalScreenSource — a thin wrapper over QGuiApplication |
| CResolverEndpoint | D-Bus endpoint that ScreenResolver queries |
| CScreenResolver | Resolve a global cursor position to the effective screen ID |
| CScreenInfo | Lightweight descriptor for a connected screen, suitable for passing across settings UIs and QML |
| CVirtualScreenSwapper | Scoped helper that performs virtual-screen swap and rotate operations against an injected IConfigStore |
| CVirtualScreenDef | Definition of a single virtual screen within a physical screen |
| CPhysicalEdges | Check which edges of this virtual screen are at the physical screen boundary (vs internal edges shared with another virtual screen) |
| CVirtualScreenConfig | Configuration for how a physical screen is subdivided into virtual screens |
| NPhosphorScripting | |
| CLuauEngine | An embedded, sandboxed Luau virtual machine with a QVariant API |
| CCallOutcome | |
| CLuauWatchdog | One supervisor thread that interrupts runaway scripts across many engines |
| NPhosphorScrollEngine | |
| CScrollEngine | Niri-style scrolling placement engine |
| CScrollOpenParams | Per-window open-behaviour overrides resolved from window rules (openColumnWidth / openTabbed / openColumnPlacement) |
| CScrollVisibleTile | One visible tile of a strip: the unit of the scroll "zone number" space |
| CScrollVisibleTileWithRect | A tile paired with its screen-normalized rect, from ONE strip walk (see ScrollEngine::visibleTilesWithRects) |
| CScrollStripSnapshotTile | One tile of a strip snapshot (see ScrollEngine::stripSnapshot) |
| CScrollStripSnapshotColumn | One column of a strip snapshot, in strip order |
| CScrollStripSnapshot | A column-aware strip snapshot for drag-popup renderers |
| CScrollStripModelTile | One tile of a strip MODEL (see ScrollStripModel) |
| CScrollStripModelColumn | One column of a strip model, in strip order |
| CScrollStripModel | The whole strip of one screen as a renderer of a strip MAP needs it: every column with its strip position and extent, the viewport's offset and size on the same axis, and the active column |
| CStashedTile | The mode-round-trip strip stash value types (ScrollEngine::m_stripStash) |
| CStashedColumn | |
| CStashedStrip | One stashed strip: the structural columns plus the focus/view pair whose loss made every mode round trip re-anchor on an arbitrary window (first arrival won the focus) |
| CFloatRestore | What a floated/minimized window's column held, so unfloat restores the slot AND the user's width/display intent (a Proportion/Preset column must not come back as the default width) |
| CDragInsertPreview | Live drag-insert preview state (drag_preview.cpp) |
| CCommittedMainExtent | What a client's own commits have taught the engine about one window's extent ALONG a strip that runs one way (ScrollEngine::reportCommittedSize) |
| CCommittedCrossExtent | What a client's own commits have taught the engine about one window's extent ACROSS a strip that runs one way (ScrollEngine::reportCommittedSize): a tile the client answers longer than its share of its column across the strip, inside the work area |
| CCommittedExtent | One window's CommittedMainExtent per strip orientation, the value type of ScrollEngine::m_committedExtents |
| CScrollState | Per-(screen, desktop, activity) scrolling state: one ScrollStrip plus the windows floated out of it |
| CScrollStrip | The pure scrolling-strip model: an ordered list of columns on an unbounded strip, viewed through a viewport of the work area's extent |
| CViewOverhang | How far the view hangs past each end of the strip, in main-axis px: leading before the first column (a negative view offset) and trailing past the last offset that still ends on the strip |
| CScrollBlueprintProgress | How far a screen has worked through its context template's seed blueprint |
| CTabIndicatorParams | The tab indicator's GEOMETRY inputs — the subset of the Scrolling.TabIndicator family that changes resolved rects, so it has to live in the layout params rather than staying with the paint half |
| CColumnWidth | Column width INTENT — the source of truth the strip stores |
| CWindowHeight | Tile height INTENT within a column (its extent ACROSS the strip) |
| CTile | One window in a column |
| CColumn | One column: a stack of tiles ACROSS the strip (vertical on a horizontal strip, horizontal on a vertical one) |
| CScrollLayoutParams | Inputs a relayout resolves pixel rects against |
| CResolvedTile | One tile's resolved output for a relayout pass |
| CResolvedColumn | One column's resolved output |
| CResolvedStrip | A full relayout pass over one strip |
| CStripAxis | Coordinate mapping for one strip orientation: a pure value type, trivially copyable, no allocation, cheap enough to read once per column and once per tile inside the relayout loop |
| NPhosphorServiceBluetooth | |
| CBluetoothAdapter | One BlueZ adapter (org.bluez.Adapter1), e.g |
| CBluetoothAdapterModel | List model over a BluetoothHost's adapters |
| CBluetoothAgent | Implements org.bluez.Agent1, the pairing agent BlueZ calls back into during a Pair() handshake |
| CBluetoothDevice | One BlueZ device (org.bluez.Device1), e.g |
| CBluetoothDeviceModel | List model over a BluetoothHost's devices, optionally scoped to a single adapter |
| CBluetoothHost | Facade over org.bluez: enumerates adapters and devices |
| NPhosphorServiceBrightness | |
| CBrightnessDevice | One brightness-controllable backlight: a display panel (under /sys/class/backlight) or a keyboard backlight (a kbd_backlight entry under /sys/class/leds) |
| CBrightnessDeviceModel | List model over a BrightnessHost's devices |
| CBrightnessHost | Enumerates the brightness-controllable backlights under a sysfs root |
| NPhosphorServiceClipboard | |
| CClipboardService | Clipboard-history host for Phosphor-based desktop shells |
| NPhosphorServiceIconTheme | |
| CIconImageProvider | QML image provider mounted at image://phosphor-service-icontheme/ |
| CIconThemeResolver | XDG Icon Theme Specification 0.13 resolver |
| NPhosphorServiceIdle | |
| CIdleService | Session idle-management host for Phosphor-based desktop shells |
| NPhosphorServiceLock | |
| CIAuthenticator | The credential-verification surface a lock UI (and the lock state machine) drives |
| CLockService | Session-lock + authentication host for Phosphor-based desktop shells |
| CPamAuthenticator | IAuthenticator backed by PAM (pam_authenticate + pam_acct_mgmt) |
| NPhosphorServiceMpris | |
| CMprisHost | |
| CMprisPlayer | |
| CMprisPlayerModel | |
| NPhosphorServiceNetwork | |
| CAccessPoint | One org.freedesktop.NetworkManager.AccessPoint — a Wi-Fi network as seen by a wireless device's last scan |
| CAccessPointModel | List model over the access points a single Wi-Fi NetworkDevice last scanned |
| CNetworkConnection | One saved profile — an org.freedesktop.NetworkManager.Settings.Connection |
| CNetworkConnectionModel | List model over the saved connection profiles NetworkManager knows about (org.freedesktop.NetworkManager.Settings) |
| CNetworkDevice | One org.freedesktop.NetworkManager.Device object |
| CNetworkDeviceModel | List model over a NetworkHost's devices |
| CNetworkHost | Root of the NetworkManager surface |
| NPhosphorServiceNightLight | |
| CWhitePoint | The colour of white at a temperature, as per-channel factors |
| CGammaBackend | What NightLight drives: something that can tint every output |
| CNightLight | A compositor-neutral night light |
| NPhosphorServiceNotifications | |
| CNotification | One live notification, decoded from an org.freedesktop.Notifications Notify call |
| CNotificationModel | List model over a NotificationServer's live notifications |
| CNotificationServer | The session-bus server for org.freedesktop.Notifications (Desktop Notifications Spec 1.3) |
| NPhosphorServicePipeWire | |
| CPipeWireConnection | Owns the PipeWire main loop on a dedicated QThread and exposes connection state to the GUI thread via Q_PROPERTY-backed signals |
| CPipeWireHost | Process-wide PipeWire host: owns the single PipeWireConnection instance the shell binds to and re-exposes its observable state as QML-friendly properties, including the error(QString) signal |
| CPwAudioProbe | On-demand audio test |
| CPwNode | One PipeWire audio node — a sink, source, output stream, or input stream |
| CPwNodeModel | Filtered view over a PipeWireConnection's registry-surfaced nodes, exposed as a QAbstractListModel for direct QML binding |
| CPwSinkModel | Convenience subclass pre-pinned to Audio/Sink |
| CPwSourceModel | Convenience subclass pre-pinned to Audio/Source |
| CPwStreamModel | Convenience subclass pinned to BOTH Stream/Output/Audio and Stream/Input/Audio |
| NPhosphorServicePolkit | |
| CAuthRequest | One active PolicyKit authentication request, decoded from polkit's initiateAuthentication callback |
| CPolkitAgent | A PolicyKit authentication agent for Phosphor-based desktop shells |
| NPhosphorServiceSession | |
| CSessionHost | Logind session manager: capability queries, session/power actions, inhibitor locks, and the sleep + session signals |
| NPhosphorServiceSni | |
| CDBusMenuModel | Flat model exposing ONE level of a com.canonical.dbusmenu tree at a time |
| CStatusNotifierHost | The shell-side counterpart to StatusNotifierWatcher |
| CStatusNotifierItem | One system-tray item |
| CStatusNotifierItemModel | QAbstractListModel adapter over StatusNotifierHost::items() |
| CTrayItems | Presentation policy over the StatusNotifierItemModel role contract |
| NPhosphorServiceUPower | |
| CUPowerDevice | |
| CUPowerDeviceModel | |
| CUPowerHost | |
| NPhosphorShaders | |
| CBaseUniformProfile | IUboProfile implementation for the overlay/animation runtime — the legacy 672-byte BaseUniforms layout |
| CBaseUniforms | GPU uniform buffer layout following std140 rules (base region) |
| CUboUploadRegion | A contiguous byte range inside the UBO to (re)upload via QRhiResourceUpdateBatch::updateDynamicBuffer |
| CUboUploadRegionList | Fixed-capacity list of upload regions |
| CUboDirtyFlags | Which conceptual blocks of the UBO changed since the last upload |
| CUboFrameState | Snapshot of every node-side value a UBO profile's fill() may read for a single frame |
| CIUboProfile | Pluggable UBO concern for the shared shader render engine |
| CIUniformExtension | Interface for appending custom uniform data after the base UBO layout |
| CIWallpaperProvider | Abstract wallpaper provider interface |
| CEntryCandidate | One candidate entry function the author may define, paired with the void main() the harness generates when that function is present and the source defines no main() of its own (T1.4) |
| CShaderIncludeResolver | Resolves #include directives in GLSL shader source |
| CPreambleParam | One declared shader parameter, in metadata declaration order, as fed to buildParamPreamble |
| CShaderPreset | One named parameter tuning for one shader pack |
| CShaderPresetRegistry | The one place a presetId on an assignment turns into parameters |
| CShaderPresetStore | One per consumer, holding every shader preset for every family it names |
| CShaderRegistry | Registry of available shader effects |
| CParameterInfo | |
| CShaderInfo | |
| CShaderPack | Registry entry: a discovered shader as a PhosphorRegistry factory |
| NPhosphorShell | |
| NPlacementMapParser | |
| CCell | One cell of the placement map, in work-area fractions |
| COccupant | One non-floating window on a screen, for applyOccupancy: the zones it fills and whether it demands attention |
| CWindowMeta | WindowTracking.getWindowMetadata, reduced to what a label needs |
| CScreenState | One screen's row of LayoutRegistry.getScreenStates |
| CTileRect | A tile from a Tiling.windowsTileRequested batch, reduced to what the map needs so the parser stays free of the D-Bus wire types |
| CStripParse | The scrolling parse: the visible columns as cells plus the lens band |
| CEnvironment | |
| CFileView | |
| CFloatingWindow | |
| CLazyLoader | |
| CPanelWindow | |
| CPerScreenPanels | Instantiates one panel per screen, parented so ShellEngine can find it |
| CPersistentProperties | |
| CPlacementMapScreen | One screen's view of the placement engine, in work-area fractions |
| CPlacementMap | QML singleton: the placement engine's geometry per screen |
| CPopupWindow | |
| CProcess | |
| CScreenModel | |
| CShellEngine | |
| CDeps | |
| CShellGlobal | |
| CShellLoader | Finds the shell.qml an app runs |
| CSystemClock | Real-time clock for status bar widgets |
| CSystemStats | |
| CSystemStatsReader | |
| CSystemUsage | CPU and memory utilisation for status bar widgets |
| CCpuTotals | Cumulative busy / idle jiffies parsed from a /proc/stat body |
| CMemoryTotals | Total / available kilobytes parsed from a /proc/meminfo body |
| CToplevelListModel | QAbstractListModel view of the live toplevel set |
| CToplevels | QML singleton exposing the live list of toplevel windows for taskbars |
| CVariants | |
| CWallpaperService | The shell's own wallpaper: which image each output shows |
| CWorkspaceListModel | Incrementally-updating model of the compositor's workspaces |
| CWorkspaces | QML singleton exposing the compositor's workspaces |
| NPhosphorShellLauncher | |
| CAppsProvider | |
| CCalculatorProvider | |
| CClipboardProvider | |
| CCommandProvider | |
| CDesktopEntry | |
| CDesktopEntryScanner | |
| CFuzzyMatch | |
| CFuzzyMatcher | |
| CLauncherModel | |
| CWindowsProvider | |
| NPhosphorShellLock | |
| CLockKeyboard | |
| CLockSurfaceWindow | Phosphor.Lock.LockSurface: a QML window that is one output's ext_session_lock_surface_v1 |
| NPhosphorShellPicker | |
| CAppearanceLibrary | |
| CRetintController | The picker's live retint: try a palette on the real desktop, put the old one back when the pointer leaves |
| CThemePresets | The theme tiles of the picker strip |
| CCandidate | One wallpaper the picker can offer |
| CWallpaperCandidates | The wallpaper candidates the picker strip scrolls through |
| NPhosphorShortcuts | |
| CIBackend | Pluggable global shortcut backend |
| CRegistry | Consumer-facing facade over IBackend |
| CBinding | |
| NPhosphorShortcutsIntegration | |
| CIAdhocRegistrar | Reduced-surface registrar interface for subsystems that need to bind a transient shortcut while a specific UI state is active (e.g |
| CAdhocBinding | One entry of the batch register form below |
| NPhosphorSnapEngine | |
| CINavigationStateProvider | Narrow read-only interface for compositor-layer state queries |
| CIZoneAdjacencyResolver | Narrow interface for zone-adjacency queries used by snap navigation |
| CPlacementDirective | What a matched open-placement rule directs for an opening window |
| CSnapEngine | Engine for manual zone-based window snapping |
| CSpanTargetResult | Result of a span (grow/shrink) target computation |
| CSnapNavigationTargetResolver | Pure snap-mode navigation target resolver |
| CSnapState | Per-screen snap placement state |
| CUnassignResult | |
| NPhosphorSurfaceQuick | |
| CSurfaceShaderItem | QQuickItem for rendering a per-window surface-decoration layer with a custom shader (border / rounded corners / focus tint / glow) |
| NPhosphorSurfaces | |
| CSurfaceManager | |
| CSurfaceManagerConfig | |
| NPhosphorSurfaceShaders | |
| CDecorationProfile | Per-surface decoration shader-pack chain and its per-pack parameters |
| CDecorationProfileTree | Hierarchical DecorationProfile storage with walk-up inheritance |
| CSurfaceShaderEffect | Metadata for a single surface shader effect |
| CParameterInfo | Declared shader inputs beyond the standard surface set (uTexture0, uSurfaceSize, uSurfaceFocused, etc.) |
| CTextureSlot | User texture slot |
| CSurfaceShaderRegistry | Registry of available surface shader effects |
| CSurfacePack | Registry entry: a discovered surface effect as a PhosphorRegistry factory |
| CSurfaceUniforms | C++ mirror of the SURFACE shader contract's daemon UBO block — the #else (non-PLASMAZONES_KWIN) branch of data/surface/shared/
surface_uniforms.glsl, a std140 layout(std140, binding = 0) uniform
SurfaceUniforms { … } |
| CSurfaceThemeColors | Theme colours a host supplies to resolveThemeParamColors() |
| CSurfaceUniformProfile | IUboProfile implementation for the surface-decoration runtime — the distinct 672-byte SurfaceUniforms layout, the same size as the overlay/animation BaseUniforms but not the same members |
| NPhosphorTheme | |
| CAppearanceStore | |
| CAppearanceWatcher | |
| CFontFaces | The shell's two type faces, resolved against what is installed |
| CTokenNames | |
| CIThemeService | |
| CMatugenRunner | |
| CPaletteStore | |
| CShellPalette | |
| CTemplateEngine | |
| NPhosphorTileEngine | |
| CAlgorithmSettings | Per-algorithm saved settings (split ratio, master count, max windows) |
| CAutotileConfig | Configuration for autotiling behavior |
| CAutotileEngine | Core engine for automatic window tiling |
| CMigrationArrival | An already-managed window ARRIVING in a state via migrateWindowBetweenKeys, with the float state it held on the source, captured before the source removed it |
| CStashedScriptState | Script-state bag rescued from a TilingState that a teardown destroys, so a re-created state for the same key can pick its bag back up |
| CDragInsertPreview | Active drag-insert preview state |
| CNavigationController | Handles navigation, focus cycling, and ratio/count adjustments |
| COverflowManager | Per-screen overflow window tracking (pure tracking — no PhosphorTiles::TilingState mutation) |
| CPerScreenConfigResolver | Resolves per-screen configuration overrides for autotiling |
| CEffectiveGaps | |
| NPhosphorTiles | |
| NScriptedHelpers | |
| CCustomParamDef | Definition of a custom algorithm parameter, declared by a script's metadata.customParams list |
| CScriptMetadata | Parsed metadata from a scripted algorithm's metadata table |
| CAlgorithmPreviewParams | User-configured tiling parameters that affect algorithm preview generation |
| CAlgorithmRegistry | Concrete tiling-algorithm registry |
| CPendingAlgorithmRegistration | Pending algorithm registration data |
| CAlgorithmRegistrar | Helper for static self-registration of built-in algorithms |
| CAutotileLayoutSource | ILayoutSource adapter wrapping an ITileAlgorithmRegistry |
| CAutotileLayoutSourceFactory | Factory for AutotileLayoutSource |
| CITileAlgorithmRegistry | Abstract contract for a tiling-algorithm registry |
| CLuauTileAlgorithm | A tiling algorithm backed by a user-provided Luau script |
| CScriptedAlgorithmLoader | Discovers, loads, and hot-reloads LuauTileAlgorithm instances |
| CSplitNode | A single node in the binary split tree |
| CSplitTree | A binary split tree for interactive window tiling |
| CTilingAlgorithm | Abstract base class for tiling algorithms |
| CWindowInfo | Per-window metadata passed to algorithms |
| CResizeEvent | Describes an interactive resize that triggered a retile |
| CTilingScreenInfo | Screen metadata passed to tiling algorithms |
| CTilingParams | Parameters for zone calculation |
| CTilingState | Tracks tiling state for a single screen |
| NPhosphorWayland | |
| CBackgroundEffect | Compositor blur behind a region of a window, through the standard ext-background-effect-v1 protocol |
| CClipboardDevice | Client-side wrapper around zwlr_data_control_device_v1 |
| CForeignToplevelManager | Client-side wrapper around zwlr_foreign_toplevel_manager_v1 |
| CForeignToplevel | A single toplevel window owned by some other Wayland client |
| CIdleInhibitor | Prevents the compositor from idling the output that the associated surface is visible on |
| CIdleNotifier | |
| CLayerSurface | Wayland layer-shell surface backed by zwlr_layer_shell_v1 |
| CBatchGuard | RAII guard: suppresses propertiesChanged() until destroyed |
| CLockSurface | Marks a QWindow as an ext_session_lock_surface_v1 for one output |
| CSessionLock | Client-side wrapper around ext_session_lock_manager_v1 / ext_session_lock_v1 |
| CSinglePixelBuffer | |
| NPhosphorWorkspaces | |
| CActivityManager | The desktop's activities, from an IActivityBackend (Plasma's is PhosphorWorkspaces::Plasma's) |
| CIActivityBackend | Where an ActivityManager's activities come from |
| CDesktopEntry | One desktop of a compositor's list: 0-based position, stable id, raw name |
| CIVirtualDesktopBackend | Where a VirtualDesktopManager's desktops come from: the transport to the compositor that owns them |
| CSnapshot | One whole desktop list, with the current desktop and the grid's rows |
| CKWinVirtualDesktopBackend | KWin's virtual desktops, over org.kde.KWin.VirtualDesktopManager on the session bus |
| CVirtualDesktopManager | The compositor's virtual desktops, and every rule about them |
| CWorkspaceEntry | One owned desktop in a screen's workspace slice |
| CWorkspaceMap | The per-monitor workspace ownership model: screenId → ordered slice of KWin desktop ids, with the inverse owner index |
| CNamedWorkspace | One declared named workspace (config-driven; persistent while empty) |
| CWorkspaceReconciler | The dynamic-workspace lifecycle state machine |
| NPhosphorZones | |
| CLayoutAssignmentKey | Key for layout assignment (screen + desktop + activity) |
| CAssignmentEntry | Explicit per-context assignment entry storing every mode's payload |
| CContextGapOverride | Per-context gap override resolved from rules |
| CContextOverlayOverride | Per-context overlay-property overrides resolved from window-rule actions |
| CContextTilingParams | Per-context autotile parameter overrides resolved from context rules |
| CContextScrollingParams | Per-context scrolling parameter overrides resolved from context rules |
| CContextResolveKey | Lookup key for the LayoutRegistry context-resolver caches |
| CZoneDetectionResult | Result of zone detection |
| CIZoneDetection | Pure-query subset of zone detection — read-only geometry lookup |
| CIZoneDetector | Abstract interface for zone detection + highlight lifecycle |
| CIZoneLayoutRegistry | Enumeration + mutation surface for the in-memory zone-layout catalog |
| CLayout | Represents a collection of zones that form a layout |
| CLayoutComputeService | |
| CZoneSnapshot | |
| CLayoutSnapshot | |
| CComputedZoneGeometry | |
| CLayoutComputeResult | |
| CLayoutFactory | |
| CCombinedAssignmentKey | Triple-axis key for the Combined-context batch API |
| CLayoutRegistry | Manual zone-layout registry + per-context assignment store |
| CRuleSlotResolution | The rule-derived slot resolution of the assignment cascade, as resolveRuleSlots produces it and resolveAssignmentEntry caches it |
| CScreenShape | The geometry-derived context facts of one screen: its orientation token ("portrait" / "landscape") and its size in device pixels (from m_screenPixelSizeProvider) |
| CLayoutSettingsStore | Persists per-layout SETTINGS in a sidecar, keyed by layout UUID, separately from the structural layout files |
| CLayoutWorker | |
| CScrollingTemplateColumn | One column of a scrolling template's seed blueprint |
| CScrollingTemplate | A scrolling screen's first-class sizing template |
| CScrollingTemplateSource | ILayoutSource over a ScrollingTemplateStore — the third card family beside manual zone layouts and autotile algorithms |
| CScrollingTemplateSourceFactory | Factory + registrar anchor, mirroring ZonesLayoutSourceFactory |
| CScrollingTemplateStore | Load/save store for scrolling templates |
| CZone | Represents a single zone within a layout |
| CZoneDetector | Efficient zone detection for window snapping |
| CZoneHighlighter | Manages zone highlighting state |
| CZonesLayoutSource | ILayoutSource adapter wrapping an IZoneLayoutRegistry |
| CZonesLayoutSourceFactory | Factory for ZonesLayoutSource |
| Nstd | STL namespace |
| Chash< PhosphorEngine::PlacementStateKey > | Std::hash alongside qHash, so the key works in a std:: container too |