reterm 0.4.2 → 0.5.0

data/lib/reterm/mixins/nav_controls.rb

@@ -0,0 +1,33 @@
+module RETerm
+  module NavControls
+    # Key which if pressed causes the navigation component
+    # to lose focus / become deactivated
+    QUIT_CONTROLS  = [27] # 27 = ESC
+
+    # Key if pressed focuses on / activates a component
+    ENTER_CONTROLS = [10, Ncurses::KEY_ENTER] # 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]
+
+    # All movement keys
+    MOVEMENT_CONTROLS = UP_CONTROLS   + DOWN_CONTROLS +
+                        LEFT_CONTROLS + RIGHT_CONTROLS
+
+    # Quit when quit-sequence detected or app-shutdown
+    def quit_nav?(ch=nil)
+      (!ch.nil? && QUIT_CONTROLS.include?(ch) || shutdown? || deactivate?)
+    end
+  end # module NavControls
+end # module RETerm

data/lib/reterm/mixins/nav_input.rb

@@ -5,30 +5,20 @@ module RETerm
   # 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
+    include MouseInput
+    include NavControls
 
-    # Key if pressed focuses on / activates a component
-    ENTER_CONTROLS = [10] # 10 = enter , space
+    # Used internally to specify component
+    # which we should navigate to
+    attr_accessor :nav_select
 
-    # 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]
+    # Used internally to specify which movement
+    # command we should follow
+    attr_accessor :ch_select
 
     # Return children which are focusabled/activable
     def focusable
-      children.select { |c| c.component.activatable? }
+      children.select { |c| c.activatable? }
     end
 
     # Return boolean indicating if any children are focusable
@@ -36,91 +26,193 @@ module RETerm
       !focusable.empty?
     end
 
+    # May be overridden by subclass to indicate if the
+    # specified input / context is valid
+    def valid_input?(ch, from_parent)
+      true
+    end
+
     # Helper to be internally invoked by navigation component
     # on activation
     def handle_input(from_parent=false)
       @focus ||= 0
 
-      ch = handle_focused
+      # focus on first component
+      ch = handle_focused unless nav_select
 
-      while(!QUIT_CONTROLS.include?(ch))
-        if ENTER_CONTROLS.include?(ch)
-          focused.activate!
+      # Repeat until quit
+      until quit_nav?(ch)
 
-        elsif UP_CONTROLS.include?(ch)
-          focused.no_border!
+        # Navigate to the specified component (nav_select)
+        if self.nav_select 
+          # it is a descendent of this one
+          if self.contains?(self.nav_select)
+            nav_to_selected
 
-          return ch if window.component.is_a?(Layouts::Horizontal) &&
-                       from_parent &&
-                       !window.parent.children.index(window) != 0
+          # specified component is not a descendent,
+          else
+            nav_to_parent
+            return nil
+          end
 
-          @focus -= 1
+        elsif ENTER_CONTROLS.include?(ch)
+          focused.activate!
 
-        elsif LEFT_CONTROLS.include?(ch)
-          focused.no_border!
+        elsif MOVEMENT_CONTROLS.include?(ch)
+          handle_movement(ch, from_parent)
 
-          return ch if window.component.is_a?(Layouts::Vertical) &&
-                       from_parent &&
-                       !window.parent.children.index(window) != 0
+        elsif mev = process_mouse(ch)
+          handle_mouse(mev)
 
-          @focus -= 1
+        else
+          dispatch(:entry, ch)
 
-        elsif DOWN_CONTROLS.include?(ch)
-          focused.no_border!
+        end
 
-          return ch if window.component.is_a?(Layouts::Horizontal) &&
-                       from_parent &&
-                       !window.parent.children.index(window) != (window.parent.children.size - 1)
+        return ch unless sanitize_focus!(from_parent)
+        ch = handle_focused unless nav_select ||
+                                   shutdown?  ||
+                                   deactivate?
+      end
 
-          @focus += 1
+      ch
+    end
 
-        elsif RIGHT_CONTROLS.include?(ch)
-          focused.no_border!
+    private
 
-          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
+    def handle_movement(ch, from_parent)
+      remove_focus
+      return ch unless valid_input?(ch, from_parent)
+      @focus = next_focus(ch)
+    end
 
-        if @focus < 0
-          @focus = 0
-          return ch if from_parent
-        end
+    def next_focus(ch)
+      if UP_CONTROLS.include?(ch) ||
+         LEFT_CONTROLS.include?(ch)
+        @focus - 1
 
-        ch = handle_focused
+      elsif DOWN_CONTROLS.include?(ch) ||
+            RIGHT_CONTROLS.include?(ch)
+        @focus + 1
       end
-
-      ch
     end
 
-    private
-
     def focused
+      return nil unless !!@focus
       focusable[@focus]
     end
 
+    def draw_focus!
+      focused.window.border! if !!focused && focused.highlight_focus?
+    end
+
+    # Internal help, set the visual properties of the focused window
+    def update_focus
+      draw_focus!
+      update_reterm
+      window.root.draw!
+    end
+
+    # Internal helper, logic invoked when a component gains focus
     def handle_focused
       ch = nil
 
-      focused.border! unless focused.component.kind_of?(Layout)
-      update_reterm
-      window.draw!
+      focused.dispatch :focused
+      update_focus
 
-      if focused.component.kind_of?(Layout)
-        ch = focused.component.handle_input(true)
+      if focused.activate_focus?
+        focused.activate!
 
-      else
-        ch = window.getch
+      elsif focused.kind_of?(Layout)
+        ch = focused.handle_input(true)
+
+      elsif !deactivate? && !nav_select
+        ch = sync_getch
+      end
+
+      if self.ch_select
+        ch = self.ch_select
+        self.ch_select = nil
       end
 
       ch
     end
+
+    # Internal helper, logic invoked when a component loses focus
+    def remove_focus
+      focused.window.no_border!
+      focused.dispatch :unfocused
+    end
+
+    # Internal helper, navigate to selected component under current
+    def nav_to_selected
+      # clear nav_select
+      ns = self.nav_select
+      self.nav_select = nil
+
+      # specified component is a direct child
+      if self.children.include?(ns)
+        remove_focus
+        @focus = focusable.index(ns)
+        #handle_focused
+        #update_focus
+        #focused.activate!
+
+      # not a direct child, navigate down to layout
+      # containing it
+      else
+        child = self.layout_containing(ns)
+        child.nav_select = ns
+        ch = child.handle_input(true)
+      end
+    end
+
+    # Internal helper, navigate to selected component up heirarchy
+    def nav_to_parent
+      # set selected component on the parent,
+      # clear it locally, and
+      # return to parent
+      remove_focus
+      ns = self.nav_select
+      self.nav_select =  nil
+      self.parent.nav_select = ns
+    end
+
+    # Internal helper, sanitize the focus tracker.
+    # Return value indicates if sanity is preseved
+    # in the context of this component (else we will
+    # return to parent)
+    def sanitize_focus!(from_parent)
+      if @focus >= focusable.size
+        @focus = focusable.size - 1
+        return false if from_parent
+
+      elsif @focus < 0
+        @focus = 0
+        return false if from_parent
+      end
+
+      true
+    end
+
+    def handle_mouse(mev)
+      child = window.root.child_containing(mev.x, mev.y, mev.z)
+
+      if child
+        child = child.component
+
+        if child.activatable?
+          if self.contains?(child)
+            nav_to_selected
+
+          else
+            self.nav_select = child
+            nav_to_parent
+            return nil
+          end
+        end
+      end
+    end
   end # module NavInput
 end # module RETerm

data/lib/reterm/terminal.rb

@@ -24,10 +24,14 @@ module RETerm
       dimensions[0]
     end
 
+    def self.contains?(r, c)
+      r < rows && c < cols
+    end
+
     def self.resize!
       Window.top.each { |w|
         w.dispatch :resize
       }
     end
-  end
-end # module Terminal
+  end # class Terminal
+end # module RETerm

data/lib/reterm/util.rb

@@ -0,0 +1,121 @@
+module RETerm
+  # Helper returning boolean indicating if specified process is alive
+  def process_alive?(pid)
+    begin
+      Process.getpgid( pid )
+      true
+    rescue Errno::ESRCH
+      false
+    end
+  end
+
+  ANSI_COLORS = {
+         1 => :bold,
+        30 => :black,
+        31 => :red,
+        32 => :green,
+        33 => :yellow,
+        34 => :blue,
+        35 => :magenta,
+        36 => :cyan,
+        37 => :white,
+
+        # XXX techincally the 'bright' variations
+        90 => :black,
+        91 => :red,
+        92 => :green,
+        93 => :yellow,
+        94 => :blue,
+        95 => :magenta,
+        96 => :cyan,
+        97 => :white,
+  }
+
+  # Converts specified ansi string to array
+  # of character data & corresponding control
+  # logic
+  def parse_ansi(str)
+    require 'strscan'
+
+    r = []
+    f = []
+    t = []
+
+    a = nil
+    s = StringScanner.new(str)
+
+    while(!s.eos?)
+      # end of formatting
+      if s.scan(/(\e|\[)\[0m/)
+        t << f.pop
+        t.compact!
+        if f.empty?
+          r << [a, t]
+          t = []
+          a = nil
+        end
+
+      # basic formatter
+      elsif s.scan(/\e\[(3[0-7]|90|1)m/)
+        # FIXME need to register formatting for 'a'
+        # up to this point (and reset 'a') (and below)
+        f << ANSI_COLORS[s[1].to_i]
+
+      # sgr
+      # https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters
+      elsif s.scan(/\e\[(([0-9]+;?)+)m/)
+        sgr = s[1].split(";").collect { |s| s.to_i }
+        f << if (30..37).include?(sgr[0])
+               ANSI_COLORS[sgr[1]]
+
+             elsif sgr[0] == 38
+               if sgr[1] == 5
+                if sgr[2] < 8
+                  ANSI_COLORS[sgr[2]]
+
+                elsif sgr[2] < 16
+                  ANSI_COLORS[sgr[2]]
+
+                elsif sgr[2] < 232
+                  # TODO verify:
+                  # https://stackoverflow.com/questions/12338015/converting-8-bit-color-into-rgb-value
+                  re = (sgr[2] >> 5) * 32
+                  gr = ((sgr[2] & 28) >> 2) * 32
+                  bl = (sgr[2] & 3) * 64
+                  [re, gr, bl]
+
+                else # if srg[2] < 256
+                  # TODO
+                end
+
+               else # if sgr[1] == 2
+                 # TODO
+               end
+
+               # TODO other sgr commands
+             end
+
+      else
+        a  = "" if a.nil?
+        a += s.scan(/./m)
+
+      end
+    end
+
+
+    # handle remaining / lingering data
+    r << [a, (t + f).compact] unless f.empty?
+
+    r
+  end
+
+  # Helper appending string to debug file
+  def file_append(f, t)
+    File.open(f, "a") { |f| f.write t }
+  end
+
+  # Flushes all input queues
+  def flush_input
+    Ncurses.flushinp
+  end
+end # module RETerm