How to enforce minimum size for a resizable split component?

[blex-max]

Hello, thanks so much for ftxui. I recently discovered it and it's great. I can do in minutes what would take me a week in ncurses. As of today I've set up a small sponsorship for the project :).

A small question I can't figure out from the doc, and I can't find it in the search either. I have the following code

  auto browser_top_row = ResizableSplitRight(pileup_info, read_viewer, &ncol_pileup);
  auto browser_bottom_row = ResizableSplitRight(gen_info, read_info, &ncol_gen_info);
  Component browser_row_split = ResizableSplitTop(browser_top_row, browser_bottom_row, &nrow_seq);

What is the appropiate way to ensure that the bottom row is never less than a minimum size?

Many thanks,

Alex

[ArthurSonzogni]

Hello @blex-max

Hello, thanks so much for ftxui. I recently discovered it and it's great. I can do in minutes what would take me a week in ncurses. As of today I've set up a small sponsorship for the project :).

Thank you very much! That's greatly appreciated!

What is the appropiate way to ensure that the bottom row is never less than a minimum size?

There are no builtin solution at the moment ;-(

I guess we could add a min/max option in ResizableSplitOption. Then you would be able to call it:

int main_size = 20;
auto foreground = ...;
auto background = ...;
int size = auto split = ResizableSplit({
  .main = foreground.
  .back = background,
  .direction = Direction::Left,
  .main_size = &main_size,
  .min = 10,
  .max = 20,
})

This could be added if we believe this would be valuable.

Alternatively, one can clamp the size value after handling events, but before rendering the component.
Here is an example:

// Copyright 2020 Arthur Sonzogni. All rights reserved.
// Use of this source code is governed by the MIT license that can be found in
// the LICENSE file.
#include <memory>  // for shared_ptr, allocator, __shared_ptr_access

#include "ftxui/component/captured_mouse.hpp"  // for ftxui
#include "ftxui/component/component.hpp"  // for Renderer, ResizableSplitBottom, ResizableSplitLeft, ResizableSplitRight, ResizableSplitTop
#include "ftxui/component/component_base.hpp"      // for ComponentBase
#include "ftxui/component/screen_interactive.hpp"  // for ScreenInteractive
#include "ftxui/dom/elements.hpp"  // for Element, operator|, text, center, border

using namespace ftxui;

std::function<Component(Component)> ClampSize(int* size, int min, int max) {
  return [=](Component component) {
    return Renderer(component, [=] {
      *size = std::max(min, std::min(max, *size));
      return component->Render();
    });
  };
}

int main() {
  auto screen = ScreenInteractive::Fullscreen();

  auto middle = Renderer([] { return text("middle") | center; });
  auto left = Renderer([] { return text("Left") | center; });
  auto right = Renderer([] { return text("right") | center; });
  auto top = Renderer([] { return text("top") | center; });
  auto bottom = Renderer([] { return text("bottom") | center; });

  int left_size = 20;
  int right_size = 20;
  int top_size = 10;
  int bottom_size = 10;

  auto container = middle;
  container = ResizableSplitLeft(left, container, &left_size);
  container = ResizableSplitRight(right, container, &right_size);
  container = ResizableSplitTop(top, container, &top_size);
  container = ResizableSplitBottom(bottom, container, &bottom_size);

  // Clamp the sizes.
  container |= ClampSize(&left_size, 3, 20);
  container |= ClampSize(&right_size, 3, 20);
  container |= ClampSize(&top_size, 1, 10);
  container |= ClampSize(&bottom_size, 1, 10);

  auto renderer =
      Renderer(container, [&] { return container->Render() | border; });

  screen.Loop(renderer);
}

The decorator ClampSize does forward normally OnRender, but clamp the size just in time.

[blex-max]

Thanks very much for the response :) I can use ClampSize for now, but in my opinion that addition to ResizableSplitOption would be an extremely valuable feature, if it's reasonably tractable to implement. What do you think?

[ArthurSonzogni]

Yes this sounds like a good idea. Let's try asking AI to implement this ;-)

[blex-max]

Great, let me know how it goes :) I'm surprised to hear that AI is reliable here, my experience of it has been quite poor. But whatever works

[blex-max]

For anyone who comes across this, at present I'm using:

std::function<Component(Component)> ClampSize(int* size, int min, int max) {
  return [=](Component component) {
    return Renderer(component, [=] {
      *size = std::clamp(*size, min, max);
      return component->Render();
    });
  };
}  // from Arthur

std::function<Component(Component)> FixDimension(ftxui::WidthOrHeight dim, ftxui::Constraint constraint, int val) {
  return [=](Component component) {
    return Renderer(component, [=] {
      return component->Render() | size(dim, constraint, val);
    });
  };
}  // because decorating directly with size doesn't rerender every frame

// ...

  Component browser_bottom_row =
      ResizableSplitRight(gen_info, r_info, &ncol_gen_info) | FixDimension(HEIGHT, GREATER_THAN, nrow_r_info);
  Component browser_row_split =
      ResizableSplitTop(browser_top_row, browser_bottom_row, &nrow_ss) | ClampSize(&nrow_s, 5, 30);

  Component browser_pane =
      Renderer(browser_row_split, [&]() {
        return browser_row_split->Render() | flex;
      });

And it's working fine.

[blex-max]

(though the maintainer may have better suggestions!)

[ArthurSonzogni]

@blex-max , I merged adding support for min/max. I hope this properly work.

[blex-max]

Great, thanks! 🎉 I'll try building my project using the main branch and let you know if it's all working ok. Are there any issues I should know about if I'm going to use main directly? I'm currently on the latest release, 6.1.9

[ArthurSonzogni]

Thanks!
It's up to you. If you are using CMake, you can either depend on a branch, a tag, or a commit hash.

You can use a commit hash to ensure your dependency won't "move" toward a different commit behind your back.

[blex-max]

Actually what I really meant was is main unstable in any known way?

[blex-max]

I'm happy to say that this is working fine for me using 252ce67 - I did notice when playing with that I can induce odd behaviour if main_size begins outside the clamped ranged, but that's not a problem in proper use. Thanks so much for implementing this :)