Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

_cursesmodule.c

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

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

Context Navigation

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

Download in other formats: