border
Demo
#include <stdlib.h>
#include <memory>
auto document =
hbox({
vbox({
text("Line 1"),
text("Line 2"),
text("Line 3"),
}) | border,
vbox({
text("Line 4"),
text("Line 5"),
text("Line 6"),
}) | border,
vbox({
text("Line 7"),
text("Line 8"),
text("Line 9"),
}) | border,
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return EXIT_SUCCESS;
}
border_colored
Demo
#include <iostream>
#include <memory>
auto make_boxed = [] {
return vbox({
});
};
auto document = hbox({
make_boxed(),
separator() | color(Color::Red),
make_boxed(),
separator() | color(Color::Red),
make_boxed(),
}) |
auto screen =
Screen::Create(Dimension::Fit(document), Dimension::Fit(document));
Render(screen, document);
screen.Print();
std::cout << std::endl;
}
Decorator borderStyled(BorderStyle style)
borderと同じですが、異なるスタイルを使用します。
border_style
Demo
#include <iostream>
#include <memory>
auto document = vbox({
});
auto screen =
Screen::Create(Dimension::Fit(document), Dimension::Fit(document));
Render(screen, document);
screen.Print();
std::cout << std::endl;
}
Element borderDouble(Element child)
要素の周囲に二重線のボーダーを描画します。
Element borderDashed(Element child)
要素の周囲に破線のボーダーを描画します。
Element borderRounded(Element child)
要素の周囲に角の丸いボーダーを描画します。
Element borderHeavy(Element child)
要素の周囲に太いボーダーを描画します。
Element borderLight(Element child)
要素の周囲に細いボーダーを描画します。
canvas
Demo
#include <stdio.h>
#include <cmath>
#include <vector>
c.DrawText(0, 0,
"This is a canvas", [](
Pixel& p) {
});
c.DrawPointLine(10, 10, 80, 10, Color::Red);
c.DrawPointLine(80, 10, 80, 40, Color::Blue);
c.DrawPointLine(80, 40, 10, 10, Color::Green);
c.DrawPointCircle(30, 50, 20);
c.DrawPointCircleFilled(40, 40, 10);
std::vector<int> ys(100);
for (int x = 0; x < 100; x++) {
ys[x] = int(80 + 20 * cos(x * 0.2));
}
for (int x = 0; x < 99; x++) {
c.DrawPointLine(x, ys[x], x + 1, ys[x + 1], Color::Red);
}
auto document = canvas(&c) |
border;
auto screen = Screen::Create(Dimension::Fit(document));
Render(screen, document);
screen.Print();
getchar();
return 0;
}
Element border(Element child)
要素の周囲にボーダーを描画します。
Canvasは、描画操作に関連付けられた描画可能なバッファです。
Unicode文字とそれに関連付けられたスタイル。
color_gallery
Demo
#include <memory>
#include <utility>
#include <vector>
auto basic_color_display =
vbox(
text("16色パレット:"),
separator(),
hbox(
vbox(
color(Color::Default, text("デフォルト")),
color(Color::Black, text("黒")),
color(Color::GrayDark, text("濃い灰色")),
color(Color::GrayLight, text("薄い灰色")),
color(Color::White, text("白")),
color(Color::Blue, text("青")),
color(Color::BlueLight, text("水色")),
color(Color::Cyan, text("シアン")),
color(Color::CyanLight, text("明るいシアン")),
color(Color::Green, text("緑")),
color(Color::GreenLight, text("明るい緑")),
color(Color::Magenta, text("マゼンタ")),
color(Color::MagentaLight, text("明るいマゼンタ")),
color(Color::Red, text("赤")),
color(Color::RedLight, text("明るい赤")),
color(Color::Yellow, text("黄")),
color(Color::YellowLight, text("明るい黄"))
),
vbox(
bgcolor(Color::Default, text("デフォルト")),
bgcolor(Color::Black, text("黒")),
bgcolor(Color::GrayDark, text("濃い灰色")),
bgcolor(Color::GrayLight, text("薄い灰色")),
bgcolor(Color::White, text("白")),
bgcolor(Color::Blue, text("青")),
bgcolor(Color::BlueLight, text("水色")),
bgcolor(Color::Cyan, text("シアン")),
bgcolor(Color::CyanLight, text("明るいシアン")),
bgcolor(Color::Green, text("緑")),
bgcolor(Color::GreenLight, text("明るい緑")),
bgcolor(Color::Magenta, text("マゼンタ")),
bgcolor(Color::MagentaLight, text("明るいマゼンタ")),
bgcolor(Color::Red, text("赤")),
bgcolor(Color::RedLight, text("明るい赤")),
bgcolor(Color::Yellow, text("黄")),
bgcolor(Color::YellowLight, text("明るい黄"))
)
)
);
auto palette_256_color_display = text("256色パレット:");
{
for (auto& column : info_columns) {
for (auto& it : column) {
column_elements.push_back(
}
columns.push_back(hbox(std::move(column_elements)));
}
palette_256_color_display = vbox({
palette_256_color_display,
separator(),
vbox(columns),
});
}
auto true_color_display = text("トゥルーカラー: 24ビット:");
{
const int max_value = 255;
const int value_increment = 8;
const int hue_increment = 6;
int saturation = max_value;
for (int value = 0; value < max_value; value += 2 * value_increment) {
for (int hue = 0; hue < max_value; hue += hue_increment) {
line.push_back(
text("▀")
| color(Color::HSV(hue, saturation, value))
| bgcolor(Color::HSV(hue, saturation, value + value_increment)));
}
array.push_back(hbox(std::move(line)));
}
true_color_display = vbox({
true_color_display,
separator(),
vbox(std::move(array)),
});
}
auto terminal_info =
vbox({
Terminal::ColorSupport() >= Terminal::Color::Palette16
? text(" 16色パレット対応: はい")
: text(" 16色パレット対応: いいえ"),
? text("256色パレット対応: はい")
: text("256色パレット対応: いいえ"),
? text(" トゥルーカラー対応: はい")
: text(" トゥルーカラー対応: いいえ"),
}) |
border;
auto document = vbox({hbox({
basic_color_display,
text(" "),
palette_256_color_display,
text(" "),
true_color_display,
}),
terminal_info});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
std::vector< std::vector< ftxui::ColorInfo > > ColorInfoSorted2D()
Colorは、ターミナルユーザーインターフェースにおける色を表すクラスです。
FTXUI ftxui::Terminal::名前空間
std::vector< Element > Elements
color_info_palette256
Demo
#include <utility>
#include <vector>
for (auto& column : info_columns) {
for (auto& it : column) {
column_elements.push_back(hbox({
text(it.name),
}));
}
columns_elements.push_back(vbox(std::move(column_elements)));
}
auto document = hbox(std::move(columns_elements));
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
color_truecolor_HSV
Demo
#include <memory>
#include <utility>
int saturation = 255;
for (int value = 0; value < 255; value += 20) {
for (int hue = 0; hue < 255; hue += 2) {
line.push_back(text("▀")
| color(Color::HSV(hue, saturation, value))
| bgcolor(Color::HSV(hue, saturation, value + 10)));
}
array.push_back(hbox(std::move(line)));
}
auto document = vbox(std::move(array));
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
color_truecolor_RGB
Demo
#include <memory>
#include <utility>
for (int value = 0; value < 255; value += 3) {
int v = value * value / 255;
red_line.push_back(text(" ") | bgcolor(Color::RGB(v, 0, 0)));
green_line.push_back(text(" ") | bgcolor(Color::RGB(0, v, 0)));
blue_line.push_back(text(" ") | bgcolor(Color::RGB(0, 0, v)));
cyan_line.push_back(text(" ") | bgcolor(Color::RGB(0, v, v)));
magenta_line.push_back(text(" ") | bgcolor(Color::RGB(v, 0, v)));
yellow_line.push_back(text(" ") | bgcolor(Color::RGB(v, v, 0)));
}
auto document = vbox({
vbox({
hbox({text("赤色線 :"), hbox(std::move(red_line))}),
hbox({text("緑色線 :"), hbox(std::move(green_line))}),
hbox({text("青色線 :"), hbox(std::move(blue_line))}),
})),
vbox({
hbox({text("シアン線 :"), hbox(std::move(cyan_line))}),
hbox({text("マゼンタ線:"), hbox(std::move(magenta_line))}),
hbox({text("黄色線 :"), hbox(std::move(yellow_line))}),
})),
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
Element window(Element title, Element content, BorderStyle border)
要素の周囲にタイトルとボーダーを持つウィンドウを描画します。
dbox
Demo
#include <memory>
auto document = dbox({
vbox({
text("line_1"),
text("line_2"),
text("line_3"),
text("line_4"),
text("line_5"),
}) | border,
text("overlay") | border | center,
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
gauge
Demo
#include <chrono>
#include <iostream>
#include <string>
#include <thread>
using namespace std::chrono_literals;
std::string reset_position;
for (float percentage = 0.0f; percentage <= 1.0f; percentage += 0.002f) {
std::string data_downloaded =
std::to_string(int(percentage * 5000)) + "/5000";
auto document = hbox({
text("downloading:"),
gauge(percentage) | flex,
text(" " + data_downloaded),
});
Render(screen, document);
std::cout << reset_position;
screen.Print();
reset_position = screen.ResetPosition();
std::this_thread::sleep_for(0.01s);
}
std::cout << std::endl;
}
gauge_direction
Demo
#include <chrono>
#include <iostream>
#include <string>
#include <thread>
using namespace std::chrono_literals;
std::string reset_position;
for (float percentage = 0.0f; percentage <= 1.0f; percentage += 0.002f) {
std::string data_downloaded =
std::to_string(int(percentage * 5000)) + "/5000";
auto gauge_up =
hbox({
vtext("gauge vertical"),
separator(),
gaugeUp(percentage),
}) |
border;
auto gauge_down =
hbox({
vtext("gauge vertical"),
separator(),
gaugeDown(percentage),
}) |
border;
auto gauge_right =
vbox({
text("gauge horizontal"),
separator(),
gaugeRight(percentage),
}) |
border;
auto gauge_left =
vbox({
text("gauge horizontal"),
separator(),
gaugeLeft(percentage),
}) |
border;
auto document = hbox({
gauge_up,
filler(),
vbox({
gauge_right,
filler(),
text(data_downloaded) | border | center,
filler(),
gauge_left,
}),
filler(),
gauge_down,
});
Render(screen, document);
std::cout << reset_position;
screen.Print();
reset_position = screen.ResetPosition();
std::this_thread::sleep_for(0.01s);
}
std::cout << std::endl;
}
graph
Demo
#include <chrono>
#include <cmath>
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <thread>
#include <utility>
#include <vector>
class Graph {
public:
std::vector<int> operator()(int width, int height) const {
std::vector<int> output(width);
for (int i = 0; i < width; ++i) {
float v = 0;
v += 0.1f * sin((i + shift) * 0.1f);
v += 0.2f * sin((i + shift + 10) * 0.15f);
v += 0.1f * sin((i + shift) * 0.03f);
v *= height;
v += 0.5f * height;
output[i] = static_cast<int>(v);
}
return output;
}
int shift = 0;
};
std::vector<int>
triangle(
int width,
int height) {
std::vector<int> output(width);
for (int i = 0; i < width; ++i) {
output[i] = i % (height - 4) + 2;
}
return output;
}
using namespace std::chrono_literals;
Graph my_graph;
std::string reset_position;
for (int i = 0;; ++i) {
std::ignore = i;
auto document = hbox({
vbox({
graph(std::ref(my_graph)),
separator(),
}) | flex,
separator(),
vbox({
graph(std::ref(my_graph)) | color(Color::BlueLight),
separator(),
graph(std::ref(my_graph)) | color(Color::RedLight),
separator(),
graph(std::ref(my_graph)) | color(Color::YellowLight),
}) | flex,
});
const int min_width = 40;
document |=
size(HEIGHT, GREATER_THAN, min_width);
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
std::cout << reset_position;
screen.Print();
reset_position = screen.ResetPosition();
const auto sleep_time = 0.03s;
std::this_thread::sleep_for(sleep_time);
my_graph.shift++;
}
return 0;
}
std::vector< int > triangle(int width, int height)
gridbox
Demo
#include <stdio.h>
#include <memory>
auto cell = [](
const char* t) {
return text(t) |
border; };
auto document =
gridbox({
{
cell("north-west"),
cell("north"),
cell("north-east"),
},
{
cell("center-west"),
gridbox({
{
cell("center-north-west"),
cell("center-north-east"),
},
{
cell("center-south-west"),
cell("center-south-east"),
},
}),
cell("center-east"),
},
{
cell("south-west"),
cell("south"),
cell("south-east"),
},
});
auto screen = Screen::Create(Dimension::Fit(document));
Render(screen, document);
screen.Print();
getchar();
return 0;
}
hflow
Demo
#include <stdio.h>
#include <string>
auto make_box = [](
int dimx,
int dimy) {
std::string title = std::to_string(dimx) + "x" + std::to_string(dimy);
return window(text(title) | hcenter | bold,
text("content") | hcenter | dim) |
size(WIDTH, EQUAL, dimx) |
size(HEIGHT, EQUAL, dimy);
};
auto style =
size(WIDTH, GREATER_THAN, 20) | border |
size(HEIGHT, GREATER_THAN, 30) |
size(WIDTH, LESS_THAN, 50);
auto document = hflow({
}) |
style;
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
getchar();
return 0;
}
Element make_box(int x, int y)
html_like
Demo
#include <chrono>
#include <iostream>
#include <string>
#include <thread>
using namespace std::chrono_literals;
auto img1 = []() {
return text(
"img") |
border; };
auto img2 = []() { return vbox({text("big"), text("image")}) | border; };
std::string reset_position;
for (int i = 0;; ++i) {
auto document =
hflow(
paragraph("こんにちは世界！ここに画像があります:"), img1(),
paragraph(" ここにテキストがあります "), text("underlined ") | underlined,
paragraph(" ここにテキストがあります "), text("bold ") | bold,
paragraph("こんにちは世界！ここに画像があります:"), img2(),
paragraph(
"Lorem Ipsumは、印刷前の組版とレイアウトに使用される単なるダミーテキストです。Lorem Ipsumは、1500年代に匿名の印刷業者が活字見本帳を作成するためにテキストの断片を組み合わせて以来、印刷業界の標準ダミーテキストです。それは5世紀以上にわたって生き残っただけでなく、その内容が変更されることなく、電子組版にも適応しました。1960年代には、Lorem Ipsumのパッセージを含むLetrasetシートのリリースによって普及し、さらに最近では、Aldus PageMakerのようなデスクトップパブリッシングアプリケーションにそのバージョンが組み込まれています。"),
paragraph(" ここにテキストがあります "), text("dim ") | dim,
paragraph("こんにちは世界！ここに画像があります:"), img1(),
paragraph(" ここにテキストがあります "), text("red ") | color(Color::Red),
paragraph(" スピナー "), spinner(6, i / 10)) |
auto screen = Screen::Create(Dimension::Fit(document));
Render(screen, document);
std::cout << reset_position;
screen.Print();
reset_position = screen.ResetPosition();
std::this_thread::sleep_for(0.01s);
}
return 0;
}
linear_gradient
Demo
#include <memory>
auto document = text("gradient") | center;
.Angle(45)
.Stop(Color::DeepPink1)
.Stop(Color::DeepSkyBlue1));
auto screen = Screen::Create(Dimension::Full(), Dimension::Full());
Render(screen, document);
screen.Print();
return 0;
}
線形グラデーションカラー効果の設定を表すクラスです。
package_manager
Demo
#include <chrono>
#include <iostream>
#include <list>
#include <memory>
#include <string>
#include <thread>
#include <utility>
#include <vector>
std::string name;
int number_of_threads;
int downloaded;
};
std::list<Task> remaining_tasks = {
{"contact server ", 10, 0, 6 * 25},
{"download index.html ", 10, 0, 9 * 25},
{"download script.js ", 1, 0, 3 * 25},
{"download style.js ", 1, 0, 4 * 25},
{"download image.png ", 1, 0, 5 * 25},
{"download big_1.png ", 1, 0, 30 * 25},
{"download icon_1.png ", 1, 0, 7 * 25},
{"download icon_2.png ", 1, 0, 8 * 25},
{"download big_2.png ", 1, 0, 30 * 25},
{"download small_1.png ", 1, 0, 10 * 25},
{"download small_2.png ", 1, 0, 11 * 25},
{"download small_3.png ", 1, 0, 12 * 25},
};
std::list<Task> displayed_task;
int remaining_threads = 12;
int nb_queued = (int)remaining_tasks.size();
int nb_active = 0;
int nb_done = 0;
auto to_text = [](int number) {
return text(std::to_string(number)) |
size(WIDTH, EQUAL, 3);
};
auto renderTask = [&](
const Task& task) {
auto style = (task.downloaded == task.size) ? dim : bold;
return hbox({
text(task.name) | style,
separator(),
to_text(task.downloaded),
text("/"),
to_text(task.size),
separator(),
gauge(task.downloaded / float(task.size)),
});
};
auto renderSummary = [&]() {
auto summary = vbox({
hbox({
text("- done: "),
to_text(nb_done) | bold,
}) | color(Color::Green),
hbox({
text("- active: "),
to_text(nb_active) | bold,
}) | color(Color::RedLight),
hbox({
text("- queue: "),
to_text(nb_queued) | bold,
}) | color(Color::Red),
});
return window(text(
" Summary "), summary);
};
auto render = [&]() {
std::vector<Element> entries;
for (auto& task : displayed_task) {
entries.push_back(renderTask(task));
}
return vbox({
window(text(
" Task "), vbox(std::move(entries))),
hbox({
renderSummary(),
filler(),
}),
});
};
auto updateModel = [&]() {
for (auto& task : displayed_task) {
if (task.downloaded != task.size) {
task.downloaded++;
} else if (task.number_of_threads) {
remaining_threads += task.number_of_threads;
task.number_of_threads = 0;
nb_active--;
nb_done++;
}
}
if (remaining_tasks.size() &&
remaining_tasks.front().number_of_threads <= remaining_threads) {
remaining_threads -= remaining_tasks.front().number_of_threads;
displayed_task.push_back(remaining_tasks.front());
remaining_tasks.pop_front();
nb_queued--;
nb_active++;
}
};
std::string reset_position;
for (;;) {
auto document = render();
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
std::cout << reset_position;
screen.Print();
reset_position = screen.ResetPosition();
using namespace std::chrono_literals;
std::this_thread::sleep_for(0.01s);
if (nb_active + nb_queued == 0) {
break;
}
updateModel();
}
std::cout << std::endl;
}
std::variant< Event, Closure, AnimationTask > Task
paragraph
Demo
#include <chrono>
#include <iostream>
#include <memory>
#include <string>
#include <thread>
using namespace std::chrono_literals;
std::string p =
R"(確率論および統計学において、ベイズの定理（またはベイズの法則、ベイズの規則）は、ある事象に関連する可能性のある条件の事前知識に基づいて、その事象の確率を記述します。例えば、癌が年齢と関連している場合、ベイズの定理を使用することで、その人の年齢を知らない状態での癌の確率の評価と比較して、その人が癌である確率をより正確に評価するために年齢を使用できます。ベイズの定理の多くの応用の1つは、統計的推論への特定のアプローチであるベイズ推論です。適用される場合、ベイズの定理に含まれる確率は、異なる確率解釈を持つことがあります。ベイズ確率解釈では、この定理は、関連する証拠の入手可能性を考慮して、主観的な信頼度が合理的に変化すべき方法を表現します。ベイズ推論は、ベイズ統計学の基礎です。) ";
std::string reset_position;
while (true) {
auto document = vbox({
hflow(paragraph(p)),
separator(),
hflow(paragraph(p)),
separator(),
hbox({
hflow(paragraph(p)),
separator(),
hflow(paragraph(p)),
}),
}) |
border;
document = vbox(filler(), document);
// auto screen = Screen::Create(Dimension::Fit(document));
// Render(screen, document);
// screen.Print();
// getchar();
auto screen = Screen::Create(Dimension::Full());
Render(screen, document);
std::cout << reset_position;
screen.Print();
reset_position = screen.ResetPosition();
std::this_thread::sleep_for(0.01s);
}
return 0;
}
separator
Demo
#include <memory>
auto document = hbox({
text("left-column"),
separator(),
vbox({
center(text("top")) | flex,
separator(),
center(text("bottom")),
}) | flex,
separator(),
text("right-column"),
}) |
border;
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
separator_style
Demo
#include <iostream>
#include <memory>
auto document = vbox({
vbox({
text("separatorLight"),
separatorLight(),
hbox(text("left"), separatorLight(), text("right")),
}) | borderLight,
vbox({
text("separatorDashed"),
separatorDashed(),
hbox(text("left"), separatorDashed(), text("right")),
}) | borderDashed,
vbox({
text("separatorHeavy"),
separatorHeavy(),
hbox(text("left"), separatorHeavy(), text("right")),
}) | borderHeavy,
vbox({
text("separatorDouble"),
separatorDouble(),
hbox(text("left"), separatorDouble(), text("right")),
}) | borderDouble,
});
auto screen =
Screen::Create(Dimension::Fit(document), Dimension::Fit(document));
Render(screen, document);
screen.Print();
std::cout << std::endl;
}
size
Demo
#include <memory>
#include <string>
#include <utility>
auto make_box = [](
const std::string& title) {
return window(text(title) | hcenter | bold,
text("content") | hcenter | dim);
};
for (int x = 3; x < 30; ++x) {
content.push_back(
make_box(std::to_string(x)) |
size(WIDTH, EQUAL, x));
}
auto document = hbox(std::move(content));
auto screen = Screen::Create(Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
spinner
Demo
#include <chrono>
#include <iostream>
#include <string>
#include <thread>
#include <utility>
#include <vector>
using namespace std::chrono_literals;
std::string reset_position;
for (int index = 0; index < 200; ++index) {
std::vector<Element> entries;
for (int i = 0; i < 23; ++i) {
if (i != 0) {
entries.push_back(separator());
}
entries.push_back(
hbox({
text(std::to_string(i)) |
size(WIDTH, EQUAL, 2),
separator(),
spinner(i, index) | bold,
}));
}
auto document = hbox({
vbox(std::move(entries)) |
border,
filler(),
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
std::cout << reset_position;
screen.Print();
reset_position = screen.ResetPosition();
std::this_thread::sleep_for(0.1s);
}
std::cout << std::endl;
}
style_blink
Demo
#include <memory>
auto document =
hbox({
text("このテキストは"),
text("点滅します") | blink,
text("。気に入りましたか？"),
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
style_bold
Demo
#include <memory>
auto document =
hbox({
text("このテキストは"),
text("太字") | bold,
text("です。気に入りましたか？"),
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
style_color
Demo
#include <memory>
auto document = hbox({
vbox({
color(Color::Default, text("Default")),
color(Color::Black, text("Black")),
color(Color::GrayDark, text("GrayDark")),
color(Color::GrayLight, text("GrayLight")),
color(Color::White, text("White")),
color(Color::Blue, text("Blue")),
color(Color::BlueLight, text("BlueLight")),
color(Color::Cyan, text("Cyan")),
color(Color::CyanLight, text("CyanLight")),
color(Color::Green, text("Green")),
color(Color::GreenLight, text("GreenLight")),
color(Color::Magenta, text("Magenta")),
color(Color::MagentaLight, text("MagentaLight")),
color(Color::Red, text("Red")),
color(Color::RedLight, text("RedLight")),
color(Color::Yellow, text("Yellow")),
color(Color::YellowLight, text("YellowLight")),
color(0x66ff66_rgb, text("Phosphor")),
text("Skyblue to DeepSkyBlue")),
}),
vbox({
bgcolor(Color::Default, text("Default")),
bgcolor(Color::Black, text("Black")),
bgcolor(Color::GrayDark, text("GrayDark")),
bgcolor(Color::GrayLight, text("GrayLight")),
bgcolor(Color::White, text("White")),
bgcolor(Color::Blue, text("Blue")),
bgcolor(Color::BlueLight, text("BlueLight")),
bgcolor(Color::Cyan, text("Cyan")),
bgcolor(Color::CyanLight, text("CyanLight")),
bgcolor(Color::Green, text("Green")),
bgcolor(Color::GreenLight, text("GreenLight")),
bgcolor(Color::Magenta, text("Magenta")),
bgcolor(Color::MagentaLight, text("MagentaLight")),
bgcolor(Color::Red, text("Red")),
bgcolor(Color::RedLight, text("RedLight")),
bgcolor(Color::Yellow, text("Yellow")),
bgcolor(Color::YellowLight, text("YellowLight")),
bgcolor(0x66ff66_rgb, text("Phosphor")),
text("Skyblue to DeepSkyBlue")),
}),
filler(),
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
style_dim
Demo
#include <memory>
auto document =
hbox({
text("This text is "),
text("dim") | dim,
text(". Do you like it?"),
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
style_gallery
Demo
#include <memory>
auto document =
hbox({
text("normal") , text(" ") ,
text("bold") | bold , text(" ") ,
text("italic") | italic , text(" ") ,
text("dim") | dim , text(" ") ,
text("inverted") | inverted , text(" ") ,
text("underlined") | underlined , text(" ") ,
text("underlinedDouble") | underlinedDouble , text(" ") ,
text("blink") | blink , text(" ") ,
text("strikethrough") | strikethrough , text(" ") ,
text("color") | color(Color::Blue) , text(" ") ,
text("bgcolor") | bgcolor(Color::Blue) , text(" ") ,
text("hyperlink") | hyperlink("https://github.com/ArthurSonzogni/FTXUI"),
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
style_hyperlink
Demo
#include <memory>
auto document =
hbox({
text("This text is an "),
text("hyperlink") | hyperlink("https://www.google.com"),
text(". Do you like it?"),
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
style_inverted
Demo
#include <memory>
auto document = hbox({
text("This text is "),
text("inverted") | inverted,
text(". Do you like it?"),
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
style_italic
Demo
#include <memory>
auto document = hbox({
text("This text is "),
text("italic") | italic,
text(". Do you like it?"),
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
style_strikethrough
Demo
#include <memory>
auto document =
hbox({
text("This text is "),
text("strikethrough") | strikethrough,
text(". Do you like it?"),
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
style_underlined
Demo
#include <memory>
auto document =
hbox({
text("This text is "),
text("underlined") | underlined,
text(". Do you like it?"),
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
style_underlined_double
Demo
#include <memory>
auto document =
hbox({
text("This text is "),
text("underlinedDouble") | underlinedDouble,
text(". Do you like it?"),
});
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
return 0;
}
table
Demo
#include <iostream>
#include <string>
#include <vector>
{"Version", "Marketing name", "Release date", "API level", "Runtime"},
{"2.3", "Gingerbread", "February 9 2011", "10", "Dalvik 1.4.0"},
{"4.0", "Ice Cream Sandwich", "October 19 2011", "15", "Dalvik"},
{"4.1", "Jelly Bean", "July 9 2012", "16", "Dalvik"},
{"4.2", "Jelly Bean", "November 13 2012", "17", "Dalvik"},
{"4.3", "Jelly Bean", "July 24 2013", "18", "Dalvik"},
{"4.4", "KitKat", "October 31 2013", "19", "Dalvik and ART"},
{"5.0", "Lollipop", "November 3 2014", "21", "ART"},
{"5.1", "Lollipop", "March 9 2015", "22", "ART"},
{"6.0", "Marshmallow", "October 5 2015", "23", "ART"},
{"7.0", "Nougat", "August 22 2016", "24", "ART"},
{"7.1", "Nougat", "October 4 2016", "25", "ART"},
{"8.0", "Oreo", "August 21 2017", "26", "ART"},
{"8.1", "Oreo", "December 5 2017", "27", "ART"},
{"9", "Pie", "August 6 2018", "28", "ART"},
{"10", "10", "September 3 2019", "29", "ART"},
{"11", "11", "September 8 2020", "30", "ART"},
});
table.SelectColumn(0).Border(LIGHT);
table.SelectRow(0).Decorate(bold);
table.SelectRow(0).SeparatorVertical(LIGHT);
table.SelectRow(0).Border(DOUBLE);
table.SelectColumn(2).DecorateCells(align_right);
auto content = table.SelectRows(1, -1);
content.DecorateCellsAlternateRow(color(Color::Blue), 3, 0);
content.DecorateCellsAlternateRow(color(Color::Cyan), 3, 1);
content.DecorateCellsAlternateRow(color(Color::White), 3, 2);
auto document = table.Render();
auto screen =
Screen::Create(Dimension::Fit(document, true));
Render(screen, document);
screen.Print();
std::cout << std::endl;
return 0;
}
void Border(BorderStyle border=LIGHT)
選択範囲に border を適用します。
TableSelection SelectAll()
テーブル全体を選択します。
Tableは、テーブルを描画するためのユーティリティです。
vbox_hbox
Demo
#include <stdio.h>
#include <memory>
auto document =
vbox({
hbox({
text("north-west"),
filler(),
text("north-east"),
}),
filler(),
hbox({
filler(),
text("center"),
filler(),
}),
filler(),
hbox({
text("south-west"),
filler(),
text("south-east"),
}),
});
auto screen = Screen::Create(Dimension::Full());
Render(screen, document);
screen.Print();
getchar();
return 0;
}
vflow
Demo
#include <stdio.h>
#include <string>
auto make_box = [](
int dimx,
int dimy) {
std::string title = std::to_string(dimx) + "x" + std::to_string(dimy);
return window(text(title) | hcenter | bold,
text("content") | hcenter | dim) |
size(WIDTH, EQUAL, dimx) |
size(HEIGHT, EQUAL, dimy);
};
auto document = vflow({
}) |
border;
auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
Render(screen, document);
screen.Print();
getchar();
return 0;
}