Rename field.

include/ftxui/dom/requirement.hpp

@@ -20,8 +20,8 @@ struct Requirement {
   int flex_shrink_y = 0;
 
   // Focus management to support the frame/focus/select element.
-  bool is_selected = false;
-  Box selected_box;
+  bool is_focused = false;
+  Box focused_box;
 };
 
 }  // namespace ftxui

src/ftxui/dom/border.cpp

@@ -54,10 +54,10 @@ class Border : public Node {
       requirement_.min_x =
           std::max(requirement_.min_x, children_[1]->requirement().min_x + 2);
     }
-    requirement_.selected_box.x_min++;
-    requirement_.selected_box.x_max++;
-    requirement_.selected_box.y_min++;
-    requirement_.selected_box.y_max++;
+    requirement_.focused_box.x_min++;
+    requirement_.focused_box.x_max++;
+    requirement_.focused_box.y_min++;
+    requirement_.focused_box.y_max++;
   }
 
   void SetBox(Box box) override {
@@ -145,10 +145,10 @@ class BorderPixel : public Node {
       requirement_.min_x =
           std::max(requirement_.min_x, children_[1]->requirement().min_x + 2);
     }
-    requirement_.selected_box.x_min++;
-    requirement_.selected_box.x_max++;
-    requirement_.selected_box.y_min++;
-    requirement_.selected_box.y_max++;
+    requirement_.focused_box.x_min++;
+    requirement_.focused_box.x_max++;
+    requirement_.focused_box.y_min++;
+    requirement_.focused_box.y_max++;
   }
 
   void SetBox(Box box) override {

src/ftxui/dom/dbox.cpp

@@ -27,17 +27,17 @@ class DBox : public Node {
     requirement_.flex_grow_y = 0;
     requirement_.flex_shrink_x = 0;
     requirement_.flex_shrink_y = 0;
-    requirement_.is_selected = false;
+    requirement_.is_focused = false;
     for (auto& child : children_) {
       child->ComputeRequirement();
       requirement_.min_x =
           std::max(requirement_.min_x, child->requirement().min_x);
       requirement_.min_y =
           std::max(requirement_.min_y, child->requirement().min_y);
 
-      if (!requirement_.is_selected && child->requirement().is_selected) {
-        requirement_.is_selected = true;
-        requirement_.selected_box = child->requirement().selected_box;
+      if (!requirement_.is_focused && child->requirement().is_focused) {
+        requirement_.is_focused = true;
+        requirement_.focused_box = child->requirement().focused_box;
       }
     }
   }

src/ftxui/dom/flexbox.cpp

@@ -104,8 +104,8 @@ class Flexbox : public Node {
     Layout(global, true);
 
     // Reset:
-    requirement_.is_selected = false;
-    requirement_.selected_box = Box();
+    requirement_.is_focused = false;
+    requirement_.focused_box = Box();
     requirement_.min_x = 0;
     requirement_.min_y = 0;
 
@@ -130,20 +130,20 @@ class Flexbox : public Node {
 
     // Find the selection:
     for (size_t i = 0; i < children_.size(); ++i) {
-      if (requirement_.is_selected ||
-          !children_[i]->requirement().is_selected) {
+      if (requirement_.is_focused ||
+          !children_[i]->requirement().is_focused) {
         continue;
       }
-      requirement_.is_selected = true;
-      Box selected_box = children_[i]->requirement().selected_box;
+      requirement_.is_focused = true;
+      Box focused_box = children_[i]->requirement().focused_box;
 
-      // Shift |selected_box| according to its position inside this component:
+      // Shift |focused_box| according to its position inside this component:
       auto& b = global.blocks[i];
-      selected_box.x_min += b.x;
-      selected_box.y_min += b.y;
-      selected_box.x_max += b.x;
-      selected_box.y_max += b.y;
-      requirement_.selected_box = Box::Intersection(selected_box, box);
+      focused_box.x_min += b.x;
+      focused_box.y_min += b.y;
+      focused_box.x_max += b.x;
+      focused_box.y_max += b.y;
+      requirement_.focused_box = Box::Intersection(focused_box, box);
     }
   }
 

src/ftxui/dom/focus.cpp

@@ -36,9 +36,9 @@ Decorator focusPositionRelative(float x, float y) {
 
     void ComputeRequirement() override {
       NodeDecorator::ComputeRequirement();
-      requirement_.is_selected = false;
+      requirement_.is_focused = false;
 
-      Box& box = requirement_.selected_box;
+      Box& box = requirement_.focused_box;
       box.x_min = int(float(requirement_.min_x) * x_);
       box.y_min = int(float(requirement_.min_y) * y_);
       box.x_max = int(float(requirement_.min_x) * x_);
@@ -75,9 +75,9 @@ Decorator focusPosition(int x, int y) {
 
     void ComputeRequirement() override {
       NodeDecorator::ComputeRequirement();
-      requirement_.is_selected = false;
+      requirement_.is_focused = false;
 
-      Box& box = requirement_.selected_box;
+      Box& box = requirement_.focused_box;
       box.x_min = x_;
       box.y_min = y_;
       box.x_max = x_;

src/ftxui/dom/frame.cpp

@@ -22,12 +22,12 @@ class Focus : public Node {
   void ComputeRequirement() override {
     Node::ComputeRequirement();
     requirement_ = children_[0]->requirement();
-    auto& selected_box = requirement_.selected_box;
-    selected_box.x_min = 0;
-    selected_box.y_min = 0;
-    selected_box.x_max = requirement_.min_x - 1;
-    selected_box.y_max = requirement_.min_y - 1;
-    requirement_.is_selected = true;
+    auto& focused_box = requirement_.focused_box;
+    focused_box.x_min = 0;
+    focused_box.y_min = 0;
+    focused_box.x_max = requirement_.min_x - 1;
+    focused_box.y_max = requirement_.min_y - 1;
+    requirement_.is_focused = true;
   }
 
   void SetBox(Box box) override {
@@ -48,14 +48,14 @@ class Frame : public Node {
 
   void SetBox(Box box) override {
     Node::SetBox(box);
-    auto& selected_box = requirement_.selected_box;
+    auto& focused_box = requirement_.focused_box;
     Box children_box = box;
 
     if (x_frame_) {
       const int external_dimx = box.x_max - box.x_min;
       const int internal_dimx = std::max(requirement_.min_x, external_dimx);
-      const int focused_dimx = selected_box.x_max - selected_box.x_min;
-      int dx = selected_box.x_min - external_dimx / 2 + focused_dimx / 2;
+      const int focused_dimx = focused_box.x_max - focused_box.x_min;
+      int dx = focused_box.x_min - external_dimx / 2 + focused_dimx / 2;
       dx = std::max(0, std::min(internal_dimx - external_dimx - 1, dx));
       children_box.x_min = box.x_min - dx;
       children_box.x_max = box.x_min + internal_dimx - dx;
@@ -64,8 +64,8 @@ class Frame : public Node {
     if (y_frame_) {
       const int external_dimy = box.y_max - box.y_min;
       const int internal_dimy = std::max(requirement_.min_y, external_dimy);
-      const int focused_dimy = selected_box.y_max - selected_box.y_min;
-      int dy = selected_box.y_min - external_dimy / 2 + focused_dimy / 2;
+      const int focused_dimy = focused_box.y_max - focused_box.y_min;
+      int dy = focused_box.y_min - external_dimy / 2 + focused_dimy / 2;
       dy = std::max(0, std::min(internal_dimy - external_dimy - 1, dy));
       children_box.y_min = box.y_min - dy;
       children_box.y_max = box.y_min + internal_dimy - dy;
@@ -104,16 +104,16 @@ class FocusCursor : public Focus {
 
 }  // namespace
 
-/// @brief Set the `child` to be the one selected among its siblings.
-/// @param child The element to be selected.
+/// @brief Set the `child` to be the one focused among its siblings.
+/// @param child The element to be focused.
 /// @ingroup dom
 Element focus(Element child) {
   return std::make_shared<Focus>(unpack(std::move(child)));
 }
 
 /// @deprecated Use `focus` instead.
-/// @brief Set the `child` to be the one selected among its siblings.
-/// @param child The element to be selected.
+/// @brief Set the `child` to be the one focused among its siblings.
+/// @param child The element to be focused.
 Element select(Element e) {
   return focus(std::move(e));
 }

src/ftxui/dom/gridbox.cpp

@@ -75,20 +75,20 @@ class GridBox : public Node {
     requirement_.min_x = Integrate(size_x);
     requirement_.min_y = Integrate(size_y);
 
-    // Forward the selected/focused child state:
-    requirement_.is_selected = false;
+    // Forward the focused/focused child state:
+    requirement_.is_focused = false;
     for (int x = 0; x < x_size; ++x) {
       for (int y = 0; y < y_size; ++y) {
-        if (requirement_.is_selected ||
-            !lines_[y][x]->requirement().is_selected) {
+        if (requirement_.is_focused ||
+            !lines_[y][x]->requirement().is_focused) {
           continue;
         }
-        requirement_.is_selected = true;
-        requirement_.selected_box = lines_[y][x]->requirement().selected_box;
-        requirement_.selected_box.x_min += size_x[x];
-        requirement_.selected_box.x_max += size_x[x];
-        requirement_.selected_box.y_min += size_y[y];
-        requirement_.selected_box.y_max += size_y[y];
+        requirement_.is_focused = true;
+        requirement_.focused_box = lines_[y][x]->requirement().focused_box;
+        requirement_.focused_box.x_min += size_x[x];
+        requirement_.focused_box.x_max += size_x[x];
+        requirement_.focused_box.y_min += size_y[y];
+        requirement_.focused_box.y_max += size_y[y];
       }
     }
   }

src/ftxui/dom/hbox.cpp

@@ -29,16 +29,16 @@ class HBox : public Node {
     requirement_.flex_grow_y = 0;
     requirement_.flex_shrink_x = 0;
     requirement_.flex_shrink_y = 0;
-    requirement_.is_selected = false;
+    requirement_.is_focused = false;
     int index = 0;
     for (auto& child : children_) {
       child->ComputeRequirement();
-      if (child->requirement().is_selected &&
-          (!requirement_.is_selected || index_ == index)) {
-        requirement_.is_selected = true;
-        requirement_.selected_box = child->requirement().selected_box;
-        requirement_.selected_box.x_min += requirement_.min_x;
-        requirement_.selected_box.x_max += requirement_.min_x;
+      if (child->requirement().is_focused &&
+          (!requirement_.is_focused || index_ == index)) {
+        requirement_.is_focused = true;
+        requirement_.focused_box = child->requirement().focused_box;
+        requirement_.focused_box.x_min += requirement_.min_x;
+        requirement_.focused_box.x_max += requirement_.min_x;
       }
       requirement_.min_x += child->requirement().min_x;
       requirement_.min_y =

src/ftxui/dom/vbox.cpp

@@ -29,16 +29,16 @@ class VBox : public Node {
     requirement_.flex_grow_y = 0;
     requirement_.flex_shrink_x = 0;
     requirement_.flex_shrink_y = 0;
-    requirement_.is_selected = false;
+    requirement_.is_focused = false;
     int index = 0;
     for (auto& child : children_) {
       child->ComputeRequirement();
-      if (child->requirement().is_selected &&
-          (!requirement_.is_selected || index_ == index)) {
-        requirement_.is_selected = true;
-        requirement_.selected_box = child->requirement().selected_box;
-        requirement_.selected_box.y_min += requirement_.min_y;
-        requirement_.selected_box.y_max += requirement_.min_y;
+      if (child->requirement().is_focused &&
+          (!requirement_.is_focused || index_ == index)) {
+        requirement_.is_focused = true;
+        requirement_.focused_box = child->requirement().focused_box;
+        requirement_.focused_box.y_min += requirement_.min_y;
+        requirement_.focused_box.y_max += requirement_.min_y;
       }
       requirement_.min_y += child->requirement().min_y;
       requirement_.min_x =