ffi-ncurses 0.3.3 → 0.4.0

data/examples/wacs_chars.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8; -*-
+require 'ffi-ncurses'
+
+include FFI::NCurses
+
+def main
+  begin
+    initscr
+
+    # FIXME: This isn't working in 1.8.x
+    def addwch(ch)
+      cchar = WinStruct::CCharT.new
+      cchar[:chars][0] = ch
+      # cchar[:attr] = WA_REVERSE
+      # chars = [ch].pack('S')
+      # padding = 5 - chars.size
+      # cchar = [WA_REVERSE].pack('L') + chars + ([0] * padding).pack('S')
+      wadd_wch(stdscr, cchar)
+    end
+
+    addstr("Upper left corner           "); addwch(WACS_ULCORNER); addstr("\n");
+    addstr("Lower left corner           "); addwch(WACS_LLCORNER); addstr("\n");
+    addstr("Lower right corner          "); addwch(WACS_LRCORNER); addstr("\n");
+    addstr("Tee pointing right          "); addwch(WACS_LTEE); addstr("\n");
+    addstr("Tee pointing left           "); addwch(WACS_RTEE); addstr("\n");
+    addstr("Tee pointing up             "); addwch(WACS_BTEE); addstr("\n");
+    addstr("Tee pointing down           "); addwch(WACS_TTEE); addstr("\n");
+    addstr("Horizontal line             "); addwch(WACS_HLINE); addstr("\n");
+    addstr("Vertical line               "); addwch(WACS_VLINE); addstr("\n");
+    addstr("Large Plus or cross over    "); addwch(WACS_PLUS); addstr("\n");
+    addstr("Scan Line 1                 "); addwch(WACS_S1); addstr("\n");
+    addstr("Scan Line 3                 "); addwch(WACS_S3); addstr("\n");
+    addstr("Scan Line 7                 "); addwch(WACS_S7); addstr("\n");
+    addstr("Scan Line 9                 "); addwch(WACS_S9); addstr("\n");
+    addstr("Diamond                     "); addwch(WACS_DIAMOND); addstr("\n");
+    addstr("Checker board (stipple)     "); addwch(WACS_CKBOARD); addstr("\n");
+    addstr("Degree Symbol               "); addwch(WACS_DEGREE); addstr("\n");
+    addstr("Plus/Minus Symbol           "); addwch(WACS_PLMINUS); addstr("\n");
+    addstr("Bullet                      "); addwch(WACS_BULLET); addstr("\n");
+    addstr("Arrow Pointing Left         "); addwch(WACS_LARROW); addstr("\n");
+    addstr("Arrow Pointing Right        "); addwch(WACS_RARROW); addstr("\n");
+    addstr("Arrow Pointing Down         "); addwch(WACS_DARROW); addstr("\n");
+    addstr("Arrow Pointing Up           "); addwch(WACS_UARROW); addstr("\n");
+    addstr("Board of squares            "); addwch(WACS_BOARD); addstr("\n");
+    addstr("Lantern Symbol              "); addwch(WACS_LANTERN); addstr("\n");
+    addstr("Solid Square Block          "); addwch(WACS_BLOCK); addstr("\n");
+    addstr("Less/Equal sign             "); addwch(WACS_LEQUAL); addstr("\n");
+    addstr("Greater/Equal sign          "); addwch(WACS_GEQUAL); addstr("\n");
+    addstr("Pi                          "); addwch(WACS_PI); addstr("\n");
+    addstr("Not equal                   "); addwch(WACS_NEQUAL); addstr("\n");
+    addstr("UK pound sign               "); addwch(WACS_STERLING); addstr("\n");
+
+    refresh
+    getch
+  rescue => e
+    endwin
+    raise
+  ensure
+    endwin
+  end
+end
+
+main

data/examples/windows.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+#
+# Sean O'Halpin, 2009-02-15
+#
+require 'ffi-ncurses'
+require 'ffi-ncurses/widechars'
+include FFI::NCurses
+
+def log(*a)
+  addstr a.inspect + "\n"
+  touchwin(stdscr)
+  # STDERR.puts a.inspect
+end
+
+begin
+  initscr
+  curs_set 0
+  raw
+  noecho
+  keypad stdscr, true
+  scrollok stdscr, true
+  txt = "Press cursor keys to move window"
+  win = newwin(7, txt.size + 4, 4, 15)
+  box(win, 0, 0)
+  inner_win = derwin(win, 4, txt.size + 2, 2, 2)
+  wmove(inner_win, 0, 0)
+  waddstr(inner_win, txt)
+  wmove(inner_win, 2, 0)
+  waddstr(inner_win, "Press Ctrl-Q to quit")
+
+  y, x = getbegyx(win)
+  move 0, 0
+  log :y, y, :x, x
+  refresh
+  wrefresh(win)
+  wrefresh(inner_win)
+
+  ch = 0
+  while (ch = getch) != KEY_CTRL_Q
+    y, x = getbegyx(win)
+    old_y, old_x = y, x
+    log :y, y, :x, x, :ch, ch, keyname(ch)
+    # move 0, 0
+    # addstr "y %d x %d" % [y, x]
+    case ch
+    when KEY_RIGHT
+      x += 1
+    when KEY_LEFT
+      x -= 1
+    when KEY_UP
+      y -= 1
+    when KEY_DOWN
+      y += 1
+    end
+    rv = mvwin(win, y, x)
+    log :y1, y, :x1, x, :rv, rv
+    if rv == ERR
+      # put the window back
+      rv = mvwin(win, old_y, old_x)
+    end
+
+    # tell ncurses we want to refresh stdscr (to erase win's frame)
+    touchwin(stdscr)
+    refresh
+    wrefresh(win)
+  end
+
+rescue Object => e
+  endwin
+  puts e
+ensure
+  endwin
+end

data/ffi-ncurses.gemspec

@@ -1,57 +1,44 @@
-# -*- encoding: utf-8 -*-
+# -*- coding: utf-8 -*-
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 
-Gem::Specification.new do |s|
-  s.name = %q{ffi-ncurses}
-  s.version = "0.3.3"
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Sean O'Halpin"]
-  s.date = %q{2009-02-24}
-  s.description = <<-EOT
-A wrapper for ncurses 5.x. Tested on Ubuntu 8.04 to 10.04 and Mac OS X
-10.4 (Tiger) with ruby 1.8.6, 1.8.7 and 1.9.x using ffi (>= 0.6.3) and
-JRuby 1.5.1.
+require 'ffi-ncurses/version'
+
+date         = "2011-09-25"
+authors      = ["Sean O'Halpin"]
+email        = "sean.ohalpin@gmail.com"
+project      = FFI::NCurses
+description  = "An FFI wrapper around ncursesw 5.x for MRI Ruby 1.8.x, 1.9.x and JRuby."
+dependencies = [
+                ["ffi", ">= 1.0.9"],
+                ["ffi-locale", ">= 1.0.0"],
+               ]
 
-The API is a transliteration of the C API rather than an attempt to
-provide an idiomatic Ruby object-oriented API.
+Gem::Specification.new do |s|
+  s.authors     = authors
+  s.email       = email
+  s.date        = date
+  s.description = description
+  dependencies.each do |dep|
+    s.add_dependency *dep
+  end
+  s.files =
+    [
+     "#{project::NAME}.gemspec",
+     "lib/#{project::NAME}.rb",
+     "COPYING",
+     "History.txt",
+     "README.rdoc",
+     "Rakefile",
+     "Gemfile",
+     "Gemfile.lock",
+    ] +
+    Dir["examples/**/*"] +
+    Dir["lib/**/*.rb"] +
+    Dir["spec/**/*.rb"]
 
-See the examples directory for real working examples.
-EOT
-  s.email = %q{sean.ohalpin@gmail.com}
-  s.extra_rdoc_files = ["History.txt", "README.rdoc"]
-  s.files = [
-             "History.txt",
-             "README.rdoc",
-             "examples/doc-eg1.rb",
-             "examples/doc-eg2.rb",
-             "examples/doc-eg3.rb",
-             "examples/example-attributes.rb",
-             "examples/example-colour.rb",
-             "examples/example-cursor.rb",
-             "examples/example-getsetsyx.rb",
-             "examples/example-hello.rb",
-             "examples/example-jruby.rb",
-             "examples/example-keys.rb",
-             "examples/example-mouse.rb",
-             "examples/example-printw-variadic.rb",
-             "examples/example-softkeys.rb",
-             "examples/example-stdscr.rb",
-             "examples/example-windows.rb",
-             "examples/example.rb",
-             "examples/ncurses-example.rb",
-             "ffi-ncurses.gemspec",
-             "lib/ffi-ncurses.rb",
-             "lib/ffi-ncurses/darwin.rb",
-             "lib/ffi-ncurses/keydefs.rb",
-             "lib/ffi-ncurses/mouse.rb",
-             "lib/ffi-ncurses/ord-shim.rb",
-             "lib/ffi-ncurses/winstruct.rb"
-            ]
-  s.has_rdoc = true
-  s.homepage = %q{http://github.com/seanohalpin/ffi-ncurses}
-  s.rdoc_options = ["--main", "README.rdoc"]
+  s.name          = project::NAME
+  s.version       = project::VERSION
+  s.homepage      = "http://github.com/seanohalpin/#{project::NAME}"
+  s.summary       = s.description
   s.require_paths = ["lib"]
-  s.rubyforge_project = %q{ffi-ncurses}
-  s.rubygems_version = %q{1.3.1}
-  s.summary = %q{FFI wrapper for ncurses}
-  s.add_dependency("ffi", ">= 0.6.3")
 end

data/lib/ffi-ncurses.rb

@@ -1,437 +1,137 @@
-# ruby-ffi wrapper for ncurses
-# Sean O'Halpin
-# version 0.1.0 - 2008-12-04
-# version 0.2.0 - 2009-01-18
-# version 0.3.0 - 2009-01-31
-# - added stdscr, newscr, curscr
-# version 0.3.3 - 2010-08-24
-# - compatible with ffi-0.6.3
-# - example working with ruby 1.9.x (using "q"[0].ord instead of ?q)
-# requires ruby-ffi >= 0.6.3 or jruby >= 1.1.6
-# tested with
-# - ruby 1.8.7, 1.9.x
-# - jruby 1.5.1
-# on
-# - Ubuntu 8.04, 9.04, 9.10, 10.04 (ncurses 5.7)
-# - Mac OS X 10.4 (ncurses 5.4)
-
+# -*- coding: utf-8; -*-
+# ruby-ffi wrapper for ncurses.
+#
+# Sean O'Halpin, 2008-2011
+#
+# repo & docs: http://github.com/seanohalpin/ffi-ncurses
+#
+# - version 0.1.0 - 2008-12-04
+# - version 0.2.0 - 2009-01-18
+# - version 0.3.0 - 2009-01-31
+# - version 0.3.3 - 2010-08-24
+# - version 0.3.4 - 2010-08-28
+# - version 0.3.5 - 2011-01-05
+# - version 0.4.0 - 2011-09-25
+#
 require 'ffi'
+require 'ffi-locale'
+
+if RUBY_VERSION < '1.9.0'
+  # 1.8.x doesn't set the locale - we need this to handle UTF-8 input
+  FFI::Locale.setlocale(FFI::Locale::LC_ALL, "")
+end
+
+# Load version.
+require 'ffi-ncurses/version'
+
+# Load typedefs.
+require 'ffi-ncurses/typedefs'
+
+# Load autogenerated function signatures.
+require 'ffi-ncurses/functions'
 
-# would like to check FFI version here rather than use gem but there
-# doesn't appear to be a version specified in the ffi lib
+# Load alternative character set definitions.
+require 'ffi-ncurses/acs'
 
+# Declare module.
 module FFI
   module NCurses
-    VERSION = "0.3.3"
     extend FFI::Library
+    # FFI overwrites the signatures when you call =attach_function= so
+    # I keep an untouched deep copy here (used in the Ncurses
+    # compatibility layer).
+
+    FUNCTION_SIGNATURES = Marshal.load(Marshal.dump(FUNCTIONS))
+    FUNCTION_SIGNATURES.each do |fsig|
+      if fsig[0].to_s == "_wrapped_#{fsig[1]}"
+        fsig.shift
+      end
+    end
+
+    # Make all instance methods module methods too.
+    extend self
 
-    # use RUBY_FFI_NCURSES_LIB to specify exactly which lib you want, e.g. ncursesw, XCurses (from PDCurses)
+    # Use `RUBY_FFI_NCURSES_LIB` to specify a colon-separated list of
+    # libs you want to try to load, e.g.
+    #
+    #     RUBY_FFI_NCURSES_LIB=XCurses:ncurses
+    #
+    # to try to load XCurses (from PDCurses) first, then ncurses.
+    LIB_HANDLE = { }
     if ENV["RUBY_FFI_NCURSES_LIB"].to_s != ""
-      LIB_HANDLE = ffi_lib( ENV["RUBY_FFI_NCURSES_LIB"] ).first
+      LIB_HANDLE[:ncurses] = ffi_lib(ENV["RUBY_FFI_NCURSES_LIB"].split(/:/)).first
     else
-      LIB_HANDLE = ffi_lib(['ncursesw', 'ncurses']).first
+      LIB_HANDLE[:ncurses] = ffi_lib(['ncursesw', 'libncursesw', 'ncurses', 'libcurses']).first
     end
+    LIB_HANDLE[:panel] = ffi_lib(['panelw', 'libpanelw', 'panel', 'libpanel']).first
 
     begin
-      symbols = [ "stdscr", "curscr", "newscr" ]
-      if LIB_HANDLE.respond_to?(:find_symbol)
-        # these symbols are defined in ncurses.h
-        SYMBOLS = Hash[*symbols.map { |sym| [sym, LIB_HANDLE.find_symbol(sym)]}.compact.flatten ]
-        SYMBOLS.keys.each do |sym|
-          # note that the symbol table entry in a dll for an exported
-          # variable contains a ~pointer to the address~ of the variable
-          # which will be initialized in the process's bss (uninitialized)
-          # data segment when the process is initialized
-
-          # this is unlike methods, where the symbol table entry points to
-          # the entry point of the method itself
-
-          # variables need another level of indirection because they are
-          # ~not~ shared between process instances - the sharing is of
-          # code only
-          define_method sym do
-            SYMBOLS[sym].read_pointer
+      # These global variables are defined in `ncurses.h`:
+      #
+      #     chtype acs_map[];
+      #     WINDOW * curscr;
+      #     WINDOW * newscr;
+      #     WINDOW * stdscr;
+      #     char ttytype[];
+      #     int COLORS;
+      #     int COLOR_PAIRS;
+      #     int COLS;
+      #     int ESCDELAY;
+      #     int LINES;
+      #     int TABSIZE;
+      #
+      # Note that the symbol table entry in a shared lib for an
+      # exported variable contains a *pointer to the address* of
+      # the variable which will be initialized in the process's
+      # bss (uninitialized) data segment when the process is
+      # initialized.
+
+      # This is unlike methods, where the symbol table entry points to
+      # the entry point of the method itself.
+
+      # Variables need another level of indirection because they are
+      # *not* shared between process instances - only code is shared.
+
+      # So we define convenience methods to perform the lookup for
+      # us. We can't just stash the value returned by
+      # `read_pointer` at load time because it's not initialized
+      # until after `initscr` has been called.
+      symbols = [
+                 ["curscr", :pointer],
+                 ["newscr", :pointer],
+                 ["stdscr", :pointer],
+                 ["ttytype", :string],
+                 ["COLORS", :int],
+                 ["COLOR_PAIRS", :int],
+                 ["COLS", :int],
+                 ["ESCDELAY", :int],
+                 ["LINES", :int],
+                 ["TABSIZE", :int],
+                ]
+      if LIB_HANDLE[:ncurses].respond_to?(:find_symbol)
+        symbols.each do |sym, type|
+          if handle = LIB_HANDLE[:ncurses].find_symbol(sym)
+            define_method sym do
+              handle.send("read_#{type}")
+            end
+            module_function sym
+          else
+            warn "#{self.name}: #{sym.inspect} not defined"
+          end
+        end
+        # `acs_map` is a special case
+        if handle = LIB_HANDLE[:ncurses].find_symbol("acs_map")
+          define_method :acs_map do
+            handle.get_array_of_uint(0, 128)
           end
-          module_function sym
         end
       else
         warn "#find_symbol not available - #{symbols.inspect} not defined"
       end
-    rescue Object => e
+    rescue => e
     end
 
-    # this list of function signatures was generated by the file
-    # generate-ffi-ncurses-function-signatures.rb and inserted here by hand
-    # then edited a bit :)
-    functions =
-      [
-       [:COLOR_PAIR, [:int], :int],
-       [:PAIR_NUMBER, [:int], :int],
-       # these functions are only in the debug version of ncurses
-       #       [:_nc_tracebits, [], :string],
-       #       [:_nc_visbuf, [:string], :string],
-       #       [:_traceattr2, [:int, :uint], :string],
-       #       [:_traceattr, [:uint], :string],
-       #       [:_tracecchar_t2, [:int, :pointer], :string],
-       #       [:_tracecchar_t, [:pointer], :string],
-       #       [:_tracechar, [:int], :string],
-       #       [:_tracechtype2, [:int, :uint], :string],
-       #       [:_tracechtype, [:uint], :string],
-       #       [:_tracedump, [:string, :pointer], :void],
-       #       [:_tracef, [:string, :varargs], :void],
-       #       [:_tracemouse, [:pointer], :string],
-       [:add_wchnstr, [:pointer, :int], :int],
-       [:add_wch, [:pointer], :int],
-       [:add_wchstr, [:pointer], :int],
-       [:addchnstr, [:pointer, :int], :int],
-       [:addchstr, [:pointer], :int],
-       [:addch, [:uint], :int],
-       [:addnstr, [:string, :int], :int],
-       [:addstr, [:string], :int],
-       [:assume_default_colors, [:int, :int], :int],
-       [:attr_get, [:pointer, :pointer, :pointer], :int],
-       [:attr_off, [:uint, :pointer], :int],
-       [:attr_on, [:uint, :pointer], :int],
-       [:attr_set, [:uint, :short, :pointer], :int],
-       [:attroff, [:uint], :int],
-       [:attron, [:uint], :int],
-       [:attrset, [:uint], :int],
-       [:baudrate, [], :int],
-       [:beep, [], :int],
-       [:bkgdset, [:uint], :void],
-       [:bkgd, [:uint], :int],
-       [:bkgrnd, [:pointer], :int],
-       [:bkgrndset, [:pointer], :void],
-       [:border_set, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int],
-       [:border, [:uint, :uint, :uint, :uint, :uint, :uint, :uint, :uint], :int],
-       [:box_set, [:pointer, :pointer, :pointer], :int],
-       [:box, [:pointer, :uint, :uint], :int],
-       [:can_change_color, [], :int],
-       [:cbreak, [], :int],
-       [:chgat, [:int, :uint, :short, :pointer], :int],
-       [:clear, [], :int],
-       [:clearok, [:pointer, :int], :int],
-       [:clrtobot, [], :int],
-       [:clrtoeol, [], :int],
-       [:color_content, [:short, :pointer, :pointer, :pointer], :int],
-       [:color_set, [:short, :pointer], :int],
-       [:copywin, [:pointer, :pointer, :int, :int, :int, :int, :int, :int, :int], :int],
-       [:curs_set, [:int], :int],
-       [:curses_version, [], :string],
-       [:def_prog_mode, [], :int],
-       [:def_shell_mode, [], :int],
-       [:define_key, [:string, :int], :int],
-       [:delay_output, [:int], :int],
-       [:delch, [], :int],
-       [:deleteln, [], :int],
-       [:delscreen, [:pointer], :void],
-       [:delwin, [:pointer], :int],
-       [:derwin, [:pointer, :int, :int, :int, :int], :pointer],
-       [:doupdate, [], :int],
-       [:dupwin, [:pointer], :pointer],
-       [:echo_wchar, [:pointer], :int],
-       [:echochar, [:uint], :int],
-       [:echo, [], :int],
-       [:endwin, [], :int],
-       [:erasechar, [], :char],
-       [:erase, [], :int],
-       [:filter, [], :void],
-       [:flash, [], :int],
-       [:flushinp, [], :int],
-       [:getbkgd, [:pointer], :uint],
-       [:getbkgrnd, [:pointer], :int],
-       [:getch, [], :int],
-
-       [:getattrs, [:pointer], :int],
-       [:getcurx, [:pointer], :int],
-       [:getcury, [:pointer], :int],
-       [:getbegx, [:pointer], :int],
-       [:getbegy, [:pointer], :int],
-       [:getmaxx, [:pointer], :int],
-       [:getmaxy, [:pointer], :int],
-       [:getparx, [:pointer], :int],
-       [:getpary, [:pointer], :int],
-
-       # this is defined in mouse.rb
-       #      [:getmouse, [:pointer], :int],
-       [:getnstr, [:string, :int], :int],
-       [:getstr, [:string], :int],
-       [:getwin, [:pointer], :pointer],
-       [:halfdelay, [:int], :int],
-       [:has_colors, [], :int],
-       [:has_ic, [], :int],
-       [:has_il, [], :int],
-       [:has_key, [:int], :int],
-       [:hline_set, [:pointer, :int], :int],
-       [:hline, [:uint, :int], :int],
-       [:idcok, [:pointer, :int], :void],
-       [:idlok, [:pointer, :int], :int],
-       [:immedok, [:pointer, :int], :void],
-       [:in_wchnstr, [:pointer, :int], :int],
-       [:in_wch, [:pointer], :int],
-       [:in_wchstr, [:pointer], :int],
-       [:inchnstr, [:pointer, :int], :int],
-       [:inchstr, [:pointer], :int],
-       [:inch, [], :uint],
-       [:init_color, [:short, :short, :short, :short], :int],
-       [:init_pair, [:short, :short, :short], :int],
-       # need to intercept this to get stdscr for JRuby (for the moment)
-       ["_initscr", :initscr, [], :pointer],
-       [:innstr, [:string, :int], :int],
-       [:ins_wch, [:pointer], :int],
-       [:insch, [:uint], :int],
-       [:insdelln, [:int], :int],
-       [:insertln, [], :int],
-       [:insnstr, [:string, :int], :int],
-       [:insstr, [:string], :int],
-       [:instr, [:string], :int],
-       [:intrflush, [:pointer, :int], :int],
-       [:is_linetouched, [:pointer, :int], :int],
-       [:is_term_resized, [:int, :int], :int],
-       [:is_wintouched, [:pointer], :int],
-       [:isendwin, [], :int],
-       [:key_defined, [:string], :int],
-       [:keybound, [:int, :int], :string],
-       [:keyname, [:int], :string],
-       [:keyok, [:int, :int], :int],
-       [:keypad, [:pointer, :int], :int],
-       [:killchar, [], :char],
-       [:leaveok, [:pointer, :int], :int],
-       [:longname, [], :string],
-       [:mcprint, [:string, :int], :int],
-       [:meta, [:pointer, :int], :int],
-       [:mouse_trafo, [:pointer, :pointer, :int], :int],
-       [:mouseinterval, [:int], :int],
-       [:mousemask, [:uint, :pointer], :uint],
-       [:move, [:int, :int], :int],
-       [:mvadd_wch, [:int, :int, :pointer], :int],
-       [:mvadd_wchnstr, [:int, :int, :pointer, :int], :int],
-       [:mvadd_wchstr, [:int, :int, :pointer], :int],
-       [:mvaddch, [:int, :int, :uint], :int],
-       [:mvaddchnstr, [:int, :int, :pointer, :int], :int],
-       [:mvaddchstr, [:int, :int, :pointer], :int],
-       [:mvaddnstr, [:int, :int, :string, :int], :int],
-       [:mvaddstr, [:int, :int, :string], :int],
-       [:mvchgat, [:int, :int, :int, :uint, :short, :pointer], :int],
-       [:mvcur, [:int, :int, :int, :int], :int],
-       [:mvdelch, [:int, :int], :int],
-       [:mvderwin, [:pointer, :int, :int], :int],
-       [:mvgetch, [:int, :int], :int],
-       [:mvgetnstr, [:int, :int, :string, :int], :int],
-       [:mvgetstr, [:int, :int, :string], :int],
-       [:mvhline_set, [:int, :int, :pointer, :int], :int],
-       [:mvhline, [:int, :int, :uint, :int], :int],
-       [:mvin_wch, [:int, :int, :pointer], :int],
-       [:mvin_wchnstr, [:int, :int, :pointer, :int], :int],
-       [:mvin_wchstr, [:int, :int, :pointer], :int],
-       [:mvinch, [:int, :int], :uint],
-       [:mvinchnstr, [:int, :int, :pointer, :int], :int],
-       [:mvinchstr, [:int, :int, :pointer], :int],
-       [:mvinnstr, [:int, :int, :string, :int], :int],
-       [:mvins_wch, [:int, :int, :pointer], :int],
-       [:mvinsch, [:int, :int, :uint], :int],
-       [:mvinsnstr, [:int, :int, :string, :int], :int],
-       [:mvinsstr, [:int, :int, :string], :int],
-       [:mvinstr, [:int, :int, :string], :int],
-       [:mvprintw, [:int, :int, :string, :varargs], :int],
-       [:mvscanw, [:int, :int, :string, :varargs], :int],
-       [:mvvline_set, [:int, :int, :pointer, :int], :int],
-       [:mvvline, [:int, :int, :uint, :int], :int],
-       [:mvwadd_wchnstr, [:pointer, :int, :int, :pointer, :int], :int],
-       [:mvwadd_wch, [:pointer, :int, :int, :pointer], :int],
-       [:mvwadd_wchstr, [:pointer, :int, :int, :pointer], :int],
-       [:mvwaddchnstr, [:pointer, :int, :int, :pointer, :int], :int],
-       [:mvwaddch, [:pointer, :int, :int, :uint], :int],
-       [:mvwaddchstr, [:pointer, :int, :int, :pointer], :int],
-       [:mvwaddnstr, [:pointer, :int, :int, :string, :int], :int],
-       [:mvwaddstr, [:pointer, :int, :int, :string], :int],
-       [:mvwchgat, [:pointer, :int, :int, :int, :uint, :short, :pointer], :int],
-       [:mvwdelch, [:pointer, :int, :int], :int],
-       [:mvwgetch, [:pointer, :int, :int], :int],
-       [:mvwgetnstr, [:pointer, :int, :int, :string, :int], :int],
-       [:mvwgetstr, [:pointer, :int, :int, :string], :int],
-       [:mvwhline_set, [:pointer, :int, :int, :pointer, :int], :int],
-       [:mvwhline, [:pointer, :int, :int, :uint, :int], :int],
-       [:mvwin_wchnstr, [:pointer, :int, :int, :pointer, :int], :int],
-       [:mvwin_wch, [:pointer, :int, :int, :pointer], :int],
-       [:mvwin_wchstr, [:pointer, :int, :int, :pointer], :int],
-       [:mvwinchnstr, [:pointer, :int, :int, :pointer, :int], :int],
-       [:mvwinch, [:pointer, :int, :int], :uint],
-       [:mvwinchstr, [:pointer, :int, :int, :pointer], :int],
-       [:mvwinnstr, [:pointer, :int, :int, :string, :int], :int],
-       [:mvwin, [:pointer, :int, :int], :int],
-       [:mvwins_wch, [:pointer, :int, :int, :pointer], :int],
-       [:mvwinsch, [:pointer, :int, :int, :uint], :int],
-       [:mvwinsnstr, [:pointer, :int, :int, :string, :int], :int],
-       [:mvwinsstr, [:pointer, :int, :int, :string], :int],
-       [:mvwinstr, [:pointer, :int, :int, :string], :int],
-       [:mvwprintw, [:pointer, :int, :int, :string, :varargs], :int],
-       [:mvwscanw, [:pointer, :int, :int, :string, :varargs], :int],
-       [:mvwvline_set, [:pointer, :int, :int, :pointer, :int], :int],
-       [:mvwvline, [:pointer, :int, :int, :uint, :int], :int],
-       [:napms, [:int], :int],
-       [:newpad, [:int, :int], :pointer],
-       [:newterm, [:string, :pointer, :pointer], :pointer],
-       [:newwin, [:int, :int, :int, :int], :pointer],
-       [:nl, [], :int],
-       [:nocbreak, [], :int],
-       [:nodelay, [:pointer, :int], :int],
-       [:noecho, [], :int],
-       [:nonl, [], :int],
-       [:noqiflush, [], :void],
-       [:noraw, [], :int],
-       [:notimeout, [:pointer, :int], :int],
-       [:overlay, [:pointer, :pointer], :int],
-       [:overwrite, [:pointer, :pointer], :int],
-       [:pair_content, [:short, :pointer, :pointer], :int],
-       [:pecho_wchar, [:pointer, :pointer], :int],
-       [:pechochar, [:pointer, :uint], :int],
-       [:pnoutrefresh, [:pointer, :int, :int, :int, :int, :int, :int], :int],
-       [:prefresh, [:pointer, :int, :int, :int, :int, :int, :int], :int],
-       [:printw, [:string, :varargs], :int],
-       [:putp, [:string], :int],
-       [:putwin, [:pointer, :pointer], :int],
-       [:qiflush, [], :void],
-       [:raw, [], :int],
-       [:redrawwin, [:pointer], :int],
-       [:refresh, [], :int],
-       [:reset_prog_mode, [], :int],
-       [:reset_shell_mode, [], :int],
-       [:resetty, [], :int],
-       [:resize_term, [:int, :int], :int],
-       [:resizeterm, [:int, :int], :int],
-       [:ripoffline, [:int, :pointer], :int],
-       [:savetty, [], :int],
-       [:scanw, [:string, :varargs], :int],
-       [:scr_dump, [:string], :int],
-       [:scr_init, [:string], :int],
-       [:scr_restore, [:string], :int],
-       [:scr_set, [:string], :int],
-       [:scrl, [:int], :int],
-       [:scrollok, [:pointer, :int], :int],
-       [:scroll, [:pointer], :int],
-       [:set_term, [:pointer], :pointer],
-       [:setscrreg, [:int, :int], :int],
-       [:slk_attr_off, [:uint, :pointer], :int],
-       [:slk_attr_on, [:uint, :pointer], :int],
-       [:slk_attr_set, [:uint, :short, :pointer], :int],
-       [:slk_attroff, [:uint], :int],
-       [:slk_attron, [:uint], :int],
-       [:slk_attrset, [:uint], :int],
-       [:slk_attr, [], :uint],
-       [:slk_clear, [], :int],
-       [:slk_color, [:short], :int],
-       [:slk_init, [:int], :int],
-       [:slk_label, [:int], :string],
-       [:slk_noutrefresh, [], :int],
-       [:slk_refresh, [], :int],
-       [:slk_restore, [], :int],
-       [:slk_set, [:int, :string, :int], :int],
-       [:slk_touch, [], :int],
-       [:standend, [], :int],
-       [:standout, [], :int],
-       [:start_color, [], :int],
-       [:subpad, [:pointer, :int, :int, :int, :int], :pointer],
-       [:subwin, [:pointer, :int, :int, :int, :int], :pointer],
-       [:syncok, [:pointer, :int], :int],
-       [:term_attrs, [], :uint],
-       [:termattrs, [], :uint],
-       [:termname, [], :string],
-       [:tigetflag, [:string], :int],
-       [:tigetnum, [:string], :int],
-       [:tigetstr, [:string], :string],
-       [:timeout, [:int], :void],
-       [:touchline, [:pointer, :int, :int], :int],
-       [:touchwin, [:pointer], :int],
-       [:tparm, [:string, :varargs], :string],
-       #       [:trace, [:uint], :void],
-       [:typeahead, [:int], :int],
-       [:ungetch, [:int], :int],
-       # moved into mouse
-       #       [:ungetmouse, [:pointer], :int],
-       [:untouchwin, [:pointer], :int],
-       [:use_default_colors, [], :int],
-       [:use_env, [:int], :void],
-       [:use_extended_names, [:int], :int],
-       [:vid_attr, [:uint, :short, :pointer], :int],
-       [:vid_puts, [:uint, :short, :pointer, :pointer], :int],
-       [:vidattr, [:uint], :int],
-       [:vidputs, [:uint, :pointer], :int],
-       [:vline_set, [:pointer, :int], :int],
-       [:vline, [:uint, :int], :int],
-       [:wadd_wchnstr, [:pointer, :pointer, :int], :int],
-       [:wadd_wch, [:pointer, :pointer], :int],
-       [:wadd_wchstr, [:pointer, :pointer], :int],
-       [:waddchnstr, [:pointer, :pointer, :int], :int],
-       [:waddch, [:pointer, :uint], :int],
-       [:waddchstr, [:pointer, :pointer], :int],
-       [:waddnstr, [:pointer, :string, :int], :int],
-       [:waddstr, [:pointer, :string], :int],
-       [:wattr_get, [:pointer, :pointer, :pointer, :pointer], :int],
-       [:wattr_off, [:pointer, :uint, :pointer], :int],
-       [:wattr_on, [:pointer, :uint, :pointer], :int],
-       [:wattr_set, [:pointer, :uint, :short, :pointer], :int],
-       [:wattroff, [:pointer, :int], :int],
-       [:wattron, [:pointer, :int], :int],
-       [:wattrset, [:pointer, :int], :int],
-       [:wbkgd, [:pointer, :uint], :int],
-       [:wbkgdset, [:pointer, :uint], :void],
-       [:wbkgrnd, [:pointer, :pointer], :int],
-       [:wbkgrndset, [:pointer, :pointer], :void],
-       [:wborder_set, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int],
-       [:wborder, [:pointer, :uint, :uint, :uint, :uint, :uint, :uint, :uint, :uint], :int],
-       [:wchgat, [:pointer, :int, :uint, :short, :pointer], :int],
-       [:wclear, [:pointer], :int],
-       [:wclrtobot, [:pointer], :int],
-       [:wclrtoeol, [:pointer], :int],
-       [:wcolor_set, [:pointer, :short, :pointer], :int],
-       [:wcursyncup, [:pointer], :void],
-       [:wdelch, [:pointer], :int],
-       [:wdeleteln, [:pointer], :int],
-       [:wecho_wchar, [:pointer, :pointer], :int],
-       [:wechochar, [:pointer, :uint], :int],
-       [:wenclose, [:pointer, :int, :int], :int],
-       [:werase, [:pointer], :int],
-       [:wgetbkgrnd, [:pointer, :pointer], :int],
-       [:wgetch, [:pointer], :int],
-       [:wgetnstr, [:pointer, :string, :int], :int],
-       [:wgetstr, [:pointer, :string], :int],
-       [:whline_set, [:pointer, :pointer, :int], :int],
-       [:whline, [:pointer, :uint, :int], :int],
-       [:win_wchnstr, [:pointer, :pointer, :int], :int],
-       [:win_wch, [:pointer, :pointer], :int],
-       [:win_wchstr, [:pointer, :pointer], :int],
-       [:winchnstr, [:pointer, :pointer, :int], :int],
-       [:winch, [:pointer], :uint],
-       [:winchstr, [:pointer, :pointer], :int],
-       [:winnstr, [:pointer, :string, :int], :int],
-       [:wins_wch, [:pointer, :pointer], :int],
-       [:winsch, [:pointer, :uint], :int],
-       [:winsdelln, [:pointer, :int], :int],
-       [:winsertln, [:pointer], :int],
-       [:winsnstr, [:pointer, :string, :int], :int],
-       [:winsstr, [:pointer, :string], :int],
-       [:winstr, [:pointer, :string], :int],
-       [:wmove, [:pointer, :int, :int], :int],
-       [:wnoutrefresh, [:pointer], :int],
-       [:wprintw, [:pointer, :string, :varargs], :int],
-       [:wredrawln, [:pointer, :int, :int], :int],
-       [:wrefresh, [:pointer], :int],
-       [:wresize, [:pointer, :int, :int], :int],
-       [:wscanw, [:pointer, :string, :varargs], :int],
-       [:wscrl, [:pointer, :int], :int],
-       [:wsetscrreg, [:pointer, :int, :int], :int],
-       [:wstandend, [:pointer], :int],
-       [:wstandout, [:pointer], :int],
-       [:wsyncdown, [:pointer], :void],
-       [:wsyncup, [:pointer], :void],
-       [:wtimeout, [:pointer, :int], :void],
-       [:wtouchln, [:pointer, :int, :int, :int], :int],
-       [:wvline_set, [:pointer, :pointer, :int], :int],
-       [:wvline, [:pointer, :uint, :int], :int]
-      ]
-    # end of autogenerated function list
-
+    # This is used for debugging.
     @unattached_functions = []
     class << self
       def unattached_functions
@@ -439,17 +139,16 @@ module FFI
       end
     end
 
-    # attach functions
-    functions.each do |func|
+    # Attach functions.
+    FUNCTIONS.each do |func|
       begin
         attach_function(*func)
       rescue Object => e
-        # for debugging
         unattached_functions << func[0]
       end
     end
 
-    module Colour
+    module Color
       COLOR_BLACK   = BLACK   = 0
       COLOR_RED     = RED     = 1
       COLOR_GREEN   = GREEN   = 2
@@ -459,31 +158,11 @@ module FFI
       COLOR_CYAN    = CYAN    = 6
       COLOR_WHITE   = WHITE   = 7
     end
-    Color = Colour
-    include Colour
-
-    # FIXME: remove this code when JRuby gets find_sym
-    # fixup for JRuby 1.1.6 - doesn't have find_sym
-    # can hack for stdscr but not curscr or newscr (no methods return them)
-    # this will all be removed when JRuby 1.1.7 is released
-    module FixupInitscr
-      if !NCurses.respond_to?(:stdscr)
-        def initscr
-          @stdscr = NCurses._initscr
-        end
-        def stdscr
-          @stdscr
-        end
-      else
-        def initscr
-          NCurses._initscr
-        end
-      end
-    end
-    include FixupInitscr
+    include Color
 
     module Attributes
-      # following definitions have been copied (almost verbatim) from ncurses.h
+      # The following definitions have been copied (almost verbatim)
+      # from `ncurses.h`.
       NCURSES_ATTR_SHIFT = 8
       def self.NCURSES_BITS(mask, shift)
         ((mask) << ((shift) + NCURSES_ATTR_SHIFT))
@@ -512,9 +191,6 @@ module FFI
     include Attributes
 
     module Constants
-      FALSE = 0
-      TRUE = 1
-
       ERR = -1
       OK = 0
     end
@@ -523,42 +199,82 @@ module FFI
     require 'ffi-ncurses/winstruct'
     include WinStruct
 
-    module EmulatedFunctions
-
-      # these 'functions' are implemented as macros in ncurses
+    require 'ffi-ncurses/panel'
+    include PanelStruct
 
-      # I'm departing from the NCurses API here - makes no sense to
-      # force people to use pointer return values when these are
-      # implemented as macros to make them easy to use in C when we have
-      # multiple return values in Ruby for that exact same purpose
-      def getyx(win)
-        [NCurses.getcury(win), NCurses.getcurx(win)]
+    # These following functions are implemented as macros in ncurses.
+    module EmulatedFunctions
+      # Note that I'm departing from the NCurses API here - it makes
+      # no sense to force people to use pointer return values when
+      # these methods have been implemented as macros to make them
+      # easy to use in *C*. We have multiple return values in Ruby, so
+      # let's use them. Call like this:
+      #
+      #     y, x = getyx(win)
+      #
+      # For compatibility with the existing Ncurses lib, you can also
+      # call these functions like so:
+      #
+      #     y = [nil]
+      #     x = [nil]
+      #     getyx(win, y, x)
+      #
+      def getyx(win, y = nil, x = nil)
+        res = [NCurses.getcury(win), NCurses.getcurx(win)]
+        if y && y.kind_of?(Array) && x.kind_of?(Array)
+          y.replace([res[0]])
+          x.replace([res[1]])
+        end
+        res
       end
-      def getbegyx(win)
-        [NCurses.getbegy(win), NCurses.getbegx(win)]
+
+      def getbegyx(win, y = nil, x = nil)
+        res = [NCurses.getbegy(win), NCurses.getbegx(win)]
+        if y && y.kind_of?(Array) && x.kind_of?(Array)
+          y.replace([res[0]])
+          x.replace([res[1]])
+        end
+        res
       end
-      def getparyx(win)
-        [NCurses.getpary(win), NCurses.getparx(win)]
+
+      def getparyx(win, y = nil, x = nil)
+        res = [NCurses.getpary(win), NCurses.getparx(win)]
+        if y && y.kind_of?(Array) && x.kind_of?(Array)
+          y.replace([res[0]])
+          x.replace([res[1]])
+        end
+        res
       end
-      def getmaxyx(win)
-        [NCurses.getmaxy(win), NCurses.getmaxx(win)]
+
+      def getmaxyx(win, y = nil, x = nil)
+        res = [NCurses.getmaxy(win), NCurses.getmaxx(win)]
+        if y && y.kind_of?(Array) && x.kind_of?(Array)
+          y.replace([res[0]])
+          x.replace([res[1]])
+        end
+        res
       end
 
-      # transliterated from ncurses.h
-      # note: had to spell out NCurses::TRUE - will look into this
-      def getsyx
-        if (is_leaveok(newscr) == NCurses::TRUE)
-			    [-1, -1]
+      # These have been transliterated from `ncurses.h`.
+      def getsyx(y = nil, x = nil)
+        if is_leaveok(newscr)
+          res = [-1, -1]
         else
-          getyx(newscr)
+          res = getyx(newscr)
+        end
+        if y && y.kind_of?(Array) && x.kind_of?(Array)
+          y.replace([res[0]])
+          x.replace([res[1]])
         end
+        res
       end
+
       def setsyx(y, x)
         if y == -1 && x == -1
-			    leaveok(newscr, NCurses::TRUE)
+          leaveok(newscr, true)
         else
-			    leaveok(newscr, NCurses::FALSE)
-			    wmove(newscr, y, x)
+          leaveok(newscr, false)
+	  wmove(newscr, y, x)
         end
       end
 
@@ -568,7 +284,7 @@ module FFI
         end
       end
 
-      # hack for XCurses (PDCurses 3.3) - many more to come I suspect :)
+      # Hack for XCurses (PDCurses 3.3) - many more to come I suspect.
       fixup :getch do
         def getch
           wgetch(stdscr)
@@ -576,17 +292,41 @@ module FFI
       end
     end
     include EmulatedFunctions
+    extend EmulatedFunctions
 
-    # fixes for Mac OS X (mostly macros directly referencing the WINDOW struct)
-    if ::FFI::Platform::OS == "darwin"
+    # Include fixes for Mac OS X (mostly macros directly referencing
+    # the `WINDOW` struct).
+    #
+    # FIXME: Might need these for BSD too.
+    if defined?(::FFI::Platform::OS) && ::FFI::Platform::OS == "darwin"
       require 'ffi-ncurses/darwin'
       include NCurses::Darwin
     end
 
-    # make all those instance methods module methods too
-    extend self
+    # We need to define our own `initscr` so we can add the ACS
+    # constants dynamically.
+    private :_wrapped_initscr
+    private :_wrapped_newterm
 
+    def initscr
+      _wrapped_initscr
+      NCurses.define_acs_constants
+      stdscr
+    end
+
+    def newterm(name, out_filep, in_filep)
+      rv = _wrapped_newterm(name, out_filep, in_filep)
+      NCurses.define_acs_constants
+      rv
+    end
   end
 end
 
+# Include wrappers for functions with bool arguments.
+require 'ffi-ncurses/bool_wrappers'
+
+# Include key definitions.
 require 'ffi-ncurses/keydefs'
+
+# Include mouse functions and key definitions.
+require 'ffi-ncurses/mouse'