Closes #80

Mitigate overflow when calculating ETA

.travis.yml

@@ -61,5 +61,5 @@ matrix:
 script:
     - if [[ "$CXX" == clang* ]]; then export CXXFLAGS="-stdlib=libc++"; fi
     - mkdir build && cd build
-    - cmake -DDEMO=ON -DSAMPLES=ON ..
+    - cmake -DINDICATORS_DEMO=ON -DINDICATORS_SAMPLES=ON ..
     - make

CMakeLists.txt

@@ -5,14 +5,14 @@ if(DEFINED PROJECT_NAME)
 endif()
 
 if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.12")
-  project(indicators VERSION 1.8.0 LANGUAGES CXX
+  project(indicators VERSION 1.9.0 LANGUAGES CXX
     HOMEPAGE_URL "https://github.com/p-ranav/indicators"
     DESCRIPTION "Activity Indicators for Modern C++")
 elseif(CMAKE_VERSION VERSION_GREATER_EQUAL "3.9")
-  project(indicators VERSION 1.8.0 LANGUAGES CXX
+  project(indicators VERSION 1.9.0 LANGUAGES CXX
     DESCRIPTION "Activity Indicators for Modern C++")
 else()
-  project(indicators VERSION 1.8.0 LANGUAGES CXX)
+  project(indicators VERSION 1.9.0 LANGUAGES CXX)
 endif()
 
 if(EXISTS "${CMAKE_BINARY_DIR}/conanbuildinfo.cmake")

README.md

@@ -12,9 +12,10 @@
   <a href="https://github.com/p-ranav/indicators/blob/master/LICENSE">
     <img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="license"/>
   </a>
-  <img src="https://img.shields.io/badge/version-1.8-blue.svg?cacheSeconds=2592000" alt="version"/>
+  <img src="https://img.shields.io/badge/version-1.9-blue.svg?cacheSeconds=2592000" alt="version"/>
 </p>
 
+
 <p align="center">
   <img src="img/demo.gif"/> 
 </p>
@@ -36,7 +37,10 @@
      *    [Multi Progress](#multiprogress)
      *    [Dynamic Progress](#dynamicprogress)
      *    [Progress Spinner](#progress-spinner)
-*    [Working with Iterables](#working-with-iterables)
+*    Additional Samples
+     *    [Decremental Progress](#decremental-progress)
+     *    [Working with Iterables](#working-with-iterables)
+     *    [Unicode Support](#unicode-support)
 *    [Building Samples](#building-samples)
 *    [Generating Single Header](#generating-single-header)
 *    [Contributing](#contributing)
@@ -625,6 +629,48 @@ int main() {
 }
 ```
 
+## Decremental Progress
+
+`indicators` allows you to easily control the progress direction, i.e., incremental or decremental progress by using  `option::ProgressType`. To program a countdown progress bar, use `option::ProgressType::decremental`
+
+<p align="center">
+  <img src="img/progress_bar_countdown.gif"/>  
+</p>
+
+```cpp
+#include <chrono>
+#include <indicators/progress_bar.hpp>
+#include <thread>
+using namespace indicators;
+
+int main() {
+
+  ProgressBar bar{option::BarWidth{50},
+                  option::ProgressType{ProgressType::decremental},
+                  option::Start{"["},
+                  option::Fill{"■"},
+                  option::Lead{"■"},
+                  option::Remainder{"-"},
+                  option::End{"]"},
+                  option::PostfixText{"Reverting System Restore"},
+                  option::ForegroundColor{Color::yellow},
+                  option::FontStyles{std::vector<FontStyle>{FontStyle::bold}}};
+
+  // Update bar state
+  while (true) {
+    bar.tick();
+    if (bar.is_completed())
+      break;
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+
+  std::cout << termcolor::bold << termcolor::white
+            << "Task Failed Successfully\n" << termcolor::reset;
+
+  return 0;
+}
+```
+
 ## Working with Iterables
 
 If you'd like to use progress bars to indicate progress while iterating over iterables, e.g., a list of numbers, this
@@ -687,6 +733,207 @@ int main() {
 }
 ```
 
+## Unicode Support
+
+`indicators` supports multi-byte unicode characters in progress bars. 
+
+If the `option::BarWidth` is set, the library aims to respect this setting. When filling the bar, if the next `Fill` string has a display width that would exceed the bar width, then the library will fill the remainder of the bar with `' '` space characters instead. 
+
+See below an example of some progress bars, each with a bar width of 50, displaying different unicode characters:
+
+<p align="center">
+  <img src="img/unicode.gif"/>  
+</p>
+
+```cpp
+#include <chrono>
+#include <indicators/progress_bar.hpp>
+#include <indicators/indeterminate_progress_bar.hpp>
+#include <indicators/cursor_control.hpp>
+#include <thread>
+
+int main() {
+
+    indicators::show_console_cursor(false);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+
+    {
+        // Plain old ASCII
+        indicators::ProgressBar bar{
+            indicators::option::BarWidth{50},
+            indicators::option::Start{"["},
+            indicators::option::Fill{"="},
+            indicators::option::Lead{">"},
+            indicators::option::Remainder{" "},
+            indicators::option::End{" ]"},
+            indicators::option::PostfixText{"Plain-old ASCII"},
+            indicators::option::ForegroundColor{indicators::Color::green},
+            indicators::option::FontStyles{
+                std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
+        };
+
+        // Update bar state
+        while (true) {
+            bar.tick();
+            if (bar.is_completed())
+            break;
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+    }
+
+    {
+        // Unicode
+        indicators::ProgressBar bar{
+            indicators::option::BarWidth{50},
+            indicators::option::Start{"["},
+            indicators::option::Fill{"驚くばかり"},
+            indicators::option::Lead{">"},
+            indicators::option::Remainder{" "},
+            indicators::option::End{" ]"},
+            indicators::option::PostfixText{"Japanese"},
+            indicators::option::ForegroundColor{indicators::Color::yellow},
+            indicators::option::FontStyles{
+                std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
+        };
+
+        // Update bar state
+        while (true) {
+            bar.tick();
+            if (bar.is_completed())
+            break;
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+    }
+
+    {
+        // Russian
+        indicators::ProgressBar bar{
+            indicators::option::BarWidth{50},
+            indicators::option::Start{"["},
+            indicators::option::Fill{"Потрясающие"},
+            indicators::option::Remainder{" "},
+            indicators::option::End{" ]"},
+            indicators::option::PostfixText{"Russian"},
+            indicators::option::ForegroundColor{indicators::Color::red},
+            indicators::option::FontStyles{
+                std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
+        };
+
+        // Update bar state
+        while (true) {
+            bar.tick();
+            if (bar.is_completed())
+            break;
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+    }
+
+    {
+        // Greek
+        indicators::ProgressBar bar{
+            indicators::option::BarWidth{50},
+            indicators::option::Start{"["},
+            indicators::option::Fill{"Φοβερός"},
+            indicators::option::Remainder{" "},
+            indicators::option::End{" ]"},
+            indicators::option::PostfixText{"Greek"},
+            indicators::option::ForegroundColor{indicators::Color::cyan},
+            indicators::option::FontStyles{
+                std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
+        };
+
+        // Update bar state
+        while (true) {
+            bar.tick();
+            if (bar.is_completed())
+            break;
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+    }
+
+    {
+        // Chinese
+        indicators::ProgressBar bar{
+            indicators::option::BarWidth{50},
+            indicators::option::Start{"["},
+            indicators::option::Fill{"太棒了"},
+            indicators::option::Remainder{" "},
+            indicators::option::End{" ]"},
+            indicators::option::PostfixText{"Chinese"},
+            indicators::option::ForegroundColor{indicators::Color::green},
+            indicators::option::FontStyles{
+                std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
+        };
+
+        // Update bar state
+        while (true) {
+            bar.tick();
+            if (bar.is_completed())
+            break;
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }        
+    }
+
+    {
+        // Emojis
+        indicators::ProgressBar bar{
+            indicators::option::BarWidth{50},
+            indicators::option::Start{"["},
+            indicators::option::Fill{"🔥"},
+            indicators::option::Lead{"🔥"},
+            indicators::option::Remainder{" "},
+            indicators::option::End{" ]"},
+            indicators::option::PostfixText{"Emojis"},
+            indicators::option::ForegroundColor{indicators::Color::white},
+            indicators::option::FontStyles{
+                std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
+        };
+
+        // Update bar state
+        while (true) {
+            bar.tick();
+            if (bar.is_completed())
+            break;
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+    }
+
+    {
+        // Indeterminate progress bar
+        indicators::IndeterminateProgressBar bar{
+            indicators::option::BarWidth{50},
+            indicators::option::Start{"["},
+            indicators::option::Fill{"✯"},
+            indicators::option::Lead{"載入中"},
+            indicators::option::End{" ]"},
+            indicators::option::PostfixText{"Loading Progress Bar"},
+            indicators::option::ForegroundColor{indicators::Color::yellow},
+            indicators::option::FontStyles{
+                std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
+        };
+
+        auto job = [&bar]() {
+            std::this_thread::sleep_for(std::chrono::milliseconds(10000));
+            bar.mark_as_completed();
+        };
+        std::thread job_completion_thread(job);
+
+        // Update bar state
+        while (!bar.is_completed()) {
+            bar.tick();
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        }
+
+        job_completion_thread.join();
+    }
+
+    indicators::show_console_cursor(true);
+
+  return 0;
+}
+```
+
 ## Building Samples
 
 ```bash

demo/demo.cpp

@@ -1,4 +1,6 @@
-#include "indicators.hpp"
+#include <indicators/cursor_control.hpp>
+#include <indicators/progress_bar.hpp>
+#include <indicators/progress_spinner.hpp>
 #include <vector>
 
 int main() {
@@ -11,15 +13,15 @@ int main() {
     //
     // PROGRESS BAR 1
     //
-    indicators::ProgressBar p{option::BarWidth{50},
+    indicators::ProgressBar p{
-                              option::Start{"["},
+        option::BarWidth{50},
-                              option::Fill{"■"},
+        option::Start{"["},
-                              option::Lead{"■"},
+        option::Fill{"■"},
-                              option::Remainder{" "},
+        option::Lead{"■"},
-                              option::End{" ]"},
+        option::Remainder{" "},
-                              option::ForegroundColor{indicators::Color::yellow},
+        option::End{" ]"},
-                              option::FontStyles{
+        option::ForegroundColor{indicators::Color::yellow},
-                                std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+        option::FontStyles{std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
 
     std::atomic<size_t> index{0};
     std::vector<std::string> status_text = {"Rocket.exe is not responding",
@@ -51,7 +53,7 @@ int main() {
     // PROGRESS BAR 2
     //
     indicators::ProgressBar p;
-    p.set_option(option::BarWidth{40});
+    p.set_option(option::BarWidth{0});
     p.set_option(option::PrefixText{"Reading package list... "});
     p.set_option(option::Start{""});
     p.set_option(option::Fill{""});
@@ -60,7 +62,8 @@ int main() {
     p.set_option(option::End{""});
     p.set_option(option::ForegroundColor{indicators::Color::white});
     p.set_option(option::ShowPercentage{false});
-    p.set_option(option::FontStyles{std::vector<indicators::FontStyle>{indicators::FontStyle::bold}});
+    p.set_option(
+        option::FontStyles{std::vector<indicators::FontStyle>{indicators::FontStyle::bold}});
     auto job = [&p]() {
       while (true) {
         p.set_option(
@@ -91,7 +94,8 @@ int main() {
     p.set_option(option::End{"]"});
     p.set_option(option::PostfixText{"Getting started"});
     p.set_option(option::ForegroundColor{indicators::Color::green});
-    p.set_option(option::FontStyles{std::vector<indicators::FontStyle>{indicators::FontStyle::bold}});
+    p.set_option(
+        option::FontStyles{std::vector<indicators::FontStyle>{indicators::FontStyle::bold}});
     auto job = [&p]() {
       while (true) {
         auto ticks = p.current();
@@ -128,7 +132,8 @@ int main() {
     p4.set_option(option::ForegroundColor{indicators::Color::cyan});
     p4.set_option(option::PostfixText{"Restoring system state"});
     p4.set_option(option::ShowPercentage{false});
-    p4.set_option(option::FontStyles{std::vector<indicators::FontStyle>{indicators::FontStyle::bold}});
+    p4.set_option(
+        option::FontStyles{std::vector<indicators::FontStyle>{indicators::FontStyle::bold}});
     std::atomic<size_t> index4{0};
     auto job4 = [&p4, &index4, &lead_spinner]() {
       while (true) {
@@ -139,6 +144,7 @@ int main() {
           std::cout << std::endl;
           p4.set_option(option::ForegroundColor{indicators::Color::red});
           p4.set_option(option::PrefixText{"{ ERROR }"});
+          p4.set_option(option::BarWidth{0});
           p4.set_option(option::Start{});
           p4.set_option(option::Fill{});
           p4.set_option(option::Lead{});
@@ -156,6 +162,35 @@ int main() {
     thread4.join();
 
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+    {
+      //
+      // GOING BACKWARDS
+      //
+      indicators::ProgressBar p{
+          option::BarWidth{50},
+          option::ProgressType{ProgressType::decremental},
+          option::Start{"["},
+          option::Fill{"■"},
+          option::Lead{"■"},
+          option::Remainder{"-"},
+          option::End{"]"},
+          option::ForegroundColor{indicators::Color::white},
+          option::PostfixText{"Reverting system restore"},
+          option::FontStyles{std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+      auto job = [&p]() {
+        while (true) {
+          p.tick();
+          if (p.is_completed()) {
+            p.set_option(option::PostfixText{"Revert complete!"});
+            break;
+          }
+          std::this_thread::sleep_for(std::chrono::milliseconds(60));
+        }
+      };
+      std::thread thread(job);
+      thread.join();
+    }
   }
 
   {
@@ -193,8 +228,10 @@ int main() {
     // PROGRESS BAR 6
     //
     indicators::ProgressSpinner p{
-        option::PrefixText{" - "}, option::PostfixText{"Searching for the Moon"},
+        option::PrefixText{" - "},
-        option::ForegroundColor{indicators::Color::white}, option::ShowPercentage{false},
+        option::PostfixText{"Searching for the Moon"},
+        option::ForegroundColor{indicators::Color::white},
+        option::ShowPercentage{false},
         option::SpinnerStates{std::vector<std::string>{"▖", "▘", "▝", "▗"}},
         option::FontStyles{std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
     auto job = [&p]() {
@@ -232,17 +269,17 @@ int main() {
           //
           // NESTED PROGRESS BAR
           //
-          indicators::ProgressBar p2{option::BarWidth{30},
+          indicators::ProgressBar p2{
-                                     option::PrefixText{" - "},
+              option::BarWidth{30},
-                                     option::Start{"🌎"},
+              option::PrefixText{" - "},
-                                     option::Fill{"·"},
+              option::Start{"🌎"},
-                                     option::Lead{"🚀"},
+              option::Fill{"·"},
-                                     option::Remainder{" "},
+              option::Lead{"🚀"},
-                                     option::End{"🌑"},
+              option::Remainder{" "},
-                                     option::PostfixText{"Achieved low-Earth orbit"},
+              option::End{"🌑"},
-                                     option::ForegroundColor{indicators::Color::white},
+              option::PostfixText{"Achieved low-Earth orbit"},
-                                     option::FontStyles{
+              option::ForegroundColor{indicators::Color::white},
-                                        std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+              option::FontStyles{std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
           std::vector<std::string> ship_trail{"⠁", "⠂", "⠄", "⡀", "⢀", "⠠", "⠐", "⠈"};
           std::atomic<int> ship_trail_index{0};
           auto job2 = [&p2, &ship_trail_index, &ship_trail]() {
@@ -283,4 +320,4 @@ int main() {
   show_console_cursor(true);
 
   return 0;
-}
+}

include/indicators/block_progress_bar.hpp

@@ -1,3 +1,4 @@
+
 #pragma once
 
 #include <indicators/color.hpp>
@@ -7,12 +8,15 @@
 #include <atomic>
 #include <chrono>
 #include <indicators/setting.hpp>
+#include <indicators/terminal_size.hpp>
 #include <iomanip>
 #include <iostream>
+#include <sstream>
 #include <mutex>
 #include <string>
 #include <thread>
 #include <tuple>
+#include <utility>
 
 namespace indicators {
 
@@ -55,11 +59,10 @@ public:
                       option::MaxPostfixTextLen{0}, std::forward<Args>(args)...),
                   details::get<details::ProgressBarOption::font_styles>(
                       option::FontStyles{std::vector<FontStyle>{}}, std::forward<Args>(args)...),
-                  details::get<details::ProgressBarOption::max_progress>(option::MaxProgress{100},
+                  details::get<details::ProgressBarOption::max_progress>(
-                                                                         std::forward<Args>(args)...),
+                      option::MaxProgress{100}, std::forward<Args>(args)...),
-                  details::get<details::ProgressBarOption::stream>(
+                  details::get<details::ProgressBarOption::stream>(option::Stream{std::cout},
-                      option::Stream{std::cout}, std::forward<Args>(args)...)
+                                                                   std::forward<Args>(args)...)) {}
-                  ) {}
 
   template <typename T, details::ProgressBarOption id>
   void set_option(details::Setting<T, id> &&setting) {
@@ -118,7 +121,8 @@ public:
 
   size_t current() {
     std::lock_guard<std::mutex> lock{mutex_};
-    return std::min(static_cast<size_t>(progress_), size_t(get_value<details::ProgressBarOption::max_progress>()));
+    return std::min(static_cast<size_t>(progress_),
+                    size_t(get_value<details::ProgressBarOption::max_progress>()));
   }
 
   bool is_completed() const { return get_value<details::ProgressBarOption::completed>(); }
@@ -159,39 +163,23 @@ private:
     }
   }
 
-public:
+  std::pair<std::string, size_t> get_prefix_text() {
-  void print_progress(bool from_multi_progress = false) {
+    std::stringstream os;
-    std::lock_guard<std::mutex> lock{mutex_};
+    os << get_value<details::ProgressBarOption::prefix_text>();
-
+    const auto result = os.str();
-    auto& os = get_value<details::ProgressBarOption::stream>();
+    const auto result_size = unicode::display_width(result);
+    return {result, result_size};
+  }
 
+  std::pair<std::string, size_t> get_postfix_text() {
+    std::stringstream os;
     const auto max_progress = get_value<details::ProgressBarOption::max_progress>();
-    if (multi_progress_mode_ && !from_multi_progress) {
-      if (progress_ > max_progress) {
-        get_value<details::ProgressBarOption::completed>() = true;
-      }
-      return;
-    }
-
     auto now = std::chrono::high_resolution_clock::now();
     auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(now - start_time_point_);
 
-    if (get_value<details::ProgressBarOption::foreground_color>() != Color::unspecified)
-      details::set_stream_color(os, get_value<details::ProgressBarOption::foreground_color>());
-
-    for (auto &style : get_value<details::ProgressBarOption::font_styles>())
-      details::set_font_style(os, style);
-    
-    os << get_value<details::ProgressBarOption::prefix_text>();
-    os << get_value<details::ProgressBarOption::start>();
-
-    details::BlockProgressScaleWriter writer{os,
-                                             get_value<details::ProgressBarOption::bar_width>()};
-    writer.write(progress_ / max_progress * 100);
-
-    os << get_value<details::ProgressBarOption::end>();
     if (get_value<details::ProgressBarOption::show_percentage>()) {
-      os << " " << std::min(static_cast<size_t>(progress_ / max_progress * 100.0), size_t(100)) << "%";
+      os << " " << std::min(static_cast<size_t>(progress_ / max_progress * 100.0), size_t(100))
+         << "%";
     }
 
     auto &saved_start_time = get_value<details::ProgressBarOption::saved_start_time>();
@@ -212,7 +200,10 @@ public:
 
       if (saved_start_time) {
         auto eta = std::chrono::nanoseconds(
-            progress_ > 0 ? static_cast<long long>(elapsed.count() * max_progress / progress_) : 0);
+            progress_ > 0
+                ? static_cast<long long>(std::ceil(float(elapsed.count()) *
+                                                   max_progress / progress_))
+                : 0);
         auto remaining = eta > elapsed ? (eta - elapsed) : (elapsed - eta);
         details::write_duration(os, remaining);
       } else {
@@ -225,12 +216,65 @@ public:
         os << "]";
     }
 
-    if (get_value<details::ProgressBarOption::max_postfix_text_len>() == 0)
+    os << " " << get_value<details::ProgressBarOption::postfix_text>();
-      get_value<details::ProgressBarOption::max_postfix_text_len>() = 10;
+
-    os << " " << get_value<details::ProgressBarOption::postfix_text>()
+    const auto result = os.str();
-              << std::string(get_value<details::ProgressBarOption::max_postfix_text_len>(), ' ')
+    const auto result_size = unicode::display_width(result);
-              << "\r";
+    return {result, result_size};
+  }
+
+public:
+  void print_progress(bool from_multi_progress = false) {
+    std::lock_guard<std::mutex> lock{mutex_};
+
+    auto &os = get_value<details::ProgressBarOption::stream>();
+
+    const auto max_progress = get_value<details::ProgressBarOption::max_progress>();
+    if (multi_progress_mode_ && !from_multi_progress) {
+      if (progress_ > max_progress) {
+        get_value<details::ProgressBarOption::completed>() = true;
+      }
+      return;
+    }
+
+    if (get_value<details::ProgressBarOption::foreground_color>() != Color::unspecified)
+      details::set_stream_color(os, get_value<details::ProgressBarOption::foreground_color>());
+
+    for (auto &style : get_value<details::ProgressBarOption::font_styles>())
+      details::set_font_style(os, style);
+
+    const auto prefix_pair = get_prefix_text();
+    const auto prefix_text = prefix_pair.first;
+    const auto prefix_length = prefix_pair.second;
+    os << prefix_text;
+
+    os << get_value<details::ProgressBarOption::start>();
+
+    details::BlockProgressScaleWriter writer{os,
+                                             get_value<details::ProgressBarOption::bar_width>()};
+    writer.write(progress_ / max_progress * 100);
+
+    os << get_value<details::ProgressBarOption::end>();
+
+    const auto postfix_pair = get_postfix_text();
+    const auto postfix_text = postfix_pair.first;
+    const auto postfix_length = postfix_pair.second;
+    os << postfix_text;
+
+    // Get length of prefix text and postfix text
+    const auto start_length = get_value<details::ProgressBarOption::start>().size();
+    const auto bar_width = get_value<details::ProgressBarOption::bar_width>();
+    const auto end_length = get_value<details::ProgressBarOption::end>().size();
+    const auto terminal_width = terminal_size().second;
+    // prefix + bar_width + postfix should be <= terminal_width
+    const int remaining = terminal_width - (prefix_length + start_length + bar_width + end_length + postfix_length);
+    if (remaining > 0) {
+      os << std::string(remaining, ' ') << "\r";
+    } else if (remaining < 0) {
+      // Do nothing. Maybe in the future truncate postfix with ...
+    }
     os.flush();
+
     if (progress_ > max_progress) {
       get_value<details::ProgressBarOption::completed>() = true;
     }

include/indicators/color.hpp

@@ -1,5 +1,5 @@
+
 #pragma once
-#include <indicators/termcolor.hpp>
 
 namespace indicators {
 enum class Color { grey, red, green, yellow, blue, magenta, cyan, white, unspecified };

include/indicators/cursor_control.hpp

@@ -1,3 +1,4 @@
+
 #pragma once
 
 #if defined(_MSC_VER)
@@ -14,7 +15,7 @@ namespace indicators {
 
 #if defined(_MSC_VER)
 
-void show_console_cursor(bool const show) {
+static inline void show_console_cursor(bool const show) {
   HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
 
   CONSOLE_CURSOR_INFO cursorInfo;
@@ -26,8 +27,8 @@ void show_console_cursor(bool const show) {
 
 #else
 
-void show_console_cursor(bool const show) {
+static inline void show_console_cursor(bool const show) {
-  std::fputs(show ? "\e[?25h" : "\e[?25l", stdout);
+  std::fputs(show ? "\033[?25h" : "\033[?25l", stdout);
 }
 
 #endif

include/indicators/cursor_movement.hpp

@@ -1,3 +1,4 @@
+
 #pragma once
 
 #if defined(_MSC_VER)
@@ -14,7 +15,7 @@ namespace indicators {
 
 #ifdef _MSC_VER
 
-void move(int x, int y) {
+static inline void move(int x, int y) {
   auto hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
   if (!hStdout)
     return;
@@ -29,17 +30,17 @@ void move(int x, int y) {
   SetConsoleCursorPosition(hStdout, cursor);
 }
 
-void move_up(int lines) { move(0, -lines); }
+static inline void move_up(int lines) { move(0, -lines); }
-void move_down(int lines) { move(0, -lines); }
+static inline void move_down(int lines) { move(0, -lines); }
-void move_right(int cols) { move(cols, 0); }
+static inline void move_right(int cols) { move(cols, 0); }
-void move_left(int cols) { move(-cols, 0); }
+static inline void move_left(int cols) { move(-cols, 0); }
 
 #else
 
-void move_up(int lines) { std::cout << "\033[" << lines << "A"; }
+static inline void move_up(int lines) { std::cout << "\033[" << lines << "A"; }
-void move_down(int lines) { std::cout << "\033[" << lines << "B"; }
+static inline void move_down(int lines) { std::cout << "\033[" << lines << "B"; }
-void move_right(int cols) { std::cout << "\033[" << cols << "C"; }
+static inline void move_right(int cols) { std::cout << "\033[" << cols << "C"; }
-void move_left(int cols) { std::cout << "\033[" << cols << "D"; }
+static inline void move_left(int cols) { std::cout << "\033[" << cols << "D"; }
 
 #endif
 

include/indicators/details/stream_helper.hpp

@@ -1,5 +1,7 @@
+
 #pragma once
 
+#include <indicators/display_width.hpp>
 #include <indicators/setting.hpp>
 #include <indicators/termcolor.hpp>
 
@@ -135,13 +137,30 @@ public:
 
   std::ostream &write(float progress) {
     auto pos = static_cast<size_t>(progress * bar_width / 100.0);
-    for (size_t i = 0; i < bar_width; ++i) {
+    for (size_t i = 0, current_display_width = 0; i < bar_width;) {
-      if (i < pos)
+      std::string next;
-        os << fill;
+
-      else if (i == pos)
+      if (i < pos) {
-        os << lead;
+        next = fill;
-      else
+        current_display_width = unicode::display_width(fill);
-        os << remainder;
+      } else if (i == pos) {
+        next = lead;
+        current_display_width = unicode::display_width(lead);
+      } else {
+        next = remainder;
+        current_display_width = unicode::display_width(remainder);
+      }
+
+      i += current_display_width;
+
+      if (i > bar_width) {
+        // `next` is larger than the allowed bar width
+        // fill with empty space instead
+        os << std::string((bar_width - (i - current_display_width)), ' ');
+        break;
+      }
+
+      os << next;
     }
     return os;
   }
@@ -157,17 +176,35 @@ private:
 class IndeterminateProgressScaleWriter {
 public:
   IndeterminateProgressScaleWriter(std::ostream &os, size_t bar_width, const std::string &fill,
-                      const std::string &lead)
+                                   const std::string &lead)
       : os(os), bar_width(bar_width), fill(fill), lead(lead) {}
 
   std::ostream &write(size_t progress) {
-    for (size_t i = 0; i < bar_width; ++i) {
+    for (size_t i = 0; i < bar_width;) {
-      if (i < progress)
+      std::string next;
-        os << fill;
+      size_t current_display_width = 0;
-      else if (i == progress)
+
-        os << lead;
+      if (i < progress) {
-      else 
+        next = fill;
-        os << fill;
+        current_display_width = unicode::display_width(fill);
+      } else if (i == progress) {
+        next = lead;
+        current_display_width = unicode::display_width(lead);
+      } else {
+        next = fill;
+        current_display_width = unicode::display_width(fill);
+      }
+
+      i += current_display_width;
+
+      if (i > bar_width) {
+        // `next` is larger than the allowed bar width
+        // fill with empty space instead
+        os << std::string((bar_width - (i - current_display_width)), ' ');
+        break;
+      }
+
+      os << next;
     }
     return os;
   }
@@ -180,4 +217,4 @@ private:
 };
 
 } // namespace details
-} // namespace indicators
+} // namespace indicators

include/indicators/display_width.hpp

@@ -0,0 +1,314 @@
+
+#pragma once
+#include <clocale>
+#if __has_include(<codecvt>)
+#include <codecvt>
+#define INDICATORS_HAVE_CODECVT 1
+#endif
+#include <cstdlib>
+#include <locale>
+#include <string>
+#include <wchar.h>
+
+namespace unicode {
+
+#if INDICATORS_HAVE_CODECVT
+namespace details {
+
+/*
+ * This is an implementation of wcwidth() and wcswidth() (defined in
+ * IEEE Std 1002.1-2001) for Unicode.
+ *
+ * http://www.opengroup.org/onlinepubs/007904975/functions/wcwidth.html
+ * http://www.opengroup.org/onlinepubs/007904975/functions/wcswidth.html
+ *
+ * In fixed-width output devices, Latin characters all occupy a single
+ * "cell" position of equal width, whereas ideographic CJK characters
+ * occupy two such cells. Interoperability between terminal-line
+ * applications and (teletype-style) character terminals using the
+ * UTF-8 encoding requires agreement on which character should advance
+ * the cursor by how many cell positions. No established formal
+ * standards exist at present on which Unicode character shall occupy
+ * how many cell positions on character terminals. These routines are
+ * a first attempt of defining such behavior based on simple rules
+ * applied to data provided by the Unicode Consortium.
+ *
+ * For some graphical characters, the Unicode standard explicitly
+ * defines a character-cell width via the definition of the East Asian
+ * FullWidth (F), Wide (W), Half-width (H), and Narrow (Na) classes.
+ * In all these cases, there is no ambiguity about which width a
+ * terminal shall use. For characters in the East Asian Ambiguous (A)
+ * class, the width choice depends purely on a preference of backward
+ * compatibility with either historic CJK or Western practice.
+ * Choosing single-width for these characters is easy to justify as
+ * the appropriate long-term solution, as the CJK practice of
+ * displaying these characters as double-width comes from historic
+ * implementation simplicity (8-bit encoded characters were displayed
+ * single-width and 16-bit ones double-width, even for Greek,
+ * Cyrillic, etc.) and not any typographic considerations.
+ *
+ * Much less clear is the choice of width for the Not East Asian
+ * (Neutral) class. Existing practice does not dictate a width for any
+ * of these characters. It would nevertheless make sense
+ * typographically to allocate two character cells to characters such
+ * as for instance EM SPACE or VOLUME INTEGRAL, which cannot be
+ * represented adequately with a single-width glyph. The following
+ * routines at present merely assign a single-cell width to all
+ * neutral characters, in the interest of simplicity. This is not
+ * entirely satisfactory and should be reconsidered before
+ * establishing a formal standard in this area. At the moment, the
+ * decision which Not East Asian (Neutral) characters should be
+ * represented by double-width glyphs cannot yet be answered by
+ * applying a simple rule from the Unicode database content. Setting
+ * up a proper standard for the behavior of UTF-8 character terminals
+ * will require a careful analysis not only of each Unicode character,
+ * but also of each presentation form, something the author of these
+ * routines has avoided to do so far.
+ *
+ * http://www.unicode.org/unicode/reports/tr11/
+ *
+ * Markus Kuhn -- 2007-05-26 (Unicode 5.0)
+ *
+ * Permission to use, copy, modify, and distribute this software
+ * for any purpose and without fee is hereby granted. The author
+ * disclaims all warranties with regard to this software.
+ *
+ * Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+ */
+
+struct interval {
+  int first;
+  int last;
+};
+
+/* auxiliary function for binary search in interval table */
+static inline int bisearch(wchar_t ucs, const struct interval *table, int max) {
+  int min = 0;
+  int mid;
+
+  if (ucs < table[0].first || ucs > table[max].last)
+    return 0;
+  while (max >= min) {
+    mid = (min + max) / 2;
+    if (ucs > table[mid].last)
+      min = mid + 1;
+    else if (ucs < table[mid].first)
+      max = mid - 1;
+    else
+      return 1;
+  }
+
+  return 0;
+}
+
+/* The following two functions define the column width of an ISO 10646
+ * character as follows:
+ *
+ *    - The null character (U+0000) has a column width of 0.
+ *
+ *    - Other C0/C1 control characters and DEL will lead to a return
+ *      value of -1.
+ *
+ *    - Non-spacing and enclosing combining characters (general
+ *      category code Mn or Me in the Unicode database) have a
+ *      column width of 0.
+ *
+ *    - SOFT HYPHEN (U+00AD) has a column width of 1.
+ *
+ *    - Other format characters (general category code Cf in the Unicode
+ *      database) and ZERO WIDTH SPACE (U+200B) have a column width of 0.
+ *
+ *    - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
+ *      have a column width of 0.
+ *
+ *    - Spacing characters in the East Asian Wide (W) or East Asian
+ *      Full-width (F) category as defined in Unicode Technical
+ *      Report #11 have a column width of 2.
+ *
+ *    - All remaining characters (including all printable
+ *      ISO 8859-1 and WGL4 characters, Unicode control characters,
+ *      etc.) have a column width of 1.
+ *
+ * This implementation assumes that wchar_t characters are encoded
+ * in ISO 10646.
+ */
+
+static inline int mk_wcwidth(wchar_t ucs) {
+  /* sorted list of non-overlapping intervals of non-spacing characters */
+  /* generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c" */
+  static const struct interval combining[] = {
+      {0x0300, 0x036F},   {0x0483, 0x0486},   {0x0488, 0x0489},   {0x0591, 0x05BD},
+      {0x05BF, 0x05BF},   {0x05C1, 0x05C2},   {0x05C4, 0x05C5},   {0x05C7, 0x05C7},
+      {0x0600, 0x0603},   {0x0610, 0x0615},   {0x064B, 0x065E},   {0x0670, 0x0670},
+      {0x06D6, 0x06E4},   {0x06E7, 0x06E8},   {0x06EA, 0x06ED},   {0x070F, 0x070F},
+      {0x0711, 0x0711},   {0x0730, 0x074A},   {0x07A6, 0x07B0},   {0x07EB, 0x07F3},
+      {0x0901, 0x0902},   {0x093C, 0x093C},   {0x0941, 0x0948},   {0x094D, 0x094D},
+      {0x0951, 0x0954},   {0x0962, 0x0963},   {0x0981, 0x0981},   {0x09BC, 0x09BC},
+      {0x09C1, 0x09C4},   {0x09CD, 0x09CD},   {0x09E2, 0x09E3},   {0x0A01, 0x0A02},
+      {0x0A3C, 0x0A3C},   {0x0A41, 0x0A42},   {0x0A47, 0x0A48},   {0x0A4B, 0x0A4D},
+      {0x0A70, 0x0A71},   {0x0A81, 0x0A82},   {0x0ABC, 0x0ABC},   {0x0AC1, 0x0AC5},
+      {0x0AC7, 0x0AC8},   {0x0ACD, 0x0ACD},   {0x0AE2, 0x0AE3},   {0x0B01, 0x0B01},
+      {0x0B3C, 0x0B3C},   {0x0B3F, 0x0B3F},   {0x0B41, 0x0B43},   {0x0B4D, 0x0B4D},
+      {0x0B56, 0x0B56},   {0x0B82, 0x0B82},   {0x0BC0, 0x0BC0},   {0x0BCD, 0x0BCD},
+      {0x0C3E, 0x0C40},   {0x0C46, 0x0C48},   {0x0C4A, 0x0C4D},   {0x0C55, 0x0C56},
+      {0x0CBC, 0x0CBC},   {0x0CBF, 0x0CBF},   {0x0CC6, 0x0CC6},   {0x0CCC, 0x0CCD},
+      {0x0CE2, 0x0CE3},   {0x0D41, 0x0D43},   {0x0D4D, 0x0D4D},   {0x0DCA, 0x0DCA},
+      {0x0DD2, 0x0DD4},   {0x0DD6, 0x0DD6},   {0x0E31, 0x0E31},   {0x0E34, 0x0E3A},
+      {0x0E47, 0x0E4E},   {0x0EB1, 0x0EB1},   {0x0EB4, 0x0EB9},   {0x0EBB, 0x0EBC},
+      {0x0EC8, 0x0ECD},   {0x0F18, 0x0F19},   {0x0F35, 0x0F35},   {0x0F37, 0x0F37},
+      {0x0F39, 0x0F39},   {0x0F71, 0x0F7E},   {0x0F80, 0x0F84},   {0x0F86, 0x0F87},
+      {0x0F90, 0x0F97},   {0x0F99, 0x0FBC},   {0x0FC6, 0x0FC6},   {0x102D, 0x1030},
+      {0x1032, 0x1032},   {0x1036, 0x1037},   {0x1039, 0x1039},   {0x1058, 0x1059},
+      {0x1160, 0x11FF},   {0x135F, 0x135F},   {0x1712, 0x1714},   {0x1732, 0x1734},
+      {0x1752, 0x1753},   {0x1772, 0x1773},   {0x17B4, 0x17B5},   {0x17B7, 0x17BD},
+      {0x17C6, 0x17C6},   {0x17C9, 0x17D3},   {0x17DD, 0x17DD},   {0x180B, 0x180D},
+      {0x18A9, 0x18A9},   {0x1920, 0x1922},   {0x1927, 0x1928},   {0x1932, 0x1932},
+      {0x1939, 0x193B},   {0x1A17, 0x1A18},   {0x1B00, 0x1B03},   {0x1B34, 0x1B34},
+      {0x1B36, 0x1B3A},   {0x1B3C, 0x1B3C},   {0x1B42, 0x1B42},   {0x1B6B, 0x1B73},
+      {0x1DC0, 0x1DCA},   {0x1DFE, 0x1DFF},   {0x200B, 0x200F},   {0x202A, 0x202E},
+      {0x2060, 0x2063},   {0x206A, 0x206F},   {0x20D0, 0x20EF},   {0x302A, 0x302F},
+      {0x3099, 0x309A},   {0xA806, 0xA806},   {0xA80B, 0xA80B},   {0xA825, 0xA826},
+      {0xFB1E, 0xFB1E},   {0xFE00, 0xFE0F},   {0xFE20, 0xFE23},   {0xFEFF, 0xFEFF},
+      {0xFFF9, 0xFFFB},   {0x10A01, 0x10A03}, {0x10A05, 0x10A06}, {0x10A0C, 0x10A0F},
+      {0x10A38, 0x10A3A}, {0x10A3F, 0x10A3F}, {0x1D167, 0x1D169}, {0x1D173, 0x1D182},
+      {0x1D185, 0x1D18B}, {0x1D1AA, 0x1D1AD}, {0x1D242, 0x1D244}, {0xE0001, 0xE0001},
+      {0xE0020, 0xE007F}, {0xE0100, 0xE01EF}};
+
+  /* test for 8-bit control characters */
+  if (ucs == 0)
+    return 0;
+  if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
+    return -1;
+
+  /* binary search in table of non-spacing characters */
+  if (bisearch(ucs, combining, sizeof(combining) / sizeof(struct interval) - 1))
+    return 0;
+
+  /* if we arrive here, ucs is not a combining or C0/C1 control character */
+
+  return 1 + (ucs >= 0x1100 &&
+              (ucs <= 0x115f || /* Hangul Jamo init. consonants */
+               ucs == 0x2329 || ucs == 0x232a ||
+               (ucs >= 0x2e80 && ucs <= 0xa4cf && ucs != 0x303f) || /* CJK ... Yi */
+               (ucs >= 0xac00 && ucs <= 0xd7a3) ||                  /* Hangul Syllables */
+               (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */
+               (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */
+               (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
+               (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */
+               (ucs >= 0xffe0 && ucs <= 0xffe6) || (ucs >= 0x20000 && ucs <= 0x2fffd) ||
+               (ucs >= 0x30000 && ucs <= 0x3fffd)));
+}
+
+static inline int mk_wcswidth(const wchar_t *pwcs, size_t n) {
+  int w, width = 0;
+
+  for (; *pwcs && n-- > 0; pwcs++)
+    if ((w = mk_wcwidth(*pwcs)) < 0)
+      return -1;
+    else
+      width += w;
+
+  return width;
+}
+
+/*
+ * The following functions are the same as mk_wcwidth() and
+ * mk_wcswidth(), except that spacing characters in the East Asian
+ * Ambiguous (A) category as defined in Unicode Technical Report #11
+ * have a column width of 2. This variant might be useful for users of
+ * CJK legacy encodings who want to migrate to UCS without changing
+ * the traditional terminal character-width behaviour. It is not
+ * otherwise recommended for general use.
+ */
+static inline int mk_wcwidth_cjk(wchar_t ucs) {
+  /* sorted list of non-overlapping intervals of East Asian Ambiguous
+   * characters, generated by "uniset +WIDTH-A -cat=Me -cat=Mn -cat=Cf c" */
+  static const struct interval ambiguous[] = {
+      {0x00A1, 0x00A1},    {0x00A4, 0x00A4}, {0x00A7, 0x00A8}, {0x00AA, 0x00AA}, {0x00AE, 0x00AE},
+      {0x00B0, 0x00B4},    {0x00B6, 0x00BA}, {0x00BC, 0x00BF}, {0x00C6, 0x00C6}, {0x00D0, 0x00D0},
+      {0x00D7, 0x00D8},    {0x00DE, 0x00E1}, {0x00E6, 0x00E6}, {0x00E8, 0x00EA}, {0x00EC, 0x00ED},
+      {0x00F0, 0x00F0},    {0x00F2, 0x00F3}, {0x00F7, 0x00FA}, {0x00FC, 0x00FC}, {0x00FE, 0x00FE},
+      {0x0101, 0x0101},    {0x0111, 0x0111}, {0x0113, 0x0113}, {0x011B, 0x011B}, {0x0126, 0x0127},
+      {0x012B, 0x012B},    {0x0131, 0x0133}, {0x0138, 0x0138}, {0x013F, 0x0142}, {0x0144, 0x0144},
+      {0x0148, 0x014B},    {0x014D, 0x014D}, {0x0152, 0x0153}, {0x0166, 0x0167}, {0x016B, 0x016B},
+      {0x01CE, 0x01CE},    {0x01D0, 0x01D0}, {0x01D2, 0x01D2}, {0x01D4, 0x01D4}, {0x01D6, 0x01D6},
+      {0x01D8, 0x01D8},    {0x01DA, 0x01DA}, {0x01DC, 0x01DC}, {0x0251, 0x0251}, {0x0261, 0x0261},
+      {0x02C4, 0x02C4},    {0x02C7, 0x02C7}, {0x02C9, 0x02CB}, {0x02CD, 0x02CD}, {0x02D0, 0x02D0},
+      {0x02D8, 0x02DB},    {0x02DD, 0x02DD}, {0x02DF, 0x02DF}, {0x0391, 0x03A1}, {0x03A3, 0x03A9},
+      {0x03B1, 0x03C1},    {0x03C3, 0x03C9}, {0x0401, 0x0401}, {0x0410, 0x044F}, {0x0451, 0x0451},
+      {0x2010, 0x2010},    {0x2013, 0x2016}, {0x2018, 0x2019}, {0x201C, 0x201D}, {0x2020, 0x2022},
+      {0x2024, 0x2027},    {0x2030, 0x2030}, {0x2032, 0x2033}, {0x2035, 0x2035}, {0x203B, 0x203B},
+      {0x203E, 0x203E},    {0x2074, 0x2074}, {0x207F, 0x207F}, {0x2081, 0x2084}, {0x20AC, 0x20AC},
+      {0x2103, 0x2103},    {0x2105, 0x2105}, {0x2109, 0x2109}, {0x2113, 0x2113}, {0x2116, 0x2116},
+      {0x2121, 0x2122},    {0x2126, 0x2126}, {0x212B, 0x212B}, {0x2153, 0x2154}, {0x215B, 0x215E},
+      {0x2160, 0x216B},    {0x2170, 0x2179}, {0x2190, 0x2199}, {0x21B8, 0x21B9}, {0x21D2, 0x21D2},
+      {0x21D4, 0x21D4},    {0x21E7, 0x21E7}, {0x2200, 0x2200}, {0x2202, 0x2203}, {0x2207, 0x2208},
+      {0x220B, 0x220B},    {0x220F, 0x220F}, {0x2211, 0x2211}, {0x2215, 0x2215}, {0x221A, 0x221A},
+      {0x221D, 0x2220},    {0x2223, 0x2223}, {0x2225, 0x2225}, {0x2227, 0x222C}, {0x222E, 0x222E},
+      {0x2234, 0x2237},    {0x223C, 0x223D}, {0x2248, 0x2248}, {0x224C, 0x224C}, {0x2252, 0x2252},
+      {0x2260, 0x2261},    {0x2264, 0x2267}, {0x226A, 0x226B}, {0x226E, 0x226F}, {0x2282, 0x2283},
+      {0x2286, 0x2287},    {0x2295, 0x2295}, {0x2299, 0x2299}, {0x22A5, 0x22A5}, {0x22BF, 0x22BF},
+      {0x2312, 0x2312},    {0x2460, 0x24E9}, {0x24EB, 0x254B}, {0x2550, 0x2573}, {0x2580, 0x258F},
+      {0x2592, 0x2595},    {0x25A0, 0x25A1}, {0x25A3, 0x25A9}, {0x25B2, 0x25B3}, {0x25B6, 0x25B7},
+      {0x25BC, 0x25BD},    {0x25C0, 0x25C1}, {0x25C6, 0x25C8}, {0x25CB, 0x25CB}, {0x25CE, 0x25D1},
+      {0x25E2, 0x25E5},    {0x25EF, 0x25EF}, {0x2605, 0x2606}, {0x2609, 0x2609}, {0x260E, 0x260F},
+      {0x2614, 0x2615},    {0x261C, 0x261C}, {0x261E, 0x261E}, {0x2640, 0x2640}, {0x2642, 0x2642},
+      {0x2660, 0x2661},    {0x2663, 0x2665}, {0x2667, 0x266A}, {0x266C, 0x266D}, {0x266F, 0x266F},
+      {0x273D, 0x273D},    {0x2776, 0x277F}, {0xE000, 0xF8FF}, {0xFFFD, 0xFFFD}, {0xF0000, 0xFFFFD},
+      {0x100000, 0x10FFFD}};
+
+  /* binary search in table of non-spacing characters */
+  if (bisearch(ucs, ambiguous, sizeof(ambiguous) / sizeof(struct interval) - 1))
+    return 2;
+
+  return mk_wcwidth(ucs);
+}
+
+static inline int mk_wcswidth_cjk(const wchar_t *pwcs, size_t n) {
+  int w, width = 0;
+
+  for (; *pwcs && n-- > 0; pwcs++)
+    if ((w = mk_wcwidth_cjk(*pwcs)) < 0)
+      return -1;
+    else
+      width += w;
+
+  return width;
+}
+
+// convert UTF-8 string to wstring
+static inline std::wstring utf8_decode(const std::string &str) {
+  std::wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
+  return myconv.from_bytes(str);
+}
+
+// convert wstring to UTF-8 string
+static inline std::string utf8_encode(const std::wstring &str) {
+  std::wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
+  return myconv.to_bytes(str);
+}
+
+} // namespace details
+
+static inline int display_width(const std::string &input) {
+  using namespace unicode::details;
+  return mk_wcswidth(utf8_decode(input).c_str(), input.size());
+}
+
+static inline int display_width(const std::wstring &input) {
+  return details::mk_wcswidth(input.c_str(), input.size());
+}
+
+#else
+
+static inline int display_width(const std::string &input) {
+  return input.length();
+}
+
+static inline int display_width(const std::wstring &input) {
+  return input.length();
+}
+
+#endif
+
+} // namespace unicode

include/indicators/dynamic_progress.hpp

@@ -1,8 +1,10 @@
+
 #pragma once
 #include <atomic>
 #include <functional>
 #include <indicators/color.hpp>
 #include <indicators/setting.hpp>
+#include <indicators/details/stream_helper.hpp>
 #include <iostream>
 #include <mutex>
 #include <vector>

include/indicators/font_style.hpp

@@ -1,7 +1,5 @@
+
 #pragma once
-
 namespace indicators {
-
 enum class FontStyle { bold, dark, italic, underline, blink, reverse, concealed, crossed };
-
 }

include/indicators/indeterminate_progress_bar.hpp

@@ -1,3 +1,4 @@
+
 #pragma once
 
 #include <indicators/details/stream_helper.hpp>
@@ -8,6 +9,7 @@
 #include <cmath>
 #include <indicators/color.hpp>
 #include <indicators/setting.hpp>
+#include <indicators/terminal_size.hpp>
 #include <iomanip>
 #include <iostream>
 #include <mutex>
@@ -15,20 +17,18 @@
 #include <thread>
 #include <tuple>
 #include <type_traits>
+#include <sstream>
+#include <utility>
 
 namespace indicators {
 
 class IndeterminateProgressBar {
   using Settings =
       std::tuple<option::BarWidth, option::PrefixText, option::PostfixText, option::Start,
-                 option::End, option::Fill, option::Lead,
+                 option::End, option::Fill, option::Lead, option::MaxPostfixTextLen,
-                 option::MaxPostfixTextLen, option::Completed,
+                 option::Completed, option::ForegroundColor, option::FontStyles, option::Stream>;
-                 option::ForegroundColor, option::FontStyles, option::Stream>;
 
-  enum class Direction {
+  enum class Direction { forward, backward };
-    forward,
-    backward
-  };
 
   Direction direction_{Direction::forward};
 
@@ -60,8 +60,8 @@ public:
                       option::ForegroundColor{Color::unspecified}, std::forward<Args>(args)...),
                   details::get<details::ProgressBarOption::font_styles>(
                       option::FontStyles{std::vector<FontStyle>{}}, std::forward<Args>(args)...),
-                  details::get<details::ProgressBarOption::stream>(
+                  details::get<details::ProgressBarOption::stream>(option::Stream{std::cout},
-                      option::Stream{std::cout}, std::forward<Args>(args)...)) {
+                                                                   std::forward<Args>(args)...)) {
     // starts with [<==>...........]
     // progress_ = 0
 
@@ -70,10 +70,10 @@ public:
     //             ^^^^^^^^^^^^ (bar_width - len(lead))
     // progress_ = bar_width - len(lead)
     progress_ = 0;
-    max_progress_ = get_value<details::ProgressBarOption::bar_width>()
+    max_progress_ = get_value<details::ProgressBarOption::bar_width>() -
-      - get_value<details::ProgressBarOption::lead>().size() 
+                    get_value<details::ProgressBarOption::lead>().size() +
-      + get_value<details::ProgressBarOption::start>().size()
+                    get_value<details::ProgressBarOption::start>().size() +
-      + get_value<details::ProgressBarOption::end>().size();
+                    get_value<details::ProgressBarOption::end>().size();
   }
 
   template <typename T, details::ProgressBarOption id>
@@ -130,9 +130,7 @@ public:
     print_progress();
   }
 
-  bool is_completed() {
+  bool is_completed() { return get_value<details::ProgressBarOption::completed>(); }
-    return get_value<details::ProgressBarOption::completed>();
-  }
 
   void mark_as_completed() {
     get_value<details::ProgressBarOption::completed>() = true;
@@ -161,11 +159,28 @@ private:
   template <typename Indicator> friend class DynamicProgress;
   std::atomic<bool> multi_progress_mode_{false};
 
+  std::pair<std::string, size_t> get_prefix_text() {
+    std::stringstream os;
+    os << get_value<details::ProgressBarOption::prefix_text>();
+    const auto result = os.str();
+    const auto result_size = unicode::display_width(result);
+    return {result, result_size};
+  }
+
+  std::pair<std::string, size_t> get_postfix_text() {
+    std::stringstream os;
+    os << " " << get_value<details::ProgressBarOption::postfix_text>();
+
+    const auto result = os.str();
+    const auto result_size = unicode::display_width(result);
+    return {result, result_size};
+  }
+
 public:
   void print_progress(bool from_multi_progress = false) {
     std::lock_guard<std::mutex> lock{mutex_};
 
-    auto& os = get_value<details::ProgressBarOption::stream>();
+    auto &os = get_value<details::ProgressBarOption::stream>();
 
     if (multi_progress_mode_ && !from_multi_progress) {
       return;
@@ -176,24 +191,40 @@ public:
     for (auto &style : get_value<details::ProgressBarOption::font_styles>())
       details::set_font_style(os, style);
 
-    os << get_value<details::ProgressBarOption::prefix_text>();
+    const auto prefix_pair = get_prefix_text();
+    const auto prefix_text = prefix_pair.first;
+    const auto prefix_length = prefix_pair.second;
+    os << prefix_text;
 
     os << get_value<details::ProgressBarOption::start>();
 
-    details::IndeterminateProgressScaleWriter writer{os,
+    details::IndeterminateProgressScaleWriter writer{
-                                        get_value<details::ProgressBarOption::bar_width>(),
+        os, get_value<details::ProgressBarOption::bar_width>(),
-                                        get_value<details::ProgressBarOption::fill>(),
+        get_value<details::ProgressBarOption::fill>(),
-                                        get_value<details::ProgressBarOption::lead>()};
+        get_value<details::ProgressBarOption::lead>()};
     writer.write(progress_);
 
     os << get_value<details::ProgressBarOption::end>();
 
-    if (get_value<details::ProgressBarOption::max_postfix_text_len>() == 0)
+    const auto postfix_pair = get_postfix_text();
-      get_value<details::ProgressBarOption::max_postfix_text_len>() = 10;
+    const auto postfix_text = postfix_pair.first;
-    os << " " << get_value<details::ProgressBarOption::postfix_text>()
+    const auto postfix_length = postfix_pair.second;
-              << std::string(get_value<details::ProgressBarOption::max_postfix_text_len>(), ' ')
+    os << postfix_text;
-              << "\r";
+
+    // Get length of prefix text and postfix text
+    const auto start_length = get_value<details::ProgressBarOption::start>().size();
+    const auto bar_width = get_value<details::ProgressBarOption::bar_width>();
+    const auto end_length = get_value<details::ProgressBarOption::end>().size();
+    const auto terminal_width = terminal_size().second;
+    // prefix + bar_width + postfix should be <= terminal_width
+    const int remaining = terminal_width - (prefix_length + start_length + bar_width + end_length + postfix_length);
+    if (remaining > 0) {
+      os << std::string(remaining, ' ') << "\r";
+    } else if (remaining < 0) {
+      // Do nothing. Maybe in the future truncate postfix with ...
+    }
     os.flush();
+
     if (get_value<details::ProgressBarOption::completed>() &&
         !from_multi_progress) // Don't std::endl if calling from MultiProgress
       os << termcolor::reset << std::endl;

include/indicators/multi_progress.hpp

@@ -1,3 +1,4 @@
+
 #pragma once
 #include <atomic>
 #include <functional>
@@ -5,8 +6,9 @@
 #include <mutex>
 #include <vector>
 
-#include <indicators/cursor_movement.hpp>
 #include <indicators/color.hpp>
+#include <indicators/cursor_movement.hpp>
+#include <indicators/details/stream_helper.hpp>
 
 namespace indicators {
 

include/indicators/progress_bar.hpp

@@ -1,3 +1,4 @@
+
 #pragma once
 
 #include <indicators/details/stream_helper.hpp>
@@ -8,101 +9,134 @@
 #include <cmath>
 #include <indicators/color.hpp>
 #include <indicators/setting.hpp>
+#include <indicators/terminal_size.hpp>
 #include <iomanip>
 #include <iostream>
+#include <sstream>
 #include <mutex>
 #include <string>
 #include <thread>
 #include <tuple>
 #include <type_traits>
+#include <utility>
 
 namespace indicators {
 
 class ProgressBar {
   using Settings =
-      std::tuple<option::BarWidth, option::PrefixText, option::PostfixText, option::Start,
+      std::tuple<option::BarWidth, option::PrefixText, option::PostfixText,
-                 option::End, option::Fill, option::Lead, option::Remainder,
+                 option::Start, option::End, option::Fill, option::Lead,
-                 option::MaxPostfixTextLen, option::Completed, option::ShowPercentage,
+                 option::Remainder, option::MaxPostfixTextLen,
-                 option::ShowElapsedTime, option::ShowRemainingTime, option::SavedStartTime,
+                 option::Completed, option::ShowPercentage,
-                 option::ForegroundColor, option::FontStyles, option::MaxProgress, option::Stream>;
+                 option::ShowElapsedTime, option::ShowRemainingTime,
+                 option::SavedStartTime, option::ForegroundColor,
+                 option::FontStyles, option::MinProgress, option::MaxProgress,
+                 option::ProgressType, option::Stream>;
 
 public:
   template <typename... Args,
-            typename std::enable_if<details::are_settings_from_tuple<
+            typename std::enable_if<
-                                        Settings, typename std::decay<Args>::type...>::value,
+                details::are_settings_from_tuple<
-                                    void *>::type = nullptr>
+                    Settings, typename std::decay<Args>::type...>::value,
+                void *>::type = nullptr>
   explicit ProgressBar(Args &&... args)
-      : settings_(details::get<details::ProgressBarOption::bar_width>(option::BarWidth{100},
+      : settings_(
-                                                                      std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::bar_width>(
-                  details::get<details::ProgressBarOption::prefix_text>(
+                option::BarWidth{100}, std::forward<Args>(args)...),
-                      option::PrefixText{}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::prefix_text>(
-                  details::get<details::ProgressBarOption::postfix_text>(
+                option::PrefixText{}, std::forward<Args>(args)...),
-                      option::PostfixText{}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::postfix_text>(
-                  details::get<details::ProgressBarOption::start>(option::Start{"["},
+                option::PostfixText{}, std::forward<Args>(args)...),
-                                                                  std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::start>(
-                  details::get<details::ProgressBarOption::end>(option::End{"]"},
+                option::Start{"["}, std::forward<Args>(args)...),
-                                                                std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::end>(
-                  details::get<details::ProgressBarOption::fill>(option::Fill{"="},
+                option::End{"]"}, std::forward<Args>(args)...),
-                                                                 std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::fill>(
-                  details::get<details::ProgressBarOption::lead>(option::Lead{">"},
+                option::Fill{"="}, std::forward<Args>(args)...),
-                                                                 std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::lead>(
-                  details::get<details::ProgressBarOption::remainder>(option::Remainder{" "},
+                option::Lead{">"}, std::forward<Args>(args)...),
-                                                                      std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::remainder>(
-                  details::get<details::ProgressBarOption::max_postfix_text_len>(
+                option::Remainder{" "}, std::forward<Args>(args)...),
-                      option::MaxPostfixTextLen{0}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::max_postfix_text_len>(
-                  details::get<details::ProgressBarOption::completed>(option::Completed{false},
+                option::MaxPostfixTextLen{0}, std::forward<Args>(args)...),
-                                                                      std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::completed>(
-                  details::get<details::ProgressBarOption::show_percentage>(
+                option::Completed{false}, std::forward<Args>(args)...),
-                      option::ShowPercentage{false}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::show_percentage>(
-                  details::get<details::ProgressBarOption::show_elapsed_time>(
+                option::ShowPercentage{false}, std::forward<Args>(args)...),
-                      option::ShowElapsedTime{false}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::show_elapsed_time>(
-                  details::get<details::ProgressBarOption::show_remaining_time>(
+                option::ShowElapsedTime{false}, std::forward<Args>(args)...),
-                      option::ShowRemainingTime{false}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::show_remaining_time>(
-                  details::get<details::ProgressBarOption::saved_start_time>(
+                option::ShowRemainingTime{false}, std::forward<Args>(args)...),
-                      option::SavedStartTime{false}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::saved_start_time>(
-                  details::get<details::ProgressBarOption::foreground_color>(
+                option::SavedStartTime{false}, std::forward<Args>(args)...),
-                      option::ForegroundColor{Color::unspecified}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::foreground_color>(
-                  details::get<details::ProgressBarOption::font_styles>(
+                option::ForegroundColor{Color::unspecified},
-                      option::FontStyles{std::vector<FontStyle>{}}, std::forward<Args>(args)...),
+                std::forward<Args>(args)...),
-                  details::get<details::ProgressBarOption::max_progress>(
+            details::get<details::ProgressBarOption::font_styles>(
-                      option::MaxProgress{100}, std::forward<Args>(args)...),
+                option::FontStyles{std::vector<FontStyle>{}},
-                  details::get<details::ProgressBarOption::stream>(
+                std::forward<Args>(args)...),
-                      option::Stream{std::cout}, std::forward<Args>(args)...)) {}
+            details::get<details::ProgressBarOption::min_progress>(
+                option::MinProgress{0}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::max_progress>(
+                option::MaxProgress{100}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::progress_type>(
+                option::ProgressType{ProgressType::incremental},
+                std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::stream>(
+                option::Stream{std::cout}, std::forward<Args>(args)...)) {
+
+    // if progress is incremental, start from min_progress
+    // else start from max_progress
+    const auto type = get_value<details::ProgressBarOption::progress_type>();
+    if (type == ProgressType::incremental)
+      progress_ = get_value<details::ProgressBarOption::min_progress>();
+    else
+      progress_ = get_value<details::ProgressBarOption::max_progress>();
+  }
 
   template <typename T, details::ProgressBarOption id>
   void set_option(details::Setting<T, id> &&setting) {
-    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(
+    static_assert(
-                                       std::declval<Settings>()))>::type>::value,
+        !std::is_same<T, typename std::decay<decltype(details::get_value<id>(
-                  "Setting has wrong type!");
+                             std::declval<Settings>()))>::type>::value,
+        "Setting has wrong type!");
     std::lock_guard<std::mutex> lock(mutex_);
     get_value<id>() = std::move(setting).value;
   }
 
   template <typename T, details::ProgressBarOption id>
   void set_option(const details::Setting<T, id> &setting) {
-    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(
+    static_assert(
-                                       std::declval<Settings>()))>::type>::value,
+        !std::is_same<T, typename std::decay<decltype(details::get_value<id>(
-                  "Setting has wrong type!");
+                             std::declval<Settings>()))>::type>::value,
+        "Setting has wrong type!");
     std::lock_guard<std::mutex> lock(mutex_);
     get_value<id>() = setting.value;
   }
 
-  void set_option(
+  void
-      const details::Setting<std::string, details::ProgressBarOption::postfix_text> &setting) {
+  set_option(const details::Setting<
+             std::string, details::ProgressBarOption::postfix_text> &setting) {
     std::lock_guard<std::mutex> lock(mutex_);
     get_value<details::ProgressBarOption::postfix_text>() = setting.value;
-    if (setting.value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()) {
+    if (setting.value.length() >
-      get_value<details::ProgressBarOption::max_postfix_text_len>() = setting.value.length();
+        get_value<details::ProgressBarOption::max_postfix_text_len>()) {
+      get_value<details::ProgressBarOption::max_postfix_text_len>() =
+          setting.value.length();
     }
   }
 
-  void
+  void set_option(
-  set_option(details::Setting<std::string, details::ProgressBarOption::postfix_text> &&setting) {
+      details::Setting<std::string, details::ProgressBarOption::postfix_text>
+          &&setting) {
     std::lock_guard<std::mutex> lock(mutex_);
-    get_value<details::ProgressBarOption::postfix_text>() = std::move(setting).value;
+    get_value<details::ProgressBarOption::postfix_text>() =
+        std::move(setting).value;
     auto &new_value = get_value<details::ProgressBarOption::postfix_text>();
-    if (new_value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()) {
+    if (new_value.length() >
-      get_value<details::ProgressBarOption::max_postfix_text_len>() = new_value.length();
+        get_value<details::ProgressBarOption::max_postfix_text_len>()) {
+      get_value<details::ProgressBarOption::max_postfix_text_len>() =
+          new_value.length();
     }
   }
 
@@ -119,7 +153,11 @@ public:
   void tick() {
     {
       std::lock_guard<std::mutex> lock{mutex_};
-      progress_ += 1;
+      const auto type = get_value<details::ProgressBarOption::progress_type>();
+      if (type == ProgressType::incremental)
+        progress_ += 1;
+      else
+        progress_ -= 1;
     }
     save_start_time();
     print_progress();
@@ -127,10 +165,14 @@ public:
 
   size_t current() {
     std::lock_guard<std::mutex> lock{mutex_};
-    return std::min(progress_, size_t(get_value<details::ProgressBarOption::max_progress>()));
+    return std::min(
+        progress_,
+        size_t(get_value<details::ProgressBarOption::max_progress>()));
   }
 
-  bool is_completed() const { return get_value<details::ProgressBarOption::completed>(); }
+  bool is_completed() const {
+    return get_value<details::ProgressBarOption::completed>();
+  }
 
   void mark_as_completed() {
     get_value<details::ProgressBarOption::completed>() = true;
@@ -139,13 +181,14 @@ public:
 
 private:
   template <details::ProgressBarOption id>
-  auto get_value() -> decltype((details::get_value<id>(std::declval<Settings &>()).value)) {
+  auto get_value()
+      -> decltype((details::get_value<id>(std::declval<Settings &>()).value)) {
     return details::get_value<id>(settings_).value;
   }
 
   template <details::ProgressBarOption id>
-  auto get_value() const
+  auto get_value() const -> decltype(
-      -> decltype((details::get_value<id>(std::declval<const Settings &>()).value)) {
+      (details::get_value<id>(std::declval<const Settings &>()).value)) {
     return details::get_value<id>(settings_).value;
   }
 
@@ -160,56 +203,41 @@ private:
   std::atomic<bool> multi_progress_mode_{false};
 
   void save_start_time() {
-    auto &show_elapsed_time = get_value<details::ProgressBarOption::show_elapsed_time>();
+    auto &show_elapsed_time =
-    auto &saved_start_time = get_value<details::ProgressBarOption::saved_start_time>();
+        get_value<details::ProgressBarOption::show_elapsed_time>();
-    auto &show_remaining_time = get_value<details::ProgressBarOption::show_remaining_time>();
+    auto &saved_start_time =
+        get_value<details::ProgressBarOption::saved_start_time>();
+    auto &show_remaining_time =
+        get_value<details::ProgressBarOption::show_remaining_time>();
     if ((show_elapsed_time || show_remaining_time) && !saved_start_time) {
       start_time_point_ = std::chrono::high_resolution_clock::now();
       saved_start_time = true;
     }
   }
 
-public:
+  std::pair<std::string, size_t> get_prefix_text() {
-  void print_progress(bool from_multi_progress = false) {
+    std::stringstream os;
-    std::lock_guard<std::mutex> lock{mutex_};
-
-    auto& os = get_value<details::ProgressBarOption::stream>();
-
-    const auto max_progress = get_value<details::ProgressBarOption::max_progress>();
-    if (multi_progress_mode_ && !from_multi_progress) {
-      if (progress_ >= max_progress) {
-        get_value<details::ProgressBarOption::completed>() = true;
-      }
-      return;
-    }
-    auto now = std::chrono::high_resolution_clock::now();
-    if (!get_value<details::ProgressBarOption::completed>())
-      elapsed_ = std::chrono::duration_cast<std::chrono::nanoseconds>(now - start_time_point_);
-
-    if (get_value<details::ProgressBarOption::foreground_color>() != Color::unspecified)
-      details::set_stream_color(os, get_value<details::ProgressBarOption::foreground_color>());
-
-    for (auto &style : get_value<details::ProgressBarOption::font_styles>())
-      details::set_font_style(os, style);
-
     os << get_value<details::ProgressBarOption::prefix_text>();
+    const auto result = os.str();
+    const auto result_size = unicode::display_width(result);
+    return {result, result_size};
+  }
 
-    os << get_value<details::ProgressBarOption::start>();
+  std::pair<std::string, size_t> get_postfix_text() {
-
+    std::stringstream os;
-    details::ProgressScaleWriter writer{os,
+    const auto max_progress =
-                                        get_value<details::ProgressBarOption::bar_width>(),
+        get_value<details::ProgressBarOption::max_progress>();
-                                        get_value<details::ProgressBarOption::fill>(),
-                                        get_value<details::ProgressBarOption::lead>(),
-                                        get_value<details::ProgressBarOption::remainder>()};
-    writer.write(double(progress_) / double(max_progress) * 100.0f);
-
-    os << get_value<details::ProgressBarOption::end>();
 
     if (get_value<details::ProgressBarOption::show_percentage>()) {
-      os << " " << std::min(static_cast<size_t>(static_cast<float>(progress_) / max_progress * 100), size_t(100)) << "%";
+      os << " "
+         << std::min(static_cast<size_t>(static_cast<float>(progress_) /
+                                         max_progress * 100),
+                     size_t(100))
+         << "%";
     }
 
-    auto &saved_start_time = get_value<details::ProgressBarOption::saved_start_time>();
+    auto &saved_start_time =
+        get_value<details::ProgressBarOption::saved_start_time>();
 
     if (get_value<details::ProgressBarOption::show_elapsed_time>()) {
       os << " [";
@@ -227,7 +255,10 @@ public:
 
       if (saved_start_time) {
         auto eta = std::chrono::nanoseconds(
-            progress_ > 0 ? static_cast<long long>(elapsed_.count() * max_progress / progress_) : 0);
+            progress_ > 0
+                ? static_cast<long long>(std::ceil(float(elapsed_.count()) *
+                                                   max_progress / progress_))
+                : 0);
         auto remaining = eta > elapsed_ ? (eta - elapsed_) : (elapsed_ - eta);
         details::write_duration(os, remaining);
       } else {
@@ -240,13 +271,81 @@ public:
         os << "]";
     }
 
-    if (get_value<details::ProgressBarOption::max_postfix_text_len>() == 0)
+    os << " " << get_value<details::ProgressBarOption::postfix_text>();
-      get_value<details::ProgressBarOption::max_postfix_text_len>() = 10;
+
-    os << " " << get_value<details::ProgressBarOption::postfix_text>()
+    const auto result = os.str();
-              << std::string(get_value<details::ProgressBarOption::max_postfix_text_len>(), ' ')
+    const auto result_size = unicode::display_width(result);
-              << "\r";
+    return {result, result_size};
+  }
+
+public:
+  void print_progress(bool from_multi_progress = false) {
+    std::lock_guard<std::mutex> lock{mutex_};
+
+    auto &os = get_value<details::ProgressBarOption::stream>();
+
+    const auto type = get_value<details::ProgressBarOption::progress_type>();
+    const auto min_progress =
+        get_value<details::ProgressBarOption::min_progress>();
+    const auto max_progress =
+        get_value<details::ProgressBarOption::max_progress>();
+    if (multi_progress_mode_ && !from_multi_progress) {
+      if ((type == ProgressType::incremental && progress_ >= max_progress) ||
+          (type == ProgressType::decremental && progress_ <= min_progress)) {
+        get_value<details::ProgressBarOption::completed>() = true;
+      }
+      return;
+    }
+    auto now = std::chrono::high_resolution_clock::now();
+    if (!get_value<details::ProgressBarOption::completed>())
+      elapsed_ = std::chrono::duration_cast<std::chrono::nanoseconds>(
+          now - start_time_point_);
+
+    if (get_value<details::ProgressBarOption::foreground_color>() !=
+        Color::unspecified)
+      details::set_stream_color(
+          os, get_value<details::ProgressBarOption::foreground_color>());
+
+    for (auto &style : get_value<details::ProgressBarOption::font_styles>())
+      details::set_font_style(os, style);
+
+    const auto prefix_pair = get_prefix_text();
+    const auto prefix_text = prefix_pair.first;
+    const auto prefix_length = prefix_pair.second;
+    os << prefix_text;
+
+    os << get_value<details::ProgressBarOption::start>();
+
+    details::ProgressScaleWriter writer{
+        os, get_value<details::ProgressBarOption::bar_width>(),
+        get_value<details::ProgressBarOption::fill>(),
+        get_value<details::ProgressBarOption::lead>(),
+        get_value<details::ProgressBarOption::remainder>()};
+    writer.write(double(progress_) / double(max_progress) * 100.0f);
+
+    os << get_value<details::ProgressBarOption::end>();
+
+    const auto postfix_pair = get_postfix_text();
+    const auto postfix_text = postfix_pair.first;
+    const auto postfix_length = postfix_pair.second;
+    os << postfix_text;
+
+    // Get length of prefix text and postfix text
+    const auto start_length = get_value<details::ProgressBarOption::start>().size();
+    const auto bar_width = get_value<details::ProgressBarOption::bar_width>();
+    const auto end_length = get_value<details::ProgressBarOption::end>().size();
+    const auto terminal_width = terminal_size().second;
+    // prefix + bar_width + postfix should be <= terminal_width
+    const int remaining = terminal_width - (prefix_length + start_length + bar_width + end_length + postfix_length);
+    if (remaining > 0) {
+      os << std::string(remaining, ' ') << "\r";
+    } else if (remaining < 0) {
+      // Do nothing. Maybe in the future truncate postfix with ...
+    }
     os.flush();
-    if (progress_ >= max_progress) {
+
+    if ((type == ProgressType::incremental && progress_ >= max_progress) ||
+        (type == ProgressType::decremental && progress_ <= min_progress)) {
       get_value<details::ProgressBarOption::completed>() = true;
     }
     if (get_value<details::ProgressBarOption::completed>() &&

include/indicators/progress_spinner.hpp

@@ -1,3 +1,4 @@
+
 #pragma once
 
 #include <indicators/details/stream_helper.hpp>
@@ -32,36 +33,37 @@ public:
                                         Settings, typename std::decay<Args>::type...>::value,
                                     void *>::type = nullptr>
   explicit ProgressSpinner(Args &&... args)
-      : settings_(details::get<details::ProgressBarOption::foreground_color>(
+      : settings_(
-                      option::ForegroundColor{Color::unspecified}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::foreground_color>(
-                  details::get<details::ProgressBarOption::prefix_text>(
+                option::ForegroundColor{Color::unspecified}, std::forward<Args>(args)...),
-                      option::PrefixText{}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::prefix_text>(option::PrefixText{},
-                  details::get<details::ProgressBarOption::postfix_text>(
+                                                                  std::forward<Args>(args)...),
-                      option::PostfixText{}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::postfix_text>(option::PostfixText{},
-                  details::get<details::ProgressBarOption::show_percentage>(
+                                                                   std::forward<Args>(args)...),
-                      option::ShowPercentage{true}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::show_percentage>(option::ShowPercentage{true},
-                  details::get<details::ProgressBarOption::show_elapsed_time>(
-                      option::ShowElapsedTime{false}, std::forward<Args>(args)...),
-                  details::get<details::ProgressBarOption::show_remaining_time>(
-                      option::ShowRemainingTime{false}, std::forward<Args>(args)...),
-                  details::get<details::ProgressBarOption::spinner_show>(
-                      option::ShowSpinner{true}, std::forward<Args>(args)...),
-                  details::get<details::ProgressBarOption::saved_start_time>(
-                      option::SavedStartTime{false}, std::forward<Args>(args)...),
-                  details::get<details::ProgressBarOption::completed>(option::Completed{false},
                                                                       std::forward<Args>(args)...),
-                  details::get<details::ProgressBarOption::max_postfix_text_len>(
+            details::get<details::ProgressBarOption::show_elapsed_time>(
-                      option::MaxPostfixTextLen{0}, std::forward<Args>(args)...),
+                option::ShowElapsedTime{false}, std::forward<Args>(args)...),
-                  details::get<details::ProgressBarOption::spinner_states>(
+            details::get<details::ProgressBarOption::show_remaining_time>(
-                      option::SpinnerStates{std::vector<std::string>{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴",
+                option::ShowRemainingTime{false}, std::forward<Args>(args)...),
-                                                                     "⠦", "⠧", "⠇", "⠏"}},
+            details::get<details::ProgressBarOption::spinner_show>(option::ShowSpinner{true},
-                      std::forward<Args>(args)...),
+                                                                   std::forward<Args>(args)...),
-                  details::get<details::ProgressBarOption::font_styles>(
+            details::get<details::ProgressBarOption::saved_start_time>(
-                      option::FontStyles{std::vector<FontStyle>{}}, std::forward<Args>(args)...),
+                option::SavedStartTime{false}, std::forward<Args>(args)...),
-                  details::get<details::ProgressBarOption::max_progress>(
+            details::get<details::ProgressBarOption::completed>(option::Completed{false},
-                      option::MaxProgress{100}, std::forward<Args>(args)...),
+                                                                std::forward<Args>(args)...),
-                  details::get<details::ProgressBarOption::stream>(
+            details::get<details::ProgressBarOption::max_postfix_text_len>(
-                      option::Stream{std::cout}, std::forward<Args>(args)...)) {}
+                option::MaxPostfixTextLen{0}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::spinner_states>(
+                option::SpinnerStates{
+                    std::vector<std::string>{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}},
+                std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::font_styles>(
+                option::FontStyles{std::vector<FontStyle>{}}, std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::max_progress>(option::MaxProgress{100},
+                                                                   std::forward<Args>(args)...),
+            details::get<details::ProgressBarOption::stream>(option::Stream{std::cout},
+                                                             std::forward<Args>(args)...)) {}
 
   template <typename T, details::ProgressBarOption id>
   void set_option(details::Setting<T, id> &&setting) {
@@ -162,7 +164,7 @@ public:
   void print_progress() {
     std::lock_guard<std::mutex> lock{mutex_};
 
-    auto& os = get_value<details::ProgressBarOption::stream>();
+    auto &os = get_value<details::ProgressBarOption::stream>();
 
     const auto max_progress = get_value<details::ProgressBarOption::max_progress>();
     auto now = std::chrono::high_resolution_clock::now();
@@ -179,7 +181,7 @@ public:
       os << get_value<details::ProgressBarOption::spinner_states>()
               [index_ % get_value<details::ProgressBarOption::spinner_states>().size()];
     if (get_value<details::ProgressBarOption::show_percentage>()) {
-      os << " " << std::min(progress_, size_t(max_progress)) << "%";
+      os << " " << std::size_t(progress_ / double(max_progress) * 100) << "%";
     }
 
     if (get_value<details::ProgressBarOption::show_elapsed_time>()) {
@@ -193,7 +195,10 @@ public:
       else
         os << " [";
       auto eta = std::chrono::nanoseconds(
-          progress_ > 0 ? static_cast<long long>(elapsed.count() * max_progress / progress_) : 0);
+          progress_ > 0
+              ? static_cast<long long>(std::ceil(float(elapsed.count()) *
+                                                 max_progress / progress_))
+              : 0);
       auto remaining = eta > elapsed ? (eta - elapsed) : (elapsed - eta);
       details::write_duration(os, remaining);
       os << "]";
@@ -205,8 +210,7 @@ public:
     if (get_value<details::ProgressBarOption::max_postfix_text_len>() == 0)
       get_value<details::ProgressBarOption::max_postfix_text_len>() = 10;
     os << " " << get_value<details::ProgressBarOption::postfix_text>()
-              << std::string(get_value<details::ProgressBarOption::max_postfix_text_len>(), ' ')
+       << std::string(get_value<details::ProgressBarOption::max_postfix_text_len>(), ' ') << "\r";
-              << "\r";
     os.flush();
     index_ += 1;
     if (progress_ > max_progress) {

include/indicators/progress_type.hpp

@@ -0,0 +1,6 @@
+
+#pragma once
+
+namespace indicators {
+enum class ProgressType { incremental, decremental };
+}

include/indicators/setting.hpp

@@ -1,3 +1,4 @@
+
 /*
 Activity Indicators for Modern C++
 https://github.com/p-ranav/indicators
@@ -29,7 +30,9 @@ SOFTWARE.
 #include <cstddef>
 #include <indicators/color.hpp>
 #include <indicators/font_style.hpp>
+#include <indicators/progress_type.hpp>
 #include <string>
+#include <tuple>
 #include <type_traits>
 #include <utility>
 #include <vector>
@@ -90,7 +93,9 @@ enum class ProgressBarOption {
   spinner_states,
   font_styles,
   hide_bar_when_complete,
+  min_progress,
   max_progress,
+  progress_type,
   stream
 };
 
@@ -135,14 +140,14 @@ template <ProgressBarOption Id, typename Default> Default &&get_impl(Default &&d
 }
 
 template <ProgressBarOption Id, typename Default, typename T, typename... Args>
-auto get_impl(Default &&/*def*/, T &&first, Args &&... /*tail*/) ->
+auto get_impl(Default && /*def*/, T &&first, Args &&... /*tail*/) ->
     typename std::enable_if<(std::decay<T>::type::id == Id),
                             decltype(std::forward<T>(first))>::type {
   return std::forward<T>(first);
 }
 
 template <ProgressBarOption Id, typename Default, typename T, typename... Args>
-auto get_impl(Default &&def, T &&/*first*/, Args &&... tail) ->
+auto get_impl(Default &&def, T && /*first*/, Args &&... tail) ->
     typename std::enable_if<(std::decay<T>::type::id != Id),
                             decltype(get_impl<Id>(std::forward<Default>(def),
                                                   std::forward<Args>(tail)...))>::type {
@@ -206,7 +211,9 @@ using HideBarWhenComplete =
     details::BooleanSetting<details::ProgressBarOption::hide_bar_when_complete>;
 using FontStyles =
     details::Setting<std::vector<FontStyle>, details::ProgressBarOption::font_styles>;
+using MinProgress = details::IntegerSetting<details::ProgressBarOption::min_progress>;
 using MaxProgress = details::IntegerSetting<details::ProgressBarOption::max_progress>;
-using Stream = details::Setting<std::ostream&, details::ProgressBarOption::stream>;
+using ProgressType = details::Setting<ProgressType, details::ProgressBarOption::progress_type>;
+using Stream = details::Setting<std::ostream &, details::ProgressBarOption::stream>;
 } // namespace option
 } // namespace indicators

include/indicators/termcolor.hpp

@@ -1,3 +1,4 @@
+
 //!
 //! termcolor
 //! ~~~~~~~~~
@@ -16,433 +17,623 @@
 // defines the appropriate macro that is used to wrap some
 // platform specific things
 #if defined(_WIN32) || defined(_WIN64)
-#define TERMCOLOR_OS_WINDOWS
+#   define TERMCOLOR_OS_WINDOWS
 #elif defined(__APPLE__)
-#define TERMCOLOR_OS_MACOS
+#   define TERMCOLOR_OS_MACOS
 #elif defined(__unix__) || defined(__unix)
-#define TERMCOLOR_OS_LINUX
+#   define TERMCOLOR_OS_LINUX
 #else
-#error unsupported platform
+#   error unsupported platform
 #endif
 
+
 // This headers provides the `isatty()`/`fileno()` functions,
 // which are used for testing whether a standart stream refers
 // to the terminal. As for Windows, we also need WinApi funcs
 // for changing colors attributes of the terminal.
 #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-#include <unistd.h>
+#   include <unistd.h>
 #elif defined(TERMCOLOR_OS_WINDOWS)
+#if defined(_MSC_VER)
 #if !defined(NOMINMAX)
 #define NOMINMAX
 #endif
-#include <io.h>
+#   include <io.h>
-#include <windows.h>
+#   include <windows.h>
+#endif
 #endif
 
-#include <cstdio>
+
 #include <iostream>
+#include <cstdio>
 
-namespace termcolor {
-// Forward declaration of the `_internal` namespace.
-// All comments are below.
-namespace _internal {
-// An index to be used to access a private storage of I/O streams. See
-// colorize / nocolorize I/O manipulators for details.
-static int colorize_index = std::ios_base::xalloc();
 
-inline FILE *get_standard_stream(const std::ostream &stream);
+namespace termcolor
-inline bool is_colorized(std::ostream &stream);
+{
-inline bool is_atty(const std::ostream &stream);
+    // Forward declaration of the `_internal` namespace.
+    // All comments are below.
+    namespace _internal
+    {
+        // An index to be used to access a private storage of I/O streams. See
+        // colorize / nocolorize I/O manipulators for details.
+        static int colorize_index = std::ios_base::xalloc();
 
-#if defined(TERMCOLOR_OS_WINDOWS)
+        inline FILE* get_standard_stream(const std::ostream& stream);
-inline void win_change_attributes(std::ostream &stream, int foreground, int background = -1);
+        inline bool is_colorized(std::ostream& stream);
-#endif
+        inline bool is_atty(const std::ostream& stream);
-} // namespace _internal
 
-inline std::ostream &colorize(std::ostream &stream) {
+    #if defined(TERMCOLOR_OS_WINDOWS)
-  stream.iword(_internal::colorize_index) = 1L;
+        inline void win_change_attributes(std::ostream& stream, int foreground, int background=-1);
-  return stream;
+    #endif
-}
+    }
 
-inline std::ostream &nocolorize(std::ostream &stream) {
+    inline
-  stream.iword(_internal::colorize_index) = 0L;
+    std::ostream& colorize(std::ostream& stream)
-  return stream;
+    {
-}
+        stream.iword(_internal::colorize_index) = 1L;
+        return stream;
+    }
 
-inline std::ostream &reset(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& nocolorize(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[00m";
+        stream.iword(_internal::colorize_index) = 0L;
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        return stream;
-    _internal::win_change_attributes(stream, -1, -1);
+    }
-#endif
-  }
-  return stream;
-}
 
-inline std::ostream &bold(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& reset(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[1m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-#endif
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-  }
+            stream << "\033[00m";
-  return stream;
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-}
+            _internal::win_change_attributes(stream, -1, -1);
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &dark(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& bold(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[2m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-#endif
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-  }
+            stream << "\033[1m";
-  return stream;
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-}
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &italic(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& dark(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[3m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-#endif
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-  }
+            stream << "\033[2m";
-  return stream;
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-}
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &underline(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& italic(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[4m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-#endif
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-  }
+            stream << "\033[3m";
-  return stream;
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-}
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &blink(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& underline(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[5m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-#endif
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-  }
+            stream << "\033[4m";
-  return stream;
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-}
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &reverse(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& blink(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[7m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-#endif
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-  }
+            stream << "\033[5m";
-  return stream;
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-}
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &concealed(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& reverse(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[8m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-#endif
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-  }
+            stream << "\033[7m";
-  return stream;
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-}
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &crossed(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& concealed(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[9m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-#endif
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-  }
+            stream << "\033[8m";
-  return stream;
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-}
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &grey(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& crossed(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[30m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream,
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-                                     0 // grey (black)
+            stream << "\033[9m";
-    );
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-#endif
+        #endif
-  }
+        }
-  return stream;
+        return stream;
-}
+    }
 
-inline std::ostream &red(std::ostream &stream) {
+    template <uint8_t code> inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& color(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[31m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream, FOREGROUND_RED);
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-#endif
+            char command[12];
-  }
+            std::snprintf(command, sizeof(command), "\033[38;5;%dm", code);
-  return stream;
+            stream << command;
-}
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &green(std::ostream &stream) {
+    template <uint8_t code> inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& on_color(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[32m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream, FOREGROUND_GREEN);
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-#endif
+            char command[12];
-  }
+            std::snprintf(command, sizeof(command), "\033[48;5;%dm", code);
-  return stream;
+            stream << command;
-}
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &yellow(std::ostream &stream) {
+    template <uint8_t r, uint8_t g, uint8_t b> inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& color(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[33m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream, FOREGROUND_GREEN | FOREGROUND_RED);
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-#endif
+            char command[20];
-  }
+            std::snprintf(command, sizeof(command), "\033[38;2;%d;%d;%dm", r, g, b);
-  return stream;
+            stream << command;
-}
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &blue(std::ostream &stream) {
+    template <uint8_t r, uint8_t g, uint8_t b> inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& on_color(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[34m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream, FOREGROUND_BLUE);
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-#endif
+            char command[20];
-  }
+            std::snprintf(command, sizeof(command), "\033[48;2;%d;%d;%dm", r, g, b);
-  return stream;
+            stream << command;
-}
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &magenta(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& grey(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[35m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream, FOREGROUND_BLUE | FOREGROUND_RED);
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-#endif
+            stream << "\033[30m";
-  }
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-  return stream;
+            _internal::win_change_attributes(stream,
-}
+                0   // grey (black)
+            );
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &cyan(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& red(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[36m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream, FOREGROUND_BLUE | FOREGROUND_GREEN);
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-#endif
+            stream << "\033[31m";
-  }
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-  return stream;
+            _internal::win_change_attributes(stream,
-}
+                FOREGROUND_RED
+            );
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &white(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& green(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[37m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-#endif
+            stream << "\033[32m";
-  }
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-  return stream;
+            _internal::win_change_attributes(stream,
-}
+                FOREGROUND_GREEN
+            );
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &on_grey(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& yellow(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[40m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream, -1,
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-                                     0 // grey (black)
+            stream << "\033[33m";
-    );
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-#endif
+            _internal::win_change_attributes(stream,
-  }
+                FOREGROUND_GREEN | FOREGROUND_RED
-  return stream;
+            );
-}
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &on_red(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& blue(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[41m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream, -1, BACKGROUND_RED);
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-#endif
+            stream << "\033[34m";
-  }
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-  return stream;
+            _internal::win_change_attributes(stream,
-}
+                FOREGROUND_BLUE
+            );
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &on_green(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& magenta(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[42m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream, -1, BACKGROUND_GREEN);
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-#endif
+            stream << "\033[35m";
-  }
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-  return stream;
+            _internal::win_change_attributes(stream,
-}
+                FOREGROUND_BLUE | FOREGROUND_RED
+            );
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &on_yellow(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& cyan(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[43m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream, -1, BACKGROUND_GREEN | BACKGROUND_RED);
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-#endif
+            stream << "\033[36m";
-  }
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-  return stream;
+            _internal::win_change_attributes(stream,
-}
+                FOREGROUND_BLUE | FOREGROUND_GREEN
+            );
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &on_blue(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& white(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[44m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream, -1, BACKGROUND_BLUE);
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-#endif
+            stream << "\033[37m";
-  }
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-  return stream;
+            _internal::win_change_attributes(stream,
-}
+                FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED
+            );
+        #endif
+        }
+        return stream;
+    }
 
-inline std::ostream &on_magenta(std::ostream &stream) {
-  if (_internal::is_colorized(stream)) {
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-    stream << "\033[45m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, -1, BACKGROUND_BLUE | BACKGROUND_RED);
-#endif
-  }
-  return stream;
-}
 
-inline std::ostream &on_cyan(std::ostream &stream) {
-  if (_internal::is_colorized(stream)) {
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-    stream << "\033[46m";
-#elif defined(TERMCOLOR_OS_WINDOWS)
-    _internal::win_change_attributes(stream, -1, BACKGROUND_GREEN | BACKGROUND_BLUE);
-#endif
-  }
-  return stream;
-}
 
-inline std::ostream &on_white(std::ostream &stream) {
+    inline
-  if (_internal::is_colorized(stream)) {
+    std::ostream& on_grey(std::ostream& stream)
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    {
-    stream << "\033[47m";
+        if (_internal::is_colorized(stream))
-#elif defined(TERMCOLOR_OS_WINDOWS)
+        {
-    _internal::win_change_attributes(stream, -1,
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-                                     BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_RED);
+            stream << "\033[40m";
-#endif
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-  }
+            _internal::win_change_attributes(stream, -1,
+                0   // grey (black)
+            );
+        #endif
+        }
+        return stream;
+    }
 
-  return stream;
+    inline
-}
+    std::ostream& on_red(std::ostream& stream)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            stream << "\033[41m";
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+            _internal::win_change_attributes(stream, -1,
+                BACKGROUND_RED
+            );
+        #endif
+        }
+        return stream;
+    }
 
-//! Since C++ hasn't a way to hide something in the header from
+    inline
-//! the outer access, I have to introduce this namespace which
+    std::ostream& on_green(std::ostream& stream)
-//! is used for internal purpose and should't be access from
+    {
-//! the user code.
+        if (_internal::is_colorized(stream))
-namespace _internal {
+        {
-//! Since C++ hasn't a true way to extract stream handler
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-//! from the a given `std::ostream` object, I have to write
+            stream << "\033[42m";
-//! this kind of hack.
+        #elif defined(TERMCOLOR_OS_WINDOWS)
-inline FILE *get_standard_stream(const std::ostream &stream) {
+            _internal::win_change_attributes(stream, -1,
-  if (&stream == &std::cout)
+                BACKGROUND_GREEN
-    return stdout;
+            );
-  else if ((&stream == &std::cerr) || (&stream == &std::clog))
+        #endif
-    return stderr;
+        }
+        return stream;
+    }
 
-  return 0;
+    inline
-}
+    std::ostream& on_yellow(std::ostream& stream)
+    {
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            stream << "\033[43m";
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+            _internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN | BACKGROUND_RED
+            );
+        #endif
+        }
+        return stream;
+    }
 
-// Say whether a given stream should be colorized or not. It's always
+    inline
-// true for ATTY streams and may be true for streams marked with
+    std::ostream& on_blue(std::ostream& stream)
-// colorize flag.
+    {
-inline bool is_colorized(std::ostream &stream) {
+        if (_internal::is_colorized(stream))
-  return is_atty(stream) || static_cast<bool>(stream.iword(colorize_index));
+        {
-}
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            stream << "\033[44m";
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+            _internal::win_change_attributes(stream, -1,
+                BACKGROUND_BLUE
+            );
+        #endif
+        }
+        return stream;
+    }
 
-//! Test whether a given `std::ostream` object refers to
+    inline
-//! a terminal.
+    std::ostream& on_magenta(std::ostream& stream)
-inline bool is_atty(const std::ostream &stream) {
+    {
-  FILE *std_stream = get_standard_stream(stream);
+        if (_internal::is_colorized(stream))
+        {
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            stream << "\033[45m";
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+            _internal::win_change_attributes(stream, -1,
+                BACKGROUND_BLUE | BACKGROUND_RED
+            );
+        #endif
+        }
+        return stream;
+    }
 
-  // Unfortunately, fileno() ends with segmentation fault
+    inline
-  // if invalid file descriptor is passed. So we need to
+    std::ostream& on_cyan(std::ostream& stream)
-  // handle this case gracefully and assume it's not a tty
+    {
-  // if standard stream is not detected, and 0 is returned.
+        if (_internal::is_colorized(stream))
-  if (!std_stream)
+        {
-    return false;
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            stream << "\033[46m";
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+            _internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN | BACKGROUND_BLUE
+            );
+        #endif
+        }
+        return stream;
+    }
 
-#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+    inline
-  return ::isatty(fileno(std_stream));
+    std::ostream& on_white(std::ostream& stream)
-#elif defined(TERMCOLOR_OS_WINDOWS)
+    {
-  return ::_isatty(_fileno(std_stream));
+        if (_internal::is_colorized(stream))
-#endif
+        {
-}
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+            stream << "\033[47m";
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+            _internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_RED
+            );
+        #endif
+        }
 
-#if defined(TERMCOLOR_OS_WINDOWS)
+        return stream;
-//! Change Windows Terminal colors attribute. If some
+    }
-//! parameter is `-1` then attribute won't changed.
-inline void win_change_attributes(std::ostream &stream, int foreground, int background) {
-  // yeah, i know.. it's ugly, it's windows.
-  static WORD defaultAttributes = 0;
 
-  // Windows doesn't have ANSI escape sequences and so we use special
-  // API to change Terminal output color. That means we can't
-  // manipulate colors by means of "std::stringstream" and hence
-  // should do nothing in this case.
-  if (!_internal::is_atty(stream))
-    return;
 
-  // get terminal handle
-  HANDLE hTerminal = INVALID_HANDLE_VALUE;
-  if (&stream == &std::cout)
-    hTerminal = GetStdHandle(STD_OUTPUT_HANDLE);
-  else if (&stream == &std::cerr)
-    hTerminal = GetStdHandle(STD_ERROR_HANDLE);
 
-  // save default terminal attributes if it unsaved
+    //! Since C++ hasn't a way to hide something in the header from
-  if (!defaultAttributes) {
+    //! the outer access, I have to introduce this namespace which
-    CONSOLE_SCREEN_BUFFER_INFO info;
+    //! is used for internal purpose and should't be access from
-    if (!GetConsoleScreenBufferInfo(hTerminal, &info))
+    //! the user code.
-      return;
+    namespace _internal
-    defaultAttributes = info.wAttributes;
+    {
-  }
+        //! Since C++ hasn't a true way to extract stream handler
+        //! from the a given `std::ostream` object, I have to write
+        //! this kind of hack.
+        inline
+        FILE* get_standard_stream(const std::ostream& stream)
+        {
+            if (&stream == &std::cout)
+                return stdout;
+            else if ((&stream == &std::cerr) || (&stream == &std::clog))
+                return stderr;
 
-  // restore all default settings
+            return nullptr;
-  if (foreground == -1 && background == -1) {
+        }
-    SetConsoleTextAttribute(hTerminal, defaultAttributes);
-    return;
-  }
 
-  // get current settings
+        // Say whether a given stream should be colorized or not. It's always
-  CONSOLE_SCREEN_BUFFER_INFO info;
+        // true for ATTY streams and may be true for streams marked with
-  if (!GetConsoleScreenBufferInfo(hTerminal, &info))
+        // colorize flag.
-    return;
+        inline
+        bool is_colorized(std::ostream& stream)
+        {
+            return is_atty(stream) || static_cast<bool>(stream.iword(colorize_index));
+        }
 
-  if (foreground != -1) {
+        //! Test whether a given `std::ostream` object refers to
-    info.wAttributes &= ~(info.wAttributes & 0x0F);
+        //! a terminal.
-    info.wAttributes |= static_cast<WORD>(foreground);
+        inline
-  }
+        bool is_atty(const std::ostream& stream)
+        {
+            FILE* std_stream = get_standard_stream(stream);
 
-  if (background != -1) {
+            // Unfortunately, fileno() ends with segmentation fault
-    info.wAttributes &= ~(info.wAttributes & 0xF0);
+            // if invalid file descriptor is passed. So we need to
-    info.wAttributes |= static_cast<WORD>(background);
+            // handle this case gracefully and assume it's not a tty
-  }
+            // if standard stream is not detected, and 0 is returned.
+            if (!std_stream)
+                return false;
 
-  SetConsoleTextAttribute(hTerminal, info.wAttributes);
+        #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
-}
+            return ::isatty(fileno(std_stream));
-#endif // TERMCOLOR_OS_WINDOWS
+        #elif defined(TERMCOLOR_OS_WINDOWS)
+            return ::_isatty(_fileno(std_stream));
+        #endif
+        }
 
-} // namespace _internal
+    #if defined(TERMCOLOR_OS_WINDOWS)
+        //! Change Windows Terminal colors attribute. If some
+        //! parameter is `-1` then attribute won't changed.
+        inline void win_change_attributes(std::ostream& stream, int foreground, int background)
+        {
+            // yeah, i know.. it's ugly, it's windows.
+            static WORD defaultAttributes = 0;
+
+            // Windows doesn't have ANSI escape sequences and so we use special
+            // API to change Terminal output color. That means we can't
+            // manipulate colors by means of "std::stringstream" and hence
+            // should do nothing in this case.
+            if (!_internal::is_atty(stream))
+                return;
+
+            // get terminal handle
+            HANDLE hTerminal = INVALID_HANDLE_VALUE;
+            if (&stream == &std::cout)
+                hTerminal = GetStdHandle(STD_OUTPUT_HANDLE);
+            else if (&stream == &std::cerr)
+                hTerminal = GetStdHandle(STD_ERROR_HANDLE);
+
+            // save default terminal attributes if it unsaved
+            if (!defaultAttributes)
+            {
+                CONSOLE_SCREEN_BUFFER_INFO info;
+                if (!GetConsoleScreenBufferInfo(hTerminal, &info))
+                    return;
+                defaultAttributes = info.wAttributes;
+            }
+
+            // restore all default settings
+            if (foreground == -1 && background == -1)
+            {
+                SetConsoleTextAttribute(hTerminal, defaultAttributes);
+                return;
+            }
+
+            // get current settings
+            CONSOLE_SCREEN_BUFFER_INFO info;
+            if (!GetConsoleScreenBufferInfo(hTerminal, &info))
+                return;
+
+            if (foreground != -1)
+            {
+                info.wAttributes &= ~(info.wAttributes & 0x0F);
+                info.wAttributes |= static_cast<WORD>(foreground);
+            }
+
+            if (background != -1)
+            {
+                info.wAttributes &= ~(info.wAttributes & 0xF0);
+                info.wAttributes |= static_cast<WORD>(background);
+            }
+
+            SetConsoleTextAttribute(hTerminal, info.wAttributes);
+        }
+    #endif // TERMCOLOR_OS_WINDOWS
+
+    } // namespace _internal
 
 } // namespace termcolor
 
+
 #undef TERMCOLOR_OS_WINDOWS
 #undef TERMCOLOR_OS_MACOS
 #undef TERMCOLOR_OS_LINUX

include/indicators/terminal_size.hpp

@@ -1,37 +1,42 @@
+
 #pragma once
 #include <utility>
 
-namespace indicators {
 
-#if defined(_MSC_VER)
+#if defined(_WIN32)
 #include <windows.h>
 
-std::pair<size_t, size_t> terminal_size() {
+namespace indicators {
-    CONSOLE_SCREEN_BUFFER_INFO csbi;
+
-    int columns, rows;
+static inline std::pair<size_t, size_t> terminal_size() {
-    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
+  CONSOLE_SCREEN_BUFFER_INFO csbi;
-    columns = csbi.srWindow.Right - csbi.srWindow.Left + 1;
+  int cols, rows;
-    rows = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
+  GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
-    return {static_cast<size_t>(rows), static_cast<size_t>(cols)};
+  cols = csbi.srWindow.Right - csbi.srWindow.Left + 1;
+  rows = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
+  return {static_cast<size_t>(rows), static_cast<size_t>(cols)};
 }
 
-size_t terminal_width() {
+static inline size_t terminal_width() { return terminal_size().second; }
-    return terminal_size().second;
+
-}
+} // namespace indicators
 
 #else
+
 #include <sys/ioctl.h> //ioctl() and TIOCGWINSZ
-#include <unistd.h> // for STDOUT_FILENO
+#include <unistd.h>    // for STDOUT_FILENO
 
-std::pair<size_t, size_t> terminal_size() {
+namespace indicators {
-    struct winsize size;
+
-    ioctl(STDOUT_FILENO, TIOCGWINSZ, &size);
+static inline std::pair<size_t, size_t> terminal_size() {
-    return {static_cast<size_t>(size.ws_row), static_cast<size_t>(size.ws_col)};
+  struct winsize size;
+  ioctl(STDOUT_FILENO, TIOCGWINSZ, &size);
+  return {static_cast<size_t>(size.ws_row), static_cast<size_t>(size.ws_col)};
 }
 
-size_t terminal_width() {
+static inline size_t terminal_width() { return terminal_size().second; }
-    return terminal_size().second;
+
-}
+} // namespace indicators
+
 #endif
 
-}

samples/CMakeLists.txt

@@ -14,9 +14,15 @@ target_link_libraries(progress_bar_set_progress PRIVATE indicators::indicators)
 add_executable(progress_bar_tick progress_bar_tick.cpp)
 target_link_libraries(progress_bar_tick PRIVATE indicators::indicators)
 
+add_executable(progress_bar_countdown progress_bar_countdown.cpp)
+target_link_libraries(progress_bar_countdown PRIVATE indicators::indicators)
+
 add_executable(progress_bar_sstream progress_bar_sstream.cpp)
 target_link_libraries(progress_bar_sstream PRIVATE indicators::indicators)
 
+add_executable(progress_bar_unicode progress_bar_unicode.cpp)
+target_link_libraries(progress_bar_unicode PRIVATE indicators::indicators)
+
 add_executable(progress_spinner progress_spinner.cpp)
 target_link_libraries(progress_spinner PRIVATE indicators::indicators)
 
@@ -38,3 +44,6 @@ target_link_libraries(max_progress PRIVATE indicators::indicators)
 add_executable(indeterminate_progress_bar indeterminate_progress_bar.cpp)
 target_link_libraries(indeterminate_progress_bar PRIVATE indicators::indicators)
 
+add_executable(dynamic_postfix_text dynamic_postfix_text.cpp)
+target_link_libraries(dynamic_postfix_text PRIVATE indicators::indicators)
+

samples/block_progress_bar.cpp

@@ -9,10 +9,9 @@ int main() {
   indicators::show_console_cursor(false);
 
   indicators::BlockProgressBar bar{
-    indicators::option::BarWidth{80},
+      indicators::option::BarWidth{80},
-    indicators::option::FontStyles{
+      indicators::option::FontStyles{
-          std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
+          std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
-  };
 
   // Update bar state
   auto progress = 0.0f;

samples/block_progress_bar_iterable.cpp

@@ -11,20 +11,15 @@ int main() {
   // Random list of numbers
   std::vector<size_t> numbers;
   for (size_t i = 0; i < 1259438; ++i) {
-      numbers.push_back(i);
+    numbers.push_back(i);
   }
 
   using namespace indicators;
-  BlockProgressBar bar{
+  BlockProgressBar bar{option::BarWidth{80}, option::ForegroundColor{Color::white},
-    option::BarWidth{80},
+                       option::FontStyles{std::vector<FontStyle>{FontStyle::bold}},
-    option::ForegroundColor{Color::white},
+                       option::MaxProgress{numbers.size()}};
-    option::FontStyles{
-          std::vector<FontStyle>{FontStyle::bold}},
-    option::MaxProgress{numbers.size()}
-  };
 
-  std::cout << "Iterating over a list of numbers (size = "
+  std::cout << "Iterating over a list of numbers (size = " << numbers.size() << ")\n";
-            << numbers.size() << ")\n";
 
   std::vector<size_t> result;
   for (size_t i = 0; i < numbers.size(); ++i) {
@@ -33,9 +28,7 @@ int main() {
     result.push_back(numbers[i] * numbers[i]);
 
     // Show iteration as postfix text
-    bar.set_option(option::PostfixText{
+    bar.set_option(option::PostfixText{std::to_string(i) + "/" + std::to_string(numbers.size())});
-      std::to_string(i) + "/" + std::to_string(numbers.size())
-    });
 
     // update progress bar
     bar.tick();

samples/dynamic_postfix_text.cpp

@@ -0,0 +1,46 @@
+#include <indicators/progress_bar.hpp>
+#include <indicators/multi_progress.hpp>
+#include <indicators/terminal_size.hpp>
+using namespace indicators;
+
+int main() {
+
+    std::cout << "Terminal width: " << terminal_size().second << "\n";
+
+    // prepare progress bar
+    auto prepare_p = [](ProgressBar *p, const std::string &prefix){
+        p->set_option(option::PrefixText{prefix});
+        p->set_option(option::Start{""});
+        p->set_option(option::Fill{""});
+        p->set_option(option::Lead{""});
+        p->set_option(option::Remainder{""});
+        p->set_option(option::End{""});
+        p->set_option(option::BarWidth{0});
+    };
+
+    ProgressBar p1, p2;
+
+    prepare_p(&p1, "Progress #1");
+    prepare_p(&p2, "Progress #2");
+
+    MultiProgress<ProgressBar, 2> mp(p1, p2);
+
+    std::string some_text[] = {"foo", "bar", "independence", "beta", "alfa"};
+    std::string dynamic_text;
+
+    // first pb with static postfix text
+    p1.set_option(option::PostfixText{"Static text"});
+
+    // second pb with dynamic postfix text
+    for (auto &t: some_text) {
+        dynamic_text += t + " ";
+        p2.set_option(option::PostfixText{dynamic_text});
+        mp.set_progress<0>(size_t(0));
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+    }
+
+    // update postfix to little text for pb #2
+    p2.set_option(option::PostfixText{"abcd"});
+    mp.set_progress<0>(size_t(0));
+
+}

samples/dynamic_progress.cpp

@@ -4,41 +4,53 @@ using namespace indicators;
 
 int main() {
 
-  ProgressBar bar1{option::BarWidth{50}, option::ForegroundColor{Color::red},
+  ProgressBar bar1{option::BarWidth{50},
-                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::ForegroundColor{Color::red},
+                   option::ShowElapsedTime{true},
+                   option::ShowRemainingTime{true},
                    option::PrefixText{"5c90d4a2d1a8: Downloading "},
                    indicators::option::FontStyles{
-                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+                       std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
 
-  ProgressBar bar2{option::BarWidth{50}, option::ForegroundColor{Color::yellow},
+  ProgressBar bar2{option::BarWidth{50},
-                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::ForegroundColor{Color::yellow},
+                   option::ShowElapsedTime{true},
+                   option::ShowRemainingTime{true},
                    option::PrefixText{"22337bfd13a9: Downloading "},
                    indicators::option::FontStyles{
-                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+                       std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
 
-  ProgressBar bar3{option::BarWidth{50}, option::ForegroundColor{Color::green},
+  ProgressBar bar3{option::BarWidth{50},
-                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::ForegroundColor{Color::green},
+                   option::ShowElapsedTime{true},
+                   option::ShowRemainingTime{true},
                    option::PrefixText{"10f26c680a34: Downloading "},
                    indicators::option::FontStyles{
-                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+                       std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
 
-  ProgressBar bar4{option::BarWidth{50}, option::ForegroundColor{Color::white},
+  ProgressBar bar4{option::BarWidth{50},
-                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::ForegroundColor{Color::white},
+                   option::ShowElapsedTime{true},
+                   option::ShowRemainingTime{true},
                    option::PrefixText{"6364e0d7a283: Downloading "},
                    indicators::option::FontStyles{
-                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+                       std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
 
-  ProgressBar bar5{option::BarWidth{50}, option::ForegroundColor{Color::blue},
+  ProgressBar bar5{option::BarWidth{50},
-                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::ForegroundColor{Color::blue},
+                   option::ShowElapsedTime{true},
+                   option::ShowRemainingTime{true},
                    option::PrefixText{"ff1356ba118b: Downloading "},
                    indicators::option::FontStyles{
-                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+                       std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
 
-  ProgressBar bar6{option::BarWidth{50}, option::ForegroundColor{Color::cyan},
+  ProgressBar bar6{option::BarWidth{50},
-                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::ForegroundColor{Color::cyan},
+                   option::ShowElapsedTime{true},
+                   option::ShowRemainingTime{true},
                    option::PrefixText{"5a17453338b4: Downloading "},
                    indicators::option::FontStyles{
-                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+                       std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
 
   std::cout << termcolor::bold << termcolor::white << "Pulling image foo:bar/baz\n";
 

samples/indeterminate_progress_bar.cpp

@@ -1,7 +1,6 @@
 #include <chrono>
-#include <indicators/indeterminate_progress_bar.hpp>
 #include <indicators/cursor_control.hpp>
-#include <indicators/termcolor.hpp>
+#include <indicators/indeterminate_progress_bar.hpp>
 #include <thread>
 
 int main() {
@@ -14,16 +13,15 @@ int main() {
       indicators::option::PostfixText{"Checking for Updates"},
       indicators::option::ForegroundColor{indicators::Color::yellow},
       indicators::option::FontStyles{
-          std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
+          std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
-  };
 
   indicators::show_console_cursor(false);
 
   auto job = [&bar]() {
     std::this_thread::sleep_for(std::chrono::milliseconds(10000));
     bar.mark_as_completed();
-    std::cout << termcolor::bold << termcolor::green 
+    std::cout << termcolor::bold << termcolor::green << "System is up to date!\n"
-        << "System is up to date!\n" << termcolor::reset;
+              << termcolor::reset;
   };
   std::thread job_completion_thread(job);
 
@@ -34,7 +32,7 @@ int main() {
   }
 
   job_completion_thread.join();
-  
+
-  indicators::show_console_cursor(true);  
+  indicators::show_console_cursor(true);
   return 0;
 }

samples/max_progress.cpp

@@ -9,11 +9,10 @@ int main() {
   indicators::show_console_cursor(false);
 
   indicators::BlockProgressBar bar{
-    indicators::option::BarWidth{80},
+      indicators::option::BarWidth{80},
-    indicators::option::FontStyles{
+      indicators::option::FontStyles{
           std::vector<indicators::FontStyle>{indicators::FontStyle::bold}},
-    indicators::option::MaxProgress{400}
+      indicators::option::MaxProgress{400}};
-  };
 
   // Update bar state
   while (true) {

samples/multi_block_progress_bar.cpp

@@ -3,23 +3,29 @@
 
 int main() {
   using namespace indicators;
-  BlockProgressBar bar1{option::BarWidth{50}, option::ForegroundColor{Color::yellow},
+  BlockProgressBar bar1{option::BarWidth{50},
-                        option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                        option::ForegroundColor{Color::yellow},
+                        option::ShowElapsedTime{true},
+                        option::ShowRemainingTime{true},
                         option::PrefixText{"Progress Bar #1 "},
                         indicators::option::FontStyles{
-                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+                            std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
 
-  BlockProgressBar bar2{option::BarWidth{50}, option::ForegroundColor{Color::cyan},
+  BlockProgressBar bar2{option::BarWidth{50},
-                        option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                        option::ForegroundColor{Color::cyan},
+                        option::ShowElapsedTime{true},
+                        option::ShowRemainingTime{true},
                         option::PrefixText{"Progress Bar #2 "},
                         indicators::option::FontStyles{
-                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+                            std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
 
-  BlockProgressBar bar3{option::BarWidth{50}, option::ForegroundColor{Color::red},
+  BlockProgressBar bar3{option::BarWidth{50},
-                        option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                        option::ForegroundColor{Color::red},
+                        option::ShowElapsedTime{true},
+                        option::ShowRemainingTime{true},
                         option::PrefixText{"Progress Bar #3 "},
                         indicators::option::FontStyles{
-                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+                            std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
 
   indicators::MultiProgress<indicators::BlockProgressBar, 3> bars(bar1, bar2, bar3);
 

samples/multi_progress_bar.cpp

@@ -13,8 +13,8 @@ int main() {
                                indicators::option::ShowElapsedTime{true},
                                indicators::option::ShowRemainingTime{true},
                                indicators::option::PrefixText{"Progress Bar #1 "},
-                               indicators::option::FontStyles{
+                               indicators::option::FontStyles{std::vector<indicators::FontStyle>{
-                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+                                   indicators::FontStyle::bold}}};
 
   indicators::ProgressBar bar2{indicators::option::BarWidth{50},
                                indicators::option::Start{"["},
@@ -26,8 +26,8 @@ int main() {
                                indicators::option::ShowElapsedTime{true},
                                indicators::option::ShowRemainingTime{true},
                                indicators::option::PrefixText{"Progress Bar #2 "},
-                               indicators::option::FontStyles{
+                               indicators::option::FontStyles{std::vector<indicators::FontStyle>{
-                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+                                   indicators::FontStyle::bold}}};
 
   indicators::ProgressBar bar3{indicators::option::BarWidth{50},
                                indicators::option::Start{"["},
@@ -39,8 +39,8 @@ int main() {
                                indicators::option::ShowElapsedTime{true},
                                indicators::option::ShowRemainingTime{true},
                                indicators::option::PrefixText{"Progress Bar #3 "},
-                               indicators::option::FontStyles{
+                               indicators::option::FontStyles{std::vector<indicators::FontStyle>{
-                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+                                   indicators::FontStyle::bold}}};
 
   indicators::MultiProgress<indicators::ProgressBar, 3> bars(bar1, bar2, bar3);
 

samples/multi_threaded_bar.cpp

@@ -3,17 +3,15 @@
 
 int main() {
 
-  indicators::ProgressBar bar{
+  indicators::ProgressBar bar{indicators::option::BarWidth{50},
-      indicators::option::BarWidth{50},
+                              indicators::option::Start{"["},
-      indicators::option::Start{"["},
+                              indicators::option::Fill{"■"},
-      indicators::option::Fill{"■"},
+                              indicators::option::Lead{"■"},
-      indicators::option::Lead{"■"},
+                              indicators::option::Remainder{"-"},
-      indicators::option::Remainder{"-"},
+                              indicators::option::End{" ]"},
-      indicators::option::End{" ]"},
+                              indicators::option::ForegroundColor{indicators::Color::yellow},
-      indicators::option::ForegroundColor{indicators::Color::yellow},
+                              indicators::option::FontStyles{
-      indicators::option::FontStyles{
+                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
-          std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
-  };
 
   // As configured, the bar will look like this:
   //

samples/progress_bar_countdown.cpp

@@ -0,0 +1,31 @@
+#include <chrono>
+#include <indicators/progress_bar.hpp>
+#include <thread>
+using namespace indicators;
+
+int main() {
+
+  ProgressBar bar{option::BarWidth{50},
+                  option::ProgressType{ProgressType::decremental},
+                  option::Start{"["},
+                  option::Fill{"■"},
+                  option::Lead{"■"},
+                  option::Remainder{"-"},
+                  option::End{"]"},
+                  option::PostfixText{"Reverting System Restore"},
+                  option::ForegroundColor{Color::yellow},
+                  option::FontStyles{std::vector<FontStyle>{FontStyle::bold}}};
+
+  // Update bar state
+  while (true) {
+    bar.tick();
+    if (bar.is_completed())
+      break;
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+
+  std::cout << termcolor::bold << termcolor::white << "Task Failed Successfully\n"
+            << termcolor::reset;
+
+  return 0;
+}

samples/progress_bar_set_progress.cpp

@@ -8,18 +8,16 @@ int main() {
   // Hide cursor
   indicators::show_console_cursor(false);
 
-  indicators::ProgressBar bar{
+  indicators::ProgressBar bar{indicators::option::BarWidth{50},
-      indicators::option::BarWidth{50},
+                              indicators::option::Start{"["},
-      indicators::option::Start{"["},
+                              indicators::option::Fill{"■"},
-      indicators::option::Fill{"■"},
+                              indicators::option::Lead{"■"},
-      indicators::option::Lead{"■"},
+                              indicators::option::Remainder{"-"},
-      indicators::option::Remainder{"-"},
+                              indicators::option::End{" ]"},
-      indicators::option::End{" ]"},
+                              indicators::option::PostfixText{"Loading dependency 1/4"},
-      indicators::option::PostfixText{"Loading dependency 1/4"},
+                              indicators::option::ForegroundColor{indicators::Color::cyan},
-      indicators::option::ForegroundColor{indicators::Color::cyan},
+                              indicators::option::FontStyles{
-      indicators::option::FontStyles{
+                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
-          std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
-  };
 
   // Update bar state
   bar.set_progress(10); // 10% done

samples/progress_bar_sstream.cpp

@@ -1,7 +1,7 @@
 #include <chrono>
 #include <indicators/progress_bar.hpp>
-#include <thread>
 #include <sstream>
+#include <thread>
 
 int main() {
   using namespace indicators;
@@ -17,10 +17,8 @@ int main() {
       option::End{"]"},
       option::PostfixText{"Getting started"},
       option::ForegroundColor{indicators::Color::green},
-      option::FontStyles{
+      option::FontStyles{std::vector<indicators::FontStyle>{indicators::FontStyle::bold}},
-          std::vector<indicators::FontStyle>{indicators::FontStyle::bold}},
+      option::Stream{os}};
-      option::Stream{os}
-  };
 
   // Update bar state
   while (true) {

samples/progress_bar_tick.cpp

@@ -3,18 +3,16 @@
 #include <thread>
 
 int main() {
-  indicators::ProgressBar bar{
+  indicators::ProgressBar bar{indicators::option::BarWidth{50},
-      indicators::option::BarWidth{50},
+                              indicators::option::Start{"["},
-      indicators::option::Start{"["},
+                              indicators::option::Fill{"="},
-      indicators::option::Fill{"="},
+                              indicators::option::Lead{">"},
-      indicators::option::Lead{">"},
+                              indicators::option::Remainder{" "},
-      indicators::option::Remainder{" "},
+                              indicators::option::End{" ]"},
-      indicators::option::End{" ]"},
+                              indicators::option::PostfixText{"Getting started"},
-      indicators::option::PostfixText{"Getting started"},
+                              indicators::option::ForegroundColor{indicators::Color::green},
-      indicators::option::ForegroundColor{indicators::Color::green},
+                              indicators::option::FontStyles{
-      indicators::option::FontStyles{
+                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
-          std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
-  };
 
   // Update bar state
   while (true) {

samples/progress_bar_unicode.cpp

@@ -0,0 +1,171 @@
+#include <chrono>
+#include <indicators/cursor_control.hpp>
+#include <indicators/indeterminate_progress_bar.hpp>
+#include <indicators/progress_bar.hpp>
+#include <thread>
+
+int main() {
+
+  indicators::show_console_cursor(false);
+
+  {
+    // Plain old ASCII
+    indicators::ProgressBar bar{indicators::option::BarWidth{50},
+                                indicators::option::Start{"["},
+                                indicators::option::Fill{"="},
+                                indicators::option::Lead{">"},
+                                indicators::option::Remainder{" "},
+                                indicators::option::End{" ]"},
+                                indicators::option::PostfixText{"Plain-old ASCII"},
+                                indicators::option::ForegroundColor{indicators::Color::green},
+                                indicators::option::FontStyles{std::vector<indicators::FontStyle>{
+                                    indicators::FontStyle::bold}}};
+
+    // Update bar state
+    while (true) {
+      bar.tick();
+      if (bar.is_completed())
+        break;
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+  }
+
+  {
+    // Unicode
+    indicators::ProgressBar bar{indicators::option::BarWidth{50},
+                                indicators::option::Start{"["},
+                                indicators::option::Fill{"驚くばかり"},
+                                indicators::option::Lead{">"},
+                                indicators::option::Remainder{" "},
+                                indicators::option::End{" ]"},
+                                indicators::option::PostfixText{"Japanese"},
+                                indicators::option::ForegroundColor{indicators::Color::yellow},
+                                indicators::option::FontStyles{std::vector<indicators::FontStyle>{
+                                    indicators::FontStyle::bold}}};
+
+    // Update bar state
+    while (true) {
+      bar.tick();
+      if (bar.is_completed())
+        break;
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+  }
+
+  {
+    // Russian
+    indicators::ProgressBar bar{indicators::option::BarWidth{50},
+                                indicators::option::Start{"["},
+                                indicators::option::Fill{"Потрясающие"},
+                                indicators::option::Remainder{" "},
+                                indicators::option::End{" ]"},
+                                indicators::option::PostfixText{"Russian"},
+                                indicators::option::ForegroundColor{indicators::Color::red},
+                                indicators::option::FontStyles{std::vector<indicators::FontStyle>{
+                                    indicators::FontStyle::bold}}};
+
+    // Update bar state
+    while (true) {
+      bar.tick();
+      if (bar.is_completed())
+        break;
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+  }
+
+  {
+    // Greek
+    indicators::ProgressBar bar{indicators::option::BarWidth{50},
+                                indicators::option::Start{"["},
+                                indicators::option::Fill{"Φοβερός"},
+                                indicators::option::Remainder{" "},
+                                indicators::option::End{" ]"},
+                                indicators::option::PostfixText{"Greek"},
+                                indicators::option::ForegroundColor{indicators::Color::cyan},
+                                indicators::option::FontStyles{std::vector<indicators::FontStyle>{
+                                    indicators::FontStyle::bold}}};
+
+    // Update bar state
+    while (true) {
+      bar.tick();
+      if (bar.is_completed())
+        break;
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+  }
+
+  {
+    // Chinese
+    indicators::ProgressBar bar{indicators::option::BarWidth{50},
+                                indicators::option::Start{"["},
+                                indicators::option::Fill{"太棒了"},
+                                indicators::option::Remainder{" "},
+                                indicators::option::End{" ]"},
+                                indicators::option::PostfixText{"Chinese"},
+                                indicators::option::ForegroundColor{indicators::Color::green},
+                                indicators::option::FontStyles{std::vector<indicators::FontStyle>{
+                                    indicators::FontStyle::bold}}};
+
+    // Update bar state
+    while (true) {
+      bar.tick();
+      if (bar.is_completed())
+        break;
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+  }
+
+  {
+    // Emojis
+    indicators::ProgressBar bar{indicators::option::BarWidth{50},
+                                indicators::option::Start{"["},
+                                indicators::option::Fill{"🔥"},
+                                indicators::option::Lead{"🔥"},
+                                indicators::option::Remainder{" "},
+                                indicators::option::End{" ]"},
+                                indicators::option::PostfixText{"Emojis"},
+                                indicators::option::ForegroundColor{indicators::Color::white},
+                                indicators::option::FontStyles{std::vector<indicators::FontStyle>{
+                                    indicators::FontStyle::bold}}};
+
+    // Update bar state
+    while (true) {
+      bar.tick();
+      if (bar.is_completed())
+        break;
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+  }
+
+  {
+    // Indeterminate progress bar
+    indicators::IndeterminateProgressBar bar{
+        indicators::option::BarWidth{50},
+        indicators::option::Start{"["},
+        indicators::option::Fill{"✯"},
+        indicators::option::Lead{"載入中"},
+        indicators::option::End{" ]"},
+        indicators::option::PostfixText{"Loading Progress Bar"},
+        indicators::option::ForegroundColor{indicators::Color::yellow},
+        indicators::option::FontStyles{
+            std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
+
+    auto job = [&bar]() {
+      std::this_thread::sleep_for(std::chrono::milliseconds(10000));
+      bar.mark_as_completed();
+    };
+    std::thread job_completion_thread(job);
+
+    // Update bar state
+    while (!bar.is_completed()) {
+      bar.tick();
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+
+    job_completion_thread.join();
+  }
+
+  indicators::show_console_cursor(true);
+
+  return 0;
+}

samples/progress_spinner.cpp

@@ -12,8 +12,7 @@ int main() {
       indicators::option::SpinnerStates{
           std::vector<std::string>{"⠈", "⠐", "⠠", "⢀", "⡀", "⠄", "⠂", "⠁"}},
       indicators::option::FontStyles{
-          std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
+          std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
-  };
 
   // Update spinner state
   auto job = [&spinner]() {

samples/time_meter.cpp

@@ -7,20 +7,18 @@ int main() {
   // Hide cursor
   indicators::show_console_cursor(false);
 
-  indicators::ProgressBar bar{
+  indicators::ProgressBar bar{indicators::option::BarWidth{50},
-      indicators::option::BarWidth{50},
+                              indicators::option::Start{" ["},
-      indicators::option::Start{" ["},
+                              indicators::option::Fill{"█"},
-      indicators::option::Fill{"█"},
+                              indicators::option::Lead{"█"},
-      indicators::option::Lead{"█"},
+                              indicators::option::Remainder{"-"},
-      indicators::option::Remainder{"-"},
+                              indicators::option::End{"]"},
-      indicators::option::End{"]"},
+                              indicators::option::PrefixText{"Training Gaze Network 👀"},
-      indicators::option::PrefixText{"Training Gaze Network 👀"},
+                              indicators::option::ForegroundColor{indicators::Color::yellow},
-      indicators::option::ForegroundColor{indicators::Color::yellow},
+                              indicators::option::ShowElapsedTime{true},
-      indicators::option::ShowElapsedTime{true},
+                              indicators::option::ShowRemainingTime{true},
-      indicators::option::ShowRemainingTime{true},
+                              indicators::option::FontStyles{
-      indicators::option::FontStyles{
+                                  std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}};
-          std::vector<indicators::FontStyle>{indicators::FontStyle::bold}}
-  };
 
   // Update bar state
   while (true) {

single_include.json

@@ -4,6 +4,7 @@
     "sources": [
         "include/indicators/color.hpp",
         "include/indicators/font_style.hpp",
+        "include/indicators/progress_type.hpp",
         "include/indicators/termcolor.hpp",
         "include/indicators/terminal_size.hpp",
         "include/indicators/setting.hpp",