20 ContainerBase(
Components children,
int* selector)
21 : selector_(selector ? selector : &selected_) {
23 Add(std::move(child));
28 bool OnEvent(Event event)
override {
29 if (event.is_mouse()) {
30 return OnMouseEvent(event);
41 return EventHandler(event);
45 if (children_.empty()) {
49 return children_[
static_cast<size_t>(*selector_) % children_.size()];
53 for (
size_t i = 0; i < children_.size(); ++i) {
54 if (children_[i].get() == child) {
55 *selector_ =
static_cast<int>(i);
63 virtual bool EventHandler(Event ) {
return false; }
65 virtual bool OnMouseEvent(Event event) {
70 int* selector_ =
nullptr;
72 void MoveSelector(
int dir) {
73 for (
int i = *selector_ + dir; i >= 0 && i < int(children_.size());
75 if (children_[i]->Focusable()) {
82 void MoveSelectorWrap(
int dir) {
83 if (children_.empty()) {
86 for (
size_t offset = 1; offset < children_.size(); ++offset) {
88 (*selector_ + offset * dir + children_.size()) % children_.size();
89 if (children_[i]->Focusable()) {
97class VerticalContainer :
public ContainerBase {
99 using ContainerBase::ContainerBase;
103 elements.reserve(children_.size());
104 for (
auto& it : children_) {
105 elements.push_back(it->Render());
107 if (elements.empty()) {
113 bool EventHandler(Event event)
override {
114 const int old_selected = *selector_;
122 for (
int i = 0; i < box_.y_max - box_.y_min; ++i) {
127 for (
int i = 0; i < box_.y_max - box_.y_min; ++i) {
132 for (
size_t i = 0; i < children_.size(); ++i) {
137 for (
size_t i = 0; i < children_.size(); ++i) {
142 MoveSelectorWrap(+1);
145 MoveSelectorWrap(-1);
148 *selector_ = std::max(0, std::min(
int(children_.size()) - 1, *selector_));
149 return old_selected != *selector_;
152 bool OnMouseEvent(Event event)
override {
153 if (ContainerBase::OnMouseEvent(event)) {
162 if (!box_.Contain(event.mouse().x, event.mouse().y)) {
166 const int old_selected = *selector_;
173 *selector_ = std::max(0, std::min(
int(children_.size()) - 1, *selector_));
175 return old_selected != *selector_;
181class HorizontalContainer :
public ContainerBase {
183 using ContainerBase::ContainerBase;
187 elements.reserve(children_.size());
188 for (
auto& it : children_) {
189 elements.push_back(it->Render());
191 if (elements.empty()) {
192 return text(
"Empty container");
194 return hbox(std::move(elements));
197 bool EventHandler(Event event)
override {
198 const int old_selected = *selector_;
206 MoveSelectorWrap(+1);
209 MoveSelectorWrap(-1);
212 *selector_ = std::max(0, std::min(
int(children_.size()) - 1, *selector_));
213 return old_selected != *selector_;
217class TabContainer :
public ContainerBase {
219 using ContainerBase::ContainerBase;
224 return active_child->Render();
226 return text(
"Empty container");
229 bool Focusable()
const override {
230 if (children_.empty()) {
233 return children_[size_t(*selector_) % children_.size()]->Focusable();
236 bool OnMouseEvent(Event event)
override {
241class StackedContainer :
public ContainerBase {
243 explicit StackedContainer(
Components children)
244 : ContainerBase(std::move(children), nullptr) {}
249 for (
auto& child : children_) {
250 elements.push_back(child->Render());
253 std::reverse(elements.begin(), elements.end());
254 return dbox(std::move(elements));
257 bool Focusable() const final {
258 for (
const auto& child : children_) {
259 if (child->Focusable()) {
267 if (children_.empty()) {
274 if (children_.empty()) {
281 std::find_if(children_.begin(), children_.end(),
282 [child](
const Component& c) { return c.get() == child; });
283 if (it == children_.end()) {
286 std::rotate(children_.begin(), it, it + 1);
289 bool OnEvent(Event event)
final {
290 for (
auto& child : children_) {
291 if (child->OnEvent(event)) {
318 return Vertical(std::move(children),
nullptr);
340 return std::make_shared<VerticalContainer>(std::move(children), selector);
361 return Horizontal(std::move(children),
nullptr);
383 return std::make_shared<HorizontalContainer>(std::move(children), selector);
406 return std::make_shared<TabContainer>(std::move(children), selector);
433 return std::make_shared<StackedContainer>(std::move(children));
It implement rendering itself as ftxui::Element. It implement keyboard navigation by responding to ft...
virtual Component ActiveChild()
Return the currently Active child.
virtual void SetActiveChild(ComponentBase *child)
Make the |child| to be the "active" one.
virtual bool OnEvent(Event)
Called in response to an event.
ComponentBase(Components children)
Component Horizontal(Components children)
A list of components, drawn one by one horizontally and navigated horizontally using left/right arrow...
Component Vertical(Components children)
A list of components, drawn one by one vertically and navigated vertically using up/down arrow key or...
Component Stacked(Components children)
A list of components to be stacked on top of each other. Events are propagated to the first component...
Component Tab(Components children, int *selector)
A list of components, where only one is drawn and interacted with at a time. The |selector| gives the...
std::shared_ptr< Node > Element
std::vector< Component > Components
Element hbox(Elements)
A container displaying elements horizontally one by one.
std::vector< Element > Elements
Element text(std::wstring text)
Display a piece of unicode text.
Element dbox(Elements)
Stack several element on top of each other.
Decorator reflect(Box &box)
std::shared_ptr< ComponentBase > Component
Element vbox(Elements)
A container displaying elements vertically one by one.
static const Event TabReverse
static const Event PageUp
static Event Character(std::string)
An event corresponding to a given typed character.
static const Event ArrowUp
static const Event ArrowDown
static const Event PageDown
static const Event ArrowLeft
static const Event ArrowRight