mancurses 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+color.2
+rbc13.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mancurses.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Rahul Kumar
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Mancurses
+
+Browse manpages inside ncurses. Jump around to other man pages
+
+
+## Installation
+
+    $ gem install mancurses
+
+## Usage
+
+Use Alt-c to enter program name to search such as "grep", "strcmp" etc.
+Use "/" to search for strings within the page displayed.
+
+Use '?' to see bindings.
+
+When pressing F1 for help or "?" for bindings, and returning, the background is black. You need to 
+press a key for it to refresh. I am figuring this out.
+
+## General
+
+    This gem is not really gonna make much difference to you. It's faster to just type `man grep` on the 
+    command line and 'q' to get out. It's not like you keep manning pages one after another.
+
+    I am writing this to test out a new text widget which uses a pad. I hope to replace the current
+    text widgets such as textview and list and maybe tabular and tree in rbcurse-core with this. 
+
+    Currently, using a window requires a lot of work each time one scrolls around. Too much string creation , truncation, sanitizing and gc going on repeatedly. Using a pad simplifies all this.
+
+    However, pad is not without its issues. If I have two pads on the screen, and a popup is displayed,
+    then a black rectangle is left on the other pad. I would have to tab there and scroll for a `prefresh` to happen. Otherwise, the app needs to do some book-keeping of underlying pads created and refresh them when a messagebox or window closes.
+    
+    If i cannot manage that reliably, then i cannot include this in the main rbcurse-core.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+https://rubygems.org/profiles/rkumar

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/mancurses

@@ -0,0 +1,724 @@
+#!/usr/bin/env ruby
+# ----------------------------------------------------------------------------- #
+#         File: mancurses
+#  Description: A class that displays text using a pad.
+#         The motivation for this is to put formatted text and not care about truncating and 
+#         stuff. Also, there will be only one write, not each time scrolling happens.
+#         I found textview code for repaint being more complex than required.
+#       Author: rkumar http://github.com/rkumar/mancurses/
+#         Date: 2011-11-09 - 16:59
+#      License: Same as Ruby's License (http://www.ruby-lang.org/LICENSE.txt)
+#  Last update: 2013-03-08 01:14
+#
+#  == CHANGES
+#  == TODO 
+#     when moving right, also don't pan straight away
+#     x add mappings and process key in handle_keys and other widget things
+#     x user can put text or list
+#     . handle putting data again and overwriting existing
+#     . formatted text
+#     x search and other features
+#     - can pad movement and other ops be abstracted into module for reuse
+#     / get scrolling like in vim (C-f e y b d)
+#     - alert issue of leaving a blank is poss due to using prefresh i/o copywin
+#
+#   == TODO 2013-03-07 - 20:34 
+#   _ key bindings not showing up -- bind properly
+#   _ F1 screen leaves everything blank, so does bindings
+# ----------------------------------------------------------------------------- #
+#
+require 'rbcurse'
+require 'rbcurse/core/include/bordertitle'
+
+include RubyCurses
+module RubyCurses
+  extend self
+  class TextPad < Widget
+    include BorderTitle
+
+    dsl_accessor :suppress_border
+    # You may pass height, width, row and col for creating a window otherwise a fullscreen window
+    # will be created. If you pass a window from caller then that window will be used.
+    # Some keys are trapped, jkhl space, pgup, pgdown, end, home, t b
+    # This is currently very minimal and was created to get me started to integrating
+    # pads into other classes such as textview.
+    def initialize form=nil, config={}, &block
+
+      @editable = false
+      @focusable = true
+      @config = config
+      @prow = @pcol = 0
+      @startrow = 0
+      @startcol = 0
+      @list = []
+      super
+
+      # FIXME 0 as height craps out. need to make it LINES
+
+      #@height = @height.ifzero(FFI::NCurses.LINES)
+      #@width = @width.ifzero(FFI::NCurses.COLS)
+      @rows = @height
+      @cols = @width
+      @startrow = @row
+      @startcol = @col
+      #@suppress_border = config[:suppress_border]
+      @row_offset = @col_offset = 1
+      unless @suppress_border
+        @startrow += 1
+        @startcol += 1
+        @rows -=3  # 3 is since print_border_only reduces one from width, to check whether this is correct
+        @cols -=3
+      end
+      @row_offset = @col_offset = 0 if @suppress_borders
+      @top = @row
+      @left = @col
+      @lastrow = @row + 1
+      @lastcol = @col + 1
+      init_vars
+    end
+    def init_vars
+      @scrollatrows = @height - 3
+      @oldindex = @current_index = 0
+      # column cursor
+      @ccol = 0
+      @repaint_required = true
+    end
+    def rowcol #:nodoc:
+      return @row+@row_offset, @col+@col_offset
+    end
+
+    private
+    def create_pad
+      destroy if @pad
+      #@pad = FFI::NCurses.newpad(@content_rows, @content_cols)
+      @pad = @window.get_pad(@content_rows, @content_cols )
+    end
+
+    private
+    # create and populate pad
+    def populate_pad
+      @_populate_needed = false
+      # how can we make this more sensible ? FIXME
+      @renderer ||= DefaultRubyRenderer.new if ".rb" == @filetype
+      @content_rows = @content.count
+      @content_cols = content_cols()
+      @content_rows = @rows if @content_rows < @rows
+      @content_cols = @cols if @content_cols < @cols
+      $log.debug "XXXX content_cols = #{@content_cols}"
+
+      create_pad
+
+      Ncurses::Panel.update_panels
+      @content.each_index { |ix|
+        #FFI::NCurses.mvwaddstr(@pad,ix, 0, @content[ix])
+        render @pad, ix, @content[ix]
+      }
+
+    end
+
+    public
+    # supply a custom renderer that implements +render()+
+    # @see render
+    def renderer r
+      @renderer = r
+    end
+    #
+    # default method for rendering a line
+    #
+    def render pad, lineno, text
+      if text.is_a? Chunks::ChunkLine
+        FFI::NCurses.wmove @pad, lineno, 0
+        a = get_attrib @attrib
+      
+        show_colored_chunks text, nil, a
+        return
+      end
+      if @renderer
+        @renderer.render @pad, lineno, text
+      else
+        FFI::NCurses.mvwaddstr(@pad,lineno, 0, @content[lineno])
+      end
+    end
+
+    # supply a filename as source for textpad
+    # Reads up file into @content
+
+    def filename(filename)
+      @file = filename
+      @filetype = File.extname filename
+      @content = File.open(filename,"r").readlines
+      if @filetype == ""
+        if @content.first.index("ruby")
+          @filetype = ".rb"
+        end
+      end
+      @_populate_needed = true
+    end
+
+    # Supply an array of string to be displayed
+    # This will replace existing text
+
+    def text lines
+      raise "text() receiving null content" unless lines
+      @content = lines
+      @_populate_needed = true
+    end
+
+    ## ---- the next 2 methods deal with printing chunks
+    # we should put it int a common module and include it
+    # in Window and Pad stuff and perhaps include it conditionally.
+
+    ## 2013-03-07 - 19:57 changed width to @content_cols since data not printing
+    # in some cases fully when ansi sequences were present int some line but not in others
+    # lines without ansi were printing less by a few chars.
+    def print(string, _width = @content_cols)
+      #return unless visible?
+      w = _width == 0? Ncurses.COLS : _width
+      FFI::NCurses.waddnstr(@pad,string.to_s, w) # changed 2011 dts  
+    end
+
+    def show_colored_chunks(chunks, defcolor = nil, defattr = nil)
+      #return unless visible?
+      chunks.each do |chunk| #|color, chunk, attrib|
+        case chunk
+        when Chunks::Chunk
+          color = chunk.color
+          attrib = chunk.attrib
+          text = chunk.text
+        when Array
+          # for earlier demos that used an array
+          color = chunk[0]
+          attrib = chunk[2]
+          text = chunk[1]
+        end
+
+        color ||= defcolor
+        attrib ||= defattr || NORMAL
+
+        #cc, bg = ColorMap.get_colors_for_pair color
+        #$log.debug "XXX: CHUNK textpad #{text}, cp #{color} ,  attrib #{attrib}. #{cc}, #{bg} "
+        FFI::NCurses.wcolor_set(@pad, color,nil) if color
+        FFI::NCurses.wattron(@pad, attrib) if attrib
+        print(text)
+        FFI::NCurses.wattroff(@pad, attrib) if attrib
+      end
+    end
+
+    def formatted_text text, fmt
+      require 'rbcurse/core/include/chunk'
+      @formatted_text = text
+      @color_parser = fmt
+      @repaint_required = true
+      # don't know if start is always required. so putting in caller
+      #goto_start
+      #remove_all
+    end
+
+    # write pad onto window
+    #private
+    def padrefresh
+      FFI::NCurses.prefresh(@pad,@prow,@pcol, @startrow, @startcol, @rows + @startrow, @cols+@startcol);
+    end
+
+    # convenience method to return byte
+    private
+    def key x
+      x.getbyte(0)
+    end
+
+    # length of longest string in array
+    # This will give a 'wrong' max length if the array has ansi color escape sequences in it
+    # which inc the length but won't be printed. Such lines actually have less length when printed
+    # So in such cases, give more space to the pad.
+    def content_cols
+      longest = @content.max_by(&:length)
+      ## 2013-03-06 - 20:41 crashes here for some reason when man gives error message no man entry
+      return 0 unless longest
+      longest.length
+    end
+
+    public
+    def repaint
+      return unless @repaint_required
+      if @formatted_text
+        $log.debug "XXX:  INSIDE FORMATTED TEXT "
+
+        l = RubyCurses::Utils.parse_formatted_text(@color_parser,
+                                               @formatted_text)
+
+        text(l)
+        @formatted_text = nil
+      end
+
+      ## moved this line up or else create_p was crashing
+      @window ||= @graphic
+      populate_pad if @_populate_needed
+      #HERE we need to populate once so user can pass a renderer
+      unless @suppress_border
+        if @repaint_all
+          @window.print_border_only @top, @left, @height-1, @width, $datacolor
+          print_title
+          @window.wrefresh
+        end
+      end
+
+      padrefresh
+      Ncurses::Panel.update_panels
+      @repaint_required = false
+      @repaint_all = false
+    end
+
+    #
+    # key mappings
+    #
+    def map_keys
+      @mapped_keys = true
+      bind_key([?g,?g], 'goto_start'){ goto_start } # mapping double keys like vim
+      bind_key(279, 'goto_start'){ goto_start } 
+      bind_keys([?G,277], 'goto end'){ goto_end } 
+      bind_keys([?k,KEY_UP], "Up"){ up } 
+      bind_keys([?j,KEY_DOWN], "Down"){ down } 
+      bind_key(?\C-e, "Scroll Window Down"){ scroll_window_down } 
+      bind_key(?\C-y, "Scroll Window Up"){ scroll_window_up } 
+      bind_keys([32,338, ?\C-d], "Scroll Forward"){ scroll_forward } 
+      bind_keys([?\C-b,339]){ scroll_backward } 
+      bind_key([?',?']){ goto_last_position } # vim , goto last row position (not column)
+      bind_key(?/, :ask_search)
+      bind_key(?n, :find_more)
+      bind_key([?\C-x, ?>], :scroll_right)
+      bind_key([?\C-x, ?<], :scroll_left)
+      bind_key(?\M-l, :scroll_right)
+      bind_key(?\M-h, :scroll_left)
+      #bind_key([?\C-x, ?\C-s], :saveas)
+      #bind_key(?r) { getstr("Enter a word: ") }
+      #bind_key(?m, :disp_menu)
+    end
+
+    # goto first line of file
+    def goto_start
+      @oldindex = @current_index
+      @current_index = @ccol = 0
+      @pcol = @prow = 0
+    end
+
+    # goto last line of file
+    def goto_end
+      @oldindex = @current_index
+      @current_index = @content_rows-1
+      @prow = @current_index - @scrollatrows
+    end
+
+    # move down a line mimicking vim's j key
+    # @param [int] multiplier entered prior to invoking key
+    def down num=(($multiplier.nil? or $multiplier == 0) ? 1 : $multiplier)
+      @oldindex = @current_index if num > 10
+      @current_index += num
+      unless is_visible? @current_index
+        if @current_index > @scrollatrows
+          @prow += 1
+        end
+      end
+      $multiplier = 0
+    end
+
+    # move up a line mimicking vim's k key
+    # @param [int] multiplier entered prior to invoking key
+    def up num=(($multiplier.nil? or $multiplier == 0) ? 1 : $multiplier)
+      @oldindex = @current_index if num > 10
+      @current_index -= num
+      unless is_visible? @current_index
+        if @prow > @current_index
+          $status_message.value = "1 #{@prow} > #{@current_index} "
+          @prow -= 1
+        else
+        end
+      end
+      $multiplier = 0
+    end
+
+    # scrolls window down mimicking vim C-e
+    # @param [int] multiplier entered prior to invoking key
+    def scroll_window_down num=(($multiplier.nil? or $multiplier == 0) ? 1 : $multiplier)
+      @prow += num
+        if @prow > @current_index
+          @current_index += 1
+        end
+      #check_prow
+      $multiplier = 0
+    end
+
+    # scrolls window up mimicking vim C-y
+    # @param [int] multiplier entered prior to invoking key
+    def scroll_window_up num=(($multiplier.nil? or $multiplier == 0) ? 1 : $multiplier)
+      @prow -= num
+      unless is_visible? @current_index
+        # one more check may be needed here TODO
+        @current_index -= num
+      end
+      $multiplier = 0
+    end
+
+    # scrolls lines a window full at a time, on pressing ENTER or C-d or pagedown
+    def scroll_forward
+      @oldindex = @current_index
+      @current_index += @scrollatrows
+      @prow = @current_index - @scrollatrows
+    end
+
+    # scrolls lines backward a window full at a time, on pressing pageup 
+    # C-u may not work since it is trapped by form earlier. Need to fix
+    def scroll_backward
+      @oldindex = @current_index
+      @current_index -= @scrollatrows
+      @prow = @current_index - @scrollatrows
+    end
+    def goto_last_position
+      return unless @oldindex
+      tmp = @current_index
+      @current_index = @oldindex
+      @oldindex = tmp
+      bounds_check
+    end
+    def scroll_right
+      if @content_cols < @cols
+        maxpcol = 0
+      else
+        maxpcol = @content_cols - @cols
+      end
+      @pcol += 1
+      @pcol = maxpcol if @pcol > maxpcol
+      # to prevent right from retaining earlier painted values
+      # padreader does not do a clear, yet works fine.
+      # OK it has an update_panel after padrefresh, that clears it seems.
+      #this clears entire window not just the pad
+      #FFI::NCurses.wclear(@window.get_window)
+      # so border and title is repainted after window clearing
+      #
+      # Next line was causing all sorts of problems when scrolling  with ansi formatted text
+      #@repaint_all = true
+    end
+    def scroll_left
+      @pcol -= 1
+    end
+    #
+    #
+    #
+    # NOTE : if advancing pcol one has to clear the pad or something or else 
+    # there'll be older content on the right side.
+    #
+    def handle_key ch
+      return :UNHANDLED unless @content
+      map_keys unless @mapped_keys
+
+      @maxrow = @content_rows - @rows
+      @maxcol = @content_cols - @cols 
+
+      # need to understand the above line, can go below zero.
+      # all this seems to work fine in padreader.rb in util.
+      # somehow maxcol going to -33
+      @oldrow = @prow
+      @oldcol = @pcol
+      #$log.debug "XXX: PAD got #{ch} maxcol = #{@maxcol} cols=#{@cols}, maxpcol = #{maxpcol}"
+      begin
+        case ch
+        when key(?H)
+        when key(?l)
+          # TODO take multipler
+          #@pcol += 1
+          if @ccol < @cols
+            @ccol += 1
+          end
+        when key(?$)
+          #@pcol = @maxcol - 1
+          @ccol = [@content[@current_index].size, @cols].min
+        when key(?h)
+          # TODO take multipler
+          if @ccol > 0
+            @ccol -= 1
+          end
+        when key(?0)
+          @ccol = 0
+      when ?0.getbyte(0)..?9.getbyte(0)
+        if ch == ?0.getbyte(0) && $multiplier == 0
+          # copy of C-a - start of line
+          @repaint_required = true if @pcol > 0 # tried other things but did not work
+          @pcol = 0
+          return 0
+        end
+        # storing digits entered so we can multiply motion actions
+        $multiplier *= 10 ; $multiplier += (ch-48)
+        return 0
+        when ?\C-c.getbyte(0)
+          $multiplier = 0
+          return 0
+        else
+          # check for bindings, these cannot override above keys since placed at end
+          begin
+            ret = process_key ch, self
+            ## If i press C-x > i get an alert from rwidgets which blacks the screen
+            # if i put a padrefresh here it becomes okay but only for one pad,
+            # i still need to do it for all pads.
+          rescue => err
+            $log.error " TEXTPAD ERROR INS #{err} "
+            $log.debug(err.backtrace.join("\n"))
+            textdialog ["Error in TextPad: #{err} ", *err.backtrace], :title => "Exception"
+            # FIXME why does this result in a blank spot on screen till its refreshed again
+            # should not happen if its deleting its panel and doing an update panel
+          end
+          return :UNHANDLED if ret == :UNHANDLED
+        end
+        bounds_check
+      rescue => err
+        $log.error " TEXTPAD ERROR 111 #{err} "
+        $log.debug( err) if err
+        $log.debug(err.backtrace.join("\n")) if err
+        textdialog ["Error in TextPad: #{err} ", *err.backtrace], :title => "Exception"
+        $error_message.value = ""
+      ensure
+        padrefresh
+        Ncurses::Panel.update_panels
+      end
+      return 0
+    end # while loop
+
+    # destroy the pad, this needs to be called from somewhere, like when the app
+    # closes or the current window closes , or else we could have a seg fault
+    # or some ugliness on the screen below this one (if nested).
+
+    # Now since we use get_pad from window, upon the window being destroyed,
+    # it will call this. Else it will destroy pad
+    def destroy
+      FFI::NCurses.delwin(@pad) if @pad # when do i do this ? FIXME
+      @pad = nil
+    end
+    def is_visible? index
+      j = index - @prow #@toprow
+      j >= 0 && j <= @scrollatrows
+    end
+    def on_enter
+      set_form_row
+    end
+    def set_form_row
+      setrowcol @lastrow, @lastcol
+    end
+    def set_form_col
+    end
+
+    private
+    
+    # check that current_index and prow are within correct ranges
+    # sets row (and someday col too)
+    # sets repaint_required
+
+    def bounds_check
+      r,c = rowcol
+      @current_index = 0 if @current_index < 0
+      @current_index = @content_rows-1 if @current_index > @content_rows-1
+      $status_message.value = "visible #{@prow} , #{@current_index} "
+      unless is_visible? @current_index
+        if @prow > @current_index
+          $status_message.value = "1 #{@prow} > #{@current_index} "
+          @prow -= 1
+        else
+        end
+      end
+      #end
+      check_prow
+      #$log.debug "XXX: PAD BOUNDS ci:#{@current_index} , old #{@oldrow},pr #{@prow}, max #{@maxrow} pcol #{@pcol} maxcol #{@maxcol}"
+      @crow = @current_index + r - @prow
+      @crow = r if @crow < r
+      # 2 depends on whetehr suppressborders
+      @crow = @row + @height -2 if @crow >= r + @height -2
+      setrowcol @crow, @ccol+c
+      lastcurpos @crow, @ccol+c
+      if @oldrow != @prow || @oldcol != @pcol
+        @repaint_required = true
+      end
+    end
+    def lastcurpos r,c
+      @lastrow = r
+      @lastcol = c
+    end
+
+
+  # check that prow and pcol are within bounds
+
+    def check_prow
+      @prow = 0 if @prow < 0
+      if @prow > @maxrow-1
+        @prow = @maxrow-1
+      end
+      if @pcol > @maxcol-1
+        @pcol = @maxcol-1
+      end
+      @pcol = 0 if @pcol < 0
+    end
+    public
+    ## 
+    # Ask user for string to search for
+    def ask_search
+      str = get_string("Enter pattern: ")
+      return if str.nil? 
+      str = @last_regex if str == ""
+      return if str == ""
+      ix = next_match str
+      return unless ix
+      @last_regex = str
+
+      @oldindex = @current_index
+      @current_index = ix[0]
+      @ccol = ix[1]
+      ensure_visible
+    end
+    ## 
+    # Find next matching row for string accepted in ask_search
+    #
+    def find_more
+      return unless @last_regex
+      ix = next_match @last_regex
+      return unless ix
+      @oldindex = @current_index
+      @current_index = ix[0]
+      @ccol = ix[1]
+      ensure_visible
+    end
+
+    ## 
+    # Find the next row that contains given string
+    # @return row and col offset of match, or nil
+    # @param String to find
+    def next_match str
+      first = nil
+      ## content can be string or Chunkline, so we had to write <tt>index</tt> for this.
+      ## =~ does not give an error, but it does not work.
+      @content.each_with_index do |line, ix|
+        col = line.index str
+        if col
+          first ||= [ ix, col ]
+          if ix > @current_index
+            return [ix, col]
+          end
+        end
+      end
+      return first
+    end
+    ## 
+    # Ensure current row is visible, if not make it first row
+    # TODO - need to check if its at end and then reduce scroll at rows, 
+    # @param current_index (default if not given)
+    #
+    def ensure_visible row = @current_line
+      unless is_visible? row
+          @prow = @current_index
+      end
+    end
+
+  end  # class textpad
+
+  # a test renderer to see how things go
+  class DefaultRubyRenderer
+    def render pad, lineno, text
+      bg = :black
+      fg = :white
+      att = NORMAL
+      cp = $datacolor
+      if text =~ /^\s*# /
+        fg = :red
+        cp = get_color($datacolor, fg, bg)
+      elsif text =~ /^\s*#/
+        fg = :blue
+        cp = get_color($datacolor, fg, bg)
+      elsif text =~ /^\s*class /
+        fg = :magenta
+        cp = get_color($datacolor, fg, bg)
+      elsif text =~ /^\s*def /
+        fg = :yellow
+        att = BOLD
+        cp = get_color($datacolor, fg, bg)
+      elsif text =~ /^\s*(begin|rescue|ensure|end)/
+        fg = :magenta
+        att = BOLD
+        cp = get_color($datacolor, fg, bg)
+      end
+      FFI::NCurses.wattron(pad,FFI::NCurses.COLOR_PAIR(cp) | att)
+      FFI::NCurses.mvwaddstr(pad, lineno, 0, text)
+      FFI::NCurses.wattroff(pad,FFI::NCurses.COLOR_PAIR(cp) | att)
+
+    end
+  end
+end
+## Since we already have an ansi sequence parser, why not convert to that and use that.
+#
+#  man pages have some kind of sucky format probably related to sme ancient hardware.
+#  I notice two patterns:
+#  1. a character is followed by a ^H and then the same character repeated.
+#     Such a char is to be printed in one color. Oh it get it, LOL, ^H is a backspace
+#     so basically the printer is giogn back and printing that char again. So its printed
+#     two times, aka bold.
+#  2. The second is an underline folowed by BS and then any character, this goes in another
+#  color and is obviously meant to be underlined text. NOW it get it, bird-brained me!
+#
+#
+def convert_man_to_ansi file
+  lines = file.split "\n"
+  l = nil
+  lines.each_with_index do |line, ix|
+    # convert underlined words to yellow or one color, these are usually params
+    line.gsub!(/((_[^ ])+)/,'\1')
+    line.gsub!(/_/,'')
+    # convert bold words to red or one color, these are usually headers and other words
+    l= line.gsub(/(([^ ][^ ])+)/,'\1').gsub(/[^ ]/,'').gsub(//,'')
+   # == 
+    #line.gsub!(/((_[^ ])+)/,'_\1_')
+    #line.gsub!(/_/,'')
+    ### convert bold words to red or one color, these are usually headers and other words
+    #l= line.gsub(/(([^ ][^ ])+)/,'*\1*').gsub(/[^ ]/,'').gsub(//,'')
+   # == 
+    lines[ix] = l
+  end
+  lines
+end
+def ask_program
+  p = @form.by_name["textpad"]; 
+  prog = get_string("Program to man:")
+  p.padrefresh
+  return unless prog
+  return if prog == ""
+  file = `man #{prog} 2>&1`
+  return unless file
+  text = convert_man_to_ansi(file)
+  p.formatted_text(text, :ansi)
+  p.goto_start
+end
+if __FILE__ == $PROGRAM_NAME
+  require 'rbcurse/core/util/app'
+  App.new do
+    @form.bind_key(?\M-c, "Ask program name: ") { ask_program }
+    @form.bind_key(?q, "quit: ") { throw :close }
+    single = true
+    w = 50
+    w2 = FFI::NCurses.COLS-w-1
+    if single
+      w = FFI::NCurses.COLS-1
+      ## no matter what you do, man's output gets wrapped to 80 cols if not going to a terminal.
+    end
+    ## create two side by side pads on for ansi and one for ruby
+    p = RubyCurses::TextPad.new @form, :height => FFI::NCurses.LINES-1, :width => w, :row => 0, :col => 0 , :title => " mancurses ", :name => "textpad"
+    #fn = "m.m"
+    #text = File.open(fn,"r").readlines
+    file = `man man`
+    text = convert_man_to_ansi(file)
+    #File.open("t.t", 'w') { |file| file.write(text.join "\n") }
+    p.formatted_text(text, :ansi)
+    #p.text(text)
+    if !single
+      RubyCurses::TextPad.new @form, :filename => "bin/mancurses", :height => FFI::NCurses.LINES, :width => w2, :row => 0, :col => w+1 , :title => " ruby "
+    end
+    #throw :close
+      @status_line = status_line :row => Ncurses.LINES-1
+
+      @status_line.command {
+        "q Quit | ? Keys | M-c Program |  " 
+      }
+  end
+end

data/mancurses.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "mancurses"
+  spec.version       = "0.0.1"
+  spec.authors       = ["Rahul Kumar"]
+  spec.email         = ["sentinel1879@gmail.com"]
+  spec.description   = %q{view manpages in an ncurses window and navigate with vim bindings}
+  spec.summary       = %q{view manpages in an ncurses window and navigate with vim bindings and much much moah}
+  spec.homepage      = "https://github.com/rkumar/mancurses"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_dependency "rbcurse-core"
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: mancurses
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Rahul Kumar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rbcurse-core
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: view manpages in an ncurses window and navigate with vim bindings
+email:
+- sentinel1879@gmail.com
+executables:
+- mancurses
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/mancurses
+- mancurses.gemspec
+homepage: https://github.com/rkumar/mancurses
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1947742288534939193
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1947742288534939193
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: view manpages in an ncurses window and navigate with vim bindings and much
+  much moah
+test_files: []