less_curse 0.6.0

data/lib/less_curse/actions.rb

@@ -0,0 +1,7 @@
+module LessCurse
+  module Actions
+    QUIT = lambda do |arg|
+      # do a sane quit.
+    end
+  end
+end

data/lib/less_curse/geometry.rb

@@ -0,0 +1,24 @@
+module LessCurse
+  module Geometry
+    class Point
+      attr_accessor :x, :y
+      def initialize(x, y)
+        @x, @y = x, y
+      end
+    end
+
+    class Size
+      attr_accessor :width, :height
+      def initialize(width, height)
+        @width, @height = width, height
+      end
+    end
+
+    class Rectangle
+      attr_accessor :position, :size
+      def initialize(x, y, width, height)
+        @position, @size = Point.new(x, y), Size.new(width, height)
+      end
+    end
+  end
+end

data/lib/less_curse/grid.rb

@@ -0,0 +1,25 @@
+module LessCurse
+  class Grid
+    attr_accessor :widget_grid
+
+    def initialize widget_grid=[[]]
+      @widget_grid = widget_grid
+    end
+
+    def rows
+      @widget_grid
+    end
+
+    def cols_in_row row_nr
+      @widget_grid[row_nr].count
+    end
+
+    def widgets
+      @widget_grid.flatten
+    end
+
+    def add widget
+      @widget_grid.last << widget
+    end
+  end
+end

data/lib/less_curse/null_logger.rb

@@ -0,0 +1,9 @@
+require 'logger'
+
+module LessCurse
+  # NullLogger â la hawkins: http://hawkins.io/2013/08/using-the-ruby-logger/
+  class NullLogger < Logger
+    def initialize(*args)  ; end
+    def add(*args, &block) ; end
+  end
+end

data/lib/less_curse/renderer.rb

@@ -0,0 +1,31 @@
+module LessCurse
+  module Renderer
+    # Draw box and title in top border of box
+    def self.box_with_title window, title
+      FFI::NCurses.box window, 0, 0
+      FFI::NCurses.mvwaddstr window, 0, 1, title
+    end
+
+    # Draw into lower border of a box
+    def self.box_foot window, text
+      height,width = FFI::NCurses::getmaxyx(window)
+      FFI::NCurses.mvwaddstr window, height - 1, 1, text
+    end
+
+    # Write a line in window
+    def self.write_line window, line_number, text
+      FFI::NCurses.mvwaddstr window, line_number + 1, 1, text
+    end
+
+    # Switch on boldness depending on condition
+    def self.bold_if condition, window
+      if condition
+        FFI::NCurses.wattron window, FFI::NCurses::A_BOLD
+      end
+      yield
+      if condition
+        FFI::NCurses.wattroff window, FFI::NCurses::A_BOLD
+      end
+    end
+  end
+end

data/lib/less_curse/screen.rb

@@ -0,0 +1,147 @@
+module LessCurse
+  class Screen
+    attr_accessor :grid
+    attr_accessor :windows
+    attr_accessor :size
+    attr_accessor :focused_widget
+    attr_accessor :header
+    attr_accessor :footer
+    attr_accessor :popups
+
+    def initialize
+      # Need to initialize screen to access the terminal size
+      FFI::NCurses.initscr
+
+      height,width =  FFI::NCurses::getmaxyx(FFI::NCurses::stdscr)
+      @size = LessCurse::Geometry::Size.new(width,height)
+      @windows = {}
+      @focused_widget = nil
+      @grid    = LessCurse::Grid.new [[]]
+      @popups  = {}
+    end
+
+    def add widget_or_grid
+      if widget_or_grid.is_a? LessCurse::Grid
+        @grid = widget_or_grid
+      else
+        @grid.add widget_or_grid
+      end
+      recalc_window_sizes
+    end
+
+    def widgets
+      @grid.widgets
+    end
+
+    def show
+      @focused_widget = widgets.first
+      @focused_widget.focus if @focused_widget
+      # Note that FFI::NCurses.initscr is called in initialize
+      FFI::NCurses.cbreak # can ctrl-c, not waiting for newlines to end input.
+      #FFI::NCurses.raw    # TODO this overrides cbreak ... 
+      FFI::NCurses.noecho # do not echo input in win.
+      FFI::NCurses.keypad FFI::NCurses::stdscr, true # recognize KEY_UP etc.
+      FFI::NCurses.clear
+      FFI::NCurses.refresh
+      repaint
+    end
+
+    # Repaint the screen and all contained widgets
+    def repaint
+      FFI::NCurses.refresh
+
+      # 'Draw' header and/or footer
+      if @header && !@header.empty?
+        FFI::NCurses::mvaddstr 0, 0, @header
+      end
+      if @footer && !@footer.empty?
+        FFI::NCurses::mvaddstr @size.height - 1, 0, @footer
+      end
+
+      # Let all Widgets redraw themselfes
+      widgets.each  do |widget|
+        window = @windows[widget]
+        FFI::NCurses.wclear   window
+        widget.draw           window
+        FFI::NCurses.wrefresh window
+      end
+
+      @popups.each do |popup, window|
+        FFI::NCurses.wclear   window
+        popup.draw            window
+        FFI::NCurses.wrefresh window
+      end
+    end
+
+    def show_popup type=:info, content='Popup'
+      # Lets take up quarter of screen and draw a boxed window
+      popup_widget = LessCurse::Widgets::Button.new title: content.to_s
+      popup_widget.focus = true
+      area = LessCurse::Geometry::Rectangle.new @size.width / 4,
+        @size.height / 4,
+        @size.width  / 2,
+        @size.height / 2
+
+      @popups[popup_widget] = LessCurse.window area
+    end
+
+    # Focus next element in #widgets
+    def focus_next
+      cycle_focus(+1)
+    end
+
+    # Focus next element in #widgets
+    def focus_previous
+      cycle_focus(-1)
+    end
+
+    # Set header text (first, top line of screen)
+    def header= new_header
+      @header = new_header
+      recalc_window_sizes
+    end
+
+    # Set footer text (last, bottom line of screen)
+    def footer= new_footer
+      @footer = new_footer
+      recalc_window_sizes
+    end
+
+    private
+
+    # Switch focus to step next (or previous) widget
+    def cycle_focus step=1
+      focused_widget_idx = widgets.index(@focused_widget) || 0
+      @focused_widget.unfocus
+      @focused_widget = widgets[(focused_widget_idx + step) % widgets.size]
+      @focused_widget.focus
+    end
+
+    def recalc_window_sizes
+      header_height = (@header.nil? || @header.empty?) ? 0 : 1
+      footer_height = (@footer.nil? || @footer.empty?) ? 0 : 1
+
+      row_height = (@size.height - header_height - footer_height) / @grid.rows.count
+
+      @grid.rows.each_with_index do |row_widgets, row_idx|
+        element_width = @size.width / (row_widgets.size)
+        row_y         = header_height + row_idx * row_height
+        row_widgets.each_with_index do |widget, idx|
+          area = LessCurse::Geometry::Rectangle.new element_width * idx, #x
+                                                    row_y, #y
+                                                    element_width - 1, #width
+                                                    row_height #height
+          if @windows[widget].nil?
+            @windows[widget] = LessCurse.window area
+          else
+            FFI::NCurses.wresize(@windows[widget],
+                                 area.size.height, area.size.width)
+            FFI::NCurses.mvwin(@windows[widget],
+                               area.position.y, area.position.x)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/less_curse/version.rb

@@ -0,0 +1,3 @@
+module LessCurse
+  VERSION = "0.6.0"
+end

data/lib/less_curse/widgets.rb

@@ -0,0 +1,4 @@
+require 'less_curse/widgets/base'
+require 'less_curse/widgets/text_area'
+require 'less_curse/widgets/text_view'
+require 'less_curse/widgets/list'

data/lib/less_curse/widgets/base.rb

@@ -0,0 +1,42 @@
+module LessCurse
+  module Widgets
+    class Base
+      attr_accessor :data
+      attr_accessor :title
+      attr_accessor :focus
+      attr_accessor :actions
+
+      def initialize data: nil, title: ""
+        @data, @title = data, title
+        set_default_actions
+      end
+
+      # Draw portions of screen, probably using ncurses primitives.
+      # Expect an already clean/red window.
+      def draw(window) ; end
+
+      # Populate actions with proper code
+      def set_default_actions ; end
+
+      # Handle input or return false if doesnt care
+      def handle_input key
+        false
+      end
+
+      # Receive Focus
+      def focus
+        @focus = true
+      end
+
+      # Loose Focus
+      def unfocus
+        @focus = false
+      end
+
+      # Is focused?
+      def focused?
+        return @focus
+      end
+    end
+  end
+end

data/lib/less_curse/widgets/list.rb

@@ -0,0 +1,108 @@
+module LessCurse
+  module Widgets
+    class List < Base
+      attr_accessor :on_select
+      attr_accessor :selected_data
+      attr_accessor :top_element_idx
+      attr_accessor :display_func
+
+      def initialize data: [], title: ""
+        super(data: data, title: title)
+      end
+
+      @top_element_idx = 0
+
+      def set_default_actions
+        @actions = { FFI::NCurses::KEY_UP   => :select_previous,
+                     FFI::NCurses::KEY_DOWN => :select_next}
+      end
+
+      def draw window
+        LessCurse::Renderer::bold_if focused?, window do
+          LessCurse::Renderer::box_with_title window, @title
+        end
+
+        # Do we have kind of a display-window?
+        visible_data.each_with_index do |d, idx|
+          LessCurse::Renderer::bold_if(@selected_data == d, window) do
+            if @display_func
+              item_text = display_func.call(d)
+            else
+              item_text = d.to_s
+            end
+            LessCurse::Renderer::write_line window, idx, item_text
+          end
+        end
+
+        if visible_data.size != @data.size
+          LessCurse::Renderer::box_foot window, "..."
+        end
+      end
+
+      def handle_input key
+        action = @actions[key]
+        LessCurse::debug_msg "List will execute action: #{action}"
+        return false if !action
+        send(action)
+      end
+
+      # Select previous data element in list (roll over if nexessary)
+      def select_previous
+        if @selected_data.nil? && @data.size >= 0
+          @selected_data = @data.to_a[0]
+        else
+          @selected_data = @data.to_a[(selected_data_index - 1) % @data.size]
+        end
+        recalc_top_index
+        if @on_select
+          @on_select.call @selected_data
+        end
+        @selected_data
+      end
+
+      # Select next data element in list (roll over if nexessary)
+      def select_next
+        if @selected_data.nil? && @data.size >= 0
+          @selected_data = @data.to_a[0]
+        else
+          @selected_data = @data.to_a[(selected_data_index + 1) % @data.size]
+        end
+        recalc_top_index
+        if @on_select
+          @on_select.call @selected_data
+        end
+        @selected_data
+      end
+
+      private
+
+      # Get index of given element in @data
+      def data_index element
+        @data.to_a.index(element)
+      end
+
+      # Get index of selected element in @data
+      def selected_data_index
+        data_index @selected_data
+      end
+
+      def recalc_top_index
+        window = LessCurse.screen.windows[self]
+        height,width = FFI::NCurses::getmaxyx(window)
+        if @data.size <= (height - 2)
+          @top_element_idx = 0
+        else
+          @top_element_idx = [selected_data_index, (@data.size - (height - 2)).abs].min
+        end
+      end
+
+      def visible_data
+        @top_element_idx ||= 0
+        window = LessCurse.screen.windows[self]
+        height,width = FFI::NCurses::getmaxyx(window)
+        # -2: border, -1: 0-based indexing
+        @data.to_a[@top_element_idx..(@top_element_idx + height - 2 - 1)]
+      end
+    end
+  end
+end

data/lib/less_curse/widgets/text_area.rb

@@ -0,0 +1,42 @@
+module LessCurse
+  module Widgets
+    class TextArea < Base
+      def draw window
+        LessCurse::Renderer::bold_if(focused?, window) do
+          LessCurse::Renderer::box_with_title window, @title
+        end
+        FFI::NCurses.wmove window, 1, 1
+        @data.to_s.split("\n").each_with_index do |line, idx|
+          FFI::NCurses.mvwaddstr window, idx + 1, 1, line
+        end
+      end
+
+      def handle_input key
+        # Its a PITA to redo all the readline loveliness, but it gets us right
+        # into doing things.  Would be cool to have moving cursor on ENTER
+        if key == FFI::NCurses::KEY_BACKSPACE
+          @data = @data[0..-2]
+        else
+          # Handle out of range stuff
+          @data += key.chr rescue false
+        end
+      end
+
+      def focus
+        @focus = true
+        ## Initial experiments where done with cbreak and echo
+        #FFI::NCurses.echo
+        #FFI::NCurses.nocbreak # can ctrl-c, not waiting for newlines to end input.
+        ##@data = ... but master.refresh afterwards ..
+        #window = LessCurse.screen.windows[self]
+        ##FFI::NCurses::mvwgetstr window, 4, 3, @data
+        ##@data += FFI::NCurses::wget_wstr window
+        #@data += FFI::NCurses::wgetch(window).chr
+        ## from ffi/ncurses getkey example
+        # #buffer = FFI::Buffer.new(FFI::NCurses.find_type(:wint_t))
+        refresh
+      end
+    end
+  end
+end
+