From 791cb46b6476c0a4fffa45405dc049c42e23a257 Mon Sep 17 00:00:00 2001 From: Linductor-alkaid <202200171251@mail.sdu.edu.cn> Date: Fri, 9 Oct 2026 11:08:17 +0800 Subject: [PATCH] fix(components): drop slider hit zIndex that outranked host overlays The slider's internal ".hit" area carried zIndex(10). Hit testing and painting traverse ordered children sorted by subtreeMaxZIndex (dsl.h rebuildOrderedElements), so any page containing a slider had its subtree sort key raised to 10: root-level overlays composed later at the default z=0 (scrim, dropdown menus) were sorted below the page and lost both hit priority and paint order - clicks fell through to the page underneath. The hit area keeps its input priority via composition order (last child of the slider stack is hit-tested first in reversed order), so the zIndex is unnecessary. Drop it and add a regression test asserting the page subtree stays at z=0, the overlay keeps its compose position, and the hit area remains the topmost ordered child of the slider stack. Reproduced end-to-end in a host app (node editor with sliders and root-level dropdown overlays): with the old zIndex, clicks on the dropdown scrim/items landed on the canvas input area; without it, overlays receive clicks as expected. --- components/slider.h | 8 +- tests/unit/slider_subtree_z_order.cpp | 110 ++++++++++++++++++++++++++ 2 files changed, 117 insertions(+), 1 deletion(-) create mode 100644 tests/unit/slider_subtree_z_order.cpp diff --git a/components/slider.h b/components/slider.h index 63e8f1f8..27913477 100644 --- a/components/slider.h +++ b/components/slider.h @@ -89,12 +89,18 @@ class SliderBuilder { .sliderKnobFrom(id_) .build(); + // Hit area keeps input priority via composition order (last + // child of this stack): ordered children are hit-tested in + // reverse, so no zIndex is needed here. A raised internal + // zIndex inflates this subtree's max z-index and makes the + // whole slider outrank host-level siblings (e.g. root-level + // overlays/scrim/menus composed at default z=0), breaking + // their hit testing and paint order. ui_.rect(id_ + ".hit") .size(width_, height_) .states(theme::color(0.0f, 0.0f, 0.0f, 0.0f), theme::color(0.0f, 0.0f, 0.0f, 0.0f), theme::color(0.0f, 0.0f, 0.0f, 0.0f)) - .zIndex(10) .interactive() .sliderInputFrom(id_) .build(); diff --git a/tests/unit/slider_subtree_z_order.cpp b/tests/unit/slider_subtree_z_order.cpp new file mode 100644 index 00000000..28adcce5 --- /dev/null +++ b/tests/unit/slider_subtree_z_order.cpp @@ -0,0 +1,110 @@ +// Regression: a slider must not inflate its subtree's max z-index. +// +// Hit testing and painting traverse ordered children sorted by +// subtreeMaxZIndex (core/dsl.h rebuildOrderedElements). The slider's internal +// ".hit" area used to carry zIndex(10), which raised any page containing a +// slider above host-level overlays composed later at the default z=0 (scrim, +// dropdown menus): the overlays lost hit priority and clicks fell through to +// the page. The hit area keeps its input priority via composition order +// (last child of the slider stack), so no zIndex is needed. +// +// Assertions: +// 1. A page containing a slider has subtreeMaxZIndex == 0. +// 2. An overlay composed after the page stays after it in the root's ordered +// children (stable order for equal keys), so reversed hit-testing reaches +// the overlay first. +// 3. The slider's ".hit" remains the last ordered child of the slider stack, +// i.e. it is still hit-tested before track/fill/knob. + +#include "components/slider.h" + +#include "core/dsl.h" + +#include +#include + +namespace { + +bool run() { + core::dsl::Ui ui; + ui.begin("slider_z_order"); + ui.stack("root") + .size(400.0f, 300.0f) + .content([&] { + ui.stack("page") + .size(400.0f, 200.0f) + .content([&] { + components::slider(ui, "page.slider") + .size(120.0f, 20.0f) + .value(0.5f) + .build(); + }) + .build(); + ui.rect("overlay") + .position(0.0f, 0.0f) + .size(400.0f, 300.0f) + .onClick([] {}) + .build(); + }) + .build(); + ui.layout(400.0f, 300.0f); + + if (ui.roots().size() != 1) { + std::cerr << "expected exactly one root\n"; + return false; + } + const core::dsl::Element& root = *ui.roots().front(); + const core::dsl::Element* page = ui.find("page"); + const core::dsl::Element* overlay = ui.find("overlay"); + const core::dsl::Element* slider = ui.find("page.slider"); + if (page == nullptr || overlay == nullptr || slider == nullptr) { + std::cerr << "missing page/overlay/slider elements\n"; + return false; + } + + if (page->subtreeMaxZIndex != 0) { + std::cerr << "slider inflates page subtreeMaxZIndex to " + << page->subtreeMaxZIndex << "\n"; + return false; + } + + std::size_t pageIndex = root.orderedChildren.size(); + std::size_t overlayIndex = root.orderedChildren.size(); + for (std::size_t index = 0; index < root.orderedChildren.size(); ++index) { + const core::dsl::Element* child = root.orderedChildren[index]; + if (child == page) { + pageIndex = index; + } else if (child == overlay) { + overlayIndex = index; + } + } + if (pageIndex >= root.orderedChildren.size() || + overlayIndex >= root.orderedChildren.size()) { + std::cerr << "page/overlay missing from root ordered children\n"; + return false; + } + if (overlayIndex < pageIndex) { + std::cerr << "overlay sorted before the page it overlays\n"; + return false; + } + + const std::vector& sliderChildren = + slider->orderedChildren; + const core::dsl::Element* sliderHit = ui.find("page.slider.hit"); + if (sliderChildren.empty() || sliderHit == nullptr || + sliderChildren.back() != sliderHit) { + std::cerr << "slider hit area is not the topmost ordered child\n"; + return false; + } + return true; +} + +} // namespace + +int main() { + const bool passed = run(); + if (!passed) { + std::cerr << "slider subtree z-order regression failed\n"; + } + return passed ? 0 : 1; +}