rbcurse 1.4.1 → 1.5.0.pre1

data/lib/rbcurse/common/bordertitle.rb

@@ -1,41 +0,0 @@
-# I am moving the common title and border printing stuff into 
-# a separate module.
-module BorderTitle
-    dsl_accessor :suppress_borders            #to_print_borders
-    dsl_accessor :border_attrib, :border_color
-    dsl_accessor :title                       #set this on top
-    dsl_accessor :title_attrib                #bold, reverse, normal
-    dsl_accessor :border_attrib, :border_color # 
-
-    def bordertitle_init
-      @row_offset = @col_offset = 0 if @suppress_borders 
-      @internal_width = 1 if @suppress_borders
-    end
-    # why the dash does it reduce height by one.
-    def print_borders
-      raise ArgumentError, "Graphic not set" unless @graphic
-      width = @width
-      height = @height-1
-      window = @graphic
-      startcol = @col 
-      startrow = @row 
-      @color_pair = get_color($datacolor)
-      bordercolor = @border_color || @color_pair
-      borderatt = @border_attrib || Ncurses::A_NORMAL
-      window.print_border startrow, startcol, height, width, bordercolor, borderatt
-      print_title
-    end
-    def print_title
-      return unless @title
-      raise "#{self} needs width" unless @width
-      @color_pair ||= get_color($datacolor) # should we not use this ??? XXX 
-      #$log.debug " print_title #{@row}, #{@col}, #{@width}  "
-      # check title.length and truncate if exceeds width
-      _title = @title
-      if @title.length > @width - 2
-        _title = @title[0..@width-2]
-      end
-      @graphic.printstring( @row, @col+(@width-_title.length)/2, _title, @color_pair, @title_attrib) unless @title.nil?
-    end
-
-end

data/lib/rbcurse/common/chunk.rb

@@ -1,177 +0,0 @@
-# ------------------------------------------------------------ #
-#         File: chunk.rb 
-#  Description: 
-#       Author: rkumar http://github.com/rkumar/rbcurse/
-#         Date: 07.11.11 - 12:31 
-#  Same as Ruby's License (http://www.ruby-lang.org/LICENSE.txt)
-#  Last update: use ,,L
-# ------------------------------------------------------------ #
-#
-
-module Chunks
-  extend self
-  class Chunk
-
-    # color_pair of associated text
-    # text to print
-    # attribute of associated text
-    #attr_accessor :color, :text, :attrib
-    attr_reader :chunk
-
-    def initialize color, text, attrib
-      @chunk = [ color, text, attrib ]
-      #@color = color
-      #@text  = text
-      #@attrib = attrib
-    end
-    def color
-      @chunk[0]
-    end
-    def text
-      @chunk[1]
-    end
-    def attrib
-      @chunk[2]
-    end
-  end
-
-  # consists of an array of chunks and corresponds to a line
-  # to be printed.
-  class ChunkLine
-
-    # an array of chunks
-    attr_reader :chunks
-
-    def initialize arr=nil
-      @chunks = arr.nil? ? Array.new : arr
-    end
-    def <<(chunk)
-      raise ArgumentError, "Chunk object expected. Received #{chunk.class} " unless chunk.is_a? Chunk
-      @chunks << chunk
-    end
-    alias :add :<<
-    def each &block
-      @chunks.each &block
-    end
-
-    # returns length of text in chunks
-    def row_length
-      result = 0
-      @chunks.each { |e| result += e.text.length }
-      return result
-    end
-    alias :length :row_length
-    alias :size   :row_length
-
-    # return a Chunkline containing only the text for the range requested
-    def substring start, size
-    end
-  end
-  class ColorParser
-    def initialize cp
-      color_parser cp
-      @color_pair = $datacolor
-      @attrib     = FFI::NCurses::A_NORMAL
-      @color_array = [:white]
-      @bgcolor_array = [:black]
-      @attrib_array = [@attrib]
-      @color_pair_array = [@color_pair]
-      @color = :white
-      @bgcolor = :black
-    end
-    #
-    # Takes a formatted string and converts the parsed parts to chunks.
-    #
-    # @param [String] takes the entire line or string and breaks into an array of chunks
-    # @yield chunk if block
-    # @return [ChunkLine] # [Array] array of chunks
-    # @since 1.4.1   2011-11-3 experimental, can change
-    public
-    def convert_to_chunk s, colorp=$datacolor, att=FFI::NCurses::A_NORMAL
-      #require 'rbcurse/common/chunk'
-
-      @color_parser ||= get_default_color_parser()
-      ## defaults
-      color_pair = @color_pair
-      attrib = @attrib
-      #res = []
-      res = ChunkLine.new
-      color = @color
-      bgcolor = @bgcolor
-      # stack the values, so when user issues "/end" we can pop earlier ones
-
-      @color_parser.parse_format(s) do |p|
-        case p
-        when Array
-          ## got color / attrib info, this starts a new span
-
-          #color, bgcolor, attrib = *p
-          lc, lb, la = *p
-          if la
-            @attrib = get_attrib la
-          end
-          if lc || lb
-            @color = lc ? lc : @color_array.last
-            @bgcolor = lb ? lb : @bgcolor_array.last
-            @color_array << @color
-            @bgcolor_array << @bgcolor
-            @color_pair = get_color($datacolor, @color, @bgcolor)
-          end
-          @color_pair_array << @color_pair
-          @attrib_array << @attrib
-          #$log.debug "XXX: CHUNK start #{color_pair} , #{attrib} :: c:#{lc} b:#{lb} "
-          #$log.debug "XXX: CHUNK start arr #{@color_pair_array} :: #{@attrib_array} "
-
-        when :endcolor
-
-          # end the current (last) span
-          @color_pair_array.pop
-          @color_pair = @color_pair_array.last
-          @attrib_array.pop
-          @attrib = @attrib_array.last
-          #$log.debug "XXX: CHUNK end #{color_pair} , #{attrib} "
-          #$log.debug "XXX: CHUNK end arr #{@color_pair_array} :: #{@attrib_array} "
-        when :reset   # ansi has this
-          # end all previous colors
-          @color_pair = $datacolor # @color_pair_array.first
-          @color_pair_array = [@color_pair]
-          @attrib = FFI::NCurses::A_NORMAL #@attrib_array.first
-          @attrib_array = [@attrib]
-          @bgcolor_array = [@bgcolor_array.first]
-          @color_array = [@color_array.first]
-
-        when String
-
-          ## create the chunk
-          $log.debug "XXX:  CHUNK     using on #{p}  : #{@color_pair} , #{@attrib} "
-
-          #chunk =  [color_pair, p, attrib] 
-          chunk = Chunk.new @color_pair, p, @attrib
-          if block_given?
-            yield chunk
-          else
-            res << chunk
-          end
-        end
-      end # parse
-      return res unless block_given?
-    end
-    def get_default_color_parser
-      require 'rbcurse/common/colorparser'
-      @color_parser || DefaultColorParser.new
-    end
-    # supply with a color parser, if you supplied formatted text
-    public
-    def color_parser f
-      $log.debug "XXX:  color_parser setting in CP to #{f} "
-      if f == :tmux
-        @color_parser = get_default_color_parser()
-      elsif f == :ansi
-        require 'rbcurse/common/ansiparser'
-        @color_parser = AnsiParser.new
-      else
-        @color_parser = f
-      end
-    end
-  end # class
-end

data/lib/rbcurse/common/colorparser.rb

@@ -1,71 +0,0 @@
-# ----------------------------------------------------------------------------- #
-#         File: colorparser.rb
-#  Description: Default parse for our tmux format
-#               The aim is to be able to specify parsers so different kinds
-#               of formatting or documents can be used, such as ANSI formatted
-#               manpages.
-#       Author: rkumar http://github.com/rkumar/rbcurse/
-#         Date: 07.11.11 - 13:17
-#      License: Same as Ruby's License (http://www.ruby-lang.org/LICENSE.txt)
-#  Last update: use ,,L
-# ----------------------------------------------------------------------------- #
-# == TODO
-#    - perhaps we can compile the regexp once and reuse
-# 
-
-class DefaultColorParser
-
-  # NOTE: Experimental and minimal
-  # parses the formatted string and yields either an array of color, bgcolor and attrib
-  # or the text. This will be called by convert_to_chunk.
-  #
-  # Currently, assumes colors and attributes are correct. No error checking or fancy stuff.
-  #  s="#[fg=green]hello there#[fg=yellow, bg=black, dim]"
-  # @since 1.4.1  2011-11-3 experimental, can change
-  # @return [nil] knows nothign about output format. 
-
-  def parse_format s  # yields attribs or text
-    ## set default colors
-    color   = :white
-    bgcolor = :black
-    attrib  = FFI::NCurses::A_NORMAL
-    text    = ""
-
-    ## split #[...]
-    a       = s.split /(#\[[^\]]*\])/
-    a.each { |e| 
-      ## process color or attrib portion
-      if e[0,2] == "#[" && e[-1] == "]"
-        # now resetting 1:20 PM November 3, 2011 , earlier we were  carrying over
-        color, bgcolor, attrib = nil, nil, nil
-        catch(:done) do
-          e = e[2..-2]
-          ## first split on commas to separate fg, bg and attr
-          atts = e.split /\s*,\s*/
-          atts.each { |att|  
-            ## next split on =
-            part = att.split /\s*=\s*/
-            case part[0]
-            when "fg"
-              color = part[1]
-            when "bg"
-              bgcolor = part[1]
-            when "/end", "end"
-              yield :endcolor if block_given?
-              #next
-              throw :done
-            else
-              # attrib
-              attrib = part[0]
-            end
-          }
-          yield [color,bgcolor,attrib] if block_given?
-        end # catch
-      else
-        text = e
-        yield text if block_given?
-      end
-    }
-  end
-
-end

data/lib/rbcurse/common/keydefs.rb

@@ -1,30 +0,0 @@
-# ----------------------------------------------------------------------------- #
-#         File: keydefs.rb
-#  Description: Some common keys used in app. Earlier part of rwidget.rb
-#       Author: rkumar http://github.com/rkumar/rbcurse/
-#         Date: 08.11.11 - 14:57
-#      License: Same as Ruby's License (http://www.ruby-lang.org/LICENSE.txt)
-#  Last update: 08.11.11 - 14:57
-# ----------------------------------------------------------------------------- #
-#
-
-# some common definition that we use throughout app. Do not add more, only what is common.
-# I should not have added Sh-F9 and C-left since they are rare, but only to show they exist.
-#
-KEY_TAB    = 9
-KEY_F1  = FFI::NCurses::KEY_F1
-KEY_F10  = FFI::NCurses::KEY_F10
-KEY_ENTER  = 10 # FFI::NCurses::KEY_ENTER gives 343
-KEY_BTAB  = 353 # nc gives same
-KEY_RETURN = 13  # Nc gives 343 for KEY_ENTER
-KEY_DELETE = 330
-KEY_BACKSPACE = KEY_BSPACE = 127 # Nc gives 263 for BACKSPACE
-KEY_CC     = 3   # C-c
-KEY_LEFT  = FFI::NCurses::KEY_LEFT
-KEY_RIGHT  = FFI::NCurses::KEY_RIGHT
-KEY_UP  = FFI::NCurses::KEY_UP
-KEY_DOWN  = FFI::NCurses::KEY_DOWN
-C_LEFT = 18168
-C_RIGHT = 18167
-S_F9 = 17949126
-META_KEY = 128

data/lib/rbcurse/common/widgetshortcuts.rb

@@ -1,302 +0,0 @@
-# ------------------------------------------------------------ #
-#         File: widgetshortcuts.rb 
-#  Description: A common module for shortcuts to create widgets
-#               Also, stacks and flows objects
-#       Author: rkumar http://github.com/rkumar/rbcurse/
-#         Date: 05.11.11 - 15:13 
-#  Last update: 06.11.11 - 10:57
-#  == TODO
-#     add multirow comps like textview and textarea, list
-#     add blocks that make sense like in app
-#     - what if user does not want form attached - app uses useform ot
-#       to check for this, if current_object don't add form
-#
-#     - usage of _position inside means these shortcuts cannot be reused
-#     with other positioning systems, we'll be cut-pasting forever
-#
-#  == CHANGES
-# ------------------------------------------------------------ #
-#
-
-# what is the real purpose of the shortcuts, is it to avoid putting nil
-# for form there if not required.
-# Or is it positioning, such as in a stack. or just a method ?
-module RubyCurses
-  module WidgetShortcuts
-    class Ws
-      attr_reader :config
-      def initialize config={}
-        @config = config
-      end
-      def [](sym)
-        @config[sym]
-      end
-      def []=(sym, val)
-        @config[sym] = val
-      end
-    end
-    class WsStack < Ws; end
-    class WsFlow < Ws; end
-    def widget_shortcuts_init
-      @_ws_app_row = @_ws_app_col = 0
-      @_ws_active = []
-      @_ws_components = []
-      @variables = {}
-    end
-    def field config={}, &block 
-      w = Field.new nil, config #, &block
-      _position w
-      if block
-        w.bind(:CHANGED, &block)
-      end
-      return w
-    end
-    def label config={}, &block 
-      w = Label.new nil, config, &block
-      _position w
-    end
-    def blank
-      label :text => ""
-    end
-    def line config={}
-      #horizontal line TODO
-      #row = config[:row] || @app_row
-      #width = config[:width] || 20
-      #_position config
-      #col = config[:col] || 1
-      #@color_pair = config[:color_pair] || $datacolor
-      #@attrib = config[:attrib] || Ncurses::A_NORMAL
-      #@window.attron(Ncurses.COLOR_PAIR(@color_pair) | @attrib)
-      #@window.mvwhline( row, col, FFI::NCurses::ACS_HLINE, width)
-      #@window.attron(Ncurses.COLOR_PAIR(@color_pair) | @attrib)
-    end
-    def check config={}, &block
-      w = CheckBox.new nil, config #, &block
-      _position w
-      if block
-        w.bind(:PRESS, &block)
-      end
-      return w
-    end
-    def button config={}, &block
-      w = Button.new nil, config #, &block
-      _position w
-      if block
-        w.bind(:PRESS, &block)
-      end
-      return w
-    end
-    def radio config={}, &block
-      a = config[:group]
-      # should we not check for a nil
-      if @variables.has_key? a
-        v = @variables[a]
-      else
-        v = Variable.new
-        @variables[a] = v
-      end
-      config[:variable] = v
-      config.delete(:group)
-      w = RadioButton.new nil, config #, &block
-      _position w
-      if block
-        w.bind(:PRESS, &block)
-      end
-      return w
-    end
-    # editable text area
-    def textarea config={}, &block
-      require 'rbcurse/rtextarea'
-      # TODO confirm events many more
-      events = [ :CHANGE,  :LEAVE, :ENTER ]
-      block_event = events[0]
-      #_process_args args, config, block_event, events
-      #config[:width] = config[:display_length] unless config.has_key? :width
-      # if no width given, expand to flows width
-      #config[:width] ||= @stack.last.width if @stack.last
-      useform = nil
-      #useform = @form if @current_object.empty?
-      w = TextArea.new useform, config
-      w.width = :expand unless w.width
-      w.height ||= 8 # TODO
-      _position(w)
-      # need to expand to stack's width or flows itemwidth if given
-      if block
-        w.bind(block_event, &block)
-      end
-      return w
-    end
-    def textview config={}, &block
-      require 'rbcurse/rtextview'
-      events = [ :LEAVE, :ENTER ]
-      block_event = events[0]
-      #_process_args args, config, block_event, events
-      #config[:width] = config[:display_length] unless config.has_key? :width
-      # if no width given, expand to flows width
-      #config[:width] ||= @stack.last.width if @stack.last
-      useform = nil
-      #useform = @form if @current_object.empty?
-      w = TextView.new useform, config
-      w.width = :expand unless w.width
-      w.height ||= 8 # TODO
-      _position(w)
-      # need to expand to stack's width or flows itemwidth if given
-      if block
-        w.bind(block_event, &block)
-      end
-      return w
-    end
-    def _position w
-      cur = @_ws_active.last
-      # this is outside any stack or flow, so we do the minimal
-      # user should specify row and col
-      unless cur
-        w.row ||= 0
-        w.col ||= 0
-        $log.debug "XXX:  LABEL #{w.row} , #{w.col} "
-        w.set_form @form if @form # temporary,, only set if not inside an object FIXME
-        if w.width == :expand
-          w.width = FFI::NCurses.COLS-0 # or take windows width since this could be in a message box
-        end
-        if w.height == :expand
-          # take from current row, and not zero  FIXME
-          w.height = FFI::NCurses.LINES-0 # or take windows width since this could be in a message box
-        end
-        return
-      end
-      r = cur[:row] || 0
-      c = cur[:col] || 0
-      w.row = r
-      w.col = c
-      if cur.is_a? WsStack
-        r += w.height || 1
-        cur[:row] = r
-      else
-        wid = cur[:item_width] || w.width || 10
-        c += wid + 1
-        cur[:col] = c
-      end
-      if w.width == :expand
-        w.width = cur[:width] or raise "Width not known for stack"
-      end
-      if w.height == :expand
-        w.height = cur[:height] or raise "height not known for flow"
-      end
-      w.color   ||= cur[:color]
-      w.bgcolor ||= cur[:bgcolor]
-      w.set_form @form if @form # temporary
-      @_ws_components << w
-      cur[:components] << w
-    end
-    # make it as simple as possible, don't try to be intelligent or
-    # clever, put as much on the user 
-    def stack config={}, &block
-      s = WsStack.new config
-      _configure s
-      @_ws_active << s
-      yield_or_eval &block if block_given?
-      @_ws_active.pop 
-      
-      # ---- stack is finished now
-      last = @_ws_active.last
-      if last 
-        case last
-        when WsStack
-        when WsFlow
-          last[:col] += last[:item_width] || 0 
-          # this tries to set height of outer flow based on highest row
-          # printed, however that does not account for height of object,
-          # so user should give a height to the flow.
-          last[:height] = s[:row] if s[:row] > (last[:height]||0)
-          $log.debug "XXX: STACK setting col to #{s[:col]} "
-        end
-      end
-
-    end
-    #
-    # item_width - width to use per item 
-    #   but the item width may apply to stacks inside not to items
-    def flow config={}, &block
-      s = WsFlow.new config
-      _configure s
-      @_ws_active << s
-      yield_or_eval &block if block_given?
-      @_ws_active.pop 
-      last = @_ws_active.last
-      if last 
-        case last
-        when WsStack
-          if s[:height]
-            last[:row] += s[:height] 
-          else
-            #last[:row] += last[:highest_row]  
-            last[:row] += 1
-          end
-        when WsFlow
-          last[:col] += last[:item_width] || 0 
-        end
-      end
-    end
-    # flow and stack could have a border option
-    def box config={}, &block
-      require 'rbcurse/extras/box'
-      # take current stacks row and col
-      # advance row by one and col by one
-      # at end note row and advance by one
-      # draw a box around using these coordinates. width should be
-      # provided unless we have item width or something.
-      last = @_ws_active.last
-      if last
-        r = last[:row]
-        c = last[:col]
-        config[:row] = r
-        config[:col] = c
-        last[:row] += config[:margin_top] || 1
-        last[:col] += config[:margin_left] || 1
-        _box = Box.new @form, config # needs to be created first or will overwrite area after others painted
-        yield_or_eval &block if block_given?
-        h = config[:height] || last[:height] || (last[:row] - r)
-        h = 2 if h < 2
-        w = config[:width] || last[:width] || 15 # tmp
-        case last
-        when WsFlow
-          w = last[:col]
-        when WsStack
-          #h += 1
-        end
-        config[:row] = r
-        config[:col] = c
-        config[:height] = h
-        config[:width] = w
-        _box.row r
-        _box.col c
-        _box.height h
-        _box.width w
-        last[:row] += 1
-        last[:col] += 1 # ??? XXX if flow we need to increment properly or not ?
-      end
-    end
-    def _configure s
-      s[:row] ||= 0
-      s[:col] ||= 0
-      s[:row] += (s[:margin_top] || 0)
-      s[:col] += (s[:margin_left] || 0)
-      s[:width] = FFI::NCurses.COLS if s[:width] == :expand
-      last = @_ws_active.last
-      if last
-        if last.is_a? WsStack
-          s[:row] += (last[:row] || 0)
-          s[:col] += (last[:col] || 0)  
-        else
-          s[:row] += (last[:row] || 0)
-          s[:col] += (last[:col] || 0)  # we are updating with item_width as each st finishes
-          s[:width] ||= last[:item_width] # 
-        end
-      end
-      s[:components] = []
-    end
-
-
-
-  end
-end