curses 1.2.7 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfa821d182e0a62293a794d22c2b09a0167be3c839a5ac67ea596e98fd5b1f55
-  data.tar.gz: 1249a4e26714cfdb8ac20394e5c1333b3136b9d5275fac18b3618165cdd1d286
+  metadata.gz: 857d0a003f909b9e148855feb1d7b5eca2487aab1d22c544e0fdf560a92293b5
+  data.tar.gz: 49329a8c35c0e157c5cba591eb317bf9acf2672af16c8e826aa22ab0ada59cda
 SHA512:
-  metadata.gz: e11281a03551d1104a38e2c9b48c0fa1dc8313c8777f2c8e25c97b7833a75c4ea4d44c6d5b0e6b7e2008f7ee012ae9e0e2719df74adbfb85ca731858b3bc2cae
-  data.tar.gz: 98b90ee805453cb60ec62f698a7477279631e712b6f83ba1ce4edb5488a06d38694e4d0ac5de4eb00e098d47ce9b77c12b4c988afc42d9b1f123705d3cb2ab18
+  metadata.gz: 7330fdebb60f3871c10d74685ea5c7ed0194ba7630d0def5cd65de72a3e32e48df343b290ed7e718a116eae1eeab52b5f32d58a4e16e64db6210da9fea19d99e
+  data.tar.gz: 77d3c8bcc7183642917311d0cbde1d14f55771b133adb2b7953a052a02672053a5bdc3dd0fc0ab78963383d1e114c9b4534df643be05cb17c2adfdcfca8d7c1a

data/.github/workflows/macos.yml

@@ -0,0 +1,19 @@
+name: macos
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install dependencies
+      run: |
+        gem install bundler --no-document
+        bundle install
+    - name: Build package
+      run: bundle exec rake build
+    - name: Install package
+      run: |
+        gem install pkg/curses-*.gem
+        ruby -r curses -e 'puts Curses::VERSION'

data/.github/workflows/ubuntu.yml

@@ -0,0 +1,26 @@
+name: ubuntu
+
+on: [push]
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        ruby: [ head, 2.7, 2.6, 2.5 ]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: Install dependencies
+      run: |
+        sudo apt install libncursesw5-dev
+        gem install bundler --no-document
+        bundle install
+    - name: Build package
+      run: bundle exec rake build
+    - name: Install package
+      run: |
+        gem install pkg/curses-*.gem
+        ruby -r curses -e 'puts Curses::VERSION'

data/.github/workflows/windows.yml

@@ -0,0 +1,25 @@
+name: windows
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        ruby: [ 'mingw', 'mswin', '2.7', '2.6', '2.5' ]
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - name: Build package
+      run: bundle exec rake build
+    - name: Install package
+      run: |
+        gem install pkg/curses-*.gem
+        ruby -r curses -e 'puts Curses::VERSION'

data/.gitmodules

@@ -1,3 +1,3 @@
 [submodule "vendor/PDCurses"]
 	path = vendor/PDCurses
-	url = https://github.com/Bill-Gray/PDCurses.git
+	url = https://github.com/shugo/PDCurses.git

data/History.md

@@ -1,3 +1,44 @@
+### 1.4.1 / 2021-05-22
+
+Bug fixes:
+
+* Use chtype instead of char to support attributes
+* Fixes for Ruby 3.1.
+
+### 1.4.0 / 2020-12-10
+
+New features:
+
+* Remove fat binary support for newer versions of Ruby
+
+### 1.3.2 / 2019-12-20
+
+Bug fixes:
+
+* Drop rb_safe_level check for Ruby 2.7 by Eric Wong.
+* Try libtinfow first.  Issue #52 by Marco Sirabella. 
+
+### 1.3.1 / 2019-04-21
+
+Bug fixes:
+
+* Check whether sizeof(WINDOW) is available to avoid build failures on macOS.
+  Issue #48 reported by chdiza.
+
+### 1.3.0 / 2019-04-16
+
+New features:
+
+* Add Curses::Form and Curses::Field.
+
+Bug fixes:
+
+* Fix TravisCI issues by amatsuda and znz.
+* Fix typo in sample/menu.rb by binford2k.
+* Ctrl-/ should return ^_ on Windows.
+* Workaround for new Windows console.
+  https://github.com/Bill-Gray/PDCurses/pull/108
+
 ### 1.2.7 / 2019-01-10
 
 Bug fixes:

data/README.md

@@ -1,8 +1,9 @@
 # curses
 
 [![Gem Version](https://badge.fury.io/rb/curses.svg)](https://badge.fury.io/rb/curses)
-[![Build Status](https://travis-ci.org/ruby/curses.svg?branch=master)](https://travis-ci.org/ruby/curses)
-[![Build status](https://ci.appveyor.com/api/projects/status/kdvksgjo4fyd3c4m/branch/master?svg=true)](https://ci.appveyor.com/project/ruby/curses/branch/master)
+[![ubuntu](https://github.com/ruby/curses/workflows/ubuntu/badge.svg)](https://github.com/ruby/curses/actions?query=workflow%3Aubuntu)
+[![windows](https://github.com/ruby/curses/workflows/windows/badge.svg)](https://github.com/ruby/curses/actions?query=workflow%3Awindows)
+[![macos](https://github.com/ruby/curses/workflows/macos/badge.svg)](https://github.com/ruby/curses/actions?query=workflow%3Amacos)
 
 * https://github.com/ruby/curses
 * https://github.com/ruby/curses/issues
@@ -18,7 +19,7 @@ with the release of Ruby 2.1.0. (see [ruby/ruby@9c5b2fd][2])
 ## Install
 
     $ gem install curses
-        
+
 Requires ncurses or ncursesw (with wide character support).
 On Debian based distributions, you can install it with apt:
 
@@ -28,6 +29,14 @@ Or
 
     $ apt install libncursesw5-dev
 
+On Windows, `gem install curses` will build bundled PDCurses, so you
+don't need to install extra libraries.
+However, if you prefer ncurses to PDCurses, specify the following option:
+
+    > gem install curses -- --use-system-libraries
+
+On mingw, you need DevKit to compile the extension library.
+
 ## Documentation
 
 See [https://www.rubydoc.info/gems/curses](https://www.rubydoc.info/gems/curses).
@@ -39,57 +48,16 @@ After checking out the repo, run `bundle install` to install dependencies.
 To compile the extension library, run `bundle exec rake compile`.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `curses.gemspec`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-### Cross compilation for Windows on Debian GNU/Linux based platforms
-
-1. Install development environment fo 32- and 64-bit Windows.
-
-   ```
-   $ sudo apt-get install mingw-w64
-   ```
-
-2. Install rake-compiler.
-
-   ```
-   $ gem install rake-compiler
-   ```
-
-3. Compile multiple versions of Ruby.
-
-   ```
-   $ rake-compiler cross-ruby HOST=i686-w64-mingw32 VERSION=2.2.6
-   $ rake-compiler cross-ruby HOST=i686-w64-mingw32 VERSION=2.3.3
-   $ rake-compiler cross-ruby HOST=i686-w64-mingw32 VERSION=2.4.0
-   $ rake-compiler cross-ruby HOST=x86_64-w64-mingw32 VERSION=2.2.6
-   $ rake-compiler cross-ruby HOST=x86_64-w64-mingw32 VERSION=2.3.3
-   $ rake-compiler cross-ruby HOST=x86_64-w64-mingw32 VERSION=2.4.0
-   ```
-
-3. Compile PDCurses.
-
-   ```
-   $ rake build:pdcurses
-   ```
-
-5. Compile curses.gem.
-
-   ```
-   $ rake RUBY_CC_VERSION=2.3.3:2.4.0 cross clean compile native gem
-   ```
-
-Binary gems are generated in pkg/.
-
 ## License
 
 curses is released under the Ruby and 2-clause BSD licenses.  See COPYING for
 details.
 
-Binary gems for mingw32 include a forked version of PDCurses, which is in
-the public domain:
+It includes a forked version of PDCurses, which is in the public domain:
 
   https://github.com/Bill-Gray/PDCurses
 
-The version for Win32 console mode in the win32 subdirectory is used.
+The version for Win32 console mode in the wincon subdirectory is used.
 
 [1]: https://bugs.ruby-lang.org/issues/8584
 [2]: https://github.com/ruby/ruby/commit/9c5b2fd8aa0fd343ad094d47a638cfd3f6ae0a81

data/Rakefile

@@ -1,86 +1,3 @@
 require "bundler"
 
 Bundler::GemHelper.install_tasks
-
-begin
-  require 'rake/extensiontask'
-rescue LoadError => e
-  warn "\nmissing #{e.path} (for rake-compiler)" if e.respond_to? :path
-  warn "run: bundle install\n\n"
-end
-
-$mswin = /mswin/ =~ RUBY_PLATFORM
-
-CLOBBER.include("vendor/#{RUBY_PLATFORM}") if $mswin
-CLOBBER.include("vendor/x86-mingw32")
-CLOBBER.include("vendor/x64-mingw32")
-CLOBBER.include("lib/2.*")
-CLOBBER.include("pkg")
-
-namespace :build do
-  desc "Build PDCurses"
-  task :pdcurses do
-    mkdir_p "vendor/#{RUBY_PLATFORM}/PDCurses" if $mswin
-    mkdir_p "vendor/x86-mingw32/PDCurses"
-    mkdir_p "vendor/x64-mingw32/PDCurses"
-    chdir "vendor/PDCurses/win32" do
-      if $mswin
-        sh "nmake -f vcwin32.mak clean all WIDE=Y DLL=Y"
-        cp %w[pdcurses.dll pdcurses.lib], "../../#{RUBY_PLATFORM}/PDCurses"
-      else
-        sh "make -f mingwin32.mak clean all WIDE=Y DLL=N"
-        cp "pdcurses.a", "../../x86-mingw32/PDCurses/libpdcurses.a"
-
-        sh "make -f mingwin32.mak clean all _w64=1 WIDE=Y DLL=N"
-        cp "pdcurses.a", "../../x64-mingw32/PDCurses/libpdcurses.a"
-      end
-    end
-  end
-end
-
-namespace :clean do
-  desc "Clean PDCurses"
-  task :pdcurses do
-    chdir "vendor/PDCurses/win32" do
-      sh "nmake -f vcwin32.mak clean" if $mswin
-      sh "make -f mingwin32.mak clean _linux_w64=1"
-    end
-  end
-end
-
-spec = eval(File.read(File.expand_path("curses.gemspec", __dir__)))
-Rake::ExtensionTask.new(spec.name, spec) do |ext|
-  if $mswin
-    ext.config_options << '--with-curses-include=' + 
-      File.expand_path("vendor/PDCurses", __dir__) +
-      ' --with-curses-version=function --enable-pdcurses-wide' +
-      ' --enable-pdcurses-dll' +
-      ' --with-curses-lib=' +
-      File.expand_path("vendor/#{RUBY_PLATFORM}/PDCurses", __dir__)
-    spec.files += ["vendor/#{RUBY_PLATFORM}/PDCurses/pdcurses.dll"]
-  end
-
-  ext.cross_compile = true
-  ext.cross_platform = ["x86-mingw32", "x64-mingw32"]
-  ext.cross_config_options << '--with-curses-include=' + 
-    File.expand_path("vendor/PDCurses", __dir__) +
-    ' --with-curses-version=function --enable-pdcurses-wide'
-  ext.cross_config_options << {
-    'x86-mingw32' => '--with-curses-lib=' +
-      File.expand_path("vendor/x86-mingw32/PDCurses", __dir__),
-    'x64-mingw32' => '--with-curses-lib=' +
-      File.expand_path("vendor/x64-mingw32/PDCurses", __dir__)
-  }
-  if $mswin
-    ext.cross_compiling do |_spec|
-      bin_file = "vendor/#{_spec.platform}/PDCurses/pdcurses.dll"
-      _spec.files += [bin_file]
-      stage_file = "#{ext.tmp_dir}/#{_spec.platform}/stage/#{bin_file}"
-      stage_dir = File.dirname(stage_file)
-      directory stage_dir
-      file stage_file => [stage_dir, bin_file] do
-        cp bin_file, stage_file
-      end
-    end
-  end
-end

data/curses.gemspec

@@ -1,17 +1,16 @@
 Gem::Specification.new { |s|
   s.name = "curses"
-  s.version = "1.2.7"
+  s.version = "1.4.1"
   s.author = ["Shugo Maeda", 'Eric Hodel']
   s.email = ["shugo@ruby-lang.org", 'drbrain@segment7.net']
   s.homepage = "https://github.com/ruby/curses"
   s.platform = Gem::Platform::RUBY
   s.summary = "A Ruby binding for curses, ncurses, and PDCurses. curses is an extension library for text UI applications. Formerly part of the Ruby standard library, [curses was removed and placed in this gem][1] with the release of Ruby 2.1.0. (see [ruby/ruby@9c5b2fd][2])"
-  s.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(vendor)/}) }
+  s.files = `git ls-files --recurse-submodules -z`.split("\x0")
   s.extensions = ["ext/curses/extconf.rb"]
   s.require_path = "lib"
   s.required_ruby_version = Gem::Requirement.new('>= 2.1.0')
   s.licenses = ['Ruby', 'BSD-2-Clause']
   s.add_development_dependency 'bundler'
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'rake-compiler'
 }

data/ext/curses/curses.c

@@ -20,7 +20,9 @@
 #include "ruby/io.h"
 #include "ruby/thread.h"
 
-#if defined(HAVE_NCURSESW_CURSES_H)
+#if defined(HAVE_PDCURSES_H)
+# include <pdcurses.h>
+#elif defined(HAVE_NCURSESW_CURSES_H)
 # include <ncursesw/curses.h>
 #elif defined(HAVE_NCURSES_CURSES_H)
 # include <ncurses/curses.h>
@@ -61,6 +63,16 @@
 # include <menu.h>
 #endif
 
+#if defined(HAVE_NCURSESW_FORM_H)
+# include <ncursesw/form.h>
+#elif defined(HAVE_NCURSES_FORM_H)
+# include <ncurses/form.h>
+#elif defined(HAVE_CURSES_FORM_H)
+# include <curses/form.h>
+#elif defined(HAVE_FORM_H)
+# include <form.h>
+#endif
+
 #ifdef HAVE_INIT_COLOR
 # define USE_COLOR 1
 #endif
@@ -70,8 +82,19 @@
 # define USE_MOUSE 1
 #endif
 
-#define NUM2CH NUM2CHR
-#define CH2FIX CHR2FIX
+#define OBJ2CHTYPE rb_obj2chtype_inline
+
+static inline chtype
+rb_obj2chtype_inline(VALUE x)
+{
+    if (RB_TYPE_P(x, RUBY_T_STRING)) {
+	ID id_ord;
+
+	CONST_ID(id_ord, "ord");
+	x = rb_funcall(x, id_ord, 0);
+    }
+    return NUM2CHTYPE(x);
+}
 
 static VALUE mCurses;
 static VALUE mKey;
@@ -84,6 +107,10 @@ static VALUE cMouseEvent;
 static VALUE cItem;
 static VALUE cMenu;
 #endif
+#ifdef HAVE_FORM
+static VALUE cField;
+static VALUE cForm;
+#endif
 static VALUE eError;
 static VALUE eSystemError;
 static VALUE eBadArgumentError;
@@ -199,6 +226,7 @@ static VALUE window_attroff(VALUE obj, VALUE attrs);
 static VALUE window_attron(VALUE obj, VALUE attrs);
 static VALUE window_attrset(VALUE obj, VALUE attrs);
 
+NORETURN(static void no_window(void));
 static void
 no_window(void)
 {
@@ -206,8 +234,6 @@ no_window(void)
 }
 
 #define GetWINDOW(obj, winp) do {\
-    if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4)\
-	rb_raise(rb_eSecurityError, "Insecure: operation on untainted window");\
     TypedData_Get_Struct((obj), struct windata, &windata_type, (winp));\
     if ((winp)->window == 0) no_window();\
 } while (0)
@@ -227,7 +253,7 @@ window_memsize(const void *p)
     const struct windata *winp = p;
     size_t size = sizeof(*winp);
     if (!winp) return 0;
-    if (winp->window && winp->window != stdscr) size += sizeof(winp->window);
+    if (winp->window && winp->window != stdscr) size += CURSES_SIZEOF_WINDOW;
     return size;
 }
 
@@ -276,7 +302,7 @@ static void curses_finalize(VALUE);
  * see also Curses.stdscr
  */
 static VALUE
-curses_init_screen(void)
+curses_init_screen(VALUE self)
 {
     if (rb_stdscr) return rb_stdscr;
     initscr();
@@ -299,7 +325,7 @@ curses_init_screen(void)
  *
  * Many curses functions use this window.
  */
-#define curses_stdscr curses_init_screen
+#define curses_stdscr() curses_init_screen(Qnil)
 
 /*
  * Document-method: Curses.close_screen
@@ -315,7 +341,7 @@ curses_init_screen(void)
  *
  */
 static VALUE
-curses_close_screen(void)
+curses_close_screen(VALUE self)
 {
     curses_stdscr();
 #ifdef HAVE_ISENDWIN
@@ -355,7 +381,7 @@ curses_finalize(VALUE dummy)
  * returns +false+ otherwise.
  */
 static VALUE
-curses_closed(void)
+curses_closed(VALUE self)
 {
     curses_stdscr();
     if (isendwin()) {
@@ -405,7 +431,7 @@ curses_erase(VALUE obj)
  * Clears to the end of line, that the cursor is currently on.
  */
 static VALUE
-curses_clrtoeol(void)
+curses_clrtoeol(VALUE self)
 {
     curses_stdscr();
     clrtoeol();
@@ -732,7 +758,7 @@ static VALUE
 curses_inch(VALUE obj)
 {
     curses_stdscr();
-    return CH2FIX(inch());
+    return CHTYPE2NUM(inch());
 }
 
 /*
@@ -747,7 +773,7 @@ static VALUE
 curses_addch(VALUE obj, VALUE ch)
 {
     curses_stdscr();
-    addch(NUM2CH(ch));
+    addch(OBJ2CHTYPE(ch));
     return Qnil;
 }
 
@@ -762,7 +788,7 @@ static VALUE
 curses_insch(VALUE obj, VALUE ch)
 {
     curses_stdscr();
-    insch(NUM2CH(ch));
+    insch(OBJ2CHTYPE(ch));
     return Qnil;
 }
 
@@ -843,7 +869,7 @@ getstr_func(void *arg)
 /*
  * Document-method: Curses.getstr
  *
- * This is equivalent to a series f Curses::Window.getch calls
+ * This is equivalent to a series of Curses::Window.getch calls
  *
  */
 static VALUE
@@ -934,7 +960,7 @@ curses_keyname(VALUE obj, VALUE c)
  * Returns the number of lines on the screen
  */
 static VALUE
-curses_lines(void)
+curses_lines(VALUE self)
 {
     return INT2FIX(LINES);
 }
@@ -945,7 +971,7 @@ curses_lines(void)
  * Returns the number of columns on the screen
  */
 static VALUE
-curses_cols(void)
+curses_cols(VALUE self)
 {
     return INT2FIX(COLS);
 }
@@ -1091,7 +1117,7 @@ curses_bkgdset(VALUE obj, VALUE ch)
 {
 #ifdef HAVE_BKGDSET
     curses_stdscr();
-    bkgdset(NUM2CHTYPE(ch));
+    bkgdset(OBJ2CHTYPE(ch));
 #endif
     return Qnil;
 }
@@ -1112,7 +1138,7 @@ curses_bkgd(VALUE obj, VALUE ch)
 {
 #ifdef HAVE_BKGD
     curses_stdscr();
-    return (bkgd(NUM2CHTYPE(ch)) == OK) ? Qtrue : Qfalse;
+    return (bkgd(OBJ2CHTYPE(ch)) == OK) ? Qtrue : Qfalse;
 #else
     return Qfalse;
 #endif
@@ -1425,6 +1451,7 @@ struct mousedata {
     MEVENT *mevent;
 };
 
+NORETURN(static void no_mevent(void));
 static void
 no_mevent(void)
 {
@@ -1432,8 +1459,6 @@ no_mevent(void)
 }
 
 #define GetMOUSE(obj, data) do {\
-    if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4)\
-	rb_raise(rb_eSecurityError, "Insecure: operation on untainted mouse");\
     TypedData_Get_Struct((obj), struct mousedata, &mousedata_type, (data));\
     if ((data)->mevent == 0) no_mevent();\
 } while (0)
@@ -1452,7 +1477,7 @@ curses_mousedata_memsize(const void *p)
     const struct mousedata *mdata = p;
     size_t size = sizeof(*mdata);
     if (!mdata) return 0;
-    if (mdata->mevent) size += sizeof(mdata->mevent);
+    if (mdata->mevent) size += CURSES_SIZEOF_MEVENT;
     return size;
 }
 
@@ -1534,7 +1559,7 @@ static VALUE
 curses_mousemask(VALUE obj, VALUE mask)
 {
     curses_stdscr();
-    return INT2NUM(mousemask(NUM2UINT(mask),NULL));
+    return ULONG2NUM(mousemask(NUM2UINT(mask),NULL));
 }
 
 #define DEFINE_MOUSE_GET_MEMBER(func_name,mem) \
@@ -1575,7 +1600,12 @@ DEFINE_MOUSE_GET_MEMBER(curs_mouse_z, z)
  * Returns the current mouse's button state.  Use this with the button state
  * constants to determine which buttons were pressed.
  */
-DEFINE_MOUSE_GET_MEMBER(curs_mouse_bstate, bstate)
+static VALUE curs_mouse_bstate(VALUE mouse)
+{
+    struct mousedata *mdata;
+    GetMOUSE(mouse, mdata);
+    return ULONG2NUM(mdata->mevent->bstate);
+}
 #undef define_curs_mouse_member
 #endif /* USE_MOUSE */
 
@@ -1667,7 +1697,7 @@ window_initialize(VALUE obj, VALUE h, VALUE w, VALUE top, VALUE left)
     struct windata *winp;
     WINDOW *window;
 
-    curses_init_screen();
+    curses_init_screen(Qnil);
     TypedData_Get_Struct(obj, struct windata, &windata_type, winp);
     if (winp->window) delwin(winp->window);
     window = newwin(NUM2INT(h), NUM2INT(w), NUM2INT(top), NUM2INT(left));
@@ -2164,7 +2194,7 @@ window_begx(VALUE obj)
 
 /*
  * Document-method: Curses::Window.box
- * call-seq: box(vert, hor)
+ * call-seq: box(vert = nil, hor = nil, corn = nil)
  *
  * set the characters to frame the window in.
  * The vertical +vert+ and horizontal +hor+ character.
@@ -2179,16 +2209,18 @@ window_box(int argc, VALUE *argv, VALUE self)
     struct windata *winp;
     VALUE vert, hor, corn;
 
-    rb_scan_args(argc, argv, "21", &vert, &hor, &corn);
+    rb_scan_args(argc, argv, "03", &vert, &hor, &corn);
 
     GetWINDOW(self, winp);
-    box(winp->window, NUM2CH(vert), NUM2CH(hor));
+    box(winp->window,
+	NIL_P(vert) ? 0 : OBJ2CHTYPE(vert),
+	NIL_P(hor) ? 0 : OBJ2CHTYPE(hor));
 
     if (!NIL_P(corn)) {
 	int cur_x, cur_y, x, y;
 	chtype c;
 
-	c = NUM2CH(corn);
+	c = OBJ2CHTYPE(corn);
 	getyx(winp->window, cur_y, cur_x);
 	x = NUM2INT(window_maxx(self)) - 1;
 	y = NUM2INT(window_maxy(self)) - 1;
@@ -2255,7 +2287,7 @@ window_inch(VALUE obj)
     struct windata *winp;
 
     GetWINDOW(obj, winp);
-    return CH2FIX(winch(winp->window));
+    return CHTYPE2NUM(winch(winp->window));
 }
 
 /*
@@ -2272,7 +2304,7 @@ window_addch(VALUE obj, VALUE ch)
     struct windata *winp;
 
     GetWINDOW(obj, winp);
-    waddch(winp->window, NUM2CH(ch));
+    waddch(winp->window, OBJ2CHTYPE(ch));
 
     return Qnil;
 }
@@ -2290,7 +2322,7 @@ window_insch(VALUE obj, VALUE ch)
     struct windata *winp;
 
     GetWINDOW(obj, winp);
-    winsch(winp->window, NUM2CH(ch));
+    winsch(winp->window, OBJ2CHTYPE(ch));
 
     return Qnil;
 }
@@ -2400,7 +2432,7 @@ wgetstr_func(void *_arg)
 /*
  * Document-method: Curses::Window.getstr
  *
- * This is equivalent to a series f Curses::Window.getch calls
+ * This is equivalent to a series of Curses::Window.getch calls
  *
  */
 static VALUE
@@ -2718,7 +2750,7 @@ window_bkgdset(VALUE obj, VALUE ch)
     struct windata *winp;
 
     GetWINDOW(obj,winp);
-    wbkgdset(winp->window, NUM2CHTYPE(ch));
+    wbkgdset(winp->window, OBJ2CHTYPE(ch));
 #endif
     return Qnil;
 }
@@ -2739,7 +2771,7 @@ window_bkgd(VALUE obj, VALUE ch)
     struct windata *winp;
 
     GetWINDOW(obj,winp);
-    return (wbkgd(winp->window, NUM2CHTYPE(ch)) == OK) ? Qtrue : Qfalse;
+    return (wbkgd(winp->window, OBJ2CHTYPE(ch)) == OK) ? Qtrue : Qfalse;
 #else
     return Qfalse;
 #endif
@@ -2907,7 +2939,7 @@ pad_initialize(VALUE obj, VALUE h, VALUE w)
     struct windata *padp;
     WINDOW *window;
 
-    curses_init_screen();
+    curses_init_screen(Qnil);
     TypedData_Get_Struct(obj, struct windata, &windata_type, padp);
     if (padp->window) delwin(padp->window);
     window = newpad(NUM2INT(h), NUM2INT(w));
@@ -3028,8 +3060,6 @@ no_item(void)
 }
 
 #define GetITEM(obj, itemp) do {\
-    if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4)\
-	rb_raise(rb_eSecurityError, "Insecure: operation on untainted item");\
     TypedData_Get_Struct((obj), struct itemdata, &itemdata_type, (itemp));\
     if ((itemp)->item == 0) no_item();\
 } while (0)
@@ -3049,7 +3079,7 @@ item_memsize(const void *p)
     const struct itemdata *itemp = p;
     size_t size = sizeof(*itemp);
     if (!itemp) return 0;
-    if (itemp->item) size += sizeof(itemp->item);
+    if (itemp->item) size += CURSES_SIZEOF_ITEM;
     return size;
 }
 
@@ -3080,7 +3110,7 @@ item_initialize(VALUE obj, VALUE name, VALUE description)
 {
     struct itemdata *itemp;
 
-    curses_init_screen();
+    curses_init_screen(Qnil);
     TypedData_Get_Struct(obj, struct itemdata, &itemdata_type, itemp);
     if (itemp->item) {
 	rb_raise(rb_eRuntimeError, "already initialized item");
@@ -3139,6 +3169,83 @@ item_description_m(VALUE obj)
     return rb_external_str_new_with_enc(desc, strlen(desc), terminal_encoding);
 }
 
+/*
+ * Document-method: Curses::Item#set_opts
+ *
+ * call-seq:
+ *   set_opts(opts)
+ *
+ * Set the option bits of the item.
+ */
+static VALUE
+item_set_opts(VALUE obj, VALUE opts)
+{
+    struct itemdata *itemp;
+    int error;
+
+    GetITEM(obj, itemp);
+    error = set_item_opts(itemp->item, NUM2INT(opts));
+    check_curses_error(error);
+    return obj;
+}
+
+/*
+ * Document-method: Curses::Item#opts_on
+ *
+ * call-seq:
+ *   opts_on(opts)
+ *
+ * Turn on the option bits of the item.
+ */
+static VALUE
+item_opts_on_m(VALUE obj, VALUE opts)
+{
+    struct itemdata *itemp;
+    int error;
+
+    GetITEM(obj, itemp);
+    error = item_opts_on(itemp->item, NUM2INT(opts));
+    check_curses_error(error);
+    return obj;
+}
+
+/*
+ * Document-method: Curses::Item#opts_off
+ *
+ * call-seq:
+ *   opts_off(opts)
+ *
+ * Turn off the option bits of the item.
+ */
+static VALUE
+item_opts_off_m(VALUE obj, VALUE opts)
+{
+    struct itemdata *itemp;
+    int error;
+
+    GetITEM(obj, itemp);
+    error = item_opts_off(itemp->item, NUM2INT(opts));
+    check_curses_error(error);
+    return obj;
+}
+
+/*
+ * Document-method: Curses::Item#opts
+ *
+ * call-seq:
+ *   opts
+ *
+ * Get the current option bits of the item.
+ */
+static VALUE
+item_opts_m(VALUE obj, VALUE opts)
+{
+    struct itemdata *itemp;
+
+    GetITEM(obj, itemp);
+    return INT2NUM(item_opts(itemp->item));
+}
+
 struct menudata {
     MENU *menu;
     VALUE items;
@@ -3151,8 +3258,6 @@ no_menu(void)
 }
 
 #define GetMENU(obj, menup) do {\
-    if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4)\
-	rb_raise(rb_eSecurityError, "Insecure: operation on untainted menu");\
     TypedData_Get_Struct((obj), struct menudata, &menudata_type, (menup));\
     if ((menup)->menu == 0) no_menu();\
 } while (0)
@@ -3183,7 +3288,7 @@ menu_memsize(const void *p)
     const struct menudata *menup = p;
     size_t size = sizeof(*menup);
     if (!menup) return 0;
-    if (menup->menu) size += sizeof(menup->menu);
+    if (menup->menu) size += CURSES_SIZEOF_MENU;
     return size;
 }
 
@@ -3205,7 +3310,7 @@ menu_s_allocate(VALUE class)
  * Document-method: Curses::Menu.new
  *
  * call-seq:
- *   new(name, description)
+ *   new(items)
  *
  * Construct a new Curses::Menu.
  */
@@ -3215,26 +3320,33 @@ menu_initialize(VALUE obj, VALUE items)
     struct menudata *menup;
     ITEM **menu_items;
     int i;
+    ID id_new;
 
     Check_Type(items, T_ARRAY);
-    curses_init_screen();
+    curses_init_screen(Qnil);
     TypedData_Get_Struct(obj, struct menudata, &menudata_type, menup);
     if (menup->menu) {
 	rb_raise(rb_eRuntimeError, "already initialized menu");
     }
+    menup->items = rb_ary_new();
     menu_items = ALLOC_N(ITEM *, RARRAY_LEN(items) + 1);
+    CONST_ID(id_new, "new");
     for (i = 0; i < RARRAY_LEN(items); i++) {
+	VALUE item = RARRAY_AREF(items, i);
 	struct itemdata *itemp;
 
-	GetITEM(RARRAY_AREF(items, i), itemp);
+	if (RB_TYPE_P(item, T_ARRAY)) {
+	    item = rb_apply(cItem, id_new, item);
+	}
+	GetITEM(item, itemp);
 	menu_items[i] = itemp->item;
+	rb_ary_push(menup->items, item);
     }
     menu_items[RARRAY_LEN(items)] = NULL;
     menup->menu = new_menu(menu_items);
     if (menup->menu == NULL) {
 	check_curses_error(errno);
     }
-    menup->items = rb_ary_dup(items);
 
     return obj;
 }
@@ -3426,190 +3538,1065 @@ menu_set_current_item(VALUE obj, VALUE item)
     return item;
 }
 
-#endif /* HAVE_MENU */
-
 /*
- * Document-method: Curses.keyboard_encoding
- * call-seq: Curses.keyboard_encoding
+ * Document-method: Curses::Menu#set_win
  *
- * Returns the encoding for keyboard input.
+ * call-seq:
+ *   set_win=(win)
+ *
+ * Set the window of the menu.
  */
 static VALUE
-curses_get_keyboard_encoding(VALUE obj)
+menu_set_win(VALUE obj, VALUE win)
 {
-    return rb_enc_from_encoding(keyboard_encoding);
+    struct menudata *menup;
+    struct windata *winp;
+
+    GetMENU(obj, menup);
+    GetWINDOW(win, winp);
+    set_menu_win(menup->menu, winp->window);
+    return win;
 }
 
 /*
- * Document-method: Curses.keyboard_encoding=
- * call-seq: Curses.keyboard_encoding = encoding
+ * Document-method: Curses::Menu#set_sub
  *
- * Sets the encoding for keyboard input.
+ * call-seq:
+ *   set_sub=(win)
+ *
+ * Set the subwindow of the menu.
  */
 static VALUE
-curses_set_keyboard_encoding(VALUE obj, VALUE enc)
+menu_set_sub(VALUE obj, VALUE win)
 {
-    keyboard_encoding = rb_to_encoding(enc);
-    return enc;
+    struct menudata *menup;
+    struct windata *winp;
+
+    GetMENU(obj, menup);
+    GetWINDOW(win, winp);
+    set_menu_sub(menup->menu, winp->window);
+    return win;
 }
 
 /*
- * Document-method: Curses.terminal_encoding
- * call-seq: Curses.terminal_encoding
+ * Document-method: Curses::Menu#scale
  *
- * Returns the encoding for terminal output.
+ * call-seq:
+ *   scale
+ *
+ * Return the minimum rows and columns required for the subwindow of the menu.
  */
 static VALUE
-curses_get_terminal_encoding(VALUE obj)
+menu_scale(VALUE obj)
 {
-    return rb_enc_from_encoding(terminal_encoding);
+    struct menudata *menup;
+    int error, rows, columns;
+
+    GetMENU(obj, menup);
+    error = scale_menu(menup->menu, &rows, &columns);
+    check_curses_error(error);
+    return rb_assoc_new(INT2NUM(rows), INT2NUM(columns));
 }
 
 /*
- * Document-method: Curses.terminal_encoding=
- * call-seq: Curses.terminal_encoding = encoding
+ * Document-method: Curses::Menu#set_format
  *
- * Sets the encoding for terminal output.
+ * call-seq:
+ *   set_format(rows, cols)
+ *
+ * Set the maximum size of the menu.
  */
 static VALUE
-curses_set_terminal_encoding(VALUE obj, VALUE enc)
+menu_set_format(VALUE obj, VALUE rows, VALUE cols)
 {
-    terminal_encoding = rb_to_encoding(enc);
-    return enc;
+    struct menudata *menup;
+    int error;
+
+    GetMENU(obj, menup);
+    error = set_menu_format(menup->menu, NUM2INT(rows), NUM2INT(cols));
+    check_curses_error(error);
+    return obj;
 }
 
 /*
- * Document-method: Curses.unget_char
- * call-seq: unget_char(ch)
+ * Document-method: Curses::Menu#format
  *
- * Places +ch+ back onto the input queue to be returned by
- * the next call to Curses.get_char etc.
+ * call-seq:
+ *   format
  *
- * There is just one input queue for all windows.
+ * Get the maximum size of the menu.
  */
 static VALUE
-curses_unget_char(VALUE obj, VALUE ch)
+menu_format_m(VALUE obj)
 {
-    ID id_ord;
-    unsigned int c;
+    struct menudata *menup;
+    int rows, cols;
 
-    curses_stdscr();
-    if (FIXNUM_P(ch)) {
-	ungetch(NUM2UINT(ch));
-    }
-    else {
-	StringValue(ch);
-	CONST_ID(id_ord, "ord");
-	c = NUM2UINT(rb_funcall(ch, id_ord, 0));
-#ifdef HAVE_UNGET_WCH
-	unget_wch(c);
-#else
-	if (c > 0xff) {
-	    rb_raise(rb_eRangeError, "Out of range: %u", c);
-	}
-	ungetch(c);
-#endif
-    }
-    return Qnil;
+    GetMENU(obj, menup);
+    menu_format(menup->menu, &rows, &cols);
+    return rb_assoc_new(INT2NUM(rows), INT2NUM(cols));
 }
 
+/*
+ * Document-method: Curses::Menu#set_opts
+ *
+ * call-seq:
+ *   set_opts(opts)
+ *
+ * Set the option bits of the menu.
+ */
 static VALUE
-keyboard_uint_chr(unsigned int ch)
+menu_set_opts(VALUE obj, VALUE opts)
 {
-    return rb_enc_uint_chr(ch, keyboard_encoding);
-}
-
-#ifdef HAVE_GET_WCH
-struct get_wch_arg {
-    int retval;
-    wint_t ch;
-};
+    struct menudata *menup;
+    int error;
 
-static void *
-get_wch_func(void *_arg)
-{
-    struct get_wch_arg *arg = (struct get_wch_arg *) _arg;
-    arg->retval = get_wch(&arg->ch);
-    return 0;
+    GetMENU(obj, menup);
+    error = set_menu_opts(menup->menu, NUM2INT(opts));
+    check_curses_error(error);
+    return obj;
 }
-#endif
 
 /*
- * Document-method: Curses.get_char
- *
- * Read and returns a character or function key from the window.
- * A single or multibyte character is represented by a String, and
- * a function key is represented by an Integer.
- * Returns nil if no input is ready.
+ * Document-method: Curses::Menu#opts_on
  *
- * See Curses::Key to all the function KEY_* available
+ * call-seq:
+ *   opts_on(opts)
  *
+ * Turn on the option bits of the menu.
  */
 static VALUE
-curses_get_char(VALUE obj)
+menu_opts_on_m(VALUE obj, VALUE opts)
 {
-#ifdef HAVE_GET_WCH
-    struct get_wch_arg arg;
-
-    curses_stdscr();
-    rb_thread_call_without_gvl(get_wch_func, &arg, RUBY_UBF_IO, 0);
-    switch (arg.retval) {
-    case OK:
-	return keyboard_uint_chr(arg.ch);
-    case KEY_CODE_YES:
-	return UINT2NUM(arg.ch);
-    }
-    return Qnil;
-#else
-    int c;
+    struct menudata *menup;
+    int error;
 
-    curses_stdscr();
-    rb_thread_call_without_gvl(getch_func, &c, RUBY_UBF_IO, 0);
-    if (c > 0xff) {
-	return INT2NUM(c);
-    }
-    else if (c >= 0) {
-	return keyboard_uint_chr(c);
-    }
-    else {
-	return Qnil;
-    }
-#endif
+    GetMENU(obj, menup);
+    error = menu_opts_on(menup->menu, NUM2INT(opts));
+    check_curses_error(error);
+    return obj;
 }
 
-
-#ifdef HAVE_WGET_WCH
-struct wget_wch_arg {
-    WINDOW *win;
-    int retval;
-    wint_t ch;
-};
-
-static void *
-wget_wch_func(void *_arg)
+/*
+ * Document-method: Curses::Menu#opts_off
+ *
+ * call-seq:
+ *   opts_off(opts)
+ *
+ * Turn off the option bits of the menu.
+ */
+static VALUE
+menu_opts_off_m(VALUE obj, VALUE opts)
 {
-    struct wget_wch_arg *arg = (struct wget_wch_arg *) _arg;
-    arg->retval = wget_wch(arg->win, &arg->ch);
-    return 0;
+    struct menudata *menup;
+    int error;
+
+    GetMENU(obj, menup);
+    error = menu_opts_off(menup->menu, NUM2INT(opts));
+    check_curses_error(error);
+    return obj;
 }
-#endif
 
 /*
- * Document-method: Curses::Window.get_char
- *
- * Read and returns a character or function key from the window.
- * A single or multibyte character is represented by a String, and
- * a function key is represented by an Integer.
- * Returns nil if no input is ready.
+ * Document-method: Curses::Menu#opts
  *
- * See Curses::Key to all the function KEY_* available
+ * call-seq:
+ *   opts
  *
+ * Get the current option bits of the menu.
  */
 static VALUE
-window_get_char(VALUE obj)
+menu_opts_m(VALUE obj, VALUE opts)
 {
-#ifdef HAVE_WGET_WCH
-    struct windata *winp;
+    struct menudata *menup;
+
+    GetMENU(obj, menup);
+    return INT2NUM(menu_opts(menup->menu));
+}
+#endif /* HAVE_MENU */
+
+#ifdef HAVE_FORM
+struct fielddata {
+    FIELD *field;
+};
+
+NORETURN(static void no_field(void));
+static void
+no_field(void)
+{
+    rb_raise(rb_eRuntimeError, "already deleted field");
+}
+
+#define GetFIELD(obj, fieldp) do {\
+    TypedData_Get_Struct((obj), struct fielddata, &fielddata_type, (fieldp));\
+    if ((fieldp)->field == 0) no_field();\
+} while (0)
+
+static void
+field_free(void *p)
+{
+    struct fielddata *fieldp = p;
+    if (fieldp->field) free_field(fieldp->field);
+    fieldp->field = 0;
+    xfree(fieldp);
+}
+
+static size_t
+field_memsize(const void *p)
+{
+    const struct fielddata *fieldp = p;
+    size_t size = sizeof(*fieldp);
+    if (!fieldp) return 0;
+    if (fieldp->field) size += CURSES_SIZEOF_FIELD;
+    return size;
+}
+
+static const rb_data_type_t fielddata_type = {
+    "fielddata",
+    {0, field_free, field_memsize,}
+};
+
+/* returns a Curses::Menu object */
+static VALUE
+field_s_allocate(VALUE class)
+{
+    struct fielddata *fieldp;
+
+    return TypedData_Make_Struct(class, struct fielddata, &fielddata_type, fieldp);
+}
+
+/*
+ * Document-method: Curses::Field.new
+ *
+ * call-seq:
+ *   new(height, width, toprow, leftcol, offscreen, nbuffers)
+ *
+ * Construct a new Curses::Field.
+ */
+static VALUE
+field_initialize(VALUE obj, VALUE height, VALUE width,
+		 VALUE toprow, VALUE leftcol, VALUE offscreen, VALUE nbuffers)
+{
+    struct fielddata *fieldp;
+
+    curses_init_screen(Qnil);
+    TypedData_Get_Struct(obj, struct fielddata, &fielddata_type, fieldp);
+    if (fieldp->field) {
+	rb_raise(rb_eRuntimeError, "already initialized field");
+    }
+    fieldp->field = new_field(NUM2INT(height), NUM2INT(width),
+			      NUM2INT(toprow), NUM2INT(leftcol),
+			      NUM2INT(offscreen), NUM2INT(nbuffers));
+    if (fieldp->field == NULL) {
+	check_curses_error(errno);
+    }
+
+    return obj;
+}
+
+/*
+ * Document-method: Curses::Field#set_buffer
+ *
+ * call-seq:
+ *   set_buffer(buf, value)
+ *
+ * Set the numbered buffer of the field.
+ */
+static VALUE
+field_set_buffer(VALUE obj, VALUE buf, VALUE value)
+{
+    struct fielddata *fieldp;
+
+    GetFIELD(obj, fieldp);
+    value = rb_str_export_to_enc(value, terminal_encoding);
+    set_field_buffer(fieldp->field, NUM2INT(buf), StringValueCStr(value));
+
+    return obj;
+}
+
+/*
+ * Document-method: Curses::Field#buffer
+ *
+ * call-seq:
+ *   buffer(buf)
+ *
+ * Get the numbered buffer of the field.
+ */
+static VALUE
+field_buffer_m(VALUE obj, VALUE buf)
+{
+    struct fielddata *fieldp;
+    char *s;
+
+    GetFIELD(obj, fieldp);
+    s = field_buffer(fieldp->field, NUM2INT(buf));
+    return rb_external_str_new_with_enc(s, strlen(s), terminal_encoding);
+}
+
+/*
+ * Document-method: Curses::Field#set_fore
+ *
+ * call-seq:
+ *   set_fore(attr)
+ *
+ * Set the foreground attribute of the field.
+ */
+static VALUE
+field_set_fore(VALUE obj, VALUE attr)
+{
+    struct fielddata *fieldp;
+
+    GetFIELD(obj, fieldp);
+    set_field_fore(fieldp->field, NUM2CHTYPE(attr));
+
+    return attr;
+}
+
+/*
+ * Document-method: Curses::Field#fore
+ *
+ * call-seq:
+ *   fore
+ *
+ * Get the foreground attribute of the field.
+ */
+static VALUE
+field_get_fore(VALUE obj)
+{
+    struct fielddata *fieldp;
+
+    GetFIELD(obj, fieldp);
+    return CHTYPE2NUM(field_fore(fieldp->field));
+}
+
+/*
+ * Document-method: Curses::Field#set_back
+ *
+ * call-seq:
+ *   set_back(attr)
+ *
+ * Set the background attribute of the field.
+ */
+static VALUE
+field_set_back(VALUE obj, VALUE attr)
+{
+    struct fielddata *fieldp;
+
+    GetFIELD(obj, fieldp);
+    set_field_back(fieldp->field, NUM2CHTYPE(attr));
+
+    return attr;
+}
+
+/*
+ * Document-method: Curses::Field#back
+ *
+ * call-seq:
+ *   back
+ *
+ * Get the background attribute of the field.
+ */
+static VALUE
+field_get_back(VALUE obj)
+{
+    struct fielddata *fieldp;
+
+    GetFIELD(obj, fieldp);
+    return CHTYPE2NUM(field_back(fieldp->field));
+}
+
+/*
+ * Document-method: Curses::Field#opts_on
+ *
+ * call-seq:
+ *   opts_on(opts)
+ *
+ * Turn on the given option bits.
+ */
+static VALUE
+field_opts_on_m(VALUE obj, VALUE opts)
+{
+    struct fielddata *fieldp;
+
+    GetFIELD(obj, fieldp);
+    field_opts_on(fieldp->field, NUM2INT(opts));
+
+    return opts;
+}
+
+/*
+ * Document-method: Curses::Field#opts_off
+ *
+ * call-seq:
+ *   opts_off(opts)
+ *
+ * Turn off the given option bits.
+ */
+static VALUE
+field_opts_off_m(VALUE obj, VALUE opts)
+{
+    struct fielddata *fieldp;
+
+    GetFIELD(obj, fieldp);
+    field_opts_off(fieldp->field, NUM2INT(opts));
+
+    return opts;
+}
+
+/*
+ * Document-method: Curses::Field#opts
+ *
+ * call-seq:
+ *   opts
+ *
+ * Get the current option bits.
+ */
+static VALUE
+field_opts_m(VALUE obj)
+{
+    struct fielddata *fieldp;
+
+    GetFIELD(obj, fieldp);
+    return INT2NUM(field_opts(fieldp->field));
+}
+
+static VALUE
+field_height(VALUE obj)
+{
+    struct fielddata *fieldp;
+    int error, val;
+
+    GetFIELD(obj, fieldp);
+    error = field_info(fieldp->field, &val, NULL, NULL, NULL, NULL, NULL);
+    check_curses_error(error);
+    return INT2NUM(val);
+}
+
+static VALUE
+field_width(VALUE obj)
+{
+    struct fielddata *fieldp;
+    int error, val;
+
+    GetFIELD(obj, fieldp);
+    error = field_info(fieldp->field, NULL, &val, NULL, NULL, NULL, NULL);
+    check_curses_error(error);
+    return INT2NUM(val);
+}
+
+static VALUE
+field_toprow(VALUE obj)
+{
+    struct fielddata *fieldp;
+    int error, val;
+
+    GetFIELD(obj, fieldp);
+    error = field_info(fieldp->field, NULL, NULL, &val, NULL, NULL, NULL);
+    check_curses_error(error);
+    return INT2NUM(val);
+}
+
+static VALUE
+field_leftcol(VALUE obj)
+{
+    struct fielddata *fieldp;
+    int error, val;
+
+    GetFIELD(obj, fieldp);
+    error = field_info(fieldp->field, NULL, NULL, NULL, &val, NULL, NULL);
+    check_curses_error(error);
+    return INT2NUM(val);
+}
+
+static VALUE
+field_offscreen(VALUE obj)
+{
+    struct fielddata *fieldp;
+    int error, val;
+
+    GetFIELD(obj, fieldp);
+    error = field_info(fieldp->field, NULL, NULL, NULL, NULL, &val, NULL);
+    check_curses_error(error);
+    return INT2NUM(val);
+}
+
+static VALUE
+field_nbuffers(VALUE obj)
+{
+    struct fielddata *fieldp;
+    int error, val;
+
+    GetFIELD(obj, fieldp);
+    error = field_info(fieldp->field, NULL, NULL, NULL, NULL, NULL, &val);
+    check_curses_error(error);
+    return INT2NUM(val);
+}
+
+static VALUE
+field_dynamic_height(VALUE obj)
+{
+    struct fielddata *fieldp;
+    int error, val;
+
+    GetFIELD(obj, fieldp);
+    error = dynamic_field_info(fieldp->field, &val, NULL, NULL);
+    check_curses_error(error);
+    return INT2NUM(val);
+}
+
+static VALUE
+field_dynamic_width(VALUE obj)
+{
+    struct fielddata *fieldp;
+    int error, val;
+
+    GetFIELD(obj, fieldp);
+    error = dynamic_field_info(fieldp->field, NULL, &val, NULL);
+    check_curses_error(error);
+    return INT2NUM(val);
+}
+
+static VALUE
+field_max(VALUE obj)
+{
+    struct fielddata *fieldp;
+    int error, val;
+
+    GetFIELD(obj, fieldp);
+    error = dynamic_field_info(fieldp->field, NULL, NULL, &val);
+    check_curses_error(error);
+    return INT2NUM(val);
+}
+
+static VALUE
+field_set_max(VALUE obj, VALUE max)
+{
+    struct fielddata *fieldp;
+    int error;
+
+    GetFIELD(obj, fieldp);
+    error = set_max_field(fieldp->field, NUM2INT(max));
+    check_curses_error(error);
+    return max;
+}
+
+#define TYPE_CODE_ALPHA 1
+#define TYPE_CODE_ALNUM 2
+#define TYPE_CODE_ENUM 3
+#define TYPE_CODE_INTEGER 4
+#define TYPE_CODE_NUMERIC 5
+#define TYPE_CODE_REGEXP 6
+
+static VALUE
+field_set_type(int argc, VALUE *argv, VALUE obj)
+{
+    struct fielddata *fieldp;
+    VALUE type;
+    int type_code;
+    int error;
+
+    if (argc < 1) {
+	rb_raise(rb_eArgError,
+                 "wrong number of arguments (given %d, expected 1)", argc);
+    }
+    type_code = NUM2INT(argv[0]);
+    GetFIELD(obj, fieldp);
+    switch (type_code) {
+    case TYPE_CODE_ALPHA:
+        {
+            VALUE width;
+	    rb_scan_args(argc, argv, "11", &type, &width);
+	    error = set_field_type(fieldp->field, TYPE_ALPHA,
+                                   NIL_P(width) ? 0 : NUM2INT(width));
+	}
+        break;
+    case TYPE_CODE_ALNUM:
+        {
+            VALUE width;
+	    rb_scan_args(argc, argv, "11", &type, &width);
+	    error = set_field_type(fieldp->field, TYPE_ALNUM,
+                                   NIL_P(width) ? 0 : NUM2INT(width));
+	}
+        break;
+#if 0
+    case TYPE_CODE_ENUM:
+        {
+            /* TODO: consider how valuelist should be allocated? */
+	}
+        break;
+#endif
+    case TYPE_CODE_INTEGER:
+        {
+            VALUE padding, vmin, vmax;
+	    rb_scan_args(argc, argv, "13", &type, &padding, &vmin, &vmax);
+	    error = set_field_type(fieldp->field, TYPE_INTEGER,
+                                   NIL_P(padding) ? 0 : NUM2INT(padding),
+                                   NIL_P(vmin) ? INT_MIN : NUM2INT(vmin),
+                                   NIL_P(vmax) ? INT_MAX : NUM2INT(vmax));
+	}
+        break;
+    case TYPE_CODE_NUMERIC:
+        {
+            VALUE padding, vmin, vmax;
+	    rb_scan_args(argc, argv, "13", &type, &padding, &vmin, &vmax);
+	    error = set_field_type(fieldp->field, TYPE_INTEGER,
+                                   NIL_P(padding) ? 0 : NUM2INT(padding),
+                                   NIL_P(vmin) ? INT_MIN : NUM2INT(vmin),
+                                   NIL_P(vmax) ? INT_MAX : NUM2INT(vmax));
+	}
+        break;
+#if 0
+    case TYPE_CODE_REGEXP:
+        {
+            /* TODO: consider how regexp should be allocated? */
+	}
+        break;
+#endif
+    default:
+	rb_raise(rb_eArgError, "unknwon type: %d", type_code);
+	break;
+    }
+    check_curses_error(error);
+    return obj;
+}
+
+struct formdata {
+    FORM *form;
+    VALUE fields;
+};
+
+NORETURN(static void no_form(void));
+static void
+no_form(void)
+{
+    rb_raise(rb_eRuntimeError, "already deleted form");
+}
+
+#define GetFORM(obj, formp) do {\
+    TypedData_Get_Struct((obj), struct formdata, &formdata_type, (formp));\
+    if ((formp)->form == 0) no_form();\
+} while (0)
+
+static void
+form_gc_mark(void *p)
+{
+    struct formdata *formp = p;
+
+    rb_gc_mark(formp->fields);
+}    
+
+static void
+form_free(void *p)
+{
+    struct formdata *formp = p;
+    FIELD **fields = form_fields(formp->form);
+    if (formp->form) free_form(formp->form);
+    xfree(fields);
+    formp->form = 0;
+    formp->fields = Qnil;
+    xfree(formp);
+}
+
+static size_t
+form_memsize(const void *p)
+{
+    const struct formdata *formp = p;
+    size_t size = sizeof(*formp);
+    if (!formp) return 0;
+    if (formp->form) size += CURSES_SIZEOF_FORM;
+    return size;
+}
+
+static const rb_data_type_t formdata_type = {
+    "formdata",
+    {form_gc_mark, form_free, form_memsize,}
+};
+
+/* returns a Curses::Form object */
+static VALUE
+form_s_allocate(VALUE class)
+{
+    struct formdata *formp;
+
+    return TypedData_Make_Struct(class, struct formdata, &formdata_type, formp);
+}
+
+/*
+ * Document-method: Curses::Form.new
+ *
+ * call-seq:
+ *   new(fields)
+ *
+ * Construct a new Curses::Form.
+ */
+static VALUE
+form_initialize(VALUE obj, VALUE fields)
+{
+    struct formdata *formp;
+    FIELD **form_fields;
+    int i;
+
+    Check_Type(fields, T_ARRAY);
+    curses_init_screen(Qnil);
+    TypedData_Get_Struct(obj, struct formdata, &formdata_type, formp);
+    if (formp->form) {
+	rb_raise(rb_eRuntimeError, "already initialized form");
+    }
+    formp->fields = rb_ary_new();
+    form_fields = ALLOC_N(FIELD *, RARRAY_LEN(fields) + 1);
+    for (i = 0; i < RARRAY_LEN(fields); i++) {
+	VALUE field = RARRAY_AREF(fields, i);
+	struct fielddata *fieldp;
+
+	GetFIELD(field, fieldp);
+	form_fields[i] = fieldp->field;
+	rb_ary_push(formp->fields, field);
+    }
+    form_fields[RARRAY_LEN(fields)] = NULL;
+    formp->form = new_form(form_fields);
+    if (formp->form == NULL) {
+	check_curses_error(errno);
+    }
+
+    return obj;
+}
+
+/*
+ * Document-method: Curses::Form#post
+ *
+ * call-seq:
+ *   post
+ *
+ * Post the form.
+ */
+static VALUE
+form_post(VALUE obj)
+{
+    struct formdata *formp;
+    int error;
+
+    GetFORM(obj, formp);
+    error = post_form(formp->form);
+    check_curses_error(error);
+
+    return obj;
+}
+
+/*
+ * Document-method: Curses::Form#unpost
+ *
+ * call-seq:
+ *   unpost
+ *
+ * Unpost the form.
+ */
+static VALUE
+form_unpost(VALUE obj)
+{
+    struct formdata *formp;
+    int error;
+
+    GetFORM(obj, formp);
+    error = unpost_form(formp->form);
+    check_curses_error(error);
+
+    return obj;
+}
+
+/*
+ * Document-method: Curses::Form#driver
+ *
+ * call-seq:
+ *   driver(command)
+ *
+ * Perform the command on the form.
+ */
+static VALUE
+form_driver_m(VALUE obj, VALUE command)
+{
+    struct formdata *formp;
+    int error, c;
+
+    GetFORM(obj, formp);
+    if (FIXNUM_P(command)) {
+	c = NUM2INT(command);
+    }
+    else {
+	ID id_ord;
+
+	StringValue(command);
+	CONST_ID(id_ord, "ord");
+	c = NUM2INT(rb_funcall(command, id_ord, 0));
+    }
+#ifdef HAVE_FORM_DRIVER_W
+    error = form_driver_w(formp->form,
+			  FIXNUM_P(command) ? KEY_CODE_YES : OK,
+			  c);
+#else
+    error = form_driver(formp->form, c);
+#endif
+    check_curses_error(error);
+
+    return obj;
+}
+
+/*
+ * Document-method: Curses::Form#set_win
+ *
+ * call-seq:
+ *   set_win=(win)
+ *
+ * Set the window of the form.
+ */
+static VALUE
+form_set_win(VALUE obj, VALUE win)
+{
+    struct formdata *formp;
+    struct windata *winp;
+
+    GetFORM(obj, formp);
+    GetWINDOW(win, winp);
+    set_form_win(formp->form, winp->window);
+    return win;
+}
+
+/*
+ * Document-method: Curses::Form#set_sub
+ *
+ * call-seq:
+ *   set_sub=(win)
+ *
+ * Set the subwindow of the form.
+ */
+static VALUE
+form_set_sub(VALUE obj, VALUE win)
+{
+    struct formdata *formp;
+    struct windata *winp;
+
+    GetFORM(obj, formp);
+    GetWINDOW(win, winp);
+    set_form_sub(formp->form, winp->window);
+    return win;
+}
+
+/*
+ * Document-method: Curses::Form#scale
+ *
+ * call-seq:
+ *   scale
+ *
+ * Return the minimum rows and columns required for the subwindow of the form.
+ */
+static VALUE
+form_scale(VALUE obj)
+{
+    struct formdata *formp;
+    int error, rows, columns;
+
+    GetFORM(obj, formp);
+    error = scale_form(formp->form, &rows, &columns);
+    check_curses_error(error);
+    return rb_assoc_new(INT2NUM(rows), INT2NUM(columns));
+}
+
+#endif /* HAVE_FORM */
+
+/*
+ * Document-method: Curses.keyboard_encoding
+ * call-seq: Curses.keyboard_encoding
+ *
+ * Returns the encoding for keyboard input.
+ */
+static VALUE
+curses_get_keyboard_encoding(VALUE obj)
+{
+    return rb_enc_from_encoding(keyboard_encoding);
+}
+
+/*
+ * Document-method: Curses.keyboard_encoding=
+ * call-seq: Curses.keyboard_encoding = encoding
+ *
+ * Sets the encoding for keyboard input.
+ */
+static VALUE
+curses_set_keyboard_encoding(VALUE obj, VALUE enc)
+{
+    keyboard_encoding = rb_to_encoding(enc);
+    return enc;
+}
+
+/*
+ * Document-method: Curses.terminal_encoding
+ * call-seq: Curses.terminal_encoding
+ *
+ * Returns the encoding for terminal output.
+ */
+static VALUE
+curses_get_terminal_encoding(VALUE obj)
+{
+    return rb_enc_from_encoding(terminal_encoding);
+}
+
+/*
+ * Document-method: Curses.terminal_encoding=
+ * call-seq: Curses.terminal_encoding = encoding
+ *
+ * Sets the encoding for terminal output.
+ */
+static VALUE
+curses_set_terminal_encoding(VALUE obj, VALUE enc)
+{
+    terminal_encoding = rb_to_encoding(enc);
+    return enc;
+}
+
+/*
+ * Document-method: Curses.unget_char
+ * call-seq: unget_char(ch)
+ *
+ * Places +ch+ back onto the input queue to be returned by
+ * the next call to Curses.get_char etc.
+ *
+ * There is just one input queue for all windows.
+ */
+static VALUE
+curses_unget_char(VALUE obj, VALUE ch)
+{
+    ID id_ord;
+    unsigned int c;
+
+    curses_stdscr();
+    if (FIXNUM_P(ch)) {
+	ungetch(NUM2UINT(ch));
+    }
+    else {
+	StringValue(ch);
+	CONST_ID(id_ord, "ord");
+	c = NUM2UINT(rb_funcall(ch, id_ord, 0));
+#ifdef HAVE_UNGET_WCH
+	unget_wch(c);
+#else
+	if (c > 0xff) {
+	    rb_raise(rb_eRangeError, "Out of range: %u", c);
+	}
+	ungetch(c);
+#endif
+    }
+    return Qnil;
+}
+
+static VALUE
+keyboard_uint_chr(unsigned int ch)
+{
+    return rb_enc_uint_chr(ch, keyboard_encoding);
+}
+
+#if defined(HAVE_GET_WCH) || defined(HAVE_WGET_WCH)
+static VALUE
+key_code_value(unsigned int ch)
+{
+#ifdef CTL_FSLASH
+    if (ch == CTL_FSLASH) {
+	return keyboard_uint_chr(0x1F);
+    }
+#endif
+    return UINT2NUM(ch);
+}
+#endif
+
+#ifdef HAVE_GET_WCH
+struct get_wch_arg {
+    int retval;
+    wint_t ch;
+};
+
+static void *
+get_wch_func(void *_arg)
+{
+    struct get_wch_arg *arg = (struct get_wch_arg *) _arg;
+    arg->retval = get_wch(&arg->ch);
+    return 0;
+}
+#endif
+
+/*
+ * Document-method: Curses.get_char
+ *
+ * Read and returns a character or function key from the window.
+ * A single or multibyte character is represented by a String, and
+ * a function key is represented by an Integer.
+ * Returns nil if no input is ready.
+ *
+ * See Curses::Key to all the function KEY_* available
+ *
+ */
+static VALUE
+curses_get_char(VALUE obj)
+{
+#ifdef HAVE_GET_WCH
+    struct get_wch_arg arg;
+
+    curses_stdscr();
+    rb_thread_call_without_gvl(get_wch_func, &arg, RUBY_UBF_IO, 0);
+    switch (arg.retval) {
+    case OK:
+	return keyboard_uint_chr(arg.ch);
+    case KEY_CODE_YES:
+	return key_code_value(arg.ch);
+    }
+    return Qnil;
+#else
+    int c;
+
+    curses_stdscr();
+    rb_thread_call_without_gvl(getch_func, &c, RUBY_UBF_IO, 0);
+    if (c > 0xff) {
+	return INT2NUM(c);
+    }
+    else if (c >= 0) {
+	return keyboard_uint_chr(c);
+    }
+    else {
+	return Qnil;
+    }
+#endif
+}
+
+
+#ifdef HAVE_WGET_WCH
+struct wget_wch_arg {
+    WINDOW *win;
+    int retval;
+    wint_t ch;
+};
+
+static void *
+wget_wch_func(void *_arg)
+{
+    struct wget_wch_arg *arg = (struct wget_wch_arg *) _arg;
+    arg->retval = wget_wch(arg->win, &arg->ch);
+    return 0;
+}
+#endif
+
+/*
+ * Document-method: Curses::Window.get_char
+ *
+ * Read and returns a character or function key from the window.
+ * A single or multibyte character is represented by a String, and
+ * a function key is represented by an Integer.
+ * Returns nil if no input is ready.
+ *
+ * See Curses::Key to all the function KEY_* available
+ *
+ */
+static VALUE
+window_get_char(VALUE obj)
+{
+#ifdef HAVE_WGET_WCH
+    struct windata *winp;
     struct wget_wch_arg arg;
 
     GetWINDOW(obj, winp);
@@ -3619,7 +4606,7 @@ window_get_char(VALUE obj)
     case OK:
 	return keyboard_uint_chr(arg.ch);
     case KEY_CODE_YES:
-	return UINT2NUM(arg.ch);
+	return key_code_value(arg.ch);
     }
     return Qnil;
 #else
@@ -3750,7 +4737,7 @@ Init_curses(void)
     rb_define_module_function(mCurses, "init_screen", curses_init_screen, 0);
     rb_define_module_function(mCurses, "close_screen", curses_close_screen, 0);
     rb_define_module_function(mCurses, "closed?", curses_closed, 0);
-    rb_define_module_function(mCurses, "stdscr", curses_stdscr, 0);
+    rb_define_module_function(mCurses, "stdscr", curses_init_screen, 0);
     rb_define_module_function(mCurses, "refresh", curses_refresh, 0);
     rb_define_module_function(mCurses, "doupdate", curses_doupdate, 0);
     rb_define_module_function(mCurses, "clear", curses_clear, 0);
@@ -3890,7 +4877,7 @@ Init_curses(void)
      *   win.close
      *
      */
-    cWindow = rb_define_class_under(mCurses, "Window", rb_cData);
+    cWindow = rb_define_class_under(mCurses, "Window", rb_cObject);
     rb_define_alloc_func(cWindow, window_s_allocate);
     rb_define_method(cWindow, "initialize", window_initialize, 4);
     rb_define_method(cWindow, "subwin", window_subwin, 4);
@@ -3974,14 +4961,18 @@ Init_curses(void)
 #endif
 
 #ifdef HAVE_MENU
-    cItem = rb_define_class_under(mCurses, "Item", rb_cData);
+    cItem = rb_define_class_under(mCurses, "Item", rb_cObject);
     rb_define_alloc_func(cItem, item_s_allocate);
     rb_define_method(cItem, "initialize", item_initialize, 2);
     rb_define_method(cItem, "==", item_eq, 1);
     rb_define_method(cItem, "name", item_name_m, 0);