Google GitGoogle Git
Sign in
skia/external/github.com/rive-app/rive-cpp/25db4792fadc1d26b9deed73e6e865122ff1ef95/./tests/unit_tests/runtime/focus_test.cpp
blob: cd691e3ac1a6b90b162c45d4afa50d1fc533f353 [file]
#include <catch.hpp>
#include "rive/animation/focus_action_clear.hpp"
#include "rive/animation/focus_action_traversal.hpp"
#include "rive/animation/transition_condition_op.hpp"
#include "rive/animation/transition_focus_condition.hpp"
#include "rive/animation/transition_property_component_comparator.hpp"
#include "rive/animation/listener_invocation.hpp"
#include "rive/animation/nested_state_machine.hpp"
#include "rive/animation/state_machine.hpp"
#include "rive/animation/state_machine_instance.hpp"
#include "rive/artboard.hpp"
#include "rive/artboard_component_list.hpp"
#include "rive/focus_data.hpp"
#include "rive/node.hpp"
#include "rive/input/focus_node.hpp"
#include "rive/input/focus_manager.hpp"
#include "utils/no_op_factory.hpp"
#include "utils/serializing_factory.hpp"
#include "rive_file_reader.hpp"
#include "rive/nested_artboard.hpp"
#include "rive/viewmodel/viewmodel_instance_artboard.hpp"
#include "rive/viewmodel/viewmodel_instance_boolean.hpp"
#include "rive/viewmodel/viewmodel_instance_number.hpp"
#include "rive/animation/listener_invocation.hpp"
#include "rive/input/gamepad_batch.hpp"
#include "rive/input/gamepad_snapshot.hpp"
#include "rive/input/standard_gamepad.hpp"
#include <cstring>
namespace rive
{
namespace
{
// A root artboard normally gets its FocusManager from File::instanceArtboard.
// Tests that build an Artboard directly and instance it skip that path, so
// give the instance a manager explicitly — otherwise focusManager() is null.
std::unique_ptr<ArtboardInstance> instanceWithFocus(Artboard& artboard)
{
auto instance = artboard.instance();
instance->ensureFocusManager();
return instance;
}
// Minimal builder for the little-endian gamepad batch wire format documented
// in `gamepad_batch.cpp`, enough to connect a pad and press one button.
// gamepad_test.cpp has a fuller version for the parsing tests.
struct GamepadWire
{
std::vector<uint8_t> buf;
void u8(uint8_t v) { buf.push_back(v); }
void u32(uint32_t v)
{
buf.push_back(static_cast<uint8_t>(v));
buf.push_back(static_cast<uint8_t>(v >> 8));
buf.push_back(static_cast<uint8_t>(v >> 16));
buf.push_back(static_cast<uint8_t>(v >> 24));
}
void f32(float v)
{
uint32_t bits;
std::memcpy(&bits, &v, sizeof(bits));
u32(bits);
}
GamepadWire() { u32(kGamepadBatchWireVersion); }
// A standard-mapped pad: 17 buttons, 4 axes, all at rest.
void connected(int32_t deviceId)
{
u8(static_cast<uint8_t>(GamepadRecordType::connected));
u32(static_cast<uint32_t>(deviceId));
u8(0); // mapping: standard
u8(17); // buttons
u8(4); // axes
u8(0); // padding to align the float arrays
for (int i = 0; i < 17 + 4; i++)
{
f32(0.f);
}
}
void button(int32_t deviceId, StandardGamepadButton index, float value)
{
u8(static_cast<uint8_t>(GamepadRecordType::update));
u32(static_cast<uint32_t>(deviceId));
u8(1); // nChanges
u8(static_cast<uint8_t>(GamepadInputChangeKind::button));
u8(static_cast<uint8_t>(index));
f32(value);
}
};
} // namespace
// Mock Focusable for testing
class MockFocusable : public Focusable
{
public:
int keyInputCount = 0;
int textInputCount = 0;
int gamepadDispatchCount = 0;
int focusedCount = 0;
int blurredCount = 0;
std::string lastText;
Key lastKey = Key::a;
bool returnValue = false;
bool keyInput(Key key,
KeyModifiers modifiers,
bool isPressed,
bool isRepeat) override
{
keyInputCount++;
lastKey = key;
return returnValue;
}
bool textInput(const std::string& text) override
{
textInputCount++;
lastText = text;
return returnValue;
}
bool gamepadDispatch(const ListenerInvocation&,
ScriptedDrawable** = nullptr) override
{
gamepadDispatchCount++;
return returnValue;
}
void focused() override { focusedCount++; }
void blurred() override { blurredCount++; }
bool eligible = true;
bool isEligibleForFocusTraversal() const override { return eligible; }
// Lets a test say which artboard tree a node belongs to, for the
// root-scoped focus calls. Null (the default) means "not attributable to
// any root", which is how a host-created FocusNode reads.
Artboard* artboard = nullptr;
Artboard* focusableArtboard() const override { return artboard; }
};
// =============================================================================
// FocusNode Tests
// =============================================================================
TEST_CASE("FocusNode default properties", "[FocusNode]")
{
auto node = make_rcp<FocusNode>();
CHECK(node->canFocus() == true);
CHECK(node->canTouch() == true);
CHECK(node->canTraverse() == true);
CHECK(node->tabIndex() == 0);
CHECK(node->edgeBehavior() == EdgeBehavior::parentScope);
CHECK(node->focusable() == nullptr);
CHECK(node->parent() == nullptr);
CHECK(node->children().empty());
CHECK(node->isScope() == false);
CHECK(node->hasFocus() == false);
CHECK(node->manager() == nullptr);
}
TEST_CASE("FocusNode property setters", "[FocusNode]")
{
auto node = make_rcp<FocusNode>();
node->canFocus(false);
CHECK(node->canFocus() == false);
node->canTouch(false);
CHECK(node->canTouch() == false);
node->canTraverse(false);
CHECK(node->canTraverse() == false);
node->tabIndex(42);
CHECK(node->tabIndex() == 42);
node->edgeBehavior(EdgeBehavior::closedLoop);
CHECK(node->edgeBehavior() == EdgeBehavior::closedLoop);
node->edgeBehavior(EdgeBehavior::stop);
CHECK(node->edgeBehavior() == EdgeBehavior::stop);
}
TEST_CASE("FocusNode with Focusable", "[FocusNode]")
{
MockFocusable focusable;
auto node = make_rcp<FocusNode>(&focusable);
CHECK(node->focusable() == &focusable);
// Test input delegation
node->keyInput(Key::a, KeyModifiers::none, true, false);
CHECK(focusable.keyInputCount == 1);
CHECK(focusable.lastKey == Key::a);
node->textInput("hello");
CHECK(focusable.textInputCount == 1);
CHECK(focusable.lastText == "hello");
// Test lifecycle delegation
node->focused();
CHECK(focusable.focusedCount == 1);
node->blurred();
CHECK(focusable.blurredCount == 1);
}
TEST_CASE("FocusNode without Focusable doesn't crash", "[FocusNode]")
{
auto node = make_rcp<FocusNode>();
// These should not crash
CHECK(node->keyInput(Key::a, KeyModifiers::none, true, false) == false);
CHECK(node->textInput("hello") == false);
node->focused();
node->blurred();
}
TEST_CASE("FocusNode setFocusable/clearFocusable", "[FocusNode]")
{
MockFocusable focusable;
auto node = make_rcp<FocusNode>();
CHECK(node->focusable() == nullptr);
node->setFocusable(&focusable);
CHECK(node->focusable() == &focusable);
node->clearFocusable();
CHECK(node->focusable() == nullptr);
}
TEST_CASE("a node that loses its Focusable stops being a focus stop",
"[FocusNode]")
{
// ~FocusData clears its node's Focusable. If that node is still in the
// tree (a detach that was never paired with a re-add, a manager torn down
// around it), nothing is left that could report it collapsed or hidden —
// so it must not stay eligible, or it becomes a focus stop that no
// visibility change can ever remove.
FocusManager manager;
MockFocusable focusable;
auto live = make_rcp<FocusNode>(&focusable);
auto defunct = make_rcp<FocusNode>(&focusable);
manager.addChild(nullptr, live);
manager.addChild(nullptr, defunct);
// Both are reachable while backed.
CHECK(manager.getTraversableNodes(nullptr).size() == 2);
defunct->clearFocusable();
CHECK(defunct->hadFocusable());
auto traversable = manager.getTraversableNodes(nullptr);
REQUIRE(traversable.size() == 1);
CHECK(traversable[0] == live.get());
// It can't be focused programmatically either.
manager.setFocus(defunct);
CHECK(manager.primaryFocusPtr() != defunct.get());
}
TEST_CASE("a node that never had a Focusable stays focusable", "[FocusNode]")
{
// Hosts create bare FocusNodes as focus targets through this API; they
// have no Focusable to consult and must keep working. Only a node that
// *lost* its backing is treated as defunct.
FocusManager manager;
auto external = make_rcp<FocusNode>();
CHECK_FALSE(external->hadFocusable());
manager.addChild(nullptr, external);
auto traversable = manager.getTraversableNodes(nullptr);
REQUIRE(traversable.size() == 1);
CHECK(traversable[0] == external.get());
manager.setFocus(external);
CHECK(manager.primaryFocusPtr() == external.get());
}
TEST_CASE("traversal still descends through a defunct node to live children",
"[FocusNode]")
{
// A defunct node stops being a stop, but its children may still be live —
// traversal must keep reaching them rather than skipping the subtree.
FocusManager manager;
MockFocusable focusable;
auto defunctScope = make_rcp<FocusNode>(&focusable);
auto liveChild = make_rcp<FocusNode>(&focusable);
manager.addChild(nullptr, defunctScope);
manager.addChild(defunctScope, liveChild);
defunctScope->clearFocusable();
// Tab traversal walks through the defunct scope and lands on the child.
CHECK(manager.focusNext());
CHECK(manager.primaryFocusPtr() == liveChild.get());
// Note: setFocus() aimed directly at the defunct node stays a no-op. Its
// descend-to-first-leaf step is gated on the requested target being
// eligible, so an ineligible target is rejected outright — the same as any
// other collapsed or hidden target.
manager.clearFocus();
manager.setFocus(defunctScope);
CHECK(manager.primaryFocusPtr() == nullptr);
}
TEST_CASE("FocusNode hierarchy", "[FocusNode]")
{
auto parent = make_rcp<FocusNode>();
auto child1 = make_rcp<FocusNode>();
auto child2 = make_rcp<FocusNode>();
parent->addChild(child1);
parent->addChild(child2);
CHECK(child1->parent() == parent.get());
CHECK(child2->parent() == parent.get());
CHECK(parent->children().size() == 2);
CHECK(parent->isScope() == true);
parent->removeChild(child1);
CHECK(child1->parent() == nullptr);
CHECK(parent->children().size() == 1);
}
// =============================================================================
// FocusManager Tests
// =============================================================================
TEST_CASE("adding a node claims its whole subtree for the manager",
"[FocusManager]")
{
// detachChild clears the manager pointer across the entire subtree, so
// addChild has to restore it across the entire subtree too. A host that
// rebuilds by detaching and re-adding a set of nodes (the Dart editor does
// exactly this) never touches the descendants underneath them; if those
// kept a null manager, their FocusData could no longer remove them from
// the tree when it died, stranding them here forever.
FocusManager manager;
MockFocusable focusable;
auto parent = make_rcp<FocusNode>(&focusable);
auto child = make_rcp<FocusNode>(&focusable);
auto grandchild = make_rcp<FocusNode>(&focusable);
manager.addChild(nullptr, parent);
manager.addChild(parent, child);
manager.addChild(child, grandchild);
CHECK(parent->manager() == &manager);
CHECK(child->manager() == &manager);
CHECK(grandchild->manager() == &manager);
// Detach only the top of the subtree — descendants come along untouched.
manager.detachChild(parent);
CHECK(parent->manager() == nullptr);
CHECK(child->manager() == nullptr);
CHECK(grandchild->manager() == nullptr);
CHECK(parent->children().size() == 1);
// Re-adding just the top has to re-claim everything beneath it.
manager.addChild(nullptr, parent);
CHECK(parent->manager() == &manager);
CHECK(child->manager() == &manager);
CHECK(grandchild->manager() == &manager);
}
TEST_CASE("a rebuild that misses a node still lets its FocusData clean up",
"[FocusManager]")
{
// End-to-end shape of the editor's rebuildFocusHierarchy: collect a subset
// of the tree, detach each collected node, re-add it. A node sitting under
// a collected node that the collection itself missed used to come out of
// that cycle with no manager pointer — and then its FocusData could never
// remove it, so it survived as an unbacked node that
// focusNodeEligibleForFocus treated as eligible: a focus stop nothing
// could take out.
FocusManager manager;
MockFocusable focusable;
auto root = make_rcp<FocusNode>(&focusable);
manager.addChild(nullptr, root);
{
FocusData missedByTheRebuild;
auto missedNode = missedByTheRebuild.focusNode();
manager.addChild(root, missedNode);
// The rebuild touches only `root`; `missedNode` is never collected.
manager.detachChild(root);
manager.addChild(nullptr, root);
CHECK(missedNode->manager() == &manager);
CHECK(root->children().size() == 1);
}
// The FocusData is gone, and so is its node — no unbacked leftover.
CHECK(root->children().empty());
// And even if one did survive, it must not be a focus stop.
CHECK(manager.getTraversableNodes(root.get()).empty());
}
TEST_CASE("a dying FocusData removes its node via an ancestor's manager",
"[FocusData]")
{
// A node can sit in a live tree while holding no manager pointer of its
// own. ~FocusData still has to take it out: left behind, it would keep a
// cleared Focusable and nothing could ever report it hidden.
FocusManager manager;
MockFocusable focusable;
auto scope = make_rcp<FocusNode>(&focusable);
manager.addChild(nullptr, scope);
REQUIRE(scope->manager() == &manager);
{
FocusData data;
auto node = data.focusNode();
// Parent it through FocusNode directly, which doesn't hand out a
// manager pointer — the same state a detach/re-add cycle used to
// leave descendants in.
scope->addChild(node);
REQUIRE(node->manager() == nullptr);
REQUIRE(scope->children().size() == 1);
manager.setFocus(node);
REQUIRE(manager.primaryFocusPtr() == node.get());
}
// Removed through the nearest registered ancestor, so focus is cleared
// too — not merely detached.
CHECK(scope->children().empty());
CHECK(manager.primaryFocusPtr() == nullptr);
}
TEST_CASE("a dying FocusData detaches its node when no manager is reachable",
"[FocusData]")
{
// Nothing in the chain is registered (a manager torn down around the
// subtree). There is no focus to clear, but the node still must not stay
// parented.
auto scope = make_rcp<FocusNode>();
{
FocusData data;
scope->addChild(data.focusNode());
REQUIRE(scope->children().size() == 1);
}
CHECK(scope->children().empty());
}
TEST_CASE("FocusManager basic focus operations", "[FocusManager]")
{
FocusManager manager;
MockFocusable focusable;
auto node = make_rcp<FocusNode>(&focusable);
CHECK(manager.primaryFocus() == nullptr);
manager.addChild(nullptr, node);
manager.setFocus(node);
CHECK(manager.primaryFocus() == node);
CHECK(manager.hasFocus(node) == true);
CHECK(manager.hasPrimaryFocus(node) == true);
CHECK(focusable.focusedCount == 1);
manager.clearFocus();
CHECK(manager.primaryFocus() == nullptr);
CHECK(focusable.blurredCount == 1);
}
// Focusable that can report live world bounds, like FocusData/TextInput do.
class MockBoundedFocusable : public MockFocusable
{
public:
bool hasBounds = true;
AABB liveBounds = AABB(10, 20, 110, 220);
bool worldBounds(AABB& outBounds) override
{
if (!hasBounds)
{
return false;
}
outBounds = liveBounds;
return true;
}
};
TEST_CASE("primaryFocusBounds prefers live focusable bounds over cached",
"[FocusManager]")
{
FocusManager manager;
MockBoundedFocusable focusable;
auto node = make_rcp<FocusNode>(&focusable);
manager.addChild(nullptr, node);
manager.setFocus(node);
// Stale bounds cached on the node by a previous update pass.
node->worldBounds(AABB(1, 2, 3, 4));
AABB bounds;
REQUIRE(manager.primaryFocusBounds(bounds) == true);
CHECK(bounds.minX == 10);
CHECK(bounds.minY == 20);
CHECK(bounds.maxX == 110);
CHECK(bounds.maxY == 220);
// When the focusable cannot compute, the cached bounds remain the
// fallback.
focusable.hasBounds = false;
REQUIRE(manager.primaryFocusBounds(bounds) == true);
CHECK(bounds.minX == 1);
CHECK(bounds.maxY == 4);
manager.clearFocus();
CHECK(manager.primaryFocusBounds(bounds) == false);
}
TEST_CASE("primaryFocusBounds uses cached bounds without a focusable",
"[FocusManager]")
{
// Externally-managed nodes (e.g. created over FFI by a host) have no
// focusable; their host pushes bounds into the node directly.
FocusManager manager;
auto node = make_rcp<FocusNode>();
manager.addChild(nullptr, node);
manager.setFocus(node);
AABB bounds;
CHECK(manager.primaryFocusBounds(bounds) == false);
node->worldBounds(AABB(5, 6, 7, 8));
REQUIRE(manager.primaryFocusBounds(bounds) == true);
CHECK(bounds.minX == 5);
CHECK(bounds.maxY == 8);
}
TEST_CASE("FocusManager focus change notifications", "[FocusManager]")
{
FocusManager manager;
MockFocusable focusable1, focusable2;
auto node1 = make_rcp<FocusNode>(&focusable1);
auto node2 = make_rcp<FocusNode>(&focusable2);
manager.addChild(nullptr, node1);
manager.addChild(nullptr, node2);
manager.setFocus(node1);
CHECK(focusable1.focusedCount == 1);
CHECK(focusable1.blurredCount == 0);
manager.setFocus(node2);
CHECK(focusable1.blurredCount == 1);
CHECK(focusable2.focusedCount == 1);
}
TEST_CASE("FocusManager respects canFocus", "[FocusManager]")
{
FocusManager manager;
auto node = make_rcp<FocusNode>();
node->canFocus(false);
manager.addChild(nullptr, node);
manager.setFocus(node);
CHECK(manager.primaryFocus() == nullptr);
}
TEST_CASE("FocusManager hierarchy", "[FocusManager]")
{
FocusManager manager;
auto parent = make_rcp<FocusNode>();
auto child1 = make_rcp<FocusNode>();
auto child2 = make_rcp<FocusNode>();
manager.addChild(nullptr, parent);
manager.addChild(parent, child1);
manager.addChild(parent, child2);
CHECK(parent->parent() == nullptr);
CHECK(child1->parent() == parent.get());
CHECK(child2->parent() == parent.get());
CHECK(parent->isScope() == true);
CHECK(child1->isScope() == false);
const auto& children = parent->children();
CHECK(children.size() == 2);
// Manager reference is set on all nodes
CHECK(parent->manager() == &manager);
CHECK(child1->manager() == &manager);
CHECK(child2->manager() == &manager);
}
TEST_CASE("FocusManager hasFocus with descendants", "[FocusManager]")
{
FocusManager manager;
auto parent = make_rcp<FocusNode>();
auto child = make_rcp<FocusNode>();
manager.addChild(nullptr, parent);
manager.addChild(parent, child);
manager.setFocus(child);
// Manager queries should work
CHECK(manager.hasFocus(parent) == true);
CHECK(manager.hasPrimaryFocus(parent) == false);
CHECK(manager.hasFocus(child) == true);
CHECK(manager.hasPrimaryFocus(child) == true);
// Node's hasFocus flag should be set for focused node and ancestors
CHECK(parent->hasFocus() == true);
CHECK(child->hasFocus() == true);
}
TEST_CASE("FocusManager removeChild clears focus", "[FocusManager]")
{
FocusManager manager;
MockFocusable focusable;
auto node = make_rcp<FocusNode>(&focusable);
manager.addChild(nullptr, node);
manager.setFocus(node);
CHECK(manager.primaryFocus() == node);
manager.removeChild(node);
CHECK(manager.primaryFocus() == nullptr);
CHECK(focusable.blurredCount == 1);
}
TEST_CASE(
"List row reparent: FocusNode removeFromParent preserves primary focus",
"[FocusManager][list]")
{
FocusManager manager;
MockFocusable fLeaf;
auto scope = make_rcp<FocusNode>(nullptr);
scope->canFocus(true);
scope->canTraverse(true);
auto row = make_rcp<FocusNode>(nullptr);
row->canFocus(true);
row->canTraverse(true);
auto leaf = make_rcp<FocusNode>(&fLeaf);
manager.addChild(nullptr, scope);
manager.addChild(scope, row);
manager.addChild(row, leaf);
manager.setFocus(leaf);
CHECK(manager.primaryFocus() == leaf);
row->removeFromParent();
CHECK(manager.primaryFocus() == leaf);
manager.addChild(scope, row, 0);
CHECK(manager.primaryFocus() == leaf);
CHECK(fLeaf.blurredCount == 0);
}
TEST_CASE("hasFocusableContent invalidates when canFocus toggles after caching",
"[FocusManager]")
{
FocusManager manager;
// Both structural: no focusable backing, canFocus=false.
auto scope = FocusNode::makeStructuralScope();
auto child = FocusNode::makeStructuralScope();
manager.addChild(nullptr, scope);
manager.addChild(scope, child);
// Compute + cache the "no focusable content" answer.
CHECK(manager.hasFocusableContent() == false);
// A canFocus flip on a cached tree must be reflected.
child->canFocus(true);
CHECK(manager.hasFocusableContent() == true);
child->canFocus(false);
CHECK(manager.hasFocusableContent() == false);
}
TEST_CASE(
"hasFocusableContent invalidates when focusable backing toggles after "
"caching",
"[FocusManager]")
{
FocusManager manager;
MockFocusable focusable;
auto scope = FocusNode::makeStructuralScope();
auto child = FocusNode::makeStructuralScope();
manager.addChild(nullptr, scope);
manager.addChild(scope, child);
CHECK(manager.hasFocusableContent() == false);
// Gaining a focusable backing counts even while canFocus stays false.
child->setFocusable(&focusable);
CHECK(manager.hasFocusableContent() == true);
child->clearFocusable();
CHECK(manager.hasFocusableContent() == false);
}
TEST_CASE("hasFocusableContent invalidates when a backed node is added then "
"removed",
"[FocusManager]")
{
// Mirrors a data-bound nested-artboard swap: a structural scope gains a
// focusable node on swap-in, then loses it on swap-out.
FocusManager manager;
MockFocusable focusable;
auto scope = FocusNode::makeStructuralScope();
manager.addChild(nullptr, scope);
CHECK(manager.hasFocusableContent() == false);
auto backed = make_rcp<FocusNode>(&focusable);
manager.addChild(scope, backed);
CHECK(manager.hasFocusableContent() == true);
manager.removeChild(backed);
CHECK(manager.hasFocusableContent() == false);
}
TEST_CASE("hasFocusableContent invalidates when the last root is erased",
"[FocusManager]")
{
// eraseRoot is the only invalidation for a root removed while migrating to
// another manager; exercise it directly via a re-parent to a second
// manager, which erases the node from the first manager's root list.
FocusManager first;
FocusManager second;
auto node = make_rcp<FocusNode>();
node->canFocus(true);
first.addChild(nullptr, node);
CHECK(first.hasFocusableContent() == true);
// Migrating the root out of `first` empties its tree.
second.addChild(nullptr, node);
CHECK(first.hasFocusableContent() == false);
CHECK(second.hasFocusableContent() == true);
}
TEST_CASE("FocusManager input routing", "[FocusManager]")
{
FocusManager manager;
MockFocusable focusable;
focusable.returnValue = true;
auto node = make_rcp<FocusNode>(&focusable);
manager.addChild(nullptr, node);
// No focus, input not handled
CHECK(manager.keyInput(Key::a, KeyModifiers::none, true, false) == false);
CHECK(manager.textInput("hello") == false);
GamepadSnapshot snap{};
snap.deviceId = 1;
snap.buttonMask = 1;
CHECK(manager.gamepadDispatch(ListenerInvocation::gamepadConnected(snap)) ==
false);
manager.setFocus(node);
// With focus, input is routed
CHECK(manager.keyInput(Key::b, KeyModifiers::none, true, false) == true);
CHECK(focusable.keyInputCount == 1);
CHECK(focusable.lastKey == Key::b);
CHECK(manager.textInput("world") == true);
CHECK(focusable.textInputCount == 1);
CHECK(focusable.lastText == "world");
CHECK(manager.gamepadDispatch(ListenerInvocation::gamepadConnected(snap)) ==
true);
CHECK(focusable.gamepadDispatchCount == 1);
}
TEST_CASE("FocusManager traversal basic", "[FocusManager]")
{
FocusManager manager;
MockFocusable f1, f2, f3;
auto node1 = make_rcp<FocusNode>(&f1);
auto node2 = make_rcp<FocusNode>(&f2);
auto node3 = make_rcp<FocusNode>(&f3);
manager.addChild(nullptr, node1);
manager.addChild(nullptr, node2);
manager.addChild(nullptr, node3);
// Focus first node
manager.setFocus(node1);
CHECK(manager.primaryFocus() == node1);
// Navigate forward
manager.focusNext();
CHECK(manager.primaryFocus() == node2);
manager.focusNext();
CHECK(manager.primaryFocus() == node3);
// Navigate backward
manager.focusPrevious();
CHECK(manager.primaryFocus() == node2);
}
TEST_CASE("FocusManager traversal with tabIndex", "[FocusManager]")
{
FocusManager manager;
auto node1 = make_rcp<FocusNode>();
auto node2 = make_rcp<FocusNode>();
auto node3 = make_rcp<FocusNode>();
node1->tabIndex(3);
node2->tabIndex(1);
node3->tabIndex(2);
manager.addChild(nullptr, node1);
manager.addChild(nullptr, node2);
manager.addChild(nullptr, node3);
// Start with no focus, focusNext should pick first by tabIndex
manager.focusNext();
CHECK(manager.primaryFocus() == node2); // tabIndex 1
manager.focusNext();
CHECK(manager.primaryFocus() == node3); // tabIndex 2
manager.focusNext();
CHECK(manager.primaryFocus() == node1); // tabIndex 3
}
TEST_CASE("FocusManager traversal skips non-traversable", "[FocusManager]")
{
FocusManager manager;
auto node1 = make_rcp<FocusNode>();
auto node2 = make_rcp<FocusNode>();
auto node3 = make_rcp<FocusNode>();
node2->canTraverse(false);
manager.addChild(nullptr, node1);
manager.addChild(nullptr, node2);
manager.addChild(nullptr, node3);
manager.setFocus(node1);
manager.focusNext();
// Should skip node2 and go to node3
CHECK(manager.primaryFocus() == node3);
}
TEST_CASE("FocusManager edge behavior closedLoop", "[FocusManager]")
{
FocusManager manager;
auto scope = make_rcp<FocusNode>();
auto node1 = make_rcp<FocusNode>();
auto node2 = make_rcp<FocusNode>();
scope->edgeBehavior(EdgeBehavior::closedLoop);
manager.addChild(nullptr, scope);
manager.addChild(scope, node1);
manager.addChild(scope, node2);
manager.setFocus(node2);
manager.focusNext();
// Should wrap to first
CHECK(manager.primaryFocus() == node1);
}
TEST_CASE("FocusManager edge behavior stop", "[FocusManager]")
{
FocusManager manager;
auto scope = make_rcp<FocusNode>();
auto node1 = make_rcp<FocusNode>();
auto node2 = make_rcp<FocusNode>();
scope->edgeBehavior(EdgeBehavior::stop);
manager.addChild(nullptr, scope);
manager.addChild(scope, node1);
manager.addChild(scope, node2);
manager.setFocus(node2);
manager.focusNext();
// Should stay on node2
CHECK(manager.primaryFocus() == node2);
}
TEST_CASE("FocusManager ancestor notification on focus", "[FocusManager]")
{
FocusManager manager;
MockFocusable grandparentFocusable, parentFocusable, childFocusable;
auto grandparent = make_rcp<FocusNode>(&grandparentFocusable);
auto parent = make_rcp<FocusNode>(&parentFocusable);
auto child = make_rcp<FocusNode>(&childFocusable);
manager.addChild(nullptr, grandparent);
manager.addChild(grandparent, parent);
manager.addChild(parent, child);
// Focus the leaf node
manager.setFocus(child);
// All ancestors should have received focused() callback
CHECK(childFocusable.focusedCount == 1);
CHECK(parentFocusable.focusedCount == 1);
CHECK(grandparentFocusable.focusedCount == 1);
// All nodes in the chain should have hasFocus flag
CHECK(child->hasFocus() == true);
CHECK(parent->hasFocus() == true);
CHECK(grandparent->hasFocus() == true);
}
TEST_CASE("FocusManager common ancestor optimization", "[FocusManager]")
{
FocusManager manager;
MockFocusable parentFocusable, child1Focusable, child2Focusable;
auto parent = make_rcp<FocusNode>(&parentFocusable);
auto child1 = make_rcp<FocusNode>(&child1Focusable);
auto child2 = make_rcp<FocusNode>(&child2Focusable);
manager.addChild(nullptr, parent);
manager.addChild(parent, child1);
manager.addChild(parent, child2);
// Focus first child
manager.setFocus(child1);
CHECK(parentFocusable.focusedCount == 1);
CHECK(child1Focusable.focusedCount == 1);
// Move focus to sibling - parent should NOT get re-notified
manager.setFocus(child2);
CHECK(child1Focusable.blurredCount == 1);
CHECK(child2Focusable.focusedCount == 1);
// Parent should not be blurred or re-focused
CHECK(parentFocusable.focusedCount == 1); // Still 1, not 2
CHECK(parentFocusable.blurredCount == 0);
// Parent still has focus (descendant focused)
CHECK(parent->hasFocus() == true);
}
TEST_CASE("FocusManager traversal focuses leaves only", "[FocusManager]")
{
FocusManager manager;
MockFocusable scopeFocusable, leaf1Focusable, leaf2Focusable;
auto scope = make_rcp<FocusNode>(&scopeFocusable);
auto leaf1 = make_rcp<FocusNode>(&leaf1Focusable);
auto leaf2 = make_rcp<FocusNode>(&leaf2Focusable);
manager.addChild(nullptr, scope);
manager.addChild(scope, leaf1);
manager.addChild(scope, leaf2);
// Start with no focus, focusNext should focus first leaf, not scope
manager.focusNext();
CHECK(manager.primaryFocus() == leaf1);
CHECK(manager.hasPrimaryFocus(scope) == false);
CHECK(scope->hasFocus() == true); // But scope has descendant focus
manager.focusNext();
CHECK(manager.primaryFocus() == leaf2);
}
TEST_CASE("FocusManager nested scopes focus deepest leaf", "[FocusManager]")
{
FocusManager manager;
auto scope1 = make_rcp<FocusNode>();
auto scope2 = make_rcp<FocusNode>();
auto leaf = make_rcp<FocusNode>();
manager.addChild(nullptr, scope1);
manager.addChild(scope1, scope2);
manager.addChild(scope2, leaf);
// Navigate should go directly to the deepest leaf
manager.focusNext();
CHECK(manager.primaryFocus() == leaf);
CHECK(scope1->hasFocus() == true);
CHECK(scope2->hasFocus() == true);
}
TEST_CASE("FocusManager edge behavior parentScope exits to parent",
"[FocusManager]")
{
FocusManager manager;
auto root = make_rcp<FocusNode>();
auto scope = make_rcp<FocusNode>();
auto inner1 = make_rcp<FocusNode>();
auto inner2 = make_rcp<FocusNode>();
auto outer = make_rcp<FocusNode>();
scope->edgeBehavior(EdgeBehavior::parentScope);
manager.addChild(nullptr, root);
manager.addChild(root, scope);
manager.addChild(scope, inner1);
manager.addChild(scope, inner2);
manager.addChild(root, outer);
// Focus last node in scope
manager.setFocus(inner2);
CHECK(manager.primaryFocus() == inner2);
// Navigate forward should exit scope and go to outer
manager.focusNext();
CHECK(manager.primaryFocus() == outer);
}
TEST_CASE("FocusManager clearFocus clears hasFocus flag chain",
"[FocusManager]")
{
FocusManager manager;
MockFocusable parentFocusable, childFocusable;
auto parent = make_rcp<FocusNode>(&parentFocusable);
auto child = make_rcp<FocusNode>(&childFocusable);
manager.addChild(nullptr, parent);
manager.addChild(parent, child);
manager.setFocus(child);
CHECK(parent->hasFocus() == true);
CHECK(child->hasFocus() == true);
manager.clearFocus();
// Both should be cleared
CHECK(parent->hasFocus() == false);
CHECK(child->hasFocus() == false);
// Both should have received blurred callback
CHECK(parentFocusable.blurredCount == 1);
CHECK(childFocusable.blurredCount == 1);
}
TEST_CASE("FocusManager removeChild clears manager reference", "[FocusManager]")
{
FocusManager manager;
auto node = make_rcp<FocusNode>();
manager.addChild(nullptr, node);
CHECK(node->manager() == &manager);
manager.removeChild(node);
CHECK(node->manager() == nullptr);
}
TEST_CASE("Freeing a FocusNode clears the parent pointer of a child that "
"outlives it",
"[FocusManager]")
{
FocusManager manager;
auto scope = make_rcp<FocusNode>(); // persistent host scope, held here
{
auto row = make_rcp<FocusNode>(); // transient list row
manager.addChild(nullptr, row);
manager.addChild(row, scope);
CHECK(scope->parent() == row.get());
// The list re-sync removes the row from the manager, then drops it.
manager.removeChild(row);
} // row FocusNode destroyed here; scope survives via the outer rcp
REQUIRE(scope->parent() == nullptr);
// Re-homing the survivor is now safe — no dereference of the freed row.
auto newParent = make_rcp<FocusNode>();
manager.addChild(nullptr, newParent);
manager.addChild(newParent, scope);
CHECK(scope->parent() == newParent.get());
CHECK(newParent->children().size() == 1);
}
TEST_CASE("FocusManager::addChild removes a migrating root from its previous "
"manager",
"[FocusManager]")
{
FocusManager internalManager;
FocusManager parentManager;
auto scope = make_rcp<FocusNode>();
internalManager.addChild(nullptr, scope);
CHECK(scope->manager() == &internalManager);
CHECK(internalManager.rootNodes().size() == 1);
// Migrate the scope to the parent manager (no FocusNode parent -> root).
parentManager.addChild(nullptr, scope);
CHECK(scope->manager() == &parentManager);
CHECK(parentManager.rootNodes().size() == 1);
// The internal manager must no longer reference the migrated scope.
CHECK(internalManager.rootNodes().empty());
}
TEST_CASE("A migrated focus scope survives destruction of its previous manager",
"[FocusManager]")
{
FocusManager parentManager;
auto scope = make_rcp<FocusNode>();
{
FocusManager internalManager;
internalManager.addChild(nullptr, scope);
parentManager.addChild(nullptr, scope); // migrate to parent
CHECK(scope->manager() == &parentManager);
} // internalManager destroyed here
// The scope still belongs to parentManager, not the destroyed one.
CHECK(scope->manager() == &parentManager);
if (scope->manager() != nullptr)
{
scope->manager()->removeChild(scope);
}
CHECK(parentManager.rootNodes().empty());
}
TEST_CASE("FocusManager traversal backward from first leaf exits scope",
"[FocusManager]")
{
FocusManager manager;
auto root = make_rcp<FocusNode>();
auto before = make_rcp<FocusNode>();
auto scope = make_rcp<FocusNode>();
auto inner = make_rcp<FocusNode>();
scope->edgeBehavior(EdgeBehavior::parentScope);
manager.addChild(nullptr, root);
manager.addChild(root, before);
manager.addChild(root, scope);
manager.addChild(scope, inner);
// Focus the inner node
manager.setFocus(inner);
// Navigate backward should exit scope and go to before
manager.focusPrevious();
CHECK(manager.primaryFocus() == before);
}
TEST_CASE("FocusManager closedLoop wraps backward", "[FocusManager]")
{
FocusManager manager;
auto scope = make_rcp<FocusNode>();
auto node1 = make_rcp<FocusNode>();
auto node2 = make_rcp<FocusNode>();
scope->edgeBehavior(EdgeBehavior::closedLoop);
manager.addChild(nullptr, scope);
manager.addChild(scope, node1);
manager.addChild(scope, node2);
manager.setFocus(node1);
manager.focusPrevious();
// Should wrap to last
CHECK(manager.primaryFocus() == node2);
}
TEST_CASE("FocusManager stop prevents backward traversal", "[FocusManager]")
{
FocusManager manager;
auto scope = make_rcp<FocusNode>();
auto node1 = make_rcp<FocusNode>();
auto node2 = make_rcp<FocusNode>();
scope->edgeBehavior(EdgeBehavior::stop);
manager.addChild(nullptr, scope);
manager.addChild(scope, node1);
manager.addChild(scope, node2);
manager.setFocus(node1);
manager.focusPrevious();
// Should stay on node1
CHECK(manager.primaryFocus() == node1);
}
TEST_CASE("StateMachineInstance hasFocusNodes ignores non-traversable scopes",
"[FocusManager]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
auto scope = make_rcp<FocusNode>();
scope->canFocus(false);
scope->canTraverse(false);
smi.focusManager()->addChild(nullptr, scope);
CHECK(smi.hasFocusNodes() == false);
}
TEST_CASE("StateMachineInstance hasFocusNodes sees leaves under a "
"transparent scope",
"[FocusManager]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
// Transparent structural scope as registered for a data-bound nested
// artboard host: unbacked (no focusable), canFocus/canTraverse/canTouch
// false. Traversal descends through it because it has no focusable.
auto scope = make_rcp<FocusNode>();
scope->canFocus(false);
scope->canTraverse(false);
scope->canTouch(false);
smi.focusManager()->addChild(nullptr, scope);
// Empty scope contributes no focus targets (e.g. a bindable artboard with
// no focus nodes).
CHECK(smi.hasFocusNodes() == false);
// Swapping in an artboard that has a focusable leaf must make the state
// machine report focus nodes, even though the leaf lives under the scope.
auto leaf = make_rcp<FocusNode>();
smi.focusManager()->addChild(scope, leaf);
CHECK(smi.hasFocusNodes() == true);
}
TEST_CASE("StateMachineInstance hasFocusNodes counts focus data that is "
"currently ineligible for traversal",
"[FocusManager]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
// hasFocusNodes gates one-time setup in high-level runtimes (attaching
// tab/shift+tab listeners in JS), so authored focus data must count even
// while it can't currently be focused: canFocus/canTraverse are
// data-bindable and collapse/visibility can change on any frame.
FocusData focusData;
// canFocus/canTraverse are now bits in the focusFlags bitmask; clear both
// (leave the rest) to make the node ineligible for traversal.
focusData.focusFlags(
focusData.focusFlags() &
~(FocusData::canFocusBitmask | FocusData::canTraverseBitmask));
smi.focusManager()->addChild(nullptr, focusData.focusNode());
CHECK(smi.hasFocusNodes() == true);
}
TEST_CASE("FocusManager traversal descends through a transparent scope "
"and keeps sibling order",
"[FocusManager]")
{
FocusManager manager;
auto leafA = make_rcp<FocusNode>();
auto scope = make_rcp<FocusNode>();
auto leafC = make_rcp<FocusNode>();
// scope mirrors a data-bound nested artboard host slot sitting between two
// sibling focus nodes: unbacked (no focusable) and not a focus target
// itself, but Tab descends through it to whatever artboard is swapped in.
scope->canFocus(false);
scope->canTraverse(false);
scope->canTouch(false);
manager.addChild(nullptr, leafA);
manager.addChild(nullptr, scope);
manager.addChild(nullptr, leafC);
// Empty scope is skipped: A -> C.
manager.focusNext();
CHECK(manager.primaryFocus() == leafA);
manager.focusNext();
CHECK(manager.primaryFocus() == leafC);
// Populate the scope (artboard swapped in). Its leaf occupies the scope's
// sibling slot, so traversal order becomes A -> B -> C.
manager.clearFocus();
auto leafB = make_rcp<FocusNode>();
manager.addChild(scope, leafB);
manager.focusNext();
CHECK(manager.primaryFocus() == leafA);
manager.focusNext();
CHECK(manager.primaryFocus() == leafB);
manager.focusNext();
CHECK(manager.primaryFocus() == leafC);
}
TEST_CASE("FocusManager drops focus when a leaf under a transparent scope "
"becomes hidden",
"[FocusManager]")
{
FocusManager manager;
// Unbacked scope: the shape of a data-bound nested artboard's scope node.
auto scope = make_rcp<FocusNode>();
scope->canFocus(false);
scope->canTraverse(false);
scope->canTouch(false);
// A focusable leaf inside it, like a swapped-in nested artboard's element.
MockFocusable leafFocusable;
auto leaf = make_rcp<FocusNode>(&leafFocusable);
manager.addChild(nullptr, scope);
manager.addChild(scope, leaf);
// Tab descends through the scope onto the nested leaf.
manager.focusNext();
REQUIRE(manager.primaryFocus() == leaf);
// Hide the nested content (its focusable reports ineligible). Focus must be
// dropped, not left stranded behind the scope.
leafFocusable.eligible = false;
manager.dropFocusIfFocusTargetHidden();
CHECK(manager.primaryFocus() == nullptr);
}
TEST_CASE("FocusManager rebuilding one scope's subtree preserves focus in a "
"sibling scope",
"[FocusManager]")
{
FocusManager manager;
// Two sibling transparent scopes, like two data-bound nested artboard
// hosts.
auto scopeA = make_rcp<FocusNode>();
scopeA->canFocus(false);
scopeA->canTraverse(false);
scopeA->canTouch(false);
auto scopeB = make_rcp<FocusNode>();
scopeB->canFocus(false);
scopeB->canTraverse(false);
scopeB->canTouch(false);
MockFocusable leafAFocusable, leafBFocusable;
auto leafA = make_rcp<FocusNode>(&leafAFocusable);
auto leafB = make_rcp<FocusNode>(&leafBFocusable);
manager.addChild(nullptr, scopeA);
manager.addChild(scopeA, leafA);
manager.addChild(nullptr, scopeB);
manager.addChild(scopeB, leafB);
// Focus the leaf inside scope A.
manager.setFocus(leafA);
REQUIRE(manager.primaryFocus() == leafA);
// Simulate swapping the artboard in sibling scope B: tear down B's current
// content and rebuild it with a new focusable leaf under the same scope.
// Focus held in the unrelated scope A must be untouched.
manager.removeChild(leafB);
MockFocusable leafB2Focusable;
auto leafB2 = make_rcp<FocusNode>(&leafB2Focusable);
manager.addChild(scopeB, leafB2);
CHECK(manager.primaryFocus() == leafA);
}
TEST_CASE("FocusActionTraversal perform advances focus with traversalKind next",
"[FocusActionTraversal]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
FocusManager* fm = smi.focusManager();
MockFocusable f1, f2;
auto node1 = make_rcp<FocusNode>(&f1);
auto node2 = make_rcp<FocusNode>(&f2);
fm->addChild(nullptr, node1);
fm->addChild(nullptr, node2);
fm->setFocus(node1);
FocusActionTraversal action;
action.traversalKind(0);
action.perform(&smi, ListenerInvocation::none());
CHECK(fm->primaryFocus() == node2);
}
TEST_CASE("FocusActionTraversal perform moves focus back with traversalKind "
"previous",
"[FocusActionTraversal]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
FocusManager* fm = smi.focusManager();
MockFocusable f1, f2;
auto node1 = make_rcp<FocusNode>(&f1);
auto node2 = make_rcp<FocusNode>(&f2);
fm->addChild(nullptr, node1);
fm->addChild(nullptr, node2);
fm->setFocus(node2);
FocusActionTraversal action;
action.traversalKind(1);
action.perform(&smi, ListenerInvocation::none());
CHECK(fm->primaryFocus() == node1);
}
TEST_CASE("FocusActionTraversal perform unknown traversalKind defaults to next",
"[FocusActionTraversal]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
FocusManager* fm = smi.focusManager();
MockFocusable f1, f2;
auto node1 = make_rcp<FocusNode>(&f1);
auto node2 = make_rcp<FocusNode>(&f2);
fm->addChild(nullptr, node1);
fm->addChild(nullptr, node2);
fm->setFocus(node1);
FocusActionTraversal action;
action.traversalKind(999);
action.perform(&smi, ListenerInvocation::none());
CHECK(fm->primaryFocus() == node2);
}
TEST_CASE(
"StateMachineInstance exposes hasFocusNodes, focusNext, focusPrevious from focusManager",
"[FocusManager]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
MockFocusable f1, f2;
auto node1 = make_rcp<FocusNode>(&f1);
auto node2 = make_rcp<FocusNode>(&f2);
CHECK(smi.hasFocusNodes() == false);
smi.focusManager()->addChild(nullptr, node1);
smi.focusManager()->addChild(nullptr, node2);
smi.focusManager()->setFocus(node1);
CHECK(smi.hasFocusNodes() == true);
CHECK(smi.focusNext() == true);
CHECK(smi.focusPrevious() == true);
}
TEST_CASE("FocusActionTraversal perform ignores null StateMachineInstance",
"[FocusActionTraversal]")
{
FocusActionTraversal action;
action.traversalKind(0);
action.perform(nullptr, ListenerInvocation::none());
}
// Mock Focusable that reports it accepts keyboard input.
class KeyboardAcceptingFocusable : public MockFocusable
{
public:
bool acceptsKeyboardInput() const override { return true; }
};
TEST_CASE("Focusable::acceptsKeyboardInput defaults to false", "[Focusable]")
{
MockFocusable f;
CHECK(f.acceptsKeyboardInput() == false);
KeyboardAcceptingFocusable kf;
CHECK(kf.acceptsKeyboardInput() == true);
}
TEST_CASE("StateMachineInstance::focusState reports no focus when nothing is "
"focused",
"[FocusState]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
auto state = smi.focusState();
CHECK(state.hasFocus == false);
CHECK(state.expectsKeyboardInput == false);
}
TEST_CASE("StateMachineInstance::focusState reports focused non-keyboard "
"focusable",
"[FocusState]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
MockFocusable f;
auto node = make_rcp<FocusNode>(&f);
smi.focusManager()->addChild(nullptr, node);
smi.focusManager()->setFocus(node);
auto state = smi.focusState();
CHECK(state.hasFocus == true);
CHECK(state.expectsKeyboardInput == false);
}
TEST_CASE("StateMachineInstance::focusState reports keyboard expectation when "
"focused focusable accepts keys",
"[FocusState]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
KeyboardAcceptingFocusable kf;
auto node = make_rcp<FocusNode>(&kf);
smi.focusManager()->addChild(nullptr, node);
smi.focusManager()->setFocus(node);
auto state = smi.focusState();
CHECK(state.hasFocus == true);
CHECK(state.expectsKeyboardInput == true);
}
TEST_CASE("StateMachineInstance::focusState clears when focus is cleared",
"[FocusState]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
KeyboardAcceptingFocusable kf;
auto node = make_rcp<FocusNode>(&kf);
smi.focusManager()->addChild(nullptr, node);
smi.focusManager()->setFocus(node);
REQUIRE(smi.focusState().hasFocus == true);
smi.focusManager()->clearFocus();
auto state = smi.focusState();
CHECK(state.hasFocus == false);
CHECK(state.expectsKeyboardInput == false);
}
TEST_CASE("StateMachineInstance::focusState tracks switches between focusables",
"[FocusState]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
MockFocusable plain;
KeyboardAcceptingFocusable kf;
auto plainNode = make_rcp<FocusNode>(&plain);
auto kfNode = make_rcp<FocusNode>(&kf);
smi.focusManager()->addChild(nullptr, plainNode);
smi.focusManager()->addChild(nullptr, kfNode);
smi.focusManager()->setFocus(plainNode);
{
auto state = smi.focusState();
CHECK(state.hasFocus == true);
CHECK(state.expectsKeyboardInput == false);
}
smi.focusManager()->setFocus(kfNode);
{
auto state = smi.focusState();
CHECK(state.hasFocus == true);
CHECK(state.expectsKeyboardInput == true);
}
smi.focusManager()->setFocus(plainNode);
{
auto state = smi.focusState();
CHECK(state.hasFocus == true);
CHECK(state.expectsKeyboardInput == false);
}
}
TEST_CASE("StateMachineInstance::focusState uses external focus manager when "
"set",
"[FocusState]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
FocusManager external;
KeyboardAcceptingFocusable kf;
auto node = make_rcp<FocusNode>(&kf);
external.addChild(nullptr, node);
external.setFocus(node);
// Before swapping, internal manager has nothing focused.
CHECK(smi.focusState().hasFocus == false);
smi.setExternalFocusManager(&external);
auto state = smi.focusState();
CHECK(state.hasFocus == true);
CHECK(state.expectsKeyboardInput == true);
}
TEST_CASE("StateMachineInstance::clearFocus clears internal focus manager",
"[FocusState]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
KeyboardAcceptingFocusable kf;
auto node = make_rcp<FocusNode>(&kf);
smi.focusManager()->addChild(nullptr, node);
smi.focusManager()->setFocus(node);
REQUIRE(smi.focusState().hasFocus == true);
smi.clearFocus();
auto state = smi.focusState();
CHECK(state.hasFocus == false);
CHECK(state.expectsKeyboardInput == false);
}
TEST_CASE("StateMachineInstance::keyInput and textInput route to the focused "
"element",
"[FocusManager]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
MockFocusable focusable;
focusable.returnValue = true;
auto node = make_rcp<FocusNode>(&focusable);
// Nothing focused yet, so there is nobody to route the events to.
CHECK(smi.keyInput(Key::a, KeyModifiers::none, true, false) == false);
CHECK(smi.textInput("hello") == false);
CHECK(focusable.keyInputCount == 0);
CHECK(focusable.textInputCount == 0);
smi.focusManager()->addChild(nullptr, node);
smi.focusManager()->setFocus(node);
CHECK(smi.keyInput(Key::b, KeyModifiers::shift, true, false) == true);
CHECK(focusable.keyInputCount == 1);
CHECK(focusable.lastKey == Key::b);
CHECK(smi.textInput("world") == true);
CHECK(focusable.textInputCount == 1);
CHECK(focusable.lastText == "world");
}
TEST_CASE("StateMachineInstance::keyInput and textInput report unhandled "
"events from the focused element",
"[FocusManager]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
MockFocusable focusable;
focusable.returnValue = false;
auto node = make_rcp<FocusNode>(&focusable);
smi.focusManager()->addChild(nullptr, node);
smi.focusManager()->setFocus(node);
// The focused element saw both events but declined to handle them.
CHECK(smi.keyInput(Key::escape, KeyModifiers::none, true, false) == false);
CHECK(smi.textInput("ignored") == false);
CHECK(focusable.keyInputCount == 1);
CHECK(focusable.textInputCount == 1);
}
TEST_CASE("StateMachineInstance::keyInput and textInput use the external focus "
"manager when set",
"[FocusManager]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
// The artboard owns the manager the state machine uses by default.
auto* ownManager = instance->ensureFocusManager();
MockFocusable internalFocusable;
internalFocusable.returnValue = true;
auto internalNode = make_rcp<FocusNode>(&internalFocusable);
ownManager->addChild(nullptr, internalNode);
ownManager->setFocus(internalNode);
FocusManager external;
MockFocusable externalFocusable;
externalFocusable.returnValue = true;
auto externalNode = make_rcp<FocusNode>(&externalFocusable);
external.addChild(nullptr, externalNode);
external.setFocus(externalNode);
smi.setExternalFocusManager(&external);
CHECK(smi.keyInput(Key::c, KeyModifiers::none, true, false) == true);
CHECK(smi.textInput("external") == true);
// Events land on the external tree, not the internal one.
CHECK(externalFocusable.keyInputCount == 1);
CHECK(externalFocusable.textInputCount == 1);
CHECK(externalFocusable.lastText == "external");
CHECK(internalFocusable.keyInputCount == 0);
CHECK(internalFocusable.textInputCount == 0);
smi.setExternalFocusManager(nullptr);
}
TEST_CASE("FocusManager setFocus on a scope descends to first leaf",
"[FocusManager]")
{
FocusManager manager;
auto scope = make_rcp<FocusNode>();
auto leaf1 = make_rcp<FocusNode>();
auto leaf2 = make_rcp<FocusNode>();
manager.addChild(nullptr, scope);
manager.addChild(scope, leaf1);
manager.addChild(scope, leaf2);
// Focusing the scope resolves to its first eligible leaf.
manager.setFocus(scope);
CHECK(manager.primaryFocus() == leaf1);
}
TEST_CASE("FocusManager setFocus on a scope descends depth-first",
"[FocusManager]")
{
FocusManager manager;
auto scope = make_rcp<FocusNode>();
auto row = make_rcp<FocusNode>();
auto leaf = make_rcp<FocusNode>();
auto sibling = make_rcp<FocusNode>();
manager.addChild(nullptr, scope);
manager.addChild(scope, row);
manager.addChild(row, leaf);
manager.addChild(scope, sibling);
// Depth-first: first leaf is the leaf nested under the first child (row).
manager.setFocus(scope);
CHECK(manager.primaryFocus() == leaf);
}
TEST_CASE("FocusManager setFocus on a scope with no eligible leaf falls back",
"[FocusManager]")
{
FocusManager manager;
auto scope = make_rcp<FocusNode>();
auto child = make_rcp<FocusNode>();
// Child cannot be traversed, so the scope has no eligible leaf to descend
// to. The scope itself remains the focus target (preserves prior behavior).
child->canTraverse(false);
manager.addChild(nullptr, scope);
manager.addChild(scope, child);
manager.setFocus(scope);
CHECK(manager.primaryFocus() == scope);
}
TEST_CASE("FocusManager setFocus on an ineligible scope is a no-op",
"[FocusManager]")
{
FocusManager manager;
auto scope = make_rcp<FocusNode>();
auto leaf = make_rcp<FocusNode>();
// The requested target itself cannot be focused. Descent must not reach an
// eligible descendant — focus stays unchanged (no-op), matching the prior
// early-return guard behavior.
scope->canFocus(false);
manager.addChild(nullptr, scope);
manager.addChild(scope, leaf);
manager.setFocus(scope);
CHECK(manager.primaryFocus() == nullptr);
}
TEST_CASE("FocusManager setFocus on a leaf is unchanged", "[FocusManager]")
{
FocusManager manager;
auto scope = make_rcp<FocusNode>();
auto leaf1 = make_rcp<FocusNode>();
auto leaf2 = make_rcp<FocusNode>();
manager.addChild(nullptr, scope);
manager.addChild(scope, leaf1);
manager.addChild(scope, leaf2);
// Directly focusing a leaf still focuses that exact leaf (no-op descent).
manager.setFocus(leaf2);
CHECK(manager.primaryFocus() == leaf2);
}
TEST_CASE("FocusManager Tab after focusing a scope traverses leaf siblings",
"[FocusManager]")
{
FocusManager manager;
auto scope = make_rcp<FocusNode>();
auto leaf1 = make_rcp<FocusNode>();
auto leaf2 = make_rcp<FocusNode>();
manager.addChild(nullptr, scope);
manager.addChild(scope, leaf1);
manager.addChild(scope, leaf2);
// Focusing the scope lands on the first leaf; Tab then advances to the
// scope's next leaf rather than skipping the scope's children.
manager.setFocus(scope);
CHECK(manager.primaryFocus() == leaf1);
manager.focusNext();
CHECK(manager.primaryFocus() == leaf2);
}
// =============================================================================
// FocusActionClear Tests
// =============================================================================
TEST_CASE("FocusActionClear perform clears the primary focus",
"[FocusActionClear]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
FocusManager* fm = smi.focusManager();
MockFocusable f1;
auto node1 = make_rcp<FocusNode>(&f1);
fm->addChild(nullptr, node1);
fm->setFocus(node1);
REQUIRE(fm->primaryFocus() == node1);
FocusActionClear action;
action.perform(&smi, ListenerInvocation::none());
CHECK(fm->primaryFocus() == nullptr);
}
TEST_CASE("FocusActionClear perform is a no-op when nothing is focused",
"[FocusActionClear]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
REQUIRE(smi.focusManager()->primaryFocus() == nullptr);
FocusActionClear action;
action.perform(&smi, ListenerInvocation::none());
CHECK(smi.focusManager()->primaryFocus() == nullptr);
}
TEST_CASE("FocusActionClear perform ignores null StateMachineInstance",
"[FocusActionClear]")
{
FocusActionClear action;
// Must not dereference the null instance.
action.perform(nullptr, ListenerInvocation::none());
}
// =============================================================================
// TransitionFocusCondition Tests
// =============================================================================
TEST_CASE("TransitionFocusCondition uses the reassigned core type key",
"[TransitionFocusCondition]")
{
// Locks in the collision fix: master's font PR claimed 1035, so this
// condition was reassigned to 1038. A regression here means a type-key
// clash on import/export.
// Copy into a local to avoid ODR-using the in-class static constant
// (which has no out-of-line definition) when binding it to Catch2's
// by-reference comparison expressions.
uint16_t typeKey = TransitionFocusConditionBase::typeKey;
CHECK(typeKey == 1038);
auto condition = std::make_unique<TransitionFocusCondition>();
CHECK(condition->coreType() == typeKey);
CHECK(condition->is<TransitionFocusCondition>());
}
TEST_CASE("TransitionFocusCondition evaluate returns false for a null "
"StateMachineInstance",
"[TransitionFocusCondition]")
{
// Heap allocation value-initializes the (comparator) members to null, so
// the guard clauses and destructor are well-defined even without import.
auto condition = std::make_unique<TransitionFocusCondition>();
CHECK(condition->evaluate(nullptr, nullptr) == false);
}
TEST_CASE("TransitionFocusCondition evaluate returns false when no target "
"comparator is configured",
"[TransitionFocusCondition]")
{
NoOpFactory factory;
Artboard artboard(&factory);
auto instance = instanceWithFocus(artboard);
StateMachine machine;
StateMachineInstance smi(&machine, instance.get());
auto condition = std::make_unique<TransitionFocusCondition>();
// With neither comparator set to a TransitionPropertyComponentComparator,
// there is no focus target to evaluate against, so the condition is false.
CHECK(condition->evaluate(&smi, nullptr) == false);
}
// =============================================================================
// Re-homing focus when the target disappears
// =============================================================================
TEST_CASE("FocusManager re-homes focus to a sibling leaf when the target hides",
"[FocusManager]")
{
FocusManager manager;
MockFocusable parentFocusable, leafAFocusable, leafBFocusable;
auto parent = make_rcp<FocusNode>(&parentFocusable);
auto leafA = make_rcp<FocusNode>(&leafAFocusable);
auto leafB = make_rcp<FocusNode>(&leafBFocusable);
manager.addChild(nullptr, parent);
manager.addChild(parent, leafA);
manager.addChild(parent, leafB);
manager.setFocus(parent); // descends to the first leaf
REQUIRE(manager.primaryFocus() == leafA);
// A hides: focus lands on its sibling, not on the parent and not nowhere.
leafAFocusable.eligible = false;
manager.dropFocusIfFocusTargetHidden();
CHECK(manager.primaryFocus() == leafB);
CHECK(leafAFocusable.blurredCount == 1);
CHECK(leafBFocusable.focusedCount == 1);
// The shared ancestor never lost focus, so it is not re-notified.
CHECK(parentFocusable.blurredCount == 0);
CHECK(parentFocusable.focusedCount == 1);
}
TEST_CASE("FocusManager re-homes focus to the parent when it is the only "
"remaining stop",
"[FocusManager]")
{
FocusManager manager;
MockFocusable parentFocusable, leafFocusable;
auto parent = make_rcp<FocusNode>(&parentFocusable);
auto leaf = make_rcp<FocusNode>(&leafFocusable);
manager.addChild(nullptr, parent);
manager.addChild(parent, leaf);
manager.setFocus(parent);
REQUIRE(manager.primaryFocus() == leaf);
// No sibling to fall back to, so the parent itself takes focus.
leafFocusable.eligible = false;
manager.dropFocusIfFocusTargetHidden();
CHECK(manager.primaryFocus() == parent);
CHECK(leafFocusable.blurredCount == 1);
}
TEST_CASE("FocusManager walks past a hidden parent to an eligible grandparent",
"[FocusManager]")
{
FocusManager manager;
MockFocusable grandFocusable, parentFocusable, leafFocusable;
auto grand = make_rcp<FocusNode>(&grandFocusable);
auto parent = make_rcp<FocusNode>(&parentFocusable);
auto leaf = make_rcp<FocusNode>(&leafFocusable);
manager.addChild(nullptr, grand);
manager.addChild(grand, parent);
manager.addChild(parent, leaf);
manager.setFocus(grand);
REQUIRE(manager.primaryFocus() == leaf);
// The whole parent branch hides: skip it, land on the grandparent.
leafFocusable.eligible = false;
parentFocusable.eligible = false;
manager.dropFocusIfFocusTargetHidden();
CHECK(manager.primaryFocus() == grand);
}
TEST_CASE("FocusManager clears focus when no ancestor can hold it",
"[FocusManager]")
{
FocusManager manager;
MockFocusable parentFocusable, leafFocusable;
auto parent = make_rcp<FocusNode>(&parentFocusable);
auto leaf = make_rcp<FocusNode>(&leafFocusable);
manager.addChild(nullptr, parent);
manager.addChild(parent, leaf);
manager.setFocus(parent);
REQUIRE(manager.primaryFocus() == leaf);
// Everything up the chain is gone, so focus really does clear.
leafFocusable.eligible = false;
parentFocusable.eligible = false;
manager.dropFocusIfFocusTargetHidden();
CHECK(manager.primaryFocus() == nullptr);
}
TEST_CASE("FocusManager re-homing does not land on a non-focusable ancestor",
"[FocusManager]")
{
FocusManager manager;
// canFocus=false ancestor: authored as a pass-through container.
MockFocusable containerFocusable, leafFocusable;
auto container = make_rcp<FocusNode>(&containerFocusable);
container->canFocus(false);
auto leaf = make_rcp<FocusNode>(&leafFocusable);
manager.addChild(nullptr, container);
manager.addChild(container, leaf);
manager.setFocus(leaf);
REQUIRE(manager.primaryFocus() == leaf);
leafFocusable.eligible = false;
manager.dropFocusIfFocusTargetHidden();
// The container cannot take focus, and there is nothing above it.
CHECK(manager.primaryFocus() == nullptr);
}
TEST_CASE("FocusManager clears rather than crossing into another root branch",
"[FocusManager]")
{
FocusManager manager;
MockFocusable rootAFocusable, leafAFocusable, rootBFocusable,
leafBFocusable;
auto rootA = make_rcp<FocusNode>(&rootAFocusable);
auto leafA = make_rcp<FocusNode>(&leafAFocusable);
auto rootB = make_rcp<FocusNode>(&rootBFocusable);
auto leafB = make_rcp<FocusNode>(&leafBFocusable);
manager.addChild(nullptr, rootA);
manager.addChild(rootA, leafA);
manager.addChild(nullptr, rootB);
manager.addChild(rootB, leafB);
manager.setFocus(rootA);
REQUIRE(manager.primaryFocus() == leafA);
// The whole first root branch goes away. Re-homing stays inside the
// ancestor chain, so it stops at rootA rather than continuing into the
// second branch — an unrelated tree, a separate artboard in practice.
// Focus clears; Tab still reaches rootB, it just isn't jumped to.
leafAFocusable.eligible = false;
rootAFocusable.eligible = false;
manager.dropFocusIfFocusTargetHidden();
CHECK(manager.primaryFocus() == nullptr);
CHECK(leafBFocusable.focusedCount == 0);
}
TEST_CASE("FocusManager clears when a focused root node hides",
"[FocusManager]")
{
FocusManager manager;
MockFocusable rootAFocusable, rootBFocusable;
auto rootA = make_rcp<FocusNode>(&rootAFocusable);
auto rootB = make_rcp<FocusNode>(&rootBFocusable);
manager.addChild(nullptr, rootA);
manager.addChild(nullptr, rootB);
manager.setFocus(rootA);
REQUIRE(manager.primaryFocus() == rootA);
// Same rule with no ancestors at all to walk: a root node's siblings are
// other root branches, so there is nothing in scope to re-home to.
rootAFocusable.eligible = false;
manager.dropFocusIfFocusTargetHidden();
CHECK(manager.primaryFocus() == nullptr);
CHECK(rootBFocusable.focusedCount == 0);
}
// =============================================================================
// Re-descending focus when a hidden child reappears
// =============================================================================
TEST_CASE("FocusManager descends focus to a child that becomes eligible",
"[FocusManager]")
{
FocusManager manager;
MockFocusable parentFocusable, childFocusable;
auto parent = make_rcp<FocusNode>(&parentFocusable);
auto child = make_rcp<FocusNode>(&childFocusable);
manager.addChild(nullptr, parent);
manager.addChild(parent, child);
// With the child hidden, the parent is a leaf and keeps focus itself.
childFocusable.eligible = false;
manager.setFocus(parent);
REQUIRE(manager.primaryFocus() == parent);
CHECK(parentFocusable.focusedCount == 1);
// Still a leaf, so an update pass changes nothing.
manager.descendFocusToLeaf(nullptr);
CHECK(manager.primaryFocus() == parent);
CHECK(childFocusable.focusedCount == 0);
// The child becomes visible: the parent has silently become a scope, and
// focus has to follow to the leaf Tab would have picked.
childFocusable.eligible = true;
manager.descendFocusToLeaf(nullptr);
CHECK(manager.primaryFocus() == child);
CHECK(childFocusable.focusedCount == 1);
// The parent stays on the focus path, so it is neither blurred nor
// re-focused.
CHECK(parentFocusable.blurredCount == 0);
CHECK(parentFocusable.focusedCount == 1);
// Focus rests on a leaf again; further passes are no-ops.
manager.descendFocusToLeaf(nullptr);
CHECK(manager.primaryFocus() == child);
CHECK(childFocusable.focusedCount == 1);
}
TEST_CASE("FocusManager only descends focus for the root that just updated",
"[FocusManager]")
{
NoOpFactory factory;
Artboard artboardA(&factory);
Artboard artboardB(&factory);
FocusManager manager;
MockFocusable parentFocusable, childFocusable;
parentFocusable.artboard = &artboardB;
childFocusable.artboard = &artboardB;
auto parent = make_rcp<FocusNode>(&parentFocusable);
auto child = make_rcp<FocusNode>(&childFocusable);
manager.addChild(nullptr, parent);
manager.addChild(parent, child);
childFocusable.eligible = false;
manager.setFocus(parent);
REQUIRE(manager.primaryFocus() == parent);
childFocusable.eligible = true;
// Root A advancing must not touch a target living in root B: only B's own
// update pass has refreshed what eligibility reads.
manager.descendFocusToLeaf(&artboardA);
CHECK(manager.primaryFocus() == parent);
// B's pass does the descent.
manager.descendFocusToLeaf(&artboardB);
CHECK(manager.primaryFocus() == child);
}
TEST_CASE("FocusManager scopes descent by where focus would land",
"[FocusManager]")
{
NoOpFactory factory;
Artboard artboardA(&factory);
Artboard artboardB(&factory);
FocusManager manager;
// A host-created parent: no artboard backs it, so no root owns it. Its
// child does live in a real artboard, which is the eligibility the
// descent would be acting on.
MockFocusable parentFocusable, childFocusable;
childFocusable.artboard = &artboardB;
auto parent = make_rcp<FocusNode>(&parentFocusable);
auto child = make_rcp<FocusNode>(&childFocusable);
manager.addChild(nullptr, parent);
manager.addChild(parent, child);
childFocusable.eligible = false;
manager.setFocus(parent);
REQUIRE(manager.primaryFocus() == parent);
childFocusable.eligible = true;
// Scoping on the unattributable parent would let root A descend into
// root B's child on B's stale state; scoping on the destination defers.
manager.descendFocusToLeaf(&artboardA);
CHECK(manager.primaryFocus() == parent);
// And it still descends — B's own pass claims it, rather than the
// unattributable target being deferred forever.
manager.descendFocusToLeaf(&artboardB);
CHECK(manager.primaryFocus() == child);
}
TEST_CASE("FocusManager only drops a hidden target for its own root",
"[FocusManager]")
{
NoOpFactory factory;
Artboard artboardA(&factory);
Artboard artboardB(&factory);
FocusManager manager;
MockFocusable parentFocusable, leafAFocusable, leafBFocusable;
parentFocusable.artboard = &artboardB;
leafAFocusable.artboard = &artboardB;
leafBFocusable.artboard = &artboardB;
auto parent = make_rcp<FocusNode>(&parentFocusable);
auto leafA = make_rcp<FocusNode>(&leafAFocusable);
auto leafB = make_rcp<FocusNode>(&leafBFocusable);
manager.addChild(nullptr, parent);
manager.addChild(parent, leafA);
manager.addChild(parent, leafB);
manager.setFocus(parent);
REQUIRE(manager.primaryFocus() == leafA);
leafAFocusable.eligible = false;
// Root A's update pass hasn't refreshed anything in root B, so it must
// not re-home B's target off what it reads there.
manager.dropFocusIfFocusTargetHidden(&artboardA);
CHECK(manager.primaryFocus() == leafA);
// B's own pass does it.
manager.dropFocusIfFocusTargetHidden(&artboardB);
CHECK(manager.primaryFocus() == leafB);
}
} // namespace rive
TEST_CASE("Swapping bindable artboard registers nested focus nodes for Tab",
"[silver]")
{
rive::SerializingFactory silver;
auto file = ReadRiveFile("assets/bindable_focus_tree_swap.riv", &silver);
auto artboard = file->artboardDefault();
REQUIRE(artboard != nullptr);
silver.frameSize(artboard->width(), artboard->height());
auto stateMachine = artboard->stateMachineAt(0);
REQUIRE(stateMachine != nullptr);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
REQUIRE(vmi != nullptr);
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.016f);
auto* focusManager = stateMachine->focusManager();
REQUIRE(focusManager != nullptr);
REQUIRE(stateMachine->hasFocusNodes() == true);
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
REQUIRE(focusManager->primaryFocus() != nullptr);
CHECK(stateMachine->focusNext() == false);
// There's only one focus node in the main artboard, go back to that last
// node
stateMachine->focusPrevious();
auto* artboardProp = vmi->propertyValue("bindedArt");
REQUIRE(artboardProp != nullptr);
REQUIRE(artboardProp->is<rive::ViewModelInstanceArtboard>());
auto* vmiArtboard = artboardProp->as<rive::ViewModelInstanceArtboard>();
// Has other focus nodes in this artboard
auto focusableSource = file->bindableArtboardNamed("Focusable");
REQUIRE(focusableSource != nullptr);
vmiArtboard->asset(focusableSource);
stateMachine->advanceAndApply(0.016f);
rive::NestedArtboard* focusableHost = nullptr;
for (auto* nestedHost : artboard->nestedArtboards())
{
auto* source = nestedHost->sourceArtboard();
if (source != nullptr && source->name() == "Focusable")
{
focusableHost = nestedHost;
break;
}
}
REQUIRE(focusableHost != nullptr);
auto* focusableInstance = focusableHost->artboardInstance(0);
REQUIRE(focusableInstance != nullptr);
CHECK(stateMachine->focusNext() == true);
CHECK(focusManager->primaryFocus() != nullptr);
CHECK(focusManager->primaryFocusImmediateArtboard() == focusableInstance);
}
TEST_CASE("Swapping a bindable nested artboard preserves focus held elsewhere",
"[silver]")
{
rive::SerializingFactory silver;
auto file = ReadRiveFile("assets/bindable_focus_tree_swap.riv", &silver);
auto artboard = file->artboardDefault();
REQUIRE(artboard != nullptr);
silver.frameSize(artboard->width(), artboard->height());
auto stateMachine = artboard->stateMachineAt(0);
REQUIRE(stateMachine != nullptr);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
REQUIRE(vmi != nullptr);
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.016f);
auto* focusManager = stateMachine->focusManager();
REQUIRE(focusManager != nullptr);
// Focus the main artboard's own focus node. Before the swap the bindable
// host is "Plain" (no focus nodes), so the main node is the only focusable.
focusManager->focusNext();
auto focused = focusManager->primaryFocus();
REQUIRE(focused != nullptr);
REQUIRE(focusManager->primaryFocusImmediateArtboard() == artboard.get());
// Swap the (unrelated) bindable nested artboard to one that HAS focus
// nodes.
auto* artboardProp = vmi->propertyValue("bindedArt");
REQUIRE(artboardProp != nullptr);
REQUIRE(artboardProp->is<rive::ViewModelInstanceArtboard>());
auto* vmiArtboard = artboardProp->as<rive::ViewModelInstanceArtboard>();
auto focusableSource = file->bindableArtboardNamed("Focusable");
REQUIRE(focusableSource != nullptr);
vmiArtboard->asset(focusableSource);
stateMachine->advanceAndApply(0.016f);
// Focus held on the main artboard must survive the unrelated nested swap:
// the swap only re-syncs the swapped host's subtree, not the whole tree.
CHECK(focusManager->primaryFocus() == focused);
CHECK(focusManager->primaryFocusImmediateArtboard() == artboard.get());
}
TEST_CASE("FocusManager skips collapsed nodes and fully transparent nodes",
"[FocusManager]")
{
rive::SerializingFactory silver;
auto file = ReadRiveFile("assets/focus_collapsing.riv", &silver);
auto artboard = file->artboardDefault();
silver.frameSize(artboard->width(), artboard->height());
auto stateMachine = artboard->stateMachineAt(0);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
auto focusManager = artboard->focusManager();
auto opacityProp =
vmi->propertyValue("opacity")->as<rive::ViewModelInstanceNumber>();
auto isMainLayout2VisibleProp = vmi->propertyValue("isMainLayout2Visible")
->as<rive::ViewModelInstanceBoolean>();
stateMachine->bindViewModelInstance(vmi);
// ===> Frame 0
auto renderer = silver.makeRenderer();
stateMachine->advanceAndApply(0.016f);
// ===> Frame 1
artboard->draw(renderer.get());
silver.addFrame();
focusManager->focusNext();
// The first focusable is now inside a data-bound nested artboard
REQUIRE(focusManager->primaryFocus() != nullptr);
REQUIRE(focusManager->primaryFocusImmediateArtboard() != nullptr);
REQUIRE(focusManager->primaryFocusImmediateArtboard() != artboard.get());
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
// ===> Frame 2
silver.addFrame();
// Tab next into the main artboard's own element — the one `opacity`
// controls.
focusManager->focusNext();
REQUIRE(focusManager->primaryFocus() != nullptr);
REQUIRE(focusManager->primaryFocusImmediateArtboard() == artboard.get());
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Hide that focused element; focus must be dropped.
opacityProp->propertyValue(0);
// The advance that zeroes the opacity is the one that drops the focus:
// the check runs after updatePass, so it reads this frame's opacity
// rather than the previous frame's.
stateMachine->advanceAndApply(0.016f);
REQUIRE(focusManager->primaryFocus() == nullptr);
stateMachine->advanceAndApply(0.016f);
REQUIRE(focusManager->primaryFocus() == nullptr);
artboard->draw(renderer.get());
// ===> Frame 3
silver.addFrame();
opacityProp->propertyValue(1);
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
// ===> Frame 4
silver.addFrame();
focusManager->focusNext();
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
REQUIRE(focusManager->primaryFocus() != nullptr);
artboard->draw(renderer.get());
// ===> Frame 5
silver.addFrame();
isMainLayout2VisibleProp->propertyValue(false);
stateMachine->advanceAndApply(0.016f);
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
// ===> Frame 6
silver.addFrame();
// Toggles only between visible focused elements
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
// ===> Frame 7
silver.addFrame();
focusManager->focusNext();
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
// ===> Frame 8
silver.addFrame();
// Fully rotates over all nodes
isMainLayout2VisibleProp->propertyValue(true);
stateMachine->advanceAndApply(0.016f);
focusManager->focusNext();
artboard->draw(renderer.get());
// ===> Frame 9
silver.addFrame();
stateMachine->advanceAndApply(0.016f);
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
// ===> Frame 10
silver.addFrame();
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
focusManager->focusNext();
artboard->draw(renderer.get());
// ===> Frame 11
silver.addFrame();
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
// ===> Frame 12
silver.addFrame();
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
CHECK(silver.matches("focus_collapsing"));
}
TEST_CASE("Focused elements receive keyboard inputs", "[silver]")
{
rive::SerializingFactory silver;
auto file = ReadRiveFile("assets/keyboard_listener.riv", &silver);
auto artboard = file->artboardDefault();
silver.frameSize(artboard->width(), artboard->height());
auto stateMachine = artboard->stateMachineAt(0);
int viewModelId = artboard.get()->viewModelId();
auto vmi = viewModelId == -1
? file->createViewModelInstance(artboard.get())
: file->createViewModelInstance(viewModelId, 0);
stateMachine->bindViewModelInstance(vmi);
auto renderer = silver.makeRenderer();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
auto focusManager = artboard->focusManager();
// Child index 5
focusManager->focusPrevious();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
focusManager->keyInput(rive::Key::space,
rive::KeyModifiers::none,
false,
false);
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Child index 4
focusManager->focusPrevious();
// Child index 3
focusManager->focusPrevious();
// Child index 2
focusManager->focusPrevious();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
focusManager->keyInput(rive::Key::space,
rive::KeyModifiers::none,
false,
false);
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Child index 1
focusManager->focusPrevious();
// Child index 0
focusManager->focusPrevious();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
focusManager->keyInput(rive::Key::space,
rive::KeyModifiers::none,
false,
false);
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
focusManager->focusPrevious();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
focusManager->keyInput(rive::Key::space,
rive::KeyModifiers::none,
false,
false);
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
CHECK(silver.matches("keyboard_listener"));
}
TEST_CASE("Keyboard inputs with different key combinations", "[silver]")
{
rive::SerializingFactory silver;
auto file = ReadRiveFile("assets/keyboard_listener.riv", &silver);
auto artboard = file->artboardNamed("KeyboardInput");
silver.frameSize(artboard->width(), artboard->height());
auto stateMachine = artboard->stateMachineAt(0);
int viewModelId = artboard.get()->viewModelId();
auto vmi = viewModelId == -1
? file->createViewModelInstance(artboard.get())
: file->createViewModelInstance(viewModelId, 0);
auto keyCountProp =
vmi->propertyValue("keyCount")->as<rive::ViewModelInstanceNumber>();
stateMachine->bindViewModelInstance(vmi);
auto renderer = silver.makeRenderer();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
auto focusManager = artboard->focusManager();
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Key "a" on phase down with no modifiers is captured
focusManager->keyInput(rive::Key::a, rive::KeyModifiers::none, true, false);
stateMachine->advanceAndApply(0.016f);
CHECK(keyCountProp->propertyValue() == 1);
artboard->draw(renderer.get());
silver.addFrame();
// Key "a" on phase repeat with no modifiers is not captured
focusManager->keyInput(rive::Key::a, rive::KeyModifiers::none, true, true);
stateMachine->advanceAndApply(0.016f);
CHECK(keyCountProp->propertyValue() == 1);
// Key "a" on phase up with no modifiers is captured
focusManager->keyInput(rive::Key::a,
rive::KeyModifiers::none,
false,
false);
stateMachine->advanceAndApply(0.016f);
CHECK(keyCountProp->propertyValue() == 2);
// Key "a" on phase down with modifiers is not captured
focusManager->keyInput(rive::Key::a,
rive::KeyModifiers::shift,
true,
false);
stateMachine->advanceAndApply(0.016f);
CHECK(keyCountProp->propertyValue() == 2);
// Key "e" on any phase is not captured
focusManager->keyInput(rive::Key::e,
rive::KeyModifiers::none,
false,
false);
focusManager->keyInput(rive::Key::e, rive::KeyModifiers::none, true, true);
focusManager->keyInput(rive::Key::e, rive::KeyModifiers::none, true, false);
CHECK(keyCountProp->propertyValue() == 2);
stateMachine->advanceAndApply(0.016f);
// Key "b" on phase down with no modifiers is NOT captured
focusManager->keyInput(rive::Key::b, rive::KeyModifiers::none, true, false);
// Key "b" on phase up with no modifiers is NOT captured
CHECK(keyCountProp->propertyValue() == 2);
stateMachine->advanceAndApply(0.016f);
focusManager->keyInput(rive::Key::b,
rive::KeyModifiers::none,
false,
false);
stateMachine->advanceAndApply(0.016f);
CHECK(keyCountProp->propertyValue() == 3);
// Key "b" on phase repeat with no modifiers is captured
focusManager->keyInput(rive::Key::b, rive::KeyModifiers::none, true, true);
stateMachine->advanceAndApply(0.016f);
CHECK(keyCountProp->propertyValue() == 4);
// Key "d" on phase down with no modifiers is not captured
focusManager->keyInput(rive::Key::d, rive::KeyModifiers::none, true, false);
stateMachine->advanceAndApply(0.016f);
CHECK(keyCountProp->propertyValue() == 4);
// Key "d" on phase down with shift + command modifiers is captured
focusManager->keyInput(rive::Key::d,
rive::KeyModifiers::shift | rive::KeyModifiers::meta,
true,
false);
stateMachine->advanceAndApply(0.016f);
CHECK(keyCountProp->propertyValue() == 5);
// Key "c" on phase down with shift + command modifiers is NOT captured
focusManager->keyInput(rive::Key::c,
rive::KeyModifiers::shift | rive::KeyModifiers::meta,
true,
false);
stateMachine->advanceAndApply(0.016f);
CHECK(keyCountProp->propertyValue() == 5);
// Key "c" on phase down with shift modifiers is captured
focusManager->keyInput(rive::Key::c,
rive::KeyModifiers::shift,
true,
false);
stateMachine->advanceAndApply(0.016f);
CHECK(keyCountProp->propertyValue() == 6);
// Key "x" on phase down with shift modifiers is NOT captured
focusManager->keyInput(rive::Key::x,
rive::KeyModifiers::shift,
true,
false);
stateMachine->advanceAndApply(0.016f);
CHECK(keyCountProp->propertyValue() == 6);
artboard->draw(renderer.get());
CHECK(silver.matches("keyboard_listener-KeyboardInput"));
}
TEST_CASE("Text input events are handled on focused nodes", "[silver]")
{
auto file = ReadRiveFile("assets/text_input_event.riv");
auto artboard = file->artboardDefault();
auto stateMachine = artboard->stateMachineAt(0);
auto vmi = file->createViewModelInstance(artboard.get());
auto isFocusedProp =
vmi->propertyValue("isFocused")->as<rive::ViewModelInstanceBoolean>();
auto hasKeyedProp =
vmi->propertyValue("hasKeyed")->as<rive::ViewModelInstanceBoolean>();
auto hasTextedProp =
vmi->propertyValue("hasTexted")->as<rive::ViewModelInstanceBoolean>();
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.016f);
auto focusManager = artboard->focusManager();
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
CHECK(isFocusedProp->propertyValue() == true);
CHECK(hasKeyedProp->propertyValue() == false);
CHECK(hasTextedProp->propertyValue() == false);
// Key "b" on phase down with no modifiers is NOT captured
focusManager->keyInput(rive::Key::b, rive::KeyModifiers::none, true, false);
stateMachine->advanceAndApply(0.016f);
CHECK(isFocusedProp->propertyValue() == true);
CHECK(hasKeyedProp->propertyValue() == false);
CHECK(hasTextedProp->propertyValue() == false);
// Text "b" on captured by text but not by key
focusManager->textInput("b");
stateMachine->advanceAndApply(0.016f);
CHECK(isFocusedProp->propertyValue() == true);
CHECK(hasKeyedProp->propertyValue() == false);
CHECK(hasTextedProp->propertyValue() == true);
// Key "a" on phase down with no modifiers is captured by key
focusManager->keyInput(rive::Key::a, rive::KeyModifiers::none, true, false);
stateMachine->advanceAndApply(0.016f);
CHECK(isFocusedProp->propertyValue() == true);
CHECK(hasKeyedProp->propertyValue() == true);
CHECK(hasTextedProp->propertyValue() == true);
}
TEST_CASE("Focus traversal listener actions", "[silver]")
{
rive::SerializingFactory silver;
auto file = ReadRiveFile("assets/focus_traversal.riv", &silver);
auto artboard = file->artboardDefault();
REQUIRE(artboard != nullptr);
silver.frameSize(artboard->width(), artboard->height());
auto stateMachine = artboard->stateMachineAt(0);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
auto renderer = silver.makeRenderer();
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// There are 2 rows of buttons
// Top row: Top / Right / Down / Left
// Bottom row: Prev / Next
// Click on Next
stateMachine->pointerDown(rive::Vec2D(180, 450));
stateMachine->pointerUp(rive::Vec2D(180, 450));
stateMachine->advanceAndApply(0.016f);
// Second advance to apply focus changes
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Click on Prev twice to reenter focus tree
stateMachine->pointerDown(rive::Vec2D(60, 450));
stateMachine->pointerUp(rive::Vec2D(60, 450));
stateMachine->advanceAndApply(0.016f);
stateMachine->pointerDown(rive::Vec2D(60, 450));
stateMachine->pointerUp(rive::Vec2D(60, 450));
stateMachine->advanceAndApply(0.016f);
// Second advance to apply focus changes
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Click on Up
stateMachine->pointerDown(rive::Vec2D(60, 350));
stateMachine->pointerUp(rive::Vec2D(60, 350));
stateMachine->advanceAndApply(0.016f);
// Second advance to apply focus changes
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Click on Left
stateMachine->pointerDown(rive::Vec2D(420, 350));
stateMachine->pointerUp(rive::Vec2D(420, 350));
stateMachine->advanceAndApply(0.016f);
// Second advance to apply focus changes
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Click on Down
stateMachine->pointerDown(rive::Vec2D(300, 350));
stateMachine->pointerUp(rive::Vec2D(300, 350));
stateMachine->advanceAndApply(0.016f);
// Second advance to apply focus changes
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Click on Right
stateMachine->pointerDown(rive::Vec2D(180, 350));
stateMachine->pointerUp(rive::Vec2D(180, 350));
stateMachine->advanceAndApply(0.016f);
// Second advance to apply focus changes
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
CHECK(silver.matches("focus_traversal"));
}
TEST_CASE("Focus traversal clears focus when it reaches edge of root scope",
"[silver]")
{
rive::SerializingFactory silver;
auto file = ReadRiveFile("assets/focusable_element.riv", &silver);
auto artboard = file->artboardDefault();
REQUIRE(artboard != nullptr);
silver.frameSize(artboard->width(), artboard->height());
auto stateMachine = artboard->stateMachineAt(0);
auto vmi = file->createViewModelInstance(artboard.get());
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.1f);
auto renderer = silver.makeRenderer();
artboard->draw(renderer.get());
silver.addFrame();
stateMachine->focusManager()->focusNext();
stateMachine->advanceAndApply(0.1f);
artboard->draw(renderer.get());
silver.addFrame();
stateMachine->focusManager()->focusNext();
stateMachine->advanceAndApply(0.1f);
artboard->draw(renderer.get());
silver.addFrame();
stateMachine->focusManager()->focusNext();
stateMachine->advanceAndApply(0.1f);
artboard->draw(renderer.get());
silver.addFrame();
stateMachine->focusManager()->focusNext();
stateMachine->advanceAndApply(0.1f);
artboard->draw(renderer.get());
silver.addFrame();
stateMachine->focusManager()->focusNext();
stateMachine->advanceAndApply(0.1f);
artboard->draw(renderer.get());
silver.addFrame();
stateMachine->focusManager()->focusNext();
stateMachine->advanceAndApply(0.1f);
artboard->draw(renderer.get());
silver.addFrame();
stateMachine->focusManager()->focusNext();
stateMachine->advanceAndApply(0.1f);
artboard->draw(renderer.get());
CHECK(silver.matches("focusable_element"));
}
TEST_CASE("ArtboardComponentList list scope is registered on shared "
"FocusManager",
"[FocusManager][list]")
{
auto file = ReadRiveFile("assets/component_list_1.riv");
auto artboard = file->artboardNamed("Main");
REQUIRE(artboard != nullptr);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
REQUIRE(vmi != nullptr);
artboard->bindViewModelInstance(vmi);
auto sm = artboard->stateMachineAt(0);
REQUIRE(sm != nullptr);
artboard->advance(0.0f);
auto* list = artboard->find<rive::ArtboardComponentList>("List");
REQUIRE(list != nullptr);
auto* fm = artboard->focusManager();
REQUIRE(fm != nullptr);
artboard->buildFocusTree(artboard->focusManager(), nullptr);
auto scope = list->listScopeFocusNode();
REQUIRE(scope != nullptr);
CHECK(scope->manager() == fm);
CHECK(scope->name() == "ArtboardComponentListScope");
// Transparent structural scope: not a focus target itself; traversal
// descends through it (focusNodeTraversable) to reach item focusables.
CHECK(scope->canFocus() == false);
CHECK(scope->canTraverse() == false);
CHECK(scope->focusable() == nullptr);
}
TEST_CASE("List under Node: when parent has a direct FocusData, "
"findClosestFocusNode from list matches that node",
"[FocusManager][list]")
{
// buildFocusTreeVisit pass-1: at most one direct child FocusData per
// container; if present, its focusNode is the scope for siblings (e.g. the
// list host). The walk-based fallback from the old findClosest for the
// no-direct-FocusData case is not used by the focus build anymore.
auto file = ReadRiveFile("assets/component_list_1.riv");
auto artboard = file->artboardNamed("Main");
REQUIRE(artboard != nullptr);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
REQUIRE(vmi != nullptr);
artboard->bindViewModelInstance(vmi);
auto sm = artboard->stateMachineAt(0);
REQUIRE(sm != nullptr);
artboard->advance(0.0f);
auto* list = artboard->find<rive::ArtboardComponentList>("List");
REQUIRE(list != nullptr);
auto* p = list->parent();
REQUIRE(p != nullptr);
REQUIRE(p->is<rive::Node>());
rive::rcp<rive::FocusNode> fromFirstDirectFd;
for (auto* ch : p->as<rive::Node>()->children())
{
if (ch != nullptr && ch->is<rive::FocusData>())
{
fromFirstDirectFd = ch->as<rive::FocusData>()->focusNode();
break;
}
}
if (fromFirstDirectFd != nullptr)
{
CHECK(rive::FocusData::findClosestFocusNode(list) == fromFirstDirectFd);
}
}
// The test asset carries Luau bytecode scripts, which only the Luau
// backend runs.
#ifdef WITH_RIVE_SCRIPTING_LUAU
TEST_CASE("Focus is correctly built and updated for lists", "[silver]")
{
rive::SerializingFactory silver;
auto file = ReadRiveFile("assets/list_focus_order.riv", &silver);
auto artboard = file->artboardDefault();
REQUIRE(artboard != nullptr);
silver.frameSize(artboard->width(), artboard->height());
auto stateMachine = artboard->stateMachineAt(0);
auto focusManager = stateMachine->focusManager();
auto vmi = file->createDefaultViewModelInstance(artboard.get());
auto stageProcessedProp = vmi->propertyValue("stageProcessed")
->as<rive::ViewModelInstanceBoolean>();
auto stageCountProp =
vmi->propertyValue("stageCount")->as<rive::ViewModelInstanceNumber>();
auto renderer = silver.makeRenderer();
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Focuses on first element of tree
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Focuses on last element of list
focusManager->focusNext();
focusManager->focusNext();
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Inserts one element at end of list
stageProcessedProp->propertyValue(false);
stageCountProp->propertyValue(1);
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Focus is on that new element
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Focused elements is moved in the list and keeps focus
stageProcessedProp->propertyValue(false);
stageCountProp->propertyValue(2);
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Focusing on the next element correctly focuses on the next element on the
// list
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Removing the focused element from the list, clears the focus
stageProcessedProp->propertyValue(false);
stageCountProp->propertyValue(3);
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
// Focuses back on first element of tree
focusManager->focusNext();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
CHECK(silver.matches("list_focus_order"));
}
#endif
TEST_CASE("Focus based transitions work", "[silver]")
{
rive::SerializingFactory silver;
auto file = ReadRiveFile("assets/focus_test.riv", &silver);
auto artboard = file->artboardDefault();
REQUIRE(artboard != nullptr);
silver.frameSize(artboard->width(), artboard->height());
auto stateMachine = artboard->stateMachineAt(0);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
auto renderer = silver.makeRenderer();
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
stateMachine->pointerDown(rive::Vec2D(55.0, 65.0));
stateMachine->pointerUp(rive::Vec2D(55.0, 65.0));
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
stateMachine->pointerDown(rive::Vec2D(442.0, 65.0));
stateMachine->pointerUp(rive::Vec2D(442.0, 65.0));
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
CHECK(silver.matches("focus_test"));
}
TEST_CASE("List item focus tree stays under its row when the item's state "
"machine is (re)wired during the focus sync",
"[FocusManager][list]")
{
// Regression for the syncListRowNodesWithList ordering bug: each list
// item's state machine must be wired to the shared FocusManager BEFORE the
// item's focus tree is (re)built under its row. setExternalFocusManager
// rebuilds the item's focus tree at the manager ROOT as a side effect, so
// if it runs after the build-under-row it clobbers the row placement and
// the item's focus nodes end up detached from the list scope (at the
// manager root).
//
// The natural build path happens to wire the manager first (via
// linkStateMachineToArtboard, whose setExternalFocusManager runs before the
// row sync), so the in-loop call is normally skipped by the
// `smi->focusManager() != fm` guard. Force the mismatch to exercise the
// ordering directly.
auto file = ReadRiveFile("assets/list_focus_order.riv");
auto artboard = file->artboardDefault();
REQUIRE(artboard != nullptr);
auto stateMachine = artboard->stateMachineAt(0);
REQUIRE(stateMachine != nullptr);
auto* fm = stateMachine->focusManager();
REQUIRE(fm != nullptr);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
REQUIRE(vmi != nullptr);
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.016f);
REQUIRE(artboard->artboardComponentLists().size() == 1);
auto* list = artboard->artboardComponentLists()[0];
REQUIRE(list != nullptr);
const int itemCount = static_cast<int>(list->artboardCount());
REQUIRE(itemCount > 0);
// A row node with children means the item's focus subtree is parented under
// it (inside the list scope) — the invariant the bug breaks.
auto rowForItem = [&](int i) -> rive::FocusNode* {
auto scope = list->listScopeFocusNode();
if (scope == nullptr || i >= static_cast<int>(scope->children().size()))
{
return nullptr;
}
return scope->children()[static_cast<size_t>(i)].get();
};
// Pick a list item that (after the normal build) has focus content placed
// under its row AND owns a state machine — the only case where the in-loop
// setExternalFocusManager fires.
int targetIndex = -1;
for (int i = 0; i < itemCount; i++)
{
rive::FocusNode* row = rowForItem(i);
if (row != nullptr && !row->children().empty() &&
list->stateMachineInstance(i) != nullptr)
{
targetIndex = i;
break;
}
}
REQUIRE(targetIndex != -1);
// Force the mismatch: drop the item's shared-manager wiring so the next
// focus sync must call setExternalFocusManager(fm) again — the exact call
// whose manager-root rebuild would clobber the row placement if it ran
// after the build-under-row.
list->stateMachineInstance(targetIndex)->setExternalFocusManager(nullptr);
CHECK(list->stateMachineInstance(targetIndex)->focusManager() != fm);
// Re-run the parent focus build; this recreates the list scope/rows and
// re-syncs each item under its row.
artboard->cleanupFocusTree();
artboard->buildFocusTree(fm, nullptr);
// With the fix (wire first, place last) the item's focus subtree is
// parented under its row inside the list scope. With the bug it was rebuilt
// at the manager root, leaving the row empty.
rive::FocusNode* targetRow = rowForItem(targetIndex);
REQUIRE(targetRow != nullptr);
CHECK(targetRow->manager() == fm);
CHECK_FALSE(targetRow->children().empty());
CHECK(list->stateMachineInstance(targetIndex)->focusManager() == fm);
}
TEST_CASE("State machines over one artboard instance share the artboard's "
"FocusManager",
"[FocusManager][list]")
{
// The FocusManager belongs to the artboard, not to a state machine. A
// second StateMachineInstance over the same ArtboardInstance must reuse it
// rather than stand up a second manager and migrate every FocusNode onto
// it. That migration is what left persistent nodes -- the component list's
// scope and row nodes, which outlive any state machine -- stamped with a
// manager that could later die while they still pointed at it.
auto file = ReadRiveFile("assets/list_focus_order.riv");
auto artboard = file->artboardDefault();
REQUIRE(artboard != nullptr);
// Root instances own a manager from the moment they are instanced, before
// any state machine exists.
auto* fm = artboard->focusManager();
REQUIRE(fm != nullptr);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
REQUIRE(vmi != nullptr);
artboard->bindViewModelInstance(vmi);
auto first = artboard->stateMachineAt(0);
REQUIRE(first != nullptr);
CHECK(first->focusManager() == fm);
first->advanceAndApply(0.016f);
REQUIRE(artboard->artboardComponentLists().size() == 1);
auto* list = artboard->artboardComponentLists()[0];
REQUIRE(list->listScopeFocusNode() != nullptr);
REQUIRE(list->listScopeFocusNode()->manager() == fm);
// This is the shape the Android controller produces: an input queued for a
// state machine that has not been instanced yet builds a second one over
// the live artboard.
auto second = artboard->stateMachineAt(0);
REQUIRE(second != nullptr);
CHECK(second->focusManager() == fm);
CHECK(first->focusManager() == fm);
CHECK(artboard->focusManager() == fm);
// The list's persistent nodes were not migrated onto a different manager.
auto scope = list->listScopeFocusNode();
REQUIRE(scope != nullptr);
CHECK(scope->manager() == fm);
for (auto& row : scope->children())
{
CHECK(row->manager() == fm);
}
CHECK(fm->focusNext() == true);
CHECK(fm->primaryFocus() != nullptr);
}
TEST_CASE("Destroying one state machine leaves another's focus tree intact",
"[FocusManager][list]")
{
// ~StateMachineInstance used to call cleanupFocusTree() whenever it owned
// the manager, ripping out a tree a second state machine over the same
// artboard was still using. With the manager owned by the artboard there
// is nothing for a state machine to tear down.
auto file = ReadRiveFile("assets/list_focus_order.riv");
auto artboard = file->artboardDefault();
REQUIRE(artboard != nullptr);
auto* fm = artboard->focusManager();
REQUIRE(fm != nullptr);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
REQUIRE(vmi != nullptr);
artboard->bindViewModelInstance(vmi);
auto first = artboard->stateMachineAt(0);
REQUIRE(first != nullptr);
first->advanceAndApply(0.016f);
auto second = artboard->stateMachineAt(0);
REQUIRE(second != nullptr);
REQUIRE(artboard->artboardComponentLists().size() == 1);
auto* list = artboard->artboardComponentLists()[0];
REQUIRE(list->listScopeFocusNode() != nullptr);
first.reset();
// The manager, the artboard's pointer to it, and the list's scope all
// outlive the first state machine.
CHECK(artboard->focusManager() == fm);
CHECK(second->focusManager() == fm);
auto scope = list->listScopeFocusNode();
REQUIRE(scope != nullptr);
CHECK(scope->manager() == fm);
// And the surviving state machine can still drive focus through it.
CHECK(fm->focusNext() == true);
CHECK(fm->primaryFocus() != nullptr);
second->advanceAndApply(0.016f);
CHECK(fm->primaryFocus() != nullptr);
}
TEST_CASE("Swappable artboard slot keeps its place in tab order",
"[FocusManager]")
{
// File: https://editor.uat.rive.app/file/untitled/36028
auto file = ReadRiveFile("assets/swappable_artboards_focus.riv");
auto artboard = file->artboardNamed("Main");
REQUIRE(artboard != nullptr);
auto stateMachine = artboard->stateMachineAt(0);
REQUIRE(stateMachine != nullptr);
auto* focusManager = stateMachine->focusManager();
REQUIRE(focusManager != nullptr);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
REQUIRE(vmi != nullptr);
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.016f);
stateMachine->advanceAndApply(0.016f);
// Only the data-bound slot is flagged as swappable; static nested
// artboards get no placeholder scope regardless of whether their artboard
// contains focusables.
rive::NestedArtboard* slotHost = nullptr;
for (auto* host : artboard->nestedArtboards())
{
auto* source = host->sourceArtboard();
REQUIRE(source != nullptr);
if (source->name() == "Swappable1" || source->name() == "Swappable2")
{
CHECK(host->isArtboardDataBound() == true);
slotHost = host;
}
else
{
CHECK(host->isArtboardDataBound() == false);
}
}
REQUIRE(slotHost != nullptr);
CHECK(stateMachine->hasFocusNodes() == true);
// The artboard owning the currently focused element.
auto focusedArtboardName = [&]() -> std::string {
auto* ab = focusManager->primaryFocusImmediateArtboard();
return ab != nullptr ? ab->name() : "<none>";
};
// Initial tab order follows the Main hierarchy: Rectangle (Main) -> slot
// (Swappable1) -> StaticNestWithFocusable. StaticNestWithoutFocusable
// contributes nothing.
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "Main");
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "Swappable1");
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "StaticNestWithFocusable");
// Edge of the root scope clears focus.
CHECK(stateMachine->focusNext() == false);
CHECK(focusManager->primaryFocus() == nullptr);
// Swap the slot to an artboard with no focusables: the slot contributes
// no focus stop and the rest of the order is untouched.
auto* artboardProp = vmi->propertyValue("artboardProp");
REQUIRE(artboardProp != nullptr);
REQUIRE(artboardProp->is<rive::ViewModelInstanceArtboard>());
auto* vmiArtboard = artboardProp->as<rive::ViewModelInstanceArtboard>();
auto swappable2 = file->bindableArtboardNamed("Swappable2");
REQUIRE(swappable2 != nullptr);
vmiArtboard->asset(swappable2);
stateMachine->advanceAndApply(0.016f);
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "Main");
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "StaticNestWithFocusable");
CHECK(stateMachine->focusNext() == false);
// Focus the Main rectangle, then swap back to the focusable artboard:
// focus held elsewhere survives the (unrelated) swap...
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "Main");
auto heldFocus = focusManager->primaryFocus();
auto swappable1 = file->bindableArtboardNamed("Swappable1");
REQUIRE(swappable1 != nullptr);
vmiArtboard->asset(swappable1);
stateMachine->advanceAndApply(0.016f);
CHECK(focusManager->primaryFocus() == heldFocus);
CHECK(focusedArtboardName() == "Main");
// ...and the swapped-in focusable takes the slot's place in the middle of
// the tab order (its hierarchy position), not the end.
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "Swappable1");
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "StaticNestWithFocusable");
CHECK(stateMachine->focusNext() == false);
}
TEST_CASE("Repeat focus-tree build keeps focus inside an untouched nested "
"artboard",
"[FocusManager]")
{
// #4 regression: a second full buildFocusTree pass over an already-wired
// tree (same manager) must not tear down and rebuild nested artboards that
// did not change — doing so blurs focus resting inside them. Only the
// non-destructive scope placement should run on the repeat pass.
auto file = ReadRiveFile("assets/swappable_artboards_focus.riv");
auto artboard = file->artboardNamed("Main");
REQUIRE(artboard != nullptr);
auto stateMachine = artboard->stateMachineAt(0);
REQUIRE(stateMachine != nullptr);
auto* focusManager = stateMachine->focusManager();
REQUIRE(focusManager != nullptr);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
REQUIRE(vmi != nullptr);
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.016f);
stateMachine->advanceAndApply(0.016f);
auto focusedArtboardName = [&]() -> std::string {
auto* ab = focusManager->primaryFocusImmediateArtboard();
return ab != nullptr ? ab->name() : "<none>";
};
// Tab into the focusable that lives inside the STATIC nested artboard.
// Order (established by the sibling test): Main -> Swappable1 ->
// StaticNestWithFocusable.
CHECK(stateMachine->focusNext() == true);
CHECK(stateMachine->focusNext() == true);
CHECK(stateMachine->focusNext() == true);
REQUIRE(focusedArtboardName() == "StaticNestWithFocusable");
auto heldFocus = focusManager->primaryFocus();
REQUIRE(heldFocus != nullptr);
// Repeat the full build pass with the SAME manager (mirrors the host's
// documented two-phase build, or any later focus-tree re-wire). Nothing
// about the static nested artboard changed, so the focus resting inside it
// must survive rather than being blurred by a needless rebuild.
artboard->buildFocusTree(focusManager, nullptr);
CHECK(focusManager->primaryFocus() == heldFocus);
CHECK(focusedArtboardName() == "StaticNestWithFocusable");
}
TEST_CASE("Cross-file swaps keep slot order and share the focus manager",
"[FocusManager]")
{
// The slot's host, bind, and scope all live in the main file; the
// swapped-in artboard may come from a different .riv. Loading the asset
// twice yields two independent Files, so pulling bindable artboards from
// the second File exercises the cross-file path.
auto file = ReadRiveFile("assets/swappable_artboards_focus.riv");
auto otherFile = ReadRiveFile("assets/swappable_artboards_focus.riv");
auto artboard = file->artboardNamed("Main");
REQUIRE(artboard != nullptr);
auto stateMachine = artboard->stateMachineAt(0);
REQUIRE(stateMachine != nullptr);
auto* focusManager = stateMachine->focusManager();
REQUIRE(focusManager != nullptr);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
REQUIRE(vmi != nullptr);
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.016f);
auto focusedArtboard = [&]() -> rive::Artboard* {
return focusManager->primaryFocusImmediateArtboard();
};
auto focusedArtboardName = [&]() -> std::string {
auto* ab = focusedArtboard();
return ab != nullptr ? ab->name() : "<none>";
};
// The slot host's bound state machine (created by the latest swap).
auto slotBoundStateMachine = [&]() -> rive::StateMachineInstance* {
for (auto* host : artboard->nestedArtboards())
{
if (!host->isArtboardDataBound())
{
continue;
}
for (auto* animation : host->nestedAnimations())
{
if (animation->is<rive::NestedStateMachine>())
{
return animation->as<rive::NestedStateMachine>()
->stateMachineInstance();
}
}
}
return nullptr;
};
auto* artboardProp = vmi->propertyValue("artboardProp");
REQUIRE(artboardProp != nullptr);
REQUIRE(artboardProp->is<rive::ViewModelInstanceArtboard>());
auto* vmiArtboard = artboardProp->as<rive::ViewModelInstanceArtboard>();
// Swap in a LEAF artboard (one focusable, no nested hosts) from the
// other file.
auto foreignSwappable = otherFile->bindableArtboardNamed("Swappable1");
REQUIRE(foreignSwappable != nullptr);
vmiArtboard->asset(foreignSwappable);
stateMachine->advanceAndApply(0.016f);
// The foreign artboard's focus node sits at the slot's hierarchy
// position, exactly like a same-file swap.
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "Main");
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "Swappable1");
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "StaticNestWithFocusable");
CHECK(stateMachine->focusNext() == false);
// The swapped-in artboard's own state machine must share the parent
// FocusManager, so its focus/keyboard listener groups act on the same
// focus state that Tab traversal uses.
auto* leafSmi = slotBoundStateMachine();
REQUIRE(leafSmi != nullptr);
CHECK(leafSmi->focusManager() == focusManager);
}
TEST_CASE("Unresolvable artboard swap leaves focus and tab order untouched",
"[FocusManager]")
{
auto file = ReadRiveFile("assets/swappable_artboards_focus.riv");
auto artboard = file->artboardNamed("Main");
REQUIRE(artboard != nullptr);
auto stateMachine = artboard->stateMachineAt(0);
REQUIRE(stateMachine != nullptr);
auto* focusManager = stateMachine->focusManager();
REQUIRE(focusManager != nullptr);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
REQUIRE(vmi != nullptr);
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.016f);
stateMachine->advanceAndApply(0.016f);
auto focusedArtboardName = [&]() -> std::string {
auto* ab = focusManager->primaryFocusImmediateArtboard();
return ab != nullptr ? ab->name() : "<none>";
};
// Default order (per the sibling test): Main -> Swappable1 ->
// StaticNestWithFocusable. Rest focus on Main's Rectangle and hold the rcp.
CHECK(stateMachine->focusNext() == true);
REQUIRE(focusedArtboardName() == "Main");
auto heldFocus = focusManager->primaryFocus();
REQUIRE(heldFocus != nullptr);
// Drive the slot's VM artboard property into the UNRESOLVABLE state: no
// bindable asset and a bogus (non -1) id that matches no artboard. This is
// distinct from an explicit clear (asset null AND propertyValue == -1), so
// updateArtboard must return early and leave the on-screen slot alone.
auto* artboardProp = vmi->propertyValue("artboardProp");
REQUIRE(artboardProp != nullptr);
REQUIRE(artboardProp->is<rive::ViewModelInstanceArtboard>());
auto* vmiArtboard = artboardProp->as<rive::ViewModelInstanceArtboard>();
vmiArtboard->propertyValue(9999u);
REQUIRE(vmiArtboard->asset() == nullptr);
REQUIRE(vmiArtboard->propertyValue() != static_cast<uint32_t>(-1));
stateMachine->advanceAndApply(0.016f);
// Focus held on Main survives the failed swap...
CHECK(focusManager->primaryFocus() == heldFocus);
CHECK(focusedArtboardName() == "Main");
// ...and the outgoing Swappable1 kept its focus nodes, so the full tab
// order is unchanged: Main -> Swappable1 -> StaticNestWithFocusable.
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "Swappable1");
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "StaticNestWithFocusable");
CHECK(stateMachine->focusNext() == false);
}
TEST_CASE("Initially-empty bindable slot keeps its authored tab position on "
"first swap",
"[FocusManager]")
{
auto file = ReadRiveFile("assets/swappable_artboards_focus.riv");
auto artboard = file->artboardNamed("Main");
REQUIRE(artboard != nullptr);
auto stateMachine = artboard->stateMachineAt(0);
REQUIRE(stateMachine != nullptr);
auto* focusManager = stateMachine->focusManager();
REQUIRE(focusManager != nullptr);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
REQUIRE(vmi != nullptr);
// Clear the slot to explicit null (asset null, propertyValue -1) BEFORE the
// first advance, so the slot is empty when the focus tree is first built.
auto* artboardProp = vmi->propertyValue("artboardProp");
REQUIRE(artboardProp != nullptr);
REQUIRE(artboardProp->is<rive::ViewModelInstanceArtboard>());
auto* vmiArtboard = artboardProp->as<rive::ViewModelInstanceArtboard>();
vmiArtboard->asset(nullptr);
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.016f);
stateMachine->advanceAndApply(0.016f);
auto focusedArtboardName = [&]() -> std::string {
auto* ab = focusManager->primaryFocusImmediateArtboard();
return ab != nullptr ? ab->name() : "<none>";
};
// The empty slot's scope holds its place but offers no focus stop, so the
// order skips it: Main -> StaticNestWithFocusable.
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "Main");
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "StaticNestWithFocusable");
CHECK(stateMachine->focusNext() == false);
// Swap Swappable1 in for the first time: it must build under the scope the
// empty-slot build pass already placed, entering the MIDDLE of the tab
// order (Main -> Swappable1 -> StaticNestWithFocusable), not the end.
auto swappable1 = file->bindableArtboardNamed("Swappable1");
REQUIRE(swappable1 != nullptr);
vmiArtboard->asset(swappable1);
stateMachine->advanceAndApply(0.016f);
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "Main");
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "Swappable1");
CHECK(stateMachine->focusNext() == true);
CHECK(focusedArtboardName() == "StaticNestWithFocusable");
CHECK(stateMachine->focusNext() == false);
}
TEST_CASE("Focus bounds track a nested artboard host that moves",
"[FocusManager]")
{
// The focusable's own layout geometry never changes here -- only the
// NestedArtboard hosting it slides. The bounds cached on the FocusNode
// during the update pass are written from that unchanged geometry, so they
// describe where the element used to be. FocusData::worldBounds recomputes
// through the root transform at call time, which is what keeps a focus
// bracket attached to the element as its host animates.
auto file = ReadRiveFile("assets/focus_bounds_moving_host.riv");
auto artboard = file->artboardDefault();
REQUIRE(artboard != nullptr);
auto stateMachine = artboard->stateMachineAt(0);
REQUIRE(stateMachine != nullptr);
// Settle without consuming time so the host is still at its authored
// position when the first bounds are read. The scene focuses itself: the
// hosted artboard's entry state fires an event at start and its own
// listener performs the FocusActionTarget.
stateMachine->advanceAndApply(0.0f);
stateMachine->advanceAndApply(0.0f);
auto* focusManager = stateMachine->focusManager();
REQUIRE(focusManager != nullptr);
REQUIRE(focusManager->primaryFocus() != nullptr);
rive::AABB atRest;
REQUIRE(focusManager->primaryFocusBounds(atRest) == true);
// Host authored at (100, 100); the target layout sits at its artboard's
// origin, since yoga owns a LayoutComponent's position and ignores the
// node's own x/y. Anchoring the start makes a drift in absolute placement
// visible, not just a wrong delta.
CHECK(atRest.minX == Approx(100.0f).margin(0.5f));
CHECK(atRest.minY == Approx(100.0f).margin(0.5f));
CHECK(atRest.width() == Approx(120.0f).margin(0.5f));
CHECK(atRest.height() == Approx(80.0f).margin(0.5f));
// Run the slide halfway: the full travel is 200pt right and 60pt down over
// 60 frames, linearly. Stop at 30 rather than 60 -- the animation
// ping-pongs, so the far end is a turning point and float accumulation
// could land either side of it.
for (int i = 0; i < 30; i++)
{
stateMachine->advanceAndApply(1.0f / 60.0f);
}
rive::AABB moved;
REQUIRE(focusManager->primaryFocusBounds(moved) == true);
CHECK(moved.minX == Approx(atRest.minX + 100.0f).margin(0.5f));
CHECK(moved.minY == Approx(atRest.minY + 30.0f).margin(0.5f));
// The element itself did not resize; only its host moved.
CHECK(moved.width() == Approx(atRest.width()).margin(0.5f));
CHECK(moved.height() == Approx(atRest.height()).margin(0.5f));
}
TEST_CASE("Focus change with gamepad navigation", "[silver]")
{
rive::SerializingFactory silver;
auto file = ReadRiveFile("assets/gamepad_inputs_test.riv", &silver);
auto artboard = file->artboardDefault();
REQUIRE(artboard != nullptr);
silver.frameSize(artboard->width(), artboard->height());
auto stateMachine = artboard->stateMachineAt(0);
auto vmi = file->createViewModelInstance(artboard.get());
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.0f);
auto renderer = silver.makeRenderer();
artboard->draw(renderer.get());
silver.addFrame();
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
// An update is only accepted for a device the state machine has already
// seen connected, so announce the pad before pressing anything.
constexpr int32_t kDeviceId = 0;
rive::GamepadWire connect;
connect.connected(kDeviceId);
REQUIRE(stateMachine->submitGamepadsFromBuffer(connect.buf.data(),
connect.buf.size()));
silver.addFrame();
rive::GamepadWire press;
press.button(kDeviceId, rive::StandardGamepadButton::rightShoulder, 1.0f);
REQUIRE(stateMachine->submitGamepadsFromBuffer(press.buf.data(),
press.buf.size()));
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
rive::GamepadWire release;
release.button(kDeviceId, rive::StandardGamepadButton::rightShoulder, 0.0f);
REQUIRE(stateMachine->submitGamepadsFromBuffer(release.buf.data(),
release.buf.size()));
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
CHECK(silver.matches("gamepad_inputs_test"));
}
TEST_CASE("Uncollapse and focus element on the same action", "[silver]")
{
rive::SerializingFactory silver;
auto file = ReadRiveFile("assets/gamepad_inputs_test.riv", &silver);
auto artboard = file->artboardNamed("UncollapsedParent");
REQUIRE(artboard != nullptr);
silver.frameSize(artboard->width(), artboard->height());
auto stateMachine = artboard->stateMachineAt(0);
auto vmi = file->createDefaultViewModelInstance(artboard.get());
stateMachine->bindViewModelInstance(vmi);
stateMachine->advanceAndApply(0.0f);
auto renderer = silver.makeRenderer();
artboard->draw(renderer.get());
silver.addFrame();
stateMachine->pointerDown(rive::Vec2D(475.0f, 475.0f));
stateMachine->pointerUp(rive::Vec2D(475.0f, 475.0f));
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
silver.addFrame();
stateMachine->pointerDown(rive::Vec2D(475.0f, 475.0f));
stateMachine->pointerUp(rive::Vec2D(475.0f, 475.0f));
stateMachine->advanceAndApply(0.016f);
artboard->draw(renderer.get());
CHECK(silver.matches("gamepad_inputs_test-collapsing"));
}