curses 1.2.5 → 1.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cde762b5d566d153efcb872a949cdd742ee678351642f99ff4142a302792f54
-  data.tar.gz: 3cacf0b68211f369d99b23592bb3e1035ab8d56f31c64ffb713ae573b30068c9
+  metadata.gz: 0c8cd5188348efc3da97bd7fd52aaf748636da0278c9d08d9b3a8aef9bd124f9
+  data.tar.gz: 98afd30e1daa2bee1a50f2f3f037ffbf503acd2befa84d89ee3fe3f6f0e62e83
 SHA512:
-  metadata.gz: c113a50e510eb659797ce295982c44e8c8d5355eb7ef9506b9d20b7a98ca92053960da5edc333d7b9fb0e9cfa659b4339abb25859d2bda4126227dce8e2ad17b
-  data.tar.gz: 8fde98598b7c32632bfdab0c0f92564d32088e311754c0c39ec905012ad874718e4a8b69f0953c9ff280de4ef399cb7c874908396a307a77118a72efdea5cb4d
+  metadata.gz: 5093a94321e82de364022d2e997263659a4ecbd0ce7528fcad780e09bbb08db7c172ee13805b6775d4dd9754e7581eafba50dd363f94aac7e458c9da9ee5af8b
+  data.tar.gz: 8e4e86a0884300c5dcd0c9da5974597eba4adcc0d4bb1ab31e648fdea2689cc50cf2d556e401a30b40a1ca9d9d3e6eedd664c1efaa44192d06dcd893e43d76f5

data/History.md

@@ -1,3 +1,15 @@
+### 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:

data/README.md

@@ -30,7 +30,7 @@ Or
 
 ## Documentation
 
-See [http://www.rubydoc.info/gems/curses](http://www.rubydoc.info/gems/curses).
+See [https://www.rubydoc.info/gems/curses](https://www.rubydoc.info/gems/curses).
 
 ## Developers
 

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.5"
+  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

@@ -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;
 };
@@ -2899,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
@@ -3444,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
@@ -4910,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

@@ -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.5
+  version: 1.2.6
 platform: ruby
 authors:
 - Shugo Maeda
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-16 00:00:00.000000000 Z
+date: 2019-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -78,6 +78,7 @@ files:
 - ext/curses/extconf.rb
 - lib/curses.rb
 - sample/hello.rb
+- sample/menu.rb
 - sample/mouse.rb
 - sample/rain.rb
 - sample/view.rb
@@ -102,8 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: A Ruby binding for curses, ncurses, and PDCurses. curses is an extension