reterm 0.4.2 → 0.5.0

data/lib/reterm/layouts/horizontal.rb

@@ -1,19 +1,40 @@
 module RETerm
   module Layouts
-    # Layout which arrainges items horizontally across screen cols
+    # Layout which arainges items horizontally across screen cols
     class Horizontal < Layout
+      def current_rows
+        return 1 if empty?
+        child_windows.max { |w1, w2| w1.rows <=> w2.rows }.rows
+      end
+
       def current_cols
-        children.sum { |c| c.cols } + 1
+        return 1 if empty?
+        child_windows.sum { |c| c.cols } + 1
       end
 
-      def exceeds_bounds?(child)
-        child.rows > window.rows || (current_cols + child.cols) > window.cols
+      def exceeds_bounds_with?(child)
+        rows = child.is_a?(Hash) ?
+               [current_rows, child[:rows]].compact.max :
+               [current_rows, child.rows].max
+
+        cols = child.is_a?(Hash) ?
+          current_cols + child[:cols] :
+          current_cols + child.cols
+
+        rows > window.rows ||
+        cols > window.cols
       end
 
       def add_child(h={})
         # set x/y to next appropriate location
         super(h.merge(:y => 1, :x => current_cols))
       end
+
+      def valid_input?(ch, from_parent)
+        return true unless from_parent
+        !((UP_CONTROLS.include?(ch)   && window.first_child?) ||
+          (DOWN_CONTROLS.include?(ch) && window.last_child?))
+      end
     end # class Horizontal
   end # module Layouts
 end # module RETerm

data/lib/reterm/layouts/vertical.rb

@@ -1,19 +1,40 @@
 module RETerm
   module Layouts
-    # Layout which arrainges items vertically down screen rows
+    # Layout which arainges items vertically down screen rows
     class Vertical < Layout
       def current_rows
-        children.sum { |c| c.rows } + 1
+        return 1 if empty?
+        child_windows.sum { |c| c.rows } + 1
       end
 
-      def exceeds_bounds?(child)
-        child.cols > window.cols || (current_rows + child.rows) > window.rows
+      def current_cols
+        return 1 if empty?
+        child_windows.max { |w1, w2| w1.cols <=> w2.cols }.cols
+      end
+
+      def exceeds_bounds_with?(child)
+        cols = child.is_a?(Hash) ?
+               [current_cols, child[:cols]].compact.max :
+               [current_cols, child.cols].max
+
+        rows = child.is_a?(Hash) ?
+          current_rows + child[:rows] :
+          current_rows + child.rows
+
+        cols > window.cols ||
+        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
+
+      def valid_input?(ch, from_parent)
+        return true unless from_parent
+        !((LEFT_CONTROLS.include?(ch) && window.first_child?) ||
+         (RIGHT_CONTROLS.include?(ch) && window.last_child?))
+      end
+    end # class Vertical
   end # module Layouts
 end # module RETerm

data/lib/reterm/loader.rb

@@ -49,7 +49,7 @@ module RETerm
       parse_child(w, win)
 
       w.border! if win.key?('border') && !!win['border']
-      w.colors = ColorPair.for(win['colors']) if win.key?('colors')
+      w.colors = ColorPair.for(win['colors']).first if win.key?('colors')
 
       w
     end
@@ -113,7 +113,7 @@ module RETerm
                          :cols => cols
 
         cw.border! if child.key?('border') && !!child['border']
-        cw.colors = ColorPair.for(child['colors']) if child.key?('colors')
+        cw.colors = ColorPair.for(child['colors']).first if child.key?('colors')
 
         cw.component = parse_child(cw, child)
       }

data/lib/reterm/mixins/button_helpers.rb

@@ -0,0 +1,7 @@
+module RETerm
+  module ButtonHelpers
+    def total_button_size
+      @buttons.sum { |b| b.size }
+    end
+  end # module ButtonHelpers
+end # module RETerm

data/lib/reterm/mixins/cdk_component.rb

@@ -1,6 +1,20 @@
 module RETerm
   # Mixin used by CDK based component defining cdk-specific helpers
   module CDKComponent
+    def init_cdk(args={})
+      self.title_attrib = args[:title_attrib] if args.key?(:title_attrib)
+    end
+
+    def title_attrib=(a)
+      @title_attrib = a
+      component.title_attrib = a if defined?(@component)
+    end
+
+    # Boolean indicating this component is a cdk component
+    def cdk?
+      true
+    end
+
     # Should be implemented in subclass to initialize component
     def _component
       raise "NotImplemented"
@@ -12,10 +26,28 @@ module RETerm
       @component ||= begin
         c = _component
         c.setBackgroundColor("</#{@colors.id}>") if colored?
+        c.timeout(SYNC_TIMEOUT) if sync_enabled? # XXX
+        c.title_attrib = @title_attrib if @title_attrib
         c
       end
     end
 
+    # Return boolean indicating if escape was hit
+    def escape_hit?
+      component.exit_type == :ESCAPE_HIT
+    end
+
+    # Return boolean indicating early exit occurred
+    def early_exit?
+      component.exit_type == :EARLY_EXIT
+    end
+
+    # Return boolean indicating if user selection made / normal
+    # exit was invoked
+    def normal_exit?
+      component.exit_type == :NORMAL
+    end
+
     # Assign {ColorPair} to component
     def colors=(c)
       super
@@ -27,19 +59,51 @@ module RETerm
       component.draw([])
     end
 
+    def erase
+      component.erase
+    end
+
     # CDK components may be activated
     def activatable?
       true
     end
 
     # Invoke CDK activation routine
-    def activate!
-      component.activate([])
+    def activate!(*input)
+      dispatch :activated
+      component.resetExitType
+
+      r = nil
+
+      while [:EARLY_EXIT, :NEVER_ACTIVATED, :TIMEOUT].include?(component.exit_type) &&
+            !shutdown?
+        r = component.activate(input)
+        run_sync! if sync_enabled?
+      end
+
+      dispatch :deactivated
+      r
+    end
+
+    def deactivate!
+      component.activate [CDK::KEY_ESC]
+      dispatch :deactivated
     end
 
     # Return stored value of cdk component
     def value
       component.getValue
     end
+
+    # Override bind_key to use cdk bindings mechanism
+    def bind_key(key, kcb=nil, &bl)
+      kcb = bl if kcb.nil? && !bl.nil?
+
+      cb = lambda do |cdktype, widget, component, key|
+        kcb.call component, key
+      end
+
+      component.bind(:ENTRY, key, cb, self)
+    end
   end # module CDKComponent
 end # module RETerm

data/lib/reterm/mixins/common_controls.rb

@@ -0,0 +1,15 @@
+module RETerm
+  # XXX copied from CDK
+  module CommonControls
+    attr_reader :quit_on_enter
+
+    def quit_on_enter=(v)
+      @quit_on_enter_set = true
+      @quit_on_enter = v
+    end
+
+    def quit_on_enter?
+      @quit_on_enter_set ? @quit_on_enter : true
+    end
+  end # module CommonControls
+end # module CDK

data/lib/reterm/mixins/common_keys.rb

@@ -0,0 +1,20 @@
+module RETerm
+  module CommonKeys
+    # Key which if pressed cause the component to
+    # lose focus / become deactivated
+    QUIT_CONTROLS = [10, 27, Ncurses::KEY_ENTER] # 10 = enter, 27 = ESC,
+
+    # \033 = CDK::KEY_ESC
+    # 343 = NCURSES::KEY_ENTER
+
+    ENTER_CONTROLS = [10, Ncurses::KEY_ENTER] # quit controls with out 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]
+
+    # TODO add page/scroll controls
+  end # module CommonKeys
+end # module CDK

data/lib/reterm/mixins/component_input.rb

@@ -3,35 +3,83 @@ module RETerm
   # 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
+    include CommonControls
+    include CommonKeys
 
-    # Keys if pressed invoked the increment operation
-    INC_CONTROLS  = ['+'.ord, Ncurses::KEY_UP, Ncurses::KEY_RIGHT]
+    # TODO include / incorporate MouseInput mixin
+    # (scroll sliders/dials, click buttons, etc) ...
 
-    # 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
+    # May be overridden in subclass, invoked when the user requests
     # an 'increment'
     def on_inc
     end
 
-    # May be overrideen in subclass, invoked when the user
+    # May be overridden in subclass, invoked when the user
     # requests a decrement
     def on_dec
     end
 
+    # May be overridden in subclass, invoked when the user inputs
+    # the enter key (unless quit_on_enter is true)
+    def on_enter
+    end
+
+    # May be overridden in subclass, invoked with every key entered
+    def on_key(ch)
+    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)
+    def handle_input(*input)
+      while ch = next_ch(input)
+        quit  = QUIT_CONTROLS.include?(ch)
+        enter = ENTER_CONTROLS.include?(ch)
+        inc   = INC_CONTROLS.include?(ch)
+        dec   = DEC_CONTROLS.include?(ch)
+
+        break if shutdown? ||
+                (quit && (!enter || quit_on_enter?))
+
+        if enter
+          on_enter
+
+        elsif inc
           on_inc
-        elsif DEC_CONTROLS.include?(ch)
+
+        elsif dec
           on_dec
         end
+
+        if key_bound?(ch)
+          invoke_key_bindings(ch)
+        end
+
+        on_key(ch)
       end
+
+      ch
+    end
+
+    def bind_key(key, kcb)
+      @bound_keys      ||= {}
+      @bound_keys[key] ||= []
+      @bound_keys[key]  << kcb
+      nil
+    end
+
+    def key_bound?(key)
+      @bound_keys ||= {}
+      @bound_keys.key?(key)
+    end
+
+    private
+
+    def next_ch(input)
+      return sync_getch if input.empty?
+      input.shift
+    end
+
+    def invoke_key_bindings(key)
+      @bound_keys[key].each { |b| b.call self, key }
     end
   end # module ComponentInput
 end # module RETerm

data/lib/reterm/mixins/event_dispatcher.rb

@@ -9,6 +9,8 @@ module RETerm
       @event_handlers[e].each { |eh|
         eh.call h
       } if @event_handlers.key?(e)
+
+      nil # return last handler return value or perhaps all ?
     end
 
     def handle(e, &bl)

data/lib/reterm/mixins/item_helpers.rb

@@ -0,0 +1,8 @@
+module RETerm
+  module ItemHelpers
+    def max_item_size
+      return 0 if @items.empty?
+      @items.max { |i1, i2| i1.size <=> i2.size }.size
+    end
+  end # module ItemHelpers
+end # module RETerm

data/lib/reterm/mixins/key_bindings.rb

@@ -0,0 +1,23 @@
+module RETerm
+  # Similar to the bindings mixin in the CDK library
+  module KeyBindings
+    def key_bindings
+      @key_bindings ||= {}
+    end
+
+    def bind_key(key, kcb=nil, &bl)
+      key_bindings[key] ||= []
+      kcb = bl if kcb.nil? && !bl.nil?
+      key_bindings[key]  << kcb
+    end
+
+    def key_bound?(key)
+      key_bindings.key?(key)
+    end
+
+    def invoke_key_bindings(key)
+      o = self
+      key_bindings[key].all? { |kcb| kcb.call(o, key) }
+    end
+  end # module ButtonBindings
+end # module RETerm

data/lib/reterm/mixins/log_helpers.rb

@@ -0,0 +1,13 @@
+module RETerm
+  # Helpers defin
+  module LogHelpers
+    LOG_FILE = './reterm.log'
+
+    def logger
+      require 'logger'
+      @@logger ||=  Logger.new LOG_FILE
+    end
+
+    alias :log :logger
+  end # module LogHelpers
+end # module RETerm

data/lib/reterm/mixins/mouse_input.rb

@@ -0,0 +1,58 @@
+module RETerm
+  module MouseInput
+    ALL_EVENTS = Ncurses::ALL_MOUSE_EVENTS |
+                 Ncurses::REPORT_MOUSE_POSITION
+
+    MOUSE_MAP = {
+      :PRESSED        => :pressed,
+      :RELEASED       => :released,
+      :CLICKED        => :click,
+      :DOUBLE_CLICKED => :dclick,
+      :TRIPLE_CLICKED => :tclick,
+    }
+
+    def mouse_paste?
+      !!reterm_opts[:mouse_paste]
+    end
+
+    # May be overridden in subclass, invoked when
+    # the user interacts with a button.
+    #
+    # @param [Integer] b number of the button that was invoked
+    # @param [Symbol] evnt button event, may be :press, :release,
+    #   :click, :dclick (double click), :tclick (triple click)
+    def on_button(b, evnt, coords)
+      #puts "B#{b} #{evnt}, #{coords}"
+    end
+
+    def process_mouse(ch)
+      return nil unless ch == Ncurses::KEY_MOUSE
+
+      mev = Ncurses::MEVENT.new
+      Ncurses.getmouse(mev)
+
+      if mev.bstate == Ncurses::BUTTON2_CLICKED && mouse_paste?
+        # TODO grab clipboard buffer & return character array
+        #   (need to handle seperately in invoker)
+        #
+        # use https://github.com/janlelis/clipboard
+        # but note this requires external programs!
+      end
+
+      # TODO 5 button support (requiest "--enable-ext-mouse" ncurses flag
+      # which is not specified in many major distrubtions)
+      1.upto(4).each { |b|
+        MOUSE_MAP.each { |n, e|
+          if mev.bstate == Ncurses.const_get("BUTTON#{b}_#{n}")
+            x,y,z = mev.x, mev.y, mev.z
+            on_button(b, e, [x,y,z])
+          end
+        }
+      }
+
+      # TODO wrap MEVENT w/ our own class,
+      # w/ high levels helpers for buttons, coords, etc
+      mev
+    end
+  end # module MouseInput
+end # module RETerm