16

Roadmap

Yves Biener edited this page 2025-10-26 21:43:44 +01:00

Table of Contents

• Roadmap

Roadmap

The following list contains goals for certain features the library supports or is planned on supporting.

• Input handling

  • basic input handling
  • support modifiers with other control characters (i.e. SHIFT + TAB)
  • support input's (i.e. Esc x, Esc 0 x or SS3, Esc [ .. or Csi, Osc, Dcs) see [src/vt.rs:156] and [src/input.rs:324] for the actual parsing implementation
    • SS3
    • [-] CSI (not everything yet - i.e. clipboard support)
    • OSC
    • DCS
  • Clipboard support (reading and writing) (later)

• Concept for focused Container's / Elements's

  • Allow usage of keyboard keys to change focus
  • Limit where Focus is actually necessary (and skip those accordingly)
  • Enhance the rendering to make it obvious where the focus is currently at

• Enhance performance through multi-threading?

  • synchronization might be a bottleneck, but maybe interesting for bigger applications? would require some tests

• Elm architecture support (through user defined struct acting as the Model)

• Container rendering

  • Layout
    • direction
      • vertical
      • horizontal
    • padding
    • gap
  • Border
    • sides
    • corners
    • separators
    • title? (later)
  • Rectangle
  • Sizing options (should be only one option at any given time possible)
    • fixed sizes (absolute)
    • growable sizes
    • percentage sizes (compared to its parent Container, or for the root, compared to the absolute screen size) (relative)
  • Inline rendering (later)

• User control

  • event loop handling
    • mouse support
  • user content
  • Default Element implementations
    • Scrollable
      • user input handling
        • vertical
        • horizontal
        • mouse input
      • scroll bar(s) rendering
        • vertical
        • horizontal
    • Content alignment (i.e. standard calculations done with the provided Size)
      • horizontal center (i.e. calculate the corresponding anchor)
      • vertical center (i.e. calculate the corresponding anchor)
    • User input
    • image support through kitty protocol (later)
    • embeeding another application (i.e. an editor, or something like that)? (later)

• Examples

  • Layouts
    • vertical
    • horizontal
    • grid
    • mixed (some sort of form)
  • Elements
    • Container Alignment
    • Button
      • custom (see example)
      • built-in
    • Progressbar
    • Form
      • basic
        • Figure out input handling (apart from mouse Event's such that they do not intersect and are easy to see - i.e. which form element is currently active?)
        • Text Input field
          • custom (see example)
          • built-in single line
          • built-in multi line (later)
          • overflow handling, i.e. where to draw the ellipse .. - left and right
        • Selection (enum's)
        • Radio Button (bool's)
        • Slider (range values)
      • support all other built-in Elements that display values accordingly
    • Stackable / Floating Containers / Elements
      • Popup
    • Dialog
      • based upon Popup's implementation to switch the dialog pages that are linked in an ordered list?
      • use Button's to make go to the next / previous dialog pages
      • use internal events that are not necessary to be listed in the App.Event?
    • Scrollable Content (i.e. show long text of an except of something and other smaller Container)
      • min size
      • mouse scrolling aware of mouse position (i.e. through multiple different scrollable Container)
      • scrollable contents through other inputs except mouse?
    • Sub application execution with outputs being rendered in a Container (later)
      • non-interactive applications (which do not request a tty/pty) and only communicate through stdin, stdout and stderr (i.e. non-interactive applications)
      • interactive applications (which can request a tty/pty); corresponding inputs need to passed through and emulated such that the outputs can be rendered in a Container
    • Table based on input data
      • scrollable if necessary with sticky header
        • vertical
        • horizontal
        • both
      • non-interactive (no navigation, selection, etc.)
      • interactive (with navigation, per row / cell, with selection, event triggering, etc.)
  • Styles
    • Text styles
      • Colors
        • foreground
        • background
        • underline
      • Emphasis
        • none
        • bold
        • dim
        • italic
        • underline
        • blink
        • invert
        • hidden
        • strikethrough
        • combinations
    • Color palette
  • Error Handling
    • log and show error's without crashing the application
  • Demo
    • use another tui application to launch and come back to (showcase the interrupt behavior)
    • Launch sub-applications (not inside of a Container but during the application workflow, like an editor)

• Testability

  • snapshot ability to safe current screen (from Renderer) to test against
    • See Testing for details on how to create the .zon files containing the expected screen data
  • try to integrate them into the library itself such that they also serve as examples on how to test
    • Layout, Border and Rectangle contain the test cases for rendering of Containers
    • Scrollable test cases containing inclusion of test creation containing user interaction (i.e. mouse scrolling)

• Debugging

  • render corresponding contents with debug information (the following points are just brain dump of potential information the developer want to see):

    Top left corner indicates type of contents (if any) while general information is located in the three remaining corners:

    • anchor of Containers (top-left corner -> meaning that is the actual Cell used for displaying the debug information)
    • size of Container
    • element of Container
    • separator of Container
    • padding of Container (i.e. by coloring the background? later)
    • gap of Container (i.e. by coloring the background? later)

• Element extensions:

  • Element implementations can link to a given event, tagged union variation to trigger events or listen to!
  • provide a reference to the parent Container of a given Element -> allow changing the parent's properties through an Element implementation (i.e. change the color of the border, add a new child element, etc.) if necessary! otherwise I would rather have this be very independent of its parent (and where it is used or rendered!)

• Capabilities

  • support setting terminal title
  • SIMD support - evaluation necessary (later)