FTXUI/examples/component/homescreen.cpp

// Copyright 2020 Arthur Sonzogni. All rights reserved.
// Use of this source code is governed by the MIT license that can be found in
// the LICENSE file.

#include <cmath>
#include <thread>

#include "ftxui/component/checkbox.hpp"
#include "ftxui/component/container.hpp"
#include "ftxui/component/input.hpp"
#include "ftxui/component/menu.hpp"
#include "ftxui/component/radiobox.hpp"
#include "ftxui/component/screen_interactive.hpp"
#include "ftxui/component/toggle.hpp"
#include "ftxui/screen/string.hpp"

using namespace ftxui;

int shift = 0;
class Graph {
 public:
  std::vector<int> operator()(int width, int height) {
    std::vector<int> output(width);
    for (int i = 0; i < width; ++i) {
      float v = 0;
      v += 0.1f * sin((i + shift) * 0.1f);
      v += 0.2f * sin((i + shift + 10) * 0.15f);
      v += 0.1f * sin((i + shift) * 0.03f);
      v *= height;
      v += 0.5f * height;
      output[i] = (int)v;
    }
    return output;
  }
};

class HTopComponent : public Component {
  Graph my_graph;

 public:
  HTopComponent() {}
  ~HTopComponent() override {}

  // clang-format off
  Element Render() override {
    return
      hbox(
        vbox(
          // --- Frequency ---
          text(L"Frequency [Mhz]") | hcenter,
          hbox(
            vbox(
              text(L"2400 "), filler(),
              text(L"1200 "), filler(),
              text(L"0% ")
            ),
            graph(std::ref(my_graph))
          ) | flex,
          separator(),
          // --- Utilization ---
          text(L"Utilization [%]") | hcenter,
          hbox(
            vbox(
              text(L"100 "), filler(),
              text(L"50 "), filler(),
              text(L"0 ")
            ),
            graph(std::ref(my_graph)) | color(Color::RedLight)
          ) | flex 
        ) | flex,
        separator(),
        // --- Ram ---
        vbox(
          text(L"Ram [Mo]") | hcenter,
          hbox(
            vbox(
              text(L"8192"), filler(),
              text(L"4096 "), filler(),
              text(L"0 ")
            ),
            graph(std::ref(my_graph)) | color(Color::BlueLight)
         ) | flex
       ) | flex
     ) | flex | border;
  }
  // clang-format on
};

class CompilerComponent : public Component {
  Container container = Container::Horizontal();
  RadioBox compiler;
  Container flag = Container::Vertical();
  CheckBox flag_checkbox[4];
  Container subcontainer = Container::Vertical();
  Container input_container = Container::Horizontal();
  Input input_add;
  Menu input;
  Input executable;

 public:
  ~CompilerComponent() override {}
  CompilerComponent() {
    Add(&container);

    // Compiler ----------------------------------------------------------------
    compiler.entries = {
        L"gcc",
        L"clang",
        L"emcc",
        L"game_maker"
        L"Ada compilers",
        L"ALGOL 60 compilers",
        L"ALGOL 68 compilers",
        L"Assemblers (Intel *86)",
        L"Assemblers (Motorola 68*)",
        L"Assemblers (Zilog Z80)",
        L"Assemblers (other)",
        L"BASIC Compilers",
        L"BASIC interpreters",
        L"Batch compilers",
        L"C compilers",
        L"Source-to-source compilers",
        L"C++ compilers",
        L"C# compilers",
        L"COBOL compilers",
        L"Common Lisp compilers",
        L"D compilers",
        L"DIBOL/DBL compilers",
        L"ECMAScript interpreters",
        L"Eiffel compilers",
        L"Fortran compilers",
        L"Go compilers",
        L"Haskell compilers",
        L"Java compilers",
        L"Pascal compilers",
        L"Perl Interpreters",
        L"PHP compilers",
        L"PL/I compilers",
        L"Python compilers",
        L"Scheme compilers and interpreters",
        L"Smalltalk compilers",
        L"Tcl Interpreters",
        L"VMS Interpreters",
        L"Rexx Interpreters",
        L"CLI compilers",
    };
    container.Add(&compiler);

    // Flags    ----------------------------------------------------------------
    container.Add(&flag);
    flag_checkbox[0].label = L"-Wall";
    flag_checkbox[1].label = L"-Werror";
    flag_checkbox[2].label = L"-lpthread";
    flag_checkbox[3].label = L"-O3";
    for (auto& c : flag_checkbox)
      flag.Add(&c);

    container.Add(&subcontainer);
    // Executable
    // ----------------------------------------------------------------
    executable.placeholder = L"executable";
    subcontainer.Add(&executable);

    // Input    ----------------------------------------------------------------
    subcontainer.Add(&input_container);

    input_add.placeholder = L"input files";
    input_add.on_enter = [this] {
      input.entries.push_back(input_add.content);
      input_add.content = L"";
    };
    input_container.Add(&input_add);
    input_container.Add(&input);
  }

  // clang-format off
  Element Render() override {
    return
      vbox(
        hbox(
          window(text(L"Compiler"),
            compiler.Render() | frame | size(HEIGHT, LESS_THAN, 6)
          ),
          window(text(L"Flags"), flag.Render()),
          vbox(
            window(text(L"Executable:"), executable.Render())
              | size(WIDTH, EQUAL, 20),
            window(text(L"Input"),
              hbox(
                vbox(
                  hbox(text(L"Add: "), input_add.Render())
                    | size(WIDTH, EQUAL, 20)
                    | size(HEIGHT, EQUAL, 1),
                  filler()
                ),
                separator(),
                input.Render() | frame | size(HEIGHT, EQUAL, 3) | flex
              )
            ) | size(WIDTH, EQUAL, 60)
          ),
          filler()
        ),
        hflow(RenderCommandLine())
      ) | border;
  }
  // clang-format on

  Elements RenderCommandLine() {
    Elements line;
    // Compiler
    line.push_back(text(compiler.entries[compiler.selected]) | bold);
    // flags
    for (auto& it : flag_checkbox) {
      if (it.state) {
        line.push_back(text(L" "));
        line.push_back(text(it.label) | dim);
      }
    }
    // Executable
    if (!executable.content.empty()) {
      line.push_back(text(L" -O ") | bold);
      line.push_back(text(executable.content) | color(Color::BlueLight) | bold);
    }
    // Input
    for (auto& it : input.entries) {
      line.push_back(text(L" " + it) | color(Color::RedLight));
    }
    return line;
  }
};

class SpinnerComponent : public Component {
  // clang-format off
  Element Render() override {
    Elements entries;
    for(int i = 0; i<22; ++i) {
      if (i != 0)
      entries.push_back(
        spinner(i, shift/2)
          | bold
          | size(WIDTH, GREATER_THAN, 2)
          | border
      );
    }
    return hflow(std::move(entries)) | border;
  }
  // clang-format on
};

class ColorComponent : public Component {
  // clang-format off
  Element Render() override {
    return
      hbox(
        vbox(
          color(Color::Default, text(L"Default")),
          color(Color::Black, text(L"Black")),
          color(Color::GrayDark, text(L"GrayDark")),
          color(Color::GrayLight, text(L"GrayLight")),
          color(Color::White, text(L"White")),
          color(Color::Blue, text(L"Blue")),
          color(Color::BlueLight, text(L"BlueLight")),
          color(Color::Cyan, text(L"Cyan")),
          color(Color::CyanLight, text(L"CyanLight")),
          color(Color::Green, text(L"Green")),
          color(Color::GreenLight, text(L"GreenLight")),
          color(Color::Magenta, text(L"Magenta")),
          color(Color::MagentaLight, text(L"MagentaLight")),
          color(Color::Red, text(L"Red")),
          color(Color::RedLight, text(L"RedLight")),
          color(Color::Yellow, text(L"Yellow")),
          color(Color::YellowLight, text(L"YellowLight"))
        ),
        vbox(
          bgcolor(Color::Default, text(L"Default")),
          bgcolor(Color::Black, text(L"Black")),
          bgcolor(Color::GrayDark, text(L"GrayDark")),
          bgcolor(Color::GrayLight, text(L"GrayLight")),
          bgcolor(Color::White, text(L"White")),
          bgcolor(Color::Blue, text(L"Blue")),
          bgcolor(Color::BlueLight, text(L"BlueLight")),
          bgcolor(Color::Cyan, text(L"Cyan")),
          bgcolor(Color::CyanLight, text(L"CyanLight")),
          bgcolor(Color::Green, text(L"Green")),
          bgcolor(Color::GreenLight, text(L"GreenLight")),
          bgcolor(Color::Magenta, text(L"Magenta")),
          bgcolor(Color::MagentaLight, text(L"MagentaLight")),
          bgcolor(Color::Red, text(L"Red")),
          bgcolor(Color::RedLight, text(L"RedLight")),
          bgcolor(Color::Yellow, text(L"Yellow")),
          bgcolor(Color::YellowLight, text(L"YellowLight"))
        )
      ) | hcenter | border;
    // clang-format on
  }
};

class GaugeComponent : public Component {
  // clang-format off
  Element RenderGauge(int delta) {
    float progress = (shift + delta) % 1000 / 1000.f;
    return hbox(text(std::to_wstring(int(progress * 100)) + L"% ") | size(WIDTH, EQUAL, 5),
                gauge(progress));
  }
  Element Render() override {
    return
      vbox(
        RenderGauge(0) | color(Color::Black),
        RenderGauge(100) | color(Color::GrayDark),
        RenderGauge(50) | color(Color::GrayLight),
        RenderGauge(6894) | color(Color::White), separator(),
        RenderGauge(6841) | color(Color::Blue),
        RenderGauge(9813) | color(Color::BlueLight),
        RenderGauge(98765) | color(Color::Cyan),
        RenderGauge(98) | color(Color::CyanLight),
        RenderGauge(9846) | color(Color::Green),
        RenderGauge(1122) | color(Color::GreenLight),
        RenderGauge(84) | color(Color::Magenta),
        RenderGauge(645) | color(Color::MagentaLight),
        RenderGauge(568) | color(Color::Red),
        RenderGauge(2222) | color(Color::RedLight),
        RenderGauge(220) | color(Color::Yellow),
        RenderGauge(348) | color(Color::YellowLight)
      ) | border;
  };
  // clang-format on
};

class Tab : public Component {
 public:
  Container main_container = Container::Vertical();

  Toggle tab_selection;
  Container container = Container::Tab(&tab_selection.selected);

  HTopComponent htop_component;
  ColorComponent color_component;
  SpinnerComponent spinner_component;
  GaugeComponent gauge_component;
  CompilerComponent compiler_component;

  Tab() {
    Add(&main_container);
    main_container.Add(&tab_selection);
    tab_selection.entries = {
        L"htop", L"color", L"spinner", L"gauge", L"compiler",
    };
    main_container.Add(&container);
    container.Add(&htop_component);
    container.Add(&color_component);
    container.Add(&spinner_component);
    container.Add(&gauge_component);
    container.Add(&compiler_component);
  }

  Element Render() override {
    return vbox(text(L"FTXUI Demo") | bold | hcenter,
                tab_selection.Render() | hcenter, container.Render());
  }
};

int main(int argc, const char* argv[]) {
  auto screen = ScreenInteractive::Fullscreen();

  std::thread update([&screen]() {
    for (;;) {
      using namespace std::chrono_literals;
      std::this_thread::sleep_for(0.05s);
      shift++;
      screen.PostEvent(Event::Custom);
    }
  });

  Tab tab;
  screen.Loop(&tab);

  return 0;
}