2 * This is a curses module for Python.
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.
8 * Version 1.5b1, heavily extended for ncurses by Oliver Andrich:
9 * Copyright 1996,1997 by Oliver Andrich, Koblenz, Germany.
11 * Tidied for Python 1.6, and currently maintained by <amk@amk.ca>.
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:
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
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.
38 A number of SysV or ncurses functions don't have wrappers yet; if you need
39 a given function, add it and send a patch. Here's a list of currently
40 unsupported functions:
42 addchnstr addchstr chgat color_set define_key
43 del_curterm delscreen dupwin inchnstr inchstr innstr keyok
44 mcprint mvaddchnstr mvaddchstr mvchgat mvcur mvinchnstr
45 mvinchstr mvinnstr mmvwaddchnstr mvwaddchstr mvwchgat
46 mvwgetnstr mvwinchnstr mvwinchstr mvwinnstr newterm
47 resizeterm restartterm ripoffline scr_dump
48 scr_init scr_restore scr_set scrl set_curterm set_term setterm
49 tgetent tgetflag tgetnum tgetstr tgoto timeout tputs
50 vidattr vidputs waddchnstr waddchstr wchgat
51 wcolor_set winchnstr winchstr winnstr wmouse_trafo wscrl
54 slk_attr slk_attr_off slk_attr_on slk_attr_set slk_attroff
55 slk_attron slk_attrset slk_clear slk_color slk_init slk_label
56 slk_noutrefresh slk_refresh slk_restore slk_set slk_touch
58 Menu extension (ncurses and probably SYSV):
59 current_item free_item free_menu item_count item_description
60 item_index item_init item_name item_opts item_opts_off
61 item_opts_on item_term item_userptr item_value item_visible
62 menu_back menu_driver menu_fore menu_format menu_grey
63 menu_init menu_items menu_mark menu_opts menu_opts_off
64 menu_opts_on menu_pad menu_pattern menu_request_by_name
65 menu_request_name menu_spacing menu_sub menu_term menu_userptr
66 menu_win new_item new_menu pos_menu_cursor post_menu
67 scale_menu set_current_item set_item_init set_item_opts
68 set_item_term set_item_userptr set_item_value set_menu_back
69 set_menu_fore set_menu_format set_menu_grey set_menu_init
70 set_menu_items set_menu_mark set_menu_opts set_menu_pad
71 set_menu_pattern set_menu_spacing set_menu_sub set_menu_term
72 set_menu_userptr set_menu_win set_top_row top_row unpost_menu
74 Form extension (ncurses and probably SYSV):
75 current_field data_ahead data_behind dup_field
76 dynamic_fieldinfo field_arg field_back field_buffer
77 field_count field_fore field_index field_info field_init
78 field_just field_opts field_opts_off field_opts_on field_pad
79 field_status field_term field_type field_userptr form_driver
80 form_fields form_init form_opts form_opts_off form_opts_on
81 form_page form_request_by_name form_request_name form_sub
82 form_term form_userptr form_win free_field free_form
83 link_field link_fieldtype move_field new_field new_form
84 new_page pos_form_cursor post_form scale_form
85 set_current_field set_field_back set_field_buffer
86 set_field_fore set_field_init set_field_just set_field_opts
87 set_field_pad set_field_status set_field_term set_field_type
88 set_field_userptr set_fieldtype_arg set_fieldtype_choice
89 set_form_fields set_form_init set_form_opts set_form_page
90 set_form_sub set_form_term set_form_userptr set_form_win
91 set_max_field set_new_page unpost_form
98 char *PyCursesVersion
= "2.2";
105 #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
109 #define STRICT_SYSV_CURSES
112 #define CURSES_MODULE
113 #include "py_curses.h"
115 /* These prototypes are in <term.h>, but including this header
116 #defines many common symbols (such as "lines") which breaks the
117 curses module in other ways. So the code will just specify
118 explicit prototypes here. */
119 extern int setupterm(char *,int,int *);
124 #if !defined(HAVE_NCURSES_H) && (defined(sgi) || defined(__sun) || defined(SCO5))
125 #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
126 typedef chtype attr_t
; /* No attr_t type is available */
130 #define STRICT_SYSV_CURSES
133 /* Definition of exception curses.error */
135 static PyObject
*PyCursesError
;
137 /* Tells whether setupterm() has been called to initialise terminfo. */
138 static int initialised_setupterm
= FALSE
;
140 /* Tells whether initscr() has been called to initialise curses. */
141 static int initialised
= FALSE
;
143 /* Tells whether start_color() has been called to initialise color usage. */
144 static int initialisedcolors
= FALSE
;
147 #define PyCursesSetupTermCalled \
148 if (initialised_setupterm != TRUE) { \
149 PyErr_SetString(PyCursesError, \
150 "must call (at least) setupterm() first"); \
153 #define PyCursesInitialised \
154 if (initialised != TRUE) { \
155 PyErr_SetString(PyCursesError, \
156 "must call initscr() first"); \
159 #define PyCursesInitialisedColor \
160 if (initialisedcolors != TRUE) { \
161 PyErr_SetString(PyCursesError, \
162 "must call start_color() first"); \
166 #define MIN(x,y) ((x) < (y) ? (x) : (y))
169 /* Utility Functions */
172 * Check the return code from a curses function and return None
173 * or raise an exception as appropriate. These are exported using the
178 PyCursesCheckERR(int code
, char *fname
)
185 PyErr_SetString(PyCursesError
, catchall_ERR
);
187 PyErr_Format(PyCursesError
, "%s() returned ERR", fname
);
194 PyCurses_ConvertToChtype(PyObject
*obj
, chtype
*ch
)
196 if (PyInt_Check(obj
)) {
197 *ch
= (chtype
) PyInt_AsLong(obj
);
198 } else if(PyString_Check(obj
)
199 && (PyString_Size(obj
) == 1)) {
200 *ch
= (chtype
) *PyString_AsString(obj
);
207 /* Function versions of the 3 functions for tested whether curses has been
208 initialised or not. */
210 static int func_PyCursesSetupTermCalled(void)
212 PyCursesSetupTermCalled
;
216 static int func_PyCursesInitialised(void)
222 static int func_PyCursesInitialisedColor(void)
224 PyCursesInitialisedColor
;
228 /*****************************************************************************
230 ******************************************************************************/
232 /* Definition of the window type */
234 PyTypeObject PyCursesWindow_Type
;
236 /* Function prototype macros for Window object
239 TYPE - parameter Type
240 ERGSTR - format string for construction of the return value
241 PARSESTR - format string for argument parsing
244 #define Window_NoArgNoReturnFunction(X) \
245 static PyObject *PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
246 { return PyCursesCheckERR(X(self->win), # X); }
248 #define Window_NoArgTrueFalseFunction(X) \
249 static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
251 if (X (self->win) == FALSE) { Py_INCREF(Py_False); return Py_False; } \
252 else { Py_INCREF(Py_True); return Py_True; } }
254 #define Window_NoArgNoReturnVoidFunction(X) \
255 static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
257 X(self->win); Py_INCREF(Py_None); return Py_None; }
259 #define Window_NoArg2TupleReturnFunction(X, TYPE, ERGSTR) \
260 static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
263 X(self->win,arg1,arg2); return Py_BuildValue(ERGSTR, arg1, arg2); }
265 #define Window_OneArgNoReturnVoidFunction(X, TYPE, PARSESTR) \
266 static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
269 if (!PyArg_ParseTuple(args, PARSESTR, &arg1)) return NULL; \
270 X(self->win,arg1); Py_INCREF(Py_None); return Py_None; }
272 #define Window_OneArgNoReturnFunction(X, TYPE, PARSESTR) \
273 static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
276 if (!PyArg_ParseTuple(args,PARSESTR, &arg1)) return NULL; \
277 return PyCursesCheckERR(X(self->win, arg1), # X); }
279 #define Window_TwoArgNoReturnFunction(X, TYPE, PARSESTR) \
280 static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
283 if (!PyArg_ParseTuple(args,PARSESTR, &arg1, &arg2)) return NULL; \
284 return PyCursesCheckERR(X(self->win, arg1, arg2), # X); }
286 /* ------------- WINDOW routines --------------- */
288 Window_NoArgNoReturnFunction(untouchwin
)
289 Window_NoArgNoReturnFunction(touchwin
)
290 Window_NoArgNoReturnFunction(redrawwin
)
291 Window_NoArgNoReturnFunction(winsertln
)
292 Window_NoArgNoReturnFunction(werase
)
293 Window_NoArgNoReturnFunction(wdeleteln
)
295 Window_NoArgTrueFalseFunction(is_wintouched
)
297 Window_NoArgNoReturnVoidFunction(wsyncup
)
298 Window_NoArgNoReturnVoidFunction(wsyncdown
)
299 Window_NoArgNoReturnVoidFunction(wstandend
)
300 Window_NoArgNoReturnVoidFunction(wstandout
)
301 Window_NoArgNoReturnVoidFunction(wcursyncup
)
302 Window_NoArgNoReturnVoidFunction(wclrtoeol
)
303 Window_NoArgNoReturnVoidFunction(wclrtobot
)
304 Window_NoArgNoReturnVoidFunction(wclear
)
306 Window_OneArgNoReturnVoidFunction(idcok
, int, "i;True(1) or False(0)")
307 Window_OneArgNoReturnVoidFunction(immedok
, int, "i;True(1) or False(0)")
308 Window_OneArgNoReturnVoidFunction(wtimeout
, int, "i;delay")
310 Window_NoArg2TupleReturnFunction(getyx
, int, "ii")
311 Window_NoArg2TupleReturnFunction(getbegyx
, int, "ii")
312 Window_NoArg2TupleReturnFunction(getmaxyx
, int, "ii")
313 Window_NoArg2TupleReturnFunction(getparyx
, int, "ii")
315 Window_OneArgNoReturnFunction(wattron
, attr_t
, "l;attr")
316 Window_OneArgNoReturnFunction(wattroff
, attr_t
, "l;attr")
317 Window_OneArgNoReturnFunction(wattrset
, attr_t
, "l;attr")
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)")
323 Window_OneArgNoReturnFunction(keypad
, int, "i;True(1) or False(0)")
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)")
329 Window_OneArgNoReturnFunction(nodelay
, int, "i;True(1) or False(0)")
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)")
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")
343 /* Allocation and deallocation of Window Objects */
346 PyCursesWindow_New(WINDOW
*win
)
348 PyCursesWindowObject
*wo
;
350 wo
= PyObject_NEW(PyCursesWindowObject
, &PyCursesWindow_Type
);
351 if (wo
== NULL
) return NULL
;
353 return (PyObject
*)wo
;
357 PyCursesWindow_Dealloc(PyCursesWindowObject
*wo
)
359 if (wo
->win
!= stdscr
) delwin(wo
->win
);
363 /* Addch, Addstr, Addnstr */
366 PyCursesWindow_AddCh(PyCursesWindowObject
*self
, PyObject
*args
)
368 int rtn
, x
, y
, use_xy
= FALSE
;
371 attr_t attr
= A_NORMAL
;
373 switch (PyTuple_Size(args
)) {
375 if (!PyArg_ParseTuple(args
, "O;ch or int", &temp
))
379 if (!PyArg_ParseTuple(args
, "Ol;ch or int,attr", &temp
, &attr
))
383 if (!PyArg_ParseTuple(args
,"iiO;y,x,ch or int", &y
, &x
, &temp
))
388 if (!PyArg_ParseTuple(args
,"iiOl;y,x,ch or int, attr",
389 &y
, &x
, &temp
, &attr
))
394 PyErr_SetString(PyExc_TypeError
, "addch requires 1 to 4 arguments");
398 if (!PyCurses_ConvertToChtype(temp
, &ch
)) {
399 PyErr_SetString(PyExc_TypeError
, "argument 1 or 3 must be a ch or an int");
404 rtn
= mvwaddch(self
->win
,y
,x
, ch
| attr
);
406 rtn
= waddch(self
->win
, ch
| attr
);
408 return PyCursesCheckERR(rtn
, "addch");
412 PyCursesWindow_AddStr(PyCursesWindowObject
*self
, PyObject
*args
)
417 attr_t attr
= A_NORMAL
, attr_old
= A_NORMAL
;
418 int use_xy
= FALSE
, use_attr
= FALSE
;
420 switch (PyTuple_Size(args
)) {
422 if (!PyArg_ParseTuple(args
,"s;str", &str
))
426 if (!PyArg_ParseTuple(args
,"sl;str,attr", &str
, &attr
))
431 if (!PyArg_ParseTuple(args
,"iis;int,int,str", &y
, &x
, &str
))
436 if (!PyArg_ParseTuple(args
,"iisl;int,int,str,attr", &y
, &x
, &str
, &attr
))
438 use_xy
= use_attr
= TRUE
;
441 PyErr_SetString(PyExc_TypeError
, "addstr requires 1 to 4 arguments");
445 if (use_attr
== TRUE
) {
446 attr_old
= getattrs(self
->win
);
447 wattrset(self
->win
,attr
);
450 rtn
= mvwaddstr(self
->win
,y
,x
,str
);
452 rtn
= waddstr(self
->win
,str
);
453 if (use_attr
== TRUE
)
454 wattrset(self
->win
,attr_old
);
455 return PyCursesCheckERR(rtn
, "addstr");
459 PyCursesWindow_AddNStr(PyCursesWindowObject
*self
, PyObject
*args
)
463 attr_t attr
= A_NORMAL
, attr_old
= A_NORMAL
;
464 int use_xy
= FALSE
, use_attr
= FALSE
;
466 switch (PyTuple_Size(args
)) {
468 if (!PyArg_ParseTuple(args
,"si;str,n", &str
, &n
))
472 if (!PyArg_ParseTuple(args
,"sil;str,n,attr", &str
, &n
, &attr
))
477 if (!PyArg_ParseTuple(args
,"iisi;y,x,str,n", &y
, &x
, &str
, &n
))
482 if (!PyArg_ParseTuple(args
,"iisil;y,x,str,n,attr", &y
, &x
, &str
, &n
, &attr
))
484 use_xy
= use_attr
= TRUE
;
487 PyErr_SetString(PyExc_TypeError
, "addnstr requires 2 to 5 arguments");
491 if (use_attr
== TRUE
) {
492 attr_old
= getattrs(self
->win
);
493 wattrset(self
->win
,attr
);
496 rtn
= mvwaddnstr(self
->win
,y
,x
,str
,n
);
498 rtn
= waddnstr(self
->win
,str
,n
);
499 if (use_attr
== TRUE
)
500 wattrset(self
->win
,attr_old
);
501 return PyCursesCheckERR(rtn
, "addnstr");
505 PyCursesWindow_Bkgd(PyCursesWindowObject
*self
, PyObject
*args
)
509 attr_t attr
= A_NORMAL
;
511 switch (PyTuple_Size(args
)) {
513 if (!PyArg_ParseTuple(args
, "O;ch or int", &temp
))
517 if (!PyArg_ParseTuple(args
,"Ol;ch or int,attr", &temp
, &attr
))
521 PyErr_SetString(PyExc_TypeError
, "bkgd requires 1 or 2 arguments");
525 if (!PyCurses_ConvertToChtype(temp
, &bkgd
)) {
526 PyErr_SetString(PyExc_TypeError
, "argument 1 or 3 must be a ch or an int");
530 return PyCursesCheckERR(wbkgd(self
->win
, bkgd
| attr
), "bkgd");
534 PyCursesWindow_BkgdSet(PyCursesWindowObject
*self
, PyObject
*args
)
538 attr_t attr
= A_NORMAL
;
540 switch (PyTuple_Size(args
)) {
542 if (!PyArg_ParseTuple(args
, "O;ch or int", &temp
))
546 if (!PyArg_ParseTuple(args
,"Ol;ch or int,attr", &temp
, &attr
))
550 PyErr_SetString(PyExc_TypeError
, "bkgdset requires 1 or 2 arguments");
554 if (!PyCurses_ConvertToChtype(temp
, &bkgd
)) {
555 PyErr_SetString(PyExc_TypeError
, "argument 1 must be a ch or an int");
559 wbkgdset(self
->win
, bkgd
| attr
);
560 return PyCursesCheckERR(0, "bkgdset");
564 PyCursesWindow_Border(PyCursesWindowObject
*self
, PyObject
*args
)
570 /* Clear the array of parameters */
576 if (!PyArg_ParseTuple(args
,"|OOOOOOOO;ls,rs,ts,bs,tl,tr,bl,br",
577 &temp
[0], &temp
[1], &temp
[2], &temp
[3],
578 &temp
[4], &temp
[5], &temp
[6], &temp
[7]))
582 if (temp
[i
] != NULL
&& !PyCurses_ConvertToChtype(temp
[i
], &ch
[i
])) {
583 PyErr_Format(PyExc_TypeError
,
584 "argument %i must be a ch or an int", i
+1);
590 ch
[0], ch
[1], ch
[2], ch
[3],
591 ch
[4], ch
[5], ch
[6], ch
[7]);
597 PyCursesWindow_Box(PyCursesWindowObject
*self
, PyObject
*args
)
600 switch(PyTuple_Size(args
)){
603 if (!PyArg_ParseTuple(args
,"ll;vertint,horint", &ch1
, &ch2
))
606 box(self
->win
,ch1
,ch2
);
611 #if defined(HAVE_NCURSES_H) || defined(MVWDELCH_IS_EXPRESSION)
612 #define py_mvwdelch mvwdelch
614 int py_mvwdelch(WINDOW
*w
, int y
, int x
)
617 /* On HP/UX, mvwdelch already returns. On other systems,
618 we may well run into this return statement. */
625 PyCursesWindow_DelCh(PyCursesWindowObject
*self
, PyObject
*args
)
630 switch (PyTuple_Size(args
)) {
632 rtn
= wdelch(self
->win
);
635 if (!PyArg_ParseTuple(args
,"ii;y,x", &y
, &x
))
637 rtn
= py_mvwdelch(self
->win
,y
,x
);
640 PyErr_SetString(PyExc_TypeError
, "delch requires 0 or 2 arguments");
643 return PyCursesCheckERR(rtn
, "[mv]wdelch");
647 PyCursesWindow_DerWin(PyCursesWindowObject
*self
, PyObject
*args
)
650 int nlines
, ncols
, begin_y
, begin_x
;
654 switch (PyTuple_Size(args
)) {
656 if (!PyArg_ParseTuple(args
,"ii;begin_y,begin_x",&begin_y
,&begin_x
))
660 if (!PyArg_ParseTuple(args
, "iiii;nlines,ncols,begin_y,begin_x",
661 &nlines
,&ncols
,&begin_y
,&begin_x
))
665 PyErr_SetString(PyExc_TypeError
, "derwin requires 2 or 4 arguments");
669 win
= derwin(self
->win
,nlines
,ncols
,begin_y
,begin_x
);
672 PyErr_SetString(PyCursesError
, catchall_NULL
);
676 return (PyObject
*)PyCursesWindow_New(win
);
680 PyCursesWindow_EchoChar(PyCursesWindowObject
*self
, PyObject
*args
)
684 attr_t attr
= A_NORMAL
;
686 switch (PyTuple_Size(args
)) {
688 if (!PyArg_ParseTuple(args
,"O;ch or int", &temp
))
692 if (!PyArg_ParseTuple(args
,"Ol;ch or int,attr", &temp
, &attr
))
696 PyErr_SetString(PyExc_TypeError
, "echochar requires 1 or 2 arguments");
702 if (!PyCurses_ConvertToChtype(temp
, &ch
)) {
703 PyErr_SetString(PyExc_TypeError
, "argument 1 must be a ch or an int");
707 #ifdef WINDOW_HAS_FLAGS
708 if (self
->win
->_flags
& _ISPAD
)
709 return PyCursesCheckERR(pechochar(self
->win
, ch
| attr
),
713 return PyCursesCheckERR(wechochar(self
->win
, ch
| attr
),
717 #ifdef NCURSES_MOUSE_VERSION
719 PyCursesWindow_Enclose(PyCursesWindowObject
*self
, PyObject
*args
)
722 if (!PyArg_ParseTuple(args
,"ii;y,x", &y
, &x
))
725 return PyInt_FromLong( wenclose(self
->win
,y
,x
) );
730 PyCursesWindow_GetBkgd(PyCursesWindowObject
*self
)
732 return PyInt_FromLong((long) getbkgd(self
->win
));
736 PyCursesWindow_GetCh(PyCursesWindowObject
*self
, PyObject
*args
)
741 switch (PyTuple_Size(args
)) {
743 Py_BEGIN_ALLOW_THREADS
744 rtn
= wgetch(self
->win
);
748 if (!PyArg_ParseTuple(args
,"ii;y,x",&y
,&x
))
750 Py_BEGIN_ALLOW_THREADS
751 rtn
= mvwgetch(self
->win
,y
,x
);
755 PyErr_SetString(PyExc_TypeError
, "getch requires 0 or 2 arguments");
758 return PyInt_FromLong((long)rtn
);
762 PyCursesWindow_GetKey(PyCursesWindowObject
*self
, PyObject
*args
)
767 switch (PyTuple_Size(args
)) {
769 Py_BEGIN_ALLOW_THREADS
770 rtn
= wgetch(self
->win
);
774 if (!PyArg_ParseTuple(args
,"ii;y,x",&y
,&x
))
776 Py_BEGIN_ALLOW_THREADS
777 rtn
= mvwgetch(self
->win
,y
,x
);
781 PyErr_SetString(PyExc_TypeError
, "getkey requires 0 or 2 arguments");
785 /* getch() returns ERR in nodelay mode */
786 PyErr_SetString(PyCursesError
, "no input");
789 return Py_BuildValue("c", rtn
);
791 #if defined(__NetBSD__)
792 return PyString_FromString(unctrl(rtn
));
794 return PyString_FromString((char *)keyname(rtn
));
799 PyCursesWindow_GetStr(PyCursesWindowObject
*self
, PyObject
*args
)
802 char rtn
[1024]; /* This should be big enough.. I hope */
805 switch (PyTuple_Size(args
)) {
807 Py_BEGIN_ALLOW_THREADS
808 rtn2
= wgetnstr(self
->win
,rtn
, 1023);
812 if (!PyArg_ParseTuple(args
,"i;n", &n
))
814 Py_BEGIN_ALLOW_THREADS
815 rtn2
= wgetnstr(self
->win
,rtn
,MIN(n
, 1023));
819 if (!PyArg_ParseTuple(args
,"ii;y,x",&y
,&x
))
821 Py_BEGIN_ALLOW_THREADS
822 rtn2
= mvwgetnstr(self
->win
,y
,x
,rtn
, 1023);
826 if (!PyArg_ParseTuple(args
,"iii;y,x,n", &y
, &x
, &n
))
828 #ifdef STRICT_SYSV_CURSES
830 Py_BEGIN_ALLOW_THREADS
831 rtn2
= wmove(self
->win
,y
,x
)==ERR
? ERR
:
832 wgetnstr(self
->win
, rtn
, MIN(n
, 1023));
835 Py_BEGIN_ALLOW_THREADS
836 rtn2
= mvwgetnstr(self
->win
, y
, x
, rtn
, MIN(n
, 1023));
841 PyErr_SetString(PyExc_TypeError
, "getstr requires 0 to 2 arguments");
846 return PyString_FromString(rtn
);
850 PyCursesWindow_Hline(PyCursesWindowObject
*self
, PyObject
*args
)
854 int n
, x
, y
, code
= OK
;
855 attr_t attr
= A_NORMAL
;
857 switch (PyTuple_Size(args
)) {
859 if (!PyArg_ParseTuple(args
, "Oi;ch or int,n", &temp
, &n
))
863 if (!PyArg_ParseTuple(args
, "Oil;ch or int,n,attr", &temp
, &n
, &attr
))
867 if (!PyArg_ParseTuple(args
, "iiOi;y,x,ch or int,n", &y
, &x
, &temp
, &n
))
869 code
= wmove(self
->win
, y
, x
);
872 if (!PyArg_ParseTuple(args
, "iiOil; y,x,ch or int,n,attr",
873 &y
, &x
, &temp
, &n
, &attr
))
875 code
= wmove(self
->win
, y
, x
);
878 PyErr_SetString(PyExc_TypeError
, "hline requires 2 to 5 arguments");
883 if (!PyCurses_ConvertToChtype(temp
, &ch
)) {
884 PyErr_SetString(PyExc_TypeError
,
885 "argument 1 or 3 must be a ch or an int");
888 return PyCursesCheckERR(whline(self
->win
, ch
| attr
, n
), "hline");
890 return PyCursesCheckERR(code
, "wmove");
894 PyCursesWindow_InsCh(PyCursesWindowObject
*self
, PyObject
*args
)
896 int rtn
, x
, y
, use_xy
= FALSE
;
899 attr_t attr
= A_NORMAL
;
901 switch (PyTuple_Size(args
)) {
903 if (!PyArg_ParseTuple(args
, "O;ch or int", &temp
))
907 if (!PyArg_ParseTuple(args
, "Ol;ch or int,attr", &temp
, &attr
))
911 if (!PyArg_ParseTuple(args
,"iiO;y,x,ch or int", &y
, &x
, &temp
))
916 if (!PyArg_ParseTuple(args
,"iiOl;y,x,ch or int, attr", &y
, &x
, &temp
, &attr
))
921 PyErr_SetString(PyExc_TypeError
, "insch requires 1 or 4 arguments");
925 if (!PyCurses_ConvertToChtype(temp
, &ch
)) {
926 PyErr_SetString(PyExc_TypeError
,
927 "argument 1 or 3 must be a ch or an int");
932 rtn
= mvwinsch(self
->win
,y
,x
, ch
| attr
);
934 rtn
= winsch(self
->win
, ch
| attr
);
936 return PyCursesCheckERR(rtn
, "insch");
940 PyCursesWindow_InCh(PyCursesWindowObject
*self
, PyObject
*args
)
944 switch (PyTuple_Size(args
)) {
946 rtn
= winch(self
->win
);
949 if (!PyArg_ParseTuple(args
,"ii;y,x",&y
,&x
))
951 rtn
= mvwinch(self
->win
,y
,x
);
954 PyErr_SetString(PyExc_TypeError
, "inch requires 0 or 2 arguments");
957 return PyInt_FromLong((long) rtn
);
961 PyCursesWindow_InStr(PyCursesWindowObject
*self
, PyObject
*args
)
964 char rtn
[1024]; /* This should be big enough.. I hope */
967 switch (PyTuple_Size(args
)) {
969 rtn2
= winnstr(self
->win
,rtn
, 1023);
972 if (!PyArg_ParseTuple(args
,"i;n", &n
))
974 rtn2
= winnstr(self
->win
,rtn
,MIN(n
,1023));
977 if (!PyArg_ParseTuple(args
,"ii;y,x",&y
,&x
))
979 rtn2
= mvwinnstr(self
->win
,y
,x
,rtn
,1023);
982 if (!PyArg_ParseTuple(args
, "iii;y,x,n", &y
, &x
, &n
))
984 rtn2
= mvwinnstr(self
->win
, y
, x
, rtn
, MIN(n
,1023));
987 PyErr_SetString(PyExc_TypeError
, "instr requires 0 or 3 arguments");
992 return PyString_FromString(rtn
);
996 PyCursesWindow_InsStr(PyCursesWindowObject
*self
, PyObject
*args
)
1001 attr_t attr
= A_NORMAL
, attr_old
= A_NORMAL
;
1002 int use_xy
= FALSE
, use_attr
= FALSE
;
1004 switch (PyTuple_Size(args
)) {
1006 if (!PyArg_ParseTuple(args
,"s;str", &str
))
1010 if (!PyArg_ParseTuple(args
,"sl;str,attr", &str
, &attr
))
1015 if (!PyArg_ParseTuple(args
,"iis;y,x,str", &y
, &x
, &str
))
1020 if (!PyArg_ParseTuple(args
,"iisl;y,x,str,attr", &y
, &x
, &str
, &attr
))
1022 use_xy
= use_attr
= TRUE
;
1025 PyErr_SetString(PyExc_TypeError
, "insstr requires 1 to 4 arguments");
1029 if (use_attr
== TRUE
) {
1030 attr_old
= getattrs(self
->win
);
1031 wattrset(self
->win
,attr
);
1034 rtn
= mvwinsstr(self
->win
,y
,x
,str
);
1036 rtn
= winsstr(self
->win
,str
);
1037 if (use_attr
== TRUE
)
1038 wattrset(self
->win
,attr_old
);
1039 return PyCursesCheckERR(rtn
, "insstr");
1043 PyCursesWindow_InsNStr(PyCursesWindowObject
*self
, PyObject
*args
)
1047 attr_t attr
= A_NORMAL
, attr_old
= A_NORMAL
;
1048 int use_xy
= FALSE
, use_attr
= FALSE
;
1050 switch (PyTuple_Size(args
)) {
1052 if (!PyArg_ParseTuple(args
,"si;str,n", &str
, &n
))
1056 if (!PyArg_ParseTuple(args
,"sil;str,n,attr", &str
, &n
, &attr
))
1061 if (!PyArg_ParseTuple(args
,"iisi;y,x,str,n", &y
, &x
, &str
, &n
))
1066 if (!PyArg_ParseTuple(args
,"iisil;y,x,str,n,attr", &y
, &x
, &str
, &n
, &attr
))
1068 use_xy
= use_attr
= TRUE
;
1071 PyErr_SetString(PyExc_TypeError
, "insnstr requires 2 to 5 arguments");
1075 if (use_attr
== TRUE
) {
1076 attr_old
= getattrs(self
->win
);
1077 wattrset(self
->win
,attr
);
1080 rtn
= mvwinsnstr(self
->win
,y
,x
,str
,n
);
1082 rtn
= winsnstr(self
->win
,str
,n
);
1083 if (use_attr
== TRUE
)
1084 wattrset(self
->win
,attr_old
);
1085 return PyCursesCheckERR(rtn
, "insnstr");
1089 PyCursesWindow_Is_LineTouched(PyCursesWindowObject
*self
, PyObject
*args
)
1092 if (!PyArg_ParseTuple(args
,"i;line", &line
))
1094 erg
= is_linetouched(self
->win
, line
);
1096 PyErr_SetString(PyExc_TypeError
,
1097 "is_linetouched: line number outside of boundaries");
1101 Py_INCREF(Py_False
);
1110 PyCursesWindow_NoOutRefresh(PyCursesWindowObject
*self
, PyObject
*args
)
1112 int pminrow
,pmincol
,sminrow
,smincol
,smaxrow
,smaxcol
;
1115 #ifndef WINDOW_HAS_FLAGS
1118 if (self
->win
->_flags
& _ISPAD
) {
1120 switch(PyTuple_Size(args
)) {
1122 if (!PyArg_ParseTuple(args
,
1124 "pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol",
1125 &pminrow
, &pmincol
, &sminrow
,
1126 &smincol
, &smaxrow
, &smaxcol
))
1128 Py_BEGIN_ALLOW_THREADS
1129 rtn
= pnoutrefresh(self
->win
,
1130 pminrow
, pmincol
, sminrow
,
1131 smincol
, smaxrow
, smaxcol
);
1132 Py_END_ALLOW_THREADS
1133 return PyCursesCheckERR(rtn
, "pnoutrefresh");
1135 PyErr_SetString(PyCursesError
,
1136 "noutrefresh() called for a pad "
1137 "requires 6 arguments");
1141 if (!PyArg_ParseTuple(args
, ":noutrefresh"))
1144 Py_BEGIN_ALLOW_THREADS
1145 rtn
= wnoutrefresh(self
->win
);
1146 Py_END_ALLOW_THREADS
1147 return PyCursesCheckERR(rtn
, "wnoutrefresh");
1152 PyCursesWindow_Overlay(PyCursesWindowObject
*self
, PyObject
*args
)
1154 PyCursesWindowObject
*temp
;
1155 int use_copywin
= FALSE
;
1156 int sminrow
, smincol
, dminrow
, dmincol
, dmaxrow
, dmaxcol
;
1159 switch (PyTuple_Size(args
)) {
1161 if (!PyArg_ParseTuple(args
, "O!;window object",
1162 &PyCursesWindow_Type
, &temp
))
1166 if (!PyArg_ParseTuple(args
, "O!iiiiii;window object, int, int, int, int, int, int",
1167 &PyCursesWindow_Type
, &temp
, &sminrow
, &smincol
,
1168 &dminrow
, &dmincol
, &dmaxrow
, &dmaxcol
))
1173 PyErr_SetString(PyExc_TypeError
,
1174 "overlay requires one or seven arguments");
1178 if (use_copywin
== TRUE
) {
1179 rtn
= copywin(self
->win
, temp
->win
, sminrow
, smincol
,
1180 dminrow
, dmincol
, dmaxrow
, dmaxcol
, TRUE
);
1181 return PyCursesCheckERR(rtn
, "copywin");
1184 rtn
= overlay(self
->win
, temp
->win
);
1185 return PyCursesCheckERR(rtn
, "overlay");
1190 PyCursesWindow_Overwrite(PyCursesWindowObject
*self
, PyObject
*args
)
1192 PyCursesWindowObject
*temp
;
1193 int use_copywin
= FALSE
;
1194 int sminrow
, smincol
, dminrow
, dmincol
, dmaxrow
, dmaxcol
;
1197 switch (PyTuple_Size(args
)) {
1199 if (!PyArg_ParseTuple(args
, "O!;window object",
1200 &PyCursesWindow_Type
, &temp
))
1204 if (!PyArg_ParseTuple(args
, "O!iiiiii;window object, int, int, int, int, int, int",
1205 &PyCursesWindow_Type
, &temp
, &sminrow
, &smincol
,
1206 &dminrow
, &dmincol
, &dmaxrow
, &dmaxcol
))
1211 PyErr_SetString(PyExc_TypeError
,
1212 "overwrite requires one or seven arguments");
1216 if (use_copywin
== TRUE
) {
1217 rtn
= copywin(self
->win
, temp
->win
, sminrow
, smincol
,
1218 dminrow
, dmincol
, dmaxrow
, dmaxcol
, FALSE
);
1219 return PyCursesCheckERR(rtn
, "copywin");
1222 rtn
= overwrite(self
->win
, temp
->win
);
1223 return PyCursesCheckERR(rtn
, "overwrite");
1228 PyCursesWindow_PutWin(PyCursesWindowObject
*self
, PyObject
*args
)
1232 if (!PyArg_ParseTuple(args
, "O;fileobj", &temp
))
1234 if (!PyFile_Check(temp
)) {
1235 PyErr_SetString(PyExc_TypeError
, "argument must be a file object");
1238 return PyCursesCheckERR(putwin(self
->win
, PyFile_AsFile(temp
)),
1243 PyCursesWindow_RedrawLine(PyCursesWindowObject
*self
, PyObject
*args
)
1246 if (!PyArg_ParseTuple(args
,"ii;beg,num", &beg
, &num
))
1248 return PyCursesCheckERR(wredrawln(self
->win
,beg
,num
), "redrawln");
1252 PyCursesWindow_Refresh(PyCursesWindowObject
*self
, PyObject
*args
)
1254 int pminrow
,pmincol
,sminrow
,smincol
,smaxrow
,smaxcol
;
1257 #ifndef WINDOW_HAS_FLAGS
1260 if (self
->win
->_flags
& _ISPAD
) {
1262 switch(PyTuple_Size(args
)) {
1264 if (!PyArg_ParseTuple(args
,
1266 "pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol",
1267 &pminrow
, &pmincol
, &sminrow
,
1268 &smincol
, &smaxrow
, &smaxcol
))
1271 Py_BEGIN_ALLOW_THREADS
1272 rtn
= prefresh(self
->win
,
1273 pminrow
, pmincol
, sminrow
,
1274 smincol
, smaxrow
, smaxcol
);
1275 Py_END_ALLOW_THREADS
1276 return PyCursesCheckERR(rtn
, "prefresh");
1278 PyErr_SetString(PyCursesError
,
1279 "refresh() for a pad requires 6 arguments");
1283 if (!PyArg_ParseTuple(args
, ":refresh"))
1285 Py_BEGIN_ALLOW_THREADS
1286 rtn
= wrefresh(self
->win
);
1287 Py_END_ALLOW_THREADS
1288 return PyCursesCheckERR(rtn
, "prefresh");
1293 PyCursesWindow_SetScrollRegion(PyCursesWindowObject
*self
, PyObject
*args
)
1296 if (!PyArg_ParseTuple(args
,"ii;top, bottom",&y
,&x
))
1298 return PyCursesCheckERR(wsetscrreg(self
->win
,y
,x
), "wsetscrreg");
1302 PyCursesWindow_SubWin(PyCursesWindowObject
*self
, PyObject
*args
)
1305 int nlines
, ncols
, begin_y
, begin_x
;
1309 switch (PyTuple_Size(args
)) {
1311 if (!PyArg_ParseTuple(args
,"ii;begin_y,begin_x",&begin_y
,&begin_x
))
1315 if (!PyArg_ParseTuple(args
, "iiii;nlines,ncols,begin_y,begin_x",
1316 &nlines
,&ncols
,&begin_y
,&begin_x
))
1320 PyErr_SetString(PyExc_TypeError
, "subwin requires 2 or 4 arguments");
1324 /* printf("Subwin: %i %i %i %i \n", nlines, ncols, begin_y, begin_x); */
1325 #ifdef WINDOW_HAS_FLAGS
1326 if (self
->win
->_flags
& _ISPAD
)
1327 win
= subpad(self
->win
, nlines
, ncols
, begin_y
, begin_x
);
1330 win
= subwin(self
->win
, nlines
, ncols
, begin_y
, begin_x
);
1333 PyErr_SetString(PyCursesError
, catchall_NULL
);
1337 return (PyObject
*)PyCursesWindow_New(win
);
1341 PyCursesWindow_Scroll(PyCursesWindowObject
*self
, PyObject
*args
)
1344 switch(PyTuple_Size(args
)) {
1346 return PyCursesCheckERR(scroll(self
->win
), "scroll");
1348 if (!PyArg_ParseTuple(args
, "i;nlines", &nlines
))
1350 return PyCursesCheckERR(wscrl(self
->win
, nlines
), "scroll");
1352 PyErr_SetString(PyExc_TypeError
, "scroll requires 0 or 1 arguments");
1358 PyCursesWindow_TouchLine(PyCursesWindowObject
*self
, PyObject
*args
)
1361 switch (PyTuple_Size(args
)) {
1363 if (!PyArg_ParseTuple(args
,"ii;start,count",&st
,&cnt
))
1365 return PyCursesCheckERR(touchline(self
->win
,st
,cnt
), "touchline");
1367 if (!PyArg_ParseTuple(args
, "iii;start,count,val", &st
, &cnt
, &val
))
1369 return PyCursesCheckERR(wtouchln(self
->win
, st
, cnt
, val
), "touchline");
1371 PyErr_SetString(PyExc_TypeError
, "touchline requires 2 or 3 arguments");
1377 PyCursesWindow_Vline(PyCursesWindowObject
*self
, PyObject
*args
)
1381 int n
, x
, y
, code
= OK
;
1382 attr_t attr
= A_NORMAL
;
1384 switch (PyTuple_Size(args
)) {
1386 if (!PyArg_ParseTuple(args
, "Oi;ch or int,n", &temp
, &n
))
1390 if (!PyArg_ParseTuple(args
, "Oil;ch or int,n,attr", &temp
, &n
, &attr
))
1394 if (!PyArg_ParseTuple(args
, "iiOi;y,x,ch or int,n", &y
, &x
, &temp
, &n
))
1396 code
= wmove(self
->win
, y
, x
);
1399 if (!PyArg_ParseTuple(args
, "iiOil; y,x,ch or int,n,attr",
1400 &y
, &x
, &temp
, &n
, &attr
))
1402 code
= wmove(self
->win
, y
, x
);
1405 PyErr_SetString(PyExc_TypeError
, "vline requires 2 to 5 arguments");
1410 if (!PyCurses_ConvertToChtype(temp
, &ch
)) {
1411 PyErr_SetString(PyExc_TypeError
,
1412 "argument 1 or 3 must be a ch or an int");
1415 return PyCursesCheckERR(wvline(self
->win
, ch
| attr
, n
), "vline");
1417 return PyCursesCheckERR(code
, "wmove");
1420 static PyMethodDef PyCursesWindow_Methods
[] = {
1421 {"addch", (PyCFunction
)PyCursesWindow_AddCh
, METH_VARARGS
},
1422 {"addnstr", (PyCFunction
)PyCursesWindow_AddNStr
, METH_VARARGS
},
1423 {"addstr", (PyCFunction
)PyCursesWindow_AddStr
, METH_VARARGS
},
1424 {"attroff", (PyCFunction
)PyCursesWindow_wattroff
, METH_VARARGS
},
1425 {"attron", (PyCFunction
)PyCursesWindow_wattron
, METH_VARARGS
},
1426 {"attrset", (PyCFunction
)PyCursesWindow_wattrset
, METH_VARARGS
},
1427 {"bkgd", (PyCFunction
)PyCursesWindow_Bkgd
, METH_VARARGS
},
1428 {"bkgdset", (PyCFunction
)PyCursesWindow_BkgdSet
, METH_VARARGS
},
1429 {"border", (PyCFunction
)PyCursesWindow_Border
, METH_VARARGS
},
1430 {"box", (PyCFunction
)PyCursesWindow_Box
, METH_VARARGS
},
1431 {"clear", (PyCFunction
)PyCursesWindow_wclear
, METH_NOARGS
},
1432 {"clearok", (PyCFunction
)PyCursesWindow_clearok
, METH_VARARGS
},
1433 {"clrtobot", (PyCFunction
)PyCursesWindow_wclrtobot
, METH_NOARGS
},
1434 {"clrtoeol", (PyCFunction
)PyCursesWindow_wclrtoeol
, METH_NOARGS
},
1435 {"cursyncup", (PyCFunction
)PyCursesWindow_wcursyncup
, METH_NOARGS
},
1436 {"delch", (PyCFunction
)PyCursesWindow_DelCh
, METH_VARARGS
},
1437 {"deleteln", (PyCFunction
)PyCursesWindow_wdeleteln
, METH_NOARGS
},
1438 {"derwin", (PyCFunction
)PyCursesWindow_DerWin
, METH_VARARGS
},
1439 {"echochar", (PyCFunction
)PyCursesWindow_EchoChar
, METH_VARARGS
},
1440 #ifdef NCURSES_MOUSE_VERSION
1441 {"enclose", (PyCFunction
)PyCursesWindow_Enclose
, METH_VARARGS
},
1443 {"erase", (PyCFunction
)PyCursesWindow_werase
, METH_NOARGS
},
1444 {"getbegyx", (PyCFunction
)PyCursesWindow_getbegyx
, METH_NOARGS
},
1445 {"getbkgd", (PyCFunction
)PyCursesWindow_GetBkgd
, METH_NOARGS
},
1446 {"getch", (PyCFunction
)PyCursesWindow_GetCh
, METH_VARARGS
},
1447 {"getkey", (PyCFunction
)PyCursesWindow_GetKey
, METH_VARARGS
},
1448 {"getmaxyx", (PyCFunction
)PyCursesWindow_getmaxyx
, METH_NOARGS
},
1449 {"getparyx", (PyCFunction
)PyCursesWindow_getparyx
, METH_NOARGS
},
1450 {"getstr", (PyCFunction
)PyCursesWindow_GetStr
, METH_VARARGS
},
1451 {"getyx", (PyCFunction
)PyCursesWindow_getyx
, METH_NOARGS
},
1452 {"hline", (PyCFunction
)PyCursesWindow_Hline
, METH_VARARGS
},
1453 {"idcok", (PyCFunction
)PyCursesWindow_idcok
, METH_VARARGS
},
1454 {"idlok", (PyCFunction
)PyCursesWindow_idlok
, METH_VARARGS
},
1455 {"immedok", (PyCFunction
)PyCursesWindow_immedok
, METH_VARARGS
},
1456 {"inch", (PyCFunction
)PyCursesWindow_InCh
, METH_VARARGS
},
1457 {"insch", (PyCFunction
)PyCursesWindow_InsCh
, METH_VARARGS
},
1458 {"insdelln", (PyCFunction
)PyCursesWindow_winsdelln
, METH_VARARGS
},
1459 {"insertln", (PyCFunction
)PyCursesWindow_winsertln
, METH_NOARGS
},
1460 {"insnstr", (PyCFunction
)PyCursesWindow_InsNStr
, METH_VARARGS
},
1461 {"insstr", (PyCFunction
)PyCursesWindow_InsStr
, METH_VARARGS
},
1462 {"instr", (PyCFunction
)PyCursesWindow_InStr
, METH_VARARGS
},
1463 {"is_linetouched", (PyCFunction
)PyCursesWindow_Is_LineTouched
, METH_VARARGS
},
1464 {"is_wintouched", (PyCFunction
)PyCursesWindow_is_wintouched
, METH_NOARGS
},
1465 {"keypad", (PyCFunction
)PyCursesWindow_keypad
, METH_VARARGS
},
1466 {"leaveok", (PyCFunction
)PyCursesWindow_leaveok
, METH_VARARGS
},
1467 {"move", (PyCFunction
)PyCursesWindow_wmove
, METH_VARARGS
},
1468 {"mvderwin", (PyCFunction
)PyCursesWindow_mvderwin
, METH_VARARGS
},
1469 {"mvwin", (PyCFunction
)PyCursesWindow_mvwin
, METH_VARARGS
},
1470 {"nodelay", (PyCFunction
)PyCursesWindow_nodelay
, METH_VARARGS
},
1471 {"notimeout", (PyCFunction
)PyCursesWindow_notimeout
, METH_VARARGS
},
1472 {"noutrefresh", (PyCFunction
)PyCursesWindow_NoOutRefresh
, METH_VARARGS
},
1473 /* Backward compatibility alias -- remove in Python 2.3 */
1474 {"nooutrefresh", (PyCFunction
)PyCursesWindow_NoOutRefresh
, METH_VARARGS
},
1475 {"overlay", (PyCFunction
)PyCursesWindow_Overlay
, METH_VARARGS
},
1476 {"overwrite", (PyCFunction
)PyCursesWindow_Overwrite
,
1478 {"putwin", (PyCFunction
)PyCursesWindow_PutWin
, METH_VARARGS
},
1479 {"redrawln", (PyCFunction
)PyCursesWindow_RedrawLine
},
1480 {"redrawwin", (PyCFunction
)PyCursesWindow_redrawwin
, METH_NOARGS
},
1481 {"refresh", (PyCFunction
)PyCursesWindow_Refresh
, METH_VARARGS
},
1482 #ifndef STRICT_SYSV_CURSES
1483 {"resize", (PyCFunction
)PyCursesWindow_wresize
, METH_VARARGS
},
1485 {"scroll", (PyCFunction
)PyCursesWindow_Scroll
, METH_VARARGS
},
1486 {"scrollok", (PyCFunction
)PyCursesWindow_scrollok
, METH_VARARGS
},
1487 {"setscrreg", (PyCFunction
)PyCursesWindow_SetScrollRegion
, METH_VARARGS
},
1488 {"standend", (PyCFunction
)PyCursesWindow_wstandend
, METH_NOARGS
},
1489 {"standout", (PyCFunction
)PyCursesWindow_wstandout
, METH_NOARGS
},
1490 {"subpad", (PyCFunction
)PyCursesWindow_SubWin
, METH_VARARGS
},
1491 {"subwin", (PyCFunction
)PyCursesWindow_SubWin
, METH_VARARGS
},
1492 {"syncdown", (PyCFunction
)PyCursesWindow_wsyncdown
, METH_NOARGS
},
1493 {"syncok", (PyCFunction
)PyCursesWindow_syncok
, METH_VARARGS
},
1494 {"syncup", (PyCFunction
)PyCursesWindow_wsyncup
, METH_NOARGS
},
1495 {"timeout", (PyCFunction
)PyCursesWindow_wtimeout
, METH_VARARGS
},
1496 {"touchline", (PyCFunction
)PyCursesWindow_TouchLine
, METH_VARARGS
},
1497 {"touchwin", (PyCFunction
)PyCursesWindow_touchwin
, METH_NOARGS
},
1498 {"untouchwin", (PyCFunction
)PyCursesWindow_untouchwin
, METH_NOARGS
},
1499 {"vline", (PyCFunction
)PyCursesWindow_Vline
, METH_VARARGS
},
1500 {NULL
, NULL
} /* sentinel */
1504 PyCursesWindow_GetAttr(PyCursesWindowObject
*self
, char *name
)
1506 return Py_FindMethod(PyCursesWindow_Methods
, (PyObject
*)self
, name
);
1509 /* -------------------------------------------------------*/
1511 PyTypeObject PyCursesWindow_Type
= {
1512 PyObject_HEAD_INIT(NULL
)
1514 "_curses.curses window", /*tp_name*/
1515 sizeof(PyCursesWindowObject
), /*tp_basicsize*/
1518 (destructor
)PyCursesWindow_Dealloc
, /*tp_dealloc*/
1520 (getattrfunc
)PyCursesWindow_GetAttr
, /*tp_getattr*/
1521 (setattrfunc
)0, /*tp_setattr*/
1525 0, /*tp_as_sequence*/
1526 0, /*tp_as_mapping*/
1530 /*********************************************************************
1532 **********************************************************************/
1534 NoArgNoReturnFunction(beep
)
1535 NoArgNoReturnFunction(def_prog_mode
)
1536 NoArgNoReturnFunction(def_shell_mode
)
1537 NoArgNoReturnFunction(doupdate
)
1538 NoArgNoReturnFunction(endwin
)
1539 NoArgNoReturnFunction(flash
)
1540 NoArgNoReturnFunction(nocbreak
)
1541 NoArgNoReturnFunction(noecho
)
1542 NoArgNoReturnFunction(nonl
)
1543 NoArgNoReturnFunction(noraw
)
1544 NoArgNoReturnFunction(reset_prog_mode
)
1545 NoArgNoReturnFunction(reset_shell_mode
)
1546 NoArgNoReturnFunction(resetty
)
1547 NoArgNoReturnFunction(savetty
)
1549 NoArgOrFlagNoReturnFunction(cbreak
)
1550 NoArgOrFlagNoReturnFunction(echo
)
1551 NoArgOrFlagNoReturnFunction(nl
)
1552 NoArgOrFlagNoReturnFunction(raw
)
1554 NoArgReturnIntFunction(baudrate
)
1555 NoArgReturnIntFunction(termattrs
)
1557 NoArgReturnStringFunction(termname
)
1558 NoArgReturnStringFunction(longname
)
1560 NoArgTrueFalseFunction(can_change_color
)
1561 NoArgTrueFalseFunction(has_colors
)
1562 NoArgTrueFalseFunction(has_ic
)
1563 NoArgTrueFalseFunction(has_il
)
1564 NoArgTrueFalseFunction(isendwin
)
1565 NoArgNoReturnVoidFunction(filter
)
1566 NoArgNoReturnVoidFunction(flushinp
)
1567 NoArgNoReturnVoidFunction(noqiflush
)
1570 PyCurses_Color_Content(PyObject
*self
, PyObject
*args
)
1575 PyCursesInitialisedColor
1577 if (!PyArg_ParseTuple(args
, "h:color_content", &color
)) return NULL
;
1579 if (color_content(color
, &r
, &g
, &b
) != ERR
)
1580 return Py_BuildValue("(iii)", r
, g
, b
);
1582 PyErr_SetString(PyCursesError
,
1583 "Argument 1 was out of range. Check value of COLORS.");
1589 PyCurses_color_pair(PyObject
*self
, PyObject
*args
)
1594 PyCursesInitialisedColor
1596 if (!PyArg_ParseTuple(args
, "i:color_pair", &n
)) return NULL
;
1597 return PyInt_FromLong((long) (n
<< 8));
1601 PyCurses_Curs_Set(PyObject
*self
, PyObject
*args
)
1607 if (!PyArg_ParseTuple(args
, "i:curs_set", &vis
)) return NULL
;
1609 erg
= curs_set(vis
);
1610 if (erg
== ERR
) return PyCursesCheckERR(erg
, "curs_set");
1612 return PyInt_FromLong((long) erg
);
1616 PyCurses_Delay_Output(PyObject
*self
, PyObject
*args
)
1622 if (!PyArg_ParseTuple(args
, "i:delay_output", &ms
)) return NULL
;
1624 return PyCursesCheckERR(delay_output(ms
), "delay_output");
1628 PyCurses_EraseChar(PyObject
*self
)
1636 return PyString_FromStringAndSize(&ch
, 1);
1640 PyCurses_getsyx(PyObject
*self
)
1648 return Py_BuildValue("(ii)", y
, x
);
1651 #ifdef NCURSES_MOUSE_VERSION
1653 PyCurses_GetMouse(PyObject
*self
)
1660 rtn
= getmouse( &event
);
1662 PyErr_SetString(PyCursesError
, "getmouse() returned ERR");
1665 return Py_BuildValue("(hiiil)",
1667 event
.x
, event
.y
, event
.z
,
1668 (long) event
.bstate
);
1672 PyCurses_UngetMouse(PyObject
*self
, PyObject
*args
)
1677 if (!PyArg_ParseTuple(args
, "hiiil",
1679 &event
.x
, &event
.y
, &event
.z
,
1680 (int *) &event
.bstate
))
1683 return PyCursesCheckERR(ungetmouse(&event
), "ungetmouse");
1688 PyCurses_GetWin(PyCursesWindowObject
*self
, PyObject
*temp
)
1694 if (!PyFile_Check(temp
)) {
1695 PyErr_SetString(PyExc_TypeError
, "argument must be a file object");
1699 win
= getwin(PyFile_AsFile(temp
));
1702 PyErr_SetString(PyCursesError
, catchall_NULL
);
1706 return PyCursesWindow_New(win
);
1710 PyCurses_HalfDelay(PyObject
*self
, PyObject
*args
)
1712 unsigned char tenths
;
1716 if (!PyArg_ParseTuple(args
, "b:halfdelay", &tenths
)) return NULL
;
1718 return PyCursesCheckERR(halfdelay(tenths
), "halfdelay");
1721 #ifndef STRICT_SYSV_CURSES
1723 static PyObject
* PyCurses_has_key(PyObject
*self
, PyObject
*args
)
1729 if (!PyArg_ParseTuple(args
,"i",&ch
)) return NULL
;
1731 if (has_key(ch
) == FALSE
) {
1732 Py_INCREF(Py_False
);
1738 #endif /* STRICT_SYSV_CURSES */
1741 PyCurses_Init_Color(PyObject
*self
, PyObject
*args
)
1743 short color
, r
, g
, b
;
1746 PyCursesInitialisedColor
1748 switch(PyTuple_Size(args
)) {
1750 if (!PyArg_ParseTuple(args
, "hhhh;color,r,g,b", &color
, &r
, &g
, &b
)) return NULL
;
1753 PyErr_SetString(PyExc_TypeError
, "init_color requires 4 arguments");
1757 return PyCursesCheckERR(init_color(color
, r
, g
, b
), "init_color");
1761 PyCurses_Init_Pair(PyObject
*self
, PyObject
*args
)
1766 PyCursesInitialisedColor
1768 if (PyTuple_Size(args
) != 3) {
1769 PyErr_SetString(PyExc_TypeError
, "init_pair requires 3 arguments");
1773 if (!PyArg_ParseTuple(args
, "hhh;pair, f, b", &pair
, &f
, &b
)) return NULL
;
1775 return PyCursesCheckERR(init_pair(pair
, f
, b
), "init_pair");
1778 static PyObject
*ModDict
;
1781 PyCurses_InitScr(PyObject
*self
)
1784 PyObject
*nlines
, *cols
;
1786 if (initialised
== TRUE
) {
1788 return (PyObject
*)PyCursesWindow_New(stdscr
);
1794 PyErr_SetString(PyCursesError
, catchall_NULL
);
1798 initialised
= initialised_setupterm
= TRUE
;
1800 /* This was moved from initcurses() because it core dumped on SGI,
1801 where they're not defined until you've called initscr() */
1802 #define SetDictInt(string,ch) \
1803 PyDict_SetItemString(ModDict,string,PyInt_FromLong((long) (ch)));
1805 /* Here are some graphic symbols you can use */
1806 SetDictInt("ACS_ULCORNER", (ACS_ULCORNER
));
1807 SetDictInt("ACS_LLCORNER", (ACS_LLCORNER
));
1808 SetDictInt("ACS_URCORNER", (ACS_URCORNER
));
1809 SetDictInt("ACS_LRCORNER", (ACS_LRCORNER
));
1810 SetDictInt("ACS_LTEE", (ACS_LTEE
));
1811 SetDictInt("ACS_RTEE", (ACS_RTEE
));
1812 SetDictInt("ACS_BTEE", (ACS_BTEE
));
1813 SetDictInt("ACS_TTEE", (ACS_TTEE
));
1814 SetDictInt("ACS_HLINE", (ACS_HLINE
));
1815 SetDictInt("ACS_VLINE", (ACS_VLINE
));
1816 SetDictInt("ACS_PLUS", (ACS_PLUS
));
1817 #if !defined(__hpux) || defined(HAVE_NCURSES_H)
1818 /* On HP/UX 11, these are of type cchar_t, which is not an
1819 integral type. If this is a problem on more platforms, a
1820 configure test should be added to determine whether ACS_S1
1821 is of integral type. */
1822 SetDictInt("ACS_S1", (ACS_S1
));
1823 SetDictInt("ACS_S9", (ACS_S9
));
1824 SetDictInt("ACS_DIAMOND", (ACS_DIAMOND
));
1825 SetDictInt("ACS_CKBOARD", (ACS_CKBOARD
));
1826 SetDictInt("ACS_DEGREE", (ACS_DEGREE
));
1827 SetDictInt("ACS_PLMINUS", (ACS_PLMINUS
));
1828 SetDictInt("ACS_BULLET", (ACS_BULLET
));
1829 SetDictInt("ACS_LARROW", (ACS_LARROW
));
1830 SetDictInt("ACS_RARROW", (ACS_RARROW
));
1831 SetDictInt("ACS_DARROW", (ACS_DARROW
));
1832 SetDictInt("ACS_UARROW", (ACS_UARROW
));
1833 SetDictInt("ACS_BOARD", (ACS_BOARD
));
1834 SetDictInt("ACS_LANTERN", (ACS_LANTERN
));
1835 SetDictInt("ACS_BLOCK", (ACS_BLOCK
));
1837 SetDictInt("ACS_BSSB", (ACS_ULCORNER
));
1838 SetDictInt("ACS_SSBB", (ACS_LLCORNER
));
1839 SetDictInt("ACS_BBSS", (ACS_URCORNER
));
1840 SetDictInt("ACS_SBBS", (ACS_LRCORNER
));
1841 SetDictInt("ACS_SBSS", (ACS_RTEE
));
1842 SetDictInt("ACS_SSSB", (ACS_LTEE
));
1843 SetDictInt("ACS_SSBS", (ACS_BTEE
));
1844 SetDictInt("ACS_BSSS", (ACS_TTEE
));
1845 SetDictInt("ACS_BSBS", (ACS_HLINE
));
1846 SetDictInt("ACS_SBSB", (ACS_VLINE
));
1847 SetDictInt("ACS_SSSS", (ACS_PLUS
));
1849 /* The following are never available with strict SYSV curses */
1851 SetDictInt("ACS_S3", (ACS_S3
));
1854 SetDictInt("ACS_S7", (ACS_S7
));
1857 SetDictInt("ACS_LEQUAL", (ACS_LEQUAL
));
1860 SetDictInt("ACS_GEQUAL", (ACS_GEQUAL
));
1863 SetDictInt("ACS_PI", (ACS_PI
));
1866 SetDictInt("ACS_NEQUAL", (ACS_NEQUAL
));
1869 SetDictInt("ACS_STERLING", (ACS_STERLING
));
1872 nlines
= PyInt_FromLong((long) LINES
);
1873 PyDict_SetItemString(ModDict
, "LINES", nlines
);
1875 cols
= PyInt_FromLong((long) COLS
);
1876 PyDict_SetItemString(ModDict
, "COLS", cols
);
1879 return (PyObject
*)PyCursesWindow_New(win
);
1883 PyCurses_setupterm(PyObject
* self
, PyObject
*args
, PyObject
* keywds
)
1887 char* termstr
= NULL
;
1889 static const char *kwlist
[] = {"term", "fd", NULL
};
1891 if (!PyArg_ParseTupleAndKeywords(
1892 args
, keywds
, "|zi:setupterm", kwlist
, &termstr
, &fd
)) {
1897 PyObject
* sys_stdout
;
1899 sys_stdout
= PySys_GetObject("stdout");
1901 if (sys_stdout
== NULL
) {
1908 fd
= PyObject_AsFileDescriptor(sys_stdout
);
1915 if (setupterm(termstr
,fd
,&err
) == ERR
) {
1916 char* s
= "setupterm: unknown error";
1919 s
= "setupterm: could not find terminal";
1920 } else if (err
== -1) {
1921 s
= "setupterm: could not find terminfo database";
1924 PyErr_SetString(PyCursesError
,s
);
1928 initialised_setupterm
= TRUE
;
1935 PyCurses_IntrFlush(PyObject
*self
, PyObject
*args
)
1941 switch(PyTuple_Size(args
)) {
1943 if (!PyArg_ParseTuple(args
,"i;True(1), False(0)",&ch
)) return NULL
;
1946 PyErr_SetString(PyExc_TypeError
, "intrflush requires 1 argument");
1950 return PyCursesCheckERR(intrflush(NULL
,ch
), "intrflush");
1953 #if !defined(__NetBSD__)
1955 PyCurses_KeyName(PyObject
*self
, PyObject
*args
)
1962 if (!PyArg_ParseTuple(args
,"i",&ch
)) return NULL
;
1965 PyErr_SetString(PyExc_ValueError
, "invalid key number");
1970 return PyString_FromString((knp
== NULL
) ? "" : (char *)knp
);
1975 PyCurses_KillChar(PyObject
*self
)
1981 return PyString_FromStringAndSize(&ch
, 1);
1985 PyCurses_Meta(PyObject
*self
, PyObject
*args
)
1991 switch(PyTuple_Size(args
)) {
1993 if (!PyArg_ParseTuple(args
,"i;True(1), False(0)",&ch
)) return NULL
;
1996 PyErr_SetString(PyExc_TypeError
, "meta requires 1 argument");
2000 return PyCursesCheckERR(meta(stdscr
, ch
), "meta");
2003 #ifdef NCURSES_MOUSE_VERSION
2005 PyCurses_MouseInterval(PyObject
*self
, PyObject
*args
)
2010 if (!PyArg_ParseTuple(args
,"i;interval",&interval
))
2012 return PyCursesCheckERR(mouseinterval(interval
), "mouseinterval");
2016 PyCurses_MouseMask(PyObject
*self
, PyObject
*args
)
2019 mmask_t oldmask
, availmask
;
2022 if (!PyArg_ParseTuple(args
,"i;mousemask",&newmask
))
2024 availmask
= mousemask(newmask
, &oldmask
);
2025 return Py_BuildValue("(ll)", (long)availmask
, (long)oldmask
);
2030 PyCurses_Napms(PyObject
*self
, PyObject
*args
)
2035 if (!PyArg_ParseTuple(args
, "i;ms", &ms
)) return NULL
;
2037 return Py_BuildValue("i", napms(ms
));
2042 PyCurses_NewPad(PyObject
*self
, PyObject
*args
)
2049 if (!PyArg_ParseTuple(args
,"ii;nlines,ncols",&nlines
,&ncols
)) return NULL
;
2051 win
= newpad(nlines
, ncols
);
2054 PyErr_SetString(PyCursesError
, catchall_NULL
);
2058 return (PyObject
*)PyCursesWindow_New(win
);
2062 PyCurses_NewWindow(PyObject
*self
, PyObject
*args
)
2065 int nlines
, ncols
, begin_y
=0, begin_x
=0;
2069 switch (PyTuple_Size(args
)) {
2071 if (!PyArg_ParseTuple(args
,"ii;nlines,ncols",&nlines
,&ncols
))
2075 if (!PyArg_ParseTuple(args
, "iiii;nlines,ncols,begin_y,begin_x",
2076 &nlines
,&ncols
,&begin_y
,&begin_x
))
2080 PyErr_SetString(PyExc_TypeError
, "newwin requires 2 or 4 arguments");
2084 win
= newwin(nlines
,ncols
,begin_y
,begin_x
);
2086 PyErr_SetString(PyCursesError
, catchall_NULL
);
2090 return (PyObject
*)PyCursesWindow_New(win
);
2094 PyCurses_Pair_Content(PyObject
*self
, PyObject
*args
)
2099 PyCursesInitialisedColor
2101 switch(PyTuple_Size(args
)) {
2103 if (!PyArg_ParseTuple(args
, "h;pair", &pair
)) return NULL
;
2106 PyErr_SetString(PyExc_TypeError
, "pair_content requires 1 argument");
2110 if (pair_content(pair
, &f
, &b
)==ERR
) {
2111 PyErr_SetString(PyCursesError
,
2112 "Argument 1 was out of range. (1..COLOR_PAIRS-1)");
2116 return Py_BuildValue("(ii)", f
, b
);
2120 PyCurses_pair_number(PyObject
*self
, PyObject
*args
)
2125 PyCursesInitialisedColor
2127 switch(PyTuple_Size(args
)) {
2129 if (!PyArg_ParseTuple(args
, "i;pairvalue", &n
)) return NULL
;
2132 PyErr_SetString(PyExc_TypeError
,
2133 "pair_number requires 1 argument");
2137 return PyInt_FromLong((long) ((n
& A_COLOR
) >> 8));
2141 PyCurses_Putp(PyObject
*self
, PyObject
*args
)
2145 if (!PyArg_ParseTuple(args
,"s;str", &str
)) return NULL
;
2146 return PyCursesCheckERR(putp(str
), "putp");
2150 PyCurses_QiFlush(PyObject
*self
, PyObject
*args
)
2156 switch(PyTuple_Size(args
)) {
2162 if (!PyArg_ParseTuple(args
, "i;True(1) or False(0)", &flag
)) return NULL
;
2163 if (flag
) qiflush();
2168 PyErr_SetString(PyExc_TypeError
, "qiflush requires 0 or 1 arguments");
2174 PyCurses_setsyx(PyObject
*self
, PyObject
*args
)
2180 if (PyTuple_Size(args
)!=2) {
2181 PyErr_SetString(PyExc_TypeError
, "setsyx requires 2 arguments");
2185 if (!PyArg_ParseTuple(args
, "ii;y, x", &y
, &x
)) return NULL
;
2194 PyCurses_Start_Color(PyObject
*self
)
2201 code
= start_color();
2203 initialisedcolors
= TRUE
;
2204 c
= PyInt_FromLong((long) COLORS
);
2205 PyDict_SetItemString(ModDict
, "COLORS", c
);
2207 cp
= PyInt_FromLong((long) COLOR_PAIRS
);
2208 PyDict_SetItemString(ModDict
, "COLOR_PAIRS", cp
);
2213 PyErr_SetString(PyCursesError
, "start_color() returned ERR");
2219 PyCurses_tigetflag(PyObject
*self
, PyObject
*args
)
2223 PyCursesSetupTermCalled
;
2225 if (!PyArg_ParseTuple(args
, "z", &capname
))
2228 return PyInt_FromLong( (long) tigetflag( capname
) );
2232 PyCurses_tigetnum(PyObject
*self
, PyObject
*args
)
2236 PyCursesSetupTermCalled
;
2238 if (!PyArg_ParseTuple(args
, "z", &capname
))
2241 return PyInt_FromLong( (long) tigetnum( capname
) );
2245 PyCurses_tigetstr(PyObject
*self
, PyObject
*args
)
2249 PyCursesSetupTermCalled
;
2251 if (!PyArg_ParseTuple(args
, "z", &capname
))
2254 capname
= tigetstr( capname
);
2255 if (capname
== 0 || capname
== (char*) -1) {
2259 return PyString_FromString( capname
);
2263 PyCurses_tparm(PyObject
*self
, PyObject
*args
)
2266 char* result
= NULL
;
2267 int i1
=0,i2
=0,i3
=0,i4
=0,i5
=0,i6
=0,i7
=0,i8
=0,i9
=0;
2269 PyCursesSetupTermCalled
;
2271 if (!PyArg_ParseTuple(args
, "s|iiiiiiiii:tparm",
2272 &fmt
, &i1
, &i2
, &i3
, &i4
,
2273 &i5
, &i6
, &i7
, &i8
, &i9
)) {
2277 result
= tparm(fmt
,i1
,i2
,i3
,i4
,i5
,i6
,i7
,i8
,i9
);
2279 return PyString_FromString(result
);
2283 PyCurses_TypeAhead(PyObject
*self
, PyObject
*args
)
2289 if (!PyArg_ParseTuple(args
,"i;fd",&fd
)) return NULL
;
2291 return PyCursesCheckERR(typeahead( fd
), "typeahead");
2295 PyCurses_UnCtrl(PyObject
*self
, PyObject
*args
)
2302 if (!PyArg_ParseTuple(args
,"O;ch or int",&temp
)) return NULL
;
2304 if (PyInt_Check(temp
))
2305 ch
= (chtype
) PyInt_AsLong(temp
);
2306 else if (PyString_Check(temp
))
2307 ch
= (chtype
) *PyString_AsString(temp
);
2309 PyErr_SetString(PyExc_TypeError
, "argument must be a ch or an int");
2313 return PyString_FromString(unctrl(ch
));
2317 PyCurses_UngetCh(PyObject
*self
, PyObject
*args
)
2324 if (!PyArg_ParseTuple(args
,"O;ch or int",&temp
)) return NULL
;
2326 if (PyInt_Check(temp
))
2327 ch
= (int) PyInt_AsLong(temp
);
2328 else if (PyString_Check(temp
))
2329 ch
= (int) *PyString_AsString(temp
);
2331 PyErr_SetString(PyExc_TypeError
, "argument must be a ch or an int");
2335 return PyCursesCheckERR(ungetch(ch
), "ungetch");
2339 PyCurses_Use_Env(PyObject
*self
, PyObject
*args
)
2345 switch(PyTuple_Size(args
)) {
2347 if (!PyArg_ParseTuple(args
,"i;True(1), False(0)",&flag
))
2351 PyErr_SetString(PyExc_TypeError
, "use_env requires 1 argument");
2359 #ifndef STRICT_SYSV_CURSES
2361 PyCurses_Use_Default_Colors(PyObject
*self
)
2366 PyCursesInitialisedColor
2368 code
= use_default_colors();
2373 PyErr_SetString(PyCursesError
, "use_default_colors() returned ERR");
2377 #endif /* STRICT_SYSV_CURSES */
2379 /* List of functions defined in the module */
2381 static PyMethodDef PyCurses_methods
[] = {
2382 {"baudrate", (PyCFunction
)PyCurses_baudrate
, METH_NOARGS
},
2383 {"beep", (PyCFunction
)PyCurses_beep
, METH_NOARGS
},
2384 {"can_change_color", (PyCFunction
)PyCurses_can_change_color
, METH_NOARGS
},
2385 {"cbreak", (PyCFunction
)PyCurses_cbreak
, METH_VARARGS
},
2386 {"color_content", (PyCFunction
)PyCurses_Color_Content
, METH_VARARGS
},
2387 {"color_pair", (PyCFunction
)PyCurses_color_pair
, METH_VARARGS
},
2388 {"curs_set", (PyCFunction
)PyCurses_Curs_Set
, METH_VARARGS
},
2389 {"def_prog_mode", (PyCFunction
)PyCurses_def_prog_mode
, METH_NOARGS
},
2390 {"def_shell_mode", (PyCFunction
)PyCurses_def_shell_mode
, METH_NOARGS
},
2391 {"delay_output", (PyCFunction
)PyCurses_Delay_Output
, METH_VARARGS
},
2392 {"doupdate", (PyCFunction
)PyCurses_doupdate
, METH_NOARGS
},
2393 {"echo", (PyCFunction
)PyCurses_echo
, METH_VARARGS
},
2394 {"endwin", (PyCFunction
)PyCurses_endwin
, METH_NOARGS
},
2395 {"erasechar", (PyCFunction
)PyCurses_EraseChar
, METH_NOARGS
},
2396 {"filter", (PyCFunction
)PyCurses_filter
, METH_NOARGS
},
2397 {"flash", (PyCFunction
)PyCurses_flash
, METH_NOARGS
},
2398 {"flushinp", (PyCFunction
)PyCurses_flushinp
, METH_NOARGS
},
2399 #ifdef NCURSES_MOUSE_VERSION
2400 {"getmouse", (PyCFunction
)PyCurses_GetMouse
, METH_NOARGS
},
2401 {"ungetmouse", (PyCFunction
)PyCurses_UngetMouse
, METH_VARARGS
},
2403 {"getsyx", (PyCFunction
)PyCurses_getsyx
, METH_NOARGS
},
2404 {"getwin", (PyCFunction
)PyCurses_GetWin
, METH_O
},
2405 {"has_colors", (PyCFunction
)PyCurses_has_colors
, METH_NOARGS
},
2406 {"has_ic", (PyCFunction
)PyCurses_has_ic
, METH_NOARGS
},
2407 {"has_il", (PyCFunction
)PyCurses_has_il
, METH_NOARGS
},
2408 #ifndef STRICT_SYSV_CURSES
2409 {"has_key", (PyCFunction
)PyCurses_has_key
, METH_VARARGS
},
2411 {"halfdelay", (PyCFunction
)PyCurses_HalfDelay
, METH_VARARGS
},
2412 {"init_color", (PyCFunction
)PyCurses_Init_Color
, METH_VARARGS
},
2413 {"init_pair", (PyCFunction
)PyCurses_Init_Pair
, METH_VARARGS
},
2414 {"initscr", (PyCFunction
)PyCurses_InitScr
, METH_NOARGS
},
2415 {"intrflush", (PyCFunction
)PyCurses_IntrFlush
, METH_VARARGS
},
2416 {"isendwin", (PyCFunction
)PyCurses_isendwin
, METH_NOARGS
},
2417 #if !defined(__NetBSD__)
2418 {"keyname", (PyCFunction
)PyCurses_KeyName
, METH_VARARGS
},
2420 {"killchar", (PyCFunction
)PyCurses_KillChar
, METH_NOARGS
},
2421 {"longname", (PyCFunction
)PyCurses_longname
, METH_NOARGS
},
2422 {"meta", (PyCFunction
)PyCurses_Meta
, METH_VARARGS
},
2423 #ifdef NCURSES_MOUSE_VERSION
2424 {"mouseinterval", (PyCFunction
)PyCurses_MouseInterval
, METH_VARARGS
},
2425 {"mousemask", (PyCFunction
)PyCurses_MouseMask
, METH_VARARGS
},
2427 {"napms", (PyCFunction
)PyCurses_Napms
, METH_VARARGS
},
2428 {"newpad", (PyCFunction
)PyCurses_NewPad
, METH_VARARGS
},
2429 {"newwin", (PyCFunction
)PyCurses_NewWindow
, METH_VARARGS
},
2430 {"nl", (PyCFunction
)PyCurses_nl
, METH_VARARGS
},
2431 {"nocbreak", (PyCFunction
)PyCurses_nocbreak
, METH_NOARGS
},
2432 {"noecho", (PyCFunction
)PyCurses_noecho
, METH_NOARGS
},
2433 {"nonl", (PyCFunction
)PyCurses_nonl
, METH_NOARGS
},
2434 {"noqiflush", (PyCFunction
)PyCurses_noqiflush
, METH_NOARGS
},
2435 {"noraw", (PyCFunction
)PyCurses_noraw
, METH_NOARGS
},
2436 {"pair_content", (PyCFunction
)PyCurses_Pair_Content
, METH_VARARGS
},
2437 {"pair_number", (PyCFunction
)PyCurses_pair_number
, METH_VARARGS
},
2438 {"putp", (PyCFunction
)PyCurses_Putp
, METH_VARARGS
},
2439 {"qiflush", (PyCFunction
)PyCurses_QiFlush
, METH_VARARGS
},
2440 {"raw", (PyCFunction
)PyCurses_raw
, METH_VARARGS
},
2441 {"reset_prog_mode", (PyCFunction
)PyCurses_reset_prog_mode
, METH_NOARGS
},
2442 {"reset_shell_mode", (PyCFunction
)PyCurses_reset_shell_mode
, METH_NOARGS
},
2443 {"resetty", (PyCFunction
)PyCurses_resetty
, METH_NOARGS
},
2444 {"savetty", (PyCFunction
)PyCurses_savetty
, METH_NOARGS
},
2445 {"setsyx", (PyCFunction
)PyCurses_setsyx
, METH_VARARGS
},
2446 {"setupterm", (PyCFunction
)PyCurses_setupterm
,
2447 METH_VARARGS
|METH_KEYWORDS
},
2448 {"start_color", (PyCFunction
)PyCurses_Start_Color
, METH_NOARGS
},
2449 {"termattrs", (PyCFunction
)PyCurses_termattrs
, METH_NOARGS
},
2450 {"termname", (PyCFunction
)PyCurses_termname
, METH_NOARGS
},
2451 {"tigetflag", (PyCFunction
)PyCurses_tigetflag
, METH_VARARGS
},
2452 {"tigetnum", (PyCFunction
)PyCurses_tigetnum
, METH_VARARGS
},
2453 {"tigetstr", (PyCFunction
)PyCurses_tigetstr
, METH_VARARGS
},
2454 {"tparm", (PyCFunction
)PyCurses_tparm
, METH_VARARGS
},
2455 {"typeahead", (PyCFunction
)PyCurses_TypeAhead
, METH_VARARGS
},
2456 {"unctrl", (PyCFunction
)PyCurses_UnCtrl
, METH_VARARGS
},
2457 {"ungetch", (PyCFunction
)PyCurses_UngetCh
, METH_VARARGS
},
2458 {"use_env", (PyCFunction
)PyCurses_Use_Env
, METH_VARARGS
},
2459 #ifndef STRICT_SYSV_CURSES
2460 {"use_default_colors", (PyCFunction
)PyCurses_Use_Default_Colors
, METH_NOARGS
},
2462 {NULL
, NULL
} /* sentinel */
2465 /* Initialization function for the module */
2470 PyObject
*m
, *d
, *v
, *c_api_object
;
2471 static void *PyCurses_API
[PyCurses_API_pointers
];
2473 /* Initialize object type */
2474 PyCursesWindow_Type
.ob_type
= &PyType_Type
;
2476 /* Initialize the C API pointer array */
2477 PyCurses_API
[0] = (void *)&PyCursesWindow_Type
;
2478 PyCurses_API
[1] = (void *)func_PyCursesSetupTermCalled
;
2479 PyCurses_API
[2] = (void *)func_PyCursesInitialised
;
2480 PyCurses_API
[3] = (void *)func_PyCursesInitialisedColor
;
2482 /* Create the module and add the functions */
2483 m
= Py_InitModule("_curses", PyCurses_methods
);
2487 /* Add some symbolic constants to the module */
2488 d
= PyModule_GetDict(m
);
2489 ModDict
= d
; /* For PyCurses_InitScr to use later */
2491 /* Add a CObject for the C API */
2492 c_api_object
= PyCObject_FromVoidPtr((void *)PyCurses_API
, NULL
);
2493 PyDict_SetItemString(d
, "_C_API", c_api_object
);
2494 Py_DECREF(c_api_object
);
2496 /* For exception curses.error */
2497 PyCursesError
= PyErr_NewException("_curses.error", NULL
, NULL
);
2498 PyDict_SetItemString(d
, "error", PyCursesError
);
2500 /* Make the version available */
2501 v
= PyString_FromString(PyCursesVersion
);
2502 PyDict_SetItemString(d
, "version", v
);
2503 PyDict_SetItemString(d
, "__version__", v
);
2506 SetDictInt("ERR", ERR
);
2507 SetDictInt("OK", OK
);
2509 /* Here are some attributes you can add to chars to print */
2511 SetDictInt("A_ATTRIBUTES", A_ATTRIBUTES
);
2512 SetDictInt("A_NORMAL", A_NORMAL
);
2513 SetDictInt("A_STANDOUT", A_STANDOUT
);
2514 SetDictInt("A_UNDERLINE", A_UNDERLINE
);
2515 SetDictInt("A_REVERSE", A_REVERSE
);
2516 SetDictInt("A_BLINK", A_BLINK
);
2517 SetDictInt("A_DIM", A_DIM
);
2518 SetDictInt("A_BOLD", A_BOLD
);
2519 SetDictInt("A_ALTCHARSET", A_ALTCHARSET
);
2520 #if !defined(__NetBSD__)
2521 SetDictInt("A_INVIS", A_INVIS
);
2523 SetDictInt("A_PROTECT", A_PROTECT
);
2524 SetDictInt("A_CHARTEXT", A_CHARTEXT
);
2525 SetDictInt("A_COLOR", A_COLOR
);
2527 /* The following are never available with strict SYSV curses */
2529 SetDictInt("A_HORIZONTAL", A_HORIZONTAL
);
2532 SetDictInt("A_LEFT", A_LEFT
);
2535 SetDictInt("A_LOW", A_LOW
);
2538 SetDictInt("A_RIGHT", A_RIGHT
);
2541 SetDictInt("A_TOP", A_TOP
);
2544 SetDictInt("A_VERTICAL", A_VERTICAL
);
2547 SetDictInt("COLOR_BLACK", COLOR_BLACK
);
2548 SetDictInt("COLOR_RED", COLOR_RED
);
2549 SetDictInt("COLOR_GREEN", COLOR_GREEN
);
2550 SetDictInt("COLOR_YELLOW", COLOR_YELLOW
);
2551 SetDictInt("COLOR_BLUE", COLOR_BLUE
);
2552 SetDictInt("COLOR_MAGENTA", COLOR_MAGENTA
);
2553 SetDictInt("COLOR_CYAN", COLOR_CYAN
);
2554 SetDictInt("COLOR_WHITE", COLOR_WHITE
);
2556 #ifdef NCURSES_MOUSE_VERSION
2557 /* Mouse-related constants */
2558 SetDictInt("BUTTON1_PRESSED", BUTTON1_PRESSED
);
2559 SetDictInt("BUTTON1_RELEASED", BUTTON1_RELEASED
);
2560 SetDictInt("BUTTON1_CLICKED", BUTTON1_CLICKED
);
2561 SetDictInt("BUTTON1_DOUBLE_CLICKED", BUTTON1_DOUBLE_CLICKED
);
2562 SetDictInt("BUTTON1_TRIPLE_CLICKED", BUTTON1_TRIPLE_CLICKED
);
2564 SetDictInt("BUTTON2_PRESSED", BUTTON2_PRESSED
);
2565 SetDictInt("BUTTON2_RELEASED", BUTTON2_RELEASED
);
2566 SetDictInt("BUTTON2_CLICKED", BUTTON2_CLICKED
);
2567 SetDictInt("BUTTON2_DOUBLE_CLICKED", BUTTON2_DOUBLE_CLICKED
);
2568 SetDictInt("BUTTON2_TRIPLE_CLICKED", BUTTON2_TRIPLE_CLICKED
);
2570 SetDictInt("BUTTON3_PRESSED", BUTTON3_PRESSED
);
2571 SetDictInt("BUTTON3_RELEASED", BUTTON3_RELEASED
);
2572 SetDictInt("BUTTON3_CLICKED", BUTTON3_CLICKED
);
2573 SetDictInt("BUTTON3_DOUBLE_CLICKED", BUTTON3_DOUBLE_CLICKED
);
2574 SetDictInt("BUTTON3_TRIPLE_CLICKED", BUTTON3_TRIPLE_CLICKED
);
2576 SetDictInt("BUTTON4_PRESSED", BUTTON4_PRESSED
);
2577 SetDictInt("BUTTON4_RELEASED", BUTTON4_RELEASED
);
2578 SetDictInt("BUTTON4_CLICKED", BUTTON4_CLICKED
);
2579 SetDictInt("BUTTON4_DOUBLE_CLICKED", BUTTON4_DOUBLE_CLICKED
);
2580 SetDictInt("BUTTON4_TRIPLE_CLICKED", BUTTON4_TRIPLE_CLICKED
);
2582 SetDictInt("BUTTON_SHIFT", BUTTON_SHIFT
);
2583 SetDictInt("BUTTON_CTRL", BUTTON_CTRL
);
2584 SetDictInt("BUTTON_ALT", BUTTON_ALT
);
2586 SetDictInt("ALL_MOUSE_EVENTS", ALL_MOUSE_EVENTS
);
2587 SetDictInt("REPORT_MOUSE_POSITION", REPORT_MOUSE_POSITION
);
2589 /* Now set everything up for KEY_ variables */
2594 #if !defined(__NetBSD__)
2595 for (key
=KEY_MIN
;key
< KEY_MAX
; key
++) {
2596 key_n
= (char *)keyname(key
);
2597 if (key_n
== NULL
|| strcmp(key_n
,"UNKNOWN KEY")==0)
2599 if (strncmp(key_n
,"KEY_F(",6)==0) {
2601 key_n2
= malloc(strlen(key_n
)+1);
2605 if (*p1
!= '(' && *p1
!= ')') {
2614 PyDict_SetItemString(d
,key_n2
,PyInt_FromLong((long) key
));
2615 if (key_n2
!= key_n
)
2619 SetDictInt("KEY_MIN", KEY_MIN
);
2620 SetDictInt("KEY_MAX", KEY_MAX
);