home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / py2s152.zip / Modules / cursesmodule.c < prev    next >
C/C++ Source or Header  |  1999-06-27  |  42KB  |  1,606 lines
  1. /***********************************************************
  2. Copyright 1994 by Lance Ellinghouse,
  3. Cathedral City, California Republic, United States of America.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the name of Lance Ellinghouse
  12. not be used in advertising or publicity pertaining to distribution 
  13. of the software without specific, written prior permission.
  14.  
  15. LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE BE LIABLE FOR ANY SPECIAL, 
  18. INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING 
  19. FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, 
  20. NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION 
  21. WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24.  
  25. /******************************************************************
  26. This is a curses implementation. I have tried to be as complete
  27. as possible. If there are functions you need that are not included,
  28. please let me know and/or send me some diffs.
  29.  
  30. There are 3 basic types exported by this module:
  31.    1) Screen - This is not currently used
  32.    2) Window - This is the basic type. This is equivalent to "WINDOW *".
  33.    3) Pad    - This is similar to Window, but works with Pads as defined
  34.                in curses.
  35.  
  36. Most of the routines can be looked up using the curses man page.
  37.  
  38. Here is a list of the currently supported methods and attributes
  39. in the curses module:
  40.  
  41. Return Value      Func/Attr            Description
  42. --------------------------------------------------------------------------
  43. StringObject      version              A string representing the current
  44.                                        version of this module.
  45. WindowObject      initscr()            This initializes the screen for use
  46. None              endwin()             Closes down the screen and returns
  47.                                        things as they were before calling
  48.                                        initscr()
  49. True/FalseObject  isendwin()           Has endwin() been called?
  50. None              doupdate()           Updates screen
  51. WindowObject      newwin(nlines,ncols,begin_y,begin_x)
  52.                   newwin(begin_y,begin_x)
  53.                                        newwin() creates and returns
  54.                                        a new window.
  55. None              beep()               Beep the screen if possible
  56. None              flash()              Flash the screen if possible
  57. None              ungetch(int)         Push the int back so next getch()
  58.                                        will return it.
  59.                                        Note: argument is an INT, not a CHAR
  60. None              flushinp()           Flush all input buffers
  61. None              cbreak()             Enter cbreak mode
  62. None              nocbreak()           Leave cbreak mode
  63. None              echo()               Enter echo mode
  64. None              noecho()             Leave echo mode
  65. None              nl()                 Enter nl mode
  66. None              nonl()               Leave nl mode
  67. None              raw()                Enter raw mode
  68. None              noraw()              Leave raw mode
  69. None              intrflush(int)       Set or reset interruptable flush
  70.                                        mode, int=1 if set, 0 if notset.
  71. None              meta(int)            Allow 8 bit or 7 bit chars.
  72.                                        int=1 is 8 bit, int=0 is 7 bit
  73. StringObject      keyname(int)         return the text representation
  74.                                        of a KEY_ value. (see below)
  75.  
  76. Here is a list of the currently supported methods and attributes
  77. in the WindowObject:
  78.  
  79. Return Value      Func/Attr            Description
  80. --------------------------------------------------------------------------
  81. None              refresh()            Do refresh
  82. None              nooutrefresh()       Mark for refresh but wait
  83. None              mvwin(new_y,new_x)   Move Window
  84. None              move(new_y,new_x)    Move Cursor
  85. WindowObject      subwin(nlines,ncols,begin_y,begin_x)
  86.                   subwin(begin_y,begin_x)
  87. None              addch(y,x,ch,attr)
  88.                   addch(y,x,ch)
  89.                   addch(ch,attr)
  90.                   addch(ch)
  91. None              insch(y,x,ch,attr)
  92.                   insch(y,x,ch)
  93.                   insch(ch,attr)
  94.                   insch(ch)
  95. None              delch(y,x)
  96.                   delch()
  97. None              echochar(ch,attr)
  98.                   echochar(ch)
  99. None              addstr(y,x,str,attr)
  100.                   addstr(y,x,str)
  101.                   addstr(str,attr)
  102.                   addstr(str)
  103. None              attron(attr)
  104. None              attroff(attr)
  105. None              attrset(sttr)
  106. None              standend()
  107. None              standout()
  108. None              border(ls,rs,ts,bs,tl,tr,bl,br)   (accepts 0-8 INT args)
  109. None              box(vertch,horch)    vertch and horch are INTS
  110.                   box()
  111. None              hline(y,x,ch,n)
  112.                   hline(ch,n)
  113. None              vline(y,x,ch,n)
  114.                   vline(ch,n)
  115. None              erase()
  116. None              deleteln()
  117. None              insertln()
  118. (y,x)             getyx()
  119. (y,x)             getbegyx()
  120. (y,x)             getmaxyx()
  121. None              clear()
  122. None              clrtobot()
  123. None              clrtoeol()
  124. None              scroll()
  125.                   scroll(nlines)
  126. None              touchwin()
  127. None              touchline(start,count)
  128. IntObject         getch(y,x)
  129.                   getch()
  130. StringObject      getstr(y,x)
  131.                   getstr()
  132. IntObject         inch(y,x)
  133.                   inch()
  134. None              clearok(int)      int=0 or int=1
  135. None              idlok(int)        int=0 or int=1
  136. None              leaveok(int)      int=0 or int=1
  137. None              scrollok(int)     int=0 or int=1
  138. None              setscrreg(top,bottom)
  139. None              keypad(int)       int=0 or int=1
  140. None              nodelay(int)      int=0 or int=1
  141. None              notimeout(int)    int=0 or int=1
  142. ******************************************************************/
  143.  
  144.  
  145. /* curses module */
  146.  
  147. #include "Python.h"
  148.  
  149. #ifdef HAVE_NCURSES_H
  150. /* Now let's hope there aren't systems that have a broken ncurses.h */
  151. #include <ncurses.h>
  152. #else
  153. #include <curses.h>
  154. #endif
  155.  
  156. typedef struct {
  157.     PyObject_HEAD
  158.     SCREEN *scr;
  159. } PyCursesScreenObject;
  160.  
  161. typedef struct {
  162.     PyObject_HEAD
  163.     WINDOW *win;
  164.     WINDOW *parent;
  165. } PyCursesWindowObject;
  166.  
  167. typedef struct {
  168.     PyObject_HEAD
  169.     WINDOW *pad;
  170. } PyCursesPadObject;
  171.  
  172. #if 0
  173. staticforward PyTypeObject PyCursesScreen_Type;
  174. #endif
  175. staticforward PyTypeObject PyCursesWindow_Type;
  176. #if 0
  177. staticforward PyTypeObject PyCursesPad_Type;
  178. #endif
  179.  
  180. #define PyCursesScreen_Check(v)     ((v)->ob_type == &PyCursesScreen_Type)
  181. #define PyCursesWindow_Check(v)     ((v)->ob_type == &PyCursesWindow_Type)
  182. #define PyCursesPad_Check(v)     ((v)->ob_type == &PyCursesPad_Type)
  183.  
  184. /* Defines */
  185. static PyObject *PyCursesError;        /* For exception curses.error */
  186.  
  187. /* Catch-all error messages */
  188. static char *catchall_ERR  = "curses function returned ERR";
  189. static char *catchall_NULL = "curses function returned NULL";
  190.  
  191. /* Tells whether initscr() has been called to initialise curses  */
  192. static int initialised = FALSE;
  193.  
  194. #define ARG_COUNT(X) \
  195.     (((X) == NULL) ? 0 : (PyTuple_Check(X) ? PyTuple_Size(X) : 1))
  196.  
  197. /******************************************************************
  198.  
  199. Change Log:
  200.  
  201. Version 1.2: 95/02/23 (Steve Clift)
  202.     Fixed several potential core-dumping bugs.
  203.     Reworked arg parsing where variable arg lists are used.
  204.     Generate exceptions when ERR or NULL is returned by curses functions.
  205.     Changed return types to match SysV Curses manual descriptions.
  206.     Added keypad() to window method list.
  207.     Added border(), hline() and vline() window methods.
  208.  
  209. Version 1.1: 94/08/31:
  210.     Minor fixes given by Guido.
  211.     Changed 'ncurses' to 'curses'
  212.     Changed '__version__' to 'version'
  213.     Added PyErr_Clear() where needed
  214.     Moved ACS_* attribute initialization to PyCurses_InitScr() to fix
  215.         crash on SGI
  216.  
  217. Version 1.0: 94/08/30:
  218.     This is the first release of this software.
  219.     Released to the Internet via python-list@cwi.nl
  220.  
  221. ******************************************************************/
  222.  
  223. static char *PyCursesVersion = "1.2";
  224.  
  225. /*
  226.  * Check the return code from a curses function and return None 
  227.  * or raise an exception as appropriate.
  228.  */
  229.  
  230. static PyObject *
  231. PyCursesCheckERR(code, fname)
  232.      int code;
  233.      char *fname;
  234. {
  235.   char buf[100];
  236.  
  237.   if (code != ERR) {
  238.     Py_INCREF(Py_None);
  239.     return Py_None;
  240.   } else {
  241.     if (fname == NULL) {
  242.       PyErr_SetString(PyCursesError, catchall_ERR);
  243.     } else {
  244.       strcpy(buf, fname);
  245.       strcat(buf, "() returned ERR");
  246.       PyErr_SetString(PyCursesError, buf);
  247.     }
  248.     return NULL;
  249.   }
  250. }
  251.  
  252.  
  253. static int
  254. PyCursesInitialised()
  255. {
  256.   if (initialised == TRUE)
  257.     return 1;
  258.   else {
  259.     PyErr_SetString(PyCursesError, "must call initscr() first");
  260.     return 0;
  261.   }
  262. }
  263.  
  264.  
  265. /* ------------- SCREEN routines --------------- */
  266.  
  267. #ifdef NOT_YET
  268. static PyObject *
  269. PyCursesScreen_New(arg)
  270.     PyObject * arg;
  271. {
  272.         char *term_type;
  273.     PyFileObject *in_fo;
  274.     PyFileObject *out_fo;
  275.     PyCursesScreenObject *xp;
  276.     xp = PyObject_NEW(PyCursesScreenObject, &PyCursesScreen_Type);
  277.     if (xp == NULL)
  278.         return NULL;
  279.     return (PyObject *)xp;
  280. }
  281. #endif
  282.  
  283.  
  284. /* ------------- WINDOW routines --------------- */
  285.  
  286. static PyObject *
  287. PyCursesWindow_New(win)
  288.     WINDOW *win;
  289. {
  290.     PyCursesWindowObject *wo;
  291.  
  292.     wo = PyObject_NEW(PyCursesWindowObject, &PyCursesWindow_Type);
  293.     if (wo == NULL)
  294.         return NULL;
  295.     wo->win = win;
  296.     wo->parent = (WINDOW *)NULL;
  297.     return (PyObject *)wo;
  298. }
  299.  
  300. static void
  301. PyCursesWindow_Dealloc(wo)
  302.     PyCursesWindowObject *wo;
  303. {
  304.   if (wo->win != stdscr)
  305.     delwin(wo->win);
  306.   PyMem_DEL(wo);
  307. }
  308.  
  309. static PyObject *
  310. PyCursesWindow_Refresh(self,arg)
  311.      PyCursesWindowObject *self;
  312.      PyObject * arg;
  313. {
  314.   if (!PyArg_NoArgs(arg))
  315.     return NULL;
  316.   return PyCursesCheckERR(wrefresh(self->win), "wrefresh");
  317. }
  318.  
  319. static PyObject *
  320. PyCursesWindow_NoOutRefresh(self,arg)
  321.      PyCursesWindowObject *self;
  322.      PyObject * arg;
  323. {
  324.   if (!PyArg_NoArgs(arg))
  325.     return NULL;
  326.   return PyCursesCheckERR(wnoutrefresh(self->win), "wnoutrefresh");
  327. }
  328.  
  329. static PyObject *
  330. PyCursesWindow_MoveWin(self,arg)
  331.      PyCursesWindowObject *self;
  332.      PyObject * arg;
  333. {
  334.   int x, y;
  335.   if (!PyArg_Parse(arg,"(ii);y,x", &y, &x))
  336.     return NULL;
  337.   return PyCursesCheckERR(mvwin(self->win,y,x), "mvwin");
  338. }
  339.  
  340. static PyObject *
  341. PyCursesWindow_Move(self,arg)
  342.      PyCursesWindowObject *self;
  343.      PyObject * arg;
  344. {
  345.   int x, y;
  346.   if (!PyArg_Parse(arg,"(ii);y,x", &y, &x))
  347.     return NULL;
  348.   return PyCursesCheckERR(wmove(self->win,y,x), "wmove");
  349. }
  350.  
  351. static PyObject *
  352. PyCursesWindow_SubWin(self,arg)
  353.      PyCursesWindowObject *self;
  354.      PyObject * arg;
  355. {
  356.   WINDOW *win;
  357.   PyCursesWindowObject *rtn_win;
  358.   int nlines, ncols, begin_y, begin_x;
  359.  
  360.   nlines = 0;
  361.   ncols  = 0;
  362.   switch (ARG_COUNT(arg)) {
  363.   case 2:
  364.     if (!PyArg_Parse(arg,"(ii);begin_y,begin_x",&begin_y,&begin_x))
  365.       return NULL;
  366.     break;
  367.   case 4:
  368.     if (!PyArg_Parse(arg, "(iiii);nlines,ncols,begin_y,begin_x",
  369.            &nlines,&ncols,&begin_y,&begin_x))
  370.       return NULL;
  371.     break;
  372.   default:
  373.     PyErr_SetString(PyExc_TypeError, "subwin requires 2 or 4 arguments");
  374.     return NULL;
  375.   }
  376.   win = subwin(self->win,nlines,ncols,begin_y,begin_x);
  377.   if (win == NULL) {
  378.     PyErr_SetString(PyCursesError, catchall_NULL);
  379.     return NULL;
  380.   }
  381.   rtn_win = (PyCursesWindowObject *)PyCursesWindow_New(win);
  382.   rtn_win->parent = self->win;
  383.   return (PyObject *)rtn_win;
  384. }
  385.  
  386. static PyObject *
  387. PyCursesWindow_AddCh(self,arg)
  388.      PyCursesWindowObject *self;
  389.      PyObject * arg;
  390. {
  391.   int rtn;
  392.   int x, y;
  393.   int ch;
  394.   int attr, attr_old = 0;
  395.   int use_xy = FALSE, use_attr = FALSE;
  396.  
  397.   switch (ARG_COUNT(arg)) {
  398.     case 1:
  399.       if (!PyArg_Parse(arg, "i;ch", &ch))
  400.         return NULL;
  401.       break;
  402.     case 2:
  403.       if (!PyArg_Parse(arg,"(ii);ch,attr", &ch, &attr))
  404.         return NULL;
  405.       use_attr = TRUE;
  406.       break;
  407.     case 3:
  408.       if (!PyArg_Parse(arg,"(iii);y,x,ch", &y, &x, &ch))
  409.         return NULL;
  410.       use_xy = TRUE;
  411.       break;
  412.     case 4:
  413.       if (!PyArg_Parse(arg,"(iiii);y,x,ch,attr", &y, &x, &ch, &attr))
  414.         return NULL;
  415.       use_xy = use_attr = TRUE;
  416.       break;
  417.     default:
  418.       PyErr_SetString(PyExc_TypeError, "addch requires 1 to 4 arguments");
  419.       return NULL;
  420.   }
  421.  
  422.   if (use_attr == TRUE) {
  423.     attr_old = getattrs(self->win);
  424.     wattrset(self->win,attr);
  425.   }
  426.   if (use_xy == TRUE)
  427.     rtn = mvwaddch(self->win,y,x,ch);
  428.   else
  429.     rtn = waddch(self->win,ch);
  430.   if (use_attr == TRUE)
  431.     wattrset(self->win,attr_old);
  432.  
  433.   return PyCursesCheckERR(rtn, "[mv]waddch");
  434. }
  435.  
  436. static PyObject *
  437. PyCursesWindow_InsCh(self,arg)
  438.      PyCursesWindowObject *self;
  439.      PyObject * arg;
  440. {
  441.   int rtn;
  442.   int x, y;
  443.   int ch;
  444.   int attr, attr_old = 0;
  445.   int use_xy = TRUE, use_attr = FALSE;
  446.  
  447.   switch (ARG_COUNT(arg)) {
  448.     case 1:
  449.       if (!PyArg_Parse(arg, "i;ch", &ch))
  450.         return NULL;
  451.       break;
  452.     case 2:
  453.       if (!PyArg_Parse(arg,"(ii);ch,attr", &ch, &attr))
  454.         return NULL;
  455.       use_attr = TRUE;
  456.       break;
  457.     case 3:
  458.       if (!PyArg_Parse(arg,"(iii);y,x,ch", &y, &x, &ch))
  459.         return NULL;
  460.       use_xy = TRUE;
  461.       break;
  462.     case 4:
  463.       if (!PyArg_Parse(arg,"(iiii);y,x,ch,attr", &y, &x, &ch, &attr))
  464.         return NULL;
  465.       use_xy = use_attr = TRUE;
  466.       break;
  467.     default:
  468.       PyErr_SetString(PyExc_TypeError, "insch requires 1 to 4 arguments");
  469.       return NULL;
  470.   }
  471.  
  472.   if (use_attr == TRUE) {
  473.     attr_old = getattrs(self->win);
  474.     wattrset(self->win,attr);
  475.   }
  476.   if (use_xy == TRUE)
  477.     rtn = mvwinsch(self->win,y,x,ch);
  478.   else
  479.     rtn = winsch(self->win,ch);
  480.   if (use_attr == TRUE)
  481.     wattrset(self->win,attr_old);
  482.  
  483.   return PyCursesCheckERR(rtn, "[mv]winsch");
  484. }
  485.  
  486. static PyObject *
  487. PyCursesWindow_DelCh(self,arg)
  488.      PyCursesWindowObject *self;
  489.      PyObject * arg;
  490. {
  491.   int rtn;
  492.   int x, y;
  493.  
  494.   switch (ARG_COUNT(arg)) {
  495.   case 0:
  496.     rtn = wdelch(self->win);
  497.     break;
  498.   case 2:
  499.     if (!PyArg_Parse(arg,"(ii);y,x", &y, &x))
  500.       return NULL;
  501.     rtn = mvwdelch(self->win,y,x);
  502.     break;
  503.   default:
  504.     PyErr_SetString(PyExc_TypeError, "delch requires 0 or 2 arguments");
  505.     return NULL;
  506.   }
  507.  
  508.   return PyCursesCheckERR(rtn, "[mv]wdelch");
  509. }
  510.  
  511. static PyObject *
  512. PyCursesWindow_EchoChar(self,arg)
  513.      PyCursesWindowObject *self;
  514.      PyObject * arg;
  515. {
  516.   int rtn;
  517.   int ch;
  518.   int attr, attr_old;
  519.  
  520.   switch (ARG_COUNT(arg)) {
  521.   case 1:
  522.     if (!PyArg_Parse(arg,"i;ch", &ch))
  523.       return NULL;
  524.     rtn = wechochar(self->win,ch);
  525.     break;
  526.   case 2:
  527.     if (!PyArg_Parse(arg,"(ii);ch,attr", &ch, &attr))
  528.       return NULL;
  529.     attr_old = getattrs(self->win);
  530.     wattrset(self->win,attr);
  531.     rtn = wechochar(self->win,ch);
  532.     wattrset(self->win,attr_old);
  533.     break;
  534.   default:
  535.     PyErr_SetString(PyExc_TypeError, "echochar requires 1 or 2 arguments");
  536.     return NULL;
  537.   }
  538.  
  539.   return PyCursesCheckERR(rtn, "wechochar");
  540. }
  541.  
  542. static PyObject *
  543. PyCursesWindow_AddStr(self,arg)
  544.      PyCursesWindowObject *self;
  545.      PyObject * arg;
  546. {
  547.   int rtn;
  548.   int x, y;
  549.   char *str;
  550.   int attr, attr_old = 0;
  551.   int use_xy = FALSE, use_attr = FALSE;
  552.  
  553.   switch (ARG_COUNT(arg)) {
  554.   case 1:
  555.     if (!PyArg_Parse(arg,"s;str", &str))
  556.       return NULL;
  557.     break;
  558.   case 2:
  559.     if (!PyArg_Parse(arg,"(si);str,attr", &str, &attr))
  560.       return NULL;
  561.     use_attr = TRUE;
  562.     break;
  563.   case 3:
  564.     if (!PyArg_Parse(arg,"(iis);y,x,str", &y, &x, &str))
  565.       return NULL;
  566.     use_xy = TRUE;
  567.     break;
  568.   case 4:
  569.     if (!PyArg_Parse(arg,"(iisi);y,x,str,attr", &y, &x, &str, &attr))
  570.       return NULL;
  571.     use_xy = use_attr = TRUE;
  572.     break;
  573.   default:
  574.     PyErr_SetString(PyExc_TypeError, "addstr requires 1 to 4 arguments");
  575.     return NULL;
  576.   }
  577.  
  578.   if (use_attr == TRUE) {
  579.     attr_old = getattrs(self->win);
  580.     wattrset(self->win,attr);
  581.   }
  582.   if (use_xy == TRUE)
  583.     rtn = mvwaddstr(self->win,y,x,str);
  584.   else
  585.     rtn = waddstr(self->win,str);
  586.   if (use_attr == TRUE)
  587.     wattrset(self->win,attr_old);
  588.  
  589.   return PyCursesCheckERR(rtn, "[mv]waddstr");
  590. }
  591.  
  592. static PyObject *
  593. PyCursesWindow_AttrOn(self,arg)
  594.      PyCursesWindowObject *self;
  595.      PyObject * arg;
  596. {
  597.   int ch;
  598.   if (!PyArg_Parse(arg,"i;attr", &ch))
  599.       return NULL;
  600.   wattron(self->win,ch);
  601.   Py_INCREF(Py_None);
  602.   return Py_None;
  603. }
  604.  
  605. static PyObject *
  606. PyCursesWindow_AttrOff(self,arg)
  607.      PyCursesWindowObject *self;
  608.      PyObject * arg;
  609. {
  610.   int ch;
  611.   if (!PyArg_Parse(arg,"i;attr", &ch))
  612.       return NULL;
  613.   wattroff(self->win,ch);
  614.   Py_INCREF(Py_None);
  615.   return Py_None;
  616. }
  617.  
  618. static PyObject *
  619. PyCursesWindow_AttrSet(self,arg)
  620.      PyCursesWindowObject *self;
  621.      PyObject * arg;
  622. {
  623.   int ch;
  624.   if (!PyArg_Parse(arg,"i;attr", &ch))
  625.       return NULL;
  626.   wattrset(self->win,ch);
  627.   Py_INCREF(Py_None);
  628.   return Py_None;
  629. }
  630.  
  631. static PyObject *
  632. PyCursesWindow_StandEnd(self,arg)
  633.      PyCursesWindowObject *self;
  634.      PyObject * arg;
  635. {
  636.   if (!PyArg_NoArgs(arg))
  637.       return NULL;
  638.   wstandend(self->win);
  639.   Py_INCREF(Py_None);
  640.   return Py_None;
  641. }
  642.  
  643. static PyObject *
  644. PyCursesWindow_StandOut(self,arg)
  645.      PyCursesWindowObject *self;
  646.      PyObject * arg;
  647. {
  648.   if (!PyArg_NoArgs(arg))
  649.       return NULL;
  650.   wstandout(self->win);
  651.   Py_INCREF(Py_None);
  652.   return Py_None;
  653. }
  654.  
  655. static PyObject *
  656. PyCursesWindow_Border(self, args)
  657.      PyCursesWindowObject *self;
  658.      PyObject *args;
  659. {
  660.   int ls, rs, ts, bs, tl, tr, bl, br;
  661.   ls = rs = ts = bs = tl = tr = bl = br = 0;
  662.   if (!PyArg_ParseTuple(args,"|iiiiiiii;ls,rs,ts,bs,tl,tr,bl,br",
  663.                         &ls, &rs, &ts, &bs, &tl, &tr, &bl, &br))
  664.     return NULL;
  665.   wborder(self->win, ls, rs, ts, bs, tl, tr, bl, br);
  666.   Py_INCREF(Py_None);
  667.   return Py_None;
  668. }
  669.  
  670. static PyObject *
  671. PyCursesWindow_Box(self,arg)
  672.      PyCursesWindowObject *self;
  673.      PyObject * arg;
  674. {
  675.   int ch1=0,ch2=0;
  676.   if (!PyArg_NoArgs(arg)) {
  677.     PyErr_Clear();
  678.     if (!PyArg_Parse(arg,"(ii);vertch,horch", &ch1, &ch2))
  679.       return NULL;
  680.   }
  681.   box(self->win,ch1,ch2);
  682.   Py_INCREF(Py_None);
  683.   return Py_None;
  684. }
  685.  
  686. static PyObject *
  687. PyCursesWindow_Hline(self, args)
  688.      PyCursesWindowObject *self;
  689.      PyObject *args;
  690. {
  691.   int ch, n, x, y, code = OK;
  692.   switch (ARG_COUNT(args)) {
  693.   case 2:
  694.     if (!PyArg_Parse(args, "(ii);ch,n", &ch, &n))
  695.       return NULL;
  696.     break;
  697.   case 4:
  698.     if (!PyArg_Parse(args, "(iiii);y,x,ch,n", &y, &x, &ch, &n))
  699.       return NULL;
  700.     code = wmove(self->win, y, x);
  701.     break;
  702.   default:
  703.     PyErr_SetString(PyExc_TypeError, "hline requires 2 or 4 arguments");
  704.     return NULL;
  705.   }
  706.   if (code != ERR)
  707.     whline(self->win, ch, n);
  708.   return PyCursesCheckERR(code, "wmove");
  709. }
  710.  
  711. static PyObject *
  712. PyCursesWindow_Vline(self, args)
  713.      PyCursesWindowObject *self;
  714.      PyObject *args;
  715. {
  716.   int ch, n, x, y, code = OK;
  717.   switch (ARG_COUNT(args)) {
  718.   case 2:
  719.     if (!PyArg_Parse(args, "(ii);ch,n", &ch, &n))
  720.       return NULL;
  721.     break;
  722.   case 4:
  723.     if (!PyArg_Parse(args, "(iiii);y,x,ch,n", &y, &x, &ch, &n))
  724.       return NULL;
  725.     code = wmove(self->win, y, x);
  726.     break;
  727.   default:
  728.     PyErr_SetString(PyExc_TypeError, "vline requires 2 or 4 arguments");
  729.     return NULL;
  730.   }
  731.   if (code != ERR)
  732.     wvline(self->win, ch, n);
  733.   return PyCursesCheckERR(code, "wmove");
  734. }
  735.  
  736. static PyObject *
  737. PyCursesWindow_Erase(self,arg)
  738.      PyCursesWindowObject *self;
  739.      PyObject * arg;
  740. {
  741.   if (!PyArg_NoArgs(arg))
  742.       return NULL;
  743.   werase(self->win);
  744.   Py_INCREF(Py_None);
  745.   return Py_None;
  746. }
  747.  
  748. static PyObject *
  749. PyCursesWindow_DeleteLine(self,arg)
  750.      PyCursesWindowObject *self;
  751.      PyObject * arg;
  752. {
  753.   if (!PyArg_NoArgs(arg))
  754.       return NULL;
  755.   return PyCursesCheckERR(wdeleteln(self->win), "wdeleteln");
  756. }
  757.  
  758. static PyObject *
  759. PyCursesWindow_InsertLine(self,arg)
  760.      PyCursesWindowObject *self;
  761.      PyObject * arg;
  762. {
  763.   if (!PyArg_NoArgs(arg))
  764.       return NULL;
  765.   return PyCursesCheckERR(winsertln(self->win), "winsertln");
  766. }
  767.  
  768. static PyObject *
  769. PyCursesWindow_GetYX(self,arg)
  770.      PyCursesWindowObject *self;
  771.      PyObject * arg;
  772. {
  773.   int x, y;
  774.   if (!PyArg_NoArgs(arg))
  775.       return NULL;
  776.   getyx(self->win,y,x);
  777.   return Py_BuildValue("(ii)", y, x);
  778. }
  779.  
  780. static PyObject *
  781. PyCursesWindow_GetBegYX(self,arg)
  782.      PyCursesWindowObject *self;
  783.      PyObject * arg;
  784. {
  785.   int x, y;
  786.   if (!PyArg_NoArgs(arg))
  787.       return NULL;
  788.   getbegyx(self->win,y,x);
  789.   return Py_BuildValue("(ii)", y, x);
  790. }
  791.  
  792. static PyObject *
  793. PyCursesWindow_GetMaxYX(self,arg)
  794.      PyCursesWindowObject *self;
  795.      PyObject * arg;
  796. {
  797.   int x, y;
  798.   if (!PyArg_NoArgs(arg))
  799.       return NULL;
  800.   getmaxyx(self->win,y,x);
  801.   return Py_BuildValue("(ii)", y, x);
  802. }
  803.  
  804. static PyObject *
  805. PyCursesWindow_Clear(self,arg)
  806.      PyCursesWindowObject *self;
  807.      PyObject * arg;
  808. {
  809.   if (!PyArg_NoArgs(arg))
  810.       return NULL;
  811.   wclear(self->win);
  812.   Py_INCREF(Py_None);
  813.   return Py_None;
  814. }
  815.  
  816. static PyObject *
  817. PyCursesWindow_ClearToBottom(self,arg)
  818.      PyCursesWindowObject *self;
  819.      PyObject * arg;
  820. {
  821.   if (!PyArg_NoArgs(arg))
  822.       return NULL;
  823.   wclrtobot(self->win);
  824.   Py_INCREF(Py_None);
  825.   return Py_None;
  826. }
  827.  
  828. static PyObject *
  829. PyCursesWindow_ClearToEOL(self,arg)
  830.      PyCursesWindowObject *self;
  831.      PyObject * arg;
  832. {
  833.   if (!PyArg_NoArgs(arg))
  834.       return NULL;
  835.   wclrtoeol(self->win);
  836.   Py_INCREF(Py_None);
  837.   return Py_None;
  838. }
  839.  
  840. static PyObject *
  841. PyCursesWindow_Scroll(self,arg)
  842.      PyCursesWindowObject *self;
  843.      PyObject * arg;
  844. {
  845.   int nlines;
  846.   int use_nlines = FALSE;
  847.   switch (ARG_COUNT(arg)) {
  848.   case 0:
  849.     break;
  850.   case 1:
  851.     if (!PyArg_Parse(arg, "i;nlines", &nlines))
  852.       return NULL;
  853.     use_nlines = TRUE;
  854.     break;
  855.   default:
  856.     PyErr_SetString(PyExc_TypeError, "scroll requires 0 or 1 arguments");
  857.     return NULL;
  858.   }
  859.   if (use_nlines)
  860.     return PyCursesCheckERR(wscrl(self->win, nlines), "scroll");
  861.   else
  862.     return PyCursesCheckERR(scroll(self->win), "scroll");
  863. }
  864.  
  865. static PyObject *
  866. PyCursesWindow_TouchWin(self,arg)
  867.      PyCursesWindowObject *self;
  868.      PyObject * arg;
  869. {
  870.   if (!PyArg_NoArgs(arg))
  871.       return NULL;
  872.   return PyCursesCheckERR(touchwin(self->win), "touchwin");
  873. }
  874.  
  875. static PyObject *
  876. PyCursesWindow_TouchLine(self,arg)
  877.      PyCursesWindowObject *self;
  878.      PyObject * arg;
  879. {
  880.   int st, cnt;
  881.   if (!PyArg_Parse(arg,"(ii);start,count",&st,&cnt))
  882.       return NULL;
  883.   return PyCursesCheckERR(touchline(self->win,st,cnt), "touchline");
  884. }
  885.  
  886. static PyObject *
  887. PyCursesWindow_GetCh(self,arg)
  888.      PyCursesWindowObject *self;
  889.      PyObject * arg;
  890. {
  891.   int x, y;
  892.   int rtn;
  893.  
  894.   switch (ARG_COUNT(arg)) {
  895.   case 0:
  896.     rtn = wgetch(self->win);
  897.     break;
  898.   case 2:
  899.     if (!PyArg_Parse(arg,"(ii);y,x",&y,&x))
  900.       return NULL;
  901.     rtn = mvwgetch(self->win,y,x);
  902.     break;
  903.   default:
  904.     PyErr_SetString(PyExc_TypeError, "getch requires 0 or 2 arguments");
  905.     return NULL;
  906.   }
  907.  
  908.   return PyInt_FromLong((long) rtn);
  909. }
  910.  
  911. static PyObject *
  912. PyCursesWindow_GetStr(self,arg)
  913.      PyCursesWindowObject *self;
  914.      PyObject * arg;
  915. {
  916.   int x, y;
  917.   char rtn[1024]; /* This should be big enough.. I hope */
  918.   int rtn2;
  919.  
  920.   switch (ARG_COUNT(arg)) {
  921.   case 0:
  922.     rtn2 = wgetstr(self->win,rtn);
  923.     break;
  924.   case 2:
  925.     if (!PyArg_Parse(arg,"(ii);y,x",&y,&x))
  926.       return NULL;
  927.     rtn2 = mvwgetstr(self->win,y,x,rtn);
  928.     break;
  929.   default:
  930.     PyErr_SetString(PyExc_TypeError, "getstr requires 0 or 2 arguments");
  931.     return NULL;
  932.   }
  933.  
  934.   if (rtn2 == ERR)
  935.     rtn[0] = 0;
  936.   return PyString_FromString(rtn);
  937. }
  938.  
  939. static PyObject *
  940. PyCursesWindow_InCh(self,arg)
  941.      PyCursesWindowObject *self;
  942.      PyObject * arg;
  943. {
  944.   int x, y, rtn;
  945.  
  946.   switch (ARG_COUNT(arg)) {
  947.   case 0:
  948.     rtn = winch(self->win);
  949.     break;
  950.   case 2:
  951.     if (!PyArg_Parse(arg,"(ii);y,x",&y,&x))
  952.       return NULL;
  953.     rtn = mvwinch(self->win,y,x);
  954.     break;
  955.   default:
  956.     PyErr_SetString(PyExc_TypeError, "inch requires 0 or 2 arguments");
  957.     return NULL;
  958.   }
  959.  
  960.   return PyInt_FromLong((long) rtn);
  961. }
  962.  
  963. static PyObject *
  964. PyCursesWindow_ClearOk(self,arg)
  965.      PyCursesWindowObject *self;
  966.      PyObject * arg;
  967. {
  968.   int val;
  969.   if (!PyArg_Parse(arg,"i;True(1) or False(0)",&val))
  970.     return NULL;
  971.   clearok(self->win,val);
  972.   Py_INCREF(Py_None);
  973.   return Py_None;
  974. }
  975.  
  976. static PyObject *
  977. PyCursesWindow_IdlOk(self,arg)
  978.      PyCursesWindowObject *self;
  979.      PyObject * arg;
  980. {
  981.   int val;
  982.   if (!PyArg_Parse(arg,"i;True(1) or False(0)",&val))
  983.     return NULL;
  984.   idlok(self->win,val);
  985.   Py_INCREF(Py_None);
  986.   return Py_None;
  987. }
  988.  
  989. static PyObject *
  990. PyCursesWindow_LeaveOk(self,arg)
  991.      PyCursesWindowObject *self;
  992.      PyObject * arg;
  993. {
  994.   int val;
  995.   if (!PyArg_Parse(arg,"i;True(1) or False(0)",&val))
  996.     return NULL;
  997.   leaveok(self->win,val);
  998.   Py_INCREF(Py_None);
  999.   return Py_None;
  1000. }
  1001.  
  1002. static PyObject *
  1003. PyCursesWindow_ScrollOk(self,arg)
  1004.      PyCursesWindowObject *self;
  1005.      PyObject * arg;
  1006. {
  1007.   int val;
  1008.   if (!PyArg_Parse(arg,"i;True(1) or False(0)",&val))
  1009.     return NULL;
  1010.   scrollok(self->win,val);
  1011.   Py_INCREF(Py_None);
  1012.   return Py_None;
  1013. }
  1014.  
  1015. static PyObject *
  1016. PyCursesWindow_SetScrollRegion(self,arg)
  1017.      PyCursesWindowObject *self;
  1018.      PyObject * arg;
  1019. {
  1020.   int x, y;
  1021.   if (!PyArg_Parse(arg,"(ii);top, bottom",&y,&x))
  1022.     return NULL;
  1023.   return PyCursesCheckERR(wsetscrreg(self->win,y,x), "wsetscrreg");
  1024. }
  1025.  
  1026. static PyObject *
  1027. PyCursesWindow_KeyPad(self,arg)
  1028.      PyCursesWindowObject * self;
  1029.      PyObject * arg;
  1030. {
  1031.   int ch;
  1032.   if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
  1033.     return NULL;
  1034.   keypad(self->win,ch);
  1035.   Py_INCREF(Py_None);
  1036.   return Py_None;
  1037. }
  1038.  
  1039. static PyObject *
  1040. PyCursesWindow_NoDelay(self,arg)
  1041.      PyCursesWindowObject * self;
  1042.      PyObject * arg;
  1043. {
  1044.   int ch;
  1045.   if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
  1046.     return NULL;
  1047.   nodelay(self->win,ch);
  1048.   Py_INCREF(Py_None);
  1049.   return Py_None;
  1050. }
  1051.  
  1052. static PyObject *
  1053. PyCursesWindow_NoTimeout(self,arg)
  1054.      PyCursesWindowObject * self;
  1055.      PyObject * arg;
  1056. {
  1057.   int ch;
  1058.   if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
  1059.     return NULL;
  1060.   notimeout(self->win,ch);
  1061.   Py_INCREF(Py_None);
  1062.   return Py_None;
  1063. }
  1064.  
  1065. static PyMethodDef PyCursesWindow_Methods[] = {
  1066.     {"refresh",         (PyCFunction)PyCursesWindow_Refresh},
  1067.     {"nooutrefresh",    (PyCFunction)PyCursesWindow_NoOutRefresh},
  1068.     {"mvwin",           (PyCFunction)PyCursesWindow_MoveWin},
  1069.     {"move",            (PyCFunction)PyCursesWindow_Move},
  1070.     {"subwin",          (PyCFunction)PyCursesWindow_SubWin},
  1071.     {"addch",           (PyCFunction)PyCursesWindow_AddCh},
  1072.     {"insch",           (PyCFunction)PyCursesWindow_InsCh},
  1073.     {"delch",           (PyCFunction)PyCursesWindow_DelCh},
  1074.     {"echochar",        (PyCFunction)PyCursesWindow_EchoChar},
  1075.     {"addstr",          (PyCFunction)PyCursesWindow_AddStr},
  1076.     {"attron",          (PyCFunction)PyCursesWindow_AttrOn},
  1077.     {"attroff",         (PyCFunction)PyCursesWindow_AttrOff},
  1078.     {"attrset",         (PyCFunction)PyCursesWindow_AttrSet},
  1079.     {"standend",        (PyCFunction)PyCursesWindow_StandEnd},
  1080.     {"standout",        (PyCFunction)PyCursesWindow_StandOut},
  1081.     {"border",          (PyCFunction)PyCursesWindow_Border, METH_VARARGS},
  1082.     {"box",             (PyCFunction)PyCursesWindow_Box},
  1083.     {"hline",           (PyCFunction)PyCursesWindow_Hline},
  1084.     {"vline",           (PyCFunction)PyCursesWindow_Vline},
  1085.     {"erase",           (PyCFunction)PyCursesWindow_Erase},
  1086.     {"deleteln",        (PyCFunction)PyCursesWindow_DeleteLine},
  1087.     {"insertln",        (PyCFunction)PyCursesWindow_InsertLine},
  1088.     {"getyx",           (PyCFunction)PyCursesWindow_GetYX},
  1089.     {"getbegyx",        (PyCFunction)PyCursesWindow_GetBegYX},
  1090.     {"getmaxyx",        (PyCFunction)PyCursesWindow_GetMaxYX},
  1091.     {"clear",           (PyCFunction)PyCursesWindow_Clear},
  1092.     {"clrtobot",        (PyCFunction)PyCursesWindow_ClearToBottom},
  1093.     {"clrtoeol",        (PyCFunction)PyCursesWindow_ClearToEOL},
  1094.     {"scroll",          (PyCFunction)PyCursesWindow_Scroll},
  1095.     {"touchwin",        (PyCFunction)PyCursesWindow_TouchWin},
  1096.     {"touchline",       (PyCFunction)PyCursesWindow_TouchLine},
  1097.     {"getch",           (PyCFunction)PyCursesWindow_GetCh},
  1098.     {"getstr",          (PyCFunction)PyCursesWindow_GetStr},
  1099.     {"inch",            (PyCFunction)PyCursesWindow_InCh},
  1100.     {"clearok",         (PyCFunction)PyCursesWindow_ClearOk},
  1101.     {"idlok",           (PyCFunction)PyCursesWindow_IdlOk},
  1102.     {"leaveok",         (PyCFunction)PyCursesWindow_LeaveOk},
  1103.     {"scrollok",        (PyCFunction)PyCursesWindow_ScrollOk},
  1104.     {"setscrreg",       (PyCFunction)PyCursesWindow_SetScrollRegion},
  1105.     {"keypad",          (PyCFunction)PyCursesWindow_KeyPad},
  1106.     {"nodelay",         (PyCFunction)PyCursesWindow_NoDelay},
  1107.     {"notimeout",       (PyCFunction)PyCursesWindow_NoTimeout},
  1108.     {NULL,                NULL}   /* sentinel */
  1109. };
  1110.  
  1111. static PyObject *
  1112. PyCursesWindow_GetAttr(self, name)
  1113.     PyCursesWindowObject *self;
  1114.     char *name;
  1115. {
  1116.   return Py_FindMethod(PyCursesWindow_Methods, (PyObject *)self, name);
  1117. }
  1118.  
  1119.  
  1120. /* --------------- PAD routines ---------------- */
  1121.  
  1122. #ifdef NOT_YET
  1123. static PyObject *
  1124. PyCursesPad_New(pad)
  1125.     WINDOW *pad;
  1126. {
  1127.     PyCursesPadObject *po;
  1128.     po = PyObject_NEW(PyCursesPadObject, &PyCursesPad_Type);
  1129.     if (po == NULL)
  1130.         return NULL;
  1131.     po->pad = pad;
  1132.     return (PyObject *)po;
  1133. }
  1134. #endif
  1135.  
  1136.  
  1137. /* -------------------------------------------------------*/
  1138.  
  1139. #if 0
  1140. static PyTypeObject PyCursesScreen_Type = {
  1141.     PyObject_HEAD_INIT(&PyType_Type)
  1142.     0,            /*ob_size*/
  1143.     "curses screen",    /*tp_name*/
  1144.     sizeof(PyCursesScreenObject),    /*tp_basicsize*/
  1145.     0,            /*tp_itemsize*/
  1146.     /* methods */
  1147.     (destructor)0 /*PyCursesScreen_Dealloc*/, /*tp_dealloc*/
  1148.     0,            /*tp_print*/
  1149.     (getattrfunc)0, /*tp_getattr*/
  1150.     (setattrfunc)0, /*tp_setattr*/
  1151.     0,            /*tp_compare*/
  1152.     0,            /*tp_repr*/
  1153.     0,            /*tp_as_number*/
  1154.     0,            /*tp_as_sequence*/
  1155.     0,            /*tp_as_mapping*/
  1156.     0,            /*tp_hash*/
  1157. };
  1158. #endif
  1159.  
  1160. static PyTypeObject PyCursesWindow_Type = {
  1161.     PyObject_HEAD_INIT(&PyType_Type)
  1162.     0,            /*ob_size*/
  1163.     "curses window",    /*tp_name*/
  1164.     sizeof(PyCursesWindowObject),    /*tp_basicsize*/
  1165.     0,            /*tp_itemsize*/
  1166.     /* methods */
  1167.     (destructor)PyCursesWindow_Dealloc, /*tp_dealloc*/
  1168.     0,            /*tp_print*/
  1169.     (getattrfunc)PyCursesWindow_GetAttr, /*tp_getattr*/
  1170.     (setattrfunc)0, /*tp_setattr*/
  1171.     0,            /*tp_compare*/
  1172.     0,            /*tp_repr*/
  1173.     0,            /*tp_as_number*/
  1174.     0,            /*tp_as_sequence*/
  1175.     0,            /*tp_as_mapping*/
  1176.     0,            /*tp_hash*/
  1177. };
  1178.  
  1179. #if 0
  1180. static PyTypeObject PyCursesPad_Type = {
  1181.     PyObject_HEAD_INIT(&PyType_Type)
  1182.     0,            /*ob_size*/
  1183.     "curses pad",    /*tp_name*/
  1184.     sizeof(PyCursesPadObject),    /*tp_basicsize*/
  1185.     0,            /*tp_itemsize*/
  1186.     /* methods */
  1187.     (destructor)0 /*PyCursesPad_Dealloc*/, /*tp_dealloc*/
  1188.     0,            /*tp_print*/
  1189.     (getattrfunc)0, /*tp_getattr*/
  1190.     (setattrfunc)0, /*tp_setattr*/
  1191.     0,            /*tp_compare*/
  1192.     0,            /*tp_repr*/
  1193.     0,            /*tp_as_number*/
  1194.     0,            /*tp_as_sequence*/
  1195.     0,            /*tp_as_mapping*/
  1196.     0,            /*tp_hash*/
  1197. };
  1198. #endif
  1199.  
  1200.  
  1201. /* -------------------------------------------------------*/
  1202.  
  1203. static PyObject *ModDict;
  1204.  
  1205. static PyObject * 
  1206. PyCurses_InitScr(self, args)
  1207.      PyObject * self;
  1208.      PyObject * args;
  1209. {
  1210.   WINDOW *win;
  1211.   if (!PyArg_NoArgs(args))
  1212.     return NULL;
  1213.   if (initialised == TRUE) {
  1214.     wrefresh(stdscr);
  1215.     return (PyObject *)PyCursesWindow_New(stdscr);
  1216.   }
  1217.  
  1218.   win = initscr();
  1219.   if (win == NULL) {
  1220.     PyErr_SetString(PyCursesError, catchall_NULL);
  1221.     return NULL;
  1222.   }
  1223.  
  1224.   initialised = TRUE;
  1225.  
  1226. /* This was moved from initcurses() because core dumped on SGI */
  1227. /* Also, they are probably not defined until you've called initscr() */
  1228. #define SetDictInt(string,ch) \
  1229.     PyDict_SetItemString(ModDict,string,PyInt_FromLong((long) (ch)));
  1230.  
  1231.     /* Here are some graphic symbols you can use */
  1232.         SetDictInt("ACS_ULCORNER",(ACS_ULCORNER));
  1233.     SetDictInt("ACS_ULCORNER",(ACS_ULCORNER));
  1234.     SetDictInt("ACS_LLCORNER",(ACS_LLCORNER));
  1235.     SetDictInt("ACS_URCORNER",(ACS_URCORNER));
  1236.     SetDictInt("ACS_LRCORNER",(ACS_LRCORNER));
  1237.     SetDictInt("ACS_RTEE",    (ACS_RTEE));
  1238.     SetDictInt("ACS_LTEE",    (ACS_LTEE));
  1239.     SetDictInt("ACS_BTEE",    (ACS_BTEE));
  1240.     SetDictInt("ACS_TTEE",    (ACS_TTEE));
  1241.     SetDictInt("ACS_HLINE",   (ACS_HLINE));
  1242.     SetDictInt("ACS_VLINE",   (ACS_VLINE));
  1243.     SetDictInt("ACS_PLUS",    (ACS_PLUS));
  1244.     SetDictInt("ACS_S1",      (ACS_S1));
  1245.     SetDictInt("ACS_S9",      (ACS_S9));
  1246.     SetDictInt("ACS_DIAMOND", (ACS_DIAMOND));
  1247.     SetDictInt("ACS_CKBOARD", (ACS_CKBOARD));
  1248.     SetDictInt("ACS_DEGREE",  (ACS_DEGREE));
  1249.     SetDictInt("ACS_PLMINUS", (ACS_PLMINUS));
  1250.     SetDictInt("ACS_BULLET",  (ACS_BULLET));
  1251.     SetDictInt("ACS_LARROW",  (ACS_LARROW));
  1252.     SetDictInt("ACS_RARROW",  (ACS_RARROW));
  1253.     SetDictInt("ACS_DARROW",  (ACS_DARROW));
  1254.     SetDictInt("ACS_UARROW",  (ACS_UARROW));
  1255.     SetDictInt("ACS_BOARD",   (ACS_BOARD));
  1256.     SetDictInt("ACS_LANTERN", (ACS_LANTERN));
  1257.     SetDictInt("ACS_BLOCK",   (ACS_BLOCK));
  1258.  
  1259.   return (PyObject *)PyCursesWindow_New(win);
  1260. }
  1261.  
  1262. static PyObject * 
  1263. PyCurses_EndWin(self, args)
  1264.      PyObject * self;
  1265.      PyObject * args;
  1266. {
  1267.   if (!PyArg_NoArgs(args) || !PyCursesInitialised())
  1268.     return NULL;
  1269.   return PyCursesCheckERR(endwin(), "endwin");
  1270. }
  1271.  
  1272. static PyObject * 
  1273. PyCurses_IsEndWin(self, args)
  1274.      PyObject * self;
  1275.      PyObject * args;
  1276. {
  1277.   if (!PyArg_NoArgs(args))
  1278.     return NULL;
  1279.   if (isendwin() == FALSE) {
  1280.     Py_INCREF(Py_False);
  1281.     return Py_False;
  1282.   }
  1283.   Py_INCREF(Py_True);
  1284.   return Py_True;
  1285. }
  1286.  
  1287. static PyObject *
  1288. PyCurses_DoUpdate(self,arg)
  1289.      PyObject * self;
  1290.      PyObject * arg;
  1291. {
  1292.   if (!PyArg_NoArgs(arg) || !PyCursesInitialised())
  1293.     return NULL;
  1294.   return PyCursesCheckERR(doupdate(), "doupdate");
  1295. }
  1296.  
  1297. static PyObject *
  1298. PyCurses_NewWindow(self,arg)
  1299.      PyObject * self;
  1300.      PyObject * arg;
  1301. {
  1302.   WINDOW *win;
  1303.   int nlines, ncols, begin_y, begin_x;
  1304.  
  1305.   if (!PyCursesInitialised())
  1306.     return NULL;
  1307.   nlines = ncols = 0;
  1308.   switch (ARG_COUNT(arg)) {
  1309.   case 2:
  1310.     if (!PyArg_Parse(arg,"(ii);begin)_y,begin_x",&begin_y,&begin_x))
  1311.       return NULL;
  1312.     break;
  1313.   case 4:
  1314.     if (!PyArg_Parse(arg, "(iiii);nlines,ncols,begin_y,begin_x",
  1315.            &nlines,&ncols,&begin_y,&begin_x))
  1316.       return NULL;
  1317.     break;
  1318.   default:
  1319.     PyErr_SetString(PyExc_TypeError, "newwin requires 2 or 4 arguments");
  1320.     return NULL;
  1321.   }
  1322.  
  1323.   win = newwin(nlines,ncols,begin_y,begin_x);
  1324.   if (win == NULL) {
  1325.     PyErr_SetString(PyCursesError, catchall_NULL);
  1326.     return NULL;
  1327.   }
  1328.  
  1329.   return (PyObject *)PyCursesWindow_New(win);
  1330. }
  1331.  
  1332. static PyObject *
  1333. PyCurses_Beep(self,arg)
  1334.      PyObject * self;
  1335.      PyObject * arg;
  1336. {
  1337.   if (!PyArg_NoArgs(arg) || !PyCursesInitialised())
  1338.     return NULL;
  1339.   beep();
  1340.   Py_INCREF(Py_None);
  1341.   return Py_None;
  1342. }
  1343.  
  1344. static PyObject *
  1345. PyCurses_Flash(self,arg)
  1346.      PyObject * self;
  1347.      PyObject * arg;
  1348. {
  1349.   if (!PyArg_NoArgs(arg) || !PyCursesInitialised())
  1350.     return NULL;
  1351.   flash();
  1352.   Py_INCREF(Py_None);
  1353.   return Py_None;
  1354. }
  1355.  
  1356. static PyObject *
  1357. PyCurses_UngetCh(self,arg)
  1358.      PyObject * self;
  1359.      PyObject * arg;
  1360. {
  1361.   int ch;
  1362.   if (!PyArg_Parse(arg,"i;integer",&ch) || !PyCursesInitialised())
  1363.     return NULL;
  1364.   return PyCursesCheckERR(ungetch(ch), "ungetch");
  1365. }
  1366.  
  1367. static PyObject *
  1368. PyCurses_FlushInp(self,arg)
  1369.      PyObject * self;
  1370.      PyObject * arg;
  1371. {
  1372.   if (!PyArg_NoArgs(arg) || !PyCursesInitialised())
  1373.     return NULL;
  1374.   flushinp();
  1375.   Py_INCREF(Py_None);
  1376.   return Py_None;
  1377. }
  1378.  
  1379. static PyObject *
  1380. PyCurses_CBreak(self,arg)
  1381.      PyObject * self;
  1382.      PyObject * arg;
  1383. {
  1384.   if (!PyArg_NoArgs(arg) || !PyCursesInitialised())
  1385.     return NULL;
  1386.   return PyCursesCheckERR(cbreak(), "cbreak");
  1387. }
  1388.  
  1389. static PyObject *
  1390. PyCurses_NoCBreak(self,arg)
  1391.      PyObject * self;
  1392.      PyObject * arg;
  1393. {
  1394.   if (!PyArg_NoArgs(arg) || !PyCursesInitialised())
  1395.     return NULL;
  1396.   return PyCursesCheckERR(nocbreak(), "nocbreak");
  1397. }
  1398.  
  1399. static PyObject *
  1400. PyCurses_Echo(self,arg)
  1401.      PyObject * self;
  1402.      PyObject * arg;
  1403. {
  1404.   if (!PyArg_NoArgs(arg) || !PyCursesInitialised())
  1405.     return NULL;
  1406.   return PyCursesCheckERR(echo(), "echo");
  1407. }
  1408.  
  1409. static PyObject *
  1410. PyCurses_NoEcho(self,arg)
  1411.      PyObject * self;
  1412.      PyObject * arg;
  1413. {
  1414.   if (!PyArg_NoArgs(arg) || !PyCursesInitialised())
  1415.     return NULL;
  1416.   return PyCursesCheckERR(noecho(), "noecho");
  1417. }
  1418.  
  1419. static PyObject *
  1420. PyCurses_Nl(self,arg)
  1421.      PyObject * self;
  1422.      PyObject * arg;
  1423. {
  1424.   if (!PyArg_NoArgs(arg) || !PyCursesInitialised())
  1425.     return NULL;
  1426.   return PyCursesCheckERR(nl(), "nl");
  1427. }
  1428.  
  1429. static PyObject *
  1430. PyCurses_NoNl(self,arg)
  1431.      PyObject * self;
  1432.      PyObject * arg;
  1433. {
  1434.   if (!PyArg_NoArgs(arg) || !PyCursesInitialised())
  1435.     return NULL;
  1436.   return PyCursesCheckERR(nonl(), "nonl");
  1437. }
  1438.  
  1439. static PyObject *
  1440. PyCurses_Raw(self,arg)
  1441.      PyObject * self;
  1442.      PyObject * arg;
  1443. {
  1444.   if (!PyArg_NoArgs(arg) || !PyCursesInitialised())
  1445.     return NULL;
  1446.   return PyCursesCheckERR(raw(), "raw");
  1447. }
  1448.  
  1449. static PyObject *
  1450. PyCurses_NoRaw(self,arg)
  1451.      PyObject * self;
  1452.      PyObject * arg;
  1453. {
  1454.   if (!PyArg_NoArgs(arg) || !PyCursesInitialised())
  1455.     return NULL;
  1456.   return PyCursesCheckERR(noraw(), "noraw");
  1457. }
  1458.  
  1459. static PyObject *
  1460. PyCurses_IntrFlush(self,arg)
  1461.      PyObject * self;
  1462.      PyObject * arg;
  1463. {
  1464.   int ch;
  1465.   if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
  1466.     return NULL;
  1467.   return PyCursesCheckERR(intrflush(NULL,ch), "intrflush");
  1468. }
  1469.  
  1470. static PyObject *
  1471. PyCurses_Meta(self,arg)
  1472.      PyObject * self;
  1473.      PyObject * arg;
  1474. {
  1475.   int ch;
  1476.   if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch) || !PyCursesInitialised())
  1477.     return NULL;
  1478.   return PyCursesCheckERR(meta(stdscr, ch), "meta");
  1479. }
  1480.  
  1481. static PyObject *
  1482. PyCurses_KeyName(self,arg)
  1483.      PyObject * self;
  1484.      PyObject * arg;
  1485. {
  1486.   const char *knp;
  1487.   int ch;
  1488.   if (!PyArg_Parse(arg,"i",&ch))
  1489.     return NULL;
  1490.   knp = keyname(ch);
  1491.   return PyString_FromString((knp == NULL) ? "" : knp);
  1492. }
  1493.  
  1494. #ifdef NOT_YET
  1495. static PyObject * 
  1496. PyCurses_NewTerm(self, args)
  1497.      PyObject * self;
  1498.      PyObject * args;
  1499. {
  1500. }
  1501.  
  1502. static PyObject * 
  1503. PyCurses_SetTerm(self, args)
  1504.      PyObject * self;
  1505.      PyObject * args;
  1506. {
  1507. }
  1508. #endif
  1509.  
  1510. /* List of functions defined in the module */
  1511.  
  1512. static PyMethodDef PyCurses_methods[] = {
  1513.     {"initscr",             (PyCFunction)PyCurses_InitScr},
  1514.     {"endwin",              (PyCFunction)PyCurses_EndWin},
  1515.     {"isendwin",            (PyCFunction)PyCurses_IsEndWin},
  1516.     {"doupdate",            (PyCFunction)PyCurses_DoUpdate},
  1517.     {"newwin",              (PyCFunction)PyCurses_NewWindow},
  1518.     {"beep",                (PyCFunction)PyCurses_Beep},
  1519.     {"flash",               (PyCFunction)PyCurses_Flash},
  1520.     {"ungetch",             (PyCFunction)PyCurses_UngetCh},
  1521.     {"flushinp",            (PyCFunction)PyCurses_FlushInp},
  1522.     {"cbreak",              (PyCFunction)PyCurses_CBreak},
  1523.     {"nocbreak",            (PyCFunction)PyCurses_NoCBreak},
  1524.     {"echo",                (PyCFunction)PyCurses_Echo},
  1525.     {"noecho",              (PyCFunction)PyCurses_NoEcho},
  1526.     {"nl",                  (PyCFunction)PyCurses_Nl},
  1527.     {"nonl",                (PyCFunction)PyCurses_NoNl},
  1528.     {"raw",                 (PyCFunction)PyCurses_Raw},
  1529.     {"noraw",               (PyCFunction)PyCurses_NoRaw},
  1530.     {"intrflush",           (PyCFunction)PyCurses_IntrFlush},
  1531.     {"meta",                (PyCFunction)PyCurses_Meta},
  1532.     {"keyname",             (PyCFunction)PyCurses_KeyName},
  1533. #ifdef NOT_YET
  1534.     {"newterm",             (PyCFunction)PyCurses_NewTerm},
  1535.     {"set_term",            (PyCFunction)PyCurses_SetTerm},
  1536. #endif
  1537.     {NULL,        NULL}        /* sentinel */
  1538. };
  1539.  
  1540. /* Initialization function for the module */
  1541.  
  1542. DL_EXPORT(void)
  1543. initcurses()
  1544. {
  1545.     PyObject *m, *d, *v;
  1546.  
  1547.     /* Create the module and add the functions */
  1548.     m = Py_InitModule("curses", PyCurses_methods);
  1549.  
  1550.     /* Add some symbolic constants to the module */
  1551.     d = PyModule_GetDict(m);
  1552.     ModDict = d; /* For PyCurses_InitScr */
  1553.  
  1554.     /* For exception curses.error */
  1555.     PyCursesError = PyErr_NewException("curses.error", NULL, NULL);
  1556.     PyDict_SetItemString(d, "error", PyCursesError);
  1557.  
  1558.     /* Make the version available */
  1559.     v = PyString_FromString(PyCursesVersion);
  1560.     PyDict_SetItemString(d, "version", v);
  1561.     PyDict_SetItemString(d, "__version__", v);
  1562.     Py_DECREF(v);
  1563.  
  1564.     /* Here are some attributes you can add to chars to print */
  1565.     SetDictInt("A_NORMAL",        A_NORMAL);
  1566.     SetDictInt("A_STANDOUT",    A_STANDOUT);
  1567.     SetDictInt("A_UNDERLINE",    A_UNDERLINE);
  1568.     SetDictInt("A_REVERSE",        A_REVERSE);
  1569.     SetDictInt("A_BLINK",        A_BLINK);
  1570.     SetDictInt("A_DIM",        A_DIM);
  1571.     SetDictInt("A_BOLD",        A_BOLD);
  1572.     SetDictInt("A_ALTCHARSET",    A_ALTCHARSET);
  1573.  
  1574.     /* Now set everything up for KEY_ variables */
  1575.     {
  1576.       int key;
  1577.       char *key_n;
  1578.       char *key_n2;
  1579.       for (key=KEY_MIN;key < KEY_MAX; key++) {
  1580.         key_n = (char *)keyname(key);
  1581.         if (key_n == NULL || strcmp(key_n,"UNKNOWN KEY")==0)
  1582.           continue;
  1583.         if (strncmp(key_n,"KEY_F(",6)==0) {
  1584.           char *p1, *p2;
  1585.           key_n2 = malloc(strlen(key_n)+1);
  1586.           p1 = key_n;
  1587.           p2 = key_n2;
  1588.           while (*p1) {
  1589.         if (*p1 != '(' && *p1 != ')') {
  1590.           *p2 = *p1;
  1591.           p2++;
  1592.         }
  1593.         p1++;
  1594.           }
  1595.           *p2 = (char)0;
  1596.         } else
  1597.           key_n2 = key_n;
  1598.         PyDict_SetItemString(d,key_n2,PyInt_FromLong((long) key));
  1599.         if (key_n2 != key_n)
  1600.           free(key_n2);
  1601.       }
  1602.       SetDictInt("KEY_MIN", KEY_MIN);
  1603.       SetDictInt("KEY_MAX", KEY_MAX);
  1604.     }
  1605. }
  1606.