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 

    38 A number of SysV or ncurses functions don't have wrappers yet; if you

    39 need a given function, add it and send a patch.  See

    40 http://www.python.org/dev/patches/ for instructions on how to submit

    41 patches to Python.

    42 

    43 Here'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 

    56 Low-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 

    61 Menu 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 

    77 Form 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 

   101 char *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. */

   122 extern 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 */

   129 typedef 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 

   138 static PyObject *PyCursesError;

   139 

   140 /* Tells whether setupterm() has been called to initialise terminfo.  */

   141 static int initialised_setupterm = FALSE;

   142 

   143 /* Tells whether initscr() has been called to initialise curses.  */

   144 static int initialised = FALSE;

   145 

   146 /* Tells whether start_color() has been called to initialise color usage. */

   147 static 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 

   180 static PyObject *

   181 PyCursesCheckERR(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 

   196 static int 

   197 PyCurses_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    

   213 static int func_PyCursesSetupTermCalled(void)

   214 {

   215     PyCursesSetupTermCalled;

   216     return 1;

   217 }

   218 

   219 static int func_PyCursesInitialised(void)

   220 {

   221     PyCursesInitialised;

   222     return 1;

   223 }

   224 

   225 static 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 

   237 PyTypeObject 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) \

   248 static PyObject *PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \

   249 { return PyCursesCheckERR(X(self->win), # X); }

   250 

   251 #define Window_NoArgTrueFalseFunction(X) \

   252 static 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) \

   258 static 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) \

   263 static 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) \

   269 static 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) \

   276 static 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) \

   283 static 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 

   291 Window_NoArgNoReturnFunction(untouchwin)

   292 Window_NoArgNoReturnFunction(touchwin)

   293 Window_NoArgNoReturnFunction(redrawwin)

   294 Window_NoArgNoReturnFunction(winsertln)

   295 Window_NoArgNoReturnFunction(werase)

   296 Window_NoArgNoReturnFunction(wdeleteln)

   297 

   298 Window_NoArgTrueFalseFunction(is_wintouched)

   299 

   300 Window_NoArgNoReturnVoidFunction(wsyncup)

   301 Window_NoArgNoReturnVoidFunction(wsyncdown)

   302 Window_NoArgNoReturnVoidFunction(wstandend)

   303 Window_NoArgNoReturnVoidFunction(wstandout)

   304 Window_NoArgNoReturnVoidFunction(wcursyncup)

   305 Window_NoArgNoReturnVoidFunction(wclrtoeol)

   306 Window_NoArgNoReturnVoidFunction(wclrtobot)

   307 Window_NoArgNoReturnVoidFunction(wclear)

   308 

   309 Window_OneArgNoReturnVoidFunction(idcok, int, "i;True(1) or False(0)")

   310 Window_OneArgNoReturnVoidFunction(immedok, int, "i;True(1) or False(0)")

   311 Window_OneArgNoReturnVoidFunction(wtimeout, int, "i;delay")

   312 

   313 Window_NoArg2TupleReturnFunction(getyx, int, "ii")

   314 Window_NoArg2TupleReturnFunction(getbegyx, int, "ii")

   315 Window_NoArg2TupleReturnFunction(getmaxyx, int, "ii")

   316 Window_NoArg2TupleReturnFunction(getparyx, int, "ii")

   317 

   318 Window_OneArgNoReturnFunction(clearok, int, "i;True(1) or False(0)")

   319 Window_OneArgNoReturnFunction(idlok, int, "i;True(1) or False(0)")

   320 #if defined(__NetBSD__)

   321 Window_OneArgNoReturnVoidFunction(keypad, int, "i;True(1) or False(0)")

   322 #else

   323 Window_OneArgNoReturnFunction(keypad, int, "i;True(1) or False(0)")

   324 #endif

   325 Window_OneArgNoReturnFunction(leaveok, int, "i;True(1) or False(0)")

   326 #if defined(__NetBSD__)

   327 Window_OneArgNoReturnVoidFunction(nodelay, int, "i;True(1) or False(0)")

   328 #else

   329 Window_OneArgNoReturnFunction(nodelay, int, "i;True(1) or False(0)")

   330 #endif

   331 Window_OneArgNoReturnFunction(notimeout, int, "i;True(1) or False(0)")

   332 Window_OneArgNoReturnFunction(scrollok, int, "i;True(1) or False(0)")

   333 Window_OneArgNoReturnFunction(winsdelln, int, "i;nlines")

   334 Window_OneArgNoReturnFunction(syncok, int, "i;True(1) or False(0)")

   335 

   336 Window_TwoArgNoReturnFunction(mvwin, int, "ii;y,x")

   337 Window_TwoArgNoReturnFunction(mvderwin, int, "ii;y,x")

   338 Window_TwoArgNoReturnFunction(wmove, int, "ii;y,x")

   339 #ifndef STRICT_SYSV_CURSES

   340 Window_TwoArgNoReturnFunction(wresize, int, "ii;lines,columns")

   341 #endif

   342 

   343 /* Allocation and deallocation of Window Objects */

   344 

   345 static PyObject *

   346 PyCursesWindow_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 

   356 static void

   357 PyCursesWindow_Dealloc(PyCursesWindowObject *wo)

   358 {

   359   if (wo->win != stdscr) delwin(wo->win);

   360   PyObject_DEL(wo);

   361 }

   362 

   363 /* Addch, Addstr, Addnstr */

   364 

   365 static PyObject *

   366 PyCursesWindow_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 

   414 static PyObject *

   415 PyCursesWindow_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 

   464 static PyObject *

   465 PyCursesWindow_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 

   513 static PyObject *

   514 PyCursesWindow_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 

   544 static PyObject *

   545 PyCursesWindow_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 

   553 static PyObject *

   554 PyCursesWindow_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 

   562 static PyObject *

   563 PyCursesWindow_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 

   571 static PyObject *

   572 PyCursesWindow_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 

   603 static PyObject *

   604 PyCursesWindow_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 

   636 static PyObject *

   637 PyCursesWindow_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

   654 int 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 

   665 static PyObject *

   666 PyCursesWindow_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 

   719 static PyObject *

   720 PyCursesWindow_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 

   741 static PyObject *

   742 PyCursesWindow_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 

   774 static PyObject *

   775 PyCursesWindow_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

   815 static PyObject *

   816 PyCursesWindow_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 

   826 static PyObject *

   827 PyCursesWindow_GetBkgd(PyCursesWindowObject *self)

   828 {

   829   return PyInt_FromLong((long) getbkgd(self->win));

   830 }

   831 

   832 static PyObject *

   833 PyCursesWindow_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 

   858 static PyObject *

   859 PyCursesWindow_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 

   895 static PyObject *

   896 PyCursesWindow_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 

   949 static PyObject *

   950 PyCursesWindow_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 

   996 static PyObject *

   997 PyCursesWindow_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 

  1045 static PyObject *

  1046 PyCursesWindow_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 

  1066 static PyObject *

  1067 PyCursesWindow_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 

  1101 static PyObject *

  1102 PyCursesWindow_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;