curses 1.2.6 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c8cd5188348efc3da97bd7fd52aaf748636da0278c9d08d9b3a8aef9bd124f9
-  data.tar.gz: 98afd30e1daa2bee1a50f2f3f037ffbf503acd2befa84d89ee3fe3f6f0e62e83
+  metadata.gz: ab24f57e39b3e38b5b9833d34f9bf5d6c2d55337f59693c628e30aa1f4f7324e
+  data.tar.gz: a91a892d3c975670cccda3d99a5d7b7a9b0ff8e708aedaf87a2d57cc505d6338
 SHA512:
-  metadata.gz: 5093a94321e82de364022d2e997263659a4ecbd0ce7528fcad780e09bbb08db7c172ee13805b6775d4dd9754e7581eafba50dd363f94aac7e458c9da9ee5af8b
-  data.tar.gz: 8e4e86a0884300c5dcd0c9da5974597eba4adcc0d4bb1ab31e648fdea2689cc50cf2d556e401a30b40a1ca9d9d3e6eedd664c1efaa44192d06dcd893e43d76f5
+  metadata.gz: eff7ca406eeb081d6dcac3fe394e44577fdfdfa41428ecfb2068fd7de5288204df78081ff1e5bc41f5594c43194e8b20797ae6361cf7ffa028faf7301b085dd9
+  data.tar.gz: d06b2e6d23e5eaac2b5c42cc9b433ef6e5ea25961e28dbe760d51b3fee5aadb2d5f68e76e1a7b1b066ecbcdc129b079c00e7e8427d7e31f4fe65950239eae9b5

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,28 @@
+name: windows
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        ruby: [ '2.7.x', '2.6.x', '2.5.x' ]
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Set up Ruby
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - 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/.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/.travis.yml

@@ -6,8 +6,11 @@ notifications:
       - drbrain@segment7.net
       - shugo@ruby-lang.org
 rvm:
-  - 2.2.7
-  - 2.3.4
-  - 2.4.1
+  - 2.2.10
+  - 2.3.8
+  - 2.4.5
+  - 2.5.3
+  - 2.6.1
   - ruby-head
+before_install: gem install bundler -v '<2'
 script: rake compile

data/History.md

@@ -1,3 +1,43 @@
+### 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:
+
+* Add curses.so for Ruby 2.5/2.6 on x86-mingw32.
+
 ### 1.2.6 / 2019-01-09
 
 New features:

data/README.md

@@ -18,7 +18,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 +28,9 @@ Or
 
     $ apt install libncursesw5-dev
 
+On mingw, `gem install curses` will install pre-built PDCurses, so you
+don't need to install extra libraries.
+
 ## Documentation
 
 See [https://www.rubydoc.info/gems/curses](https://www.rubydoc.info/gems/curses).

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.6"
+  s.version = "1.4.0"
   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
@@ -84,6 +96,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 +215,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 +223,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 +242,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;
 }
 
@@ -843,7 +858,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
@@ -1425,6 +1440,7 @@ struct mousedata {
     MEVENT *mevent;
 };
 
+NORETURN(static void no_mevent(void));
 static void
 no_mevent(void)
 {
@@ -1432,8 +1448,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 +1466,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;
 }
 
@@ -2400,7 +2414,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
@@ -3028,8 +3042,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 +3061,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;
 }
 
@@ -3139,6 +3151,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 +3240,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 +3270,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 +3292,7 @@ menu_s_allocate(VALUE class)
  * Document-method: Curses::Menu.new
  *
  * call-seq:
- *   new(name, description)
+ *   new(items)
  *
  * Construct a new Curses::Menu.
  */
@@ -3215,6 +3302,7 @@ 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();
@@ -3222,19 +3310,25 @@ menu_initialize(VALUE obj, VALUE items)
     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,200 +3520,1075 @@ 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 wget_wch_arg arg;
+    struct menudata *menup;
 
-    GetWINDOW(obj, winp);
-    arg.win = winp->window;
-    rb_thread_call_without_gvl(wget_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);
+    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();
+    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();
+    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);
+    arg.win = winp->window;
+    rb_thread_call_without_gvl(wget_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
@@ -3980,6 +4949,10 @@ Init_curses(void)
     rb_define_method(cItem, "==", item_eq, 1);
     rb_define_method(cItem, "name", item_name_m, 0);
     rb_define_method(cItem, "description", item_description_m, 0);
+    rb_define_method(cItem, "set_opts", item_set_opts, 1);
+    rb_define_method(cItem, "opts_on", item_opts_on_m, 1);
+    rb_define_method(cItem, "opts_off", item_opts_off_m, 1);
+    rb_define_method(cItem, "opts", item_opts_m, 0);
 
     cMenu = rb_define_class_under(mCurses, "Menu", rb_cData);
     rb_define_alloc_func(cMenu, menu_s_allocate);
@@ -3992,6 +4965,54 @@ Init_curses(void)
     rb_define_method(cMenu, "items=", menu_set_items, 1);
     rb_define_method(cMenu, "current_item", menu_get_current_item, 0);
     rb_define_method(cMenu, "current_item=", menu_set_current_item, 1);
+    rb_define_method(cMenu, "set_win", menu_set_win, 1);
+    rb_define_method(cMenu, "set_sub", menu_set_sub, 1);
+    rb_define_method(cMenu, "scale", menu_scale, 0);
+    rb_define_method(cMenu, "set_format", menu_set_format, 2);
+    rb_define_method(cMenu, "format", menu_format_m, 0);
+    rb_define_method(cMenu, "set_opts", menu_set_opts, 1);
+    rb_define_method(cMenu, "opts_on", menu_opts_on_m, 1);
+    rb_define_method(cMenu, "opts_off", menu_opts_off_m, 1);
+    rb_define_method(cMenu, "opts", menu_opts_m, 0);
+#endif
+
+#ifdef HAVE_FORM
+    cField = rb_define_class_under(mCurses, "Field", rb_cData);
+    rb_define_alloc_func(cField, field_s_allocate);
+    rb_define_method(cField, "initialize", field_initialize, 6);
+    rb_define_method(cField, "set_buffer", field_set_buffer, 2);
+    rb_define_method(cField, "buffer", field_buffer_m, 1);
+    rb_define_method(cField, "set_fore", field_set_fore, 1);
+    rb_define_method(cField, "fore=", field_set_fore, 1);
+    rb_define_method(cField, "fore", field_get_fore, 0);
+    rb_define_method(cField, "set_back", field_set_back, 1);
+    rb_define_method(cField, "back=", field_set_back, 1);
+    rb_define_method(cField, "back", field_get_back, 0);
+    rb_define_method(cField, "opts_on", field_opts_on_m, 1);
+    rb_define_method(cField, "opts_off", field_opts_off_m, 1);
+    rb_define_method(cField, "opts", field_opts_m, 0);
+    rb_define_method(cField, "height", field_height, 0);
+    rb_define_method(cField, "width", field_width, 0);
+    rb_define_method(cField, "toprow", field_toprow, 0);
+    rb_define_method(cField, "leftcol", field_leftcol, 0);
+    rb_define_method(cField, "offscreen", field_offscreen, 0);
+    rb_define_method(cField, "nbuffers", field_nbuffers, 0);
+    rb_define_method(cField, "dynamic_height", field_dynamic_height, 0);
+    rb_define_method(cField, "dynamic_width", field_dynamic_width, 0);
+    rb_define_method(cField, "max", field_max, 0);
+    rb_define_method(cField, "set_max", field_set_max, 1);
+    rb_define_method(cField, "max=", field_set_max, 1);
+    rb_define_method(cField, "set_type", field_set_type, -1);
+
+    cForm = rb_define_class_under(mCurses, "Form", rb_cData);
+    rb_define_alloc_func(cForm, form_s_allocate);
+    rb_define_method(cForm, "initialize", form_initialize, 1);
+    rb_define_method(cForm, "post", form_post, 0);
+    rb_define_method(cForm, "unpost", form_unpost, 0);
+    rb_define_method(cForm, "driver", form_driver_m, 1);
+    rb_define_method(cForm, "set_win", form_set_win, 1);
+    rb_define_method(cForm, "set_sub", form_set_sub, 1);
+    rb_define_method(cForm, "scale", form_scale, 0);
 #endif
 
 #define rb_curses_define_error(c) do { \
@@ -5482,6 +6503,17 @@ Init_curses(void)
 #endif
 
 #ifdef HAVE_MENU
+    rb_curses_define_const(O_ONEVALUE);
+    rb_curses_define_const(O_SHOWDESC);
+    rb_curses_define_const(O_ROWMAJOR);
+    rb_curses_define_const(O_IGNORECASE);
+    rb_curses_define_const(O_SHOWMATCH);
+    rb_curses_define_const(O_NONCYCLIC);
+#ifdef O_MOUSE_MENU
+    rb_curses_define_const(O_MOUSE_MENU);
+#endif
+    rb_curses_define_const(O_SELECTABLE);
+
     rb_curses_define_const(REQ_LEFT_ITEM);
     rb_curses_define_const(REQ_RIGHT_ITEM);
     rb_curses_define_const(REQ_UP_ITEM);
@@ -5500,5 +6532,93 @@ Init_curses(void)
     rb_curses_define_const(REQ_NEXT_MATCH);
     rb_curses_define_const(REQ_PREV_MATCH);
 #endif
+
+#ifdef HAVE_FORM
+    rb_curses_define_const(O_VISIBLE);
+    rb_curses_define_const(O_ACTIVE);
+    rb_curses_define_const(O_PUBLIC);
+    rb_curses_define_const(O_EDIT);
+    rb_curses_define_const(O_WRAP);
+    rb_curses_define_const(O_BLANK);
+    rb_curses_define_const(O_AUTOSKIP);
+    rb_curses_define_const(O_NULLOK);
+    rb_curses_define_const(O_PASSOK);
+    rb_curses_define_const(O_STATIC);
+#ifdef O_DYNAMIC_JUSTIFY
+    rb_curses_define_const(O_DYNAMIC_JUSTIFY);
+#endif
+#ifdef O_NO_LEFT_STRIP
+    rb_curses_define_const(O_NO_LEFT_STRIP);
+#endif
+
+    rb_define_const(mCurses, "TYPE_ALPHA", INT2NUM(TYPE_CODE_ALPHA));
+    rb_define_const(mCurses, "TYPE_ALNUM", INT2NUM(TYPE_CODE_ALNUM));
+    rb_define_const(mCurses, "TYPE_ENUM", INT2NUM(TYPE_CODE_ENUM));
+    rb_define_const(mCurses, "TYPE_INTEGER", INT2NUM(TYPE_CODE_INTEGER));
+    rb_define_const(mCurses, "TYPE_NUMERIC", INT2NUM(TYPE_CODE_NUMERIC));
+    rb_define_const(mCurses, "TYPE_REGEXP", INT2NUM(TYPE_CODE_REGEXP));
+
+    rb_curses_define_const(REQ_NEXT_PAGE);
+    rb_curses_define_const(REQ_PREV_PAGE);
+    rb_curses_define_const(REQ_FIRST_PAGE);
+    rb_curses_define_const(REQ_LAST_PAGE);
+
+    rb_curses_define_const(REQ_NEXT_FIELD);
+    rb_curses_define_const(REQ_PREV_FIELD);
+    rb_curses_define_const(REQ_FIRST_FIELD);
+    rb_curses_define_const(REQ_LAST_FIELD);
+    rb_curses_define_const(REQ_SNEXT_FIELD);
+    rb_curses_define_const(REQ_SPREV_FIELD);
+    rb_curses_define_const(REQ_SFIRST_FIELD);
+    rb_curses_define_const(REQ_SLAST_FIELD);
+    rb_curses_define_const(REQ_LEFT_FIELD);
+    rb_curses_define_const(REQ_RIGHT_FIELD);
+    rb_curses_define_const(REQ_UP_FIELD);
+    rb_curses_define_const(REQ_DOWN_FIELD);
+
+    rb_curses_define_const(REQ_NEXT_CHAR);
+    rb_curses_define_const(REQ_PREV_CHAR);
+    rb_curses_define_const(REQ_NEXT_LINE);
+    rb_curses_define_const(REQ_PREV_LINE);
+    rb_curses_define_const(REQ_NEXT_WORD);
+    rb_curses_define_const(REQ_PREV_WORD);
+    rb_curses_define_const(REQ_BEG_FIELD);
+    rb_curses_define_const(REQ_END_FIELD);
+    rb_curses_define_const(REQ_BEG_LINE);
+    rb_curses_define_const(REQ_END_LINE);
+    rb_curses_define_const(REQ_LEFT_CHAR);
+    rb_curses_define_const(REQ_RIGHT_CHAR);
+    rb_curses_define_const(REQ_UP_CHAR);
+    rb_curses_define_const(REQ_DOWN_CHAR);
+
+    rb_curses_define_const(REQ_NEW_LINE);
+    rb_curses_define_const(REQ_INS_CHAR);
+    rb_curses_define_const(REQ_INS_LINE);
+    rb_curses_define_const(REQ_DEL_CHAR);
+    rb_curses_define_const(REQ_DEL_PREV);
+    rb_curses_define_const(REQ_DEL_LINE);
+    rb_curses_define_const(REQ_DEL_WORD);
+    rb_curses_define_const(REQ_CLR_EOL);
+    rb_curses_define_const(REQ_CLR_EOF);
+    rb_curses_define_const(REQ_CLR_FIELD);
+    rb_curses_define_const(REQ_OVL_MODE);
+    rb_curses_define_const(REQ_INS_MODE);
+    rb_curses_define_const(REQ_SCR_FLINE);
+    rb_curses_define_const(REQ_SCR_BLINE);
+    rb_curses_define_const(REQ_SCR_FPAGE);
+    rb_curses_define_const(REQ_SCR_BPAGE);
+    rb_curses_define_const(REQ_SCR_FHPAGE);
+    rb_curses_define_const(REQ_SCR_BHPAGE);
+    rb_curses_define_const(REQ_SCR_FCHAR);
+    rb_curses_define_const(REQ_SCR_BCHAR);
+    rb_curses_define_const(REQ_SCR_HFLINE);
+    rb_curses_define_const(REQ_SCR_HBLINE);
+    rb_curses_define_const(REQ_SCR_HFHALF);
+    rb_curses_define_const(REQ_SCR_HBHALF);
+
+    rb_curses_define_const(REQ_VALIDATION);
+    rb_curses_define_const(REQ_NEXT_CHOICE);
+    rb_curses_define_const(REQ_PREV_CHOICE);
+#endif
 #undef rb_curses_define_const
 }