Modules/_cursesmodule.c

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