Initialize

ftxui/examples/dom/package_manager.cpp

@@ -0,0 +1,150 @@
+// 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 <chrono>                  // for operator""s, chrono_literals
+#include <ftxui/dom/elements.hpp>  // for operator|, text, Element, hbox, bold, color, filler, separator, vbox, window, gauge, Fit, size, dim, EQUAL, WIDTH
+#include <ftxui/screen/screen.hpp>  // for Full, Screen
+#include <iostream>                 // for cout, endl, ostream
+#include <list>  // for list, operator==, _List_iterator, _List_iterator<>::_Self
+#include <memory>   // for allocator, shared_ptr, allocator_traits<>::value_type
+#include <string>   // for string, operator<<, to_string
+#include <thread>   // for sleep_for
+#include <utility>  // for move
+#include <vector>   // for vector
+
+#include "ftxui/dom/node.hpp"  // for Render
+#include "ftxui/screen/color.hpp"  // for Color, Color::Green, Color::Red, Color::RedLight, ftxui
+
+int main() {
+  using namespace ftxui;
+
+  struct Task {
+    std::string name;
+    int number_of_threads;
+    int downloaded;
+    int size;
+  };
+
+  std::list<Task> remaining_tasks = {
+      {"contact server       ", 10, 0, 6 * 25},
+      {"download index.html  ", 10, 0, 9 * 25},
+      {"download script.js   ", 1, 0, 3 * 25},
+      {"download style.js    ", 1, 0, 4 * 25},
+      {"download image.png   ", 1, 0, 5 * 25},
+      {"download big_1.png   ", 1, 0, 30 * 25},
+      {"download icon_1.png  ", 1, 0, 7 * 25},
+      {"download icon_2.png  ", 1, 0, 8 * 25},
+      {"download big_2.png   ", 1, 0, 30 * 25},
+      {"download small_1.png ", 1, 0, 10 * 25},
+      {"download small_2.png ", 1, 0, 11 * 25},
+      {"download small_3.png ", 1, 0, 12 * 25},
+  };
+
+  std::list<Task> displayed_task;
+
+  int remaining_threads = 12;
+
+  int nb_queued = (int)remaining_tasks.size();
+  int nb_active = 0;
+  int nb_done = 0;
+
+  auto to_text = [](int number) {
+    return text(std::to_string(number)) | size(WIDTH, EQUAL, 3);
+  };
+
+  auto renderTask = [&](const Task& task) {
+    auto style = (task.downloaded == task.size) ? dim : bold;
+    return hbox({
+        text(task.name) | style,
+        separator(),
+        to_text(task.downloaded),
+        text("/"),
+        to_text(task.size),
+        separator(),
+        gauge(task.downloaded / float(task.size)),
+    });
+  };
+
+  auto renderSummary = [&]() {
+    auto summary = vbox({
+        hbox({
+            text("- done:   "),
+            to_text(nb_done) | bold,
+        }) | color(Color::Green),
+        hbox({
+            text("- active: "),
+            to_text(nb_active) | bold,
+        }) | color(Color::RedLight),
+        hbox({
+            text("- queue:  "),
+            to_text(nb_queued) | bold,
+        }) | color(Color::Red),
+    });
+
+    return window(text(" Summary "), summary);
+  };
+
+  auto render = [&]() {
+    std::vector<Element> entries;
+    for (auto& task : displayed_task) {
+      entries.push_back(renderTask(task));
+    }
+
+    return vbox({
+        // List of tasks.
+        window(text(" Task "), vbox(std::move(entries))),
+
+        // Summary.
+        hbox({
+            renderSummary(),
+            filler(),
+        }),
+    });
+  };
+
+  auto updateModel = [&]() {
+    for (auto& task : displayed_task) {
+      if (task.downloaded != task.size) {
+        task.downloaded++;
+      } else if (task.number_of_threads) {
+        remaining_threads += task.number_of_threads;
+        task.number_of_threads = 0;
+        nb_active--;
+        nb_done++;
+      }
+    }
+
+    if (remaining_tasks.size() &&
+        remaining_tasks.front().number_of_threads <= remaining_threads) {
+      remaining_threads -= remaining_tasks.front().number_of_threads;
+      displayed_task.push_back(remaining_tasks.front());
+      remaining_tasks.pop_front();
+      nb_queued--;
+      nb_active++;
+    }
+  };
+
+  std::string reset_position;
+  for (;;) {
+    // Draw.
+    auto document = render();
+    auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+    Render(screen, document);
+    std::cout << reset_position;
+    screen.Print();
+    reset_position = screen.ResetPosition();
+
+    // Simulate time.
+    using namespace std::chrono_literals;
+    std::this_thread::sleep_for(0.01s);
+
+    // Exit
+    if (nb_active + nb_queued == 0) {
+      break;
+    }
+
+    // Update the model for the next frame.
+    updateModel();
+  }
+  std::cout << std::endl;
+}