curses 1.2.4-x86-mingw32 → 1.2.6-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d4d65fe6f42a0b4fd66ec443e77d93037a6e6697
-  data.tar.gz: 66943ccf5dc0139bf3ad5bde95a75b5c0dc24259
+SHA256:
+  metadata.gz: ee6ead4e00fdd1086b5e312a676644dba25d6c58e0c144ff2329b7040f616698
+  data.tar.gz: 54b230b90151cacbcf271b07605c96385d318e870f42c2eb1fb2764d4aa18d5a
 SHA512:
-  metadata.gz: 1f40fa29797f6088f588aff9ab58a72e322c8c555e543f99045f9bf3444ef9dfdad6e0c201eacf25206f6405c4ec7e5dfeeca8ef7d8c8ab075dabe8b35fab4b2
-  data.tar.gz: c725a0458bef0e7b9c3c2d7da79f0941ab47f5c7714e6738687a83ed8578f25270a583c1a863bc68daf33a3bcf222dc5e67b4007c1d554a88b1c07b365931cf0
+  metadata.gz: 31fcbb017f7c9e8d8cd22b9d22b969285ebd05649945ad24dda478cb21e46aa83260030067497f1d804571638f3092bbb7b6d0b9394fc994b14fb39d6cbfca56
+  data.tar.gz: 59e73a5f7df978ff8de71d21d5ca8cffda4f8adf2e9ff862a3c23323ff9978a846ec7f4f2e042446a6ec9db95ac58874f699f126d3a9ff34af19052400052dfc

data/History.md

@@ -1,5 +1,32 @@
+### 1.2.6 / 2019-01-09
+
+New features:
+
+* Add Curses::Menu and Curses::Item.
+
+Bug fixes:
+
+* Link PDCurses statically to avoid LoadError on mingw.
+* Use https for documentation link.  Pull request #43 by stomar.
+* Fix typo in example code.  Pull request #44 by stomar.
+
+### 1.2.5 / 2018-10-16
+
+New features:
+
+* Add mvderwin and derwin methods to Window.  Pull request #37 by meschbach.
+* Add documentation link.  Pull request #39 by atshakil.
+
+Bug fixes:
+
+* Favor ncursesw over curses.  Pull request #40 by DivineDominion.
+
 ### 1.2.4 / 2017-09-13
 
+New features:
+
+* Update PDCurses.
+
 Bug fixes:
 
 * Fix the path of pdcurses.dll for i386-mingw.  (Issue #36)

data/README.md

@@ -28,6 +28,10 @@ Or
 
     $ apt install libncursesw5-dev
 
+## Documentation
+
+See [https://www.rubydoc.info/gems/curses](https://www.rubydoc.info/gems/curses).
+
 ## Developers
 
 After checking out the repo, run `bundle install` to install dependencies.

data/Rakefile

@@ -28,11 +28,11 @@ namespace :build do
         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=Y"
-        cp "pdcurses.dll", "../../x86-mingw32/PDCurses"
+        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=Y"
-        cp "pdcurses.dll", "../../x64-mingw32/PDCurses"
+        sh "make -f mingwin32.mak clean all _w64=1 WIDE=Y DLL=N"
+        cp "pdcurses.a", "../../x64-mingw32/PDCurses/libpdcurses.a"
       end
     end
   end
@@ -71,14 +71,16 @@ Rake::ExtensionTask.new(spec.name, spec) do |ext|
     'x64-mingw32' => '--with-curses-lib=' +
       File.expand_path("vendor/x64-mingw32/PDCurses", __dir__)
   }
-  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
+  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,6 +1,6 @@
 Gem::Specification.new { |s|
   s.name = "curses"
-  s.version = "1.2.4"
+  s.version = "1.2.6"
   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

@@ -20,12 +20,12 @@
 #include "ruby/io.h"
 #include "ruby/thread.h"
 
-#if defined(HAVE_NCURSES_H)
-# include <ncurses.h>
-#elif defined(HAVE_NCURSESW_CURSES_H)
+#if defined(HAVE_NCURSESW_CURSES_H)
 # include <ncursesw/curses.h>
 #elif defined(HAVE_NCURSES_CURSES_H)
 # include <ncurses/curses.h>
+#elif defined(HAVE_NCURSES_H)
+# include <ncurses.h>
 #elif defined(HAVE_CURSES_COLR_CURSES_H)
 # ifdef HAVE_STDARG_PROTOTYPES
 #  include <stdarg.h>
@@ -51,6 +51,16 @@
 # endif
 #endif
 
+#if defined(HAVE_NCURSESW_MENU_H)
+# include <ncursesw/menu.h>
+#elif defined(HAVE_NCURSES_MENU_H)
+# include <ncurses/menu.h>
+#elif defined(HAVE_CURSES_MENU_H)
+# include <curses/menu.h>
+#elif defined(HAVE_MENU_H)
+# include <menu.h>
+#endif
+
 #ifdef HAVE_INIT_COLOR
 # define USE_COLOR 1
 #endif
@@ -70,12 +80,117 @@ static VALUE cPad;
 #ifdef USE_MOUSE
 static VALUE cMouseEvent;
 #endif
+#ifdef HAVE_MENU
+static VALUE cItem;
+static VALUE cMenu;
+#endif
+static VALUE eError;
+static VALUE eSystemError;
+static VALUE eBadArgumentError;
+static VALUE ePostedError;
+static VALUE eConnectedError;
+static VALUE eBadStateError;
+static VALUE eNoRoomError;
+static VALUE eNotPostedError;
+static VALUE eUnknownCommandError;
+static VALUE eNoMatchError;
+static VALUE eNotSelectableError;
+static VALUE eNotConnectedError;
+static VALUE eRequestDeniedError;
+static VALUE eInvalidFieldError;
+static VALUE eCurrentError;
 
 static VALUE rb_stdscr;
 
 static rb_encoding *keyboard_encoding;
 static rb_encoding *terminal_encoding;
 
+#ifndef E_OK
+#define E_OK 0
+#endif
+
+static void
+check_curses_error(int error)
+{
+    switch (error) {
+    case E_OK:
+	break;
+#ifdef E_SYSTEM_ERROR
+    case E_SYSTEM_ERROR:
+	rb_raise(eSystemError, "A system error occurred");
+	break;
+#endif
+#ifdef E_BAD_ARGUMENT
+    case E_BAD_ARGUMENT:
+	rb_raise(eBadArgumentError, "Incorrect or out-of-range argument");
+	break;
+#endif
+#ifdef E_POSTED
+    case E_POSTED:
+	rb_raise(ePostedError, "The menu has already been posted");
+	break;
+#endif
+#ifdef E_CONNECTED
+    case E_CONNECTED:
+	rb_raise(eConnectedError, "The field is already connected to a form");
+	break;
+#endif
+#ifdef E_BAD_STATE
+    case E_BAD_STATE:
+	rb_raise(eBadStateError, "Called from an initialization or termination function");
+	break;
+#endif
+#ifdef E_NO_ROOM
+    case E_NO_ROOM:
+	rb_raise(eNoRoomError, "Form is too large for its window");
+	break;
+#endif
+#ifdef E_NOT_POSTED
+    case E_NOT_POSTED:
+	rb_raise(eNotPostedError, "The menu has not been posted");
+	break;
+#endif
+#ifdef E_UNKNOWN_COMMAND
+    case E_UNKNOWN_COMMAND:
+	rb_raise(eUnknownCommandError, "Unknown command");
+	break;
+#endif
+#ifdef E_NO_MATCH
+    case E_NO_MATCH:
+	rb_raise(eNoMatchError, "Character failed to match");
+	break;
+#endif
+#ifdef E_NOT_SELECTABLE
+    case E_NOT_SELECTABLE:
+	rb_raise(eNotSelectableError, "The designated item cannot be selected");
+	break;
+#endif
+#ifdef E_NOT_CONNECTED
+    case E_NOT_CONNECTED:
+	rb_raise(eNotConnectedError, "No fields or items are connected");
+	break;
+#endif
+#ifdef E_REQUEST_DENIED
+    case E_REQUEST_DENIED:
+	rb_raise(eRequestDeniedError, "The request could not be processed");
+	break;
+#endif
+#ifdef E_INVALID_FIELD
+    case E_INVALID_FIELD:
+	rb_raise(eInvalidFieldError, "Contents of a field is not valid");
+	break;
+#endif
+#ifdef E_CURRENT
+    case E_CURRENT:
+	rb_raise(eCurrentError, "The field is the current field");
+	break;
+#endif
+    default:
+	rb_raise(eError, "Unknown error");
+	break;
+    }
+}
+
 struct windata {
     WINDOW *window;
 };
@@ -1589,6 +1704,38 @@ window_subwin(VALUE obj, VALUE height, VALUE width, VALUE top, VALUE left)
     return win;
 }
 
+#ifdef HAVE_DERWIN
+/*
+ * Document-method: Curses::Window.derwin
+ * call-seq: derwin(height, width, relative_top, relative_left)
+ *
+ * Construct a new subwindow with constraints of
+ * +height+ lines, +width+ columns, begin at +top+ line, and begin +left+ most column
+ * relative to the parent window.
+ *
+ */
+static VALUE
+window_derwin(VALUE obj, VALUE height, VALUE width, VALUE top, VALUE left)
+{
+    struct windata *winp;
+    WINDOW *window;
+    VALUE win;
+    int h, w, t, l;
+
+    h = NUM2INT(height);
+    w = NUM2INT(width);
+    t = NUM2INT(top);
+    l = NUM2INT(left);
+    GetWINDOW(obj, winp);
+    window = derwin(winp->window, h, w, t, l);
+    win = prep_window(rb_obj_class(obj), window);
+
+    return win;
+}
+#else
+#define window_derwin rb_f_notimplement
+#endif
+
 /*
  * Document-method: Curses::Window.close
  *
@@ -1854,6 +2001,28 @@ window_move(VALUE obj, VALUE y, VALUE x)
     return Qnil;
 }
 
+#ifdef HAVE_MVDERWIN
+/*
+ * Document-method: Curses::Window.move_relative
+ * call-seq: move_relative(x,y)
+ *
+ * Moves the derived or subwindow inside its parent window. The screen-relative
+ * parameters of the window are not changed.
+ */
+static VALUE
+window_move_relative(VALUE obj, VALUE y, VALUE x)
+{
+    struct windata *winp;
+
+    GetWINDOW(obj, winp);
+    mvderwin(winp->window, NUM2INT(y), NUM2INT(x));
+
+    return Qnil;
+}
+#else
+#define window_move_relative rb_f_notimplement
+#endif
+
 /*
  * Document-method: Curses::Window.setpos
  * call-seq: setpos(y, x)
@@ -2845,6 +3014,420 @@ pad_noutrefresh(VALUE obj, VALUE pminrow, VALUE pmincol, VALUE sminrow,
 }
 #endif /* HAVE_NEWPAD */
 
+#ifdef HAVE_MENU
+/*--------------------------- class Item ----------------------------*/
+
+struct itemdata {
+    ITEM *item;
+};
+
+static void
+no_item(void)
+{
+    rb_raise(rb_eRuntimeError, "already deleted item");
+}
+
+#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)
+
+static void
+item_free(void *p)
+{
+    struct itemdata *itemp = p;
+    if (itemp->item) free_item(itemp->item);
+    itemp->item = 0;
+    xfree(itemp);
+}
+
+static size_t
+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);
+    return size;
+}
+
+static const rb_data_type_t itemdata_type = {
+    "itemdata",
+    {0, item_free, item_memsize,}
+};
+
+/* returns a Curses::Item object */
+static VALUE
+item_s_allocate(VALUE class)
+{
+    struct itemdata *itemp;
+
+    return TypedData_Make_Struct(class, struct itemdata, &itemdata_type, itemp);
+}
+
+/*
+ * Document-method: Curses::Item.new
+ *
+ * call-seq:
+ *   new(name, description)
+ *
+ * Construct a new Curses::Item.
+ */
+static VALUE
+item_initialize(VALUE obj, VALUE name, VALUE description)
+{
+    struct itemdata *itemp;
+
+    curses_init_screen();
+    TypedData_Get_Struct(obj, struct itemdata, &itemdata_type, itemp);
+    if (itemp->item) {
+	rb_raise(rb_eRuntimeError, "already initialized item");
+    }
+    name = rb_str_export_to_enc(name, terminal_encoding);
+    description = rb_str_export_to_enc(description, terminal_encoding);
+    itemp->item = new_item(StringValueCStr(name),
+			   StringValueCStr(description));
+    if (itemp->item == NULL) {
+	check_curses_error(errno);
+    }
+
+    return obj;
+}
+
+static VALUE
+item_new(ITEM *item)
+{
+    VALUE obj = item_s_allocate(cItem);
+    struct itemdata *itemp;
+
+    TypedData_Get_Struct(obj, struct itemdata, &itemdata_type, itemp);
+    itemp->item = item;
+    return obj;
+}
+
+static VALUE
+item_eq(VALUE obj, VALUE other)
+{
+    struct itemdata *item1, *item2;
+
+    GetITEM(obj, item1);
+    GetITEM(other, item2);
+    return item1->item == item2->item ? Qtrue : Qfalse;
+}
+
+static VALUE
+item_name_m(VALUE obj)
+{
+    struct itemdata *itemp;
+    const char *name;
+
+    GetITEM(obj, itemp);
+    name = item_name(itemp->item);
+    return rb_external_str_new_with_enc(name, strlen(name), terminal_encoding);
+}
+
+static VALUE
+item_description_m(VALUE obj)
+{
+    struct itemdata *itemp;
+    const char *desc;
+
+    GetITEM(obj, itemp);
+    desc = item_description(itemp->item);
+    return rb_external_str_new_with_enc(desc, strlen(desc), terminal_encoding);
+}
+
+struct menudata {
+    MENU *menu;
+    VALUE items;
+};
+
+static void
+no_menu(void)
+{
+    rb_raise(rb_eRuntimeError, "already deleted menu");
+}
+
+#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)
+
+static void
+menu_gc_mark(void *p)
+{
+    struct menudata *menup = p;
+
+    rb_gc_mark(menup->items);
+}    
+
+static void
+menu_free(void *p)
+{
+    struct menudata *menup = p;
+    ITEM **items = menu_items(menup->menu);
+    if (menup->menu) free_menu(menup->menu);
+    xfree(items);
+    menup->menu = 0;
+    menup->items = Qnil;
+    xfree(menup);
+}
+
+static size_t
+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);
+    return size;
+}
+
+static const rb_data_type_t menudata_type = {
+    "menudata",
+    {menu_gc_mark, menu_free, menu_memsize,}
+};
+
+/* returns a Curses::Menu object */
+static VALUE
+menu_s_allocate(VALUE class)
+{
+    struct menudata *menup;
+
+    return TypedData_Make_Struct(class, struct menudata, &menudata_type, menup);
+}
+
+/*
+ * Document-method: Curses::Menu.new
+ *
+ * call-seq:
+ *   new(name, description)
+ *
+ * Construct a new Curses::Menu.
+ */
+static VALUE
+menu_initialize(VALUE obj, VALUE items)
+{
+    struct menudata *menup;
+    ITEM **menu_items;
+    int i;
+
+    Check_Type(items, T_ARRAY);
+    curses_init_screen();
+    TypedData_Get_Struct(obj, struct menudata, &menudata_type, menup);
+    if (menup->menu) {
+	rb_raise(rb_eRuntimeError, "already initialized menu");
+    }
+    menu_items = ALLOC_N(ITEM *, RARRAY_LEN(items) + 1);
+    for (i = 0; i < RARRAY_LEN(items); i++) {
+	struct itemdata *itemp;
+
+	GetITEM(RARRAY_AREF(items, i), itemp);
+	menu_items[i] = itemp->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;
+}
+
+/*
+ * Document-method: Curses::Menu#post
+ *
+ * call-seq:
+ *   post
+ *
+ * Post the menu.
+ */
+static VALUE
+menu_post(VALUE obj)
+{
+    struct menudata *menup;
+    int error;
+
+    GetMENU(obj, menup);
+    error = post_menu(menup->menu);
+    check_curses_error(error);
+
+    return obj;
+}
+
+/*
+ * Document-method: Curses::Menu#unpost
+ *
+ * call-seq:
+ *   unpost
+ *
+ * Unpost the menu.
+ */
+static VALUE
+menu_unpost(VALUE obj)
+{
+    struct menudata *menup;
+    int error;
+
+    GetMENU(obj, menup);
+    error = unpost_menu(menup->menu);
+    check_curses_error(error);
+
+    return obj;
+}
+
+/*
+ * Document-method: Curses::Menu#driver
+ *
+ * call-seq:
+ *   driver(command)
+ *
+ * Perform the command on the menu.
+ */
+static VALUE
+menu_driver_m(VALUE obj, VALUE command)
+{
+    struct menudata *menup;
+    int error;
+
+    GetMENU(obj, menup);
+    error = menu_driver(menup->menu, NUM2INT(command));
+    check_curses_error(error);
+
+    return obj;
+}
+
+/*
+ * Document-method: Curses::Menu#item_count
+ *
+ * call-seq:
+ *   item_count
+ *
+ * Returns the count of items in the menu.
+ */
+static VALUE
+menu_item_count(VALUE obj)
+{
+    struct menudata *menup;
+
+    GetMENU(obj, menup);
+    return INT2NUM(item_count(menup->menu));
+}
+
+/*
+ * Document-method: Curses::Menu#items
+ *
+ * call-seq:
+ *   items
+ *
+ * Returns the items of the menu.
+ */
+static VALUE
+menu_get_items(VALUE obj)
+{
+    struct menudata *menup;
+    ITEM **items;
+    int count, i;
+    VALUE ary;
+
+    GetMENU(obj, menup);
+    items = menu_items(menup->menu);
+    if (items == NULL) {
+	return Qnil;
+    }
+    count = item_count(menup->menu);
+    ary = rb_ary_new();
+    for (i = 0; i < count; i++) {
+	rb_ary_push(ary, item_new(items[i]));
+    }
+    return ary;
+}
+
+/*
+ * Document-method: Curses::Menu#items=
+ *
+ * call-seq:
+ *   items=(items)
+ *
+ * Returns the items of the menu.
+ */
+static VALUE
+menu_set_items(VALUE obj, VALUE items)
+{
+    struct menudata *menup;
+    ITEM **old_items, **new_items;
+    int i, error;
+
+    Check_Type(items, T_ARRAY);
+    GetMENU(obj, menup);
+    old_items = menu_items(menup->menu);
+    new_items = ALLOC_N(ITEM*, RARRAY_LEN(items) + 1);
+    for (i = 0; i < RARRAY_LEN(items); i++) {
+	struct itemdata *itemp;
+	GetITEM(RARRAY_AREF(items, i), itemp);
+	new_items[i] = itemp->item;
+    }
+    new_items[RARRAY_LEN(items)] = NULL;
+    error = set_menu_items(menup->menu, new_items);
+    if (error != E_OK) {
+	xfree(new_items);
+	check_curses_error(error);
+	return items;
+    }
+    xfree(old_items);
+    menup->items = rb_ary_dup(items);
+    return items;
+}
+
+/*
+ * Document-method: Curses::Menu#current_item
+ *
+ * call-seq:
+ *   current_item
+ *
+ * Returns the current item.
+ */
+static VALUE
+menu_get_current_item(VALUE obj)
+{
+    struct menudata *menup;
+    ITEM *item;
+
+    GetMENU(obj, menup);
+    item = current_item(menup->menu);
+    if (item == NULL) {
+	return Qnil;
+    }
+    return item_new(item);
+}
+
+/*
+ * Document-method: Curses::Menu#current_item=
+ *
+ * call-seq:
+ *   current_item=(item)
+ *
+ * Sets the current item.
+ */
+static VALUE
+menu_set_current_item(VALUE obj, VALUE item)
+{
+    struct menudata *menup;
+    struct itemdata *itemp;
+
+    GetMENU(obj, menup);
+    GetITEM(item, itemp);
+    set_current_item(menup->menu, itemp->item);
+    return item;
+}
+
+#endif /* HAVE_MENU */
+
 /*
  * Document-method: Curses.keyboard_encoding
  * call-seq: Curses.keyboard_encoding
@@ -3311,6 +3894,7 @@ Init_curses(void)
     rb_define_alloc_func(cWindow, window_s_allocate);
     rb_define_method(cWindow, "initialize", window_initialize, 4);
     rb_define_method(cWindow, "subwin", window_subwin, 4);
+    rb_define_method(cWindow, "derwin", window_derwin, 4);
     rb_define_method(cWindow, "close", window_close, 0);
     rb_define_method(cWindow, "clear", window_clear, 0);
     rb_define_method(cWindow, "erase", window_erase, 0);
@@ -3325,6 +3909,7 @@ Init_curses(void)
     rb_define_method(cWindow, "line_touched?", window_line_touched, 1);
     rb_define_method(cWindow, "box", window_box, -1);
     rb_define_method(cWindow, "move", window_move, 2);
+    rb_define_method(cWindow, "move_relative", window_move_relative, 2);
     rb_define_method(cWindow, "setpos", window_setpos, 2);
 #if defined(USE_COLOR) && defined(HAVE_WCOLOR_SET)
     rb_define_method(cWindow, "color_set", window_color_set, 1);
@@ -3388,6 +3973,47 @@ Init_curses(void)
     rb_undef_method(cPad, "subwin");
 #endif
 
+#ifdef HAVE_MENU
+    cItem = rb_define_class_under(mCurses, "Item", rb_cData);
+    rb_define_alloc_func(cItem, item_s_allocate);
+    rb_define_method(cItem, "initialize", item_initialize, 2);
+    rb_define_method(cItem, "==", item_eq, 1);
+    rb_define_method(cItem, "name", item_name_m, 0);
+    rb_define_method(cItem, "description", item_description_m, 0);
+
+    cMenu = rb_define_class_under(mCurses, "Menu", rb_cData);
+    rb_define_alloc_func(cMenu, menu_s_allocate);
+    rb_define_method(cMenu, "initialize", menu_initialize, 1);
+    rb_define_method(cMenu, "post", menu_post, 0);
+    rb_define_method(cMenu, "unpost", menu_unpost, 0);
+    rb_define_method(cMenu, "driver", menu_driver_m, 1);
+    rb_define_method(cMenu, "item_count", menu_item_count, 0);
+    rb_define_method(cMenu, "items", menu_get_items, 0);
+    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);
+#endif
+
+#define rb_curses_define_error(c) do { \
+	e##c = rb_define_class_under(mCurses, #c, eError); \
+} while (0)    
+
+    eError = rb_define_class_under(mCurses, "Error", rb_eStandardError);
+    rb_curses_define_error(SystemError);
+    rb_curses_define_error(BadArgumentError);
+    rb_curses_define_error(PostedError);
+    rb_curses_define_error(ConnectedError);
+    rb_curses_define_error(BadStateError);
+    rb_curses_define_error(NoRoomError);
+    rb_curses_define_error(NotPostedError);
+    rb_curses_define_error(UnknownCommandError);
+    rb_curses_define_error(NoMatchError);
+    rb_curses_define_error(NotSelectableError);
+    rb_curses_define_error(NotConnectedError);
+    rb_curses_define_error(RequestDeniedError);
+    rb_curses_define_error(InvalidFieldError);
+    rb_curses_define_error(CurrentError);
+
 #define rb_curses_define_const(c) rb_define_const(mCurses,#c,CHTYPE2NUM(c))
 
 #ifdef USE_COLOR
@@ -4854,5 +5480,25 @@ Init_curses(void)
     rb_curses_define_const(PDC_KEY_MODIFIER_ALT);
     rb_curses_define_const(PDC_KEY_MODIFIER_NUMLOCK);
 #endif
+
+#ifdef HAVE_MENU
+    rb_curses_define_const(REQ_LEFT_ITEM);
+    rb_curses_define_const(REQ_RIGHT_ITEM);
+    rb_curses_define_const(REQ_UP_ITEM);
+    rb_curses_define_const(REQ_DOWN_ITEM);
+    rb_curses_define_const(REQ_SCR_ULINE);
+    rb_curses_define_const(REQ_SCR_DLINE);
+    rb_curses_define_const(REQ_SCR_DPAGE);
+    rb_curses_define_const(REQ_SCR_UPAGE);
+    rb_curses_define_const(REQ_FIRST_ITEM);
+    rb_curses_define_const(REQ_LAST_ITEM);
+    rb_curses_define_const(REQ_NEXT_ITEM);
+    rb_curses_define_const(REQ_PREV_ITEM);
+    rb_curses_define_const(REQ_TOGGLE_ITEM);
+    rb_curses_define_const(REQ_CLEAR_PATTERN);
+    rb_curses_define_const(REQ_BACK_PATTERN);
+    rb_curses_define_const(REQ_NEXT_MATCH);
+    rb_curses_define_const(REQ_PREV_MATCH);
+#endif
 #undef rb_curses_define_const
 }

data/ext/curses/extconf.rb

@@ -59,7 +59,7 @@ if header_library
               getbkgd getnstr init isendwin keyname keypad resizeterm
               scrl set setscrreg ungetch addnwstr
               wattroff wattron wattrset wbkgd wbkgdset wdeleteln wgetnstr
-              wresize wscrl wsetscrreg werase redrawwin waddnwstr
+              wresize wscrl wsetscrreg werase redrawwin waddnwstr mvderwin derwin
               touchwin untouchwin wtouchln is_linetouched is_wintouched
               def_prog_mode reset_prog_mode timeout wtimeout nodelay
               init_color wcolor_set use_default_colors assume_default_colors
@@ -141,6 +141,15 @@ if header_library
     $defs << '-DPDC_DLL_BUILD'
   end
 
+  if (have_header("ncursesw/menu.h") ||
+      have_header("ncurses/menu.h") ||
+      have_header("curses/menu.h") ||
+      have_header("menu.h")) &&
+      (have_library("menuw", "new_menu") ||
+       have_library("menu", "new_menu"))
+    $defs << '-DHAVE_MENU'
+  end
+
   if RUBY_VERSION >= '2.1'
     create_header
     create_makefile("curses")

data/lib/curses.rb

@@ -21,3 +21,76 @@ end
 if pdcurses_bundled
   Curses.keyboard_encoding = Encoding::UTF_8
 end
+
+if defined?(Curses::Menu)
+  class Curses::Menu
+    def left_item
+      driver(Curses::REQ_LEFT_ITEM)
+    end
+
+    def right_item
+      driver(Curses::REQ_RIGHT_ITEM)
+    end
+
+    def up_item
+      driver(Curses::REQ_UP_ITEM)
+    end
+
+    def down_item
+      driver(Curses::REQ_DOWN_ITEM)
+    end
+
+    def scroll_up_line
+      driver(Curses::REQ_SCR_ULINE)
+    end
+
+    def scroll_down_line
+      driver(Curses::REQ_SCR_DLINE)
+    end
+
+    def scroll_up_page
+      driver(Curses::REQ_SCR_UPAGE)
+    end
+
+    def scroll_down_page
+      driver(Curses::REQ_SCR_DPAGE)
+    end
+
+    def first_item
+      driver(Curses::REQ_FIRST_ITEM)
+    end
+
+    def last_item
+      driver(Curses::REQ_LAST_ITEM)
+    end
+
+    def next_item
+      driver(Curses::REQ_NEXT_ITEM)
+    end
+
+    def prev_item
+      driver(Curses::REQ_PREV_ITEM)
+    end
+
+    def toggle_item
+      driver(Curses::REQ_TOGGLE_ITEM)
+    end
+
+    def clear_pattern
+      driver(Curses::REQ_CLEAR_PATTERN)
+    end
+
+    def back_pattern
+      driver(Curses::REQ_BACK_PATTERN)
+    end
+
+    def next_match
+      driver(Curses::REQ_NEXT_MATCH)
+    end
+
+    def prev_match
+      driver(Curses::REQ_PREV_MATCH)
+    end
+  end
+end
+

data/sample/menu.rb

@@ -0,0 +1,32 @@
+require "curses"
+
+Curses.init_screen
+Curses.cbreak
+Curses.noecho
+Curses.stdscr.keypad = true
+at_exit do
+  Curses.cloes_screen
+end
+
+menu = Curses::Menu.new([
+  Curses::Item.new("Apple", "Red fruit"),
+  Curses::Item.new("Orange", "Orange fruit"),
+  Curses::Item.new("Banana", "Yellow fruit")
+])
+menu.post
+
+while ch = Curses.getch
+  begin
+    case ch
+    when Curses::KEY_UP, ?k
+      menu.up_item
+    when Curses::KEY_DOWN, ?j
+      menu.down_item
+    else
+      break
+    end
+  rescue Curses::RequestDeniedError
+  end
+end
+
+menu.unpost

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: curses
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.2.6
 platform: x86-mingw32
 authors:
 - Shugo Maeda
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-13 00:00:00.000000000 Z
+date: 2019-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,16 +75,15 @@ files:
 - ext/curses/curses.c
 - ext/curses/depend
 - ext/curses/extconf.rb
-- lib/2.2/curses.so
 - lib/2.3/curses.so
 - lib/2.4/curses.so
 - lib/curses.rb
 - sample/hello.rb
+- sample/menu.rb
 - sample/mouse.rb
 - sample/rain.rb
 - sample/view.rb
 - sample/view2.rb
-- vendor/x86-mingw32/PDCurses/pdcurses.dll
 homepage: https://github.com/ruby/curses
 licenses:
 - Ruby
@@ -98,18 +97,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: '2.3'
   - - "<"
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: 2.7.dev
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: A Ruby binding for curses, ncurses, and PDCurses. curses is an extension