rbcurse 1.4.1 → 1.5.0.pre1

data/lib/rbcurse/extras/textpad.rb

@@ -1,516 +0,0 @@
-# ----------------------------------------------------------------------------- #
-#         File: textpad.rb
-#  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/rbcurse/
-#         Date: 2011-11-09 - 16:59
-#      License: Same as Ruby's License (http://www.ruby-lang.org/LICENSE.txt)
-#  Last update: 2011-11-10 - 12:39
-#
-#  == CHANGES
-#  == TODO 
-#     when moving right, also don't pan straight away
-#     x add mappings and process key in handle_keys and other widget things
-#     - user can put text or list
-#     - handle putting data again and overwriting existing
-#     - formatted text
-#     - 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
-#
-# ----------------------------------------------------------------------------- #
-#
-require 'rbcurse'
-require 'rbcurse/common/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
-      #@rows = FFI::NCurses.LINES-1
-      #@cols = FFI::NCurses.COLS-1
-      @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
-      init_vars
-    end
-    def init_vars
-      @scrollatrows = @height - 3
-      @oldindex = @current_index = 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()
-
-      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
-      @_populate_needed = true
-    end
-
-    # Supply an array of string to be displayed
-    # This will replace existing text
-
-    def text 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.
-
-    def print(string, width = width)
-      #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/common/chunk'
-      @formatted_text = text
-      @color_parser = fmt
-      #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
-    def content_cols
-      longest = @content.max_by(&:length)
-      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
-
-      populate_pad if @_populate_needed
-      #HERE we need to populate once so user can pass a renderer
-      @window ||= @graphic
-      unless @suppress_border
-        if @repaint_all
-          @window.print_border_only @top, @left, @height-1, @width, $datacolor
-          print_title
-          @window.wrefresh
-        end
-      end
-
-      padrefresh
-      @repaint_required = false
-      @repaint_all = false
-    end
-
-    #
-    # key mappings
-    #
-    def map_keys
-      @mapped_keys = true
-      bind_key([?g,?g]){ goto_start } # mapping double keys like vim
-      bind_key(279){ goto_start } 
-      bind_keys([?G,277]){ goto_end } 
-      bind_keys([?k,KEY_UP]){ up } 
-      bind_keys([?j,KEY_DOWN]){ down } 
-      bind_key(?\C-e){ scroll_window_down } 
-      bind_key(?\C-y){ scroll_window_up } 
-      bind_keys([32,338]){ 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 = 0
-      @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 handle_key ch
-      return :UNHANDLED unless @content
-      map_keys unless @mapped_keys
-
-      @maxrow = @content_rows - @rows
-      @maxcol = @content_cols - @cols 
-      @oldrow = @prow
-      @oldcol = @pcol
-      $log.debug "XXX: PAD got #{ch} "
-      begin
-        case ch
-        when key(?l)
-          @pcol += 1
-        when key(?$)
-          @pcol = @maxcol - 1
-        when key(?h)
-          if @pcol > 0
-            @pcol -= 1
-          end
-        when key(?q)
-          #throw :close
-      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
-          rescue => err
-            $log.error " TEXTPAD ERROR #{err} "
-            $log.debug(err.backtrace.join("\n"))
-            alert err.to_s
-            # 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.debug( err) if err
-        $log.debug(err.backtrace.join("\n")) if err
-        alert "Got an exception in PadReader: #{err}. Check log"
-        $error_message.value = ""
-      ensure
-      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
-
-    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} "
-      @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, nil
-      if @oldrow != @prow || @oldcol != @pcol
-        @repaint_required = true
-      end
-    end
-  end
-
-  # check that prow and pcol are within bounds
-
-  def check_prow
-    @prow = 0 if @prow < 0
-    @pcol = 0 if @pcol < 0
-    if @prow > @maxrow-1
-      @prow = @maxrow-1
-    end
-    if @pcol > @maxcol-1
-      @pcol = @maxcol-1
-    end
-  end
-  # 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
-if __FILE__ == $PROGRAM_NAME
-  require 'rbcurse/app'
-  App.new do
-    w = 50
-    w2 = FFI::NCurses.COLS-w-1
-    p = RubyCurses::TextPad.new @form, :height => FFI::NCurses.LINES, :width => w, :row => 0, :col => 0 , :title => " ansi "
-    fn = "../../../examples/color.2"
-    text = File.open(fn,"r").readlines
-    p.formatted_text(text, :ansi)
-    RubyCurses::TextPad.new @form, :filename => "textpad.rb", :height => FFI::NCurses.LINES, :width => w2, :row => 0, :col => w+1 , :title => " ruby "
-    #throw :close
-    #status_line
-  end
-end