.paleda-btn {
    background-color: var(--paleda-color-primary, #B3BB7F)!important;
    color: white!important;
}

/*
    Import preview rows (Snabborder "Läs in order från fil", Final_countdown Blad117, #1904).
    QuickOrderImportPreviewListViewController gives a DxGrid data row one of these classes through
    DxGridModel.CustomizeElement (GridElementType.DataRow, the documented row hook). The colours are the theme's
    status tokens (scss/_paleda.scanner.scss), so red, grey and green mean the same here as in the scanner views.
    Text stays black on every state (P9). Never yellow: yellow is "the next row" in every work list (P15).
*/
.paleda-import-row--problem > td {
    background-color: var(--paleda-scanner-status-error-bg);
    color: #000;
}

.paleda-import-row--superseded > td {
    background-color: var(--paleda-scanner-status-neutral-bg);
    color: #000;
}

.paleda-import-row--added > td {
    background-color: var(--paleda-scanner-status-success-bg);
    color: #000;
}

.input-group {
    display: flex;
}

.flex-grow-1 {
    flex-grow: 1;
}

.input-group-icon {
    display: flex;
    align-items: center;
    padding-left: 5px;
    margin-left: 2rem;
}
.updated-row {
    background-color: var(--bs-primary);
}
.paleda-background {
    background-color: var(--paleda-color-primary, #B3BB7F);
    color: white;
    opacity:0.8;
}

.xaf-inline-visibility-checkbox {
    display: flex;
    align-items: center;
    justify-content: center;
    width: 100%;
    height: 100%;
}

.xaf-inline-visibility-checkbox .dxbl-checkbox {
    margin: 0 auto;
}

/*
    Keep the horizontal grid scrollbar from covering the last visible row.
    DevExpress renders the bar as an overlay, so we reserve extra space
    inside the scrollable content area and keep the bar at a stable height.

    The height of the bar (0.35rem idle, 0.5rem under the pointer: Peter, Blad47, "the side scrollbar must be easy to grab") is not set here any more.
    It was an override of DevExpress's internal --dxbl-scroll-viewer-hor-scroll-bar-height and -hover-height, which dxdocs (Blazor 405705, 401740) calls
    internal and "may change between versions". The Paleda theme sets it through DevExpress's Sass variables $dx-scroll-viewer-scroll-bar-size and
    $dx-scroll-viewer-scroll-bar-hover-size (src/Presentation/paleda.se.Theming/scss/paleda.theme.scss and paleda.theme.clear.scss, #1830), and
    GridScrollBarSizeIsAThemeSettingTests fails if a stylesheet of ours names the internal variables again or a DevExpress upgrade renames them.

    The reserved space is skipped by a grid that has a footer (#1804): DevExpress draws the bar directly above a sticky footer (it hands the
    scroll viewer the footer's height as the bottom offset), and the padding moved the footer 0.9rem up, over the bar. Inköpsordrar shows "Antal"
    in a footer under Ordernummer, because virtual scrolling takes the pager, and with it the row count, away. Measured in Edge at 1366x650
    against a copy of Paleda's data, 2026-11-04:
        with the padding     footer 597-626 px, bar 606-611 px (under the footer), a drag on the bar: scrollLeft 0 -> 0
        without the padding  footer 611-640 px (the grid's edge), bar 606-611 px (above it), a drag on the bar: scrollLeft 0 -> 437

    Hand-rolled, and it names DevExpress's internal classes, so re-check it on a DevExpress upgrade (devexpress-blazor-css-api). No API places the bar
    or the footer: DxGrid.FooterDisplayMode only shows or hides the footer, DxGridModel.CssClass reaches the root element only, and the CSS API pages
    (Blazor 401740, 405705) call the .dxbl-* classes internal. Source: DxGridBase.razor:106-107 (the grid's own footer selector,
    `:scope > .dxbl-grid-table > tfoot`, which this rule mirrors), Scripts/scroll-viewer/dx-scroll-viewer.ts:388,467 and scroll-controller.ts:74-76,117
    (the bottom offset of the bar), Grid/Rendering/GridMainTable.razor:40-43 (the tfoot is rendered only while the footer row is visible).
    :has() follows the DOM, so a list whose user shows or hides the footer from the column menu is right either way and no list has to opt in
    (MDN BCD css.selectors.has: Chrome and Edge 105, Chrome Android 105, Samsung Internet 20.0, Safari 15.4, Firefox 121).
*/
.dxbl-grid .dxbl-scroll-viewer > .dxbl-scroll-viewer-content {
    scrollbar-gutter: stable both-edges;
}

.dxbl-grid .dxbl-scroll-viewer > .dxbl-scroll-viewer-content:not(:has(> .dxbl-grid-table > tfoot)) {
    padding-bottom: 0.9rem;
}

/*
    The page is as tall as the window while XAF has the application hidden behind the splash screen (#1826, found on paledatest 2026-11-04:
    F5 or a deep link on a list that scrolls virtually, "Application Error").

    XAF renders `<app class="d-none">` (Pages/_Host.cshtml) and styles it `app.d-none { display: block !important; opacity: 0 !important }`
    (DevExpress.ExpressApp.Blazor Styles/styles.css:29) until loadingPanelObserver.ts finds text in it and takes `d-none` off. While it is
    there, `<app>` is a block whose height is `auto`, so `.app { height: 100% }` (Styles/layout/template.css:5) has no height to be a percentage
    of and computes to `auto` (MDN `height`, Percentages: "If the height of the containing block is not specified explicitly ... the value
    computes to auto"): the whole layout is as tall as its content. Afterwards `<app>` is an inline element, `.app` is the height of the body and
    every container below it is bounded. A grid that scrolls virtually is built in the first phase. Its viewer takes its viewport from the size
    of its container, which is the height of all its rows (22 303 articles x 20 px = 446 000 px measured), so the first viewport asks for
    22 303 rows and DxVirtualScrollViewer throws UnableToRequestItemsException at 788 (VirtualScrollEngine.UpdateViewportCore against
    DxVirtualScrollViewerSettings.MaximumItemCountPerRequest, DevExpress.Blazor ScrollViewer/Virtual/Internal/Engine.cs:416 and
    VirtualScrollViewerUtils.cs:42). A menu click is not hit because the application is already visible then. The start page is: Inköpsordrar
    and Ordrar are the lists the users land on, and one of them rendered 753 rows of 788 on a cold load.

    The documented rule for a grid that scrolls virtually is "define a CSS constraint for the Grid height. Without it, the Grid automatically adjusts
    its height ... to fit all rows" (dxdocs, Scrolling in Blazor Grid, Blazor 404753; the same sentence in Get Started, 403625). A fixed cap on the
    grid (`max-height: 100vh`) was measured and rejected: it replaces XAF's `max-height: 100%`, and once the application is visible the grid is
    taller than its container (1080 against 919 px, the list scrolls inside the page). The one rule that gives the first phase the layout of the
    second is a height for the hidden `<app>`: the same bounded layout, and nothing is cut, because `app.d-none` is invisible (opacity 0).
    Measured in Edge at 1920x1080 against a copy of Paleda's data (Produkt, 22 303 rows, virtual scrolling): without this rule the grid is
    448 095 px tall on a cold load, 20 rows are requested, the first viewport asks for the rest and the page errors out; with it the grid is 919 px, 31 rows.
    Why DevExpress's own cap does not save it: the theme caps a virtual grid at `$dx-grid-max-height: 10000px`, but XAF's
    `.main-content > .grid-content dxbl-grid { max-height: 100% }` (XAF Styles/layout/master-detail.css:136-141) replaces it, and 100% of an
    auto-height parent is no limit (MDN, height: a percentage of a containing block without an explicit height computes to auto).
    Hand-rolled: no XAF or DxGrid setting reaches the splash phase (`_Host.cshtml` is the template's own markup; the rule is on XAF's own
    element and class, not on a dxbl-* element). Re-check it on a DevExpress upgrade; VirtualScrollingOptInMergedModelTests holds the rule.
*/
app.d-none {
    height: 100%;
}

/*
    A nested list view inside a detail view, put back on the same footing as a root list view.

    XAF sizes the grid of a root list view to its scrolling area — `.app .main-content > .grid-content`
    gets `height: 100%` and the grid `max-height: 100%` — so both of its scrollbars are always at the
    edge of the screen. A nested list view only gets `overflow-x: auto` on the same wrapper, no height,
    and DxGrid then does what DevExpress documents: "the Grid automatically adjusts its height (up to a
    maximum of 10,000 pixels) to fit all rows".

    Measured in Edge at 1600x900 against Paleda's own data on 2026-09-25, Inköpsförslag for supplier 5000
    with 1 472 generated rows and 200 on the page:
      before  grid 10 000 px, detail view scroll range 9 771 px, horizontal scrollbar at y=10 601, never
              on screen — Peter, Blad47: "sidoscrollen kan inte bara vara längst ner för det går inte att
              sidoscrolla om man är högst upp på sidan"
      first   grid capped at `calc(100vh - 9rem)` (756-806 px depending on viewport), scroll range still
              527 px: a flat viewport-minus-a-constant formula only bounds the grid itself, and this view
              has the supplier/criteria fields and the Anmärkning box above the grid, which the constant
              does not know about — at 1500x950 the horizontal scrollbar still sat at y=1407, below the
              viewport, until the page itself was scrolled 527 px first. Measured again 2026-09-26 against
              697c158: "sidoscrollen kan inte bara vara längst ner för det går inte att sidoscrolla om man
              är högst upp på sidan" still held.
              The Inköpsorder detail view he compares with is not actually bounded either — it only looks
              right because that order has one line and its grid measures 307 px, under the cap.

    The fix generalises `.app .main-content > .grid-content`'s own idea instead of guessing a second flat
    constant: the DetailView's root layout group is bounded to the viewport and turned into a column flex
    box (`paleda-detailview-fills-view`, on `Main`), its fixed-height children (the editors, Anmärkning)
    keep their natural height, and the row that holds the grid (`paleda-detailview-fills-view__grid-row`,
    on `Lines_Group`) is stretched to whatever is left — so the grid always ends where the *viewport*
    ends, whatever the header above it measures, on this view or the next one that opts in the same way.
    9rem is the same application chrome already subtracted above `.main-content` — ribbon, view tabs and
    padding, 137 px measured. A view opts in through `CustomCSSClassName` in Model.xafml: the outer class
    on the DetailView's root `LayoutGroup`, the inner one on the `LayoutGroup` that holds the grid.

    Round 2 (granskning of the first attempt above, 2026-09-27): `CustomCSSClassName` lands on
    `<dxbl-form-layout-group>` (`LayoutComponent.razor` -> `DxFormLayoutGroup.CssClass`), but that element's
    *only* DOM child is DevExpress's own `.dxbl-row` (`DxFormLayoutGroup.razor.cs GetGroupContainerCssClass`,
    a Bootstrap-style flex-wrap row) — never the LayoutGroup children directly. So `.paleda-detailview-
    fills-view > *` only ever matched that one `.dxbl-row`, not `SimpleEditors`/`Anmärkning`/`Lines_Group`,
    and `flex: 1 1 auto` on `.paleda-detailview-fills-view__grid-row` grew the row's *width* inside a
    flex-wrap row, never its height. Modelled with the real theme CSS in headless msedge
    (`scratchpad/rev-b47/`): the grid measured 12 000 px unbounded on the branch at both 1500x950 and
    1280x800, `Main` clipped at 806/656 px by `overflow: hidden`, and the page's scroll range was 0 — the
    horizontal scrollbar was not reachable at all, worse than round 1.
    The fix below turns that `.dxbl-row` itself into the column flex container. A second trap on the way:
    `Lines_Group`/the grid `LayoutItem` also carry DevExpress's own `.dxbl-col`/`.dxbl-col-md-12`
    (`flex: 0 0 auto`, same one-class specificity as a bare `.paleda-detailview-fills-view__grid-row`
    selector), and a `.dxbl-row > *` catch-all is *two* classes deep (`.dxbl-row` plus the outer class) and
    so silently outranks a bare one-class rule too — measured: without the `> .dxbl-row > .grid-row-class`
    scoping below, `flex-grow`/`flex-shrink` stayed computed `0`/`0` on the grid row even with the intended
    declaration present in this file. Re-measured on the same model after this fix: grid 454/304 px (well
    under the viewport) and the scrollbar inside the viewport at both sizes.
    `PurchaseProposalGridHeightTests` (paleda.se.Blazor.Server.Tests) is the structural guard that this
    exact selector shape stays in this file; `docs/assets/detail_views/purchase-proposal-wizard/
    blad47-rutnat-innanfor-fonstret-*.png` is the real Admin msedge measurement, taken by
    `PurchaseProposal_Supplier5000_GridScrollbarStaysInsideViewportAtPageTop`
    (paleda.se.E2E.Playwright) against the live Inköpsförslag wizard rather than a hand-built model of
    this file. The round-by-round history of the CSS decisions below is kept inline, in this file, because
    each round changed a selector or a property here; the E2E test's own XML doc-comment and PR #1434 carry
    the matching history of what was measured in the DOM and in the test itself, which is a different record
    from this one.
*/
/*
    Round 2 granskning (2026-09-27): `overflow: hidden` here clipped, with nothing left reachable, whenever the
    fixed-height children above the grid (the editors, Anmärkning) plus the grid's own `min-height: 0` still
    added up to more than `calc(100vh - 9rem)` — a short viewport, a higher browser zoom, or a narrow width
    where the form layout stacks. `overflow-y: auto` is the safe fallback: the common case (everything fits)
    still shows no scrollbar and the grid fills through flex exactly as before, and the rare case scrolls the
    whole view instead of silently hiding content, which is what the page did before this feature existed.
*/
.paleda-detailview-fills-view {
    display: flex;
    flex-direction: column;
    height: calc(100vh - 9rem);
    max-height: calc(100vh - 9rem);
    overflow-y: auto;
}

.paleda-detailview-fills-view > .dxbl-row {
    display: flex;
    flex-direction: column;
    flex-wrap: nowrap;
    height: 100%;
    min-height: 0;
}

.paleda-detailview-fills-view > .dxbl-row > * {
    flex: 0 0 auto;
}

/*
    Scoped to the parent `.dxbl-row` (not just the class alone): the grid row's own element also carries
    DevExpress's `.dxbl-col`/`.dxbl-col-md-12` (`flex: 0 0 auto`, `flex-shrink: 0`), the same one-class
    specificity as a bare `.paleda-detailview-fills-view__grid-row` rule, and the catch-all rule above is
    two classes deep too. A bare class selector here loses that tie to whichever framework or catch-all
    rule happens to win it, which is what made the first round's fix a no-op.
*/
/*
    Peter 2026-09-28 (B120/B121): the 50vh half of round 8's floor only existed to clear the 1280x800
    assertion round 5 added for a tablet target he never asked for. With the header restored above the
    grid (Model.xafml, Lines_Group Index="2"), 50vh at 1500x950 pushed the total past the viewport again
    and the horizontal bar was back below the fold. Inköpsförslag is a desktop view; 20rem alone still
    keeps the grid legible without re-introducing that regression.

    Round 11 (real-window measurement, 2026-09-29): round 10 was only ever measured at 1500x950 and
    1920x1080, both taller than the *innerHeight* a real windowed browser actually gives — 1920x865,
    1600x900 and 1366x650 (the usable area under the OS taskbar and the browser's own chrome; PR #1476,
    deployed 3de6dea). The header above this row (SimpleEditors + Anmärkning) measures a near-constant
    ~595px regardless of viewport height (it stacks vertically, so only *width* changes its wrapping), so
    at 1920x865 the 20rem floor pushed the grid row's own scroll viewer to bottom 873px against an
    innerHeight of 865 — the exact defect this feature exists to prevent, on the tall side of a floor that
    is bigger than the room actually left once, only shifted from "1280x800" to "any window shorter than
    roughly 915px". flex: 1 1 auto already gives this row *exactly* the space Main has left once the fixed
    -height header above it is measured (`min-height` only matters when that remainder is SMALLER than the
    floor) — so a floor of 20rem was never "the grid's normal height", only a hard lower bound that firmly
    became binding, and therefore forced Main to overflow, at every window shorter than header+20rem.
    Lowering the floor to 4rem — enough to keep the grid's own column-header row (and a sliver of the first
    data row) from disappearing entirely, never a claim that 4rem is a usable grid — stops the floor itself
    from being what pushes the total past the window at these three real sizes; Model.xafml's
    `RowCount="2"` on Anmärkningar (Remarks) trims the header's own height at the same time, so the row
    that is actually left is bigger than 4rem long before the floor would ever bind again on a realistic
    desktop window.

    Round 12 (skeptic granskning of round 11, 2026-09-29): "bigger than 4rem" was not the same claim as
    "shows real data rows" — round 11's own screenshot at 1366x650 measured a scroll viewer that fit inside
    the window while showing zero rows, only the grid's own toolbar and a clipped column-header strip
    directly above the pager. The ~595px header this comment measures above was still 2 columns of 6 rows
    (`SimpleEditors` > `PurchaseProposalWizard` > `_col1`/`_col2`, `Model.xafml`), a fixed content height
    independent of viewport height. That group is now 4 columns of 3 rows — the same `LayoutGroup`/
    `LayoutItem` model, nothing collapsed or hidden, roughly half the height — so this floor has real room
    above it before it ever needs to bind, at every size `GridScrollbarStaysInsideRealisticWindowSizes`
    measures. No change to this rule or to the flex mechanics above was needed for that; see
    `docs/features/PurchaseLedger/dev/purchase-proposal-grid.md` for the column layout itself.
*/
.paleda-detailview-fills-view > .dxbl-row > .paleda-detailview-fills-view__grid-row {
    flex: 1 1 auto;
    min-height: 4rem;
    display: flex;
    flex-direction: column;
}

.paleda-detailview-fills-view__grid-row > .dxbl-row {
    flex: 1 1 auto;
    min-height: 0;
    display: flex;
    flex-direction: column;
}

.paleda-detailview-fills-view__grid-row > .dxbl-row > * {
    flex: 1 1 auto;
    min-height: 0;
    display: flex;
    flex-direction: column;
}

/*
    Round 3 (granskning against the live Inköpsförslag wizard, 2026-09-27): the grid still measured 15 892 px
    unbounded, worse than round 2's model showed, because everything above bounds the LAYOUT ITEM
    (`dxbl-form-layout-item.paleda-nested-grid-fills-view`) but never reaches `.grid-content` itself — three
    plain-block wrappers sit between them that none of the rules above (or DevExpress's own theme CSS) ever turn
    into a flex container: `DxFormLayoutItem.razor.cs GetItemContentCssClass` renders the item's own content in a
    `<div class="dxbl-fl-ctrl">` (`dxbl-fl-ctrl-nc` when the item has no caption, which `Lines` does not), and
    inside that XAF's `NestedFrameTemplateComponent.razor` renders the nested ListView as
    `<div class="nested-frame"><div class="nested-toolbar">…</div><div class="nested-content">…</div></div>` before
    `.grid-content` finally appears. A plain block child of a flex container is sized to its own content, not
    stretched to the parent's height — `flex: 1 1 auto`/`height: 100%` on `.grid-content` alone only resolves once
    every ancestor up to the flexed layout item is itself `display: flex` with a real height to give away, which
    none of `.dxbl-fl-ctrl(-nc)`, `.nested-frame` or `.nested-content` were. DevExpress's own
    `master-detail.css`/`template.css` only chains this for the master-detail/modal-popup ListView cases, never for
    a nested ListView inside an ordinary DetailView layout item, which is exactly this wizard's `Lines`.
*/
.paleda-nested-grid-fills-view > .dxbl-fl-ctrl,
.paleda-nested-grid-fills-view > .dxbl-fl-ctrl-nc,
.paleda-nested-grid-fills-view .nested-frame,
.paleda-nested-grid-fills-view .nested-content {
    display: flex;
    flex-direction: column;
    flex: 1 1 auto;
    min-height: 0;
}

/*
    Round 4 (granskning against the live Inköpsförslag wizard, 2026-09-27, same day): round 3's chain above still
    measured 15 892 px — worse, because it never actually took effect. `Lines` has no caption, so
    `DxFormLayoutItem.razor.cs GetItemContentCssClass` puts BOTH `dxbl-fl-ctrl` and `dxbl-fl-ctrl-nc` on the same
    div, and DevExpress's own compiled theme (`DevExpress.Blazor.Themes/scss/components/_formlayout.scss`, the
    `.dxbl-fl-item { .dxbl-fl-ctrl-nc { flex-grow: 0; margin-top: auto; } }` nested rule — "an item without a
    caption does not grow, it sits at the bottom of its row") ships exactly that selector, compiled to
    `.dxbl-fl-item .dxbl-fl-ctrl-nc`. That selector and round 3's `.paleda-nested-grid-fills-view > .dxbl-fl-ctrl-nc`
    both carry two classes — a specificity tie — and `Pages/_Host.cshtml` links `padmin.css` (line 55) before
    DevExpress's own `_content/DevExpress.ExpressApp.Blazor/styles.css` (line 90), so on the tie the framework's
    rule is the one applied last and wins: `flex-grow` computes to 0, the div never grows, and it sizes to its
    content instead — every proposal row, unbounded. `<dxbl-form-layout-item>` itself carries DevExpress's own
    `dxbl-fl-item` class (`FormLayoutCssClasses.Item`, `DxFormLayoutItem.razor.cs GetCssClass`) alongside
    `paleda-nested-grid-fills-view`, so folding that class into this selector adds a third class and beats
    DevExpress's rule on specificity alone — no `!important`, and it stays correct however the two stylesheets
    ever get reordered.
*/
.paleda-nested-grid-fills-view.dxbl-fl-item > .dxbl-fl-ctrl,
.paleda-nested-grid-fills-view.dxbl-fl-item > .dxbl-fl-ctrl-nc {
    flex: 1 1 auto;
    min-height: 0;
    margin-top: 0;
}

/*
    Round 5 (same live-DOM measurement, 2026-09-27): round 4's fix made the `dxbl-fl-ctrl-nc` div itself willing
    to grow, but the grid still measured 15 892 px, because CSS flexbox gives every flex item a default
    `min-height: auto`, which resolves to that item's own content's min size (not 0) unless a stylesheet says
    otherwise — the "automatic minimum size" rule. Walking the real DOM from the grid upward
    (`getComputedStyle` at every ancestor, msedge, 1500x950) found three more flex items still on that default,
    each one alone enough to force every ancestor above it back up to content height regardless of `flex-grow`:
    `<dxbl-form-layout-item class="… paleda-nested-grid-fills-view">` itself (`min-height: auto`, `flex-grow: 0`
    — this file had only ever touched its CHILD `.dxbl-fl-ctrl(-nc)`, never the item element that carries our
    own marker class), `<div class="dxbl-group-body-content">` (`min-height: auto`, `flex-grow: 0`) and
    `<dxbl-group-control class="dxbl-group …">` (`min-height: auto`, `flex-grow: 0`) — the collapsible-group
    wrapper `Lines_Group` renders around its body because XAF gives every `LayoutGroup` a `<dxbl-group-control>`
    regardless of whether it has a caption. `<dxbl-expandable-container class="… dxbl-group-body …">` between
    them already had `flex-grow: 1` from DevExpress's own `.dxbl-expandable-container { display: flex }`
    (`DevExpress.Blazor.Themes/scss/components/_expandable-container.scss`), but not `min-height: 0` either.
    None of DevExpress's own theme SCSS sets either property on any of these three classes, so unlike round 4
    this is a plain addition — except for the item element itself, which is also a `.dxbl-col`
    (`DevExpress.Blazor.Themes/scss/components/_cols.scss`: `.dxbl-col { flex-shrink: 0; width: 100%; … }`, the
    Bootstrap-style grid column XAF puts every layout item in): that one-class rule ties `.paleda-nested-grid-
    fills-view` alone on specificity, and padmin.css again loads before DevExpress's own stylesheet, so
    `flex-shrink: 0` from `.dxbl-col` would otherwise win the same way round 4's `.dxbl-fl-ctrl-nc` fight did.
    Folding in `.dxbl-fl-item` (present on the same element, `FormLayoutCssClasses.Item`) the same way round 4
    did settles that one too.
*/
.paleda-nested-grid-fills-view.dxbl-fl-item {
    flex: 1 1 auto;
    min-height: 0;
}

.paleda-detailview-fills-view__grid-row .dxbl-expandable-container,
.paleda-detailview-fills-view__grid-row .dxbl-group-body-content,
.paleda-detailview-fills-view__grid-row dxbl-group-control {
    flex-grow: 1;
    min-height: 0;
}

/*
    Round 6 (same live-DOM measurement, 2026-09-27): with round 5's three fixes in place, `dxbl-group-control`
    and `.dxbl-group-body-content` measured exactly as bounded as `Lines_Group` itself (393 px, 350 px) — but the
    grid still measured 3 900 px, because `.dxbl-group-body-content` is `display: block` (DevExpress never makes
    it a flex container) and its own single child, `<div class="dxbl-row">`, is therefore not a flex item at
    all: it just sizes to its content in normal block flow and overflows its own box, because nothing clips it.
    A first attempt turned `.dxbl-group-body-content` into a column flex container and gave its `.dxbl-row` child
    `flex: 1 1 auto; min-height: 0` — still 3 900 px, because `.dxbl-row` itself is DevExpress's Bootstrap-style
    grid ROW (`DevExpress.Blazor.Themes/scss/components/_cols.scss`: `display: flex; flex-wrap: wrap;`), and its
    `.dxbl-col` children get `flex-shrink: 0; width: 100%`. That is a HORIZONTAL layout system: `flex-grow`
    governs each column's WIDTH, and with `flex-wrap: wrap` a line's HEIGHT is however tall its tallest item's
    content needs — never the reverse, so giving the row itself a bounded height (as `flex: 1 1 auto` from its
    OWN parent does) does nothing to stop a wrapped line from rendering taller than that box and overflowing it.
    Exactly this — `.dxbl-row` defaulting to Bootstrap's row+wrap instead of a column stack — is why `Main`'s own
    `.dxbl-row` needed an explicit `flex-direction: column` back in round 1 (`.paleda-detailview-fills-view >
    .dxbl-row`); this nested one needs the identical override, or it is still a row-and-wrap container underneath
    everything else in this file.
*/
.paleda-detailview-fills-view__grid-row .dxbl-group-body-content {
    display: flex;
    flex-direction: column;
}

.paleda-detailview-fills-view__grid-row .dxbl-group-body-content > .dxbl-row {
    display: flex;
    flex-direction: column;
    flex: 1 1 auto;
    min-height: 0;
}

/*
    Round 7 (same live-DOM measurement, 2026-09-27): with rounds 4–6 all in place, the div from round 4
    (`.dxbl-fl-ctrl-nc`) still measured 3 942 px — because `Lines`, like every layout item, also carries
    `dxbl-fl-item-horizontal` (`GetItemCaptionPosition`/`CaptionPosition.Horizontal` — the shared default caption
    position, not something this wizard set), and at `lg` and wider DevExpress's own theme has:
    <pre>
    @media (min-width: …lg) {
        .dxbl-fl .dxbl-fl-item.dxbl-fl-item-horizontal { flex-flow: row nowrap; … }
    }
    </pre>
    (`DevExpress.Blazor.Themes/scss/components/_formlayout.scss`) — three classes, switching the ITEM ITSELF
    (not just its content div) from the column layout `.dxbl-fl-item` normally has back to a horizontal
    caption-beside-control row, exactly the layout a one-line text field wants and a nested grid never should
    get. At our 1500 px test width this is active, so round 4's own flex-grow/shrink/min-height on `.dxbl-fl-
    ctrl-nc` governed WIDTH, not height, and height fell back to fitting content again — invisible at 1280 px,
    below `lg`, which is why this test measures both widths. Three classes tie the media query's three, so this
    file's own compound selector needs a fourth to win outright — the item's tag name (round 4 instead added
    `.dxbl-fl-item` itself as a class to beat `.dxbl-fl-item .dxbl-fl-ctrl-nc`; here that class is already used
    up on the media query's own selector, so the tag name is the only class-free specificity left to add).
*/
dxbl-form-layout-item.paleda-nested-grid-fills-view.dxbl-fl-item.dxbl-fl-item-horizontal {
    flex-flow: column nowrap;
}

/*
    Round 8 (granskning of rounds 1-7, 2026-09-27): rounds 1-7 made the grid bounded, but bounded all the way
    to zero on a real page — `min-height: 0` on `.paleda-detailview-fills-view__grid-row` means flexbox is free
    to give the grid row whatever is left over once every fixed-height sibling (supplier/criteria fields,
    Anmärkning) has taken its share, and on a short viewport or with several fixed-height fields above the grid
    that remainder can be a few tens of pixels — 85 px of scroll viewer at 1280x800 in the real wizard, 0 of 98
    rows visible, and 235 px at 1500x950, still 0 rows fully visible. `Main` itself measured `scrollHeight`
    equal to `clientHeight` (no page scroll either), so the rows were unreachable both ways: not on the fixed
    part of the page and not behind a scrollbar. That is worse than the pre-round-1 behaviour Peter reported
    for Blad47, which at least let the page scroll to reach the horizontal bar.
    The fix gives the grid row a floor instead of letting it collapse: `min-height: max(20rem, 50vh)` keeps at
    least a legible, roughly half-viewport-tall grid however many fixed-height fields sit above it. `Main`
    (`.paleda-detailview-fills-view`) already carries `overflow-y: auto` (round 2's fallback, above), so when
    the floor pushes the total past the viewport the PAGE scrolls that difference — at most the header's own
    height, never the grid's, because the grid keeps growing to fill whatever vertical space is left once the
    page is scrolled to the row's top. That is the behaviour Peter's own Blad47 answer describes (a page that
    scrolls a bounded amount, then a grid that fills the rest with its own scrollbars), and it holds even on a
    1366x768 laptop, where 50vh alone still clears the assertion floor
    `PurchaseProposal_Supplier5000_GridScrollbarStaysInsideViewportAtPageTop` now carries (below).
*/

.paleda-detailview-fills-view__grid-row .grid-content,
.paleda-nested-grid-fills-view .grid-content {
    flex: 1 1 auto;
    min-height: 0;
    height: 100%;
}

.paleda-detailview-fills-view__grid-row .grid-content dxbl-grid,
.paleda-detailview-fills-view__grid-row .grid-content dxbl-tree-list,
.paleda-nested-grid-fills-view .grid-content dxbl-grid,
.paleda-nested-grid-fills-view .grid-content dxbl-tree-list {
    height: 100%;
    max-height: 100%;
}

/*
    Nested list views in a Detail View's tabs, capped at the window (#1677, Blad74 B252: "På alla underflikar … är
    sidoscrollen längst ner så ska man sidoscroll för att läsa t.ex första raden måste man scrolla ända ner sedan
    sidoscrolla och sedan scroll upp").

    A tab's grid has no height of its own, so DxGrid does what DevExpress documents ("Get Started with Blazor Grid",
    Enable Scrolling): it "automatically adjusts its height (up to a maximum of 10,000 pixels) to fit all rows".
    Measured in Edge against a copy of Paleda's data on 2026-10-29, Product_DetailView, tab Försäljningsrader of
    the freight article (1 568 lines, 200 on the page), 1500x950: the grid was 8 098 px tall, the card's scroll
    range 9 509 px, and the grid's horizontal scrollbar sat at the very end of the card — to read the first row
    sideways you scroll to the bottom, scroll the grid, and scroll all the way back up.

    This is NOT `paleda-nested-grid-fills-view` above. That one hands the grid whatever room the view has left, and
    needs the whole ancestor chain — the root group, the row holding the grid, the layout item, every wrapper in
    between — turned into column flex boxes. It works for a view built around one grid (Inköpsförslag). A card
    with a long field block above its tabs (Product, Customer, Supplier) cannot be flexed that way: measured
    2026-09-25, a flex chain from `.main-content` down collapsed the field block from 513 px to 112 px and then
    lost the lines group (docs/development/agents/xaf-xpo/editor-and-grid-gotchas.md, "A nested ListView has no
    height"). Here the tab strip is simply the end of the card, so the grid gets an explicit cap instead — the
    same shape `.paleda-scanner-grid` in scanner.css already uses, a class of our own on the grid and no `dxbl-*`
    element in the selector — and nothing above it changes.

    `max-height`, not `height`: a tab with three lines stays three lines tall (measured 308 px at 1500x950) and a
    tab with 200 rows scrolls inside the grid, which keeps its horizontal scrollbar at the grid's own bottom edge.
    16rem is the 9rem of application chrome above `.main-content` (137 px measured, the same constant as above) plus
    the tab strip, the nested toolbar and the card's bottom padding (98 px + 21 px measured at 1500x950, 7.4rem
    together, rounded up so the strip stays visible). With the card scrolled to its end, the tab strip, the toolbar,
    the whole grid and its scrollbar are then in the window at once. The `max()` floor keeps a very short window from
    capping the grid below a header row and two data rows.

    Why CSS and not a model setting (dxdocs checked 2026-10-29, framework first): `IModelListViewBlazor` has no
    height property (docs.devexpress.com/eXpressAppFramework/DevExpress.ExpressApp.Blazor.SystemModule.
    IModelListViewBlazor._properties; `VirtualScrollingEnabled` changes how rows are loaded, not how tall the grid
    is). DevExpress documents the height of a Blazor grid as a CSS constraint — "Define a CSS constraint for the
    Grid height. Otherwise, the Grid automatically adjusts its height (up to a maximum of 10,000 pixels) to fit all
    rows" (docs.devexpress.com/Blazor/403625, Enable Scrolling; docs.devexpress.com/Blazor/404753, Scrolling in
    Blazor Grid) — and XAF documents `CustomCSSClassName` plus a rule in `wwwroot/css` as the way to style a layout
    element (docs.devexpress.com/eXpressAppFramework/403068, Blazor Application Appearance). The grid's own class is
    the documented `DxGrid.CssClass` (docs.devexpress.com/Blazor/405705; XAF: `DxGridModel.CssClass`), which
    `DxGridDefaultController.ApplyNestedGridSettings` fills for every ordinary nested list, as it already does for
    the scanner lists. That is exactly the shape used here; no JavaScript, no custom component.

    XAF's own cap for a nested grid was read and rejected: `.nested-content > .grid-content.grid-virtual-scrolling-mode
    dxbl-grid { max-height: 300px }` (DevExpress.ExpressApp.Blazor, Styles/layout/master-detail.css:131) applies only
    with `VirtualScrollingEnabled`, which `DxGridDefaultController` switches off for every list but the scanner lists
    because virtual scrolling replaces the pager with loading on scroll (dxdocs, `IModelListViewBlazor.
    VirtualScrollingEnabled`), and 300 px is a fixed number that does not follow the window.

    A view opts in with `CustomCSSClassName="paleda-tab-grids-bounded"` on its `TabbedGroup` in Model.xafml
    (`LayoutComponent.razor` `CreateTabbedGroup` puts it on the tab pages element), so every tab of that group is
    covered and a tab added later needs nothing. `.paleda-nested-grid` is only on a nested list's grid
    (`DxGridDefaultController`: not a root list, not a scanner list), so the rule cannot reach another grid.
    `NestedTabGridHeightTests` (paleda.se.Blazor.Server.Tests) and `NestedGridCssClassTests` (Module.Integration.Tests)
    guard the two ends; `ProductDetailTabGridE2ETests` (paleda.se.E2E.Playwright) measures it against the real fixture.
*/
.paleda-tab-grids-bounded .paleda-nested-grid {
    max-height: max(15rem, calc(100vh - 16rem));
}

/*
    The reconnect box (WP11 of the scanner layout, #1531, B24; UX review F16). Blazor Server uses an element with the id
    `components-reconnect-modal` in the page instead of its own English dialog, and sets one of `components-reconnect-show` (the
    connection was lost and Blazor is trying again), `-failed` (it gave up and waits for a button), `-rejected` (the server no longer
    has the circuit) and `-hide` on it (Microsoft Learn, "ASP.NET Core Blazor SignalR guidance", .NET 9). The markup is in
    Pages/_Host.cshtml, in Swedish; this is its structure only. The colours are not ours: XAF paints the box from the theme's own tokens
    while it is a direct child of <body> (DevExpress.ExpressApp.Blazor app.ts, "check reconnection", and styles.css, which gives it
    `z-index`, `opacity` and `padding`), so no colour is written here, and no `dxbl-*` name.

    Why the rules name the id: styles.css gives `#components-reconnect-modal` `position: relative`, and an id beats a class, so the
    box is made a full-screen overlay with the same id plus its class. Why the states are wrappers and not the elements themselves:
    XAF adds `d-flex` (Bootstrap's `display: flex !important`) to the first button of the box, and nothing but a hidden parent
    can hide a button that has that class. A button is at least 48 px, a text at least 1.25 rem, for a thumb and for a picker who
    looks at the box from arm's length.
*/
#components-reconnect-modal.paleda-reconnect {
    display: none;
}

#components-reconnect-modal.paleda-reconnect.components-reconnect-show,
#components-reconnect-modal.paleda-reconnect.components-reconnect-failed,
#components-reconnect-modal.paleda-reconnect.components-reconnect-rejected {
    position: fixed;
    inset: 0;
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    text-align: center;
    /* The box blocks work until the circuit is back, so it must not be see-through:
       XAF's styles.css sets `opacity: 0.9 !important` on this id and no background at
       all, which left the text floating over the page. Dim the page, keep the box
       itself fully opaque (the !important wins over the XAF rule). */
    opacity: 1 !important;
    background-color: rgba(0, 0, 0, 0.45);
}

.paleda-reconnect__state {
    display: none;
    flex-direction: column;
    align-items: center;
    gap: 1rem;
    max-width: 36rem;
    background-color: var(--bs-body-bg, #ffffff);
    color: var(--bs-body-color, #1b1b1b);
    padding: 1.5rem 2rem;
    border-radius: 0.5rem;
    box-shadow: 0 3px 6px 2px rgba(0, 0, 0, 0.3);
}

.components-reconnect-show > .paleda-reconnect__state--show,
.components-reconnect-failed > .paleda-reconnect__state--failed,
.components-reconnect-rejected > .paleda-reconnect__state--rejected {
    display: flex;
}

.paleda-reconnect__text {
    margin: 0;
    font-size: 1.25rem;
}

.paleda-reconnect__button {
    min-width: 12rem;
    min-height: 48px;
    padding: 0.5rem 1.5rem;
    font-size: 1.125rem;
    cursor: pointer;
}

/* XAF styles only the first button; the second one has the same weight in the box and takes the box's own colours. */
.paleda-reconnect__state--rejected .paleda-reconnect__button {
    color: inherit;
    background: transparent;
    border: 2px solid currentcolor;
}

/* Blad52: a scan that lands while the scan field is read-only (a previous scan is still being resolved) is refused,
   never queued. padmin.js marks the field with this class for a moment and shows the refusal in
   #paleda-scanner-refused-status, so the picker sees that the scan was not taken and scans again. The colours, the radius and the
   shadow are the theme's tokens (--paleda-scanner-refused*, paleda.se.Theming/scss/_paleda.scanner.scss), not literals here. */
input.paleda-scanner-input--refused {
    outline: 3px solid var(--paleda-scanner-refused);
    outline-offset: 1px;
    background-color: var(--paleda-scanner-refused-tint);
}

.paleda-scanner-refused-status {
    position: fixed;
    z-index: 2000;
    padding: 0.35rem 0.6rem;
    border-radius: var(--paleda-scanner-refused-radius);
    background-color: var(--paleda-scanner-refused);
    color: var(--paleda-scanner-refused-ink);
    font-weight: 600;
    box-shadow: var(--paleda-scanner-refused-shadow);
}

.paleda-scanner-refused-status[hidden] {
    display: none;
}

/*
    The goods receipt scanning view's remaining in-form button, "Bokför" (Anders, 2026-09-29; alone in its row below
    the tabs since 2026-10-14): one XAF ActionContainerViewItem, "Spara EAN" and "Bekräfta rad" are the DomainActions
    bar's buttons since #1612 and get their 48 px from the [data-domain-action-bar] rule below. The component API does
    the rest first: DxToolbar SizeMode.Large and no toolbar adaptivity (GoodsReceiptScannerWorkspaceViewController).
    What is left is Paleda's own detail — a 48 px target the receiver hits with a thumb on the SM-X210, as wide as its column.
    Measured 2026-09-29 before this rule: the Large button was 34 px tall and only as wide as its caption, because
    every wrapper between the layout item and the button (dxbl-btn-toolbar, the toolbar group, dxbl-toolbar-item)
    is `flex: 0 1 auto`. The item's own `dxbl-fl-item` class is part of the selector so it outranks DevExpress's
    toolbar rules, which load after padmin.css (layout.css resolves `.paleda-nested-grid-fills-view` the same way).
*/
.dxbl-fl-item.paleda-scanner-action .dxbl-toolbar,
.dxbl-fl-item.paleda-scanner-action .dxbl-btn-toolbar,
.dxbl-fl-item.paleda-scanner-action .dxbl-toolbar-group,
.dxbl-fl-item.paleda-scanner-action .dxbl-toolbar-item {
    flex: 1 1 100%;
    width: 100%;
}

/*
    A disabled action is rendered without the `xaf-action` class (measured 2026-09-30: enabled
    "class=dxbl-btn … dxbl-toolbar-item xaf-action", disabled "class=dxbl-btn … dxbl-disabled … dxbl-toolbar-item"), and
    DxToolbar writes its own measured `height` inline on the root — 30 px for a row whose only button is disabled. The
    selector below therefore names `.dxbl-btn` alone, and the toolbar root gets the same floor, so a button keeps its 48 px
    target whether or not it can be pressed: "Lägg tillbaka" must not grow under the thumb when it becomes enabled.

    Why `min-height` wins against the inline `height` (MDN, "min-height", checked 2026-09-30): it "prevents the used value
    of the height property from becoming smaller than the value specified for min-height". Min/max constraints act on the
    used value, after the cascade has settled `height`, so this is not a specificity contest that an inline style would win
    — do not "fix" it with !important or a longer selector. Its explicit length also replaces the flex item's automatic
    minimum size (`min-height: auto`, content-based): the floor is the 48 px written here, not whatever height the caption
    happens to have — the disabled button was 30 px tall by content before this rule reached it. `flex: 1 1 100%` sets
    flex-basis, the MAIN size of the flex item (MDN, "flex-basis": a percentage resolves against the container's inner main
    size) — width in these row containers — so it makes each button fill its column and takes no part in the height.

    Every `.dxbl-*` selector in this file names non-public API: DevExpress documents `--dxbl-*` variables and classes as
    internal, "may change between versions" (dxdocs, "CSS Variables in Fluent Themes", 405705; "CSS Classes", 401740).
    The public API was tried first and does not reach the target — DxToolbar SizeMode.Large measures 34 px, and there is
    no `--dxds-*` variable for a control's height. The guard against a silent break is the E2E measurement of the
    in-form buttons, enabled and disabled (InFormScannerActionButtons; the three *_WithTheInFormButtons_* test pairs):
    a DevExpress upgrade that renames these classes or changes the inline height DxToolbar writes turns it red.
*/
.dxbl-fl-item.paleda-scanner-action .dxbl-toolbar {
    min-height: 48px;
}

.dxbl-fl-item.paleda-scanner-action .dxbl-toolbar-item > .dxbl-btn {
    flex: 1 1 100%;
    min-height: 48px;
    justify-content: center;
}

/*
    The scanner lists' height (generisk-scannerlayout.md, WP2, decision B8; #1531): the list fills what is left of the
    viewport below the scanning card and the tab strip, and only the list scrolls — the page does not.

    Framework first: DevExpress documents a CSS constraint on the grid's height as the way to bound a virtualized grid
    ("define a CSS constraint for the Grid height. Without it, the Grid automatically adjusts its height (up to a maximum
    of 10,000 pixels) to fit all rows", dxdocs 404753 "Scrolling in Blazor Grid", Row Virtualization). The hook is the
    class Paleda puts on the grid with DxGrid.CssClass (GridModel.CssClass, ScannerListRules.GridCssClass), never a
    dxbl-* selector.

    XAF's own rule is in the way, and that is why the selector is as long as it is. master-detail.css:131 in
    DevExpress.ExpressApp.Blazor says `.nested-content > .grid-content.grid-virtual-scrolling-mode dxbl-grid {
    max-height: 300px; }` — a nested list with virtual scrolling is capped at 300 px (measured 2026-10-06, 800x1280: the
    grid was 300 px tall and nine rows were in view). That selector is three classes and one element (0,3,1), so the
    bare `.paleda-scanner-grid` (0,1,0) loses. This one is the same three class names plus ours (0,4,0), which wins
    whatever the order of the style sheets, with no !important. `nested-content`, `grid-content` and
    `grid-virtual-scrolling-mode` are XAF's own markup classes (NestedFrameTemplateComponent.razor, the grid list editor's
    wrapper), the very ones its rule is written against, so a XAF change that renames them also removes the cap.

    The height is a viewport length minus the chrome above the list, which is a measured constant and not a guess:
    the scanning card, the tab strip and the shell above them measured 520 px at 800x1280 and 768x1024 and 430 px at
    1280x800 (getBoundingClientRect of the grid's top edge, msedge, 2026-10-06). The card is shorter from 992 px because
    LayoutAdaptivity lays its buttons out in one row from there (two per row from 768 px), hence the media query, at
    the same breakpoint. Rem, not px, so the constants follow the user's text size like the card above them does.
    The reserve stays below the list so a status line that grows the card a little does not push the page into
    scrolling. WP9 replaces the card's buttons with one bar and these two numbers are re-measured then.
    Why a flat calc is acceptable here when layout.css refused it for Inköpsförslag: that view had editors of unknown
    height above its grid; the card here has a fixed set of rows, so the measured constant bounds the grid itself.

    Units (MDN, "<length>", checked 2026-10-06): `vh` is the large viewport (browser toolbars retracted) and can hide the
    list's last rows behind the browser's own interface; `dvh` is the dynamic viewport and fits it exactly (Baseline since
    2022-12: Chrome 108, Edge 108, Samsung Internet 21 — the SM-X210's browser — Firefox 101, Safari 15.4, MDN BCD
    css.types.length.viewport_percentage_units_dynamic). The `vh` declaration first is the fallback for a browser that
    does not know `dvh`: it drops the second declaration and keeps the first. `min-height` (MDN: it "prevents the used
    value of the height property from becoming smaller than the value specified for min-height") keeps a few rows on a
    very short window; there the page scrolls instead of the list shrinking to nothing. No `min-height: 0` flex chain is
    involved: the grid is sized by its own height, not by flex growth, so no ancestor has to be turned into a flex box
    (unlike paleda-detailview-fills-view, which this file does not touch and which PurchaseProposalWizard keeps).
*/
.nested-content > .grid-content.grid-virtual-scrolling-mode .paleda-scanner-grid {
    --paleda-scanner-grid-chrome: 33rem;
    --paleda-scanner-grid-reserve: 2rem;
    height: calc(100vh - var(--paleda-scanner-grid-chrome) - var(--paleda-scanner-grid-reserve));
    height: calc(100dvh - var(--paleda-scanner-grid-chrome) - var(--paleda-scanner-grid-reserve));
    max-height: calc(100vh - var(--paleda-scanner-grid-chrome) - var(--paleda-scanner-grid-reserve));
    max-height: calc(100dvh - var(--paleda-scanner-grid-chrome) - var(--paleda-scanner-grid-reserve));
    min-height: 10rem;
}

/*
    WP12 S3.1: the picking card is constant, so its chrome is re-measured and its reserve drops to 0.5rem (the card
    no longer grows). The grid's top edge measured 488 px stacked and 212 px side by side (msedge, 2026-10-08), and
    the tab content and layout items add 24 px below the grid (12 px of tab padding, 6 px margins twice), so the
    stacked chrome is 31.5rem: at 800x1280 the list is 768 px (25 rows), at 800x1105 593 px (19 rows), with 4 px of
    slack inside div.main-content. Side by side the chrome is 14rem: at 1280x800 the list is 568 px, at 1280x625
    393 px (12 rows). Scoped to the picking flow: the goods receipt and the inventory count keep the stacked card
    and its 33/29rem with the 2rem reserve until their layouts are re-measured. One class more (0,5,0), so it wins
    over the rule above whatever the order.
*/
.nested-content > .grid-content.grid-virtual-scrolling-mode .paleda-scanner-grid.paleda-scanner-flow-pick {
    --paleda-scanner-grid-chrome: 31.5rem;
    --paleda-scanner-grid-reserve: 0.5rem;
}

/*
    WP4 re-measure (2026-10-06): the scan field (46 -> 48 px) and the quantity editor (DevExpress Large, 48 px buttons) are taller than
    when the 27 rem below was measured, and ScannerLists_With120Lines_… found the page scrolling by 25 px at 1280x800
    (`div.main-content` scrollHeight 688 against clientHeight 663). Two rem more (32 px) leaves 7 px.
*/
@media (min-width: 992px) {
    .nested-content > .grid-content.grid-virtual-scrolling-mode .paleda-scanner-grid {
        --paleda-scanner-grid-chrome: 29rem;
    }

    /* WP12 S3.1, side by side (picking only, ColSpanLg 5/7): the list has the whole height next to the card. */
    .nested-content > .grid-content.grid-virtual-scrolling-mode .paleda-scanner-grid.paleda-scanner-flow-pick {
        --paleda-scanner-grid-chrome: 14rem;
    }
}

/*
    The primary cells of the scanner lists (WP12 S7; decision B31; UX review F18): the shelf and the quantity are what the picker reads from
    40 to 50 cm, so they are 16 px against the list's 14 px. DxGridDefaultController adds this class to the data cells of the two columns
    through GridCustomizeElementEventArgs.CssClass, the documented hook for one cell's class (dxdocs, DxGrid.CustomizeElement); neither
    DxGridDataColumn nor the XAF column model has a font parameter (dxdocs guard 2026-10-08), so this one rule is what is left.

    The line height is 1.25rem (20 px), the box the row's 14 px text already has, so the row stays 28-29 px and the number of rows in view
    does not change (the 120-line test measures it). Three classes (0,3,0): the DevExpress cell font
    (.dxbl-grid .dxbl-grid-table > tbody > tr > td, (0,2,3), in office-white.bs5 and paleda.theme) beats the bare two-class rule,
    measured 2026-10-08 (the cells read 14 px with the class on them). Only Paleda's own classes, no dxbl-*, no !important,
    and it reaches nothing outside the two scanner lists.
*/
.paleda-scanner-grid.paleda-scanner-list-todo .paleda-scanner-cell-primary,
.paleda-scanner-grid.paleda-scanner-list-done .paleda-scanner-cell-primary {
    font-size: 1rem;
    line-height: 1.25rem;
}

/*
    The scan field (generisk-scannerlayout.md, WP4; decisions B13 and B14; #1531): a dark "terminal" prompt, at least
    48 px tall, with its prompt in the field instead of a label. ScannerTextPropertyEditor puts two classes of Paleda's
    own on the field — paleda-scanner-field on the editor's root, paleda-scanner-input on its <input> — and this is the
    only place that styles them. Nothing here names a dxbl-* class or variable; the colours are the three tokens of
    the shared theme (paleda.se.Theming, scss/_paleda.scanner.scss), so Admin's two themes cannot drift apart.

    The 48 px floor is min-height on the root, not height: the root is a flex row whose <input> stretches to it
    (align-items: stretch), and DevExpress' own SizeMode.Large, which the editor sets first, is the component-API half
    of the size. The theme sets no height on the root, so one class is enough. 48 px is a CSS pixel length, WCAG 2.5.8
    and 2.5.5 and Android's 48 dp, and is deliberately not rem: a target does not shrink with the user's text size.
    MDN, "min-height": it "prevents the used value of the height property from becoming smaller than the value
    specified for min-height".

    Why the colours are on the root and only while the field takes input: a DevExpress text editor draws its surface
    and border on the root element and keeps its <input> transparent with color: inherit, so the background and the text
    colour go on paleda-scanner-field and the input follows. The selector asks for "a root that holds a scanner input
    that is not read-only" with :has() (MDN, "<:has()>": Baseline 2023; Chrome 105, Samsung Internet 20, Firefox 121,
    Safari 15.4 — the SM-X210's browser is covered, and a browser without it keeps DevExpress' own look). :has() takes the
    specificity of its most specific argument, so this is (0,3,1) and outranks the theme's `.dxbl-text-edit` and its
    state classes (0,2,0) whatever the order of the style sheets, without !important and without naming a dxbl class.
    While a scan is being resolved the field is read-only (XafScannerEditorModelExtensions.ProcessScanWhileReadOnlyAsync,
    the owner's visible busy state): the rule steps aside and DevExpress' own read-only look, which is dimmed, shows —
    framework first. Fighting it would mean painting over the overlay DevExpress draws on a read-only editor.

    The prompt is NullText, which DevExpress renders as the <input>'s placeholder attribute (the web component copies
    its custom-placeholder attribute, text-editor.ts), so ::placeholder is the one selector (MDN, "::placeholder").
    Chrome's default placeholder colour is darkgray and Firefox dims the field's own colour to 54 %; setting both
    colour and opacity explicitly is the MDN-documented way to a fixed, readable prompt ("Opaque text"), and the colour
    is --paleda-scanner-prompt, which ScannerFieldTerminalLookTests holds to 7:1 against the field's background (7.90:1). It
    carries the same "not read-only" condition as the background, so the green prompt is never drawn on the light
    read-only surface, where it would be 2.2:1.

    caret-color is the field's own caret, which already blinks; "caret-shape: block" is experimental and missing from
    Samsung Internet (the SM-X210's browser), so it is not used (the spec's Workarounds).
*/
.paleda-scanner-field {
    min-height: 48px;
}

.paleda-scanner-field:has(input.paleda-scanner-input:not([readonly])) {
    background-color: var(--paleda-scanner-bg);
    color: var(--paleda-scanner-ink);
    caret-color: var(--paleda-scanner-ink);
}

.paleda-scanner-field input.paleda-scanner-input:not([readonly])::placeholder {
    color: var(--paleda-scanner-prompt);
    opacity: 1;
}

/*
    Is the scan field ready for a scan? (UX review 2026-10-07, F7; WCAG 2.2 1.4.11 non-text contrast, 2.4.7 focus visible.) A wedge
    scanner can only type, never click, so what the picker must be able to see before scanning is whether the field takes the scan.
    Two outlines of the same width and offset, which differ in colour and in line style, so that colour is not the only signal
    (WCAG 1.4.1):

      has the cursor   solid  3 px  --paleda-scanner-ready   the field is where a person types, and a scan lands in it
      is busy          dashed 3 px  --paleda-scanner-idle    read-only: the scan before is being resolved, a scan now is refused

    The dashed ring used to mean "the field lacks the cursor", and that was true until WP11 (#1531, B19): padmin.js now moves a scan's keys
    into the field from wherever the cursor is, so a scan is no longer lost because the cursor is elsewhere, and a ring that said so
    would be a lie. "Not ready" is tied to what actually refuses a scan: the field is read-only (the server's busy window and the browser's
    own lock after the Enter that commits, B20 a) — never to `:focus` missing. Without the cursor and not busy the field has no ring.

    Why an outline (MDN, "outline"): it is drawn outside the border and, unlike the rest of the box, takes up no space, so the ring
    changes nothing about the card's layout, which is measured to the pixel by the E2E tests (the grid's height is a calc of the card's
    height). `outline-offset: 2px` (MDN, "outline-offset": the space between the outline and the element's border edge) leaves a gap
    of page showing between field and ring; for that reason both colours have to stand 3:1 against the PAGE behind the field and not
    only against the field's dark surface, which ScannerFieldTerminalLookTests holds them to, against both themes' light and dark
    surface tokens (_paleda.scanner.scss says why neither is --paleda-focus-ring). An outline paints outside the border box (ink
    overflow, MDN glossary), where an ancestor whose `overflow` is not `visible` can cut it off: ScanFieldProbe measures that no
    ancestor of the field comes within the ring's 5 px of the field's edge with a clipping overflow, in both tablet orientations.

    Why `:focus` on the <input> and not `:focus-visible` or `:focus-within` on the root (MDN): `:focus` is "has received focus" however
    it got it, by a tap, Tab or the programmatic FocusAsync() the application uses to hand the cursor back. `:focus-visible` is the
    browser's own guess at whether to show a ring, and `:focus-within` on the root would also be true for a button inside it. The ring
    of the ready state asks for `:not([readonly])`: while a scan is being resolved the field keeps the cursor but is read-only, and
    "ready" would be a lie for those few hundred milliseconds. `:not()` takes a selector list and `:has()` is a selector (MDN, ":not()",
    ":has()"); `:has()` is Baseline 2023 (BCD css.selectors.has: Chrome 105, Samsung Internet 20, Firefox 121, Safari 15.4), and a
    browser without it drops the rule and keeps DevExpress' look. Both rules outrank DevExpress' `outline: 0` on the focused root
    (0,2,0): the ready rule is (0,4,1) and the busy rule (0,3,1), whatever the order of the style sheets, without !important and without
    naming a dxbl class. This file, not the theme, holds them because it is the one owner of how this field looks (B14); the colours are
    the theme's tokens like the rest.
*/
.paleda-scanner-field:has(input.paleda-scanner-input:focus:not([readonly])) {
    outline: 3px solid var(--paleda-scanner-ready);
    outline-offset: 2px;
}

.paleda-scanner-field:has(input.paleda-scanner-input[readonly]) {
    outline: 3px dashed var(--paleda-scanner-idle);
    outline-offset: 2px;
}

/*
    The status row (generisk-scannerlayout.md, WP12 S1; decision B25; UX review F5): what the last scan or press did, in the card, under the
    quantity, until the next event. It is XAF's StaticText view item, a <label class="xaf-static-text …"> that
    ScannerStatusController gives the attribute data-paleda-scanner-status="neutral|success|warning|error" (a `class` in the component's
    Attributes loses to the label's own class, which is written after @attributes, so the attribute is the hook) and aria-live="polite".
    The colours are the theme's tokens, in pairs (_paleda.scanner.scss: every pair is held to 4.5:1 by ScannerStatusLookTests), and the
    sentence starts with a sign, so colour is never the only signal.

    The height is fixed on purpose, `height` and not `min-height`: the card must have the same height from the first line to the last
    (B26, F10), and a status line that grows with its text is what moved the buttons 112 px in the review. Room for two lines of 1.375rem
    plus 0.5rem of padding is 3.25rem (52 px); a longer sentence is cut after its second line with the line-clamp pattern of MDN,
    "line-clamp" (display -webkit-box, -webkit-box-orient vertical, overflow hidden, and the prefixed -webkit-line-clamp: 2). The unprefixed
    `line-clamp` is not shipped yet, and the prefixed form is what every browser has (MDN BCD css.properties.line-clamp, checked 2026-10-08:
    -webkit- since Chrome 6 and Chrome Android 18, Edge 79, Firefox 68, Samsung Internet 1.0, Safari 5 — the SM-X210's Chrome and Samsung
    Internet are covered). A code scanned into a sentence is one long word, so `overflow-wrap: anywhere` lets it break at any character and
    take its two lines instead of running out of the row (MDN, "overflow-wrap"; BCD css.properties.overflow-wrap.anywhere: Chrome 80,
    Edge 80, Firefox 65, Samsung Internet 13, Safari 15.4). Every sentence the flows write is written to fit two lines at the card's
    narrowest width, 496 px.
    `box-sizing: border-box` makes `height` the whole row, border and padding included (MDN, "box-sizing").

    The left border is the ink of the state, 0.25rem wide: a second non-colour-only mark next to the sign and a line of the same colour as
    the text, so it stands against the page as the text stands against the row.
*/
.xaf-static-text[data-paleda-scanner-status] {
    display: -webkit-box;
    -webkit-box-orient: vertical;
    -webkit-line-clamp: 2;
    overflow: hidden;
    overflow-wrap: anywhere;
    box-sizing: border-box;
    height: 3.25rem;
    width: 100%;
    padding: 0.25rem 0.5rem;
    border-left: 0.25rem solid var(--paleda-scanner-status-neutral-ink);
    background-color: var(--paleda-scanner-status-neutral-bg);
    color: var(--paleda-scanner-status-neutral-ink);
    font-size: 1rem;
    line-height: 1.375rem;
}

.xaf-static-text[data-paleda-scanner-status="success"] {
    border-left-color: var(--paleda-scanner-status-success-ink);
    background-color: var(--paleda-scanner-status-success-bg);
    color: var(--paleda-scanner-status-success-ink);
}

.xaf-static-text[data-paleda-scanner-status="warning"] {
    border-left-color: var(--paleda-scanner-status-warning-ink);
    background-color: var(--paleda-scanner-status-warning-bg);
    color: var(--paleda-scanner-status-warning-ink);
}

.xaf-static-text[data-paleda-scanner-status="error"] {
    border-left-color: var(--paleda-scanner-status-error-ink);
    background-color: var(--paleda-scanner-status-error-bg);
    color: var(--paleda-scanner-status-error-ink);
}

/*
    The scanner tabs (WP12 S6; decision B30; UX review F6): ATT PLOCKA | PLOCKAT | INFO are tapped with a finger, so each header is a
    48 px target (WCAG 2.5.8 and Android 48 dp; the tabs were 40 px). ScannerTabCaptionController puts this class on each tab's header
    through DxFormLayoutTabPageModel.HeaderCssClass, the documented parameter (dxdocs, DxFormLayoutTabPage.HeaderCssClass), and the class
    lands on the clickable tab item itself (dxbl-tabs-item), so the whole 48 px is hit area. The colours of the active tab are not here: they
    are DevExpress' own SCSS variables set in the theme (paleda.theme*.scss), because they must change for every tab of Admin.

    `min-height` and not `height`: it "prevents the used value of the height property from becoming smaller than the value specified for
    min-height" (MDN, "min-height"), so a tab with a larger text size keeps growing as it does today and a smaller one is lifted to 48 px.
    The size mode that DevExpress ships does not reach it: SizeMode.Large gives a tab strip 44 px (dxdocs guard 2026-10-08, theme
    $dx-tab-size-lg 2.75rem), and $dx-tab-size would change every tab in Admin (the theme README: row heights are not increased without
    need). The caption stays in the middle of the taller tab with a flex row (MDN, "align-items").
*/
.paleda-scanner-tab {
    min-height: 48px;
    align-items: center;
}

/*
    The quantity field's −/+ buttons (WP4, B13; WP4b F12): at least 48 x 48 px, enabled or not. ConfigureScannerSpinEdit gives the
    editor DevExpress' SizeMode.Large and puts paleda-scanner-spin on its root, and AddScannerQuantityButtons gives it two custom
    command buttons, − then + (XAF's NumericPropertyEditor.Buttons; DxSpinButtons cannot reverse its up and down buttons) — the
    component-API half. The buttons are plain <button> elements inside that root (aria-label "Minska antalet med 1" / "Öka antalet
    med 1", and the clear button), so the rule names an HTML element and Paleda's own class and nothing of DevExpress'. min-width and min-height, not width and height: a floor, as above (MDN, "min-width": it "prevents the
    used value of the width property from becoming smaller than the value specified for min-width"). The selector matches
    a disabled button as well, which is the point: a button must not grow under the thumb when it becomes enabled.
*/
.paleda-scanner-spin button {
    min-width: 48px;
    min-height: 48px;
}

/*
    OK and Avbryt of a scanner popup (the UX review of #1821, one mechanism since #1829; the pickers dispatch and confirm on the
    SM-X210): at least 48 px tall, the same floor as the scanner tabs and the quantity buttons above (WCAG 2.5.8 and Android 48 dp).
    XAF draws the DialogController's two buttons in the popup's footer, and ScannerPopupFooterController puts this class on that footer
    through DxPopupModel.FooterCssClass, the documented parameter (dxdocs, DxPopupBase.FooterCssClass), so only a scanner popup is
    taller; the OK and Avbryt of every other popup in Admin are the theme's. A popup takes part by its object implementing
    IScannerPopupObject: the Utleverans wizard and every ScannerConfirmationPopup confirmation (Spara EAN, Avsluta plockningen, brist).
    The rule names the class and the HTML element, nothing of DevExpress': the buttons are plain <button> elements in the footer.
    `min-height`, not `height`: a floor, as above (MDN, "min-height"): it keeps the used height from becoming smaller than 48 px and
    leaves a button with a larger text size to grow.
*/
.paleda-scanner-popup-footer button {
    min-height: 48px;
}

/*
    The button bar of the scanner screens (N2C.XAF.Editors.DomainActions; #1531 WP9 S2, so far the picking view). The
    bar floors every button at a touch target, a disabled one too (TouchTargetMode="Enforce" in Model.xafml), and the
    size of that floor is one custom property the package documents for exactly this (DomainActionLayout.cs,
    TouchTargetVariableName "--n2c-domain-action-touch-target", default 2.75rem = 44 px, 3.25rem under xaf-size-l;
    the min-width variable defaults to it). 48 px is what the SM-X210 needs (WCAG 2.5.8/2.5.5, Android 48 dp), so the
    scanner bars re-point the variable: one declaration against the bar's own, named attribute, no `dxbl-*` selector and
    no `!important`.

    Why this wins without either (checked against MDN 2026-10-06): the package keeps its default in the cascade layer
    `n2c-domain-actions`, and an unlayered declaration beats a layered one whatever its specificity or position
    (MDN, "@layer"). It is set on the bar's root, the element that also carries the package's default and its
    `--n2c-domain-action-min-width: var(--n2c-domain-action-touch-target)`, so the floor on both axes follows. Custom
    properties inherit (MDN, "Using CSS custom properties"), so the buttons inside the bar read it. `data-domain-action-bar`
    is the package's `BarNameAttributeName`, written from BarName="scanner" in the model; a `data-*` attribute value is
    matched exactly and case-sensitively (MDN, "Attribute selectors").

    The `.paleda-scanner-action` rules above are the older recipe; since #1612 (S3-S5) they carry only Bokför, the one
    in-form button the goods receipt kept.
*/
[data-domain-action-bar="scanner"] {
    --n2c-domain-action-touch-target: 48px;
}

/*
    The right-hand group of the bar. The package positions a button with a class (DomainActionLayout.SlotCssClass:
    DomainActionSlot.End is `n2c-domain-action-slot-end`, which the package's own rule turns into `margin-left: auto`), but
    that rule sits inside its cascade layer, and an unlayered rule of the theme beats a layered one whatever its specificity
    (MDN, "@layer"). Measured 2026-10-06 with the Fluent theme in the picking view: the class is on the button and the
    computed `margin-left` is 0px, so "Mer" and "Avsluta plockning" sat right after the first button instead of at the end of
    the row. The same declaration, unlayered and scoped to the scanner bar, gives the class its meaning again: the free space
    goes in front of the first button of the right-hand group and the buttons after it follow (the builder gives
    Slot.End to that one button only). It names the package's public class, not a `dxbl-*` one.

    The second selector is for the drop-down: the package puts the slot class on the <button> inside the drop-down's host,
    and the host, not the button, is the flex item of the bar, so a margin on the button has no free space to take (measured
    2026-10-06: the class on "Mer", computed margin-left 0px, the position unchanged although the unlayered rule matched).
    `:has()` (MDN, ":has()", Baseline 2023) selects the bar's direct child that holds the slotted element, whatever tag
    DevExpress gives the host, so no `dxbl-*` name is needed. A browser without `:has()` drops a whole rule that contains it
    (MDN), so it is a rule of its own and the plain one above keeps working. Reported upstream as a gap in N2C.XAF.Editors.DomainActions:
    the slot margin should land on the flex item, and not lose to the theme's own reset.
*/
[data-domain-action-bar="scanner"] > .n2c-domain-action-slot-end {
    margin-left: auto;
}

[data-domain-action-bar="scanner"] > :has(> .n2c-domain-action-slot-end) {
    margin-left: auto;
}

/*
    Room in front of the button that cannot be taken back (WP12 S5; decisions B28 and B29; UX review F11). "Avsluta plockning" completes the
    order, makes the delivery note and mails it to the customer, and sat 8 px (1.5 mm) after "Mer", a menu: a thumb aiming for the menu hit
    the wrong target. 44 px is 8 mm, the distance the review asks for between a menu and an act that cannot be undone (Microsoft's 9 mm
    target, MIT Touch Lab's 8 to 10 mm fingertip). The bar's own gap is 8 px (--n2c-domain-action-gap) between every button, so 36 px of margin
    on this one button makes the 44 px, and the margin and the gap add: in a flex container the margins of an item are outside the
    gap between items (MDN, "gap" and "margin"; a margin is not collapsed in a flex formatting context, MDN, "Mastering margin collapsing").

    ScannerActionBar.ForPicking gives the button this class through DomainActionButtonDefinition.CssClass, a documented parameter; the
    package renders it on the <button>, which is a direct child of the bar. The "Mer" menu's free space ("margin-left: auto" above) stays in
    front of "Mer": free space goes there and the finish button follows it at a fixed distance. Goods receipt's "Bokför" has a slot of its
    own and does not get the class: a margin on the element that carries margin-left: auto would take the auto margin away (same specificity,
    the later rule wins).
*/
[data-domain-action-bar="scanner"] > .paleda-scanner-action-finish {
    margin-inline-start: 36px;
}

body {
    /* Brand colours belong to the shared theme (paleda.se.Theming/wwwroot/paleda.theme.css).
       These aliases only forward them, so no app can drift to a colour of its own. The literal
       fallbacks apply when a non-Paleda DevExpress theme is selected in Admin. */
    --paleda-background-color: var(--paleda-color-primary, #B3BB7F);
    --paleda-secondary-background-color: var(--paleda-color-surface-muted, #E9ECEF);
    --paleda-font-color: var(--paleda-color-text, #212529);
    --paleda-font-color-grey: var(--paleda-color-text-muted, rgba(0,0,0,50%));
}

html, body {
    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
    height: 100%;
    overflow: hidden;
}

.valid.modified:not([type=checkbox]) {
    outline: 1px solid #26b050;
}

.invalid {
    outline: 1px solid red;
}

.validation-message {
    color: red;
}

#blazor-error-ui {
    background: lightyellow;
    bottom: 0;
    box-shadow: 0 -1px 2px rgba(0, 0, 0, 0.2);
    display: none;
    left: 0;
    padding: 0.6rem 1.25rem 0.7rem 1.25rem;
    position: fixed;
    width: 100%;
    z-index: 1000;
}

    #blazor-error-ui .dismiss {
        cursor: pointer;
        position: absolute;
        right: 0.75rem;
        top: 0.5rem;
    }

.dx-card {
    box-shadow: 0 1px 3px rgba(0,0,0,.12), 0 1px 2px rgba(0,0,0,.24);
    border-radius: 4px;
    background-color: #fff;
    margin: 2px 2px 3px;
}

    .dx-card.wide-card {
        border-radius: 0;
        margin-left: 0;
        margin-right: 0;
        border-right: 0;
        border-left: 0;
    }

.paleda-button {
    background-color: var(--paleda-background-color);
    color: var(--black);
    border-color: #6c757d;
    border-radius: 0.25rem;
    padding: 0.375rem 0.75rem;
}

    .paleda-button:hover {
        background-color: var(--paleda-color-primary-hover, #8f9861) !important;
        color: #fff;
        border-color: #6c757d;
    }

    .paleda-button:active {
        background-color: var(--paleda-color-primary-active, #c5bd7b) !important;
        color: #fff;
        border-color: lightgrey !important;
        border-width: medium;
    }

    .paleda-button:focus {
        background-color: var(--paleda-color-primary-active, #c5bd7b) !important;
        color: #fff;
        border-color: lightgrey !important;
        border-width: medium;
    }

.dxbl-treeview-items-container {
    padding-top: 10px !important;
}

.dxbl-treeview-item .dxbl-treeview-item-content {
    height: 21px;
    margin-bottom: 0 !important;
    font-size: 13.3333px;
}

.dxbl-treeview-item .dxbl-treeview-item .dxbl-treeview-item-content {
    height: 18px;
    font-size: 13px;
}

@media (max-width: 450px) {
    dxbl-menu-item a.dxbl-btn {
        font-size: 14px;
        padding-top: 4px;
        padding-bottom: 4px;
    }
}

@media (min-width: 451px) {
    dxbl-menu-item a.dxbl-btn {
        font-size: 16px;
    }
}

a {
    font-size: 16px;
    text-decoration: none;
    color: var(--black);
}

/* Override link font-size in grids to inherit from grid cells */
.dxbl-grid a,
.dx-datagrid a {
    font-size: inherit;
}

p {
    font-size: 16px;
    color: var(--black);
    margin-bottom: 0;
}

.accordion-button {
    position: static !important;
}

@keyframes spin {
    0% {
        transform: rotate(0deg);
    }

    100% {
        transform: rotate(360deg);
    }
}

.loading-indicator-class {
    z-index: 1000;
    position: absolute;
    width: -webkit-fill-available;
    height: -webkit-fill-available;
    background-color: rgba(255, 255, 255, 0.8);
    display: flex;
    justify-content: center;
    align-items: center;
}

button.dxbl-btn.dxbl-menu-dropdown-item {
    font-size: medium;
}

.custom-menu-logo-container {
    padding-left: 3em;
}

@media only screen and (max-width: 1300px) {

    .custom-html-content td {
        vertical-align: baseline;
    }

    .custom-menu-logo-container {
        padding-left: 1em;
    }

    dxbl-menu-item .dxbl-btn {
        padding-left: 0.5rem;
        padding-right: 0.5rem;
    }

    .custom-html-content img {
        width: 100%;
        height: 100%;
    }
}

.sidebar {
    box-sizing: border-box !important;
    flex: 0 0 240px !important;
    min-width: 224px !important;
    width: 240px !important;
    max-width: 240px !important;
    overflow-x: hidden !important;
}

.sidebar .dxbl-navigation-item,
.sidebar .dxbl-treeview-item-content,
.sidebar .dxbl-accordion-group-header {
    max-width: 100%;
}

.sidebar .dxbl-navigation-item-text,
.sidebar .dxbl-treeview-item-text,
.sidebar .dxbl-accordion-group-header-text {
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
}

.sidebar .dxbl-scroll-viewer-vert-scroll-bar {
    visibility: hidden;
}

.main-ribbon-template {
    position: relative;
}

.main-ribbon-template > .header[role="banner"] {
    position: absolute !important;
    top: 0;
    right: 0;
    width: 0;
    height: 0 !important;
    min-height: 0 !important;
    padding: 0 !important;
    border: 0 !important;
    overflow: visible !important;
    background: transparent !important;
    z-index: 20;
}

.main-ribbon-template > .header[role="banner"] .header-left-side,
.main-ribbon-template > .header[role="banner"] .view-caption-root {
    display: none !important;
}

.main-ribbon-template > .header[role="banner"] .header-right-side,
.main-ribbon-template > .header[role="banner"] .header-right-side > .d-flex.ms-auto {
    height: 0 !important;
}

.main-ribbon-template > .header[role="banner"] .header-right-side > .d-flex.ms-auto {
    position: absolute !important;
    top: 70px;
    right: 12px;
    display: flex !important;
    align-items: center;
    gap: 6px;
}

.main-ribbon-template > .main-ribbon {
    padding-right: 108px;
}

/* The ribbon's hamburger keeps XAF's look after RibbonNavigationToggleController renames its class:
   XAF writes this rule for .xaf-ribbon-hamburger-tab (no hover/focus overlay on the button). */
.dxbl-ribbon .paleda-ribbon-navigation-toggle::after {
    content: none !important;
}


/*salkjdlkasjdkad*/

/* Scanner lists' image link and the larger image (#575; Peter, Blad52; shared by picking, goods receipt and inventory count since
   #1681; the link's classes are product-image-link*, flow-neutral since #1698). These rules were written here when Admin linked no scoped-CSS bundle (found 2026-09-15). Admin has linked
   paleda.se.Blazor.Server.styles.css since 2026-10-06 (#1536, Pages/_Host.cshtml:73), so a .razor.css next to ProductImageLink
   (Features/ScannerLayout) would take effect now; the rules and the picking-product-image* class names have not been moved
   (docs/development/agents/no-inline-css.md owns what a .razor.css does in Admin). */
.product-image-link {
    display: inline-flex;
}

/* The link's hit box is at least 24 x 24 CSS px (WCAG 2.5.8 Target Size (Minimum), met by size, not by the spacing exception; #1698)
   while its row stays at text height. DxButton has no setting for this (dxdocs verdict: hand-rolled required; only SizeMode and CssClass,
   "DxButton" / "Size Modes"), so the floor is ours. The selector hangs on our own wrapper and class, not on DevExpress' internal .dxbl-btn,
   with the same specificity (two classes) as the DevExpress rule it overrides; if a DevExpress upgrade makes the theme win, re-check
   (devexpress-blazor-css-api: internal class names change between versions).
   The box is taller than the text line, so the block margin takes the difference back out of the flow: a negative margin "places it closer"
   (MDN margin-bottom). 1lh is the computed line height of this element (MDN <length> "lh"), so the margin is (line box - 24px) / 2 on both
   sides, which is -4px at the 16px line height measured with the tablet's html 110%; the row height was 30.8px with and without this rule. */
.product-image-link > .product-image-link__button {
    padding: 0;
    min-inline-size: 24px;
    min-block-size: 24px;
    margin-block: calc((1lh - 24px) / 2);
    justify-content: center;
}

.picking-product-image {
    display: flex;
    flex-direction: column;
    gap: 0.75rem;
}

.picking-product-image__image {
    display: block;
    width: 100%;
    max-height: 60vh;
    object-fit: contain;
}

.picking-product-image__facts {
    display: grid;
    grid-template-columns: max-content 1fr;
    gap: 0.25rem 1rem;
    margin: 0;
}

.picking-product-image__facts dd {
    margin: 0;
}

/*
 * #1742 - the line at the top of a customer, supplier or article that has not reached Visma:
 * "Inte skickad till Visma: <orsak> Gör så här: <åtgärd>".
 *
 * Hooked on by the layout group's CustomCSSClassName in Model.xafml (IModelViewLayoutElementBlazor, dxdocs
 * "Customize UI Elements Using CSS"), so it is a class and not a style attribute. The colours are Bootstrap's
 * warning tokens, which the Paleda theme already carries, so no colour is invented here. The text is in a <textarea>
 * (the read-only multi-line editor), a plain HTML element, not a DevExpress class.
 */
.paleda-visma-status-line {
	padding: 0 0 0.5rem 0;
}

.paleda-visma-status-line textarea {
	background-color: var(--bs-warning-bg-subtle, #fff3cd);
	color: var(--bs-warning-text-emphasis, #664d03);
	border: 1px solid var(--bs-warning-border-subtle, #ffe69c);
	font-weight: 600;
}

/*
 * No resize grip: the line is read, never sized. The theme sets `resize: vertical` with the selector
 * `.dxbl-text-edit.dxbl-memo-edit > .dxbl-v-resize` (specificity 0,3,0), which beats the rule above (0,1,1), so this one repeats
 * the hook class until it outweighs it (MDN, "Specificity": a repeated class adds to the weight) instead of naming
 * the component's internal classes or using !important.
 */
.paleda-visma-status-line.paleda-visma-status-line.paleda-visma-status-line textarea {
	resize: none;
}
