_cursesmodule.c | searchcode

/Modules/_cursesmodule.c

Large files files are truncated, but you can click here to view the full 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…
Large files files are truncated, but you can click here to view the full file