Unfocusable child selected

[CoinFuMasterShifu]

The

  int selected_ = 0;
  int* selector_ = nullptr;

members of ContainerBase should be updated to point to a valid focusable child when some child becomes unfocusable. I had a case where I used Maybe() with several Button()s in a Container::Horizontal() nested in a Container::Vertical() and when the button was made unfocusable, when I focused again on the horizontal container, no button was highlighted because selector_ was not updated.

[CoinFuMasterShifu]

To me it looks like FTXUI suffers from a poor design choice and I will try to elaborate:
This is the definition of the Maybe convenience function:

/// @brief Decorate a component |child|. It is shown only when |show| returns
/// true.
/// @param child the component to decorate.
/// @param show a function returning whether |child| should shown.
/// @ingroup component
Component Maybe(Component child, std::function<bool()> show) {
  class Impl : public ComponentBase {
   public:
    explicit Impl(std::function<bool()> show) : show_(std::move(show)) {}

   private:
    Element OnRender() override {
      return show_() ? ComponentBase::OnRender() : std::make_unique<Node>();
    }
    bool Focusable() const override {
      return show_() && ComponentBase::Focusable();
    }
    bool OnEvent(Event event) override {
      return show_() && ComponentBase::OnEvent(event);
    }

    std::function<bool()> show_;
  };

  auto maybe = Make<Impl>(std::move(show));
  maybe->Add(std::move(child));
  return maybe;
}

As I have already written in #1181 hiding the implementation in the cpp files is the root of the evil in my opinion. Since only the base class ComponentBase is usable by the user, not the local Impl definition, the author has decided to base the boolean criterion whether the element is available to be a std::function<bool()> call.

The problem with this design is that we cannot know when the value changes. It would be much better to just have a boolean bool bshow as a private property that can be controlled with a public member void set_enabled(bool) which sets the value AND also reports value changes to parent components. Making such a member usable would require to expose the definition Impl to the header files named something like MaybeBase. Then one could have access to the set_enabled member.

Then I would also implement some code like this

/// @brief Call all the ancestors' OnActiveChildFocusableChange callback.
void ComponentBase::OnFocusableChanged() {
  auto* current = this;
  while (current->Active()) {
        current = current->parent_;
        if (!current) 
            break;
        current->OnActiveChildFocusableChange();
  }
}

void ComponentBase::OnActiveChildFocusableChange(){
}

where OnActiveChildFocusableChange is virtual and can be overridden by implementations such as ContainerBase to adapt the int* selector_ = nullptr; member to some focusable alternative if the active child turned unfocusable.

The problem with the current design is that we cannot really place the trigger of such change checks because we don't konw when the underlying std::function<bool()> show_; returned value changes.