kinogaki-editor

What it is

Depends on

For its tests alone

Third-party

Used by

Modules

• browser (private)The Tab browser: lib-ui's browser at the pointer, over the network pane or the views.373 lines
• commands (private)The commands: the key stores and what keys run (keys), the menu bar and the right-click menu (menus), the A, S and D marking menus (marking), Repeat (repeat), the tools' remembered values and adjustments (tools) and the shelves (shelves).26 lines
• commands::keys (private)Key stores: every key the editor answers, as one table of bindings, each in a store.703 lines
• commands::marking (private)The A, S and D marking menus: held over the views, a radial menu of eight compass items (North first, clockwise) and a list below South, drawn by lib-ui's radial without icons.474 lines
• commands::menus (private)The menu bar and the right-click menu over the views as data: each menu's items, built from what applies now and drawn by one drawer; each item's shortcut is the key store's (keys), so what a menu shows, what its key does and what a test reads are the same ...628 lines
• commands::menus::draw (private)The menus drawn: the bar's through lib-ui's menu bar, the right-click menu over the views, and the library's items in submenus by family.264 lines
• commands::repeat (private)Repeat, core's for every context: running an item its library marks repeatable (Places::repeatable) over the views (a tool, not a node added from the network) makes it the item Repeat (REPEAT, an item of core's own ...51 lines
• commands::shelves (private)The user's shelves: whether the shelf shows under the views (Window ▸ Tool Shelf), and the shelves of each set of menus the user changed, whole, by its store (MenuDefaults::store).356 lines
• commands::tools (private)Tools remember their settings and the last tool stays adjustable, the same for every context's node types (the SDK's HostTools).156 lines
• cook (private)CookState: the editor's side of the scene cook, and the host's lanes for packages' latest-wins jobs.195 lines
• cook::latest (private)Packages' latest-wins jobs (HostLatestExt::latest): one of core's lanes per package and kind, keeping the kind's last ask.161 lines
• frame (private)The editor and its frame: the one place that names every part.800 lines
• frame::calls (private)Calls into packages: each with its state and a host context over the other parts, the open context's parts among them, and what the inspector asked of a package.354 lines
• frame::drive (private)The surface core/harness drives the editor through (the harness feature).96 lines
• frame::drive::counts (private)What tests count of the editor's work: sheets made, key stores made, and whether the Settings window is open to make them.30 lines
• frame::drive::menus (private)Menus as the harness reads them: the bar's, the views' right-click menu, the marking menus and the shelf.164 lines
• frame::drive::panes (private)The panes as the harness reads them: the network, the outliner, the spreadsheet, the Console, the Timeline and the status line.246 lines
• frame::drive::render (private)Rendering as the harness drives it: Render views, final renders and their progress.57 lines
• frame::drive::types (private)The plain values the harness reads the editor as.397 lines
• frame::drive::views (private)The views as the harness reads them: what they draw, mark and preview, their cameras and their controls.262 lines
• frame::drive::work (private)The work counters the harness reads: what the views and the scene cook did so far, counted, never timed.87 lines
• frame::files (private)Projects and files: saving, importing and exporting, image files embedded and extracted, a finished open or import adopted, and a new document put in place of the old.309 lines
• frame::layer (private)The open context's live tools and the keyboard: keys and typed text over the views reach its LiveTools::key before any binding, Escape never: it goes to the first of a handle drag (which puts back the drag alone), the host's modal state (a dialog, a menu, a ...146 lines
• frame::live (private)The open context's viewport parts, asked around the panes (the views draw inside the dock, where no package can be called; crate::view::live): before them its holds and whether its Gear has rows, then each view's panels, the branch picks into its live ...212 lines
• frame::offers (private)The frame's half of the menus built from libraries: what the place the user is at offers (Menus), each entry as it shows now (its When held against the place, its vocabulary's shown and label), and running what was chosen: core's object items ...562 lines
• frame::outside (private)Files outside the document read again: when the window is focused again, and when the system's file-system events report a change to a file the document reads (a file its nodes' File rows name, a file the image store holds or failed to read: written over by ...66 lines
• frame::popover (private)The popover open over the views (view::popover), after the panes: the Gear, its rows core's own (the current tool's space, kept per context, while the context takes the host's transform tools: its Transforms part) and that part's sheet ...197 lines
• frame::render (private)The views' and engines' rendering: the views drawn this frame rendered with what the open context adds, the render geometry and live engine in step with the document, final renders, and the project's colors.425 lines
• frame::settings (private)The frame's half of the Settings window: what it lists, read when it opens (the plugins found, the formats Import reads with, the packages' pages, every set of marking menus and of shelves, and every key store with what can be bound there), and each frame the ...371 lines
• frame::shelf (private)The frame's half of the shelf: what it shows where the user is, built from the user's shelves (else the library's) and what applies now (each tile's shown asked), kept while what it was built from holds; and what it asked: a tile's item run as the menus run ...227 lines
• frame::status (private)The frame's half of the status line: what its pieces read, gathered each frame from the document, the cook and the views; the shell makes the pieces again only when that changed (crate::shell::status).70 lines
• gesture (private)A part's gesture: what a drag of the views, the network pane, the outliner, the timeline or a sheet holds while it lasts.76 lines
• host (private)HostCx: the SDK's host interface over the editor's parts, for one call of a package's UI.705 lines
• log (private)The Console's log: one bounded, thread-safe record of what the application reported (the cook's errors and warnings, opens and saves, packages through HostStatus::console, rendering), for the Console pane and the status bar's counts.444 lines
• log::sinks (private)What reaches the Console from outside the editor's own code: the log facade (wgpu, naga and any crate write to it) at warnings and worse, and panics (a worker that catches its own goes on; the message and its place still belong in the Console).80 lines
• packages (private)Packages: the installed packages with a UI, each one's UI state, and what their calls queued for after the call.225 lines
• packages::library (private)The libraries as the menus read them: for where the user is, the held-key menus' defaults, the right-click menu and the menu bar's entries, and every item they may hold, by name, with where it runs.343 lines
• packages::plugins (private)The plugins of a run, loaded once at startup, before the first editor is made: from the application's plugin folder and the user's (core/plugin-host), but those turned off in the settings; or, given a --plugins list, exactly the packages it names and what ...73 lines
• paint (private)What the image pipeline draws, painted by the window: a Render view's image and the canvas's composite as paint callbacks inside the interface's own pass, and the swatches' pictures as textures, each uploaded once.123 lines
• panes (private)Panes: the panes docked between the menu bar and the status bar (dock): the network pane over every level, the inspector, the outliner, the spreadsheet, the Console, the Timeline, the 2D canvas and the views' slot (E5), the shelf across the bottom of ...440 lines
• panes::canvas (private)The 2D canvas pane: what the open object's result, or the active object's, paints through its data type's Canvas facet, drawn on the GPU (kinogaki_image_pipeline::canvas) and shown through the color service's view transform.738 lines
• panes::canvas::arrange (private)Arranging a picture's pieces on the canvas, for any context whose values say which node placed each piece (PieceSource) and whose nodes declare Translate, Rotate and Scale handles over their rows.611 lines
• panes::canvas::laid (private)The geometry of arranging on the canvas, on plain numbers: where a picture's pieces lie, the frame around a selection, what lies at a point or in a box, what a gizmo's drag makes of the pointer, and snapping.619 lines
• panes::canvas::paint (private)What the canvas draws over the picture while arranging: the picked pieces' outlines, the frame and its handles, a box being drawn and the lines a move snapped to, square and in the accent, as the interface draws everything.57 lines
• panes::canvas_text (private)A picture's text set: each text piece becomes an image piece in its place among the others, its color (the display's code values: white text is 255) times the text's coverage, at the size placed shows it, one pixel a canvas unit.157 lines
• panes::console (private)The Console (R4 E4): the Shell's log drawn by lib-ui's console, a view only.67 lines
• panes::dock (private)The dock's panes and where they sit at first (bced4430's arrangement): on the left the views with the Timeline along their bottom, over the network pane with the spreadsheet and the Console as its tabs; on the right the outliner over the inspector.104 lines
• panes::inspector (private)The inspector (R4 E4): the sheet of what the user looks at.464 lines
• panes::inspector::edits (private)What the inspector asks for, as values: the pane reads &Document and returns these (Asked): edits of the document, which the frame applies with apply, and asks of the frame (Ask).281 lines
• panes::inspector::keys (private)Keying rows, one way for every sheet: a node's parameters, an object's placement and its kind's rows.132 lines
• panes::inspector::node (private)A node's sheet, whatever its context: its Name; its type's rows (NodeType::schema over its description and its spares, at the values cooks read: what subnet parameters drive written in); a Reload under each File row; its held delta's rows ...772 lines
• panes::inspector::node::edits (private)What the user did to a node's sheet or card, as the inspector's edits: parameter changes (one step per change, a drag's inside its gesture), renames, wire edits, promotions and row actions.259 lines
• panes::inspector::object (private)An object's sheet: its name and kind, its local transform where its kind has a place in the world (Scale's fields locked together or not), its kind rows (Scene::kind_sheet: a Render Output's own fields, a light's, fog's or Render Output's engine values, a ...326 lines
• panes::inspector::subnet (private)A subnet's sheet: its name and its interface.273 lines
• panes::network (private)The network pane (R4 E3): lib-ui's graph canvas over every level the document can show, an object level's tiles or a level of any core network, with the same gestures everywhere.627 lines
• panes::network::asset (private)Save as Asset…: a window asking what the picked subnet's asset is called (its label, and the name its definition is kept under, which follows the label until it is typed).88 lines
• panes::network::category (private)What kind of work a node does, which a network shows by color alone (owner 2026-10-25: tiles carry no per-tool icon): lib-ui's graph accent, a bar along the node's left edge and, in pixel art, its title band.86 lines
• panes::network::commands (private)The network pane's commands: what its right-click menus list and its keys run, in families (Edit, Flags, Actions, Subnet, Hierarchy).348 lines
• panes::network::edits (private)What the network pane asks of the document, as values: the pane reads &Document and returns these; the frame applies them with apply.480 lines
• panes::network::header (private)The bars floating over the network canvas: Up and the breadcrumb at the top left, Frame at the bottom right, each a panel as wide as what it holds so nodes show (and take the pointer) everywhere else.94 lines
• panes::network::input (private)What the pane runs beside its canvas: its keys and the window's clipboard events while the pointer is over it, the commands those and its menus run on the picks, the in-place rename they start, and Tab and Save as Asset while they ask.163 lines
• panes::network::level (private)A level of the network pane as plain data, built from the document and the registry (no model trait): an object level's objects as tiles, or a level of a core network: its nodes, subnets and boundaries, their ports colored by their data types and their wires.442 lines
• panes::outliner (private)The outliner (R4 E4): the scene's object tree by lib-ui's tree view, with a search field over it and the flag columns (Lock, Visible, Template, Render).488 lines
• panes::probe (private)What the harness reads of the panes (the harness feature).67 lines
• panes::shelf (private)The shelf (Window ▸ Tool Shelf): lib-ui's Alias-style shelf across the bottom of the views' pane, or the canvas's where a context works on it, the pane and its toolbar above it.186 lines
• panes::spreadsheet (private)The spreadsheet (R4 E4): the tables the shown value's data type gives (its Tabular facet), one tab a domain, a column a value of a row: vectors as components (.x .y .z, .r .g .b .a, .u .v), matrices as [r][c], arrays as their length and first items ...172 lines
• panes::spreadsheet::model (private)The spreadsheet's model of one table of one value: its sub-columns, the sort order and the block of rows on screen, built when the value, the table or the sort changes and read when the rows on screen do (never every frame).348 lines
• panes::timeline (private)The Timeline (R4 E4): lib-ui's time slider over the scene's time (Document::time), in frames at the range's rate, with a tick at each key of the inspected node.324 lines
• places (private)Where the frame drew what a driver may point at (menu titles and items, a modal's buttons), by label path, and the texts a context's live tools painted over each view: the harness's locators and a --script's @names read it instead of the editor's state.154 lines
• probe (private)Probe: what a part reports to the harness, held only in builds with the harness feature.69 lines
• settings (private)The user's settings, kept as a Prism text document (settings.prisma) in the user's configuration folder:542 lines
• settings::color (private)The user's color settings (def color "color" in the settings file) and Settings ▸ Color: the viewer's display, view, look, exposure and gamma.143 lines
• settings::import_page (private)Settings ▸ Import: File ▸ Import's options, one format at a time, chosen from a Format dropdown, as the format's own rows for reading a file's items as objects (FileFormat::schema, Purpose::Objects) over the draft's options of it (its defaults until the ...96 lines
• settings::marking_page (private)Settings ▸ Marking Menus: the menus' size, and for each set of menus (the object levels', each package's), each held key and each level, the eight compass items and the list below South.305 lines
• settings::shelves_page (private)Settings ▸ Shelves: for each set of shelves (the object levels', each package's), the shelves in order with their items.256 lines
• settings::shortcuts_page (private)Settings ▸ Shortcuts: one key store at a time (Global, the viewport's, the network's, each package's).193 lines
• settings::transform (private)The transform tools' user settings: the space each tool works in, per context, and snapping (on or off, Rotate's and Scale's steps, how near the pointer a target must be).328 lines
• settings::window (private)The Settings window (File ▸ Settings…, ⌘,): lib-ui's settings window over a draft of the user's settings, applied on OK or Apply, dropped on Cancel.470 lines
• settings::writer (private)The settings file written on a worker of its own: a change hands it the text; the worker writes the newest text it holds (changes that come while it writes are coalesced into one write), wakes the window with a failure, and the UI thread never waits on the ...136 lines
• shell (private)Shell: the application around the document: the system's file dialogs, the document's file and its opens and saves, the status line, what this frame's input says, and the services every worker wakes the window through.530 lines
• shell::chrome (private)The window's chrome around the workspace: the menu bar with the document's name and the status bar with the status line.142 lines
• shell::clipboard (private)What Copy and Cut put on the system clipboard.98 lines
• shell::confirm (private)"Save changes?": asked before an action that leaves the document, and the windows over everything it shows in.68 lines
• shell::dialogs (private)File dialogs: the editor asks, the system's panel answers later and wakes the UI, and the answer becomes an action in the next frame.147 lines
• shell::files (private)The document's file: where it is, what it kept unread, and the open, save, import, export, embedding or extracting under way.299 lines
• shell::machine (private)What the shell asks of the machine.113 lines
• shell::objects (private)The object levels' library (the scene root and a Part), in core's own vocabulary: the creations (core's Part and Camera, the installed kinds'), the commands on the selected objects and the object selection's.291 lines
• shell::probe (private)What the harness reads of the shell (the harness feature): every probe of the shell's state is here.72 lines
• shell::status (private)The status line's own pieces, beside the problems the shell keeps (the error, the progress, the Console's counts): on the left where the user is and what the selection holds, on the right the cook, the grid step and the up axis.195 lines
• view (private)ViewState: the viewport.531 lines
• view::apply (private)What the user asked of the document in the views, done to it (apply), and the gestures the views' drags hold.107 lines
• view::branches (private)Branch picks: while the open context's live tool works on a node (its viewport layer's live_node), the open network's templated branches are picked in the views through the shown value's type (ObjectPicking::piece_ray on each template piece).148 lines
• view::camera_menu (private)A view's name at its top is its Camera menu: the Camera objects to look through (while there are any), the view's own Perspective, axis and isometric views, Camera from View, and Render (while an engine is installed), which shows the active render in the view.84 lines
• view::cameras (private)The views' cameras and display options, held here and nowhere else: one or four views (Top, Perspective, Front and Right), the active one, each view's camera, the installed packages' values of it (core's among them: what it draws, ViewDisplay) and its ...520 lines
• view::chrome (private)Core's controls over the views: each view's buttons and Camera menu, the popovers they open, the Tab browser, the toolbar's choices and what the controls cover of the views.227 lines
• view::components (private)Picking the open object's components: what lies under the pointer, or in a box, on its shown value's own surface, as the value's Components through its type's Pickable.499 lines
• view::display (private)A view's Display popover, core's own beside its Camera menu: what the view draws, each view's own (saved with the project's view, never undone, nothing cooks).395 lines
• view::drag_events (private)The events a view's drag reads, one way for the transform gizmo and the declared handles: a drag takes the events of the view it began in alone (of_view), and each event reads as what it does to a drag (read): a press that may begin one, a move, the ...68 lines
• view::drawn (private)What the views draw of the scene: every shown object's pieces from the board, each placed by its object's world, in the look its role, its flags and the selection give it.416 lines
• view::edit (private)What the frame lends the views (Reads) and what the user asked of the document in them (Edit).175 lines
• view::edited (private)What the open context adds over its object in a view: the Edited its display part returns each frame, as the views draw it over the packet core prepared from the shown value.74 lines
• view::glyphs (private)Objects drawn as lines where they are (a camera's frustum, a light's shape): the glyphs of every kind with the Glyphs facet, placed by their objects' worlds, drawn as world-space scene lines with the rest of the scene, picked by the pointer's distance to ...284 lines
• view::gpu (private)The views on the GPU: lib-viewport's renderer drawing each shown view into its own texture, which the view's pane paints.315 lines
• view::gpu::probe (private)What the harness reads of the renderer.36 lines
• view::handles (private)Declared and cooked handles (Houdini's handle bindings, Maya's manipulators): the handles a node type's description binds to its parameters and those its cook places on its result (Outputs::handles), or those an object kind gives its objects (a spot's ...520 lines
• view::handles::drag (private)What a drag of a declared handle's part writes: the values at the press, moved as the pointer says, kept to the handle's constraint and range and to the parameters' limits, and snapped while snapping is active (positions and lengths to the grid, turns by the ...370 lines
• view::handles::paint (private)How declared handles look: the gizmo kinds as the transform gizmo, the rest as accent lines and dots (the lit one larger).135 lines
• view::handles::shape (private)Where a declared handle's parts are in a view and which one a point is over: the transform gizmo's frame for the gizmo kinds, and the dots and rings of the others, each in the handle's place (its frame in its space) and from its anchor.448 lines
• view::handles::target (private)Whose handles a view shows, and how their values are written.179 lines
• view::harness (private)What the harness reads of the views (the harness feature).97 lines
• view::input (private)The views' input: handles and the gizmo, hover, clicks and the marquee on objects or the open value's components, the pivot pick and the views' keys.593 lines
• view::instance_marks (private)The open object's marked instances: the placements of those selected and of the one under the pointer, as extra scene objects drawn over the rest.94 lines
• view::levels (private)The open context's selection levels in the views: the level row at the top left of the view pane (the levels the context declares, then its preset), and the number keys over a view (the viewport's key store's Level and AddLevel).315 lines
• view::live (private)The open context's live tools over the views.154 lines
• view::looks (private)The colors and images the views shade pieces in: each shown value's Look asked for each of its pieces against the scene's Materials (the render geometry's one store, as Displays).104 lines
• view::moving (private)A drag of the open polygons' points, previewed over the shown value: the Edited::moving the open context hands each frame, shown through geometry-view's DragPreview.147 lines
• view::node_values (private)Nodes' values the open context has core draw (Edited::ghosts, each in its tone's theme role) or snaps its tools on (SnapOn::Node).130 lines
• view::objects_frame (private)The object level's gizmo frame: the selected objects' pivots and the box of their subtrees as the views draw them (ViewState::objects_frame), and the boxes F frames (ViewState::objects_bounds).143 lines
• view::pick (private)Picking objects at an object level through their results' types (ObjectPicking): the nearest surface under the pointer, and every object a marquee touches.173 lines
• view::popover (private)The viewport's popovers: the Gear at the foot of the left toolbar (the transform tool's settings here: its space, core's own row, then the open context's rows, its Transforms::gear), shown while it has rows; and each view's Display beside its Camera menu ...229 lines
• view::press (private)Whose the pointer's press is: the camera's or the views' tools', never both.99 lines
• view::render (private)The views' images: each view's texture or render painted, then rendered at the frame's end with what the open context adds over its object; the drag preview, the marked selection and the tools' snaps.255 lines
• view::snaps (private)A context's tools snapping in a view (ViewCx::snap): the same search as the gizmo's (Probe) over one value (an object's shown value or a node's, super::node_values).56 lines
• view::space (private)The views' tapped key (Space by default, ViewKey::Views): a tap — a press and its release within half a second, with no other key or button between — shows four views or the one under the pointer, on the release; its fill key pressed while it is held ...157 lines
• view::through (private)Looking through Camera objects, as Maya does: a view bound to a camera shows what its lens sees (projection, view angle, film shape, clipping and roll), and navigating that view moves the camera, one undo step a drag or a scroll (an orthographic camera's zoom ...351 lines
• view::toolbar (private)The left toolbar of every view: manipulation only (owner, 2026-10-20), the same set in every context, in the middle of the views' height.90 lines
• view::transform (private)The transform tool every context shares: Q (Select), W (Move), E (Rotate), R (Scale) and T (the Manipulator); the space each tool works in; snapping and its steps; and the gizmo's drags (drag, typed values in typed).682 lines
• view::transform::drag (private)One gizmo drag, from press to release: what it makes of the pointer.179 lines
• view::transform::entry (private)The numeric bar at the bottom center of the active view (owner round 3): with objects selected and Move, Rotate or Scale on, the pivot button, then the active object's translate, rotate or scale (objects) as three fields, X, Y and Z in the axis colors, in ...199 lines
• view::transform::objects (private)W, E, R and T on the objects of an object level.195 lines
• view::transform::pivot (private)The transform pivot (owner, 2026-10-20): the point the gizmo sits at and Rotate and Scale turn and scale about, chosen from the numeric bar's pivot button.322 lines
• view::transform::selection (private)The gizmo inside an object, for the open context's selection (G7): while its viewport part transforms(), the handles sit at the pivot resolved against what its levels' pivot gives, along the user's space in the open object's space, and each step of a drag ...82 lines
• view::transform::snap (private)Snapping a gizmo drag to targets.624 lines
• view::transform::typed (private)A value typed during a gizmo drag: digits, arithmetic and units (as the sheet's number fields take them) set the drag's distance, angle or factor exactly.108 lines

Public types and traits

At the crate root

Structs EditorLaunchOptionsPlugins