Initial prototype

ftxui/include/ftxui/README.md

@@ -0,0 +1 @@
+State => Components => Document => Text.

ftxui/include/ftxui/core/box.hpp

@@ -0,0 +1,11 @@
+#ifndef FTX_UI_CORE_BOX
+#define FTX_UI_CORE_BOX
+
+struct Box {
+  int left;
+  int right;
+  int top;
+  int bottom;
+};
+
+#endif /* end of include guard: FTX_UI_CORE_BOX */

ftxui/include/ftxui/core/component.hpp

@@ -0,0 +1,23 @@
+#ifndef FTXUI_STATE_HPP
+#define FTXUI_STATE_HPP
+
+#include "ftxui/core/requirement.hpp"
+#include "ftxui/core/document.hpp"
+
+namespace ftxui {
+
+class Component {
+ public:
+  virtual Document Render() = 0;
+
+  // Requirement -------------------------------------------------------------
+  virtual void ComputeRequirement();
+  Requirement requirement() { return requirement_; }
+
+ private:
+  Requirement requirement_;
+};
+
+};  // namespace ftxui
+
+#endif /* end of include guard: FTXUI_STATE_HPP */

ftxui/include/ftxui/core/document.hpp

@@ -0,0 +1,12 @@
+#ifndef FTXUI_DOCUMENT_HPP
+#define FTXUI_DOCUMENT_HPP
+
+namespace ftxui {
+
+class Document {
+   
+};
+
+};
+
+#endif /* end of include guard: FTXUI_DOCUMENT_HPP */

ftxui/include/ftxui/core/dom/elements.hpp

@@ -0,0 +1,38 @@
+#ifndef FTXUI_CORE_DOM_ELEMENTS_HPP
+#define FTXUI_CORE_DOM_ELEMENTS_HPP
+
+#include "ftxui/core/dom/node.hpp"
+#include <initializer_list>
+
+namespace ftxui {
+namespace dom {
+
+using Child = std::unique_ptr<Node>;
+using Children = std::vector<std::unique_ptr<Node>>;
+
+std::unique_ptr<Node> vbox(Children);
+std::unique_ptr<Node> hbox(Children);
+std::unique_ptr<Node> text(std::wstring text);
+std::unique_ptr<Node> flex();
+
+template <class... Args>
+std::vector<Child> unpack(Args... args) {
+  std::vector<Child> vec;
+  (vec.push_back(std::forward<Args>(args)), ...);
+  return vec;
+}
+
+template <class... Args>
+std::unique_ptr<Node> vbox(Args... children) {
+  return vbox(unpack(std::forward<Args>(children)...));
+}
+
+template <class... Args>
+std::unique_ptr<Node> hbox(Args... children) {
+  return hbox(unpack(std::forward<Args>(children)...));
+}
+
+};  // namespace dom
+};  // namespace ftxui
+
+#endif /* end of include guard: FTXUI_CORE_DOM_ELEMENTS_HPP */

ftxui/include/ftxui/core/dom/node.hpp

@@ -0,0 +1,44 @@
+#ifndef CORE_DOM_NODE_HPP
+#define CORE_DOM_NODE_HPP
+
+#include <memory>
+#include <vector>
+
+#include "ftxui/core/requirement.hpp"
+#include "ftxui/core/screen.hpp"
+#include "ftxui/core/box.hpp"
+
+namespace ftxui {
+namespace dom {
+
+class Node {
+ public:
+  Node();
+  Node(std::vector<std::unique_ptr<Node>> children);
+  virtual ~Node();
+
+  // Step 1: Direction parent <= children.
+  //         Compute layout requirement. Tell parent what dimensions this
+  //         element wants to be.
+  virtual void ComputeRequirement();
+  Requirement requirement() { return requirement_; }
+
+  // Step 2: Direction parent => children.
+  //         Assign this element its final dimensions.
+  virtual void SetBox(Box box);
+
+  // Step 3: Draw this element.
+  virtual void Render(Screen& screen);
+
+  std::vector<std::unique_ptr<Node>> children;
+ protected:
+  Requirement requirement_;
+  Box box_;
+};
+
+void Render(Screen& screen, Node* node);
+
+};  // namespace dom
+};  // namespace ftxui
+
+#endif /* end of include guard: CORE_DOM_NODE_HPP */

ftxui/include/ftxui/core/requirement.hpp

@@ -0,0 +1,28 @@
+#ifndef FTXUI_LAYOUT_REQUIREMENT_HPP
+#define FTXUI_LAYOUT_REQUIREMENT_HPP
+
+namespace ftxui {
+
+struct Requirement {
+  // Minimal dimensions.
+  struct {
+    int x = 0;
+    int y = 0;
+  } min;
+
+  // Maximal dimensions.
+  struct {
+    int x = -1;
+    int y = -1;
+  } max;
+
+  // Flex.
+  struct {
+    int x = 0;
+    int y = 0;
+  } flex;
+};
+
+};  // namespace ftxui
+
+#endif /* end of include guard: FTXUI_LAYOUT_REQUIREMENT_HPP */

ftxui/include/ftxui/core/screen.hpp

@@ -0,0 +1,28 @@
+#ifndef FTXUI_CORE_SCREEN
+#define FTXUI_CORE_SCREEN
+
+#include <string>
+#include <vector>
+
+namespace ftxui {
+
+class Screen {
+ public:
+  Screen(size_t dimx, size_t dimy);
+  wchar_t& at(size_t x, size_t y);
+  std::string ToString();
+
+  size_t dimx() { return dimx_;}
+  size_t dimy() { return dimy_;}
+
+  static Screen WholeTerminal();
+
+ private:
+  size_t dimx_;
+  size_t dimy_;
+  std::vector<std::wstring> lines_;
+};
+
+};  // namespace ftxui
+
+#endif /* end of include guard: FTXUI_CORE_SCREEN */

ftxui/include/ftxui/util/string.hpp

@@ -0,0 +1,4 @@
+#include <string>
+
+std::string to_string(const std::wstring& s);
+std::wstring to_wstring(const std::string& s);