In what scenario would I get no output to the console?

[mscofield0]

So I have 2 components: Chat and Input and one main component that is being passed to screen.Loop() method.

Main component

This is the definition of the Main component:

class Main : public ftxui::ComponentBase
{
	using Base = ftxui::ComponentBase;
	using Tx = Comms::Tunnel<Packet>::Tx;
	using Rx = Comms::Tunnel<MessageService::Update>::Rx;

public:
	Main(ftxui::ScreenInteractive& screen, Tx&& packet_tx, Rx&& update_rx);
	ftxui::Element Render() override;
	bool OnEvent(ftxui::Event evt) override;

private:
	ftxui::ScreenInteractive* screen_;
	ftxui::Component chat_;
	ftxui::Component input_;
};

Main::Main(ftxui::ScreenInteractive& screen, Tx&& packet_tx, Rx&& update_rx)
	: screen_(&screen), chat_(std::make_shared<Component::Chat>(screen, std::move(update_rx))),
	  input_(std::make_shared<Component::Input>(screen, std::move(packet_tx))) 
{
	this->Add(chat_);
	this->Add(input_);
}

ftxui::Element Main::Render() {
	using namespace ftxui;

	// clang-format off
	return vbox({
           this->chat_->Render() | flex,
           this->input_->Render()
       });
	// clang-format on
}

bool Main::OnEvent(ftxui::Event evt) {
	if (evt == ftxui::Event::Escape) {
		screen_->ExitLoopClosure()();
		return true;
	}

	return Base::OnEvent(evt);
}

Chat component

class Chat : public ftxui::ComponentBase
{
	using Base = ftxui::ComponentBase;
	using Rx = Comms::Tunnel<MessageService::Update>::Rx;
public:
	Chat(ftxui::ScreenInteractive& screen, Rx&& rx);
	~Chat();
	ftxui::Element Render() override;
	bool OnEvent(ftxui::Event evt) override;
private:
	void update_messages(std::vector<Message> const& messages);
private:
	ftxui::ScreenInteractive* screen_;
	ftxui::Component messages_;
	std::mutex mtx_;
	std::atomic<bool> running_;
	std::thread listener_;
	Rx update_rx_;
};

Chat::Chat(ftxui::ScreenInteractive& screen, Rx&& rx) : 
    screen_(&screen), 
    messages_(ftxui::Container::Vertical({})), 
    running_(true), 
    update_rx_(std::move(rx)) 
{
	this->Add(messages_);

	listener_ = std::thread([this] {
		while (this->running_.load(std::memory_order_acquire)) {
			if (const auto update = update_rx_.try_receive(); update) {
				// Update the component children
				this->update_messages(update.value().messages);

				// Force redraw
				this->screen_->PostEvent(ftxui::Event::Custom);
			}
			std::this_thread::yield();
		}
	});
}

Chat::~Chat() {
	running_.store(false, std::memory_order_release);
	listener_.join();
}

ftxui::Element Chat::Render() {
	using namespace ftxui;
	auto lock = std::lock_guard(mtx_);

	if (messages_->ChildCount() == 0) {
		return window(text("Chat"), vbox(text("No messages")));
	} else {
		return window(text("Chat"), vbox(messages_->Render()));
	}
}

bool Chat::OnEvent(ftxui::Event evt) {
	return Base::OnEvent(evt);
}

void Chat::update_messages(std::vector<Message> const& messages) {
	auto lock = std::lock_guard(mtx_);
	messages_->DetachAllChildren();

	for (const auto& msg : messages) {
		messages_->Add(ftxui::Renderer([&msg] { return ftxui::text(to_string(msg)); }));
	}
}

Input component

class Input : public ftxui::ComponentBase
{
	using Base = ftxui::ComponentBase;
	using Tx = Comms::Tunnel<Packet>::Tx;
public:
	Input(ftxui::ScreenInteractive& screen, Tx&& tx);
	ftxui::Element Render() override;
	bool OnEvent(ftxui::Event evt) override;
private:
	ftxui::InputOption create_input_option();
private:
	ftxui::ScreenInteractive* screen_;
	std::string input_buf_;
	ftxui::Component input_;
	Tx packet_tx_;
};

Input::Input(ftxui::ScreenInteractive& screen, Tx&& tx)
	: screen_(&screen), input_(ftxui::Input(&input_buf_, "Input here:", create_input_option())),
	  packet_tx_(std::move(tx)) 
{
	this->Add(input_);
}

ftxui::Element Input::Render() {
	using namespace ftxui;
	return window(text("Input"), input_->Render());
}

bool Input::OnEvent(ftxui::Event evt) {
	return Base::OnEvent(evt);
}

ftxui::InputOption Input::create_input_option() {
	ftxui::InputOption opt;
	opt.on_enter = [this] { this->packet_tx_.try_send(Packet(Packet::Kind::Standard, this->input_buf_)); };
	return opt;
}

Closing remarks

I have no idea why it wouldn't display anything. I added them to as children, I did everything "by the book". I even tried replacing the Render() of the Main component with a simple text("Test") and it still didn't work.

I apologize for the huge block of code, but I assumed that full context would be good.

[ArthurSonzogni]

At first glance, I would say the std::thread is posting events more quickly than what the screen can process. You probably send hundreds of millions of them per seconds, and the screen is processing only a few millions.

The screen's loop implementation:

FTXUI/src/ftxui/component/screen_interactive.cpp

Lines 421 to 448 in 7e5cd23

	void ScreenInteractive::Main(Component component) {
	while (!quit_) {
	if (!event_receiver_->HasPending()) {
	Draw(component);
	std::cout << ToString() << set_cursor_position;
	Flush();
	Clear();
	}
	Event event;
	if (!event_receiver_->Receive(&event))
	break;
	if (event.is_cursor_reporting()) {
	cursor_x_ = event.cursor_x();
	cursor_y_ = event.cursor_y();
	continue;
	}
	if (event.is_mouse()) {
	event.mouse().x -= cursor_x_;
	event.mouse().y -= cursor_y_;
	}
	event.screen_ = this;
	component->OnEvent(event);
	}
	}

Works by:

1. Handle every events posted in the queue.
2. Draw a new frame

In your example, we stay at step (1) forever, resulting in drawing the at 0 fps.

You probably need to replace yield by:

      using namespace std::chrono_literals;
      std::this_thread::sleep_for(0.05s);

[mscofield0]

It's not that, though it would probably be safer to use sleep_for(). No messages are being sent at that point in time (the client hasn't even connected).

[ArthurSonzogni]

Did you tried?

If yes, maybe you can check that ftxui::Element Main::Render() is called, by inserting a line crashing inside?

[mscofield0]

I tried, and I did the print debug thing after I sent the message on Github. If I don't put the print, it doesn't even run my app.run() method. If I do put the print, then the app.run() method gets run. And after 2 runs (I have no idea why there are 2 runs of the Main::render() method, it should be 1 since no change occurs afterwards...) then the program crashes because of "stack smashing". Lol. Never in my life have I ever experienced something like this. What the hell

[mscofield0]

Ah thankfully I managed to make asan detect (I just made Loop() wrap the main component via Renderer) some things... I'll get back with feedback.

[mscofield0]

I had lifetime issues not related to ftxui. Fixed!