termgui 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af01d169693ceefa3a955883a770af3768f7a902e526ce00cd4aa11b09afa73d
-  data.tar.gz: 4360e7b85f248e64074ae8371d3725d92518a1d9571ce0005884c5af3081226f
+  metadata.gz: de4eb3e84f29fd18258803d8e4e7b9d34bdecdc6d7831cca3471c5116f43a2ff
+  data.tar.gz: 8b7d86b1debb3a37e2e7a31223effaee8da41f6053978e2a6b172059a0f656f0
 SHA512:
-  metadata.gz: 2e929dcad6d63589630c51c62ffd1638e3409a613b00acdac8d661e2b16ae9a93070e90b479259518b637b14d66729a5e404a4f657fcbf7fc3e943cdbe1f1111
-  data.tar.gz: 34ab0ae4d6c7754b6e0b0806367c5f05584182c7d787d16c73abfeb058f2a5407da1e4bab8d666075af06399cb2fdc2ced757568858580c7a5f30f29bfd41319
+  metadata.gz: 12587d24d2e4b714101bbdea5f39d0a99df91e8d3b73fa155efdffdba7060323a4cb0d1d45edc7e59ed819d86639f39919e788cd19b1e32f582abde746493c1e
+  data.tar.gz: b6ada34e0e93522f29e71658ca587cb0c13c25ec11180107a7c211f96f9d6981e2ea153a2d966359138abcc6e1a1b5c77d89e9a3e8f23ff7a1fc207c459539ce

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+gem 'chunky_png'
+# gem 'justify'
+gem 'rexml'
+# gem 'strings'
+
+gem 'filewatcher', group: :development
+gem 'rubocop', require: false, group: :development
+gem 'solargraph', require: false, group: :development
+gem 'test-unit', group: :development
+# gem 'yarn', require: false, group: :development

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2020 Sebastián Gurin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,321 @@
+# termgui
+
+Repository: https://github.com/cancerberoSgx/termgui
+
+ * Command line graphical user interface Ruby toolkit.
+ * Create desktop-like interfaces in the command line.
+ * Personal ruby-learning project at the beginning
+ * 100% ruby, no binaries, no dependencies
+ * some ideas taken from npm.org/blessed and my own npm.org/accursed
+ * HTML DOM like high level API with styles, layouts, box-model, cascade styles
+ * xml / edb support for declaring components in XML syntax
+ * rendered optionally supporting a buffer to print out the current screen for testing
+ * very well tested
+ * flexible managers for focus, actions, scroll, keys, input grab, input grab, cursor
+ * event loop supporting set_timeout, wait_for, set_interval 
+ * text-area / editor support
+ * all colors and attributes
+ * some basic high level widgets: Button, Label, InputBox, TextArea, Editor, Select, 
+ * independent low level APIs can be used without the high level overhead for listening stdin, drawing, etc
+ * box drawing, easing, css parser and dom selector 
+
+
+## TODO / Status
+
+See [TODO](TODO.md)
+
+
+## Motivation
+
+ * I don't want to use ncurses based dependencies since is binary
+ * I know there are a couple of initiatives 100% in ruby now, but I didn't knew them when I started this project
+ * I'm the author of npm.org/accursed which is a similar library so I can of already implemented this in JavaScript
+ * Initially a pet project to learn Ruby
+
+## Usage
+
+```
+gem install termgui
+```
+
+### Example
+
+```rb
+require 'termgui'
+screen = Screen.new
+left =  screen.append_child Col.new(width: 0.4, height: 0.99, style: { bg: 'red' })
+(0..8).map { |i| left.append_child Label.new(text: "Label_#{i}") }
+right = screen.append_child Col.new(width: 0.6, height: 0.99, x: 0.4, style: {bg: 'blue'))
+(0..4).map do |i|
+  right.append_child Button.new(
+    text: "Button_#{i}", x: 0.5,
+    style: {focus: {fg: '#ed5525'}},
+    action: proc { open_modal(screen: screen, title: "Button_#{i}") }
+  )
+end
+screen.start
+```
+
+Result:
+
+![readme_screenshot01](readme_screenshot01.jpg)
+
+## Development commands
+
+```sh
+cd termui
+bundler install
+sh bin/test
+sh bin/doc
+sh bin/dev   # rails server
+sh bin/watch # tests in watch mode
+```
+
+## API Reference
+
+TODO
+
+### low level (working) examples
+
+TODO
+
+#### No DOM - just draw
+
+TODO
+
+#### Only Input
+
+TODO
+
+#### Only Renderer
+
+TODO
+
+
+
+
+## Element attributes
+
+Some high level element attributes implemented:
+
+### style-cascade
+
+By default, children inherit parent style. If `element.get_attribute('style-cascade') == 'prevent'` it won't happen - this is the children won't be affected by its parent style and only its own is rendered. 
+
+### focusable, focused and screen.focus.keys, focus, blur
+
+elements with focusable attribute will be able to be focused when user press focus keys (configurable in screen.focus.keys ). By default screen.focus.keys ==  { next: ['tab'], prev: ['S-tab'] }. 
+
+focusable elements will emit "focus" and "blur" events
+
+When focused, the attribute focused will be true and the element is able to receive "action" event (see actionable, action-keys below)
+
+### actionable, action-keys, action
+
+this is useful to implement actionable widgets like buttons that, when focused, can emit "action" events when certain keys are pressed (by default ENTER)
+
+focused elements with attribute "actionable" will emit "action" events if user press action-keys (enter by default) when they are focused. Action keys can be configured globally using screen.action.keys or by element with attribute action-keys. Both could be a string or array. 
+
+
+### action-on-focus
+
+automatically trigger an action event wneh an element is focused. helpful for selectbox so no enter is needed for working
+
+### escape-on-blur
+
+automatically escapes an entered element on blur. helpful for selectbox so no escape is needed for switching focus - so it behaves like buttons
+
+
+### enterable, entered, change, input, escape, escape-keys
+
+This is useful to implement textarea / textinput widgets for which we don't want to trigger focus or action events when user is writing text. When an enterable element (that also should be focusable) receives "action" it is set to "entered" mode. (whey you are writing text, you want TAB S-tab, enter, etc to actually insert characters and don't emit "focus" "action", etc events...)
+
+When an element is on this mode (only one at a time) the rest of the elements will stop receiving common events like focus or action until it leaves the entered mode. . This could happen programmatically or by receiving "escape" event, by default pressing ESC will provoke "escape" event which will set entered = false and enable normal events again (like focus, action, etc). When entered==true, the entered element will listen for input independently and emit "input" events. 
+
+the enter event by default is provoked by "action" (enter) so it can be configured individually using action-keys. 
+
+the escape event by default pressing "escape" can be configurable per element using attribute escape-keys (just like action-keys)
+
+TODO: configure to better play with focus: enter-on-focus to automatically "entered" without "action" and automatically "escape" on "blur" (focus will keep working on this case). Also is not clear how escape plays with change 
+
+
+
+
+## Performance notes
+
+ * disabling renderer buffer speeds up rendering about 30%: `screen.renderer.no_buffer = true`. Genereally don't needed in production.
+
+
+## API example prototypes (WIP)
+
+** initial design stories**
+
+### layout
+
+TODO  / proposal
+
+```
+require 'termgui'
+class AppExplorer < Column
+  def initialize(model)
+    super
+    @model=model
+    @text = append_child(text: Textarea.new model.text, onChange: {|e| print e.key})
+    @text.onChange {|e| print e.key}
+  end
+end
+screen = Screen.new
+main = Row.new
+left = main.append_child(Column.new 0.3)
+right = main.append_child(Column.new 0.7)
+explorer = left.append_child(AppExplorer.new model)
+editor = right.append_child(AppEditor.new model)
+screen start
+```
+
+### structure
+
+TODO  / proposal
+
+```
+class MyWidget < Column
+  def initialize
+    super 0.5
+    append_children [
+      {type: Row, height: 0.6, children: [
+        {type: Input, value: 'edit me', width: 0.5, onChange: {|e|print e} },
+        {type: Label, text: 'edit me'},
+      ]}
+      {type: Button, text: 'click me', onClick: {|e|print e}},
+    ]
+  end
+end
+```
+
+#### aside
+
+```
+{type: Button, text: 'click me', onclick: {|e|print e}},
+vs
+Button.new text: 'click me', onclick: {|e|print e}},
+
+{type: Row, height: 0.6, children: [
+  {type: Input, value: 'edit me', width: 0.5, onChange: {|e|print e} },
+  {type: Label, text: 'hello'},
+]}
+vs
+Row.new height: 0.6, children: [
+  Input.new value: 'edit me', width: 0.5, onChange: {|e|print e},
+  Label new: label: 'hello'
+]
+```
+
+### style
+
+style = {
+  '.primary': {
+    bg: 'red',
+    fg: 'black'
+    bold: true
+  }
+}
+screen.append_child(Column.new children: [
+  Label.new text: 'are you sure?',
+  Button.new
+])
+
+
+### high level no layout
+
+TODO / proposal
+
+```
+s=Screen.new
+b=Button.new(parent: s.document, width: 0.3, height: 0.3, left: 0, top: 0, label: 'click me', onClick: { |e| alert "#{e.target.label} clicked!" })
+s.start
+```
+
+### example low level
+
+(no HTML DOM at all, just drawing)
+```
+screen = Screen.new
+screen.renderer.rect(2,3,9,3,'-', {fg: 'yellow', bg: 'gray'})
+screen.renderer.text(x: 3, y: 4,text; 'click me', style: Style.new(fg: '#ffee11', bg: 'black', bold: true))
+```
+
+### events
+
+```
+screen=Screen.new
+screen.event.add_listener('key', {|e| exit 0 if e.key=='q'})
+renderer.text(text: 'press q to exit')
+```
+
+
+
+## Design
+
+### concepts
+
+Screen: contains document, renderer, buffer, Input
+
+Renderer: responsible of drawing given pixels to the terminal
+
+Buffer: maintains screen as bitmap structure (so users can read the current screen contents like a bitmap)
+
+Document: Node subclass analog to html's (access to parent screen)
+
+Node: DOM like representation analog to html's (children, attributes)
+
+Element: Node subclass analog to html's (border, margin, padding)
+
+Input: responsible of user input - notifies screen - emitter
+
+## Summary
+
+I'm author of npm.org/flor that although has superior terminal support (tput) I would like to re implement a similar library for ruby, writing it from scratch (currently learning ruby).
+
+ * low level html-canvas like to set attributes and write strings
+  * try to stick to html canvas api for Renderer
+  * user is responsible of setting the 'active style' like canvas' stroke-width - this simplifies renderer
+ * renderer of styled strings supporting cursor management,
+  *  responsible of translating user's `{bg: 'red', s: 'hello'}` into a string with ansi codes
+ * screen maintains a virtual Buffer so current drawn screen can be accessed like a bitmap
+ * a DOM like API for children, attributes, box model, style
+  * supports user input events also like html dom EventSource (element.add_listener('key', ...))
+  * basic widget implementations: button,input,textarea
+ * style: fg, bg, ch, bold, etc.
+ * focus management: focused/focusable - element.style.focus
+ * input event loop : set_timeout
+ * easy keyboard event representation and API
+
+## Future
+
+add features from npm.org/flor:
+
+ * scroll (element.scrollX=0.2) - dom support
+ * a xmlish syntax for defining GUI.
+   * support function attributes for event handlers as ruby fragments
+
+## Side projects
+
+ * cli/driver for ruby : for properly testing termgui we need cli-driver for ruby. see probes/stdin.rb for working exec and writing to process stdin async
+
+
+## Design notes
+
+TODO
+
+Screen, renderer, input are responsible of basic terminal styles like bg, fg, bold, etc.
+
+On top of the screen, renderer and input a document object model like HTML DOM is supported. See Node, Element, Style, etc. Some features based on HTML supported are:
+
+ * box model similar
+ * children rendering
+ * text
+ * element query
+ * border
+ * padding
+
+Some high level utilities, like the focus/action management, work on top of this DOM so probably 99% of users will want to go that way for building their GUIs.

data/TODO.md

@@ -0,0 +1,259 @@
+## TODO
+
+ - [ ] issues with bounds andborders is probably solvable by fixing box() by allowing not to print the content and only the border - so can be run after render_self without affecting the content
+ - [ ] this doesn't work: ` style: { padding: Bounds.new(top: 11, left: 11)` nor this: ``this does `style: Style.new(padding: Bounds.new(top: 11, left: 11)`
+ - [ ] advance focus
+   - [ ] how to support focus hierarchies ? 
+     - [ ] alternative 1: use tabs to focus primary panels and arrows to focus internal widgets of current first level focused panel 
+     - [ ] alternative 2: make a focusable & enterable - when entered focus-keys will only work inside it (focusing focusable children)
+     
+ - [w] editor - generic text area like (see section "editor" below). See src/editor
+
+ - [ ] investigate similar target projects 
+    - [ ] https://github.com/Shopify/cli-ui 
+    - [ ]  https://github.com/gavinlaking/vedeu
+    - [ ] input - check this - https://github.com/piotrmurach/tty-reader supports raw mode for multi line - "https://github.com/piotrmurach/tty-reader#22-read_line" - has the key map implemented. - 
+    - [ ] keys - full map verify https://rubydoc.info/gems/vedeu/Vedeu
+    - [ ] check this out - terminal toolkit - many things needed here - research if it targets the same use cases https://ttytoolkit.org/components/
+
+ - [ ] scroll 
+   - [x] Element#offset
+   - [ ] ScrollManager : define "scrollable" and define keys for scroll up, down, left right if current focused el is scrollable ? (manager?)
+     - [ ] scroll events
+     - [ ] need overflow: hidden to make sense - see probes/fileProbe.rb 
+       - [ ] renderer should prevent children content outside overflow:hidden ancestors (expensive render)
+     - [ ] configurable scroll keys, offset amounts and easing, globally and per element.
+   - [ ] inspiration perhaps : https://github.com/xunker/peter_pan/blob/master/lib/peter_pan.rb
+
+ - [ ] test coverage : https://github.com/colszowka/simplecov
+
+ - [ ] notify / responsive when terminal is resized dynamically
+
+ - [ ] widgets
+    - [x] col
+    - [x] row
+    - [x] label
+    - [x] inputbox
+      - [ ] not grabing input - need a way of preventing other global listeners to listen while entered
+    - [x] checkbox
+    - [x] InputNumber
+    - [x] SelectBox
+      - [ ] trigger changeValue event 
+      - [ ] trigger option-focus event
+      - [ ] call change, input and option_focus props
+    - [w] textarea- see editorbase
+
+
+ - [x]  colors:
+  - [x] verify character attributes work in style (see color.rb ATTRIBUTES  Update - removed ). - 
+    - [x] test in a realProbe
+    - [x] fix src/tco to support all attributes - checkout https://github.com/sickill/rainbow and https://github.com/fazibear/colorize  and https://github.com/piotrmurach/pastel - update - tco fixed 
+      - [ ] TODO: tco pull request (blink, underline, etc)
+  - [x] tco [r,g,b] colouring is slow when using many colors (imgs, random_color) 
+    - (WONT) this could be improved by auto generating a rgb->colour mapping table loaded in memory
+    - [ ] tco PR palette.rb #569 just using a simpler hash than to_s for cache key doubles speed
+    - [x] make a fast mode with simpler diff algorithm - see TermGui::fast_colouring(true) (tco PR?)
+
+ - [ ] how to debug ? check if this could help debugging
+
+ - [ ] DOM stuff
+  - [ ] bounds/layout cascade ? 
+  - [x] border_final_style
+  - [x] attribute action-on-focus automatically trigger an action event wneh an element is focused. helpful for selectbox so no enter is needed for working
+  - [x] attribute escape-on-blur
+  - [ ] final_style performance - always cloning/merging even if elements don't have any focus or border style...
+  - [x] fix HashObject#assign so it won't merge nil valued properties. see element_style#merge_style
+  - [x] support hash style declarations: `Element.new(x: 0.1, y: 0.2, style: {fg: 'magenta', border: {style: :double}})`
+  - [x] CSS cascade style: children should inherit parent style if explicit and child has no value. (make it optional/configurable) (see `element.get_attribute('style-cascade') == 'prevent'`)
+  - [ ] store and formalize Element options (initialize arguments). store it so implementations can look at original values given by user (props)
+  - [ ] overflow: hidden
+  - [ ] overflow: scroll
+  - [x] Element#layout() 
+    - [x] widgets Col and Row not working correctly - formalize them and test
+    - [x] an inline layout - similar to HTML display: inline - so I can add arbitrary elements. it will break when there is no more space and resize itself. See widget/Inline
+    - [ ] GridLayout and GridWidget 
+    - [ ] check https://rubydoc.info/gems/terminal-layout
+    - [ ] element's margin
+    - [ ] introduce yoga-layout ? (binary)
+
+ - [x] Elements / renderer dirty / fast-re-render
+   - [x] expensive elements (like images) should have the chance to support render_cache and dirty flags-
+   - [x] if render_cache==true - Element.render only will be executed if dirty=true - otherwise Element.render output should cached
+
+ - [ ] mouse ? minimal mouse support possible ? 
+
+ - [ ] gem
+   - [ ] minimally test gem pack from probe project
+   - [ ] publish
+   - [ ] check this helper: https://github.com/technicalpickles/jeweler
+
+ - [ ] cursor
+   - [x] simple cursor artificial class set_interval see src/cursor.rb
+   - [ ] use ansi escapes - https://github.com/piotrmurach/tty-cursor for cursor_current state
+   - [x] hide when screen.start
+   - [ ] widgets responsible of showing/hiding ? or should it be a cursor manager - enterable - cursorable attributes  ? currently in inputbox, editor_base managing artificial cursor manually
+
+ - [ ] data table widget https://www.google.com/search?q=ruby+gem+terminal&oq=ruby+gem+terminal&aqs=chrome..69i57j69i64.3455j0j4&sourceid=chrome&ie=UTF-8#
+
+ - [ ] documentation
+   - [x] generate API documentation (using yard)
+   - [ ] publish docs/termgui to github pages
+   - [ ] add links to important APIs in README
+   - [ ] document important APIs - how to document events and DOM attributes as part of the API docs? 
+   - [ ] screencasts, screenshots (check http://buildkite.github.io/terminal-to-html/) - asciicam-thing
+   - [ ] tutorials
+   - [ ] examples using only low level apis (Input, Renderer) without DOM 
+   - [ ] announce in stack overflow, medium articles like https://medium.com/@bryantteng/outputting-to-the-terminal-in-style-f489bc2fa52c - 
+
+ - [x] erb probe for elements (see xml/xml)
+ - [x] xml syntax with binding support
+   - [x] properly require '/Users/wyeworks/.rubies/ruby-2.6.5/lib/ruby/2.6.0/rexml/document'
+   - [x] access self (the element instance) from attribute handlers: `action="proc {|e| e.target.text = 'asdasd'; e.target.render}"`
+   - [ ] complete widgets and attributes - padding, border, style.focus, stc
+
+ - [ ] fonts with http://www.figlet.org/ - https://github.com/miketierney/artii - also check http://github.com/piotrmurach/tty-font
+ 
+ - [ ] terminal capabilities http://github.com/piotrmurach/tty-color
+
+ - [ ] support drawing using morse unicodes like blessed-contrib
+
+ - [x] image rendering - see probes/pngProbe.rb using chunky_png
+   - [x] add renderer.image
+   - [x] improve perf by pre-reading pixels in memory?
+   - [x] try not to use binary dependencies like RMagick:  https://github.com/nodanaonlyzuul/asciiart/blob/master/asciiart.gemspec - this other project is not so old also rely on rmagick https://github.com/nathanpc/ascii-image -  also this https://github.com/pazdera/catpix
+   - [x] pure ruby https://github.com/wvanbergen/chunky_png maintained project - see https://github.com/wvanbergen/chunky_png/blob/master/spec/chunky_png/canvas_spec.rb -
+   - [x] alpha channel ? currently totally ignored - solution : mix fg and bg according with alpha(bg given by user) - maybe this could be handled by tco/colouring and not Image
+      - [ ] currently getting bg color using final_style or parent.final_style but is not correct - we should use renderer.buffer!
+   - [x] a simple image slider widget for demos - auto-resize large images to feet screen first - arrows to switch
+   - [ ] support ascii art chars like ? currently only printing fixed ch
+   - [w] set_pixel, rect, circle, poly, blezier, rotate, trim
+     - [x] screen.circle()
+   - [x] an ImageWidget - auto resize img to given dims - or viceversa, set widget bounds to fit given image size.
+     - [x] support render cache / dirty - just store print() and write it back - this should be done at renderer/nodes
+   - [x] use local imagemagick to support other formats than png
+   - [ ] use local imagemagick to render fonts
+
+ - [w] text rendering - use this : https://github.com/piotrmurach/strings#21-align
+   - [x] line wrap
+   - [ ] some kind of language so is easy to write stuff with attributes / colors like blessed has - or markdown-like syntax... `<red,bold,underline>Title</>` etc... 
+   - [ ] use https://github.com/piotrmurach/strings for align and more sine supports unicode and ansi. 
+   - [ ] use https://github.com/piotrmurach/strings also for line wrap and remove current impl.
+   - [ ] justified, https://rubydoc.info/gems/justify
+   - [x] left
+   - [ ] right, center (any gem for this?) https://github.com/piotrmurach/strings
+   - [ ] node.text_children or all_text - returns this node text plus all its children text recursively in children order (useful for testing)
+
+ - [w] idea: canvas drawing taking advantage of chunky_png Canvas class  bleziers, resize, rotate, ellipse, etc. Example: draw bleziers in png canvas with transparent bg and only render fg.
+
+ - [ ] fix duplicated Event class ... see emitter.rb : " this is the same as event.rb Event. Move Event classes to individual - non dependency file"
+
+ - [w] easing/animations : adapt formulas from accursed project - see src/util/easing.rb
+
+ - [w] npm.org/inquirer like apis - see /inquirer
+ 
+ - [ ] promise like apis : `screen.wait_for(predicate1).then(proc {screen.wait_for(predicate2)}).then(verb2).catch(proc {|error|p error})` - right now is callback hell :(
+     - [x] Could RUby's then() help here ? ANSWER: NO
+   - [ ] based on our own event loop? or could we use a gem like concurrency? update - currently supporting method block which is similar ?
+
+ - [w] element query cssish query support : `element.queryAll '[a="b"] .item > add-button'`
+   - [x] query_by_attribute, query_one_by_attribute
+   - [x] CSS like language parser
+   - [ ] query engine based on css like language below. 
+   - [ ] stylesheets CSS like for declare styles. Can we use ruby based language instead of CSSish ? 
+
+   
+### Done
+ - [x] fixed border and box model
+ - [x] wait_for/when : `screen.when( proc {element.query_one_by_attribute 'progress', 'ready'}, proc { print 'done' })`
+ - [x] issue when pipe to file, i.e. ruby a_screen_start_app.rb > file.txt `screen.rb:22:in winsize': Inappropriate ioctl for device (Errno::ENOTTY)`
+ - [x] renderer.buffer disabled by default (faster) - Screen.new_for_testing will enable buffer and silent screen.
+ - [x] renderer methods accepts style and always print "closed" styled strings.
+ - [w] Layouts
+   - [x] So I don't need to specify element bounds: `col = Col.new; top = Row.new(height: 9,4); bottom= Row.new(height: 0.6); col.append_child(top, bottom)`
+ - [x] text-box - how to lock focus ? how to implement the text-input experience ? WIP see src/widget/textbox
+ - [w] set_timeout, set_interval
+   - [x] separate input@set_timeout in a module
+   - [x] support set_interval correctly - test it
+ - [x] cli-driver for testing interactions / see probes/pty*
+   - [x] waitForData
+ - [x] change camelCase to snake_case
+ - [x] rubocop
+ - [x] styled box drawing to string
+ - [x] review callback's api and use yield, examples: `s.set_timeout(0.5){ p 'after'}` , `client.wait_for(proc { @ready }){ |timeout| p 'finished' unless timeout } ` - is it possible for set_timeout ? 
+ - [x] element border using boxes 
+     - [x] (box model different than html). 
+     - [x] 1-size border support only. 
+     - [x] border is a style on its own that by default equals its element's style.
+ - [x] element's padding
+ - [x] input.grab / ungrab
+ - [x] focus manager
+
+- [x] put everything inside module TermGui
+  - [x] group widget hight -level in TermGui::Widget 
+  - [x] an export * file - see termgui.rb
+   
+ - [x] Keys : test support for key-names 
+   - [x] test names - enter, left,up, right down, escape
+   - [x]  test complex (C-x, S-C-right, escape, tab, etc) : `s.add_key_listener('S-C-right', proc {|ev|p 123})`
+
+
+### Editor TODO
+
+I didn't saw this implemented in similar libraries like tty-reader, vedeu or shopify-cli ( tty-reader mentions multiline editor bur is not this...  this is like terminal prompt - not text area) 
+
+Current status: implements a text area supporting configurable set of keys arrows, enter, backspace, delete, home, end, next-page, prev-page, tab, shift-tab. The basics are there, a text area could be implemented currently easily. 
+
+
+But what about a "real world" editor and which feature should be responsibility of this library?
+
+* should this be in a separate project ? 
+
+* filesystem
+
+* selection  : shift arrows, shift-end,  C-a, etc
+  * this impacts on handle_keys since if there's a selection, 
+    * modifications will replace the selection. 
+    * arrows - navigation changes semantics
+
+* basic text buffer - TextChange, span, etc this will enable:
+  * undo-redo 
+  * change notifications
+  * big buffers
+
+* clipboard ? system clipboard ? 
+
+* MISSING KEYS: shift-tab, home, end, next-page, prev-page - these are not supported in keys currently
+
+* scrolling for lines outside area
+  * alternatively implement word wrap -
+  * ideally we want both (toggle word wrap)
+  * right now text is truncated on the right and bottom.
+
+* configurable key-shortcuts - ideally we should be able to move, scroll, undo, redo, copy, etc a-la-vim with just config
+
+* UX we will need to ESCAPE to activate menus - like vim... or should we support complex key-shortcuts like emacs?
+  * ideally I want a menu that is activated with escape . escape or action to enter in the editor... 
+  * in the future other widgets like folder explorer can be escape-tab to focus escape-tab enter to enter the editor again ? or the menu? like blessed/blessed-based-editor...
+
+* file chooser - save/load files visually
+* projects:
+  * multiple buffers (tabs?) opened
+  * file explorer - tree showing a folder allowing opening files - some actions like remove , rename, move ? visually!
+    * implies kind of MVC - an open file renamed
+
+#### current editor_base implementation todo
+
+  *  TODO: maybe is better to extend Element and use its coords and root_screen? or have a CursorElement or EnterableElement with cursor stuff? Maybe also move all this to a module instead of class
+    *  x, y accessors should support percents - or we should just call abs_content_x, etc
+    *  enable() should be called on_enter, disable() on_blur or on_escape
+    *  render() should call super and compatible with element
+    *  width, height - currently will print stuff outside screen 
+      * line break - word wrap ? 
+      *   if no linebreak then we need a viewport for "scrolling" - if not is not usable for a text editor (can we leave this reponsibility to container Element - don't think so - another reason to make this an Element?)
+
+  *  won't work for tab (currently hacking) and unicode chars width != 1
+  
+
+#### editor plan
+
+ * implement editor API only nothing visual but the text area: