Table of Contents

Strip Charts

The strip charts visualise a windowed, downsampled view of the full mission timeline for physics / quality aspects that are computed per step across the whole NC program. They are rendered as min/max banded series over the ClStrip.GetDispBegin() .. AbsDispEnd window — except on the Color Index chart an ID key (ToolId, FileNo, and the two cutter zones of the stress ratio, StressCriticalZone and StressOnsetZone), which is drawn as IDs in the colours the 3D view paints them with, and a color tree's key, which is drawn as one lane per leaf in the same colours (see Layout). Operators use them to spot which segments of the mission are loading the spindle, degrading surface quality, or hitting thermal limits.

They are tabs of the Session Info panel on the Execution Page: Color Index, then Availability (only while physics options are on), then Surface Roughness. One tab is mounted at a time; the three share one ClStrip window and one selection. The anatomy covers the three, all sharing BaseStripChart.vue:

Chart Source Aspect Items
Availability Chart Availability Stress / max-spindle-torque / max-spindle-power / spindle-working-temperature / thermal-stress ratios (5 series), read in percent.
Surface Roughness Chart SurfaceRoughness Re-cut depth + program-side cusp + Δ tip deflection X / Y / Z in µm (5 series).
Color Index Time Chart Individual One series of a user-picked StepPropertyAccessDictionary key (≈90 keys).

The Surface Roughness chart plots the geometric and deflection contributions to the finished surface. It does not compute a roughness parameter such as Ra or Rz, and it has no series for the cusp left between neighbouring passes (Surface Roughness Values). Its re-cut depth is the axial distance the point on the tip plane at the cutter's largest radius, on the side the tip deflects to, moves under the step's maximum force. That point is the outer end of a flat end mill's bottom edge, so the re-cut depth is meaningful only for a flat end mill.

Key Model: MachiningProject via LocalProjectService.ClStrip + LocalProjectService.StepPropertyAccessDictionary.

Layout

One group bar drives all three charts. It is drawn on the open chart's tab, and that chart's own controls are teleported into the front of the bar. The chart is not a collapsible panel of its own.

  • Group Bar
    • Range chip — [{dispBegin}..{absDispEnd}] / {count}, tabular-nums, with Showing steps {begin}..{end} of {count} total as its tool-tip. With no steps it is an invisible stand-in, out of the layout flow, so the bar's height can be measured before the first play.
    • Cursor x readout — the hovered x value, shared by all three charts and reserving a fixed width so hovering never reflows the bar. It is the one place the hovered value is printed; the charts themselves carry no per-chart cursor row.
    • X-axis mode — IndexByTime (default) / IndexByStep, applied to every strip chart at once.
    • Fit View — fits the 3D canvas to the positions in the window that cut (ClStrip.GetFittingView: the box of the touched steps, or of every step when none touched), or to the home view without a strip. Disabled without a rendering connection id, and the only control here that acts on something other than the charts.
    • Stick disp-end to live end — on, the window's end follows the running end of the mission; off, it stays where it is. The toggle is on exactly when dispEnd === -1, one of the three states of dispEnd: -1 follows the strip's end (AbsDispEnd is the count); 0 … count − 1 is a concrete end short of the strip's end; the count itself is a concrete end pinned at the strip's end. A following window: a wheel, pan or rubber-band zoom whose new window still reaches the end keeps it (on the time axis the end shown when the gesture began: ShowTimeRange → ClStrip.UpdateDispSegmentByChartRange(caller, shownEndTime)), one stopping short writes a concrete end, and a concrete end short of the strip's end that a gesture brings back onto it follows again. The off click POSTs disp-range { dispBegin, dispEnd: absDispEnd, pinEnd: true }: during a play the count has usually grown past the end seen by the time it lands, and that end is a concrete one; while the play is paused or finished the count stands, and the end is pinned at it (ClStrip.SetDispEnd(int, object, bool); without pinEnd a value equal to the count reads as “follow” and changes nothing). While the count still equals the pinned end, a gesture that leaves the end there keeps the pin — on the step axis a setter's value at or past the end stays the count, on the time axis UpdateDispSegmentByChartRange(caller, shownEndTime) keeps the end while the range's max reaches the end shown, and a time-axis zoom-in onto the last position, which empties the segment, stays pinned under the 3D view's IsKeepingDispAlive — and one that moves the end back writes a concrete end. The strip's growth leaves a pinned end where it is (no AbsDispEndChanged; the client sees the count move through Updated), after which it is an ordinary concrete end. On and Reset send -1 and follow again, as does a run reset (ClStrip.Clear); an empty strip has no end to pin.
    • Reset display range — returns the window to the whole mission. The button's icon is the Material Symbols arrow_range path in stripIcons.ts (STRIP_RESET_RANGE_ICON), two arrows pointing left and right.
    • Reload all strip charts.
  • Each chart
    • Controls — no title row, since the tab names the chart; teleported to the front of the group bar: the aspect picker on the Color Index chart, a dropdown listing every StepPropertyAccessDictionary key with a GetQuantityFunc in two groups by group — Engineering view, the color trees, the built-in ones first and captioned Built-in (builtInTree), then Science view — each other row captioned with its unit (unitLabel: as Step Properties prints it, % for a ratio and for the breakage probability), sorted by each property's name in the interface language — PresentAttribute.Name in English, the step-field catalog's translation otherwise, where it has one — under that language's collation, and filtered by a type-to-search field over the name, short name, key and unit in either spelling (mm/min or mmdmin, % or ratio, never a unitless row's None) that ignores letter case, diacritics and character width and finds katakana by their hiragana (Typing and Searching), inside each group, an empty group left out and Enter picking the first row shown; the Y-axis range editor (Fit / Lock / Symmetric with a ± bound), which the Color Index chart drops while its key is an ID or a color tree's, ignoring any range stored for that key (see Body for an ID key) — for a percent unit (Availability's five ratios, a ratio or the breakage probability inspected, the unit read off the picker's list or the chart's items) its bounds are shown and typed in percent beside a % suffix and stored in the values' own units, a ratio's 0 to 1 as 0 to 100, and its button reads them as a tick prints them, [0%, 100%] or ±50%, a bound nearer to zero than 0.01 % as <0.01%; and, on the Color Index chart only, a Colors dropdown editing the colour guide's floor / ceiling / tone function, the floor and ceiling in the selected key's unit (rule.unitLabel, rule.scale): a ratio's in percent beside a % suffix, the rule keeping the ratio. That editor drives the 3D workpiece colouring and the colour-scale bar, not the chart's own line. For ToolId, FileNo and the two zone keys the guide has no range, and the dropdown reads This guide has no editable range.; for a color tree's key it lists the tree's leaves instead (see Body for a color tree).
    • Body — UplotChart.vue rendering one min/max band pair per item (two stroked series of the same colour plus a filled band at 15% opacity), with uPlot's own legend panel in a splitter pane beside the plot. The legend carries the swatches, labels and live values; its width is shared by all three charts, so dragging one divider moves them together. The x-axis name (xGutterName) is drawn at the lower left of the plot, on the same line as the tick labels — Time (s) or Step in English, not a row of its own. The x axis is 22 px and the plot has 8 px above it (STRIP_TOP_PADDING_PX), and above those the ID rows ticked, ID_ROW_PX (14 px, a line of AXIS_FONT) each: uPlot's top padding is 8 px plus the rows, so a row adds to the canvas' height that is not the plot and the plot keeps its height. A wheel over the legend pane scrolls the legend and does not POST; over the divider it does not POST, does not zoom the chart and does not scroll the legend.
    • Body for the ID rows — on every strip chart, whatever its items, a row of tool IDs and a row of file numbers over the plot, as the two boxes after Above the plots, in the Strip charts block of the Session Info panel's last tab, Panel Layout, tick them — Tool ID (data-testid="session-id-rows-tool", stripToolIdRow, on by default) and File No (session-id-rows-file, stripFileNoRow, off by default), one pair for all three charts, kept as device-local view preferences (Session State) and read as the default when the stored value is not a boolean; the group bar carries no control for them (Session Info Panel) (idRowKeys in BaseStripChart.vue: FileNo over ToolId, so the tool row keeps its place by the plot whether the file row shows or not). The rows' data is the answer's idRows, asked for with the chart's own request (idRows= the keys ticked) and so bucketed in the same walk as the items; ticking a row on fetches again at once (debounced), ticking it off only drops it, and a row ticked before the answer that carries it draws empty. A change of the rows' number rebuilds the chart, a change of their names or prefixes alone (a language switch) only redraws it. drawIdRows (UplotChart.vue, in the draw hook) paints them from the canvas' top down, ID_ROW_PX each, each row's edges rounded to device px on their own; nothing reaches the 8 px room above the plot, where the plot's top grid line (half above the edge) and a top tick's text stand:
      • Segments — bucket i covers (x[i−1], x[i]], its edges rounded to whole canvas px as an ID chart's tint reads them (categorySpans), so a tool's segment ends where the Tool ID chart's tint of it ends; buckets side by side of one ID (lowest and highest alike) and one run number make one segment (idRowSegments). A bucket without a value leaves a gap. A bucket whose lowest and highest differ holds a change of ID: a divider in #9e9e9e, at least one device px wide, that belongs to no run, the run after it starting past it.
      • Greys — #e0e0e0 and #f2f2f2 (ID_ROW_SHADES) by the parity of the segment's run number, which the server counts over the window's steps from its first (REST below), not of the segment's place among those drawn: the greys hold still while the buckets' edges move under a growing strip. Two segments side by side that are different runs of one parity — a run between them in no bucket of its own — are parted by a 1 px divider at the later one's left edge (parted). Not the IDs' colours: those are the ID chart's and the 3D view's.
      • Text — labelPrefix + ID (T13; a file number bare) centred in #212121, in AXIS_FONT scaled to the pixel ratio, where its width plus ID_ROW_TEXT_PAD_PX (3 px) on each side fits the segment, else none. The row's name, charts.idRows.toolIdName / fileNoName, stands in the y gutter in #616161, cut to the gutter as a lane's name is (fitCategoryLabel). While the x scale has no range the rows draw their names alone.
      • The root's data-id-rows mirrors the rows as last drawn, for acceptance scripts: JSON, per row { key, name, top, bottom, segments } in canvas px, each segment { x0, x1, id, run, shade, label, parted } (id null and shade −1 for a divider); empty while no row is drawn. The empty-state overlay stands under the rows.
    • Body for a percent unit — Availability's five ratios, or a ratio or the breakage probability on the Color Index chart (an item whose unit is %, its values multiplied by its scale, 100 for a ratio, before they print): every value prints as every percent HiNC shows (percentText in wwwroot-src/src/utils/stripFormat.ts: two decimals and the sign, 82.35%; exactly zero 0%; above zero but under 0.01 % <0.01%, >-0.01% below zero), a min ~ max whose two ends print alike once; the legend label adds no (%), the sign riding on every value, and the Y axis carries no title. The ticks are in percent with as many decimals as the step between them needs, two at most (0%, 25%, 0.5%, 0.01%: percentAxisText), and the step is never under 0.01 % (yMinTickStep, 0.0001 of a ratio), so an auto-fit range narrower than one step widens to the step's multiples around it: a breakage probability far under 0.01 % draws on the floor of a 0% to 0.01% axis, with no exponent ticks and no row of <0.01%. Availability ticks in percent from the first frame, before an answer has brought its unit. A magnitude of any other unit prints by formatGeneral — a whole number from 10 000 up (11518), two decimals from 1, three under 1 and an exponent under 0.01 (3.78e-4) —, the unit after its label in brackets.
    • Body for an ID key — the Color Index chart inspecting a key whose isCategorical is set (IsCategorical(API): ToolId, FileNo, StressCriticalZone and StressOnsetZone; a color tree's key is categorical too, but its item carries a colorTree and is drawn in lanes, see Body for a color tree) draws IDs instead of a min/max band: two grey (#616161) stepped series with no fill, where bucket i holds over (x[i−1], x[i]] because x[i] is where bucket i ends; a 6 px ID band of each bucket's colour along the bottom of the plot; a Y scale over the IDs present, from the lowest less half an ID and a margin that keeps its line clear of the ID band, to the highest plus half, with ticks on the IDs only, at least 16 px apart and labelled labelPrefix + ID (T16; the file number bare), or with the ID's name where the item's valueLabels names it (a zone: Flute), cut to the axis' room as a lane's name is (fitCategoryLabel); a 25 % tint of each bucket's ID colour under the grid and the lines; and an 8 px swatch beside each tick, the ID band and the swatches outlined 1 px #616161. The colours are the answer's idColors. A bucket keeps only its lowest and highest ID, so one spanning IDs paints the upper half of its tint and band in the highest and the lower half in the lowest; an ID between them shows only after a zoom. A step without an ID is a gap, drawn in no colour, and hiding the series in the legend hides the colours too. The legend reads T3, or T1 ~ T3 for a bucket spanning IDs, and a named ID by its name (Flute ~ Cylinder). Pointing at a Y-axis label or at the swatch beside it shows that ID's full name, including a label the axis left out. The Y axis keeps the width all three charts share, so the plot areas stay aligned. While one ID key is inspected no poll rebuilds the chart — a new ID only rescales it, new colours only repaint it — and picking another key, another ID key included, rebuilds it. The header follows the picked key's isCategorical at once; the chart starts drawing IDs once an ID key's own data has arrived, and stops as soon as another key is picked, showing the previous values as an ordinary banded line until the new key's data arrives.
    • Body for a color tree — drawn whenever the answer's item carries a colorTree, which the server sends for a tree's key alone (the project's tree, a script's or HiNC's built-in); the mode rides on that field, never on isCategorical. It keeps the ID chart's frame:
      • Lanes — the y scale holds every lane 0 … n − 1, the tree's first leaf the highest, a lane no step of the window fell into included, so nothing rescales during a play. A value leaf's legend row is hidden while the answer carries no value of it in the window; the lane stays. Of each bucket's lowest and highest lane (min, max), the lowest holds no value and draws nothing (paths: () => null: no line, no cursor point) and the highest is the lane bar, series 2, a 'laneBars' series that draws no path of its own (its paths builder returns null; drawLaneBars fills it, under Grid below): for each lane, over each run of pixel columns whose set holds that lane (Pixel columns, below), a translucent grey block filling that lane's cell — so a column bars the lane its most important leaf takes and the lane of each leaf that holds at once on that leaf's steps, all in the one grey, the tint and the 6 px band saying which is the most important —, and nothing from one cell to the next, which would cross the lanes between as if their leaves held steps there (the owner, 2026-11-15: no vertical lines on Machining State, and a translucent grey bar as thick as a lane, so that a stretch reads as held by its leaf's state). Its fill and stroke are rgba(97,97,97,0.35), the ID lines' grey #616161 (CATEGORY_LINE) at LANE_BAR_ALPHA 0.35, dark enough to stand out on every lane's tint and light enough that the 25 % tint under it still reads as its leaf's colour; the stroke draws no line and is there for uPlot's legend marker, a border in the stroke around the fill, so that the tree's row shows a swatch of the bar's grey (the series' width, 1.25, keeps the marker on that stroke: uPlot takes the points' for a series of width 0), and its points' stroke, #616161, keeps the cursor point the grey it was. The tint, the 6 px band and the swatches are painted from idColors alone, keyed by lane, and hiding the tree's row in the legend hides them with the bar; the pointer on another row of the legend dims the bar with the other series.
      • Grid — a lane is a cell of the y grid. The y axis' own grid, which uPlot draws through the ticks and so through the lanes' centres, is off on a tree's chart (grid: { show: false }), and drawLaneBorders draws a line on every border lane ± 0.5: n + 1 lines for n lanes, the highest lane's upper border on the plot's top edge (the y scale's maximum, n − 0.5), the lowest lane's lower border half a lane above the plot's bottom. It runs in the drawClear hook after the tint and the lane bars, so the lines lie over the tint and the bars, each cell's edges in sight, and under the x grid and the value bands, and it draws as uPlot draws an axis' grid (drawOrthoLines): the y axis' grid stroke, width, dash and cap, uPlot's defaults (rgba(0,0,0,0.07), 2 CSS px), each line at its value's canvas px rounded (valToPos), the context shifted by half a device px for an odd width. The lane bar then fills its cells: drawLaneBars, which runs in that hook right after drawCategoryTint and before drawLaneBorders (so before uPlot draws the axes' grid and the series), fills, lane by lane (barsOf), each run of columns whose set holds the lane with one fillRect over the rows [round(valToPos(lane + 0.5)), round(valToPos(lane − 0.5))), the rounding drawLaneBorders uses, so that at a device pixel ratio of 1 or more the grid lines lie over the block's first and last rows, and two lanes' blocks in one column meet on the line between their cells, sharing no row; it fills at the series' alpha (a legend hover's focus), draws nothing while the series is hidden in the legend; the lowest lane's bar ends at its lower border, half a lane above the plot's bottom, clear of the 6 px band while half a lane is 6 px or more, as on a tree of up to eighteen lanes at the least height (Height, below); the band, drawn later in draw, lies over whatever of a bar reaches it. A value band reaches no further than lane ± 0.3 (VALUE_BAND_HALF), 0.2 of a lane short of each border: the band's 1.25 px edge lines share no pixel row with the 2 px grid lines on a tree of up to fourteen lanes, whose lanes are at least 16 px; from fifteen lanes on at the least height (a lane of 14.97 px, then 14.06 px) the lower edge's line lies a quarter of a row onto the grid line under it on some lanes at a 100 % browser zoom, and at 110 % and more it is clear down to a lane of 13.64 px. Every lane has its two borders, a lane whose tick categorySplits leaves out included (Height, below). The ticks, their names and the swatches are on the lanes' centres, the whole numbers. An ID chart keeps uPlot's grid through its ticks.
      • Names on the axis — a lane's tick reads the leaf's shortName, or its name when that is empty (an unnamed leaf's id), cut with … to 61 px in the axis font at grapheme boundaries of its NFC form (fitCategoryLabel), inside the gutter every strip chart already has, so the three plots keep one left edge. Pointing at the gutter or at the swatch column (CATEGORY_SWATCH_ZONE_PX, 12 px) shows the nearest tick's full name — within half a lane-pitch and at least 8 px — on data-testid="strip-lane-name". A lane of undecidedLanes prints ? after its name, the name cut to fit with it, never the mark (fitCategoryLabel(name, mark)), and its tooltip adds charts.lanes.undecided under the name (data-testid="strip-lane-undecided"): some of its bars or its band may be missing. The legend and Colors keep the full name.
      • Pixel columns — categoriesAreLanes has UplotChart show the lanes one canvas pixel column at a time (laneColumns): column k covers canvas px [⌊bbox.left⌋ + k, ⌊bbox.left⌋ + k + 1), and of the buckets that cover any part of it — bucket i covering (x[i − 1], x[i]] as a staircase reads it, bucket 0 none — it shows one in the highest lane (max), the first of them on a tie. The tree's first leaf is the highest lane and the most important, so where the steps of several leaves share a column the column shows the most important alone (the owner, 2026-11-15), and a bucket narrower than a pixel still shows where it is the most important of its column. The column's 25 % tint fills the plot's height in its lane's colour, and its piece of the 6 px band takes that colour in both halves; a column that no bucket with a leaf covers has neither. A column's set (setOf), the lanes it bars, is the union of holdingLanes over every bucket overlapping it in its highest lane (maxBucketsOf, not only the one the pointer reads) — that leaf and the leaves that hold at once on its steps, never another leaf's steps that merely share the column — and barsOf[lane] marks the columns whose set holds lane. UplotChart takes the item's holdingLanes as its laneHoldings prop, read at draw time and memoised with the columns, not part of the structure signature, so a poll rebuilds nothing; executionCharts.ts (parseHoldingLanes) accepts it only as one strictly descending list of the tree's lanes a bucket, its first the bucket's max and [] where max is null, and anything else, or a list not aligned with the buckets, reads each bucket as its max alone: one bar a column.
      • Value bands — a leaf in leafValues draws two stepped edges in its lane at lane − 0.3 + 0.6 (v − lo) / (hi − lo), lo / hi the least and greatest finite value of the leaf's minima and maxima in the window (finiteRangeOf), clamped to ±0.3 (VALUE_BAND_HALF; why 0.3, under Grid above): hi = lo draws the lane itself (its centre), ±Infinity sits on the band's limit, lane ± 0.3, and a bucket without a value is a gap — leafValues gives a bucket the leaf's values over the steps of the bucket's max leaf on which it holds, so a finite value already means the lane is in the bucket's holdingLanes; both edges, and the fill between them, are drawn only on the pixel columns whose set holds the leaf's lane (drawnOnLane, the leaf's own lane, on the series; laneClippedSteppedPaths reads barsOf: the staircase's clip is replaced by the runs of those columns, taken back by drawPath's pxAlign shift, less its own gaps), whether the lane bar series is shown or not — clicking the tree's row off hides the bars, not the bands; lo and hi stay the whole window's, every bucket's values. The clip is by whole pixel columns: inside a column whose set holds the lane, the band may also draw a sub-pixel part of a bucket in a lower lane on whose max steps the leaf holds, which the legend, reading the column's buckets in its highest lane, leaves out. Edges in the lane's colour at width 1.25, the fill at 15 %, the series keyed by leaf id. A leaf with sameStepsAs (Step Colors REST) holds wherever the leaf it names holds, so its bar and its band stand beside that leaf's; it takes no step, so no column shows its lane as its highest.
      • Legend — read through the pixel column under the cursor (UplotChart's laneColumnAtX, the column's set and its buckets in its highest lane), so it names what the bars there show, and is written again when the cursor changes column on one data index. The tree's row lists the column's set, highest lane first, by the lanes' short names (laneLabels) joined by /, a leaf with sameStepsAs left out where the leaf it names is listed (its bar is still drawn), — for an empty set, and the value cell's title gives the full names (KeyedSeries.valueTitle, set from the setLegend hook); a value leaf's row, <leaf> · <value name> and (<unit>) when it has one other than %, reads the least of the minima and the greatest of the maxima over the column's buckets in its highest lane whose holdingLanes hold the leaf's lane, — where the set does not hold it, off the plot the least and the greatest value over every bucket of the window, an overload (±∞) among them (valueRangeOf; the band's lo / hi above take the finite values alone) — the values the answer carries, each bucket's over its max leaf's steps, so a leaf whose steps are all outranked in their buckets has none there though Colors counts its steps; — when it carries none —, in the leaf's unit — a ratio's or the breakage probability's values as every percent prints (valueScale: 123.45%, <0.01%), a whole number the leaf's valueLabels names — a cutter zone's — as that name (Flute, Flute ~ Cylinder), one value when the two ends print alike. A value leaf's row is listed only while the answer carries a value of it in some bucket of the window (legendIdleKeys hides it by class and does not rebuild the legend). The tree's own row stays.
      • Pointer — the bucket the cursor, the legend, a hover and a click read is a staircase's, the first ending at or after the pointer, unless the pixel column under the pointer shows a more important leaf; then it is the bucket that column shows (laneBucketAt, from uPlot's cursor.dataIdx and from bucketAtX, which BaseStripChart's bucketAtClientX asks; the column read the cursor's way, valToPos of the x value the pointer stands for, and the plot's last CSS px, which uPlot reads at the right edge, read as the last column, and its first CSS px, which uPlot reads at bucket 0 — a bucket covering no column —, as the first column's bucket), so the legend's index is the bucket whose leaf the column is drawn in, and a hover or a click sends that bucket's leafStepIndex. An echo's cursor (setHoverIdx, cursorLeftAt) stands three quarters into the step's bucket as on any staircase; where the column there shows a more important leaf, it moves inside the bucket to the first column that shows the bucket's own lane (found through posToVal / valToPos, the cursor's own path, not CSS px times the pixel ratio, which drifts from uPlot's plot width by up to a column at 125 %), and a bucket with no such column keeps the place, the cursor then reading the bucket that column shows.
      • Height — the y scale runs from one lane under the lowest lane, the room for the 6 px band and the swatch, to half a lane over the highest, and the canvas is at least min(262, max(93, 16 × (n + 0.5) + 30)) px (categoryMinCanvasPx: 93 for 3 lanes, 214 for 11, 262 from 14 on, the ticks thinning again from 15 on) plus ID_ROW_PX (14 px) for each ID row shown, as every strip chart's least canvas is its 93 px plus the rows (chartMinPx; without the rows plotMinCanvasPx), the rows standing over the plot and leaving it its height. Bottom-up, a tick is kept when it stands at least CATEGORY_TICK_GAP_PX (16 px) over the last one kept, less CATEGORY_TICK_GAP_TOLERANCE_PX (0.5 px; categorySplits, which thins an ID chart's ticks the same way): the plot's height is read back from uPlot's bbox, rounded to half device pixels, so a lane of 16 px can read 15.99 px — fourteen lanes at a 110 % browser zoom (a device pixel ratio of 1.1) with the group bar on two lines — and would lose every other tick without it; under the cap, 15 lanes (14.97 px a lane) and 16 (14.06 px) still thin out. The panel's floor is the same on every tab: the tallest chart tab's group bar and least card, the Color Index chart's card raised by its lanes (colorIndexCardPx, which holds no row), and 14 px for each ID row ticked, added to every tab's card by the page (idRowsPx in ExecutionPage.vue), so a row ticked on any tab moves the floor at once: under a group bar of one line, 188 px with the Tool ID row the default leaves on (174 px with no row), and 357 px for a tree of 14 lanes (343 px with no row). ExecutionPage.vue takes the bar's row count at the panel's width (stripGroupBarLayout.ts): the bar says what it is made of, and the page lays the rows out, so a bar that wraps in a narrow column raises the floor by those rows.
      • No rebuild per poll — the series, bands, lanes, tick formatter and least height come from one spec held as a string; a colour change rebuilds once.
      • The Colors dropdown — while the selected guide is a tree's (the colour guide's tree): Color tree: {name} (the key without a name), In the display range and the leaves in tree order — the leaf's own colour, its name or id, its steps and its share of the drawn time from the chart's latest leafTotals by leaf id, printed as every percent is (12.35%, 0%, <0.01%), — while that answer is pending or another tree's (a leaf with sameStepsAs stays out of the drawn time; its row counts the steps of the leaf it names that hold its value, the two rows reading the same when all of them do, and it reads —, not 0, while the leaf it names has steps and none holds its value) — the answer of a tree standing in for the guide's (colorTree.standsInFor, the no-physics built-in tree for MachiningState) counting by the ids the two share, 0 for a leaf the stand-in lacks — then a No value row when steps fell into no leaf, and Edit color tree → (?tree= the editTreeId, through the host's dirty-switch gate); for a built-in tree (origin builtIn) its notes under In the display range — the chart's latest colorTree.notes while it draws that tree, else the guide's, the color guide read again as the dropdown opens over a stand-in — and Built-in, read-only with Copy to project tree…; for a script's tree, Registered at run, read-only. It sends no request but the copy's and that read.
    • Empty-state overlay — in order: “No project loaded”; “Pick a property to inspect” (Color Index with no key chosen); “Not ready — reading the values of this property” while the strip has positions and the Color Index answer is pending (the host is still filling the inspecting slots for the picked key, or the key is not yet the project's); “No mission data” when the fetch returned none; then, when every item's min / max arrays are all NaN, “No mapped measurement data for this property” if the Color Index chart inspects a by-mapping property — one whose values are measurements paired onto the steps, so the gap is in the measured data — and “No physics data” otherwise, which is what Availability looks like without a physics licence. A color tree's chart shows neither: a window no step of which fell into a leaf is a result, drawn as its empty lanes.

Behavior

A gesture on one chart writes the shared ClStrip window, so the wheel, a pan, a rubber-band zoom, a click and the right-click segment menu move all three charts together, and a chart fetches only that window, one request at a time. How each gesture is sent, and how a fetch stays single-flight, is Strip Charts Behavior.

Source Code Path

The chart components, the REST routes that feed them and the step fields they read are Strip Charts Source Code.

See Also

  • Color Trees — the tree a color-index key draws as one lane per leaf
  • Strip Charts Behavior — the shared window, the pointer gestures and the single-flight fetch
  • Strip Charts Source Code — the components, the routes and the step fields
  • Execution Page — the page whose Session Info panel hosts these charts as tabs
  • Session Info Panel — the panel that holds these charts as its first tabs, with the tools' breakage probability table and the run's message lists after them
  • Color Guide System — the colour guides behind the Colors dropdown, among them the one-colour-per-ID guide whose colours an ID chart and a color tree's lanes repeat
  • Step Colors Branch — the color trees' editor, which Edit color tree → opens and whose Set as color index the Color Index chart follows
  • Step Colors REST — the fields of a tree's colorTree, the built-in trees and their notes
  • Cycle-Line Charts — per-selected-step charts that share the same uplot engine
  • Execution Extended RenderingCanvas Tool Bar — the tool-path display Fit View on Session Info's chart tabs acts on
  • Watching the Run — the task Session Info's chart tabs serve, with the pointer contract read as a procedure
  • Selecting a Machining Segment — the right-click menu and POST select-feature-segment read as a task: what each rule takes in and what the charts and the canvas show then