rubytext 0.1.22 → 0.1.26

data/lib/menu.rb

@@ -1,17 +1,331 @@
+#### FIXME LATER
+
+# The top-level module
+
 module RubyText
 
+  # Wrapper for a curses window
+
   class Window
-    def topmenu(items:, curr: 0, fg: Green, bg: Black)
-      r, c = 0, 0
-      high = 1
 
+    class Menu2D
+
+      class Vertical
+        attr_reader :widest, :height, :header, :hash
+        def initialize(vlist)
+          @header = vlist[0]
+          @hash = vlist[1]
+          @widest = @header.length
+          @hash.each_pair {|k,v| puts "k = #{k.inspect}"; getch; @widest = [@widest, k.length].max }
+          @height = @hash.size
+        end
+      end
+
+      def initialize(win:, r: :center, c: :center, items:, colrow: [0, 0], 
+                     border: true, title: nil, fg: Green, bg: Black)
+        @win = win
+        @list = []
+        @header = @list.map {|x| x.header }
+        items.each {|vlist| @list << Vertical.new(vlist) }
+        @highest = @list.map {|x| x.height }.max
+        @full_width = @list.inject(0) {|sum, vlist| sum += vlist.widest + 2 }
+        @nlists = items.size
+        @grid = Array.new(@nlists)  # column major order
+        @grid.map! {|x| [" "] * @highest }
+        @list.each.with_index do |vlist, i|  
+          vlist.hash.each_pair.with_index do |kv, j|
+            k, v = kv
+            @grid[i][j] = [k, v]
+          end
+        end
+        RubyText.hide_cursor
+        @high = @highest
+        @wide = @full_width
+        @high += 2 if border
+        @wide += 2 if border
+
+        tlen = title.length + 8 rescue 0
+        # wide = [wide, tlen].max
+        row, col = @win.coords(r, c)
+        row = row - @high/2 if r == :center
+        col = col - @wide/2 if c == :center
+        r, c = row, col
+        @win.saveback(@high+1, @wide, r, c)
+        mr, mc = r+@win.r0, c+@win.c0
+        title = nil unless border
+
+        @mwin = RubyText.window(@high+1, @wide, r: mr, c: mc, border: true,
+                                fg: fg, bg: bg, title: title)
+        @header.each {|head| printf "%-#{maxw}s", head }
+        puts  # after header
+        Curses.stdscr.keypad(true)
+        maxcol = items.size - 1
+        sizes = items.map {|x| x.size }
+        max = sizes.max
+        # mwin.go(r, c)
+        r += 1   # account for header
+        @selc, @selr = colrow
+      end
+
+      def show(r, c, colrow: [0, 0])
+        @selc, @selr = colrow
+        @grid.each.with_index do |column, cix|
+          column.each.with_index do |pairs, rix|   # {Jan: ..., Feb: ..., Mar: ..., ...}
+            # STDSCR.puts "go: #{r}+#{rix}, #{c}+#{cix}*#{maxw}"
+            @mwin.go(rix, cix)  # FIXME wrong?
+            style = ([@selc, @selr] == [cix, rix]) ? :reverse : :normal
+            key, val = pairs
+            label = key.to_s
+            @mwin.print label # fx(label, style)
+          end
+        end
+      end
+
+      def handle(r, c)
+        loop do
+          show(r, c)
+          ch = getch
+          case ch
+            when RubyText::Window::Up
+              @selr -= 1 if @selr > 0
+            when RubyText::Window::Down
+#             puts "PAUSE r,c = #@selr #@selc  highest=#@highest"; getch
+              @selr += 1 if @selr < @highest - 1
+            when RubyText::Window::Left
+              @selc -= 1 if @selc > 0
+            when RubyText::Window::Right
+              @selc += 1 if @selc < @full_width
+            when RubyText::Window::Esc
+              @win.restback(@high+1, @wide, r-1, c)
+              RubyText.show_cursor
+              return [nil, nil, nil]
+            when RubyText::Window::Enter
+              @win.restback(@high+1, @wide, r-1, c)
+              RubyText.show_cursor
+              choice = @grid[@selc][@selr][1]
+              case choice
+                when String;   
+                     puts "Returning #{[@selc, @selr, choice].inspect}"; getch
+                     return [@selc, @selr, choice]
+                when NilClass; return [nil, nil, nil]
+              end
+              result = choice.call   # should be a Proc
+              return [nil, nil, nil] if result.nil? || result.empty?
+              return result
+            else Curses.beep
+          end
+        end
+        RubyText.show_cursor
+      end
+    end
+
+
+    def rectmenu(r: :center, c: :center, items:, colrow: [0, 0], 
+                 border: true,
+                 title: nil, fg: Green, bg: Black)
       RubyText.hide_cursor
+      maxh, maxw = _rectmenu_maxes(items)
+      header, stuff = _rect_hash2array(items, maxh, maxw)
+      wide = items.size * maxw
+      high = maxh
+      high += 2 if border
+      wide += 2 if border
+
+      tlen = title.length + 8 rescue 0
+      # wide = [wide, tlen].max
+      row, col = @win.coords(r, c)
+      row = row - high/2 if r == :center
+      col = col - wide/2 if c == :center
+      r, c = row, col
+      @win.saveback(high+1, wide, r, c)
+      mr, mc = r+@win.r0, c+@win.c0
+      title = nil unless border
+
+      mwin = RubyText.window(high+1, wide, r: mr, c: mc, border: true,
+                             fg: fg, bg: bg, title: title)
+      header.each {|head| printf "%-#{maxw}s", head }
+      puts  # after header
+      Curses.stdscr.keypad(true)
+      maxcol = items.size - 1
+      sizes = items.map {|x| x.size }
+      max = sizes.max
+      # mwin.go(r, c)
+      r += 1   # account for header
+      selc, selr = colrow
+
+      loop do
+        RubyText.hide_cursor  # FIXME should be unnecessary
+        stuff.each.with_index do |column, cix|
+          column.each.with_index do |pairs, rix|   # {Jan: ..., Feb: ..., Mar: ..., ...}
+            STDSCR.puts "go: #{r}+#{rix}, #{c}+#{cix}*#{maxw}"
+            mwin.go(rix+1, cix*maxw)
+            style = ([selc, selr] == [cix, rix]) ? :reverse : :normal
+            key, val = pairs
+            label = key.to_s
+#           mwin.print fx(label, style)
+            mwin.print label # fx(label, style)
+          end
+        end
+        ch = getch
+        case ch
+          when Up
+            selr -= 1 if selr > 0
+          when Down
+            selr += 1 if selr < maxh - 1
+          when Left
+            selc -= 1 if selc > 0
+          when Right
+            selc += 1 if selc < maxcol
+          when Esc
+            self.restback(high+1, wide, r-1, c)
+            RubyText.show_cursor
+            return [nil, nil, nil]
+          when Enter
+            self.restback(high+1, wide, r-1, c)
+            RubyText.show_cursor
+            choice = stuff[selc][selr][1]
+            case choice
+              when String;   return [selc, selr, choice]
+              when NilClass; return [nil, nil, nil]
+            end
+            result = choice.call   # should be a Proc
+            return [nil, nil, nil] if result.nil? || result.empty?
+            return result
+          else Curses.beep
+        end
+        RubyText.show_cursor
+      end
+    end
+  end
+end
+
+module RubyText
+
+  # Two-paned widget with menu on left, informtional area on right
+
+  def self.selector(win: STDSCR, r: 0, c: 0, rows: 10, cols: 20, 
+                    items:, fg: White, bg: Blue,
+                    win2:, callback:, enter: nil, quit: "q")
+    high = rows
+    wide = cols
+    mwin = RubyText.window(high, wide, r: r, c: c, fg: fg, bg: bg)
+    handler = callback
+    Curses.stdscr.keypad(true)
+    RubyText.hide_cursor
+    sel = 0
+    max = items.size - 1
+    handler.call(sel, items[sel], win2)
+    loop do
+      mwin.home
+      items.each.with_index do |item, row|
+        mwin.crlf
+        style = (sel == row) ? :reverse : :normal
+        mwin.print fx(" #{item}", style)
+      end
+      ch = getch
+      case ch
+        when Up
+          if sel > 0
+            sel -= 1
+            handler.call(sel, items[sel], win2)
+          end
+        when Down
+          if sel < max
+            sel += 1
+            handler.call(sel, items[sel], win2)
+          end
+        when Enter
+          if enter
+            del = enter.call(sel, items[sel], win2)
+            if del
+              items -= [items[sel]]
+              raise 
+            end
+          end
+        when Tab
+          Curses.flash
+        when quit  # parameter
+          exit
+        else Curses.beep    # all else is trash
+      end
+    end
+  rescue
+    retry
+  end
+
+  # "Menu" for checklists
+
+    def checklist(r: :center, c: :center, 
+                  items:, curr: 0, selected: [],
+                  title: nil, sel_fg: Yellow, fg: White, bg: Blue)
+      RubyText.hide_cursor
+      high = items.size + 2
+      wide = items.map(&:length).max + 8
+      tlen = title.length + 8 rescue 0
+      wide = [wide, tlen].max
+      row, col = self.coords(r, c)
+      row = row - high/2 if r == :center
+      col = col - wide/2 if c == :center
+      r, c = row, col
+      self.saveback(high, wide, r, c)
+      mr, mc = r+self.r0, c+self.c0
+      mwin = RubyText.window(high, wide, r: mr, c: mc, 
+                             fg: fg, bg: bg, title: title)
+      Curses.stdscr.keypad(true)
+      sel = curr
+      max = items.size - 1
+      loop do
+        RubyText.hide_cursor  # FIXME should be unnecessary
+        items.each.with_index do |item, row|
+          mwin.go row, 0
+          style = (sel == row) ? :reverse : :normal
+          color = selected.find {|x| x[0] == row } ? sel_fg : fg
+          label = "[ ]" + item
+          mwin.print fx(label, color, style)
+        end
+        ch = getch
+        case ch
+          when Up
+            sel -= 1 if sel > 0
+          when Down
+            sel += 1 if sel < max
+          when Esc
+            self.restback(high, wide, r, c)
+            RubyText.show_cursor
+            return []
+          when Enter
+            self.restback(high, wide, r, c)
+            RubyText.show_cursor
+            return selected.map {|i| items[i] }
+          when " "
+            selected << [sel, items[sel]]
+            sel += 1 if sel < max
+        else Curses.beep
+        end
+        RubyText.show_cursor
+      end
+    end
+
+end
+
+# The top-level module
+
+module RubyText
+
+  # Wrapper for a curses window
+
+  class Window
+
+    # One-line menu at top of window
+
+    def topmenu(items:, curr: 0, fg: Green, bg: Black)
+      r, c, high = 0, 0, 1
+      RubyText.hide_cursor
+      hash_flag = false
+      results = items
       if items.is_a?(Hash)
-        results = items.values
-        items = items.keys
+        results, items = items.values, items.keys
         hash_flag = true
-      else
-        results = items
       end
 
       width = 0   # total width
@@ -45,25 +359,30 @@ module RubyText
           when Esc, " "   # spacebar also quits
             self.restback(high, width, r, c)
             RubyText.show_cursor
+            STDSCR.go r, c
             return [nil, nil]
           when Down, Enter
             self.restback(high, width, r, c)
             RubyText.show_cursor
+            STDSCR.go r, c
             choice = results[sel]
             return [sel, choice] if choice.is_a? String
             result = choice.call
-            next if result.nil?
-            next if result.empty?
-            return result
-          else Curses.beep
+            return [nil, nil, nil] if result.nil? || result.empty?
+#           next if result.nil?
+#           next if result.empty?
+#           return result
+        else Curses.beep
         end
         RubyText.show_cursor
       end
     end
 
+    # Simple menu with rows of strings (or Procs)
+
     def menu(r: :center, c: :center, items:, curr: 0, 
-             border: true,
-             title: nil, fg: Green, bg: Black)
+             border: true, sticky: false,
+             title: nil, fg: Green, bg: Black, wrap: false)
       RubyText.hide_cursor
       if items.is_a?(Hash)
         results = items.values
@@ -103,15 +422,23 @@ module RubyText
         ch = getch
         case ch
           when Up
-            sel -= 1 if sel > 0
-          when Down
-            sel += 1 if sel < max
+            if sel > 0
+              sel -= 1 
+            else
+              sel = max if wrap  # asteroids mode :)
+            end
+          when Down, " "  # let space mean down?
+            if sel < max
+              sel += 1 
+            else
+              sel = 0 if wrap    # asteroids mode :)
+            end
           when Esc
             self.restback(high, wide, r, c)
             RubyText.show_cursor
             return [nil, nil]
           when Enter
-            self.restback(high, wide, r, c)
+            self.restback(high, wide, r, c) unless sticky
             RubyText.show_cursor
             choice = results[sel]
             return [sel, choice] if choice.is_a? String
@@ -124,6 +451,8 @@ module RubyText
       end
     end
 
+    # Menu for multiple selections (buggy/unused?)
+
     def multimenu(r: :center, c: :center, 
                   items:, curr: 0, selected: [],
                   title: nil, sel_fg: Yellow, fg: White, bg: Blue)
@@ -175,6 +504,8 @@ module RubyText
       end
     end
 
+    # Simple yes/no decision
+
     def yesno
       # TODO: Accept YyNn
       r, c = STDSCR.rc
@@ -182,6 +513,8 @@ module RubyText
       num == 0
     end
 
+    # Menu to choose a single setting and retain it
+
     def radio_menu(r: :center, c: :center, items:, curr: 0, 
              # Handle current value better?
              border: true,
@@ -251,6 +584,11 @@ module RubyText
       end
     end
   end
+end
+
+module RubyText
+
+  # Two-paned widget with menu on left, informtional area on right
 
   def self.selector(win: STDSCR, r: 0, c: 0, rows: 10, cols: 20, 
                     items:, fg: White, bg: Blue,
@@ -301,5 +639,60 @@ module RubyText
   rescue
     retry
   end
+
+  # "Menu" for checklists
+
+    def checklist(r: :center, c: :center, 
+                  items:, curr: 0, selected: [],
+                  title: nil, sel_fg: Yellow, fg: White, bg: Blue)
+      RubyText.hide_cursor
+      high = items.size + 2
+      wide = items.map(&:length).max + 8
+      tlen = title.length + 8 rescue 0
+      wide = [wide, tlen].max
+      row, col = self.coords(r, c)
+      row = row - high/2 if r == :center
+      col = col - wide/2 if c == :center
+      r, c = row, col
+      self.saveback(high, wide, r, c)
+      mr, mc = r+self.r0, c+self.c0
+      mwin = RubyText.window(high, wide, r: mr, c: mc, 
+                             fg: fg, bg: bg, title: title)
+      Curses.stdscr.keypad(true)
+      sel = curr
+      max = items.size - 1
+      loop do
+        RubyText.hide_cursor  # FIXME should be unnecessary
+        items.each.with_index do |item, row|
+          mwin.go row, 0
+          style = (sel == row) ? :reverse : :normal
+          color = selected.find {|x| x[0] == row } ? sel_fg : fg
+          label = "[ ]" + item
+          mwin.print fx(label, color, style)
+        end
+        ch = getch
+        case ch
+          when Up
+            sel -= 1 if sel > 0
+          when Down
+            sel += 1 if sel < max
+          when Esc
+            self.restback(high, wide, r, c)
+            RubyText.show_cursor
+            return []
+          when Enter
+            self.restback(high, wide, r, c)
+            RubyText.show_cursor
+            return selected.map {|i| items[i] }
+          when " "
+            selected << [sel, items[sel]]
+            sel += 1 if sel < max
+        else Curses.beep
+        end
+        RubyText.show_cursor
+      end
+    end
+
 end
 
+

data/lib/navigation.rb

@@ -1,5 +1,9 @@
+# Reopening: Coordinate handling (1-based!)
+
 class RubyText::Window
 
+  # Handle special coordinate names (symbols)
+
   def coords(r, c)
     r = case
           when r == :center
@@ -24,10 +28,17 @@ class RubyText::Window
     [r, c]
   end
 
+  # Go to specified row/column in current window
+
   def goto(r, c)  # only accepts numbers!
     @cwin.setpos(r, c)
+    @cwin.refresh
   end
 
+
+  # Go to specified row/column in current window,
+  #   execute block, and return cursor
+
   def go(r0, c0)
     r, c = coords(r0, c0)
     save = self.rc
@@ -38,60 +49,84 @@ class RubyText::Window
     end
   end
 
+  # Move cursor up
+
   def up(n=1)
     r, c = rc
     go r-n, c
   end
 
+  # Move cursor down
+
   def down(n=1)
     r, c = rc
     go r+n, c
   end
 
+  # Move cursor left
+
   def left(n=1)
     r, c = rc
     go r, c-n
   end
 
+  # Move cursor right
+
   def right(n=1)
     r, c = rc
     go r, c+n
   end
 
+  # Move cursor to top of window
+
   def top
     r, c = rc
     go 0, c
   end
 
+  # Move cursor to bottom of window
+
   def bottom 
     r, c = rc
     rmax = self.rows - 1
     go rmax, c
   end
 
+  # Move cursor to top of window
+
   def up!
     top
   end
 
+  # Move cursor to bottom of window
+
   def down!
     bottom
   end
 
+  # Move cursor to far left of window
+
   def left!
     r, c = rc
     go r, 0
   end
 
+  # Move cursor to far left of window
+
   def right!
     r, c = rc
     cmax = self.cols - 1
     go r, cmax
   end
 
+  # Move cursor to home (upper left)
+
   def home
     go 0, 0
   end
 
+  # Return current row/column
+
   def rc
     [@cwin.cury, @cwin.curx]
   end

data/lib/output.rb

@@ -123,17 +123,31 @@ class RubyText::Window
     $stdscr = STDSCR
   end
 
+=begin
+  def go(r0, c0)
+    r, c = coords(r0, c0)
+    save = self.rc
+    goto r, c 
+    if block_given?
+      yield 
+      goto *save
+    end
+  end
+=end
+
   def [](r, c)
-    ch = nil
-    go(r, c) { ch = @cwin.inch }
-    debug "ch = #{ch}  ch.chr = #{ch.chr}"
+    r0, c0 = self.rc
+    @cwin.setpos(r, c)
+    ch = @cwin.inch
+    @cwin.setpos(r0, c0)
     ch.chr
   end
 
   def []=(r, c, char)
+    r0, c0 = self.rc
     @cwin.setpos(r, c)
     @cwin.addch(char[0].ord|Curses::A_NORMAL)
-    @cwin.setpos(r, c)
+    @cwin.setpos(r0, c0)
     @cwin.refresh
   end
 

data/lib/rubytext_version.rb

@@ -1,6 +1,6 @@
 
 module RubyText
-  VERSION = "0.1.22"
+  VERSION = "0.1.26"
 
   Path  = File.expand_path(File.join(File.dirname(__FILE__)))
 end

data/lib/settings.rb

@@ -9,7 +9,7 @@ module RubyText
       @current = @defaults.dup
       @stack = []
       @stack.push @current   # Note: Never let stack be empty
-      set_curses(@current)   # Set them for real
+      set_curses(**@current)   # Set them for real
       # FIXME To be continued...
     end
 
@@ -39,7 +39,7 @@ module RubyText
       cursor ||= @current[:cursor]
       @stack.push @current
       @current = {raw: raw, echo: echo, cbreak: cbreak, keypad: keypad, cursor: cursor}
-      set_curses(@current)
+      set_curses(**@current)
     end
 
     def reset_boolean
@@ -57,7 +57,7 @@ module RubyText
         sym0 = val ? sym : str[1..-1].to_sym
         list[sym0] = val
       end
-      set_boolean(list)
+      set_boolean(**list)
       # allow a block here?
     end
 
@@ -101,6 +101,7 @@ module RubyText
     Object.const_set(:STDSCR, main) unless defined? STDSCR
     $stdscr = STDSCR  # FIXME global needed?
     Object.include(WindowIO)
+    Curses.ESCDELAY = 10
     @started = true
 # rescue => err
 #   puts(err.inspect)
@@ -129,7 +130,7 @@ module RubyText
     if name[0] == '_'
       Curses.send(name[1..-1], *args)
     else
-      raise "#{name} #{args.inspect}" # NoMethodError
+      raise "Missing: #{name} #{args.inspect}" # NoMethodError
     end
   end