reterm 0.4.2

data/lib/reterm/layout.rb

@@ -0,0 +1,63 @@
+module RETerm
+  # Provides mechanism to orgranize on screen components according
+  # to rules defined by subclasses.
+  #
+  # Layouts themselves are specialized types of components as they
+  # are intended to be associated with windows in which to be rendered
+  class Layout < Component
+    include NavInput
+
+    # TODO padding / margin support
+
+    attr_accessor :children
+
+    def initialize(args={})
+      @children ||= []
+    end
+
+    # Subclasses should override this method returning
+    # boolean if child window exceeds bounds of layout
+    def exceeds_bounds?(child)
+      raise "NotImplemented"
+    end
+
+    # Return boolean indicating if any child component
+    # is activatable
+    def activatable?
+      children.any? { |c| c.component.activatable? }
+    end
+
+    # Create new child window and add it to layout
+    def add_child(h={})
+      child = window.create_child(h)
+
+      if child.win.nil?
+        raise ArgumentError, "could not create child window"
+      end
+
+      if exceeds_bounds?(child)
+        window.del_child(child) unless child.win.nil?
+        raise ArgumentError, "child exceeds bounds"
+      end
+
+      children << child
+      update_reterm
+      child
+    end
+
+    # Draw all layout children
+    def draw!
+      children.each { |c| c.draw! }
+    end
+
+    # Activates layout by dispatching to navigation
+    # input system.
+    #
+    # @see NavInput
+    def activate!
+      draw!
+      update_reterm
+      handle_input
+    end
+  end # class Layout
+end # module RETerm

data/lib/reterm/layouts.rb

@@ -0,0 +1,16 @@
+module RETerm
+  # Encapsulates all Layouts currently implemented
+  module Layouts
+    def self.all
+      @a ||= Layouts.constants
+    end
+
+    def self.names
+      @n ||= all.collect { |l| l.to_s }
+    end
+  end
+end
+
+require 'reterm/layout'
+require 'reterm/layouts/horizontal'
+require 'reterm/layouts/vertical'

data/lib/reterm/layouts/horizontal.rb

@@ -0,0 +1,19 @@
+module RETerm
+  module Layouts
+    # Layout which arrainges items horizontally across screen cols
+    class Horizontal < Layout
+      def current_cols
+        children.sum { |c| c.cols } + 1
+      end
+
+      def exceeds_bounds?(child)
+        child.rows > window.rows || (current_cols + child.cols) > window.cols
+      end
+
+      def add_child(h={})
+        # set x/y to next appropriate location
+        super(h.merge(:y => 1, :x => current_cols))
+      end
+    end # class Horizontal
+  end # module Layouts
+end # module RETerm

data/lib/reterm/layouts/vertical.rb

@@ -0,0 +1,19 @@
+module RETerm
+  module Layouts
+    # Layout which arrainges items vertically down screen rows
+    class Vertical < Layout
+      def current_rows
+        children.sum { |c| c.rows } + 1
+      end
+
+      def exceeds_bounds?(child)
+        child.cols > window.cols || (current_rows + child.rows) > window.rows
+      end
+
+      def add_child(h={})
+        # set x/y to next appropriate location
+        super(h.merge(:y => current_rows, :x => 1))
+      end
+    end # class Horizontal
+  end # module Layouts
+end # module RETerm

data/lib/reterm/loader.rb

@@ -0,0 +1,126 @@
+module RETerm
+  # JSON schema loader, instantiates RETerm subsystem from schema
+  # stored in a JSON string. Currently this schema does not have a
+  # formal definition, but see examples/ for what can currently be
+  # done.
+  class Loader
+    # Initialie new loader from JSON string
+    def initialize(str)
+      require 'json'
+      parse_doc(str)
+    end
+
+    # Return top level window in loader
+    def window
+      @win
+    end
+
+    private
+
+    def parse_doc(str)
+      @j = JSON.parse(str)
+
+      raise ArgumentError unless @j.is_a?(Hash)
+      raise ArgumentError unless @j.key?("window")
+
+      parse_colors(@j['colors']) if @j.key?('colors')
+
+      @win = parse_win(@j['window'])
+      update_reterm
+    end
+
+    def parse_colors(colors)
+      raise ArgumentError unless colors.is_a?(Array)
+      colors.each { |c|
+        raise ArgumentError unless c.is_a?(Array) && c.size >= 3
+        ColorPair.register(*c)
+      }
+    end
+
+    def parse_win(win)
+      raise ArgumentError unless win.is_a?(Hash)
+
+      args = {}
+
+      args[:rows] = win['rows'] if win.key?('rows')
+      args[:cols] = win['cols'] if win.key?('cols')
+
+      w = Window.new args
+      parse_child(w, win)
+
+      w.border! if win.key?('border') && !!win['border']
+      w.colors = ColorPair.for(win['colors']) if win.key?('colors')
+
+      w
+    end
+
+    def parse_child(win, parent)
+      raise ArgumentError if  parent.key?('component') &&  parent.key?('layout')
+      raise ArgumentError if !parent.key?('component') && !parent.key?('layout')
+
+      if parent.key?('component')
+        parse_component win, parent['component']
+
+      else # if parent.key?('layout')
+        parse_layout win, parent['layout']
+      end
+    end
+
+    def prep_init(init)
+      raise ArgumentError unless init.is_a?(Hash)
+      init = Hash[init] # make copy
+
+      init.keys.each { |k|
+        init[k.intern] = init[k] # XXX unsafe intern
+        init.delete(k)
+      }
+
+      init
+    end
+
+    def parse_component(win, c)
+      raise ArgumentError unless c.is_a?(Hash)
+      raise ArgumentError unless c.key?("type") ||
+                                !Components.names.include?(c["type"])
+
+      init = c.key?("init") ? prep_init(c["init"]) : {}
+      c = RETerm::Components.const_get(c["type"]).new(init)
+      win.component = c
+      c
+    end
+
+    def parse_layout(win, l)
+      raise ArgumentError unless l.is_a?(Hash)
+      raise ArgumentError unless l.key?("type") ||
+                                !Layouts.names.include?(l["type"])
+
+      init = l.key?("init") ? prep_init(l["init"]) : {}
+      lc = RETerm::Layouts.const_get(l["type"]).new(init)
+      win.component = lc
+      parse_layout_children(lc, l["children"]) if l.key?("children")
+      lc
+    end
+
+    def parse_layout_children(l, children)
+      raise ArgumentError unless children.is_a?(Array)
+
+      children.each { |child|
+        raise ArgumentError unless child.is_a?(Hash)
+        rows = child['rows'] if child.key?('rows')
+        cols = child['cols'] if child.key?('cols')
+
+        cw = l.add_child :rows => rows,
+                         :cols => cols
+
+        cw.border! if child.key?('border') && !!child['border']
+        cw.colors = ColorPair.for(child['colors']) if child.key?('colors')
+
+        cw.component = parse_child(cw, child)
+      }
+    end
+  end # class Loader
+
+  def load_reterm(str)
+    Loader.new(str).window
+  end
+end # module RETerm

data/lib/reterm/menu.rb

@@ -0,0 +1,81 @@
+module RETerm
+  # Graphical menu rendered on screen
+  #
+  # TODO: look into working this into std component/activation subsystem
+  class Menu
+    include EventDispatcher
+
+    attr_accessor :window
+
+    # Menus should be instantiated with a hash of label/value
+    # pairs to assign to menu
+    def initialize(items={})
+      @items = items
+      @menu  = Ncurses::Menu.new_menu(items.collect { |k,v|
+                 Ncurses::Menu.new_item(k.to_s, v.to_s)
+               })
+
+      @menu.menu_opts_off(Ncurses::Menu::O_SHOWDESC)
+    end
+
+    # Return number of rows in menu
+    def rows
+      @items.size
+    end
+
+    # Return number of cols in menu
+    def cols
+      @cols ||= @items.keys.max { |k| k.size }.size + 3
+    end
+
+    # Attach menu to specified window
+    def attach_to(win)
+      @menu.set_menu_win(win.win)
+      win.component = self
+
+      @child_win = win.create_child :rows => rows,
+                                    :cols => cols,
+                                    :x => 1, :y => 1
+      @menu.set_menu_sub(@child_win.win)
+      @menu.post_menu
+
+      self
+    end
+
+    # Destroy menu subsystem
+    def detach
+      @menu.unpost_menu
+    end
+
+    def finalize!
+    end
+
+    # Static map of menu drivers to internal representations.
+    #
+    # XXX defined here (as opposed to a const) since these
+    # consts won't be available until after init_scr
+    def driver_map
+      @driver_map ||= {
+        :left          => Ncurses::Menu::REQ_LEFT_ITEM,
+        :right         => Ncurses::Menu::REQ_RIGHT_ITEM,
+        :up            => Ncurses::Menu::REQ_UP_ITEM,
+        :down          => Ncurses::Menu::REQ_DOWN_ITEM,
+        :scr_up_line   => Ncurses::Menu::REQ_SCR_ULINE,
+        :scr_down_line => Ncurses::Menu::REQ_SCR_DLINE,
+        :scr_down_page => Ncurses::Menu::REQ_SCR_DPAGE,
+        :scr_up_page   => Ncurses::Menu::REQ_SCR_UPAGE,
+        :first         => Ncurses::Menu::REQ_FIRST_ITEM,
+        :last          => Ncurses::Menu::REQ_LAST_ITEM,
+        :next          => Ncurses::Menu::REQ_NEXT_ITEM,
+        :prev          => Ncurses::Menu::REQ_PREV_ITEM,
+        :toggle        => Ncurses::Menu::REQ_TOGGLE_ITEM
+      }
+    end
+
+    # Drive menu from input
+    def drive(i)
+      i = driver_map[i] if i.is_a?(Symbol)
+      Ncurses::Menu.menu_driver(@menu, i)
+    end
+  end # class Menu
+end # module RETerm

data/lib/reterm/mixins/cdk_component.rb

@@ -0,0 +1,45 @@
+module RETerm
+  # Mixin used by CDK based component defining cdk-specific helpers
+  module CDKComponent
+    # Should be implemented in subclass to initialize component
+    def _component
+      raise "NotImplemented"
+    end
+
+    # Return completely initialized CDK component
+    def component
+      enable_cdk!
+      @component ||= begin
+        c = _component
+        c.setBackgroundColor("</#{@colors.id}>") if colored?
+        c
+      end
+    end
+
+    # Assign {ColorPair} to component
+    def colors=(c)
+      super
+      component.setBackgroundColor("</#{@colors.id}>")
+    end
+
+    # Invoke CDK draw routine
+    def draw!
+      component.draw([])
+    end
+
+    # CDK components may be activated
+    def activatable?
+      true
+    end
+
+    # Invoke CDK activation routine
+    def activate!
+      component.activate([])
+    end
+
+    # Return stored value of cdk component
+    def value
+      component.getValue
+    end
+  end # module CDKComponent
+end # module RETerm

data/lib/reterm/mixins/component_input.rb

@@ -0,0 +1,37 @@
+module RETerm
+  # Helper mixin defining standard input controls for custom
+  # components. 'In House' components included in the project
+  # may used this to standarding their usage.
+  module ComponentInput
+    # Key which if pressed cause the component to
+    # lose focus / become deactivated
+    QUIT_CONTROLS = [10, 27] # 10 = enter, 27 = ESC
+
+    # Keys if pressed invoked the increment operation
+    INC_CONTROLS  = ['+'.ord, Ncurses::KEY_UP, Ncurses::KEY_RIGHT]
+
+    # Keys if pressed invoked the decrement operation
+    DEC_CONTROLS  = ['-'.ord, Ncurses::KEY_DOWN, Ncurses::KEY_LEFT]
+
+    # May be overrideen in subclass, invoked when the user requests
+    # an 'increment'
+    def on_inc
+    end
+
+    # May be overrideen in subclass, invoked when the user
+    # requests a decrement
+    def on_dec
+    end
+
+    # Helper to be internally invoked by component on activation
+    def handle_input
+      while(!QUIT_CONTROLS.include?((ch = window.getch)))
+        if INC_CONTROLS.include?(ch)
+          on_inc
+        elsif DEC_CONTROLS.include?(ch)
+          on_dec
+        end
+      end
+    end
+  end # module ComponentInput
+end # module RETerm

data/lib/reterm/mixins/event_dispatcher.rb

@@ -0,0 +1,20 @@
+module RETerm
+  # Helper mixin defining methods to register event
+  # handlers and dispatch events. Events are simply
+  # composed parameters which are passed to the
+  # callback blocks when dispatched
+  module EventDispatcher
+    def dispatch(e, h={})
+      @event_handlers ||= {}
+      @event_handlers[e].each { |eh|
+        eh.call h
+      } if @event_handlers.key?(e)
+    end
+
+    def handle(e, &bl)
+      @event_handlers    ||= {}
+      @event_handlers[e] ||= []
+      @event_handlers[e]  << bl
+    end
+  end # module EventDispatcher
+end # module RETerm

data/lib/reterm/mixins/nav_input.rb

@@ -0,0 +1,126 @@
+module RETerm
+  # Helper mixin defining standard navigation controls.
+  # Used by layouts and top level components this tightly
+  # defines keyboard navigation and allows the user to
+  # seemlessly move between and activate/decativate
+  # components.
+  module NavInput
+    # Key which if pressed causes the navigation component
+    # to lose focus / become deactivated
+    QUIT_CONTROLS  = [27, 'q'.ord, 'Q'.ord] # 27 = ESC
+
+    # Key if pressed focuses on / activates a component
+    ENTER_CONTROLS = [10] # 10 = enter , space
+
+    # Up navigation keys
+    UP_CONTROLS    = ['k'.ord, 'K'.ord, Ncurses::KEY_UP]
+
+    # Down navigation keys
+    DOWN_CONTROLS  = ['j'.ord, 'J'.ord, Ncurses::KEY_DOWN]
+
+    # Left navigation keys
+    LEFT_CONTROLS  = ['h'.ord, 'H'.ord, Ncurses::KEY_BACKSPACE,
+                                        Ncurses::KEY_BTAB,
+                                        Ncurses::KEY_LEFT]
+
+    # Right navigation keys
+    RIGHT_CONTROLS = ['l'.ord, 'L'.ord, "\t".ord, Ncurses::KEY_RIGHT]
+
+    # Return children which are focusabled/activable
+    def focusable
+      children.select { |c| c.component.activatable? }
+    end
+
+    # Return boolean indicating if any children are focusable
+    def focusable?
+      !focusable.empty?
+    end
+
+    # Helper to be internally invoked by navigation component
+    # on activation
+    def handle_input(from_parent=false)
+      @focus ||= 0
+
+      ch = handle_focused
+
+      while(!QUIT_CONTROLS.include?(ch))
+        if ENTER_CONTROLS.include?(ch)
+          focused.activate!
+
+        elsif UP_CONTROLS.include?(ch)
+          focused.no_border!
+
+          return ch if window.component.is_a?(Layouts::Horizontal) &&
+                       from_parent &&
+                       !window.parent.children.index(window) != 0
+
+          @focus -= 1
+
+        elsif LEFT_CONTROLS.include?(ch)
+          focused.no_border!
+
+          return ch if window.component.is_a?(Layouts::Vertical) &&
+                       from_parent &&
+                       !window.parent.children.index(window) != 0
+
+          @focus -= 1
+
+        elsif DOWN_CONTROLS.include?(ch)
+          focused.no_border!
+
+          return ch if window.component.is_a?(Layouts::Horizontal) &&
+                       from_parent &&
+                       !window.parent.children.index(window) != (window.parent.children.size - 1)
+
+          @focus += 1
+
+        elsif RIGHT_CONTROLS.include?(ch)
+          focused.no_border!
+
+          return ch if window.component.is_a?(Layouts::Vertical) &&
+                       from_parent &&
+                       !window.parent.children.index(window) != (window.parent.children.size - 1)
+
+          @focus += 1
+        end
+
+        if @focus >= focusable.size
+          @focus = focusable.size - 1
+          return ch if from_parent
+        end
+
+        if @focus < 0
+          @focus = 0
+          return ch if from_parent
+        end
+
+        ch = handle_focused
+      end
+
+      ch
+    end
+
+    private
+
+    def focused
+      focusable[@focus]
+    end
+
+    def handle_focused
+      ch = nil
+
+      focused.border! unless focused.component.kind_of?(Layout)
+      update_reterm
+      window.draw!
+
+      if focused.component.kind_of?(Layout)
+        ch = focused.component.handle_input(true)
+
+      else
+        ch = window.getch
+      end
+
+      ch
+    end
+  end # module NavInput
+end # module RETerm