A wall end point (spec 11 D2, decision 4): wall wall's end k (0 its
start, 1 its end) on side, looking from the wall's start to its end.
It stores no coordinate: its point is read from the wall
(wallEndPoint), and the dimension group's transform never touches it
(decision 12).
Spec 06 D13: two opposite corners, world-axis aligned, committed as a
parametric box — a group at the lower-left corner carrying BoxParams.
The expander generates its lines. Fill does not apply.
A rectangle whose outline loses what lies strictly inside any
overlapping box: overlapping boxes read as one outline, the wall
clean-up preview (spec 06 D13).
A dimension's grips (spec 11 D13), through the render layer's object
grip seam. Every coordinate is world, and every grip is a stretch grip,
so it is hit and dragged only while components and geometry are
allowed (07 OG5). The ordinals (R-26):
Spec 11 D12: the Dimension tool (I). A PlacementTool of three clicks
per dimension (decision 9), not chained (R-25): after the commit it
waits for a new first click, as 10's Separator tool.
The toolbar at the left of the top bar (spec 12a D7): one icon button
per command of the table (D6), keyed toolbar-<id>, with the command's
tooltip, disabled while the command is. The file commands come first,
then a gap, then Undo and Redo. A bare shell has no file commands and
shows Undo and Redo only. DocumentToolbar.groups lays out any run of
groups the same way (host embedding API spec C-2): a gap between two
groups that both show a button.
The font's bytes, read on first use and then held for the app's
lifetime (spec 13 D7: "once per app"). A failed read is not held: the
next bytes reads again.
The ghost's reused matrix (spec 09b D6, 09c D5): the placement transform
P is handed in by the tool, which computes it on pointer, key, camera
and re-arm events (spec 09c D12); its linear part is written only
when one of its six doubles differs from the last (update); a paint
(forOrigin) writes only the translation less the rebase origin.
Spec 12b D12: the Selection section's layer menu. It shows the
selection's common layer (layerOfKey), or the strings' mixed;
choosing a layer dispatches layerMoveCommand's one command, built from
the document and the selection as they are at the choice, not at the
last build.
One layer of the Layers panel (spec 12b D9): the current-layer mark, the
eye, the lock, the colour swatch and its menu, and the name, which a
double-click turns into an inline field.
An opening tool's settings (spec 08 D14, Ruling 08-17): the width of the
next opening, in mm. The shell owns one per kind; the Selection panel's
Opening section edits the active tool's.
Spec 08 D14: the Door (D), Window (N) and Gap (G) tools, one class and
three instances. A PlacementTool whose first click commits one
opening; the tool stays active, so a run of doors is a run of clicks,
and Escape (with nothing pending, ever) returns to the select tool.
The smallest panel that lets a human change the page (spec D12). Every
control executes one SetComponentCommand; the panel rebuilds from the
notifier, so undo moves the controls back. 12 replaces this.
What traceRoomAmong traces among (spec 10 D7): the live walls and
separators, by place box. RoomInputs (the document adapter) and
placeSourceInView (the view's) implement it.
Owns the index, the camera and -- since 03 -- the outline cache and the
grip cache for the document's lifetime; since 05, the tools and the Fill
toggle. It lays out the chrome slots.
The rulers around the drawing area: a RulerFrame whose child is a
CameraGestureDetector over the page chrome, the DraftCanvas and the
selection overlay, with -- since 05 -- the text tool's inline field
painted above it. Without rulers (the selection mode) the drawing area
stands alone.
A room's label grip (spec 10 D21, S-10, R-22, R-26), through the render
layer's object grip seam. Every step is in a named frame: _w world,
_l the room group's local space.
The trace inputs of a whole document, for the Room and Separator tools
and the separator grips (spec 10 D4, D19-D21; Ruling 10-11): the
document adapter. The shell owns one instance and hands it to all
three.
Spec 10 D19: the Room tool (M). A PlacementTool whose one click
commits one room; it stays active, and Escape (with nothing pending,
ever) returns to the select tool.
The seed lies inside source's band, or within roomTrace.linear of
one of its edges or of its separator's segment. When several inputs hold
the seed, source is the lowest handle among them (Ruling 10-7).
A room separator's parameters (spec 10 D3): both ends in group-local
space, in mm. A free two-point line that splits a face as a
zero-thickness wall would.
Spec 10 D20: the Separator tool (S). A PlacementTool of two clicks
per separator, not chained (R-20): after the second click it waits for
a new first click. Escape cancels a pending start, then returns to the
select tool.
A symbol's identity and display data, attached to a definition's
handle (spec 09 D3, R-2): a stable key (lower-case dotted, e.g.
bed.double), the display name, a category, tags and an integer
version. The same key and version is reused by a placement, a different
version is copied beside it (decision 8).
One symbol of a library: its identity (the SymbolComponent fields), its
definition and a snapshot of its leaves, ascending by handle so
draw order is preserved when a placement copies them (spec D6).
One library the loader reads (spec 14 V-4): a name its errors use and
a reader of its bytes. A host adds its own beside the planner's
furnitureSymbolSource.
An edit and the derived commands it makes necessary: inner applies,
then, per touched handle in touched's order, a table whose label no
longer matches tableLabelStamp for its transform is re-stamped (T12),
by exact == on the stored values. A deleted table's host data is not
among them: RemoveNodeCommand takes it (node-components D-1). All or
nothing; undo restores the stamps and the edit. Created only by
TableLabelSystem, once per execute.
Stacks on the dispatcher's one expander slot (spec 06 D2, 14a F-1):
install keeps the expander it found (the parametric system's, or none)
and wraps what that one returns; dispose puts it back.
The walls' bands, cached for the tools that look for a wall under the
pointer on every move (spec 07 D11; spec 08 D14, Ruling 08-11): the Wall
tool, which joins a band it is clicked in, and the Door, Window and Gap
tools, which find their host with hostAt. The shell owns one instance
and hands it to all four.
The Wall tool's settings (spec 07 D11): what the next wall is drawn
with. The shell owns them; the Selection panel's Wall section edits
them while the tool is active.
What a dimension measures along (spec 11 D6, decision 2): the true
distance between its two points, or their distance along its group's
local x (horizontal) or local y (vertical) (decision 17).
Which of a wall's two faces a run lies on: the wall's frame's
(local) sides (HostFrame.n is the left normal), not the world's. Under
a mirrored group the frame's left face is on the world's right.
Which of a wall end's three points (spec 11 D4, decision 4): the left
face, the centreline or the right face, looking from the wall's start to
its end.
Every attach decision of a dimension (spec 11 D10): a candidate is a
wall end point within linear mm of the resolved point, Euclidean, and
decision 19's parallel band is angular wide. Absolute, in mm, like
wallJoin: the snapped point is the stored local ring mapped to world,
the attach point is computed in world, and they differ by rounding only,
worst 4.3e-7 mm at +1e9 mm turned 23° in own groups (the spike's Q3a).
Nothing a person draws is 1e-5 mm apart. Stored values are still
compared with exact ==.
Every rounding and reading decision of a dimension's value and text
(spec 11 D8, D9): a value within linear mm (one wallJoin.linear) of
a rounding half is on it and rounds up, and a unit direction whose
|x| is at most angular is vertical.
The largest value, mm, a dimension lays out (spec 11 D9, D15): 1e15 mm,
1e9 km. Above it layoutDimension gives null and the dimension is
dimension.broken, as for a value that is not finite.
The bundled font's asset key: the package's lib/fonts/ file, declared
under assets: in its pubspec.yaml, so every host has it. It lives
under lib/ so a host can also declare the bare family Roboto from it
(packages/jet_cad_floor_plan/fonts/Roboto-Regular.ttf), as
apps/floor_planner does (spec 14 V-11, review F-1); either way
ensureFloorPlanFonts registers Roboto from these bytes.
Each label line sits this many of its own heights above (the name) or
below (the area) the anchor, in world directions (spec 10 D10): a gap of
0.2 · (h_name + h_area) between the two.
How far a room's read box reaches past its stored points and its seed,
mm (spec 10 D16, R-7): twice D7's certificate margin, so rounding in the
local-to-world map of the stored tint cannot put box(F) ⊕ m outside
it.
The tint's colour (spec 10 D9, R-8): ACI 7, the foreground, black on
White, Ivory and Grey paper and white on Blueprint, resolved at paint
time. Explicit, not ByLayer, so a change to layer 0's colour does not
recolour tints.
The Rotation field's display steps per degree: it shows a rotation
rounded to a millionth of a degree, and a typed value within one step
of the current rotation is the shown value committed again, not a
turn. A property of the field's text, not a geometric tolerance.
The width of the tint's slit to each hole, mm (spec 10 D9, R-11): the
engine's triangulator refuses an exact keyhole, whose bridge is two
coincident edges (the spike's Q5, M-slit).
Spec 09c D4, D6: how near a wall face, in screen pixels, the raw pointer
attaches a tagged symbol. Larger than the snap aperture: in placement
the pointer is often the symbol's centre, far from its back.
Every wall child's colour (spec 07 D3): a black band, fill, outline
and centreline alike, on every paper. Concrete, not ByLayer. When 07
landed, layer 0's ACI 7 resolved to white (aciToRgb(7)) and a ByLayer
band was paper-white. Since fix/post-07 the shell's resolver draws ACI 7
in a foreground that follows the paper, black on a light one and white
on Blueprint, so ByLayer drafting follows the paper and a ByLayer wall
would too. Walls stay black on the human's decision: a concrete colour
does not depend on the resolver, so on Blueprint a wall is black while
drafting is white.
Every geometric decision of the room tracer (spec 10 D5, R-6): two
points within Tolerance.linear are one vertex, a segment no longer
than it is dropped (and a separator no longer than it is degenerate,
D3), and two directions within Tolerance.angular are parallel.
How many walls have passed attachCandidates' line test, ever. For
tests only, which read the difference across a call (TL8: a hover
inside a wall's band passes none); a plain counter, as 10's
debugTracedSegments (the plan's Ruling 11-2).
The tint steps (1 or 2) a room's tint builder treats as failing to
triangulate (Ruling 10-16). Honest rooms reach D9's steps 2 and 3 (RG2
has both); the seam exists to exercise the room's local-frame
triangulation guard (_storedTint), which no honest fixture reaches:
RG2 and DG3 set it. Null in the library, which never sets it; tests
restore it to null in tearDown.
The segments every traceRoom call has taken in (step 3 of spec 10 D5,
after the short ones are dropped), summed: the tracer's cost for tests
that pin it (D7's counter). Never reset by the library.
How many times attachCandidates computed a wall's six points (one
wallsInDocument and wallEndPoints each), ever. For tests only, which
read the difference across calls (TL8: with a memo, a wall's points
are computed once per generation); a plain counter, as
debugLineTestPasses.
Every file command's chord: what the app binds a second time above the
Navigator, consume-only (spec 12a D6, U-3, R-10). Export's and Print's
join them (spec 13 D8, R-8): with a dialog up, Ctrl+P must not reach the
browser's own print.
The floor planner's parametric types (spec 07 D1, 08 D1, 10 D1, 11 D1):
the Box, the Wall, the Opening, the room Separator, the Room and the
Dimension. A box and a wall may be neighbours; each type's generate
ignores the other's parameters. An opening is nobody's neighbour: it
relates to its host wall by reference (08 D2). A separator and a room are
nobody's neighbours either (their reach is empty, 10 D2, D3): walls and
separators contribute places, and rooms read them (10 D16). A dimension
is nobody's neighbour either (11 D3): it relates to the walls it measures
by reference.
The attach candidates at world point q (spec 11 D10, R-16; decision
23; S-13): every (W, k, side) of a live wall W whose point
(wallEndPoint, among every other live wall: wallsInDocument) lies
within dimAttach.linear of q, Euclidean. Ascending by wall handle,
then k, then side (left, centre, right).
The one attachment rule (spec 09c D4): where a symbol whose local box is
box stands against one of runs for the anchor point p (the raw
pointer in placement, D6; the plain-moved back-centre in a move, D8), or
null when no run takes it.
The local box of the definition definition in doc, from its live
leaves (the entities it owns); null when definition names no definition
or none of its leaves draws.
The document holding every symbol of catalog as a definition with its
leaves (spec 14 V-3: any catalog, the furniture one or a host's).
Deterministic: handles ascend in catalog order (a definition, then its
leaves, then the next definition), so two builds encode to identical
bytes. A servable symbol's definition also carries its
SeatingComponent (spec 14 S2), set right after its SymbolComponent.
outline's two caps kept apart (spec 08 D7), in world space: the end
cap, from the wall's right face to its left face, and the start cap,
from its left face to its right face — [...endCap, ...startCap] is
outline's ring before it is simplified. When that ring is not simple
and anticlockwise, both caps are the free caps and fellBack is true,
as outline's fallback. Null for a degenerate wall (07 D2).
One open two-point centreline per piece piecesOf keeps, in the same
order (spec 08 D9, decision 16): the start piece's from u = 0 (the
stored start) to a₀, a middle piece's from bᵢ to aᵢ₊₁, the end
piece's from bₙ to L (the stored end). A dropped piece has none.
The Change size step (D7, decision 9): instance takes entry's
definition (reused or copied, definitionForEntry), its linear part
kept and its translation chosen so the new box's back-left corner
(left', back') lands where the old (left, back) was. Null when the
instance already draws entry's key (re-picking the checked size is
not a size change: it would copy a fresh definition over an older
version or an edited one), or a box is missing.
Where each of one host's openings cuts, and the host's merged cuts (spec
08 D8). openings are (centre, width) in ascending handle order;
stretches and frame are the host's.
The end a dimension stores for a point whose attach candidates are
given (spec 11 D10's "The choice among candidates", R-17; decisions 19
and 22), or null when there are none (the end is fixed).
The page a new document gets (spec 12a D4, S-3, T-11): A4 landscape at
1:50 in metres, every field at its default, with a fixed origin. The
sheet is 297 × 210 paper mm, 14,850 × 10,500 world mm at 1:50, so this
origin centres it on the world origin. Not centred on the extents, as
the sample's page is: an empty document's extents have a NaN centre,
which the page refuses.
The definition a placement of entry in doc uses, and the commands
that make it when it is a copy (none when one is reused): the one
reuse-or-copy path, shared by placeSymbol and a size change (spec 09c
D7, V-7). A definition is reused when it carries the entry's key and
version, still exists, agrees on seating (spec 14 S2) and is leaf-equal
to the entry; otherwise the definition is copied with fresh handles,
allocated here. The entry's leaves are ascending by handle (R5-7).
The decimal separator a new plan takes in strings' language (N1):
DecimalSeparator.comma when the language's panels print ,
(FloorPlanStrings.decimalSeparator), DecimalSeparator.point
otherwise. Only a new plan reads it: nothing converts a plan that exists
(N2).
w's caps as they are drawn (spec 11 D4, R-5): the caps whose
points are the corners of the outline the wall stores, in world. Null for
a degenerate wall (07 D2). Two steps, 07's two fallbacks:
The world point of end of dimension self in view (spec 11 D6), or
null when the end is broken (D7): an attached end whose wall is not a
live wall or whose k is outside {0, 1}, or a fixed end with a
non-finite coordinate.
Adds kDashedLinetypeRecord to doc's linetypes, outside the history
(spec 10 D3): the sample plan and the test fixtures call it when they
make a document. installParametric does not: on a loaded file it would
change the document outside the history.
Registers family kFloorPlanFontFamily from the package's bundled Roboto
(read from bundle, rootBundle when null). Once per process: every
call after the first returns the first call's future, unless that one
failed, in which case the next call tries again. A host awaits it before
runApp (after WidgetsFlutterBinding.ensureInitialized()).
instance's library entry (V-5): the exact key@version of its
definition's SymbolComponent, else the key's highest version; null
when the library has neither.
page of document as choice says: a vector PDF with fontBytes'
font embedded (read only for a PDF), or a PNG at the chosen dpi; the
separators omitted either way, and the coloured tables filled under the
drawing at tableColorOpacity (plan colours spec PC-7).
The page document's root carries, or null when it has none (spec 13
D8: the flow then returns without effect). Read from the document, never
from the screen: the export plots the page, at its scale.
page of document as a vector PDF with fontBytes' font embedded,
the separators omitted, the coloured tables filled under the drawing at
tableColorOpacity (plan colours spec PC-7): what Export → PDF writes
and what Print hands to the printer (spec 13 D8, D9).
host's face runs among walls (any walls; host itself, degenerate
walls and walls that do not touch it are ignored), spec 09c D3. The
left face's runs, then the right face's, each ascending along the
frame's direction. Empty for a degenerate host.
The face runs of wall wall of doc (spec 09c D3) through the document
adapter (wallsInDocument: every other live wall can cut it). Empty when
wall is not a live wall, is degenerate, or accept refuses it (the
shell passes isUsableHost: a hidden or locked wall hosts nothing).
accept is asked only for a live wall.
The members of entry's size family (V-5, V-4): every entry of
library carrying its tag, from any source, one per key (its highest
version), none servable, sorted by width then depth. Empty when entry
has no family. Memoised per library and family: the panel rebuilds on
every hover.
The lowest-handle leaf owner owns, or null. O(entities): at command
or document-change rate, never per frame. With leavesByOwner
(DraftDocument.leavesByOwner, shared by a caller asking for many
owners in one pass), only owner's own leaves are visited.
The area label's string for mm2 mm² in the page's unit (spec 10
D11, decision 6): m² for millimetres, centimetres and metres, ft² for
inches and feet-inches (304.8 × 304.8 mm² to the square foot, in double
arithmetic); always two decimals, the page's decimalSeparator as the
separator (spec Q0 T1), no grouping.
A dimension's text for a length of mm in the page's display unit
(spec 11 D9, decision 7): no unit symbol, the page's decimalSeparator
(spec Q0 T1; . in the examples below), no grouping, each unit at its
plan precision:
The outline of entry's leaves in the symbol's local frame (the
definition's coordinates, base point not subtracted), built on the first
call and the same object on every later call for the same entry.
host's cuts through the view adapter: one computation, made by the wall
for its pieces and by each of its openings for its symbol and its
diagnostics, so all of them see the same decision. Memoised per view
and host. Null when host has no openings, is not a live wall, or is
degenerate (07 D2: no frame).
host's frame (spec 08 D7), among walls (any walls; classify skips
host itself, degenerate walls and walls that do not join it). Null
for a degenerate host (07 D2).
Whether the UTF-16 code unit u is a control character: below U+0020
(C0, a line break among them) or U+007F to U+009F (DEL and C1). The one
rule tableNumberProblem and the table data limits
(tableDataProblem) share.
Whether the definition definition in doc is leaf-equal to entry
(spec 09c D10, W-11): what a placement checks before it reuses a
definition found by key and version.
Whether h is a live T of doc: a live parametric object whose
naming registration is exactly T's, as the engine's survey reads it
(ParametricCatalog.names on parametricCatalog). A root-level group
carrying two registered types (only a file makes one) is the later
registration's object, and the earlier type's nowhere; a component on a
nested group, an instance, a leaf or a handle with no node is no
object's. T is matched exactly: a supertype names nothing.
Whether w is a width the tools and the panel may give an opening of
kind (spec 08 D6): finite and greater than wallJoin.linear, or than
4 × wallJoin.linear for a gap, whose threshold line is inset from each
jamb (D10). A loaded opening may still hold any width.
Whether g's linear part is orthonormal (spec 09c W-8, S-10):
|a² + b² − 1|, |c² + d² − 1| and |ac + bd| each at most
Tolerance.standard.linear. A mirror is orthonormal; a scale is not.
Whether h is a live parametric object of one of the floor planner's
registered types (parametricCatalog), by the engine's own rule
(isLiveObject): a root-level group carrying a registered component.
Whether wall wall of doc may host a new opening (spec 12b S-11): its
object layer (objectLayer) is visible and unlocked. A tool acting on
the wall under the pointer is selection-like, so a door is never placed
on a wall the user cannot see or select. A missing record counts as
visible and unlocked, as FilterEvaluator counts it. (Decision 8 is
untouched: a hidden wall's existing openings still cut it.)
Whether ring is a piece the engine stores (spec 08 D9; 07 D6's
invariant, per piece): at least three vertices, simple and anticlockwise
(isSimpleCcw), and, closed as the wall stores it, with a non-empty
triangulation (triangulationFor: the very check the engine's planner
makes on a generated region, so the app never generates one it refuses).
Whether t is a thickness a wall may be drawn or edited with (final
review m1, fix/post-11): finite, greater than wallJoin.linear and at
most kWallMaxThickness. A positive thickness at or below the floor is
a band thinner than the join tolerance, and far from the origin its
faces round onto each other; one above the ceiling can collapse the
band (see kWallMaxThickness). The Selection panel rejects any other
value, for a wall and for the Wall tool's settings, and the Wall tool
does not commit with one. A loaded wall may still hold one (D2's
degenerate wall is t <= 0; a thicker one still throws on the Wall
tool's and the grips' regenerating edits, a known limit).
Why the picker is disabled for keys in doc, or null when it is
enabled: a permission set without Capability.components (D11), or a
plain group among the keys (D12).
In strings' language (spec 14d); English by default, the constants
above.
layers in the panel's order (spec 12b D10): layer 0 first, then the
others by name under toLowerCase(), ties by handle. Independent of
creation order, so stable across undo, save and load.
The 0xRRGGBB a layer of color is drawn in, as the style resolver
draws it: ACI 7 (and anything that is not a colour of its own) in the
paper's foreground, another index through aciToRgb, a true colour as
stored.
The layout of a dimension of kind from world p0 to world p1, in a
group whose local-to-world transform is m, with offset its stored
local offset, on page (spec 11 D6-D8; the plan's Ruling 11-3: the
one layout every caller uses). All in world, computed relative to p0
(a far origin costs nothing beyond the points' own rounding):
host's layout (frame, obstacles, stretches) through the document
adapter (wallsInDocument, with moved standing in for the walls it
names). Null when host is not a live wall or is degenerate.
self's outline in its group-local space among neighbours (spec 07
D4-D6; Ruling 10-8): what WallType stores and diagnoses, and what a
room traces once it is taken back to world (spec 10 D4, R-5). One
function, so the wall and both of the rooms' adapters compute one ring.
The measuring direction u (spec 11 D6), a world unit vector, of a
dimension of kind from world point p0 to world point p1 in a group
whose local-to-world transform is m:
The cuts of one wall merged (spec 08 D8, decision 6): sorted by start; a
cut that starts within wallJoin.linear of the previous merged cut's end
joins it, so two overlapping or touching openings make one gap and no
sliver piece.
The document New and launch open (spec 12a D4): prepareDocument, then
defaultPage with decimalSeparator attached through the log (spec Q0
N1), then the history cleared, so a fresh document has Undo disabled
and the host's save point finds it clean.
The name the panel's + gives a new layer (spec 12b D4, spec 14d L7):
strings' Layer N, the smallest N ≥ 1 that no layer's name already
takes in any built-in language (by toLowerCase(), the table's own
folding) and that layerNameError accepts in target.
The next table number over the live tables' numbers (T5): max + 1
over the counted ones, written without leading zeros; "1" when none
counts. When max + 1 would take nine digits, the smallest unused
positive integer instead, so a placement never makes a duplicate or an
invalid number.
The node's reference point: the endpoint of its lowest (handle, end),
the same bits for every member. Used only as the clamp reference and the
feet's base, never inserted as a cap vertex (spec 07 D5.3).
The placement function (spec 11 D6, R-7): the offset, in the group's
local units, that puts a dimension of kind from world p0 to world
p1 in a group whose local-to-world transform is m through world point
q. With u = measuringDirection, n its left normal, the heights
h0 = 0 and h1 (0 for aligned by definition, (p1 − p0) · n for a
linear kind), hi/lo their max and min, hq = (q − p0) · n and s = m.scaleMagnitude:
host's openings in doc: the live openings (the engine's object
rule, asked through live_objects.dart) whose host is host, ascending
by handle, with their parameters, as openingsInView reads them in a
regeneration.
The outer contour of each connected component of the arrangement of
inputs (spec 10 D19; the re-review's T-8 cache, adopted at execution),
its points relative to origin: the component's most negative face
cycle, the walk around its outside, as traceRoom's step 8 finds a
hole's contour. A component with no area (a free separator, or a free
tree of them) is kept too: its walk goes out and back along each edge,
so the crossing number of any point off it is even.
Whether two fitting cuts of one host overlap (spec 08 D8, for D17): each
starts more than wallJoin.linear before the other ends. Touching is not
overlap.
v as the shell shows a stored number: in a Selection panel field, in
the Page panel's scale field and in the status line's scale. The text is
one the fields' parser (double.tryParse) reads back as exactly v,
sign of zero included, so a commit of a shown value writes nothing. A
whole number below 2^53 in magnitude shows without ".0" ("200");
anything else is Dart's shortest round-trip form ("0.1",
"100000000000000000000.0", "1e+300", "-0.0").
The rings of f's band cut at merged (spec 08 D9), in u order, start
piece first: each simple and anticlockwise in the host's local space.
merged must not be empty.
translation(at) · rotation · scale(mirrored ? -1 : 1, 1) · translation(-basePoint): the definition's base point lands on at
(spec F-2), and a mirror flips the local x axis whatever the
rotation.
What a room traces among inside generate and diagnose (spec 10 D7):
the view's placedIn, roomInputInView, and U the union of
placeBoxOf(h) over placedIn of the whole plane (Ruling 10-13), the
engine having already turned a non-finite box into null. Memoised per
view, U included.
A fresh document over measurer with the app's set-up and nothing else
(spec 12a D4): the app's component types registered, once
(registerAppComponents); the header's units millimetres (the header's
own default is unitless); the DASHED linetype record at handle 6,
outside the history (spec 10 D3). No page, no entity, no history.
page's paper in pt, as laid out (orientation applied): the size the
print dialog opens on (spec 13 D9; without it the dialog opens on
PdfPageFormat.standard).
u (a world unit direction) or its reverse, so text along it reads
from the bottom or the right of the page (spec 11 D8, R-11): reversed
when u.x < −dimFormat.angular, or when |u.x| ≤ dimFormat.angular and
u.y < 0. Text angles land in (−90°, 90°], and exactly vertical, within
the tolerance, reads upwards (+90°): a group turned −90° gives u = (6.1e-17, −1), which without it would read from the left.
Registers every component type the app's documents carry (spec 12a D8,
S-1): PageComponent, the parametric catalog's types, then
SymbolComponent (spec 09 D1; not a parametric type), the
SeatingComponent (spec 14 S1; not a parametric type either), and the
host's FloorPlanTableData (host embedding API spec E-6) and
FloorPlanTableColor (plan colours spec PC-4). The one
registration New, the sample and Open use — pass it as
DraftDocumentCodec.decode(…, registerComponents: registerAppComponents).
Without the page's registration a file's page loads as preserve-unknown;
without the catalog's, its walls, openings, rooms and dimensions do.
Registers the font's licence with LicenseRegistry under the package
name Roboto, its text read from bundle (rootBundle when null) when
the licences are collected.
Forgets the registration, so the next ensureFloorPlanFonts registers
again: a test seam (the registration is process-wide, and a test must
not inherit another's pending future). The engine keeps any face already
loaded.
payload re-stamped for placement: anchor and height kept, rotation
and width factor replaced. Null when they already match by exact ==
(stored values), so a translation writes nothing (T12).
h's input through the view adapter (spec 10 D4): a wall's neighbours
are view.neighbours(h) carrying WallParams, ascending. Memoised per
view and handle. Null for a handle that is not a live wall or
separator of the view, and for a degenerate one.
t turned so its Rotation reads degrees (any finite number, taken
modulo 360), about the insertion point t · basePoint (D7): the linear
part A becomes R(θ' − θ)·A, so a mirror and a file's scale are
kept; an orthonormal result at a multiple of 90° is R(θ')·S from the
exact table, S the mirror or the identity, -0.0 normalised.
The command that turns instance by quarterTurns × 90° (positive is
counter-clockwise, on the world and on the screen alike) about its
definition's base point, or null when instance is not a live instance
of a live definition. One TransformNodeCommand in a Rotate compound.
mm in whole quanta of quantumMm, round-half-up, the half decided
robustly (spec 11 D9, R-13): with x = mm / quantum and n = floor(x),
a value within dimFormat.linear mm of (n + 0.5) · quantum is on the
half and gives n + 1; any other value gives round(x).
Removes exact consecutive duplicates and zero-width spikes a, b, a
(spec 07 D6). Stored-value comparisons, so exact; zero area, so the tiling
is unchanged. Without it the triangulator refuses a pinched outline.
The sample's page: A4 landscape at 1:50 in metres, centred on
extents (spec D4), printing decimalSeparator (spec Q0 N1). A new
document's page is defaultPage() (spec 12a D4).
Builds the sample flat (File > Open sample, spec 12a D4) over
measurer. DraftCanvas refuses a document whose measurer is not a
FlutterTextMeasurer, so the caller supplies one it owns. Its rooms are
named in strings' language (spec 14d L7), English by default, and its
page prints that language's decimal separator (spec Q0 N1).
The centre to store for an opening of width w that is to cut at
cut among stretches (spec 08 D14, D16: stored where it is drawn):
cut.a + w/2, moved by the fewest ulps that make placeCut place it
unclamped. (cut.a + w/2) − w/2 need not round back to cut.a, and a
start one ulp outside [a, b − w] would be clamped (D8's exact
comparison), so the opening would be opening.clamped from birth.
Gives up after a few ulps and returns the last value tried: a stretch
exactly w long whose b − w rounds below a holds no unclamped
start at all.
The stretches of frame (spec 08 D7): its straight span minus the union
of obstacles, sorted and disjoint. Subtracting compares computed values
exactly, so each stretch's ends are the span's or an obstacle's own
bits; only the final test, which drops a stretch no longer than
wallJoin.linear, uses the tolerance.
Whether p lies on o's centreline within wallJoin.linear and more
than wallJoin.linear from both of its ends, measured along it (D4.1).
Spec 08 D7's T obstacle reads it with the host as o.
Opening o's symbol (spec 08 D10, D11), computed in its host's local
space on the host's frame f and taken to the opening's own local space
by toOwn, which is toWorld(self)⁻¹ · toWorld(host): host-local →
world → own local. Every child is ByLayer, Generated's default.
A thumbnail's document (spec D5): the placer's own output, so a thumbnail
is what a placement makes. prepareDocument registers the app's
components (so the SymbolComponent is accepted), then placeSymbol
runs at the definition's base point, no turn, not mirrored: an identity
transform.
min(200, 0.4 × min(w, h)), where w × h is the local bounding box of
the served top: the definition's first leaf (14s S4), a closed polyline
or a circle. Any other kind gives the full height.
The label record of a table: owned by instance, on layer 0 (so it
follows the instance's layer, spec 12b S-2), BYBLOCK style, the
standard text style, tag TABLE, text number (T8).
The rotation and width factor that make a label owned by an instance
placed by placement read left to right, unmirrored, along world +x
(T10). The only place this is computed.
Why raw, trimmed, is not a table number, or null when it is one (T4):
non-empty, at most kTableNumberMaxLength code units, no control
character (no line break).
T (spec 11 D10): the largest world thickness of a live wall of
doc, each wall's stored thickness times its group's scaleMagnitude
(so a scaled group, file only, is covered); 0 with no live wall. One pass
over the walls. A live wall is the engine's (the plan's Ruling 11-4, as
amended by fix/live-object-rule: asked through live_objects.dart).
The tint of the face ring minus holes (spec 10 D9), both
anticlockwise as Traced gives them, in the trace's seed-relative
frame (the caller subtracts the seed, and maps Tint.points to the
room's local space after): so the bridges and the slit are decided on
numbers the size of a building, not of the far origin.
The room around seed among every contributor source holds, tracing
only those near its face (spec 10 D7). The result is, bit for bit,
traceRoom(seed, every input) (LZ1):
The separator a person draws from a to b, in world, as it is stored
(spec 10 D20, R-21; Ruling 10-9): the one function the Separator tool and
the separator grips call.
Wall w's point at end k (0 its start, 1 its end) on side, among
others, its wall neighbours (w itself and degenerate walls are
ignored, as in classify) (spec 11 D4):
The walls the tools, the grips and the panel see around host (the
document adapter, Ruling 08-8): host as a WorldWall, and every
other live wall of doc (the engine's object rule, asked through
live_objects.dart: a file's group that also carries a later-registered
type is that type's object, not a wall), ascending by handle. The view
adapter (wallsInView) sees only host's neighbours; classify, cap
and obstaclesOf ignore a wall that does not join host, so the extra
walls change nothing (HF7 pins that both give the same bits). Null
when host is not a live wall.
The walls a regeneration sees around host (the view adapter,
Ruling 08-8): host as a WorldWall, and every neighbour of it in
view carrying WallParams, as 07's outline reads them. Null when
host is not a live wall.
Writes translate(−origin) ∘ p into m, an identity-initialised
column-major 4×4 (canvas.transform's layout): the linear part of p in
[0] [1] [4] [5], its translation less origin in [12] [13]. Composed
in doubles; the other ten entries are left as they are.
A placed symbol standing against a run (spec 09c D4's neighbours): the
interval [lo, hi] its back edge covers along the run's t, measured
from the run's a, and the instance's handle (so a move can leave its
own instance out, D8).
Registers the shell's delete with its host (host embedding API spec
C-3, as Slice 4's S-16 ruled): delete deletes the selection as the
select tool's idle Delete does and answers whether it did. Returns the
withdrawal, which the shell calls on dispose, as
ShellSettleRegistrar's.
Registers the shell's idle probe with its host (host embedding API spec
S-4): true while no tool is part-way through a shape, so the host's own
Undo and Redo wait as the shell's do. Returns the withdrawal, which the
shell calls on dispose, as ShellSettleRegistrar's.
Registers the shell's synchronous settle with its host (spec 12a D2,
plan 12a P-4): the host calls settle before a flow reads or replaces
the document. Returns the function that withdraws the registration; the
shell calls it on dispose, and it withdraws only settle itself, since
a swap builds the next shell before the old one is disposed.
Registers the shell's tool selector with its host (host embedding API
spec C-3, S-6): select activates a tool when the shell's capabilities
allow it and answers whether it did. Returns the withdrawal, which the
shell calls on dispose, as ShellSettleRegistrar's.
What attachToWall returns: the attached placement transform, the
point q on the face the symbol's back-centre lands on (the snap
marker's, D6), and the run it stands against.
