ffi-ncurses 0.3.3 → 0.4.0

data/lib/ffi-ncurses/ncurses.rb

@@ -0,0 +1,176 @@
+# Ncurses compatiblity layer.
+require "ffi-ncurses"
+require 'ffi-ncurses/ord_shim'  # for 1.8.6 compatibility
+
+def log(*a)
+  File.open("ncurses.log", "a") do |file|
+    file.puts(a.inspect)
+  end
+end
+
+module FFI
+  module NCurses
+    # Methods to help wrap FFI::NCurses methods to be compatible with Ncurses.
+    module Compatibility
+      extend self
+
+      def lookup_signature(method)
+        FFI::NCurses::FUNCTION_SIGNATURES.assoc(method)
+      end
+
+      def unbox_args(signature, args)
+        if signature
+        signature[1].zip(args).map{ |sig, arg|
+          case sig
+          when :window_p
+            #log :unbox_args, signature, arg, arg.respond_to?(:win)
+            if arg.respond_to?(:win)
+              #log :unbox_args, :win, arg.win
+              arg.win
+            else
+              #log :unbox_args, :nowin, arg
+              arg
+            end
+          when :chtype
+            arg.ord
+          else
+            arg
+          end
+        }
+        else
+          args
+        end
+      end
+    end
+  end
+end
+
+module Ncurses
+  module NCX
+    def COLS
+      FFI::NCurses.getmaxx(FFI::NCurses.stdscr)
+    end
+
+    def LINES
+      FFI::NCurses.getmaxy(FFI::NCurses.stdscr)
+    end
+
+    def has_colors?
+      FFI::NCurses.has_colors
+    end
+  end
+  include NCX
+  extend NCX
+
+  class WINDOW
+    attr_accessor :win
+
+    def initialize(*args, &block)
+      # SOH: Lifted from Ncurses. One example of how truly horrible
+      # that interface is (using the existence of an otherwise useless
+      # block as a flag).
+      if block_given?
+        @win = args.first
+      else
+        @win = FFI::NCurses.newwin(*args)
+      end
+    end
+
+    # Lifted from Ncurses.
+    def method_missing(name, *args)
+      # log(:mm, 1, name)
+      name = name.to_s
+      if name[0,2] == "mv"
+        # log(:mm, 2, "mv")
+        test_name = name.dup
+        test_name[2,0] = "w" # insert "w" after"mv"
+        if FFI::NCurses.respond_to?(test_name)
+          # log(:mm, 2.1, test_name)
+          Ncurses.send(test_name, @win, *args)
+        else
+          super
+        end
+      else
+        # log(:mm, 3, "w")
+        test_name = "w" + name
+        if FFI::NCurses.respond_to?(test_name)
+          # log(:mm, 4, test_name)
+          Ncurses.send(test_name, @win, *args)
+        elsif FFI::NCurses.respond_to?(name)
+          # log(:mm, 5, name)
+          Ncurses.send(name, @win, *args)
+        else
+          super
+        end
+      end
+    end
+
+    def respond_to?(name)
+      if super
+        true
+      else
+        name = name.to_s
+        if name[0,2] == "mv" && FFI::NCurses.respond_to?("mvw" + name[2..-1])
+          true
+        else
+          FFI::NCurses.respond_to?("w" + name) || FFI::NCurses.respond_to?(name)
+        end
+      end
+    end
+
+    def del
+      FFI::NCurses.delwin(@win)
+    end
+    alias delete del
+
+  end
+
+  def self.initscr
+    @stdscr = Ncurses::WINDOW.new(FFI::NCurses.initscr) { }
+  end
+
+  def initscr
+    Ncurses.initscr
+  end
+
+  def self.stdscr
+    @stdscr
+  end
+
+  def stdscr
+    Ncurses.stdscr
+  end
+
+  module MM
+    def method_missing(method, *args, &block)
+      if FFI::NCurses.respond_to?(method)
+        signature = FFI::NCurses::Compatibility.lookup_signature(method)
+        args = FFI::NCurses::Compatibility.unbox_args(signature, args)
+        res = FFI::NCurses.send(method, *args, &block)
+        # log :MM, signature, res
+        if signature && signature.last == :window_p && res.kind_of?(FFI::Pointer)
+          Ncurses::WINDOW.new(res) { }
+        else
+          res
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to?(method)
+      FFI::NCurses.respond_to?(method)
+    end
+  end
+  include MM
+  extend MM
+
+  TRUE  = true
+  FALSE = false
+
+  include FFI::NCurses::Color
+  include FFI::NCurses::Attributes
+  include FFI::NCurses::KeyDefs
+  include FFI::NCurses::Constants
+  include FFI::NCurses::Mouse
+end

data/lib/ffi-ncurses/panel.rb

@@ -0,0 +1,21 @@
+# typedef struct panel
+# {
+#   WINDOW *win;
+#   struct panel *below;
+#   struct panel *above;
+#   NCURSES_CONST void *user;
+# } PANEL;
+
+module FFI
+  module NCurses
+    module PanelStruct
+      class Panel < FFI::Struct
+        layout \
+        :win, :pointer,   # WINDOW*
+        :below, :pointer, # PANEL*
+        :above, :pointer, # PANEL*
+        :user, :pointer   # void*
+      end
+    end
+  end
+end

data/lib/ffi-ncurses/typedefs.rb

@@ -0,0 +1,35 @@
+module FFI
+  module NCurses
+    extend FFI::Library
+
+    # If I define my own typedefs, a bug in FFI (at least 0.6.3) means
+    # I have to redefine the built-in types if they're going to be
+    # used in variadic functions
+    FFI::TypeDefs.keys.each do |key|
+      typedef key, key
+    end
+
+    typedef :ulong,   :attr_t
+    typedef :pointer, :attr_t_p
+    typedef :pointer, :cchar_t_p
+    typedef :ulong,   :chtype
+    typedef :pointer, :chtype_p
+    typedef :pointer, :file_p
+    typedef :pointer, :int_p
+    typedef :pointer, :mevent_p
+    typedef :ulong,   :mmask_t
+    typedef :pointer, :mmask_t_p
+    typedef :pointer, :panel_p
+    typedef :pointer, :screen_p
+    typedef :pointer, :short_p
+    typedef :ushort,  :wchar_t
+    typedef :pointer, :wchar_t_p
+    typedef :pointer, :window_p
+    typedef :int,     :wint_t    # An integral type capable of storing any valid value of wchar_t, or WEOF
+    typedef :pointer, :wint_t_p
+
+  end
+end
+
+# Refs:
+# http://pubs.opengroup.org/onlinepubs/007908799/xsh/wchar.h.html

data/lib/ffi-ncurses/version.rb

@@ -0,0 +1,7 @@
+module FFI
+  module NCurses
+    NAME    = "ffi-ncurses"
+    VERSION = "0.4.0"
+  end
+end
+

data/lib/ffi-ncurses/widechars.rb

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+
+module WideChars
+  def display_width(txt)
+    #buffer_size = (FFI::WideChars.mbstowcs(nil, self, 0) + 1) * FFI::WideChars.find_type(:wchar_t).size
+    wchar_t = FFI::WideChars.find_type(:wchar_t)
+    buffer_size = (txt.size + 1) * wchar_t.size
+    buffer = FFI::Buffer.new(wchar_t, buffer_size)
+    rv = FFI::WideChars.mbstowcs(buffer, txt, txt.size)
+    if rv == -1
+      raise ArgumentError, "Invalid multibyte sequence"
+    else
+      rv = FFI::WideChars.wcswidth(buffer, rv)
+      if rv == -1
+        raise ArgumentError, "Wide character string contains non-printable characters"
+      else
+        rv
+      end
+    end
+  end
+
+  if RUBY_VERSION < '1.9.0'
+    def display_slice(txt, start, length = 1)
+      count = 0
+      str = ""
+      if start.kind_of?(Range)
+        limit = start.last + (start.exclude_end? ? 0 : 1)
+        start = start.first
+      else
+        limit = start + length
+      end
+      txt.each_char do |char|
+        if count >= start && count < limit
+          str << char
+        end
+        count += 1
+      end
+      str
+    end
+  else
+    def display_slice(txt, *args, &b)
+      txt.slice(*args, &b)
+    end
+  end
+
+  extend self
+end
+
+module FFI
+  module WideChars
+    extend FFI::Library
+
+    FFI::TypeDefs.keys.each do |key|
+      typedef key, key
+    end
+
+    typedef :ulong,   :attr_t
+    typedef :pointer, :attr_t_p
+    typedef :pointer, :cchar_t_p
+    typedef :ulong,   :chtype
+    typedef :pointer, :chtype_p
+    typedef :pointer, :file_p
+    typedef :pointer, :int_p
+    typedef :pointer, :mevent_p
+    typedef :ulong,   :mmask_t
+    typedef :pointer, :mmask_t_p
+    typedef :pointer, :panel_p
+    typedef :pointer, :screen_p
+    typedef :pointer, :short_p
+    typedef :ushort,  :wchar_t
+    typedef :pointer, :wchar_t_p
+    typedef :pointer, :window_p
+    typedef :pointer, :wint_t_p
+
+    # add some functions for handling widechars
+    FUNCTIONS = [
+                 [:mbstowcs, [:pointer, :string, :size_t], :int],
+                 [:setlocale, [:int, :string], :string],
+                 [:wcwidth, [:wchar_t], :int],
+                 [:wcswidth, [:wchar_t_p, :size_t], :int],
+                ]
+    FUNCTION_SIGNATURES = Marshal.load(Marshal.dump(FUNCTIONS))
+
+    LIB_HANDLE = { }
+    LIB_HANDLE[:c] = ffi_lib(FFI::Library::LIBC) # for wcwidth, wcswidth
+    FUNCTIONS.each do |function|
+      attach_function *function
+    end
+
+    #if RUBY_VERSION < '1.9.0'
+    lc_all = 0
+    setlocale(lc_all, "")
+    #end
+  end
+end
+
+# JRuby 1.6 --1.9 fails when using wcswidth on multichar string
+# but seems to work when you feed it character by character.
+# Also, this seems to be the only safe version.
+
+# This won't work in 1.8.7 (chars == bytes)
+module WideCharsJR
+  def display_width2
+    width = 0
+    wchar_t_size = FFI::WideChars.find_type(:wchar_t).size
+    # we rely on Ruby to convert a char into a mbs
+    each_char do |ch|
+      buffer_size = (ch.size + 1) * wchar_t_size
+      # p [:size, size]
+      buffer = FFI::Buffer.new(FFI::WideChars.find_type(:wchar_t), buffer_size)
+      rv = FFI::WideChars.mbstowcs(buffer, ch, ch.size)
+      # p [:mbstowcs, rv]
+      if rv == -1
+        raise ArgumentError, "Invalid multibyte sequence"
+      else
+        rv = FFI::WideChars.wcswidth(buffer, rv)
+        # p [:wcswidth, rv]
+        if rv == -1
+          raise ArgumentError, "Wide character string contains non-printable characters"
+        else
+          width += rv
+        end
+      end
+    end
+    width
+  end
+end
+
+class String
+  def display_width
+    WideChars.display_width(self)
+  end
+  def display_slice(*args, &b)
+    WideChars.display_slice(self, *args, &b)
+  end
+end
+

data/lib/ffi-ncurses/winstruct.rb

@@ -1,23 +1,20 @@
 module FFI
   module NCurses
     module WinStruct
-      NCURSES_SIZE_T = :short
-      NCURSES_ATTR_T = :int
+      NCURSES_SIZE_T  = :short
+      NCURSES_ATTR_T  = :int
       NCURSES_COLOR_T = :short
-      NCURSES_CH_T = :short
+      NCURSES_CH_T    = :short
+      BOOLEAN         = :uchar              # sizeof(bool) == 1
+      WCHAR_T         = :ushort
+      CHTYPE          = :ulong
+      CCHARW_MAX      = 5
 
-      CHTYPE = :ulong
-      CCHARW_MAX = 5
-
-      BOOLEAN = :uchar              # sizeof(bool) == 1
-
-      WCHAR_T = :ushort
-      
-      #   class CCharT < FFI::Struct
-      #     layout \
-      #     :attr, NCURSES_ATTR_T,
-      #     :chars, [WCHAR_T, CCHARW_MAX]
-      #   end
+      class CCharT < FFI::Struct
+        layout \
+        :attr, NCURSES_ATTR_T,
+        :chars, [WCHAR_T, CCHARW_MAX]
+      end
 
       class PDat < FFI::Struct
         layout \
@@ -57,57 +54,82 @@ module FFI
         :_regtop, NCURSES_SIZE_T,
         :_regbottom, NCURSES_SIZE_T,
 
-        # why x,y when everything else is y,x?
+        # aside: why x,y when everything else is y,x?
         :_parx, :int,
         :_pary, :int,
-        :_parent, :pointer          # WINDOW
+        :_parent, :pointer,          # WINDOW
 
-        # don't know how to include nested Struct yet
-        #     :_pad, PDat,
-        
-        #     :_yoffset, NCURSES_SIZE_T
-        #     :_bkgrnd, CCharT
+        # nested struct (for Pads)
+        :_pad, PDat,  # NB. Rubinius doesn't like this (but Rubinius FFI is very far behind...)
+        #:_pad, :pointer,
+        :_yoffset, NCURSES_SIZE_T,
+        :_bkgrnd, :pointer #CCharT
       end
 
       def _win(win, member)
+        # TODO: raise exception if win.nil?
         win && WinSt.new(win)[member]
       end
       private :_win
-      
+
       # extensions - not in X/Open
+
+      # consider all data in the window invalid?
       def is_cleared(win)
-        _win(win, :_clear)
+        _win(win, :_clear) != 0
       end
+
+      # OK to use insert/delete char?
       def is_idcok(win)
-        _win(win, :_idcok)
+        _win(win, :_idcok) != 0
       end
+
+      # OK to use insert/delete line?
       def is_idlok(win)
-        _win(:win, :_idlok)
+        _win(:win, :_idlok) != 0
       end
+
+      # window in immed mode? (not yet used)
       def is_immedok(win)
-        _win(win, :_immed)
+        _win(win, :_immed) != 0
       end
+
+      # process function keys into KEY_ symbols?
       def is_keypad(win)
-        _win(win, :_use_keypad)
+        _win(win, :_use_keypad) != 0
       end
+
+      # OK to not reset cursor on exit?
       def is_leaveok(win)
-        _win(win, :_leaveok) || ERR
+        # I've changed this to return true or false - ncurses returns ERR if not true
+        # (_win(win, :_leaveok) != 0) || ERR # why ERR - why not false?
+        _win(win, :_leaveok) != 0
       end
+
+      # 0 = nodelay, <0 = blocking, >0 = delay
       def is_nodelay(win)
-        _win(win, :_delay) == 0 ? FFI::NCurses::TRUE : FFI::NCurses::FALSE
+        _win(win, :_delay) == 0
       end
+
+      # no time out on function-key entry?
       def is_notimeout(win)
-        _win(win, :_notimeout)
+        _win(win, :_notimeout) != 0
       end
+
+      # OK to scroll this window?
       def is_scrollok(win)
-        _win(win, :_scroll)
+        _win(win, :_scroll) != 0
       end
+
+      # window in sync mode?
       def is_syncok(win)
-        _win(win, :_sync)
+        _win(win, :_sync) != 0
       end
+
       def wgetparent(win)
         _win(win, :_parent)
       end
+
       def wgetscrreg(win, t, b)
         # ((win) ? (*(t) = (win)->_regtop, *(b) = (win)->_regbottom, OK) : ERR)
         # not entirely satisfactory - no error return