Context Navigation

_cursesmodule.c

Last change on this file was 2, checked in by Yuri Dario, 15 years ago
Initial import for vendor code.
Property svn:eol-style set to `native`
File size: 77.9 KB

Line
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 78324 2010-02-22 17:06:22Z 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	const char *knp;
889	#if defined(__NetBSD__)
890	knp = unctrl(rtn);
891	#else
892	knp = keyname(rtn);
893	#endif
894	return PyString_FromString((knp == NULL) ? "" : knp);
895	}
896	}
897
898	static PyObject *
899	PyCursesWindow_GetStr(PyCursesWindowObject self, PyObject args)
900	{
901	int x, y, n;
902	char rtn[1024]; /* This should be big enough.. I hope */
903	int rtn2;
904
905	switch (PyTuple_Size(args)) {
906	case 0:
907	Py_BEGIN_ALLOW_THREADS
908	rtn2 = wgetnstr(self->win,rtn, 1023);
909	Py_END_ALLOW_THREADS
910	break;
911	case 1:
912	if (!PyArg_ParseTuple(args,"i;n", &n))
913	return NULL;
914	Py_BEGIN_ALLOW_THREADS
915	rtn2 = wgetnstr(self->win,rtn,MIN(n, 1023));
916	Py_END_ALLOW_THREADS
917	break;
918	case 2:
919	if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
920	return NULL;
921	Py_BEGIN_ALLOW_THREADS
922	#ifdef STRICT_SYSV_CURSES
923	rtn2 = wmove(self->win,y,x)==ERR ? ERR : wgetnstr(self->win, rtn, 1023);
924	#else
925	rtn2 = mvwgetnstr(self->win,y,x,rtn, 1023);
926	#endif
927	Py_END_ALLOW_THREADS
928	break;
929	case 3:
930	if (!PyArg_ParseTuple(args,"iii;y,x,n", &y, &x, &n))
931	return NULL;
932	#ifdef STRICT_SYSV_CURSES
933	Py_BEGIN_ALLOW_THREADS
934	rtn2 = wmove(self->win,y,x)==ERR ? ERR :
935	wgetnstr(self->win, rtn, MIN(n, 1023));
936	Py_END_ALLOW_THREADS
937	#else
938	Py_BEGIN_ALLOW_THREADS
939	rtn2 = mvwgetnstr(self->win, y, x, rtn, MIN(n, 1023));
940	Py_END_ALLOW_THREADS
941	#endif
942	break;
943	default:
944	PyErr_SetString(PyExc_TypeError, "getstr requires 0 to 3 arguments");
945	return NULL;
946	}
947	if (rtn2 == ERR)
948	rtn[0] = 0;
949	return PyString_FromString(rtn);
950	}
951
952	static PyObject *
953	PyCursesWindow_Hline(PyCursesWindowObject self, PyObject args)
954	{
955	PyObject *temp;
956	chtype ch;
957	int n, x, y, code = OK;
958	attr_t attr = A_NORMAL;
959	long lattr;
960
961	switch (PyTuple_Size(args)) {
962	case 2:
963	if (!PyArg_ParseTuple(args, "Oi;ch or int,n", &temp, &n))
964	return NULL;
965	break;
966	case 3:
967	if (!PyArg_ParseTuple(args, "Oil;ch or int,n,attr", &temp, &n, &lattr))
968	return NULL;
969	attr = lattr;
970	break;
971	case 4:
972	if (!PyArg_ParseTuple(args, "iiOi;y,x,ch or int,n", &y, &x, &temp, &n))
973	return NULL;
974	code = wmove(self->win, y, x);
975	break;
976	case 5:
977	if (!PyArg_ParseTuple(args, "iiOil; y,x,ch or int,n,attr",
978	&y, &x, &temp, &n, &lattr))
979	return NULL;
980	attr = lattr;
981	code = wmove(self->win, y, x);
982	break;
983	default:
984	PyErr_SetString(PyExc_TypeError, "hline requires 2 to 5 arguments");
985	return NULL;
986	}
987
988	if (code != ERR) {
989	if (!PyCurses_ConvertToChtype(temp, &ch)) {
990	PyErr_SetString(PyExc_TypeError,
991	"argument 1 or 3 must be a ch or an int");
992	return NULL;
993	}
994	return PyCursesCheckERR(whline(self->win, ch \| attr, n), "hline");
995	} else
996	return PyCursesCheckERR(code, "wmove");
997	}
998
999	static PyObject *
1000	PyCursesWindow_InsCh(PyCursesWindowObject self, PyObject args)
1001	{
1002	int rtn, x, y, use_xy = FALSE;
1003	PyObject *temp;
1004	chtype ch = 0;
1005	attr_t attr = A_NORMAL;
1006	long lattr;
1007
1008	switch (PyTuple_Size(args)) {
1009	case 1:
1010	if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
1011	return NULL;
1012	break;
1013	case 2:
1014	if (!PyArg_ParseTuple(args, "Ol;ch or int,attr", &temp, &lattr))
1015	return NULL;
1016	attr = lattr;
1017	break;
1018	case 3:
1019	if (!PyArg_ParseTuple(args,"iiO;y,x,ch or int", &y, &x, &temp))
1020	return NULL;
1021	use_xy = TRUE;
1022	break;
1023	case 4:
1024	if (!PyArg_ParseTuple(args,"iiOl;y,x,ch or int, attr", &y, &x, &temp, &lattr))
1025	return NULL;
1026	attr = lattr;
1027	use_xy = TRUE;
1028	break;
1029	default:
1030	PyErr_SetString(PyExc_TypeError, "insch requires 1 or 4 arguments");
1031	return NULL;
1032	}
1033
1034	if (!PyCurses_ConvertToChtype(temp, &ch)) {
1035	PyErr_SetString(PyExc_TypeError,
1036	"argument 1 or 3 must be a ch or an int");
1037	return NULL;
1038	}
1039
1040	if (use_xy == TRUE)
1041	rtn = mvwinsch(self->win,y,x, ch \| attr);
1042	else {
1043	rtn = winsch(self->win, ch \| attr);
1044	}
1045	return PyCursesCheckERR(rtn, "insch");
1046	}
1047
1048	static PyObject *
1049	PyCursesWindow_InCh(PyCursesWindowObject self, PyObject args)
1050	{
1051	int x, y, rtn;
1052
1053	switch (PyTuple_Size(args)) {
1054	case 0:
1055	rtn = winch(self->win);
1056	break;
1057	case 2:
1058	if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
1059	return NULL;
1060	rtn = mvwinch(self->win,y,x);
1061	break;
1062	default:
1063	PyErr_SetString(PyExc_TypeError, "inch requires 0 or 2 arguments");
1064	return NULL;
1065	}
1066	return PyInt_FromLong((long) rtn);
1067	}
1068
1069	static PyObject *
1070	PyCursesWindow_InStr(PyCursesWindowObject self, PyObject args)
1071	{
1072	int x, y, n;
1073	char rtn[1024]; /* This should be big enough.. I hope */
1074	int rtn2;
1075
1076	switch (PyTuple_Size(args)) {
1077	case 0:
1078	rtn2 = winnstr(self->win,rtn, 1023);
1079	break;
1080	case 1:
1081	if (!PyArg_ParseTuple(args,"i;n", &n))
1082	return NULL;
1083	rtn2 = winnstr(self->win,rtn,MIN(n,1023));
1084	break;
1085	case 2:
1086	if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
1087	return NULL;
1088	rtn2 = mvwinnstr(self->win,y,x,rtn,1023);
1089	break;
1090	case 3:
1091	if (!PyArg_ParseTuple(args, "iii;y,x,n", &y, &x, &n))
1092	return NULL;
1093	rtn2 = mvwinnstr(self->win, y, x, rtn, MIN(n,1023));
1094	break;
1095	default:
1096	PyErr_SetString(PyExc_TypeError, "instr requires 0 or 3 arguments");
1097	return NULL;
1098	}
1099	if (rtn2 == ERR)
1100	rtn[0] = 0;
1101	return PyString_FromString(rtn);
1102	}
1103
1104	static PyObject *
1105	PyCursesWindow_InsStr(PyCursesWindowObject self, PyObject args)
1106	{
1107	int rtn;
1108	int x, y;
1109	char *str;
1110	attr_t attr = A_NORMAL , attr_old = A_NORMAL;
1111	long lattr;
1112	int use_xy = FALSE, use_attr = FALSE;
1113
1114	switch (PyTuple_Size(args)) {
1115	case 1:
1116	if (!PyArg_ParseTuple(args,"s;str", &str))
1117	return NULL;
1118	break;
1119	case 2:
1120	if (!PyArg_ParseTuple(args,"sl;str,attr", &str, &lattr))
1121	return NULL;
1122	attr = lattr;
1123	use_attr = TRUE;
1124	break;
1125	case 3:
1126	if (!PyArg_ParseTuple(args,"iis;y,x,str", &y, &x, &str))
1127	return NULL;
1128	use_xy = TRUE;
1129	break;
1130	case 4:
1131	if (!PyArg_ParseTuple(args,"iisl;y,x,str,attr", &y, &x, &str, &lattr))
1132	return NULL;
1133	attr = lattr;
1134	use_xy = use_attr = TRUE;
1135	break;
1136	default:
1137	PyErr_SetString(PyExc_TypeError, "insstr requires 1 to 4 arguments");
1138	return NULL;
1139	}
1140
1141	if (use_attr == TRUE) {
1142	attr_old = getattrs(self->win);
1143	wattrset(self->win,attr);
1144	}
1145	if (use_xy == TRUE)
1146	rtn = mvwinsstr(self->win,y,x,str);
1147	else
1148	rtn = winsstr(self->win,str);
1149	if (use_attr == TRUE)
1150	wattrset(self->win,attr_old);
1151	return PyCursesCheckERR(rtn, "insstr");
1152	}
1153
1154	static PyObject *
1155	PyCursesWindow_InsNStr(PyCursesWindowObject self, PyObject args)
1156	{
1157	int rtn, x, y, n;
1158	char *str;
1159	attr_t attr = A_NORMAL , attr_old = A_NORMAL;
1160	long lattr;
1161	int use_xy = FALSE, use_attr = FALSE;
1162
1163	switch (PyTuple_Size(args)) {
1164	case 2:
1165	if (!PyArg_ParseTuple(args,"si;str,n", &str, &n))
1166	return NULL;
1167	break;
1168	case 3:
1169	if (!PyArg_ParseTuple(args,"sil;str,n,attr", &str, &n, &lattr))
1170	return NULL;
1171	attr = lattr;
1172	use_attr = TRUE;
1173	break;
1174	case 4:
1175	if (!PyArg_ParseTuple(args,"iisi;y,x,str,n", &y, &x, &str, &n))
1176	return NULL;
1177	use_xy = TRUE;
1178	break;
1179	case 5:
1180	if (!PyArg_ParseTuple(args,"iisil;y,x,str,n,attr", &y, &x, &str, &n, &lattr))
1181	return NULL;
1182	attr = lattr;
1183	use_xy = use_attr = TRUE;
1184	break;
1185	default:
1186	PyErr_SetString(PyExc_TypeError, "insnstr requires 2 to 5 arguments");
1187	return NULL;
1188	}
1189
1190	if (use_attr == TRUE) {
1191	attr_old = getattrs(self->win);
1192	wattrset(self->win,attr);
1193	}
1194	if (use_xy == TRUE)
1195	rtn = mvwinsnstr(self->win,y,x,str,n);
1196	else
1197	rtn = winsnstr(self->win,str,n);
1198	if (use_attr == TRUE)
1199	wattrset(self->win,attr_old);
1200	return PyCursesCheckERR(rtn, "insnstr");
1201	}
1202
1203	static PyObject *
1204	PyCursesWindow_Is_LineTouched(PyCursesWindowObject self, PyObject args)
1205	{
1206	int line, erg;
1207	if (!PyArg_ParseTuple(args,"i;line", &line))
1208	return NULL;
1209	erg = is_linetouched(self->win, line);
1210	if (erg == ERR) {
1211	PyErr_SetString(PyExc_TypeError,
1212	"is_linetouched: line number outside of boundaries");
1213	return NULL;
1214	} else
1215	if (erg == FALSE) {
1216	Py_INCREF(Py_False);
1217	return Py_False;
1218	} else {
1219	Py_INCREF(Py_True);
1220	return Py_True;
1221	}
1222	}
1223
1224	static PyObject *
1225	PyCursesWindow_NoOutRefresh(PyCursesWindowObject self, PyObject args)
1226	{
1227	int pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol;
1228	int rtn;
1229
1230	#ifndef WINDOW_HAS_FLAGS
1231	if (0) {
1232	#else
1233	if (self->win->_flags & _ISPAD) {
1234	#endif
1235	switch(PyTuple_Size(args)) {
1236	case 6:
1237	if (!PyArg_ParseTuple(args,
1238	"iiiiii;" \
1239	"pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol",
1240	&pminrow, &pmincol, &sminrow,
1241	&smincol, &smaxrow, &smaxcol))
1242	return NULL;
1243	Py_BEGIN_ALLOW_THREADS
1244	rtn = pnoutrefresh(self->win,
1245	pminrow, pmincol, sminrow,
1246	smincol, smaxrow, smaxcol);
1247	Py_END_ALLOW_THREADS
1248	return PyCursesCheckERR(rtn, "pnoutrefresh");
1249	default:
1250	PyErr_SetString(PyCursesError,
1251	"noutrefresh() called for a pad "
1252	"requires 6 arguments");
1253	return NULL;
1254	}
1255	} else {
1256	if (!PyArg_ParseTuple(args, ":noutrefresh"))
1257	return NULL;
1258
1259	Py_BEGIN_ALLOW_THREADS
1260	rtn = wnoutrefresh(self->win);
1261	Py_END_ALLOW_THREADS
1262	return PyCursesCheckERR(rtn, "wnoutrefresh");
1263	}
1264	}
1265
1266	static PyObject *
1267	PyCursesWindow_Overlay(PyCursesWindowObject self, PyObject args)
1268	{
1269	PyCursesWindowObject *temp;
1270	int use_copywin = FALSE;
1271	int sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol;
1272	int rtn;
1273
1274	switch (PyTuple_Size(args)) {
1275	case 1:
1276	if (!PyArg_ParseTuple(args, "O!;window object",
1277	&PyCursesWindow_Type, &temp))
1278	return NULL;
1279	break;
1280	case 7:
1281	if (!PyArg_ParseTuple(args, "O!iiiiii;window object, int, int, int, int, int, int",
1282	&PyCursesWindow_Type, &temp, &sminrow, &smincol,
1283	&dminrow, &dmincol, &dmaxrow, &dmaxcol))
1284	return NULL;
1285	use_copywin = TRUE;
1286	break;
1287	default:
1288	PyErr_SetString(PyExc_TypeError,
1289	"overlay requires one or seven arguments");
1290	return NULL;
1291	}
1292
1293	if (use_copywin == TRUE) {
1294	rtn = copywin(self->win, temp->win, sminrow, smincol,
1295	dminrow, dmincol, dmaxrow, dmaxcol, TRUE);
1296	return PyCursesCheckERR(rtn, "copywin");
1297	}
1298	else {
1299	rtn = overlay(self->win, temp->win);
1300	return PyCursesCheckERR(rtn, "overlay");
1301	}
1302	}
1303
1304	static PyObject *
1305	PyCursesWindow_Overwrite(PyCursesWindowObject self, PyObject args)
1306	{
1307	PyCursesWindowObject *temp;
1308	int use_copywin = FALSE;
1309	int sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol;
1310	int rtn;
1311
1312	switch (PyTuple_Size(args)) {
1313	case 1:
1314	if (!PyArg_ParseTuple(args, "O!;window object",
1315	&PyCursesWindow_Type, &temp))
1316	return NULL;
1317	break;
1318	case 7:
1319	if (!PyArg_ParseTuple(args, "O!iiiiii;window object, int, int, int, int, int, int",
1320	&PyCursesWindow_Type, &temp, &sminrow, &smincol,
1321	&dminrow, &dmincol, &dmaxrow, &dmaxcol))
1322	return NULL;
1323	use_copywin = TRUE;
1324	break;
1325	default:
1326	PyErr_SetString(PyExc_TypeError,
1327	"overwrite requires one or seven arguments");
1328	return NULL;
1329	}
1330
1331	if (use_copywin == TRUE) {
1332	rtn = copywin(self->win, temp->win, sminrow, smincol,
1333	dminrow, dmincol, dmaxrow, dmaxcol, FALSE);
1334	return PyCursesCheckERR(rtn, "copywin");
1335	}
1336	else {
1337	rtn = overwrite(self->win, temp->win);
1338	return PyCursesCheckERR(rtn, "overwrite");
1339	}
1340	}
1341
1342	static PyObject *
1343	PyCursesWindow_PutWin(PyCursesWindowObject self, PyObject args)
1344	{
1345	PyObject *temp;
1346
1347	if (!PyArg_ParseTuple(args, "O;fileobj", &temp))
1348	return NULL;
1349	if (!PyFile_Check(temp)) {
1350	PyErr_SetString(PyExc_TypeError, "argument must be a file object");
1351	return NULL;
1352	}
1353	return PyCursesCheckERR(putwin(self->win, PyFile_AsFile(temp)),
1354	"putwin");
1355	}
1356
1357	static PyObject *
1358	PyCursesWindow_RedrawLine(PyCursesWindowObject self, PyObject args)
1359	{
1360	int beg, num;
1361	if (!PyArg_ParseTuple(args, "ii;beg,num", &beg, &num))
1362	return NULL;
1363	return PyCursesCheckERR(wredrawln(self->win,beg,num), "redrawln");
1364	}
1365
1366	static PyObject *
1367	PyCursesWindow_Refresh(PyCursesWindowObject self, PyObject args)
1368	{
1369	int pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol;
1370	int rtn;
1371
1372	#ifndef WINDOW_HAS_FLAGS
1373	if (0) {
1374	#else
1375	if (self->win->_flags & _ISPAD) {
1376	#endif
1377	switch(PyTuple_Size(args)) {
1378	case 6:
1379	if (!PyArg_ParseTuple(args,
1380	"iiiiii;" \
1381	"pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol",
1382	&pminrow, &pmincol, &sminrow,
1383	&smincol, &smaxrow, &smaxcol))
1384	return NULL;
1385
1386	Py_BEGIN_ALLOW_THREADS
1387	rtn = prefresh(self->win,
1388	pminrow, pmincol, sminrow,
1389	smincol, smaxrow, smaxcol);
1390	Py_END_ALLOW_THREADS
1391	return PyCursesCheckERR(rtn, "prefresh");
1392	default:
1393	PyErr_SetString(PyCursesError,
1394	"refresh() for a pad requires 6 arguments");
1395	return NULL;
1396	}
1397	} else {
1398	if (!PyArg_ParseTuple(args, ":refresh"))
1399	return NULL;
1400	Py_BEGIN_ALLOW_THREADS
1401	rtn = wrefresh(self->win);
1402	Py_END_ALLOW_THREADS
1403	return PyCursesCheckERR(rtn, "prefresh");
1404	}
1405	}
1406
1407	static PyObject *
1408	PyCursesWindow_SetScrollRegion(PyCursesWindowObject self, PyObject args)
1409	{
1410	int x, y;
1411	if (!PyArg_ParseTuple(args,"ii;top, bottom",&y,&x))
1412	return NULL;
1413	return PyCursesCheckERR(wsetscrreg(self->win,y,x), "wsetscrreg");
1414	}
1415
1416	static PyObject *
1417	PyCursesWindow_SubWin(PyCursesWindowObject self, PyObject args)
1418	{
1419	WINDOW *win;
1420	int nlines, ncols, begin_y, begin_x;
1421
1422	nlines = 0;
1423	ncols = 0;
1424	switch (PyTuple_Size(args)) {
1425	case 2:
1426	if (!PyArg_ParseTuple(args,"ii;begin_y,begin_x",&begin_y,&begin_x))
1427	return NULL;
1428	break;
1429	case 4:
1430	if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
1431	&nlines,&ncols,&begin_y,&begin_x))
1432	return NULL;
1433	break;
1434	default:
1435	PyErr_SetString(PyExc_TypeError, "subwin requires 2 or 4 arguments");
1436	return NULL;
1437	}
1438
1439	/* printf("Subwin: %i %i %i %i \n", nlines, ncols, begin_y, begin_x); */
1440	#ifdef WINDOW_HAS_FLAGS
1441	if (self->win->_flags & _ISPAD)
1442	win = subpad(self->win, nlines, ncols, begin_y, begin_x);
1443	else
1444	#endif
1445	win = subwin(self->win, nlines, ncols, begin_y, begin_x);
1446
1447	if (win == NULL) {
1448	PyErr_SetString(PyCursesError, catchall_NULL);
1449	return NULL;
1450	}
1451
1452	return (PyObject *)PyCursesWindow_New(win);
1453	}
1454
1455	static PyObject *
1456	PyCursesWindow_Scroll(PyCursesWindowObject self, PyObject args)
1457	{
1458	int nlines;
1459	switch(PyTuple_Size(args)) {
1460	case 0:
1461	return PyCursesCheckERR(scroll(self->win), "scroll");
1462	case 1:
1463	if (!PyArg_ParseTuple(args, "i;nlines", &nlines))
1464	return NULL;
1465	return PyCursesCheckERR(wscrl(self->win, nlines), "scroll");
1466	default:
1467	PyErr_SetString(PyExc_TypeError, "scroll requires 0 or 1 arguments");
1468	return NULL;
1469	}
1470	}
1471
1472	static PyObject *
1473	PyCursesWindow_TouchLine(PyCursesWindowObject self, PyObject args)
1474	{
1475	int st, cnt, val;
1476	switch (PyTuple_Size(args)) {
1477	case 2:
1478	if (!PyArg_ParseTuple(args,"ii;start,count",&st,&cnt))
1479	return NULL;
1480	return PyCursesCheckERR(touchline(self->win,st,cnt), "touchline");
1481	case 3:
1482	if (!PyArg_ParseTuple(args, "iii;start,count,val", &st, &cnt, &val))
1483	return NULL;
1484	return PyCursesCheckERR(wtouchln(self->win, st, cnt, val), "touchline");
1485	default:
1486	PyErr_SetString(PyExc_TypeError, "touchline requires 2 or 3 arguments");
1487	return NULL;
1488	}
1489	}
1490
1491	static PyObject *
1492	PyCursesWindow_Vline(PyCursesWindowObject self, PyObject args)
1493	{
1494	PyObject *temp;
1495	chtype ch;
1496	int n, x, y, code = OK;
1497	attr_t attr = A_NORMAL;
1498	long lattr;
1499
1500	switch (PyTuple_Size(args)) {
1501	case 2:
1502	if (!PyArg_ParseTuple(args, "Oi;ch or int,n", &temp, &n))
1503	return NULL;
1504	break;
1505	case 3:
1506	if (!PyArg_ParseTuple(args, "Oil;ch or int,n,attr", &temp, &n, &lattr))
1507	return NULL;
1508	attr = lattr;
1509	break;
1510	case 4:
1511	if (!PyArg_ParseTuple(args, "iiOi;y,x,ch or int,n", &y, &x, &temp, &n))
1512	return NULL;
1513	code = wmove(self->win, y, x);
1514	break;
1515	case 5:
1516	if (!PyArg_ParseTuple(args, "iiOil; y,x,ch or int,n,attr",
1517	&y, &x, &temp, &n, &lattr))
1518	return NULL;
1519	attr = lattr;
1520	code = wmove(self->win, y, x);
1521	break;
1522	default:
1523	PyErr_SetString(PyExc_TypeError, "vline requires 2 to 5 arguments");
1524	return NULL;
1525	}
1526
1527	if (code != ERR) {
1528	if (!PyCurses_ConvertToChtype(temp, &ch)) {
1529	PyErr_SetString(PyExc_TypeError,
1530	"argument 1 or 3 must be a ch or an int");
1531	return NULL;
1532	}
1533	return PyCursesCheckERR(wvline(self->win, ch \| attr, n), "vline");
1534	} else
1535	return PyCursesCheckERR(code, "wmove");
1536	}
1537
1538	static PyMethodDef PyCursesWindow_Methods[] = {
1539	{"addch", (PyCFunction)PyCursesWindow_AddCh, METH_VARARGS},
1540	{"addnstr", (PyCFunction)PyCursesWindow_AddNStr, METH_VARARGS},
1541	{"addstr", (PyCFunction)PyCursesWindow_AddStr, METH_VARARGS},
1542	{"attroff", (PyCFunction)PyCursesWindow_AttrOff, METH_VARARGS},
1543	{"attron", (PyCFunction)PyCursesWindow_AttrOn, METH_VARARGS},
1544	{"attrset", (PyCFunction)PyCursesWindow_AttrSet, METH_VARARGS},
1545	{"bkgd", (PyCFunction)PyCursesWindow_Bkgd, METH_VARARGS},
1546	{"chgat", (PyCFunction)PyCursesWindow_ChgAt, METH_VARARGS},
1547	{"bkgdset", (PyCFunction)PyCursesWindow_BkgdSet, METH_VARARGS},
1548	{"border", (PyCFunction)PyCursesWindow_Border, METH_VARARGS},
1549	{"box", (PyCFunction)PyCursesWindow_Box, METH_VARARGS},
1550	{"clear", (PyCFunction)PyCursesWindow_wclear, METH_NOARGS},
1551	{"clearok", (PyCFunction)PyCursesWindow_clearok, METH_VARARGS},
1552	{"clrtobot", (PyCFunction)PyCursesWindow_wclrtobot, METH_NOARGS},
1553	{"clrtoeol", (PyCFunction)PyCursesWindow_wclrtoeol, METH_NOARGS},
1554	{"cursyncup", (PyCFunction)PyCursesWindow_wcursyncup, METH_NOARGS},
1555	{"delch", (PyCFunction)PyCursesWindow_DelCh, METH_VARARGS},
1556	{"deleteln", (PyCFunction)PyCursesWindow_wdeleteln, METH_NOARGS},
1557	{"derwin", (PyCFunction)PyCursesWindow_DerWin, METH_VARARGS},
1558	{"echochar", (PyCFunction)PyCursesWindow_EchoChar, METH_VARARGS},
1559	#ifdef NCURSES_MOUSE_VERSION
1560	{"enclose", (PyCFunction)PyCursesWindow_Enclose, METH_VARARGS},
1561	#endif
1562	{"erase", (PyCFunction)PyCursesWindow_werase, METH_NOARGS},
1563	{"getbegyx", (PyCFunction)PyCursesWindow_getbegyx, METH_NOARGS},
1564	{"getbkgd", (PyCFunction)PyCursesWindow_GetBkgd, METH_NOARGS},
1565	{"getch", (PyCFunction)PyCursesWindow_GetCh, METH_VARARGS},
1566	{"getkey", (PyCFunction)PyCursesWindow_GetKey, METH_VARARGS},
1567	{"getmaxyx", (PyCFunction)PyCursesWindow_getmaxyx, METH_NOARGS},
1568	{"getparyx", (PyCFunction)PyCursesWindow_getparyx, METH_NOARGS},
1569	{"getstr", (PyCFunction)PyCursesWindow_GetStr, METH_VARARGS},
1570	{"getyx", (PyCFunction)PyCursesWindow_getyx, METH_NOARGS},
1571	{"hline", (PyCFunction)PyCursesWindow_Hline, METH_VARARGS},
1572	{"idcok", (PyCFunction)PyCursesWindow_idcok, METH_VARARGS},
1573	{"idlok", (PyCFunction)PyCursesWindow_idlok, METH_VARARGS},
1574	{"immedok", (PyCFunction)PyCursesWindow_immedok, METH_VARARGS},
1575	{"inch", (PyCFunction)PyCursesWindow_InCh, METH_VARARGS},
1576	{"insch", (PyCFunction)PyCursesWindow_InsCh, METH_VARARGS},
1577	{"insdelln", (PyCFunction)PyCursesWindow_winsdelln, METH_VARARGS},
1578	{"insertln", (PyCFunction)PyCursesWindow_winsertln, METH_NOARGS},
1579	{"insnstr", (PyCFunction)PyCursesWindow_InsNStr, METH_VARARGS},
1580	{"insstr", (PyCFunction)PyCursesWindow_InsStr, METH_VARARGS},
1581	{"instr", (PyCFunction)PyCursesWindow_InStr, METH_VARARGS},
1582	{"is_linetouched", (PyCFunction)PyCursesWindow_Is_LineTouched, METH_VARARGS},
1583	{"is_wintouched", (PyCFunction)PyCursesWindow_is_wintouched, METH_NOARGS},
1584	{"keypad", (PyCFunction)PyCursesWindow_keypad, METH_VARARGS},
1585	{"leaveok", (PyCFunction)PyCursesWindow_leaveok, METH_VARARGS},
1586	{"move", (PyCFunction)PyCursesWindow_wmove, METH_VARARGS},
1587	{"mvderwin", (PyCFunction)PyCursesWindow_mvderwin, METH_VARARGS},
1588	{"mvwin", (PyCFunction)PyCursesWindow_mvwin, METH_VARARGS},
1589	{"nodelay", (PyCFunction)PyCursesWindow_nodelay, METH_VARARGS},
1590	{"notimeout", (PyCFunction)PyCursesWindow_notimeout, METH_VARARGS},
1591	{"noutrefresh", (PyCFunction)PyCursesWindow_NoOutRefresh, METH_VARARGS},
1592	/* Backward compatibility alias -- remove in Python 2.3 */
1593	{"nooutrefresh", (PyCFunction)PyCursesWindow_NoOutRefresh, METH_VARARGS},
1594	{"overlay", (PyCFunction)PyCursesWindow_Overlay, METH_VARARGS},
1595	{"overwrite", (PyCFunction)PyCursesWindow_Overwrite,
1596	METH_VARARGS},
1597	{"putwin", (PyCFunction)PyCursesWindow_PutWin, METH_VARARGS},
1598	{"redrawln", (PyCFunction)PyCursesWindow_RedrawLine, METH_VARARGS},
1599	{"redrawwin", (PyCFunction)PyCursesWindow_redrawwin, METH_NOARGS},
1600	{"refresh", (PyCFunction)PyCursesWindow_Refresh, METH_VARARGS},
1601	#ifndef STRICT_SYSV_CURSES
1602	{"resize", (PyCFunction)PyCursesWindow_wresize, METH_VARARGS},
1603	#endif
1604	{"scroll", (PyCFunction)PyCursesWindow_Scroll, METH_VARARGS},
1605	{"scrollok", (PyCFunction)PyCursesWindow_scrollok, METH_VARARGS},
1606	{"setscrreg", (PyCFunction)PyCursesWindow_SetScrollRegion, METH_VARARGS},
1607	{"standend", (PyCFunction)PyCursesWindow_wstandend, METH_NOARGS},
1608	{"standout", (PyCFunction)PyCursesWindow_wstandout, METH_NOARGS},
1609	{"subpad", (PyCFunction)PyCursesWindow_SubWin, METH_VARARGS},
1610	{"subwin", (PyCFunction)PyCursesWindow_SubWin, METH_VARARGS},
1611	{"syncdown", (PyCFunction)PyCursesWindow_wsyncdown, METH_NOARGS},
1612	{"syncok", (PyCFunction)PyCursesWindow_syncok, METH_VARARGS},
1613	{"syncup", (PyCFunction)PyCursesWindow_wsyncup, METH_NOARGS},
1614	{"timeout", (PyCFunction)PyCursesWindow_wtimeout, METH_VARARGS},
1615	{"touchline", (PyCFunction)PyCursesWindow_TouchLine, METH_VARARGS},
1616	{"touchwin", (PyCFunction)PyCursesWindow_touchwin, METH_NOARGS},
1617	{"untouchwin", (PyCFunction)PyCursesWindow_untouchwin, METH_NOARGS},
1618	{"vline", (PyCFunction)PyCursesWindow_Vline, METH_VARARGS},
1619	{NULL, NULL} /* sentinel */
1620	};
1621
1622	static PyObject *
1623	PyCursesWindow_GetAttr(PyCursesWindowObject self, char name)
1624	{
1625	return Py_FindMethod(PyCursesWindow_Methods, (PyObject *)self, name);
1626	}
1627
1628	/* -------------------------------------------------------*/
1629
1630	PyTypeObject PyCursesWindow_Type = {
1631	PyVarObject_HEAD_INIT(NULL, 0)
1632	"_curses.curses window", /tp_name/
1633	sizeof(PyCursesWindowObject), /tp_basicsize/
1634	0, /tp_itemsize/
1635	/* methods */
1636	(destructor)PyCursesWindow_Dealloc, /tp_dealloc/
1637	0, /tp_print/
1638	(getattrfunc)PyCursesWindow_GetAttr, /tp_getattr/
1639	(setattrfunc)0, /tp_setattr/
1640	0, /tp_compare/
1641	0, /tp_repr/
1642	0, /tp_as_number/
1643	0, /tp_as_sequence/
1644	0, /tp_as_mapping/
1645	0, /tp_hash/
1646	};
1647
1648	/*********************************************************************
1649	Global Functions
1650	**********************************************************************/
1651
1652	NoArgNoReturnFunction(beep)
1653	NoArgNoReturnFunction(def_prog_mode)
1654	NoArgNoReturnFunction(def_shell_mode)
1655	NoArgNoReturnFunction(doupdate)
1656	NoArgNoReturnFunction(endwin)
1657	NoArgNoReturnFunction(flash)
1658	NoArgNoReturnFunction(nocbreak)
1659	NoArgNoReturnFunction(noecho)
1660	NoArgNoReturnFunction(nonl)
1661	NoArgNoReturnFunction(noraw)
1662	NoArgNoReturnFunction(reset_prog_mode)
1663	NoArgNoReturnFunction(reset_shell_mode)
1664	NoArgNoReturnFunction(resetty)
1665	NoArgNoReturnFunction(savetty)
1666
1667	NoArgOrFlagNoReturnFunction(cbreak)
1668	NoArgOrFlagNoReturnFunction(echo)
1669	NoArgOrFlagNoReturnFunction(nl)
1670	NoArgOrFlagNoReturnFunction(raw)
1671
1672	NoArgReturnIntFunction(baudrate)
1673	NoArgReturnIntFunction(termattrs)
1674
1675	NoArgReturnStringFunction(termname)
1676	NoArgReturnStringFunction(longname)
1677
1678	NoArgTrueFalseFunction(can_change_color)
1679	NoArgTrueFalseFunction(has_colors)
1680	NoArgTrueFalseFunction(has_ic)
1681	NoArgTrueFalseFunction(has_il)
1682	NoArgTrueFalseFunction(isendwin)
1683	NoArgNoReturnVoidFunction(flushinp)
1684	NoArgNoReturnVoidFunction(noqiflush)
1685
1686	static PyObject *
1687	PyCurses_filter(PyObject *self)
1688	{
1689	/* not checking for PyCursesInitialised here since filter() must
1690	be called before initscr() */
1691	filter();
1692	Py_INCREF(Py_None);
1693	return Py_None;
1694	}
1695
1696	static PyObject *
1697	PyCurses_Color_Content(PyObject self, PyObject args)
1698	{
1699	short color,r,g,b;
1700
1701	PyCursesInitialised
1702	PyCursesInitialisedColor
1703
1704	if (!PyArg_ParseTuple(args, "h:color_content", &color)) return NULL;
1705
1706	if (color_content(color, &r, &g, &b) != ERR)
1707	return Py_BuildValue("(iii)", r, g, b);
1708	else {
1709	PyErr_SetString(PyCursesError,
1710	"Argument 1 was out of range. Check value of COLORS.");
1711	return NULL;
1712	}
1713	}
1714
1715	static PyObject *
1716	PyCurses_color_pair(PyObject self, PyObject args)
1717	{
1718	int n;
1719
1720	PyCursesInitialised
1721	PyCursesInitialisedColor
1722
1723	if (!PyArg_ParseTuple(args, "i:color_pair", &n)) return NULL;
1724	return PyInt_FromLong((long) (n << 8));
1725	}
1726
1727	static PyObject *
1728	PyCurses_Curs_Set(PyObject self, PyObject args)
1729	{
1730	int vis,erg;
1731
1732	PyCursesInitialised
1733
1734	if (!PyArg_ParseTuple(args, "i:curs_set", &vis)) return NULL;
1735
1736	erg = curs_set(vis);
1737	if (erg == ERR) return PyCursesCheckERR(erg, "curs_set");
1738
1739	return PyInt_FromLong((long) erg);
1740	}
1741
1742	static PyObject *
1743	PyCurses_Delay_Output(PyObject self, PyObject args)
1744	{
1745	int ms;
1746
1747	PyCursesInitialised
1748
1749	if (!PyArg_ParseTuple(args, "i:delay_output", &ms)) return NULL;
1750
1751	return PyCursesCheckERR(delay_output(ms), "delay_output");
1752	}
1753
1754	static PyObject *
1755	PyCurses_EraseChar(PyObject *self)
1756	{
1757	char ch;
1758
1759	PyCursesInitialised
1760
1761	ch = erasechar();
1762
1763	return PyString_FromStringAndSize(&ch, 1);
1764	}
1765
1766	static PyObject *
1767	PyCurses_getsyx(PyObject *self)
1768	{
1769	int x,y;
1770
1771	PyCursesInitialised
1772
1773	getsyx(y, x);
1774
1775	return Py_BuildValue("(ii)", y, x);
1776	}
1777
1778	#ifdef NCURSES_MOUSE_VERSION
1779	static PyObject *
1780	PyCurses_GetMouse(PyObject *self)
1781	{
1782	int rtn;
1783	MEVENT event;
1784
1785	PyCursesInitialised
1786
1787	rtn = getmouse( &event );
1788	if (rtn == ERR) {
1789	PyErr_SetString(PyCursesError, "getmouse() returned ERR");
1790	return NULL;
1791	}
1792	return Py_BuildValue("(hiiil)",
1793	(short)event.id,
1794	event.x, event.y, event.z,
1795	(long) event.bstate);
1796	}
1797
1798	static PyObject *
1799	PyCurses_UngetMouse(PyObject self, PyObject args)
1800	{
1801	MEVENT event;
1802
1803	PyCursesInitialised
1804	if (!PyArg_ParseTuple(args, "hiiil",
1805	&event.id,
1806	&event.x, &event.y, &event.z,
1807	(int *) &event.bstate))
1808	return NULL;
1809
1810	return PyCursesCheckERR(ungetmouse(&event), "ungetmouse");
1811	}
1812	#endif
1813
1814	static PyObject *
1815	PyCurses_GetWin(PyCursesWindowObject self, PyObject temp)
1816	{
1817	WINDOW *win;
1818
1819	PyCursesInitialised
1820
1821	if (!PyFile_Check(temp)) {
1822	PyErr_SetString(PyExc_TypeError, "argument must be a file object");
1823	return NULL;
1824	}
1825
1826	win = getwin(PyFile_AsFile(temp));
1827
1828	if (win == NULL) {
1829	PyErr_SetString(PyCursesError, catchall_NULL);
1830	return NULL;
1831	}
1832
1833	return PyCursesWindow_New(win);
1834	}
1835
1836	static PyObject *
1837	PyCurses_HalfDelay(PyObject self, PyObject args)
1838	{
1839	unsigned char tenths;
1840
1841	PyCursesInitialised
1842
1843	if (!PyArg_ParseTuple(args, "b:halfdelay", &tenths)) return NULL;
1844
1845	return PyCursesCheckERR(halfdelay(tenths), "halfdelay");
1846	}
1847
1848	#ifndef STRICT_SYSV_CURSES
1849	/* No has_key! */
1850	static PyObject * PyCurses_has_key(PyObject self, PyObject args)
1851	{
1852	int ch;
1853
1854	PyCursesInitialised
1855
1856	if (!PyArg_ParseTuple(args,"i",&ch)) return NULL;
1857
1858	if (has_key(ch) == FALSE) {
1859	Py_INCREF(Py_False);
1860	return Py_False;
1861	}
1862	Py_INCREF(Py_True);
1863	return Py_True;
1864	}
1865	#endif /* STRICT_SYSV_CURSES */
1866
1867	static PyObject *
1868	PyCurses_Init_Color(PyObject self, PyObject args)
1869	{
1870	short color, r, g, b;
1871
1872	PyCursesInitialised
1873	PyCursesInitialisedColor
1874
1875	switch(PyTuple_Size(args)) {
1876	case 4:
1877	if (!PyArg_ParseTuple(args, "hhhh;color,r,g,b", &color, &r, &g, &b)) return NULL;
1878	break;
1879	default:
1880	PyErr_SetString(PyExc_TypeError, "init_color requires 4 arguments");
1881	return NULL;
1882	}
1883
1884	return PyCursesCheckERR(init_color(color, r, g, b), "init_color");
1885	}
1886
1887	static PyObject *
1888	PyCurses_Init_Pair(PyObject self, PyObject args)
1889	{
1890	short pair, f, b;
1891
1892	PyCursesInitialised
1893	PyCursesInitialisedColor
1894
1895	if (PyTuple_Size(args) != 3) {
1896	PyErr_SetString(PyExc_TypeError, "init_pair requires 3 arguments");
1897	return NULL;
1898	}
1899
1900	if (!PyArg_ParseTuple(args, "hhh;pair, f, b", &pair, &f, &b)) return NULL;
1901
1902	return PyCursesCheckERR(init_pair(pair, f, b), "init_pair");
1903	}
1904
1905	static PyObject *ModDict;
1906
1907	static PyObject *
1908	PyCurses_InitScr(PyObject *self)
1909	{
1910	WINDOW *win;
1911
1912	if (initialised == TRUE) {
1913	wrefresh(stdscr);
1914	return (PyObject *)PyCursesWindow_New(stdscr);
1915	}
1916
1917	win = initscr();
1918
1919	if (win == NULL) {
1920	PyErr_SetString(PyCursesError, catchall_NULL);
1921	return NULL;
1922	}
1923
1924	initialised = initialised_setupterm = TRUE;
1925
1926	/* This was moved from initcurses() because it core dumped on SGI,
1927	where they're not defined until you've called initscr() */
1928	#define SetDictInt(string,ch) \
1929	do { \
1930	PyObject *o = PyInt_FromLong((long) (ch)); \
1931	if (o && PyDict_SetItemString(ModDict, string, o) == 0) { \
1932	Py_DECREF(o); \
1933	} \
1934	} while (0)
1935
1936	/* Here are some graphic symbols you can use */
1937	SetDictInt("ACS_ULCORNER", (ACS_ULCORNER));
1938	SetDictInt("ACS_LLCORNER", (ACS_LLCORNER));
1939	SetDictInt("ACS_URCORNER", (ACS_URCORNER));
1940	SetDictInt("ACS_LRCORNER", (ACS_LRCORNER));
1941	SetDictInt("ACS_LTEE", (ACS_LTEE));
1942	SetDictInt("ACS_RTEE", (ACS_RTEE));
1943	SetDictInt("ACS_BTEE", (ACS_BTEE));
1944	SetDictInt("ACS_TTEE", (ACS_TTEE));
1945	SetDictInt("ACS_HLINE", (ACS_HLINE));
1946	SetDictInt("ACS_VLINE", (ACS_VLINE));
1947	SetDictInt("ACS_PLUS", (ACS_PLUS));
1948	#if !defined(__hpux) \|\| defined(HAVE_NCURSES_H)
1949	/* On HP/UX 11, these are of type cchar_t, which is not an
1950	integral type. If this is a problem on more platforms, a
1951	configure test should be added to determine whether ACS_S1
1952	is of integral type. */
1953	SetDictInt("ACS_S1", (ACS_S1));
1954	SetDictInt("ACS_S9", (ACS_S9));
1955	SetDictInt("ACS_DIAMOND", (ACS_DIAMOND));
1956	SetDictInt("ACS_CKBOARD", (ACS_CKBOARD));
1957	SetDictInt("ACS_DEGREE", (ACS_DEGREE));
1958	SetDictInt("ACS_PLMINUS", (ACS_PLMINUS));
1959	SetDictInt("ACS_BULLET", (ACS_BULLET));
1960	SetDictInt("ACS_LARROW", (ACS_LARROW));
1961	SetDictInt("ACS_RARROW", (ACS_RARROW));
1962	SetDictInt("ACS_DARROW", (ACS_DARROW));
1963	SetDictInt("ACS_UARROW", (ACS_UARROW));
1964	SetDictInt("ACS_BOARD", (ACS_BOARD));
1965	SetDictInt("ACS_LANTERN", (ACS_LANTERN));
1966	SetDictInt("ACS_BLOCK", (ACS_BLOCK));
1967	#endif
1968	SetDictInt("ACS_BSSB", (ACS_ULCORNER));
1969	SetDictInt("ACS_SSBB", (ACS_LLCORNER));
1970	SetDictInt("ACS_BBSS", (ACS_URCORNER));
1971	SetDictInt("ACS_SBBS", (ACS_LRCORNER));
1972	SetDictInt("ACS_SBSS", (ACS_RTEE));
1973	SetDictInt("ACS_SSSB", (ACS_LTEE));
1974	SetDictInt("ACS_SSBS", (ACS_BTEE));
1975	SetDictInt("ACS_BSSS", (ACS_TTEE));
1976	SetDictInt("ACS_BSBS", (ACS_HLINE));
1977	SetDictInt("ACS_SBSB", (ACS_VLINE));
1978	SetDictInt("ACS_SSSS", (ACS_PLUS));
1979
1980	/* The following are never available with strict SYSV curses */
1981	#ifdef ACS_S3
1982	SetDictInt("ACS_S3", (ACS_S3));
1983	#endif
1984	#ifdef ACS_S7
1985	SetDictInt("ACS_S7", (ACS_S7));
1986	#endif
1987	#ifdef ACS_LEQUAL
1988	SetDictInt("ACS_LEQUAL", (ACS_LEQUAL));
1989	#endif
1990	#ifdef ACS_GEQUAL
1991	SetDictInt("ACS_GEQUAL", (ACS_GEQUAL));
1992	#endif
1993	#ifdef ACS_PI
1994	SetDictInt("ACS_PI", (ACS_PI));
1995	#endif
1996	#ifdef ACS_NEQUAL
1997	SetDictInt("ACS_NEQUAL", (ACS_NEQUAL));
1998	#endif
1999	#ifdef ACS_STERLING
2000	SetDictInt("ACS_STERLING", (ACS_STERLING));
2001	#endif
2002
2003	SetDictInt("LINES", LINES);
2004	SetDictInt("COLS", COLS);
2005
2006	return (PyObject *)PyCursesWindow_New(win);
2007	}
2008
2009	static PyObject *
2010	PyCurses_setupterm(PyObject* self, PyObject args, PyObject keywds)
2011	{
2012	int fd = -1;
2013	int err;
2014	char* termstr = NULL;
2015
2016	static char *kwlist[] = {"term", "fd", NULL};
2017
2018	if (!PyArg_ParseTupleAndKeywords(
2019	args, keywds, "\|zi:setupterm", kwlist, &termstr, &fd)) {
2020	return NULL;
2021	}
2022
2023	if (fd == -1) {
2024	PyObject* sys_stdout;
2025
2026	sys_stdout = PySys_GetObject("stdout");
2027
2028	if (sys_stdout == NULL) {
2029	PyErr_SetString(
2030	PyCursesError,
2031	"lost sys.stdout");
2032	return NULL;
2033	}
2034
2035	fd = PyObject_AsFileDescriptor(sys_stdout);
2036
2037	if (fd == -1) {
2038	return NULL;
2039	}
2040	}
2041
2042	if (setupterm(termstr,fd,&err) == ERR) {
2043	char* s = "setupterm: unknown error";
2044
2045	if (err == 0) {
2046	s = "setupterm: could not find terminal";
2047	} else if (err == -1) {
2048	s = "setupterm: could not find terminfo database";
2049	}
2050
2051	PyErr_SetString(PyCursesError,s);
2052	return NULL;
2053	}
2054
2055	initialised_setupterm = TRUE;
2056
2057	Py_INCREF(Py_None);
2058	return Py_None;
2059	}
2060
2061	static PyObject *
2062	PyCurses_IntrFlush(PyObject self, PyObject args)
2063	{
2064	int ch;
2065
2066	PyCursesInitialised
2067
2068	switch(PyTuple_Size(args)) {
2069	case 1:
2070	if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&ch)) return NULL;
2071	break;
2072	default:
2073	PyErr_SetString(PyExc_TypeError, "intrflush requires 1 argument");
2074	return NULL;
2075	}
2076
2077	return PyCursesCheckERR(intrflush(NULL,ch), "intrflush");
2078	}
2079
2080	#ifdef HAVE_CURSES_IS_TERM_RESIZED
2081	static PyObject *
2082	PyCurses_Is_Term_Resized(PyObject self, PyObject args)
2083	{
2084	int lines;
2085	int columns;
2086	int result;
2087
2088	PyCursesInitialised
2089
2090	if (!PyArg_ParseTuple(args,"ii:is_term_resized", &lines, &columns))
2091	return NULL;
2092	result = is_term_resized(lines, columns);
2093	if (result == TRUE) {
2094	Py_INCREF(Py_True);
2095	return Py_True;
2096	} else {
2097	Py_INCREF(Py_False);
2098	return Py_False;
2099	}
2100	}
2101	#endif /* HAVE_CURSES_IS_TERM_RESIZED */
2102
2103	#if !defined(__NetBSD__)
2104	static PyObject *
2105	PyCurses_KeyName(PyObject self, PyObject args)
2106	{
2107	const char *knp;
2108	int ch;
2109
2110	PyCursesInitialised
2111
2112	if (!PyArg_ParseTuple(args,"i",&ch)) return NULL;
2113
2114	if (ch < 0) {
2115	PyErr_SetString(PyExc_ValueError, "invalid key number");
2116	return NULL;
2117	}
2118	knp = keyname(ch);
2119
2120	return PyString_FromString((knp == NULL) ? "" : (char *)knp);
2121	}
2122	#endif
2123
2124	static PyObject *
2125	PyCurses_KillChar(PyObject *self)
2126	{
2127	char ch;
2128
2129	ch = killchar();
2130
2131	return PyString_FromStringAndSize(&ch, 1);
2132	}
2133
2134	static PyObject *
2135	PyCurses_Meta(PyObject self, PyObject args)
2136	{
2137	int ch;
2138
2139	PyCursesInitialised
2140
2141	switch(PyTuple_Size(args)) {
2142	case 1:
2143	if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&ch)) return NULL;
2144	break;
2145	default:
2146	PyErr_SetString(PyExc_TypeError, "meta requires 1 argument");
2147	return NULL;
2148	}
2149
2150	return PyCursesCheckERR(meta(stdscr, ch), "meta");
2151	}
2152
2153	#ifdef NCURSES_MOUSE_VERSION
2154	static PyObject *
2155	PyCurses_MouseInterval(PyObject self, PyObject args)
2156	{
2157	int interval;
2158	PyCursesInitialised
2159
2160	if (!PyArg_ParseTuple(args,"i;interval",&interval))
2161	return NULL;
2162	return PyCursesCheckERR(mouseinterval(interval), "mouseinterval");
2163	}
2164
2165	static PyObject *
2166	PyCurses_MouseMask(PyObject self, PyObject args)
2167	{
2168	int newmask;
2169	mmask_t oldmask, availmask;
2170
2171	PyCursesInitialised
2172	if (!PyArg_ParseTuple(args,"i;mousemask",&newmask))
2173	return NULL;
2174	availmask = mousemask(newmask, &oldmask);
2175	return Py_BuildValue("(ll)", (long)availmask, (long)oldmask);
2176	}
2177	#endif
2178
2179	static PyObject *
2180	PyCurses_Napms(PyObject self, PyObject args)
2181	{
2182	int ms;
2183
2184	PyCursesInitialised
2185	if (!PyArg_ParseTuple(args, "i;ms", &ms)) return NULL;
2186
2187	return Py_BuildValue("i", napms(ms));
2188	}
2189
2190
2191	static PyObject *
2192	PyCurses_NewPad(PyObject self, PyObject args)
2193	{
2194	WINDOW *win;
2195	int nlines, ncols;
2196
2197	PyCursesInitialised
2198
2199	if (!PyArg_ParseTuple(args,"ii;nlines,ncols",&nlines,&ncols)) return NULL;
2200
2201	win = newpad(nlines, ncols);
2202
2203	if (win == NULL) {
2204	PyErr_SetString(PyCursesError, catchall_NULL);
2205	return NULL;
2206	}
2207
2208	return (PyObject *)PyCursesWindow_New(win);
2209	}
2210
2211	static PyObject *
2212	PyCurses_NewWindow(PyObject self, PyObject args)
2213	{
2214	WINDOW *win;
2215	int nlines, ncols, begin_y=0, begin_x=0;
2216
2217	PyCursesInitialised
2218
2219	switch (PyTuple_Size(args)) {
2220	case 2:
2221	if (!PyArg_ParseTuple(args,"ii;nlines,ncols",&nlines,&ncols))
2222	return NULL;
2223	break;
2224	case 4:
2225	if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
2226	&nlines,&ncols,&begin_y,&begin_x))
2227	return NULL;
2228	break;
2229	default:
2230	PyErr_SetString(PyExc_TypeError, "newwin requires 2 or 4 arguments");
2231	return NULL;
2232	}
2233
2234	win = newwin(nlines,ncols,begin_y,begin_x);
2235	if (win == NULL) {
2236	PyErr_SetString(PyCursesError, catchall_NULL);
2237	return NULL;
2238	}
2239
2240	return (PyObject *)PyCursesWindow_New(win);
2241	}
2242
2243	static PyObject *
2244	PyCurses_Pair_Content(PyObject self, PyObject args)
2245	{
2246	short pair,f,b;
2247
2248	PyCursesInitialised
2249	PyCursesInitialisedColor
2250
2251	switch(PyTuple_Size(args)) {
2252	case 1:
2253	if (!PyArg_ParseTuple(args, "h;pair", &pair)) return NULL;
2254	break;
2255	default:
2256	PyErr_SetString(PyExc_TypeError, "pair_content requires 1 argument");
2257	return NULL;
2258	}
2259
2260	if (pair_content(pair, &f, &b)==ERR) {
2261	PyErr_SetString(PyCursesError,
2262	"Argument 1 was out of range. (1..COLOR_PAIRS-1)");
2263	return NULL;
2264	}
2265
2266	return Py_BuildValue("(ii)", f, b);
2267	}
2268
2269	static PyObject *
2270	PyCurses_pair_number(PyObject self, PyObject args)
2271	{
2272	int n;
2273
2274	PyCursesInitialised
2275	PyCursesInitialisedColor
2276
2277	switch(PyTuple_Size(args)) {
2278	case 1:
2279	if (!PyArg_ParseTuple(args, "i;pairvalue", &n)) return NULL;
2280	break;
2281	default:
2282	PyErr_SetString(PyExc_TypeError,
2283	"pair_number requires 1 argument");
2284	return NULL;
2285	}
2286
2287	return PyInt_FromLong((long) ((n & A_COLOR) >> 8));
2288	}
2289
2290	static PyObject *
2291	PyCurses_Putp(PyObject self, PyObject args)
2292	{
2293	char *str;
2294
2295	if (!PyArg_ParseTuple(args,"s;str", &str)) return NULL;
2296	return PyCursesCheckERR(putp(str), "putp");
2297	}
2298
2299	static PyObject *
2300	PyCurses_QiFlush(PyObject self, PyObject args)
2301	{
2302	int flag = 0;
2303
2304	PyCursesInitialised
2305
2306	switch(PyTuple_Size(args)) {
2307	case 0:
2308	qiflush();
2309	Py_INCREF(Py_None);
2310	return Py_None;
2311	case 1:
2312	if (!PyArg_ParseTuple(args, "i;True(1) or False(0)", &flag)) return NULL;
2313	if (flag) qiflush();
2314	else noqiflush();
2315	Py_INCREF(Py_None);
2316	return Py_None;
2317	default:
2318	PyErr_SetString(PyExc_TypeError, "qiflush requires 0 or 1 arguments");
2319	return NULL;
2320	}
2321	}
2322
2323	/* Internal helper used for updating curses.LINES, curses.COLS, _curses.LINES
2324	* and _curses.COLS */
2325	#if defined(HAVE_CURSES_RESIZETERM) \|\| defined(HAVE_CURSES_RESIZE_TERM)
2326	static int
2327	update_lines_cols(void)
2328	{
2329	PyObject *o;
2330	PyObject *m = PyImport_ImportModuleNoBlock("curses");
2331
2332	if (!m)
2333	return 0;
2334
2335	o = PyInt_FromLong(LINES);
2336	if (!o) {
2337	Py_DECREF(m);
2338	return 0;
2339	}
2340	if (PyObject_SetAttrString(m, "LINES", o)) {
2341	Py_DECREF(m);
2342	Py_DECREF(o);
2343	return 0;
2344	}
2345	if (PyDict_SetItemString(ModDict, "LINES", o)) {
2346	Py_DECREF(m);
2347	Py_DECREF(o);
2348	return 0;
2349	}
2350	Py_DECREF(o);
2351	o = PyInt_FromLong(COLS);
2352	if (!o) {
2353	Py_DECREF(m);
2354	return 0;
2355	}
2356	if (PyObject_SetAttrString(m, "COLS", o)) {
2357	Py_DECREF(m);
2358	Py_DECREF(o);
2359	return 0;
2360	}
2361	if (PyDict_SetItemString(ModDict, "COLS", o)) {
2362	Py_DECREF(m);
2363	Py_DECREF(o);
2364	return 0;
2365	}
2366	Py_DECREF(o);
2367	Py_DECREF(m);
2368	return 1;
2369	}
2370	#endif
2371
2372	#ifdef HAVE_CURSES_RESIZETERM
2373	static PyObject *
2374	PyCurses_ResizeTerm(PyObject self, PyObject args)
2375	{
2376	int lines;
2377	int columns;
2378	PyObject *result;
2379
2380	PyCursesInitialised
2381
2382	if (!PyArg_ParseTuple(args,"ii:resizeterm", &lines, &columns))
2383	return NULL;
2384
2385	result = PyCursesCheckERR(resizeterm(lines, columns), "resizeterm");
2386	if (!result)
2387	return NULL;
2388	if (!update_lines_cols())
2389	return NULL;
2390	return result;
2391	}
2392
2393	#endif
2394
2395	#ifdef HAVE_CURSES_RESIZE_TERM
2396	static PyObject *
2397	PyCurses_Resize_Term(PyObject self, PyObject args)
2398	{
2399	int lines;
2400	int columns;
2401
2402	PyObject *result;
2403
2404	PyCursesInitialised
2405
2406	if (!PyArg_ParseTuple(args,"ii:resize_term", &lines, &columns))
2407	return NULL;
2408
2409	result = PyCursesCheckERR(resize_term(lines, columns), "resize_term");
2410	if (!result)
2411	return NULL;
2412	if (!update_lines_cols())
2413	return NULL;
2414	return result;
2415	}
2416	#endif /* HAVE_CURSES_RESIZE_TERM */
2417
2418	static PyObject *
2419	PyCurses_setsyx(PyObject self, PyObject args)
2420	{
2421	int y,x;
2422
2423	PyCursesInitialised
2424
2425	if (PyTuple_Size(args)!=2) {
2426	PyErr_SetString(PyExc_TypeError, "setsyx requires 2 arguments");
2427	return NULL;
2428	}
2429
2430	if (!PyArg_ParseTuple(args, "ii;y, x", &y, &x)) return NULL;
2431
2432	setsyx(y,x);
2433
2434	Py_INCREF(Py_None);
2435	return Py_None;
2436	}
2437
2438	static PyObject *
2439	PyCurses_Start_Color(PyObject *self)
2440	{
2441	int code;
2442	PyObject c, cp;
2443
2444	PyCursesInitialised
2445
2446	code = start_color();
2447	if (code != ERR) {
2448	initialisedcolors = TRUE;
2449	c = PyInt_FromLong((long) COLORS);
2450	PyDict_SetItemString(ModDict, "COLORS", c);
2451	Py_DECREF(c);
2452	cp = PyInt_FromLong((long) COLOR_PAIRS);
2453	PyDict_SetItemString(ModDict, "COLOR_PAIRS", cp);
2454	Py_DECREF(cp);
2455	Py_INCREF(Py_None);
2456	return Py_None;
2457	} else {
2458	PyErr_SetString(PyCursesError, "start_color() returned ERR");
2459	return NULL;
2460	}
2461	}
2462
2463	static PyObject *
2464	PyCurses_tigetflag(PyObject self, PyObject args)
2465	{
2466	char *capname;
2467
2468	PyCursesSetupTermCalled;
2469
2470	if (!PyArg_ParseTuple(args, "z", &capname))
2471	return NULL;
2472
2473	return PyInt_FromLong( (long) tigetflag( capname ) );
2474	}
2475
2476	static PyObject *
2477	PyCurses_tigetnum(PyObject self, PyObject args)
2478	{
2479	char *capname;
2480
2481	PyCursesSetupTermCalled;
2482
2483	if (!PyArg_ParseTuple(args, "z", &capname))
2484	return NULL;
2485
2486	return PyInt_FromLong( (long) tigetnum( capname ) );
2487	}
2488
2489	static PyObject *
2490	PyCurses_tigetstr(PyObject self, PyObject args)
2491	{
2492	char *capname;
2493
2494	PyCursesSetupTermCalled;
2495
2496	if (!PyArg_ParseTuple(args, "z", &capname))
2497	return NULL;
2498
2499	capname = tigetstr( capname );
2500	if (capname == 0 \|\| capname == (char*) -1) {
2501	Py_INCREF(Py_None);
2502	return Py_None;
2503	}
2504	return PyString_FromString( capname );
2505	}
2506
2507	static PyObject *
2508	PyCurses_tparm(PyObject self, PyObject args)
2509	{
2510	char* fmt;
2511	char* result = NULL;
2512	int i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0,i8=0,i9=0;
2513
2514	PyCursesSetupTermCalled;
2515
2516	if (!PyArg_ParseTuple(args, "s\|iiiiiiiii:tparm",
2517	&fmt, &i1, &i2, &i3, &i4,
2518	&i5, &i6, &i7, &i8, &i9)) {
2519	return NULL;
2520	}
2521
2522	result = tparm(fmt,i1,i2,i3,i4,i5,i6,i7,i8,i9);
2523	if (!result) {
2524	PyErr_SetString(PyCursesError, "tparm() returned NULL");
2525	return NULL;
2526	}
2527
2528	return PyString_FromString(result);
2529	}
2530
2531	static PyObject *
2532	PyCurses_TypeAhead(PyObject self, PyObject args)
2533	{
2534	int fd;
2535
2536	PyCursesInitialised
2537
2538	if (!PyArg_ParseTuple(args,"i;fd",&fd)) return NULL;
2539
2540	return PyCursesCheckERR(typeahead( fd ), "typeahead");
2541	}
2542
2543	static PyObject *
2544	PyCurses_UnCtrl(PyObject self, PyObject args)
2545	{
2546	PyObject *temp;
2547	chtype ch;
2548
2549	PyCursesInitialised
2550
2551	if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;
2552
2553	if (PyInt_Check(temp))
2554	ch = (chtype) PyInt_AsLong(temp);
2555	else if (PyString_Check(temp))
2556	ch = (chtype) *PyString_AsString(temp);
2557	else {
2558	PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");
2559	return NULL;
2560	}
2561
2562	return PyString_FromString(unctrl(ch));
2563	}
2564
2565	static PyObject *
2566	PyCurses_UngetCh(PyObject self, PyObject args)
2567	{
2568	PyObject *temp;
2569	int ch;
2570
2571	PyCursesInitialised
2572
2573	if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;
2574
2575	if (PyInt_Check(temp))
2576	ch = (int) PyInt_AsLong(temp);
2577	else if (PyString_Check(temp))
2578	ch = (int) *PyString_AsString(temp);
2579	else {
2580	PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");
2581	return NULL;
2582	}
2583
2584	return PyCursesCheckERR(ungetch(ch), "ungetch");
2585	}
2586
2587	static PyObject *
2588	PyCurses_Use_Env(PyObject self, PyObject args)
2589	{
2590	int flag;
2591
2592	switch(PyTuple_Size(args)) {
2593	case 1:
2594	if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&flag))
2595	return NULL;
2596	break;
2597	default:
2598	PyErr_SetString(PyExc_TypeError, "use_env requires 1 argument");
2599	return NULL;
2600	}
2601	use_env(flag);
2602	Py_INCREF(Py_None);
2603	return Py_None;
2604	}
2605
2606	#ifndef STRICT_SYSV_CURSES
2607	static PyObject *
2608	PyCurses_Use_Default_Colors(PyObject *self)
2609	{
2610	int code;
2611
2612	PyCursesInitialised
2613	PyCursesInitialisedColor
2614
2615	code = use_default_colors();
2616	if (code != ERR) {
2617	Py_INCREF(Py_None);
2618	return Py_None;
2619	} else {
2620	PyErr_SetString(PyCursesError, "use_default_colors() returned ERR");
2621	return NULL;
2622	}
2623	}
2624	#endif /* STRICT_SYSV_CURSES */
2625
2626	/* List of functions defined in the module */
2627
2628	static PyMethodDef PyCurses_methods[] = {
2629	{"baudrate", (PyCFunction)PyCurses_baudrate, METH_NOARGS},
2630	{"beep", (PyCFunction)PyCurses_beep, METH_NOARGS},
2631	{"can_change_color", (PyCFunction)PyCurses_can_change_color, METH_NOARGS},
2632	{"cbreak", (PyCFunction)PyCurses_cbreak, METH_VARARGS},
2633	{"color_content", (PyCFunction)PyCurses_Color_Content, METH_VARARGS},
2634	{"color_pair", (PyCFunction)PyCurses_color_pair, METH_VARARGS},
2635	{"curs_set", (PyCFunction)PyCurses_Curs_Set, METH_VARARGS},
2636	{"def_prog_mode", (PyCFunction)PyCurses_def_prog_mode, METH_NOARGS},
2637	{"def_shell_mode", (PyCFunction)PyCurses_def_shell_mode, METH_NOARGS},
2638	{"delay_output", (PyCFunction)PyCurses_Delay_Output, METH_VARARGS},
2639	{"doupdate", (PyCFunction)PyCurses_doupdate, METH_NOARGS},
2640	{"echo", (PyCFunction)PyCurses_echo, METH_VARARGS},
2641	{"endwin", (PyCFunction)PyCurses_endwin, METH_NOARGS},
2642	{"erasechar", (PyCFunction)PyCurses_EraseChar, METH_NOARGS},
2643	{"filter", (PyCFunction)PyCurses_filter, METH_NOARGS},
2644	{"flash", (PyCFunction)PyCurses_flash, METH_NOARGS},
2645	{"flushinp", (PyCFunction)PyCurses_flushinp, METH_NOARGS},
2646	#ifdef NCURSES_MOUSE_VERSION
2647	{"getmouse", (PyCFunction)PyCurses_GetMouse, METH_NOARGS},
2648	{"ungetmouse", (PyCFunction)PyCurses_UngetMouse, METH_VARARGS},
2649	#endif
2650	{"getsyx", (PyCFunction)PyCurses_getsyx, METH_NOARGS},
2651	{"getwin", (PyCFunction)PyCurses_GetWin, METH_O},
2652	{"has_colors", (PyCFunction)PyCurses_has_colors, METH_NOARGS},
2653	{"has_ic", (PyCFunction)PyCurses_has_ic, METH_NOARGS},
2654	{"has_il", (PyCFunction)PyCurses_has_il, METH_NOARGS},
2655	#ifndef STRICT_SYSV_CURSES
2656	{"has_key", (PyCFunction)PyCurses_has_key, METH_VARARGS},
2657	#endif
2658	{"halfdelay", (PyCFunction)PyCurses_HalfDelay, METH_VARARGS},
2659	{"init_color", (PyCFunction)PyCurses_Init_Color, METH_VARARGS},
2660	{"init_pair", (PyCFunction)PyCurses_Init_Pair, METH_VARARGS},
2661	{"initscr", (PyCFunction)PyCurses_InitScr, METH_NOARGS},
2662	{"intrflush", (PyCFunction)PyCurses_IntrFlush, METH_VARARGS},
2663	{"isendwin", (PyCFunction)PyCurses_isendwin, METH_NOARGS},
2664	#ifdef HAVE_CURSES_IS_TERM_RESIZED
2665	{"is_term_resized", (PyCFunction)PyCurses_Is_Term_Resized, METH_VARARGS},
2666	#endif
2667	#if !defined(__NetBSD__)
2668	{"keyname", (PyCFunction)PyCurses_KeyName, METH_VARARGS},
2669	#endif
2670	{"killchar", (PyCFunction)PyCurses_KillChar, METH_NOARGS},
2671	{"longname", (PyCFunction)PyCurses_longname, METH_NOARGS},
2672	{"meta", (PyCFunction)PyCurses_Meta, METH_VARARGS},
2673	#ifdef NCURSES_MOUSE_VERSION
2674	{"mouseinterval", (PyCFunction)PyCurses_MouseInterval, METH_VARARGS},
2675	{"mousemask", (PyCFunction)PyCurses_MouseMask, METH_VARARGS},
2676	#endif
2677	{"napms", (PyCFunction)PyCurses_Napms, METH_VARARGS},
2678	{"newpad", (PyCFunction)PyCurses_NewPad, METH_VARARGS},
2679	{"newwin", (PyCFunction)PyCurses_NewWindow, METH_VARARGS},
2680	{"nl", (PyCFunction)PyCurses_nl, METH_VARARGS},
2681	{"nocbreak", (PyCFunction)PyCurses_nocbreak, METH_NOARGS},
2682	{"noecho", (PyCFunction)PyCurses_noecho, METH_NOARGS},
2683	{"nonl", (PyCFunction)PyCurses_nonl, METH_NOARGS},
2684	{"noqiflush", (PyCFunction)PyCurses_noqiflush, METH_NOARGS},
2685	{"noraw", (PyCFunction)PyCurses_noraw, METH_NOARGS},
2686	{"pair_content", (PyCFunction)PyCurses_Pair_Content, METH_VARARGS},
2687	{"pair_number", (PyCFunction)PyCurses_pair_number, METH_VARARGS},
2688	{"putp", (PyCFunction)PyCurses_Putp, METH_VARARGS},
2689	{"qiflush", (PyCFunction)PyCurses_QiFlush, METH_VARARGS},
2690	{"raw", (PyCFunction)PyCurses_raw, METH_VARARGS},
2691	{"reset_prog_mode", (PyCFunction)PyCurses_reset_prog_mode, METH_NOARGS},
2692	{"reset_shell_mode", (PyCFunction)PyCurses_reset_shell_mode, METH_NOARGS},
2693	{"resetty", (PyCFunction)PyCurses_resetty, METH_NOARGS},
2694	#ifdef HAVE_CURSES_RESIZETERM
2695	{"resizeterm", (PyCFunction)PyCurses_ResizeTerm, METH_VARARGS},
2696	#endif
2697	#ifdef HAVE_CURSES_RESIZE_TERM
2698	{"resize_term", (PyCFunction)PyCurses_Resize_Term, METH_VARARGS},
2699	#endif
2700	{"savetty", (PyCFunction)PyCurses_savetty, METH_NOARGS},
2701	{"setsyx", (PyCFunction)PyCurses_setsyx, METH_VARARGS},
2702	{"setupterm", (PyCFunction)PyCurses_setupterm,
2703	METH_VARARGS\|METH_KEYWORDS},
2704	{"start_color", (PyCFunction)PyCurses_Start_Color, METH_NOARGS},
2705	{"termattrs", (PyCFunction)PyCurses_termattrs, METH_NOARGS},
2706	{"termname", (PyCFunction)PyCurses_termname, METH_NOARGS},
2707	{"tigetflag", (PyCFunction)PyCurses_tigetflag, METH_VARARGS},
2708	{"tigetnum", (PyCFunction)PyCurses_tigetnum, METH_VARARGS},
2709	{"tigetstr", (PyCFunction)PyCurses_tigetstr, METH_VARARGS},
2710	{"tparm", (PyCFunction)PyCurses_tparm, METH_VARARGS},
2711	{"typeahead", (PyCFunction)PyCurses_TypeAhead, METH_VARARGS},
2712	{"unctrl", (PyCFunction)PyCurses_UnCtrl, METH_VARARGS},
2713	{"ungetch", (PyCFunction)PyCurses_UngetCh, METH_VARARGS},
2714	{"use_env", (PyCFunction)PyCurses_Use_Env, METH_VARARGS},
2715	#ifndef STRICT_SYSV_CURSES
2716	{"use_default_colors", (PyCFunction)PyCurses_Use_Default_Colors, METH_NOARGS},
2717	#endif
2718	{NULL, NULL} /* sentinel */
2719	};
2720
2721	/* Initialization function for the module */
2722
2723	PyMODINIT_FUNC
2724	init_curses(void)
2725	{
2726	PyObject m, d, v, c_api_object;
2727	static void *PyCurses_API[PyCurses_API_pointers];
2728
2729	/* Initialize object type */
2730	Py_TYPE(&PyCursesWindow_Type) = &PyType_Type;
2731
2732	/* Initialize the C API pointer array */
2733	PyCurses_API[0] = (void *)&PyCursesWindow_Type;
2734	PyCurses_API[1] = (void *)func_PyCursesSetupTermCalled;
2735	PyCurses_API[2] = (void *)func_PyCursesInitialised;
2736	PyCurses_API[3] = (void *)func_PyCursesInitialisedColor;
2737
2738	/* Create the module and add the functions */
2739	m = Py_InitModule("_curses", PyCurses_methods);
2740	if (m == NULL)
2741	return;
2742
2743	/* Add some symbolic constants to the module */
2744	d = PyModule_GetDict(m);
2745	if (d == NULL)
2746	return;
2747	ModDict = d; /* For PyCurses_InitScr to use later */
2748
2749	/* Add a CObject for the C API */
2750	c_api_object = PyCObject_FromVoidPtr((void *)PyCurses_API, NULL);
2751	PyDict_SetItemString(d, "_C_API", c_api_object);
2752	Py_DECREF(c_api_object);
2753
2754	/* For exception curses.error */
2755	PyCursesError = PyErr_NewException("_curses.error", NULL, NULL);
2756	PyDict_SetItemString(d, "error", PyCursesError);
2757
2758	/* Make the version available */
2759	v = PyString_FromString(PyCursesVersion);
2760	PyDict_SetItemString(d, "version", v);
2761	PyDict_SetItemString(d, "__version__", v);
2762	Py_DECREF(v);
2763
2764	SetDictInt("ERR", ERR);
2765	SetDictInt("OK", OK);
2766
2767	/* Here are some attributes you can add to chars to print */
2768
2769	SetDictInt("A_ATTRIBUTES", A_ATTRIBUTES);
2770	SetDictInt("A_NORMAL", A_NORMAL);
2771	SetDictInt("A_STANDOUT", A_STANDOUT);
2772	SetDictInt("A_UNDERLINE", A_UNDERLINE);
2773	SetDictInt("A_REVERSE", A_REVERSE);
2774	SetDictInt("A_BLINK", A_BLINK);
2775	SetDictInt("A_DIM", A_DIM);
2776	SetDictInt("A_BOLD", A_BOLD);
2777	SetDictInt("A_ALTCHARSET", A_ALTCHARSET);
2778	#if !defined(__NetBSD__)
2779	SetDictInt("A_INVIS", A_INVIS);
2780	#endif
2781	SetDictInt("A_PROTECT", A_PROTECT);
2782	SetDictInt("A_CHARTEXT", A_CHARTEXT);
2783	SetDictInt("A_COLOR", A_COLOR);
2784
2785	/* The following are never available with strict SYSV curses */
2786	#ifdef A_HORIZONTAL
2787	SetDictInt("A_HORIZONTAL", A_HORIZONTAL);
2788	#endif
2789	#ifdef A_LEFT
2790	SetDictInt("A_LEFT", A_LEFT);
2791	#endif
2792	#ifdef A_LOW
2793	SetDictInt("A_LOW", A_LOW);
2794	#endif
2795	#ifdef A_RIGHT
2796	SetDictInt("A_RIGHT", A_RIGHT);
2797	#endif
2798	#ifdef A_TOP
2799	SetDictInt("A_TOP", A_TOP);
2800	#endif
2801	#ifdef A_VERTICAL
2802	SetDictInt("A_VERTICAL", A_VERTICAL);
2803	#endif
2804
2805	SetDictInt("COLOR_BLACK", COLOR_BLACK);
2806	SetDictInt("COLOR_RED", COLOR_RED);
2807	SetDictInt("COLOR_GREEN", COLOR_GREEN);
2808	SetDictInt("COLOR_YELLOW", COLOR_YELLOW);
2809	SetDictInt("COLOR_BLUE", COLOR_BLUE);
2810	SetDictInt("COLOR_MAGENTA", COLOR_MAGENTA);
2811	SetDictInt("COLOR_CYAN", COLOR_CYAN);
2812	SetDictInt("COLOR_WHITE", COLOR_WHITE);
2813
2814	#ifdef NCURSES_MOUSE_VERSION
2815	/* Mouse-related constants */
2816	SetDictInt("BUTTON1_PRESSED", BUTTON1_PRESSED);
2817	SetDictInt("BUTTON1_RELEASED", BUTTON1_RELEASED);
2818	SetDictInt("BUTTON1_CLICKED", BUTTON1_CLICKED);
2819	SetDictInt("BUTTON1_DOUBLE_CLICKED", BUTTON1_DOUBLE_CLICKED);
2820	SetDictInt("BUTTON1_TRIPLE_CLICKED", BUTTON1_TRIPLE_CLICKED);
2821
2822	SetDictInt("BUTTON2_PRESSED", BUTTON2_PRESSED);
2823	SetDictInt("BUTTON2_RELEASED", BUTTON2_RELEASED);
2824	SetDictInt("BUTTON2_CLICKED", BUTTON2_CLICKED);
2825	SetDictInt("BUTTON2_DOUBLE_CLICKED", BUTTON2_DOUBLE_CLICKED);
2826	SetDictInt("BUTTON2_TRIPLE_CLICKED", BUTTON2_TRIPLE_CLICKED);
2827
2828	SetDictInt("BUTTON3_PRESSED", BUTTON3_PRESSED);
2829	SetDictInt("BUTTON3_RELEASED", BUTTON3_RELEASED);
2830	SetDictInt("BUTTON3_CLICKED", BUTTON3_CLICKED);
2831	SetDictInt("BUTTON3_DOUBLE_CLICKED", BUTTON3_DOUBLE_CLICKED);
2832	SetDictInt("BUTTON3_TRIPLE_CLICKED", BUTTON3_TRIPLE_CLICKED);
2833
2834	SetDictInt("BUTTON4_PRESSED", BUTTON4_PRESSED);
2835	SetDictInt("BUTTON4_RELEASED", BUTTON4_RELEASED);
2836	SetDictInt("BUTTON4_CLICKED", BUTTON4_CLICKED);
2837	SetDictInt("BUTTON4_DOUBLE_CLICKED", BUTTON4_DOUBLE_CLICKED);
2838	SetDictInt("BUTTON4_TRIPLE_CLICKED", BUTTON4_TRIPLE_CLICKED);
2839
2840	SetDictInt("BUTTON_SHIFT", BUTTON_SHIFT);
2841	SetDictInt("BUTTON_CTRL", BUTTON_CTRL);
2842	SetDictInt("BUTTON_ALT", BUTTON_ALT);
2843
2844	SetDictInt("ALL_MOUSE_EVENTS", ALL_MOUSE_EVENTS);
2845	SetDictInt("REPORT_MOUSE_POSITION", REPORT_MOUSE_POSITION);
2846	#endif
2847	/* Now set everything up for KEY_ variables */
2848	{
2849	int key;
2850	char *key_n;
2851	char *key_n2;
2852	#if !defined(__NetBSD__)
2853	for (key=KEY_MIN;key < KEY_MAX; key++) {
2854	key_n = (char *)keyname(key);
2855	if (key_n == NULL \|\| strcmp(key_n,"UNKNOWN KEY")==0)
2856	continue;
2857	if (strncmp(key_n,"KEY_F(",6)==0) {
2858	char p1, p2;
2859	key_n2 = malloc(strlen(key_n)+1);
2860	if (!key_n2) {
2861	PyErr_NoMemory();
2862	break;
2863	}
2864	p1 = key_n;
2865	p2 = key_n2;
2866	while (*p1) {
2867	if (p1 != '(' && p1 != ')') {
2868	p2 = p1;
2869	p2++;
2870	}
2871	p1++;
2872	}
2873	*p2 = (char)0;
2874	} else
2875	key_n2 = key_n;
2876	SetDictInt(key_n2,key);
2877	if (key_n2 != key_n)
2878	free(key_n2);
2879	}
2880	#endif
2881	SetDictInt("KEY_MIN", KEY_MIN);
2882	SetDictInt("KEY_MAX", KEY_MAX);
2883	}
2884	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: python/vendor/Python-2.6.5/Modules/_cursesmodule.c

Download in other formats: