elliottcable-ncurses 1.3.1

data/ext/ncurses/ncurses_wrap.h

@@ -0,0 +1,111 @@
+/*
+ * ncurses-ruby is a ruby module for accessing the FSF's ncurses library
+ * (C) 2002, 2003 Tobias Peters <t-peters@berlios.de>
+ * (C) 2004 Simon Kaczor <skaczor@cox.net>
+ * 
+ *  This module is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This module is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this module; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * $Id: ncurses_wrap.h,v 1.2 2004/07/31 08:35:13 t-peters Exp $
+ *
+ * This file was adapted from the original ncurses header file which
+ * has the following copyright statements:
+ */
+
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
+ *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
+ ****************************************************************************/
+
+/*
+  NOT IMPLEMENTED:
+  - terminfo, termcap-functions
+  - rippoffline
+  - v*printw functions (but normal printw functions are supported!)
+*/
+
+#if defined(HAVE_GETWIN) || defined(HAVE_PUTWIN)
+#  ifdef HAVE_UNISTD_H
+#    include <unistd.h>
+#  else
+int dup(int);
+int close(int);
+#  endif
+#endif
+
+#ifdef HAVE_NCURSESW_NCURSESW_H
+#  include <ncursesw/ncursesw.h>
+#elif HAVE_NCURSESW_CURSESW_H
+#  include <ncursesw/cursesw.h>
+#elif HAVE_NCURSESW_NCURSES_H
+#  include <ncursesw/ncurses.h>
+#elif HAVE_NCURSESW_CURSES_H
+#  include <ncursesw/curses.h>
+#elif HAVE_NCURSESW_H
+#  include <ncursesw.h>
+#elif HAVE_CURSESW_H
+#  include <cursesw.h>
+#elif HAVE_NCURSES_NCURSES_H
+#  include <ncurses/ncurses.h>
+#elif HAVE_NCURSES_CURSES_H
+#  include <ncurses/curses.h>
+#elif HAVE_NCURSES_H
+#  include <ncurses.h>
+#else
+#  include <curses.h>
+#endif
+
+#include <ruby.h>
+
+extern VALUE mNcurses;  /* module Ncurses */
+extern VALUE cWINDOW;   /* class Ncurses::WINDOW */
+extern VALUE cSCREEN;   /* class Ncurses::SCREEN */
+extern VALUE eNcurses;  /* Ncurses::Exception thrown by this extension */
+
+#define NCFUNC(name, nargs)                       \
+  rb_define_singleton_method(mNcurses,            \
+                             #name,               \
+                             &rbncurs_ ## name,   \
+                             nargs)
+
+WINDOW* get_window(VALUE rb_window);
+VALUE   wrap_window(WINDOW* window);

data/ext/ncurses/panel_wrap.c

@@ -0,0 +1,256 @@
+/*
+ * ncurses-ruby is a ruby module for accessing the FSF's ncurses library
+ * (C) 2002 Tobias Peters <t-peters@berlios.de>
+ * 
+ *  This module is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This module is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this module; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+/* $Id: panel_wrap.c,v 1.2 2004/07/31 08:35:13 t-peters Exp $ */
+
+#ifdef HAVE_PANEL_H
+
+#include "panel_wrap.h"
+#include "ncurses_wrap.h"
+
+VALUE mPanel;
+VALUE cPANEL;
+
+static VALUE wrap_panel(PANEL* panel)
+{
+    if (panel == 0) return Qnil;
+    {
+        VALUE panels_hash   = rb_iv_get(mPanel, "@panels_hash");
+        VALUE panel_adress  = INT2NUM((long)(panel));
+        VALUE rb_panel      = rb_hash_aref(panels_hash, panel_adress);
+        if (rb_panel == Qnil) {
+            rb_panel = Data_Wrap_Struct(cPANEL, 0, 0, panel);
+            rb_iv_set(rb_panel, "@destroyed", Qfalse);
+            rb_hash_aset(panels_hash, panel_adress, rb_panel);
+        }
+        return rb_panel;
+    }
+}
+static PANEL* get_panel(VALUE rb_panel)
+{
+    PANEL* panel;
+    if (rb_panel == Qnil) return 0;
+    if (rb_iv_get(rb_panel, "@destroyed") == Qtrue) {
+        rb_raise(rb_eRuntimeError, "Attempt to access a destroyed panel");
+        return 0;
+    }
+    Data_Get_Struct(rb_panel, PANEL, panel);
+    return panel;
+}
+static VALUE rbncurs_c_del_panel(VALUE rb_panel) {
+    VALUE panels_hash   = rb_iv_get(mPanel, "@panels_hash");
+    PANEL* panel       = get_panel(rb_panel);
+    VALUE panel_adress  = INT2NUM((long)(panel));
+    rb_funcall(panels_hash, rb_intern("delete"), 1, panel_adress);
+    rb_iv_set(rb_panel, "@destroyed", Qtrue);
+    return INT2NUM(del_panel(panel));
+}
+static VALUE rbncurs_m_del_panel(VALUE dummy, VALUE rb_panel)
+{ return rbncurs_c_del_panel(rb_panel); }
+
+static VALUE rbncurs_c_panel_window(VALUE rb_panel)
+{ return wrap_window(panel_window(get_panel(rb_panel))); }
+static VALUE rbncurs_m_panel_window(VALUE dummy, VALUE rb_panel)
+{ return rbncurs_c_panel_window(rb_panel); }
+
+static VALUE rbncurs_m_update_panels(VALUE dummy)
+{ update_panels(); return Qnil; }
+
+static VALUE rbncurs_c_hide_panel(VALUE rb_panel)
+{ return INT2NUM(hide_panel(get_panel(rb_panel))); }
+static VALUE rbncurs_m_hide_panel(VALUE dummy, VALUE rb_panel)
+{ return rbncurs_c_hide_panel(rb_panel); }
+
+static VALUE rbncurs_c_show_panel(VALUE rb_panel)
+{ return INT2NUM(show_panel(get_panel(rb_panel))); }
+static VALUE rbncurs_m_show_panel(VALUE dummy, VALUE rb_panel)
+{ return rbncurs_c_show_panel(rb_panel); }
+
+static VALUE rbncurs_c_top_panel(VALUE rb_panel)
+{ return INT2NUM(top_panel(get_panel(rb_panel))); }
+static VALUE rbncurs_m_top_panel(VALUE dummy, VALUE rb_panel)
+{ return rbncurs_c_top_panel(rb_panel); }
+
+static VALUE rbncurs_c_bottom_panel(VALUE rb_panel)
+{ return INT2NUM(bottom_panel(get_panel(rb_panel))); }
+static VALUE rbncurs_m_bottom_panel(VALUE dummy, VALUE rb_panel)
+{ return rbncurs_c_bottom_panel(rb_panel); }
+
+static VALUE rbncurs_c_new_panel(VALUE rb_window)
+{ return wrap_panel(new_panel(get_window(rb_window))); }
+static VALUE rbncurs_m_new_panel(VALUE dummy, VALUE rb_window)
+{ return rbncurs_c_new_panel(rb_window); }
+static VALUE rbncurs_c_panel_above(VALUE rb_panel)
+{ return wrap_panel(panel_above(get_panel(rb_panel))); }
+static VALUE rbncurs_m_panel_above(VALUE rb_panel)
+{ return rbncurs_c_panel_above(rb_panel); }
+static VALUE rbncurs_c_panel_below(VALUE rb_panel)
+{ return wrap_panel(panel_below(get_panel(rb_panel))); }
+static VALUE rbncurs_m_panel_below(VALUE rb_panel)
+{ return rbncurs_c_panel_below(rb_panel); }
+static VALUE rbncurs_c_set_panel_userptr(VALUE rb_panel, VALUE userptr)
+{ return INT2NUM(set_panel_userptr(get_panel(rb_panel),
+                                   (void*)(userptr))); }
+static VALUE rbncurs_m_set_panel_userptr(VALUE dummy, VALUE rb_panel, VALUE userptr)
+{ return rbncurs_c_set_panel_userptr(rb_panel, userptr); }
+static VALUE rbncurs_c_panel_userptr(VALUE rb_panel)
+{ return (VALUE)(panel_userptr(get_panel(rb_panel))); }
+static VALUE rbncurs_m_panel_userptr(VALUE dummy, VALUE rb_panel)
+{ return rbncurs_c_panel_userptr(rb_panel); }
+static VALUE rbncurs_c_move_panel(VALUE rb_panel, VALUE starty, VALUE startx)
+{ return INT2NUM(move_panel(get_panel(rb_panel), NUM2INT(starty),
+                            NUM2INT(startx))); }
+static VALUE rbncurs_m_move_panel(VALUE dummy, VALUE rb_panel, VALUE starty, VALUE startx)
+{ return rbncurs_c_move_panel(rb_panel, starty, startx); }
+static VALUE rbncurs_c_replace_panel(VALUE rb_panel, VALUE rb_window)
+{ return INT2NUM(replace_panel(get_panel(rb_panel), get_window(rb_window))); }
+static VALUE rbncurs_m_replace_panel(VALUE dummy, VALUE rb_panel, VALUE rb_window)
+{ return rbncurs_c_replace_panel(rb_panel, rb_window); }
+static VALUE rbncurs_c_panel_hidden(VALUE rb_panel)
+{ return panel_hidden(get_panel(rb_panel)) ? Qtrue : Qfalse; }
+static VALUE rbncurs_m_panel_hidden(VALUE dummy, VALUE rb_panel)
+{ return rbncurs_c_panel_hidden(rb_panel); }
+
+
+void init_panel(void)
+{
+    mPanel = rb_define_module_under(mNcurses, "Panel");
+    rb_iv_set(mPanel, "@panels_hash", rb_hash_new());
+    cPANEL  = rb_define_class_under(mPanel, "PANEL", rb_cObject);
+    rb_define_singleton_method(mPanel, "del_panel",
+                               (&rbncurs_m_del_panel),
+                               1);
+    rb_define_singleton_method(mPanel, "delpanel",
+                               (&rbncurs_m_del_panel),
+                               1);
+    rb_define_method(cPANEL, "del",
+                     (&rbncurs_c_del_panel), 0);
+    rb_define_method(cPANEL, "delete",
+                     (&rbncurs_c_del_panel), 0);
+    rb_define_singleton_method(mPanel, "panel_window",
+                               (&rbncurs_m_panel_window),
+                               1);
+    rb_define_method(cPANEL, "panel_window",
+                     (&rbncurs_c_panel_window), 0);
+    rb_define_method(cPANEL, "window",
+                     (&rbncurs_c_panel_window), 0);
+    rb_define_singleton_method(mPanel, "update_panels",
+                               (&rbncurs_m_update_panels),
+                               0);
+    rb_define_singleton_method(mPanel, "update",
+                               (&rbncurs_m_update_panels),
+                               0);
+    rb_define_singleton_method(mPanel, "hide_panel",
+                               (&rbncurs_m_hide_panel),
+                               1);
+    rb_define_method(cPANEL, "hide_panel",
+                     (&rbncurs_c_hide_panel), 0);
+    
+    rb_define_method(cPANEL, "hide",
+                     (&rbncurs_c_hide_panel), 0);
+    rb_define_singleton_method(mPanel, "show_panel",
+                               (&rbncurs_m_show_panel),
+                               1);
+    rb_define_method(cPANEL, "show_panel",
+                     (&rbncurs_c_show_panel), 0);
+    
+    rb_define_method(cPANEL, "show",
+                     (&rbncurs_c_show_panel), 0);
+    rb_define_singleton_method(mPanel, "top_panel",
+                               (&rbncurs_m_top_panel), 1);
+    rb_define_method(cPANEL, "top_panel",
+                     (&rbncurs_c_top_panel), 0);
+    
+    rb_define_method(cPANEL, "top",
+                     (&rbncurs_c_top_panel), 0);
+    rb_define_singleton_method(mPanel, "bottom_panel",
+                               (&rbncurs_m_bottom_panel),
+                               1);
+    rb_define_method(cPANEL, "bottom_panel",
+                     (&rbncurs_c_bottom_panel), 0);
+    
+    rb_define_method(cPANEL, "bottom",
+                     (&rbncurs_c_bottom_panel), 0);
+    rb_define_singleton_method(mPanel, "new_panel",
+                               (&rbncurs_m_new_panel),
+                               1);
+    rb_define_singleton_method(cPANEL, "new",
+                               (&rbncurs_m_new_panel),
+                               1);
+    rb_define_method(cWINDOW, "new_panel",
+                     (&rbncurs_c_new_panel),
+                     0);
+    rb_define_singleton_method(mPanel, "panel_above",
+                               (&rbncurs_m_panel_above),
+                               1);
+    rb_define_method(cPANEL, "panel_above",
+                     (&rbncurs_c_panel_above), 0);
+    rb_define_method(cPANEL, "above",
+                     (&rbncurs_c_panel_above), 0);
+    rb_define_singleton_method(mPanel, "panel_below",
+                               (&rbncurs_m_panel_below),
+                               1);
+    rb_define_method(cPANEL, "panel_below",
+                     (&rbncurs_c_panel_below), 0);
+    rb_define_method(cPANEL, "below",
+                     (&rbncurs_c_panel_below), 0);
+    rb_define_singleton_method(mPanel, "set_panel_userptr",
+                               (&rbncurs_m_set_panel_userptr), 2);
+    rb_define_method(cPANEL, "set_panel_userptr",
+                     (&rbncurs_c_set_panel_userptr),
+                     1);
+    rb_define_method(cPANEL, "set_userptr",
+                     (&rbncurs_c_set_panel_userptr),
+                     1);
+    rb_define_method(cPANEL, "userptr=",
+                     (&rbncurs_c_set_panel_userptr),
+                     1);
+    rb_define_singleton_method(mPanel, "panel_userptr",
+                               (&rbncurs_m_panel_userptr),
+                               1);
+    rb_define_method(cPANEL, "panel_userptr",
+                     (&rbncurs_c_panel_userptr),
+                     0);
+    rb_define_method(cPANEL, "userptr",                
+                     (&rbncurs_c_panel_userptr),
+                     0);
+    rb_define_singleton_method(mPanel, "move_panel",
+                               (&rbncurs_m_move_panel),
+                               3);
+    rb_define_method(cPANEL, "move_panel",
+                     (&rbncurs_c_move_panel), 2);
+    rb_define_method(cPANEL, "move",
+                     (&rbncurs_c_move_panel), 2);
+    rb_define_singleton_method(mPanel, "replace_panel",
+                               (&rbncurs_m_replace_panel),
+                               2);
+    rb_define_method(cPANEL, "replace_panel",
+                     (&rbncurs_c_replace_panel), 1);
+    rb_define_method(cPANEL, "replace",
+                     (&rbncurs_c_replace_panel), 1);
+    rb_define_singleton_method(mPanel, "panel_hidden?",
+                               (&rbncurs_m_panel_hidden),
+                               1);
+    rb_define_method(cPANEL, "panel_hidden?",
+                     (&rbncurs_c_panel_hidden), 0);
+    rb_define_method(cPANEL, "hidden?",
+                     (&rbncurs_c_panel_hidden), 0);
+}
+
+#endif

data/ext/ncurses/panel_wrap.h

@@ -0,0 +1,32 @@
+/*
+ * ncurses-ruby is a ruby module for accessing the FSF's ncurses library
+ * (C) 2002 Tobias Peters <t-peters@berlios.de>
+ * 
+ *  This module is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This module is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this module; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+/* $Id: panel_wrap.h,v 1.5 2004/07/31 08:35:13 t-peters Exp $ */
+
+#if !defined(PANEL_HH) && defined(HAVE_PANEL_H)
+#define PANEL_HH
+#include <panel.h>
+#include <ruby.h>
+
+extern VALUE mPanel;
+extern VALUE cPANEL;
+
+void init_panel(void);
+
+#endif

data/lib/ncurses.rb

@@ -0,0 +1,350 @@
+# ncurses-ruby is a ruby module for accessing the FSF's ncurses library
+# (C) 2002, 2003, 2004 Tobias Peters <t-peters@users.berlios.de>
+# (C) 2004 Simon Kaczor <skaczor@cox.net>
+# (C) 2005 Tobias Herzke
+#
+# This module is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This module is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this module; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+
+# $Id: ncurses.rb,v 1.7 2005/02/26 22:51:29 t-peters Exp $
+
+require 'ncurses/etc'
+
+begin
+  require 'ncurses.bundle'
+rescue LoadError => e
+  raise e unless e.message =~ /^no such file to load -- ncurses\.bundle$/
+  require 'ncurses.so'
+end
+
+# Ncurses constants with leading underscore
+def Ncurses._XOPEN_CURSES
+  Ncurses::XOPEN_CURSES
+end
+def Ncurses._SUBWIN  
+  Ncurses::SUBWIN
+end
+def Ncurses._ENDLINE 
+  Ncurses::ENDLINE
+end
+def Ncurses._FULLWIN 
+  Ncurses::FULLWIN
+end
+def Ncurses._SCROLLWIN
+  Ncurses::SCROLLWIN
+end
+def Ncurses._ISPAD   
+  Ncurses::ISPAD
+end
+def Ncurses._HASMOVED
+  Ncurses::HASMOVED
+end
+def Ncurses._WRAPPED 
+  Ncurses::WRAPPED
+end
+def Ncurses._NOCHANGE
+  Ncurses::NOCHANGE
+end
+def Ncurses._NEWINDEX
+  Ncurses::NEWINDEX
+end
+
+
+module Ncurses
+  module Destroy_checker; def destroyed?; @destroyed; end; end
+  class WINDOW
+    include Destroy_checker
+    def method_missing(name, *args)
+      name = name.to_s
+      if (name[0,2] == "mv")
+        test_name = name.dup
+        test_name[2,0] = "w" # insert "w" after"mv"
+        if (Ncurses.respond_to?(test_name))
+          return Ncurses.send(test_name, self, *args)
+        end
+      end
+      test_name = "w" + name
+      if (Ncurses.respond_to?(test_name))
+        return Ncurses.send(test_name, self, *args)
+      end
+      Ncurses.send(name, self, *args)
+    end
+    def respond_to?(name)
+      name = name.to_s
+      if (name[0,2] == "mv" && Ncurses.respond_to?("mvw" + name[2..-1]))
+        return true
+      end
+      Ncurses.respond_to?("w" + name) || Ncurses.respond_to?(name)
+    end
+    def del
+      Ncurses.delwin(self)
+    end
+    alias delete del
+    def WINDOW.new(*args)
+      Ncurses.newwin(*args)
+    end
+  end
+  class SCREEN
+    include Destroy_checker
+    def del
+      Ncurses.delscreen(self)
+    end
+    alias delete del
+  end
+  class MEVENT
+    attr_accessor :id, :x,:y,:z, :bstate
+  end
+  GETSTR_LIMIT = 1024
+
+  module Panel 
+    class PANEL; end
+  end
+
+  module Form
+    class FORM
+      attr_reader :user_object
+
+      # This placeholder replaces the form_userptr function in curses
+      def user_object=(obj)
+        @user_object = obj
+      end
+    end
+    
+    class FIELD
+      attr_reader :user_object
+
+      # This placeholder replaces the field_userptr function in curses
+      def user_object=(obj)
+        @user_object = obj
+      end
+    end
+
+    class FIELDTYPE
+    end
+  end
+
+  module Menu
+    class MENU
+      attr_reader :user_object
+
+      # This placeholder replaces the menu_userptr function in curses
+      def user_object=(obj)
+        @user_object = obj
+      end
+    end
+
+    class ITEM
+      attr_reader :user_object
+
+      # This placeholder replaces the item_userptr function in curses
+      def user_object=(obj)
+        @user_object = obj
+      end
+    end
+  end
+end
+def Ncurses.inchnstr(str,n)
+  Ncurses.winchnstr(Ncurses.stdscr, str, n)
+end
+def Ncurses.inchstr(str)
+  Ncurses.winchstr(Ncurses.stdscr, str)
+end
+def Ncurses.mvinchnstr(y,x, str, n)
+  Ncurses.mvwinchnstr(Ncurses.stdscr, y,x, str, n)
+end
+def Ncurses.mvinchstr(y,x, str)
+  Ncurses.mvwinchstr(Ncurses.stdscr, y,x, str)
+end
+def Ncurses.mvwinchnstr(win, y,x, str, n)
+  if (Ncurses.wmove(win,y,x) == Ncurses::ERR) 
+    Ncurses::ERR
+  else
+    Ncurses.winchnstr(win,str,n)
+  end
+end
+def Ncurses.mvwinchstr(win, y,x, str)
+  maxy = []; maxx = []; getmaxyx(win, maxy,maxx)
+  return Ncurses::ERR if (maxx[0] == Ncurses::ERR)
+  Ncurses.mvwinchnstr(win, y,x, str, maxx[0]+1)
+end
+def Ncurses.winchstr(win, str)
+  maxy = []; maxx = []; getmaxyx(win, maxy,maxx)
+  return Ncurses::ERR if (maxx[0] == Ncurses::ERR)
+  Ncurses.winchnstr(win, str, maxx[0]+1)
+end
+
+def Ncurses.getnstr(str,n)
+  Ncurses.wgetnstr(Ncurses.stdscr, str, n)
+end
+def Ncurses.mvgetnstr(y,x, str, n)
+  Ncurses.mvwgetnstr(Ncurses.stdscr, y,x, str, n)
+end
+def Ncurses.mvwgetnstr(win, y,x, str, n)
+  if (Ncurses.wmove(win,y,x) == Ncurses::ERR) 
+    Ncurses::ERR
+  else
+    Ncurses.wgetnstr(win,str,n)
+  end
+end
+
+def Ncurses.innstr(str,n)
+  Ncurses.winnstr(Ncurses.stdscr, str, n)
+end
+def Ncurses.instr(str)
+  Ncurses.winstr(Ncurses.stdscr, str)
+end
+def Ncurses.mvinnstr(y,x, str, n)
+  Ncurses.mvwinnstr(Ncurses.stdscr, y,x, str, n)
+end
+def Ncurses.mvinstr(y,x, str)
+  Ncurses.mvwinstr(Ncurses.stdscr, y,x, str)
+end
+def Ncurses.mvwinnstr(win, y,x, str, n)
+  if (Ncurses.wmove(win,y,x) == Ncurses::ERR) 
+    Ncurses::ERR
+  else
+    Ncurses.winnstr(win,str,n)
+  end
+end
+def Ncurses.mvwinstr(win, y,x, str)
+  maxy = []; maxx = []; getmaxyx(win, maxy,maxx)
+  return Ncurses::ERR if (maxx[0] == Ncurses::ERR)
+  Ncurses.mvwinnstr(win, y,x, str, maxx[0]+1)
+end
+def Ncurses.winstr(win, str)
+  maxy = []; maxx = []; getmaxyx(win, maxy,maxx)
+  return Ncurses::ERR if (maxx[0] == Ncurses::ERR)
+  Ncurses.winnstr(win, str, maxx[0]+1)
+end
+
+def Ncurses.mouse_trafo(pY, pX, to_screen)
+  Ncurses.wmouse_trafo(Ncurses.stdscr, pY, pX, to_screen)
+end
+
+def Ncurses.getcurx(win)
+  x = []; y = []; Ncurses.getyx(win, y,x); x[0]
+end
+def Ncurses.getcury(win)
+  x = []; y = []; Ncurses.getyx(win, y,x); y[0]
+end
+def Ncurses.getbegx(win)
+  x = []; y = []; Ncurses.getbegyx(win, y,x); x[0]
+end
+def Ncurses.getbegy(win)
+  x = []; y = []; Ncurses.getbegyx(win, y,x); y[0]
+end
+def Ncurses.getmaxx(win)
+  x = []; y = []; Ncurses.getmaxyx(win, y,x); x[0]
+end
+def Ncurses.getmaxy(win)
+  x = []; y = []; Ncurses.getmaxyx(win, y,x); y[0]
+end
+def Ncurses.getparx(win)
+  x = []; y = []; Ncurses.getparyx(win, y,x); x[0]
+end
+def Ncurses.getpary(win)
+  x = []; y = []; Ncurses.getparyx(win, y,x); y[0]
+end
+def Ncurses.erase
+  Ncurses.werase(Ncurses.stdscr)
+end
+def Ncurses.getstr(str)
+  Ncurses.getnstr(str, Ncurses::GETSTR_LIMIT)
+end
+def Ncurses.mvgetstr(y,x, str)
+  Ncurses.mvgetnstr(y,x, str, Ncurses::GETSTR_LIMIT)
+end
+def Ncurses.mvwgetstr(win, y,x, str)
+  Ncurses.mvwgetnstr(win, y,x, str, Ncurses::GETSTR_LIMIT)
+end
+def Ncurses.wgetstr(win, str)
+  Ncurses.wgetnstr(win, str, Ncurses::GETSTR_LIMIT)
+end
+
+def Ncurses.scanw(format, result)
+  Ncurses.wscanw(Ncurses.stdscr, format, result)
+end
+def Ncurses.mvscanw(y,x, format, result)
+  Ncurses.mvwscanw(Ncurses.stdscr, y,x, format, result)
+end
+def Ncurses.mvwscanw(win, y,x, format, result)
+  if (Ncurses.wmove(win, y,x) == Ncurses::ERR) 
+    Ncurses::ERR
+  else
+    Ncurses.wscanw(win, format, result)
+  end
+end
+def Ncurses.wscanw(win, format, result)
+  str = ""
+  if (Ncurses.wgetstr(win, str) == Ncurses::ERR) 
+    Ncurses::ERR
+  else
+    require "scanf.rb" # Use ruby's implementation of scanf
+    result.replace(str.scanf(format))
+  end
+end
+
+def Ncurses.mvprintw(*args)
+  Ncurses.mvwprintw(Ncurses.stdscr, *args)
+end
+def Ncurses.mvwprintw(win, y,x, *args)
+  if (Ncurses.wmove(win,y,x) == Ncurses::ERR) 
+    Ncurses::ERR
+  else
+    wprintw(win, *args)
+  end
+end
+def Ncurses.printw(*args)
+  Ncurses.wprintw(Ncurses.stdscr, *args)
+end
+def Ncurses.touchline(win, start, count)
+  Ncurses.wtouchln(win, start, count, 1)
+end
+def Ncurses.touchwin(win)
+  wtouchln(win, 0, getmaxy(win), 1)
+end
+
+module Ncurses
+  Ncurses = self # for accessing Ncurses from a Module that includes Ncurses
+
+  # Some users like to include ncurses names despite namespace pollution
+  # This module is for them
+  module Namespace
+    def self.append_features(target)
+      # include constants
+      unless target.ancestors.member?(Ncurses)
+        target.__send__(:include, Ncurses)
+      end
+      
+      # make methods available
+      unless target.respond_to?(:pre_Ncurses_method_missing)
+        target.module_eval{
+          alias pre_Ncurses_method_missing method_missing
+          def method_missing(name, *args)
+            if Ncurses.respond_to?(name)
+              Ncurses.send(name, *args)
+            else
+              pre_Ncurses_method_missing(name, *args)
+            end
+          end
+        }
+      end
+    end
+    def self.entend_object(object)
+      class << object
+        self
+      end.__send__(:include, self)
+    end
+  end
+end