PageRenderTime 909ms CodeModel.GetById 81ms app.highlight 690ms RepoModel.GetById 74ms app.codeStats 1ms

/Modules/_cursesmodule.c

http://unladen-swallow.googlecode.com/
C | 2883 lines | 2343 code | 374 blank | 166 comment | 348 complexity | 17253a5759df49c249045e238fb1613f MD5 | raw file
   1/*
   2 *   This is a curses module for Python.
   3 *
   4 *   Based on prior work by Lance Ellinghaus and Oliver Andrich
   5 *   Version 1.2 of this module: Copyright 1994 by Lance Ellinghouse,
   6 *    Cathedral City, California Republic, United States of America.
   7 *
   8 *   Version 1.5b1, heavily extended for ncurses by Oliver Andrich:
   9 *   Copyright 1996,1997 by Oliver Andrich, Koblenz, Germany.
  10 *
  11 *   Tidied for Python 1.6, and currently maintained by <amk@amk.ca>.
  12 *
  13 *   Permission is hereby granted, free of charge, to any person obtaining
  14 *   a copy of this source file to use, copy, modify, merge, or publish it
  15 *   subject to the following conditions:
  16 *
  17 *   The above copyright notice and this permission notice shall be included
  18 *   in all copies or in any new file that contains a substantial portion of
  19 *   this file.
  20 *
  21 *   THE  AUTHOR  MAKES  NO  REPRESENTATIONS ABOUT  THE  SUITABILITY  OF
  22 *   THE  SOFTWARE FOR  ANY  PURPOSE.  IT IS  PROVIDED  "AS IS"  WITHOUT
  23 *   EXPRESS OR  IMPLIED WARRANTY.  THE AUTHOR DISCLAIMS  ALL WARRANTIES
  24 *   WITH  REGARD TO  THIS  SOFTWARE, INCLUDING  ALL IMPLIED  WARRANTIES
  25 *   OF   MERCHANTABILITY,  FITNESS   FOR  A   PARTICULAR  PURPOSE   AND
  26 *   NON-INFRINGEMENT  OF THIRD  PARTY  RIGHTS. IN  NO  EVENT SHALL  THE
  27 *   AUTHOR  BE LIABLE  TO  YOU  OR ANY  OTHER  PARTY  FOR ANY  SPECIAL,
  28 *   INDIRECT,  OR  CONSEQUENTIAL  DAMAGES  OR  ANY  DAMAGES  WHATSOEVER
  29 *   WHETHER IN AN  ACTION OF CONTRACT, NEGLIGENCE,  STRICT LIABILITY OR
  30 *   ANY OTHER  ACTION ARISING OUT OF  OR IN CONNECTION WITH  THE USE OR
  31 *   PERFORMANCE OF THIS SOFTWARE.
  32 */
  33
  34/* CVS: $Id: _cursesmodule.c 64406 2008-06-19 14:02:30Z andrew.kuchling $ */
  35
  36/*
  37
  38A number of SysV or ncurses functions don't have wrappers yet; if you
  39need a given function, add it and send a patch.  See
  40http://www.python.org/dev/patches/ for instructions on how to submit
  41patches to Python.
  42
  43Here's a list of currently unsupported functions:
  44
  45	addchnstr addchstr color_set define_key
  46	del_curterm delscreen dupwin inchnstr inchstr innstr keyok
  47	mcprint mvaddchnstr mvaddchstr mvcur mvinchnstr
  48	mvinchstr mvinnstr mmvwaddchnstr mvwaddchstr 
  49	mvwinchnstr mvwinchstr mvwinnstr newterm
  50	restartterm ripoffline scr_dump
  51	scr_init scr_restore scr_set scrl set_curterm set_term setterm
  52	tgetent tgetflag tgetnum tgetstr tgoto timeout tputs
  53	vidattr vidputs waddchnstr waddchstr
  54	wcolor_set winchnstr winchstr winnstr wmouse_trafo wscrl
  55
  56Low-priority: 
  57	slk_attr slk_attr_off slk_attr_on slk_attr_set slk_attroff
  58	slk_attron slk_attrset slk_clear slk_color slk_init slk_label
  59	slk_noutrefresh slk_refresh slk_restore slk_set slk_touch
  60
  61Menu extension (ncurses and probably SYSV):
  62	current_item free_item free_menu item_count item_description
  63	item_index item_init item_name item_opts item_opts_off
  64	item_opts_on item_term item_userptr item_value item_visible
  65	menu_back menu_driver menu_fore menu_format menu_grey
  66	menu_init menu_items menu_mark menu_opts menu_opts_off
  67	menu_opts_on menu_pad menu_pattern menu_request_by_name
  68	menu_request_name menu_spacing menu_sub menu_term menu_userptr
  69	menu_win new_item new_menu pos_menu_cursor post_menu
  70	scale_menu set_current_item set_item_init set_item_opts
  71	set_item_term set_item_userptr set_item_value set_menu_back
  72	set_menu_fore set_menu_format set_menu_grey set_menu_init
  73	set_menu_items set_menu_mark set_menu_opts set_menu_pad
  74	set_menu_pattern set_menu_spacing set_menu_sub set_menu_term
  75	set_menu_userptr set_menu_win set_top_row top_row unpost_menu
  76
  77Form extension (ncurses and probably SYSV):
  78	current_field data_ahead data_behind dup_field
  79	dynamic_fieldinfo field_arg field_back field_buffer
  80	field_count field_fore field_index field_info field_init
  81	field_just field_opts field_opts_off field_opts_on field_pad
  82	field_status field_term field_type field_userptr form_driver
  83	form_fields form_init form_opts form_opts_off form_opts_on
  84	form_page form_request_by_name form_request_name form_sub
  85	form_term form_userptr form_win free_field free_form
  86	link_field link_fieldtype move_field new_field new_form
  87	new_page pos_form_cursor post_form scale_form
  88	set_current_field set_field_back set_field_buffer
  89	set_field_fore set_field_init set_field_just set_field_opts
  90	set_field_pad set_field_status set_field_term set_field_type
  91	set_field_userptr set_fieldtype_arg set_fieldtype_choice
  92	set_form_fields set_form_init set_form_opts set_form_page
  93	set_form_sub set_form_term set_form_userptr set_form_win
  94	set_max_field set_new_page unpost_form
  95
  96
  97 */
  98
  99/* Release Number */
 100
 101char *PyCursesVersion = "2.2";
 102
 103/* Includes */
 104
 105#include "Python.h"
 106
 107#ifdef __osf__
 108#define STRICT_SYSV_CURSES      /* Don't use ncurses extensions */
 109#endif
 110
 111#ifdef __hpux
 112#define STRICT_SYSV_CURSES
 113#endif
 114
 115#define CURSES_MODULE
 116#include "py_curses.h"
 117
 118/*  These prototypes are in <term.h>, but including this header 
 119    #defines many common symbols (such as "lines") which breaks the 
 120    curses module in other ways.  So the code will just specify 
 121    explicit prototypes here. */
 122extern int setupterm(char *,int,int *);
 123#ifdef __sgi
 124#include <term.h>
 125#endif
 126
 127#if !defined(HAVE_NCURSES_H) && (defined(sgi) || defined(__sun) || defined(SCO5))
 128#define STRICT_SYSV_CURSES       /* Don't use ncurses extensions */
 129typedef chtype attr_t;           /* No attr_t type is available */
 130#endif
 131
 132#if defined(_AIX)
 133#define STRICT_SYSV_CURSES
 134#endif
 135
 136/* Definition of exception curses.error */
 137
 138static PyObject *PyCursesError;
 139
 140/* Tells whether setupterm() has been called to initialise terminfo.  */
 141static int initialised_setupterm = FALSE;
 142
 143/* Tells whether initscr() has been called to initialise curses.  */
 144static int initialised = FALSE;
 145
 146/* Tells whether start_color() has been called to initialise color usage. */
 147static int initialisedcolors = FALSE;
 148
 149/* Utility Macros */
 150#define PyCursesSetupTermCalled \
 151  if (initialised_setupterm != TRUE) { \
 152                  PyErr_SetString(PyCursesError, \
 153                                  "must call (at least) setupterm() first"); \
 154                  return 0; }
 155
 156#define PyCursesInitialised \
 157  if (initialised != TRUE) { \
 158                  PyErr_SetString(PyCursesError, \
 159                                  "must call initscr() first"); \
 160                  return 0; }
 161
 162#define PyCursesInitialisedColor \
 163  if (initialisedcolors != TRUE) { \
 164                  PyErr_SetString(PyCursesError, \
 165                                  "must call start_color() first"); \
 166                  return 0; }
 167
 168#ifndef MIN
 169#define MIN(x,y) ((x) < (y) ? (x) : (y))
 170#endif
 171
 172/* Utility Functions */
 173
 174/*
 175 * Check the return code from a curses function and return None 
 176 * or raise an exception as appropriate.  These are exported using the
 177 * CObject API. 
 178 */
 179
 180static PyObject *
 181PyCursesCheckERR(int code, char *fname)
 182{
 183  if (code != ERR) {
 184    Py_INCREF(Py_None);
 185    return Py_None;
 186  } else {
 187    if (fname == NULL) {
 188      PyErr_SetString(PyCursesError, catchall_ERR);
 189    } else {
 190      PyErr_Format(PyCursesError, "%s() returned ERR", fname);
 191    }
 192    return NULL;
 193  }
 194}
 195
 196static int 
 197PyCurses_ConvertToChtype(PyObject *obj, chtype *ch)
 198{
 199  if (PyInt_Check(obj)) {
 200    *ch = (chtype) PyInt_AsLong(obj);
 201  } else if(PyString_Check(obj) 
 202	    && (PyString_Size(obj) == 1)) {
 203    *ch = (chtype) *PyString_AsString(obj);
 204  } else {
 205    return 0;
 206  }
 207  return 1;
 208}
 209
 210/* Function versions of the 3 functions for tested whether curses has been
 211   initialised or not. */
 212   
 213static int func_PyCursesSetupTermCalled(void)
 214{
 215    PyCursesSetupTermCalled;
 216    return 1;
 217}
 218
 219static int func_PyCursesInitialised(void)
 220{
 221    PyCursesInitialised;
 222    return 1;
 223}
 224
 225static int func_PyCursesInitialisedColor(void)
 226{
 227    PyCursesInitialisedColor;
 228    return 1;
 229}
 230
 231/*****************************************************************************
 232 The Window Object
 233******************************************************************************/
 234
 235/* Definition of the window type */
 236
 237PyTypeObject PyCursesWindow_Type;
 238
 239/* Function prototype macros for Window object
 240
 241   X - function name
 242   TYPE - parameter Type
 243   ERGSTR - format string for construction of the return value
 244   PARSESTR - format string for argument parsing
 245   */
 246
 247#define Window_NoArgNoReturnFunction(X) \
 248static PyObject *PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
 249{ return PyCursesCheckERR(X(self->win), # X); }
 250
 251#define Window_NoArgTrueFalseFunction(X) \
 252static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
 253{ \
 254  if (X (self->win) == FALSE) { Py_INCREF(Py_False); return Py_False; } \
 255  else { Py_INCREF(Py_True); return Py_True; } }
 256
 257#define Window_NoArgNoReturnVoidFunction(X) \
 258static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
 259{ \
 260  X(self->win); Py_INCREF(Py_None); return Py_None; }
 261
 262#define Window_NoArg2TupleReturnFunction(X, TYPE, ERGSTR) \
 263static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
 264{ \
 265  TYPE arg1, arg2; \
 266  X(self->win,arg1,arg2); return Py_BuildValue(ERGSTR, arg1, arg2); } 
 267
 268#define Window_OneArgNoReturnVoidFunction(X, TYPE, PARSESTR) \
 269static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
 270{ \
 271  TYPE arg1; \
 272  if (!PyArg_ParseTuple(args, PARSESTR, &arg1)) return NULL; \
 273  X(self->win,arg1); Py_INCREF(Py_None); return Py_None; }
 274
 275#define Window_OneArgNoReturnFunction(X, TYPE, PARSESTR) \
 276static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
 277{ \
 278  TYPE arg1; \
 279  if (!PyArg_ParseTuple(args,PARSESTR, &arg1)) return NULL; \
 280  return PyCursesCheckERR(X(self->win, arg1), # X); }
 281
 282#define Window_TwoArgNoReturnFunction(X, TYPE, PARSESTR) \
 283static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
 284{ \
 285  TYPE arg1, arg2; \
 286  if (!PyArg_ParseTuple(args,PARSESTR, &arg1, &arg2)) return NULL; \
 287  return PyCursesCheckERR(X(self->win, arg1, arg2), # X); }
 288
 289/* ------------- WINDOW routines --------------- */
 290
 291Window_NoArgNoReturnFunction(untouchwin)
 292Window_NoArgNoReturnFunction(touchwin)
 293Window_NoArgNoReturnFunction(redrawwin)
 294Window_NoArgNoReturnFunction(winsertln)
 295Window_NoArgNoReturnFunction(werase)
 296Window_NoArgNoReturnFunction(wdeleteln)
 297
 298Window_NoArgTrueFalseFunction(is_wintouched)
 299
 300Window_NoArgNoReturnVoidFunction(wsyncup)
 301Window_NoArgNoReturnVoidFunction(wsyncdown)
 302Window_NoArgNoReturnVoidFunction(wstandend)
 303Window_NoArgNoReturnVoidFunction(wstandout)
 304Window_NoArgNoReturnVoidFunction(wcursyncup)
 305Window_NoArgNoReturnVoidFunction(wclrtoeol)
 306Window_NoArgNoReturnVoidFunction(wclrtobot)
 307Window_NoArgNoReturnVoidFunction(wclear)
 308
 309Window_OneArgNoReturnVoidFunction(idcok, int, "i;True(1) or False(0)")
 310Window_OneArgNoReturnVoidFunction(immedok, int, "i;True(1) or False(0)")
 311Window_OneArgNoReturnVoidFunction(wtimeout, int, "i;delay")
 312
 313Window_NoArg2TupleReturnFunction(getyx, int, "ii")
 314Window_NoArg2TupleReturnFunction(getbegyx, int, "ii")
 315Window_NoArg2TupleReturnFunction(getmaxyx, int, "ii")
 316Window_NoArg2TupleReturnFunction(getparyx, int, "ii")
 317
 318Window_OneArgNoReturnFunction(clearok, int, "i;True(1) or False(0)")
 319Window_OneArgNoReturnFunction(idlok, int, "i;True(1) or False(0)")
 320#if defined(__NetBSD__)
 321Window_OneArgNoReturnVoidFunction(keypad, int, "i;True(1) or False(0)")
 322#else
 323Window_OneArgNoReturnFunction(keypad, int, "i;True(1) or False(0)")
 324#endif
 325Window_OneArgNoReturnFunction(leaveok, int, "i;True(1) or False(0)")
 326#if defined(__NetBSD__)
 327Window_OneArgNoReturnVoidFunction(nodelay, int, "i;True(1) or False(0)")
 328#else
 329Window_OneArgNoReturnFunction(nodelay, int, "i;True(1) or False(0)")
 330#endif
 331Window_OneArgNoReturnFunction(notimeout, int, "i;True(1) or False(0)")
 332Window_OneArgNoReturnFunction(scrollok, int, "i;True(1) or False(0)")
 333Window_OneArgNoReturnFunction(winsdelln, int, "i;nlines")
 334Window_OneArgNoReturnFunction(syncok, int, "i;True(1) or False(0)")
 335
 336Window_TwoArgNoReturnFunction(mvwin, int, "ii;y,x")
 337Window_TwoArgNoReturnFunction(mvderwin, int, "ii;y,x")
 338Window_TwoArgNoReturnFunction(wmove, int, "ii;y,x")
 339#ifndef STRICT_SYSV_CURSES
 340Window_TwoArgNoReturnFunction(wresize, int, "ii;lines,columns")
 341#endif
 342
 343/* Allocation and deallocation of Window Objects */
 344
 345static PyObject *
 346PyCursesWindow_New(WINDOW *win)
 347{
 348	PyCursesWindowObject *wo;
 349
 350	wo = PyObject_NEW(PyCursesWindowObject, &PyCursesWindow_Type);
 351	if (wo == NULL) return NULL;
 352	wo->win = win;
 353	return (PyObject *)wo;
 354}
 355
 356static void
 357PyCursesWindow_Dealloc(PyCursesWindowObject *wo)
 358{
 359  if (wo->win != stdscr) delwin(wo->win);
 360  PyObject_DEL(wo);
 361}
 362
 363/* Addch, Addstr, Addnstr */
 364
 365static PyObject *
 366PyCursesWindow_AddCh(PyCursesWindowObject *self, PyObject *args)
 367{
 368  int rtn, x, y, use_xy = FALSE;
 369  PyObject *temp;
 370  chtype ch = 0;
 371  attr_t attr = A_NORMAL;
 372  long lattr;
 373  
 374  switch (PyTuple_Size(args)) {
 375  case 1:
 376    if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
 377	  return NULL;
 378    break;
 379  case 2:
 380    if (!PyArg_ParseTuple(args, "Ol;ch or int,attr", &temp, &lattr))
 381      return NULL;
 382    attr = lattr;
 383    break;
 384  case 3:
 385    if (!PyArg_ParseTuple(args,"iiO;y,x,ch or int", &y, &x, &temp))
 386      return NULL;
 387    use_xy = TRUE;
 388    break;
 389  case 4:
 390    if (!PyArg_ParseTuple(args,"iiOl;y,x,ch or int, attr", 
 391		     &y, &x, &temp, &lattr))
 392      return NULL;
 393    attr = lattr;
 394    use_xy = TRUE;
 395    break;
 396  default:
 397    PyErr_SetString(PyExc_TypeError, "addch requires 1 to 4 arguments");
 398    return NULL;
 399  }
 400
 401  if (!PyCurses_ConvertToChtype(temp, &ch)) {
 402    PyErr_SetString(PyExc_TypeError, "argument 1 or 3 must be a ch or an int");
 403    return NULL;
 404  }
 405  
 406  if (use_xy == TRUE)
 407    rtn = mvwaddch(self->win,y,x, ch | attr);
 408  else {
 409    rtn = waddch(self->win, ch | attr);
 410  }
 411  return PyCursesCheckERR(rtn, "addch");
 412}
 413
 414static PyObject *
 415PyCursesWindow_AddStr(PyCursesWindowObject *self, PyObject *args)
 416{
 417  int rtn;
 418  int x, y;
 419  char *str;
 420  attr_t attr = A_NORMAL , attr_old = A_NORMAL;
 421  long lattr;
 422  int use_xy = FALSE, use_attr = FALSE;
 423
 424  switch (PyTuple_Size(args)) {
 425  case 1:
 426    if (!PyArg_ParseTuple(args,"s;str", &str))
 427      return NULL;
 428    break;
 429  case 2:
 430    if (!PyArg_ParseTuple(args,"sl;str,attr", &str, &lattr))
 431      return NULL;
 432    attr = lattr;
 433    use_attr = TRUE;
 434    break;
 435  case 3:
 436    if (!PyArg_ParseTuple(args,"iis;int,int,str", &y, &x, &str))
 437      return NULL;
 438    use_xy = TRUE;
 439    break;
 440  case 4:
 441    if (!PyArg_ParseTuple(args,"iisl;int,int,str,attr", &y, &x, &str, &lattr))
 442      return NULL;
 443    attr = lattr;
 444    use_xy = use_attr = TRUE;
 445    break;
 446  default:
 447    PyErr_SetString(PyExc_TypeError, "addstr requires 1 to 4 arguments");
 448    return NULL;
 449  }
 450
 451  if (use_attr == TRUE) {
 452    attr_old = getattrs(self->win);
 453    wattrset(self->win,attr);
 454  }
 455  if (use_xy == TRUE)
 456    rtn = mvwaddstr(self->win,y,x,str);
 457  else
 458    rtn = waddstr(self->win,str);
 459  if (use_attr == TRUE)
 460    wattrset(self->win,attr_old);
 461  return PyCursesCheckERR(rtn, "addstr");
 462}
 463
 464static PyObject *
 465PyCursesWindow_AddNStr(PyCursesWindowObject *self, PyObject *args)
 466{
 467  int rtn, x, y, n;
 468  char *str;
 469  attr_t attr = A_NORMAL , attr_old = A_NORMAL;
 470  long lattr;
 471  int use_xy = FALSE, use_attr = FALSE;
 472
 473  switch (PyTuple_Size(args)) {
 474  case 2:
 475    if (!PyArg_ParseTuple(args,"si;str,n", &str, &n))
 476      return NULL;
 477    break;
 478  case 3:
 479    if (!PyArg_ParseTuple(args,"sil;str,n,attr", &str, &n, &lattr))
 480      return NULL;
 481    attr = lattr;
 482    use_attr = TRUE;
 483    break;
 484  case 4:
 485    if (!PyArg_ParseTuple(args,"iisi;y,x,str,n", &y, &x, &str, &n))
 486      return NULL;
 487    use_xy = TRUE;
 488    break;
 489  case 5:
 490    if (!PyArg_ParseTuple(args,"iisil;y,x,str,n,attr", &y, &x, &str, &n, &lattr))
 491      return NULL;
 492    attr = lattr;
 493    use_xy = use_attr = TRUE;
 494    break;
 495  default:
 496    PyErr_SetString(PyExc_TypeError, "addnstr requires 2 to 5 arguments");
 497    return NULL;
 498  }
 499
 500  if (use_attr == TRUE) {
 501    attr_old = getattrs(self->win);
 502    wattrset(self->win,attr);
 503  }
 504  if (use_xy == TRUE)
 505    rtn = mvwaddnstr(self->win,y,x,str,n);
 506  else
 507    rtn = waddnstr(self->win,str,n);
 508  if (use_attr == TRUE)
 509    wattrset(self->win,attr_old);
 510  return PyCursesCheckERR(rtn, "addnstr");
 511}
 512
 513static PyObject *
 514PyCursesWindow_Bkgd(PyCursesWindowObject *self, PyObject *args)
 515{
 516  PyObject *temp;
 517  chtype bkgd;
 518  attr_t attr = A_NORMAL;
 519  long lattr;
 520
 521  switch (PyTuple_Size(args)) {
 522    case 1:
 523      if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
 524        return NULL;
 525      break;
 526    case 2:
 527      if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &lattr))
 528        return NULL;
 529      attr = lattr;
 530      break;
 531    default:
 532      PyErr_SetString(PyExc_TypeError, "bkgd requires 1 or 2 arguments");
 533      return NULL;
 534  }
 535
 536  if (!PyCurses_ConvertToChtype(temp, &bkgd)) {
 537    PyErr_SetString(PyExc_TypeError, "argument 1 or 3 must be a ch or an int");
 538    return NULL;
 539  }
 540
 541  return PyCursesCheckERR(wbkgd(self->win, bkgd | attr), "bkgd");
 542}
 543
 544static PyObject *
 545PyCursesWindow_AttrOff(PyCursesWindowObject *self, PyObject *args)
 546{
 547  long lattr;
 548  if (!PyArg_ParseTuple(args,"l;attr", &lattr))
 549    return NULL;
 550  return PyCursesCheckERR(wattroff(self->win, (attr_t)lattr), "attroff");
 551}
 552
 553static PyObject *
 554PyCursesWindow_AttrOn(PyCursesWindowObject *self, PyObject *args)
 555{
 556  long lattr;
 557  if (!PyArg_ParseTuple(args,"l;attr", &lattr))
 558    return NULL;
 559  return PyCursesCheckERR(wattron(self->win, (attr_t)lattr), "attron");
 560}
 561
 562static PyObject *
 563PyCursesWindow_AttrSet(PyCursesWindowObject *self, PyObject *args)
 564{
 565  long lattr;
 566  if (!PyArg_ParseTuple(args,"l;attr", &lattr))
 567    return NULL;
 568  return PyCursesCheckERR(wattrset(self->win, (attr_t)lattr), "attrset");
 569}
 570
 571static PyObject *
 572PyCursesWindow_BkgdSet(PyCursesWindowObject *self, PyObject *args)
 573{
 574  PyObject *temp;
 575  chtype bkgd;
 576  attr_t attr = A_NORMAL;
 577  long lattr;
 578
 579  switch (PyTuple_Size(args)) {
 580    case 1:
 581      if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
 582        return NULL;
 583      break;
 584    case 2:
 585      if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &lattr))
 586        return NULL;
 587      attr = lattr;
 588      break;
 589    default:
 590      PyErr_SetString(PyExc_TypeError, "bkgdset requires 1 or 2 arguments");
 591      return NULL;
 592  }
 593
 594  if (!PyCurses_ConvertToChtype(temp, &bkgd)) {
 595    PyErr_SetString(PyExc_TypeError, "argument 1 must be a ch or an int");
 596    return NULL;
 597  }
 598
 599  wbkgdset(self->win, bkgd | attr);
 600  return PyCursesCheckERR(0, "bkgdset");
 601}
 602
 603static PyObject *
 604PyCursesWindow_Border(PyCursesWindowObject *self, PyObject *args)
 605{
 606  PyObject *temp[8];
 607  chtype ch[8];
 608  int i;
 609
 610  /* Clear the array of parameters */
 611  for(i=0; i<8; i++) {
 612       temp[i] = NULL;
 613       ch[i] = 0;
 614  }    
 615  
 616  if (!PyArg_ParseTuple(args,"|OOOOOOOO;ls,rs,ts,bs,tl,tr,bl,br",
 617                        &temp[0], &temp[1], &temp[2], &temp[3],
 618                        &temp[4], &temp[5], &temp[6], &temp[7]))
 619    return NULL;
 620
 621  for(i=0; i<8; i++) {
 622      if (temp[i] != NULL && !PyCurses_ConvertToChtype(temp[i], &ch[i])) {
 623          PyErr_Format(PyExc_TypeError,
 624                       "argument %i must be a ch or an int", i+1);
 625          return NULL;
 626      }
 627  }
 628  
 629  wborder(self->win,
 630          ch[0], ch[1], ch[2], ch[3],
 631          ch[4], ch[5], ch[6], ch[7]);
 632  Py_INCREF(Py_None);
 633  return Py_None;
 634}
 635
 636static PyObject *
 637PyCursesWindow_Box(PyCursesWindowObject *self, PyObject *args)
 638{
 639  chtype ch1=0,ch2=0;
 640  switch(PyTuple_Size(args)){
 641  case 0: break;
 642  default:
 643    if (!PyArg_ParseTuple(args,"ll;vertint,horint", &ch1, &ch2))
 644      return NULL;
 645  }
 646  box(self->win,ch1,ch2);
 647  Py_INCREF(Py_None);
 648  return Py_None;
 649}
 650
 651#if defined(HAVE_NCURSES_H) || defined(MVWDELCH_IS_EXPRESSION)
 652#define py_mvwdelch mvwdelch
 653#else
 654int py_mvwdelch(WINDOW *w, int y, int x)
 655{
 656  mvwdelch(w,y,x);
 657  /* On HP/UX, mvwdelch already returns. On other systems,
 658     we may well run into this return statement. */
 659  return 0;
 660}
 661#endif
 662
 663/* chgat, added by Fabian Kreutz <fabian.kreutz at gmx.net> */
 664
 665static PyObject *
 666PyCursesWindow_ChgAt(PyCursesWindowObject *self, PyObject *args)
 667{
 668  int rtn;
 669  int x, y;
 670  int num = -1;
 671  short color;
 672  attr_t attr = A_NORMAL;
 673  long lattr;
 674  int use_xy = FALSE;
 675
 676  switch (PyTuple_Size(args)) {
 677  case 1:
 678    if (!PyArg_ParseTuple(args,"l;attr", &lattr))
 679      return NULL;
 680    attr = lattr;
 681    break;
 682  case 2:
 683    if (!PyArg_ParseTuple(args,"il;n,attr", &num, &lattr))
 684      return NULL;
 685    attr = lattr;
 686    break;
 687  case 3:
 688    if (!PyArg_ParseTuple(args,"iil;int,int,attr", &y, &x, &lattr))
 689      return NULL;
 690    attr = lattr;
 691    use_xy = TRUE;
 692    break;
 693  case 4:
 694    if (!PyArg_ParseTuple(args,"iiil;int,int,n,attr", &y, &x, &num, &lattr))
 695      return NULL;
 696    attr = lattr;
 697    use_xy = TRUE;
 698    break;
 699  default:
 700    PyErr_SetString(PyExc_TypeError, "chgat requires 1 to 4 arguments");
 701    return NULL;
 702  }
 703
 704  color = (short)((attr >> 8) & 0xff);
 705  attr = attr - (color << 8);
 706
 707  if (use_xy == TRUE) {
 708    rtn = mvwchgat(self->win,y,x,num,attr,color,NULL);
 709    touchline(self->win,y,1);
 710  } else {
 711    getyx(self->win,y,x);
 712    rtn = wchgat(self->win,num,attr,color,NULL);
 713    touchline(self->win,y,1);
 714  }
 715  return PyCursesCheckERR(rtn, "chgat");
 716}
 717
 718
 719static PyObject *
 720PyCursesWindow_DelCh(PyCursesWindowObject *self, PyObject *args)
 721{
 722  int rtn;
 723  int x, y;
 724
 725  switch (PyTuple_Size(args)) {
 726  case 0:
 727    rtn = wdelch(self->win);
 728    break;
 729  case 2:
 730    if (!PyArg_ParseTuple(args,"ii;y,x", &y, &x))
 731      return NULL;
 732    rtn = py_mvwdelch(self->win,y,x);
 733    break;
 734  default:
 735    PyErr_SetString(PyExc_TypeError, "delch requires 0 or 2 arguments");
 736    return NULL;
 737  }
 738  return PyCursesCheckERR(rtn, "[mv]wdelch");
 739}
 740
 741static PyObject *
 742PyCursesWindow_DerWin(PyCursesWindowObject *self, PyObject *args)
 743{
 744  WINDOW *win;
 745  int nlines, ncols, begin_y, begin_x;
 746
 747  nlines = 0;
 748  ncols  = 0;
 749  switch (PyTuple_Size(args)) {
 750  case 2:
 751    if (!PyArg_ParseTuple(args,"ii;begin_y,begin_x",&begin_y,&begin_x))
 752      return NULL;
 753    break;
 754  case 4:
 755    if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
 756		   &nlines,&ncols,&begin_y,&begin_x))
 757      return NULL;
 758    break;
 759  default:
 760    PyErr_SetString(PyExc_TypeError, "derwin requires 2 or 4 arguments");
 761    return NULL;
 762  }
 763
 764  win = derwin(self->win,nlines,ncols,begin_y,begin_x);
 765
 766  if (win == NULL) {
 767    PyErr_SetString(PyCursesError, catchall_NULL);
 768    return NULL;
 769  }
 770
 771  return (PyObject *)PyCursesWindow_New(win);
 772}
 773
 774static PyObject *
 775PyCursesWindow_EchoChar(PyCursesWindowObject *self, PyObject *args)
 776{
 777  PyObject *temp;
 778  chtype ch;
 779  attr_t attr = A_NORMAL;
 780  long lattr;
 781
 782  switch (PyTuple_Size(args)) {
 783  case 1:
 784    if (!PyArg_ParseTuple(args,"O;ch or int", &temp))
 785      return NULL;
 786    break;
 787  case 2:
 788    if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &lattr))
 789      return NULL;
 790    attr = lattr;
 791    break;
 792  default:
 793    PyErr_SetString(PyExc_TypeError, "echochar requires 1 or 2 arguments");
 794
 795
 796    return NULL;
 797  }
 798
 799  if (!PyCurses_ConvertToChtype(temp, &ch)) {
 800    PyErr_SetString(PyExc_TypeError, "argument 1 must be a ch or an int");
 801    return NULL;
 802  }
 803  
 804#ifdef WINDOW_HAS_FLAGS
 805  if (self->win->_flags & _ISPAD)
 806    return PyCursesCheckERR(pechochar(self->win, ch | attr), 
 807			    "echochar");
 808  else
 809#endif
 810    return PyCursesCheckERR(wechochar(self->win, ch | attr), 
 811			    "echochar");
 812}
 813
 814#ifdef NCURSES_MOUSE_VERSION
 815static PyObject *
 816PyCursesWindow_Enclose(PyCursesWindowObject *self, PyObject *args)
 817{
 818	int x, y;
 819	if (!PyArg_ParseTuple(args,"ii;y,x", &y, &x))
 820		return NULL;
 821
 822	return PyInt_FromLong( wenclose(self->win,y,x) );
 823}
 824#endif
 825
 826static PyObject *
 827PyCursesWindow_GetBkgd(PyCursesWindowObject *self)
 828{
 829  return PyInt_FromLong((long) getbkgd(self->win));
 830}
 831
 832static PyObject *
 833PyCursesWindow_GetCh(PyCursesWindowObject *self, PyObject *args)
 834{
 835  int x, y;
 836  int rtn;
 837
 838  switch (PyTuple_Size(args)) {
 839  case 0:
 840    Py_BEGIN_ALLOW_THREADS
 841    rtn = wgetch(self->win);
 842    Py_END_ALLOW_THREADS
 843    break;
 844  case 2:
 845    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
 846      return NULL;
 847    Py_BEGIN_ALLOW_THREADS
 848    rtn = mvwgetch(self->win,y,x);
 849    Py_END_ALLOW_THREADS
 850    break;
 851  default:
 852    PyErr_SetString(PyExc_TypeError, "getch requires 0 or 2 arguments");
 853    return NULL;
 854  }
 855  return PyInt_FromLong((long)rtn);
 856}
 857
 858static PyObject *
 859PyCursesWindow_GetKey(PyCursesWindowObject *self, PyObject *args)
 860{
 861  int x, y;
 862  int rtn;
 863
 864  switch (PyTuple_Size(args)) {
 865  case 0:
 866    Py_BEGIN_ALLOW_THREADS
 867    rtn = wgetch(self->win);
 868    Py_END_ALLOW_THREADS
 869    break;
 870  case 2:
 871    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
 872      return NULL;
 873    Py_BEGIN_ALLOW_THREADS
 874    rtn = mvwgetch(self->win,y,x);
 875    Py_END_ALLOW_THREADS
 876    break;
 877  default:
 878    PyErr_SetString(PyExc_TypeError, "getkey requires 0 or 2 arguments");
 879    return NULL;
 880  }
 881  if (rtn == ERR) {
 882    /* getch() returns ERR in nodelay mode */
 883    PyErr_SetString(PyCursesError, "no input");
 884    return NULL;
 885  } else if (rtn<=255)
 886    return Py_BuildValue("c", rtn);
 887  else
 888#if defined(__NetBSD__)
 889    return PyString_FromString(unctrl(rtn));
 890#else
 891    return PyString_FromString((char *)keyname(rtn));
 892#endif
 893}
 894
 895static PyObject *
 896PyCursesWindow_GetStr(PyCursesWindowObject *self, PyObject *args)
 897{
 898  int x, y, n;
 899  char rtn[1024]; /* This should be big enough.. I hope */
 900  int rtn2;
 901
 902  switch (PyTuple_Size(args)) {
 903  case 0:
 904    Py_BEGIN_ALLOW_THREADS
 905    rtn2 = wgetnstr(self->win,rtn, 1023);
 906    Py_END_ALLOW_THREADS
 907    break;
 908  case 1:
 909    if (!PyArg_ParseTuple(args,"i;n", &n))
 910      return NULL;
 911    Py_BEGIN_ALLOW_THREADS
 912    rtn2 = wgetnstr(self->win,rtn,MIN(n, 1023));
 913    Py_END_ALLOW_THREADS
 914    break;
 915  case 2:
 916    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
 917      return NULL;
 918    Py_BEGIN_ALLOW_THREADS
 919#ifdef STRICT_SYSV_CURSES
 920    rtn2 = wmove(self->win,y,x)==ERR ? ERR : wgetnstr(self->win, rtn, 1023);
 921#else
 922    rtn2 = mvwgetnstr(self->win,y,x,rtn, 1023);
 923#endif
 924    Py_END_ALLOW_THREADS
 925    break;
 926  case 3:
 927    if (!PyArg_ParseTuple(args,"iii;y,x,n", &y, &x, &n))
 928      return NULL;
 929#ifdef STRICT_SYSV_CURSES
 930    Py_BEGIN_ALLOW_THREADS
 931    rtn2 = wmove(self->win,y,x)==ERR ? ERR :
 932      wgetnstr(self->win, rtn, MIN(n, 1023));
 933    Py_END_ALLOW_THREADS
 934#else
 935    Py_BEGIN_ALLOW_THREADS
 936    rtn2 = mvwgetnstr(self->win, y, x, rtn, MIN(n, 1023));
 937    Py_END_ALLOW_THREADS
 938#endif
 939    break;
 940  default:
 941    PyErr_SetString(PyExc_TypeError, "getstr requires 0 to 3 arguments");
 942    return NULL;
 943  }
 944  if (rtn2 == ERR)
 945    rtn[0] = 0;
 946  return PyString_FromString(rtn);
 947}
 948
 949static PyObject *
 950PyCursesWindow_Hline(PyCursesWindowObject *self, PyObject *args)
 951{
 952  PyObject *temp;
 953  chtype ch;
 954  int n, x, y, code = OK;
 955  attr_t attr = A_NORMAL;
 956  long lattr;
 957
 958  switch (PyTuple_Size(args)) {
 959  case 2:
 960    if (!PyArg_ParseTuple(args, "Oi;ch or int,n", &temp, &n))
 961      return NULL;
 962    break;
 963  case 3:
 964    if (!PyArg_ParseTuple(args, "Oil;ch or int,n,attr", &temp, &n, &lattr))
 965      return NULL;
 966    attr = lattr;
 967    break;
 968  case 4:
 969    if (!PyArg_ParseTuple(args, "iiOi;y,x,ch or int,n", &y, &x, &temp, &n))
 970      return NULL;
 971    code = wmove(self->win, y, x);
 972    break;
 973  case 5:
 974    if (!PyArg_ParseTuple(args, "iiOil; y,x,ch or int,n,attr", 
 975		     &y, &x, &temp, &n, &lattr))
 976      return NULL;
 977    attr = lattr;
 978    code = wmove(self->win, y, x);
 979    break;
 980  default:
 981    PyErr_SetString(PyExc_TypeError, "hline requires 2 to 5 arguments");
 982    return NULL;
 983  }
 984
 985  if (code != ERR) {
 986    if (!PyCurses_ConvertToChtype(temp, &ch)) {
 987      PyErr_SetString(PyExc_TypeError, 
 988		      "argument 1 or 3 must be a ch or an int");
 989      return NULL;
 990    }
 991    return PyCursesCheckERR(whline(self->win, ch | attr, n), "hline");
 992  } else 
 993    return PyCursesCheckERR(code, "wmove");
 994}
 995
 996static PyObject *
 997PyCursesWindow_InsCh(PyCursesWindowObject *self, PyObject *args)
 998{
 999  int rtn, x, y, use_xy = FALSE;
1000  PyObject *temp;
1001  chtype ch = 0;
1002  attr_t attr = A_NORMAL;
1003  long lattr;
1004  
1005  switch (PyTuple_Size(args)) {
1006  case 1:
1007    if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
1008      return NULL;
1009    break;
1010  case 2:
1011    if (!PyArg_ParseTuple(args, "Ol;ch or int,attr", &temp, &lattr))
1012      return NULL;
1013    attr = lattr;
1014    break;
1015  case 3:
1016    if (!PyArg_ParseTuple(args,"iiO;y,x,ch or int", &y, &x, &temp))
1017      return NULL;
1018    use_xy = TRUE;
1019    break;
1020  case 4:
1021    if (!PyArg_ParseTuple(args,"iiOl;y,x,ch or int, attr", &y, &x, &temp, &lattr))
1022      return NULL;
1023    attr = lattr;
1024    use_xy = TRUE;
1025    break;
1026  default:
1027    PyErr_SetString(PyExc_TypeError, "insch requires 1 or 4 arguments");
1028    return NULL;
1029  }
1030
1031  if (!PyCurses_ConvertToChtype(temp, &ch)) {
1032    PyErr_SetString(PyExc_TypeError, 
1033		    "argument 1 or 3 must be a ch or an int");
1034    return NULL;
1035  }
1036  
1037  if (use_xy == TRUE)
1038    rtn = mvwinsch(self->win,y,x, ch | attr);
1039  else {
1040    rtn = winsch(self->win, ch | attr);
1041  }
1042  return PyCursesCheckERR(rtn, "insch");
1043}
1044
1045static PyObject *
1046PyCursesWindow_InCh(PyCursesWindowObject *self, PyObject *args)
1047{
1048  int x, y, rtn;
1049
1050  switch (PyTuple_Size(args)) {
1051  case 0:
1052    rtn = winch(self->win);
1053    break;
1054  case 2:
1055    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
1056      return NULL;
1057    rtn = mvwinch(self->win,y,x);
1058    break;
1059  default:
1060    PyErr_SetString(PyExc_TypeError, "inch requires 0 or 2 arguments");
1061    return NULL;
1062  }
1063  return PyInt_FromLong((long) rtn);
1064}
1065
1066static PyObject *
1067PyCursesWindow_InStr(PyCursesWindowObject *self, PyObject *args)
1068{
1069  int x, y, n;
1070  char rtn[1024]; /* This should be big enough.. I hope */
1071  int rtn2;
1072
1073  switch (PyTuple_Size(args)) {
1074  case 0:
1075    rtn2 = winnstr(self->win,rtn, 1023);
1076    break;
1077  case 1:
1078    if (!PyArg_ParseTuple(args,"i;n", &n))
1079      return NULL;
1080    rtn2 = winnstr(self->win,rtn,MIN(n,1023));
1081    break;
1082  case 2:
1083    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
1084      return NULL;
1085    rtn2 = mvwinnstr(self->win,y,x,rtn,1023);
1086    break;
1087  case 3:
1088    if (!PyArg_ParseTuple(args, "iii;y,x,n", &y, &x, &n))
1089      return NULL;
1090    rtn2 = mvwinnstr(self->win, y, x, rtn, MIN(n,1023));
1091    break;
1092  default:
1093    PyErr_SetString(PyExc_TypeError, "instr requires 0 or 3 arguments");
1094    return NULL;
1095  }
1096  if (rtn2 == ERR)
1097    rtn[0] = 0;
1098  return PyString_FromString(rtn);
1099}
1100
1101static PyObject *
1102PyCursesWindow_InsStr(PyCursesWindowObject *self, PyObject *args)
1103{
1104  int rtn;
1105  int x, y;
1106  char *str;
1107  attr_t attr = A_NORMAL , attr_old = A_NORMAL;
1108  long lattr;
1109  int use_xy = FALSE, use_attr = FALSE;
1110
1111  switch (PyTuple_Size(args)) {
1112  case 1:
1113    if (!PyArg_ParseTuple(args,"s;str", &str))
1114      return NULL;
1115    break;
1116  case 2:
1117    if (!PyArg_ParseTuple(args,"sl;str,attr", &str, &lattr))
1118      return NULL;
1119    attr = lattr;
1120    use_attr = TRUE;
1121    break;
1122  case 3:
1123    if (!PyArg_ParseTuple(args,"iis;y,x,str", &y, &x, &str))
1124      return NULL;
1125    use_xy = TRUE;
1126    break;
1127  case 4:
1128    if (!PyArg_ParseTuple(args,"iisl;y,x,str,attr", &y, &x, &str, &lattr))
1129      return NULL;
1130    attr = lattr;
1131    use_xy = use_attr = TRUE;
1132    break;
1133  default:
1134    PyErr_SetString(PyExc_TypeError, "insstr requires 1 to 4 arguments");
1135    return NULL;
1136  }
1137
1138  if (use_attr == TRUE) {
1139    attr_old = getattrs(self->win);
1140    wattrset(self->win,attr);
1141  }
1142  if (use_xy == TRUE)
1143    rtn = mvwinsstr(self->win,y,x,str);
1144  else
1145    rtn = winsstr(self->win,str);
1146  if (use_attr == TRUE)
1147    wattrset(self->win,attr_old);
1148  return PyCursesCheckERR(rtn, "insstr");
1149}
1150
1151static PyObject *
1152PyCursesWindow_InsNStr(PyCursesWindowObject *self, PyObject *args)
1153{
1154  int rtn, x, y, n;
1155  char *str;
1156  attr_t attr = A_NORMAL , attr_old = A_NORMAL;
1157  long lattr;
1158  int use_xy = FALSE, use_attr = FALSE;
1159
1160  switch (PyTuple_Size(args)) {
1161  case 2:
1162    if (!PyArg_ParseTuple(args,"si;str,n", &str, &n))
1163      return NULL;
1164    break;
1165  case 3:
1166    if (!PyArg_ParseTuple(args,"sil;str,n,attr", &str, &n, &lattr))
1167      return NULL;
1168    attr = lattr;
1169    use_attr = TRUE;
1170    break;
1171  case 4:
1172    if (!PyArg_ParseTuple(args,"iisi;y,x,str,n", &y, &x, &str, &n))
1173      return NULL;
1174    use_xy = TRUE;
1175    break;
1176  case 5:
1177    if (!PyArg_ParseTuple(args,"iisil;y,x,str,n,attr", &y, &x, &str, &n, &lattr))
1178      return NULL;
1179    attr = lattr;
1180    use_xy = use_attr = TRUE;
1181    break;
1182  default:
1183    PyErr_SetString(PyExc_TypeError, "insnstr requires 2 to 5 arguments");
1184    return NULL;
1185  }
1186
1187  if (use_attr == TRUE) {
1188    attr_old = getattrs(self->win);
1189    wattrset(self->win,attr);
1190  }
1191  if (use_xy == TRUE)
1192    rtn = mvwinsnstr(self->win,y,x,str,n);
1193  else
1194    rtn = winsnstr(self->win,str,n);
1195  if (use_attr == TRUE)
1196    wattrset(self->win,attr_old);
1197  return PyCursesCheckERR(rtn, "insnstr");
1198}
1199
1200static PyObject *
1201PyCursesWindow_Is_LineTouched(PyCursesWindowObject *self, PyObject *args)
1202{
1203  int line, erg;
1204  if (!PyArg_ParseTuple(args,"i;line", &line))
1205    return NULL;
1206  erg = is_linetouched(self->win, line);
1207  if (erg == ERR) {
1208    PyErr_SetString(PyExc_TypeError, 
1209		    "is_linetouched: line number outside of boundaries");
1210    return NULL;
1211  } else 
1212    if (erg == FALSE) {
1213      Py_INCREF(Py_False);
1214      return Py_False;
1215    } else {
1216      Py_INCREF(Py_True);
1217      return Py_True;
1218    }
1219}
1220
1221static PyObject *
1222PyCursesWindow_NoOutRefresh(PyCursesWindowObject *self, PyObject *args)
1223{
1224  int pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol;
1225  int rtn;
1226
1227#ifndef WINDOW_HAS_FLAGS
1228  if (0) {
1229#else
1230  if (self->win->_flags & _ISPAD) {
1231#endif
1232    switch(PyTuple_Size(args)) {
1233    case 6:
1234      if (!PyArg_ParseTuple(args, 
1235		       "iiiiii;" \
1236		       "pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol", 
1237		       &pminrow, &pmincol, &sminrow, 
1238		       &smincol, &smaxrow, &smaxcol))
1239	return NULL;
1240      Py_BEGIN_ALLOW_THREADS
1241      rtn = pnoutrefresh(self->win,
1242			 pminrow, pmincol, sminrow, 
1243			 smincol, smaxrow, smaxcol);
1244      Py_END_ALLOW_THREADS
1245      return PyCursesCheckERR(rtn, "pnoutrefresh");
1246    default:
1247      PyErr_SetString(PyCursesError, 
1248		      "noutrefresh() called for a pad " 
1249		      "requires 6 arguments");
1250      return NULL;
1251    }
1252  } else {
1253    if (!PyArg_ParseTuple(args, ":noutrefresh"))
1254      return NULL;    
1255
1256    Py_BEGIN_ALLOW_THREADS
1257    rtn = wnoutrefresh(self->win);
1258    Py_END_ALLOW_THREADS
1259    return PyCursesCheckERR(rtn, "wnoutrefresh");
1260  }
1261}
1262
1263static PyObject *
1264PyCursesWindow_Overlay(PyCursesWindowObject *self, PyObject *args)
1265{
1266    PyCursesWindowObject *temp;
1267    int use_copywin = FALSE;
1268    int sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol;
1269    int rtn;
1270    
1271    switch (PyTuple_Size(args)) {
1272    case 1:
1273	if (!PyArg_ParseTuple(args, "O!;window object",
1274			      &PyCursesWindow_Type, &temp))
1275	    return NULL;
1276	break;
1277    case 7:
1278	if (!PyArg_ParseTuple(args, "O!iiiiii;window object, int, int, int, int, int, int",
1279			      &PyCursesWindow_Type, &temp, &sminrow, &smincol,
1280			      &dminrow, &dmincol, &dmaxrow, &dmaxcol))
1281	    return NULL;
1282	use_copywin = TRUE;
1283	break;
1284    default:
1285	PyErr_SetString(PyExc_TypeError,
1286			"overlay requires one or seven arguments");
1287	return NULL;
1288    }
1289
1290    if (use_copywin == TRUE) {
1291	    rtn = copywin(self->win, temp->win, sminrow, smincol,
1292			  dminrow, dmincol, dmaxrow, dmaxcol, TRUE);
1293	    return PyCursesCheckERR(rtn, "copywin");
1294    }
1295    else {
1296	    rtn = overlay(self->win, temp->win);
1297	    return PyCursesCheckERR(rtn, "overlay");
1298    }
1299}
1300
1301static PyObject *
1302PyCursesWindow_Overwrite(PyCursesWindowObject *self, PyObject *args)
1303{
1304    PyCursesWindowObject *temp;
1305    int use_copywin = FALSE;
1306    int sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol;
1307    int rtn;
1308    
1309    switch (PyTuple_Size(args)) {
1310    case 1:
1311	if (!PyArg_ParseTuple(args, "O!;window object",
1312			      &PyCursesWindow_Type, &temp))
1313	    return NULL;
1314	break;
1315    case 7:
1316	if (!PyArg_ParseTuple(args, "O!iiiiii;window object, int, int, int, int, int, int",
1317			      &PyCursesWindow_Type, &temp, &sminrow, &smincol,
1318			      &dminrow, &dmincol, &dmaxrow, &dmaxcol))
1319	    return NULL;
1320	use_copywin = TRUE;
1321	break;
1322    default:
1323	PyErr_SetString(PyExc_TypeError,
1324			"overwrite requires one or seven arguments");
1325	return NULL;
1326    }
1327
1328    if (use_copywin == TRUE) {
1329	rtn = copywin(self->win, temp->win, sminrow, smincol,
1330		      dminrow, dmincol, dmaxrow, dmaxcol, FALSE);
1331        return PyCursesCheckERR(rtn, "copywin");
1332    }
1333    else {
1334	    rtn = overwrite(self->win, temp->win);
1335	    return PyCursesCheckERR(rtn, "overwrite");
1336    }
1337}
1338
1339static PyObject *
1340PyCursesWindow_PutWin(PyCursesWindowObject *self, PyObject *args)
1341{
1342  PyObject *temp;
1343  
1344  if (!PyArg_ParseTuple(args, "O;fileobj", &temp))
1345    return NULL;
1346  if (!PyFile_Check(temp)) {
1347    PyErr_SetString(PyExc_TypeError, "argument must be a file object");
1348    return NULL;
1349  }
1350  return PyCursesCheckERR(putwin(self->win, PyFile_AsFile(temp)), 
1351			  "putwin");
1352}
1353
1354static PyObject *
1355PyCursesWindow_RedrawLine(PyCursesWindowObject *self, PyObject *args)
1356{
1357  int beg, num;
1358  if (!PyArg_ParseTuple(args, "ii;beg,num", &beg, &num))
1359    return NULL;
1360  return PyCursesCheckERR(wredrawln(self->win,beg,num), "redrawln");
1361}
1362
1363static PyObject *
1364PyCursesWindow_Refresh(PyCursesWindowObject *self, PyObject *args)
1365{
1366  int pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol;
1367  int rtn;
1368  
1369#ifndef WINDOW_HAS_FLAGS
1370  if (0) {
1371#else
1372  if (self->win->_flags & _ISPAD) {
1373#endif
1374    switch(PyTuple_Size(args)) {
1375    case 6:
1376      if (!PyArg_ParseTuple(args, 
1377		       "iiiiii;" \
1378		       "pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol", 
1379		       &pminrow, &pmincol, &sminrow, 
1380		       &smincol, &smaxrow, &smaxcol))
1381	return NULL;
1382
1383      Py_BEGIN_ALLOW_THREADS
1384      rtn = prefresh(self->win,
1385		     pminrow, pmincol, sminrow, 
1386		     smincol, smaxrow, smaxcol);
1387      Py_END_ALLOW_THREADS
1388      return PyCursesCheckERR(rtn, "prefresh");
1389    default:
1390      PyErr_SetString(PyCursesError, 
1391		      "refresh() for a pad requires 6 arguments");
1392      return NULL;
1393    }
1394  } else {
1395    if (!PyArg_ParseTuple(args, ":refresh"))
1396      return NULL;    
1397    Py_BEGIN_ALLOW_THREADS
1398    rtn = wrefresh(self->win);
1399    Py_END_ALLOW_THREADS
1400    return PyCursesCheckERR(rtn, "prefresh");    
1401  }
1402}
1403
1404static PyObject *
1405PyCursesWindow_SetScrollRegion(PyCursesWindowObject *self, PyObject *args)
1406{
1407  int x, y;
1408  if (!PyArg_ParseTuple(args,"ii;top, bottom",&y,&x))
1409    return NULL;
1410  return PyCursesCheckERR(wsetscrreg(self->win,y,x), "wsetscrreg");
1411}
1412
1413static PyObject *
1414PyCursesWindow_SubWin(PyCursesWindowObject *self, PyObject *args)
1415{
1416  WINDOW *win;
1417  int nlines, ncols, begin_y, begin_x;
1418
1419  nlines = 0;
1420  ncols  = 0;
1421  switch (PyTuple_Size(args)) {
1422  case 2:
1423    if (!PyArg_ParseTuple(args,"ii;begin_y,begin_x",&begin_y,&begin_x))
1424      return NULL;
1425    break;
1426  case 4:
1427    if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
1428		   &nlines,&ncols,&begin_y,&begin_x))
1429      return NULL;
1430    break;
1431  default:
1432    PyErr_SetString(PyExc_TypeError, "subwin requires 2 or 4 arguments");
1433    return NULL;
1434  }
1435
1436  /* printf("Subwin: %i %i %i %i   \n", nlines, ncols, begin_y, begin_x); */
1437#ifdef WINDOW_HAS_FLAGS
1438  if (self->win->_flags & _ISPAD)
1439    win = subpad(self->win, nlines, ncols, begin_y, begin_x);
1440  else
1441#endif
1442    win = subwin(self->win, nlines, ncols, begin_y, begin_x);
1443
1444  if (win == NULL) {
1445    PyErr_SetString(PyCursesError, catchall_NULL);
1446    return NULL;
1447  }
1448  
1449  return (PyObject *)PyCursesWindow_New(win);
1450}
1451
1452static PyObject *
1453PyCursesWindow_Scroll(PyCursesWindowObject *self, PyObject *args)
1454{
1455  int nlines;
1456  switch(PyTuple_Size(args)) {
1457  case 0:
1458    return PyCursesCheckERR(scroll(self->win), "scroll");
1459  case 1:
1460    if (!PyArg_ParseTuple(args, "i;nlines", &nlines))
1461      return NULL;
1462    return PyCursesCheckERR(wscrl(self->win, nlines), "scroll");
1463  default:
1464    PyErr_SetString(PyExc_TypeError, "scroll requires 0 or 1 arguments");
1465    return NULL;
1466  }
1467}
1468
1469static PyObject *
1470PyCursesWindow_TouchLine(PyCursesWindowObject *self, PyObject *args)
1471{
1472  int st, cnt, val;
1473  switch (PyTuple_Size(args)) {
1474  case 2:
1475    if (!PyArg_ParseTuple(args,"ii;start,count",&st,&cnt))
1476      return NULL;
1477    return PyCursesCheckERR(touchline(self->win,st,cnt), "touchline");
1478  case 3:
1479    if (!PyArg_ParseTuple(args, "iii;start,count,val", &st, &cnt, &val))
1480      return NULL;
1481    return PyCursesCheckERR(wtouchln(self->win, st, cnt, val), "touchline");
1482  default:
1483    PyErr_SetString(PyExc_TypeError, "touchline requires 2 or 3 arguments");
1484    return NULL;
1485  }
1486}
1487
1488static PyObject *
1489PyCursesWindow_Vline(PyCursesWindowObject *self, PyObject *args)
1490{
1491  PyObject *temp;
1492  chtype ch;
1493  int n, x, y, code = OK;
1494  attr_t attr = A_NORMAL;
1495  long lattr;
1496
1497  switch (PyTuple_Size(args)) {
1498  case 2:
1499    if (!PyArg_ParseTuple(args, "Oi;ch or int,n", &temp, &n))
1500      return NULL;
1501    break;
1502  case 3:
1503    if (!PyArg_ParseTuple(args, "Oil;ch or int,n,attr", &temp, &n, &lattr))
1504      return NULL;
1505    attr = lattr;
1506    break;
1507  case 4:
1508    if (!PyArg_ParseTuple(args, "iiOi;y,x,ch or int,n", &y, &x, &temp, &n))
1509      return NULL;
1510    code = wmove(self->win, y, x);
1511    break;
1512  case 5:
1513    if (!PyArg_ParseTuple(args, "iiOil; y,x,ch or int,n,attr", 
1514		     &y, &x, &temp, &n, &lattr))
1515      return NULL;
1516    attr = lattr;
1517    code = wmove(self->win, y, x);
1518    break;
1519  default:
1520    PyErr_SetString(PyExc_TypeError, "vline requires 2 to 5 arguments");
1521    return NULL;
1522  }
1523
1524  if (code != ERR) {
1525    if (!PyCurses_ConvertToChtype(temp, &ch)) {
1526      PyErr_SetString(PyExc_TypeError, 
1527		      "argument 1 or 3 must be a ch or an int");
1528      return NULL;
1529    }
1530    return PyCursesCheckERR(wvline(self->win, ch | attr, n), "vline");
1531  } else
1532    return PyCursesCheckERR(code, "wmove");
1533}
1534
1535static PyMethodDef PyCursesWindow_Methods[] = {
1536	{"addch",           (PyCFunction)PyCursesWindow_AddCh, METH_VARARGS},
1537	{"addnstr",         (PyCFunction)PyCursesWindow_AddNStr, METH_VARARGS},
1538	{"addstr",          (PyCFunction)PyCursesWindow_AddStr, METH_VARARGS},
1539	{"attroff",         (PyCFunction)PyCursesWindow_AttrOff, METH_VARARGS},
1540	{"attron",          (PyCFunction)PyCursesWindow_AttrOn, METH_VARARGS},
1541	{"attrset",         (PyCFunction)PyCursesWindow_AttrSet, METH_VARARGS},
1542	{"bkgd",            (PyCFunction)PyCursesWindow_Bkgd, METH_VARARGS},
1543	{"chgat",           (PyCFunction)PyCursesWindow_ChgAt, METH_VARARGS},
1544	{"bkgdset",         (PyCFunction)PyCursesWindow_BkgdSet, METH_VARARGS},
1545	{"border",          (PyCFunction)PyCursesWindow_Border, METH_VARARGS},
1546	{"box",             (PyCFunction)PyCursesWindow_Box, METH_VARARGS},
1547	{"clear",           (PyCFunction)PyCursesWindow_wclear, METH_NOARGS},
1548	{"clearok",         (PyCFunction)PyCursesWindow_clearok, METH_VARARGS},
1549	{"clrtobot",        (PyCFunction)PyCursesWindow_wclrtobot, METH_NOARGS},
1550	{"clrtoeol",        (PyCFunction)PyCursesWindow_wclrtoeol, METH_NOARGS},
1551	{"cursyncup",       (PyCFunction)PyCursesWindow_wcursyncup, METH_NOARGS},
1552	{"delch",           (PyCFunction)PyCursesWindow_DelCh, METH_VARARGS},
1553	{"deleteln",        (PyCFunction)PyCursesWindow_wdeleteln, METH_NOARGS},
1554	{"derwin",          (PyCFunction)PyCursesWindow_DerWin, METH_VARARGS},
1555	{"echochar",        (PyCFunction)PyCursesWindow_EchoChar, METH_VARARGS},
1556#ifdef NCURSES_MOUSE_VERSION
1557	{"enclose",         (PyCFunction)PyCursesWindow_Enclose, METH_VARARGS},
1558#endif
1559	{"erase",           (PyCFunction)PyCursesWindow_werase, METH_NOARGS},
1560	{"getbegyx",        (PyCFunction)PyCursesWindow_getbegyx, METH_NOARGS},
1561	{"getbkgd",         (PyCFunction)PyCursesWindow_GetBkgd, METH_NOARGS},
1562	{"getch",           (PyCFunction)PyCursesWindow_GetCh, METH_VARARGS},
1563	{"getkey",          (PyCFunction)PyCursesWindow_GetKey, METH_VARARGS},
1564	{"getmaxyx",        (PyCFunction)PyCursesWindow_getmaxyx, METH_NOARGS},
1565	{"getparyx",        (PyCFunction)PyCursesWindow_getparyx, METH_NOARGS},
1566	{"getstr",          (PyCFunction)PyCursesWindow_GetStr, METH_VARARGS},
1567	{"getyx",           (PyCFunction)PyCursesWindow_getyx, METH_NOARGS},
1568	{"hline",           (PyCFunction)PyCursesWindow_Hline, METH_VARARGS},
1569	{"idcok",           (PyCFunction)PyCursesWindow_idcok, METH_VARARGS},
1570	{"idlok",           (PyCFunction)PyCursesWindow_idlok, METH_VARARGS},
1571	{"immedok",         (PyCFunction)PyCursesWindow_immedok, METH_VARARGS},
1572	{"inch",            (PyCFunction)PyCursesWindow_InCh, METH_VARARGS},
1573	{"insch",           (PyCFunction)PyCursesWindow_InsCh, METH_VARARGS},
1574	{"insdelln",        (PyCFunction)PyCursesWindow_winsdelln, METH_VARARGS},
1575	{"insertln",        (PyCFunction)PyCursesWindow_winsertln, METH_NOARGS},
1576	{"insnstr",         (PyCFunction)PyCursesWindow_InsNStr, METH_VARARGS},
1577	{"insstr",          (PyCFunction)PyCursesWindow_InsStr, METH_VARARGS},
1578	{"instr",           (PyCFunction)PyCursesWindow_InStr, METH_VARARGS},
1579	{"is_linetouched",  (PyCFunction)PyCursesWindow_Is_LineTouched, METH_VARARGS},
1580	{"is_wintouched",   (PyCFunction)PyCursesWindow_is_wintouched, METH_NOARGS},
1581	{"keypad",          (PyCFunction)PyCursesWindow_keypad, METH_VARARGS},
1582	{"leaveok",         (PyCFunction)PyCursesWindow_leaveok, METH_VARARGS},
1583	{"move",            (PyCFunction)PyCursesWindow_wmove, METH_VARARGS},
1584	{"mvderwin",        (PyCFunction)PyCursesWindow_mvderwin, METH_VARARGS},
1585	{"mvwin",           (PyCFunction)PyCursesWindow_mvwin, METH_VARARGS},
1586	{"nodelay",         (PyCFunction)PyCursesWindow_nodelay, METH_VARARGS},
1587	{"notimeout",       (PyCFunction)PyCursesWindow_notimeout, METH_VARARGS},
1588	{"noutrefresh",     (PyCFunction)PyCursesWindow_NoOutRefresh, METH_VARARGS},
1589        /* Backward compatibility alias -- remove in Python 2.3 */
1590	{"nooutrefresh",    (PyCFunction)PyCursesWindow_NoOutRefresh, METH_VARARGS},
1591	{"overlay",         (PyCFunction)PyCursesWindow_Overlay, METH_VARARGS},
1592	{"overwrite",       (PyCFunction)PyCursesWindow_Overwrite,
1593         METH_VARARGS},
1594	{"putwin",          (PyCFunction)PyCursesWindow_PutWin, METH_VARARGS},
1595	{"redrawln",        (PyCFunction)PyCursesWindow_RedrawLine, METH_VARARGS},
1596	{"redrawwin",       (PyCFunction)PyCursesWindow_redrawwin, METH_NOARGS},
1597	{"refresh",         (PyCFunction)PyCursesWindow_Refresh, METH_VARARGS},
1598#ifndef STRICT_SYSV_CURSES
1599	{"resize",          (PyCFunction)PyCursesWindow_wresize, METH_VARARGS},
1600#endif
1601	{"scroll",          (PyCFunction)PyCursesWindow_Scroll, METH_VARARGS},
1602	{"scrollok",        (PyCFunction)PyCursesWindow_scrollok, METH_VARARGS},
1603	{"setscrreg",       (PyCFunction)PyCursesWindow_SetScrollRegion, METH_VARARGS},
1604	{"standend",        (PyCFunction)PyCursesWindow_wstandend, METH_NOARGS},
1605	{"standout",        (PyCFunction)PyCursesWindow_wstandout, METH_NOARGS},
1606	{"subpad",          (PyCFunction)PyCursesWindow_SubWin, METH_VARARGS},
1607	{"subwin",          (PyCFunction)PyCursesWindow_SubWin, METH_VARARGS},
1608	{"syncdown",        (PyCFunction)PyCursesWindow_wsyncdown, METH_NOARGS},
1609	{"syncok",          (PyCFunction)PyCursesWindow_syncok, METH_VARARGS},
1610	{"syncup",          (PyCFunction)PyCursesWindow_wsyncup, METH_NOARGS},
1611	{"timeout",         (PyCFunction)PyCursesWindow_wtimeout, METH_VARARGS},
1612	{"touchline",       (PyCFunction)PyCursesWindow_TouchLine, METH_VARARGS},
1613	{"touchwin",        (PyCFunction)PyCursesWindow_touchwin, METH_NOARGS},
1614	{"untouchwin",      (PyCFunction)PyCursesWindow_untouchwin, METH_NOARGS},
1615	{"vline",           (PyCFunction)PyCursesWindow_Vline, METH_VARARGS},
1616	{NULL,		    NULL}   /* sentinel */
1617};
1618
1619static PyObject *
1620PyCursesWindow_GetAttr(PyCursesWindowObject *self, char *name)
1621{
1622  return Py_FindMethod(PyCursesWindow_Methods, (PyObject *)self, name);
1623}
1624
1625/* -------------------------------------------------------*/
1626
1627PyTypeObject PyCursesWindow_Type = {
1628	PyVarObject_HEAD_INIT(NULL, 0)
1629	"_curses.curses window",	/*tp_name*/
1630	sizeof(PyCursesWindowObject),	/*tp_basicsize*/
1631	0,			/*tp_itemsize*/
1632	/* methods */
1633	(destructor)PyCursesWindow_Dealloc, /*tp_dealloc*/
1634	0,			/*tp_print*/
1635	(getattrfunc)PyCursesWindow_GetAttr, /*tp_getattr*/
1636	(setattrfunc)0, /*tp_setattr*/
1637	0,			/*tp_compare*/
1638	0,			/*tp_repr*/
1639	0,			/*tp_as_number*/
1640	0,			/*tp_as_sequence*/
1641	0,			/*tp_as_mapping*/
1642	0,			/*tp_hash*/
1643};
1644
1645/*********************************************************************
1646 Global Functions
1647**********************************************************************/
1648
1649NoArgNoReturnFunction(beep)
1650NoArgNoReturnFunction(def_prog_mode)
1651NoArgNoReturnFunction(def_shell_mode)
1652NoArgNoReturnFunction(doupdate)
1653NoArgNoReturnFunction(endwin)
1654NoArgNoReturnFunction(flash)
1655NoArgNoReturnFunction(nocbreak)
1656NoArgNoReturnFunction(noecho)
1657NoArgNoReturnFunction(nonl)
1658NoArgNoReturnFunction(noraw)
1659NoArgNoReturnFunction(reset_prog_mode)
1660NoArgNoReturnFunction(reset_shell_mode)
1661NoArgNoReturnFunction(resetty)
1662NoArgNoReturnFunction(savetty)
1663
1664NoArgOrFlagNoReturnFunction(cbreak)
1665NoArgOrFlagNoReturnFunction(echo)
1666NoArgOrFlagNoReturnFunction(nl)
1667NoArgOrFlagNoReturnFunction(raw)
1668
1669NoArgReturnIntFunction(baudrate)
1670NoArgReturnIntFunction(termattrs)
1671
1672NoArgReturnStringFunction(termname)
1673NoArgReturnStringFunction(longname)
1674
1675NoArgTrueFalseFunction(can_change_color)
1676NoArgTrueFalseFunction(has_colors)
1677NoArgTrueFalseFunction(has_ic)
1678NoArgTrueFalseFunction(has_il)
1679NoArgTrueFalseFunction(isendwin)
1680NoArgNoReturnVoidFunction(flushinp)
1681NoArgNoReturnVoidFunction(noqiflush)
1682
1683static PyObject *
1684PyCurses_filter(PyObject *self)
1685{
1686  /* not checking for PyCursesInitialised here since filter() must
1687     be called before initscr() */
1688  filter();
1689  Py_INCREF(Py_None);
1690  return Py_None;
1691}
1692
1693static PyObject *
1694PyCurses_Color_Content(PyObject *self, PyObject *args)
1695{
1696  short color,r,g,b;
1697
1698  PyCursesInitialised
1699  PyCursesInitialisedColor
1700
1701  if (!PyArg_ParseTuple(args, "h:color_content", &color)) return NULL;
1702
1703  if (color_content(color, &r, &g, &b) != ERR)
1704    return Py_BuildValue("(iii)", r, g, b);
1705  else {
1706    PyErr_SetString(PyCursesError, 
1707		    "Argument 1 was out of range. Check value of COLORS.");
1708    return NULL;
1709  }
1710}
1711
1712static PyObject *
1713PyCurses_color_pair(PyObject *self, PyObject *args)
1714{
1715  int n;
1716
1717  PyCursesInitialised
1718  PyCursesInitialisedColor
1719
1720  if (!PyArg_ParseTuple(args, "i:color_pair", &n)) return NULL;
1721  return PyInt_FromLong((long) (n << 8));
1722}
1723
1724static PyObject *
1725PyCurses_Curs_Set(PyObject *self, PyObject *args)
1726{
1727  int vis,erg;
1728
1729  PyCursesInitialised
1730
1731  if (!PyArg_ParseTuple(args, "i:curs_set", &vis)) return NULL;
1732
1733  erg = curs_set(vis);
1734  if (erg == ERR) return PyCursesCheckERR(erg, "curs_set");
1735
1736  return PyInt_FromLong((long) erg);
1737}
1738
1739static PyObject *
1740PyCurses_Delay_Output(PyObject *self, PyObject *args)
1741{
1742  int ms;
1743
1744  PyCursesInitialised
1745
1746  if (!PyArg_ParseTuple(args, "i:delay_output", &ms)) return NULL;
1747
1748  return PyCursesCheckERR(delay_output(ms), "delay_output");
1749}
1750
1751static PyObject *
1752PyCurses_EraseChar(PyObject *self)
1753{
1754  char ch;
1755
1756  PyCursesInitialised
1757
1758  ch = erasechar();
1759
1760  return PyString_FromStringAndSize(&ch, 1);
1761}
1762
1763static PyObject *
1764PyCurses_getsyx(PyObject *self)
1765{
1766  int x,y;
1767
1768  PyCursesInitialised
1769
1770  getsyx(y, x);
1771
1772  return Py_BuildValue("(ii)", y, x);
1773}
1774
1775#ifdef NCURSES_MOUSE_VERSION
1776static PyObject *
1777PyCurses_GetMouse(PyObject *self)
1778{
1779	int rtn;
1780	MEVENT event;
1781
1782	PyCursesInitialised
1783
1784	rtn = getmouse( &event );
1785	if (rtn == ERR) {
1786		PyErr_SetString(PyCursesError, "getmouse() returned ERR");
1787		return NULL;
1788	}
1789	return Py_BuildValue("(hiiil)", 
1790			     (short)event.id, 
1791			     event.x, event.y, event.z,
1792			     (long) event.bstate);
1793}
1794
1795static PyObject *
1796PyCurses_UngetMouse(PyObject *self, PyObject *args)
1797{
1798	MEVENT event;
1799
1800	PyCursesInitialised
1801	if (!PyArg_ParseTuple(args, "hiiil",
1802			     &event.id, 
1803			     &event.x, &event.y, &event.z,
1804			     (int *) &event.bstate))
1805	  return NULL;
1806
1807	return PyCursesCheckERR(ungetmouse(&event), "ungetmouse");
1808}
1809#endif
1810
1811static PyObject *
1812PyCurses_GetWin(PyCursesWindowObject *self, PyObject *temp)
1813{
1814  WINDOW *win;
1815
1816  PyCursesInitialised
1817
1818  if (!PyFile_Check(temp)) {
1819    PyErr_SetString(PyExc_TypeError, "argument must be a file object");
1820    return NULL;
1821  }
1822
1823  win = getwin(PyFile_AsFile(temp));
1824
1825  if (win == NULL) {
1826    PyErr_SetString(PyCursesError, catchall_NULL);
1827    return NULL;
1828  }
1829
1830  return PyCursesWindow_New(win);
1831}
1832
1833static PyObject *
1834PyCurses_HalfDelay(PyObject *self, PyObject *args)
1835{
1836  unsigned char tenths;
1837
1838  PyCursesInitialised
1839
1840  if (!PyArg_ParseTuple(args, "b:halfdelay", &tenths)) return NULL;
1841
1842  return PyCursesCheckERR(halfdelay(tenths), "halfdelay");
1843}
1844
1845#ifndef STRICT_SYSV_CURSES
1846 /* No has_key! */
1847static PyObject * PyCurses_has_key(PyObject *self, PyObject *args)
1848{
1849  int ch;
1850
1851  PyCursesInitialised
1852
1853  if (!PyArg_ParseTuple(args,"i",&ch)) return NULL;
1854
1855  if (has_key(ch) == FALSE) {
1856    Py_INCREF(Py_False);
1857    return Py_False;
1858  }
1859  Py_INCREF(Py_True);
1860  return Py_True; 
1861}
1862#endif /* STRICT_SYSV_CURSES */
1863
1864static PyObject *
1865PyCurses_Init_Color(PyObject *self, PyObject *args)
1866{
1867  short color, r, g, b;
1868
1869  PyCursesInitialised
1870  PyCursesInitialisedColor
1871
1872  switch(PyTuple_Size(args)) {
1873  case 4:
1874    if (!PyArg_ParseTuple(args, "hhhh;color,r,g,b", &color, &r, &g, &b)) return NULL;
1875    break;
1876  default:
1877    PyErr_SetString(PyExc_TypeError, "init_color requires 4 arguments");
1878    return NULL;
1879  }
1880
1881  return PyCursesCheckERR(init_color(color, r, g, b), "init_color");
1882}
1883
1884static PyObject *
1885PyCurses_Init_Pair(PyObject *self, PyObject *args)
1886{
1887  short pair, f, b;
1888
1889  PyCursesInitialised
1890  PyCursesInitialisedColor
1891
1892  if (PyTuple_Size(args) != 3) {
1893    PyErr_SetString(PyExc_TypeError, "init_pair requires 3 arguments");
1894    return NULL;
1895  }
1896
1897  if (!PyArg_ParseTuple(args, "hhh;pair, f, b", &pair, &f, &b)) return NULL;
1898
1899  return PyCursesCheckERR(init_pair(pair, f, b), "init_pair");
1900}
1901
1902static PyObject *ModDict;
1903
1904static PyObject * 
1905PyCurses_InitScr(PyObject *self)
1906{
1907  WINDOW *win;
1908
1909  if (initialised == TRUE) {
1910    wrefresh(stdscr);
1911    return (PyObject *)PyCursesWindow_New(stdscr);
1912  }
1913
1914  win = initscr();
1915
1916  if (win == NULL) {
1917    PyErr_SetString(PyCursesError, catchall_NULL);
1918    return NULL;
1919  }
1920
1921  initialised = initialised_setupterm = TRUE;
1922
1923/* This was moved from initcurses() because it core dumped on SGI,
1924   where they're not defined until you've called initscr() */
1925#define SetDictInt(string,ch) \
1926    do {							\
1927	PyObject *o = PyInt_FromLong((long) (ch));		\
1928	if (o && PyDict_SetItemString(ModDict, string, o) == 0)	{ \
1929	    Py_DECREF(o);					\
1930	}							\
1931    } while (0)
1932
1933	/* Here are some graphic symbols you can use */
1934        SetDictInt("ACS_ULCORNER",      (ACS_ULCORNER));
1935	SetDictInt("ACS_LLCORNER",      (ACS_LLCORNER));
1936	SetDictInt("ACS_URCORNER",      (ACS_URCORNER));
1937	SetDictInt("ACS_LRCORNER",      (ACS_LRCORNER));
1938	SetDictInt("ACS_LTEE",          (ACS_LTEE));
1939	SetDictInt("ACS_RTEE",          (ACS_RTEE));
1940	SetDictInt("ACS_BTEE",          (ACS_BTEE));
1941	SetDictInt("ACS_TTEE",          (ACS_TTEE));
1942	SetDictInt("ACS_HLINE",         (ACS_HLINE));
1943	SetDictInt("ACS_VLINE",         (ACS_VLINE));
1944	SetDictInt("ACS_PLUS",          (ACS_PLUS));
1945#if !defined(__hpux) || defined(HAVE_NCURSES_H)
1946        /* On HP/UX 11, these are of type cchar_t, which is not an
1947           integral type. If this is a problem on more platforms, a
1948           configure test should be added to determine whether ACS_S1
1949           is of integral type. */
1950	SetDictInt("ACS_S1",            (ACS_S1));
1951	SetDictInt("ACS_S9",            (ACS_S9));
1952	SetDictInt("ACS_DIAMOND",       (ACS_DIAMOND));
1953	SetDictInt("ACS_CKBOARD",       (ACS_CKBOARD));
1954	SetDictInt("ACS_DEGREE",        (ACS_DEGREE));
1955	SetDictInt("ACS_PLMINUS",       (ACS_PLMINUS));
1956	SetDictInt("ACS_BULLET",        (ACS_BULLET));
1957	SetDictInt("ACS_LARROW",        (ACS_LARROW));
1958	SetDictInt("ACS_RARROW",        (ACS_RARROW));
1959	SetDictInt("ACS_DARROW",        (ACS_DARROW));
1960	SetDictInt("ACS_UARROW",        (ACS_UARROW));
1961	SetDictInt("ACS_BOARD",         (ACS_BOARD));
1962	SetDictInt("ACS_LANTERN",       (ACS_LANTERN));
1963	SetDictInt("ACS_BLOCK",         (ACS_BLOCK));
1964#endif
1965	SetDictInt("ACS_BSSB",          (ACS_ULCORNER));
1966	SetDictInt("ACS_SSBB",          (ACS_LLCORNER));
1967	SetDictInt("ACS_BBSS",          (ACS_URCORNER));
1968	SetDictInt("ACS_SBBS",          (ACS_LRCORNER));
1969	SetDictInt("ACS_SBSS",          (ACS_RTEE));
1970	SetDictInt("ACS_SSSB",          (ACS_LTEE));
1971	SetDictInt("ACS_SSBS",          (ACS_BTEE));
1972	SetDictInt("ACS_BSSS",          (ACS_TTEE));
1973	SetDictInt("ACS_BSBS",          (ACS_HLINE));
1974	SetDictInt("ACS_SBSB",          (ACS_VLINE));
1975	SetDictInt("ACS_SSSS",          (ACS_PLUS));
1976
1977	/* The following are never available with strict SYSV curses */
1978#ifdef ACS_S3
1979	SetDictInt("ACS_S3",            (ACS_S3));
1980#endif
1981#ifdef ACS_S7
1982	SetDictInt("ACS_S7",            (ACS_S7));
1983#endif
1984#ifdef ACS_LEQUAL
1985	SetDictInt("ACS_LEQUAL",        (ACS_LEQUAL));
1986#endif
1987#ifdef ACS_GEQUAL
1988	SetDictInt("ACS_GEQUAL",        (ACS_GEQUAL));
1989#endif
1990#ifdef ACS_PI
1991	SetDictInt("ACS_PI",            (ACS_PI));
1992#endif
1993#ifdef ACS_NEQUAL
1994	SetDictInt("ACS_NEQUAL",        (ACS_NEQUAL));
1995#endif
1996#ifdef ACS_STERLING
1997	SetDictInt("ACS_STERLING",      (ACS_STERLING));
1998#endif
1999
2000  SetDictInt("LINES", LINES);
2001  SetDictInt("COLS", COLS);
2002
2003  return (PyObject *)PyCursesWindow_New(win);
2004}
2005
2006static PyObject *
2007PyCurses_setupterm(PyObject* self, PyObject *args, PyObject* keywds)
2008{
2009	int fd = -1;
2010	int err;
2011	char* termstr = NULL;
2012
2013	static char *kwlist[] = {"term", "fd", NULL};
2014
2015	if (!PyArg_ParseTupleAndKeywords(
2016		args, keywds, "|zi:setupterm", kwlist, &termstr, &fd)) {
2017		return NULL;
2018	}
2019	
2020	if (fd == -1) {
2021		PyObject* sys_stdout;
2022
2023		sys_stdout = PySys_GetObject("stdout");
2024
2025		if (sys_stdout == NULL) {
2026			PyErr_SetString(
2027				PyCursesError,
2028				"lost sys.stdout");
2029			return NULL;
2030		}
2031
2032		fd = PyObject_AsFileDescriptor(sys_stdout);
2033
2034		if (fd == -1) {
2035			return NULL;
2036		}
2037	}
2038
2039	if (setupterm(termstr,fd,&err) == ERR) {
2040		char* s = "setupterm: unknown error";
2041		
2042		if (err == 0) {
2043			s = "setupterm: could not find terminal";
2044		} else if (err == -1) {
2045			s = "setupterm: could not find terminfo database";
2046		}
2047
2048		PyErr_SetString(PyCursesError,s);
2049		return NULL;
2050	}
2051
2052	initialised_setupterm = TRUE;
2053
2054	Py_INCREF(Py_None);
2055	return Py_None;	
2056}
2057
2058static PyObject *
2059PyCurses_IntrFlush(PyObject *self, PyObject *args)
2060{
2061  int ch;
2062
2063  PyCursesInitialised
2064
2065  switch(PyTuple_Size(args)) {
2066  case 1:
2067    if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&ch)) return NULL;
2068    break;
2069  default:
2070    PyErr_SetString(PyExc_TypeError, "intrflush requires 1 argument");
2071    return NULL;
2072  }
2073
2074  return PyCursesCheckERR(intrflush(NULL,ch), "intrflush");
2075}
2076
2077#ifdef HAVE_CURSES_IS_TERM_RESIZED
2078static PyObject *
2079PyCurses_Is_Term_Resized(PyObject *self, PyObject *args)
2080{
2081  int lines;
2082  int columns;
2083  int result;
2084
2085  PyCursesInitialised
2086
2087  if (!PyArg_ParseTuple(args,"ii:is_term_resized", &lines, &columns))
2088    return NULL;
2089  result = is_term_resized(lines, columns);
2090  if (result == TRUE) {
2091    Py_INCREF(Py_True);
2092    return Py_True;
2093  } else {
2094    Py_INCREF(Py_False);
2095    return Py_False;
2096  }
2097}
2098#endif /* HAVE_CURSES_IS_TERM_RESIZED */
2099
2100#if !defined(__NetBSD__)
2101static PyObject *
2102PyCurses_KeyName(PyObject *self, PyObject *args)
2103{
2104  const char *knp;
2105  int ch;
2106
2107  PyCursesInitialised
2108
2109  if (!PyArg_ParseTuple(args,"i",&ch)) return NULL;
2110
2111  if (ch < 0) {
2112    PyErr_SetString(PyExc_ValueError, "invalid key number");
2113    return NULL;
2114  }
2115  knp = keyname(ch);
2116
2117  return PyString_FromString((knp == NULL) ? "" : (char *)knp);
2118}
2119#endif
2120
2121static PyObject *  
2122PyCurses_KillChar(PyObject *self)  
2123{  
2124  char ch;  
2125
2126  ch = killchar();  
2127
2128  return PyString_FromStringAndSize(&ch, 1);  
2129}  
2130
2131static PyObject *
2132PyCurses_Meta(PyObject *self, PyObject *args)
2133{
2134  int ch;
2135
2136  PyCursesInitialised
2137
2138  switch(PyTuple_Size(args)) {
2139  case 1:
2140    if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&ch)) return NULL;
2141    break;
2142  default:
2143    PyErr_SetString(PyExc_TypeError, "meta requires 1 argument");
2144    return NULL;
2145  }
2146
2147  return PyCursesCheckERR(meta(stdscr, ch), "meta");
2148}
2149
2150#ifdef NCURSES_MOUSE_VERSION
2151static PyObject *
2152PyCurses_MouseInterval(PyObject *self, PyObject *args)
2153{
2154	int interval;
2155	PyCursesInitialised 
2156
2157	if (!PyArg_ParseTuple(args,"i;interval",&interval)) 
2158		return NULL;
2159	return PyCursesCheckERR(mouseinterval(interval), "mouseinterval");
2160}
2161
2162static PyObject *
2163PyCurses_MouseMask(PyObject *self, PyObject *args)
2164{
2165	int newmask;
2166	mmask_t oldmask, availmask;
2167
2168	PyCursesInitialised 
2169	if (!PyArg_ParseTuple(args,"i;mousemask",&newmask)) 
2170		return NULL;
2171	availmask = mousemask(newmask, &oldmask);
2172	return Py_BuildValue("(ll)", (long)availmask, (long)oldmask);
2173}
2174#endif
2175
2176static PyObject *
2177PyCurses_Napms(PyObject *self, PyObject *args)
2178{
2179    int ms;
2180
2181    PyCursesInitialised
2182    if (!PyArg_ParseTuple(args, "i;ms", &ms)) return NULL;
2183
2184    return Py_BuildValue("i", napms(ms));
2185}
2186
2187
2188static PyObject *
2189PyCurses_NewPad(PyObject *self, PyObject *args)
2190{
2191  WINDOW *win;
2192  int nlines, ncols;
2193
2194  PyCursesInitialised 
2195
2196  if (!PyArg_ParseTuple(args,"ii;nlines,ncols",&nlines,&ncols)) return NULL;
2197
2198  win = newpad(nlines, ncols);
2199  
2200  if (win == NULL) {
2201    PyErr_SetString(PyCursesError, catchall_NULL);
2202    return NULL;
2203  }
2204
2205  return (PyObject *)PyCursesWindow_New(win);
2206}
2207
2208static PyObject *
2209PyCurses_NewWindow(PyObject *self, PyObject *args)
2210{
2211  WINDOW *win;
2212  int nlines, ncols, begin_y=0, begin_x=0;
2213
2214  PyCursesInitialised
2215
2216  switch (PyTuple_Size(args)) {
2217  case 2:
2218    if (!PyArg_ParseTuple(args,"ii;nlines,ncols",&nlines,&ncols))
2219      return NULL;
2220    break;
2221  case 4:
2222    if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
2223		   &nlines,&ncols,&begin_y,&begin_x))
2224      return NULL;
2225    break;
2226  default:
2227    PyErr_SetString(PyExc_TypeError, "newwin requires 2 or 4 arguments");
2228    return NULL;
2229  }
2230
2231  win = newwin(nlines,ncols,begin_y,begin_x);
2232  if (win == NULL) {
2233    PyErr_SetString(PyCursesError, catchall_NULL);
2234    return NULL;
2235  }
2236
2237  return (PyObject *)PyCursesWindow_New(win);
2238}
2239
2240static PyObject *
2241PyCurses_Pair_Content(PyObject *self, PyObject *args)
2242{
2243  short pair,f,b;
2244
2245  PyCursesInitialised
2246  PyCursesInitialisedColor
2247
2248  switch(PyTuple_Size(args)) {
2249  case 1:
2250    if (!PyArg_ParseTuple(args, "h;pair", &pair)) return NULL;
2251    break;
2252  default:
2253    PyErr_SetString(PyExc_TypeError, "pair_content requires 1 argument");
2254    return NULL;
2255  }
2256
2257  if (pair_content(pair, &f, &b)==ERR) {
2258    PyErr_SetString(PyCursesError,
2259		    "Argument 1 was out of range. (1..COLOR_PAIRS-1)");
2260    return NULL;
2261  }
2262
2263  return Py_BuildValue("(ii)", f, b);
2264}
2265
2266static PyObject *
2267PyCurses_pair_number(PyObject *self, PyObject *args)
2268{
2269  int n;
2270
2271  PyCursesInitialised
2272  PyCursesInitialisedColor
2273
2274  switch(PyTuple_Size(args)) {
2275  case 1:
2276    if (!PyArg_ParseTuple(args, "i;pairvalue", &n)) return NULL;
2277    break;
2278  default:
2279    PyErr_SetString(PyExc_TypeError,
2280                    "pair_number requires 1 argument");
2281    return NULL;
2282  }
2283
2284  return PyInt_FromLong((long) ((n & A_COLOR) >> 8));
2285}
2286
2287static PyObject *
2288PyCurses_Putp(PyObject *self, PyObject *args)
2289{
2290  char *str;
2291
2292  if (!PyArg_ParseTuple(args,"s;str", &str)) return NULL;
2293  return PyCursesCheckERR(putp(str), "putp");
2294}
2295
2296static PyObject *
2297PyCurses_QiFlush(PyObject *self, PyObject *args)
2298{
2299  int flag = 0;
2300
2301  PyCursesInitialised
2302
2303  switch(PyTuple_Size(args)) {
2304  case 0:
2305    qiflush();
2306    Py_INCREF(Py_None);
2307    return Py_None;
2308  case 1:
2309    if (!PyArg_ParseTuple(args, "i;True(1) or False(0)", &flag)) return NULL;
2310    if (flag) qiflush();
2311    else noqiflush();
2312    Py_INCREF(Py_None);
2313    return Py_None;
2314  default:
2315    PyErr_SetString(PyExc_TypeError, "qiflush requires 0 or 1 arguments");
2316    return NULL;
2317  }
2318}
2319
2320/* Internal helper used for updating curses.LINES, curses.COLS, _curses.LINES
2321 * and _curses.COLS */
2322#if defined(HAVE_CURSES_RESIZETERM) || defined(HAVE_CURSES_RESIZE_TERM)
2323static int
2324update_lines_cols(void)
2325{
2326  PyObject *o;
2327  PyObject *m = PyImport_ImportModuleNoBlock("curses");
2328
2329  if (!m)
2330    return 0;
2331
2332  o = PyInt_FromLong(LINES);
2333  if (!o) {
2334    Py_DECREF(m);
2335    return 0;
2336  }
2337  if (PyObject_SetAttrString(m, "LINES", o)) {
2338    Py_DECREF(m);
2339    Py_DECREF(o);
2340    return 0;
2341  }
2342  if (PyDict_SetItemString(ModDict, "LINES", o)) {
2343    Py_DECREF(m);
2344    Py_DECREF(o);
2345    return 0;
2346  }
2347  Py_DECREF(o);
2348  o = PyInt_FromLong(COLS);
2349  if (!o) {
2350    Py_DECREF(m);
2351    return 0;
2352  }
2353  if (PyObject_SetAttrString(m, "COLS", o)) {
2354    Py_DECREF(m);
2355    Py_DECREF(o);
2356    return 0;
2357  }
2358  if (PyDict_SetItemString(ModDict, "COLS", o)) {
2359    Py_DECREF(m);
2360    Py_DECREF(o);
2361    return 0;
2362  }
2363  Py_DECREF(o);
2364  Py_DECREF(m);
2365  return 1;
2366}
2367#endif
2368
2369#ifdef HAVE_CURSES_RESIZETERM
2370static PyObject *
2371PyCurses_ResizeTerm(PyObject *self, PyObject *args)
2372{
2373  int lines;
2374  int columns;
2375  PyObject *result;
2376
2377  PyCursesInitialised
2378
2379  if (!PyArg_ParseTuple(args,"ii:resizeterm", &lines, &columns))
2380    return NULL;
2381
2382  result = PyCursesCheckERR(resizeterm(lines, columns), "resizeterm");
2383  if (!result)
2384    return NULL;
2385  if (!update_lines_cols())
2386    return NULL;
2387  return result;
2388}
2389
2390#endif
2391
2392#ifdef HAVE_CURSES_RESIZE_TERM
2393static PyObject *
2394PyCurses_Resize_Term(PyObject *self, PyObject *args)
2395{
2396  int lines;
2397  int columns;
2398
2399  PyObject *result;
2400
2401  PyCursesInitialised
2402
2403  if (!PyArg_ParseTuple(args,"ii:resize_term", &lines, &columns))
2404    return NULL;
2405
2406  result = PyCursesCheckERR(resize_term(lines, columns), "resize_term");
2407  if (!result)
2408    return NULL;
2409  if (!update_lines_cols())
2410    return NULL;
2411  return result;
2412}
2413#endif /* HAVE_CURSES_RESIZE_TERM */
2414
2415static PyObject *
2416PyCurses_setsyx(PyObject *self, PyObject *args)
2417{
2418  int y,x;
2419
2420  PyCursesInitialised
2421
2422  if (PyTuple_Size(args)!=2) {
2423    PyErr_SetString(PyExc_TypeError, "setsyx requires 2 arguments");
2424    return NULL;
2425  }
2426
2427  if (!PyArg_ParseTuple(args, "ii;y, x", &y, &x)) return NULL;
2428
2429  setsyx(y,x);
2430
2431  Py_INCREF(Py_None);
2432  return Py_None;
2433}
2434
2435static PyObject *
2436PyCurses_Start_Color(PyObject *self)
2437{
2438  int code;
2439  PyObject *c, *cp;
2440
2441  PyCursesInitialised
2442
2443  code = start_color();
2444  if (code != ERR) {
2445    initialisedcolors = TRUE;
2446    c = PyInt_FromLong((long) COLORS);
2447    PyDict_SetItemString(ModDict, "COLORS", c);
2448    Py_DECREF(c);
2449    cp = PyInt_FromLong((long) COLOR_PAIRS);
2450    PyDict_SetItemString(ModDict, "COLOR_PAIRS", cp);
2451    Py_DECREF(cp);
2452    Py_INCREF(Py_None);
2453    return Py_None;
2454  } else {
2455    PyErr_SetString(PyCursesError, "start_color() returned ERR");
2456    return NULL;
2457  }
2458}
2459
2460static PyObject *
2461PyCurses_tigetflag(PyObject *self, PyObject *args)
2462{
2463	char *capname;
2464
2465	PyCursesSetupTermCalled;
2466		
2467	if (!PyArg_ParseTuple(args, "z", &capname))
2468		return NULL;
2469
2470	return PyInt_FromLong( (long) tigetflag( capname ) );
2471}
2472
2473static PyObject *
2474PyCurses_tigetnum(PyObject *self, PyObject *args)
2475{
2476	char *capname;
2477
2478	PyCursesSetupTermCalled;
2479		
2480	if (!PyArg_ParseTuple(args, "z", &capname))
2481		return NULL;
2482
2483	return PyInt_FromLong( (long) tigetnum( capname ) );
2484}
2485
2486static PyObject *
2487PyCurses_tigetstr(PyObject *self, PyObject *args)
2488{
2489	char *capname;
2490
2491	PyCursesSetupTermCalled;
2492		
2493	if (!PyArg_ParseTuple(args, "z", &capname))
2494		return NULL;
2495
2496	capname = tigetstr( capname );
2497	if (capname == 0 || capname == (char*) -1) {
2498		Py_INCREF(Py_None);
2499		return Py_None;
2500	}
2501	return PyString_FromString( capname );
2502}
2503
2504static PyObject *
2505PyCurses_tparm(PyObject *self, PyObject *args)
2506{
2507	char* fmt;
2508	char* result = NULL;
2509	int i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0,i8=0,i9=0;
2510
2511	PyCursesSetupTermCalled;
2512
2513	if (!PyArg_ParseTuple(args, "s|iiiiiiiii:tparm", 
2514			      &fmt, &i1, &i2, &i3, &i4, 
2515			      &i5, &i6, &i7, &i8, &i9)) {
2516		return NULL;
2517	}
2518
2519	result = tparm(fmt,i1,i2,i3,i4,i5,i6,i7,i8,i9);
2520	if (!result) {
2521		PyErr_SetString(PyCursesError, "tparm() returned NULL");
2522  		return NULL;
2523	}
2524
2525	return PyString_FromString(result);
2526}
2527
2528static PyObject *
2529PyCurses_TypeAhead(PyObject *self, PyObject *args)
2530{
2531  int fd;
2532
2533  PyCursesInitialised
2534
2535  if (!PyArg_ParseTuple(args,"i;fd",&fd)) return NULL;
2536
2537  return PyCursesCheckERR(typeahead( fd ), "typeahead");
2538}
2539
2540static PyObject *
2541PyCurses_UnCtrl(PyObject *self, PyObject *args)
2542{
2543  PyObject *temp;
2544  chtype ch;
2545
2546  PyCursesInitialised
2547
2548  if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;
2549
2550  if (PyInt_Check(temp))
2551    ch = (chtype) PyInt_AsLong(temp);
2552  else if (PyString_Check(temp))
2553    ch = (chtype) *PyString_AsString(temp);
2554  else {
2555    PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");
2556    return NULL;
2557  }
2558
2559  return PyString_FromString(unctrl(ch));
2560}
2561
2562static PyObject *
2563PyCurses_UngetCh(PyObject *self, PyObject *args)
2564{
2565  PyObject *temp;
2566  int ch;
2567
2568  PyCursesInitialised
2569
2570  if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;
2571
2572  if (PyInt_Check(temp))
2573    ch = (int) PyInt_AsLong(temp);
2574  else if (PyString_Check(temp))
2575    ch = (int) *PyString_AsString(temp);
2576  else {
2577    PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");
2578    return NULL;
2579  }
2580
2581  return PyCursesCheckERR(ungetch(ch), "ungetch");
2582}
2583
2584static PyObject *
2585PyCurses_Use_Env(PyObject *self, PyObject *args)
2586{
2587  int flag;
2588
2589  PyCursesInitialised
2590
2591  switch(PyTuple_Size(args)) {
2592  case 1:
2593    if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&flag))
2594      return NULL;
2595    break;
2596  default:
2597    PyErr_SetString(PyExc_TypeError, "use_env requires 1 argument");
2598    return NULL;
2599  }
2600  use_env(flag);
2601  Py_INCREF(Py_None);
2602  return Py_None;
2603}
2604
2605#ifndef STRICT_SYSV_CURSES
2606static PyObject *
2607PyCurses_Use_Default_Colors(PyObject *self)
2608{
2609  int code;
2610
2611  PyCursesInitialised
2612  PyCursesInitialisedColor
2613
2614  code = use_default_colors();
2615  if (code != ERR) {
2616    Py_INCREF(Py_None);
2617    return Py_None;
2618  } else {
2619    PyErr_SetString(PyCursesError, "use_default_colors() returned ERR");
2620    return NULL;
2621  }
2622}
2623#endif /* STRICT_SYSV_CURSES */
2624
2625/* List of functions defined in the module */
2626
2627static PyMethodDef PyCurses_methods[] = {
2628  {"baudrate",            (PyCFunction)PyCurses_baudrate, METH_NOARGS},
2629  {"beep",                (PyCFunction)PyCurses_beep, METH_NOARGS},
2630  {"can_change_color",    (PyCFunction)PyCurses_can_change_color, METH_NOARGS},
2631  {"cbreak",              (PyCFunction)PyCurses_cbreak, METH_VARARGS},
2632  {"color_content",       (PyCFunction)PyCurses_Color_Content, METH_VARARGS},
2633  {"color_pair",          (PyCFunction)PyCurses_color_pair, METH_VARARGS},
2634  {"curs_set",            (PyCFunction)PyCurses_Curs_Set, METH_VARARGS},
2635  {"def_prog_mode",       (PyCFunction)PyCurses_def_prog_mode, METH_NOARGS},
2636  {"def_shell_mode",      (PyCFunction)PyCurses_def_shell_mode, METH_NOARGS},
2637  {"delay_output",        (PyCFunction)PyCurses_Delay_Output, METH_VARARGS},
2638  {"doupdate",            (PyCFunction)PyCurses_doupdate, METH_NOARGS},
2639  {"echo",                (PyCFunction)PyCurses_echo, METH_VARARGS},
2640  {"endwin",              (PyCFunction)PyCurses_endwin, METH_NOARGS},
2641  {"erasechar",           (PyCFunction)PyCurses_EraseChar, METH_NOARGS},
2642  {"filter",              (PyCFunction)PyCurses_filter, METH_NOARGS},
2643  {"flash",               (PyCFunction)PyCurses_flash, METH_NOARGS},
2644  {"flushinp",            (PyCFunction)PyCurses_flushinp, METH_NOARGS},
2645#ifdef NCURSES_MOUSE_VERSION
2646  {"getmouse",            (PyCFunction)PyCurses_GetMouse, METH_NOARGS},
2647  {"ungetmouse",          (PyCFunction)PyCurses_UngetMouse, METH_VARARGS},
2648#endif
2649  {"getsyx",              (PyCFunction)PyCurses_getsyx, METH_NOARGS},
2650  {"getwin",              (PyCFunction)PyCurses_GetWin, METH_O},
2651  {"has_colors",          (PyCFunction)PyCurses_has_colors, METH_NOARGS},
2652  {"has_ic",              (PyCFunction)PyCurses_has_ic, METH_NOARGS},
2653  {"has_il",              (PyCFunction)PyCurses_has_il, METH_NOARGS},
2654#ifndef STRICT_SYSV_CURSES
2655  {"has_key",             (PyCFunction)PyCurses_has_key, METH_VARARGS},
2656#endif
2657  {"halfdelay",           (PyCFunction)PyCurses_HalfDelay, METH_VARARGS},
2658  {"init_color",          (PyCFunction)PyCurses_Init_Color, METH_VARARGS},
2659  {"init_pair",           (PyCFunction)PyCurses_Init_Pair, METH_VARARGS},
2660  {"initscr",             (PyCFunction)PyCurses_InitScr, METH_NOARGS},
2661  {"intrflush",           (PyCFunction)PyCurses_IntrFlush, METH_VARARGS},
2662  {"isendwin",            (PyCFunction)PyCurses_isendwin, METH_NOARGS},
2663#ifdef HAVE_CURSES_IS_TERM_RESIZED
2664  {"is_term_resized",     (PyCFunction)PyCurses_Is_Term_Resized, METH_VARARGS},
2665#endif
2666#if !defined(__NetBSD__)
2667  {"keyname",             (PyCFunction)PyCurses_KeyName, METH_VARARGS},
2668#endif
2669  {"killchar",            (PyCFunction)PyCurses_KillChar, METH_NOARGS}, 
2670  {"longname",            (PyCFunction)PyCurses_longname, METH_NOARGS}, 
2671  {"meta",                (PyCFunction)PyCurses_Meta, METH_VARARGS},
2672#ifdef NCURSES_MOUSE_VERSION
2673  {"mouseinterval",       (PyCFunction)PyCurses_MouseInterval, METH_VARARGS},
2674  {"mousemask",           (PyCFunction)PyCurses_MouseMask, METH_VARARGS},
2675#endif
2676  {"napms",               (PyCFunction)PyCurses_Napms, METH_VARARGS},
2677  {"newpad",              (PyCFunction)PyCurses_NewPad, METH_VARARGS},
2678  {"newwin",              (PyCFunction)PyCurses_NewWindow, METH_VARARGS},
2679  {"nl",                  (PyCFunction)PyCurses_nl, METH_VARARGS},
2680  {"nocbreak",            (PyCFunction)PyCurses_nocbreak, METH_NOARGS},
2681  {"noecho",              (PyCFunction)PyCurses_noecho, METH_NOARGS},
2682  {"nonl",                (PyCFunction)PyCurses_nonl, METH_NOARGS},
2683  {"noqiflush",           (PyCFunction)PyCurses_noqiflush, METH_NOARGS},
2684  {"noraw",               (PyCFunction)PyCurses_noraw, METH_NOARGS},
2685  {"pair_content",        (PyCFunction)PyCurses_Pair_Content, METH_VARARGS},
2686  {"pair_number",         (PyCFunction)PyCurses_pair_number, METH_VARARGS},
2687  {"putp",                (PyCFunction)PyCurses_Putp, METH_VARARGS},
2688  {"qiflush",             (PyCFunction)PyCurses_QiFlush, METH_VARARGS},
2689  {"raw",                 (PyCFunction)PyCurses_raw, METH_VARARGS},
2690  {"reset_prog_mode",     (PyCFunction)PyCurses_reset_prog_mode, METH_NOARGS},
2691  {"reset_shell_mode",    (PyCFunction)PyCurses_reset_shell_mode, METH_NOARGS},
2692  {"resetty",             (PyCFunction)PyCurses_resetty, METH_NOARGS},
2693#ifdef HAVE_CURSES_RESIZETERM
2694  {"resizeterm",          (PyCFunction)PyCurses_ResizeTerm, METH_VARARGS},
2695#endif
2696#ifdef HAVE_CURSES_RESIZE_TERM
2697  {"resize_term",         (PyCFunction)PyCurses_Resize_Term, METH_VARARGS},
2698#endif
2699  {"savetty",             (PyCFunction)PyCurses_savetty, METH_NOARGS},
2700  {"setsyx",              (PyCFunction)PyCurses_setsyx, METH_VARARGS},
2701  {"setupterm",           (PyCFunction)PyCurses_setupterm,
2702   METH_VARARGS|METH_KEYWORDS},
2703  {"start_color",         (PyCFunction)PyCurses_Start_Color, METH_NOARGS},
2704  {"termattrs",           (PyCFunction)PyCurses_termattrs, METH_NOARGS},
2705  {"termname",            (PyCFunction)PyCurses_termname, METH_NOARGS},
2706  {"tigetflag",		  (PyCFunction)PyCurses_tigetflag, METH_VARARGS},
2707  {"tigetnum",		  (PyCFunction)PyCurses_tigetnum, METH_VARARGS},
2708  {"tigetstr",		  (PyCFunction)PyCurses_tigetstr, METH_VARARGS},
2709  {"tparm",               (PyCFunction)PyCurses_tparm, METH_VARARGS},
2710  {"typeahead",           (PyCFunction)PyCurses_TypeAhead, METH_VARARGS},
2711  {"unctrl",              (PyCFunction)PyCurses_UnCtrl, METH_VARARGS},
2712  {"ungetch",             (PyCFunction)PyCurses_UngetCh, METH_VARARGS},
2713  {"use_env",             (PyCFunction)PyCurses_Use_Env, METH_VARARGS},
2714#ifndef STRICT_SYSV_CURSES
2715  {"use_default_colors",  (PyCFunction)PyCurses_Use_Default_Colors, METH_NOARGS},
2716#endif
2717  {NULL,		  NULL}		/* sentinel */
2718};
2719
2720/* Initialization function for the module */
2721
2722PyMODINIT_FUNC
2723init_curses(void)
2724{
2725	PyObject *m, *d, *v, *c_api_object;
2726	static void *PyCurses_API[PyCurses_API_pointers];
2727
2728	/* Initialize object type */
2729	Py_TYPE(&PyCursesWindow_Type) = &PyType_Type;
2730
2731	/* Initialize the C API pointer array */
2732	PyCurses_API[0] = (void *)&PyCursesWindow_Type;
2733	PyCurses_API[1] = (void *)func_PyCursesSetupTermCalled;
2734	PyCurses_API[2] = (void *)func_PyCursesInitialised;
2735	PyCurses_API[3] = (void *)func_PyCursesInitialisedColor;
2736
2737	/* Create the module and add the functions */
2738	m = Py_InitModule("_curses", PyCurses_methods);
2739	if (m == NULL)
2740    		return;
2741
2742	/* Add some symbolic constants to the module */
2743	d = PyModule_GetDict(m);
2744	if (d == NULL)
2745		return;
2746	ModDict = d; /* For PyCurses_InitScr to use later */
2747
2748	/* Add a CObject for the C API */
2749	c_api_object = PyCObject_FromVoidPtr((void *)PyCurses_API, NULL);
2750	PyDict_SetItemString(d, "_C_API", c_api_object);
2751	Py_DECREF(c_api_object);
2752
2753	/* For exception curses.error */
2754	PyCursesError = PyErr_NewException("_curses.error", NULL, NULL);
2755	PyDict_SetItemString(d, "error", PyCursesError);
2756
2757	/* Make the version available */
2758	v = PyString_FromString(PyCursesVersion);
2759	PyDict_SetItemString(d, "version", v);
2760	PyDict_SetItemString(d, "__version__", v);
2761	Py_DECREF(v);
2762
2763        SetDictInt("ERR", ERR);
2764        SetDictInt("OK", OK);
2765
2766	/* Here are some attributes you can add to chars to print */
2767	
2768	SetDictInt("A_ATTRIBUTES",      A_ATTRIBUTES);
2769	SetDictInt("A_NORMAL",		A_NORMAL);
2770	SetDictInt("A_STANDOUT",	A_STANDOUT);
2771	SetDictInt("A_UNDERLINE",	A_UNDERLINE);
2772	SetDictInt("A_REVERSE",		A_REVERSE);
2773	SetDictInt("A_BLINK",		A_BLINK);
2774	SetDictInt("A_DIM",		A_DIM);
2775	SetDictInt("A_BOLD",		A_BOLD);
2776	SetDictInt("A_ALTCHARSET",	A_ALTCHARSET);
2777#if !defined(__NetBSD__)
2778	SetDictInt("A_INVIS",           A_INVIS);
2779#endif
2780	SetDictInt("A_PROTECT",         A_PROTECT);
2781	SetDictInt("A_CHARTEXT",        A_CHARTEXT);
2782	SetDictInt("A_COLOR",           A_COLOR);
2783
2784	/* The following are never available with strict SYSV curses */
2785#ifdef A_HORIZONTAL
2786	SetDictInt("A_HORIZONTAL",      A_HORIZONTAL);
2787#endif
2788#ifdef A_LEFT
2789	SetDictInt("A_LEFT",            A_LEFT);
2790#endif
2791#ifdef A_LOW
2792	SetDictInt("A_LOW",             A_LOW);
2793#endif
2794#ifdef A_RIGHT
2795	SetDictInt("A_RIGHT",           A_RIGHT);
2796#endif
2797#ifdef A_TOP
2798	SetDictInt("A_TOP",             A_TOP);
2799#endif
2800#ifdef A_VERTICAL
2801	SetDictInt("A_VERTICAL",        A_VERTICAL);
2802#endif
2803
2804	SetDictInt("COLOR_BLACK",       COLOR_BLACK);
2805	SetDictInt("COLOR_RED",         COLOR_RED);
2806	SetDictInt("COLOR_GREEN",       COLOR_GREEN);
2807	SetDictInt("COLOR_YELLOW",      COLOR_YELLOW);
2808	SetDictInt("COLOR_BLUE",        COLOR_BLUE);
2809	SetDictInt("COLOR_MAGENTA",     COLOR_MAGENTA);
2810	SetDictInt("COLOR_CYAN",        COLOR_CYAN);
2811	SetDictInt("COLOR_WHITE",       COLOR_WHITE);
2812
2813#ifdef NCURSES_MOUSE_VERSION
2814	/* Mouse-related constants */
2815	SetDictInt("BUTTON1_PRESSED",          BUTTON1_PRESSED);
2816	SetDictInt("BUTTON1_RELEASED",         BUTTON1_RELEASED);
2817	SetDictInt("BUTTON1_CLICKED",          BUTTON1_CLICKED);
2818	SetDictInt("BUTTON1_DOUBLE_CLICKED",   BUTTON1_DOUBLE_CLICKED);
2819	SetDictInt("BUTTON1_TRIPLE_CLICKED",   BUTTON1_TRIPLE_CLICKED);
2820
2821	SetDictInt("BUTTON2_PRESSED",          BUTTON2_PRESSED);
2822	SetDictInt("BUTTON2_RELEASED",         BUTTON2_RELEASED);
2823	SetDictInt("BUTTON2_CLICKED",          BUTTON2_CLICKED);
2824	SetDictInt("BUTTON2_DOUBLE_CLICKED",   BUTTON2_DOUBLE_CLICKED);
2825	SetDictInt("BUTTON2_TRIPLE_CLICKED",   BUTTON2_TRIPLE_CLICKED);
2826
2827	SetDictInt("BUTTON3_PRESSED",          BUTTON3_PRESSED);
2828	SetDictInt("BUTTON3_RELEASED",         BUTTON3_RELEASED);
2829	SetDictInt("BUTTON3_CLICKED",          BUTTON3_CLICKED);
2830	SetDictInt("BUTTON3_DOUBLE_CLICKED",   BUTTON3_DOUBLE_CLICKED);
2831	SetDictInt("BUTTON3_TRIPLE_CLICKED",   BUTTON3_TRIPLE_CLICKED);
2832
2833	SetDictInt("BUTTON4_PRESSED",          BUTTON4_PRESSED);
2834	SetDictInt("BUTTON4_RELEASED",         BUTTON4_RELEASED);
2835	SetDictInt("BUTTON4_CLICKED",          BUTTON4_CLICKED);
2836	SetDictInt("BUTTON4_DOUBLE_CLICKED",   BUTTON4_DOUBLE_CLICKED);
2837	SetDictInt("BUTTON4_TRIPLE_CLICKED",   BUTTON4_TRIPLE_CLICKED);
2838
2839	SetDictInt("BUTTON_SHIFT",             BUTTON_SHIFT);
2840	SetDictInt("BUTTON_CTRL",              BUTTON_CTRL);
2841	SetDictInt("BUTTON_ALT",               BUTTON_ALT);
2842
2843	SetDictInt("ALL_MOUSE_EVENTS",         ALL_MOUSE_EVENTS);
2844	SetDictInt("REPORT_MOUSE_POSITION",    REPORT_MOUSE_POSITION);
2845#endif
2846	/* Now set everything up for KEY_ variables */
2847	{
2848	  int key;
2849	  char *key_n;
2850	  char *key_n2;
2851#if !defined(__NetBSD__)
2852	  for (key=KEY_MIN;key < KEY_MAX; key++) {
2853	    key_n = (char *)keyname(key);
2854	    if (key_n == NULL || strcmp(key_n,"UNKNOWN KEY")==0)
2855	      continue;
2856	    if (strncmp(key_n,"KEY_F(",6)==0) {
2857	      char *p1, *p2;
2858	      key_n2 = malloc(strlen(key_n)+1);
2859	      if (!key_n2) {
2860		PyErr_NoMemory();
2861		break;
2862              }
2863	      p1 = key_n;
2864	      p2 = key_n2;
2865	      while (*p1) {
2866		if (*p1 != '(' && *p1 != ')') {
2867		  *p2 = *p1;
2868		  p2++;
2869		}
2870		p1++;
2871	      }
2872	      *p2 = (char)0;
2873	    } else
2874	      key_n2 = key_n;
2875	    SetDictInt(key_n2,key);
2876	    if (key_n2 != key_n)
2877	      free(key_n2);
2878	  }
2879#endif
2880	  SetDictInt("KEY_MIN", KEY_MIN);
2881	  SetDictInt("KEY_MAX", KEY_MAX);
2882	}
2883}