curses 1.2.7-x86-mingw32 → 1.3.0-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d134b66b211ee8d5771404219f79804f505347bc94b039a5cca279366567951
-  data.tar.gz: 8a9a11d4b954ea57f2defb061daa357eca604b5b1e657440a37fac6ac6a8031a
+  metadata.gz: 5b4b1a96db6c9366ea949b9c20760518cff4cf7311f087f3857f70ee55fad7a3
+  data.tar.gz: 0c6ab70e2aaa051bf857611cee459040b0200cd50bc8d465f507d5873760d2ec
 SHA512:
-  metadata.gz: 820553fb5ec92c9fffda3d905574d39dcc61977ddad217468e56ba1adeed8cd429d436736e3217acc40eecbc1d5b0f52d701d4db5ecbc2d269aae858b6af08b2
-  data.tar.gz: b7f284a386bdcd084c5c286bd6776dcb8ed8ac83f4b296bd2d8de20e96c5c8c9b902ec0a940c2b47b94348228fd0c556b251204cf562082790a5414dc38ad891
+  metadata.gz: b1e28f0519971fd78884a969dd1dd6ee8fb052076114c0c8a9b9b54c2ce1179fc1f778fb2afbbde6136a9c2ac35635941d847f1541bb54f450be136f81116ae2
+  data.tar.gz: 6b4fa2f5632dc64805fb97ffa1f3d4c3dfb3b723c64e3c7454394095e6878ea2959ff5200ca37f9ed9f0676f83d3084670efc4d5a11316c8b80b9f8d1fd1ed81

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,17 @@
+### 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/Rakefile

@@ -23,15 +23,15 @@ namespace :build 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
+    chdir "vendor/PDCurses/wincon" do
       if $mswin
-        sh "nmake -f vcwin32.mak clean all WIDE=Y DLL=Y"
+        sh "nmake -f Makefile.vc 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"
+        sh "make -f Makefile.mng 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"
+        sh "make -f Makefile.mng clean all _w64=1 WIDE=Y DLL=N"
         cp "pdcurses.a", "../../x64-mingw32/PDCurses/libpdcurses.a"
       end
     end
@@ -41,9 +41,12 @@ 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"
+    chdir "vendor/PDCurses/wincon" do
+      if $mswin
+        sh "nmake -f Makefile.vc clean"
+      else
+        sh "make -f Makefile.mng clean _linux_w64=1"
+      end
     end
   end
 end

data/curses.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new { |s|
   s.name = "curses"
-  s.version = "1.2.7"
+  s.version = "1.3.0"
   s.author = ["Shugo Maeda", 'Eric Hodel']
   s.email = ["shugo@ruby-lang.org", 'drbrain@segment7.net']
   s.homepage = "https://github.com/ruby/curses"

data/ext/curses/curses.c

@@ -61,6 +61,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 +94,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;
@@ -227,7 +241,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 += sizeof(*winp->window);
     return size;
 }
 
@@ -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 += sizeof(*mdata->mevent);
     return size;
 }
 
@@ -3049,7 +3063,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 += sizeof(*itemp->item);
     return size;
 }
 
@@ -3139,6 +3153,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;
@@ -3183,7 +3274,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 += sizeof(*menup->menu);
     return size;
 }
 
@@ -3205,7 +3296,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 +3306,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 +3314,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 +3524,1077 @@ 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;
+};
+
+static void
+no_field(void)
+{
+    rb_raise(rb_eRuntimeError, "already deleted field");
+}
+
+#define GetFIELD(obj, fieldp) do {\
+    if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4)\
+	rb_raise(rb_eSecurityError, "Insecure: operation on untainted field");\
+    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 += sizeof(*fieldp->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;
+};
+
+static void
+no_form(void)
+{
+    rb_raise(rb_eRuntimeError, "already deleted form");
+}
+
+#define GetFORM(obj, formp) do {\
+    if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4)\
+	rb_raise(rb_eSecurityError, "Insecure: operation on untainted form");\
+    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 += sizeof(*formp->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 +4955,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 +4971,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 +6509,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 +6538,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
 }