canis 0.0.4

data/lib/canis/core/util/extras/padreader.rb

@@ -0,0 +1,192 @@
+=begin
+  * Name: PadReader.rb
+  * Description : This is an independent file viewer that uses a Pad and traps keys
+  * Author: jkepler (http://github.com/mare-imbrium/canis/)
+  * Date: 22.10.11 - 20:35
+  * License: Same as Ruby's License (http://www.ruby-lang.org/LICENSE.txt)
+  * Last update:  2013-04-01 13:43
+
+  == CHANGES
+  == TODO 
+     make the window configurable so we can move to a textview that is pad based, later even list ?
+     Note that cursor does not move, in real life applicatino cursor must move to bottom row
+     and only then scrolling should start.
+     NOTE: I have continued this in textpad which is a widget that uses pads to scroll.
+           This is very rough, i may work on this more later.
+=end
+require 'canis'
+
+include Canis
+module Canis
+  class PadReader
+
+    # 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 config={}, &block
+
+      @config = config
+      @rows = FFI::NCurses.LINES-1
+      @cols = FFI::NCurses.COLS-1
+      @prow = @pcol = 0
+      @startrow = 0
+      @startcol = 0
+
+      h = config.fetch(:height, 0)
+      w = config.fetch(:width, 0)
+      t = config.fetch(:row, 0)
+      l = config.fetch(:col, 0)
+      @rows = h unless h == 0
+      @cols = w unless w == 0
+      @startrow = t unless t == 0
+      @startcol = l unless l == 0
+      @suppress_border = config[:suppress_border]
+      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
+      @top = t
+      @left = l
+      view_file config[:filename]
+      @window = config[:window] || Canis::Window.new(:height => h, :width => w, :top => t, :left => l)
+      # print border reduces on from width for some historical reason
+      @window.print_border_only @top, @left, h-1, w, $datacolor
+      @ph = @content_rows
+      @pw = @content_cols # get max col
+      @pad = FFI::NCurses.newpad(@ph, @pw)
+
+      Ncurses::Panel.update_panels
+      @content.each_index { |ix|
+
+        FFI::NCurses.mvwaddstr(@pad,ix, 0, @content[ix])
+      }
+      @window.wrefresh
+      padrefresh
+      #FFI::NCurses.prefresh(@pad, 0,0, @startrow ,@startcol, @rows,@cols);
+
+      @window.bkgd(Ncurses.COLOR_PAIR(5));
+      FFI::NCurses.keypad(@pad, true);
+      #@form = Form.new @window
+      config[:row] = config[:col] = 0 # ??? XXX
+    end
+
+    private
+    def view_file(filename)
+      @file = filename
+      @content = File.open(filename,"r").readlines
+      @content_rows = @content.count
+      @content_cols = content_cols()
+      #run()
+    end
+    # write pad onto window
+    private
+    def padrefresh
+      FFI::NCurses.prefresh(@pad,@prow,@pcol, @startrow,@startcol, @rows + @startrow,@cols+@startcol);
+    end
+    # returns button index
+    # Call this after instantiating the window
+    public
+    def run
+      #@form.repaint
+      #@window.wrefresh
+      return handle_keys
+    end
+
+    # convenience method
+    private
+    def key x
+      x.getbyte(0)
+    end
+    def content_cols
+      longest = @content.max_by(&:length)
+      longest.length
+    end
+
+    # returns button index
+    private
+    def handle_keys
+      ht = @window.height.ifzero FFI::NCurses.LINES-1
+      buttonindex = catch(:close) do 
+        @maxrow = @content_rows - @rows
+        @maxcol = @content_cols - @cols 
+        while((ch = @window.getchar()) != FFI::NCurses::KEY_F10 )
+          #while((ch = FFI::NCurses.wgetch(@pad)) != FFI::NCurses::KEY_F10 )
+          break if ch == ?\C-q.getbyte(0) 
+          begin
+            case ch
+            when key(?g), 279 # home as per iterm2
+              @prow = 0
+            when key(?b), key(?G), 277 # end as per iterm2
+              @prow = @maxrow-1
+            when key(?j)
+              @prow += 1
+            when key(?k)
+              @prow -= 1
+            when 32, 338   # Page Down abd Page Up as per iTerm2
+              @prow += 10
+            when key(?\C-d)
+              @prow += ht
+            when key(?\C-b)
+              @prow -= ht
+            when 339
+              @prow -= 10
+            when key(?l)
+              @pcol += 1
+            when key(?$)
+              @pcol = @maxcol - 1
+            when key(?h)
+              @pcol -= 1
+            when key(?0)
+              @pcol = 0
+            when key(?q)
+              throw :close
+            else 
+              alert " #{ch} not mapped "
+            end
+            @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
+            #@window.wclear
+            #FFI::NCurses.prefresh(@pad,@prow,@pcol, @startrow,0, @rows,@cols);
+            padrefresh
+            Ncurses::Panel.update_panels
+            #@form.handle_key(ch)
+            #@window.wrefresh
+          rescue => err
+            $log.debug( err) if err
+            $log.debug(err.backtrace.join("\n")) if err
+
+            textdialog ["Error in padreader: #{err} ", *err.backtrace], :title => "Exception"
+            $error_message.value = ""
+          ensure
+          end
+
+        end # while loop
+      end # close
+      $log.debug "XXX: CALLER GOT #{buttonindex} "
+      @window.destroy unless @config[:window]
+      FFI::NCurses.delwin(@pad)
+      return buttonindex 
+    end
+  end
+end
+if __FILE__ == $PROGRAM_NAME
+  require 'canis/core/util/app'
+  App.new do
+    #status_line :row => FFI::NCurses.LINES-1
+    @form.repaint
+    #p = PadReader.new :filename => "padreader.rb", :height => 20, :width => 60, :row => 4, :col => 4, :window => @window, :suppress_border => true
+    p = PadReader.new :filename => "padreader.rb", :height => FFI::NCurses.LINES-1, :width => 0, :row => 0, :col => 0, :window => @window, :suppress_border => true
+    p.run
+    throw :close
+  end
+end

data/lib/canis/core/util/focusmanager.rb

@@ -0,0 +1,31 @@
+# Allow some objects to take focus when a certain key is pressed.
+# This is for objects like scrollbars and grabbars. We don't want these always
+# getting focus, only sometimes when we want to resize panes.
+# This will not only be included by Form but by containers such as Vimsplit
+# or MasterDetail.
+# Usage: the idea is that when you create grabbars, you would add them to the FocusManager
+# Thus they would remain non-focusable on creation. When hte user presses (say F3) then
+# make_focusable is called, or toggle_focusable. Now user can press TAB and access
+# these bars. When he is done he can toggle again.
+# TODO: we might add a Circular class here so user can traverse only these objects
+module Canis
+  module FocusManager
+    extend self
+    attr_reader :focusables
+    # add a component to this list so it can be made focusable later
+    def add component
+      @focusables ||= []
+      @focusables << component
+      self
+    end
+    def make_focusable bool=true
+      @focusing = bool
+      @focusables.each { |e| e.focusable(bool) }
+    end
+    def toggle_focusable
+      return unless @focusables
+      alert "FocusManager Making #{@focusables.length} objects #{!@focusing} "
+      make_focusable !@focusing
+    end
+  end
+end

data/lib/canis/core/util/helpmanager.rb

@@ -0,0 +1,160 @@
+# ----------------------------------------------------------------------------- #
+#         File: helpmanager.rb
+#  Description: manages display of help text and hyperlinking with other files in doc dir.
+#       Author: j kepler  http://github.com/mare-imbrium/canis/
+#         Date: 2014-07-08 - 20:59
+#      License: MIT
+#  Last update: 2014-07-08 21:07
+# ----------------------------------------------------------------------------- #
+#  helpmanager.rb  Copyright (C) 2012-2014 j kepler
+#  TODO
+#   - the method display_help is huge and a mess. That part needs to be a class.
+module Canis
+  CANIS_DOCPATH = File.dirname(File.dirname(__FILE__)) + "/docs/"
+
+  # manages the help file of an application and the inbuilt help the application provides
+  #  for the widgets.
+  class HelpManager  # {{{
+    def initialize form, config={}, &block
+      @form = form
+       #super
+       #instance_eval &block if block_given?
+    end
+    def help_text text=nil
+      if text
+        @help_text = text
+      end
+      return @help_text
+    end
+    # Assign help text to variable
+    # @param [String] help text is a string with newlines, or an Array. Will be split if String.
+    #     May use markup for help files which is a very limited subset of markdown.
+    def help_text=(text); help_text(text); end
+
+    # Displays help provided by program. If no program is specified, then default help
+    # is displayed. If help was provided, then default help is also displayed on next page
+    # after program's help
+    def display_help
+      require 'canis/core/util/textutils'
+      filename = CANIS_DOCPATH + "index.txt"
+      stylesheet = CANIS_DOCPATH + "style_help.yml"
+      # defarr contains default help
+      if File.exists?(filename)
+        defarr = File.open(filename,'r').read.split("\n")
+        # convert help file into styles for use by tmux
+        # quick dirty converter for the moment
+        defarr = Canis::TextUtils::help2tmux defarr
+      else
+        arr = []
+        arr << "  Could not find help file for application "
+        arr << "    "
+        arr << "Most applications provide the following keys, unless overriden:"
+        arr << "    "
+        arr << "    F10         -  exit application "
+        arr << "    C-q         -  exit application "
+        arr << "    ? (or M-?)  -  current widget key bindings  "
+        arr << "    "
+        arr << "    Alt-x       -  select commands  "
+        arr << "    : (or M-:)  -  select commands  "
+        arr << "    "
+        defarr = arr
+      end
+      defhelp = true
+      if @help_text
+        defhelp = false
+        arr = @help_text
+        arr = arr.split("\n") if arr.is_a? String
+        arr = Canis::TextUtils::help2tmux arr # FIXME can this happen automatically if it is help format
+      else
+        arr = defarr
+      end
+      #w = arr.max_by(&:length).length
+      h = FFI::NCurses.LINES - 4
+      w = FFI::NCurses.COLS - 10
+      wbkgd = get_color($reversecolor, :black, :cyan)
+
+      require 'canis/core/util/viewer'
+      # this was the old layout that centered with a border, but was a slight bit confusing since the bg was the same
+      # as the lower window.
+      _layout = [h, w, 2, 4]
+      sh = Ncurses.LINES-1
+      sc = Ncurses.COLS-0
+      # this is the new layout that is much like bline's command list. no border, a thick app header on top
+      #  and no side margin
+      #  Suppressing border means that title will not be updated on app_header, we have to do so FIXME
+      _layout = [ h, sc, sh - h, 0]
+      doc = TextDocument.new :text => arr, :content_type => :tmux, :stylesheet => stylesheet
+      Canis::Viewer.view(doc, :layout => _layout, :close_key => KEY_F10, :title => "[ Help ]", :print_footer => true,
+                        :app_header => true ) do |t, items|
+        # would have liked it to be 'md' or :help
+        #t.content_type = :tmux
+        #t.stylesheet   = stylesheet
+        t.suppress_borders = true
+        t.print_footer = false
+        t.bgcolor = :black
+        t.bgcolor = 16
+        t.color = :white
+        ah = items[:header]
+        t.bind(:PROPERTY_CHANGE) { |eve|
+          # title is not a property, so we check if text has changed and then look for title.
+          if eve.property_name == :text
+            #$log.debug "  PROP NAME IS #{eve.property_name} , title is #{t.title} "
+            ah.text_center = t.title
+          end
+        }
+        #t.text_patterns[:link] = Regexp.new(/\[[^\]]\]/)
+        t.text_patterns[:link] = Regexp.new(/\[\w+\]/)
+        t.bind_key(KEY_TAB, "goto link") { t.next_regex(:link) }
+        # FIXME bgcolor add only works if numberm not symbol
+        t.bind_key(?a, "increment bgcolor") { t.bgcolor += 1 ; t.bgcolor = 1 if t.bgcolor > 256; 
+                                      $log.debug " HELP BGCOLOR is #{t.bgcolor} ";
+                                      t.clear_pad; t.render_all }
+        t.bind(:PRESS){|eve| 
+          link = nil
+          s = eve.word_under_cursor
+          if is_link?(t, s)
+            link = get_link(t, s)
+          end
+          #alert "word under cursor is #{eve.word_under_cursor}, link is #{link}"
+          if link
+            arr = read_help_file link
+            if arr
+              doc = TextDocument.new :text => arr, :content_type => :tmux, :stylesheet => stylesheet, :title => link
+              #t.add_content arr, :title => link
+              t.add_content doc
+              #items[:header].text_center = "[#{link}]" 
+              t.buffer_last
+            else
+              alert "No help file for #{link}"
+            end
+          else
+          end
+        }
+
+        # help was provided, so default help is provided in second buffer
+        unless defhelp
+          doc = TextDocument.new :text => defarr, :content_type => :tmux, :stylesheet => stylesheet, :title => " General Help "
+          #t.add_content defarr, :title => ' General Help ', :stylesheet => stylesheet, :content_type => :tmux
+          t.add_content doc
+        end
+      end
+    end
+    def is_link? t, s
+      s.index(t.text_patterns[:link]) >= 0
+    end
+    def get_link t, s
+      s.match(t.text_patterns[:link])[0].gsub!(/[\[\]]/,"")
+    end
+    def read_help_file link
+      filename = CANIS_DOCPATH + "#{link}.txt"
+      defarr = nil
+      # defarr contains default help
+      if File.exists?(filename)
+        defarr = File.open(filename,'r').read.split("\n")
+        # convert help file into styles for use by tmux
+        # quick dirty converter for the moment
+        defarr = Canis::TextUtils::help2tmux defarr
+      end
+    end
+  end # class }}}
+end

data/lib/canis/core/util/oldwidgetshortcuts.rb

@@ -0,0 +1,304 @@
+# ------------------------------------------------------------ #
+#         File: widgetshortcuts.rb 
+#  Description: A common module for shortcuts to create widgets
+#               Also, stacks and flows objects
+#       Author: jkepler http://github.com/mare-imbrium/canis/
+#         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 ?
+require 'canis/core/widgets/rlist'
+require 'canis/core/widgets/rtextview'
+module Canis
+  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
+      return 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 'canis/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
+      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 'canis/core/widgets/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