reterm 0.4.2 → 0.5.0

data/lib/reterm/config.rb

@@ -0,0 +1,22 @@
+require 'json'
+
+module RETerm
+  class Config
+    CONFIG_FILE = File.expand_path("~/.reterm")
+
+    def self.get
+      @config ||=
+        begin
+          return {} unless File.exist?(CONFIG_FILE)
+          JSON.parse(File.read(CONFIG_FILE))
+        end
+    end
+
+    def self.load_plugins
+      return unless get.key?("plugins")
+      get["plugins"].each { |p|
+        require p
+      }
+    end
+  end # class Config
+end # module RETerm

data/lib/reterm/init.rb

@@ -2,6 +2,10 @@ require 'ncursesw'
 require_relative './resize'
 
 module RETerm
+  SYNC_TIMEOUT = 150 # in milliseconds if enabled
+
+  ###############################
+
   # Initializes the RETerm subsystem before invoking block.
   # After block is finished regardless of execution state
   # (return, exception, etc) this will cleanup the terminal
@@ -17,6 +21,11 @@ module RETerm
   #   }
   #
   def init_reterm(opts={}, &bl)
+    @@shutdown = false
+    @@reterm_opts = opts
+
+    err = nil
+
     begin
       Terminal.load # XXX: not sure why but loading terminal
                     #      info after changing terminal settings via
@@ -25,25 +34,43 @@ module RETerm
                     #      without a 'reset' (see below).
                     #      So just preload terminal info here.
 
+      # shorten up the esc delay time
+      ENV["ESCDELAY"] = 100.to_s
+
       stdscr = Ncurses::initscr
       Ncurses::start_color
       Ncurses::noecho
       Ncurses::cbreak
-      Ncurses::curs_set(0)
+      disable_cursor! unless !!opts[:cursor]
       Ncurses::keypad(stdscr, true)
 
+      no_mouse = opts[:nomouse] || (opts.key?(:mouse) && !opts[:mouse])
+      Ncurses::mousemask(MouseInput::ALL_EVENTS, []) unless no_mouse
+
       track_resize if opts[:resize]
 
       bl.call
 
-    #ensure
+    rescue => e
+      err = e
+
+    ensure
       stop_track_resize
       Ncurses.curs_set(1)
-      Window.all.each { |w| w.finalize! }
+      Window.top.each { |w| w.finalize! }
       CDK::SCREEN.endCDK if cdk_enabled?
-      Ncurses.endwin()
+      Ncurses.endwin
       #`reset -Q` # XXX only way to guarantee a full reset (see above)
     end
+
+    if err
+      puts "Unhandled error:"
+      puts "  " + err.to_s
+      puts err.backtrace
+              .collect { |b|
+                "    " + b
+              }.join("\n")
+    end
   end
 
   # This method resyncs the visible terminal with the internal
@@ -58,18 +85,74 @@ module RETerm
   #     win.getch   # wait for input
   #   }
   #
-  def update_reterm
-    Window.top.each { |w| w.refresh }
+  def update_reterm(force_refresh=false)
+    if force_refresh
+      Window.top.each { |w|
+        w.erase
+        w.draw!
+      }
+    else
+      Window.top.each { |w| w.noutrefresh }
+    end
+
     Ncurses::Panel.update_panels
     Ncurses.doupdate
   end
 
+  # Return copy of options specified to init_reterm
+  def reterm_opts
+    @@_reterm_opts ||= Hash[@@reterm_opts]
+  end
+
   # XXX Ncurses is exposed so that users
   # may employ any constants if desired.
   # This should not be needed though and
   # is discouraged to maintain portability
   NC = Ncurses
 
+  ###
+
+  # Cursor
+
+  def cursor?
+    !(@@cursor_disabled ||= false)
+  end
+
+  def disable_cursor!
+    # store cursor state
+    o = cursor?
+
+    # set cursor state
+    @@cursor_disabled = true
+    Ncurses::curs_set(0)
+
+    # invoke block if given
+    return unless block_given?
+    yield
+
+    # restore cursor state after block
+    enable_cursor! if o
+  end
+
+  def enable_cursor!
+    # store cursor state
+    o = cursor?
+
+    # set cursor state
+    @@cursor_disabled = false
+    Ncurses::curs_set(1)
+
+    # invoke block if given
+    return unless block_given?
+    yield
+
+    # restore cursor state after block
+    disable_cursor! unless o
+  end
+
+
+  ###############################
+
   # Enable the CDK subsystem. Used by CDKbased components
   #
   # @see #cdk_enabled?
@@ -92,4 +175,46 @@ module RETerm
   def cdk_enabled?
     !!@cdk_enabled
   end
+
+  ###############################
+
+  # Enables the input timeout and component syncronization.
+  #
+  # Used internally by components that need to periodically
+  # be updated outside of user input.
+  def activate_sync!
+    @@sync_activated = true
+    Window.all.each { |w|
+      w.win.timeout(SYNC_TIMEOUT)
+    }
+  end
+
+  # Boonean indicating if component syncronization is
+  # enabled
+  def sync_enabled?
+    defined?(@@sync_activated) && !!@@sync_activated
+  end
+
+  # Run the sync process, used internally
+  def run_sync!
+    return unless sync_enabled?
+
+    Window.all.each { |w|
+      w.sync!
+    }
+
+    update_reterm
+  end
+
+  ###############################
+
+  # Use to halt all operation and cleanup.
+  def shutdown!
+    @@shutdown = true
+  end
+
+  # Boolean indicating if app in being halted
+  def shutdown?
+    !!@@shutdown
+  end
 end # module RETerm

data/lib/reterm/layout.rb

@@ -7,57 +7,193 @@ module RETerm
   class Layout < Component
     include NavInput
 
-    # TODO padding / margin support
+    # Flag indicating if layout should expand
+    # to be able to contain childen (if false
+    # error will be throw if trying to add
+    # child to layout that cannot contain it)
+    attr_accessor :expand
+
+    def expandable?
+      (!defined?(@expand) || !!@expand) &&
+      (!parent? || parent.expandable?)
+    end
+
+    def children
+      window.children.collect { |w| w.component }
+    end
+
+    def empty?
+      return true if window.nil?
+      window.children.empty?
+    end
+
+    def child_windows
+      window.children
+    end
+
+    def parent?
+      window.parent?
+    end
+
+    def parent
+      window.parent.component
+    end
 
-    attr_accessor :children
+    # TODO padding / margin support
 
-    def initialize(args={})
-      @children ||= []
+    # Subclasses should override this method returning
+    # current rows in layout
+    def current_rows
+      raise "NotImplemented"
     end
 
     # Subclasses should override this method returning
-    # boolean if child window exceeds bounds of layout
-    def exceeds_bounds?(child)
+    # current cols in layout
+    def current_cols
       raise "NotImplemented"
     end
 
+    # Subclasses should overrid this method returning
+    # boolean indicating if boundries will be
+    # exceeded when child is added
+    def exceeds_bounds_with?(child)
+      raise "NotImplemented"
+    end
+
+    # Returns boolean indicating if current layout
+    # exceeds bounds of window
+    def exceeds_bounds?
+      current_cols > window.cols ||
+      current_rows > window.rows
+    end
+
+
+    # Return layout containing component
+    # If coordinates are contained in a child in current layout
+    def layout_containing(component)
+      return self if children.include?(component)
+
+      found = nil
+      children.each { |c|
+        next if found
+
+        if c.kind_of?(Layout)
+          found = c unless c.layout_containing(component).nil?
+        end
+      }
+
+      found
+    end
+
+    # Return boolean indicating if layout contains specified child
+    def contains?(child)
+      children.any? { |c|
+        (c.kind_of?(Layout) && c.contains?(child)) || c == child
+      }
+    end
+
     # Return boolean indicating if any child component
     # is activatable
     def activatable?
-      children.any? { |c| c.component.activatable? }
+      return false if empty?
+      children.any? { |c| c.activatable? }
+    end
+
+    def highlight_focus?
+      false
     end
 
     # Create new child window and add it to layout
     def add_child(h={})
+      c = nil
+
+      if h.key?(:component)
+        c = h[:component]
+
+        h = {:rows => c.requested_rows + c.extra_padding,
+             :cols => c.requested_cols + c.extra_padding}.merge(h)
+      end
+
+      raise ArgumentError, "must specify x/y" unless h.key?(:x) &&
+                                                     h.key?(:y)
+
+      raise ArgumentError, "must specify rows/cols" unless h.key?(:rows) &&
+                                                           h.key?(:cols)
+
+      h[:rows], h[:cols] = *Window.adjust_proportional(window, h[:rows], h[:cols])
+      h[:x],    h[:y]    = *Window.align(window, h[:x], h[:y], h[:rows], h[:cols])
+      h[:rows], h[:cols] = *Window.fill_parent(parent? ? parent.window : Terminal,
+                                               h[:x], h[:y],
+                                               h[:rows], h[:cols]) if h[:fill]
+
+      if exceeds_bounds_with?(h)
+        if expandable? # ... && can_expand_to?(h)
+          expand(h)
+
+        else
+          raise ArgumentError, "child exceeds bounds"
+
+        end
+      end
+
       child = window.create_child(h)
 
+      # TODO need to reverse expansion if operation fails at any
+      # point on, or verify expandable before create_child but
+      # do not expand until after
+
       if child.win.nil?
         raise ArgumentError, "could not create child window"
       end
 
-      if exceeds_bounds?(child)
+      if exceeds_bounds?
         window.del_child(child) unless child.win.nil?
         raise ArgumentError, "child exceeds bounds"
       end
 
-      children << child
+      child.component = c unless c.nil?
+
       update_reterm
       child
     end
 
+    def expand(h)
+      nr = [current_rows, h[:y] + h[:rows]].max
+      nc = [current_cols, h[:x] + h[:cols]].max
+
+      # verify parent can contain expanded area and is expandable
+      if parent?
+        if parent.exceeds_bounds_with?(h)
+          raise ArgumentError, "cannot expand parent" unless parent.expandable?
+
+          # expand parent
+          parent.expand(h)
+        end
+      end
+
+      # perform actual window expansion
+      window.resize(nr+1, nc+1)
+
+      # FIXME need to expand children who are marked as 'fill'
+    end
+
     # Draw all layout children
     def draw!
       children.each { |c| c.draw! }
+      draw_focus!
     end
 
     # Activates layout by dispatching to navigation
     # input system.
     #
     # @see NavInput
-    def activate!
+    def activate!(*input)
+      reactivate!
+
       draw!
       update_reterm
-      handle_input
+      handle_input(*input)
+      deactivate!
     end
   end # class Layout
 end # module RETerm

data/lib/reterm/layouts.rb

@@ -14,3 +14,4 @@ end
 require 'reterm/layout'
 require 'reterm/layouts/horizontal'
 require 'reterm/layouts/vertical'
+require 'reterm/layouts/grid'

data/lib/reterm/layouts/grid.rb

@@ -0,0 +1,69 @@
+module RETerm
+  module Layouts
+    # Layout which permits the user to arrainge items anywhere on screen
+    class Grid < Layout
+      def current_rows
+        return 1 if empty?
+        child_windows.max { |c1, c2| c1.rows <=> c2.rows }.rows + 1
+      end
+
+      def current_cols
+        return 1 if empty?
+        child_windows.max { |c1, c2| c1.cols <=> c2.cols }.cols + 1
+      end
+
+      def exceeds_bounds_with?(child)
+        x1 = child.is_a?(Hash) ? child[:x] : child.x
+        y1 = child.is_a?(Hash) ? child[:y] : child.y
+
+        x2 = child.is_a?(Hash) ?
+              [current_cols, x1 + child[:cols]].compact.max :
+              [current_cols, x1 + child.cols].max
+
+        y2 = child.is_a?(Hash) ?
+               [current_rows, y1 + child[:rows]].compact.max :
+               [current_rows, y1 + child.rows].max
+
+        x1 < window.x    || y1 < window.y ||
+        x2 > window.cols || y2 > window.rows
+      end
+
+      def valid_input?(ch, from_parent)
+        if     UP_CONTROLS.include?(ch)
+          return focusable.any? { |f| f.window.y < focused.window.y }
+
+        elsif  DOWN_CONTROLS.include?(ch)
+          return focusable.any? { |f| f.window.y > focused.window.y }
+
+        elsif  LEFT_CONTROLS.include?(ch)
+          focusable.any? { |f| f.window.x < focused.window.x }
+
+        elsif RIGHT_CONTROLS.include?(ch)
+          focusable.any? { |f| f.window.x > focused.window.x }
+        end
+      end
+
+      # Cycle through components child position on grid
+      def next_focus(ch)
+        f = nil
+        if     UP_CONTROLS.include?(ch)
+          f = focusable.select { |f| f.window.y < focused.window.y }.first
+
+        elsif  DOWN_CONTROLS.include?(ch)
+          f = focusable.select { |f| f.window.y > focused.window.y }.first
+
+        elsif  LEFT_CONTROLS.include?(ch)
+          f = focusable.select { |f| f.window.x < focused.window.x }.first
+
+        elsif RIGHT_CONTROLS.include?(ch)
+          f = focusable.select { |f| f.window.x > focused.window.x }.first
+
+        else
+          return super
+        end
+
+        focusable.index(f)
+      end
+    end # class Grid
+  end # module Layouts
+end # module RETerm